from __future__ import annotations import copy import os import pickle import stat from pathlib import Path import pytest import ctx.runtime.release_skill_layout as layout_module from ctx.runtime.release_skill_layout import ( ReleaseSkillRuntimeLayoutError, open_release_skill_runtime_layout, open_workspace_release_skill_runtime_layout, ) def _open(tmp_path: Path, workspace: Path): return open_release_skill_runtime_layout( state_root=tmp_path / "state", host_context_id="codex", native_session_id="native/session secret", workspace=workspace, ) def _open_workspace_layout( tmp_path: Path, workspace: Path, *, state_name: str = "workspace-state", policy_name: str = "onboarding-policy", ): policy_root = tmp_path / policy_name policy_root.mkdir(mode=0o700, exist_ok=True) policy_root.chmod(0o700) return open_workspace_release_skill_runtime_layout( state_root=tmp_path / state_name, policy_store_root=policy_root, workspace=workspace, ) def test_workspace_layout_is_stable_across_native_host_sessions(tmp_path: Path) -> None: workspace = tmp_path / "workspace" workspace.mkdir() policy_root = tmp_path / "onboarding-policy" policy_root.mkdir(mode=0o700) policy_root.chmod(0o700) before = open_workspace_release_skill_runtime_layout( state_root=tmp_path / "workspace-state", policy_store_root=policy_root, workspace=workspace, ) open_release_skill_runtime_layout( state_root=tmp_path / "legacy-state", host_context_id="codex", native_session_id="codex-turn-1", workspace=workspace, ) open_release_skill_runtime_layout( state_root=tmp_path / "legacy-state", host_context_id="claude-code", native_session_id="claude-turn-9", workspace=workspace, ) after = open_workspace_release_skill_runtime_layout( state_root=tmp_path / "workspace-state", policy_store_root=policy_root, workspace=workspace, ) assert after == before assert before.host_context_id == "ctx-workspace-management" assert before.session_id.startswith("workspace-session-") assert "codex" not in before.session_id assert "claude" not in before.session_id assert before.journal_path == after.journal_path assert before.benefit_audit_path == after.benefit_audit_path assert before.consent_broker_path == after.consent_broker_path assert before.skill_store_root == after.skill_store_root assert before.policy_store_root == policy_root assert not (before.managed_root / "install-policy-v1").exists() def test_workspace_layout_does_not_reinterpret_or_migrate_v1_state(tmp_path: Path) -> None: workspace = tmp_path / "workspace" workspace.mkdir() state_root = tmp_path / "shared-state" legacy = open_release_skill_runtime_layout( state_root=state_root, host_context_id="codex", native_session_id="legacy-session", workspace=workspace, ) policy_root = tmp_path / "onboarding-policy" policy_root.mkdir(mode=0o700) policy_root.chmod(0o700) workspace_layout = open_workspace_release_skill_runtime_layout( state_root=state_root, policy_store_root=policy_root, workspace=workspace, ) assert legacy.managed_root == state_root / "managed-capabilities-v1" assert workspace_layout.managed_root == state_root / "managed-capabilities-v2" assert legacy.policy_store_root.exists() assert legacy.skill_store_root.exists() assert workspace_layout.policy_store_root == policy_root assert workspace_layout.skill_store_root != legacy.skill_store_root assert legacy.consent_broker_path is None assert workspace_layout.consent_broker_path is not None def test_v1_layout_keeps_legacy_namespace_and_host_session_partition(tmp_path: Path) -> None: workspace = tmp_path / "workspace" workspace.mkdir() codex = open_release_skill_runtime_layout( state_root=tmp_path / "legacy-state", host_context_id="codex", native_session_id="codex-session", workspace=workspace, ) claude = open_release_skill_runtime_layout( state_root=tmp_path / "legacy-state", host_context_id="claude-code", native_session_id="claude-session", workspace=workspace, ) assert codex.managed_root == codex.state_root / "managed-capabilities-v1" assert codex.policy_store_root == codex.managed_root / "install-policy-v1" assert codex.skill_store_root == codex.managed_root / "skill-cas-v1" assert codex.session_root != claude.session_root assert codex.journal_path == codex.session_root / "engine.sqlite3" assert codex.benefit_audit_path == codex.session_root / "benefit.sqlite3" assert codex.consent_broker_path is None assert claude.consent_broker_path is None def test_workspace_layout_keeps_management_and_host_exposure_separate(tmp_path: Path) -> None: workspace = tmp_path / "workspace" workspace.mkdir() layout = _open_workspace_layout(tmp_path, workspace) assert layout.managed_root == layout.state_root / "managed-capabilities-v2" assert layout.session_root.parent.name == "workspaces" assert layout.session_root.name == layout.workspace_identity_digest assert layout.skill_store_root == layout.session_root / "skill-cas-v1" assert layout.consent_broker_path == layout.session_root / "install-consent-v1.sqlite3" assert not layout.consent_broker_path.exists() assert not any(part.startswith("host-") for part in layout.session_root.parts) assert "codex" not in os.fspath(layout.session_root) assert "claude" not in os.fspath(layout.session_root) request = layout.install_request( task="manage one useful capability", language="Python", occurred_at="2026-08-02T12:00:00Z", ) assert request.host_context_id == "ctx-workspace-management" assert request.host_identity_digest == layout.host_identity_digest assert request.session_id == layout.session_id assert request.policy_store_root == layout.policy_store_root def test_workspace_consent_broker_path_is_shared_but_outside_user_policy_and_cas_roots( tmp_path: Path, ) -> None: workspace = tmp_path / "workspace" workspace.mkdir() first = _open_workspace_layout(tmp_path, workspace) second = open_workspace_release_skill_runtime_layout( state_root=first.state_root, policy_store_root=first.policy_store_root, workspace=workspace, ) assert first.consent_broker_path is not None assert second.consent_broker_path == first.consent_broker_path assert first.consent_broker_path.parent == first.session_root assert first.consent_broker_path not in workspace.parents assert workspace not in first.consent_broker_path.parents assert first.policy_store_root not in first.consent_broker_path.parents assert first.skill_store_root not in first.consent_broker_path.parents assert not first.consent_broker_path.exists() @pytest.mark.skipif(os.name == "nt", reason="POSIX owner-mode contract") def test_workspace_layout_accepts_only_private_single_link_broker_database( tmp_path: Path, ) -> None: workspace = tmp_path / "workspace" workspace.mkdir() layout = _open_workspace_layout(tmp_path, workspace) assert layout.consent_broker_path is not None layout.consent_broker_path.touch(mode=0o600) layout.consent_broker_path.chmod(0o600) reopened = _open_workspace_layout(tmp_path, workspace) assert reopened.consent_broker_path == layout.consent_broker_path reopened.assert_current() layout.consent_broker_path.chmod(0o644) with pytest.raises(ReleaseSkillRuntimeLayoutError, match="unsafe|owner-private"): reopened.assert_current() @pytest.mark.skipif(os.name == "nt", reason="POSIX inode contract") @pytest.mark.parametrize("hazard", ["symlink", "directory", "hardlink"]) def test_workspace_layout_rejects_broker_path_alias_hazards( tmp_path: Path, hazard: str, ) -> None: workspace = tmp_path / "workspace" workspace.mkdir() layout = _open_workspace_layout(tmp_path, workspace) assert layout.consent_broker_path is not None if hazard == "symlink": layout.consent_broker_path.symlink_to(layout.policy_store_root, target_is_directory=True) elif hazard == "directory": layout.consent_broker_path.mkdir(mode=0o700) else: layout.journal_path.touch(mode=0o600) layout.journal_path.chmod(0o600) os.link(layout.journal_path, layout.consent_broker_path) with pytest.raises(ReleaseSkillRuntimeLayoutError, match="unsafe|distinct|regular|overlap"): _open_workspace_layout(tmp_path, workspace) def test_workspace_layout_rejects_broker_path_escape_or_cas_nesting(tmp_path: Path) -> None: workspace = tmp_path / "workspace" workspace.mkdir() layout = _open_workspace_layout(tmp_path, workspace) assert layout.consent_broker_path is not None object.__setattr__( layout, "consent_broker_path", layout.skill_store_root / "install-consent-v1.sqlite3", ) with pytest.raises(ReleaseSkillRuntimeLayoutError, match="changed|unsafe"): layout.assert_current() def test_workspace_layout_isolated_per_workspace_but_shares_explicit_policy( tmp_path: Path, ) -> None: first_workspace = tmp_path / "first-workspace" second_workspace = tmp_path / "second-workspace" first_workspace.mkdir() second_workspace.mkdir() policy_root = tmp_path / "onboarding-policy" policy_root.mkdir(mode=0o700) policy_root.chmod(0o700) first = open_workspace_release_skill_runtime_layout( state_root=tmp_path / "workspace-state", policy_store_root=policy_root, workspace=first_workspace, ) second = open_workspace_release_skill_runtime_layout( state_root=tmp_path / "workspace-state", policy_store_root=policy_root, workspace=second_workspace, ) assert first.session_id != second.session_id assert first.journal_path != second.journal_path assert first.benefit_audit_path != second.benefit_audit_path assert first.skill_store_root != second.skill_store_root assert first.policy_store_root == second.policy_store_root == policy_root def test_workspace_layout_requires_absolute_input_roots( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: workspace = tmp_path / "workspace" workspace.mkdir() policy_root = tmp_path / "policy" policy_root.mkdir(mode=0o700) policy_root.chmod(0o700) with pytest.raises(ReleaseSkillRuntimeLayoutError, match="absolute"): open_workspace_release_skill_runtime_layout( state_root=Path("relative-state"), policy_store_root=policy_root, workspace=workspace, ) with pytest.raises(ReleaseSkillRuntimeLayoutError, match="absolute"): open_workspace_release_skill_runtime_layout( state_root=tmp_path / "state", policy_store_root=Path("relative-policy"), workspace=workspace, ) monkeypatch.chdir(tmp_path) with pytest.raises(ReleaseSkillRuntimeLayoutError, match="absolute"): open_workspace_release_skill_runtime_layout( state_root=tmp_path / "state", policy_store_root=policy_root, workspace=Path("workspace"), ) def test_workspace_layout_canonicalizes_absolute_lexical_aliases(tmp_path: Path) -> None: workspace = tmp_path / "workspace" workspace.mkdir() policy_root = tmp_path / "policy" policy_root.mkdir(mode=0o700) policy_root.chmod(0o700) lexical_parent = tmp_path / "lexical-parent" lexical_parent.mkdir() lexical = open_workspace_release_skill_runtime_layout( state_root=lexical_parent / ".." / "state", policy_store_root=lexical_parent / ".." / "policy", workspace=lexical_parent / ".." / "workspace", ) canonical = open_workspace_release_skill_runtime_layout( state_root=tmp_path / "state", policy_store_root=policy_root, workspace=workspace, ) assert lexical == canonical assert lexical.state_root == tmp_path / "state" assert lexical.policy_store_root == policy_root @pytest.mark.parametrize( ("alias_kind", "expected_error"), ( ("state", "distinct"), ("managed", "overlap"), ("workspace", "overlap"), ("skill", "overlap"), ), ) def test_workspace_layout_rejects_policy_root_aliases( tmp_path: Path, alias_kind: str, expected_error: str, ) -> None: workspace = tmp_path / "workspace" workspace.mkdir() state_root = tmp_path / "state" policy_root = tmp_path / "policy" policy_root.mkdir(mode=0o700) policy_root.chmod(0o700) baseline = open_workspace_release_skill_runtime_layout( state_root=state_root, policy_store_root=policy_root, workspace=workspace, ) aliases = { "state": baseline.state_root, "managed": baseline.managed_root, "workspace": baseline.session_root, "skill": baseline.skill_store_root, } with pytest.raises(ReleaseSkillRuntimeLayoutError, match=expected_error): open_workspace_release_skill_runtime_layout( state_root=state_root, policy_store_root=aliases[alias_kind], workspace=workspace, ) def test_workspace_layout_rejects_state_or_policy_alias_of_workspace(tmp_path: Path) -> None: workspace = tmp_path / "workspace" workspace.mkdir(mode=0o700) workspace.chmod(0o700) policy_root = tmp_path / "policy" policy_root.mkdir(mode=0o700) policy_root.chmod(0o700) with pytest.raises(ReleaseSkillRuntimeLayoutError, match="distinct"): open_workspace_release_skill_runtime_layout( state_root=workspace, policy_store_root=policy_root, workspace=workspace, ) with pytest.raises(ReleaseSkillRuntimeLayoutError, match="distinct"): open_workspace_release_skill_runtime_layout( state_root=tmp_path / "state", policy_store_root=workspace, workspace=workspace, ) @pytest.mark.parametrize( ("descendant", "ancestor"), ( ("state", "workspace"), ("policy", "workspace"), ("workspace", "state"), ("workspace", "policy"), ("policy", "state"), ("state", "policy"), ), ) def test_workspace_layout_rejects_nested_caller_roots( tmp_path: Path, descendant: str, ancestor: str, ) -> None: roots = { "state": tmp_path / "state", "policy": tmp_path / "policy", "workspace": tmp_path / "workspace", } roots[descendant] = roots[ancestor] / f"nested-{descendant}" for path in sorted(set(roots.values()), key=lambda item: len(item.parts)): path.mkdir(parents=True, exist_ok=True, mode=0o700) path.chmod(0o700) with pytest.raises(ReleaseSkillRuntimeLayoutError, match="overlap"): open_workspace_release_skill_runtime_layout( state_root=roots["state"], policy_store_root=roots["policy"], workspace=roots["workspace"], ) assert not (roots["state"] / "managed-capabilities-v2").exists() def test_workspace_layout_rejects_physical_aliases_before_creating_state( tmp_path: Path, ) -> None: workspace = tmp_path / "workspace" workspace.mkdir() state_root = tmp_path / "state" state_root.mkdir(mode=0o700) state_root.chmod(0o700) policy_alias = tmp_path / "policy-alias" policy_alias.symlink_to(state_root, target_is_directory=True) with pytest.raises(ReleaseSkillRuntimeLayoutError, match="distinct"): open_workspace_release_skill_runtime_layout( state_root=state_root, policy_store_root=policy_alias, workspace=workspace, ) assert not (state_root / "managed-capabilities-v2").exists() def test_workspace_layout_rejects_symlinked_policy_alias(tmp_path: Path) -> None: workspace = tmp_path / "workspace" workspace.mkdir() real_policy = tmp_path / "real-policy" real_policy.mkdir(mode=0o700) real_policy.chmod(0o700) policy_alias = tmp_path / "policy-alias" policy_alias.symlink_to(real_policy, target_is_directory=True) with pytest.raises(ReleaseSkillRuntimeLayoutError, match="unsafe"): open_workspace_release_skill_runtime_layout( state_root=tmp_path / "state", policy_store_root=policy_alias, workspace=workspace, ) def test_workspace_layout_detects_policy_alias_after_open(tmp_path: Path) -> None: workspace = tmp_path / "workspace" workspace.mkdir() layout = _open_workspace_layout(tmp_path, workspace) layout.policy_store_root.rmdir() layout.policy_store_root.symlink_to(layout.skill_store_root, target_is_directory=True) with pytest.raises(ReleaseSkillRuntimeLayoutError): layout.assert_current() @pytest.mark.parametrize("public_root", ["state", "policy"]) def test_workspace_layout_rejects_non_private_roots( tmp_path: Path, public_root: str, ) -> None: workspace = tmp_path / "workspace" workspace.mkdir() state_root = tmp_path / "state" policy_root = tmp_path / "policy" state_root.mkdir(mode=0o700) policy_root.mkdir(mode=0o700) state_root.chmod(0o755 if public_root == "state" else 0o700) policy_root.chmod(0o755 if public_root == "policy" else 0o700) with pytest.raises( ReleaseSkillRuntimeLayoutError, match="unsafe|owner-private", ): open_workspace_release_skill_runtime_layout( state_root=state_root, policy_store_root=policy_root, workspace=workspace, ) @pytest.mark.skipif(os.name == "nt", reason="POSIX owner-mode contract") def test_workspace_layout_roots_are_absolute_distinct_and_owner_private(tmp_path: Path) -> None: workspace = tmp_path / "workspace" workspace.mkdir() layout = _open_workspace_layout(tmp_path, workspace) roots = ( layout.state_root, layout.managed_root, layout.session_root, layout.skill_store_root, layout.policy_store_root, ) assert all(root.is_absolute() for root in roots) assert len(set(roots)) == len(roots) assert len({(root.stat().st_dev, root.stat().st_ino) for root in roots}) == len(roots) assert all(stat.S_IMODE(root.stat(follow_symlinks=False).st_mode) == 0o700 for root in roots) def test_workspace_layout_fails_closed_on_windows( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: workspace = tmp_path / "workspace" workspace.mkdir() policy_root = tmp_path / "policy" policy_root.mkdir() monkeypatch.setattr(layout_module.os, "name", "nt") with pytest.raises(ReleaseSkillRuntimeLayoutError, match="not available on Windows"): open_workspace_release_skill_runtime_layout( state_root=tmp_path / "state", policy_store_root=policy_root, workspace=workspace, ) def test_release_skill_layout_is_restart_stable_and_path_private(tmp_path: Path) -> None: workspace = tmp_path / "customer-secret-workspace" workspace.mkdir() first = _open(tmp_path, workspace) second = _open(tmp_path, workspace) assert first == second assert first.workspace_identity_digest == second.workspace_identity_digest assert first.session_id == second.session_id assert "native/session secret" not in os.fspath(first.session_root) assert workspace.name not in os.fspath(first.session_root) assert str(workspace) not in repr(first) with pytest.raises(TypeError): copy.copy(first) with pytest.raises(TypeError): pickle.dumps(first) @pytest.mark.skipif(os.name == "nt", reason="POSIX owner-mode contract") def test_release_skill_layout_creates_only_owner_private_directories(tmp_path: Path) -> None: workspace = tmp_path / "workspace" workspace.mkdir() layout = _open(tmp_path, workspace) for directory in ( layout.state_root, layout.managed_root, layout.session_root, layout.skill_store_root, layout.policy_store_root, ): assert stat.S_IMODE(directory.stat(follow_symlinks=False).st_mode) == 0o700 def test_release_skill_layout_request_uses_only_derived_stable_identity(tmp_path: Path) -> None: workspace = tmp_path / "workspace" workspace.mkdir() layout = _open(tmp_path, workspace) request = layout.install_request( task="repair state restoration", language="Python", occurred_at="2026-08-02T12:00:00Z", ) assert request.workspace == workspace assert request.session_id == layout.session_id assert request.journal_path == layout.journal_path assert request.benefit_audit_path == layout.benefit_audit_path assert request.skill_store_root == layout.skill_store_root assert request.policy_store_root == layout.policy_store_root assert request.host_identity_digest == layout.host_identity_digest def test_release_skill_layout_does_not_inherit_recreated_workspace(tmp_path: Path) -> None: """Recreating the workspace must not inherit the previous session. Only observable where the filesystem does not immediately reuse the freed inode. ext4 does, so this skips there rather than asserting something the platform cannot deliver -- see ``_identity_digest`` for why stat alone cannot close that gap, and GOOD_FIRST_ISSUES.md for the durable fix. """ workspace = tmp_path / "workspace" workspace.mkdir() first = _open(tmp_path, workspace) before = workspace.stat().st_ino workspace.rmdir() workspace.mkdir() if workspace.stat().st_ino == before: pytest.skip("filesystem reused the freed inode; recreation is not observable via stat") second = _open(tmp_path, workspace) assert second.workspace_identity_digest != first.workspace_identity_digest assert second.session_root != first.session_root with pytest.raises(ReleaseSkillRuntimeLayoutError, match="changed"): first.assert_current() def test_release_skill_layout_rejects_symlink_state_root(tmp_path: Path) -> None: workspace = tmp_path / "workspace" workspace.mkdir() real_state = tmp_path / "real-state" real_state.mkdir() alias = tmp_path / "state-alias" alias.symlink_to(real_state, target_is_directory=True) with pytest.raises(ReleaseSkillRuntimeLayoutError, match="unsafe"): open_release_skill_runtime_layout( state_root=alias, host_context_id="codex", native_session_id="session", workspace=workspace, )