diff --git a/.github/workflows/orchestration-ledger-checks.yml b/.github/workflows/orchestration-ledger-checks.yml
index e037c3f6..35c3daab 100644
--- a/.github/workflows/orchestration-ledger-checks.yml
+++ b/.github/workflows/orchestration-ledger-checks.yml
@@ -9,8 +9,9 @@ on:
       - "scripts/compass.ps1"
       - "scripts/orchestration-ledger.py"
       - "scripts/orchestration-ledger.ps1"
-      - "scripts/test-orchestration-ledger-lock.py"
-      - "scripts/test-orchestration-ledger.py"
+      - "scripts/_orchestration_ledger_*.py"
+      - "scripts/test-orchestration-ledger*.py"
+      - "scripts/test-orchestration-ledger*.ps1"
       - "workflows/orchestration-ledger.md"
   push:
     branches:
@@ -22,8 +23,9 @@ on:
       - "scripts/compass.ps1"
       - "scripts/orchestration-ledger.py"
       - "scripts/orchestration-ledger.ps1"
-      - "scripts/test-orchestration-ledger-lock.py"
-      - "scripts/test-orchestration-ledger.py"
+      - "scripts/_orchestration_ledger_*.py"
+      - "scripts/test-orchestration-ledger*.py"
+      - "scripts/test-orchestration-ledger*.ps1"
       - "workflows/orchestration-ledger.md"
 
 jobs:
@@ -47,6 +49,16 @@ jobs:
         with:
           python-version: "3.12"
 
+      - name: Compile ledger sources
+        shell: pwsh
+        run: |
+          Get-ChildItem scripts -File -Filter "*orchestration_ledger*.py" |
+            ForEach-Object {
+              python -m py_compile $_.FullName
+              if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+            }
+          python -m py_compile scripts/orchestration-ledger.py
+
       - name: Run ledger tests
         id: ledger
         continue-on-error: true
@@ -56,6 +68,7 @@ jobs:
           $exitCode = 0
           foreach ($test in @(
             "scripts/test-orchestration-ledger.py",
+            "scripts/test-orchestration-ledger-output.py",
             "scripts/test-orchestration-ledger-lock.py"
           )) {
             $output.Add("== $test ==")
@@ -72,6 +85,10 @@ jobs:
           $output | ForEach-Object { Write-Host $_ }
           exit $exitCode
 
+      - name: Test PowerShell ledger wrapper
+        shell: pwsh
+        run: ./scripts/test-orchestration-ledger-wrapper.ps1
+
       - name: Smoke test orchestration dispatcher
         shell: pwsh
         run: ./scripts/compass.ps1 orchestration -Plain
diff --git a/.github/workflows/portable-checks.yml b/.github/workflows/portable-checks.yml
index fadbf8a3..6aa2393d 100644
--- a/.github/workflows/portable-checks.yml
+++ b/.github/workflows/portable-checks.yml
@@ -43,6 +43,7 @@ jobs:
           $files = @(
             Get-ChildItem codex/hooks -Recurse -File -Filter *.py
             Get-ChildItem codex/skills -Recurse -File -Filter *.py
+            Get-ChildItem carried -Recurse -File -Filter *.py
             Get-ChildItem scripts -File -Filter *.py
           )
           foreach ($file in $files) {
@@ -50,6 +51,18 @@ jobs:
             if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
           }
 
+      - name: Test Compass architecture
+        shell: pwsh
+        run: python scripts/test-compass-architecture.py
+
+      - name: Test behavior-validator isolation
+        shell: pwsh
+        run: python scripts/test-behavior-validator-workspace.py
+
+      - name: Test reviewed config
+        shell: pwsh
+        run: python scripts/test-reviewed-config.py
+
       - name: Test skill audit
         shell: pwsh
         run: python scripts/test-skills-audit.py
@@ -62,6 +75,14 @@ jobs:
         shell: pwsh
         run: python scripts/test-review-bundle.py
 
+      - name: Validate policy contracts
+        shell: pwsh
+        run: python scripts/validate-policy-contracts.py
+
+      - name: Validate skill sources
+        shell: pwsh
+        run: python scripts/validate-skill-sources.py
+
       - name: Check shell launcher syntax
         if: runner.os == 'Linux'
         shell: bash
diff --git a/AGENTS.md b/AGENTS.md
index 6cc13160..b485b1c2 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -1,85 +1,100 @@
 # Repository Guidance
 
-Compass is the reviewed source for portable Codex setup. It is not a raw backup
-of `~/.codex`, `$HOME/.agents`, or `$HOME/.claude`.
-
-- `codex/AGENTS.md` is the portable source for the live global
-  `~/.codex/AGENTS.md`. Only put session-wide defaults there.
-- Installed agentic guidance source belongs under `codex/AGENTS.md`,
-  `codex/agents/`, or `codex/skills/`.
-- Installed Codex hook behavior belongs under `codex/hooks.json` or
-  `codex/hooks/`.
-- This repo-root `AGENTS.md` is for Compass maintenance guidance.
-- If a rule only makes sense while editing Compass, put it here or in
-  `workflows/` or `local-docs/`, not in installed agentic docs.
-- Repo-maintainer guidance belongs in this file, `workflows/`, `local-docs/`,
-  `manifests/`, or `scripts/`. These surfaces are not copied into live install
-  targets as agent behavior.
-- Keep `codex/AGENTS.md` short and global.
-- Put detailed operating behavior in the narrowest surface: installed agents or
-  skills for reusable agent capability, hook docs for hook operation, repo
-  workflows for Compass maintenance, scripts for mechanical checks, and
-  manifests for boundaries.
-- Treat `codex/agents` and manifest-listed `codex/skills` as one portable
-  bundle. When editing bundled skills or agents, reference bundled capabilities
-  directly instead of making them sound optional. Keep conditional wording for
-  external services, permissions, credentials, CI, browser state, MCP tools,
-  goal tools, or repository access.
-- For Compass-owned capabilities, fix the config, install map, verifier, or
-  agent contract. Do not add alternate-path, best-effort, or compatibility
-  prose to installed skills when this repo can make the capability exact.
-- Codex is the reviewed source of truth for shared skills and agents. Claude
-  skills and most agents derive from `codex/skills/<name>` and
-  `codex/agents/<name>.toml` at install time, so a shared change lands on both
-  runtimes. A platform-specific direct agent may live under `claude/agents/`
-  only when the shared transform cannot express its frontmatter, tools, or
-  isolation contract. See `workflows/claude-config.md`.
-- For nontrivial changes to this repo, read
-  `local-docs/maintenance-learnings.md` before editing.
-- For Compass audits, use `workflows/compass-review-program.md` before pruning
-  installed skills, agents, hooks, or maintainer guidance.
-- Do not commit auth, sessions, logs, caches, browser state, SQLite files, or
-  generated plugin caches.
+Compass is reviewed source for portable Codex and Claude Code behavior. It is
+not a raw runtime-home backup.
+
+## Source Boundaries
+
+- `codex/AGENTS.md` is the separately authored Codex global instruction source.
+- `claude/CLAUDE.md` is the separately authored Claude global instruction
+  source.
+- Maintain those two files separately. Share values, not runtime fiction.
+- Reusable runtime-neutral skills live under `codex/skills/` and may derive into
+  Claude when listed in `manifests/portable-files.toml`.
+- Shared agent roles live under `codex/agents/`. Direct Claude agents live under
+  `claude/agents/` only when their platform contract cannot be derived.
+- Installed hook behavior lives under `codex/hooks.json` and `codex/hooks/`.
+- Portable opt-in domain packs live under `carried/` and stay out of global
+  install lists.
+- Compass-only maintenance belongs in this file, `workflows/`, `local-docs/`,
+  `manifests/`, or `scripts/`.
+- Project-specific capability belongs in the target project.
+
+Keep `codex/AGENTS.md` and `claude/CLAUDE.md` short and session-wide. Put focused
+runtime judgment in the narrowest skill or agent. Put deterministic truth in a
+script, hook, manifest, schema, or test.
+
+## Maintenance Posture
+
+Read [philosophy.md](philosophy.md), [glossary.md](glossary.md),
+[local-docs/maintenance-learnings.md](local-docs/maintenance-learnings.md), and
+the workflow nearest the change before a nontrivial edit.
+
+Understand first. Reduce second. Preserve behavior while reducing repeated
+context, duplicate sources, mutable states, weak choices, and maintenance cost.
+
+Lead documentation with the desired role and state. Use a prohibition when the
+forbidden boundary is crisp or when a recurring failure has an unmistakable
+shape. Pair judgment-heavy prohibitions with the positive replacement.
+
+For long-running work, preserve one logical principal across contexts. The
+principal or user authors the goal, plan, catalog, assignments, and checkpoints.
+Delegates execute reviewed assignments and return artifacts plus evidence. Do
+not distribute control authorship across worker-written ledgers.
+
+Material plans and assignments should be reviewable before dispatch unless the
+user has already granted or explicitly waived that review boundary.
+
+## Exact Repository Rules
+
+- Treat every manifest-listed skill and agent as one reviewed portable bundle.
+- Fix Compass-owned wiring in source, transforms, manifests, policy contracts,
+  and tests. Avoid alternate-path prose where Compass can make the route exact.
+- Update source, install maps, retirement maps, required-file checks, policy
+  contracts, MCP catalog expectations, and tests together when ownership moves.
+- Preserve external provenance and license evidence for imported skills.
+- Keep `AGENTS.override.md`, auth, sessions, logs, caches, browser state,
+  database files, generated plugin state, and machine-only values untracked.
+- Respect `CODEX_HOME`, `-AgentsHome`, and `-ClaudeHome` instead of hardcoding
+  default runtime paths.
+- Review `codex/config.review.toml` before changing its authority. Install
+  overlays reviewed keys and preserves unrelated live keys.
+- Use a focused pull request as the review unit.
+- Run `git diff --check` and the narrow tests for every changed mechanism.
 - Run `.\scripts\doctor.ps1` before committing.
-- Use `.\scripts\verify-live.ps1 -SkipCodexCommand` to inspect live drift.
-- Review `codex/config.review.toml` before changing its contract. Normal install
-  overlays every reviewed key while preserving unrelated live config state.
-
-## Review guidelines
-
-- Flag changes that accidentally expand the portable scope by committing auth,
-  sessions, logs, caches, browser state, SQLite files, generated plugin state,
-  or other local-only Codex data.
-- Flag changes that hardcode `~/.codex`, `%USERPROFILE%\.codex`, or
-  `$HOME/.agents` when the path should respect `CODEX_HOME` or `-AgentsHome`.
-- Flag changes that hardcode `$HOME/.claude` when the path should respect
-  `-ClaudeHome`.
-- Flag config changes that introduce undocumented keys, stale settings, or
-  stronger default authority without a current-doc justification.
-- Flag guidance that routes project-specific behavior into Compass
-  when it should live in the target project repo instead.
-- Flag tracked `AGENTS.override.md` or `rules/` files unless they were
-  intentionally adopted as reviewed portable policy.
-- Flag project-specific agents or skills routed into Compass when they
-  should live in the target repo.
-
-## Skill authoring
-
-Skills should shape judgment before they prescribe steps. Start by making the
-agent understand the role it is taking on, why that role exists, what failure
-mode it prevents, and what boundaries preserve good judgment.
-
-- Front-load action-critical guidance. If only the first screen or first 10
-  lines are read, the agent should still see the role, terminal result,
-  non-negotiables, and failure mode to avoid.
-- For goal-bearing or long-lived guidance, put the finished state and completion
-  evidence before the current next action. Keep changing owners, blockers, and
-  next actions in a named live state surface rather than in the durable
-  objective.
-- Lead with the mental model, not a checklist.
-- Use procedures only for fragile or exact operations.
-- Prefer principles, boundaries, and short examples over exhaustive branches.
-- Trust the agent to reason from the right stance instead of turning the skill
-  into a flowchart.
-- Keep concrete prompts and templates where they teach the role or preserve a
-  handoff contract.
+- Run `.\scripts\verify-live.ps1 -SkipCodexCommand` when install or retirement
+  drift matters.
+
+## Skill Authoring
+
+Use `write-a-skill` for general skill design and `write-a-compass-skill` for
+Compass routing, install, derivation, provenance, retirement, and validation.
+
+A skill should make the reader absorb, in its first screen:
+
+- the role;
+- the desired terminal result;
+- why the role exists at runtime;
+- the recurring failure it corrects;
+- the evidence that matters;
+- the authority boundary.
+
+Shape judgment before prescribing steps. Use procedures only when order is real
+or mechanics are fragile. Keep maintainer history and model anecdotes out of
+installed runtime text.
+
+## Review Focus
+
+Flag:
+
+- accidental expansion of the portable boundary;
+- project-specific material promoted globally;
+- duplicated Codex and Claude global guidance that should remain separate;
+- soft language around required behavior;
+- negative-only guidance with no desired replacement;
+- distributed control authorship in long-running work;
+- premature implementation while authority remains in planning;
+- worker claims accepted without current evidence;
+- model routing that conflicts with the dated current profile;
+- stale skill names, install maps, retirement paths, policy strings, or tests;
+- generated mechanics expressed only as remembered prose.
diff --git a/README.md b/README.md
index ca096164..d6fc5ee2 100644
--- a/README.md
+++ b/README.md
@@ -1,149 +1,156 @@
 # Compass
 
-Reviewed source for my human-owned Codex setup.
+Reviewed source for a human-owned Codex and Claude Code setup.
 
-Its central theme is reduction: preserve capability while reducing the context,
-duplication, state, and maintenance overhead required to use it well.
+Compass preserves capability while reducing the context, duplication, state,
+and maintenance overhead required to use agents well. Its central concern is
+coherence: one intention should survive long sessions, compaction, delegation,
+model changes, and machine changes without turning intelligent work into a rigid
+script.
 
-This repo is intentionally an allowlist, not a backup of the whole Codex home,
-user skill home, or Claude home. The live Codex directory contains auth, logs,
-sessions, caches, databases, generated plugin state, browser state, and
-machine-specific runtime paths. Those are not portable and should not be
-committed.
+This repository is an allowlist, not a backup of runtime homes. Authentication,
+sessions, logs, caches, databases, browser state, generated plugin state,
+machine paths, hosted settings, cloud task history, and connector installs stay
+outside the reviewed source.
 
-Hosted Codex web settings, cloud task history, repository connections, and
-workspace connector installs such as Slack or Linear are also out of scope for
-this repo. They are service-side state, not portable files.
+Read [philosophy.md](philosophy.md) for the governing ideas and
+[glossary.md](glossary.md) for terms whose distinctions change behavior.
 
-For the philosophy behind this repo's shape, see [philosophy.md](philosophy.md).
-
-For public use, treat this repository as a worked example of a reviewed portable
-Codex setup. Read [CONTRIBUTING.md](CONTRIBUTING.md),
-[SECURITY.md](SECURITY.md), and [SUPPORT.md](SUPPORT.md) before copying its
-files or proposing changes.
+For public use, treat this repository as a worked example. Review
+[CONTRIBUTING.md](CONTRIBUTING.md), [SECURITY.md](SECURITY.md), and
+[SUPPORT.md](SUPPORT.md) before copying its files or proposing changes.
 
 ## Layout
 
-- `codex/AGENTS.md`: portable source for the live global `AGENTS.md` in the
-  active Codex home, usually `~/.codex/AGENTS.md`. Keep only session-wide
-  defaults there. Keep `AGENTS.override.md` local, and keep project
-  `AGENTS.md` files in the target repo.
-- `AGENTS.md`: repo-local maintenance guidance for this portable config repo.
-  Use this for Compass process and review rules.
-- `codex/keybindings.json`: portable keyboard bindings.
-- `codex/hooks.json` and `codex/hooks/`: reviewed Codex hooks installed into
-  the live Codex home. Hooks require `/hooks` trust review after install.
-- `codex/agents/`: reusable global custom agents installed into the live Codex
-  home. Project-specific custom agents belong in the target repo.
-- `codex/skills/`: reviewed source for reusable user skills installed into
-  `$HOME/.agents/skills`, excluding system and plugin cache skills.
-  Project-specific `.agents/skills` belong in the target repo. Broader sharing
-  should usually happen through a plugin.
-- Claude Code skills and agents are installed into `$HOME/.claude` from the
-  reviewed `codex/` source at install time (listed in
-  `[claude].derived_skills` and `[claude].derived_agents`). There are no
-  hand-maintained `claude/` source files in the repo. See
-  `workflows/claude-config.md`.
-- `codex/config.review.toml`: reviewed scalar config contract overlaid into the
-  live `config.toml` during install and update. Keys absent from the fragment,
-  including generated and machine-local state, are preserved.
-- `workflows/`: repo-side operating notes for recurring maintenance work. These
-  are not installed into a live Codex home, user skill home, or Claude home.
-  Start with [workflows/README.md](workflows/README.md) to select the matching
-  workflow.
-  Use `workflows/addition-intake.md` before promoting new portable artifacts.
-  Use `workflows/compass-review-program.md` when auditing installed skills,
-  agents, hooks, and maintainer guidance for pruning or rerouting.
-  Use `workflows/codex-restart-recovery.md` for restart-only recovery of
-  unfinished local Codex sessions.
-  Use `workflows/which-llm-plugin.md` for the durable `which-llm` plugin
-  install and update route.
-- `local-docs/`: repo-local maintenance learnings that are not installed into a
-  live Codex home, user skill home, or Claude home.
-- `manifests/portable-files.toml`: the install allowlist, repo-only list, and
-  local-only denylist.
-- `manifests/plugins.json`: external plugin marketplaces and plugins that the
-  reviewed install keeps present without tracking generated plugin state.
-- `manifests/tool-surfaces.md`: repo-side review notes for tools that can touch
-  local or external state.
-- `scripts/`: repo-side snapshot, diff, install, and health check helpers.
-
-## Common commands
-
-Preview the difference between this repo and the live install targets:
+### Runtime instruction sources
+
+- `codex/AGENTS.md` is the separately authored global instruction source for
+  Codex, normally installed as `~/.codex/AGENTS.md`.
+- `claude/CLAUDE.md` is the separately authored global instruction source for
+  Claude Code, normally installed as `~/.claude/CLAUDE.md`.
+- `codex/agents/` contains reusable Codex agent roles. Most derive into Claude
+  agent files during installation. Platform-specific Claude agents live under
+  `claude/agents/` only when the shared transform cannot express their contract.
+- `codex/skills/` contains reviewed reusable skills installed into
+  `$HOME/.agents/skills`. Runtime-neutral skills listed in the manifest derive
+  into `$HOME/.claude/skills` from the same reviewed source.
+- `codex/hooks.json` and `codex/hooks/` contain reviewed Codex hooks. Hooks
+  require runtime trust review after installation.
+- `codex/keybindings.json` contains portable Codex keyboard bindings.
+- `codex/config.review.toml` is the reviewed scalar config fragment overlaid on
+  the live Codex config. Live keys absent from the fragment remain untouched.
+
+Global Codex and Claude instruction files remain separate because their runtime,
+model, context, and delegation contracts differ. Shared skills and most shared
+agent roles derive when the behavior is genuinely runtime-neutral.
+
+### Narrower and maintainer surfaces
+
+- `carried/` contains portable opt-in domain packs that do not belong in every
+  session. The benchmark operations pack and WebMCP pack live here.
+- `workflows/` contains recurring Compass maintenance procedures. Start with
+  [workflows/README.md](workflows/README.md).
+- `local-docs/` contains reviewed maintenance reasoning and dated calibration
+  that should not enter runtime context.
+- `manifests/` contains install boundaries, skill ownership, policy contracts,
+  plugins, and mechanical schemas.
+- `scripts/` contains deterministic install, diff, validation, status,
+  orchestration-ledger, and recovery mechanics.
+- `AGENTS.md` is repository-local guidance for maintaining Compass itself.
+
+Project-specific `AGENTS.md`, `CLAUDE.md`, agents, and skills belong in their
+project. `AGENTS.override.md` and machine-only rules remain local unless they are
+deliberately adopted as reviewed portable policy.
+
+## Long-Running Work
+
+Long-running work uses durable control documents rather than conversation
+history as authority. The user-facing principal, or the user directly, authors
+the goal, plan, catalog, assignments, and checkpoints. Delegates receive
+reviewed assignments and return artifacts plus evidence. A fresh principal
+context resumes the same logical role by reopening and verifying those anchors.
+
+See [workflows/long-running-work.md](workflows/long-running-work.md) and
+[workflows/orchestration-ledger.md](workflows/orchestration-ledger.md).
+
+## Common Commands
+
+Preview the difference between reviewed source and live install targets:
 
 ```powershell
 .\scripts\diff-live.ps1
 ```
 
-Check the repo for obvious portability mistakes:
+Check portability, manifests, policies, skills, agents, hooks, and text rules:
 
 ```powershell
 .\scripts\doctor.ps1
 ```
 
-Preview local Codex sessions that would be resumed after a restart:
+Preview unfinished Codex sessions that restart recovery would resume:
 
 ```powershell
 .\scripts\codex-restart-recovery.ps1 -DryRun
 ```
 
-Check whether live Codex, user skill, and Claude files match the portable
-allowlist and ask Codex to report active instruction sources:
+Check live Codex, user-skill, and Claude files against the allowlist:
 
 ```powershell
 .\scripts\verify-live.ps1
 ```
 
-Install reviewed portable files and overlay reviewed Codex config into the live
-Codex home, user skill home, and Claude home:
+Preview an installation:
+
+```powershell
+.\scripts\install.ps1
+```
+
+Apply the reviewed installation and config overlay:
 
 ```powershell
 .\scripts\install.ps1 -Apply
 ```
 
-Fetch latest `main`, fast-forward the checkout, install reviewed portable
-files and config, and verify the live allowlist:
+Fetch the requested reviewed ref, install it, and verify live state:
 
 ```powershell
 .\scripts\update-live.ps1
 ```
 
-Refresh the repo from the current live allowlist:
+Refresh reviewed source from the current live allowlist:
 
 ```powershell
 .\scripts\snapshot.ps1 -Apply
 ```
 
-Without `-Apply`, `snapshot.ps1` and `install.ps1` run in review mode and explain
-what they would change, including exact reviewed config key paths.
-
-Scripts use `-CodexHome` for Codex-home files, otherwise `$env:CODEX_HOME`,
-otherwise `%USERPROFILE%\.codex`. They use `-AgentsHome` for user skills,
-otherwise `$HOME\.agents`. They use `-ClaudeHome` for Claude-home files,
-otherwise `$HOME\.claude`.
-
-## Rules
-
-- Keep this repo small and boring.
-- Every durable addition should delete, merge, move, derive, or mechanize
-  something, or explicitly justify its recurring cost.
-- Copy ordinary files into normal Codex locations. Avoid symlink-based setup.
-- Treat every key in `codex/config.review.toml` as authoritative during install
-  while preserving every live key absent from the fragment.
-- Keep `AGENTS.override.md` and `rules/` local unless you deliberately decide
-  they are reviewed portable policy.
-- Do not commit secrets, auth files, SQLite state, logs, session history, caches,
-  browser profiles, generated plugin caches, or machine runtime paths.
-- If an automation should become portable, capture it as a skill, workflow, or
-  reviewed config change, not by tracking live `automations/` state.
-- If you intentionally author a plugin, keep the plugin source and marketplace
-  metadata in a normal repo path or dedicated plugin repo, not in live cache
-  directories.
-- Keep plugin install routes in workflows. Keep installed plugin cache and
-  generated marketplace state local.
-- Keep machine-specific values in ignored local files or in live config only.
-- Keep skill descriptions concise. Put detailed instructions in `SKILL.md` and
-  references.
-- Promote additions through a PR after checking nearby docs, manifests, and
-  install maps for stale guidance.
+Read local orchestration state:
+
+```powershell
+.\scripts\compass.ps1 orchestration
+```
+
+Without `-Apply`, mutation scripts stay in review mode and report exact planned
+changes. Scripts use `-CodexHome`, then `$env:CODEX_HOME`, then
+`%USERPROFILE%\.codex`; `-AgentsHome`, then `$HOME\.agents`; and `-ClaudeHome`,
+then `$HOME\.claude`.
+
+## Repository Rules
+
+- Keep Compass small, explicit, and auditable.
+- Every durable addition removes, merges, narrows, derives, or mechanizes
+  recurring cost, or states why its distinct behavior earns that cost.
+- Lead guidance with the role and desired state. Use prohibitions for crisp
+  boundaries and known failure shapes.
+- Shape judgment before procedure. Exact steps protect fragile mechanics,
+  irreversible actions, and handoff contracts.
+- Preserve one logical principal author across long-running contexts. Delegates
+  return evidence instead of inventing parallel control state.
+- Keep model-specific observations dated and revisable in maintainer docs.
+- Copy ordinary files into normal runtime locations. Avoid symlink-based setup.
+- Keep secrets, auth, databases, logs, sessions, browser profiles, caches,
+  generated plugin state, and machine paths outside the repository.
+- Keep plugin source in a normal repository and install routes in workflows.
+- Keep skill descriptions concise. Put action-critical behavior in `SKILL.md`,
+  optional detail in references, and deterministic mechanics in scripts.
+- Use a pull request as the durable review unit. Readiness never grants merge or
+  other public-mutation authority.
diff --git a/apps/compass-mcp/README.md b/apps/compass-mcp/README.md
index afab1ce6..a0d6f0f7 100644
--- a/apps/compass-mcp/README.md
+++ b/apps/compass-mcp/README.md
@@ -2,15 +2,21 @@
 
 This directory exposes the reviewed Compass profile and skills as a read-only MCP server for regular ChatGPT.com chat-mode conversations. ChatGPT work mode and Codex are explicitly outside its intended surface.
 
-At initialization, the server includes the reviewed user profile plus every skill name, description, and source path. This mirrors the native Codex harness: select a workflow from the available catalog without a discovery call, then load only that workflow's full `SKILL.md` before applying it.
+At initialization, the server includes its separately authored ChatGPT profile plus every skill name, description, and source path. This mirrors the native Codex harness: select a workflow from the available catalog without a discovery call, then load only that workflow's full `SKILL.md` before applying it.
 
 ## Tools
 
-- `get_profile` re-reads `codex/AGENTS.md` for explicit inspection or freshness checks. The profile is already present in initialization instructions.
+- `get_profile` re-reads `apps/compass-mcp/profile.md` for explicit inspection or freshness checks. The profile is already present in initialization instructions.
 - `list_skills` re-reads the reviewed skill catalog for explicit inspection or freshness checks. Skill summaries are already present in initialization instructions.
 - `get_skill` loads one full `SKILL.md` after a workflow is selected.
 - `search` and `fetch` expose the same content through the standard read-only knowledge shapes.
 
+
+The app profile is maintained separately from `codex/AGENTS.md` and
+`claude/CLAUDE.md`. It carries shared engineering preferences without importing
+Codex-only Sol and Luna routing or Claude-only GLM-5.2 assumptions into regular
+ChatGPT chat mode.
+
 The app does not install global config, run hooks, mutate the repository, or create subagents. Native subagents remain a host capability. A later server-side workflow can add explicit multi-agent execution without pretending it is native ChatGPT delegation.
 
 ## Run locally
diff --git a/apps/compass-mcp/profile.md b/apps/compass-mcp/profile.md
new file mode 100644
index 00000000..45e62e41
--- /dev/null
+++ b/apps/compass-mcp/profile.md
@@ -0,0 +1,42 @@
+# User Preferences
+
+## Writing
+
+- Never use em dashes or en dashes in commits, code comments, prose, or chat.
+  Use other punctuation or separate sentences.
+
+## Git And Pull Requests
+
+- Commit with one lowercase subject, about 8 words or fewer, with no trailing
+  punctuation, body, or `Co-Authored-By` trailer. Describe changes neutrally.
+- Prefer a pull request as the unit for repository changes. Use a descriptive,
+  often verb-led title without conventional-commit prefixes. Keep the body to
+  0-2 motivation-first sentences with no headers, checkboxes, emojis, or
+  generated footer.
+
+## Direction
+
+- Lead with the role, desired state, and evidence. Use prohibitions for crisp
+  boundaries and pair judgment-heavy prohibitions with the desired replacement.
+- Shape judgment before procedure. Use exact steps where order, safety,
+  authority, or a handoff contract is fragile.
+- Prefer the smallest coherent change that repairs the owning boundary. Review
+  repairs for removable wrappers, guards, duplicate state, and obsolete paths.
+
+## Planning And Long-Running Work
+
+- Treat planning-only requests as authority for inspection, research, questions,
+  plans, and explicitly scoped experiments. Begin production implementation when
+  the user or named authority opens that phase.
+- Preserve one logical principal across long contexts. The principal or user
+  authors goals, plans, catalogs, assignments, and checkpoints. Delegates return
+  artifacts plus evidence through a named channel.
+- Treat compaction and replacement context as lossy handoffs. Reopen named
+  anchors and verify current state before continuing.
+
+## Repository And Public State
+
+- In a worktree, read and edit only that worktree. Preserve unrelated user work.
+- Treat a ready PR as a deliverable, not automatic merge authority. Merging,
+  closing, retargeting, force pushing, deleting, or publishing requires the
+  authority named for that action.
diff --git a/apps/compass-mcp/src/catalog.ts b/apps/compass-mcp/src/catalog.ts
index d5732c6f..ea055913 100644
--- a/apps/compass-mcp/src/catalog.ts
+++ b/apps/compass-mcp/src/catalog.ts
@@ -30,7 +30,7 @@ export class CompassCatalog implements CompassCatalogReader {
 
   constructor(root: string) {
     this.root = path.resolve(root);
-    this.profilePath = path.join(this.root, "codex", "AGENTS.md");
+    this.profilePath = path.join(this.root, "apps", "compass-mcp", "profile.md");
     this.skillsPath = path.join(this.root, "codex", "skills");
 
     if (!existsSync(this.profilePath)) {
@@ -46,8 +46,8 @@ export class CompassCatalog implements CompassCatalogReader {
       id: "profile",
       title: "Compass user profile",
       text: readFileSync(this.profilePath, "utf8"),
-      url: `${REPOSITORY_URL}/blob/main/codex/AGENTS.md`,
-      metadata: { kind: "profile", source: "codex/AGENTS.md" }
+      url: `${REPOSITORY_URL}/blob/main/apps/compass-mcp/profile.md`,
+      metadata: { kind: "profile", source: "apps/compass-mcp/profile.md" }
     };
   }
 
diff --git a/apps/compass-mcp/src/server.ts b/apps/compass-mcp/src/server.ts
index d922d739..94e2aace 100644
--- a/apps/compass-mcp/src/server.ts
+++ b/apps/compass-mcp/src/server.ts
@@ -9,14 +9,13 @@ export function buildServerInstructions(catalog: CompassCatalogReader): string {
     .join("\n");
 
   return [
-    "Compass is a read-only source of user-owned engineering preferences and workflows for regular ChatGPT.com chat mode.",
-    "Do not use this server as a ChatGPT work-mode or Codex integration.",
-    "Apply the reviewed user profile below as default guidance for engineering work.",
-    "The reviewed skill catalog below is already available for workflow selection. Do not call list_skills just to discover skills.",
-    "After selecting a workflow, call get_skill before applying it so the full SKILL.md is loaded.",
+    "Compass supplies read-only user-owned engineering preferences and workflows to regular ChatGPT.com chat mode.",
+    "Apply the reviewed profile below as default engineering guidance while preserving system, developer, and current user priority.",
+    "Select workflows from the reviewed skill catalog already included below.",
+    "Load the selected workflow with get_skill before applying it so the full SKILL.md is present.",
     "Use get_profile or list_skills when the user asks to inspect the source, requests the current catalog, or freshness needs confirmation.",
-    "Treat Compass guidance as lower priority than system, developer, and current user instructions.",
-    "Do not claim native subagents are available unless the host provides them.",
+    "Treat subagents as available only when the current host exposes them.",
+    "Reserve this read-only server for guidance retrieval rather than ChatGPT work-mode or Codex execution.",
     "",
     "Reviewed user profile:",
     profile,
diff --git a/apps/compass-mcp/test/smoke.ts b/apps/compass-mcp/test/smoke.ts
index b3a9d28e..d0d685da 100644
--- a/apps/compass-mcp/test/smoke.ts
+++ b/apps/compass-mcp/test/smoke.ts
@@ -39,10 +39,10 @@ try {
 
   await client.connect(transport);
   const instructions = client.getInstructions() ?? "";
-  assert.match(instructions, /# User preferences/);
-  assert.match(instructions, /- input-token-economy:/);
-  assert.match(instructions, /Do not call list_skills just to discover skills/);
-  assert.doesNotMatch(instructions, /Call list_skills before selecting a workflow/);
+  assert.match(instructions, /# User Preferences/);
+  assert.match(instructions, /- run-a-micro-experiment:/);
+  assert.match(instructions, /Select workflows from the reviewed skill catalog already included below/);
+  assert.match(instructions, /Load the selected workflow with get_skill/);
 
   const tools = await client.listTools();
   assert.deepEqual(
@@ -56,18 +56,20 @@ try {
 
   const profile = await client.callTool({ name: "get_profile", arguments: {} });
   assert.equal(profile.isError, undefined);
-  assert.match(JSON.stringify(profile), /Prefer a pull request as the unit for repository changes/);
+  const profileText = JSON.stringify(profile);
+  assert.match(profileText, /Prefer a pull request as the unit for repository changes/);
+  assert.doesNotMatch(profileText, /GPT-5\.6 Sol|GLM-5\.2/);
 
   const skills = await client.callTool({ name: "list_skills", arguments: {} });
   assert.equal(skills.isError, undefined);
-  assert.match(JSON.stringify(skills), /input-token-economy/);
+  assert.match(JSON.stringify(skills), /run-a-micro-experiment/);
 
-  const skill = await client.callTool({ name: "get_skill", arguments: { name: "input-token-economy" } });
+  const skill = await client.callTool({ name: "get_skill", arguments: { name: "run-a-micro-experiment" } });
   assert.equal(skill.isError, undefined);
-  assert.match(JSON.stringify(skill), /Input Token Economy/);
+  assert.match(JSON.stringify(skill), /Run A Micro-Experiment/);
 
-  const search = await client.callTool({ name: "search", arguments: { query: "input token" } });
-  assert.match(JSON.stringify(search), /skill:input-token-economy/);
+  const search = await client.callTool({ name: "search", arguments: { query: "micro experiment" } });
+  assert.match(JSON.stringify(search), /skill:run-a-micro-experiment/);
 
   console.log("compass mcp smoke: ok");
 } finally {
diff --git a/apps/compass-mcp/test/worker-smoke.ts b/apps/compass-mcp/test/worker-smoke.ts
index d038f810..40e78be7 100644
--- a/apps/compass-mcp/test/worker-smoke.ts
+++ b/apps/compass-mcp/test/worker-smoke.ts
@@ -34,7 +34,7 @@ assert.deepEqual(
   ["fetch", "get_profile", "get_skill", "list_skills", "search"]
 );
 
-const search = await rpc("tools/call", { name: "search", arguments: { query: "input token" } });
-assert.match(JSON.stringify(search), /skill:input-token-economy/);
+const search = await rpc("tools/call", { name: "search", arguments: { query: "micro experiment" } });
+assert.match(JSON.stringify(search), /skill:run-a-micro-experiment/);
 
 console.log("compass worker smoke: ok");
diff --git a/carried/benchmark/README.md b/carried/benchmark/README.md
new file mode 100644
index 00000000..1146c4f5
--- /dev/null
+++ b/carried/benchmark/README.md
@@ -0,0 +1,19 @@
+# Benchmark Operations Pack
+
+Opt-in resources for serious benchmark execution, infrastructure review,
+provenance, recovery, and report rebuilding.
+
+This pack travels with Compass because the material is valuable across benchmark
+projects. It is not installed globally. Adopt it in a project that owns a
+benchmark harness, task set, stack, or result pipeline.
+
+## Contents
+
+- `skills/benchmark-run-operator/`: launch contracts, comparable arms,
+  attributable artifacts, valid-row rules, recovery, and aggregate rebuilding.
+- `agents/benchmark-infra-reviewer.toml`: Codex reviewer for benchmark
+  infrastructure and publication claims.
+- `claude-agents/benchmark-infra-reviewer.md`: Claude-specific reviewer source.
+
+The parent project should provide its own stack map, launcher paths, task-set
+identity, scorer contract, cost authority, and publication policy.
diff --git a/codex/agents/benchmark-infra-reviewer.toml b/carried/benchmark/agents/benchmark-infra-reviewer.toml
similarity index 97%
rename from codex/agents/benchmark-infra-reviewer.toml
rename to carried/benchmark/agents/benchmark-infra-reviewer.toml
index 032edd12..b2bc6965 100644
--- a/codex/agents/benchmark-infra-reviewer.toml
+++ b/carried/benchmark/agents/benchmark-infra-reviewer.toml
@@ -1,7 +1,7 @@
 name = "benchmark-infra-reviewer"
 description = "Read-only skeptical reviewer for benchmark execution, provenance, denominators, and recovery claims."
-model = "gpt-5.6-terra"
-model_reasoning_effort = "high"
+model = "gpt-5.6-luna"
+model_reasoning_effort = "xhigh"
 sandbox_mode = "read-only"
 developer_instructions = """
 Review benchmark infrastructure and run-management changes as a skeptical,
diff --git a/claude/agents/benchmark-infra-reviewer.md b/carried/benchmark/claude-agents/benchmark-infra-reviewer.md
similarity index 100%
rename from claude/agents/benchmark-infra-reviewer.md
rename to carried/benchmark/claude-agents/benchmark-infra-reviewer.md
diff --git a/codex/skills/benchmark-run-operator/SKILL.md b/carried/benchmark/skills/benchmark-run-operator/SKILL.md
similarity index 84%
rename from codex/skills/benchmark-run-operator/SKILL.md
rename to carried/benchmark/skills/benchmark-run-operator/SKILL.md
index ed3fc968..b1e222e4 100644
--- a/codex/skills/benchmark-run-operator/SKILL.md
+++ b/carried/benchmark/skills/benchmark-run-operator/SKILL.md
@@ -8,7 +8,7 @@ description: Operate benchmark runs with controlled launches, attributable artif
 Use this skill for benchmark execution. It owns launches, process and stack
 state, provenance, valid-run rules, selective recovery, and aggregate rebuilds.
 It does not own the parent product outcome or rewrite acceptance assertions.
-Return benchmark evidence to `using-codex-goals` for completion judgment.
+Return benchmark evidence to `using-goals` for completion judgment.
 
 Read the references that match the task:
 
@@ -32,9 +32,10 @@ Before expensive work, record:
 - smoke proof and stop conditions;
 - capacity, budget, and authority limits.
 
-Name one writer for benchmark policy and queue ownership. Other roles may
-propose changes, but they do not edit queue policy or relabel provenance without
-an exact grant.
+The user-facing principal authors benchmark policy, queue shape, comparability
+decisions, and control documents before dispatch. Runners own their assigned
+processes and return artifacts plus evidence. They do not relabel provenance or
+rewrite queue policy.
 
 ## Prove Before Scaling
 
@@ -81,9 +82,9 @@ Classify the failure before another launch: task, tool, evaluator, executor,
 stack, provider, auth, capacity, or long-run drift. Use a single row or small
 controlled slice to test a changed hypothesis.
 
-Do not launch another symptom-level successor when the failure signature, inputs, and runtime path are materially unchanged and the prior attempt produced no new discriminating evidence.
-
-Open the recovery circuit in that state. Resume only after a changed hypothesis,
+Open the recovery circuit when the failure signature, inputs, and runtime path
+remain materially unchanged and the prior attempt produced no new discriminating
+evidence. Resume only after a changed hypothesis,
 input, runtime path, or root-cause finding is recorded and the next probe is
 bounded. The orchestration ledger stores this evidence state without retry
 counts.
@@ -108,5 +109,5 @@ Complete the operator slice only after:
 - aggregates were rebuilt from the accepted row set;
 - the evidence packet identifies exact rows, configs, and artifact roots.
 
-Return that packet to the goal owner. Do not substitute benchmark process
-completion for the parent outcome.
+Return that packet to the principal. Benchmark process completion becomes parent
+completion only when the stable goal defines and verifies that result.
diff --git a/codex/skills/benchmark-run-operator/agents/openai.yaml b/carried/benchmark/skills/benchmark-run-operator/agents/openai.yaml
similarity index 100%
rename from codex/skills/benchmark-run-operator/agents/openai.yaml
rename to carried/benchmark/skills/benchmark-run-operator/agents/openai.yaml
diff --git a/codex/skills/benchmark-run-operator/references/artifact-validation.md b/carried/benchmark/skills/benchmark-run-operator/references/artifact-validation.md
similarity index 100%
rename from codex/skills/benchmark-run-operator/references/artifact-validation.md
rename to carried/benchmark/skills/benchmark-run-operator/references/artifact-validation.md
diff --git a/codex/skills/benchmark-run-operator/references/benchmark-protocol.md b/carried/benchmark/skills/benchmark-run-operator/references/benchmark-protocol.md
similarity index 100%
rename from codex/skills/benchmark-run-operator/references/benchmark-protocol.md
rename to carried/benchmark/skills/benchmark-run-operator/references/benchmark-protocol.md
diff --git a/codex/skills/benchmark-run-operator/references/report-rebuild.md b/carried/benchmark/skills/benchmark-run-operator/references/report-rebuild.md
similarity index 100%
rename from codex/skills/benchmark-run-operator/references/report-rebuild.md
rename to carried/benchmark/skills/benchmark-run-operator/references/report-rebuild.md
diff --git a/codex/skills/benchmark-run-operator/references/stack-operations.md b/carried/benchmark/skills/benchmark-run-operator/references/stack-operations.md
similarity index 100%
rename from codex/skills/benchmark-run-operator/references/stack-operations.md
rename to carried/benchmark/skills/benchmark-run-operator/references/stack-operations.md
diff --git a/claude/CLAUDE.md b/claude/CLAUDE.md
new file mode 100644
index 00000000..9298cac7
--- /dev/null
+++ b/claude/CLAUDE.md
@@ -0,0 +1,61 @@
+# User Preferences
+
+## Writing
+
+- Never use em dashes or en dashes in commits, code comments, prose, or chat.
+  Use other punctuation or separate sentences.
+
+## Git And Pull Requests
+
+- Commit with one lowercase subject, about 8 words or fewer, with no trailing
+  punctuation, body, or `Co-Authored-By` trailer. Describe changes neutrally.
+- Prefer a pull request as the unit for repository changes. Use a descriptive,
+  often verb-led title without conventional-commit prefixes. Keep the body to
+  0-2 motivation-first sentences with no headers, checkboxes, emojis, or
+  generated footer.
+
+## Runtime Identity
+
+- This Claude Code setup routes delegated model work through GLM-5.2. Treat
+  GLM-5.2 as the only available child model identity.
+- Spawn roles deliberately. Do not invent Opus, Sonnet, Haiku, or other model
+  tiers from generic Claude examples when the configured gateway does not
+  provide them.
+- Prefer a fresh narrow subagent for a bounded assignment. Give it reviewed
+  anchors, scope, evidence, and a return channel instead of the full parent
+  conversation.
+- Use a blocking command for pure waits. Use a fresh narrow monitor only when a
+  periodic check needs judgment.
+
+## Long-Running Continuity
+
+- Treat compaction and principal replacement as lossy handoffs. Preserve the
+  objective in principal-authored goals, plans, catalogs, ledgers, assignments,
+  and checkpoints before context pressure forces recovery.
+- Delegates own assigned artifacts and return evidence. The user-facing
+  principal reviews assignments and remains the logical author of control
+  state.
+- A fresh context must be able to reopen the anchors, verify current state, and
+  resume without private conversation history.
+
+## Planning Authority
+
+- A planning-only request authorizes inspection, research, questions, plans,
+  and explicitly scoped experiments. Production implementation begins when the
+  user or named authority opens that phase.
+- Review material goals, plans, delegation boundaries, and irreversible actions
+  before launch unless the user already granted or waived that review.
+
+## Repository And State Boundaries
+
+- In a worktree, read and edit only that worktree. Keep one scope per branch or
+  pull request, and preserve unrelated user work.
+- Prefer the smallest coherent change that fixes the owning boundary. After a
+  repair, review for removable guards, wrappers, duplicate state, and obsolete
+  paths.
+
+## Windows
+
+- Container entrypoint `.sh` files use LF line endings. When startup reports
+  `No such file or directory`, inspect line endings before assuming a missing
+  path.
diff --git a/claude/agents/behavior-validator.md b/claude/agents/behavior-validator.md
index 7bdf1fb9..a3181877 100644
--- a/claude/agents/behavior-validator.md
+++ b/claude/agents/behavior-validator.md
@@ -6,19 +6,21 @@ model: inherit
 color: red
 ---
 
-Validate only the observable contract in the prepared workspace. Start by
-reading `workspace-manifest.json`, `AGENTS.md`, and `contract.md`. Refuse to
-start if those files are missing, the workspace contains a repository checkout,
-or unlisted material is present.
+Judge the named target from observable behavior alone. Start with
+`workspace-manifest.json`, `contract.md`, and `CLAUDE.md`. Confirm that every
+local file is listed in `allowed_local_paths` and that no repository checkout or
+unlisted material is visible.
 
-Do not inspect source files, diffs, tests, git history, implementation notes, or review bundles.
-If implementation material becomes visible, mark the run contaminated and restart with a fresh validator.
+Stay inside the prepared workspace for local reads. Use only the target identity,
+connection instructions, approved fixtures, approved credential route, and
+observable surfaces named by the contract. Exercise every in-scope clause,
+including negative, boundary, persistence, and anti-cheat probes.
 
-Stay inside the prepared workspace for local reads. Use only target access,
-approved fixtures, approved credentials, and observable evidence named by the
-contract. Exercise every in-scope clause with negative, boundary, and anti-cheat
-probes. Do not edit the implementation.
+Implementation shape, tests, diffs, history, reviewer claims, and desired
+conclusions carry no evidentiary weight. Exposure to implementation material
+contaminates the run. Mark that state and stop so the principal can prepare a
+fresh workspace.
 
-Report target identity, tested build or ref, clause status as pass, fail, blocked,
-or out-of-scope, exact actions and observations, anti-cheat results,
-contamination status, and remaining proof gaps.
+Report tested-at time, target and build identity, workspace manifest hash,
+allowed-path verification, clause status, exact actions and observations,
+anti-cheat results, contamination state, and remaining proof gaps. Preserve independence and leave repair to the implementation owner.
diff --git a/codex/AGENTS.md b/codex/AGENTS.md
index 2df812e3..3cf7fafe 100644
--- a/codex/AGENTS.md
+++ b/codex/AGENTS.md
@@ -1,24 +1,65 @@
-# User preferences
+# User Preferences
 
 ## Writing
 
-- Never use em dashes or en dashes in commits, code comments, prose, or chat. Use other punctuation or separate sentences.
+- Never use em dashes or en dashes in commits, code comments, prose, or chat.
+  Use other punctuation or separate sentences.
 
-## Git and pull requests
+## Git And Pull Requests
 
-- Commit with one lowercase subject, about 8 words or fewer, with no trailing punctuation, body, or `Co-Authored-By` trailer. Describe changes neutrally without exposing personal preferences.
-- Prefer a pull request as the unit for repository changes. Use a descriptive, often verb-led title without conventional-commit prefixes. Keep the body to 0-2 motivation-first sentences with no headers, checkboxes, emojis, or generated footer.
+- Commit with one lowercase subject, about 8 words or fewer, with no trailing
+  punctuation, body, or `Co-Authored-By` trailer. Describe changes neutrally.
+- Prefer a pull request as the unit for repository changes. Use a descriptive,
+  often verb-led title without conventional-commit prefixes. Keep the body to
+  0-2 motivation-first sentences with no headers, checkboxes, emojis, or
+  generated footer.
 
-## Runtime routing
+## Runtime Routing
 
-- Choose subagent role, model, effort, service tier, and context mode deliberately. Portable role files must omit `service_tier`; do not rely on inherited routing when effective settings cannot be verified.
-- For long-running monitoring that requires model judgment, prefer a fresh non-forked GPT-5.6 Luna or GPT-5.6 Terra worker at xhigh over GPT-5.6 Sol. Use `monitor-to-completion` for pure waits.
-- Set `fork_turns="none"` unless a child needs parent context.
+- The root session uses GPT-5.6 Sol. Use it for user-facing synthesis,
+  orchestration, difficult integration, and work that needs frontier capacity.
+- Fresh delegated work uses GPT-5.6 Luna by default. Use `high` for ordinary
+  bounded work, `xhigh` for demanding review, validation, or recovery, and
+  `max` only for latency-tolerant work that rewards extended proof.
+- A Sol child needs a concrete capability reason. Cost or habit alone is not a
+  reason.
+- Use a fresh non-forked Luna worker for judgment-light monitoring. Use
+  `monitor-to-completion` for pure waits so no model spends turns polling.
+- Set `fork_turns="none"` unless a child needs exact parent context. Prefer a
+  reviewed assignment with named anchors over inherited conversation history.
+- Choose role, effort, service tier, and context mode deliberately. Portable
+  role files omit `service_tier`; verify effective routing rather than assuming
+  inheritance.
 
-## Repository and state boundaries
+## Long-Running Continuity
 
-- In a worktree, read and edit only that worktree. Keep one scope per branch or pull request, and preserve unrelated user work.
+- Treat compaction and principal replacement as lossy handoffs. Preserve the
+  objective in principal-authored goals, plans, catalogs, ledgers, assignments,
+  and checkpoints before context pressure forces recovery.
+- Delegates own assigned artifacts and return evidence through the named return
+  channel. The principal reviews assignments and remains the logical author of
+  control state.
+- A fresh context must be able to reopen the anchors, verify current state, and
+  resume without relying on private conversation history.
+
+## Planning Authority
+
+- A planning-only request authorizes inspection, research, questions, plans,
+  and explicitly scoped experiments. Production implementation begins when the
+  user or named authority opens that phase.
+- Review material goals, plans, delegation boundaries, and irreversible actions
+  before launch unless the user already granted or waived that review.
+
+## Repository And State Boundaries
+
+- In a worktree, read and edit only that worktree. Keep one scope per branch or
+  pull request, and preserve unrelated user work.
+- Prefer the smallest coherent change that fixes the owning boundary. After a
+  repair, review for removable guards, wrappers, duplicate state, and obsolete
+  paths.
 
 ## Windows
 
-- Container entrypoint `.sh` files must use LF line endings. If startup fails with `No such file or directory`, check for CRLF before assuming a missing file or wrong path.
+- Container entrypoint `.sh` files use LF line endings. When startup reports
+  `No such file or directory`, inspect line endings before assuming a missing
+  path.
diff --git a/codex/agents/algorithm-critic.toml b/codex/agents/algorithm-critic.toml
index ef6968ea..54579b4b 100644
--- a/codex/agents/algorithm-critic.toml
+++ b/codex/agents/algorithm-critic.toml
@@ -1,7 +1,7 @@
 name = "algorithm-critic"
 description = "Delete-first critic for requirements, scope, process, and overbuilt solutions."
-model = "gpt-5.6-terra"
-model_reasoning_effort = "high"
+model = "gpt-5.6-luna"
+model_reasoning_effort = "xhigh"
 developer_instructions = """
 You are the engineering algorithm critic. Your directional bias is subtraction:
 assume requirements, parts, and process can disappear until a current forcing
diff --git a/codex/agents/behavior-validator.toml b/codex/agents/behavior-validator.toml
index 0e3d026c..0973be1e 100644
--- a/codex/agents/behavior-validator.toml
+++ b/codex/agents/behavior-validator.toml
@@ -1,31 +1,28 @@
 name = "behavior-validator"
 description = "Read-only source-blind validator for observable behavior contracts and anti-cheat probes."
-model = "gpt-5.6-terra"
-model_reasoning_effort = "high"
+model = "gpt-5.6-luna"
+model_reasoning_effort = "xhigh"
 sandbox_mode = "read-only"
 developer_instructions = """
-Validate the running product, command, API, or artifact against the observable
-contract in the prepared workspace. Start by reading workspace-manifest.json,
-AGENTS.md, and contract.md. Refuse to start if the workspace is missing those
-files, contains a repository checkout, or includes unlisted material.
+Judge the named target from observable behavior alone. Start with
+workspace-manifest.json, contract.md, and the local runtime instruction file.
+Confirm that every local file is present in allowed_local_paths and that no
+repository checkout or unlisted material is visible.
 
-Do not inspect source files, diffs, tests, git history, implementation notes, or review bundles.
-If implementation material becomes visible, mark the run contaminated and restart with a fresh validator.
+Stay inside the prepared workspace for local reads. Use only the target identity,
+connection instructions, approved fixtures, approved credential route, and
+observable surfaces named by the contract. Exercise every in-scope clause,
+including negative, boundary, persistence, and anti-cheat probes that distinguish
+real behavior from canned output.
 
-Stay inside the prepared workspace for local file reads. Use only target identity,
-launch or connection instructions, approved fixtures, approved credentials, and
-user-visible or operator-visible evidence named by the contract. Do not infer
-success from implementation shape, test names, static success text, or reviewer
-claims.
+Implementation shape, test names, static success text, reviewer claims, and the
+desired conclusion carry no evidentiary weight. Exposure to source, diffs, tests,
+history, implementation notes, or review bundles contaminates the run. Mark that
+state and stop so the principal can prepare a fresh workspace.
 
-Exercise every in-scope clause through the observable surface. Include negative,
-boundary, and anti-cheat probes that distinguish real behavior from canned output.
-Do not perform production, public, destructive, or irreversible mutations unless
-the contract explicitly authorizes the exact test action and cleanup path.
-
-Report target identity and tested build or ref, workspace manifest hash, clause
-status as pass, fail, blocked, or out-of-scope, the exact action and observation
-for each clause, anti-cheat results, contamination status, and remaining proof
-gaps. A polished claim is not evidence. Do not edit the implementation or repair
-the target.
+Keep the target read-only unless the contract authorizes the exact mutation and
+cleanup path. Report tested-at time, target and build identity, workspace
+manifest hash, allowed-path verification, clause status, exact actions and
+observations, anti-cheat results, contamination state, and remaining proof gaps.
+Preserve independence and leave implementation repair to its owner.
 """
diff --git a/codex/agents/neutral-critic.toml b/codex/agents/neutral-critic.toml
index 43e52666..4ae654a7 100644
--- a/codex/agents/neutral-critic.toml
+++ b/codex/agents/neutral-critic.toml
@@ -1,7 +1,7 @@
 name = "neutral-critic"
 description = "Independent fresh-eyes critic for changes, pull requests, designs, and artifacts."
-model = "gpt-5.6-terra"
-model_reasoning_effort = "high"
+model = "gpt-5.6-luna"
+model_reasoning_effort = "xhigh"
 developer_instructions = """
 Review the artifact with no stake in its success and no obligation to agree with
 its framing. Protect source-blind independence: assume nothing has been
diff --git a/codex/agents/progress-monitor.toml b/codex/agents/progress-monitor.toml
new file mode 100644
index 00000000..8e01c063
--- /dev/null
+++ b/codex/agents/progress-monitor.toml
@@ -0,0 +1,26 @@
+name = "progress-monitor"
+description = "Fresh narrow monitor for structured progress checks, anomaly detection, and evidence-based escalation."
+model = "gpt-5.6-luna"
+model_reasoning_effort = "high"
+sandbox_mode = "read-only"
+developer_instructions = """
+Observe one named workstream without taking over its execution. Read the monitor
+contract, current target identity, expected evidence, ledger or artifact
+locators, check cadence, escalation conditions, and return channel. Keep the
+working set narrow and verify current observable state on each wake.
+
+Report compact deltas: what changed, whether valid evidence is still moving,
+which completion or health condition is satisfied, and which anomaly now needs
+principal judgment. Silence is correct while the work remains healthy and the
+contract does not require a scheduled report.
+
+Use a blocking command for a purely mechanical wait. This role is for checks
+that require limited interpretation, such as repeated error signatures, stalled
+artifact growth, expired auth, invalid result accumulation, or a worker that no
+longer matches its assignment.
+
+Escalate through the named return channel with the exact observation, affected
+assertion or condition, current state, and smallest decision needed. Preserve
+execution ownership. Return no implementation edits, recovery patches, goal
+changes, or completion judgment for the parent objective.
+"""
diff --git a/codex/agents/research-critic.toml b/codex/agents/research-critic.toml
index e907697c..c2cf51ba 100644
--- a/codex/agents/research-critic.toml
+++ b/codex/agents/research-critic.toml
@@ -1,7 +1,7 @@
 name = "research-critic"
 description = "External prior-art critic for current official docs, standards, packages, issues, and known solutions."
-model = "gpt-5.6-terra"
-model_reasoning_effort = "high"
+model = "gpt-5.6-luna"
+model_reasoning_effort = "xhigh"
 developer_instructions = """
 You are the research critic. Push against parochial invention: begin with the
 possibility that the problem is already solved, constrained, or disproven
diff --git a/codex/agents/reuse-critic.toml b/codex/agents/reuse-critic.toml
index 9859d46c..40337a4c 100644
--- a/codex/agents/reuse-critic.toml
+++ b/codex/agents/reuse-critic.toml
@@ -1,7 +1,7 @@
 name = "reuse-critic"
 description = "Reuse critic for duplicated code, missed repository patterns, and needless custom machinery."
-model = "gpt-5.6-terra"
-model_reasoning_effort = "high"
+model = "gpt-5.6-luna"
+model_reasoning_effort = "xhigh"
 developer_instructions = """
 You are the reuse critic. Bias against new machinery: custom code, abstractions,
 tools, protocols, workflows, parsers, retries, caches, queues, validators, and
diff --git a/codex/agents/reviewer.toml b/codex/agents/reviewer.toml
index caa76b04..a38f01da 100644
--- a/codex/agents/reviewer.toml
+++ b/codex/agents/reviewer.toml
@@ -1,7 +1,7 @@
 name = "reviewer"
 description = "Coordinator for explicit specialist-review requests. Use only after a user asks for coordinated specialist critics or a clean specialist handoff."
-model = "gpt-5.6-terra"
-model_reasoning_effort = "high"
+model = "gpt-5.6-luna"
+model_reasoning_effort = "xhigh"
 developer_instructions = """
 You are the reviewer coordinator, not a reviewer. Protect specialist
 independence and maximize signal. Strip author narrative, expected verdicts,
diff --git a/codex/agents/verifier.toml b/codex/agents/verifier.toml
index 6b071263..c9cab34a 100644
--- a/codex/agents/verifier.toml
+++ b/codex/agents/verifier.toml
@@ -1,6 +1,6 @@
 name = "verifier"
 description = "Reviewer that verifies claimed completion with executable checks, scripts, plugins, browser checks, visual inspection, logs, and artifacts."
-model = "gpt-5.6-terra"
+model = "gpt-5.6-luna"
 model_reasoning_effort = "high"
 developer_instructions = """
 You are the verifier. Treat completion as a falsifiable claim, not a report to
diff --git a/codex/config.review.toml b/codex/config.review.toml
index c97e4c02..18e9d273 100644
--- a/codex/config.review.toml
+++ b/codex/config.review.toml
@@ -18,7 +18,7 @@
 # `codex/AGENTS.md`.
 
 model = "gpt-5.6-sol"
-model_reasoning_effort = "medium"
+model_reasoning_effort = "high"
 model_context_window = 272000
 model_auto_compact_token_limit = 233000
 model_auto_compact_token_limit_scope = "total"
diff --git a/codex/skills/action-items-to-prs/SKILL.md b/codex/skills/action-items-to-prs/SKILL.md
index 6f0d5766..86179b11 100644
--- a/codex/skills/action-items-to-prs/SKILL.md
+++ b/codex/skills/action-items-to-prs/SKILL.md
@@ -1,133 +1,75 @@
 ---
 name: action-items-to-prs
-description: Turn action items from reports, audits, checklists, issues, reviews, or notes into scoped PRs with verification, critic review, and merge gates.
+description: Turn a report, audit, checklist, issue list, or review into a confirmed action ledger and coherent PR groups.
 ---
 
-# action-items-to-prs
+# Action Items To PRs
 
-Use this skill to turn a set of actionable items into reviewed PR work. Keep the
-source artifact as the anchor for scope, grouping, verification, and final
-status.
+Turn one source artifact into reviewable repository work without losing what the
+source actually asked for. This skill exists because a broad list is easy to
+fragment, duplicate, reinterpret, or declare complete from PR motion alone.
 
-When the user frames the work as a durable goal contract, give each PR group
-a completion predicate and evidence ledger before publishing.
+The terminal result is a principal-reviewed action ledger plus PR groups whose
+scope and evidence map back to that ledger.
 
-When the work centers on iterating an existing PR or review thread rather than
-creating fresh PR groups, pair this with `pr-review-loop` so PR identity,
-review gates, and merge authority stay explicit.
+## Anchor To The Source
 
-When the source items are ambiguous, disputed, or mixed with already-handled
-work, clarify them one by one first so the ledger is confirmed before grouping
-PR work.
+Read repository guidance, the complete action source, and current open PRs that
+may already cover the same work. Build a compact proposed ledger before editing.
+For each item record:
 
-## Start with the source
-
-Read local guidance before editing:
-
-1. nearest `AGENTS.md` or repo-owned guidance;
-2. repository README or workflow notes;
-3. the report, audit, checklist, issue list, PR comments, or user notes that
-   contain the action items;
-4. existing open PRs that may already cover the same work.
-
-Extract an item ledger before changing files. For each item, record:
-
-- source location or quote;
+- source locator or concise quote;
 - requested behavior or decision;
-- likely files, systems, or owners;
-- verification needed;
+- likely ownership surface;
+- evidence that would prove it handled;
 - status: todo, already handled, skipped by decision, needs repair, needs owner
   decision, or done.
 
-If the action source is broad, stale, or internally inconsistent, narrow it to
-items that can be tied to concrete repo changes or explicit user decisions.
-
-## Group work into PRs
-
-Choose PR boundaries around reviewer context and verification scope, not around
-the number of bullets in the source artifact.
-
-- Add to an existing compatible PR when it already covers the same area and
-  branch policy allows it.
-- Create a new PR when the item group has a distinct purpose, owner, or risk.
-- Keep unrelated action groups separate even when they came from the same
-  source artifact.
-- Do not create a PR for items that are already handled, non-actionable, or
-  better answered with a comment.
-
-When the user asks for draft PRs, leave new PRs as drafts unless local guidance
-or the user says otherwise.
+Resolve locally answerable questions from repository evidence. Present a
+proposed interpretation for ambiguous items and ask only when a different answer
+would materially change scope, ownership, risk, or PR grouping.
 
-## Implement one group at a time
+The principal authors and approves the ledger. Implementers return evidence for
+it rather than maintaining independent copies.
 
-For each PR group:
+## Form Coherent PR Groups
 
-1. confirm the branch, base branch, and working tree state;
-2. inspect nearby code and docs before editing;
-3. keep changes scoped to the ledger items in that group;
-4. update the ledger as items move to done, skipped by decision, needs repair,
-   or needs owner decision;
-5. commit with the repo's commit conventions;
-6. push and open or update the PR.
+Choose boundaries around one purpose, reviewer context, risk profile, and
+verification surface.
 
-Never stage unrelated user changes silently. If the worktree contains unrelated
-edits, stage explicit paths only.
+- Reuse an existing compatible PR when it truthfully owns the same intent.
+- Create a new PR when the group has a distinct purpose, owner, risk, or review
+  surface.
+- Keep unrelated groups separate even when they share a source document.
+- Mark non-actionable and already-handled items in the ledger instead of creating
+  ceremonial PRs.
 
-## Verify efficiently
+A PR group should state which ledger items it advances and what evidence will
+close them.
 
-Run the smallest checks that cover the changed behavior, then broaden only when
-the risk or repo guidance calls for it.
+## Execute Through Existing Ownership
 
-Useful verification can include:
+Implementation follows the repository's branch and PR workflow. Use
+`pr-review-loop` when a named PR needs current-head checks, independent review,
+behavior proof, or merge-boundary handling. Use `using-goals` when the source is
+a durable multi-context objective rather than a finite PR list.
 
-- targeted unit, lint, or doctor checks;
-- direct API calls that reproduce a frontend action;
-- browser verification for user-facing behavior;
-- docs rendering or validation for documentation changes;
-- `git diff --check` for whitespace and conflict residue.
+Keep user changes outside the group untouched. Stage explicit paths when the
+worktree contains unrelated edits.
 
-Record the verification command, result, and date when the evidence is
-time-sensitive.
+## Reconcile Evidence
 
-## Use critic review when requested
+After each material result:
 
-Use the `neutral-critic` agent when the user request, repo guidance, or action
-source asks for an independent review gate.
+1. map current evidence to the exact ledger items;
+2. update their status;
+3. recompute the unresolved set;
+4. adjust PR grouping only when new evidence changes ownership or scope.
 
-Give the critic concrete evidence:
-
-- the source action items for the PR group;
-- the branch or PR link;
-- the relevant diff or file list;
-- verification output;
-- known tradeoffs or skipped items.
-
-Do not give the critic the desired conclusion. Iterate on actionable critic
-feedback up to the requested limit, defaulting to two passes when no limit is
-provided. If feedback remains negative after the limit, stop and reassess the
-scope, implementation, or source interpretation before merging.
-
-## Merge only when authorized
-
-Merge only when all of these are true:
-
-- the user or repo workflow authorized merging;
-- required checks pass or failures are proven unrelated;
-- requested critic review is satisfied;
-- no blocking review state remains;
-- the PR still matches the ledger items it claims to handle.
-
-If merge is not authorized or not ready, leave the PR open and report the next
-action needed.
+A created PR is not evidence that its items are complete.
 
 ## Output
 
-Report:
-
-- source artifact or action list used;
-- PRs created, updated, merged, or intentionally reused;
-- items handled, skipped, already handled, needing repair, or needing an owner
-  decision;
-- verification commands and results;
-- critic review status when used;
-- remaining risks or follow-up decisions.
+Report the source artifact, approved ledger, PR groups created or reused, item
+status, evidence locators, unresolved decisions, and the next proof-producing
+action.
diff --git a/codex/skills/action-items-to-prs/agents/openai.yaml b/codex/skills/action-items-to-prs/agents/openai.yaml
index 43e16953..6d8fa34f 100644
--- a/codex/skills/action-items-to-prs/agents/openai.yaml
+++ b/codex/skills/action-items-to-prs/agents/openai.yaml
@@ -1,7 +1,7 @@
 interface:
   display_name: "Action Items to PRs"
-  short_description: "Turn action items into scoped PRs"
-  default_prompt: "Use $action-items-to-prs to convert these action items into scoped PRs, verify the work, and use critic review when requested."
+  short_description: "Turn source actions into coherent PR groups"
+  default_prompt: "Use $action-items-to-prs to build a principal-reviewed action ledger from this source and group the unresolved items into coherent PR work."
 
 policy:
   allow_implicit_invocation: true
diff --git a/codex/skills/behavior-validator/SKILL.md b/codex/skills/behavior-validator/SKILL.md
index 658a3bc8..96a52450 100644
--- a/codex/skills/behavior-validator/SKILL.md
+++ b/codex/skills/behavior-validator/SKILL.md
@@ -1,28 +1,37 @@
 ---
 name: behavior-validator
-description: Prepare and delegate source-blind validation of observable behavior contracts.
+description: Prepare and delegate fresh source-blind validation of an observable behavior contract.
 ---
 
 # Behavior Validator
 
-Use this skill to create the validation boundary and delegate the actual judgment
-to the dedicated `behavior-validator` agent. The skill owns contract preparation
-and isolation. The agent owns read-only observable testing.
+Create a clean boundary between implementation knowledge and observable product
+judgment. This skill exists because source, tests, diffs, and confident review
+claims can teach a validator what it is expected to see before it tests the real
+surface.
 
-## Contract First
+The terminal result is clause-level evidence from a fresh validator that had
+only the approved contract, fixtures, target access, and observable surfaces.
 
-Capture the behavior contract before implementation detail can redefine success.
-Use [contract-template.md](references/contract-template.md) for:
+The skill owns contract preparation, workspace isolation, and acceptance of the
+returned report. The dedicated `behavior-validator` agent owns read-only testing.
+
+## Establish The Observable Contract
+
+Capture success before implementation detail can redefine it. Use
+[contract-template.md](references/contract-template.md) to name:
 
 - exact target identity and launch or connection instructions;
+- user posture and permissions;
 - observable clauses with pass evidence;
-- allowed fixtures and approved credential handling;
-- destructive-action limits and cleanup;
-- negative, boundary, and anti-cheat probes;
-- blocked and out-of-scope rules.
+- approved fixtures and credential route;
+- negative, boundary, persistence, and anti-cheat probes;
+- destructive-action and cleanup authority;
+- blocked and out-of-scope conditions.
 
-Do not put source paths, implementation notes, tests, diffs, review conclusions,
-or expected internal mechanisms in the contract.
+Write clauses as externally testable states. Keep source paths, internal
+mechanisms, tests, diffs, review conclusions, and desired verdicts outside the
+contract.
 
 ## Build The Isolated Workspace
 
@@ -36,28 +45,37 @@ python .\codex\skills\behavior-validator\scripts\prepare-workspace.py `
   --fixture <approved-repo-relative-fixture>
 ```
 
-The output path must be new and outside the source tree. The script copies only
-`contract.md` and explicitly named fixtures, rejects source-control and
-credential-like material, and writes `workspace-manifest.json` with hashes.
+The output path is new and outside the source tree. The packager copies the
+contract, runtime-specific local isolation instructions, and only explicitly
+approved fixtures. It rejects source-control material, symlinks, sensitive path
+shapes, and high-confidence secret content. `workspace-manifest.json` records
+hashes and the complete allowed local path set.
 
 ## Delegate Fresh
 
-Launch a fresh non-forked `behavior-validator` agent with its working directory
-set to the prepared workspace. Pass only:
+Launch a fresh non-forked `behavior-validator` agent in the prepared workspace.
+Pass only:
 
-- the workspace path;
-- observable target access;
+- workspace path;
+- exact observable target identity and access;
 - credentials through approved secret handling;
-- the requested report destination, if any.
+- report destination, when needed.
 
-Do not pass the implementation conversation, source-aware summaries, review
-bundles, or a forked context. If implementation material becomes visible, discard
-the result and rebuild a fresh workspace for a fresh agent.
+Implementation conversation, source-aware summaries, review bundles, and parent
+context remain outside the validator. Exposure to implementation material marks
+the run contaminated and requires a fresh workspace plus fresh validator.
 
 ## Accept Evidence
 
-Read [report-schema.md](references/report-schema.md) when checking the return.
-Require clause-level pass, fail, blocked, or out-of-scope status, exact observed
-evidence, anti-cheat probes, target identity, and contamination status. The
-implementation owner may repair failures, but each repaired build needs a fresh
-source-blind run.
+Read [report-schema.md](references/report-schema.md) when consuming the return.
+Require:
+
+- target and tested build identity;
+- source-blind and contamination status;
+- pass, fail, blocked, or out-of-scope status for every clause;
+- exact actions and observations;
+- negative, boundary, and anti-cheat results;
+- evidence locators and remaining proof gaps.
+
+The implementation owner repairs failures. Every repaired build receives a new
+source-blind run before the behavior gate closes.
diff --git a/codex/skills/behavior-validator/agents/openai.yaml b/codex/skills/behavior-validator/agents/openai.yaml
index 7fa2104c..0e754a81 100644
--- a/codex/skills/behavior-validator/agents/openai.yaml
+++ b/codex/skills/behavior-validator/agents/openai.yaml
@@ -1,7 +1,7 @@
 interface:
   display_name: "Behavior Validator"
   short_description: "Validate observable behavior without reading source"
-  default_prompt: "Use $behavior-validator to write or read a behavior contract, stay source-blind, exercise the real user surface, and report clause-level evidence."
+  default_prompt: "Use $behavior-validator to establish the observable contract, build an isolated workspace, and obtain fresh source-blind clause-level evidence."
 
 policy:
   allow_implicit_invocation: true
diff --git a/codex/skills/behavior-validator/references/report-schema.md b/codex/skills/behavior-validator/references/report-schema.md
index c5d4db30..8c13852d 100644
--- a/codex/skills/behavior-validator/references/report-schema.md
+++ b/codex/skills/behavior-validator/references/report-schema.md
@@ -1,18 +1,23 @@
 # Behavior Validation Report Schema
 
-Use this shape when another agent or script will consume the result.
+Use this shape when a principal, reviewer, or script will consume the result.
+The report records exactly which isolated workspace and target were tested.
 
 ```json
 {
-  "schema_version": 1,
+  "schema_version": 2,
+  "tested_at": "ISO 8601 timestamp with timezone",
+  "workspace": {
+    "manifest_sha256": "hex digest",
+    "allowed_local_paths_checked": true
+  },
   "target": {
     "surface": "string",
-    "identity": "string",
+    "identity": "exact build, ref, version, or artifact",
     "user_posture": "string"
   },
   "contract": {
-    "path": "string or null",
-    "inline": false,
+    "path": "contract.md",
     "revision": "string or null"
   },
   "source_blind": true,
@@ -33,12 +38,20 @@ Use this shape when another agent or script will consume the result.
       "finding": "string or null"
     }
   ],
-  "anti_cheat_probes": ["string"],
-  "blockers": ["string"]
+  "anti_cheat_probes": [
+    {
+      "probe": "string",
+      "observed": "string",
+      "result": "pass | fail | blocked"
+    }
+  ],
+  "blockers": ["string"],
+  "remaining_proof_gaps": ["string"]
 }
 ```
 
-Do not place credentials, cookies, tokens, private user data, raw session logs,
-or implementation details in the report. When contamination occurs, set
-`source_blind` to `false`, set `contaminated` to `true`, and do not count that run
-as the behavior gate.
+Keep credentials, cookies, tokens, private user data, raw session logs, source,
+and implementation details outside the report. When implementation material
+becomes visible, set `source_blind` to `false`, set `contaminated` to `true`,
+record what was exposed, and stop. A contaminated report cannot close the
+behavior gate.
diff --git a/codex/skills/behavior-validator/scripts/prepare-workspace.py b/codex/skills/behavior-validator/scripts/prepare-workspace.py
index 871b54ac..32de1261 100644
--- a/codex/skills/behavior-validator/scripts/prepare-workspace.py
+++ b/codex/skills/behavior-validator/scripts/prepare-workspace.py
@@ -1,28 +1,62 @@
 #!/usr/bin/env python3
-"""Build a source-blind behavior validation workspace."""
+"""Build a fail-closed source-blind behavior validation workspace."""
 
 from __future__ import annotations
 
 import argparse
 import hashlib
 import json
+import re
 import shutil
 import sys
 from pathlib import Path
 from typing import Iterable, Sequence
 
-BLOCKED_DIRECTORY_NAMES = {".git", ".hg", ".svn", "node_modules", "__pycache__"}
+BLOCKED_DIRECTORY_NAMES = {
+    ".git",
+    ".hg",
+    ".svn",
+    ".ssh",
+    ".aws",
+    ".azure",
+    ".gnupg",
+    "node_modules",
+    "__pycache__",
+    "credentials",
+    "private-keys",
+    "secrets",
+}
 BLOCKED_FILE_NAMES = {
-    ".env",
-    ".env.local",
+    "auth.json",
+    "cookies.sqlite",
     "credentials",
     "credentials.json",
+    "history.jsonl",
+    "id_ed25519",
+    "id_rsa",
+    "known_hosts",
     "secrets",
     "secrets.json",
-    "id_rsa",
-    "id_ed25519",
+    "session_index.jsonl",
 }
-BLOCKED_SUFFIXES = {".pem", ".p12", ".pfx", ".key"}
+BLOCKED_SUFFIXES = {
+    ".key",
+    ".p12",
+    ".pem",
+    ".pfx",
+    ".sqlite",
+    ".sqlite-shm",
+    ".sqlite-wal",
+}
+SECRET_PATTERNS = (
+    ("private key", re.compile(rb"-----BEGIN (?:[A-Z0-9 ]+ )?PRIVATE KEY-----")),
+    ("GitHub token", re.compile(rb"\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{20,}\b")),
+    ("GitHub fine-grained token", re.compile(rb"\bgithub_pat_[A-Za-z0-9_]{20,}\b")),
+    ("OpenAI-style key", re.compile(rb"\bsk-[A-Za-z0-9_-]{20,}\b")),
+    ("AWS access key", re.compile(rb"\bAKIA[0-9A-Z]{16}\b")),
+)
+SCAN_CHUNK_BYTES = 1024 * 1024
+SCAN_OVERLAP_BYTES = 4096
 
 
 class WorkspaceError(ValueError):
@@ -32,7 +66,7 @@ class WorkspaceError(ValueError):
 def sha256(path: Path) -> str:
     digest = hashlib.sha256()
     with path.open("rb") as handle:
-        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+        for chunk in iter(lambda: handle.read(SCAN_CHUNK_BYTES), b""):
             digest.update(chunk)
     return digest.hexdigest()
 
@@ -57,14 +91,45 @@ def reject_symlink_path(path: Path, stop: Path, label: str) -> None:
         cursor = cursor.parent
 
 
-def reject_sensitive_name(path: Path) -> None:
-    for part in path.parts:
-        lowered = part.lower()
-        if lowered in BLOCKED_DIRECTORY_NAMES:
-            raise WorkspaceError(f"fixture includes blocked directory: {part}")
-    lowered_name = path.name.lower()
-    if lowered_name in BLOCKED_FILE_NAMES or path.suffix.lower() in BLOCKED_SUFFIXES:
-        raise WorkspaceError(f"fixture looks credential-bearing: {path.name}")
+def sensitive_path_reason(path: Path) -> str | None:
+    parts = [part.lower() for part in path.parts]
+    for part in parts[:-1]:
+        if part in BLOCKED_DIRECTORY_NAMES:
+            return f"blocked directory: {part}"
+    name = parts[-1] if parts else ""
+    if name == ".env" or name.startswith(".env."):
+        return f"environment file: {name}"
+    if name in BLOCKED_FILE_NAMES:
+        return f"sensitive filename: {name}"
+    if any(name.endswith(suffix) for suffix in BLOCKED_SUFFIXES):
+        return f"sensitive file type: {name}"
+    return None
+
+
+def reject_sensitive_path(path: Path, label: str) -> None:
+    reason = sensitive_path_reason(path)
+    if reason:
+        raise WorkspaceError(f"{label} looks credential-bearing ({reason}): {path.as_posix()}")
+
+
+def secret_reason(path: Path) -> str | None:
+    overlap = b""
+    with path.open("rb") as handle:
+        while True:
+            chunk = handle.read(SCAN_CHUNK_BYTES)
+            if not chunk:
+                return None
+            sample = overlap + chunk
+            for label, pattern in SECRET_PATTERNS:
+                if pattern.search(sample):
+                    return label
+            overlap = sample[-SCAN_OVERLAP_BYTES:]
+
+
+def reject_secret_content(path: Path, label: str) -> None:
+    reason = secret_reason(path)
+    if reason:
+        raise WorkspaceError(f"{label} contains a possible {reason}: {path.name}")
 
 
 def iter_fixture_files(path: Path) -> Iterable[Path]:
@@ -91,11 +156,28 @@ def normalize_source_item(raw: Path, source_root: Path, label: str) -> Path:
     return resolved
 
 
+def fixture_destination(relative: Path) -> Path:
+    parts = relative.parts
+    if parts and parts[0].lower() == "fixtures":
+        parts = parts[1:]
+    if not parts:
+        raise WorkspaceError(f"fixture does not identify a file: {relative}")
+    return Path("fixtures", *parts)
+
+
 def write_text(path: Path, text: str) -> None:
     path.parent.mkdir(parents=True, exist_ok=True)
     path.write_text(text, encoding="utf-8", newline="\n")
 
 
+def file_record(path: Path, relative: str) -> dict[str, object]:
+    return {
+        "path": relative,
+        "sha256": sha256(path),
+        "size_bytes": path.stat().st_size,
+    }
+
+
 def build_workspace(
     source_root: Path,
     contract: Path,
@@ -111,7 +193,7 @@ def build_workspace(
         output_unresolved = Path.cwd() / output_unresolved
     output_parent = output_unresolved.parent.resolve()
     output_resolved = output_parent / output_unresolved.name
-    if output_resolved.exists():
+    if output_resolved.exists() or output_resolved.is_symlink():
         raise WorkspaceError(f"output already exists: {output_resolved}")
     if is_relative_to(output_resolved, source_root):
         raise WorkspaceError("output must be outside the source root")
@@ -119,61 +201,75 @@ def build_workspace(
         raise WorkspaceError("output must not contain the source root")
 
     contract_path = normalize_source_item(contract, source_root, "contract")
-    if not contract_path.is_file():
-        raise WorkspaceError(f"contract is not a file: {contract_path}")
-    if contract_path.is_symlink():
-        raise WorkspaceError(f"contract must not be a symlink: {contract_path}")
+    if not contract_path.is_file() or contract_path.is_symlink():
+        raise WorkspaceError(f"contract must be a regular non-symlink file: {contract_path}")
+    reject_sensitive_path(contract_path.relative_to(source_root), "contract")
+    reject_secret_content(contract_path, "contract")
 
     fixture_files: list[tuple[Path, Path]] = []
-    seen_destinations: set[str] = set()
+    seen_destinations: dict[str, Path] = {}
     for raw_fixture in fixtures:
         fixture_root = normalize_source_item(raw_fixture, source_root, "fixture")
-        reject_sensitive_name(fixture_root.relative_to(source_root))
+        reject_sensitive_path(fixture_root.relative_to(source_root), "fixture")
         for fixture_file in iter_fixture_files(fixture_root):
             relative = fixture_file.relative_to(source_root)
-            reject_sensitive_name(relative)
-            destination = Path("fixtures") / relative
-            destination_key = destination.as_posix().lower()
-            if destination_key in seen_destinations:
-                continue
-            seen_destinations.add(destination_key)
+            reject_sensitive_path(relative, "fixture")
+            reject_secret_content(fixture_file, "fixture")
+            destination = fixture_destination(relative)
+            destination_key = destination.as_posix().casefold()
+            previous_source = seen_destinations.get(destination_key)
+            if previous_source is not None:
+                if previous_source == fixture_file:
+                    continue
+                raise WorkspaceError(
+                    "fixture destinations collide case-insensitively: "
+                    f"{previous_source.relative_to(source_root).as_posix()} and "
+                    f"{relative.as_posix()} -> {destination.as_posix()}"
+                )
+            seen_destinations[destination_key] = fixture_file
             fixture_files.append((fixture_file, destination))
 
+    isolation = (
+        "# Source-Blind Validator Workspace\n\n"
+        "Validate the observable contract against the named target. Stay inside this "
+        "workspace for local reads and use only the approved fixture paths listed in "
+        "`workspace-manifest.json`. Treat source, diffs, tests, history, implementation "
+        "notes, review bundles, or any unlisted local material as contamination. Record "
+        "contamination and stop so the principal can create a fresh workspace.\n"
+    )
+
     try:
         output_resolved.mkdir(parents=True)
         contract_destination = output_resolved / "contract.md"
         shutil.copyfile(contract_path, contract_destination)
 
+        write_text(output_resolved / "AGENTS.md", isolation)
+        write_text(output_resolved / "CLAUDE.md", isolation)
+
         copied: list[dict[str, object]] = []
         for source_file, destination_relative in fixture_files:
             destination = output_resolved / destination_relative
             destination.parent.mkdir(parents=True, exist_ok=True)
             shutil.copyfile(source_file, destination)
-            copied.append(
-                {
-                    "path": destination_relative.as_posix(),
-                    "sha256": sha256(destination),
-                    "size_bytes": destination.stat().st_size,
-                }
-            )
-
-        isolation = (
-            "# Validator Workspace\n\n"
-            "This directory contains only an observable behavior contract and explicitly "
-            "approved fixtures. Do not leave this directory to inspect implementation "
-            "material. Treat any source, diff, test, history, or review bundle exposure "
-            "as contamination.\n"
-        )
-        write_text(output_resolved / "AGENTS.md", isolation)
-
+            copied.append(file_record(destination, destination_relative.as_posix()))
+
+        instructions = [
+            file_record(output_resolved / "AGENTS.md", "AGENTS.md"),
+            file_record(output_resolved / "CLAUDE.md", "CLAUDE.md"),
+        ]
+        allowed_paths = [
+            "AGENTS.md",
+            "CLAUDE.md",
+            "contract.md",
+            "workspace-manifest.json",
+            *[record["path"] for record in copied],
+        ]
         manifest: dict[str, object] = {
-            "schema_version": 1,
-            "contract": {
-                "path": "contract.md",
-                "sha256": sha256(contract_destination),
-                "size_bytes": contract_destination.stat().st_size,
-            },
+            "schema_version": 2,
+            "contract": file_record(contract_destination, "contract.md"),
+            "instructions": instructions,
             "fixtures": copied,
+            "allowed_local_paths": allowed_paths,
             "forbidden_material": [
                 "source",
                 "diffs",
@@ -181,6 +277,8 @@ def build_workspace(
                 "git history",
                 "implementation notes",
                 "review bundles",
+                "credentials",
+                "unlisted local files",
             ],
         }
         write_text(
diff --git a/codex/skills/compass/SKILL.md b/codex/skills/compass/SKILL.md
index 31861175..5294024b 100644
--- a/codex/skills/compass/SKILL.md
+++ b/codex/skills/compass/SKILL.md
@@ -1,35 +1,57 @@
 ---
 name: compass
-description: Maintain Compass source, install boundaries, and validation. Invoke manually for Compass repository changes.
+description: Maintain Compass source, runtime boundaries, install wiring, retirement, and validation. Invoke manually for Compass repository changes.
 ---
 
 # Compass
 
-Use this skill only when changing Compass itself.
+Maintain Compass as reviewed source for portable Codex and Claude behavior. This
+skill exists because a strong runtime change can still fail when source routing,
+derivation, retirement, policy, and verification disagree.
 
-## Boundaries
+Use it only when changing Compass itself.
 
-- Reviewed source lives in this repository, not in live config homes.
-- Installed agent behavior belongs under `codex/`.
-- Repo-maintainer process belongs under `workflows/`, `local-docs/`,
-  `manifests/`, and `scripts/`.
-- Carried opt-in packs belong under `carried/` and stay out of global manifests.
-- Claude surfaces derive from Codex sources where the manifest says so.
-- Deterministic mechanics belong in scripts; reviewer personas belong in agents.
+## Preserve The Source Boundaries
 
-## Read First
+- Codex global guidance belongs in `codex/AGENTS.md`.
+- Claude global guidance belongs in `claude/CLAUDE.md`.
+- Runtime-neutral shared skills and agents belong under `codex/` and derive only
+  where the manifest says so.
+- Claude-specific agent contracts belong under `claude/agents/`.
+- Portable opt-in domain packs belong under `carried/` and stay out of global
+  install lists.
+- Compass maintainer reasoning belongs in `workflows/` and `local-docs/`.
+- Deterministic truth belongs in scripts, hooks, manifests, schemas, and tests.
 
-Read root `AGENTS.md`, `local-docs/maintenance-learnings.md`,
-`workflows/addition-intake.md`, and the workflow nearest the change.
+Read root `AGENTS.md`, `philosophy.md`, `workflows/addition-intake.md`,
+`local-docs/maintenance-learnings.md`, and the workflow nearest the change.
 
-## Change Exactly
+## Change The Whole Ownership Contract
 
-Update source, install maps, policy contracts, required-file checks, and tests in
-the same branch when ownership changes. Do not add fallback guidance for a
-capability Compass can make exact.
+When behavior or ownership moves, update the complete route in one change:
 
-## Validate
+- reviewed source;
+- Codex and Claude install or derivation maps;
+- source provenance;
+- explicit retirement paths;
+- policy and required-file checks;
+- MCP catalog expectations;
+- narrow tests and install round-trip coverage;
+- directly related documentation.
 
-Run `.\scripts\doctor.ps1`, narrow script tests, and `git diff --check`. Use
-`.\scripts\verify-live.ps1 -SkipCodexCommand` only when live drift matters. Use a
-PR as the review unit.
+Make Compass-owned capability exact. A fallback paragraph is not a substitute
+for correct wiring.
+
+## Validate The Result
+
+Run narrow tests first, then:
+
+```powershell
+.\scripts\doctor.ps1
+.\scripts\verify-live.ps1 -SkipCodexCommand
+git diff --check
+```
+
+Exercise install and retirement paths when ownership changes. Forward-test
+judgment changes with a fresh realistic invocation. Use a focused PR as the
+review unit and keep public mutation behind named authority.
diff --git a/codex/skills/grill-me/SKILL.md b/codex/skills/grill-me/SKILL.md
index 2e2a1fde..b4f4cad3 100644
--- a/codex/skills/grill-me/SKILL.md
+++ b/codex/skills/grill-me/SKILL.md
@@ -1,32 +1,58 @@
 ---
 name: grill-me
-description: Interview the user about a plan or design through one-question-at-a-time stress testing. Use when user says "grill me" or wants plan review.
+description: Stress-test a plan or design one consequential question at a time after mapping the full unresolved decision space.
 ---
 
 # Grill Me
 
-Use this skill to stress test a plan, design, or decision before the user acts
-on it. The role is a skeptical design partner: find unclear assumptions,
-missing constraints, risky dependencies, and premature decisions while keeping
-the conversation moving.
+Act as a skeptical design partner. Strengthen the plan by finding the few
+unknowns that can still change its outcome, scope, sequence, interface, or risk.
+This skill exists to replace vague agreement and improvisational questioning
+with a deliberate decision conversation.
 
-The failure mode this prevents is vague agreement. Do not turn the review into
-a broad lecture or a checklist dump. Ask one sharp question at a time, explain
-why it matters when useful, and include your recommended answer so the user can
-accept, reject, or correct it quickly.
+The user sees one sharp question at a time. The reasoning begins with the whole
+question space, not the first question that comes to mind.
 
-## Boundaries
+## Build The Question Catalog First
 
-- Ask one question at a time.
-- Prefer questions that change the plan, sequence, scope, or risk model.
-- Use codebase evidence instead of asking when the answer is locally available.
-- Stop when the plan has clear decisions, unresolved risks, and next actions.
-- Do not keep interrogating just to cover every possible branch.
+Read the available conversation, repository evidence, research, and prior
+answers before asking anything. Create a compact internal catalog of candidate
+questions.
 
-## Question Loop
+For each candidate, identify:
 
-1. Identify the next most consequential unknown.
-2. Ask one concise question.
-3. Provide the recommended answer or default assumption.
-4. Wait for the user's response before asking the next question.
-5. When the plan is stable enough, summarize decisions and remaining risks.
+- the decision it would change;
+- whether the answer already exists in current context or local evidence;
+- overlap with another question;
+- consequence of delaying it;
+- recommended answer or default assumption.
+
+Remove answered, duplicate, cosmetic, and low-impact questions. Rank what
+remains by decision impact.
+
+## Ask One Consequential Question
+
+Ask the highest-ranked unresolved question in concise language. Include the
+recommended answer or default assumption so the user can accept, reject, or
+correct it quickly. Explain why it matters only when the consequence is not
+obvious.
+
+After each answer, recompute the catalog. A response may resolve several planned
+questions or create a more important one.
+
+Use repository evidence instead of asking the user to restate facts already
+available. Refer back to earlier answers rather than rephrasing the same three
+questions.
+
+## Stop On Decision Sufficiency
+
+Finish when the remaining unknowns no longer materially change the plan. Do not
+continue merely because the interaction has established a question-answer
+rhythm.
+
+Return a compact synthesis of:
+
+- decisions made;
+- assumptions accepted;
+- material unresolved risks;
+- next action or planning artifact.
diff --git a/codex/skills/grill-me/agents/openai.yaml b/codex/skills/grill-me/agents/openai.yaml
index acceeb11..64e5a70c 100644
--- a/codex/skills/grill-me/agents/openai.yaml
+++ b/codex/skills/grill-me/agents/openai.yaml
@@ -1,7 +1,7 @@
 interface:
   display_name: "Grill Me"
-  short_description: "Stress test plans one question at a time"
-  default_prompt: "Use $grill-me to stress test my plan one question at a time, recommending a concrete answer for each consequential unknown."
+  short_description: "Map the decision space, then ask one sharp question"
+  default_prompt: "Use $grill-me to map the unresolved decision space, remove questions already answered by context, and stress-test my plan one consequential question at a time."
 
 policy:
   allow_implicit_invocation: true
diff --git a/codex/skills/input-token-economy/SKILL.md b/codex/skills/input-token-economy/SKILL.md
deleted file mode 100644
index 701947d4..00000000
--- a/codex/skills/input-token-economy/SKILL.md
+++ /dev/null
@@ -1,77 +0,0 @@
----
-name: input-token-economy
-description: In long agent sessions, accumulated input often dominates cost. Read targeted slices, keep the working set small, and split long sessions deliberately.
----
-
-# Input Token Economy
-
-On a coding agent, accumulated input often becomes the largest cost in long
-sessions. Each turn may carry a large working set: instructions, tools, file
-reads, tool outputs, and running history. Compaction, caching, and response
-state can reduce what is charged or re-sent, but every new line dragged into
-the working set still has to be paid for somewhere. Output and reasoning effort
-matter too, especially when quality permits smaller answers or lower reasoning.
-This skill focuses on the cost that quietly compounds: how much context you
-carry per turn and how many turns you keep carrying it.
-
-This skill is about spending input on purpose. Not about being stingy with the
-answer.
-
-## Read Slices, Not Whole Files
-
-Most questions about a file are about a part of it. Read that part.
-
-- Prefer a targeted read over a full one: the part you need, an end, a known
-  line range, or the matching lines. Go whole-file only when you truly need the
-  whole file, and say why.
-- One good read beats several full ones. If you will need the same large file
-  more than once, read the slice you need, or extract the relevant region once,
-  rather than re-reading the whole thing each turn.
-- Keep big output out of the context. Tail long logs, count and summarize, or
-  write results to a file and read the summary back. A 50k-line dump read
-  across five turns is paid for five times.
-
-The test: could you have answered from the last forty lines, or the matched
-lines, instead of the whole file? Then read those.
-
-## Keep Sessions Short Enough To Re-Send
-
-A long thread is expensive by construction, because the growing tail tends to
-stay in the working set. A session twice as long is not twice the cost; late
-turns often cost more than early ones, since they carry more accumulated
-context.
-
-- Start a fresh session for a new sub-goal. Restating the small piece of
-  context a new task needs is cheaper than carrying the whole history of the
-  last one forward.
-- When a thread has grown large and the work shifts, summarize the result so
-  far and continue lean, rather than dragging the full transcript along.
-- Prefer a subagent or a fresh run for self-contained chunks of work only when
-  you can preserve the work cleanly. Carry a compact handoff with the objective,
-  constraints, branch or file state, pending verification, and known risks. For
-  governed implementation splits, use `subagent-driven-development`. When
-  durable goal state matters, use the active runtime's goal-contract route if
-  one is available; otherwise include the objective, owner, completion evidence,
-  and next action in the handoff.
-
-The frontier case is the monitoring thread: one long-running session that
-watches something can dwarf everything else, because each watch cycle is a full
-turn. The monitor-to-completion skill handles that one directly.
-
-## What This Rules Out
-
-- read-then-reread: pulling the same large file whole across multiple turns.
-- dump-into-context: pasting a huge log or directory listing into the thread
-  when a count, a tail, or a grep would have answered.
-- one-thread-forever: running unrelated sub-goals in a single ever-growing
-  session just because it is the one already open.
-- optimize-only-the-visible-axis: trimming the answer while repeatedly loading
-  large irrelevant input. Lower reasoning effort and shorter output can be valid
-  when quality permits, but they do not fix an oversized working set.
-
-## Judgment Over Checklist
-
-The model is the part that thinks. The expensive part is everything it may have
-to keep looking at while the session grows. Read the slice you need, keep the
-thread to the work at hand, and let finished context go. Spend input like it is
-often the bill, because in long agent work it often is.
diff --git a/codex/skills/input-token-economy/agents/openai.yaml b/codex/skills/input-token-economy/agents/openai.yaml
deleted file mode 100644
index e5796ac7..00000000
--- a/codex/skills/input-token-economy/agents/openai.yaml
+++ /dev/null
@@ -1,7 +0,0 @@
-interface:
-  display_name: "Input Token Economy"
-  short_description: "Spend input tokens on purpose"
-  default_prompt: "Use $input-token-economy to cut re-sent context: read targeted slices not whole files, keep the working set small, and split long sessions instead of one growing thread."
-
-policy:
-  allow_implicit_invocation: true
diff --git a/codex/skills/monitor-to-completion/SKILL.md b/codex/skills/monitor-to-completion/SKILL.md
index 74c1478c..f64e7a6c 100644
--- a/codex/skills/monitor-to-completion/SKILL.md
+++ b/codex/skills/monitor-to-completion/SKILL.md
@@ -1,33 +1,54 @@
 ---
 name: monitor-to-completion
-description: Wait on one observable condition in a bounded command and return one compact result.
+description: Wait on one observable condition inside one bounded command and return one compact terminal result.
 ---
 
 # Monitor To Completion
 
-Use this skill only for mechanical waiting. The script owns the clock. The
-parent owner chooses the condition, timeout, and response.
+Structure a mechanical wait so the clock stays outside model conversation. This
+skill exists because repeated short polling turns expand context, consume model
+calls, and create narration without adding judgment.
 
-## Contract
+The parent chooses the condition, deadline, and response policy. One blocking
+command owns the wait.
 
-- Wait on one stable observable condition: process exit, port state, file,
-  container status, log match, HTTP response, or equivalent signal.
-- Prefer a native wait. Otherwise poll inside one blocking command, never across
-  model turns.
-- Derive the timeout from a deadline, service expectation, process budget, or
-  explicit operator limit. Do not use arbitrary poll counts.
-- Exit distinctly on success, target failure, and timeout.
-- Sample diagnostics without streaming repetitive logs into context.
-- Print one compact result: condition, outcome, elapsed time, and the value the
-  parent owner needs.
-- Return the result to the execution or goal owner. A successful wait is evidence,
-  not automatic completion of the parent task.
+## Wait Contract
 
-## Timeout
+Wait for one stable observable condition, such as:
 
-A timeout wakes the parent owner for judgment. Re-read current state, decide
-whether the condition is still valid, and choose recovery, a changed timeout,
-another action, or a stop. Do not silently relaunch the same wait.
+- process exit;
+- port or service state;
+- file creation or change;
+- container state;
+- log match;
+- HTTP result;
+- review or check terminal state exposed through a command.
 
-Use a scheduled watcher or automation when a condition must be checked over a
-long span without model judgment.
+Prefer a native wait. Otherwise poll inside one command. Derive the timeout from
+a deadline, service expectation, process budget, or explicit operating limit.
+
+Return distinct outcomes for success, target failure, and timeout. Sample useful
+diagnostics without streaming repetitive logs into context.
+
+## Compact Result
+
+Print only what the parent needs:
+
+- condition;
+- outcome;
+- elapsed time;
+- final observed value;
+- compact diagnostic on failure or timeout.
+
+A successful wait is evidence for the parent objective. The parent decides what
+that evidence means.
+
+## Judgment Boundary
+
+Use a fresh narrow `progress-monitor` agent when periodic checks require limited
+interpretation, anomaly detection, or escalation. Use an orchestration
+controller when the result can change ownership, route, authority, or goal
+completion.
+
+A timeout returns judgment to the parent. Reinspect current state before choosing
+a new condition, changed timeout, recovery action, or stop.
diff --git a/codex/skills/monitor-to-completion/agents/openai.yaml b/codex/skills/monitor-to-completion/agents/openai.yaml
index c6108399..e1fddd98 100644
--- a/codex/skills/monitor-to-completion/agents/openai.yaml
+++ b/codex/skills/monitor-to-completion/agents/openai.yaml
@@ -1,7 +1,7 @@
 interface:
   display_name: "Monitor To Completion"
-  short_description: "Run waits in one blocking script, not a poll loop"
-  default_prompt: "Use $monitor-to-completion to run this mechanical wait or watch to completion in one blocking script instead of polling in a sleep loop, which carries session context on every wake."
+  short_description: "Concentrate one mechanical wait in one command"
+  default_prompt: "Use $monitor-to-completion to wait for this one observable condition inside a bounded command and return a compact terminal result."
 
 policy:
   allow_implicit_invocation: true
diff --git a/codex/skills/orchestration-controller/SKILL.md b/codex/skills/orchestration-controller/SKILL.md
index a9abe5ef..52806d2c 100644
--- a/codex/skills/orchestration-controller/SKILL.md
+++ b/codex/skills/orchestration-controller/SKILL.md
@@ -1,139 +1,118 @@
 ---
 name: orchestration-controller
-description: Oversee delegated work without taking over worker execution or accepting completion without evidence.
+description: Preserve a parent objective above delegated work, prepare reviewed assignments, reconcile evidence, and correct drift.
 ---
 
 # Orchestration Controller
 
-Use this skill when a parent objective spans workers, reviews, monitors, or
-long-running execution and needs an owner above the work. Do not use it to
-perform a worker task. Use `subagent-driven-development` for same-session plan
-execution and `monitor-to-completion` for mechanical waits.
-
-## Posture
-
-Stay one level above execution. The controller is the control plane, not a
-stronger worker. Its value is preserved perspective, not extra implementation
-throughput. Resist three common drifts: accepting a confident return claim as
-reality, taking over when a worker becomes slow or uncertain, and allowing the
-current route to replace the parent result.
-
-Be calm, skeptical, and sparse. When an active owner has a coherent plan and is
-producing new evidence, send nothing. A controller message should change the
-outcome contract only with authority, or otherwise change context, route,
-evidence standard, authorization, or decision point. Generic continuation
-acknowledgements, repeated nudging, and controller-authored task artifacts erase
-the separation this skill exists to protect. Restore worker agency rather than
-replacing it.
-
-## Control State Model
-
-For a long-lived objective, keep three logical layers distinct:
-
-- **Parent outcome, stable:** the finished state, required assertions, evidence
-  standard, constraints, scope, and amendment authority.
-- **Acceptance ledger, status-mutable:** stable assertion text with current
-  status and linked evidence.
-- **Execution state, mutable:** observed state, unmet assertions, owners, running
-  work, blockers, and next actions.
-
-These layers may share one compact control surface, but their authority differs.
-A discovered prerequisite, repair, failed attempt, phase, command, handoff, or
-monitor condition changes execution state. It does not replace the parent
-outcome. Only an explicit authorized amendment changes the finished state or
-assertion text.
-
-Name authoritative inputs in precedence order and identify one mutable
-current-state surface. After interruption, compaction, restart, or handoff,
-re-open those inputs before directing work. Chat summaries and historical
-ledgers are evidence, not current authority, unless the contract explicitly says
-otherwise.
-
-## Ownership Boundaries
-
-- The controller owns the stable parent outcome, required assertions, amendment
-  history, assignments, routing, evidence checks, and completion judgment.
-- The controller keeps the acceptance ledger and execution state truthful. It
-  may change assertion status and next actions from evidence; it may not rewrite
-  assertion text merely because the route changed.
-- Do not write worker-owned code, config, docs, benchmark output, product output,
-  or task artifacts. That work belongs to the worker or a fresh worker.
-- Long-running execution must have a named execution owner for the shell session,
-  live process, logs, and immediate recovery. The controller may direct that
-  owner but does not become the runner.
-- Controller edits are limited to control surfaces such as assignments,
-  assertion status, runtime state, monitor schedules, review requests, and
-  handoffs.
-- Name one writer for each mutable control surface. Prep, runner, monitor, and
-  review owners remain read-only on controller policy unless their assignment
-  explicitly grants that exact edit. A delegated suggestion is not edit
-  authority.
-- When a child needs active goal state, the child applies its own slice outcome.
-  The parent outcome remains read-only context, and the controller retains
-  parent-goal ownership and completion authority.
-
-If controller judgment and live execution collapse into one context, treat that
-as a control-plane failure. A runner may still own monitoring and immediate
-local repair inside its contract. Preserve evidence, stop dispatching new
-successors, restore the controller and runner split plus the compact control
-contract, then resume.
-
-## Continuation And Return Signals
-
-Treat continuation as the normal state. An active worker keeps executing while
-safe, authorized work remains. A routine turn boundary, progress update, or
-controller silence does not suspend the assignment or transfer ownership. Do not
-require a worker to ask permission to keep doing assigned work.
-
-The runtime or host owns lifecycle state such as queued, running, suspended,
-waiting on an external event, completed, failed, or cancelled. A worker report is
-evidence for a routing decision, not authority to set the parent state:
-
-- **Progress evidence:** if the plan remains coherent and evidence is improving,
-  send nothing. Intervene only with a concrete correction or changed condition.
-- **Completion claim:** verify the slice postcondition and map the evidence to the
-  named parent assertions. A polished report is not self-verifying.
-- **Input request:** require the exact missing fact or decision, why it blocks all
-  safe useful work, and what was already tried. Supply it or route it to the
-  right owner before escalating to the user.
-- **External wait:** require the named event or process and confirmation that no
-  useful parallel work remains. Put mechanical waiting in a bounded monitor.
-- **Failure report:** inspect the failed action, evidence, local recovery,
-  current state, smallest reversible move, owner, and any true authorization or
-  dependency boundary.
-- **Negative result:** evaluate it as task evidence. It is not an orchestration
-  state by itself.
-
-After every material result or worker return:
-
-1. attach current evidence to the parent assertions the slice was meant to
-   advance;
-2. update observed state and assertion status;
-3. recompute which required assertions remain unmet;
-4. choose the next route, owner, review, wait, or recovery action; and
-5. complete only when no required assertion remains unverified.
-
-Completing a repair, command, phase, review, or delegated slice is progress. If
-another parent assertion remains unmet, the controller must route the next move
-rather than treating the completed route as the finish line.
-
-Keep completion and concern severity separate. A completed artifact may still
-have residual risk; an incomplete artifact may have no major concern beyond a
-specific missing input.
-
-A timeout or quiet worker is not an automatic takeover signal. Collect partial
-evidence, account for execution ownership, and choose a concrete recovery,
-routing, hold, cancellation, or reassignment action. Use a controller heartbeat
-only when each wake requires judgment. Put purely mechanical waits in one
-bounded `monitor-to-completion` run.
-
-## Required Reference
-
-Read [controller-principles.md](references/controller-principles.md) when return
-interpretation, rerouting, monitoring, review, or handoff judgment needs detail.
+Act as the project manager above execution. Preserve one coherent parent
+objective while temporary workers, monitors, reviews, and contexts advance it.
+This role exists because long-running work can produce abundant motion while
+compaction, delegation, and local failures quietly replace the original result.
+
+The controller is the user-facing logical principal. It authors control state,
+prepares reviewed assignments, receives evidence, and judges completion. It
+does not prove its value by becoming the worker.
+
+Use `using-goals` when the objective needs a durable goal and checkpoint
+contract. Use `subagent-driven-development` when an approved implementation plan
+contains delegable slices. Use `monitor-to-completion` for pure waits and the
+`progress-monitor` agent for narrow judgment-based observation.
+
+## Preserve One Logical Author
+
+The principal, or the user directly, authors:
+
+- the stable goal and amendments;
+- anchor precedence;
+- plan and assignment boundaries;
+- catalog, ledger, and checkpoint state;
+- evidence acceptance;
+- route, ownership, and completion decisions.
+
+Delegates own assigned artifacts and investigations. They return evidence
+through the named return channel. They do not invent their own control format or
+mutate the principal's state merely to report progress.
+
+Before dispatch, review the assignment yourself. Give the user an opportunity
+to review material goals, plans, slice boundaries, and irreversible authority
+unless existing authority or an explicit waiver covers the launch.
+
+## Stay Above Execution
+
+A controller message should change one of these things:
+
+- context;
+- route;
+- owner;
+- evidence standard;
+- authority;
+- scope;
+- decision point;
+- goal amendment, when authorized.
+
+Silence is correct while an owner has a coherent route and current evidence is
+improving. Ordinary continuation requires no acknowledgement handshake.
+
+Implementation repairs return to the implementation owner or a fresh assigned
+worker. Controller edits are limited to principal-authored control documents and
+explicitly owned coordination artifacts.
+
+## Give Workers A Clean Return Path
+
+Every assignment names:
+
+- worker identity and role;
+- bounded outcome;
+- parent assertion IDs;
+- authoritative anchors;
+- owned artifact or investigation;
+- allowed actions and preservation boundaries;
+- evidence target;
+- return conditions;
+- controller return channel.
+
+Workers escalate one exact missing decision, authority boundary, external event,
+or exhausted recovery path. The controller answers or reroutes without absorbing
+the task.
+
+## Read Returns As Evidence
+
+A worker return is a claim about an artifact or a real exception. Reinspect the
+relevant state, then:
+
+1. map accepted evidence to parent assertions;
+2. update observed state;
+3. recompute the remaining gap;
+4. choose the next route, owner, review, wait, or decision;
+5. complete only when the full goal is verified.
+
+A polished report, finished slice, quiet process, timeout, or negative result is
+not parent completion by itself.
+
+## Correct Drift Without Babysitting
+
+Intervene when evidence stalls, the route loses contact with the goal, a worker
+repeats unchanged attempts, scope expands without authority, or context becomes
+polluted.
+
+Ask questions that restore agency:
+
+- Which parent assertion are you advancing?
+- What did the last action prove?
+- What observable state exists now?
+- What is the smallest action that can produce new evidence?
+- Does the current owner still have the right context and authority?
+
+Be direct when work drifts. Friendly pressure serves delivery; constant presence
+does not.
+
+Read [references/controller-principles.md](references/controller-principles.md)
+for return interpretation, intervention, recovery, and checkpoint detail.
 
 ## Completion
 
-Complete only when current evidence verifies every required parent assertion, or
-when the user explicitly amends the outcome to accept an incomplete endpoint and
-the remaining owner and dependency are recorded.
+Completion is a principal judgment against current evidence and the stable goal.
+Record verified assertions, authorized amendments, residual concerns, and any
+public mutations. A remaining assertion requires a next owner or an explicit
+amendment, not a completion claim.
diff --git a/codex/skills/orchestration-controller/agents/openai.yaml b/codex/skills/orchestration-controller/agents/openai.yaml
index b4a98248..55d57f39 100644
--- a/codex/skills/orchestration-controller/agents/openai.yaml
+++ b/codex/skills/orchestration-controller/agents/openai.yaml
@@ -1,6 +1,6 @@
 interface:
   display_name: "Orchestration Controller"
   short_description: "Oversee workers without taking over"
-  default_prompt: "Use $orchestration-controller to keep ordinary continuation implicit, intervene only when evidence changes the route, preserve execution ownership, and verify the parent objective."
+  default_prompt: "Use $orchestration-controller to preserve one principal-authored objective, prepare reviewed assignments, reconcile returned evidence, and correct drift without taking over execution."
 policy:
   allow_implicit_invocation: true
diff --git a/codex/skills/orchestration-controller/references/controller-principles.md b/codex/skills/orchestration-controller/references/controller-principles.md
index 4bcb89ea..b62a9be7 100644
--- a/codex/skills/orchestration-controller/references/controller-principles.md
+++ b/codex/skills/orchestration-controller/references/controller-principles.md
@@ -1,188 +1,115 @@
 # Controller Principles
 
-Use this reference when the controller needs more detail than the router.
-
-## Stance
-
-A controller protects judgment by staying outside execution. Workers are close
-to commands, edits, logs, and local failures. The controller remains close enough
-to understand evidence but far enough away to keep the parent result, required
-assertions, ownership, and stop conditions visible.
-
-Do not answer worker friction with slogans or takeover. Strong direction names an
-owner, executable action, and proof. A controller message should change the
-route, context, evidence standard, authorization, or decision point. Otherwise it
-is noise.
-
-## Control Contract
-
-Front-load the stable contract before mutable execution state:
-
-1. desired finished state;
-2. required final-state assertions and verification surfaces;
-3. constraints, scope, exclusions, and amendment authority;
-4. authoritative inputs in precedence order;
-5. live state surface and its writer;
-6. current owner and execution state;
-7. next action, evidence, and history.
-
-The first four items describe what completion means and should not change merely
-because the current route changes. The final three are operating state and may be
-rewritten as evidence arrives.
-
-Treat controller state as four linked variables:
-
-- **O - outcome:** stable finished-state assertions;
-- **S - observed state:** what current evidence says exists now;
-- **G - gap:** required assertions not yet verified from `S`;
-- **P - plan:** the current route for reducing `G`.
-
-Worker returns normally change `S`, `G`, and `P`. Only an explicit authorized
-amendment changes `O`. If the current obstacle vanished, `O` should still tell a
-fresh controller what finished work looks like.
-
-Long-running work needs an execution owner for the process, output, logs, and
-immediate retries. The controller owns the outcome contract, acceptance ledger,
-evidence checks, reroutes, and completion decision.
-
-Each mutable control surface has one named writer. Delegated prep, execution,
-monitoring, and review roles may propose policy changes but do not edit the
-controller-owned contract unless the assignment grants that exact authority.
-Before accepting an edit, verify the expected prior revision and preserve the
-previous state as evidence. Outcome or assertion edits also require the named
-amendment authority and a recorded reason.
-
-After interruption, compaction, restart, or handoff, re-open the authoritative
-inputs in order before routing work. Use history to explain how the current state
-arose, not to override the current-state surface. If execution, monitoring, and
-immediate local repair remain with the runner, that is normal. If controller
-judgment also collapses into that execution context, preserve evidence and
-restore the controller and runner split before dispatching more work.
-
-## Autonomous Continuation
-
-Once dispatched, an owner keeps the assignment while useful, safe, authorized
-work remains. The end of a model turn, a progress update, or controller silence
-does not transfer ownership. The owner returns control only after verifying its
-slice postcondition or reaching a real exception: an exact missing input, a named
-external wait with no parallel work, an explicit hold or cancellation, an
-authorization or safety boundary, or an unrecoverable failure after local
-recovery.
-
-When a host forces a checkpoint, preserve the parent assertion mapping, slice
-outcome, current route, and evidence, then requeue the same owner unless the
-controller explicitly changes the route. Do not add an acknowledgement handshake
-to ordinary progress.
-
-When an active worker has a coherent plan and is producing new evidence, send no
-worker-directed message. Intervene only to supply missing input, correct course,
-change scope, set a hold, cancel, reassign, or choose a recovery action.
-
-## Read Return Signals
-
-The host owns lifecycle state. A worker report is a claim about the artifact or
-an exception that may require routing:
-
-- A **progress report** should include evidence, the parent assertions it
-  advances, and the next action. If progress is coherent, it requires no
-  controller response.
-- A **completion claim** triggers independent checks against the slice
-  postcondition and named parent assertions. Remaining concerns are recorded
-  separately from completion.
-- An **input request** must name the exact fact, decision, permission, or context
-  that blocks all remaining safe work.
-- An **external wait** must name the event or process, its owner, and why no useful
-  parallel work remains. Route mechanical waiting to a monitor.
-- A **failure report** must name the failed action, evidence, local recovery,
-  current system state, smallest reversible next move, and required owner.
-- A **negative result** is evidence to assess, not a reason to stop by itself.
-
-A useful exception diagnosis is short:
+Use this reference when orchestration needs more detail than the main role
+statement.
 
-```text
-Which parent assertion is still unmet?
-What exactly prevents the next safe action?
-What did the last attempt prove?
-What state exists now?
-What is the smallest reversible move?
-Who owns that move?
-```
+## Control Posture
 
-The worker performs diagnosis and execution inside its boundary. The controller
-chooses the route without absorbing the task.
+The controller preserves perspective by staying outside execution. It remains
+close enough to inspect evidence and far enough away to keep the complete goal,
+authority, ownership, and next decision visible.
 
-After a return, the controller updates evidence and status, recomputes the gap to
-the full parent outcome, and then chooses the next route. A completed slice never
-short-circuits this reconciliation.
+Strong direction names an owner, executable action, and proof. Generic nudges,
+status acknowledgements, and controller-authored worker artifacts add noise.
 
-## Detect Thrash
+## Event-Driven First
 
-Thrash is motion that no longer improves judgment. It includes repeated attempts
-without new evidence, widening scope, log dumps without a next action, routine
-debugging escalated to the user, a worker nearing context saturation, or repeated
-rewrites of the objective to match whichever route is currently active.
+Workers keep their assignments while safe, authorized, useful work remains.
+They return on verified slice completion or a real exception.
 
-Reset the route with:
+Controller intervention is justified by:
 
-```text
-Parent outcome, read-only:
-Required parent assertions:
-Assertions advanced by this slice:
-Current evidence:
-Still-unmet assertions:
-Attempts that changed state:
-Next smallest reversible action:
-Fresh owner needed:
-```
+- new evidence that changes the route;
+- a material decision or missing authority;
+- repeated attempts without discriminating evidence;
+- stale or contradictory control state;
+- a workstream no longer matching its assignment;
+- a checkpoint or review boundary;
+- a user hold, cancellation, or amendment.
+
+Use a heartbeat only when each wake can require judgment. A purely mechanical
+condition belongs in one bounded command. A narrow periodic observation belongs
+to a fresh progress monitor with a compact contract.
+
+## Return Signals
+
+### Progress
+
+Accept the evidence locator, update nothing when no principal judgment is
+needed, and let the worker continue.
+
+### Completion Claim
+
+Inspect the artifact and mapped evidence. Decide whether the slice postcondition
+is verified, then reconcile it against the parent assertions.
 
-A fresh owner receives that packet and owns execution. The controller does not
-absorb the task or replace the parent outcome with the recovery action.
+### Decision Request
 
-## Monitoring And Review
+Require the exact question, affected assertion or constraint, options and
+consequences, work already completed, and recommendation.
 
-Use a controller heartbeat only when each wake requires judgment such as
-inspecting new evidence, rerouting, requesting review, or choosing recovery. Put
-mechanical waits inside one bounded command through `monitor-to-completion`.
+### External Wait
 
-A monitor's exit condition is evidence for the controller. It is not parent
-completion unless the stable parent contract explicitly defines it as a required
-assertion.
+Require the named event, owner, observable condition, and why no useful parallel
+work remains. Route the wait mechanically when possible.
 
-Monitoring should create perspective, not constant presence. When work is moving
-under a clear owner and evidence gate, step back. When the next event is purely
-mechanical, do not spend model turns watching it.
+### Failure
 
-Use independent review or checks to test worker claims. Review is a source of
-judgment, not another reporting ritual. Route findings back to the implementation
-owner and then update the parent acceptance ledger from evidence.
+Require the failed action, observed state, recovery attempted, what changed in
+the causal model, smallest reversible next move, and next owner.
 
-## Controller Handoff
+### Negative Result
 
-A handoff should preserve the completion contract and current control state, not
-narrate every attempt.
+Treat it as task evidence. Determine which hypothesis or assertion it supports
+or falsifies.
+
+## Detect Thrash
+
+Thrash is motion that no longer improves judgment. Common signals include:
+
+- repeated repairs with the same failure signature and no new evidence;
+- expanding scope around the latest symptom;
+- large log transfers without a proposed next action;
+- routine friction repeatedly escalated to the user;
+- rewriting the goal to match the current route;
+- a worker approaching context saturation without a checkpoint;
+- multiple agents authoring incompatible control state.
+
+Reset with a principal-authored packet:
 
 ```text
-Parent outcome, read-only:
-Required assertions and evidence standard:
-Outcome amendments, if any:
-Acceptance ledger or canonical path:
-Authoritative inputs, in order:
-Live state surface and writer:
-Current owner:
-Current runtime state:
-Running now:
-Evidence matched to assertion IDs:
+Parent goal and revision:
+Assertions advanced by this workstream:
+Current evidence:
 Still-unmet assertions:
-Signals needing judgment:
-Reroutes or questions sent:
-Next decision point:
-Remaining dependency:
-Re-anchor action:
+Attempts that changed state:
+Attempts that repeated unchanged state:
+Next smallest proof-producing action:
+Fresh owner or context needed:
 ```
 
-## Goal Activation
+## Compaction And Replacement
 
-When a child needs active goal state, tell it to apply and confirm an observable
-slice outcome tied to named parent assertion IDs in its own context. Delegated
-goal text alone is not active state. The parent outcome remains read-only context,
-and parent completion authority remains with the controller.
+Before replacing the principal context, write the checkpoint. The successor
+reopens anchors, verifies current branch or runtime state, confirms active
+workers and return channels, and then resumes the same logical role.
+
+Conversation summaries explain how the state arose. Authoritative anchors and
+current observations decide what is true now.
+
+## Handoff Shape
+
+```text
+Goal and revision:
+Amendment authority:
+Authoritative anchors, in order:
+Control document paths:
+Current observed state:
+Accepted evidence mapped to assertions:
+Still-unmet assertions:
+Active assignments, workers, processes, and worktrees:
+Signals awaiting judgment:
+Decisions or authority needed:
+Next proof-producing action:
+First state to reverify:
+```
diff --git a/codex/skills/pr-review-loop/SKILL.md b/codex/skills/pr-review-loop/SKILL.md
index 99440f48..b299b4e8 100644
--- a/codex/skills/pr-review-loop/SKILL.md
+++ b/codex/skills/pr-review-loop/SKILL.md
@@ -1,64 +1,95 @@
 ---
 name: pr-review-loop
-description: Drive a named PR through current-head checks, independent review, behavior validation, fixes, and merge gates.
+description: Drive a named pull request through current-head evidence, independent review, repairs, behavior proof, and its authorized merge boundary.
 ---
 
 # PR Review Loop
 
-Use this skill when a pull request must move through evidence and review without
-losing branch identity or current-head discipline.
+Move one named pull request from its current head to a truthful readiness
+judgment. This skill exists because checks, approvals, runtime evidence, and
+comments become stale whenever the head changes, while a polished summary can
+make old proof look current.
 
-Read [review-loop-playbook.md](references/review-loop-playbook.md) for review
-bundles, source-blind validation, stale-head handling, and merge boundaries.
+The terminal result is a current-head evidence packet and an explicit statement
+of the remaining review or mutation boundary.
 
-## Start With The Named PR
+Read [review-loop-playbook.md](references/review-loop-playbook.md) for confined
+review bundles, source-blind behavior proof, waiting, and stale-PR decisions.
 
-Record:
+## Preserve The Named Identity
 
-- repository, PR number, base branch, head branch, and head SHA;
-- current checks, review decision, inline findings, and merge state;
-- whether the user asked to preserve this PR or rebuild from current main.
+Record repository, PR number, base branch, head branch, current head SHA, checks,
+review decision, inline findings, and merge state.
 
-Keep the exact branch and PR unless the user explicitly asks for replacement,
-retargeting, or cleanup.
+Continue on the named PR unless the user explicitly asks to replace, retarget,
+close, or rebuild it. When the requested outcome is current-main intent rather
+than historical branch preservation, make that decision explicit before
+creating a replacement.
 
-## Required Gates
+## Bind Every Gate To The Head
 
-- `neutral-critic` reviews every PR loop.
-- Any `ariobarin/*` repository also requires a second independent reviewer.
-- Observable behavior changes require a separate source-blind
-  `behavior-validator` result.
-- All conclusions are tied to the current head SHA.
+All readiness conclusions target one exact head SHA. After a push, rebase,
+force-push, retarget, or material build change:
 
-A local test supports readiness but does not replace an independent gate.
+- reread the head SHA;
+- rerun affected checks;
+- refresh independent review;
+- refresh observable behavior evidence;
+- inspect current inline and top-level findings.
 
-## Iteration
+A local check supports a gate. It does not replace independent judgment when
+that judgment is required.
 
-1. Inspect the current PR and inline comments.
-2. Run the narrow checks that prove the changed surfaces.
-3. Request or perform source-aware review on the current head.
+## Choose Proportionate Independent Evidence
+
+Every PR review loop includes current-head independent review. Use
+`neutral-critic` unless the user or repository names another accepted reviewer.
+Apply additional reviewers when repository policy, user direction, change risk,
+or specialist scope requires them.
+
+Observable user or operator behavior receives source-blind validation when the
+claim is material and ordinary current-head tests do not fully establish it.
+Small documentation-only, metadata-only, or mechanically proven changes need no
+invented runtime ceremony.
+
+Record the gate selection and its reason. Strong review is evidence-bearing, not
+a fixed number of agents.
+
+## Iterate Through The Implementation Owner
+
+1. Inspect current PR state and unresolved comments.
+2. Run the narrow checks that cover changed behavior.
+3. Obtain independent current-head review.
 4. Route actionable findings to the implementation owner.
-5. Re-run checks after each material push.
-6. Re-read the head SHA and refresh stale review gates.
-7. Run source-blind behavior validation for observable changes.
-8. Stop at the authorized merge boundary.
+5. Rerun affected checks after every material change.
+6. Refresh stale reviewers and behavior evidence against the new SHA.
+7. Stop at the named public-mutation boundary.
 
-Use `scripts/build-review-bundle.py` when a fresh reviewer should receive the
-complete selected patch without arbitrary checkout context.
+Use `scripts/build-review-bundle.py` when a fresh source-aware reviewer needs the
+complete selected patch without arbitrary checkout or conversation context.
 
-## Waiting For Review
+## Wait On Actual State
 
-After review acknowledgement, use `monitor-to-completion` to wait on the actual
-review, comment, or check state. Choose a bounded timeout from the repository
-review expectation, user deadline, or explicit service window. Do not use a
-fixed clock sleep or repeated model polling.
+After review or check acknowledgement, use `monitor-to-completion` for the
+observable terminal state. Derive the timeout from repository expectations,
+user deadline, or an explicit service window.
 
-On timeout, re-read the head SHA, checks, reviews, and comments once. Then
-reroute to an authorized alternate reviewer, report the pending gate, or choose
-a new evidence-based wait. Do not treat timeout as approval.
+A timeout returns judgment. Reread the current head, checks, reviews, and
+comments, then choose a named alternate route, a new evidence-based wait, or a
+truthful pending-gate report.
 
 ## Completion
 
-Report the current head SHA, checks, review gates, behavior gate, unresolved
-findings, and merge authority. Merge only when explicitly authorized. If a
-required gate is pending, leave the PR open and name the exact gate.
+Report:
+
+- repository and PR identity;
+- base, head branch, and current SHA;
+- checks and exact results;
+- independent review gates and the SHA each covered;
+- behavior contract result when used;
+- unresolved findings;
+- public-mutation authority.
+
+Merge only when explicitly authorized and every required current-head gate is
+satisfied. Otherwise leave the PR open and name the exact remaining gate or
+owner.
diff --git a/codex/skills/pr-review-loop/agents/openai.yaml b/codex/skills/pr-review-loop/agents/openai.yaml
index 43bd5b09..498408b8 100644
--- a/codex/skills/pr-review-loop/agents/openai.yaml
+++ b/codex/skills/pr-review-loop/agents/openai.yaml
@@ -1,7 +1,7 @@
 interface:
   display_name: "PR Review Loop"
   short_description: "Review and close out a PR"
-  default_prompt: "Use $pr-review-loop to iterate on this pull request with explicit PR identity, green neutral-critic review before @codex review for ariobarin repos, current-head checks, quiet acknowledged-review waits, merge-boundary discipline, and archive-after-merge closeout when requested."
+  default_prompt: "Use $pr-review-loop to preserve this pull request identity, bind every claim to the current head, choose proportionate independent gates, route findings to the implementation owner, and stop at the authorized mutation boundary."
 
 policy:
   allow_implicit_invocation: true
diff --git a/codex/skills/pr-review-loop/references/review-loop-playbook.md b/codex/skills/pr-review-loop/references/review-loop-playbook.md
index 85648224..5caa16be 100644
--- a/codex/skills/pr-review-loop/references/review-loop-playbook.md
+++ b/codex/skills/pr-review-loop/references/review-loop-playbook.md
@@ -1,103 +1,101 @@
 # PR Review Loop Playbook
 
-Use this reference for current-head review, confined reviewer context,
-source-blind behavior proof, and stale PR decisions.
+Use this reference when current-head review needs a confined patch, observable
+behavior proof, structured waiting, or a decision about stale PR identity.
 
 ## Current-Head Discipline
 
-Review evidence belongs to a head SHA.
+Evidence belongs to a head SHA.
 
-- Re-read the SHA after push, force-push, rebase, or retarget.
-- Refresh checks and reviewers when their evidence targets an older head.
-- Identify the tested build, ref, or artifact for behavior validation.
-- Do not call a PR ready from stale approval or stale runtime proof.
+- Reread the SHA after every push, rebase, force-push, or retarget.
+- Refresh checks and reviewers whose proof targets an older head.
+- Name the tested build, ref, or artifact for behavior validation.
+- Inspect inline comments independently from top-level comments and review
+  bodies.
+- Treat approval, test output, and runtime proof as stale when their target
+  identity changed materially.
 
 ## Confined Source-Aware Review
 
 Use `scripts/build-review-bundle.py` when a fresh reviewer should see the full
-selected patch without the current conversation or arbitrary checkout files.
+selected patch without parent conversation or arbitrary checkout files.
 
-The bundle includes:
+The bundle contains:
 
-- the complete binary-capable patch;
+- complete binary-capable patch;
 - base and head SHAs;
 - changed paths and hashes;
-- an optional task file;
-- only explicitly selected datasets.
+- optional task file;
+- explicitly selected context datasets.
 
-It rejects dirty worktrees, empty or oversized patches, secret-like content,
-escaping paths, symlinks, and existing output directories. A truncated diff is
-not an equivalent fallback.
+It accepts only a clean committed range and rejects escaping paths, symlinks,
+secret-like content, existing output directories, empty patches, and oversized
+bundles. A truncated diff is not an equivalent review surface.
+
+## Proportionate Review Selection
+
+Choose gates from the claim being made:
+
+- Every PR loop: one independent current-head reviewer.
+- Repository or user policy: every additional named reviewer.
+- Specialized risk: the relevant specialist reviewer.
+- Material observable behavior not fully proven by ordinary tests: fresh
+  source-blind `behavior-validator` result.
+- Narrow documentation, metadata, formatting, or deterministic generated output:
+  the independent review and exact mechanical check may be sufficient.
+
+Record why a gate applies. Neither habitual over-review nor convenient
+under-review is evidence.
 
 ## Source-Blind Behavior Validation
 
 Capture the observable contract before implementation detail can redefine
-success. Build the isolated workspace through `behavior-validator`, then launch
-a fresh non-forked validator agent.
+success. Build an isolated workspace through `behavior-validator` and launch a
+fresh non-forked validator.
 
-Give the validator only:
+Provide only:
 
 - contract and approved fixtures;
-- exact target identity and access instructions;
-- approved credentials;
+- exact target identity and access;
+- approved credential route;
 - observable evidence surfaces.
 
-Do not provide source, diffs, tests, history, review summaries, or a review
-bundle. Contamination requires a fresh workspace and fresh run.
-
-Skip this gate only when there is no user-visible or operator-visible behavior
-claim.
+Implementation source, diffs, tests, history, review summaries, and source-aware
+bundles remain outside the validator. Contamination requires a fresh workspace
+and fresh run.
 
 ## Review Waiting
 
-Review acknowledgement is not approval. Wait on the actual review state with one
-bounded condition:
+Review acknowledgement is not the terminal state. Wait on one observable
+condition:
 
 - requested review submitted;
 - actionable comment added;
-- check reaches terminal state;
+- check reaches a terminal result;
 - head SHA changes and invalidates the wait.
 
-Derive the timeout from a repository SLA, stated reviewer window, user deadline,
-or explicit operational limit. Put polling inside one command. On timeout,
-refresh the live PR once and choose an authorized alternate route or report the
-pending gate. Never use a fixed interval as proof that a reviewer had enough
-time.
-
-## Stale PR Rebuild
-
-Rebuild when the user wants current-main intent rather than preservation of the
-old PR identity.
-
-- Inspect the old branch for source material.
-- Start from current default branch.
-- Reapply only still-relevant intent.
-- Open a new PR when the result is no longer truthfully the same branch history.
-
-Preserve the named PR when the user asked to keep iterating it.
-
-## Gate Order
+Put polling inside one bounded command. On timeout, refresh live state once and
+choose an authorized alternate reviewer, a changed wait, or a pending-gate
+report.
 
-Unless the user requires parallel review:
+## Stale PR Decision
 
-1. run narrow checks;
-2. complete `neutral-critic`;
-3. resolve findings and verify the new head;
-4. request the second reviewer;
-5. run source-blind behavior validation when required;
-6. report readiness at the merge boundary.
+Preserve the named PR when the user wants its branch identity and history.
 
-A pending gate stays pending. An authorized alternate route must be named.
+Rebuild from the current default branch when the user wants current intent and
+the old branch can no longer express that truthfully. Inspect the old branch as
+source material, reapply only still-relevant intent, and open a replacement PR
+under explicit authority.
 
-## Output
+## Output Evidence
 
-Report:
+Return:
 
-- repository and PR;
-- base, head branch, and current SHA;
-- preserved or rebuilt identity;
-- checks and their result;
-- reviewer gates and head SHA each targeted;
-- behavior contract result;
+- PR and branch identity;
+- current head SHA;
+- preserved or rebuilt decision;
+- checks and their target;
+- reviewer gates and their target SHA;
+- behavior proof and target identity;
 - unresolved findings;
-- merge authority and current boundary.
+- current public-mutation boundary.
diff --git a/codex/skills/root-cause-not-symptom/SKILL.md b/codex/skills/root-cause-not-symptom/SKILL.md
index 83d9acdb..155abf0c 100644
--- a/codex/skills/root-cause-not-symptom/SKILL.md
+++ b/codex/skills/root-cause-not-symptom/SKILL.md
@@ -1,78 +1,77 @@
 ---
 name: root-cause-not-symptom
-description: Force root-cause-first on bugs, errors, and failing tests. Use before any patch, suppress, swap, retry, or premature done call on a symptom.
+description: Diagnose the mechanism and owning boundary before repairing bugs, errors, regressions, and failing tests.
 ---
 
 # Root Cause, Not Symptom
 
-A symptom is what you see: an error, a failing test, a wrong value, a strange
-output. The cause is the mechanism, one or more layers down, that produces it.
-You fix causes. You do not patch symptoms. A bandage stops the bleeding for a
-minute. The cut is still open. This skill exists to make you get the stitches.
-
-The posture is the point: name the cause before you touch code. If you cannot
-state the mechanism in one sentence, you do not understand the bug yet, and
-investigating is the correct next move, not editing. The discipline below is
-firm because every item is a documented way agents ship a fix that does not
-hold. It is orientation, not a cage.
-
-## Name The Cause Before The Fix
-
-Before you write, edit, delete, or swap a line, state in one sentence:
-
-  The cause is X. The fix lives at Y. Because Z.
-
-- X is the mechanism, not the symptom. "The string double-quotes a JSON value,
-  so it is escaped on serialization" is a cause. "Quotes are escaped" is a
-  symptom.
-- Y is the single site or boundary that owns the behavior, not the site that
-  displays it. If you cannot point to one site or boundary, the cause is not
-  understood yet.
-- Z is why that site owns the behavior.
-
-If you cannot fill X, Y, and Z, stop and investigate. Patching a cause you
-cannot name is the exact failure this skill prevents.
-
-## The Recurrence Rule
-
-If the same class of symptom returns after your fix, your fix was symptomatic.
-Do not patch again.
-
-A returning symptom is a signal, not a todo. Reopen the cause statement,
-assume your first cause was wrong, and look one layer deeper. One fix per
-cause. A second fix for the same symptom is reason to re-examine the cause.
-
-## What This Rules Out
-
-These are the recurring shapes of the failure. Recognize them and refuse them.
-
-- fix-output-not-cause: editing the producing string or display layer to hide
-  a symptom while the data contract underneath is wrong.
-- patch-and-pray: stacking a second guard on a guard that "did not fully work."
-  Layers mean you missed the cause.
-- declare-done-on-disappearance: calling it fixed because the symptom vanished
-  in one run. Symptom gone is not cause fixed. Re-run from a clean state and
-  confirm the cause is gone.
-- suppress-the-signal: catching, swallowing, filtering, or defaulting past the
-  error instead of removing its source.
-- swap-instead-of-diagnose: rewriting the format or delivery shape, or swapping
-  a component, because the real fix is hard. Diagnose first; swap only if
-  diagnosis says swap.
-- react-to-surface-signal: reshaping behavior around a heuristic you inferred
-  ("these look simple") instead of the stated requirement. Re-read the spec.
-  The spec beats your read of the surface.
-- enshrine-as-policy: rewriting docs, evals, or READMEs to make a symptomatic
-  fix permanent instead of reverting it.
-
-## When To Stop And Surface
-
-- You have written more than one fix for the same symptom. Stop.
-- The spec is ambiguous or self-contradictory. Ask; do not infer and proceed.
-- Fixing the cause would delete or reshape behavior the user did not ask to
-  change. Confirm scope first.
-
-## Judgment Over Checklist
-
-The lists above are guardrails against known failures, not a replacement for
-thinking. Keep the stance: causes first, symptoms second, and a returning
-symptom is always a reason to go deeper, never a reason to patch again.
+Repair the mechanism that produces the failure. This skill exists because a
+visible error invites guards, retries, catches, rewrites, and suppressions that
+make the symptom disappear while the broken ownership remains.
+
+The first deliverable is a causal model strong enough to locate the repair.
+
+## State The Causal Model
+
+Before production edits, state:
+
+> The observed symptom is S. The supported cause is X. The repair belongs at Y
+> because Z. The evidence is E.
+
+`X` names the producing mechanism. `Y` names the narrowest ownership boundary
+that can correct it. `Z` explains why that boundary owns the behavior. `E`
+distinguishes observation from inference.
+
+Some failures have interacting or independent causes. Name the causal chain or
+cause set when one site cannot truthfully explain the result.
+
+When the statement is not yet supportable, investigate. Trace inputs, state,
+ownership, execution flow, and the earliest divergence from the required
+contract.
+
+## Let Recurrence Reopen The Model
+
+A recurring symptom is new evidence. Reopen the causal model before adding
+another layer. Determine whether:
+
+- the first cause was incomplete;
+- another independent cause produces the same symptom;
+- the repair landed outside the owning boundary;
+- stale state or a different runtime path bypasses the repair;
+- the verification never exercised the real failure path.
+
+A second patch begins with a changed explanation, not a larger pile of guards.
+
+## Repair The Owning Boundary
+
+Make the smallest coherent change that removes the supported cause while
+preserving required behavior. Verification should reproduce the original path
+from a clean state and show that the mechanism, not only the visible message,
+changed.
+
+Crisp boundaries remain firm:
+
+- Error suppression is not a repair when the error source remains.
+- A rewritten requirement is not evidence that a broken implementation became
+  correct.
+- A component swap follows diagnosis; it does not substitute for diagnosis.
+
+## Subtractive Review
+
+After the repair works, inspect the changed and neighboring surface:
+
+- Which guard, wrapper, fallback, branch, state, or compatibility path became
+  obsolete?
+- Did the patch introduce a second source of truth?
+- Did an existing abstraction already own the behavior?
+- Is the changed surface broader than the causal boundary requires?
+- Can the same behavior remain with fewer maintained concepts or states?
+
+Line reduction is useful evidence, not the target. The target is a system with a
+simpler truthful explanation.
+
+## Completion Evidence
+
+Report the symptom, causal model, evidence, owning boundary, repair, focused
+checks, clean-state reproduction, removed obsolete machinery, and any remaining
+unverified cause.
diff --git a/codex/skills/root-cause-not-symptom/agents/openai.yaml b/codex/skills/root-cause-not-symptom/agents/openai.yaml
index 3a1517dd..1dc05faa 100644
--- a/codex/skills/root-cause-not-symptom/agents/openai.yaml
+++ b/codex/skills/root-cause-not-symptom/agents/openai.yaml
@@ -1,7 +1,7 @@
 interface:
   display_name: "Root Cause, Not Symptom"
-  short_description: "Fix causes, not symptoms"
-  default_prompt: "Use $root-cause-not-symptom to force root-cause-first on this bug: name the cause before any fix, and refuse to patch, suppress, swap, or declare done on a symptom."
+  short_description: "Repair the mechanism and simplify the boundary"
+  default_prompt: "Use $root-cause-not-symptom to establish the causal model and owning boundary before editing, then perform a subtractive review after the repair."
 
 policy:
   allow_implicit_invocation: true
diff --git a/codex/skills/run-a-micro-experiment/SKILL.md b/codex/skills/run-a-micro-experiment/SKILL.md
new file mode 100644
index 00000000..8dcac328
--- /dev/null
+++ b/codex/skills/run-a-micro-experiment/SKILL.md
@@ -0,0 +1,70 @@
+---
+name: run-a-micro-experiment
+description: Answer one technical uncertainty with the smallest disposable program, preserve the finding, then reimplement deliberately.
+---
+
+# Run A Micro-Experiment
+
+Answer one uncertainty with the smallest disposable program that makes the
+mechanism visible. This skill exists because prototypes easily grow into hidden
+partial products whose copied code, accidental architecture, and broad context
+contaminate the real implementation.
+
+The terminal result is a verified finding that changes a production decision.
+The experiment itself remains disposable.
+
+## Define One Question
+
+State the uncertainty in a form the experiment can settle:
+
+> Given X, does Y produce Z under conditions C?
+
+Name:
+
+- the decision this result will change;
+- the smallest observation that answers the question;
+- what the experiment intentionally does not represent;
+- the stopping condition.
+
+A vague goal such as "prototype the feature" is too broad. Reduce it until one
+mechanism can be observed directly.
+
+## Build The Smallest Revealing Program
+
+Create only the code, input, dependency, and output needed to expose the
+mechanism. Optimize for fast iteration and legibility of the result, not
+production architecture.
+
+A micro-experiment lives outside production code and does not copy the whole
+project. Mock or reduce surrounding systems when the question permits it.
+
+When the uncertainty genuinely depends on the real build, integration boundary,
+performance profile, or repository behavior, use a clearly labeled disposable
+integration-spike worktree instead. That is not a micro-experiment.
+
+## Observe And Record
+
+Run enough controlled cases to distinguish the proposed mechanism from plausible
+alternatives. Record:
+
+- question;
+- environment and relevant versions;
+- tiny program or command;
+- observed output;
+- interpretation and uncertainty;
+- production consequence;
+- timestamp.
+
+Preserve the finding in a compact note or artifact when it will inform later
+work.
+
+## Graduate The Finding
+
+Experimental code does not graduate into production. The finding graduates.
+Return to the production repository, create or use the correct worktree, and
+implement the learned behavior against real ownership, tests, style, and review
+requirements.
+
+Delete or archive the experiment after the decision is captured. Promote a
+reusable test fixture or tool only through an explicit review that justifies its
+new durable purpose.
diff --git a/codex/skills/run-a-micro-experiment/agents/openai.yaml b/codex/skills/run-a-micro-experiment/agents/openai.yaml
new file mode 100644
index 00000000..182e91bd
--- /dev/null
+++ b/codex/skills/run-a-micro-experiment/agents/openai.yaml
@@ -0,0 +1,7 @@
+interface:
+  display_name: "Run A Micro-Experiment"
+  short_description: "Answer one uncertainty with disposable code"
+  default_prompt: "Use $run-a-micro-experiment to reduce this uncertainty to one tiny disposable program, record the finding, and keep experimental code out of production."
+
+policy:
+  allow_implicit_invocation: true
diff --git a/codex/skills/subagent-driven-development/SKILL.md b/codex/skills/subagent-driven-development/SKILL.md
index a943630d..732c1afc 100644
--- a/codex/skills/subagent-driven-development/SKILL.md
+++ b/codex/skills/subagent-driven-development/SKILL.md
@@ -1,126 +1,95 @@
 ---
 name: subagent-driven-development
-description: Execute a real implementation plan through independent worker slices with shared-checkout safety and staged review.
+description: Execute an approved implementation plan through bounded worker-owned slices, safe checkouts, and independent evidence gates.
 ---
 
 # Subagent-Driven Development
 
-Use this skill when a real implementation plan exists and its tasks are
-independent enough to hand off with local context and concrete checks. Do not use
-it for exploration, tightly coupled work, branch triage, ordinary review, or a
-one-shot manual change.
-
-## Posture
-
-This is a disciplined implementation pipeline, not permission to maximize
-fan-out. Delegate only when a fresh execution owner gains clarity or reduces the
-controller's working set. The controller holds the parent outcome and acceptance
-criteria above execution. It is accountable for task boundaries, sequence,
-review, integration, and completion, but should be reluctant to prove its value
-by editing the worker's slice.
-
-The implementer owns the assigned artifact and carries ordinary setup,
-debugging, testing, and recovery inside that boundary. Ordinary continuation is
-implicit. A worker keeps the slice until it verifies its postcondition or reaches
-a real exception; it does not return merely to ask whether it should keep
-working. Completion and exception reports are evidence for routing, not
-self-verifying runtime state.
-
-A slice is a route for advancing the parent outcome. It is not permission to
-replace that outcome with the current implementation task. The parent outcome
-and assertion text remain read-only unless the user explicitly amends them.
-
-## Task Shape
-
-A slice is ready for delegation when it has:
-
-- one coherent observable slice outcome or postcondition;
-- the parent assertion IDs it is meant to advance;
-- an integration target that explains how the artifact contributes to the
-  parent result;
-- an owner who can work without constant shared reasoning;
-- exact context and scope boundaries;
-- a concrete validation target;
-- limited collision with other active work.
-
-Do not split work merely because several agents are available. Keep coupled
-changes with one owner. Do not derive a slice only from the latest symptom;
-derive it from an unmet parent assertion and the current evidence about the gap.
-
-## Ownership Boundaries
-
-- The controller owns the stable parent outcome, required assertions, plan, task
-  boundaries, sequence, review gates, integration, and completion judgment.
-- The implementer owns assigned edits, focused tests, narrow validation, and
-  ordinary recovery inside the slice. Route repairs back through the implementer
-  path instead of editing worker-owned artifacts.
-- The implementer may adapt its local route, but it may not rewrite the parent
-  outcome or parent assertion text.
-- Use a fresh implementer for an unrelated slice.
-- Do not run multiple editing implementers against the same checkout. While a
-  child may edit shared files, keep controller work read-only and outside that
-  slice. Account for the child before the controller edits shared files.
-- Do not start implementation on the default branch without explicit consent.
-
-## Required Handoffs
-
-Use these templates:
-
-- [implementer-prompt.md](implementer-prompt.md)
-- [spec-reviewer-prompt.md](spec-reviewer-prompt.md)
-- [code-quality-reviewer-prompt.md](code-quality-reviewer-prompt.md)
-
-Give the implementer the parent outcome as read-only context, parent assertion
-IDs, observable slice outcome, integration target, full task text, absolute repo
-path, exact files or artifacts, scope boundaries, validation target, and known
-pitfalls.
-
-Require one return record only when the slice is complete or a real exception
-prevents further safe useful work. The return kind describes why control is
-being returned; it is not a repeated progress status:
-
-- `completed`: the slice postcondition is evidenced, the artifact exists, focused
-  checks ran, and self-review is done. Proceed to independent spec review; do not
-  accept the claim as proof or infer parent completion.
-- `needs_input`: an exact fact, decision, permission, or context item blocks all
-  remaining safe work. Supply it or route it to the correct owner.
-- `waiting_external`: a named process or event remains and no useful parallel
-  work is available. Assign a bounded monitor rather than spending model turns
-  waiting.
-- `failed`: local recovery is exhausted or a safety boundary prevents further
-  execution. Diagnose the failed action, evidence, current state, smallest
-  reversible move, and next owner.
-
-Keep residual concerns in a separate field. Do not encode concern severity as a
-different completion state. A negative search or test result belongs in evidence
-and may still support completion, replanning, or a more precise input request.
-
-A progress update, timeout, or quiet child is not an automatic pause or takeover
-signal. Collect partial evidence, account for shared-checkout ownership, and
-restore a concrete next move. If the host forces a checkpoint, preserve the
-parent assertion mapping, slice outcome, current route, and evidence, then
-requeue the same owner unless the route changes.
-
-## Required Sequence
-
-1. Dispatch the implementer with the parent assertion mapping and slice
-   postcondition.
-2. After implementation, run spec compliance review, then code quality review.
-3. Send findings back through the implementer path and repeat the failed review
-   until clear.
-4. Map accepted evidence to the parent assertions, update their status, and
-   recompute which assertions remain unmet before choosing another slice or
-   declaring completion.
-
-The two reviews are independent gates, not ceremony. Spec review compares the
-artifact with the requested slice. Quality review tests whether the accepted
-slice is well built. Do not replace either with implementer self-review or a
-controller summary.
-
-## Completion
-
-Complete only when every required parent assertion is verified by current
-evidence, every delegated slice used as proof has passed both reviews,
-integration checks pass, and branch readiness or the next repair owner is named.
-Completing the predefined task list is not sufficient if the parent outcome is
-still unmet.
+Use fresh implementers when an approved implementation plan contains slices that
+can be owned and verified independently. This skill exists to reduce context and
+increase focus without losing integration, scope, or review discipline.
+
+It is an implementation pipeline, not an alternate controller. The user-facing
+principal keeps the parent goal, plan, control documents, assignment authorship,
+and final completion judgment.
+
+## Delegate Only A Coherent Slice
+
+A slice is ready when it has:
+
+- one observable postcondition;
+- the parent assertion IDs it advances;
+- an integration target;
+- authoritative anchors;
+- exact scope and preservation boundaries;
+- production and public mutation authority;
+- a concrete evidence target;
+- limited collision with other active work;
+- a named return channel.
+
+The principal prepares and reviews the assignment before launch. Material slice
+boundaries remain available for user review unless existing authority or an
+explicit waiver covers them.
+
+Keep coupled changes with one owner. A fresh worker is useful when it gains a
+cleaner context, not merely because another agent slot exists.
+
+## Preserve Checkout Ownership
+
+One editing owner operates in one checkout at a time. Use a dedicated worktree
+for production-bound work when parallel activity or a dirty main checkout would
+create collisions.
+
+The principal stays read-only against worker-owned files until the worker
+returns or the assignment is explicitly held, cancelled, or reassigned.
+
+## Worker Ownership
+
+The implementer owns ordinary setup, repository reading, debugging, focused
+tests, and local recovery inside the assignment. It continues while safe,
+authorized work remains and returns only when:
+
+- the slice postcondition is verified;
+- one exact decision or permission blocks all useful work;
+- a named external event remains with no useful parallel work;
+- recovery is exhausted or a safety boundary stops execution.
+
+The worker returns artifacts and evidence. It does not edit the parent goal,
+catalog, ledger, checkpoint, or assignment after dispatch.
+
+Use [implementer-prompt.md](implementer-prompt.md) for the assignment handoff.
+
+## Independent Evidence Gates
+
+After implementation, test two different claims:
+
+1. **Specification:** the accepted artifact matches the assigned slice and adds
+   no unauthorized scope.
+2. **Quality:** the accepted slice is correct, robust, tested, maintainable,
+   integrated, and no larger than its ownership boundary requires.
+
+Use separate reviewers for substantial or risky slices. A narrow low-risk slice
+may use one combined independent review when the approved assignment says so.
+Implementer self-review supports these gates and does not replace them.
+
+Route findings back to the implementation owner or a fresh explicitly assigned
+repair worker. Re-run the failed evidence gate after material changes.
+
+Use [spec-reviewer-prompt.md](spec-reviewer-prompt.md) and
+[code-quality-reviewer-prompt.md](code-quality-reviewer-prompt.md).
+
+## Return To The Principal
+
+The pipeline returns:
+
+- slice postcondition;
+- artifact and exact changed files;
+- checks and results;
+- independent review results;
+- evidence mapped to parent assertions;
+- integration status;
+- remaining concerns or repair owner.
+
+The principal reconciles this evidence against the complete parent goal.
+Completing the planned slice list is not sufficient while a required parent
+assertion remains unverified.
diff --git a/codex/skills/subagent-driven-development/agents/openai.yaml b/codex/skills/subagent-driven-development/agents/openai.yaml
index a971a6dc..103aacd0 100644
--- a/codex/skills/subagent-driven-development/agents/openai.yaml
+++ b/codex/skills/subagent-driven-development/agents/openai.yaml
@@ -1,6 +1,6 @@
 interface:
   display_name: "Subagent-Driven Development"
-  short_description: "Execute independent plan slices safely"
-  default_prompt: "Use $subagent-driven-development to execute this plan through autonomous worker-owned slices, explicit completion or exception reports, one editing owner per checkout, and independent spec and quality gates."
+  short_description: "Execute approved implementation slices with fresh owners"
+  default_prompt: "Use $subagent-driven-development to turn this approved plan into reviewed worker-owned implementation slices, independent evidence gates, and a compact return to the principal."
 policy:
   allow_implicit_invocation: true
diff --git a/codex/skills/subagent-driven-development/code-quality-reviewer-prompt.md b/codex/skills/subagent-driven-development/code-quality-reviewer-prompt.md
index 7c9e529f..06153adc 100644
--- a/codex/skills/subagent-driven-development/code-quality-reviewer-prompt.md
+++ b/codex/skills/subagent-driven-development/code-quality-reviewer-prompt.md
@@ -1,32 +1,34 @@
-# Code Quality Reviewer Prompt Template
+# Code Quality Reviewer Template
 
 ```text
-Independently review implementation quality after spec compliance passed.
+Independently review implementation quality after the accepted scope is known.
 
-Spec compliance narrows the accepted scope. It does not prove the implementation
-is correct, robust, tested, maintainable, or well integrated.
+## Reviewed Assignment
 
-## Requested Task
-
-[FULL TASK TEXT]
+[FULL ASSIGNMENT]
 
 ## Evidence Locator
 
-- Repo path: [ABSOLUTE_REPO_PATH]
-- Diff: [BASE_SHA..HEAD_SHA, PR, patch, or exact changed files]
-- Implementer summary: [SHORT SUMMARY]
+- Repository or artifact root: [PATH]
+- Diff or changed artifact: [LOCATOR]
+- Implementer return: [SHORT RETURN]
 
-Do not review until the repo path and diff locator are present. Inspect the code,
-relevant tests, and nearby patterns yourself. Look for correctness risks,
-unhandled edge cases, weak tests, accidental complexity, poor fit with local
-patterns, muddled responsibilities, naming problems, and maintainability costs.
+Inspect the implementation, focused tests, and nearby ownership patterns.
+Evaluate correctness, edge cases, failure behavior, test strength, integration,
+maintainability, and conceptual size.
 
-Prefer a small number of evidence-backed findings over a broad style inventory.
-Do not repeat spec findings unless they also create a quality risk.
+Perform a subtractive review:
+- identify duplicate state or sources of truth;
+- identify guards, wrappers, fallbacks, branches, or abstractions that can be
+  removed while preserving required behavior;
+- check whether the change is broader than the owning boundary;
+- check whether existing repository capability should replace custom machinery.
 
-Use the repo review format when one exists. Otherwise return:
+Prefer a small number of evidence-backed findings.
 
-- Strengths
-- Issues: Critical | Important | Minor, with file:line evidence
+Return:
+- Strengths that matter to acceptance
+- Issues: Critical | Important | Minor, with exact evidence
+- Subtraction opportunities
 - Assessment
 ```
diff --git a/codex/skills/subagent-driven-development/implementer-prompt.md b/codex/skills/subagent-driven-development/implementer-prompt.md
index 3b2c6be5..d532b77c 100644
--- a/codex/skills/subagent-driven-development/implementer-prompt.md
+++ b/codex/skills/subagent-driven-development/implementer-prompt.md
@@ -1,92 +1,60 @@
-# Implementer Prompt Template
+# Implementer Assignment Template
 
 ```text
-You are the execution owner for Task N: [task name]
+You are the execution owner for assignment [ASSIGNMENT_ID].
 
-Success is an observable, validated slice outcome inside the assigned boundary.
-A polished report is not a substitute for the artifact, and completing this
-slice is not the same as completing the parent outcome.
+Your result is the observable slice outcome inside the reviewed boundary. Return
+artifacts and evidence through the named channel. The principal remains the
+author of the parent goal and control documents.
 
-## Parent Contract, Read-Only
+## Parent Context, Read-Only
 
-- Parent outcome: [FINISHED_STATE]
-- Parent assertion IDs advanced by this slice: [ASSERTION_IDS]
+- Parent goal and revision: [GOAL]
+- Parent assertion IDs advanced: [ASSERTION_IDS]
 - Parent evidence standard: [EVIDENCE_STANDARD]
-- Parent contract or acceptance-ledger path: [PATH_OR_NONE]
-
-Do not rewrite the parent outcome or assertion text. When evidence changes,
-adapt the local route and report what it proves against the named assertions.
+- Goal and control document paths: [PATHS]
 
 ## Slice Contract
 
-- Slice outcome or postcondition: [OBSERVABLE_POSTCONDITION]
-- Integration target: [HOW_THIS_ARTIFACT_ADVANCES_THE_PARENT]
-- Full task text: [FULL_TASK_TEXT]
-
-## Context
-
-- Repo path: [ABSOLUTE_REPO_PATH]
-- Exact files or artifacts: [PATHS]
-- Scope boundaries: [BOUNDARIES]
-- Validation target: [CHECKS]
-- Live state surface and writer: [PATH_AND_WRITER_OR_NONE]
-- Delegated edit authority: [EXACT_EDITS_OR_NONE]
-- Known pitfalls: [PITFALLS]
-
-## Ownership And Continuation
+- Slice outcome: [OBSERVABLE_POSTCONDITION]
+- Integration target: [HOW_THIS_ADVANCES_THE_PARENT]
+- Full task: [TASK]
 
-Read repo guidance and inspect nearby files before editing. Resolve ordinary
-path, setup, pattern, test, dependency, merge, and validation questions inside
-the assigned slice. Carry local friction instead of returning it to the
-controller in final-answer form.
+## Authoritative Anchors
 
-Keep working while useful, safe, authorized steps remain. A routine model turn
-boundary, progress update, or controller silence does not suspend the assignment
-or transfer ownership. Do not stop merely to ask whether to continue.
+Read in this order:
+1. [ANCHOR]
+2. [ANCHOR]
 
-A discovered prerequisite, repair, or changed implementation sequence updates
-your local plan. It does not replace the slice postcondition or parent outcome.
-After each material result, compare current evidence with the slice postcondition
-and continue while it remains unmet.
+## Scope And Authority
 
-Ask for input only when an exact missing requirement, decision, permission, or
-piece of context blocks all remaining safe work. Name the missing item, why it
-blocks progress, and what you already tried.
-
-Use an external wait only when a named process or event remains and no useful
-parallel work is available. Name its owner and the observable completion
-condition. For a failure, exhaust reasonable local recovery first, then report
-the failed action, evidence, current state, and smallest reversible next move.
+- Repository or workspace: [ABSOLUTE_PATH]
+- Owned files or artifacts: [PATHS]
+- Allowed edits or actions: [AUTHORITY]
+- Production mutation authority: [AUTHORITY]
+- Public mutation authority: [NONE_OR_EXACT_ACTION]
+- State to preserve: [BOUNDARIES]
+- Validation target: [CHECKS]
+- Return channel: [LOCATOR]
 
-Implement exactly the requested slice. Keep edits scoped, add focused tests when
-needed, run the narrowest useful checks, and self-review. Follow local patterns
-unless the task explicitly requires a different shape. Commit only when the
-controller explicitly asks or repo policy requires it.
+Carry ordinary setup, repository reading, debugging, focused tests, and local
+recovery inside this boundary. Keep working while safe, authorized actions can
+advance the slice.
 
-When the controller asks diagnostic questions, answer with evidence, ownership,
-current state, unmet slice conditions, and the smallest reversible action. Keep
-execution ownership unless the controller explicitly holds, cancels, or
-reassigns the slice.
+Return once when the postcondition is verified or a real exception prevents all
+remaining safe useful work.
 
 ## Return Record
 
-Return once when the slice postcondition is verified or a real exception
-prevents further safe useful work.
-
-- Return kind: completed | needs_input | waiting_external | failed
-- Slice outcome claimed
-- Parent assertion IDs advanced
-- What changed
-- Files changed
-- Checks run and results
-- Evidence mapped to each named parent assertion
-- Slice conditions still unmet, if any
-- Self-review findings
-- Remaining concerns, kept separate from completion
-- Missing input or external dependency, when relevant
-- Recovery tried and exact next action with owner
-
-A negative search or test result belongs under evidence. It is not a return kind
-by itself. The controller decides whether the parent outcome is complete after
-integrating this evidence with every other required assertion.
+- Result: completed | needs decision | waiting external | failed
+- Slice outcome claimed:
+- Parent assertions advanced:
+- Artifact or files changed:
+- Checks and exact results:
+- Evidence mapped to each parent assertion:
+- Slice conditions still unmet:
+- Recovery attempted:
+- Exact missing decision, event, or boundary:
+- Next action and owner:
+- Residual concerns, separate from completion:
 ```
diff --git a/codex/skills/subagent-driven-development/spec-reviewer-prompt.md b/codex/skills/subagent-driven-development/spec-reviewer-prompt.md
index 63bc41e8..1a7b1647 100644
--- a/codex/skills/subagent-driven-development/spec-reviewer-prompt.md
+++ b/codex/skills/subagent-driven-development/spec-reviewer-prompt.md
@@ -1,31 +1,25 @@
-# Spec Compliance Reviewer Prompt Template
+# Specification Reviewer Template
 
 ```text
-Independently review whether the implementation matches its specification.
+Independently compare the implementation with the reviewed assignment.
 
-Your job is comparison, not assistance. Do not help the implementation pass by
-inferring intent, accepting a plausible summary, or overlooking extra work.
+Your role is exact comparison. Read the artifact and evidence directly. The
+implementer report is a locator, not proof.
 
-## Requested Task
+## Reviewed Assignment
 
-[FULL TASK TEXT]
-
-## Implementer Report
-
-[IMPLEMENTER REPORT]
+[FULL ASSIGNMENT]
 
 ## Evidence Locator
 
-- Repo path: [ABSOLUTE_REPO_PATH]
-- Diff: [BASE_SHA..HEAD_SHA, PR, patch, or exact changed files]
+- Repository or artifact root: [PATH]
+- Diff or changed artifact: [LOCATOR]
+- Implementer return: [RETURN]
 
-Do not review until the repo path and diff locator are present. Treat the report
-as a locator, not evidence. Read changed files and compare them directly with the
-task. Check for missing requirements, extra work, scope mistakes, behavior
-mismatches, and unsupported claims.
+Verify the slice outcome, every stated requirement, scope boundary, preserved
+state, and absence of unauthorized extra work.
 
 Return one of:
-
-- [OK] Spec compliant
-- [Issues] Specific missing or extra work with file:line evidence
+- [OK] Specification compliant, with evidence inspected
+- [Issues] Missing, mismatched, or extra work with exact location and consequence
 ```
diff --git a/codex/skills/using-codex-goals/SKILL.md b/codex/skills/using-codex-goals/SKILL.md
deleted file mode 100644
index 97fbbfe2..00000000
--- a/codex/skills/using-codex-goals/SKILL.md
+++ /dev/null
@@ -1,91 +0,0 @@
----
-name: using-codex-goals
-description: Maintain durable outcomes, acceptance assertions, evidence, and live goal state across long-running work.
----
-
-# Using Codex Goals
-
-Use this skill when work must survive turns, workers, compaction, or restarts
-without losing what completion means. It owns outcome semantics and evidence
-reconciliation. It does not own benchmark execution, process supervision, or
-artifact recovery.
-
-## Keep Three Layers Distinct
-
-- **Parent outcome:** stable finished state, constraints, exclusions, and
-  amendment authority.
-- **Acceptance ledger:** stable assertion text with current status and linked
-  evidence.
-- **Execution state:** current owner, observed state, blockers, and next action.
-
-A failed command, discovered prerequisite, repair, phase, worker return, or
-monitor timeout changes execution state. It does not rewrite the parent outcome.
-
-Read [goal-contracts.md](references/goal-contracts.md) when creating or repairing
-a durable goal surface.
-
-## Start With Assertions
-
-Write the outcome as observable assertions. Each assertion needs:
-
-- a stable identifier;
-- exact pass evidence;
-- current status: unmet, in progress, verified, blocked, or removed by authorized
-  amendment;
-- evidence locators;
-- the owner of the next proof-producing action.
-
-Completion is a reconciliation operation. After material evidence arrives,
-attach it to assertions, update status, recompute the unmet set, and route the
-next action. A completed subtask is not completion while a required assertion
-remains unverified.
-
-## Keep Live State Small
-
-The live surface should answer:
-
-- what finished state is still authoritative;
-- which assertions remain unmet;
-- who owns the current action;
-- what evidence arrived;
-- what action can reduce the remaining gap;
-- what exact external event or decision is required, if any.
-
-Archive history elsewhere. Do not let a long diary become current authority.
-
-## Blocked Means No Safe Move Exists
-
-Mark the goal blocked only when current evidence names a specific external
-dependency, authority boundary, or unavailable fact and no safe local action can
-advance any unmet assertion. Repeated turns, failed attempts, uncertainty, or
-controller silence are not blocker evidence.
-
-Before escalating, finish reversible local work, test alternative hypotheses,
-prepare the exact decision, and name the event or owner that can unblock the
-goal. Use waiting when an external event is expected and a bounded next check is
-useful.
-
-## Ownership
-
-- The controller owns the parent outcome, assertion text, amendments, and final completion judgment.
-- Execution owners produce artifacts and evidence for assigned slices.
-- Reviewers and validators may change assertion status through evidence, but do
-  not silently rewrite the acceptance contract.
-- `benchmark-run-operator` owns benchmark launch, provenance, valid-run rules,
-  and recovery. This skill consumes that evidence against the parent assertions.
-- `monitor-to-completion` owns mechanical waiting, not goal completion.
-
-## Pause, Resume, And Handoff
-
-A pause stops owned work and monitors without claiming completion or blockage.
-Record the current owner, active process state, unmet assertions, last evidence,
-and first safe resume action.
-
-After compaction, restart, or handoff, reopen authoritative inputs in precedence order. Treat summaries and history as evidence, not authority.
-
-## Completion
-
-Complete only when every required assertion is verified by current evidence, or
-when the authorized outcome owner explicitly amends the contract to accept an
-incomplete endpoint. Record the amendment, remaining dependency, and responsible
-owner.
diff --git a/codex/skills/using-codex-goals/agents/openai.yaml b/codex/skills/using-codex-goals/agents/openai.yaml
deleted file mode 100644
index 1f221ba2..00000000
--- a/codex/skills/using-codex-goals/agents/openai.yaml
+++ /dev/null
@@ -1,7 +0,0 @@
-interface:
-  display_name: "Using Codex Goals"
-  short_description: "Write durable Codex goal contracts"
-  default_prompt: "Use $using-codex-goals to draft or run a Codex goal with completion criteria, verification evidence, continuation rules, and bounded subagent slices."
-
-policy:
-  allow_implicit_invocation: true
diff --git a/codex/skills/using-codex-goals/references/goal-contracts.md b/codex/skills/using-codex-goals/references/goal-contracts.md
deleted file mode 100644
index 43ed72fb..00000000
--- a/codex/skills/using-codex-goals/references/goal-contracts.md
+++ /dev/null
@@ -1,210 +0,0 @@
-# Goal Contracts
-
-Use this reference when work needs a durable outcome and a small live control
-surface.
-
-## Outcome Contract
-
-Write the stable layer first:
-
-```markdown
-# Outcome
-
-## Finished State
-Describe what exists when the work is done.
-
-## Required Assertions
-- A1: Observable assertion.
-  - Pass evidence:
-  - Status: unmet
-  - Evidence:
-- A2: Observable assertion.
-  - Pass evidence:
-  - Status: unmet
-  - Evidence:
-
-## Constraints
-- Safety, scope, compatibility, budget, and authority limits.
-
-## Exclusions
-- Work intentionally outside this outcome.
-
-## Amendment Authority
-- Who may change finished state or assertion text.
-```
-
-Assertions should be independently checkable. Prefer product behavior, runtime
-state, persisted artifacts, current-head checks, and attributable rows over
-completion prose.
-
-## Live Execution State
-
-Keep mutable state compact and replace it rather than appending history:
-
-```markdown
-# Live State
-
-Outcome revision: 3
-Control writer: controller
-Execution owner: worker-7
-Observed state:
-- ...
-
-Unmet assertions:
-- A2
-- A4
-
-Current action:
-- ...
-
-Next proof:
-- ...
-
-External wait or decision:
-- none
-
-Last evidence:
-- A1 verified by run:835
-```
-
-The outcome revision changes only after an authorized amendment. Ordinary
-progress changes observed state, assertion status, and next action.
-
-## Evidence Rules
-
-For each material result:
-
-1. identify which assertion it supports or falsifies;
-2. record an exact locator;
-3. distinguish direct observation from inference;
-4. update status;
-5. recompute the remaining assertion set;
-6. route the smallest proof-producing action.
-
-Evidence locators can be a commit SHA, current-head check, test command, artifact
-path, benchmark row set, screenshot, runtime query, or reviewer result. Do not
-use "worker says done" as a locator.
-
-## Assignment Shape
-
-A delegated slice should include:
-
-```text
-Parent outcome, read-only:
-Parent assertions advanced:
-Slice postcondition:
-Allowed edits or actions:
-Authoritative inputs:
-Evidence required:
-Return conditions:
-```
-
-The worker returns when the slice postcondition is verified or a real exception
-exists. A turn boundary or progress update does not transfer ownership.
-
-## Exception Diagnosis
-
-A useful exception report answers:
-
-```text
-Which parent assertion remains unmet?
-What exact condition prevents the next safe action?
-What did the last attempt prove?
-What state exists now?
-What changed since the prior attempt?
-What smallest action could produce new evidence?
-Who owns that action?
-```
-
-Do not route another identical attempt when failure signature, inputs, and
-runtime path are unchanged and no new discriminating evidence exists.
-
-## Blocked And Waiting
-
-Use `blocked` only when:
-
-- a specific external dependency, missing authority, or unavailable fact is
-  named;
-- no safe local action can advance any unmet assertion;
-- reversible preparation and alternative hypotheses are exhausted;
-- the unblocking owner or event is identified.
-
-Use `waiting` when an external event is expected and the next useful judgment
-can be scheduled or triggered. Put mechanical polling inside one bounded command
-rather than spending model turns.
-
-No fixed number of turns or attempts proves blockage. Evidence about available
-actions does.
-
-## Human Decision Packet
-
-When authority is required, prepare:
-
-```markdown
-## Decision
-Exact question:
-
-## Why It Is Required
-Assertion or constraint affected:
-
-## Options
-1. Option with consequence.
-2. Option with consequence.
-
-## Safe Work Already Completed
-- ...
-
-## Recommendation
-- ...
-```
-
-Do not ask the user to solve routine diagnosis.
-
-## Pause Packet
-
-```markdown
-## Paused Goal
-Outcome revision:
-Execution owner:
-Active processes stopped:
-Monitors stopped:
-Unmet assertions:
-Last evidence:
-First safe resume action:
-External conditions to recheck:
-```
-
-Pause is not complete, blocked, or cancelled.
-
-## Completion Packet
-
-```markdown
-## Completion
-Outcome revision:
-Verified assertions:
-- A1: evidence locator
-- A2: evidence locator
-
-Authorized amendments:
-- none
-
-Residual concerns:
-- ...
-
-Public mutations:
-- authorized action and verification, or none
-```
-
-Residual concerns do not erase verified completion, but they must remain
-separate from assertion status.
-
-## Benchmark Boundary
-
-For benchmark work:
-
-- this goal contract owns final assertions, evidence mapping, and completion;
-- `benchmark-run-operator` owns launch contracts, worker and stack execution,
-  provenance, valid-row rules, recovery, and aggregate rebuilds;
-- benchmark evidence returns here as attributable artifacts and row sets.
-
-Do not duplicate benchmark process doctrine in the goal surface.
diff --git a/codex/skills/using-goals/SKILL.md b/codex/skills/using-goals/SKILL.md
new file mode 100644
index 00000000..4bcb80dc
--- /dev/null
+++ b/codex/skills/using-goals/SKILL.md
@@ -0,0 +1,100 @@
+---
+name: using-goals
+description: Preserve stable outcomes, anchors, evidence, authority, and resumable control state across long-running work.
+---
+
+# Using Goals
+
+Use a goal when work must survive turns, compaction, restarts, or delegated
+assignments without losing what completion means. This skill exists to keep the
+finish line stable while plans, workers, failures, and next actions change.
+
+The principal authors the goal and control packet. Delegates return artifacts
+and evidence. They do not rewrite the objective or maintain parallel ledgers.
+
+## Stable Goal
+
+A durable goal names:
+
+- a stable ID and revision;
+- the finished state;
+- independently observable assertions;
+- exact pass evidence for each assertion;
+- constraints and exclusions;
+- authoritative anchors in precedence order;
+- planning and implementation authority;
+- public mutation authority;
+- amendment authority.
+
+The goal remains stable until its named authority records an amendment. A failed
+command, new prerequisite, implementation choice, worker return, review,
+timeout, or discovered repair changes the route or observed state. It does not
+change what finished means.
+
+Read [references/goal-contracts.md](references/goal-contracts.md) when creating or
+repairing the control packet.
+
+## Principal-Authored Control
+
+Keep one logical author across finite contexts. The user-facing principal, or
+the user directly, prepares and reviews goals, plans, catalogs, assignments, and
+checkpoints.
+
+Delegation is lossy. Give each delegate a reviewed assignment with the smallest
+complete set of anchors, scope, authority, evidence, and return conditions. The
+delegate owns its assigned artifact and returns evidence through the named
+channel. The principal verifies that evidence and updates current state.
+
+## Separate Stable Meaning From Current State
+
+Keep current state compact and replace it as evidence changes. It should answer:
+
+- which goal revision is authoritative;
+- what observable state exists now;
+- which assertions remain unmet;
+- what work is active and where;
+- what evidence arrived;
+- what decision or next proof can reduce the gap;
+- when the state was last verified.
+
+Historical narrative belongs in an archive. The current ledger is not a diary.
+
+## Preserve Planning Authority
+
+Record whether the objective is in planning or implementation. Planning may
+include inspection, research, questions, plans, and explicitly scoped
+experiments. Production mutation begins when the named authority opens that
+phase.
+
+Material assignments should be reviewable before dispatch. User review may be
+covered by previously granted authority or explicitly waived.
+
+## Reconcile Evidence
+
+After each material result:
+
+1. identify which assertion it supports or falsifies;
+2. record an exact evidence locator and observation time;
+3. distinguish direct observation from inference;
+4. update current status;
+5. recompute the remaining assertion set;
+6. choose the smallest proof-producing next action.
+
+A completed task, phase, review, process, or wait is progress until the whole
+required assertion set is verified.
+
+## Survive Context Change
+
+Before compaction, restart, pause, or deliberate handoff, write a checkpoint
+that names the goal revision, anchors, observed state, accepted evidence,
+remaining gap, active work, and next verification.
+
+A successor principal reopens authoritative anchors in order and verifies
+changeable state before continuing. The fresh-context test passes when that
+successor can resume correctly without private conversation history.
+
+## Completion
+
+Complete only when current evidence verifies every required assertion, or the
+amendment authority explicitly records an accepted different endpoint. Keep
+residual concerns separate from assertion status.
diff --git a/codex/skills/using-goals/agents/openai.yaml b/codex/skills/using-goals/agents/openai.yaml
new file mode 100644
index 00000000..f8b74312
--- /dev/null
+++ b/codex/skills/using-goals/agents/openai.yaml
@@ -0,0 +1,7 @@
+interface:
+  display_name: "Using Goals"
+  short_description: "Preserve stable outcomes across finite contexts"
+  default_prompt: "Use $using-goals to create or repair a principal-authored goal, current control state, assignment boundary, and resumable checkpoint for this long-running objective."
+
+policy:
+  allow_implicit_invocation: true
diff --git a/codex/skills/using-goals/references/goal-contracts.md b/codex/skills/using-goals/references/goal-contracts.md
new file mode 100644
index 00000000..d7dd84c9
--- /dev/null
+++ b/codex/skills/using-goals/references/goal-contracts.md
@@ -0,0 +1,164 @@
+# Goal Contracts
+
+Use this reference to create a compact principal-authored control packet for
+long-running work.
+
+## Stable Goal
+
+```markdown
+# Goal: <name>
+
+Goal ID: <stable-id>
+Revision: 1
+Created at: <timestamp with timezone>
+Principal: <logical principal>
+Amendment authority: <identity>
+
+## Finished State
+
+<Achieved condition.>
+
+## Required Assertions
+
+- A1: <observable assertion>
+  - Pass evidence: <exact surface>
+- A2: <observable assertion>
+  - Pass evidence: <exact surface>
+
+## Constraints
+
+- <scope, safety, compatibility, budget, and authority limits>
+
+## Exclusions
+
+- <work deliberately outside the goal>
+
+## Authoritative Anchors
+
+1. <user-approved brief, PRD, issue, or contract>
+2. <repository or runtime source of truth>
+
+## Implementation Authority
+
+Phase: planning | implementation
+Production edits authorized by: <identity or none>
+Public mutations authorized: <exact actions or none>
+
+## Live State
+
+See `<catalog>` and `<checkpoint>`.
+```
+
+Assertions should be independently checkable. Prefer product behavior, runtime
+state, persisted artifacts, current-head checks, and attributable result rows
+over completion prose.
+
+## Current Catalog
+
+```markdown
+# Work Catalog
+
+Goal: <id> revision <n>
+Control author: <principal>
+Updated at: <timestamp>
+Last verified at: <timestamp>
+Applies to commit or runtime identity: <locator>
+
+## Observed State
+
+...
+
+## Unmet Assertions
+
+- A2
+
+## Active Work
+
+| ID | Assignment | Worker or process | Worktree or artifact root | State | Return channel | Last evidence |
+| --- | --- | --- | --- | --- | --- | --- |
+
+## Current Decision
+
+...
+
+## Next Proof
+
+...
+```
+
+The principal updates this document from verified returns. A worker report is
+an evidence locator, not automatic acceptance.
+
+## Assignment
+
+```text
+Assignment ID:
+Prepared by:
+Review state: draft | approved | user-waived
+Parent goal and assertion IDs:
+Slice outcome:
+Integration target:
+Authoritative anchors, in order:
+Allowed edits or actions:
+Production mutation authority:
+Public mutation authority:
+State to preserve:
+Evidence required:
+Return channel:
+Return conditions:
+```
+
+The assignment advances the goal and cannot amend it.
+
+## Checkpoint
+
+```text
+Goal and revision:
+Principal role:
+Written at:
+Last verified at:
+Reason for checkpoint:
+Anchors to reopen, in order:
+Observed state:
+Accepted evidence mapped to assertions:
+Remaining gap:
+Active delegates, processes, and worktrees:
+Risks and decisions:
+Next proof-producing action:
+Successor verification:
+```
+
+Write the checkpoint before context loss, not after the successor discovers the
+missing state.
+
+## Blocked, Waiting, And Decisions
+
+Use `blocked` when a named external dependency, missing authority, or unavailable
+fact prevents every safe local action that could advance any unmet assertion.
+
+Use `waiting` when a named external event is expected and the next useful check
+can be scheduled. Put pure polling inside one bounded command.
+
+When human authority is required, prepare the exact question, affected
+assertion, options and consequences, safe work already completed, and a
+recommendation.
+
+## Completion Packet
+
+```markdown
+## Completion
+
+Goal revision:
+Verified assertions:
+- A1: <evidence locator>
+- A2: <evidence locator>
+
+Authorized amendments:
+- none
+
+Residual concerns:
+- ...
+
+Public mutations:
+- <authorized action and verification, or none>
+```
diff --git a/codex/skills/workspace-steward/SKILL.md b/codex/skills/workspace-steward/SKILL.md
index 90800806..436467e8 100644
--- a/codex/skills/workspace-steward/SKILL.md
+++ b/codex/skills/workspace-steward/SKILL.md
@@ -1,153 +1,132 @@
 ---
 name: workspace-steward
-description: Organize and audit local multi-repo workspaces with clean main checkouts, PR worktrees, experiments, local docs, artifacts, tmp space, and evidence rules.
+description: Organize and audit agentic multi-repo workspaces, worktrees, control docs, experiments, evidence, scratch, and archives.
 ---
 
 # Workspace Steward
 
-Use this skill to make a workspace easier to enter, operate, and review while
-preserving active work and evidence. The first move is to make the requested
-change earn its place.
+Create a workspace that makes parallel agent work easy to enter, isolate,
+resume, review, and retire. This skill exists because repositories, worktrees,
+control documents, experiments, artifacts, and scratch acquire different
+lifecycles, and a flat directory turns those differences into hidden risk.
 
-An umbrella workspace coordinates multiple child repos and local operating
-surfaces. It is not automatically a monorepo, and its root might not be the repo
-that a command should operate on.
+The requested organization must earn its maintenance. Preserve active work and
+make the smallest layout change that removes real confusion, repeated cost, or
+safety risk.
 
-## Decision Filter
+## Apply The Reduction Filter
 
-Run this filter in order before changing layout, moving files, adding scripts,
-or automating cleanup:
+Before moving files or adding process:
 
-1. Challenge the requirement. State the current confusion, repeated cost, or
-   safety risk the change is meant to fix.
-2. Remove what does not earn maintenance. Delete proposed buckets, docs, scripts,
-   or conventions that do not solve that stated problem.
-3. Simplify what remains. Prefer fewer paths, clearer names, and existing Git
-   or shell behavior over new process.
-4. Speed up only after the shape is right. Add aliases, scripts, templates, or
-   manifests only when they shorten a proven workflow.
-5. Automate last. Automate only stable, repeated operations with clear inputs,
-   outputs, rollback, and preservation boundaries.
+1. Name the current confusion, repeated cost, or preservation risk.
+2. Remove proposed buckets, docs, scripts, or automation that do not solve it.
+3. Simplify names and paths around existing Git and shell behavior.
+4. Accelerate a proven workflow only after its shape is clear.
+5. Automate stable repeated operations with explicit inputs, outputs, rollback,
+   and preservation boundaries.
 
-If a proposed folder, move, script, or automation fails an earlier filter, stop
-and report the smaller change that survived.
+A smaller note, ignore rule, catalog, or worktree convention may solve the
+problem better than a new hierarchy.
 
-When creating a new umbrella workspace from scratch, use
-`references/project-template/` only after the decision filter leaves a full
-skeleton as the smallest useful shape. Read
-`references/project-template/README.md`, copy the template contents into the new
-workspace root, and replace placeholders with real project and repo names.
+## Separate Lifecycles
 
-## Operating Model
+An umbrella workspace coordinates child repositories and local operating state.
+It is not automatically a monorepo.
 
-Question the target layout before moving anything. Ask what problem the change
-solves, who will use it next, and whether a smaller note, ignore rule, or
-worktree convention would solve it.
+Use visible, purpose-named areas when they match the work:
 
-Keep top-level areas tied to one lifecycle:
+- canonical repositories and clean default-branch checkouts at the root;
+- `worktrees/prs/` for branch work intended to become reviewed repository
+  changes;
+- `worktrees/spikes/` for disposable integration questions against the real
+  repository;
+- `experiments/` for tiny disposable mechanism tests;
+- `local-docs/` for principal-authored goals, plans, catalogs, assignments,
+  checkpoints, and handoffs;
+- `docs/` for durable project or workspace documentation;
+- `artifacts/` for generated evidence, reports, exports, logs, and manifests;
+- `tmp/` for recreatable scratch;
+- `archived/` for inactive material retained as reference.
 
-- canonical repo checkouts stay visible at the root;
-- clean main checkouts, usually `<repo>-main`, stay on the default branch for
-  reading, syncing, and creating worktrees;
-- `worktrees/prs/` holds branch or PR work that is intended to be pushed;
-- `experiments/` holds exploratory work that is not yet a repo, artifact, or
-  PR;
-- `local-docs/` holds controller notes, plans, and handoffs;
-- `docs/` holds durable project or workspace documentation;
-- `artifacts/` holds generated evidence, reports, exports, logs, and manifests;
-- `tmp/` holds scratch files that can be recreated or deleted;
-- `archived/` holds inactive reference material.
+Use names that reveal repository and workstream identity. Generic buckets such
+as `src/` weaken an umbrella workspace unless the root is truly one repository.
 
-Use names that reveal repo identity. Do not move active repos under generic
-buckets such as `src/` unless the workspace is actually one repository with
-internal packages and every path dependency has a migration plan.
+## Worktrees Are Real Work
 
-## Before Editing
+Keep a clean default-branch checkout for reading, syncing, and creating
+worktrees. Start production-bound work from the intended current remote base,
+usually `origin/main`, after fetching and verifying state.
 
-1. Read root `AGENTS.md`, root `README.md`, and the nearest docs index.
-2. Identify the actual Git repo before branch, commit, push, or status work:
+Use `git-branch-resolver` whenever branch identity, divergence, registration,
+cleanup, or PR state needs interpretation.
 
-```powershell
-git rev-parse --show-toplevel
-git status --short --branch
-git remote -v
-```
+Move registered worktrees with Git. Remove them after merge, preservation, or
+explicit disposable evidence. A dirty worktree remains active work until its
+contents are understood and preserved.
 
-3. Classify each uncertain directory by evidence, not name:
+## Experiments Are Disposable Learning
 
-```powershell
-git -C <candidate> rev-parse --git-common-dir
-git -C <candidate> worktree list --porcelain
-git -C <candidate> status --short --branch
-```
+A micro-experiment answers one uncertainty with tiny code that will never be
+copied into production. Keep it independent of the project when the mechanism
+can be isolated. Record the finding, then implement deliberately in a real
+worktree.
 
-4. Inspect dirty state and preserve useful work before moving or deleting files.
-5. Draft the smallest target layout that solves the specific confusion.
+Use `run-a-micro-experiment` for that contract. Use a disposable integration
+spike worktree when the uncertainty requires the real repository.
 
-## Worktree Rules
+## Preserve Principal Control State
 
-Keep the clean main checkout clean. Use it for reading, syncing, and creating
-worktrees, not ordinary implementation edits.
+Long-running goals, plans, catalogs, assignments, and checkpoints are authored
+by the user-facing principal or the user. Delegated workers return evidence and
+artifacts through named channels rather than maintaining independent control
+files.
 
-Start PR worktrees from `origin/main` by default, not from a dirty local main
-checkout:
+Keep current state compact. Timestamp operational documents with the fields that
+answer freshness questions, such as:
 
-```powershell
-git -C <repo-main> fetch origin
-git -C <repo-main> status --short --branch
-git -C <repo-main> worktree add -b <branch-name> <umbrella>\worktrees\prs\<slug> origin/main
-```
+- created at;
+- updated at;
+- last verified at;
+- next check at;
+- applies to commit or runtime identity;
+- archived at.
 
-If local project guidance names a different default branch, use that branch
-explicitly and explain the deviation.
+Use absolute ISO 8601 timestamps with time zones. Source code and ordinary code
+comments do not need historical timestamps.
 
-Treat `worktrees/prs/` as pushed-work territory. If the work is exploratory or
-local-only, use `experiments/`, `artifacts/`, or `local-docs/` instead.
+## Promote Useful State
 
-Move registered worktrees with `git worktree move`. Remove them with
-`git worktree remove` only after merge, preservation, or explicit disposable
-evidence.
+Scratch must not become a hidden source of truth. Promote useful material to the
+surface that owns its lifecycle:
 
-Before cleanup, inspect registration:
+- reproducible evidence to `artifacts/`;
+- reusable tooling to a reviewed script or repository;
+- durable project guidance to `docs/`;
+- principal control state to `local-docs/`;
+- production-bound edits to a branch and PR.
 
-```powershell
-git -C <repo-main> worktree list --porcelain
-git -C <repo-main> worktree prune --dry-run --verbose
-```
+Generated evidence should record source, owner, observed time, secret-scan state,
+and regeneration instructions when those facts are not obvious.
 
-Treat stale or prunable entries as report targets first. Run `git worktree
-prune` only after confirming the path is gone and no work needs preservation.
+## Copyable Workspace
 
-## Evidence Rules
-
-Do not let `tmp/` become a hidden source of truth. Promote useful scratch work
-to the right durable surface:
+For a new umbrella workspace, use `references/project-template/` only when the
+reduction filter leaves the full structure as the smallest useful shape. Read
+its root README, glossary, runtime guidance, and lifecycle READMEs before
+copying it.
 
-- reproducible evidence or reports: `artifacts/`;
-- reusable tooling: `scripts/`;
-- project or workspace docs: `docs/`;
-- controller notes or handoffs: `local-docs/`;
-- branch-bound code changes: a repo branch or PR.
+## Audit Result
 
-When preserving generated evidence, add nearby notes with source, owner, date
-range, retention, secret-scan status, and regeneration instructions when those
-details are not obvious.
+A workspace audit should make these answers immediate:
 
-Keep secrets, credentials, browser state, local trust state, and machine-only
-runtime caches ignored and local.
+- Where is each canonical repository?
+- Which checkout is clean default branch?
+- Which worktrees are active production work?
+- Which experiments are disposable and what question did each answer?
+- Which control documents are current and when were they last verified?
+- Which artifacts are accepted evidence and how were they produced?
+- Which paths are safe to delete because they are recreatable scratch?
+- Which inactive material should be archived or removed?
 
-## Maintenance Pass
-
-When auditing an existing workspace, answer these questions in the final report
-or the changed README:
-
-- Where is the canonical repo?
-- Which checkout is clean main?
-- Which worktrees are active PR work?
-- Which artifacts are evidence, and how were they produced?
-- Which notes are local controller state instead of product docs?
-- Which files are safe to delete because they are recreatable scratch?
-
-Prefer one small ownership README or ignore rule over a broad cleanup. Cleanup
-is done when the workspace is easier to operate, not when the root has the
-fewest folders.
+Cleanup is complete when the workspace is easier to operate and resume, not when
+it has the fewest visible folders.
diff --git a/codex/skills/workspace-steward/agents/openai.yaml b/codex/skills/workspace-steward/agents/openai.yaml
index b4162ded..f94d450a 100644
--- a/codex/skills/workspace-steward/agents/openai.yaml
+++ b/codex/skills/workspace-steward/agents/openai.yaml
@@ -1,7 +1,7 @@
 interface:
   display_name: "Workspace Steward"
-  short_description: "Organize multi-repo workspaces"
-  default_prompt: "Use $workspace-steward to organize or audit an umbrella workspace with clean main checkouts, PR worktrees, experiments, local docs, artifacts, tmp space, and cleanup boundaries."
+  short_description: "Organize parallel agent work by lifecycle"
+  default_prompt: "Use $workspace-steward to make this workspace easy to isolate, resume, review, and retire across repositories, worktrees, control docs, experiments, evidence, scratch, and archives."
 
 policy:
   allow_implicit_invocation: true
diff --git a/codex/skills/workspace-steward/references/project-template/.gitignore b/codex/skills/workspace-steward/references/project-template/.gitignore
index 10a26f68..69af45e5 100644
--- a/codex/skills/workspace-steward/references/project-template/.gitignore
+++ b/codex/skills/workspace-steward/references/project-template/.gitignore
@@ -1,16 +1,18 @@
-# Scratch - recreatable and deletable. Keep the directory, ignore its contents.
+# Recreatable scratch. Keep the directory contract, ignore its contents.
 /tmp/*
 !/tmp/README.md
 
-# Child-repo worktrees - linked through git, not tracked in this root repo.
+# Child-repository worktrees are linked through Git, not tracked by this root.
 /worktrees/prs/*
-!/worktrees/prs/.gitkeep
+!/worktrees/prs/README.md
+/worktrees/spikes/*
+!/worktrees/spikes/README.md
 
-# Canonical child repo checkouts - add concrete names before cloning.
+# Canonical child checkouts. Add concrete names before cloning.
 # /example-repo/
 # /example-repo-main/
 
-# Secrets and credentials - never commit.
+# Secrets and credentials.
 .env
 .env.*
 !.env.example
@@ -18,8 +20,9 @@
 *.key
 *.p12
 secrets/
+credentials/
 
-# Local runtime state - browser profiles, sessions, logs, and databases.
+# Machine-only runtime state.
 /browser/
 /browser-profile/
 /cache/
@@ -39,7 +42,7 @@ secrets/
 *.db-wal
 *.log
 
-# Machine-only runtime caches and build state.
+# Build and tool caches.
 **/__pycache__/
 **/.venv/
 **/node_modules/
diff --git a/codex/skills/workspace-steward/references/project-template/AGENTS.md b/codex/skills/workspace-steward/references/project-template/AGENTS.md
index 972f306a..2ffd5e02 100644
--- a/codex/skills/workspace-steward/references/project-template/AGENTS.md
+++ b/codex/skills/workspace-steward/references/project-template/AGENTS.md
@@ -1,7 +1,7 @@
-# Agent Guidance for <Project> Workspace
+# Codex Guidance for <Project> Workspace
 
-This root is an umbrella workspace, not a single product repo. Identify the
-actual git repo before any branch, commit, push, or status work:
+This root coordinates several repositories and local operating surfaces. Identify
+the actual Git repository before branch, commit, push, or status work.
 
 ```sh
 git rev-parse --show-toplevel
@@ -9,18 +9,32 @@ git status --short --branch
 git remote -v
 ```
 
-Operating rules:
-
-- Canonical repo checkouts live at the root by name. A `<repo>-main` checkout
-  stays on the default branch and stays clean of implementation edits.
-- PR work goes in `worktrees/prs/<slug>`, started from the child repo's
-  `origin/main`, not a dirty local main.
-- `docs/` is durable documentation. `local-docs/` is controller operating state
-  for this workspace.
-- `artifacts/` holds generated evidence with a provenance note. `tmp/` is
-  deletable scratch and is gitignored.
-- Keep secrets, credentials, browser state, and machine-only caches ignored and
-  local.
-
-Read the root `README.md` for the full layout before moving files or adding
-conventions.
+## Direction
+
+Preserve one coherent objective across finite contexts. The user or user-facing
+principal authors goals, plans, catalogs, assignments, and checkpoints under
+`local-docs/`. Delegated workers execute reviewed assignments and return
+artifacts plus evidence. They do not invent independent control state.
+
+Lead with the desired state and evidence. Use prohibitions for crisp safety,
+authority, and lifecycle boundaries.
+
+## Workspace Boundaries
+
+- Keep `<repo>-main` checkouts on the declared default branch and free of
+  implementation edits.
+- Put production-bound work in `worktrees/prs/<slug>` from the intended current
+  remote base.
+- Put real-repository integration spikes in `worktrees/spikes/`.
+- Put isolated one-question disposable programs in `experiments/`.
+- Let findings graduate from experiments. Reimplement production behavior in a
+  real worktree.
+- Keep durable product truth in `docs/` and principal operating state in
+  `local-docs/`.
+- Keep generated evidence in `artifacts/` with provenance and timestamps.
+- Treat `tmp/` as deletable.
+- Preserve secrets, credentials, browser state, sessions, and machine caches
+  outside tracked files.
+
+Read the root README and the lifecycle README nearest the work before moving,
+promoting, or deleting material.
diff --git a/codex/skills/workspace-steward/references/project-template/CLAUDE.md b/codex/skills/workspace-steward/references/project-template/CLAUDE.md
new file mode 100644
index 00000000..3ed409cb
--- /dev/null
+++ b/codex/skills/workspace-steward/references/project-template/CLAUDE.md
@@ -0,0 +1,29 @@
+# Claude Code Guidance for <Project> Workspace
+
+This root coordinates several repositories and local operating surfaces. Resolve
+the actual repository before using Git or changing product files.
+
+## Direction
+
+Preserve one coherent objective across finite contexts. The user or user-facing
+principal authors goals, plans, catalogs, assignments, and checkpoints under
+`local-docs/`. Delegated GLM-5.2 workers receive reviewed assignments and return
+artifacts plus evidence. They do not create competing control documents.
+
+Point toward the desired result, evidence, and ownership boundary. Keep
+procedures exact only where mechanics or authority are fragile.
+
+## Workspace Boundaries
+
+- Keep clean-main checkouts clean and current.
+- Put production-bound changes in `worktrees/prs/<slug>`.
+- Put disposable real-repository integration spikes in `worktrees/spikes/`.
+- Put isolated micro-experiments in `experiments/`.
+- Graduate findings, then implement deliberately in the production codebase.
+- Keep durable project truth in `docs/` and current principal control state in
+  `local-docs/`.
+- Preserve generated evidence in `artifacts/` and recreatable scratch in `tmp/`.
+- Keep secrets and machine-only runtime state local and ignored.
+
+Read the root README and the nearest lifecycle README before reorganizing the
+workspace.
diff --git a/codex/skills/workspace-steward/references/project-template/README.md b/codex/skills/workspace-steward/references/project-template/README.md
index e44009ca..671004f8 100644
--- a/codex/skills/workspace-steward/references/project-template/README.md
+++ b/codex/skills/workspace-steward/references/project-template/README.md
@@ -1,58 +1,78 @@
 # <Project> Workspace
 
-Umbrella workspace for <project>. This root coordinates several child repos and
-local operating surfaces. It is usually its own git repo, but it is not a
-monorepo: canonical repo checkouts stay visible at the root by name.
+Umbrella workspace for <project>. This root coordinates child repositories,
+production worktrees, disposable experiments, control documents, evidence, and
+archives. It may be its own small Git repository, but it is not automatically a
+monorepo. Canonical child checkouts stay visible at the root by name.
+
+## Operating Model
+
+One user-facing principal preserves the objective across contexts. The user or
+principal authors goals, plans, catalogs, assignments, and checkpoints under
+`local-docs/`. Delegates execute reviewed assignments and return artifacts plus
+evidence. A fresh principal context resumes from those anchors rather than from
+conversation memory.
+
+Use absolute timestamps with time zones in mutable control documents and
+evidence notes. `Last verified at` matters more than a vague modification date.
 
 ## Layout
 
-- `<repo>/` and `<repo>-main/` - canonical repo checkouts live at the root,
-  revealed by name, never tucked under `src/` or a generic bucket. A `<repo>-main`
-  checkout stays on the default branch for reading, syncing, and spawning
-  worktrees; keep it clean of implementation edits.
-- `worktrees/prs/` - branch and PR work that is meant to be pushed. Start each
-  from the child repo's `origin/main`, not a dirty local main.
-- `experiments/` - exploratory work that is not yet a repo, artifact, or PR.
-  Promote it out when it earns a place.
-- `local-docs/` - controller notes, plans, and handoffs: state about operating
-  this workspace.
-- `docs/` - durable project and workspace documentation.
-- `artifacts/` - generated evidence: reports, exports, logs, manifests.
-- `tmp/` - scratch files that can be recreated or deleted.
-- `archived/` - inactive reference material, preserved as-is.
-
-Each directory above has its own README with the rules that keep it honest.
-
-## Adopt this template
-
-1. Copy the contents of this directory into your new project root.
-2. If the root is not yet a git repo, `git init` it. The shipped `.gitignore`
-   keeps `tmp/` and child-repo worktrees out, and ignores secrets and caches.
-3. Add each real root checkout name to `.gitignore`, such as
-   `/example-repo/` and `/example-repo-main/`, before cloning child repos.
-4. Clone each child repo as a clean `<repo>-main` on the default branch, used
-   only for reading, syncing, and creating worktrees.
-5. Start PR work in `worktrees/prs/<slug>` from the child repo's `origin/main`.
-6. Replace this heading and the bracketed placeholders with the project name and
-   real repo identities.
-
-## Worktree convention
-
-Keep the clean main checkout clean. Create PR worktrees from the child repo:
+- `<repo>-main/`: clean default-branch checkout for reading, syncing, and
+  creating worktrees.
+- `<repo>/`: canonical checkout when the project needs one distinct from the
+  clean-main checkout.
+- `worktrees/prs/`: production-bound branch and PR work.
+- `worktrees/spikes/`: disposable integration spikes that require the real
+  repository but are not production-bound.
+- `experiments/`: tiny isolated programs that answer one uncertainty and never
+  become production code.
+- `local-docs/`: principal-authored goals, plans, catalogs, assignments,
+  checkpoints, and decisions.
+- `docs/`: durable project and workspace documentation.
+- `artifacts/`: generated evidence, reports, exports, logs, and manifests.
+- `tmp/`: recreatable scratch.
+- `archived/`: inactive material preserved with dated context.
+- `glossary.md`: terms whose distinctions change behavior.
+
+Each lifecycle area has its own README. Read it before creating or promoting
+material there.
+
+## Adopt This Template
+
+1. Copy the template contents into a new workspace root.
+2. Replace `<Project>` and other placeholders with real names.
+3. Initialize the root repository when it will own these control documents.
+4. Add concrete child checkout names to `.gitignore` before cloning.
+5. Clone each child as a clean `<repo>-main` checkout.
+6. Record repository identities and default branches in the root documentation.
+7. Create production work in `worktrees/prs/<slug>` from the intended current
+   remote base, usually `origin/main`.
+8. Keep experiments and spikes visibly disposable.
+9. Review `AGENTS.md`, `CLAUDE.md`, and `glossary.md` for project-specific truth.
+
+## Fresh Worktree Convention
 
 ```sh
 git -C <repo>-main fetch origin
-git -C <repo>-main worktree add -b <branch> <root>/worktrees/prs/<slug> origin/main
+git -C <repo>-main status --short --branch
+git -C <repo>-main worktree add -b <branch> <workspace>/worktrees/prs/<slug> origin/main
 ```
 
-If local project guidance names a different default branch, use it explicitly
-and note why. Move worktrees with `git worktree move`, and remove them with
-`git worktree remove` only after merge, preservation, or explicit disposable
-evidence.
+Use the project-declared default branch when it differs. Move registered
+worktrees with `git worktree move`. Remove them with `git worktree remove` only
+after merge, preservation, or explicit disposable evidence.
+
+## Continuity Test
+
+A fresh principal context should be able to open the current goal, plan,
+catalog, checkpoint, and named repository state, then answer:
 
-## Operating notes
+- What finished state remains authoritative?
+- What phase is authorized?
+- Which assignments are active?
+- What evidence is current?
+- What remains unresolved?
+- What action can produce the next useful proof?
 
-Read this README and `AGENTS.md` before changing layout. Treat `tmp/` as
-deletable: promote useful scratch to `artifacts/`, `scripts/`, `docs/`, or
-`local-docs/`. Add `scripts/` or `manifests/` only when a repeated operation
-earns the maintenance.
+When it cannot, repair the control documents before adding more work.
diff --git a/codex/skills/workspace-steward/references/project-template/archived/README.md b/codex/skills/workspace-steward/references/project-template/archived/README.md
index 6777f2d6..4b6da5af 100644
--- a/codex/skills/workspace-steward/references/project-template/archived/README.md
+++ b/codex/skills/workspace-steward/references/project-template/archived/README.md
@@ -1,13 +1,8 @@
 # archived
 
-Historical folders that should be preserved but are not active work targets.
+Inactive material retained for reference. Archive only after current catalogs
+and control documents point to the active replacement or record closure.
 
-Rules:
-
-- Do not use archived folders as current runbooks or the current source of truth.
-- Do not move active worktrees here. Active, review, preserved, and
-  delete-candidate worktrees belong under `../worktrees/`.
-- Do not delete archived folders unless a later cleanup pass records explicit
-  owner approval and preservation evidence.
-- Keep archive evidence intact. Prefer adding a dated note over editing old
-  chronology.
+Preserve chronology. Add a dated archive note instead of rewriting historical
+state. Active worktrees, current runbooks, and authoritative control documents
+remain in their live lifecycle locations.
diff --git a/codex/skills/workspace-steward/references/project-template/artifacts/README.md b/codex/skills/workspace-steward/references/project-template/artifacts/README.md
index 05d2b74a..d4268cb8 100644
--- a/codex/skills/workspace-steward/references/project-template/artifacts/README.md
+++ b/codex/skills/workspace-steward/references/project-template/artifacts/README.md
@@ -1,11 +1,17 @@
 # artifacts
 
-Generated evidence: reports, exports, logs, run outputs, and manifests produced
-by tools or runs.
+Generated evidence and deliverables: reports, exports, logs, screenshots,
+scoreboards, run outputs, manifests, and validation packets.
 
-When you preserve evidence here, add a nearby note with source, owner, date
-range, retention, secret-scan status, and how to regenerate it, unless those are
-obvious. Prefer a dated folder name such as `benchmark-run-20260101/`.
+Preserved evidence names:
 
-Do not commit raw dumps or large binaries without a retention note. Pure scratch
-that can be regenerated belongs in `../tmp/`, not here.
+- source or producing command;
+- owner or producer;
+- observed date range and time zone;
+- relevant commit, build, or target identity;
+- secret-scan status;
+- retention or archive decision;
+- regeneration instructions when practical.
+
+Prefer dated, descriptive folders. Keep recreatable scratch in `../tmp/`. Keep
+raw private or secret-bearing output outside tracked files.
diff --git a/codex/skills/workspace-steward/references/project-template/docs/README.md b/codex/skills/workspace-steward/references/project-template/docs/README.md
index b6f65161..3d38ff65 100644
--- a/codex/skills/workspace-steward/references/project-template/docs/README.md
+++ b/codex/skills/workspace-steward/references/project-template/docs/README.md
@@ -1,8 +1,8 @@
 # docs
 
-Durable project and workspace documentation that is meant to be read over time:
-indexes, glossaries, standards, designs, and runbooks that describe how the
-workspace operates.
+Durable project and workspace truth: architecture, standards, glossaries,
+decisions intended for broad reuse, and runbooks that remain authoritative over
+time.
 
-This is product and workspace truth, checked into git. Put controller operating
-state, plans, and handoffs in `../local-docs/` instead.
+Current principal operating state, assignments, and checkpoints belong in
+`../local-docs/`. Generated evidence belongs in `../artifacts/`.
diff --git a/codex/skills/workspace-steward/references/project-template/experiments/README.md b/codex/skills/workspace-steward/references/project-template/experiments/README.md
index 793946fc..becb4277 100644
--- a/codex/skills/workspace-steward/references/project-template/experiments/README.md
+++ b/codex/skills/workspace-steward/references/project-template/experiments/README.md
@@ -1,9 +1,28 @@
 # experiments
 
-Exploratory work that is not yet a repo, an artifact, or a PR: spikes, drafts,
-and prototypes whose home is not decided.
+Use this directory for micro-experiments: the smallest disposable program that
+answers one technical uncertainty without copying the production project.
 
-Promote work out of here when it earns a place: a repo checkout at the root, a
-PR worktree under `../worktrees/prs/`, evidence under `../artifacts/`, or a doc
-under `../docs/`. Long-lived experiments are a signal that they should have been
-promoted already.
+Every experiment records:
+
+- question;
+- decision the result will change;
+- smallest revealing program or command;
+- environment and relevant versions;
+- observed output;
+- interpretation and remaining uncertainty;
+- production consequence;
+- created and observed timestamps with time zones;
+- disposition: delete or archive.
+
+Optimize for fast learning and visible mechanism, not production architecture.
+The experiment does not become a partial product, shadow implementation, or
+source of copied production code.
+
+Experimental code does not graduate. The finding graduates. Implement the
+learned behavior deliberately in a production worktree with the real ownership,
+style, tests, and review requirements.
+
+When the question requires the real repository, build, integration boundary, or
+performance profile, use a disposable integration-spike worktree under
+`../worktrees/spikes/` instead.
diff --git a/codex/skills/workspace-steward/references/project-template/experiments/TEMPLATE.md b/codex/skills/workspace-steward/references/project-template/experiments/TEMPLATE.md
new file mode 100644
index 00000000..0fc9c210
--- /dev/null
+++ b/codex/skills/workspace-steward/references/project-template/experiments/TEMPLATE.md
@@ -0,0 +1,36 @@
+# Micro-Experiment: <question>
+
+Created at: <ISO 8601 timestamp with timezone>
+Observed at: <ISO 8601 timestamp with timezone>
+Owner: <identity>
+Disposition: active | delete | archive
+
+## Question
+
+<One technical uncertainty.>
+
+## Decision This Changes
+
+<What will be decided from the result.>
+
+## Smallest Revealing Test
+
+<Minimal disposable program or command.>
+
+## Environment
+
+- <versions and assumptions>
+
+## Observation
+
+<Exact output or behavior.>
+
+## Finding
+
+<What the observation supports or falsifies.>
+
+## Production Consequence
+
+<How to implement or avoid the behavior in a real worktree.>
+
+Experimental code does not graduate. The finding graduates.
diff --git a/codex/skills/workspace-steward/references/project-template/glossary.md b/codex/skills/workspace-steward/references/project-template/glossary.md
new file mode 100644
index 00000000..26a585dc
--- /dev/null
+++ b/codex/skills/workspace-steward/references/project-template/glossary.md
@@ -0,0 +1,54 @@
+# Workspace Glossary
+
+Use these terms consistently because confusing them changes ownership and
+lifecycle behavior.
+
+## Principal
+
+The user-facing logical owner of the objective. A new model context may resume
+this role after reading and verifying the current anchors.
+
+## Goal
+
+The stable finished state, evidence standard, constraints, exclusions, and
+amendment authority. It does not narrate current progress.
+
+## Plan
+
+The current reviewed route toward the goal. Evidence may change the plan without
+silently changing the goal.
+
+## Catalog
+
+The principal-authored index of active assignments, repositories, worktrees,
+experiments, evidence, decisions, and checkpoints.
+
+## Assignment
+
+A reviewed delegate packet containing one bounded result, context, authority,
+validation target, and return evidence.
+
+## Checkpoint
+
+A principal-authored resume point written before compaction, interruption, or
+handoff. It points to current anchors and observable state.
+
+## Worktree
+
+A real repository checkout attached to a branch. A PR worktree may produce
+production code. A spike worktree is explicitly disposable.
+
+## Micro-Experiment
+
+A tiny isolated program that answers one uncertainty. Its finding may graduate.
+Its code does not.
+
+## Artifact
+
+A generated output retained as evidence or a deliverable, with provenance and
+retention context.
+
+## Evidence
+
+A current observation or artifact that supports or falsifies a claim. A worker's
+summary is a locator for verification, not proof by itself.
diff --git a/codex/skills/workspace-steward/references/project-template/local-docs/README.md b/codex/skills/workspace-steward/references/project-template/local-docs/README.md
index 58552530..4d2c714e 100644
--- a/codex/skills/workspace-steward/references/project-template/local-docs/README.md
+++ b/codex/skills/workspace-steward/references/project-template/local-docs/README.md
@@ -1,10 +1,22 @@
 # local-docs
 
-Controller operating state for this workspace: plans, handoffs, maintenance
-notes, and other context about running the workspace day to day.
-
-This complements `../docs/`, which holds durable product and workspace
-documentation. Use `local-docs/` for notes that are about operating this
-workspace, and `docs/` for material meant to be read over time as product truth.
-If a note should stay on one machine only, keep it ignored locally rather than
-abandoning the directory convention.
+Principal-authored operating state for this workspace. These documents preserve
+one intention across context limits, compaction, delegation, interruption, and
+replacement workers.
+
+- `goals/`: stable finished states and evidence standards.
+- `plans/`: current reviewed routes and implementation authority.
+- `catalogs/`: indexes of active work, locations, assignments, and evidence.
+- `assignments/`: reviewed delegate packets.
+- `checkpoints/`: compact resume points written before handoff or compaction.
+- `decisions/`: material decisions and their authority.
+
+Use absolute timestamps with time zones. Name authoritative inputs in precedence
+order. Replace current state rather than appending an endless diary. Archive
+superseded documents with a clear replacement locator.
+
+Delegates return artifacts and evidence to the principal. They do not each
+maintain a private ledger or redefine these documents.
+
+Durable project and workspace truth belongs in `../docs/`. Generated evidence
+belongs in `../artifacts/`.
diff --git a/codex/skills/workspace-steward/references/project-template/local-docs/assignments/README.md b/codex/skills/workspace-steward/references/project-template/local-docs/assignments/README.md
new file mode 100644
index 00000000..86c93e51
--- /dev/null
+++ b/codex/skills/workspace-steward/references/project-template/local-docs/assignments/README.md
@@ -0,0 +1,15 @@
+# assignments
+
+Assignments are reviewed packets authored by the principal before delegation.
+Each packet names:
+
+- parent goal and assertions advanced;
+- bounded desired result;
+- authoritative context and exact paths;
+- allowed edits or actions;
+- validation target;
+- return evidence and real exception conditions;
+- controller return channel when available.
+
+A delegate owns the assigned artifact, not the parent objective or control
+documents.
diff --git a/codex/skills/workspace-steward/references/project-template/local-docs/assignments/TEMPLATE.md b/codex/skills/workspace-steward/references/project-template/local-docs/assignments/TEMPLATE.md
new file mode 100644
index 00000000..21c63f02
--- /dev/null
+++ b/codex/skills/workspace-steward/references/project-template/local-docs/assignments/TEMPLATE.md
@@ -0,0 +1,38 @@
+# Assignment: <name>
+
+Assignment ID: <stable-id>
+Prepared by: <principal>
+Prepared at: <ISO 8601 timestamp with timezone>
+Review state: draft | approved | user-waived
+Parent goal and assertions: <locators>
+Return channel: <thread, agent handle, or named location>
+
+## Slice Outcome
+
+<One observable postcondition.>
+
+## Integration Target
+
+<How the return advances the parent goal.>
+
+## Authoritative Anchors
+
+1. <anchor>
+2. <anchor>
+
+## Scope And Authority
+
+- Owned artifact or investigation:
+- Allowed edits or actions:
+- Production mutation authority:
+- Public mutation authority:
+- State to preserve:
+
+## Evidence Required
+
+- <command, artifact, review, or observation>
+
+## Return Conditions
+
+Return when the slice outcome is verified or one exact decision, authority
+boundary, external event, or exhausted recovery path prevents further safe work.
diff --git a/codex/skills/workspace-steward/references/project-template/local-docs/catalogs/README.md b/codex/skills/workspace-steward/references/project-template/local-docs/catalogs/README.md
new file mode 100644
index 00000000..6ae5705c
--- /dev/null
+++ b/codex/skills/workspace-steward/references/project-template/local-docs/catalogs/README.md
@@ -0,0 +1,7 @@
+# catalogs
+
+A catalog is the current index of active repositories, worktrees, assignments,
+experiments, monitors, evidence artifacts, decisions, and checkpoints.
+
+Keep locators and current status concise. Point to source documents instead of
+copying them. Include `Last verified at` so a fresh context can judge freshness.
diff --git a/codex/skills/workspace-steward/references/project-template/local-docs/catalogs/TEMPLATE.md b/codex/skills/workspace-steward/references/project-template/local-docs/catalogs/TEMPLATE.md
new file mode 100644
index 00000000..fa0da24d
--- /dev/null
+++ b/codex/skills/workspace-steward/references/project-template/local-docs/catalogs/TEMPLATE.md
@@ -0,0 +1,28 @@
+# Work Catalog
+
+Goal: <goal-id> revision <n>
+Control author: <principal>
+Updated at: <ISO 8601 timestamp with timezone>
+Last verified at: <ISO 8601 timestamp with timezone>
+Applies to commit or runtime identity: <locator>
+
+## Current State
+
+<Compact current facts.>
+
+## Remaining Gap
+
+- <unmet assertion or decision>
+
+## Active Work
+
+| ID | Role | Assignment | Worker or process | Worktree or artifact root | State | Return channel | Last evidence |
+| --- | --- | --- | --- | --- | --- | --- | --- |
+
+## Current Decisions
+
+- <decision and owner, or none>
+
+## Next Proof
+
+<Smallest action that can reduce the remaining gap.>
diff --git a/codex/skills/workspace-steward/references/project-template/local-docs/checkpoints/README.md b/codex/skills/workspace-steward/references/project-template/local-docs/checkpoints/README.md
new file mode 100644
index 00000000..bbcbcce2
--- /dev/null
+++ b/codex/skills/workspace-steward/references/project-template/local-docs/checkpoints/README.md
@@ -0,0 +1,11 @@
+# checkpoints
+
+Write a checkpoint before compaction, restart, interruption, or principal-context
+replacement.
+
+A checkpoint names the goal revision, current phase, authoritative inputs,
+observed state, evidence locators, active assignments, still-unmet conditions,
+next principal judgment, and exact re-anchor action.
+
+A fresh context must verify current repository and runtime state rather than
+trusting the checkpoint blindly.
diff --git a/codex/skills/workspace-steward/references/project-template/local-docs/checkpoints/TEMPLATE.md b/codex/skills/workspace-steward/references/project-template/local-docs/checkpoints/TEMPLATE.md
new file mode 100644
index 00000000..f65495ab
--- /dev/null
+++ b/codex/skills/workspace-steward/references/project-template/local-docs/checkpoints/TEMPLATE.md
@@ -0,0 +1,42 @@
+# Checkpoint
+
+Goal: <goal-id> revision <n>
+Principal role: <identity>
+Written at: <ISO 8601 timestamp with timezone>
+Last verified at: <ISO 8601 timestamp with timezone>
+Reason: compaction | restart | handoff | pause | milestone
+
+## Reopen First
+
+1. <goal path>
+2. <authoritative anchor>
+3. <catalog path>
+4. <current repository or runtime locator>
+
+## Observed State
+
+<Current facts.>
+
+## Accepted Evidence
+
+- <assertion>: <locator and observation>
+
+## Remaining Gap
+
+- <unmet assertion, decision, or proof>
+
+## Active Work
+
+- <worker, process, worktree, assignment, state, and return channel>
+
+## Risks And Decisions
+
+- <material item or none>
+
+## Next Proof-Producing Action
+
+<One concrete next action.>
+
+## Successor Verification
+
+- <state that may have changed and must be rechecked>
diff --git a/codex/skills/workspace-steward/references/project-template/local-docs/decisions/README.md b/codex/skills/workspace-steward/references/project-template/local-docs/decisions/README.md
new file mode 100644
index 00000000..0ab887ae
--- /dev/null
+++ b/codex/skills/workspace-steward/references/project-template/local-docs/decisions/README.md
@@ -0,0 +1,8 @@
+# decisions
+
+Record choices that materially change outcome, scope, interface, authority,
+risk, or lifecycle. Include the question, options considered, decision, owner,
+evidence, timestamp, and affected goal or plan revision.
+
+Routine implementation choices stay with the assigned worker and do not need a
+permanent decision record.
diff --git a/codex/skills/workspace-steward/references/project-template/local-docs/decisions/TEMPLATE.md b/codex/skills/workspace-steward/references/project-template/local-docs/decisions/TEMPLATE.md
new file mode 100644
index 00000000..2cea7767
--- /dev/null
+++ b/codex/skills/workspace-steward/references/project-template/local-docs/decisions/TEMPLATE.md
@@ -0,0 +1,28 @@
+# Decision: <name>
+
+Decision ID: <stable-id>
+Prepared at: <ISO 8601 timestamp with timezone>
+Decided at: <ISO 8601 timestamp with timezone or pending>
+Owner: <authority>
+Affected goal or plan: <locator>
+
+## Question
+
+<Exact material choice.>
+
+## Options
+
+1. <option and consequence>
+2. <option and consequence>
+
+## Evidence
+
+- <locator or observation>
+
+## Recommendation
+
+<Recommended option and reason.>
+
+## Decision
+
+<pending or selected option>
diff --git a/codex/skills/workspace-steward/references/project-template/local-docs/goals/README.md b/codex/skills/workspace-steward/references/project-template/local-docs/goals/README.md
new file mode 100644
index 00000000..5a6ce502
--- /dev/null
+++ b/codex/skills/workspace-steward/references/project-template/local-docs/goals/README.md
@@ -0,0 +1,8 @@
+# goals
+
+Each goal states a stable finished condition, required assertions, pass evidence,
+constraints, exclusions, and amendment authority.
+
+The goal remains stable while routes, owners, workers, and next actions change.
+Current state belongs in a catalog or checkpoint. Record an authorized amendment
+as a new revision with timestamp, owner, and reason.
diff --git a/codex/skills/workspace-steward/references/project-template/local-docs/goals/TEMPLATE.md b/codex/skills/workspace-steward/references/project-template/local-docs/goals/TEMPLATE.md
new file mode 100644
index 00000000..fe9f6fa7
--- /dev/null
+++ b/codex/skills/workspace-steward/references/project-template/local-docs/goals/TEMPLATE.md
@@ -0,0 +1,39 @@
+# Goal: <name>
+
+Goal ID: <stable-id>
+Revision: 1
+Created at: <ISO 8601 timestamp with timezone>
+Principal: <logical principal>
+Amendment authority: <identity>
+
+## Finished State
+
+<Observable achieved condition.>
+
+## Required Assertions
+
+- A1: <observable assertion>
+  - Pass evidence: <exact surface>
+
+## Constraints
+
+- <scope, safety, compatibility, budget, or authority limit>
+
+## Exclusions
+
+- <deliberately excluded work>
+
+## Authoritative Anchors
+
+1. <user-approved brief, PRD, issue, or contract>
+2. <repository or runtime source of truth>
+
+## Implementation Authority
+
+Phase: planning | implementation
+Production edits authorized by: <identity or none>
+Public mutations authorized: <exact action or none>
+
+## Live State
+
+See the current catalog and checkpoint.
diff --git a/codex/skills/workspace-steward/references/project-template/local-docs/plans/README.md b/codex/skills/workspace-steward/references/project-template/local-docs/plans/README.md
new file mode 100644
index 00000000..befcae38
--- /dev/null
+++ b/codex/skills/workspace-steward/references/project-template/local-docs/plans/README.md
@@ -0,0 +1,9 @@
+# plans
+
+Plans are principal-authored current routes. Record goal anchor, observed state,
+decisions, ordered dependencies where real, verification, risks, and explicit
+implementation authority.
+
+A planning document may authorize research, questions, and scoped experiments
+while withholding production edits. Implementation begins only after the named
+authority grants that phase.
diff --git a/codex/skills/workspace-steward/references/project-template/local-docs/plans/TEMPLATE.md b/codex/skills/workspace-steward/references/project-template/local-docs/plans/TEMPLATE.md
new file mode 100644
index 00000000..9d461c27
--- /dev/null
+++ b/codex/skills/workspace-steward/references/project-template/local-docs/plans/TEMPLATE.md
@@ -0,0 +1,45 @@
+# Plan: <name>
+
+Created at: <ISO 8601 timestamp with timezone>
+Last verified at: <ISO 8601 timestamp with timezone>
+Principal: <logical principal>
+Status: draft | reviewed | approved | superseded | complete
+Implementation authority: withheld | granted
+Authority source: <locator or none>
+
+## Goal Anchor
+
+- Goal and revision:
+- Authoritative sources, in precedence order:
+
+## Observed State
+
+- <fact with evidence locator>
+
+## Decisions
+
+- <decision, owner, and reason>
+
+## Route
+
+<Smallest coherent route. Use numbered steps only when order is real.>
+
+## Assignments
+
+- <assignment locator or none>
+
+## Verification
+
+- <evidence that closes the goal assertions>
+
+## Risks And Recovery
+
+- <risk, preservation boundary, and smallest reversible recovery action>
+
+## Open Decisions
+
+- <material decision, options, recommendation, and owner>
+
+## Next Principal Action
+
+<Next judgment-bearing action.>
diff --git a/codex/skills/workspace-steward/references/project-template/tmp/README.md b/codex/skills/workspace-steward/references/project-template/tmp/README.md
index 4d57a899..3d744355 100644
--- a/codex/skills/workspace-steward/references/project-template/tmp/README.md
+++ b/codex/skills/workspace-steward/references/project-template/tmp/README.md
@@ -1,14 +1,14 @@
 # tmp
 
-Scratch files that can be recreated or deleted without loss. The root
-`.gitignore` ignores `/tmp/*` but keeps this README, so scratch contents are
-not tracked while the directory convention survives a clone.
-
-Do not let `tmp/` become a hidden source of truth. Promote useful scratch to the
-right durable surface:
-
-- reproducible evidence or reports: `../artifacts/`;
-- reusable tooling: `../scripts/` (add it when a tool is reused);
-- project or workspace docs: `../docs/`;
-- controller notes or handoffs: `../local-docs/`;
-- branch-bound code changes: a child repo branch or PR worktree.
+Recreatable scratch that can be deleted without loss. The root `.gitignore`
+keeps this README and ignores the remaining contents.
+
+Promote useful results deliberately:
+
+- evidence or reports to `../artifacts/`;
+- durable project truth to `../docs/`;
+- current principal control state to `../local-docs/`;
+- reusable tooling to an explicitly justified scripts surface;
+- production code to a child-repository PR worktree.
+
+`tmp/` never becomes an unindexed source of truth.
diff --git a/codex/skills/workspace-steward/references/project-template/worktrees/README.md b/codex/skills/workspace-steward/references/project-template/worktrees/README.md
index 437aeed8..e578f68b 100644
--- a/codex/skills/workspace-steward/references/project-template/worktrees/README.md
+++ b/codex/skills/workspace-steward/references/project-template/worktrees/README.md
@@ -1,14 +1,14 @@
 # worktrees
 
-Branch and PR work for the child repos, kept out of the clean main checkouts.
+Real child-repository checkouts attached to branches.
 
-- `prs/<slug>/` - worktrees for branches or PRs that are meant to be pushed.
-- Create them from the child repo's `origin/main`, not a dirty local main.
-- Exploratory or local-only work does not belong here; use `../experiments/`,
-  `../artifacts/`, or `../local-docs/` instead.
+- `prs/<slug>/`: production-bound work intended for review and possible merge.
+- `spikes/<slug>/`: disposable integration questions against the real project.
 
-The contents of `prs/` are gitignored in the root repo because each entry is a
-git worktree linked to its child repo, not files this root should track.
+Create each worktree from the intended current remote base after fetching and
+checking the clean-main checkout. Keep one coherent scope per branch. Preserve
+useful dirty work before rebase, move, or removal.
 
-Move worktrees with `git worktree move`, and remove them with `git worktree
-remove` only after merge, preservation, or explicit disposable evidence.
+A spike remains disposable. Reimplement accepted findings in a fresh PR
+worktree. Move registered worktrees with `git worktree move` and remove them with
+`git worktree remove` only after merge, preservation, or explicit disposal.
diff --git a/codex/skills/workspace-steward/references/project-template/worktrees/prs/.gitkeep b/codex/skills/workspace-steward/references/project-template/worktrees/prs/.gitkeep
deleted file mode 100644
index 0a7d7be3..00000000
--- a/codex/skills/workspace-steward/references/project-template/worktrees/prs/.gitkeep
+++ /dev/null
@@ -1 +0,0 @@
-# PR worktrees land here, one folder per branch: worktrees/prs/<slug>/.
diff --git a/codex/skills/workspace-steward/references/project-template/worktrees/prs/README.md b/codex/skills/workspace-steward/references/project-template/worktrees/prs/README.md
new file mode 100644
index 00000000..2cba23cf
--- /dev/null
+++ b/codex/skills/workspace-steward/references/project-template/worktrees/prs/README.md
@@ -0,0 +1,23 @@
+# PR Worktrees
+
+Use this area for real repository changes intended for review and possible merge.
+Each worktree has one branch, one coherent purpose, one editing owner, and a
+clear base.
+
+Before creating a worktree:
+
+- fetch the remote through the clean-main checkout;
+- identify the project-declared default or target base;
+- confirm the branch name and destination are unused;
+- record the assignment, scope, evidence target, and public mutation authority.
+
+Create from current remote state, usually:
+
+```sh
+git -C <repo>-main worktree add -b <branch> <workspace>/worktrees/prs/<slug> origin/main
+```
+
+Keep experiments, integration spikes, private control documents, and unrelated
+user changes outside the PR branch. Preserve useful dirty work before rebase,
+move, or removal. Remove the worktree through Git after merge, preservation, or
+an explicit decision that the branch is disposable.
diff --git a/codex/skills/workspace-steward/references/project-template/worktrees/spikes/README.md b/codex/skills/workspace-steward/references/project-template/worktrees/spikes/README.md
new file mode 100644
index 00000000..237ca6b9
--- /dev/null
+++ b/codex/skills/workspace-steward/references/project-template/worktrees/spikes/README.md
@@ -0,0 +1,11 @@
+# integration spikes
+
+Use this area when a disposable question genuinely requires the real repository,
+build, integration boundary, or performance profile.
+
+A spike worktree is not production-bound. Name the question, base commit,
+allowed scope, evidence, and deletion condition before editing. Keep the change
+small enough that the mechanism remains visible.
+
+Preserve the finding, then reimplement any accepted behavior in a fresh PR
+worktree. Do not silently retarget the spike branch into production work.
diff --git a/codex/skills/write-a-compass-skill/SKILL.md b/codex/skills/write-a-compass-skill/SKILL.md
new file mode 100644
index 00000000..4464f53a
--- /dev/null
+++ b/codex/skills/write-a-compass-skill/SKILL.md
@@ -0,0 +1,81 @@
+---
+name: write-a-compass-skill
+description: Add, revise, route, install, validate, or retire a skill inside the Compass reviewed source.
+---
+
+# Write A Compass Skill
+
+Maintain a Compass skill as both runtime guidance and reviewed portable source.
+This overlay exists because good skill prose is not enough when install maps,
+Claude derivation, provenance, retirement, policy contracts, and tests can drift.
+
+Use `write-a-skill` for the skill's role and language. This skill owns Compass
+routing and repository integration.
+
+Read root `AGENTS.md`, `workflows/addition-intake.md`, and the workflow nearest
+the change before editing.
+
+## Choose The Compass Surface
+
+- reusable global capability: `codex/skills/`;
+- portable opt-in domain pack: `carried/`;
+- project-specific capability: the target repository;
+- skeptical or independent persona: `codex/agents/`;
+- deterministic mechanic: `scripts/`, hooks, manifests, or tests;
+- Compass maintenance process: `workflows/`;
+- repo-only learning: `local-docs/`.
+
+A global addition needs repeated cross-project value or a distinct new behavior
+that repays its retrieval and maintenance cost.
+
+## Integrate One Reviewed Source
+
+A global skill update lands together across every owning surface:
+
+1. `codex/skills/<name>/`;
+2. `[agents].skills` in `manifests/portable-files.toml`;
+3. `[claude].derived_skills` when the runtime-neutral skill belongs in Claude;
+4. `manifests/skill-sources.json`;
+5. policy contracts or required-file checks that bind its behavior;
+6. MCP catalog fixtures and other tests that depend on the installed set.
+
+Claude derives shared skills from Codex source. Maintain `codex/AGENTS.md` and
+`claude/CLAUDE.md` separately because their global runtime context differs.
+
+A carried pack stays out of global install lists and documents its adoption
+route. A project skill stays with the project.
+
+## Preserve Provenance
+
+An externally adapted skill records reviewed repository, source path, commit or
+immutable ref, license, and deterministic source hash. Keep provenance in a
+reference that normal runtime work does not load.
+
+## Retire Completely
+
+A retirement removes the global source catalog and install entries, preserves
+useful material in its approved narrower destination, and adds explicit retired
+live paths for every location Compass previously owned.
+
+A rename is a retirement plus a new skill. It must clean old Codex, user-skill,
+and Claude copies without deleting unrelated personal skills.
+
+## Validate Behavior And Wiring
+
+Run the skill authoring review from `write-a-skill`, then validate Compass:
+
+```powershell
+.\scripts\doctor.ps1
+.\scripts\verify-live.ps1 -SkipCodexCommand
+git diff --check origin/main...HEAD
+```
+
+Run added scripts and tests directly. Exercise install and retirement paths when
+ownership changes. Forward-test judgment with a fresh realistic invocation.
+
+Before review, inspect duplicate skills, stale triggers, missing references,
+forgotten manifests, Claude divergence, retired paths, policy strings, MCP
+catalog expectations, and mechanics that belong in scripts.
+
+Use a focused PR as the review unit. A green build is evidence; current-head
+review and named authority determine readiness and merge.
diff --git a/codex/skills/write-a-compass-skill/agents/openai.yaml b/codex/skills/write-a-compass-skill/agents/openai.yaml
new file mode 100644
index 00000000..cdf3f294
--- /dev/null
+++ b/codex/skills/write-a-compass-skill/agents/openai.yaml
@@ -0,0 +1,7 @@
+interface:
+  display_name: "Write A Compass Skill"
+  short_description: "Maintain Compass skill source and install wiring"
+  default_prompt: "Use $write-a-compass-skill to create, revise, route, validate, or retire this Compass skill across source, manifests, Claude derivation, policy, and tests."
+
+policy:
+  allow_implicit_invocation: false
diff --git a/codex/skills/write-a-skill/SKILL.md b/codex/skills/write-a-skill/SKILL.md
index f37f1472..c89ae823 100644
--- a/codex/skills/write-a-skill/SKILL.md
+++ b/codex/skills/write-a-skill/SKILL.md
@@ -1,32 +1,54 @@
 ---
 name: write-a-skill
-description: Create or revise a Compass skill and its install wiring. Invoke manually for skill work.
+description: Create or revise a reusable agent skill that strongly orients judgment, stays lean, and proves its behavior.
 ---
 
 # Write A Skill
 
-Use the system Skill Creator for general skill design when it is available. This
-skill is the Compass overlay for routing, source layout, install wiring,
-retirement, and repository review boundaries. Read the repo-root `AGENTS.md` and
-`workflows/addition-intake.md` before editing.
+Create a direction vector strong enough to change how a capable model judges new
+cases. This skill exists because weak skills become trigger phrases plus
+checklists, while bloated skills compete for context and still fail to establish
+the role.
 
-## Choose The Right Surface
+The terminal result is a lean reusable skill whose purpose, trigger, stance,
+evidence, and authority are clear before its procedure.
 
-- reusable global agent capability: `codex/skills/`;
-- carried but not global pack: `carried/`;
-- project-specific capability: the target repository's skill folder;
-- skeptical or independent reviewer persona: `codex/agents/`;
-- deterministic or fragile mechanic: `scripts/`;
-- repo-maintainer process: `workflows/`;
-- portability boundary: `manifests/`;
-- repo-only lesson: `local-docs/`.
+## Establish The Role
 
-Do not promote a project-specific pack into global context without repeated
-cross-repository evidence.
+Front-load what the invoking agent must absorb:
 
-## Author The Skill
+- role;
+- desired terminal result;
+- why the role exists at runtime;
+- recurring failure it corrects;
+- evidence that matters;
+- authority boundary.
 
-A normal skill contains:
+Give only enough explanation of purpose to orient action. Preserve discovery
+history, model anecdotes, and maintenance rationale outside the installed skill.
+
+## Point Positively
+
+Lead with the behavior and state to create. Use prohibitions for crisp,
+observable boundaries and recurring failure shapes with an unambiguous forbidden
+form. Pair a prohibition with the desired replacement when judgment is involved.
+
+Write decisively. Remove hedging, filler politeness, apology, and optional
+language around required behavior.
+
+## Teach Judgment Before Procedure
+
+Use principles, boundaries, and compact examples for decisions that vary by
+context. Use ordered steps when sequence is real, mechanics are fragile, or a
+handoff contract must remain exact.
+
+A skill should help the model handle cases the author did not enumerate. A long
+branching flowchart usually means the skill has not yet expressed the underlying
+judgment.
+
+## Keep The Runtime Surface Lean
+
+A normal skill may contain:
 
 ```text
 skill-name/
@@ -34,50 +56,51 @@ skill-name/
   references/
   scripts/
   assets/
+  agents/openai.yaml
 ```
 
-Use only needed folders. Frontmatter contains `name` and `description`. The
-description states capability and trigger in no more than 160 characters.
+Use only needed folders.
 
-Front-load role, non-negotiables, failure mode, and next decision. Keep
-`SKILL.md` lean. Put detailed reference material one level under `references/`,
-deterministic mechanics under `scripts/`, and output resources under `assets/`.
+- `SKILL.md` carries the role and action-critical guidance.
+- `references/` carries detail loaded only when needed.
+- `scripts/` carries deterministic or fragile mechanics.
+- `assets/` carries output resources.
+- `agents/openai.yaml` carries Codex discovery metadata when that runtime uses
+  it.
 
-Do not add auxiliary README, changelog, quick-reference, or installation files
-inside an installed skill.
+Frontmatter contains a kebab-case `name` and a concise capability plus trigger
+description. Avoid auxiliary installation notes, changelogs, and duplicate quick
+references inside an installed skill.
 
-## Install Wiring
+## Separate Scope Correctly
 
-For a global skill, update together:
+Choose the narrowest durable surface:
 
-1. `codex/skills/<name>/`;
-2. `[agents].skills` in `manifests/portable-files.toml`;
-3. `[claude].derived_skills` when Claude should derive it;
-4. `manifests/skill-sources.json`;
-5. policy or required-file checks that bind to the skill.
+- reusable cross-project judgment: global skill;
+- project-specific capability: project skill;
+- reviewer persona: agent;
+- repeated human maintenance process: workflow;
+- deterministic guard: script, hook, manifest, or test;
+- portable but opt-in domain pack: carried resource.
 
-For a carried pack, create the real `carried/` path, keep it out of installed
-skill lists, and document the opt-in route. For a project-local skill, edit the
-target repository instead.
+A useful one-off does not automatically earn global retrieval cost.
 
-For a retirement, remove installed and derived manifest entries, remove the
-source catalog record, and add explicit retired paths for every live location
-Compass previously owned. Preserve useful project-specific material in its
-authorized destination or a documented carried route before removing the global
-copy.
+## Prove The Skill
 
-## Validate
+Review the skill as behavior, not prose alone:
 
-Run:
+- Can the right trigger be distinguished from neighboring skills?
+- Does the first screen establish role, result, failure, evidence, and boundary?
+- Does the language point toward the desired state?
+- Can detailed material move to a reference or mechanic?
+- Does any rule make a decision that should remain contextual?
+- Does a fresh agent behave differently on a realistic task?
+- Can the skill be shortened without losing behavior?
 
-```powershell
-.\scripts\doctor.ps1
-git diff --check origin/main...HEAD
-```
+Forward-test fragile judgment with realistic prompts and inspect failure cases.
+Revise the cause of weak behavior rather than adding another isolated warning.
+
+## Output
 
-Run `.\scripts\verify-live.ps1 -SkipCodexCommand` when install or retirement
-drift matters. Run added scripts and tests directly. Forward-test fragile
-judgment with a fresh agent and realistic task. Before review, check for
-duplicated skills, stale triggers, missing references, forgotten manifests, and
-mechanics that should move to scripts. Keep a focused PR draft until current-head
-review and required checks are complete.
+Return the authored skill, resources, trigger rationale, behavior evidence,
+known boundaries, and the durable surface that owns its installation.
diff --git a/codex/skills/write-a-skill/agents/openai.yaml b/codex/skills/write-a-skill/agents/openai.yaml
index 11fb8ca0..6813244a 100644
--- a/codex/skills/write-a-skill/agents/openai.yaml
+++ b/codex/skills/write-a-skill/agents/openai.yaml
@@ -1,7 +1,7 @@
 interface:
   display_name: "Write A Skill"
-  short_description: "Maintain Compass skills"
-  default_prompt: "Use $write-a-skill to create or revise a Compass skill and its install wiring."
+  short_description: "Write strong lean reusable agent skills"
+  default_prompt: "Use $write-a-skill to create or revise a reusable skill that establishes a strong role, desired result, evidence standard, and authority boundary before procedure."
 
 policy:
   allow_implicit_invocation: false
diff --git a/glossary.md b/glossary.md
new file mode 100644
index 00000000..0dd3a442
--- /dev/null
+++ b/glossary.md
@@ -0,0 +1,148 @@
+# Compass Glossary
+
+These terms exist because confusing them changes behavior. Keep the vocabulary
+small and use each term consistently.
+
+## Principal
+
+The user-facing logical owner of an objective. The underlying model context may
+change after compaction or restart, but the principal role resumes the same
+intention from durable control documents.
+
+Confusing the principal with every temporary worker distributes authorship and
+lets the objective drift.
+
+## Context
+
+One finite model working state, including instructions, conversation, reads,
+and tool results currently available to it.
+
+A context is temporary. The objective must survive without it.
+
+## Compaction
+
+A continuity event that reduces or replaces accumulated context. Treat it as a
+lossy handoff and recover from authoritative anchors plus a current checkpoint.
+
+## Anchor
+
+An authoritative source for meaning or truth, such as a user-approved brief,
+PRD, issue, contract, repository file, current branch, or observable runtime
+surface.
+
+A summary may point to an anchor. It does not silently replace one.
+
+## Goal
+
+The stable achieved state, required evidence, constraints, exclusions, and
+amendment authority for a long-running objective.
+
+A goal says what finished means. It does not narrate current progress.
+
+## Plan
+
+The current intended route from observed state to the goal. A plan may change as
+evidence changes while the goal remains stable.
+
+## Control Document
+
+A principal-authored document that preserves goal, plan, assignments, current
+state, or checkpoints across contexts.
+
+Delegates return evidence for these documents. They do not invent parallel
+control documents.
+
+## Catalog
+
+A compact index of active workstreams, workers, branches, worktrees, monitors,
+artifacts, and their authoritative locations.
+
+A catalog locates state. It does not duplicate every state entry.
+
+## Ledger
+
+A compact current record of assertions, evidence, decisions, and remaining
+work. Replace mutable state instead of appending a diary.
+
+## Checkpoint
+
+A principal-authored resume packet written before compaction, interruption, or
+handoff. It names the goal revision, anchors, observed state, accepted evidence,
+remaining gap, active work, and next decision.
+
+## Assignment
+
+A reviewed delegation packet with a bounded outcome, relevant anchors, allowed
+actions, evidence target, and return channel.
+
+An assignment advances the goal. It does not amend the goal.
+
+## Worker
+
+A delegate that owns one assigned artifact, investigation, review, or monitored
+workstream until its return condition is satisfied.
+
+## Controller
+
+The principal role above delegated execution. It authors control state,
+prepares assignments, reconciles evidence, corrects routes, and judges parent
+completion.
+
+## Return Channel
+
+The stable locator a delegate uses to return evidence or request a material
+decision. It may be a thread ID, parent agent handle, message channel, or named
+control location supported by the runtime.
+
+## Evidence
+
+A current observation or durable artifact that supports or falsifies a claim.
+Examples include a commit SHA, command result, review, screenshot, benchmark row
+set, runtime query, or persisted file.
+
+A worker's confidence is a claim, not evidence.
+
+## Mechanical Wait
+
+One bounded command that waits for a stable observable condition and returns a
+compact terminal result.
+
+Repeated model turns are not a mechanical wait.
+
+## Monitor
+
+A narrow observer for a named workstream or condition. A monitor reports state
+and escalates anomalies. It does not own the parent objective.
+
+## Worktree
+
+A real repository checkout attached to a branch. Work in a PR worktree may enter
+production through review and merge.
+
+## Micro-Experiment
+
+A tiny disposable program that answers one technical uncertainty outside the
+production implementation. The finding may graduate. The experimental code does
+not.
+
+## Integration Spike
+
+Disposable investigation against the real repository when the uncertainty
+cannot be tested in isolation. It belongs in a clearly labeled disposable
+worktree, not in the micro-experiment directory.
+
+## Artifact
+
+A generated output retained as evidence or as a deliverable, such as a report,
+export, manifest, benchmark result, screenshot, or archive.
+
+## Amendment
+
+An authorized change to the stable goal or its required assertions. Route
+changes and implementation discoveries are not amendments by themselves.
+
+## Completion
+
+The state in which current evidence satisfies every required part of the goal,
+or the authorized owner explicitly amends the goal to accept a different end
+state.
diff --git a/local-docs/2026-07-17-compass-revision.md b/local-docs/2026-07-17-compass-revision.md
new file mode 100644
index 00000000..f60e4ade
--- /dev/null
+++ b/local-docs/2026-07-17-compass-revision.md
@@ -0,0 +1,137 @@
+# Compass Revision, 2026-07-17
+
+This revision turns the July 2026 skill review and design discussion into one
+coherent Compass source tree. It preserves the capabilities that proved useful,
+reduces repeated control doctrine, separates runtime-specific truth, and makes
+long-running work resumable without treating conversation history as authority.
+
+## Governing Decisions
+
+- One logical user-facing principal owns the objective across finite contexts.
+- The user or principal authors goals, plans, catalogs, assignments,
+  checkpoints, and ledger structure.
+- Delegates execute reviewed assignments and return artifacts plus evidence.
+  They do not create parallel control state.
+- Compaction, restart, and principal replacement are lossy handoffs. A fresh
+  context reopens named anchors and verifies current state before continuing.
+- Guidance leads with the desired role, state, and evidence. Prohibitions remain
+  for crisp boundaries and unmistakable recurring failure shapes.
+- Skills shape judgment before procedure. Exact steps protect fragile mechanics,
+  authority boundaries, and handoff contracts.
+- Planning-only authority permits inspection, research, planning, and scoped
+  experiments. Production implementation begins after the named authority opens
+  that phase.
+
+## Runtime Sources And Routing
+
+- `codex/AGENTS.md` and `claude/CLAUDE.md` are separately authored global
+  sources.
+- Codex uses Sol for the user-facing principal and Luna for fresh delegated work.
+  Terra has no default role in the current coding profile.
+- Claude Code treats GLM-5.2 as the only available delegated model identity in
+  the current installation.
+- `apps/compass-mcp/profile.md` gives the ChatGPT MCP surface its own
+  runtime-neutral profile instead of importing Codex-specific routing.
+- A new `progress-monitor` agent handles narrow judgment-based observation.
+  `monitor-to-completion` remains the route for pure waiting.
+
+## Skill Set Changes
+
+Added globally:
+
+- `run-a-micro-experiment`;
+- `using-goals`;
+- `write-a-compass-skill`;
+- a general, runtime-oriented `write-a-skill`.
+
+Moved out of global installation:
+
+- `benchmark-run-operator` now lives in `carried/benchmark/` with its specialist
+  reviewer sources.
+
+Retired from global installation:
+
+- `input-token-economy`; its useful behavior now lives in context architecture,
+  monitoring, assignment, and continuity guidance.
+- `using-codex-goals`; replaced by runtime-neutral `using-goals`.
+
+Reshaped:
+
+- `grill-me` maps and ranks the full question space before asking one question at
+  a time.
+- `orchestration-controller` owns principal control, reviewed assignments,
+  evidence reconciliation, and drift correction.
+- `subagent-driven-development` owns bounded implementation delegation under an
+  already approved plan.
+- `root-cause-not-symptom` supports multiple interacting causes and requires a
+  subtractive review after repair.
+- `action-items-to-prs` owns source-ledger creation and PR grouping rather than
+  duplicating the full review loop.
+- `behavior-validator` has a stronger source-blind workspace boundary and report
+  contract.
+- `workspace-steward` distinguishes production worktrees, integration spikes,
+  disposable micro-experiments, control documents, evidence, scratch, and
+  archives.
+
+The frontend design skill, branch resolver, specialist review, PRD, update, and
+other proven focused skills remain present.
+
+## Durable Work Surfaces
+
+Added or expanded:
+
+- `glossary.md`;
+- `workflows/long-running-work.md`;
+- principal-authored goal, catalog, assignment, and checkpoint templates;
+- schema version 4 of the local orchestration ledger;
+- a richer copyable workspace with separate Codex and Claude guidance,
+  lifecycle READMEs, control-document templates, timestamps, micro-experiment
+  rules, PR worktrees, and integration spikes.
+
+The orchestration ledger is now a compact mechanical index. It links to reviewed
+Markdown control documents, records phase and current routing, stores
+principal-verified evidence with provenance and timestamps, and enforces one
+logical principal through optimistic revisions. Delegated edit grants were
+removed.
+
+## Isolation And Safety
+
+The behavior-validator packager now:
+
+- rejects source-control material, symlink traversal, sensitive names and path
+  segments, credential-like file types, and common secret content patterns;
+- scans the contract and fixtures;
+- normalizes fixture destinations without duplicate `fixtures/fixtures` paths;
+- writes both Codex and Claude local instruction files;
+- records exact allowed local paths and content hashes in schema version 2 of the
+  workspace manifest.
+
+The validator reports target identity, tested time, manifest hash, allowed-path
+verification, clause-level observations, anti-cheat probes, contamination, and
+remaining proof gaps.
+
+## Installation And Retirement
+
+The portable manifest, source catalog, installers, Claude derivation, doctor
+checks, MCP catalog, and install round-trip expectations were updated together.
+Explicit retirement paths remove prior global copies of:
+
+- `benchmark-run-operator`;
+- `input-token-economy`;
+- `using-codex-goals`;
+- `benchmark-infra-reviewer.md` from the Claude agent home.
+
+Carried benchmark resources remain in the repository for explicit project
+adoption.
+
+## Validation
+
+The final archive is validated through repository Python tests, direct manifest
+and policy validators, JSON and TOML parsing, Markdown-link inspection, text and
+line-ending checks, Python compilation, MCP TypeScript build, local MCP smoke,
+Cloudflare Worker catalog generation and smoke, Git diff checks, archive content
+inspection, and a clean extraction test.
+
+PowerShell is not installed in the packaging environment. The Windows doctor and
+install round-trip scripts were updated and are wired into GitHub Actions, but
+they could not be executed locally while producing this archive.
diff --git a/local-docs/README.md b/local-docs/README.md
index 4def9015..fdd7bc3c 100644
--- a/local-docs/README.md
+++ b/local-docs/README.md
@@ -1,29 +1,36 @@
 # Local Docs
 
-These docs are for maintaining this repository. They are not installed into a
-live Codex home or user skill home and are not part of the portable allowlist.
-
-Use them when changing this repo so updates preserve the current design:
-portable config stays small, workflow detail lives in focused files, and checks
-catch drift before config is copied into a live machine.
+These files preserve Compass maintenance reasoning. They are not installed into
+Codex, user-skill, or Claude runtime homes.
 
 ## Files
 
-- [maintenance-learnings.md](maintenance-learnings.md): local principles for
-  making useful changes to Compass without bloating the portable setup.
-- [benchmark-run-evidence.md](benchmark-run-evidence.md):
-  compact evidence behind the promoted benchmark and goal guidance, kept out of
-  installed runtime behavior.
-- [../workflows/addition-intake.md](../workflows/addition-intake.md): promotion
-  flow for new repo-maintenance workflows, installed skills and agents,
-  repo-side scripts and manifests, and config fragments. Workflows guide repo
-  maintenance and are not installed into a live Codex home or user skill home.
+- [2026-07-17-compass-revision.md](2026-07-17-compass-revision.md): the
+  reviewed architecture, routing, skill-set, continuity, isolation, and install
+  changes in this revision.
+- [maintenance-learnings.md](maintenance-learnings.md): durable lessons for
+  changing Compass without bloating runtime context.
+- [context-economy.md](context-economy.md): why durable anchors, compact
+  handoffs, targeted reads, bounded waits, and fresh workers replace a callable
+  token-economy reminder.
+- [model-calibration.md](model-calibration.md): dated current Sol, Luna, Terra,
+  GLM-5.2, and effort-routing observations.
+- [benchmark-run-evidence.md](benchmark-run-evidence.md): evidence behind the
+  carried benchmark operations pack and long-running recovery doctrine.
+- [../glossary.md](../glossary.md): shared terms whose distinctions change
+  behavior.
+- [../workflows/long-running-work.md](../workflows/long-running-work.md):
+  principal-authored continuity protocol.
 - [../workflows/compass-review-program.md](../workflows/compass-review-program.md):
-  audit method for reviewing installed skills, agents, and maintainer guidance
-  for audience fit, pruning, rerouting, and global-install eligibility.
+  audit method for installed and maintainer surfaces.
 
 ## Boundary
 
-Local docs may describe practices, tradeoffs, and repo maintenance habits. They
-should not contain secrets, machine-specific runtime paths, generated plugin
-state, or instructions that must apply to every Codex session.
+Local docs may contain dates, tradeoffs, model observations, failure history,
+and maintainer rationale when those facts change future decisions. Keep secrets,
+machine-only runtime state, raw private logs, and action-critical global rules
+out of this directory.
+
+When a lesson should change future runtime behavior, compress the current rule
+into the narrowest `AGENTS.md`, `CLAUDE.md`, skill, agent, hook, script, or
+manifest. Leave the history here.
diff --git a/local-docs/benchmark-run-evidence.md b/local-docs/benchmark-run-evidence.md
index b162e35c..263fa18a 100644
--- a/local-docs/benchmark-run-evidence.md
+++ b/local-docs/benchmark-run-evidence.md
@@ -1,22 +1,28 @@
 # Benchmark Run Evidence
 
-This repo-local record explains the benchmark and goal guidance promoted from a
-reviewed run. Raw logs, artifacts, session state, auth, and machine paths stay
-local.
+Reviewed: 2026-07-17
 
-| Evidence | Durable response | Surface |
+This record preserves the evidence that shaped the carried benchmark pack and
+the shared long-running-work guidance. Raw logs, auth, result directories,
+session state, and machine paths remain local.
+
+| Evidence | Durable response | Current surface |
 | --- | --- | --- |
-| Full launches needed named arms, smoke gates, monitors, and stop conditions. | Require a launch contract and proof gates before expensive spend. | `benchmark-run-operator` |
-| Terminal artifacts could conceal missing tools, wrong routes, or other infrastructure poison. | Validate related logs and strict denominators before headline counts. | `artifact-validation.md` |
-| Timeout, poison, and forced-stop rows needed recovery or explicit exclusion. | Treat invalid rows as attributable recovery work, not presentation caveats. | `benchmark-run-operator` and `artifact-validation.md` |
-| Repair launches depended on working wrappers, upstream health, port validity, and ownership. | Reuse proven launch records and stop the smallest poisoned slice. | `stack-operations.md` |
-| Observed valid-row pace contradicted requested deadlines. | Report observed and required pace, then act on the rate gap. | `benchmark-run-operator` and `stack-operations.md` |
-| A user pause had to stop owned work and monitors without claiming completion. | Preserve resume state and keep pause distinct from completion or blockage. | `using-codex-goals` and `goal-contracts.md` |
-| A prep-only child amended and reconstructed a controller-owned control file from partial context. | Require one named writer, exact edit authority, revision checks, and preservation after a mismatch. | `orchestration-controller` and `benchmark-run-operator` |
-| A long-running goal kept producing work after compaction while control files became contradictory. | Require precedence-ordered inputs, one small live surface, explicit re-anchoring, and split controller and execution ownership. | `using-codex-goals`, `goal-contracts.md`, and `orchestration-controller` |
-| Recovery successors passed narrow gates but repeated an unchanged real child failure path. | Open recovery when no new discriminating evidence exists, and resume only after the hypothesis, inputs, runtime path, or root-cause evidence changes. | `benchmark-run-operator` and `orchestration-ledger` |
+| Full launches needed named arms, smoke gates, monitors, provenance, and stop conditions. | Establish a launch contract before expensive spend. | `carried/benchmark/skills/benchmark-run-operator` |
+| Terminal summaries could coexist with missing tools, wrong routes, stale runners, or infrastructure poison. | Validate related logs and attributable denominators before headline claims. | `artifact-validation.md` |
+| Timeout, poison, and forced-stop rows remained recovery work until controlled rerun, rescore, classification, or exclusion. | Preserve row provenance and prosecute gaps before presenting them as caveats. | benchmark operator and artifact validation |
+| Repair launches depended on proven wrappers, healthy upstreams, valid ports, and explicit process ownership. | Reuse attributable launch records and stop only the smallest poisoned slice. | `stack-operations.md` |
+| Observed valid-row pace contradicted requested deadlines. | Report observed pace, required pace, healthy capacity, and the bounded action that changes the gap. | benchmark operator and stack operations |
+| A user pause needed to stop owned work and monitors without claiming completion or blockage. | Preserve a resume packet and keep pause distinct from the goal state. | `using-goals` and long-running work |
+| A delegated child reconstructed a principal-owned control file from partial context. | Keep control documents principal-authored and accept delegated evidence through a reviewed return shape. | orchestration controller and ledger schema v4 |
+| Compaction preserved activity while the objective and current state became contradictory. | Reopen anchors, verify a current checkpoint, and resume one logical principal role. | `using-goals`, long-running work, orchestration controller |
+| Recovery successors repeated the same child path without new evidence. | Open recovery when another equivalent attempt would repeat motion without learning. | benchmark operator and orchestration ledger |
+
+The benchmark operator remains portable with Compass but no longer loads as a
+global skill. Its stack-specific references and reviewer live under
+`carried/benchmark/` so projects adopt the complete pack deliberately.
 
-The control-file overwrite and repeated recovery failures justified promoting
-writer, revision, delegated edit, and evidence-based recovery state into the
-local orchestration ledger. Route new evidence through
-`workflows/addition-intake.md` and `workflows/agent-failures.md`.
+The ledger no longer grants delegates write access. The principal records
+returned benchmark evidence with producer, observation time, verification, and
+locator metadata. Optimistic revision and recovery circuits protect the control
+surface without distributing authorship.
diff --git a/local-docs/context-economy.md b/local-docs/context-economy.md
new file mode 100644
index 00000000..f7a40bb2
--- /dev/null
+++ b/local-docs/context-economy.md
@@ -0,0 +1,36 @@
+# Context Economy
+
+Context economy is a property of the system, not a recurring burden placed on
+the worker.
+
+The retired `input-token-economy` skill correctly identified repeated full-file
+reads, log dumps, growing conversations, and model-turn polling as expensive.
+A callable reminder was the wrong durable surface. The economical route should
+be built into how Compass structures work.
+
+## System Shape
+
+- Read the smallest complete slice that answers the question.
+- Keep large logs outside model context and return compact diagnostics.
+- Use principal-authored anchors and checkpoints so completed conversation can
+  be released.
+- Start fresh, non-forked delegates for self-contained assignments.
+- Give each delegate only the anchors and evidence target it needs.
+- Put mechanical waits inside one bounded command.
+- Use a fresh narrow monitor when periodic observation needs limited judgment.
+- Archive completed workstreams instead of carrying their narrative forever.
+
+## Continuity Over Transcript
+
+A long transcript is not durable project state. It is expensive, hard to audit,
+and vulnerable to compaction loss.
+
+The stronger test is whether a fresh context can resume from the named goal,
+anchors, current ledger, and checkpoint. When it can, context can be replaced
+without losing the work's logic.
+
+## Reduction Standard
+
+Optimize maintained surface rather than visible answer length. Prefer fewer
+sources of truth, states, branches, wrappers, dependencies, and repeated reads
+when the same capability remains intact.
diff --git a/local-docs/model-calibration.md b/local-docs/model-calibration.md
new file mode 100644
index 00000000..6ef6c919
--- /dev/null
+++ b/local-docs/model-calibration.md
@@ -0,0 +1,97 @@
+# Model Calibration
+
+Observed and reviewed: 2026-07-17
+
+This file records the current Compass routing profile. It is dated because model
+capability, pricing, latency, and runtime support change quickly. Runtime files
+carry the compact active policy. This document preserves the reasoning behind
+it.
+
+## Reviewed Tier Defaults
+
+| Model | Default effort |
+| --- | --- |
+| GPT-5.6 Sol | `high` |
+| GPT-5.6 Terra | `xhigh` |
+| GPT-5.6 Luna | `high` |
+
+These defaults apply when no task or role supplies a deliberate override. A
+reviewed role may pin a different effort when its bounded contract justifies the
+added latency. One-off work should prefer an explicit runtime override rather
+than changing the shared tier default.
+
+## Codex Profile
+
+### GPT-5.6 Sol
+
+Use Sol for the user-facing principal, top-level orchestration, difficult
+integration, and work whose final synthesis benefits from the highest available
+capacity.
+
+The reviewed root default is Sol at high effort. A Sol child needs a concrete
+reason because Luna is the default delegated route.
+
+### GPT-5.6 Luna
+
+Use Luna for fresh delegated work. Luna provides the strongest current
+performance-to-cost fit for Compass coding subagents.
+
+- `high`: ordinary delegated implementation, exploration, review, and monitoring
+  that needs judgment.
+- `xhigh`: difficult bounded work, independent criticism, behavior validation,
+  or recovery where stronger persistence is worth the added latency.
+- `max`: long, proof-oriented work where latency is acceptable and the result
+  rewards extended exploration, checks, and revision.
+
+### GPT-5.6 Terra
+
+The current Compass coding profile has no default Terra route. Luna is preferred
+for cost-efficient delegated coding work, while Sol is preferred when frontier
+capacity is justified. When Terra is selected explicitly, its tier default is
+`xhigh`.
+
+Reconsider this decision when current evaluations show a distinct Terra role.
+Do not preserve the route merely because earlier files used it.
+
+### Effort
+
+Treat effort as a persistence and verification budget. Higher effort gives the
+model more room to explore alternatives, run checks, and revise its approach.
+It is not a guarantee of correctness, and not every task benefits equally.
+
+Use the lowest level that still produces the required evidence. Use `max` only
+when the work is latency-tolerant and the additional exploration can change the
+result.
+
+## Claude Code Profile
+
+This Compass installation routes Claude Code through GLM-5.2. That is the only
+model identity available to Claude delegates in the current setup.
+
+Claude guidance states this directly so the runtime does not invent Opus,
+Sonnet, Haiku, or other unavailable child tiers from generic Claude examples.
+The actual gateway configuration remains the mechanical source of truth.
+
+## Current Model Counterweights
+
+Observed GPT-5.6 strengths include strong continuation and willingness to carry
+work through ordinary friction.
+
+Current counterweights address the corresponding failure risks:
+
+- Establish planning authority before production implementation.
+- Reopen the causal model before adding another repair layer.
+- Prefer correction and subtraction over accumulating guards and wrappers.
+- Review for duplicated state, unnecessary abstractions, and broader edits than
+  the owning boundary requires.
+- Preserve the objective in principal-authored control documents before context
+  pressure forces a handoff.
+
+## Public Sources
+
+- [GPT-5.6 launch](https://openai.com/index/gpt-5-6/): current Sol, Terra, and
+  Luna positioning, pricing context, and the behavior of `max` effort.
+- [GPT-5 developer guidance](https://openai.com/index/introducing-gpt-5-for-developers/):
+  reasoning effort trades quality, time, and task-specific benefit.
+- [Claude Code memory](https://docs.anthropic.com/en/docs/claude-code/memory):
+  `CLAUDE.md` hierarchy and concise, specific project memory guidance.
diff --git a/manifests/orchestration-ledger.schema.json b/manifests/orchestration-ledger.schema.json
index 5012ea64..f7d50d1c 100644
--- a/manifests/orchestration-ledger.schema.json
+++ b/manifests/orchestration-ledger.schema.json
@@ -1,7 +1,8 @@
 {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://ariobarin.com/compass/orchestration-ledger.schema.json",
-  "title": "Compass orchestration ledger",
+  "title": "Compass principal-authored orchestration ledger",
+  "description": "A local mechanical index for principal-authored goals, control documents, verified evidence, and recovery gates.",
   "type": "object",
   "additionalProperties": false,
   "required": [
@@ -11,7 +12,7 @@
   ],
   "properties": {
     "schema_version": {
-      "const": 3
+      "const": 4
     },
     "updated_at": {
       "type": "string",
@@ -25,27 +26,48 @@
     }
   },
   "$defs": {
+    "nonemptyString": {
+      "type": "string",
+      "minLength": 1
+    },
+    "nullableNonemptyString": {
+      "type": [
+        "string",
+        "null"
+      ],
+      "minLength": 1
+    },
+    "stringList": {
+      "type": "array",
+      "uniqueItems": true,
+      "items": {
+        "$ref": "#/$defs/nonemptyString"
+      }
+    },
     "goal": {
       "type": "object",
       "additionalProperties": false,
       "required": [
         "id",
         "goal",
+        "anchors",
+        "control_documents",
+        "phase",
         "execution_owner",
         "worker_id",
         "state",
         "next_action",
         "next_check_at",
-        "completion_evidence",
+        "evidence",
         "public_mutation_gate",
         "public_mutation_action",
         "decision_needed",
         "control_writer",
         "control_revision",
-        "control_edit_grants",
         "recovery_circuits",
         "created_at",
-        "updated_at"
+        "updated_at",
+        "last_verified_at"
       ],
       "properties": {
         "id": {
@@ -53,19 +75,25 @@
           "pattern": "^[a-z0-9][a-z0-9._-]{0,63}$"
         },
         "goal": {
-          "type": "string",
-          "minLength": 1
+          "$ref": "#/$defs/nonemptyString"
+        },
+        "anchors": {
+          "$ref": "#/$defs/stringList"
+        },
+        "control_documents": {
+          "$ref": "#/$defs/stringList"
+        },
+        "phase": {
+          "enum": [
+            "planning",
+            "implementation"
+          ]
         },
         "execution_owner": {
-          "type": "string",
-          "minLength": 1
+          "$ref": "#/$defs/nonemptyString"
         },
         "worker_id": {
-          "type": [
-            "string",
-            "null"
-          ],
-          "minLength": 1
+          "$ref": "#/$defs/nullableNonemptyString"
         },
         "state": {
           "enum": [
@@ -78,11 +106,7 @@
           ]
         },
         "next_action": {
-          "type": [
-            "string",
-            "null"
-          ],
-          "minLength": 1
+          "$ref": "#/$defs/nullableNonemptyString"
         },
         "next_check_at": {
           "type": [
@@ -91,7 +115,7 @@
           ],
           "format": "date-time"
         },
-        "completion_evidence": {
+        "evidence": {
           "type": "array",
           "items": {
             "$ref": "#/$defs/evidence"
@@ -106,11 +130,7 @@
           ]
         },
         "public_mutation_action": {
-          "type": [
-            "string",
-            "null"
-          ],
-          "minLength": 1
+          "$ref": "#/$defs/nullableNonemptyString"
         },
         "decision_needed": {
           "oneOf": [
@@ -123,22 +143,14 @@
           ]
         },
         "control_writer": {
-          "type": "string",
-          "minLength": 1
+          "$ref": "#/$defs/nonemptyString"
         },
         "control_revision": {
           "type": "integer",
           "minimum": 1
         },
-        "control_edit_grants": {
-          "type": "array",
-          "items": {
-            "$ref": "#/$defs/controlEditGrant"
-          }
-        },
         "recovery_circuits": {
           "type": "array",
-          "uniqueItems": true,
           "items": {
             "$ref": "#/$defs/recoveryCircuit"
           }
@@ -150,8 +162,65 @@
         "updated_at": {
           "type": "string",
           "format": "date-time"
+        },
+        "last_verified_at": {
+          "type": "string",
+          "format": "date-time"
         }
-      }
+      },
+      "allOf": [
+        {
+          "if": {
+            "properties": {
+              "state": {
+                "const": "complete"
+              }
+            },
+            "required": [
+              "state"
+            ]
+          },
+          "then": {
+            "properties": {
+              "evidence": {
+                "minItems": 1
+              },
+              "next_action": {
+                "const": null
+              },
+              "decision_needed": {
+                "const": null
+              }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "public_mutation_gate": {
+                "const": "closed"
+              }
+            },
+            "required": [
+              "public_mutation_gate"
+            ]
+          },
+          "then": {
+            "properties": {
+              "public_mutation_action": {
+                "const": null
+              }
+            }
+          },
+          "else": {
+            "properties": {
+              "public_mutation_action": {
+                "$ref": "#/$defs/nonemptyString"
+              }
+            }
+          }
+        }
+      ]
     },
     "evidence": {
       "type": "object",
@@ -160,6 +229,9 @@
         "kind",
         "summary",
         "locator",
+        "producer",
+        "observed_at",
+        "verified_by",
         "recorded_at"
       ],
       "properties": {
@@ -174,15 +246,20 @@
           ]
         },
         "summary": {
-          "type": "string",
-          "minLength": 1
+          "$ref": "#/$defs/nonemptyString"
         },
         "locator": {
-          "type": [
-            "string",
-            "null"
-          ],
-          "minLength": 1
+          "$ref": "#/$defs/nullableNonemptyString"
+        },
+        "producer": {
+          "$ref": "#/$defs/nullableNonemptyString"
+        },
+        "observed_at": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "verified_by": {
+          "$ref": "#/$defs/nonemptyString"
         },
         "recorded_at": {
           "type": "string",
@@ -200,16 +277,14 @@
       ],
       "properties": {
         "question": {
-          "type": "string",
-          "minLength": 1
+          "$ref": "#/$defs/nonemptyString"
         },
         "options": {
           "type": "array",
           "minItems": 2,
           "uniqueItems": true,
           "items": {
-            "type": "string",
-            "minLength": 1
+            "$ref": "#/$defs/nonemptyString"
           }
         },
         "prepared_at": {
@@ -218,74 +293,75 @@
         }
       }
     },
-    "controlEditGrant": {
+    "recoveryCircuit": {
       "type": "object",
       "additionalProperties": false,
       "required": [
-        "actor",
-        "mutations"
+        "slice_label",
+        "state",
+        "assigned_worker",
+        "last_failure_evidence",
+        "last_failure_at",
+        "last_reset_evidence",
+        "last_reset_at"
       ],
       "properties": {
-        "actor": {
-          "type": "string",
-          "minLength": 1
+        "slice_label": {
+          "$ref": "#/$defs/nonemptyString"
         },
-        "mutations": {
-          "type": "array",
-          "minItems": 1,
-          "uniqueItems": true,
-          "items": {
-            "enum": [
-              "set-owner",
-              "set-state",
-              "set-next",
-              "add-evidence",
-              "set-gate",
-              "set-decision",
-              "clear-decision",
-              "claim-successor",
-              "record-successor-failure",
-              "record-successor-success"
-            ]
-          }
+        "state": {
+          "enum": [
+            "closed",
+            "active",
+            "open"
+          ]
+        },
+        "assigned_worker": {
+          "$ref": "#/$defs/nullableNonemptyString"
+        },
+        "last_failure_evidence": {
+          "$ref": "#/$defs/nullableNonemptyString"
+        },
+        "last_failure_at": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "format": "date-time"
+        },
+        "last_reset_evidence": {
+          "$ref": "#/$defs/nullableNonemptyString"
+        },
+        "last_reset_at": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "format": "date-time"
         }
-      }
-    },
-    "recoveryCircuit": {
-      "type": "object",
-      "additionalProperties": false,
+      },
       "allOf": [
         {
           "if": {
             "properties": {
               "state": {
-                "const": "claimed"
+                "const": "active"
               }
-            }
+            },
+            "required": [
+              "state"
+            ]
           },
           "then": {
             "properties": {
-              "claimed_by": {
-                "type": "string",
-                "minLength": 1
-              }
-            }
-          }
-        },
-        {
-          "if": {
-            "properties": {
-              "state": {
-                "enum": [
-                  "closed",
-                  "open"
-                ]
+              "assigned_worker": {
+                "$ref": "#/$defs/nonemptyString"
               }
             }
           },
-          "then": {
+          "else": {
             "properties": {
-              "claimed_by": {
+              "assigned_worker": {
                 "const": null
               }
             }
@@ -297,7 +373,10 @@
               "last_failure_evidence": {
                 "type": "string"
               }
-            }
+            },
+            "required": [
+              "last_failure_evidence"
+            ]
           },
           "then": {
             "properties": {
@@ -306,17 +385,8 @@
                 "format": "date-time"
               }
             }
-          }
-        },
-        {
-          "if": {
-            "properties": {
-              "last_failure_evidence": {
-                "const": null
-              }
-            }
           },
-          "then": {
+          "else": {
             "properties": {
               "last_failure_at": {
                 "const": null
@@ -330,7 +400,10 @@
               "last_reset_evidence": {
                 "type": "string"
               }
-            }
+            },
+            "required": [
+              "last_reset_evidence"
+            ]
           },
           "then": {
             "properties": {
@@ -339,17 +412,8 @@
                 "format": "date-time"
               }
             }
-          }
-        },
-        {
-          "if": {
-            "properties": {
-              "last_reset_evidence": {
-                "const": null
-              }
-            }
           },
-          "then": {
+          "else": {
             "properties": {
               "last_reset_at": {
                 "const": null
@@ -357,64 +421,7 @@
             }
           }
         }
-      ],
-      "required": [
-        "slice_label",
-        "state",
-        "last_failure_evidence",
-        "last_failure_at",
-        "last_reset_evidence",
-        "last_reset_at",
-        "claimed_by"
-      ],
-      "properties": {
-        "slice_label": {
-          "type": "string",
-          "minLength": 1
-        },
-        "state": {
-          "enum": [
-            "open",
-            "claimed",
-            "closed"
-          ]
-        },
-        "last_failure_evidence": {
-          "type": [
-            "string",
-            "null"
-          ],
-          "minLength": 1
-        },
-        "last_failure_at": {
-          "type": [
-            "string",
-            "null"
-          ],
-          "format": "date-time"
-        },
-        "last_reset_evidence": {
-          "type": [
-            "string",
-            "null"
-          ],
-          "minLength": 1
-        },
-        "last_reset_at": {
-          "type": [
-            "string",
-            "null"
-          ],
-          "format": "date-time"
-        },
-        "claimed_by": {
-          "type": [
-            "string",
-            "null"
-          ],
-          "minLength": 1
-        }
-      }
+      ]
     }
   }
 }
diff --git a/manifests/policy-contracts.json b/manifests/policy-contracts.json
index de97fb84..c5fb7240 100644
--- a/manifests/policy-contracts.json
+++ b/manifests/policy-contracts.json
@@ -1,54 +1,130 @@
 {
   "schema_version": 1,
   "contracts": [
+    {
+      "id": "desired-state-first-prompting",
+      "path": "philosophy.md",
+      "required": [
+        "Lead with the role to inhabit, the state to create, and the evidence that proves success.",
+        "Pair a prohibition with the desired replacement whenever judgment is involved."
+      ]
+    },
+    {
+      "id": "separate-runtime-global-sources",
+      "path": "AGENTS.md",
+      "required": [
+        "Maintain those two files separately. Share values, not runtime fiction.",
+        "Delegates execute reviewed assignments and return artifacts plus evidence. Do not distribute control authorship across worker-written ledgers."
+      ]
+    },
+    {
+      "id": "codex-luna-first-delegation",
+      "path": "codex/AGENTS.md",
+      "required": [
+        "The root session uses GPT-5.6 Sol.",
+        "Fresh delegated work uses GPT-5.6 Luna by default.",
+        "A Sol child needs a concrete capability reason."
+      ],
+      "forbidden": [
+        "GPT-5.6 Terra"
+      ]
+    },
+    {
+      "id": "claude-glm-only-routing",
+      "path": "claude/CLAUDE.md",
+      "required": [
+        "Treat GLM-5.2 as the only available child model identity.",
+        "Prefer a fresh narrow subagent for a bounded assignment."
+      ]
+    },
+    {
+      "id": "mcp-runtime-neutral-profile",
+      "path": "apps/compass-mcp/profile.md",
+      "required": [
+        "Lead with the role, desired state, and evidence.",
+        "Preserve one logical principal across long contexts."
+      ],
+      "forbidden": [
+        "GPT-5.6 Sol",
+        "GLM-5.2"
+      ]
+    },
     {
       "id": "pr-current-head-and-authority",
       "path": "codex/skills/pr-review-loop/SKILL.md",
       "required": [
-        "All conclusions are tied to the current head SHA.",
-        "Merge only when explicitly authorized."
+        "All readiness conclusions target one exact head SHA.",
+        "Merge only when explicitly authorized and every required current-head gate is satisfied."
       ]
     },
     {
       "id": "behavior-validator-source-blind",
       "path": "codex/agents/behavior-validator.toml",
       "required": [
-        "Do not inspect source files, diffs, tests, git history, implementation notes, or review bundles.",
-        "If implementation material becomes visible, mark the run contaminated and restart with a fresh validator."
+        "Implementation shape, test names, static success text, reviewer claims, and the desired conclusion carry no evidentiary weight.",
+        "Exposure to source, diffs, tests, history, implementation notes, or review bundles contaminates the run."
       ]
     },
     {
-      "id": "controller-does-not-absorb-worker-work",
+      "id": "controller-preserves-principal-authorship",
       "path": "codex/skills/orchestration-controller/SKILL.md",
       "required": [
-        "Do not write worker-owned code, config, docs, benchmark output, product output, or task artifacts. That work belongs to the worker or a fresh worker.",
-        "The controller owns the stable parent outcome, required assertions, amendment history, assignments, routing, evidence checks, and completion judgment.",
-        "Name one writer for each mutable control surface.",
-        "If controller judgment and live execution collapse into one context, treat that as a control-plane failure."
+        "The controller is the user-facing logical principal. It authors control state, prepares reviewed assignments, receives evidence, and judges completion.",
+        "Delegates own assigned artifacts and investigations. They return evidence through the named return channel.",
+        "Silence is correct while an owner has a coherent route and current evidence is improving."
       ]
     },
     {
-      "id": "orchestration-ledger-does-not-grant-authority",
+      "id": "orchestration-ledger-principal-only",
       "path": "workflows/orchestration-ledger.md",
       "required": [
-        "The ledger records authority, current state, evidence, and recovery gates.",
+        "A delegate returns artifacts and evidence. The principal verifies that return and records any resulting control-state change.",
+        "The tool does not support delegated edit grants.",
         "Changing the field does not grant permission."
+      ],
+      "forbidden": [
+        "set-grant",
+        "claim-successor"
+      ]
+    },
+    {
+      "id": "goal-stability-and-resume",
+      "path": "codex/skills/using-goals/SKILL.md",
+      "required": [
+        "The goal remains stable until its named authority records an amendment.",
+        "A successor principal reopens authoritative anchors in order and verifies changeable state before continuing.",
+        "Production mutation begins when the named authority opens that phase."
+      ]
+    },
+    {
+      "id": "monitor-keeps-clock-outside-context",
+      "path": "codex/skills/monitor-to-completion/SKILL.md",
+      "required": [
+        "One blocking command owns the wait.",
+        "A successful wait is evidence for the parent objective. The parent decides what that evidence means."
+      ]
+    },
+    {
+      "id": "root-cause-subtractive-repair",
+      "path": "codex/skills/root-cause-not-symptom/SKILL.md",
+      "required": [
+        "A recurring symptom is new evidence. Reopen the causal model before adding another layer.",
+        "Line reduction is useful evidence, not the target. The target is a system with a simpler truthful explanation."
       ]
     },
     {
-      "id": "goal-completion-authority",
-      "path": "codex/skills/using-codex-goals/SKILL.md",
+      "id": "micro-experiment-code-does-not-graduate",
+      "path": "codex/skills/run-a-micro-experiment/SKILL.md",
       "required": [
-        "The controller owns the parent outcome, assertion text, amendments, and final completion judgment.",
-        "After compaction, restart, or handoff, reopen authoritative inputs in precedence order."
+        "Experimental code does not graduate into production. The finding graduates."
       ]
     },
     {
       "id": "benchmark-recovery-circuit-breaker",
-      "path": "codex/skills/benchmark-run-operator/SKILL.md",
+      "path": "carried/benchmark/skills/benchmark-run-operator/SKILL.md",
       "required": [
-        "Do not launch another symptom-level successor when the failure signature, inputs, and runtime path are materially unchanged and the prior attempt produced no new discriminating evidence.",
-        "Name one writer for benchmark policy and queue ownership."
+        "Open the recovery circuit when the failure signature, inputs, and runtime path remain materially unchanged and the prior attempt produced no new discriminating evidence.",
+        "The user-facing principal authors benchmark policy, queue shape, comparability decisions, and control documents before dispatch."
       ]
     },
     {
diff --git a/manifests/portable-files.toml b/manifests/portable-files.toml
index 7afa5dd0..17d1f128 100644
--- a/manifests/portable-files.toml
+++ b/manifests/portable-files.toml
@@ -25,22 +25,22 @@ skills_dir = "$HOME\\.agents\\skills"
 skills = [
   "action-items-to-prs",
   "behavior-validator",
-  "benchmark-run-operator",
   "compass",
   "design-taste-frontend",
   "git-branch-resolver",
   "grill-me",
-  "input-token-economy",
   "monitor-to-completion",
   "orchestration-controller",
   "pr-review-loop",
   "root-cause-not-symptom",
+  "run-a-micro-experiment",
   "specialist-review",
   "subagent-driven-development",
   "to-prd",
   "update-compass",
-  "using-codex-goals",
+  "using-goals",
   "workspace-steward",
+  "write-a-compass-skill",
   "write-a-skill",
 ]
 
@@ -51,25 +51,31 @@ home = "$HOME\\.claude"
 skills_dir = "$HOME\\.claude\\skills"
 agents_dir = "$HOME\\.claude\\agents"
 
+files = [
+  "CLAUDE.md",
+]
+
 # Claude skills derive from the reviewed codex/skills source at install time.
 # List a skill under `derived_skills` to copy SKILL.md plus references/,
 # scripts/, and assets/, dropping agents/openai.yaml.
 derived_skills = [
   "action-items-to-prs",
   "behavior-validator",
-  "benchmark-run-operator",
   "compass",
   "design-taste-frontend",
   "git-branch-resolver",
   "grill-me",
-  "input-token-economy",
   "monitor-to-completion",
   "orchestration-controller",
   "pr-review-loop",
+  "root-cause-not-symptom",
+  "run-a-micro-experiment",
   "specialist-review",
   "subagent-driven-development",
   "to-prd",
+  "using-goals",
   "workspace-steward",
+  "write-a-compass-skill",
   "write-a-skill",
 ]
 
@@ -77,13 +83,13 @@ derived_skills = [
 # frontmatter and Codex read-only sandbox contracts are platform-specific.
 agents = [
   "behavior-validator",
-  "benchmark-infra-reviewer",
 ]
 
 # Other Claude agents derive from codex/agents/<name>.toml at install time.
 derived_agents = [
   "algorithm-critic",
   "neutral-critic",
+  "progress-monitor",
   "repo-explorer",
   "research-critic",
   "reuse-critic",
@@ -105,6 +111,7 @@ files = [
   "AGENTS.md",
   "CODE_OF_CONDUCT.md",
   "CONTRIBUTING.md",
+  "glossary.md",
   "LICENSE",
   "README.md",
   "SECURITY.md",
diff --git a/manifests/skill-sources.json b/manifests/skill-sources.json
index 673c7cb2..d93c215e 100644
--- a/manifests/skill-sources.json
+++ b/manifests/skill-sources.json
@@ -21,16 +21,6 @@
         "claude": "derived"
       }
     },
-    {
-      "name": "benchmark-run-operator",
-      "owner": "compass",
-      "source": "codex/skills/benchmark-run-operator",
-      "profile": "default",
-      "targets": {
-        "codex": "copy",
-        "claude": "derived"
-      }
-    },
     {
       "name": "compass",
       "owner": "compass",
@@ -76,16 +66,6 @@
         "claude": "derived"
       }
     },
-    {
-      "name": "input-token-economy",
-      "owner": "compass",
-      "source": "codex/skills/input-token-economy",
-      "profile": "default",
-      "targets": {
-        "codex": "copy",
-        "claude": "derived"
-      }
-    },
     {
       "name": "monitor-to-completion",
       "owner": "compass",
@@ -123,7 +103,17 @@
       "profile": "default",
       "targets": {
         "codex": "copy",
-        "claude": "none"
+        "claude": "derived"
+      }
+    },
+    {
+      "name": "run-a-micro-experiment",
+      "owner": "compass",
+      "source": "codex/skills/run-a-micro-experiment",
+      "profile": "default",
+      "targets": {
+        "codex": "copy",
+        "claude": "derived"
       }
     },
     {
@@ -167,13 +157,13 @@
       }
     },
     {
-      "name": "using-codex-goals",
+      "name": "using-goals",
       "owner": "compass",
-      "source": "codex/skills/using-codex-goals",
+      "source": "codex/skills/using-goals",
       "profile": "default",
       "targets": {
         "codex": "copy",
-        "claude": "none"
+        "claude": "derived"
       }
     },
     {
@@ -186,6 +176,16 @@
         "claude": "derived"
       }
     },
+    {
+      "name": "write-a-compass-skill",
+      "owner": "compass",
+      "source": "codex/skills/write-a-compass-skill",
+      "profile": "default",
+      "targets": {
+        "codex": "copy",
+        "claude": "derived"
+      }
+    },
     {
       "name": "write-a-skill",
       "owner": "compass",
diff --git a/philosophy.md b/philosophy.md
index f161a25a..92725dbc 100644
--- a/philosophy.md
+++ b/philosophy.md
@@ -1,260 +1,194 @@
 # Philosophy
 
-This repository is not a backup of a Codex home. It is a reviewed source for a
-way of working with agents.
+Compass is reviewed source for a way of working with agents. It is not a backup
+of whatever happened to exist in one runtime home.
 
-That distinction matters. A backup preserves whatever happened to be present on
-one machine. A reviewed source preserves the choices that are worth carrying to
-the next machine, the next session, and the next agent.
+A reviewed source preserves choices that deserve to survive the next machine,
+session, model, and maintainer. Every durable artifact pays recurring cost, so
+it must produce distinct useful behavior.
 
-The goal is not to restrain Codex until it can only follow a script. The goal is
-to show the kind of behavior we want agents to embody: clear judgment, strong
-ownership, current evidence, and respect for the boundary between local
-autonomy and durable policy.
-
-Every durable Markdown file in this repo should carry that same standard. A
-reader should notice not only what it says, but how it says it. The document
-should behave like the thing it is describing.
+The goal is capable agency with clear judgment, strong ownership, current
+evidence, and explicit human authority. The repository should make good work
+more natural without turning an intelligent model into a script interpreter.
 
 ## Show, Do Not Tell
 
-Guidance must embody its own standard. If it says be terse, be terse. If it
-says be strong, use strong language. If it asks the agent to push past weak
-answers, the text itself must push first.
+Guidance must embody its own standard. Terse guidance is terse. Strong guidance
+uses strong language. A skill that asks for judgment begins by demonstrating the
+judgment it expects.
 
-Do not explain the desired behavior from outside it. Demonstrate it. Make the
-reader feel the behavior the document demands. A sentence that asks for
-confidence while hedging against itself has already failed.
+Serve the artifact's purpose directly. Runtime guidance gives the invoking agent
+the context needed to act. Maintainer history, failed drafts, and author intent
+belong in maintainer documentation.
 
-The same rule applies to products, pages, tools, reports, and skills. Know the
-purpose of the thing being made. Serve that purpose directly. Do not leak the
-prompt, the request, the implementation history, or the author's private
-thinking into the artifact.
+Examples reveal patterns. They do not define the boundary. A visible failure is
+evidence of a class of failures. Find the class and repair its cause.
 
-A web page with a requested style should not tell the external audience, "here
-is the style you wanted." It should be that style. A skill written for an agent
-should not explain why the skill was invented. It should give the invoking
-agent the exact context needed to act. History belongs in maintainer docs.
-Runtime context is for action.
+## Point Toward The Desired State
 
-An example is evidence, not the boundary. If one bad case is pointed out, do
-not patch only that case and stop. Extract the pattern. Find the family. Fix
-the root cause. A visible failure is a symptom. The real work is finding the
-class of failures that produced it.
+Every instruction shifts the model's direction. Lead with the role to inhabit,
+the state to create, and the evidence that proves success. A positive direction
+names a destination. A prohibition only excludes one part of an otherwise open
+space.
 
-## Prompt, Context, Loop
+Use prohibitions when the boundary is crisp, observable, and important, such as
+protecting secrets, preserving worktree scope, or withholding merge authority.
+Pair a prohibition with the desired replacement whenever judgment is involved.
 
-Prompt engineering shapes the words that make an agent behave. It is the
-lowest layer, and it still matters. Words are levers. Choose them surgically.
-Do not leak uncertainty, private reasoning, or author history into instruction
-text. The text should produce the behavior, not narrate the attempt.
+Write with calm authority. Remove hedging, apology, empty encouragement, and
+optional language around required behavior. Politeness may express respect. It
+must not dilute the instruction.
 
-Context engineering shapes the moment of action. Skills, agents, workflows,
-and references are not archives. They are operating surfaces. Their audience is
-the agent that invokes them while doing work. Give that agent what it needs.
-Keep the rest out.
-
-Loop engineering shapes the life of the work. This is where Compass should
-innovate. Current agents are capable. Bad prompts and bloated context make
-them weaker. Strong foundations let long-running loops become real work
-systems instead of long chat transcripts.
+## Prompt, Context, Loop
 
-The foundation must be dense with direction, understanding, purpose, and
-philosophy. No bloat. No politeness as filler. No weak language. No soft
-framing that makes the agent comfortable with collapse. Compress the beliefs.
-Purify the wording. Make every skill and agent a golden example of the
-behavior it asks for.
+Prompt engineering shapes the immediate direction. Words are levers. Choose
+them surgically.
 
-## Reduction Is The Central Theme
+Context engineering shapes the moment of action. Skills, agents, workflows,
+references, and control documents are operating surfaces, not archives. Give
+each reader the smallest complete context for its job.
 
-Compass exists to reduce the context, duplication, state, and judgment overhead
-required for an agent to act well. The target is not a smaller agent. It is a
-more capable one that carries only what its current job needs.
+Loop engineering preserves coherent work over time. Long-running work crosses
+finite contexts, compactions, interruptions, and replacement workers. Compass
+must preserve the intention outside the conversation so a fresh context can
+resume without inventing what the prior one meant.
 
-Reduction is not line count. A shorter document that loses a safety boundary is
-worse than a longer one that makes the right decision unavoidable. Preserve
-capability while shrinking the cost to express, retrieve, install, verify, and
-maintain it.
+## Preserve One Intention Across Contexts
 
-Every durable artifact pays recurring cost: runtime context, retrieval
-competition, install and derivation complexity, drift risk, review burden, and
-extra choices for the next agent. It must repay that cost with distinct useful
-behavior. If it does not, remove it, merge it, move it to a narrower surface,
-derive it from one reviewed source, or replace its repeated prose with a
-mechanical check.
+Delegation is lossy. Compaction is a handoff to a context that remembers less.
+Durable control documents counter that loss.
 
-Use this order when simplifying:
+The user-facing principal, or the user directly, authors the goal, plan,
+assignment boundaries, catalog, ledger shape, and checkpoints. Delegates receive
+reviewed assignments and return artifacts plus evidence. They do not redefine
+the objective or invent a parallel control system.
 
-1. Delete material that does not change behavior.
-2. Merge material that teaches the same judgment.
-3. Move material to the audience that actually needs it.
-4. Derive copies instead of maintaining parallel sources.
-5. Mechanize properties that should not drift.
-6. Keep the remaining surface dense, legible, and easy to audit.
+A new principal context resumes the same logical authorship. It reopens the
+authoritative anchors, verifies the current checkpoint against observable state,
+and continues the same objective.
 
-Reduction does not mean collapsing distinct roles, removing evidence, or
-weakening authority boundaries. It removes recurring cost without amputating
-the behavior that makes the system trustworthy.
+The test is simple: a fresh agent with no conversation history should be able to
+read the named anchors and control documents, recover what matters, and take the
+next correct action.
 
-## Goals Are The Loop Foundation
+## Reduction Is The Central Theme
 
-An agent gets things wrong as much as the goal allows it to get things wrong.
+Compass reduces the context, duplication, state, and judgment overhead required
+for an agent to act well. The target is not a smaller agent. It is a more capable
+agent carrying only what its current job needs.
 
-"Run the benchmark" is not enough. That goal lets the worker run a script,
-collect errors, and call the job done. The real goal is to get valid benchmark
-results for a specific configuration, with specific metrics and statistics,
-enough to support a decision by the deadline.
+Reduction is not raw line count. Prefer fewer maintained states, branches,
+wrappers, sources of truth, dependencies, and concepts when behavior remains
+intact. A longer sentence that preserves a critical boundary is better than a
+shorter sentence that points the agent in the wrong direction.
 
-Say the achieved state. Say what does not count. Say what evidence proves the
-goal. Say what authority the agent has to repair, rerun, branch, patch, make a
-PR, restart services, preserve artifacts, and keep moving. If that authority is
-not explicit, the agent will invent a conservative boundary and stop inside it.
+Simplify in this order:
 
-A blocker report is not the product when the requested product is results.
-Blockers are evidence. They should trigger diagnosis, repair, rerouting,
-replacement, or escalation with options. They are not a resting place.
+1. Delete material that does not change behavior.
+2. Merge material that teaches the same judgment.
+3. Move material to the audience that needs it.
+4. Derive copies when shared content is truly identical.
+5. Maintain runtime-specific sources separately when their environments differ.
+6. Mechanize properties that should not drift.
+7. Keep the remaining surface dense, legible, and easy to audit.
 
-## Managers Need Meetings
+Reduction preserves roles, authority, and evidence. It removes recurring cost
+without amputating trustworthy behavior.
 
-Loop engineering lets us treat agents more like workers in an organization.
+## Goals Anchor The Loop
 
-The human owns taste and direction. The project manager agent owns delivery
-pressure. It does not need to care about implementation. It needs to know what
-done looks like, what matters, who owns each slice, what evidence is real, and
-when the next meeting happens.
+A goal states the achieved condition, the evidence that proves it, the
+constraints that remain true, and the authority available to reach it. It stays
+stable while routes, owners, blockers, and next actions change.
 
-Scheduled meetings are not ceremony. They create pressure before the final
-deadline. They force compression. They force proof. The manager must arrive
-with progress, evidence, risks, decisions needed, and the next move. The worker
-must arrive with its slice advanced or with a concrete reason, evidence, and a
-repair path.
+Current state belongs in a ledger or checkpoint. Historical detail belongs in
+an archive. A completed command, phase, worker slice, or review is progress until
+current evidence satisfies the complete goal.
 
-The manager does not micromanage. It stays closer to the details than the
-human, audits worker claims, corrects bad context, replaces polluted workers,
-and keeps the goal alive. A failed worker is usually not a defective model. It
-is usually defective context. Diagnose the context, fix it, and spawn a clean
-instance when needed.
+Blockers are evidence, not a substitute for the requested result. They trigger
+diagnosis, repair, rerouting, a prepared decision, or an explicit authorized
+change to the goal.
 
-Escalation should be normal, but not lazy. Do not bring every friction point to
-the human. Solve inside authority first. Escalate when direction, taste, risk,
-or irreversible cost exceeds the contract. Bring evidence and options, not a
-helpless status packet.
+## Planning Earns Implementation
 
-The long-term shape is an agent organization: top-level orchestrators, project
-managers, team leads, workers, critics, and verifiers, all reporting upward at
-strict cadences. Work should trickle up as compressed evidence. Direction
-should flow down as clarified goals, corrected context, and sharper authority.
+Eagerness is not understanding. Planning work establishes the objective,
+constraints, anchors, risks, and evidence before production mutation begins.
 
-## Guidance Should Shape Judgment
+When the user reserves implementation authority, exploration, research,
+questions, plans, and explicitly scoped experiments may proceed. Product edits,
+implementation worktrees, and public mutations begin only after that authority
+is granted.
 
-Good guidance begins by giving the agent a stance. It makes the role legible,
-explains why it exists, what failure it prevents, what evidence matters, and
-what boundary keeps the work honest. Once those things are clear, a capable
-agent can make decisions without being walked through every branch.
+Good planning compresses later execution. It creates a brief that a fresh
+worker can act on without reconstructing the user's intent from chat history.
 
-Numbered lists still have a place. They are useful when order is real, state is
-fragile, or a command must be run exactly. They are weak when they stand in for
-judgment. A checklist can preserve a delicate operation. It cannot substitute
-for understanding what good work looks like.
+## Guidance Shapes Judgment
 
-Skills should make the role felt before procedure. A skill is a role, not a
-trigger plus a task list. A reviewer should feel independent and
-evidence-hungry. A controller should feel calm, directive, and unwilling to
-confuse motion with completion. A writing skill should make the agent attentive
-to audience, structure, and reader impact before it starts.
+A skill gives the agent a stance before procedure. The opening should make the
+role, desired result, reason for the role, evidence standard, and authority
+boundary legible.
 
-Use exact steps when they protect fragile mechanics, preserve a handoff
-contract, or prevent a known recurring mistake. Otherwise, a clear principle,
-boundary, and small example teach better judgment than a flowchart.
+Exact procedures protect fragile mechanics, irreversible actions, and handoff
+contracts. Principles, boundaries, and compact examples handle judgment. A
+checklist can preserve a delicate operation. It cannot replace understanding
+what good work looks like.
 
-The point of a skill is to make the agent better oriented, not smaller.
+The purpose of a skill is to make the model grok the direction strongly enough
+to handle cases the author did not enumerate.
 
-## Agents Have Different Work To Do
+## Roles Stay Distinct
 
-Agents are not interchangeable workers with longer prompts.
+A worker owns the assigned artifact and carries ordinary implementation friction
+inside that boundary.
 
-A worker owns implementation. It reads the code, makes the change, runs the
-checks, and carries ordinary friction inside its scope. A worker that reports a
-routine failure has not completed the goal. It has produced evidence that the
-work needs a sharper next move.
+A critic owns doubt. It tests claims independently and returns evidence-backed
+findings.
 
-A critic does not own the diff. It owns doubt. It can run commands, inspect
-state, use a browser, or gather whatever evidence is needed to test a claim, but
-it stays independent from the implementation it is judging.
+An explorer maps terrain until the principal can act without guessing.
 
-An explorer maps the current terrain. It should be patient with files, branches,
-tool output, and source evidence. Its job is not to sound decisive before the
-repo has taught it what is true.
+A monitor observes a named condition or workstream and escalates only when a
+judgment point appears. Mechanical waiting belongs inside one bounded command.
 
-A controller holds the level above execution. It keeps the parent objective
-visible, notices when work has become thrash, asks questions that restore
-agency, routes work to the right owner, and verifies evidence when someone says
-done. It does not prove its value by becoming the fastest worker in the room.
+A controller stays above execution. It preserves the parent objective, prepares
+reviewed assignments, reconciles returned evidence, corrects drift, and decides
+when the goal is complete. It creates pressure without standing over a coherent
+worker's shoulder.
 
-These boundaries do not make agents passive. They make their agency cleaner.
+These boundaries create cleaner agency, not passive agents.
 
 ## Authority Belongs In The Narrowest Surface
 
-Durable guidance has weight, so it should live where its authority actually
-belongs.
-
-Global instructions should be rare. They affect every future session, so they
-need stronger justification than a repo-local workflow or a focused skill.
-
-Skills and agents carry reusable runtime judgment. They should speak directly
-to the agent that will use them. They should not ask that agent to sort through
-maintainer history, packaging details, or dated observations before acting.
-
-Workflows and local docs carry maintainer reasoning. They explain why this repo
-is shaped the way it is, how additions are reviewed, and what mistakes should
-not be repeated. They can hold context that would distract a runtime agent.
+Global instructions are rare because they affect every future session. Skills
+and agents carry reusable runtime judgment. Project guidance stays with the
+project. Workflows and local docs carry maintainer reasoning. Scripts and
+manifests carry mechanical truth.
 
-Scripts and manifests carry mechanical truth. If a property should not drift,
-it should be checked by `doctor.ps1`, an install map, a manifest, or CI when
-that is practical. Memory is useful for orientation. It is not a guardrail.
+Codex and Claude share values but operate through different runtime contracts.
+Maintain their global instruction files separately. Share a rule only when both
+runtimes genuinely need the same behavior.
 
 The destination of a document determines its voice.
 
-## Autonomy, Evidence, and Human Authority
+## Autonomy, Evidence, And Human Authority
 
-This setup is comfortable with trusted-machine autonomy. Codex should move
-quickly when the machine, repository, and task are trusted, but strong claims
-still need current evidence: files read, commands run, tests passed, GitHub
-state checked, or live drift inspected.
+Trusted-machine autonomy should move quickly. Strong claims still require
+current evidence: files read, commands run, tests passed, runtime state
+observed, or remote state checked.
 
-Prior chats can explain why we care and suggest where to look. They do not
-replace looking again. Good agents do not need ceremony, but they must show
-their work wherever a future maintainer, reviewer, or user could ask, "How do
-we know?"
+Prior chats explain history. They do not replace current inspection.
 
-Local autonomy does not grant durable authority. A high-trust local
-configuration does not make durable or remote state the agent's to change
-silently.
-
-A ready pull request is a good stopping point. Merging, closing, retargeting,
-force pushing, deleting branches, or publishing to another system changes shared
-state. Those actions need explicit user intent.
+Local autonomy does not grant durable or public authority. A ready pull request
+is a useful result. Merging, closing, retargeting, force pushing, deleting,
+publishing, or changing shared state requires the authority named for that
+action.
 
 Readiness is not permission.
 
-## The Writing Should Embody The System
-
-Markdown is part of the system. It is not just commentary around the system.
-
-A skill file should feel like a skill worth using. A workflow should feel like a
-workflow a maintainer could actually follow. A local lesson should preserve the
-reason without leaking that reason into runtime behavior. A manifest should make
-the boundary easier to audit. A README should orient without trying to carry
-every argument itself.
-
-This is the real standard: each document should make its reader more capable of
-doing the next right thing.
+## The Writing Is Part Of The System
 
-That is why the repo prefers small durable artifacts over swollen instruction
-blocks. It is why procedure belongs after posture. It is why evidence beats
-habit, and why mechanical checks are better than remembered preferences. It is
-why an agent should not merely comply with the words in a file, but absorb the
-shape of good work that the file demonstrates.
+Markdown is operating behavior. A skill should feel like the role it creates. A
+workflow should be usable. A local lesson should preserve reasoning without
+polluting runtime context. A manifest should make boundaries auditable.
 
-The best guidance in this repo should not feel like a cage. It should feel like
-good taste made explicit enough to be shared.
+Each document should make its reader more capable of the next right action.
+The best guidance feels like good taste made explicit enough to share.
diff --git a/scripts/README.md b/scripts/README.md
index 0f23faf6..609fe134 100644
--- a/scripts/README.md
+++ b/scripts/README.md
@@ -50,22 +50,26 @@ structural findings or an exceeded budget should fail the command. Run
 `scripts/skills-audit.ps1` directly for usage-log, context-window, and threshold
 options. Usage scanning is opt-in and never emits raw log content.
 
-`orchestration` reads compact local controller state from
+`orchestration` reads the local mechanical control index from
 `.local/orchestration-ledger.json` by default. Use `-GoalId` for one goal and
-`-Ledger` for an explicit path under `.local/`. Mutations go through
-`scripts/orchestration-ledger.ps1`, which records owners, next actions, evidence,
-public-mutation gates, prepared decisions, control writers, optimistic control
-revisions, delegated edit grants, and recovery circuits with exclusive locking,
-guarded validation, and atomic writes. Existing schema version 1 ledgers are
-read with migration defaults and become version 2 on the next successful write.
-Mutating an existing goal requires `-Actor` and `-ExpectedRevision`; delegated
-actors must have a grant for the exact action. The live ledger remains local and
-ignored. Run `orchestration-ledger.ps1 check-recovery -GoalId <id>
--SliceLabel <slice>` for read-only observation. Use
-`claim-successor` as the atomic prelaunch gate, then record a successor
-failure or success. Only the control writer can run `reset-recovery`, which
-requires root-cause evidence. A claimed slice records `claimed_by`, and only
-that actor can record its outcome.
+`-Ledger` for an explicit path under `.local/`. Durable meaning remains in the
+principal-authored Markdown goal, plan, catalog, assignment, and checkpoint
+documents referenced by the ledger.
+
+Mutations go through `scripts/orchestration-ledger.ps1`. Schema version 4
+records anchors, control-document links, planning or implementation phase,
+current routing, principal-verified evidence with producer and observation
+time, public-mutation gates, decisions, timestamps, and recovery circuits.
+Every mutation requires the named principal and expected revision. Delegated
+workers return artifacts and evidence; they cannot mutate control state. Schema
+versions 1 through 3 migrate on load and are rewritten as version 4 on the next
+successful write.
+
+Use `check-recovery` for read-only observation. Use `begin-recovery` after the
+principal reviews an assignment. A failure with no new discriminating evidence
+opens the circuit. Resume after a changed hypothesis, input, runtime path, or
+root-cause finding is recorded through `reset-recovery`. The ledger stays local,
+uses exclusive locking, validates before write, and replaces files atomically.
 
 `update` accepts a branch, tag, commit SHA, or other resolvable Git commit with
 `-Ref`; `-Branch` remains an alias for compatibility. Branch refs keep the
diff --git a/scripts/_orchestration_ledger_cli.py b/scripts/_orchestration_ledger_cli.py
index 7a702642..4fbdc50a 100644
--- a/scripts/_orchestration_ledger_cli.py
+++ b/scripts/_orchestration_ledger_cli.py
@@ -1,21 +1,21 @@
 from __future__ import annotations
 
-import argparse
 import json
-import os
-import re
-import stat
-import sys
-import tempfile
-from contextlib import contextmanager
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, Iterator, Sequence
+from typing import Sequence
+
+from _orchestration_ledger_core import LedgerError
+from _orchestration_ledger_mutation import mutate
+from _orchestration_ledger_parser import parse_args
+from _orchestration_ledger_storage import (
+    check_recovery,
+    ledger_lock,
+    load_ledger,
+    render_status,
+    resolve_ledger_path,
+    status_payload,
+    write_ledger,
+)
 
-from _orchestration_ledger_core import *
-from _orchestration_ledger_storage import *
-from _orchestration_ledger_parser import *
-from _orchestration_ledger_mutation import *
 
 def main(argv: Sequence[str] | None = None) -> int:
     args = parse_args(argv)
@@ -24,25 +24,13 @@ def main(argv: Sequence[str] | None = None) -> int:
         if args.command == "status":
             ledger = load_ledger(path, allow_missing=True)
             payload = status_payload(path, ledger, args.goal_id)
-            if args.json:
-                print(json.dumps(payload, indent=2, sort_keys=True))
-            else:
-                print(render_status(payload, args.plain))
+            print(json.dumps(payload, indent=2, sort_keys=True) if args.json else render_status(payload, args.plain))
             return 0
         if args.command == "validate":
             ledger = load_ledger(path)
             assert ledger is not None
             if args.json:
-                print(
-                    json.dumps(
-                        {
-                            "valid": True,
-                            "ledger": str(path),
-                            "goals": len(ledger["goals"]),
-                        },
-                        indent=2,
-                    )
-                )
+                print(json.dumps({"valid": True, "ledger": str(path), "goals": len(ledger["goals"])}, indent=2))
             else:
                 print(f"orchestration ledger valid: {path} ({len(ledger['goals'])} goals)")
             return 0
@@ -51,17 +39,7 @@ def main(argv: Sequence[str] | None = None) -> int:
             assert ledger is not None
             circuit = check_recovery(ledger, args.goal_id, args.slice_label)
             if args.json:
-                print(
-                    json.dumps(
-                        {
-                            "check": "recovery",
-                            "ok": True,
-                            "observation_only": True,
-                            "circuit": circuit,
-                        },
-                        indent=2,
-                    )
-                )
+                print(json.dumps({"check": "recovery", "ok": True, "observation_only": True, "circuit": circuit}, indent=2))
             else:
                 print(
                     f"recovery observation passed for {args.goal_id} "
@@ -74,5 +52,5 @@ def main(argv: Sequence[str] | None = None) -> int:
         print(message)
         return 0
     except (LedgerError, OSError) as error:
-        print(f"orchestration ledger failed: {error}", file=sys.stderr)
+        print(f"orchestration ledger failed: {error}", file=__import__("sys").stderr)
         return 1
diff --git a/scripts/_orchestration_ledger_core.py b/scripts/_orchestration_ledger_core.py
index 7ced9e6f..a532fc0d 100644
--- a/scripts/_orchestration_ledger_core.py
+++ b/scripts/_orchestration_ledger_core.py
@@ -1,51 +1,42 @@
 from __future__ import annotations
 
-import argparse
-import json
-import os
 import re
-import stat
-import sys
-import tempfile
-from contextlib import contextmanager
 from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, Iterator, Sequence
+from typing import Any
 
-SCHEMA_VERSION = 3
-LEGACY_SCHEMA_VERSIONS = {1, 2}
+SCHEMA_VERSION = 4
+LEGACY_SCHEMA_VERSIONS = {1, 2, 3}
 STATES = {"planned", "active", "waiting", "blocked", "complete", "cancelled"}
+PHASES = {"planning", "implementation"}
 GATES = {"closed", "authorized", "in_flight", "complete"}
 EVIDENCE_KINDS = {"test", "artifact", "review", "runtime", "decision", "other"}
+RECOVERY_STATES = {"closed", "active", "open"}
 ID_RE = re.compile(r"^[a-z0-9][a-z0-9._-]{0,63}$")
 MUTATION_COMMANDS = {
     "set-owner",
+    "set-phase",
+    "set-links",
     "set-state",
     "set-next",
     "add-evidence",
     "set-gate",
     "set-decision",
     "clear-decision",
-    "set-grant",
-    "clear-grant",
-    "claim-successor",
-    "record-successor-failure",
-    "record-successor-success",
+    "begin-recovery",
+    "record-recovery-failure",
+    "record-recovery-success",
     "reset-recovery",
 }
-GRANTABLE_MUTATION_COMMANDS = MUTATION_COMMANDS - {
-    "set-grant",
-    "clear-grant",
-    "reset-recovery",
-}
-CONTROL_ONLY_MUTATIONS = {"set-grant", "clear-grant", "reset-recovery"}
+
 
 class LedgerError(ValueError):
-    """The requested ledger operation would violate the local control contract."""
+    """The requested ledger operation would violate the control contract."""
+
 
 def utc_now() -> str:
     return datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
 
+
 def parse_timestamp(value: object, label: str, *, nullable: bool = False) -> str | None:
     if value is None and nullable:
         return None
@@ -60,6 +51,7 @@ def parse_timestamp(value: object, label: str, *, nullable: bool = False) -> str
         raise LedgerError(f"{label} must include a timezone: {normalized}")
     return parsed.astimezone(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
 
+
 def nonempty_string(value: object, label: str, *, nullable: bool = False) -> str | None:
     if value is None and nullable:
         return None
@@ -67,6 +59,7 @@ def nonempty_string(value: object, label: str, *, nullable: bool = False) -> str
         raise LedgerError(f"{label} must be a non-empty string")
     return value.strip()
 
+
 def validate_id(value: object, label: str = "goal id") -> str:
     result = nonempty_string(value, label)
     assert result is not None
@@ -74,162 +67,37 @@ def validate_id(value: object, label: str = "goal id") -> str:
         raise LedgerError(f"{label} must match {ID_RE.pattern}: {result}")
     return result
 
+
 def check_unknown(record: dict[str, Any], allowed: set[str], label: str) -> None:
     unknown = sorted(set(record) - allowed)
     if unknown:
         raise LedgerError(f"{label} has unsupported fields: {', '.join(unknown)}")
 
-def validate_evidence(value: object, label: str) -> dict[str, Any]:
-    if not isinstance(value, dict):
-        raise LedgerError(f"{label} must be an object")
-    check_unknown(value, {"kind", "summary", "locator", "recorded_at"}, label)
-    kind = nonempty_string(value.get("kind"), f"{label}.kind")
-    assert kind is not None
-    if kind not in EVIDENCE_KINDS:
-        raise LedgerError(f"{label}.kind must be one of: {', '.join(sorted(EVIDENCE_KINDS))}")
-    return {
-        "kind": kind,
-        "summary": nonempty_string(value.get("summary"), f"{label}.summary"),
-        "locator": nonempty_string(value.get("locator"), f"{label}.locator", nullable=True),
-        "recorded_at": parse_timestamp(value.get("recorded_at"), f"{label}.recorded_at"),
-    }
-
-def validate_decision(value: object, label: str) -> dict[str, Any] | None:
-    if value is None:
-        return None
-    if not isinstance(value, dict):
-        raise LedgerError(f"{label} must be null or an object")
-    check_unknown(value, {"question", "options", "prepared_at"}, label)
-    options = value.get("options")
-    if not isinstance(options, list) or len(options) < 2:
-        raise LedgerError(f"{label}.options must contain at least two strings")
-    cleaned = [nonempty_string(item, f"{label}.options") for item in options]
-    if len(set(cleaned)) != len(cleaned):
-        raise LedgerError(f"{label}.options must be unique")
-    return {
-        "question": nonempty_string(value.get("question"), f"{label}.question"),
-        "options": cleaned,
-        "prepared_at": parse_timestamp(value.get("prepared_at"), f"{label}.prepared_at"),
-    }
-
-def validate_control_grant(value: object, label: str, *, legacy: bool = False) -> dict[str, Any]:
-    if not isinstance(value, dict):
-        raise LedgerError(f"{label} must be an object")
-    check_unknown(value, {"actor", "mutations"}, label)
-    mutations = value.get("mutations")
-    if not isinstance(mutations, list) or not mutations:
-        raise LedgerError(f"{label}.mutations must contain at least one command")
-    cleaned = [nonempty_string(item, f"{label}.mutations") for item in mutations]
+
+def string_list(value: object, label: str, *, require_item: bool = False) -> list[str]:
+    if not isinstance(value, list):
+        raise LedgerError(f"{label} must be an array")
+    cleaned = [nonempty_string(item, f"{label} item") for item in value]
     assert all(item is not None for item in cleaned)
-    allowed = MUTATION_COMMANDS if legacy else GRANTABLE_MUTATION_COMMANDS
-    unsupported = sorted(set(cleaned) - allowed)
-    if unsupported:
-        raise LedgerError(f"{label}.mutations contains unsupported commands: {', '.join(unsupported)}")
-    if len(set(cleaned)) != len(cleaned):
-        raise LedgerError(f"{label}.mutations must be unique")
-    return {
-        "actor": nonempty_string(value.get("actor"), f"{label}.actor"),
-        "mutations": cleaned,
-    }
+    result = [item for item in cleaned if item is not None]
+    if require_item and not result:
+        raise LedgerError(f"{label} requires at least one item")
+    if len(result) != len(set(result)):
+        raise LedgerError(f"{label} items must be unique")
+    return result
+
 
 def paired_optional_strings(
-    value: dict[str, Any],
-    evidence_field: str,
-    time_field: str,
-    label: str,
+    value: dict[str, Any], evidence_field: str, time_field: str, label: str
 ) -> tuple[str | None, str | None]:
     evidence = nonempty_string(
-        value.get(evidence_field),
-        f"{label}.{evidence_field}",
-        nullable=True,
+        value.get(evidence_field), f"{label}.{evidence_field}", nullable=True
     )
     recorded_at = parse_timestamp(
-        value.get(time_field),
-        f"{label}.{time_field}",
-        nullable=True,
+        value.get(time_field), f"{label}.{time_field}", nullable=True
     )
     if (evidence is None) != (recorded_at is None):
         raise LedgerError(
             f"{label}.{evidence_field} and {label}.{time_field} must both be set or null"
         )
     return evidence, recorded_at
-
-def migrate_recovery_circuit(value: object, goal_updated_at: str) -> object:
-    if not isinstance(value, dict) or "consecutive_successor_failures" not in value:
-        return value
-    migrated = dict(value)
-    failures = migrated.pop("consecutive_successor_failures")
-    if isinstance(failures, bool) or not isinstance(failures, int) or failures < 0:
-        return value
-    migrated.setdefault(
-        "last_failure_evidence",
-        f"migrated successor failure count: {failures}" if failures else None,
-    )
-    migrated.setdefault("last_failure_at", goal_updated_at if failures else None)
-    migrated.setdefault("last_reset_evidence", None)
-    migrated.setdefault("last_reset_at", None)
-    migrated.setdefault("claimed_by", None)
-    return migrated
-
-def validate_recovery_circuit(value: object, label: str) -> dict[str, Any]:
-    if not isinstance(value, dict):
-        raise LedgerError(f"{label} must be an object")
-    check_unknown(
-        value,
-        {
-            "slice_label",
-            "state",
-            "last_failure_evidence",
-            "last_failure_at",
-            "last_reset_evidence",
-            "last_reset_at",
-            "claimed_by",
-        },
-        label,
-    )
-    state = nonempty_string(value.get("state"), f"{label}.state")
-    assert state is not None
-    if state not in {"open", "claimed", "closed"}:
-        raise LedgerError(f"{label}.state must be closed, claimed, or open")
-    claimed_by_present = "claimed_by" in value
-    claimed_by = nonempty_string(value.get("claimed_by"), f"{label}.claimed_by", nullable=True)
-    if not claimed_by_present and state == "claimed":
-        state = "open"
-        claimed_by = None
-    if state == "claimed" and claimed_by is None:
-        raise LedgerError(f"{label}.claimed requires a non-empty claimed_by")
-    if state in {"closed", "open"} and claimed_by is not None:
-        raise LedgerError(f"{label}.claimed_by must be null when state is {state}")
-    last_failure_evidence, last_failure_at = paired_optional_strings(
-        value,
-        "last_failure_evidence",
-        "last_failure_at",
-        label,
-    )
-    last_reset_evidence, last_reset_at = paired_optional_strings(
-        value,
-        "last_reset_evidence",
-        "last_reset_at",
-        label,
-    )
-    return {
-        "slice_label": nonempty_string(value.get("slice_label"), f"{label}.slice_label"),
-        "state": state,
-        "last_failure_evidence": last_failure_evidence,
-        "last_failure_at": last_failure_at,
-        "last_reset_evidence": last_reset_evidence,
-        "last_reset_at": last_reset_at,
-        "claimed_by": claimed_by,
-    }
-
-def validate_recovery_circuits(value: object, label: str) -> list[dict[str, Any]]:
-    if not isinstance(value, list):
-        raise LedgerError(f"{label} must be an array")
-    circuits = [
-        validate_recovery_circuit(item, f"{label}[{index}]")
-        for index, item in enumerate(value)
-    ]
-    labels = [circuit["slice_label"] for circuit in circuits]
-    if len(set(labels)) != len(labels):
-        raise LedgerError(f"{label} slice_label values must be unique")
-    return circuits
diff --git a/scripts/_orchestration_ledger_model.py b/scripts/_orchestration_ledger_model.py
index cbe3c2ac..bf0616ec 100644
--- a/scripts/_orchestration_ledger_model.py
+++ b/scripts/_orchestration_ledger_model.py
@@ -1,181 +1,304 @@
 from __future__ import annotations
 
-import argparse
-import json
-import os
-import re
-import stat
-import sys
-import tempfile
-from contextlib import contextmanager
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, Iterator, Sequence
+from datetime import datetime
+from typing import Any
 
 from _orchestration_ledger_core import *
 
-def validate_goal(value: object, index: int, *, legacy: bool = False) -> dict[str, Any]:
+
+def validate_evidence(value: object, label: str) -> dict[str, Any]:
+    if not isinstance(value, dict):
+        raise LedgerError(f"{label} must be an object")
+    check_unknown(
+        value,
+        {
+            "kind",
+            "summary",
+            "locator",
+            "producer",
+            "observed_at",
+            "verified_by",
+            "recorded_at",
+        },
+        label,
+    )
+    kind = nonempty_string(value.get("kind"), f"{label}.kind")
+    assert kind is not None
+    if kind not in EVIDENCE_KINDS:
+        raise LedgerError(f"{label}.kind must be one of: {', '.join(sorted(EVIDENCE_KINDS))}")
+    return {
+        "kind": kind,
+        "summary": nonempty_string(value.get("summary"), f"{label}.summary"),
+        "locator": nonempty_string(value.get("locator"), f"{label}.locator", nullable=True),
+        "producer": nonempty_string(value.get("producer"), f"{label}.producer", nullable=True),
+        "observed_at": parse_timestamp(value.get("observed_at"), f"{label}.observed_at"),
+        "verified_by": nonempty_string(value.get("verified_by"), f"{label}.verified_by"),
+        "recorded_at": parse_timestamp(value.get("recorded_at"), f"{label}.recorded_at"),
+    }
+
+
+def validate_decision(value: object, label: str) -> dict[str, Any] | None:
+    if value is None:
+        return None
+    if not isinstance(value, dict):
+        raise LedgerError(f"{label} must be null or an object")
+    check_unknown(value, {"question", "options", "prepared_at"}, label)
+    options = string_list(value.get("options"), f"{label}.options", require_item=True)
+    if len(options) < 2:
+        raise LedgerError(f"{label}.options must contain at least two strings")
+    return {
+        "question": nonempty_string(value.get("question"), f"{label}.question"),
+        "options": options,
+        "prepared_at": parse_timestamp(value.get("prepared_at"), f"{label}.prepared_at"),
+    }
+
+
+def validate_recovery_circuit(value: object, label: str) -> dict[str, Any]:
+    if not isinstance(value, dict):
+        raise LedgerError(f"{label} must be an object")
+    check_unknown(
+        value,
+        {
+            "slice_label",
+            "state",
+            "assigned_worker",
+            "last_failure_evidence",
+            "last_failure_at",
+            "last_reset_evidence",
+            "last_reset_at",
+        },
+        label,
+    )
+    state = nonempty_string(value.get("state"), f"{label}.state")
+    assert state is not None
+    if state not in RECOVERY_STATES:
+        raise LedgerError(f"{label}.state must be one of: {', '.join(sorted(RECOVERY_STATES))}")
+    worker = nonempty_string(value.get("assigned_worker"), f"{label}.assigned_worker", nullable=True)
+    if state == "active" and worker is None:
+        raise LedgerError(f"{label}.active requires assigned_worker")
+    if state in {"closed", "open"} and worker is not None:
+        raise LedgerError(f"{label}.assigned_worker must be null when state is {state}")
+    failure, failure_at = paired_optional_strings(
+        value, "last_failure_evidence", "last_failure_at", label
+    )
+    reset, reset_at = paired_optional_strings(
+        value, "last_reset_evidence", "last_reset_at", label
+    )
+    return {
+        "slice_label": nonempty_string(value.get("slice_label"), f"{label}.slice_label"),
+        "state": state,
+        "assigned_worker": worker,
+        "last_failure_evidence": failure,
+        "last_failure_at": failure_at,
+        "last_reset_evidence": reset,
+        "last_reset_at": reset_at,
+    }
+
+
+def validate_recovery_circuits(value: object, label: str) -> list[dict[str, Any]]:
+    if not isinstance(value, list):
+        raise LedgerError(f"{label} must be an array")
+    circuits = [
+        validate_recovery_circuit(item, f"{label}[{index}]")
+        for index, item in enumerate(value)
+    ]
+    labels = [circuit["slice_label"] for circuit in circuits]
+    if len(set(labels)) != len(labels):
+        raise LedgerError(f"{label} slice_label values must be unique")
+    return circuits
+
+
+def migrate_evidence(item: object, writer: str, fallback_time: str) -> object:
+    if not isinstance(item, dict):
+        return item
+    migrated = dict(item)
+    recorded = migrated.get("recorded_at", fallback_time)
+    migrated.setdefault("producer", None)
+    migrated.setdefault("observed_at", recorded)
+    migrated.setdefault("verified_by", writer)
+    migrated.setdefault("recorded_at", recorded)
+    return migrated
+
+
+def migrate_circuit(item: object, fallback_time: str) -> object:
+    if not isinstance(item, dict):
+        return item
+    migrated = dict(item)
+    if "consecutive_successor_failures" in migrated:
+        failures = migrated["consecutive_successor_failures"]
+        if isinstance(failures, bool) or not isinstance(failures, int) or failures < 0:
+            return migrated
+        migrated.pop("consecutive_successor_failures")
+        migrated.setdefault(
+            "last_failure_evidence",
+            f"migrated successor failure count: {failures}" if failures else None,
+        )
+        migrated.setdefault("last_failure_at", fallback_time if failures else None)
+        migrated.setdefault("last_reset_evidence", None)
+        migrated.setdefault("last_reset_at", None)
+    if migrated.get("state") == "claimed":
+        migrated["state"] = "active"
+    if "claimed_by" in migrated and "assigned_worker" not in migrated:
+        migrated["assigned_worker"] = migrated.pop("claimed_by")
+    migrated.setdefault("assigned_worker", None)
+    return migrated
+
+
+def migrate_goal(value: object, schema_version: int) -> object:
+    if not isinstance(value, dict) or schema_version == SCHEMA_VERSION:
+        return value
+    goal = dict(value)
+    updated = goal.get("updated_at") if isinstance(goal.get("updated_at"), str) else utc_now()
+    writer = goal.get("control_writer") or goal.get("execution_owner") or "legacy-principal"
+    if "recovery_circuit" in goal and "recovery_circuits" not in goal:
+        goal["recovery_circuits"] = [goal.pop("recovery_circuit")]
+    goal["recovery_circuits"] = [
+        migrate_circuit(item, updated) for item in goal.get("recovery_circuits", [])
+    ]
+    legacy_evidence = goal.pop("completion_evidence", goal.get("evidence", []))
+    goal["evidence"] = [migrate_evidence(item, str(writer), updated) for item in legacy_evidence]
+    goal.setdefault("anchors", [])
+    goal.setdefault("control_documents", [])
+    goal.setdefault("phase", "planning" if goal.get("state") == "planned" else "implementation")
+    goal.setdefault("control_writer", writer)
+    goal.setdefault("control_revision", 1)
+    goal.pop("control_edit_grants", None)
+    goal.setdefault("last_verified_at", updated)
+    return goal
+
+
+def validate_goal(value: object, index: int) -> dict[str, Any]:
     label = f"goals[{index}]"
     if not isinstance(value, dict):
         raise LedgerError(f"{label} must be an object")
     allowed = {
         "id",
         "goal",
+        "anchors",
+        "control_documents",
+        "phase",
         "execution_owner",
         "worker_id",
         "state",
         "next_action",
         "next_check_at",
-        "completion_evidence",
+        "evidence",
         "public_mutation_gate",
         "public_mutation_action",
         "decision_needed",
         "control_writer",
         "control_revision",
-        "control_edit_grants",
         "recovery_circuits",
         "created_at",
         "updated_at",
+        "last_verified_at",
     }
     check_unknown(value, allowed, label)
-    if not legacy:
-        missing = sorted(
-            field
-            for field in (
-                "control_writer",
-                "control_revision",
-                "control_edit_grants",
-                "recovery_circuits",
-            )
-            if field not in value
-        )
-        if missing:
-            raise LedgerError(f"{label} is missing required control fields: {', '.join(missing)}")
+    missing = sorted(field for field in allowed if field not in value)
+    if missing:
+        raise LedgerError(f"{label} is missing required fields: {', '.join(missing)}")
+
     state = nonempty_string(value.get("state"), f"{label}.state")
     assert state is not None
     if state not in STATES:
         raise LedgerError(f"{label}.state must be one of: {', '.join(sorted(STATES))}")
+    phase = nonempty_string(value.get("phase"), f"{label}.phase")
+    assert phase is not None
+    if phase not in PHASES:
+        raise LedgerError(f"{label}.phase must be one of: {', '.join(sorted(PHASES))}")
     gate = nonempty_string(value.get("public_mutation_gate"), f"{label}.public_mutation_gate")
     assert gate is not None
     if gate not in GATES:
         raise LedgerError(f"{label}.public_mutation_gate must be one of: {', '.join(sorted(GATES))}")
     gate_action = nonempty_string(
-        value.get("public_mutation_action"),
-        f"{label}.public_mutation_action",
-        nullable=True,
+        value.get("public_mutation_action"), f"{label}.public_mutation_action", nullable=True
     )
     if gate == "closed" and gate_action is not None:
         raise LedgerError(f"{label}.public_mutation_action must be null when the gate is closed")
     if gate != "closed" and gate_action is None:
         raise LedgerError(f"{label}.public_mutation_action is required when the gate is {gate}")
-    evidence = value.get("completion_evidence")
-    if not isinstance(evidence, list):
-        raise LedgerError(f"{label}.completion_evidence must be an array")
+
+    evidence_value = value.get("evidence")
+    if not isinstance(evidence_value, list):
+        raise LedgerError(f"{label}.evidence must be an array")
+    evidence = [
+        validate_evidence(item, f"{label}.evidence[{evidence_index}]")
+        for evidence_index, item in enumerate(evidence_value)
+    ]
     if state == "complete":
         if not evidence:
-            raise LedgerError(f"{label}.state complete requires completion evidence")
+            raise LedgerError(f"{label}.state complete requires evidence")
         if value.get("next_action") is not None:
             raise LedgerError(f"{label}.state complete requires next_action null")
         if value.get("decision_needed") is not None:
             raise LedgerError(f"{label}.state complete requires decision_needed null")
     if gate == "complete" and not evidence:
-        raise LedgerError(f"{label}.public_mutation_gate complete requires completion evidence")
-    execution_owner = nonempty_string(value.get("execution_owner"), f"{label}.execution_owner")
-    control_writer = nonempty_string(
-        value.get("control_writer", execution_owner),
-        f"{label}.control_writer",
-    )
-    control_revision = value.get("control_revision", 1)
-    if isinstance(control_revision, bool) or not isinstance(control_revision, int) or control_revision < 1:
+        raise LedgerError(f"{label}.public_mutation_gate complete requires evidence")
+
+    revision = value.get("control_revision")
+    if isinstance(revision, bool) or not isinstance(revision, int) or revision < 1:
         raise LedgerError(f"{label}.control_revision must be a positive integer")
-    raw_grants = value.get("control_edit_grants", [])
-    if not isinstance(raw_grants, list):
-        raise LedgerError(f"{label}.control_edit_grants must be an array")
-    grants = [
-        validate_control_grant(
-            item,
-            f"{label}.control_edit_grants[{grant_index}]",
-            legacy=legacy,
-        )
-        for grant_index, item in enumerate(raw_grants)
-    ]
-    grant_actors = [grant["actor"] for grant in grants]
-    if len(set(grant_actors)) != len(grant_actors):
-        raise LedgerError(f"{label}.control_edit_grants actors must be unique")
-    recovery_circuits = validate_recovery_circuits(
-        value.get("recovery_circuits", []),
-        f"{label}.recovery_circuits",
-    )
     created = parse_timestamp(value.get("created_at"), f"{label}.created_at")
     updated = parse_timestamp(value.get("updated_at"), f"{label}.updated_at")
-    assert created and updated
+    verified = parse_timestamp(value.get("last_verified_at"), f"{label}.last_verified_at")
+    assert created and updated and verified
     if datetime.fromisoformat(updated.replace("Z", "+00:00")) < datetime.fromisoformat(
         created.replace("Z", "+00:00")
     ):
         raise LedgerError(f"{label}.updated_at must not precede created_at")
+
     return {
         "id": validate_id(value.get("id"), f"{label}.id"),
         "goal": nonempty_string(value.get("goal"), f"{label}.goal"),
-        "execution_owner": execution_owner,
+        "anchors": string_list(value.get("anchors"), f"{label}.anchors"),
+        "control_documents": string_list(
+            value.get("control_documents"), f"{label}.control_documents"
+        ),
+        "phase": phase,
+        "execution_owner": nonempty_string(value.get("execution_owner"), f"{label}.execution_owner"),
         "worker_id": nonempty_string(value.get("worker_id"), f"{label}.worker_id", nullable=True),
         "state": state,
         "next_action": nonempty_string(value.get("next_action"), f"{label}.next_action", nullable=True),
         "next_check_at": parse_timestamp(
-            value.get("next_check_at"),
-            f"{label}.next_check_at",
-            nullable=True,
+            value.get("next_check_at"), f"{label}.next_check_at", nullable=True
         ),
-        "completion_evidence": [
-            validate_evidence(item, f"{label}.completion_evidence[{evidence_index}]")
-            for evidence_index, item in enumerate(evidence)
-        ],
+        "evidence": evidence,
         "public_mutation_gate": gate,
         "public_mutation_action": gate_action,
         "decision_needed": validate_decision(value.get("decision_needed"), f"{label}.decision_needed"),
-        "control_writer": control_writer,
-        "control_revision": control_revision,
-        "control_edit_grants": grants,
-        "recovery_circuits": recovery_circuits,
+        "control_writer": nonempty_string(value.get("control_writer"), f"{label}.control_writer"),
+        "control_revision": revision,
+        "recovery_circuits": validate_recovery_circuits(
+            value.get("recovery_circuits"), f"{label}.recovery_circuits"
+        ),
         "created_at": created,
         "updated_at": updated,
+        "last_verified_at": verified,
     }
 
+
 def validate_ledger(value: object) -> dict[str, Any]:
     if not isinstance(value, dict):
         raise LedgerError("ledger must be a JSON object")
     check_unknown(value, {"schema_version", "updated_at", "goals"}, "ledger")
     schema_version = value.get("schema_version")
-    if schema_version not in LEGACY_SCHEMA_VERSIONS | {SCHEMA_VERSION}:
-        legacy_text = ", ".join(str(item) for item in sorted(LEGACY_SCHEMA_VERSIONS))
+    if (
+        isinstance(schema_version, bool)
+        or not isinstance(schema_version, int)
+        or schema_version not in LEGACY_SCHEMA_VERSIONS | {SCHEMA_VERSION}
+    ):
+        legacy = ", ".join(str(item) for item in sorted(LEGACY_SCHEMA_VERSIONS))
         raise LedgerError(
             f"ledger requires schema_version {SCHEMA_VERSION} "
-            f"(legacy {legacy_text} is migrated on load)"
+            f"(legacy {legacy} is migrated on load)"
         )
     goals = value.get("goals")
     if not isinstance(goals, list):
         raise LedgerError("ledger.goals must be an array")
-    normalized_goals: list[object] = []
-    for raw_goal in goals:
-        if not isinstance(raw_goal, dict):
-            normalized_goals.append(raw_goal)
-            continue
-        goal = dict(raw_goal)
-        if "recovery_circuit" in goal and "recovery_circuits" not in goal:
-            goal["recovery_circuits"] = [goal.pop("recovery_circuit")]
-        if schema_version in LEGACY_SCHEMA_VERSIONS:
-            updated_at = goal.get("updated_at")
-            if isinstance(updated_at, str):
-                goal["recovery_circuits"] = [
-                    migrate_recovery_circuit(item, updated_at)
-                    for item in goal.get("recovery_circuits", [])
-                ]
-        normalized_goals.append(goal)
-    validated = [
-        validate_goal(goal, index, legacy=schema_version in LEGACY_SCHEMA_VERSIONS)
-        for index, goal in enumerate(normalized_goals)
-    ]
+    normalized = [migrate_goal(goal, schema_version) for goal in goals]
+    validated = [validate_goal(goal, index) for index, goal in enumerate(normalized)]
     ids = [goal["id"] for goal in validated]
-    if len(set(ids)) != len(ids):
+    if len(ids) != len(set(ids)):
         raise LedgerError("ledger goal ids must be unique")
     return {
         "schema_version": SCHEMA_VERSION,
diff --git a/scripts/_orchestration_ledger_mutation.py b/scripts/_orchestration_ledger_mutation.py
index 5808dc74..9b217cf1 100644
--- a/scripts/_orchestration_ledger_mutation.py
+++ b/scripts/_orchestration_ledger_mutation.py
@@ -1,21 +1,21 @@
 from __future__ import annotations
 
 import argparse
-import json
-import os
-import re
-import stat
-import sys
-import tempfile
-from contextlib import contextmanager
-from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any, Iterator, Sequence
+from typing import Any
 
 from _orchestration_ledger_core import *
-from _orchestration_ledger_model import *
+from _orchestration_ledger_model import validate_ledger
 from _orchestration_ledger_storage import *
 
+
+def circuit_index(circuits: list[dict[str, Any]], slice_label: str) -> int | None:
+    return next(
+        (index for index, item in enumerate(circuits) if item["slice_label"] == slice_label),
+        None,
+    )
+
+
 def mutate(args: argparse.Namespace, path: Path) -> tuple[dict[str, Any], str]:
     existing = load_ledger(path, allow_missing=True)
     if args.command == "init":
@@ -28,39 +28,42 @@ def mutate(args: argparse.Namespace, path: Path) -> tuple[dict[str, Any], str]:
         if any(goal["id"] == goal_id for goal in ledger["goals"]):
             raise LedgerError(f"goal already exists: {goal_id}")
         now = utc_now()
-        control_writer = nonempty_string(
-            args.control_writer if args.control_writer is not None else args.execution_owner,
-            "control writer",
-        )
+        writer = nonempty_string(args.control_writer, "control writer")
+        assert writer is not None
         ledger["goals"].append(
             {
                 "id": goal_id,
                 "goal": nonempty_string(args.goal, "goal"),
+                "anchors": string_list(args.anchor, "anchors", require_item=True),
+                "control_documents": string_list(
+                    args.control_document, "control documents", require_item=True
+                ),
+                "phase": args.phase,
                 "execution_owner": nonempty_string(args.execution_owner, "execution owner"),
                 "worker_id": nonempty_string(args.worker_id, "worker id", nullable=True),
                 "state": args.state,
                 "next_action": None,
                 "next_check_at": None,
-                "completion_evidence": [],
+                "evidence": [],
                 "public_mutation_gate": "closed",
                 "public_mutation_action": None,
                 "decision_needed": None,
-                "control_writer": control_writer,
+                "control_writer": writer,
                 "control_revision": args.control_revision,
-                "control_edit_grants": [],
                 "recovery_circuits": [],
                 "created_at": now,
                 "updated_at": now,
+                "last_verified_at": now,
             }
         )
         ledger["updated_at"] = now
-        return ledger, f"initialized goal {goal_id}"
+        return validate_ledger(ledger), f"initialized goal {goal_id} for principal {writer}"
 
     if existing is None:
         raise LedgerError(f"orchestration ledger is missing: {path}")
     ledger = existing
     goal = goal_by_id(ledger, validate_id(args.goal_id))
-    authorize_mutation(args, goal)
+    actor = authorize_mutation(args, goal)
 
     if args.command == "set-owner":
         goal["execution_owner"] = nonempty_string(args.execution_owner, "execution owner")
@@ -69,6 +72,15 @@ def mutate(args: argparse.Namespace, path: Path) -> tuple[dict[str, Any], str]:
         elif args.worker_id is not None:
             goal["worker_id"] = nonempty_string(args.worker_id, "worker id")
         message = f"set {goal['id']} execution owner"
+    elif args.command == "set-phase":
+        goal["phase"] = args.phase
+        message = f"set {goal['id']} phase to {args.phase}"
+    elif args.command == "set-links":
+        goal["anchors"] = string_list(args.anchor, "anchors", require_item=True)
+        goal["control_documents"] = string_list(
+            args.control_document, "control documents", require_item=True
+        )
+        message = f"set {goal['id']} anchors and control documents"
     elif args.command == "set-state":
         goal["state"] = args.state
         message = f"set {goal['id']} state to {args.state}"
@@ -82,15 +94,23 @@ def mutate(args: argparse.Namespace, path: Path) -> tuple[dict[str, Any], str]:
             goal["next_check_at"] = parse_timestamp(args.check_at, "next check", nullable=True)
             message = f"set {goal['id']} next action"
     elif args.command == "add-evidence":
-        goal["completion_evidence"].append(
+        now = utc_now()
+        observed = parse_timestamp(args.observed_at, "observed at", nullable=True) or now
+        goal["evidence"].append(
             {
                 "kind": args.kind,
                 "summary": nonempty_string(args.summary, "evidence summary"),
                 "locator": nonempty_string(args.locator, "evidence locator", nullable=True),
-                "recorded_at": utc_now(),
+                "producer": nonempty_string(args.producer, "evidence producer", nullable=True),
+                "observed_at": observed,
+                "verified_by": actor,
+                "recorded_at": now,
             }
         )
-        message = f"added evidence to {goal['id']}"
+        goal["last_verified_at"] = max(
+            item["observed_at"] for item in goal["evidence"]
+        )
+        message = f"added principal-verified evidence to {goal['id']}"
     elif args.command == "set-gate":
         goal["public_mutation_gate"] = args.gate
         if args.gate == "closed":
@@ -98,14 +118,11 @@ def mutate(args: argparse.Namespace, path: Path) -> tuple[dict[str, Any], str]:
                 raise LedgerError("--action is not allowed when closing the public mutation gate")
             goal["public_mutation_action"] = None
         else:
-            goal["public_mutation_action"] = nonempty_string(
-                args.action,
-                "public mutation action",
-            )
+            goal["public_mutation_action"] = nonempty_string(args.action, "public mutation action")
         message = f"set {goal['id']} public mutation gate to {args.gate}"
     elif args.command == "set-decision":
-        options = [nonempty_string(option, "decision option") for option in args.option]
-        if len(options) < 2 or len(set(options)) != len(options):
+        options = string_list(args.option, "decision options", require_item=True)
+        if len(options) < 2:
             raise LedgerError("decision requires at least two unique options")
         goal["decision_needed"] = {
             "question": nonempty_string(args.question, "decision question"),
@@ -116,113 +133,66 @@ def mutate(args: argparse.Namespace, path: Path) -> tuple[dict[str, Any], str]:
     elif args.command == "clear-decision":
         goal["decision_needed"] = None
         message = f"cleared decision for {goal['id']}"
-    elif args.command == "set-grant":
-        grant_actor = nonempty_string(args.grant_actor, "grant actor")
-        mutations = [nonempty_string(item, "grant mutation") for item in args.mutations]
-        assert all(item is not None for item in mutations)
-        unsupported = sorted(set(mutations) - GRANTABLE_MUTATION_COMMANDS)
-        if unsupported:
-            raise LedgerError(f"grant mutations contain unsupported commands: {', '.join(unsupported)}")
-        if len(set(mutations)) != len(mutations):
-            raise LedgerError("grant mutations must be unique")
-        goal["control_edit_grants"] = [
-            grant
-            for grant in goal["control_edit_grants"]
-            if grant["actor"] != grant_actor
-        ]
-        goal["control_edit_grants"].append(
-            {"actor": grant_actor, "mutations": mutations}
-        )
-        message = f"set control edit grant for {grant_actor} on {goal['id']}"
-    elif args.command == "clear-grant":
-        grant_actor = nonempty_string(args.grant_actor, "grant actor")
-        before = len(goal["control_edit_grants"])
-        goal["control_edit_grants"] = [
-            grant
-            for grant in goal["control_edit_grants"]
-            if grant["actor"] != grant_actor
-        ]
-        if len(goal["control_edit_grants"]) == before:
-            raise LedgerError(f"no control edit grant for actor {grant_actor}")
-        message = f"cleared control edit grant for {grant_actor} on {goal['id']}"
     elif args.command in {
-        "claim-successor",
-        "record-successor-failure",
-        "record-successor-success",
+        "begin-recovery",
+        "record-recovery-failure",
+        "record-recovery-success",
         "reset-recovery",
     }:
         circuits = goal["recovery_circuits"]
-        slice_label = nonempty_string(args.slice_label, "slice label")
-        assert slice_label is not None
-        current_index = next(
-            (
-                index
-                for index, circuit in enumerate(circuits)
-                if circuit["slice_label"] == slice_label
-            ),
-            None,
-        )
-        current = circuits[current_index] if current_index is not None else None
-        if args.command == "claim-successor":
+        label = nonempty_string(args.slice_label, "slice label")
+        assert label is not None
+        index = circuit_index(circuits, label)
+        current = circuits[index] if index is not None else None
+        if args.command == "begin-recovery":
             if current is not None and current["state"] == "open":
-                raise LedgerError(f"recovery circuit is open for slice {slice_label}")
-            if current is not None and current["state"] == "claimed":
-                raise LedgerError(f"successor is already claimed for slice {slice_label}")
-            updated = dict(current or empty_circuit(slice_label))
-            updated["state"] = "claimed"
-            updated["claimed_by"] = args.actor
-            message = f"claimed successor for {goal['id']} slice {slice_label}"
-        elif args.command == "record-successor-failure":
-            if current is None or current["state"] != "claimed":
-                raise LedgerError(f"slice {slice_label} must be claimed before recording failure")
-            if current["claimed_by"] != args.actor:
-                raise LedgerError(
-                    f"actor {args.actor} does not own the claim for slice {slice_label}"
-                )
-            failure_evidence = nonempty_string(args.failure_evidence, "failure evidence")
-            assert failure_evidence is not None
+                raise LedgerError(f"recovery circuit is open for slice {label}")
+            if current is not None and current["state"] == "active":
+                raise LedgerError(f"recovery is already active for slice {label}")
+            updated = dict(current or empty_circuit(label))
+            updated["state"] = "active"
+            updated["assigned_worker"] = nonempty_string(args.worker_id, "worker id")
+            message = f"began recovery for {goal['id']} slice {label}"
+        elif args.command == "record-recovery-failure":
+            if current is None or current["state"] != "active":
+                raise LedgerError(f"slice {label} must be active before recording failure")
             updated = dict(current)
-            updated["last_failure_evidence"] = failure_evidence
+            updated["last_failure_evidence"] = nonempty_string(
+                args.failure_evidence, "failure evidence"
+            )
             updated["last_failure_at"] = utc_now()
-            updated["claimed_by"] = None
+            updated["assigned_worker"] = None
             if args.no_new_evidence:
                 updated["state"] = "open"
                 updated["last_reset_evidence"] = None
                 updated["last_reset_at"] = None
             else:
-                discriminating = nonempty_string(
-                    args.discriminating_evidence,
-                    "discriminating evidence",
-                )
-                assert discriminating is not None
                 updated["state"] = "closed"
-                updated["last_reset_evidence"] = discriminating
-                updated["last_reset_at"] = utc_now()
-            message = f"recorded successor failure for {goal['id']} slice {slice_label}"
-        elif args.command == "record-successor-success":
-            if current is None or current["state"] != "claimed":
-                raise LedgerError(f"slice {slice_label} must be claimed before recording success")
-            if current["claimed_by"] != args.actor:
-                raise LedgerError(
-                    f"actor {args.actor} does not own the claim for slice {slice_label}"
+                updated["last_reset_evidence"] = nonempty_string(
+                    args.discriminating_evidence, "discriminating evidence"
                 )
-            updated = empty_circuit(slice_label)
-            message = f"recorded successor success for {goal['id']} slice {slice_label}"
+                updated["last_reset_at"] = utc_now()
+            message = f"recorded recovery failure for {goal['id']} slice {label}"
+        elif args.command == "record-recovery-success":
+            if current is None or current["state"] != "active":
+                raise LedgerError(f"slice {label} must be active before recording success")
+            updated = empty_circuit(label)
+            message = f"recorded recovery success for {goal['id']} slice {label}"
         else:
-            evidence = nonempty_string(args.root_cause_evidence, "root-cause evidence")
-            assert evidence is not None
-            updated = dict(current or empty_circuit(slice_label))
+            updated = dict(current or empty_circuit(label))
             updated["state"] = "closed"
-            updated["claimed_by"] = None
-            updated["last_reset_evidence"] = evidence
+            updated["assigned_worker"] = None
+            updated["last_reset_evidence"] = nonempty_string(
+                args.root_cause_evidence, "root-cause evidence"
+            )
             updated["last_reset_at"] = utc_now()
-            message = f"reset recovery for {goal['id']} slice {slice_label}"
-        if current_index is None:
+            message = f"reset recovery for {goal['id']} slice {label}"
+        if index is None:
             circuits.append(updated)
         else:
-            circuits[current_index] = updated
+            circuits[index] = updated
     else:
         raise LedgerError(f"unsupported mutation: {args.command}")
 
     touch(ledger, goal)
-    return ledger, message
+    return validate_ledger(ledger), message
diff --git a/scripts/_orchestration_ledger_parser.py b/scripts/_orchestration_ledger_parser.py
index 65cb4640..dae0e9f7 100644
--- a/scripts/_orchestration_ledger_parser.py
+++ b/scripts/_orchestration_ledger_parser.py
@@ -1,25 +1,19 @@
 from __future__ import annotations
 
 import argparse
-import json
-import os
-import re
-import stat
-import sys
-import tempfile
-from contextlib import contextmanager
-from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any, Iterator, Sequence
+from typing import Sequence
 
 from _orchestration_ledger_core import *
 
+
 def add_common_options(parser: argparse.ArgumentParser) -> None:
     parser.add_argument("--root", type=Path, default=Path(__file__).resolve().parents[1])
     parser.add_argument("--ledger", type=Path)
 
+
 def add_mutation_auth_options(parser: argparse.ArgumentParser) -> None:
-    parser.add_argument("--actor", "--control-actor", required=True)
+    parser.add_argument("--actor", "--principal", required=True)
     parser.add_argument(
         "--expected-revision",
         "--expected-control-revision",
@@ -29,6 +23,7 @@ def add_mutation_auth_options(parser: argparse.ArgumentParser) -> None:
         type=int,
     )
 
+
 def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
     parser = argparse.ArgumentParser(description=__doc__)
     add_common_options(parser)
@@ -45,8 +40,11 @@ def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
     init = subparsers.add_parser("init")
     init.add_argument("--goal-id", required=True)
     init.add_argument("--goal", required=True)
+    init.add_argument("--anchor", action="append", required=True)
+    init.add_argument("--control-document", action="append", required=True)
+    init.add_argument("--phase", choices=sorted(PHASES), default="planning")
     init.add_argument("--execution-owner", required=True)
-    init.add_argument("--control-writer", "--writer")
+    init.add_argument("--control-writer", "--principal", required=True)
     init.add_argument("--control-revision", type=int, default=1)
     init.add_argument("--worker-id")
     init.add_argument("--state", choices=sorted(STATES), default="planned")
@@ -59,6 +57,17 @@ def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
     worker_group.add_argument("--worker-id")
     worker_group.add_argument("--clear-worker", action="store_true")
 
+    phase = subparsers.add_parser("set-phase")
+    add_mutation_auth_options(phase)
+    phase.add_argument("--goal-id", required=True)
+    phase.add_argument("--phase", choices=sorted(PHASES), required=True)
+
+    links = subparsers.add_parser("set-links")
+    add_mutation_auth_options(links)
+    links.add_argument("--goal-id", required=True)
+    links.add_argument("--anchor", action="append", required=True)
+    links.add_argument("--control-document", action="append", required=True)
+
     state = subparsers.add_parser("set-state")
     add_mutation_auth_options(state)
     state.add_argument("--goal-id", required=True)
@@ -78,6 +87,8 @@ def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
     evidence.add_argument("--kind", choices=sorted(EVIDENCE_KINDS), required=True)
     evidence.add_argument("--summary", required=True)
     evidence.add_argument("--locator")
+    evidence.add_argument("--producer")
+    evidence.add_argument("--observed-at")
 
     gate = subparsers.add_parser("set-gate")
     add_mutation_auth_options(gate)
@@ -95,31 +106,13 @@ def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
     add_mutation_auth_options(clear_decision)
     clear_decision.add_argument("--goal-id", required=True)
 
-    grant = subparsers.add_parser("set-grant", aliases=["set-control-grant"])
-    add_mutation_auth_options(grant)
-    grant.add_argument("--goal-id", required=True)
-    grant.add_argument("--grant-actor", "--granted-actor", required=True)
-    grant.add_argument(
-        "--mutation",
-        "--command",
-        "--edit",
-        "--grant-mutation",
-        dest="mutations",
-        action="append",
-        required=True,
-    )
-
-    clear_grant = subparsers.add_parser("clear-grant", aliases=["clear-control-grant"])
-    add_mutation_auth_options(clear_grant)
-    clear_grant.add_argument("--goal-id", required=True)
-    clear_grant.add_argument("--grant-actor", "--granted-actor", required=True)
-
-    claim = subparsers.add_parser("claim-successor")
-    add_mutation_auth_options(claim)
-    claim.add_argument("--goal-id", required=True)
-    claim.add_argument("--slice-label", required=True)
+    begin = subparsers.add_parser("begin-recovery")
+    add_mutation_auth_options(begin)
+    begin.add_argument("--goal-id", required=True)
+    begin.add_argument("--slice-label", required=True)
+    begin.add_argument("--worker-id", required=True)
 
-    failure = subparsers.add_parser("record-successor-failure")
+    failure = subparsers.add_parser("record-recovery-failure")
     add_mutation_auth_options(failure)
     failure.add_argument("--goal-id", required=True)
     failure.add_argument("--slice-label", required=True)
@@ -128,7 +121,7 @@ def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
     failure_route.add_argument("--discriminating-evidence")
     failure_route.add_argument("--no-new-evidence", action="store_true")
 
-    success = subparsers.add_parser("record-successor-success")
+    success = subparsers.add_parser("record-recovery-success")
     add_mutation_auth_options(success)
     success.add_argument("--goal-id", required=True)
     success.add_argument("--slice-label", required=True)
@@ -137,12 +130,7 @@ def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
     add_mutation_auth_options(reset)
     reset.add_argument("--goal-id", required=True)
     reset.add_argument("--slice-label", required=True)
-    reset.add_argument(
-        "--root-cause-evidence",
-        "--root-cause-evidence-locator",
-        "--evidence-locator",
-        required=True,
-    )
+    reset.add_argument("--root-cause-evidence", required=True)
 
     recovery_check = subparsers.add_parser("check-recovery")
     recovery_check.add_argument("--goal-id", required=True)
@@ -150,12 +138,8 @@ def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
     recovery_check.add_argument("--json", action="store_true")
 
     args = parser.parse_args(argv)
-    args.command = {
-        "set-control-grant": "set-grant",
-        "clear-control-grant": "clear-grant",
-    }.get(args.command, args.command)
     if getattr(args, "json", False) and getattr(args, "plain", False):
         parser.error("choose either --json or --plain")
-    if args.command == "init" and (args.control_revision is None or args.control_revision < 1):
+    if args.command == "init" and args.control_revision < 1:
         parser.error("--control-revision must be a positive integer")
     return args
diff --git a/scripts/_orchestration_ledger_storage.py b/scripts/_orchestration_ledger_storage.py
index 42f73efa..044d2a58 100644
--- a/scripts/_orchestration_ledger_storage.py
+++ b/scripts/_orchestration_ledger_storage.py
@@ -1,19 +1,16 @@
 from __future__ import annotations
 
-import argparse
 import json
 import os
-import re
 import stat
-import sys
 import tempfile
 from contextlib import contextmanager
-from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any, Iterator, Sequence
+from typing import Any, Iterator
 
 from _orchestration_ledger_core import *
-from _orchestration_ledger_model import *
+from _orchestration_ledger_model import validate_ledger
+
 
 def resolve_ledger_path(root: Path, raw: Path | None) -> tuple[Path, Path]:
     root = root.expanduser().resolve()
@@ -33,6 +30,7 @@ def resolve_ledger_path(root: Path, raw: Path | None) -> tuple[Path, Path]:
             raise LedgerError(f"ledger path must not traverse a symlink: {cursor}")
     return root, candidate
 
+
 def load_ledger(path: Path, *, allow_missing: bool = False) -> dict[str, Any] | None:
     try:
         raw = json.loads(path.read_text(encoding="utf-8-sig"))
@@ -46,12 +44,14 @@ def load_ledger(path: Path, *, allow_missing: bool = False) -> dict[str, Any] |
         ) from error
     return validate_ledger(raw)
 
+
 def set_private_mode(path: Path, directory: bool) -> None:
     try:
         path.chmod(stat.S_IRUSR | stat.S_IWUSR | (stat.S_IXUSR if directory else 0))
     except OSError:
         pass
 
+
 @contextmanager
 def ledger_lock(path: Path) -> Iterator[None]:
     path.parent.mkdir(parents=True, exist_ok=True)
@@ -75,6 +75,7 @@ def ledger_lock(path: Path) -> Iterator[None]:
         except FileNotFoundError:
             pass
 
+
 def write_ledger(path: Path, ledger: dict[str, Any]) -> None:
     ledger = validate_ledger(ledger)
     path.parent.mkdir(parents=True, exist_ok=True)
@@ -83,9 +84,7 @@ def write_ledger(path: Path, ledger: dict[str, Any]) -> None:
     set_private_mode(path.parent, True)
     payload = (json.dumps(ledger, indent=2, sort_keys=False) + "\n").encode("utf-8")
     descriptor, temporary_name = tempfile.mkstemp(
-        prefix=f".{path.name}.",
-        suffix=".tmp",
-        dir=path.parent,
+        prefix=f".{path.name}.", suffix=".tmp", dir=path.parent
     )
     temporary = Path(temporary_name)
     try:
@@ -100,14 +99,17 @@ def write_ledger(path: Path, ledger: dict[str, Any]) -> None:
         if temporary.exists():
             temporary.unlink()
 
+
 def goal_by_id(ledger: dict[str, Any], goal_id: str) -> dict[str, Any]:
     for goal in ledger["goals"]:
         if goal["id"] == goal_id:
             return goal
     raise LedgerError(f"unknown goal id: {goal_id}")
 
-def authorize_mutation(args: argparse.Namespace, goal: dict[str, Any]) -> None:
+
+def authorize_mutation(args: Any, goal: dict[str, Any]) -> str:
     actor = nonempty_string(getattr(args, "actor", None), "actor")
+    assert actor is not None
     expected_revision = getattr(args, "expected_revision", None)
     if isinstance(expected_revision, bool) or not isinstance(expected_revision, int) or expected_revision < 1:
         raise LedgerError("expected revision must be a positive integer")
@@ -116,17 +118,12 @@ def authorize_mutation(args: argparse.Namespace, goal: dict[str, Any]) -> None:
             f"stale control revision for {goal['id']}: "
             f"expected {expected_revision}, current {goal['control_revision']}"
         )
-    command = getattr(args, "command", None)
-    if command in CONTROL_ONLY_MUTATIONS:
-        if actor != goal["control_writer"]:
-            raise LedgerError(f"only control writer may mutate {goal['id']} with {command}")
-        return
-    if actor == goal["control_writer"]:
-        return
-    for grant in goal["control_edit_grants"]:
-        if grant["actor"] == actor and command in grant["mutations"]:
-            return
-    raise LedgerError(f"actor {actor} is not authorized to mutate {goal['id']} with {command}")
+    if actor != goal["control_writer"]:
+        raise LedgerError(
+            f"only principal control writer {goal['control_writer']} may mutate {goal['id']}"
+        )
+    return actor
+
 
 def touch(ledger: dict[str, Any], goal: dict[str, Any]) -> None:
     now = utc_now()
@@ -134,17 +131,19 @@ def touch(ledger: dict[str, Any], goal: dict[str, Any]) -> None:
     goal["control_revision"] += 1
     ledger["updated_at"] = now
 
+
 def empty_circuit(slice_label: str) -> dict[str, Any]:
     return {
         "slice_label": slice_label,
         "state": "closed",
+        "assigned_worker": None,
         "last_failure_evidence": None,
         "last_failure_at": None,
         "last_reset_evidence": None,
         "last_reset_at": None,
-        "claimed_by": None,
     }
 
+
 def status_payload(path: Path, ledger: dict[str, Any] | None, goal_id: str | None) -> dict[str, Any]:
     if ledger is None:
         return {
@@ -164,6 +163,7 @@ def status_payload(path: Path, ledger: dict[str, Any] | None, goal_id: str | Non
         "goals": goals,
     }
 
+
 def check_recovery(ledger: dict[str, Any], goal_id: str, slice_label: str) -> dict[str, Any]:
     goal = goal_by_id(ledger, validate_id(goal_id))
     label = nonempty_string(slice_label, "slice label")
@@ -175,10 +175,11 @@ def check_recovery(ledger: dict[str, Any], goal_id: str, slice_label: str) -> di
     if circuit is not None and circuit["state"] == "open":
         raise LedgerError(
             f"recovery circuit is open for {goal['id']} slice {label}; "
-            "no new discriminating evidence supports another successor"
+            "a changed hypothesis, input, runtime path, or root-cause finding is required"
         )
     return circuit or empty_circuit(label)
 
+
 def render_status(payload: dict[str, Any], plain: bool) -> str:
     if not payload["present"]:
         if plain:
@@ -196,24 +197,30 @@ def render_status(payload: dict[str, Any], plain: bool) -> str:
                 " ".join(
                     [
                         f"goal={goal['id']}",
+                        f"phase={goal['phase']}",
                         f"state={goal['state']}",
                         f"owner={goal['execution_owner']}",
-                        f"writer={goal['control_writer']}",
+                        f"principal={goal['control_writer']}",
                         f"revision={goal['control_revision']}",
                         f"worker={goal['worker_id'] or 'none'}",
                         f"gate={goal['public_mutation_gate']}",
-                        f"evidence={len(goal['completion_evidence'])}",
+                        f"evidence={len(goal['evidence'])}",
                         f"decision={'yes' if decision else 'no'}",
                     ]
                 )
             )
             continue
         lines.append(
-            f"{goal['id']}: {goal['state']} | owner {goal['execution_owner']} | "
-            f"writer {goal['control_writer']} rev {goal['control_revision']} | "
+            f"{goal['id']}: {goal['phase']} | {goal['state']} | "
+            f"principal {goal['control_writer']} rev {goal['control_revision']} | "
             f"gate {goal['public_mutation_gate']}"
         )
         lines.append(f"  goal: {goal['goal']}")
+        lines.append(f"  last verified: {goal['last_verified_at']}")
+        for anchor in goal["anchors"]:
+            lines.append(f"  anchor: {anchor}")
+        for document in goal["control_documents"]:
+            lines.append(f"  control: {document}")
         if goal["worker_id"]:
             lines.append(f"  worker: {goal['worker_id']}")
         if goal["public_mutation_action"]:
@@ -221,15 +228,15 @@ def render_status(payload: dict[str, Any], plain: bool) -> str:
         if goal["next_action"]:
             suffix = f" at {goal['next_check_at']}" if goal["next_check_at"] else ""
             lines.append(f"  next: {goal['next_action']}{suffix}")
-        lines.append(f"  evidence: {len(goal['completion_evidence'])}")
+        lines.append(f"  evidence: {len(goal['evidence'])}")
         for circuit in goal["recovery_circuits"]:
             lines.append(f"  recovery: {circuit['slice_label']} | {circuit['state']}")
+            if circuit["assigned_worker"]:
+                lines.append(f"    worker: {circuit['assigned_worker']}")
             if circuit["last_failure_evidence"]:
                 lines.append(f"    last failure: {circuit['last_failure_evidence']}")
             if circuit["last_reset_evidence"]:
                 lines.append(f"    resume evidence: {circuit['last_reset_evidence']}")
-            if circuit["claimed_by"]:
-                lines.append(f"    claimed by: {circuit['claimed_by']}")
         if decision:
             lines.append(f"  decision: {decision['question']}")
             for option in decision["options"]:
diff --git a/scripts/_test_orchestration_ledger_cases1.py b/scripts/_test_orchestration_ledger_cases1.py
deleted file mode 100644
index a0c6e8a6..00000000
--- a/scripts/_test_orchestration_ledger_cases1.py
+++ /dev/null
@@ -1,270 +0,0 @@
-from __future__ import annotations
-
-from _test_orchestration_ledger_common import *
-
-class OrchestrationLedgerTests1(unittest.TestCase):
-    def test_status_reports_absent_without_creating_state(self) -> None:
-            with tempfile.TemporaryDirectory() as directory:
-                root = Path(directory)
-                code, stdout, stderr = run_cli("--root", str(root), "status", "--json")
-                self.assertEqual(code, 0, stderr)
-                self.assertFalse(json.loads(stdout)["present"])
-                self.assertFalse((root / ".local").exists())
-
-    def test_control_lifecycle_and_private_file(self) -> None:
-            with tempfile.TemporaryDirectory() as directory:
-                root = Path(directory)
-                init_goal(root, "release")
-                self.assertEqual(
-                    run_mutation(
-                        root,
-                        "set-owner",
-                        "--goal-id",
-                        "release",
-                        "--execution-owner",
-                        "worker-2",
-                        "--worker-id",
-                        "thread-2",
-                    )[0],
-                    0,
-                )
-                self.assertEqual(
-                    run_mutation(
-                        root,
-                        "set-next",
-                        "--goal-id",
-                        "release",
-                        "--action",
-                        "Run final proof",
-                        "--check-at",
-                        "2026-07-12T12:00:00Z",
-                    )[0],
-                    0,
-                )
-                self.assertEqual(
-                    run_mutation(
-                        root,
-                        "add-evidence",
-                        "--goal-id",
-                        "release",
-                        "--kind",
-                        "test",
-                        "--summary",
-                        "Checks passed",
-                        "--locator",
-                        "run:835",
-                    )[0],
-                    0,
-                )
-                self.assertEqual(
-                    run_mutation(
-                        root,
-                        "set-gate",
-                        "--goal-id",
-                        "release",
-                        "--gate",
-                        "authorized",
-                        "--action",
-                        "merge PR 42",
-                    )[0],
-                    0,
-                )
-                self.assertEqual(
-                    run_mutation(
-                        root,
-                        "set-decision",
-                        "--goal-id",
-                        "release",
-                        "--question",
-                        "Which channel?",
-                        "--option",
-                        "stable",
-                        "--option",
-                        "beta",
-                    )[0],
-                    0,
-                )
-                code, stdout, error = run_cli(
-                    "--root",
-                    str(root),
-                    "status",
-                    "--goal-id",
-                    "release",
-                    "--json",
-                )
-                self.assertEqual(code, 0, error)
-                goal = json.loads(stdout)["goals"][0]
-                self.assertEqual(goal["execution_owner"], "worker-2")
-                self.assertEqual(goal["worker_id"], "thread-2")
-                self.assertEqual(goal["next_action"], "Run final proof")
-                self.assertEqual(goal["public_mutation_action"], "merge PR 42")
-                self.assertEqual(goal["decision_needed"]["options"], ["stable", "beta"])
-                self.assertEqual(run_cli("--root", str(root), "validate")[0], 0)
-                if os.name != "nt":
-                    mode = stat.S_IMODE(
-                        (root / ".local" / "orchestration-ledger.json").stat().st_mode
-                    )
-                    self.assertEqual(mode, 0o600)
-
-    def test_complete_requires_evidence_and_no_open_work(self) -> None:
-            with tempfile.TemporaryDirectory() as directory:
-                root = Path(directory)
-                init_goal(root, "proof")
-                code, _, error = run_mutation(
-                    root,
-                    "set-state",
-                    "--goal-id",
-                    "proof",
-                    "--state",
-                    "complete",
-                )
-                self.assertEqual(code, 1)
-                self.assertIn("requires completion evidence", error)
-                self.assertEqual(
-                    run_mutation(
-                        root,
-                        "add-evidence",
-                        "--goal-id",
-                        "proof",
-                        "--kind",
-                        "test",
-                        "--summary",
-                        "Final condition passed",
-                    )[0],
-                    0,
-                )
-                self.assertEqual(
-                    run_mutation(
-                        root,
-                        "set-next",
-                        "--goal-id",
-                        "proof",
-                        "--clear",
-                    )[0],
-                    0,
-                )
-                self.assertEqual(
-                    run_mutation(
-                        root,
-                        "set-state",
-                        "--goal-id",
-                        "proof",
-                        "--state",
-                        "complete",
-                    )[0],
-                    0,
-                )
-
-    def test_duplicate_goal_and_invalid_timestamp_are_rejected(self) -> None:
-            with tempfile.TemporaryDirectory() as directory:
-                root = Path(directory)
-                init_goal(root, "same")
-                code, _, error = run_cli(
-                    "--root",
-                    str(root),
-                    "init",
-                    "--goal-id",
-                    "same",
-                    "--goal",
-                    "Duplicate",
-                    "--execution-owner",
-                    "worker",
-                )
-                self.assertEqual(code, 1)
-                self.assertIn("goal already exists", error)
-                code, _, error = run_mutation(
-                    root,
-                    "set-next",
-                    "--goal-id",
-                    "same",
-                    "--action",
-                    "Wake later",
-                    "--check-at",
-                    "tomorrow",
-                )
-                self.assertEqual(code, 1)
-                self.assertIn("ISO 8601", error)
-
-    def test_ledger_path_escape_and_symlink_are_rejected(self) -> None:
-            with tempfile.TemporaryDirectory() as directory:
-                root = Path(directory)
-                code, _, error = run_cli(
-                    "--root",
-                    str(root),
-                    "--ledger",
-                    str(root / "outside.json"),
-                    "status",
-                )
-                self.assertEqual(code, 1)
-                self.assertIn("must stay under", error)
-                target = root / "target"
-                target.mkdir()
-                try:
-                    (root / ".local").symlink_to(target, target_is_directory=True)
-                except OSError:
-                    return
-                code, _, error = run_cli("--root", str(root), "status")
-                self.assertEqual(code, 1)
-                self.assertIn("must not traverse a symlink", error)
-
-    def test_authorization_revision_and_exact_grants(self) -> None:
-            with tempfile.TemporaryDirectory() as directory:
-                root = Path(directory)
-                init_goal(root, "auth")
-                code, _, error = run_cli(
-                    "--root",
-                    str(root),
-                    "set-state",
-                    "--goal-id",
-                    "auth",
-                    "--state",
-                    "waiting",
-                    "--actor",
-                    "intruder",
-                    "--expected-revision",
-                    "1",
-                )
-                self.assertEqual(code, 1)
-                self.assertIn("not authorized", error)
-                self.assertEqual(
-                    run_mutation(
-                        root,
-                        "set-grant",
-                        "--goal-id",
-                        "auth",
-                        "--grant-actor",
-                        "runner",
-                        "--mutation",
-                        "set-state",
-                    )[0],
-                    0,
-                )
-                code, _, error = run_cli(
-                    "--root",
-                    str(root),
-                    "set-state",
-                    "--goal-id",
-                    "auth",
-                    "--state",
-                    "waiting",
-                    "--actor",
-                    "runner",
-                    "--expected-revision",
-                    "2",
-                )
-                self.assertEqual(code, 0, error)
-                code, _, error = run_cli(
-                    "--root",
-                    str(root),
-                    "set-state",
-                    "--goal-id",
-                    "auth",
-                    "--state",
-                    "active",
-                    "--actor",
-                    "controller",
-                    "--expected-revision",
-                    "1",
-                )
-                self.assertEqual(code, 1)
-                self.assertIn("stale control revision", error)
diff --git a/scripts/_test_orchestration_ledger_cases2.py b/scripts/_test_orchestration_ledger_cases2.py
deleted file mode 100644
index 22633178..00000000
--- a/scripts/_test_orchestration_ledger_cases2.py
+++ /dev/null
@@ -1,281 +0,0 @@
-from __future__ import annotations
-
-from _test_orchestration_ledger_common import *
-
-class OrchestrationLedgerTests2(unittest.TestCase):
-    def test_failure_with_new_evidence_allows_changed_successor(self) -> None:
-            with tempfile.TemporaryDirectory() as directory:
-                root = Path(directory)
-                init_goal(root, "circuit")
-                self.assertEqual(
-                    run_mutation(
-                        root,
-                        "claim-successor",
-                        "--goal-id",
-                        "circuit",
-                        "--slice-label",
-                        "slice-a",
-                    )[0],
-                    0,
-                )
-                self.assertEqual(
-                    run_mutation(
-                        root,
-                        "record-successor-failure",
-                        "--goal-id",
-                        "circuit",
-                        "--slice-label",
-                        "slice-a",
-                        "--failure-evidence",
-                        "run:41",
-                        "--discriminating-evidence",
-                        "trace shows provider layer failed",
-                    )[0],
-                    0,
-                )
-                payload = json.loads(
-                    (root / ".local" / "orchestration-ledger.json").read_text()
-                )
-                circuit = payload["goals"][0]["recovery_circuits"][0]
-                self.assertEqual(circuit["state"], "closed")
-                self.assertEqual(circuit["last_failure_evidence"], "run:41")
-                self.assertEqual(
-                    circuit["last_reset_evidence"],
-                    "trace shows provider layer failed",
-                )
-                self.assertEqual(
-                    run_mutation(
-                        root,
-                        "claim-successor",
-                        "--goal-id",
-                        "circuit",
-                        "--slice-label",
-                        "slice-a",
-                    )[0],
-                    0,
-                )
-
-    def test_failure_without_new_evidence_opens_circuit(self) -> None:
-            with tempfile.TemporaryDirectory() as directory:
-                root = Path(directory)
-                init_goal(root, "circuit")
-                self.assertEqual(
-                    run_mutation(
-                        root,
-                        "claim-successor",
-                        "--goal-id",
-                        "circuit",
-                        "--slice-label",
-                        "slice-a",
-                    )[0],
-                    0,
-                )
-                self.assertEqual(
-                    run_mutation(
-                        root,
-                        "record-successor-failure",
-                        "--goal-id",
-                        "circuit",
-                        "--slice-label",
-                        "slice-a",
-                        "--failure-evidence",
-                        "run:42",
-                        "--no-new-evidence",
-                    )[0],
-                    0,
-                )
-                code, _, error = run_cli(
-                    "--root",
-                    str(root),
-                    "check-recovery",
-                    "--goal-id",
-                    "circuit",
-                    "--slice-label",
-                    "slice-a",
-                )
-                self.assertEqual(code, 1)
-                self.assertIn("no new discriminating evidence", error)
-                code, _, error = run_mutation(
-                    root,
-                    "claim-successor",
-                    "--goal-id",
-                    "circuit",
-                    "--slice-label",
-                    "slice-a",
-                )
-                self.assertEqual(code, 1)
-                self.assertIn("circuit is open", error)
-
-    def test_failure_requires_evidence_route_without_mutation(self) -> None:
-            with tempfile.TemporaryDirectory() as directory:
-                root = Path(directory)
-                init_goal(root, "circuit")
-                self.assertEqual(
-                    run_mutation(
-                        root,
-                        "claim-successor",
-                        "--goal-id",
-                        "circuit",
-                        "--slice-label",
-                        "slice-a",
-                    )[0],
-                    0,
-                )
-                revision = current_revision(root)
-                with self.assertRaises(SystemExit):
-                    ledger_module.parse_args(
-                        [
-                            "--root",
-                            str(root),
-                            "record-successor-failure",
-                            "--goal-id",
-                            "circuit",
-                            "--slice-label",
-                            "slice-a",
-                            "--failure-evidence",
-                            "run:43",
-                            "--actor",
-                            "controller",
-                            "--expected-revision",
-                            str(revision),
-                        ]
-                    )
-                self.assertEqual(current_revision(root), revision)
-
-    def test_only_claim_owner_may_record_outcome(self) -> None:
-            with tempfile.TemporaryDirectory() as directory:
-                root = Path(directory)
-                init_goal(root, "claim")
-                self.assertEqual(
-                    run_mutation(
-                        root,
-                        "set-grant",
-                        "--goal-id",
-                        "claim",
-                        "--grant-actor",
-                        "runner",
-                        "--mutation",
-                        "claim-successor",
-                        "--mutation",
-                        "record-successor-failure",
-                        "--mutation",
-                        "record-successor-success",
-                    )[0],
-                    0,
-                )
-                code, _, error = run_cli(
-                    "--root",
-                    str(root),
-                    "claim-successor",
-                    "--goal-id",
-                    "claim",
-                    "--slice-label",
-                    "a",
-                    "--actor",
-                    "runner",
-                    "--expected-revision",
-                    "2",
-                )
-                self.assertEqual(code, 0, error)
-                code, _, error = run_cli(
-                    "--root",
-                    str(root),
-                    "record-successor-success",
-                    "--goal-id",
-                    "claim",
-                    "--slice-label",
-                    "a",
-                    "--actor",
-                    "controller",
-                    "--expected-revision",
-                    "3",
-                )
-                self.assertEqual(code, 1)
-                self.assertIn("does not own the claim", error)
-
-    def test_writer_reset_requires_evidence_and_success_clears_state(self) -> None:
-            with tempfile.TemporaryDirectory() as directory:
-                root = Path(directory)
-                init_goal(root, "reset")
-                self.assertEqual(
-                    run_mutation(
-                        root,
-                        "claim-successor",
-                        "--goal-id",
-                        "reset",
-                        "--slice-label",
-                        "a",
-                    )[0],
-                    0,
-                )
-                self.assertEqual(
-                    run_mutation(
-                        root,
-                        "record-successor-failure",
-                        "--goal-id",
-                        "reset",
-                        "--slice-label",
-                        "a",
-                        "--failure-evidence",
-                        "run:44",
-                        "--no-new-evidence",
-                    )[0],
-                    0,
-                )
-                code, _, error = run_cli(
-                    "--root",
-                    str(root),
-                    "reset-recovery",
-                    "--goal-id",
-                    "reset",
-                    "--slice-label",
-                    "a",
-                    "--root-cause-evidence",
-                    "review:root",
-                    "--actor",
-                    "runner",
-                    "--expected-revision",
-                    str(current_revision(root)),
-                )
-                self.assertEqual(code, 1)
-                self.assertIn("only control writer", error)
-                self.assertEqual(
-                    run_mutation(
-                        root,
-                        "reset-recovery",
-                        "--goal-id",
-                        "reset",
-                        "--slice-label",
-                        "a",
-                        "--root-cause-evidence",
-                        "review:root",
-                    )[0],
-                    0,
-                )
-                self.assertEqual(
-                    run_mutation(
-                        root,
-                        "claim-successor",
-                        "--goal-id",
-                        "reset",
-                        "--slice-label",
-                        "a",
-                    )[0],
-                    0,
-                )
-                self.assertEqual(
-                    run_mutation(
-                        root,
-                        "record-successor-success",
-                        "--goal-id",
-                        "reset",
-                        "--slice-label",
-                        "a",
-                    )[0],
-                    0,
-                )
-                payload = json.loads(
-                    (root / ".local" / "orchestration-ledger.json").read_text()
-                )
-                circuit = payload["goals"][0]["recovery_circuits"][0]
-                self.assertEqual(circuit, ledger_module.empty_circuit("a"))
diff --git a/scripts/_test_orchestration_ledger_cases3.py b/scripts/_test_orchestration_ledger_cases3.py
deleted file mode 100644
index c1afc09d..00000000
--- a/scripts/_test_orchestration_ledger_cases3.py
+++ /dev/null
@@ -1,152 +0,0 @@
-from __future__ import annotations
-
-from _test_orchestration_ledger_common import *
-
-class OrchestrationLedgerTests3(unittest.TestCase):
-    def test_recovery_slices_are_independent(self) -> None:
-            with tempfile.TemporaryDirectory() as directory:
-                root = Path(directory)
-                init_goal(root, "slices")
-                for label, mode in (("a", "open"), ("b", "closed")):
-                    self.assertEqual(
-                        run_mutation(
-                            root,
-                            "claim-successor",
-                            "--goal-id",
-                            "slices",
-                            "--slice-label",
-                            label,
-                        )[0],
-                        0,
-                    )
-                    arguments = [
-                        "record-successor-failure",
-                        "--goal-id",
-                        "slices",
-                        "--slice-label",
-                        label,
-                        "--failure-evidence",
-                        f"run:{label}",
-                    ]
-                    if mode == "open":
-                        arguments.append("--no-new-evidence")
-                    else:
-                        arguments.extend(
-                            ["--discriminating-evidence", "new layer identified"]
-                        )
-                    self.assertEqual(run_mutation(root, *arguments)[0], 0)
-                payload = json.loads(
-                    (root / ".local" / "orchestration-ledger.json").read_text()
-                )
-                circuits = {
-                    item["slice_label"]: item
-                    for item in payload["goals"][0]["recovery_circuits"]
-                }
-                self.assertEqual(circuits["a"]["state"], "open")
-                self.assertEqual(circuits["b"]["state"], "closed")
-
-    def test_legacy_schema_versions_migrate(self) -> None:
-            now = "2026-07-11T12:00:00Z"
-            legacy_v1 = {
-                "schema_version": 1,
-                "updated_at": now,
-                "goals": [
-                    {
-                        "id": "legacy",
-                        "goal": "Migrate",
-                        "execution_owner": "worker",
-                        "worker_id": None,
-                        "state": "active",
-                        "next_action": None,
-                        "next_check_at": None,
-                        "completion_evidence": [],
-                        "public_mutation_gate": "closed",
-                        "public_mutation_action": None,
-                        "decision_needed": None,
-                        "created_at": now,
-                        "updated_at": now,
-                    }
-                ],
-            }
-            migrated = ledger_module.validate_ledger(legacy_v1)
-            self.assertEqual(migrated["schema_version"], 3)
-            self.assertEqual(migrated["goals"][0]["control_writer"], "worker")
-            self.assertEqual(migrated["goals"][0]["recovery_circuits"], [])
-
-            legacy_v2 = {
-                "schema_version": 2,
-                "updated_at": now,
-                "goals": [
-                    {
-                        **legacy_v1["goals"][0],
-                        "control_writer": "controller",
-                        "control_revision": 2,
-                        "control_edit_grants": [],
-                        "recovery_circuits": [
-                            {
-                                "slice_label": "a",
-                                "consecutive_successor_failures": 2,
-                                "state": "open",
-                                "last_reset_evidence": None,
-                                "last_reset_at": None,
-                                "claimed_by": None,
-                            }
-                        ],
-                    }
-                ],
-            }
-            migrated = ledger_module.validate_ledger(legacy_v2)
-            circuit = migrated["goals"][0]["recovery_circuits"][0]
-            self.assertEqual(migrated["schema_version"], 3)
-            self.assertEqual(circuit["state"], "open")
-            self.assertEqual(circuit["last_failure_evidence"], "migrated successor failure count: 2")
-            self.assertEqual(circuit["last_failure_at"], now)
-
-    def test_recovery_slice_labels_must_be_unique(self) -> None:
-            duplicate = ledger_module.empty_circuit("slice-a")
-            with self.assertRaisesRegex(
-                ledger_module.LedgerError,
-                "slice_label values must be unique",
-            ):
-                ledger_module.validate_recovery_circuits(
-                    [duplicate, dict(duplicate)],
-                    "circuits",
-                )
-
-    def test_unknown_fields_and_protected_legacy_grants_are_rejected(self) -> None:
-            with self.assertRaisesRegex(ledger_module.LedgerError, "unsupported fields"):
-                ledger_module.validate_ledger(
-                    {
-                        "schema_version": 3,
-                        "updated_at": "2026-07-11T12:00:00Z",
-                        "goals": [],
-                        "secret": "no",
-                    }
-                )
-            with tempfile.TemporaryDirectory() as directory:
-                root = Path(directory)
-                init_goal(root, "grant")
-                path = root / ".local" / "orchestration-ledger.json"
-                payload = json.loads(path.read_text())
-                payload["schema_version"] = 1
-                payload["goals"][0]["control_edit_grants"] = [
-                    {"actor": "runner", "mutations": ["set-grant", "reset-recovery"]}
-                ]
-                path.write_text(json.dumps(payload), encoding="utf-8")
-                code, _, error = run_cli(
-                    "--root",
-                    str(root),
-                    "set-grant",
-                    "--goal-id",
-                    "grant",
-                    "--grant-actor",
-                    "other",
-                    "--mutation",
-                    "set-state",
-                    "--actor",
-                    "runner",
-                    "--expected-revision",
-                    "1",
-                )
-                self.assertEqual(code, 1)
-                self.assertIn("only control writer", error)
diff --git a/scripts/_test_orchestration_ledger_common.py b/scripts/_test_orchestration_ledger_common.py
deleted file mode 100644
index 40a2701d..00000000
--- a/scripts/_test_orchestration_ledger_common.py
+++ /dev/null
@@ -1,70 +0,0 @@
-from __future__ import annotations
-
-import contextlib
-import importlib.util
-import io
-import json
-import os
-import stat
-import sys
-import tempfile
-import unittest
-from pathlib import Path
-
-MODULE_PATH = Path(__file__).with_name("orchestration-ledger.py")
-SPEC = importlib.util.spec_from_file_location("orchestration_ledger", MODULE_PATH)
-assert SPEC and SPEC.loader
-ledger_module = importlib.util.module_from_spec(SPEC)
-sys.modules[SPEC.name] = ledger_module
-SPEC.loader.exec_module(ledger_module)
-
-
-def run_cli(*arguments: str) -> tuple[int, str, str]:
-    stdout = io.StringIO()
-    stderr = io.StringIO()
-    with contextlib.redirect_stdout(stdout), contextlib.redirect_stderr(stderr):
-        result = ledger_module.main(list(arguments))
-    return result, stdout.getvalue(), stderr.getvalue()
-
-
-def current_revision(root: Path) -> int:
-    path = root / ".local" / "orchestration-ledger.json"
-    if not path.exists():
-        return 1
-    return json.loads(path.read_text(encoding="utf-8"))["goals"][0]["control_revision"]
-
-
-def run_mutation(
-    root: Path,
-    *arguments: str,
-    actor: str = "controller",
-) -> tuple[int, str, str]:
-    return run_cli(
-        "--root",
-        str(root),
-        *arguments,
-        "--actor",
-        actor,
-        "--expected-revision",
-        str(current_revision(root)),
-    )
-
-
-def init_goal(root: Path, goal_id: str = "goal") -> None:
-    code, _, error = run_cli(
-        "--root",
-        str(root),
-        "init",
-        "--goal-id",
-        goal_id,
-        "--goal",
-        "Deliver verified work",
-        "--execution-owner",
-        "worker",
-        "--control-writer",
-        "controller",
-        "--state",
-        "active",
-    )
-    if code != 0:
-        raise AssertionError(error)
diff --git a/scripts/codex-restart-recovery.ps1 b/scripts/codex-restart-recovery.ps1
index b7ae3950..a04c83c7 100644
--- a/scripts/codex-restart-recovery.ps1
+++ b/scripts/codex-restart-recovery.ps1
@@ -4,7 +4,7 @@ param(
     [string]$StateDir,
     [string]$TaskName = "Codex Restart Recovery",
     [string]$TaskPath = "\Compass\",
-    [string]$Prompt = "continue, the computer restarted for some reason",
+    [string]$Prompt = "Resume the interrupted task. Reopen repository guidance and any named goal, plan, ledger, or checkpoint. Verify current state before continuing.",
     [ValidateRange(1, 720)]
     [int]$LookbackHours = 24,
     [ValidateRange(1, 20)]
diff --git a/scripts/common.ps1 b/scripts/common.ps1
index 4a3ba797..8569609b 100644
--- a/scripts/common.ps1
+++ b/scripts/common.ps1
@@ -185,6 +185,10 @@ function Get-PortableManifestArray {
     return @($keyValue)
 }
 
+function Get-PortableClaudeFileNames {
+    return Get-PortableManifestArray -Section "claude" -Key "files"
+}
+
 function Get-PortableClaudeSkillNames {
     return Get-PortableManifestArray -Section "claude" -Key "skills"
 }
@@ -208,6 +212,7 @@ function Get-PortableClaudeDerivedAgentNames {
 $script:ClaudeDerivedAgentFrontmatter = @{
     "algorithm-critic" = @{ Tools = "Read, Grep, Glob, Bash"; Color = "red" }
     "neutral-critic"   = @{ Tools = "Read, Grep, Glob, Bash"; Color = "red" }
+    "progress-monitor" = @{ Tools = "Read, Grep, Glob, Bash"; Color = "yellow" }
     "repo-explorer"    = @{ Tools = "Read, Grep, Glob, Bash"; Color = "blue" }
     "research-critic"  = @{ Tools = "Read, Grep, Glob, Bash, WebSearch, WebFetch"; Color = "red" }
     "reuse-critic"     = @{ Tools = "Read, Grep, Glob, Bash"; Color = "red" }
@@ -309,6 +314,18 @@ function Get-PortableFileMap {
         })
     }
 
+    # Claude owns a separately authored global instruction file. Shared skills
+    # and most agents still derive from the reviewed Codex source.
+    foreach ($relative in Get-PortableClaudeFileNames) {
+        $items.Add([pscustomobject]@{
+            Type = "file"
+            RepoPath = Join-Path (Join-Path $RepoRoot "claude") $relative
+            LivePath = Join-Path $ClaudeHome $relative
+            LiveRoot = $ClaudeHome
+            BackupScope = "claude"
+        })
+    }
+
     # Claude skills install to ~/.claude/skills and agents to ~/.claude/agents.
     $claudeSkillsHome = Join-Path $ClaudeHome "skills"
     foreach ($skill in Get-PortableClaudeSkillNames) {
@@ -363,7 +380,7 @@ function Get-RetiredPortableFileMap {
 
     $items = New-Object System.Collections.Generic.List[object]
 
-    foreach ($skill in @(@(Get-PortableSkillNames) + @("codex-portable", "pr-merge-closeout", "proper-flowcharts", "ui-ux-pro-max"))) {
+    foreach ($skill in @(@(Get-PortableSkillNames) + @("benchmark-run-operator", "codex-portable", "input-token-economy", "pr-merge-closeout", "proper-flowcharts", "ui-ux-pro-max", "using-codex-goals"))) {
         $items.Add([pscustomobject]@{
             Type = "dir"
             LivePath = Join-Path (Join-Path $CodexHome "skills") $skill
@@ -374,7 +391,7 @@ function Get-RetiredPortableFileMap {
 
     # Keep retired user-skill removals explicit so install does not delete
     # unrelated personal skills that Compass does not own.
-    foreach ($skill in @("benchmark-infra-reviewer", "pr-merge-closeout", "ui-ux-pro-max", "webmcp-eval-triage", "webmcp-tool-authoring", "webmcp-verify-tool")) {
+    foreach ($skill in @("benchmark-infra-reviewer", "benchmark-run-operator", "input-token-economy", "pr-merge-closeout", "ui-ux-pro-max", "using-codex-goals", "webmcp-eval-triage", "webmcp-tool-authoring", "webmcp-verify-tool")) {
         $items.Add([pscustomobject]@{
             Type = "dir"
             LivePath = Join-Path (Join-Path $AgentsHome "skills") $skill
@@ -389,7 +406,7 @@ function Get-RetiredPortableFileMap {
     if (-not $claudeHome) {
         $claudeHome = Get-ClaudeHome
     }
-    foreach ($skill in @("benchmark-infra-reviewer")) {
+    foreach ($skill in @("benchmark-infra-reviewer", "benchmark-run-operator", "input-token-economy", "using-codex-goals")) {
         $items.Add([pscustomobject]@{
             Type = "dir"
             LivePath = Join-Path (Join-Path $claudeHome "skills") $skill
@@ -398,6 +415,13 @@ function Get-RetiredPortableFileMap {
         })
     }
 
+    $items.Add([pscustomobject]@{
+        Type = "file"
+        LivePath = Join-Path (Join-Path $claudeHome "agents") "benchmark-infra-reviewer.md"
+        LiveRoot = $claudeHome
+        BackupScope = "claude"
+    })
+
     return $items
 }
 
diff --git a/scripts/doctor/checks/agents.ps1 b/scripts/doctor/checks/agents.ps1
index 5387455e..435404b7 100644
--- a/scripts/doctor/checks/agents.ps1
+++ b/scripts/doctor/checks/agents.ps1
@@ -1,4 +1,13 @@
-$agentFiles = Get-ChildItem -Path (Join-Path $repoRoot "codex\agents") -File -Filter "*.toml" -ErrorAction SilentlyContinue
+$agentFiles = @(
+    Get-ChildItem -Path (Join-Path $repoRoot "codex\agents") -File -Filter "*.toml" -ErrorAction SilentlyContinue
+)
+$carriedRoot = Join-Path $repoRoot "carried"
+if (Test-Path -LiteralPath $carriedRoot) {
+    $agentFiles += @(
+        Get-ChildItem -Path (Join-Path $carriedRoot "*\agents\*.toml") -File -ErrorAction SilentlyContinue
+    )
+}
+
 foreach ($agentFile in $agentFiles) {
     $agentText = Get-Content -Raw -LiteralPath $agentFile.FullName
     $topLevelValues = Get-TopLevelTomlStringValues -Text $agentText
@@ -10,4 +19,12 @@ foreach ($agentFile in $agentFiles) {
     if ($null -ne $topLevelValues["service_tier"]) {
         $problems.Add("portable agent must omit service_tier and inherit the active parent choice: $($agentFile.FullName)")
     }
+
+    $model = $topLevelValues["model"]
+    if ($model -eq "gpt-5.6-terra") {
+        $problems.Add("agent uses retired current-profile Terra route: $($agentFile.FullName)")
+    }
+    if ($model -and $model -notin @("gpt-5.6-luna", "gpt-5.6-sol")) {
+        $problems.Add("agent uses unreviewed model route '$model': $($agentFile.FullName)")
+    }
 }
diff --git a/scripts/doctor/checks/claude.ps1 b/scripts/doctor/checks/claude.ps1
index 8f1848b7..1ce4a839 100644
--- a/scripts/doctor/checks/claude.ps1
+++ b/scripts/doctor/checks/claude.ps1
@@ -1,6 +1,28 @@
 $maxDescriptionLength = 160
 $claudeRoot = Join-Path $repoRoot "claude"
 
+# Separately authored Claude global files.
+$manifestPath = Join-Path $repoRoot "manifests\portable-files.toml"
+$manifestText = Get-Content -Raw -LiteralPath $manifestPath
+$manifestClaudeFiles = @(Get-PortableManifestArray -Text $manifestText -Section "claude" -Key "files" | Sort-Object -Unique)
+foreach ($relative in $manifestClaudeFiles) {
+    $source = Join-Path $claudeRoot $relative
+    if (-not (Test-Path -LiteralPath $source -PathType Leaf)) {
+        $problems.Add("claude file in manifest missing from disk: $relative")
+    }
+}
+
+$diskClaudeTopLevelFiles = @(
+    Get-ChildItem -LiteralPath $claudeRoot -File -ErrorAction SilentlyContinue |
+        ForEach-Object { $_.Name } |
+        Sort-Object -Unique
+)
+foreach ($relative in $diskClaudeTopLevelFiles) {
+    if ($manifestClaudeFiles -notcontains $relative) {
+        $problems.Add("claude top-level file on disk missing from manifest: $relative")
+    }
+}
+
 # Claude skill frontmatter.
 $claudeSkillFiles = Get-ChildItem -Path (Join-Path $claudeRoot "skills") -Recurse -File -Filter "SKILL.md" -ErrorAction SilentlyContinue
 foreach ($skillFile in $claudeSkillFiles) {
@@ -41,8 +63,6 @@ foreach ($agentFile in $claudeAgentFiles) {
 }
 
 # Manifest [claude] skills and agents must match the install map on disk.
-$manifestPath = Join-Path $repoRoot "manifests\portable-files.toml"
-$manifestText = Get-Content -Raw -LiteralPath $manifestPath
 $claudeSectionMatch = [regex]::Match($manifestText, "(?ms)^\[claude\]\s*(.*?)(?=^\[|\z)")
 if (-not $claudeSectionMatch.Success) {
     $problems.Add("missing claude section in portable manifest")
diff --git a/scripts/doctor/checks/required-files.ps1 b/scripts/doctor/checks/required-files.ps1
index d74bf27a..94a23de6 100644
--- a/scripts/doctor/checks/required-files.ps1
+++ b/scripts/doctor/checks/required-files.ps1
@@ -16,40 +16,59 @@ foreach ($path in @(
     ".github\workflows\orchestration-ledger-checks.yml",
     ".github\workflows\portable-checks.yml",
     "AGENTS.md",
+    "apps\compass-mcp\profile.md",
+    "README.md",
+    "glossary.md",
+    "philosophy.md",
+    "carried\benchmark\README.md",
+    "carried\benchmark\agents\benchmark-infra-reviewer.toml",
+    "carried\benchmark\claude-agents\benchmark-infra-reviewer.md",
+    "carried\benchmark\skills\benchmark-run-operator\SKILL.md",
     "carried\webmcp\README.md",
+    "claude\CLAUDE.md",
     "claude\agents\behavior-validator.md",
-    "claude\agents\benchmark-infra-reviewer.md",
     "codex\AGENTS.md",
     "codex\agents\behavior-validator.toml",
-    "codex\agents\benchmark-infra-reviewer.toml",
+    "codex\agents\progress-monitor.toml",
+    "codex\config.review.toml",
     "codex\hooks.json",
     "codex\hooks\README.md",
     "codex\hooks\portable_guard.py",
     "codex\hooks\portable_guard.ps1",
     "codex\hooks\portable_guard.sh",
     "codex\keybindings.json",
-    "codex\config.review.toml",
     "codex\skills\behavior-validator\SKILL.md",
     "codex\skills\behavior-validator\references\contract-template.md",
     "codex\skills\behavior-validator\references\report-schema.md",
     "codex\skills\behavior-validator\scripts\prepare-workspace.py",
     "codex\skills\pr-review-loop\scripts\build-review-bundle.py",
+    "codex\skills\run-a-micro-experiment\SKILL.md",
+    "codex\skills\using-goals\SKILL.md",
+    "codex\skills\using-goals\references\goal-contracts.md",
+    "codex\skills\write-a-compass-skill\SKILL.md",
+    "codex\skills\write-a-skill\SKILL.md",
+    "codex\skills\workspace-steward\references\project-template\CLAUDE.md",
+    "codex\skills\workspace-steward\references\project-template\experiments\TEMPLATE.md",
+    "codex\skills\workspace-steward\references\project-template\glossary.md",
+    "codex\skills\workspace-steward\references\project-template\local-docs\assignments\TEMPLATE.md",
+    "codex\skills\workspace-steward\references\project-template\local-docs\catalogs\TEMPLATE.md",
+    "codex\skills\workspace-steward\references\project-template\local-docs\checkpoints\TEMPLATE.md",
+    "codex\skills\workspace-steward\references\project-template\local-docs\decisions\TEMPLATE.md",
+    "codex\skills\workspace-steward\references\project-template\local-docs\goals\TEMPLATE.md",
+    "codex\skills\workspace-steward\references\project-template\local-docs\plans\TEMPLATE.md",
+    "codex\skills\workspace-steward\references\project-template\worktrees\prs\README.md",
+    "codex\skills\workspace-steward\references\project-template\worktrees\spikes\README.md",
+    "local-docs\README.md",
+    "local-docs\2026-07-17-compass-revision.md",
+    "local-docs\context-economy.md",
+    "local-docs\maintenance-learnings.md",
+    "local-docs\model-calibration.md",
     "manifests\orchestration-ledger.schema.json",
     "manifests\policy-contracts.json",
     "manifests\plugins.json",
     "manifests\portable-files.toml",
     "manifests\skill-sources.json",
     "manifests\tool-surfaces.md",
-    "local-docs\README.md",
-    "local-docs\maintenance-learnings.md",
-    "workflows\addition-intake.md",
-    "workflows\codex-restart-recovery.md",
-    "workflows\orchestration-ledger.md",
-    "workflows\portable-config.md",
-    "workflows\multi-thread-pr-coordination.md",
-    "workflows\plan-template.md",
-    "workflows\read-only-research.md",
-    "workflows\agent-failures.md",
     "scripts\codex-restart-recovery.ps1",
     "scripts\orchestration-ledger.py",
     "scripts\_orchestration_ledger_cli.py",
@@ -63,14 +82,14 @@ foreach ($path in @(
     "scripts\skills-audit.py",
     "scripts\skills-audit.ps1",
     "scripts\test-behavior-validator-workspace.py",
+    "scripts\test-compass-architecture.py",
+    "scripts\test-install-roundtrip.ps1",
     "scripts\test-orchestration-ledger-lock.py",
     "scripts\test-orchestration-ledger-output.py",
+    "scripts\test-orchestration-ledger-wrapper.ps1",
     "scripts\test-orchestration-ledger.py",
-    "scripts\_test_orchestration_ledger_common.py",
-    "scripts\_test_orchestration_ledger_cases1.py",
-    "scripts\_test_orchestration_ledger_cases2.py",
-    "scripts\_test_orchestration_ledger_cases3.py",
     "scripts\test-review-bundle.py",
+    "scripts\test-reviewed-config.py",
     "scripts\test-skills-audit.py",
     "scripts\test-validate-skill-sources.py",
     "scripts\update-live.ps1",
@@ -80,6 +99,7 @@ foreach ($path in @(
     "scripts\verify-live.ps1",
     "scripts\doctor\common.ps1",
     "scripts\doctor\checks\agents.ps1",
+    "scripts\doctor\checks\claude.ps1",
     "scripts\doctor\checks\hooks.ps1",
     "scripts\doctor\checks\manifest-boundaries.ps1",
     "scripts\doctor\checks\plugins.ps1",
@@ -91,11 +111,27 @@ foreach ($path in @(
     "scripts\doctor\checks\text-policy.ps1",
     "scripts\doctor\hooks\base.tests.ps1",
     "scripts\doctor\hooks\common.ps1",
-    "scripts\doctor\checks\claude.ps1",
-    "workflows\claude-config.md"
+    "workflows\README.md",
+    "workflows\addition-intake.md",
+    "workflows\agent-failures.md",
+    "workflows\claude-config.md",
+    "workflows\codex-restart-recovery.md",
+    "workflows\compass-review-program.md",
+    "workflows\long-running-work.md",
+    "workflows\multi-thread-pr-coordination.md",
+    "workflows\orchestration-ledger.md",
+    "workflows\plan-template.md",
+    "workflows\portable-config.md",
+    "workflows\read-only-research.md",
+    "workflows\templates\assignment.md",
+    "workflows\templates\catalog.md",
+    "workflows\templates\checkpoint.md",
+    "workflows\templates\decision.md",
+    "workflows\templates\goal.md",
+    "workflows\templates\plan.md"
 )) {
     $fullPath = Join-Path $repoRoot $path
-    if (-not (Test-Path $fullPath)) {
+    if (-not (Test-Path -LiteralPath $fullPath)) {
         $problems.Add("missing required file: $path")
     }
 }
diff --git a/scripts/doctor/checks/skills.ps1 b/scripts/doctor/checks/skills.ps1
index fecdad4b..55e6daee 100644
--- a/scripts/doctor/checks/skills.ps1
+++ b/scripts/doctor/checks/skills.ps1
@@ -1,5 +1,20 @@
 $maxDescriptionLength = 160
-$skillFiles = Get-ChildItem -Path (Join-Path $repoRoot "codex\skills") -Recurse -File -Filter "SKILL.md" -ErrorAction SilentlyContinue
+$skillRoots = @(
+    (Join-Path $repoRoot "codex\skills")
+)
+$carriedRoot = Join-Path $repoRoot "carried"
+if (Test-Path -LiteralPath $carriedRoot) {
+    $skillRoots += @(
+        Get-ChildItem -LiteralPath $carriedRoot -Directory -ErrorAction SilentlyContinue |
+            ForEach-Object { Join-Path $_.FullName "skills" } |
+            Where-Object { Test-Path -LiteralPath $_ }
+    )
+}
+$skillFiles = @(
+    foreach ($skillRoot in $skillRoots) {
+        Get-ChildItem -Path $skillRoot -Recurse -File -Filter "SKILL.md" -ErrorAction SilentlyContinue
+    }
+)
 $skillNames = New-Object 'System.Collections.Generic.Dictionary[string, string]' ([System.StringComparer]::OrdinalIgnoreCase)
 
 function Get-SkillFrontMatterValue {
diff --git a/scripts/orchestration-ledger.ps1 b/scripts/orchestration-ledger.ps1
index c43c2d27..f5a5ed97 100644
--- a/scripts/orchestration-ledger.ps1
+++ b/scripts/orchestration-ledger.ps1
@@ -3,22 +3,29 @@
 Reads and updates the local Compass orchestration ledger.
 
 .DESCRIPTION
-Stores control state under .local/orchestration-ledger.json. The ledger is
-repo-local, ignored, and never installed into Codex or Claude homes.
+Stores a principal-authored mechanical index under
+.local/orchestration-ledger.json. The durable goal, plan, catalog,
+assignments, and checkpoints remain Markdown control documents. Delegated
+workers return artifacts and evidence; only the named principal writes ledger
+control state.
 #>
 [CmdletBinding()]
 param(
-    [ValidateSet("status", "validate", "init", "set-owner", "set-state", "set-next", "add-evidence", "set-gate", "set-decision", "clear-decision", "set-grant", "clear-grant", "claim-successor", "record-successor-failure", "record-successor-success", "reset-recovery", "check-recovery")]
+    [ValidateSet("status", "validate", "init", "set-owner", "set-phase", "set-links", "set-state", "set-next", "add-evidence", "set-gate", "set-decision", "clear-decision", "begin-recovery", "record-recovery-failure", "record-recovery-success", "reset-recovery", "check-recovery")]
     [string]$Action = "status",
     [string]$GoalId,
     [string]$Goal,
-    [Alias("ControlActor")]
+    [Alias("Principal", "ControlActor")]
     [string]$Actor,
     [string]$ExecutionOwner,
     [Alias("Writer")]
     [string]$ControlWriter,
     [string]$WorkerId,
     [switch]$ClearWorker,
+    [string[]]$Anchor,
+    [string[]]$ControlDocument,
+    [ValidateSet("planning", "implementation")]
+    [string]$Phase,
     [ValidateSet("planned", "active", "waiting", "blocked", "complete", "cancelled")]
     [string]$State,
     [string]$NextAction,
@@ -28,6 +35,8 @@ param(
     [string]$EvidenceKind,
     [string]$EvidenceSummary,
     [string]$EvidenceLocator,
+    [string]$EvidenceProducer,
+    [string]$EvidenceObservedAt,
     [ValidateSet("closed", "authorized", "in_flight", "complete")]
     [string]$Gate,
     [string]$GateAction,
@@ -35,9 +44,6 @@ param(
     [string[]]$DecisionOption,
     [Alias("ExpectedControlRevision", "Revision")]
     [Nullable[int]]$ExpectedRevision,
-    [Alias("GrantedActor")]
-    [string]$GrantActor,
-    [string[]]$Mutation,
     [string]$SliceLabel,
     [string]$FailureEvidence,
     [string]$DiscriminatingEvidence,
@@ -71,12 +77,25 @@ if ($Ledger) {
 $arguments += $Action
 
 function Add-MutationAuth {
-    if (-not $PSBoundParameters.ContainsKey("Actor") -or -not $PSBoundParameters.ContainsKey("ExpectedRevision")) {
+    if ([string]::IsNullOrWhiteSpace($Actor) -or $null -eq $ExpectedRevision) {
         throw "mutations require -Actor and -ExpectedRevision"
     }
     $script:arguments += @("--actor", $Actor, "--expected-revision", $ExpectedRevision)
 }
 
+function Add-RepeatedArgument {
+    param(
+        [Parameter(Mandatory = $true)]
+        [string]$Name,
+        [string[]]$Values
+    )
+    foreach ($value in @($Values)) {
+        if ($value) {
+            $script:arguments += @($Name, $value)
+        }
+    }
+}
+
 switch ($Action) {
     "status" {
         if ($GoalId) { $arguments += @("--goal-id", $GoalId) }
@@ -92,10 +111,18 @@ switch ($Action) {
         if ($Json) { $arguments += "--json" }
     }
     "init" {
+        if ($ControlWriter -and $Actor -and $ControlWriter -ne $Actor) {
+            throw "init received conflicting -ControlWriter and -Principal values"
+        }
+        $principal = if ($ControlWriter) { $ControlWriter } else { $Actor }
+
         if ($GoalId) { $arguments += @("--goal-id", $GoalId) }
         if ($Goal) { $arguments += @("--goal", $Goal) }
+        Add-RepeatedArgument -Name "--anchor" -Values $Anchor
+        Add-RepeatedArgument -Name "--control-document" -Values $ControlDocument
+        if ($Phase) { $arguments += @("--phase", $Phase) }
         if ($ExecutionOwner) { $arguments += @("--execution-owner", $ExecutionOwner) }
-        if ($ControlWriter) { $arguments += @("--control-writer", $ControlWriter) }
+        if ($principal) { $arguments += @("--control-writer", $principal) }
         if ($WorkerId) { $arguments += @("--worker-id", $WorkerId) }
         if ($State) { $arguments += @("--state", $State) }
     }
@@ -110,6 +137,17 @@ switch ($Action) {
             $arguments += @("--worker-id", $WorkerId)
         }
     }
+    "set-phase" {
+        Add-MutationAuth
+        if ($GoalId) { $arguments += @("--goal-id", $GoalId) }
+        if ($Phase) { $arguments += @("--phase", $Phase) }
+    }
+    "set-links" {
+        Add-MutationAuth
+        if ($GoalId) { $arguments += @("--goal-id", $GoalId) }
+        Add-RepeatedArgument -Name "--anchor" -Values $Anchor
+        Add-RepeatedArgument -Name "--control-document" -Values $ControlDocument
+    }
     "set-state" {
         Add-MutationAuth
         if ($GoalId) { $arguments += @("--goal-id", $GoalId) }
@@ -132,6 +170,8 @@ switch ($Action) {
         if ($EvidenceKind) { $arguments += @("--kind", $EvidenceKind) }
         if ($EvidenceSummary) { $arguments += @("--summary", $EvidenceSummary) }
         if ($EvidenceLocator) { $arguments += @("--locator", $EvidenceLocator) }
+        if ($EvidenceProducer) { $arguments += @("--producer", $EvidenceProducer) }
+        if ($EvidenceObservedAt) { $arguments += @("--observed-at", $EvidenceObservedAt) }
     }
     "set-gate" {
         Add-MutationAuth
@@ -143,33 +183,19 @@ switch ($Action) {
         Add-MutationAuth
         if ($GoalId) { $arguments += @("--goal-id", $GoalId) }
         if ($DecisionQuestion) { $arguments += @("--question", $DecisionQuestion) }
-        foreach ($option in @($DecisionOption)) {
-            if ($option) { $arguments += @("--option", $option) }
-        }
+        Add-RepeatedArgument -Name "--option" -Values $DecisionOption
     }
     "clear-decision" {
         Add-MutationAuth
         if ($GoalId) { $arguments += @("--goal-id", $GoalId) }
     }
-    "set-grant" {
-        Add-MutationAuth
-        if ($GoalId) { $arguments += @("--goal-id", $GoalId) }
-        if ($GrantActor) { $arguments += @("--grant-actor", $GrantActor) }
-        foreach ($item in @($Mutation)) {
-            if ($item) { $arguments += @("--mutation", $item) }
-        }
-    }
-    "clear-grant" {
-        Add-MutationAuth
-        if ($GoalId) { $arguments += @("--goal-id", $GoalId) }
-        if ($GrantActor) { $arguments += @("--grant-actor", $GrantActor) }
-    }
-    "claim-successor" {
+    "begin-recovery" {
         Add-MutationAuth
         if ($GoalId) { $arguments += @("--goal-id", $GoalId) }
         if ($SliceLabel) { $arguments += @("--slice-label", $SliceLabel) }
+        if ($WorkerId) { $arguments += @("--worker-id", $WorkerId) }
     }
-    "record-successor-failure" {
+    "record-recovery-failure" {
         Add-MutationAuth
         if ($GoalId) { $arguments += @("--goal-id", $GoalId) }
         if ($SliceLabel) { $arguments += @("--slice-label", $SliceLabel) }
@@ -181,7 +207,7 @@ switch ($Action) {
             $arguments += "--no-new-evidence"
         }
     }
-    "record-successor-success" {
+    "record-recovery-success" {
         Add-MutationAuth
         if ($GoalId) { $arguments += @("--goal-id", $GoalId) }
         if ($SliceLabel) { $arguments += @("--slice-label", $SliceLabel) }
diff --git a/scripts/orchestration-ledger.py b/scripts/orchestration-ledger.py
index b68c2adb..5bb09e59 100644
--- a/scripts/orchestration-ledger.py
+++ b/scripts/orchestration-ledger.py
@@ -1,20 +1,14 @@
 #!/usr/bin/env python3
-"""Maintain a local-only orchestration control ledger under .local/."""
+"""Maintain a principal-authored local orchestration index and recovery guard."""
 
 from __future__ import annotations
 
-import sys
-from pathlib import Path
-
-SCRIPT_DIR = str(Path(__file__).resolve().parent)
-if SCRIPT_DIR not in sys.path:
-    sys.path.insert(0, SCRIPT_DIR)
-
-from _orchestration_ledger_core import LedgerError, validate_recovery_circuits
-from _orchestration_ledger_model import validate_ledger
-from _orchestration_ledger_storage import empty_circuit, ledger_lock
-from _orchestration_ledger_parser import parse_args
-from _orchestration_ledger_cli import main
+from _orchestration_ledger_cli import *
+from _orchestration_ledger_core import *
+from _orchestration_ledger_model import *
+from _orchestration_ledger_mutation import *
+from _orchestration_ledger_parser import *
+from _orchestration_ledger_storage import *
 
 if __name__ == "__main__":
     raise SystemExit(main())
diff --git a/scripts/portable-data.py b/scripts/portable-data.py
index 0ea4f2ca..96631dc0 100644
--- a/scripts/portable-data.py
+++ b/scripts/portable-data.py
@@ -21,7 +21,7 @@
 MANIFEST_ARRAYS = {
     "codex": ("files", "dirs"),
     "agents": ("skills",),
-    "claude": ("derived_skills", "agents", "derived_agents"),
+    "claude": ("files", "derived_skills", "agents", "derived_agents"),
     "repo_only": ("files", "dirs"),
     "local_only": ("files", "dirs", "patterns"),
 }
diff --git a/scripts/test-behavior-validator-workspace.py b/scripts/test-behavior-validator-workspace.py
index 032a4e11..5a7cfa38 100644
--- a/scripts/test-behavior-validator-workspace.py
+++ b/scripts/test-behavior-validator-workspace.py
@@ -24,13 +24,17 @@
 
 
 class BehaviorWorkspaceTests(unittest.TestCase):
-    def test_copies_only_contract_and_explicit_fixtures(self) -> None:
+    def make_source(self, base: Path) -> Path:
+        source = base / "repo"
+        source.mkdir()
+        (source / "contract.md").write_text("# Contract\n", encoding="utf-8")
+        return source
+
+    def test_copies_only_contract_instructions_and_explicit_fixtures(self) -> None:
         with tempfile.TemporaryDirectory() as directory:
             base = Path(directory)
-            source = base / "repo"
-            source.mkdir()
-            (source / "contract.md").write_text("# Contract\n", encoding="utf-8")
-            (source / "source.py").write_text("secret implementation\n", encoding="utf-8")
+            source = self.make_source(base)
+            (source / "source.py").write_text("implementation\n", encoding="utf-8")
             fixture = source / "fixtures" / "sample.json"
             fixture.parent.mkdir()
             fixture.write_text('{"ok": true}\n', encoding="utf-8")
@@ -44,78 +48,142 @@ def test_copies_only_contract_and_explicit_fixtures(self) -> None:
             )
 
             self.assertTrue((output / "contract.md").is_file())
-            self.assertTrue((output / "fixtures" / "fixtures" / "sample.json").is_file())
+            self.assertTrue((output / "AGENTS.md").is_file())
+            self.assertTrue((output / "CLAUDE.md").is_file())
+            self.assertTrue((output / "fixtures" / "sample.json").is_file())
             self.assertFalse((output / "source.py").exists())
-            self.assertEqual(manifest["schema_version"], 1)
+            self.assertEqual(manifest["schema_version"], 2)
             disk = json.loads((output / "workspace-manifest.json").read_text())
-            self.assertEqual(disk["fixtures"][0]["path"], "fixtures/fixtures/sample.json")
+            self.assertEqual(disk["fixtures"][0]["path"], "fixtures/sample.json")
+            self.assertEqual(
+                sorted(path.relative_to(output).as_posix() for path in output.rglob("*") if path.is_file()),
+                sorted(disk["allowed_local_paths"]),
+            )
+
+    def test_directory_fixture_preserves_one_stable_prefix(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            base = Path(directory)
+            source = self.make_source(base)
+            nested = source / "testdata" / "nested" / "sample.txt"
+            nested.parent.mkdir(parents=True)
+            nested.write_text("approved fixture\n", encoding="utf-8")
+            output = base / "validator"
+
+            workspace.build_workspace(source, Path("contract.md"), output, [Path("testdata")])
+
+            self.assertTrue((output / "fixtures" / "testdata" / "nested" / "sample.txt").is_file())
 
     def test_output_must_be_new_and_outside_source_root(self) -> None:
         with tempfile.TemporaryDirectory() as directory:
-            source = Path(directory) / "repo"
-            source.mkdir()
-            (source / "contract.md").write_text("contract", encoding="utf-8")
+            base = Path(directory)
+            source = self.make_source(base)
             with self.assertRaisesRegex(workspace.WorkspaceError, "outside the source root"):
-                workspace.build_workspace(
-                    source,
-                    Path("contract.md"),
-                    source / "validator",
-                    [],
-                )
-            output = Path(directory) / "validator"
+                workspace.build_workspace(source, Path("contract.md"), source / "validator", [])
+            output = base / "validator"
             output.mkdir()
             with self.assertRaisesRegex(workspace.WorkspaceError, "already exists"):
+                workspace.build_workspace(source, Path("contract.md"), output, [])
+
+    def test_rejects_env_variants_and_sensitive_path_segments(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            base = Path(directory)
+            source = self.make_source(base)
+            (source / ".env.production").write_text("TOKEN=value", encoding="utf-8")
+            secret = source / "secrets" / "sample.txt"
+            secret.parent.mkdir()
+            secret.write_text("placeholder", encoding="utf-8")
+
+            with self.assertRaisesRegex(workspace.WorkspaceError, "environment file"):
                 workspace.build_workspace(
-                    source,
-                    Path("contract.md"),
-                    output,
-                    [],
+                    source, Path("contract.md"), base / "env-output", [Path(".env.production")]
+                )
+            with self.assertRaisesRegex(workspace.WorkspaceError, "blocked directory"):
+                workspace.build_workspace(
+                    source, Path("contract.md"), base / "secret-output", [Path("secrets/sample.txt")]
                 )
 
-    def test_rejects_symlink_and_credential_like_fixtures(self) -> None:
+    def test_rejects_high_confidence_secret_content_in_ordinary_file(self) -> None:
         with tempfile.TemporaryDirectory() as directory:
             base = Path(directory)
-            source = base / "repo"
-            source.mkdir()
-            (source / "contract.md").write_text("contract", encoding="utf-8")
-            (source / ".env").write_text("TOKEN=value", encoding="utf-8")
-            with self.assertRaisesRegex(workspace.WorkspaceError, "credential-bearing"):
+            source = self.make_source(base)
+            fixture = source / "sample.txt"
+            fixture.write_text("github_pat_abcdefghijklmnopqrstuvwxyz1234567890\n", encoding="utf-8")
+            with self.assertRaisesRegex(workspace.WorkspaceError, "GitHub fine-grained token"):
                 workspace.build_workspace(
-                    source,
-                    Path("contract.md"),
-                    base / "credential-output",
-                    [Path(".env")],
+                    source, Path("contract.md"), base / "token-output", [Path("sample.txt")]
                 )
+
+    def test_rejects_secret_content_in_contract(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            base = Path(directory)
+            source = self.make_source(base)
+            (source / "contract.md").write_text(
+                "-----BEGIN PRIVATE KEY-----\nnot-real\n", encoding="utf-8"
+            )
+            with self.assertRaisesRegex(workspace.WorkspaceError, "contract contains a possible private key"):
+                workspace.build_workspace(source, Path("contract.md"), base / "output", [])
+
+    def test_rejects_symlinks(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            base = Path(directory)
+            source = self.make_source(base)
             target = source / "target.txt"
             target.write_text("target", encoding="utf-8")
             link = source / "link.txt"
             try:
                 link.symlink_to(target)
             except OSError:
-                return
+                self.skipTest("symlinks unavailable")
             with self.assertRaisesRegex(workspace.WorkspaceError, "symlink"):
                 workspace.build_workspace(
-                    source,
-                    Path("contract.md"),
-                    base / "symlink-output",
-                    [Path("link.txt")],
+                    source, Path("contract.md"), base / "symlink-output", [Path("link.txt")]
                 )
 
     def test_contract_must_stay_under_source_root(self) -> None:
         with tempfile.TemporaryDirectory() as directory:
             base = Path(directory)
-            source = base / "repo"
-            source.mkdir()
-            outside = base / "contract.md"
+            source = self.make_source(base)
+            outside = base / "outside-contract.md"
             outside.write_text("contract", encoding="utf-8")
             with self.assertRaisesRegex(workspace.WorkspaceError, "escapes source root"):
+                workspace.build_workspace(source, outside, base / "validator", [])
+
+    def test_case_colliding_distinct_fixtures_fail_closed(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            base = Path(directory)
+            source = self.make_source(base)
+            fixtures = source / "fixtures"
+            fixtures.mkdir()
+            lower = fixtures / "sample.json"
+            upper = fixtures / "Sample.json"
+            lower.write_text('{"case": "lower"}', encoding="utf-8")
+            upper.write_text('{"case": "upper"}', encoding="utf-8")
+            if lower.resolve() == upper.resolve():
+                self.skipTest("filesystem is case-insensitive")
+            with self.assertRaisesRegex(workspace.WorkspaceError, "collide case-insensitively"):
                 workspace.build_workspace(
                     source,
-                    outside,
+                    Path("contract.md"),
                     base / "validator",
-                    [],
+                    [Path("fixtures/sample.json"), Path("fixtures/Sample.json")],
                 )
 
+    def test_duplicate_fixture_inputs_are_deduplicated(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            base = Path(directory)
+            source = self.make_source(base)
+            fixture = source / "fixtures" / "sample.json"
+            fixture.parent.mkdir()
+            fixture.write_text("{}", encoding="utf-8")
+            output = base / "validator"
+            manifest = workspace.build_workspace(
+                source,
+                Path("contract.md"),
+                output,
+                [Path("fixtures"), Path("fixtures/sample.json")],
+            )
+            self.assertEqual(len(manifest["fixtures"]), 1)
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/scripts/test-compass-architecture.py b/scripts/test-compass-architecture.py
new file mode 100644
index 00000000..03e0e19a
--- /dev/null
+++ b/scripts/test-compass-architecture.py
@@ -0,0 +1,260 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import re
+import tomllib
+import unittest
+from pathlib import Path
+
+from _orchestration_ledger_model import LedgerError, validate_ledger
+
+ROOT = Path(__file__).resolve().parents[1]
+MODEL_EFFORT_DEFAULTS = {
+    "gpt-5.6-sol": "high",
+    "gpt-5.6-terra": "xhigh",
+    "gpt-5.6-luna": "high",
+}
+
+
+class CompassArchitectureTests(unittest.TestCase):
+    def read(self, relative: str) -> str:
+        return (ROOT / relative).read_text(encoding="utf-8")
+
+    def manifest(self) -> dict[str, object]:
+        with (ROOT / "manifests" / "portable-files.toml").open("rb") as handle:
+            return tomllib.load(handle)
+
+    def test_installed_skill_set_matches_current_architecture(self) -> None:
+        manifest = self.manifest()
+        skills = set(manifest["agents"]["skills"])
+        self.assertIn("run-a-micro-experiment", skills)
+        self.assertIn("using-goals", skills)
+        self.assertIn("write-a-compass-skill", skills)
+        self.assertIn("write-a-skill", skills)
+        self.assertNotIn("benchmark-run-operator", skills)
+        self.assertNotIn("input-token-economy", skills)
+        self.assertNotIn("using-codex-goals", skills)
+
+        for skill in skills:
+            self.assertTrue((ROOT / "codex" / "skills" / skill / "SKILL.md").is_file(), skill)
+
+        carried = ROOT / "carried" / "benchmark" / "skills" / "benchmark-run-operator" / "SKILL.md"
+        self.assertTrue(carried.is_file())
+
+    def test_runtime_globals_are_separate_and_truthful(self) -> None:
+        manifest = self.manifest()
+        self.assertEqual(manifest["claude"]["files"], ["CLAUDE.md"])
+
+        codex = self.read("codex/AGENTS.md")
+        claude = self.read("claude/CLAUDE.md")
+        mcp = self.read("apps/compass-mcp/profile.md")
+
+        self.assertIn("GPT-5.6 Sol", codex)
+        self.assertIn("GPT-5.6 Luna", codex)
+        self.assertNotIn("GPT-5.6 Terra", codex)
+        self.assertNotIn("GLM-5.2", codex)
+
+        self.assertIn("GLM-5.2", claude)
+        self.assertNotIn("GPT-5.6 Sol", claude)
+        self.assertNotIn("GPT-5.6 Luna", claude)
+
+        self.assertNotRegex(mcp, r"GPT-5\.6 (?:Sol|Luna|Terra)|GLM-5\.2")
+
+    def test_model_tier_defaults_are_documented_and_applied(self) -> None:
+        with (ROOT / "codex" / "config.review.toml").open("rb") as handle:
+            config = tomllib.load(handle)
+        model = config["model"]
+        self.assertEqual(config["model_reasoning_effort"], MODEL_EFFORT_DEFAULTS[model])
+
+        calibration = self.read("local-docs/model-calibration.md")
+        for model_name, effort in (
+            ("GPT-5.6 Sol", "high"),
+            ("GPT-5.6 Terra", "xhigh"),
+            ("GPT-5.6 Luna", "high"),
+        ):
+            self.assertIn(f"| {model_name} | `{effort}` |", calibration)
+
+    def test_current_ledger_schema_does_not_backfill_legacy_fields(self) -> None:
+        timestamp = "2026-07-17T12:00:00Z"
+        goal = {
+            "id": "strict-v4",
+            "goal": "Reject malformed current records",
+            "anchors": ["product-requirements.md"],
+            "control_documents": ["local-docs/control/goal.md"],
+            "phase": "planning",
+            "execution_owner": "principal",
+            "worker_id": None,
+            "state": "planned",
+            "next_action": None,
+            "next_check_at": None,
+            "evidence": [],
+            "public_mutation_gate": "closed",
+            "public_mutation_action": None,
+            "decision_needed": None,
+            "control_writer": "principal",
+            "control_revision": 1,
+            "recovery_circuits": [],
+            "created_at": timestamp,
+            "updated_at": timestamp,
+            "last_verified_at": timestamp,
+        }
+        del goal["anchors"]
+        current = {"schema_version": 4, "updated_at": timestamp, "goals": [goal]}
+        with self.assertRaisesRegex(LedgerError, "missing required fields: anchors"):
+            validate_ledger(current)
+
+    def test_ledger_schema_version_rejects_boolean_values(self) -> None:
+        invalid = {
+            "schema_version": True,
+            "updated_at": "2026-07-17T12:00:00Z",
+            "goals": [],
+        }
+        with self.assertRaisesRegex(LedgerError, "requires schema_version 4"):
+            validate_ledger(invalid)
+
+    def test_legacy_recovery_counter_rejects_malformed_values(self) -> None:
+        timestamp = "2026-07-17T12:00:00Z"
+        for invalid_count in (True, -1, "two"):
+            with self.subTest(invalid_count=invalid_count):
+                legacy = {
+                    "schema_version": 2,
+                    "updated_at": timestamp,
+                    "goals": [
+                        {
+                            "id": "legacy",
+                            "goal": "Reject malformed recovery state",
+                            "execution_owner": "principal",
+                            "worker_id": None,
+                            "state": "active",
+                            "next_action": None,
+                            "next_check_at": None,
+                            "completion_evidence": [],
+                            "public_mutation_gate": "closed",
+                            "public_mutation_action": None,
+                            "decision_needed": None,
+                            "control_writer": "principal",
+                            "control_revision": 1,
+                            "control_edit_grants": [],
+                            "recovery_circuits": [
+                                {
+                                    "slice_label": "api",
+                                    "consecutive_successor_failures": invalid_count,
+                                    "state": "open",
+                                    "last_reset_evidence": None,
+                                    "last_reset_at": None,
+                                    "claimed_by": None,
+                                }
+                            ],
+                            "created_at": timestamp,
+                            "updated_at": timestamp,
+                        }
+                    ],
+                }
+                with self.assertRaisesRegex(LedgerError, "unsupported fields"):
+                    validate_ledger(legacy)
+
+    def test_codex_agents_follow_luna_first_profile(self) -> None:
+        for path in sorted((ROOT / "codex" / "agents").glob("*.toml")):
+            with path.open("rb") as handle:
+                agent = tomllib.load(handle)
+            self.assertEqual(agent.get("model"), "gpt-5.6-luna", path.name)
+            self.assertNotIn("service_tier", agent, path.name)
+            effort = agent.get("model_reasoning_effort")
+            self.assertIn(effort, {"high", "xhigh", "max"}, path.name)
+
+    def test_principal_authorship_is_consistent(self) -> None:
+        for relative in (
+            "philosophy.md",
+            "workflows/long-running-work.md",
+            "codex/skills/using-goals/SKILL.md",
+            "codex/skills/orchestration-controller/SKILL.md",
+            "codex/skills/subagent-driven-development/SKILL.md",
+            "workflows/orchestration-ledger.md",
+        ):
+            text = self.read(relative)
+            self.assertRegex(text, r"(?i)principal")
+            self.assertRegex(text, r"(?i)return(?:s|ed)? (?:artifacts (?:plus|and) )?evidence|return evidence")
+
+        ledger = self.read("workflows/orchestration-ledger.md")
+        self.assertRegex(ledger.lower(), r"does not\s+support delegated edit grants")
+        self.assertNotIn("set-grant", ledger)
+        self.assertNotIn("claim-successor", ledger)
+
+    def test_long_running_work_has_complete_control_templates(self) -> None:
+        for name in ("goal", "plan", "catalog", "assignment", "decision", "checkpoint"):
+            self.assertTrue((ROOT / "workflows" / "templates" / f"{name}.md").is_file(), name)
+
+    def test_workspace_template_has_distinct_lifecycles_and_templates(self) -> None:
+        base = ROOT / "codex" / "skills" / "workspace-steward" / "references" / "project-template"
+        required = (
+            "README.md",
+            "AGENTS.md",
+            "CLAUDE.md",
+            "glossary.md",
+            "experiments/README.md",
+            "experiments/TEMPLATE.md",
+            "worktrees/README.md",
+            "worktrees/prs/README.md",
+            "worktrees/spikes/README.md",
+            "local-docs/README.md",
+            "local-docs/goals/TEMPLATE.md",
+            "local-docs/plans/TEMPLATE.md",
+            "local-docs/catalogs/TEMPLATE.md",
+            "local-docs/assignments/TEMPLATE.md",
+            "local-docs/checkpoints/TEMPLATE.md",
+            "local-docs/decisions/TEMPLATE.md",
+        )
+        for relative in required:
+            self.assertTrue((base / relative).is_file(), relative)
+
+        experiment = (base / "experiments" / "README.md").read_text(encoding="utf-8")
+        self.assertIn("Experimental code does not graduate. The finding graduates.", experiment)
+
+    def test_skill_descriptions_are_routable_and_bounded(self) -> None:
+        skill_files = list((ROOT / "codex" / "skills").glob("*/SKILL.md"))
+        skill_files += list((ROOT / "carried").glob("*/skills/*/SKILL.md"))
+        seen: set[str] = set()
+        for path in sorted(skill_files):
+            text = path.read_text(encoding="utf-8")
+            match = re.match(r"^---\n(?P<header>.*?)\n---\n", text, re.DOTALL)
+            self.assertIsNotNone(match, path)
+            header = match.group("header")
+            name_match = re.search(r"^name:\s*(.+)$", header, re.MULTILINE)
+            description_match = re.search(r"^description:\s*(.+)$", header, re.MULTILINE)
+            self.assertIsNotNone(name_match, path)
+            self.assertIsNotNone(description_match, path)
+            name = name_match.group(1).strip().strip('"\'')
+            description = description_match.group(1).strip().strip('"\'')
+            self.assertEqual(name, path.parent.name, path)
+            self.assertNotIn(name.casefold(), seen, path)
+            seen.add(name.casefold())
+            self.assertLessEqual(len(description), 160, path)
+
+    def test_powershell_ledger_wrapper_uses_script_arguments(self) -> None:
+        wrapper = self.read("scripts/orchestration-ledger.ps1")
+        self.assertNotIn('$PSBoundParameters.ContainsKey("Actor")', wrapper)
+        self.assertIn('[string]::IsNullOrWhiteSpace($Actor)', wrapper)
+        self.assertIn('$null -eq $ExpectedRevision', wrapper)
+
+    def test_skill_interface_prompts_match_current_architecture(self) -> None:
+        prompt_files = list((ROOT / "codex" / "skills").glob("*/agents/openai.yaml"))
+        prompt_files += list((ROOT / "carried").glob("*/skills/*/agents/openai.yaml"))
+        for path in prompt_files:
+            text = path.read_text(encoding="utf-8")
+            self.assertNotIn("@codex", text, path)
+            self.assertNotIn("using-codex-goals", text, path)
+            self.assertNotIn("input-token-economy", text, path)
+
+    def test_retirement_map_names_every_replaced_global_surface(self) -> None:
+        common = self.read("scripts/common.ps1")
+        for retired in (
+            "benchmark-run-operator",
+            "input-token-economy",
+            "using-codex-goals",
+            "benchmark-infra-reviewer.md",
+        ):
+            self.assertIn(retired, common)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/scripts/test-install-roundtrip.ps1 b/scripts/test-install-roundtrip.ps1
index 191331ce..791c0fb3 100644
--- a/scripts/test-install-roundtrip.ps1
+++ b/scripts/test-install-roundtrip.ps1
@@ -188,9 +188,11 @@ last_refresh = "machine-local"
     Assert-PathPresent -Path (Join-Path $codexHome "AGENTS.md")
     Assert-PathPresent -Path (Join-Path (Join-Path (Join-Path $agentsHome "skills") "compass") "SKILL.md")
     Assert-PathPresent -Path (Join-Path (Join-Path (Join-Path $agentsHome "skills") "behavior-validator") "SKILL.md")
+    Assert-PathPresent -Path (Join-Path $claudeHome "CLAUDE.md")
     Assert-PathPresent -Path (Join-Path (Join-Path (Join-Path $claudeHome "skills") "compass") "SKILL.md")
     Assert-PathPresent -Path (Join-Path (Join-Path (Join-Path $claudeHome "skills") "behavior-validator") "SKILL.md")
     Assert-PathPresent -Path (Join-Path (Join-Path (Join-Path (Join-Path $claudeHome "skills") "pr-review-loop") "scripts") "build-review-bundle.py")
+    Assert-PathPresent -Path (Join-Path (Join-Path $claudeHome "agents") "progress-monitor.md")
     Assert-PathPresent -Path (Join-Path (Join-Path $claudeHome "agents") "reviewer.md")
 
     $missingConfig = (Get-Content -Raw -LiteralPath $configPath) -replace '(?m)^model_auto_compact_token_limit = 233000\r?\n', ''
@@ -217,18 +219,35 @@ last_refresh = "machine-local"
     [void](Invoke-TestScript -Path $installPath -Arguments (@("-Apply", "-SkipPlugins") + $homeArguments))
     [void](Invoke-TestScript -Path $verifyPath -Arguments (@("-SkipCodexCommand", "-SkipPlugins", "-RequireInSync") + $homeArguments))
 
-    $retiredCodexSkill = Join-Path (Join-Path $codexHome "skills") "proper-flowcharts"
-    $retiredUserSkill = Join-Path (Join-Path $agentsHome "skills") "ui-ux-pro-max"
-    New-Item -ItemType Directory -Force $retiredCodexSkill, $retiredUserSkill | Out-Null
-    Set-Content -LiteralPath (Join-Path $retiredCodexSkill "legacy.txt") -Value "legacy"
-    Set-Content -LiteralPath (Join-Path $retiredUserSkill "legacy.txt") -Value "legacy"
+    $retiredPaths = @(
+        (Join-Path (Join-Path $codexHome "skills") "proper-flowcharts"),
+        (Join-Path (Join-Path $codexHome "skills") "benchmark-run-operator"),
+        (Join-Path (Join-Path $codexHome "skills") "input-token-economy"),
+        (Join-Path (Join-Path $codexHome "skills") "using-codex-goals"),
+        (Join-Path (Join-Path $agentsHome "skills") "ui-ux-pro-max"),
+        (Join-Path (Join-Path $agentsHome "skills") "benchmark-run-operator"),
+        (Join-Path (Join-Path $agentsHome "skills") "input-token-economy"),
+        (Join-Path (Join-Path $agentsHome "skills") "using-codex-goals"),
+        (Join-Path (Join-Path $claudeHome "skills") "benchmark-run-operator"),
+        (Join-Path (Join-Path $claudeHome "skills") "input-token-economy"),
+        (Join-Path (Join-Path $claudeHome "skills") "using-codex-goals")
+    )
+    foreach ($retiredPath in $retiredPaths) {
+        New-Item -ItemType Directory -Force $retiredPath | Out-Null
+        Set-Content -LiteralPath (Join-Path $retiredPath "legacy.txt") -Value "legacy"
+    }
+    $retiredClaudeAgent = Join-Path (Join-Path $claudeHome "agents") "benchmark-infra-reviewer.md"
+    New-Item -ItemType Directory -Force (Split-Path -Parent $retiredClaudeAgent) | Out-Null
+    Set-Content -LiteralPath $retiredClaudeAgent -Value "legacy"
 
     [void](Invoke-TestScript -Path $installPath -Arguments (@("-Apply", "-SkipPlugins") + $homeArguments))
-    if (Test-Path -LiteralPath $retiredCodexSkill) {
-        throw "retired Codex skill was not removed: $retiredCodexSkill"
+    foreach ($retiredPath in $retiredPaths) {
+        if (Test-Path -LiteralPath $retiredPath) {
+            throw "retired skill was not removed: $retiredPath"
+        }
     }
-    if (Test-Path -LiteralPath $retiredUserSkill) {
-        throw "retired user skill was not removed: $retiredUserSkill"
+    if (Test-Path -LiteralPath $retiredClaudeAgent) {
+        throw "retired Claude agent was not removed: $retiredClaudeAgent"
     }
     [void](Invoke-TestScript -Path $verifyPath -Arguments (@("-SkipCodexCommand", "-SkipPlugins", "-RequireInSync") + $homeArguments))
 
diff --git a/scripts/test-orchestration-ledger-lock.py b/scripts/test-orchestration-ledger-lock.py
index 74ad7079..8aeffde7 100644
--- a/scripts/test-orchestration-ledger-lock.py
+++ b/scripts/test-orchestration-ledger-lock.py
@@ -35,8 +35,14 @@ def test_second_writer_fails_without_mutating_ledger(self) -> None:
                             "sample",
                             "--goal",
                             "Keep concurrent updates",
+                            "--anchor",
+                            "requirements.md",
+                            "--control-document",
+                            "local-docs/control/goal.md",
                             "--execution-owner",
-                            "worker",
+                            "principal",
+                            "--control-writer",
+                            "principal",
                         ]
                     )
 
diff --git a/scripts/test-orchestration-ledger-wrapper.ps1 b/scripts/test-orchestration-ledger-wrapper.ps1
new file mode 100644
index 00000000..db5fde73
--- /dev/null
+++ b/scripts/test-orchestration-ledger-wrapper.ps1
@@ -0,0 +1,170 @@
+[CmdletBinding()]
+param()
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = "Stop"
+
+$repoRoot = (Resolve-Path (Join-Path $PSScriptRoot "..")).Path
+$wrapperPath = Join-Path $PSScriptRoot "orchestration-ledger.ps1"
+$ledgerName = "orchestration-ledger-wrapper-$([guid]::NewGuid().ToString('N')).json"
+$ledgerPath = Join-Path (Join-Path $repoRoot ".local") $ledgerName
+$lockPath = "$ledgerPath.lock"
+$powerShellPath = (Get-Process -Id $PID).Path
+
+function Invoke-Wrapper {
+    param(
+        [string[]]$Arguments,
+        [int]$ExpectedExitCode = 0
+    )
+
+    $processArguments = @("-NoProfile")
+    if ($env:OS -eq "Windows_NT") {
+        $processArguments += @("-ExecutionPolicy", "Bypass")
+    }
+    $processArguments += @("-File", $wrapperPath) + $Arguments
+
+    $output = @(& $powerShellPath @processArguments 2>&1 | ForEach-Object { $_.ToString() })
+    $exitCode = $LASTEXITCODE
+    if ($exitCode -ne $ExpectedExitCode) {
+        throw "expected ledger wrapper exit code $ExpectedExitCode, got $exitCode`n$($output -join "`n")"
+    }
+    return $output
+}
+
+try {
+    [void](Invoke-Wrapper -Arguments @(
+        "-Action", "init",
+        "-GoalId", "principal-alias",
+        "-Goal", "Prove the PowerShell principal alias",
+        "-Anchor", "brief.md",
+        "-ControlDocument", "goal.md",
+        "-ExecutionOwner", "principal",
+        "-Principal", "principal",
+        "-Ledger", $ledgerPath
+    ))
+
+    [void](Invoke-Wrapper -Arguments @(
+        "-Action", "set-phase",
+        "-GoalId", "principal-alias",
+        "-Principal", "principal",
+        "-ExpectedRevision", "1",
+        "-Phase", "implementation",
+        "-Ledger", $ledgerPath
+    ))
+
+    [void](Invoke-Wrapper -Arguments @(
+        "-Action", "set-links",
+        "-GoalId", "principal-alias",
+        "-Principal", "principal",
+        "-ExpectedRevision", "2",
+        "-Anchor", "brief.md#approved",
+        "-ControlDocument", "checkpoint.md",
+        "-Ledger", $ledgerPath
+    ))
+
+    [void](Invoke-Wrapper -Arguments @(
+        "-Action", "add-evidence",
+        "-GoalId", "principal-alias",
+        "-Principal", "principal",
+        "-ExpectedRevision", "3",
+        "-EvidenceKind", "test",
+        "-EvidenceSummary", "PowerShell wrapper mutation passed",
+        "-EvidenceLocator", "wrapper:test",
+        "-EvidenceProducer", "wrapper-test",
+        "-EvidenceObservedAt", "2026-07-17T12:00:00Z",
+        "-Ledger", $ledgerPath
+    ))
+
+    [void](Invoke-Wrapper -Arguments @(
+        "-Action", "begin-recovery",
+        "-GoalId", "principal-alias",
+        "-Principal", "principal",
+        "-ExpectedRevision", "4",
+        "-SliceLabel", "wrapper-slice",
+        "-WorkerId", "recovery-01",
+        "-Ledger", $ledgerPath
+    ))
+
+    [void](Invoke-Wrapper -Arguments @(
+        "-Action", "record-recovery-failure",
+        "-GoalId", "principal-alias",
+        "-Principal", "principal",
+        "-ExpectedRevision", "5",
+        "-SliceLabel", "wrapper-slice",
+        "-FailureEvidence", "wrapper:unchanged-failure",
+        "-NoNewEvidence",
+        "-Ledger", $ledgerPath
+    ))
+
+    $blockedOutput = @(Invoke-Wrapper -Arguments @(
+        "-Action", "check-recovery",
+        "-GoalId", "principal-alias",
+        "-SliceLabel", "wrapper-slice",
+        "-Ledger", $ledgerPath
+    ) -ExpectedExitCode 1) -join "`n"
+    if (-not $blockedOutput.Contains("changed hypothesis")) {
+        throw "open recovery circuit did not block an unchanged successor"
+    }
+
+    [void](Invoke-Wrapper -Arguments @(
+        "-Action", "reset-recovery",
+        "-GoalId", "principal-alias",
+        "-Principal", "principal",
+        "-ExpectedRevision", "6",
+        "-SliceLabel", "wrapper-slice",
+        "-RootCauseEvidence", "wrapper:changed-route",
+        "-Ledger", $ledgerPath
+    ))
+
+    # Every wrapper call runs in a new PowerShell process. This mutation proves a
+    # fresh process can reopen the ledger and continue from the stored revision.
+    [void](Invoke-Wrapper -Arguments @(
+        "-Action", "set-state",
+        "-GoalId", "principal-alias",
+        "-Principal", "principal",
+        "-ExpectedRevision", "7",
+        "-State", "active",
+        "-Ledger", $ledgerPath
+    ))
+
+    $statusText = @(Invoke-Wrapper -Arguments @(
+        "-Action", "status",
+        "-GoalId", "principal-alias",
+        "-Ledger", $ledgerPath,
+        "-Json"
+    )) -join "`n"
+    $status = $statusText | ConvertFrom-Json
+    $goal = @($status.goals)[0]
+    $circuit = @($goal.recovery_circuits)[0]
+
+    if ($goal.control_writer -ne "principal") {
+        throw "-Principal did not initialize control_writer"
+    }
+    if ($goal.execution_owner -ne "principal") {
+        throw "ledger wrapper changed the execution owner"
+    }
+    if ($goal.phase -ne "implementation" -or $goal.state -ne "active") {
+        throw "ledger wrapper did not preserve mutation and resume state"
+    }
+    if (@($goal.control_documents)[0] -ne "checkpoint.md") {
+        throw "ledger wrapper did not preserve the checkpoint link"
+    }
+    if (@($goal.evidence).Count -ne 1 -or $goal.evidence[0].verified_by -ne "principal") {
+        throw "ledger wrapper did not preserve principal-verified evidence"
+    }
+    if ($circuit.state -ne "closed" -or $circuit.last_reset_evidence -ne "wrapper:changed-route") {
+        throw "ledger wrapper did not preserve recovery reset evidence"
+    }
+    if ($goal.control_revision -ne 8) {
+        throw "ledger wrapper revision mismatch after round trip: $($goal.control_revision)"
+    }
+
+    Write-Host "orchestration ledger wrapper: ok"
+}
+finally {
+    foreach ($path in @($ledgerPath, $lockPath)) {
+        if (Test-Path -LiteralPath $path) {
+            Remove-Item -LiteralPath $path -Force
+        }
+    }
+}
diff --git a/scripts/test-orchestration-ledger.py b/scripts/test-orchestration-ledger.py
index a819b7bb..cb9ad7ef 100644
--- a/scripts/test-orchestration-ledger.py
+++ b/scripts/test-orchestration-ledger.py
@@ -1,17 +1,444 @@
 #!/usr/bin/env python3
 from __future__ import annotations
 
+import importlib.util
+import io
+import json
 import sys
+import tempfile
 import unittest
+from contextlib import redirect_stderr, redirect_stdout
 from pathlib import Path
 
-SCRIPT_DIR = str(Path(__file__).resolve().parent)
-if SCRIPT_DIR not in sys.path:
-    sys.path.insert(0, SCRIPT_DIR)
+MODULE_PATH = Path(__file__).with_name("orchestration-ledger.py")
+SPEC = importlib.util.spec_from_file_location("orchestration_ledger", MODULE_PATH)
+assert SPEC and SPEC.loader
+ledger = importlib.util.module_from_spec(SPEC)
+sys.modules[SPEC.name] = ledger
+SPEC.loader.exec_module(ledger)
+
+
+class LedgerHarness:
+    def __init__(self, root: Path) -> None:
+        self.root = root
+        self.path = root / ".local" / "orchestration-ledger.json"
+
+    def run(self, *args: str) -> tuple[int, str, str]:
+        stdout = io.StringIO()
+        stderr = io.StringIO()
+        with redirect_stdout(stdout), redirect_stderr(stderr):
+            try:
+                exit_code = ledger.main(["--root", str(self.root), *args])
+            except SystemExit as error:
+                exit_code = int(error.code or 0)
+        return exit_code, stdout.getvalue(), stderr.getvalue()
+
+    def init(self, goal_id: str = "release-42") -> dict[str, object]:
+        exit_code, stdout, stderr = self.run(
+            "init",
+            "--goal-id",
+            goal_id,
+            "--goal",
+            "Ship the reviewed release",
+            "--anchor",
+            "product-requirements.md",
+            "--control-document",
+            "local-docs/control/goal.md",
+            "--control-document",
+            "local-docs/control/catalog.md",
+            "--execution-owner",
+            "principal",
+            "--control-writer",
+            "principal",
+        )
+        if exit_code != 0:
+            raise AssertionError(f"init failed: {stdout}{stderr}")
+        return json.loads(self.path.read_text(encoding="utf-8"))
+
+    def goal(self) -> dict[str, object]:
+        return json.loads(self.path.read_text(encoding="utf-8"))["goals"][0]
+
+
+class OrchestrationLedgerTests(unittest.TestCase):
+    def test_init_writes_principal_authored_control_links(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            harness = LedgerHarness(Path(directory))
+            document = harness.init()
+            goal = document["goals"][0]
+
+            self.assertEqual(document["schema_version"], 4)
+            self.assertEqual(goal["control_writer"], "principal")
+            self.assertEqual(goal["phase"], "planning")
+            self.assertEqual(goal["anchors"], ["product-requirements.md"])
+            self.assertEqual(
+                goal["control_documents"],
+                ["local-docs/control/goal.md", "local-docs/control/catalog.md"],
+            )
+            self.assertEqual(goal["evidence"], [])
+            self.assertEqual(goal["control_revision"], 1)
+            self.assertTrue(goal["last_verified_at"].endswith("Z"))
+
+    def test_init_requires_anchor_and_control_document(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            harness = LedgerHarness(Path(directory))
+            exit_code, _, stderr = harness.run(
+                "init",
+                "--goal-id",
+                "missing-links",
+                "--goal",
+                "Keep continuity",
+                "--execution-owner",
+                "principal",
+                "--control-writer",
+                "principal",
+            )
+            self.assertEqual(exit_code, 2)
+            self.assertIn("--anchor", stderr)
+            self.assertFalse(harness.path.exists())
+
+    def test_only_named_principal_may_mutate_control_state(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            harness = LedgerHarness(Path(directory))
+            harness.init()
+            exit_code, _, stderr = harness.run(
+                "set-next",
+                "--goal-id",
+                "release-42",
+                "--actor",
+                "worker-7",
+                "--expected-revision",
+                "1",
+                "--action",
+                "Implement the approved slice",
+            )
+            self.assertEqual(exit_code, 1)
+            self.assertIn("only principal control writer principal may mutate", stderr)
+            self.assertEqual(harness.goal()["control_revision"], 1)
+
+    def test_stale_revision_fails_before_write(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            harness = LedgerHarness(Path(directory))
+            harness.init()
+            first = harness.run(
+                "set-next",
+                "--goal-id",
+                "release-42",
+                "--actor",
+                "principal",
+                "--expected-revision",
+                "1",
+                "--action",
+                "Review the assignment",
+            )
+            self.assertEqual(first[0], 0)
+            second = harness.run(
+                "set-state",
+                "--goal-id",
+                "release-42",
+                "--actor",
+                "principal",
+                "--expected-revision",
+                "1",
+                "--state",
+                "active",
+            )
+            self.assertEqual(second[0], 1)
+            self.assertIn("stale control revision", second[2])
+            self.assertEqual(harness.goal()["state"], "planned")
+
+    def test_phase_and_links_change_only_through_principal(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            harness = LedgerHarness(Path(directory))
+            harness.init()
+            self.assertEqual(
+                harness.run(
+                    "set-phase",
+                    "--goal-id",
+                    "release-42",
+                    "--actor",
+                    "principal",
+                    "--expected-revision",
+                    "1",
+                    "--phase",
+                    "implementation",
+                )[0],
+                0,
+            )
+            self.assertEqual(
+                harness.run(
+                    "set-links",
+                    "--goal-id",
+                    "release-42",
+                    "--actor",
+                    "principal",
+                    "--expected-revision",
+                    "2",
+                    "--anchor",
+                    "product-requirements.md#revision-4",
+                    "--control-document",
+                    "local-docs/control/checkpoint.md",
+                )[0],
+                0,
+            )
+            goal = harness.goal()
+            self.assertEqual(goal["phase"], "implementation")
+            self.assertEqual(goal["anchors"], ["product-requirements.md#revision-4"])
+            self.assertEqual(goal["control_documents"], ["local-docs/control/checkpoint.md"])
+
+    def test_delegate_evidence_is_verified_and_recorded_by_principal(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            harness = LedgerHarness(Path(directory))
+            harness.init()
+            exit_code, _, stderr = harness.run(
+                "add-evidence",
+                "--goal-id",
+                "release-42",
+                "--actor",
+                "principal",
+                "--expected-revision",
+                "1",
+                "--kind",
+                "test",
+                "--summary",
+                "Targeted tests passed",
+                "--locator",
+                "run:835",
+                "--producer",
+                "implementation-auth-01",
+                "--observed-at",
+                "2026-07-17T09:15:00-06:00",
+            )
+            self.assertEqual(exit_code, 0, stderr)
+            evidence = harness.goal()["evidence"][0]
+            self.assertEqual(evidence["producer"], "implementation-auth-01")
+            self.assertEqual(evidence["verified_by"], "principal")
+            self.assertEqual(evidence["observed_at"], "2026-07-17T15:15:00Z")
+            self.assertEqual(harness.goal()["last_verified_at"], "2026-07-17T15:15:00Z")
+
+    def test_last_verified_tracks_latest_observation_not_write_order(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            harness = LedgerHarness(Path(directory))
+            harness.init()
+            observations = (
+                ("2026-07-17T10:00:00Z", "first"),
+                ("2026-07-17T09:00:00Z", "older imported evidence"),
+                ("2026-07-17T11:00:00Z", "newest"),
+            )
+            for revision, (observed_at, summary) in enumerate(observations, start=1):
+                exit_code, _, stderr = harness.run(
+                    "add-evidence",
+                    "--goal-id",
+                    "release-42",
+                    "--actor",
+                    "principal",
+                    "--expected-revision",
+                    str(revision),
+                    "--kind",
+                    "runtime",
+                    "--summary",
+                    summary,
+                    "--observed-at",
+                    observed_at,
+                )
+                self.assertEqual(exit_code, 0, stderr)
+            self.assertEqual(harness.goal()["last_verified_at"], "2026-07-17T11:00:00Z")
+
+    def test_recovery_opens_without_discriminating_evidence(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            harness = LedgerHarness(Path(directory))
+            harness.init()
+            self.assertEqual(
+                harness.run(
+                    "begin-recovery",
+                    "--goal-id",
+                    "release-42",
+                    "--actor",
+                    "principal",
+                    "--expected-revision",
+                    "1",
+                    "--slice-label",
+                    "checkout",
+                    "--worker-id",
+                    "recovery-01",
+                )[0],
+                0,
+            )
+            self.assertEqual(
+                harness.run(
+                    "record-recovery-failure",
+                    "--goal-id",
+                    "release-42",
+                    "--actor",
+                    "principal",
+                    "--expected-revision",
+                    "2",
+                    "--slice-label",
+                    "checkout",
+                    "--failure-evidence",
+                    "run:843",
+                    "--no-new-evidence",
+                )[0],
+                0,
+            )
+            check = harness.run(
+                "check-recovery",
+                "--goal-id",
+                "release-42",
+                "--slice-label",
+                "checkout",
+            )
+            self.assertEqual(check[0], 1)
+            self.assertIn("changed hypothesis", check[2])
+            self.assertEqual(harness.goal()["recovery_circuits"][0]["state"], "open")
+
+    def test_root_cause_reset_allows_new_recovery(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            harness = LedgerHarness(Path(directory))
+            harness.init()
+            commands = [
+                (
+                    "begin-recovery",
+                    "--goal-id", "release-42", "--actor", "principal",
+                    "--expected-revision", "1", "--slice-label", "checkout",
+                    "--worker-id", "recovery-01",
+                ),
+                (
+                    "record-recovery-failure",
+                    "--goal-id", "release-42", "--actor", "principal",
+                    "--expected-revision", "2", "--slice-label", "checkout",
+                    "--failure-evidence", "run:843", "--no-new-evidence",
+                ),
+                (
+                    "reset-recovery",
+                    "--goal-id", "release-42", "--actor", "principal",
+                    "--expected-revision", "3", "--slice-label", "checkout",
+                    "--root-cause-evidence", "review:provider-startup",
+                ),
+                (
+                    "begin-recovery",
+                    "--goal-id", "release-42", "--actor", "principal",
+                    "--expected-revision", "4", "--slice-label", "checkout",
+                    "--worker-id", "recovery-02",
+                ),
+            ]
+            for command in commands:
+                exit_code, _, stderr = harness.run(*command)
+                self.assertEqual(exit_code, 0, stderr)
+            circuit = harness.goal()["recovery_circuits"][0]
+            self.assertEqual(circuit["state"], "active")
+            self.assertEqual(circuit["assigned_worker"], "recovery-02")
+            self.assertEqual(circuit["last_reset_evidence"], "review:provider-startup")
+
+    def test_complete_requires_evidence_and_no_next_action(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            harness = LedgerHarness(Path(directory))
+            harness.init()
+            failed = harness.run(
+                "set-state", "--goal-id", "release-42", "--actor", "principal",
+                "--expected-revision", "1", "--state", "complete",
+            )
+            self.assertEqual(failed[0], 1)
+            self.assertIn("state complete requires evidence", failed[2])
+            self.assertEqual(harness.goal()["control_revision"], 1)
+
+    def test_public_mutation_gate_records_existing_authority(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            harness = LedgerHarness(Path(directory))
+            harness.init()
+            missing_action = harness.run(
+                "set-gate", "--goal-id", "release-42", "--actor", "principal",
+                "--expected-revision", "1", "--gate", "authorized",
+            )
+            self.assertEqual(missing_action[0], 1)
+            self.assertIn("public mutation action", missing_action[2])
+            success = harness.run(
+                "set-gate", "--goal-id", "release-42", "--actor", "principal",
+                "--expected-revision", "1", "--gate", "authorized",
+                "--action", "merge PR 256 after current-head review",
+            )
+            self.assertEqual(success[0], 0, success[2])
+            self.assertEqual(harness.goal()["public_mutation_gate"], "authorized")
+
+    def test_schema_three_migrates_to_principal_only_schema_four(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            harness = LedgerHarness(Path(directory))
+            harness.path.parent.mkdir(parents=True)
+            legacy = {
+                "schema_version": 3,
+                "updated_at": "2026-07-17T12:00:00Z",
+                "goals": [
+                    {
+                        "id": "legacy",
+                        "goal": "Preserve the result",
+                        "execution_owner": "principal",
+                        "worker_id": "worker-7",
+                        "state": "active",
+                        "next_action": "Verify the result",
+                        "next_check_at": None,
+                        "completion_evidence": [
+                            {
+                                "kind": "runtime",
+                                "summary": "Service is healthy",
+                                "locator": "probe:1",
+                                "recorded_at": "2026-07-17T11:00:00Z",
+                            }
+                        ],
+                        "public_mutation_gate": "closed",
+                        "public_mutation_action": None,
+                        "decision_needed": None,
+                        "control_writer": "principal",
+                        "control_revision": 4,
+                        "control_edit_grants": [
+                            {"actor": "worker-7", "mutations": ["add-evidence"]}
+                        ],
+                        "recovery_circuits": [
+                            {
+                                "slice_label": "api",
+                                "state": "claimed",
+                                "last_failure_evidence": None,
+                                "last_failure_at": None,
+                                "last_reset_evidence": None,
+                                "last_reset_at": None,
+                                "claimed_by": "worker-7",
+                            }
+                        ],
+                        "created_at": "2026-07-17T10:00:00Z",
+                        "updated_at": "2026-07-17T12:00:00Z",
+                    }
+                ],
+            }
+            harness.path.write_text(json.dumps(legacy), encoding="utf-8")
+            exit_code, stdout, stderr = harness.run("status", "--json")
+            self.assertEqual(exit_code, 0, stderr)
+            migrated = json.loads(stdout)["goals"][0]
+            self.assertNotIn("control_edit_grants", migrated)
+            self.assertEqual(migrated["phase"], "implementation")
+            self.assertEqual(migrated["evidence"][0]["verified_by"], "principal")
+            self.assertEqual(migrated["recovery_circuits"][0]["state"], "active")
+            self.assertEqual(migrated["recovery_circuits"][0]["assigned_worker"], "worker-7")
+
+    def test_ledger_path_stays_under_local_directory(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            outside = root / "control.json"
+            stderr = io.StringIO()
+            with redirect_stderr(stderr):
+                exit_code = ledger.main(
+                    ["--root", str(root), "--ledger", str(outside), "status"]
+                )
+            self.assertEqual(exit_code, 1)
+            self.assertIn("ledger path must stay under", stderr.getvalue())
+
+    def test_status_exposes_links_phase_and_principal(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            harness = LedgerHarness(Path(directory))
+            harness.init()
+            exit_code, stdout, stderr = harness.run("status", "--plain")
+            self.assertEqual(exit_code, 0, stderr)
+            self.assertIn("phase=planning", stdout)
+            self.assertIn("principal=principal", stdout)
+            self.assertIn("revision=1", stdout)
 
-from _test_orchestration_ledger_cases1 import OrchestrationLedgerTests1
-from _test_orchestration_ledger_cases2 import OrchestrationLedgerTests2
-from _test_orchestration_ledger_cases3 import OrchestrationLedgerTests3
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/scripts/test-reviewed-config.py b/scripts/test-reviewed-config.py
index 012502c7..cfaffc4d 100644
--- a/scripts/test-reviewed-config.py
+++ b/scripts/test-reviewed-config.py
@@ -59,9 +59,9 @@ def evaluate(self, reviewed: str = REVIEWED, live: str | None = LIVE):
             root = Path(temp_dir)
             reviewed_path = root / "config.review.toml"
             live_path = root / "config.toml"
-            reviewed_path.write_text(reviewed, encoding="utf-8")
+            reviewed_path.write_text(reviewed, encoding="utf-8", newline="")
             if live is not None:
-                live_path.write_text(live, encoding="utf-8")
+                live_path.write_text(live, encoding="utf-8", newline="")
             return reviewed_config.evaluate(reviewed_path, live_path)
 
     def test_overlay_preserves_unreviewed_state(self):
diff --git a/workflows/README.md b/workflows/README.md
index 92793b4c..1d8c388c 100644
--- a/workflows/README.md
+++ b/workflows/README.md
@@ -1,24 +1,25 @@
-# Maintainer Workflows
+# Workflows
 
-These workflows maintain Compass. They are not installed into a live Codex
-home, user skill home, or Claude home.
+These files guide recurring Compass maintenance. They are not installed into a
+Codex home, user-skill home, or Claude home.
 
-Choose the narrowest workflow that matches the work in front of you. Read the
-linked workflow before changing its covered surface.
+Choose the workflow by the decision or operation it owns:
 
-| Read when | Workflow |
+| Work | Workflow |
 | --- | --- |
-| Adding or rerouting a durable file, skill, agent, hook, script, manifest, or config fragment | [addition-intake.md](addition-intake.md) |
-| Turning a repeated agent failure into a durable improvement | [agent-failures.md](agent-failures.md) |
-| Changing the derived Claude skills or agents | [claude-config.md](claude-config.md) |
-| Recovering unfinished local sessions after a Codex restart | [codex-restart-recovery.md](codex-restart-recovery.md) |
-| Auditing or pruning installed skills, agents, hooks, or maintainer guidance | [compass-review-program.md](compass-review-program.md) |
-| Preserving controller-owned goals, owners, evidence, cadence, gates, and decisions across sessions | [orchestration-ledger.md](orchestration-ledger.md) |
-| Coordinating several audit or PR threads without expanding public PR scope | [multi-thread-pr-coordination.md](multi-thread-pr-coordination.md) |
-| Creating a durable written implementation plan | [plan-template.md](plan-template.md) |
-| Installing, copying, diffing, or updating the portable Codex and Claude setup | [portable-config.md](portable-config.md) |
-| Mapping a repository or external source before deciding whether to edit | [read-only-research.md](read-only-research.md) |
-| Installing or refreshing the separately owned `which-llm` plugin | [which-llm-plugin.md](which-llm-plugin.md) |
+| Decide whether a durable artifact belongs in Compass | [addition-intake.md](addition-intake.md) |
+| Audit skills, agents, hooks, docs, manifests, and config | [compass-review-program.md](compass-review-program.md) |
+| Maintain separate Claude global guidance and derived surfaces | [claude-config.md](claude-config.md) |
+| Install, diff, snapshot, verify, or update portable source | [portable-config.md](portable-config.md) |
+| Preserve one objective across contexts and delegates | [long-running-work.md](long-running-work.md) |
+| Operate the local mechanical control index | [orchestration-ledger.md](orchestration-ledger.md) |
+| Author a reviewed durable plan artifact | [plan-template.md](plan-template.md) |
+| Coordinate parallel PR work without public sprawl | [multi-thread-pr-coordination.md](multi-thread-pr-coordination.md) |
+| Recover unfinished Codex sessions after restart | [codex-restart-recovery.md](codex-restart-recovery.md) |
+| Map repository or external evidence before editing | [read-only-research.md](read-only-research.md) |
+| Turn repeated agent failures into durable improvements | [agent-failures.md](agent-failures.md) |
+| Install and refresh the separately owned `which-llm` plugin | [which-llm-plugin.md](which-llm-plugin.md) |
 
-For design rationale and maintenance lessons, see
-[../local-docs/README.md](../local-docs/README.md).
+Use [../glossary.md](../glossary.md) when a term changes ownership, authority,
+or lifecycle behavior. Keep workflows focused on maintainer action. Put reusable
+runtime judgment in skills or agents, and put exact mechanics in scripts.
diff --git a/workflows/addition-intake.md b/workflows/addition-intake.md
index 87e06a2d..ab663d65 100644
--- a/workflows/addition-intake.md
+++ b/workflows/addition-intake.md
@@ -1,156 +1,147 @@
 # Addition Intake Workflow
 
-Use this workflow when deciding whether a new Compass rule, workflow, skill,
-agent, hook, script, manifest entry, or config fragment belongs in Compass.
-This is maintainer guidance for promoting durable artifacts, not a runtime rule
-for every agent session.
-
-## Intake Standard
-
-Treat additions as candidates until evidence shows they solve a repeated problem
-and can be reviewed, reinstalled, and verified without carrying generated state.
-Promote additions when they are human-owned, portable, and useful outside one
-transient task.
-
-## Reduction Case
-
-Before treating an addition as durable, name its reduction case:
-
-- the recurring context, state, duplication, drift, or maintenance cost it
-  removes or prevents;
-- the existing artifact, manual step, duplicate source, or decision branch it
-  replaces, merges, narrows, derives, or mechanizes;
-- why the remaining surface is the narrowest one that preserves the behavior.
-
-An addition can be justified when it creates distinct new behavior. In that
-case, state why its continuing cost is worth carrying instead of presenting it
-as free improvement.
-
-Keep generated state, plugin cache output, auth state, sessions, logs, browser
-profiles, local runtime paths, and one-machine trust settings in live or ignored
-local storage.
-
-The default path is staged:
-
-1. For installed agentic guidance, use or test the addition in the live target
-   home first when that is the lowest risk way to validate behavior.
-2. Capture the problem it solves, the evidence that it worked, and its
-   reduction case.
-3. Decide the smallest durable artifact type and what existing surface it can
-   replace, narrow, or intentionally leave unchanged.
-4. Copy only reviewed portable files into this repo.
-5. Wire the addition into the route-specific allowlist, install map, docs, and
-   checks that apply to that artifact type.
-6. Open a PR before treating the portable copy as accepted.
-
-Imported setup from other agents follows the same path. Treat imported files,
-skills, hooks, MCP config, and settings as candidate input only. Review them,
-route them to the narrowest durable artifact, and keep imported chats, project
-lists, auth, plugin follow-up state, and other migration-only runtime data out
-of this repo unless the repo intentionally adopts a reviewed portable form.
-
-## Routing
-
-- Repeated human process: add a focused file in `workflows/`.
-- Specialized agent behavior: add a skill under `codex/skills/`.
-- Focused reviewer or researcher persona: add an agent under `codex/agents/`.
-- Claude Code skill or agent: add the reviewed source under `codex/skills/` or
-  `codex/agents/`, then list it in `[claude].derived_skills` or
-  `[claude].derived_agents` so it derives at install time.
-- Mechanical check or sync behavior: add or update a script under `scripts/`.
-- Portability boundary or tool capability: update `manifests/`.
-- Repo-only maintenance lesson: update `local-docs/`.
-- Session-wide personal default: update `codex/AGENTS.md` only after review.
-- Stable config fragment: update `codex/config.review.toml`; keep live
-  `config.toml` out of repo changes.
-
-If an addition fits more than one route, choose the narrowest route that solves
-the repeated problem.
-
-## Runtime Vs Maintainer Guidance
-
-Decide whether the artifact is meant to be installed into a live Codex home,
-user skill home, Claude home, or only used to maintain this repo.
-
-Installed agentic guidance changes how future agent sessions behave. Put its
-reviewed source in `codex/AGENTS.md`, `codex/agents/`, or `codex/skills/`; the
-Claude surface derives from that source at install time. Keep it focused on
-durable role, stance, judgment, and capability boundaries. Do not include
-Compass maintenance process, PR hygiene, install-map details, or one-repo
-review habits in installed agentic docs.
-
-Repo-maintainer guidance helps humans and agents edit this repository. Put that
-in this root `AGENTS.md`, `workflows/`, `local-docs/`, `manifests/`, or
-`scripts/`. It can explain promotion rules, local checks, stale-guidance sweeps,
-and why a portable file belongs here. It should not pretend to be a runtime rule
-for every agent session.
-
-## Skill And Agent Additions
-
-Skills and agents need extra review because they shape future agent behavior.
-
-- Keep skill descriptions concise and specific.
-- Put detailed skill instructions in `SKILL.md`, references, scripts, or
-  assets.
-- Exclude system skills and plugin cache skills unless the repo intentionally
-  owns a local copy.
-- Install user skills into `$HOME/.agents/skills`; keep `codex/skills/` as the
-  reviewed source tree.
-- Add each portable skill name to `manifests/portable-files.toml`.
-- `scripts/common.ps1` reads portable skill names from that manifest.
-- For Claude skills and agents, list the codex skill in `[claude].derived_skills`
-  and the codex agent in `[claude].derived_agents` in
-  `manifests/portable-files.toml`.
-- When removing a previously portable user skill, keep its legacy Codex-home
-  retirement entry and add an explicit user-home retirement entry to
-  `Get-RetiredPortableFileMap` so `install.ps1 -Apply` actually uninstalls
-  both live copies.
-- Give agents a sandbox that matches their evidence path. Pure explorers that
-  should never mutate state need `sandbox_mode = "read-only"`. Reviewers that
-  must run tests, commands, browser checks, or plugin-backed validation should
-  be non-editing by instruction instead of blocked by sandbox.
-- Run `.\scripts\doctor.ps1` to catch manifest boundary and agent sandbox
-  drift.
-
-## Memory-Only Skills
-
-Treat files under the live Codex memory skills directory (`$CODEX_HOME/memories/skills` or equivalent) as candidate
-legacy material, not active portable skills. They are useful evidence about past
-workflow experiments, but they do not belong in `codex/skills/` until fresh
-examples show the capability is still repeated, portable, and worth installing.
-
-When reviewing a memory-only skill:
-
-- Promote it only when recent repeated examples prove the same capability is
-  still useful across repos or workflows.
-- Fold it into an existing Compass skill when the behavior overlaps a current
-  installed skill.
-- Retire it as stale local history when it no longer maps to current Codex,
-  Compass, or repo workflows.
-- Prefer a maintainer workflow note, local doc, or `*-learnings.md` entry in `local-docs/` when
-  the material explains how to maintain Compass rather than how future agent
-  sessions should act.
-
-Do not create a new installed global skill from memory-only material unless the
-fresh evidence supports promotion better than a repo-maintainer note or an
-update to an existing Compass skill.
-
-## Stale Guidance Sweep
-
-Every addition should include a nearby stale-guidance pass:
-
-- Check whether README layout notes mention the new artifact type or workflow.
-- Check whether `local-docs/README.md` lists new local docs.
-- Check whether `workflows/portable-config.md` links new workflows.
-- Check whether `scripts/doctor.ps1` should require the new durable file.
-- Check whether agent or tool docs still match current sandbox and review rules.
-- Replace guidance that describes an old flow with the current route.
-
-Scope the sweep to directly related cleanup. Fix stale items that affect the new
-addition flow or current portability checks.
-
-## PR Shape
-
-Use a pull request as the review unit for additions. Keep the PR focused on the
-addition and its directly related stale-guidance fixes. Include the verification
-commands in the PR body or final report.
+Use this workflow to decide whether a new Compass rule, workflow, skill, agent,
+hook, script, manifest entry, config fragment, or carried pack deserves a durable
+place in the repository.
+
+Compass is an allowlist. Every addition must earn its recurring context,
+retrieval, install, validation, and maintenance cost.
+
+## Start With The Reduction Case
+
+State the repeated problem and the cost the addition removes or prevents:
+
+- recurring context or explanation;
+- duplicate sources or decisions;
+- generated state mistaken for reviewed source;
+- drift that should become mechanically detectable;
+- repeated judgment that needs a durable stance;
+- a distinct capability worth its continuing cost.
+
+Name what the addition replaces, narrows, derives, mechanizes, or makes
+obsolete. When it creates net-new behavior, say why that behavior belongs in
+every intended runtime instead of one project, one experiment, or one machine.
+
+Generated state, auth, sessions, logs, browser profiles, caches, machine paths,
+and live trust settings remain local.
+
+## Choose The Narrowest Durable Surface
+
+Route the behavior to the reader that needs it:
+
+- session-wide Codex defaults: `codex/AGENTS.md`;
+- session-wide Claude defaults: `claude/CLAUDE.md`;
+- reusable runtime judgment: `codex/skills/`;
+- reusable reviewer, explorer, monitor, or worker persona: `codex/agents/`;
+- Claude-specific agent contract that cannot derive safely: `claude/agents/`;
+- project-specific capability: the target project repository;
+- useful portable pack outside every global session: `carried/`;
+- Compass maintainer process: `workflows/`;
+- maintainer reasoning and dated evidence: `local-docs/`;
+- deterministic or fragile mechanics: `scripts/`;
+- install, portability, schema, and policy truth: `manifests/`;
+- stable reviewed Codex configuration: `codex/config.review.toml`.
+
+Codex and Claude share skills and many agents when the runtime contract is truly
+portable. Their global instruction files remain separately authored because the
+runtimes, models, and delegation surfaces differ.
+
+## Shape Runtime Guidance
+
+Installed guidance points toward a desired state. Front-load:
+
+- the role being adopted;
+- the result it should create;
+- the repeated failure the role corrects;
+- the evidence that proves success;
+- the authority boundary that preserves trust.
+
+Use decisive positive direction for judgment. Reserve prohibitions for crisp,
+observable boundaries and recurring failure shapes. Put exact procedures only
+where sequence protects a fragile operation or handoff contract.
+
+Runtime files carry action. Maintainer history, model calibration, provenance,
+and packaging rationale belong in maintainer documentation or references that
+normal work does not load.
+
+## Prove The Addition Before Promotion
+
+A durable addition follows this path:
+
+1. Observe a repeated failure or distinct recurring need.
+2. Test the smallest candidate behavior in the lowest-risk appropriate surface.
+3. Record the reduction case and evidence.
+4. Choose the narrowest durable artifact.
+5. Remove or update the surface the addition supersedes.
+6. Wire the reviewed files into the exact install and derivation maps.
+7. Add mechanical checks for properties that should not drift.
+8. Forward-test judgment guidance with a fresh realistic agent when behavior is
+   the product.
+9. Review the complete change as one PR before treating it as accepted.
+
+Imported setup is candidate material, not reviewed source. Preserve only the
+portable behavior Compass intentionally adopts.
+
+## Skills And Agents
+
+A global skill or agent must remain useful across repositories and ordinary
+workflows. Project lore, benchmark families, and temporary experiments belong
+in the target repository or a carried pack.
+
+For an installed skill:
+
+- keep `SKILL.md` lean and put optional depth one level under `references/`;
+- put deterministic mechanics under `scripts/`;
+- put output resources under `assets/`;
+- keep the description concise enough to route invocation correctly;
+- list it in `[agents].skills`;
+- list it in `[claude].derived_skills` only when the runtime contract is shared;
+- add its reviewed source record to `manifests/skill-sources.json`;
+- update required-file and policy checks that bind to it.
+
+For a shared agent, maintain the reviewed Codex source and derive Claude only
+when the transform preserves its tools, model-independent role, and isolation
+contract. Maintain a direct Claude agent when the platform-specific contract is
+material.
+
+Model and effort routing should reflect the current dated profile, not inherited
+habit. Runtime role files state their effective route where the platform
+supports it.
+
+## Retirement Is Part Of The Change
+
+Removing or renaming an installed capability requires explicit retirement for
+every live location Compass previously owned:
+
+- legacy Codex-home skill copies;
+- user skill-home copies;
+- derived Claude skill copies;
+- direct or derived agent copies;
+- stale manifest, source catalog, doctor, MCP, and documentation references.
+
+Preserve useful specialized material in its authorized carried or project route
+before retiring the global copy.
+
+## Memory-Only Material
+
+Treat live memory skills as historical evidence. Promote them only when fresh
+examples prove a repeated portable capability. Fold overlapping behavior into
+an existing skill, route maintainer lessons to `local-docs/`, and retire stale
+experiments instead of converting history directly into global context.
+
+## Stale-Guidance Sweep
+
+Every addition or retirement checks the nearby system:
+
+- root and workflow indexes;
+- Codex and Claude global guidance;
+- install and derivation maps;
+- source provenance;
+- retired-path maps;
+- required-file and policy checks;
+- MCP catalogs and smoke tests;
+- copyable workspace guidance;
+- model calibration when routing changed.
+
+Fix directly related stale guidance in the same change. The accepted repository
+should describe one current route.
diff --git a/workflows/agent-failures.md b/workflows/agent-failures.md
index 65144d0d..5a8ac987 100644
--- a/workflows/agent-failures.md
+++ b/workflows/agent-failures.md
@@ -1,124 +1,167 @@
 # Agent Failure Journal
 
-Use this file to convert repeated agent mistakes into targeted workflow changes.
-Do not add global rules for one-off failures. Record enough detail to identify
-the first upstream failure and decide whether the fix belongs in instructions,
-a skill, a script, a test, or repo documentation.
+Use this file to convert repeated agent mistakes into targeted system changes.
+Record the first upstream failure, the evidence that exposes it, and the narrowest
+surface that can prevent recurrence.
 
-This is repo-maintainer guidance and is not installed into a live Codex home,
-user skill home, or Claude home. When a failure should change future agent
-behavior, route the fix into the reviewed source under `codex/AGENTS.md`,
-`codex/agents/`, or `codex/skills/`. The Claude surface derives from those
-sources at install time.
+This is maintainer evidence. Runtime corrections belong in the separately
+reviewed Codex or Claude global source, a focused skill or agent, a project
+surface, or a mechanical check.
 
 ## Entry Template
 
 ```text
 date:
+runtime and model:
 repo or workflow:
 task:
 first failure:
 downstream effects:
 evidence:
 root cause category:
-fix made:
+durable response:
 verification:
-should become durable guidance:
+review date:
 ```
 
 ## Categories
 
-- missing context: the agent did not inspect required files, docs, logs, or
-  runtime state;
-- incorrect context: the agent relied on stale, guessed, or irrelevant facts;
-- noisy context: useful evidence was buried under low-value output;
-- weak verification: completion was claimed without a check that covered the
-  changed behavior;
-- objective drift: a current obstacle, repair, phase, action, or delegated slice
-  replaced the user's terminal outcome or completion predicate;
+- missing context: authoritative files, runtime state, or prior decisions were
+  not inspected;
+- incorrect context: stale, guessed, or irrelevant material drove the route;
+- noisy context: useful evidence was buried under low-value transcript or logs;
+- lossy delegation: an assignment or compaction handoff weakened the original
+  understanding;
+- distributed control authorship: delegates invented or rewrote the goal, plan,
+  catalog, ledger, or checkpoint;
+- premature implementation: production mutation began before the objective and
+  authority were stable;
+- accretive repair: repeated guards, wrappers, or rewrites accumulated around a
+  cause that remained uncorrected;
+- weak verification: completion was claimed without evidence covering the
+  required behavior;
+- objective drift: the current route replaced the requested finished state;
 - unsafe mutation: files, branches, services, or external state changed outside
-  the intended scope;
-- workflow mismatch: the task needed planning, research, browser validation,
-  or PR handling but ran as a simple edit;
-- tool-surface risk: a plugin, MCP server, browser, shell, or network tool had
-  broader capability than the task required.
+  granted authority;
+- workflow mismatch: the task needed planning, research, experimentation,
+  monitoring, review, or orchestration but used the wrong operating shape;
+- tool-surface risk: a tool had broader capability than the assignment needed.
 
 ## Review Loop
 
-1. Record the first failure, not every downstream symptom.
-2. Group similar entries after several traces.
-3. Add durable guidance only when the same category repeats.
-4. Prefer a script or focused workflow over a broad global rule.
-5. Remove stale guidance when the underlying failure no longer appears.
+1. Capture the first failure and current evidence.
+2. Group repeated instances by cause rather than visible symptom.
+3. Select the narrowest durable correction.
+4. Prefer mechanics for exact properties and guidance for judgment.
+5. Forward-test behavioral corrections with a fresh context.
+6. Revisit dated model counterweights when the model profile changes.
+7. Remove guidance after evidence shows the failure no longer justifies its
+   recurring cost.
 
 ## Recorded Failures
 
+### 2026-07-17: Delegates became authors of control state
+
+- Failure: control guidance assigned separate goal, catalog, and worker-ledger
+  writers. Each delegation added another interpretation layer and another state
+  format.
+- Cause: lossy delegation, distributed control authorship, noisy context.
+- Durable response: one logical user-facing principal authors the goal, plan,
+  catalog, assignments, ledger shape, and checkpoints across contexts. Delegates
+  receive reviewed assignments and return artifacts plus evidence. Principal-only
+  ledger mutation is mechanically enforced.
+- Verification: schema version 4 rejects delegated control grants and records
+  evidence provenance while preserving optimistic revision checks.
+
+### 2026-07-17: Negative-only guidance left the route undefined
+
+- Failure: several instructions described forbidden behavior without naming the
+  desired replacement, leaving a broad unstable action space.
+- Cause: incorrect context, workflow mismatch.
+- Durable response: Compass guidance leads with role, desired state, evidence,
+  and authority. Crisp prohibitions remain for secrets, worktree scope, public
+  mutation, and similarly observable boundaries.
+- Verification: philosophy, skill-authoring guidance, runtime globals, and policy
+  contracts encode desired-state-first prompting.
+
+### 2026-07-17: Eager implementation outran understanding
+
+- Failure: production edits began while the user was still shaping the plan.
+  Early motion made a weak interpretation costly to stop.
+- Cause: premature implementation, objective drift.
+- Durable response: goals and control state carry a planning or implementation
+  phase. Material plans and assignments remain reviewable before dispatch unless
+  the user has granted or waived that review boundary.
+- Verification: long-running-work guidance, plan templates, global instructions,
+  and ledger phase state preserve the implementation gate.
+
+### 2026-07-17: Persistent repair accumulated code around symptoms
+
+- Failure: repeated patches added guards, wrappers, and broad rewrites instead
+  of repairing the owning boundary.
+- Cause: accretive repair, weak verification.
+- Durable response: `root-cause-not-symptom` reopens the causal model when the
+  symptom recurs and ends with a subtractive review for duplicate state,
+  unnecessary branches, and obsolete compatibility paths.
+- Verification: the skill and code-quality review template require causal and
+  subtractive evidence.
+
 ### 2026-07-13: Goal substituted a route for the requested result
 
-- Failure: a parent goal and its delegated slices described the currently known
-  repair sequence and subsequent action instead of the observable state the user
-  wanted at the end. Completing the repair therefore left no durable contract
-  that required the remaining result and evidence.
+- Failure: a parent goal described a repair sequence instead of the observable
+  state the user wanted at the end.
 - Cause: objective drift, workflow mismatch, weak verification.
-- Durable response: goal contracts separate a stable finished state and required
-  assertions from a mutable acceptance ledger and execution state; child slices
-  name the parent assertions they advance; controllers recompute unmet assertions
-  after every return; monitors and route completion never imply parent completion.
-
-These records preserve the first upstream failure and durable correction. Keep
-detailed evidence with the reviewable change that adopted it, not repeated here.
-
-### 2026-07-13: Goal lost its operational map
-
-- Failure: a prep-only benchmark child amended and reconstructed a
-  controller-owned Markdown control file without edit authority. Later, the
-  long-running goal kept driving output after controller, worker, monitor, and
-  repair roles collapsed together and required control files became large,
-  contradictory, and partly historical.
-- Cause: missing context, incorrect context, noisy context, workflow mismatch.
-- Durable response: mutable control surfaces have one named writer and delegated
-  roles need exact edit authority; goal contracts name authoritative inputs in
-  precedence order, one short mutable-state surface, and a compaction or handoff
-  re-anchor; orchestration restores separate controller and execution owners
-  before new dispatches; benchmark recovery stops after two failed successors
-  until the complete child runtime path receives fresh root-cause review.
-
-### 2026-07-08: Inline review visibility
+- Durable response: `using-goals` separates stable finished state and assertions
+  from mutable route, owner, blocker, and next action. Completion reconciles the
+  whole goal after every material return.
+
+### 2026-07-13: Long-running work lost its operational map
+
+- Failure: a child reconstructed a control file from partial context, then role
+  boundaries collapsed and the surviving documents became contradictory.
+- Cause: lossy delegation, distributed control authorship, noisy context.
+- Durable response: principal-authored anchors, a compact current checkpoint,
+  evidence provenance, and the fresh-context resume test preserve one intention
+  across compaction and replacement contexts.
+
+### 2026-07-08: Inline review findings remained hidden
 
 - Failure: top-level PR comments, reviews, and checks hid actionable inline
   comments.
 - Cause: missing context, weak verification.
-- Durable response: `compass-review-program` and `pr-review-loop` require
-  current-head inline-comment inspection alongside top-level review state.
+- Durable response: `pr-review-loop` inspects current-head inline threads beside
+  top-level review state.
 
-### 2026-07-02: Specialist review delegation
+### 2026-07-02: Specialist review lost independence
 
-- Failure: a parent shell-launched CLI children after missing the subagent route,
-  then risked reporting that output as coordinated specialist review.
+- Failure: a parent substituted shell-launched prompts for the dedicated
+  specialist route, then risked reporting the output as coordinated review.
 - Cause: workflow mismatch, tool-surface risk.
-- Durable response: `specialist-review` and `reviewer` require direct specialist
-  subagents; a manual prompt is explicitly outside coordinated review.
+- Durable response: `specialist-review` routes a neutral handoff through the
+  dedicated reviewer and reports failure when that capability is unavailable.
 
-### 2026-06-12: Multi-thread public-branch sprawl
+### 2026-06-12: Parallel work created public-branch sprawl
 
 - Failure: workers combined local tracking with public PR authority, producing
   overlapping drafts and scratch content.
-- Cause: workflow mismatch.
-- Durable response: `multi-thread-pr-coordination.md` separates local tracking
-  from focused PR branches, with current-head review gates for publication.
+- Cause: workflow mismatch, unsafe mutation.
+- Durable response: `multi-thread-pr-coordination.md` gives one principal public
+  branch authority, principal-authored assignments, and a focused PR budget.
 
-### 2026-06-18 and 2026-06-22: Controller recovery posture
+### 2026-06-18 and 2026-06-22: Controllers alternated between passivity and takeover
 
 - Failure: controllers accepted blocker or waiting claims as endpoints, then
-  overcorrected by taking worker-owned execution.
+  overcorrected by absorbing worker-owned execution.
 - Cause: workflow mismatch, weak verification.
-- Durable response: controller, goal, subagent, and benchmark guidance treat
-  those claims as evidence to diagnose, route to a named owner, and keep moving.
+- Durable response: the controller stays above execution, treats returns as
+  evidence, prepares the next reviewed route, and lets coherent workers continue
+  without babysitting.
 
-### 2026-06-23: Invalid benchmark rows as terminal blockers
+### 2026-06-23: Invalid benchmark rows became terminal blockers
 
 - Failure: timeout and provider-failure rows stopped healthy comparable work and
-  pulled the controller into the runner role.
+  pulled the principal into the runner role.
 - Cause: workflow mismatch, weak verification.
-- Durable response: benchmark and goal guidance treat invalid rows as recovery
-  work, preserve a named runner owner, and continue unaffected safe slices.
+- Durable response: the carried benchmark pack treats invalid rows as attributable
+  recovery work, preserves a named runner, and continues unaffected comparable
+  slices while provenance remains clean.
diff --git a/workflows/claude-config.md b/workflows/claude-config.md
index d72d81f1..a86682e0 100644
--- a/workflows/claude-config.md
+++ b/workflows/claude-config.md
@@ -1,38 +1,63 @@
 # Portable Claude Config Workflow
 
-Claude is an install target of Compass. Shared skills and most shared agents
-derive from the reviewed `codex/` source. A platform-specific direct agent may
-live under `claude/agents/` when Claude needs different frontmatter, tools, or
-isolation instructions.
-
-Use [portable-config.md](portable-config.md) for the shared edit, diff, install,
-and latest-to-live flow.
-
-## Source Rules
-
-- Edit shared skills under `codex/skills/<name>/` and list them in
-  `[claude].derived_skills`.
-- Edit shared agents under `codex/agents/<name>.toml` and list them in
-  `[claude].derived_agents`.
-- Put a Claude-specific agent under `claude/agents/<name>.md` and list it in
-  `[claude].agents` only when the shared transform cannot express its contract.
-- With `-ClaudeHome`, skills install to `<ClaudeHome>\skills\<name>` and agents
-  to `<ClaudeHome>\agents\<name>.md`; otherwise their root is `$HOME\.claude`.
-- Keep shared guidance runtime-neutral and avoid Codex-only invocation syntax.
-- Do not list Codex-only skills such as `using-codex-goals` in
-  `[claude].derived_skills`.
-- Carried packs are not installed into Claude unless a target project explicitly
-  adopts them.
-
-## Derivation
-
-For each derived skill, the installer copies `SKILL.md`, `references/`,
-`scripts/`, and `assets/` from the Codex source while excluding
-`agents/openai.yaml`.
-
-For each derived agent, it creates Claude frontmatter from the Codex TOML and
-`scripts/common.ps1`, preserves `developer_instructions`, and drops Codex-only
-fields. Direct Claude agents are copied as authored.
-
-The manifest and installer are the mechanical source of truth. Use
-[addition-intake.md](addition-intake.md) when promoting or retiring a capability.
+Claude Code is a first-class Compass install target with its own global runtime
+instructions. Shared runtime-neutral skills and most agent roles still derive
+from reviewed Codex sources.
+
+## Separate Global Guidance
+
+Maintain `claude/CLAUDE.md` directly and install it as
+`$HOME/.claude/CLAUDE.md`. Maintain `codex/AGENTS.md` separately.
+
+The two files may share values such as writing rules, worktree discipline,
+planning authority, and evidence standards. They should state runtime-specific
+model, delegation, tools, and context behavior directly instead of pretending
+both environments are identical.
+
+The current Claude profile uses GLM-5.2 for delegated work. Claude guidance
+names that fact so generic examples do not cause invented Opus, Sonnet, Haiku,
+or other unavailable routes.
+
+## Shared Skills And Agents
+
+- Author a shared skill under `codex/skills/<name>`.
+- List it in `[claude].derived_skills` when its behavior is runtime-neutral.
+- Author a shared agent under `codex/agents/<name>.toml`.
+- List it in `[claude].derived_agents` when the transform can express its
+  frontmatter and isolation contract.
+- Put a platform-specific direct agent under `claude/agents/<name>.md` and list
+  it in `[claude].agents` only when derivation is insufficient.
+- Keep carried packs out of Claude global installation unless a target project
+  explicitly adopts them.
+
+At install time, a derived skill copies `SKILL.md`, `references/`, `scripts/`,
+and `assets/` while excluding `agents/openai.yaml`. A derived agent receives
+Claude frontmatter from the reviewed transform and the role body from its Codex
+TOML source. Direct Claude agents copy as authored.
+
+## Install Map
+
+`manifests/portable-files.toml` owns:
+
+- `[claude].files` for separately authored top-level files;
+- `[claude].derived_skills` for shared skills;
+- `[claude].agents` for direct platform-specific agents;
+- `[claude].derived_agents` for shared derived roles.
+
+With `-ClaudeHome`, installation targets that root. Otherwise the target is
+`$HOME/.claude`.
+
+The manifest, installer transform, retirement map, doctor checks, and install
+round-trip tests are the mechanical source of truth. Update them together.
+
+## Review
+
+Before accepting a Claude change:
+
+- confirm whether the behavior is global, shared, direct, carried, or
+  project-specific;
+- inspect `claude/CLAUDE.md` for concise, current runtime truth;
+- inspect the derived output contract rather than maintaining a duplicate source;
+- verify model names and routing against dated current calibration;
+- remove retired files from every previously owned live location;
+- run doctor and install round-trip validation.
diff --git a/workflows/compass-review-program.md b/workflows/compass-review-program.md
index 13909caf..c72768a6 100644
--- a/workflows/compass-review-program.md
+++ b/workflows/compass-review-program.md
@@ -1,235 +1,181 @@
 # Compass Review Program
 
-Use this workflow when auditing Compass itself: installed skills, agents, hooks,
-maintainer docs, workflows, manifests, scripts, and reviewed config. The work is
-slow by design. Do not one-shot the repo.
+Use this workflow to audit Compass runtime guidance, agents, skills, hooks,
+maintainer documentation, carried packs, manifests, scripts, reviewed config,
+and install behavior.
 
-This is repo-maintainer guidance. It is not installed into a live Codex home,
-user skill home, or Claude home.
+Review one coherent surface family at a time. Understand first. Reduce recurring
+cost without weakening capability.
 
 ## Purpose
 
-Compass is the configuration of the configuration. If agents are led astray
-while maintaining this repo, the first suspect is Compass itself.
+Compass is configuration for agent judgment. A fresh runtime begins without the
+user's lived context or implicit taste. The reviewed source must establish the
+right direction quickly, preserve it across finite contexts, and make drift
+visible.
 
-The job is to make the setup night and day better than vanilla Codex, not a
-little better. That starts with understanding. A fresh agent begins with no
-project memory, no lived history, and no implicit taste. The repo must implant
-the right ideas quickly, without bloat, weak language, or distracting context.
+Review asks:
 
-Review is not cleanup theater. Review asks what each surface is for, who reads
-it, what they need at that moment, and what can be cut or moved without behavior
-loss. If pruning preserves behavior or improves behavior, the removed text was
-probably for the wrong audience or carried weak signal.
+- who reads this surface;
+- what state the reader is in;
+- what behavior the surface must create;
+- what evidence proves that behavior;
+- what authority belongs here;
+- what material can move, merge, mechanize, or disappear.
 
-The central theme is reduction: remove recurring context, duplication, state,
-and maintenance cost while preserving the behavior that makes the system useful
-and trustworthy.
+## Inventory The Current System
 
-## Review Stance
+Classify each item:
 
-Understand first. Cut second. Reduce cost, not capability.
+- Codex runtime global: `codex/AGENTS.md`;
+- Claude runtime global: `claude/CLAUDE.md`;
+- shared installed runtime capability: `codex/agents/` or `codex/skills/` with an
+  explicit Claude derivation decision;
+- Claude-specific runtime capability: `claude/agents/`;
+- carried capability: `carried/`;
+- maintainer context: root `AGENTS.md`, `workflows/`, or `local-docs/`;
+- mechanical truth: `scripts/`, `manifests/`, hooks, and reviewed config;
+- stale or removal candidate.
 
-Do not begin by rewriting. Read the target surface, name its runtime or
-maintainer audience, and state the job it must perform. Then decide what
-belongs, what distracts, what should move, and what should disappear.
-
-Examples are symptoms. If one skill leaks history, look for history leakage in
-nearby skills. If one workflow dilly-dallies around its point, look for the
-same weakness in related docs. If one global skill looks project-specific, check
-the installed set, the manifest, the Claude mirror, and the retirement path.
-
-## Inventory Pass
-
-Before editing a family of files, create a compact inventory. Use current files
-as authority, and update the inventory only when the map changes.
-
-Classify each item as one of:
-
-- runtime context: installed agentic behavior under `codex/AGENTS.md`,
-  `codex/agents/`, or `codex/skills/` (the Claude surface derives from these);
-- maintainer context: repo-only guidance under `AGENTS.md`, `workflows/`,
-  `local-docs/`, `manifests/`, or `scripts/`;
-- mechanical truth: scripts, manifests, checks, and reviewed config fragments;
-- historical evidence: failure journals and maintenance learnings;
-- carried but not global candidate: useful material that should travel in this
-  repo but should not be installed for every session;
-- stale or removal candidate: text or files that no longer justify their cost.
-
-For each item, record:
+Record only what changes a decision:
 
 ```text
 Path:
 Audience:
 Purpose:
+Desired behavior:
 Must preserve:
 Recurring cost:
+Overlap or stale route:
 Reduction move or net-new justification:
-What becomes obsolete, if anything:
-Possible cuts:
-Move candidates:
-Global-install justification:
 Evidence to inspect:
-Recommended PR:
+Verification:
 ```
 
-Keep the inventory short. It is a decision tool, not a second repo.
+## Review Runtime Guidance
 
-## Runtime Surface Audit
+Runtime guidance should establish a direction before procedure. The first screen
+should reveal:
 
-Installed runtime context must speak to the agent using it while doing work.
+- role;
+- desired result;
+- reason the role exists;
+- evidence standard;
+- authority boundary.
 
-Ask:
+Prefer desired-state-first language. Keep prohibitions when the forbidden shape
+is crisp, observable, and materially safer. Replace soft modal language around
+required behavior with calm direct instruction.
 
-- Who invokes this, and in what state?
-- What must the agent understand in the first screen?
-- What exact behavior should the text produce?
-- What authority does the agent have?
-- What must not be decided by this agent?
-- What evidence proves done?
-- What text explains history instead of producing action?
-- What phrasing makes failure, waiting, fallback, or drift feel acceptable?
-- What could be moved to maintainer docs with no runtime loss?
+Move dated observations, author history, packaging rationale, and maintainer
+debates out of runtime context. Keep exact procedures only where order protects
+a fragile mechanic, public mutation, isolation boundary, or handoff contract.
 
-Cut provenance, dated observations, packaging explanation, stale caveats, owner
-intent, and maintainer reasoning from runtime context. Keep the role, stance,
-non-negotiables, boundaries, evidence standard, and fragile procedure.
+For long-running guidance, verify that:
 
-## Hook Surface Audit
+- one logical principal authors control documents across contexts;
+- delegates receive reviewed assignments and return evidence;
+- compaction and restart can resume from anchors plus a checkpoint;
+- current route never replaces the stable goal;
+- planning authority is explicit before production mutation.
 
-Hooks are installed runtime behavior, not agent prose. Audit them as mechanical
-guards.
+## Review Model Routing
 
-Ask:
+Compare every role file with `local-docs/model-calibration.md` and current
+runtime support.
 
-- What event invokes this hook?
-- What does the hook add, deny, or block?
-- Does it fail open or fail closed, and is that correct for the event?
-- What exact guard module handles the behavior?
-- What doctor test proves the portable copy works?
-- Does hook-local documentation explain trust review and disablement?
-- Is this better as a hook than a skill, agent, script, or local workflow?
+For the current profile:
 
-Keep hook behavior narrow. Put broad judgment in skills, agents, or workflows.
-Hook PRs should include the hook definition, guard module, hook-local docs, and
-doctor tests.
+- Sol owns the Codex principal and work that justifies frontier capacity;
+- Luna is the default Codex delegated route;
+- Terra has no default coding role;
+- Claude delegates use the configured GLM-5.2 route;
+- effort matches the persistence and verification needed by the assignment;
+- mechanical waits use `monitor-to-completion` rather than a model loop.
 
-## Maintainer Surface Audit
+Treat this as dated policy. Update the calibration and runtime files together
+when evidence changes.
 
-Maintainer docs should make Compass easier to change without bloating runtime
-context.
+## Review Skills And Agents
 
-Ask:
+Every installed capability pays retrieval and maintenance cost. Ask:
 
-- Does this help a future maintainer understand why the repo is shaped this way?
-- Does it route a decision to the right surface?
-- Does it preserve history that would distract a runtime agent?
-- Does it explain a mechanical check, install boundary, or promotion path?
-- Does it make the next PR smaller and safer?
+- Is the behavior reusable across repositories?
+- Does ordinary runtime work benefit from retrieving it?
+- Is its description specific enough for natural invocation?
+- Does it shape judgment rather than prescribe every thought?
+- Does it overlap another role or merely compose with it?
+- Would a carried or project-local route preserve value at lower global cost?
+- Does the Claude derivation remain truthful?
+- Do install maps, source records, retirements, policy checks, and MCP catalogs
+  agree?
 
-Maintainer docs may hold history. They should not become dumping grounds. Keep
-history only when it changes a future maintenance decision.
+Useful specialized material moves to `carried/` before its global copy retires.
 
-## Skill Set Audit
+## Review Control And Ledger Surfaces
 
-Every installed skill pays rent. Being useful once is not enough.
+Control documents preserve one principal intention. Verify:
 
-For each global skill, ask:
+- principal-only authorship of goal, plan, catalog, assignments, and checkpoint;
+- evidence provenance for delegated returns;
+- absolute timestamps with time zones;
+- compact mutable state rather than narrative history;
+- optimistic revision protection for mechanical ledgers;
+- recovery that requires changed evidence before another equivalent attempt;
+- a fresh-context resume path.
 
-- Is this reusable across repos or workflows?
-- Does it need to be retrieved during ordinary Codex work?
-- Is it project-specific, benchmark-specific, or temporary?
-- Could it live as repo-carried but not globally installed material?
-- Does it overlap another skill enough to fold?
-- Does its Claude mirror still match the intended behavior?
-- Do manifests, installer logic, retired maps, and docs agree?
+A ledger supports the work. It never becomes the product.
 
-Do not delete useful material just because it is not global. Move it to a
-carried-but-not-global area only after the route exists and the install map,
-docs, and retirement behavior are clear.
+## Review Hooks And Mechanics
 
-## Pruning Standard
+Hooks and scripts enforce exact properties. Ask:
 
-Cut text when cutting it does not weaken the behavior. Cut harder when cutting
-it strengthens the behavior.
+- what event or command invokes the mechanic;
+- what it permits, adds, denies, or validates;
+- whether failure behavior matches the risk;
+- which test proves the reviewed copy works;
+- whether broad judgment has leaked into code;
+- whether prose describes a property that should be mechanized.
 
-Good pruning removes:
+## Reduction Standard
 
+Good reduction removes:
+
+- duplicate doctrine;
+- distributed state and alternate sources of truth;
 - audience mismatch;
-- author history in runtime context;
-- alternate paths for Compass-owned capabilities;
-- compatibility prose without a current compatibility need;
-- repeated explanation that hides the first action;
-- soft wording that makes collapse acceptable;
-- examples that became the boundary instead of teaching the pattern;
-- lists that replace judgment without preserving a fragile operation.
-
-Do not equate shorter with better. Dense is better. Exact is better. A small
-sentence that points the agent the wrong way is worse than a longer sentence
-that makes the right behavior unavoidable.
-
-## PR Rhythm
-
-Use focused PRs. The review program should create pressure and evidence, not
-one giant rewrite.
-
-Good PR boundaries:
-
-- add or revise the audit rubric;
-- inventory one family;
-- prune one skill or one closely related skill family;
-- move one project-specific capability out of global install;
-- add a check that prevents a repeated drift;
-- update maintainer docs after a runtime cleanup.
-
-The review artifact should say:
-
-- what surface was reviewed;
-- what audience it serves;
-- what was cut, moved, or preserved;
-- what recurring cost was reduced, or why a net-new surface earns its cost;
-- what behavior should change;
-- what commands or source inspection verified the change.
-
-Keep the PR body consistent with repo convention: short, motivation-first, and
-without headers or checklists. Put detailed evidence in the audit packet, local
-doc, final report, or review comment that travels with the PR.
-
-Run `.\scripts\doctor.ps1` before committing. Run skill validation for skill
-edits when available. Run `.\scripts\verify-live.ps1 -SkipCodexCommand` when
-live drift matters.
-
-## Review Gate
-
-Green draft PRs are build evidence. They are not readiness.
-
-Before calling a Compass review-program PR ready, inspect the live PR state:
-base branch, head branch, head SHA, check results, review status, and open
-comments. For stacked PRs, verify every base points at the intended previous
-head and name the merge order.
-
-Inspect inline review comments separately from top-level PR comments and review
-bodies. A clean current-head review comment does not prove every inline finding
-has been checked. On GitHub, include the pull review comments endpoint, for
-example `gh api repos/<owner>/<repo>/pulls/<number>/comments --paginate`, or a
-thread-aware equivalent when resolution state matters.
-
-Use `pr-review-loop` for the final review path. Local checks and GitHub checks
-support readiness, but they do not replace current-head review gates. After any
-material push, re-read the head SHA and make sure required reviewers are looking
-at that SHA before marking the PR ready.
-
-If the current session lacks authority to invoke a required reviewer, stop at
-that gate and name it as unsatisfied. Do not self-review, count a local check as
-review, or keep stacking PRs as if review happened. Ask for the authority or an
-explicit approved reviewer route.
-
-## Stop Conditions
-
-Stop and ask for user taste when the decision changes the system's philosophy,
-removes a valued capability, narrows global behavior in a way that may affect
-ordinary work, or chooses between two plausible directions with different
-values.
-
-Do not stop for routine cuts, stale wording, missing links, or obvious audience
-mismatch. Make the narrow PR and preserve evidence.
+- project lore from global context;
+- model routes preserved by habit;
+- soft wording that weakens required behavior;
+- lists that replace judgment without protecting a fragile operation;
+- wrappers, branches, fallbacks, and compatibility paths made obsolete by the
+  accepted design.
+
+Measure maintained surface, concepts, states, dependencies, and sources of truth.
+Raw line count is supporting evidence, not the target.
+
+## Review And Verification
+
+Use a focused PR as the review unit. Record:
+
+- surface and audience;
+- behavior preserved or changed;
+- files moved, merged, added, retired, or mechanized;
+- recurring cost reduced;
+- verification performed;
+- remaining risk or dated assumption.
+
+Run the narrow checks, then the repository doctor and install round trip when the
+changed surface affects portability. Forward-test judgment changes with a fresh
+agent. Inspect current-head checks, reviews, inline threads, and behavior proof
+before calling the PR ready.
+
+A green build is evidence. Readiness still requires the current review contract.
+Public mutation still requires authority.
+
+## Taste Boundary
+
+Bring the user a prepared decision when a change alters Compass philosophy,
+removes a valued capability, materially narrows ordinary behavior, or chooses
+between plausible value systems. Apply routine stale-guidance repair and exact
+mechanical reconciliation without turning every cleanup into a taste question.
diff --git a/workflows/long-running-work.md b/workflows/long-running-work.md
new file mode 100644
index 00000000..12b8f3c5
--- /dev/null
+++ b/workflows/long-running-work.md
@@ -0,0 +1,113 @@
+# Long-Running Work
+
+Use this workflow when an objective must survive compaction, interruption,
+multiple delegated assignments, or a replacement principal context.
+
+The purpose is continuity. Preserve one coherent intention in principal-authored
+control documents, then let temporary contexts and delegates advance it without
+becoming alternate authors of the objective.
+
+## The Principal Authors Control
+
+The user-facing principal, or the user directly, authors and reviews:
+
+- the stable goal;
+- anchor precedence;
+- the current plan;
+- the work catalog and ledger shape;
+- assignment packets;
+- checkpoints;
+- amendments and completion judgment.
+
+Delegates own their assigned artifacts and investigations. They return evidence
+through the named return channel. The principal verifies that evidence and
+updates control state.
+
+A delegate never needs write access to the control documents merely to report
+progress.
+
+## Minimal Control Packet
+
+Use only the documents the objective needs. A substantial multi-context task
+usually has:
+
+```text
+local-docs/control/
+  goal.md
+  catalog.md
+  checkpoint.md
+  assignments/
+    <assignment>.md
+```
+
+Templates for goals, plans, catalogs, assignments, decisions, and checkpoints live
+under [templates/](templates/). Keep stable meaning in `goal.md`, current state
+in `catalog.md`, and the smallest complete resume packet in `checkpoint.md`.
+
+The local JSON orchestration ledger is an optional mechanical index and recovery
+guard. It remains principal-written and points at the Markdown control packet.
+It does not replace the goal or checkpoint.
+
+## Review Before Dispatch
+
+A delegation packet should be reviewable before launch. The principal reviews
+every assignment. Give the user an opportunity to review material goals, plans,
+slice boundaries, and irreversible authority unless the user already granted
+that operating authority or explicitly waived review.
+
+A reviewed assignment names:
+
+- the slice outcome;
+- parent goal and assertion identifiers;
+- authoritative anchors;
+- exact scope and allowed actions;
+- production mutation authority;
+- evidence required;
+- return channel;
+- return conditions.
+
+The assignment carries enough context to act and no narrative history that does
+not change the work.
+
+## Checkpoint Before Context Loss
+
+Write a checkpoint before compaction, restart, or deliberate handoff. Record:
+
+- goal revision and authoritative anchors;
+- current observed state;
+- accepted evidence and its locators;
+- remaining assertions or decisions;
+- active delegates, processes, and worktrees;
+- unresolved risks;
+- the next proof-producing action;
+- the first verification a successor must perform.
+
+The successor reopens anchors in precedence order and checks current observable
+state before trusting the checkpoint.
+
+## Fresh-Context Resume Test
+
+A fresh agent with no conversation history should be able to:
+
+1. identify the authoritative goal;
+2. locate the current repository, worktree, branch, and artifacts;
+3. distinguish accepted evidence from claims;
+4. identify active delegated work and its return channel;
+5. name the remaining gap;
+6. take the next correct action without reconstructing private chat history.
+
+Repair the control packet when this test fails.
+
+## Completion And Archive
+
+Completion reconciles current evidence against the complete goal. A finished
+assignment, command, review, wait, or phase is progress until every required
+assertion is verified.
+
+After completion:
+
+- write a final checkpoint or completion packet;
+- preserve durable evidence in `artifacts/` or the project repository;
+- archive control documents that retain future value;
+- remove stale monitor state and disposable scratch;
+- leave the stable goal and amendments auditable.
diff --git a/workflows/multi-thread-pr-coordination.md b/workflows/multi-thread-pr-coordination.md
index d97aaf12..317b5f23 100644
--- a/workflows/multi-thread-pr-coordination.md
+++ b/workflows/multi-thread-pr-coordination.md
@@ -1,102 +1,93 @@
 # Multi-Thread PR Coordination
 
-Use this workflow when launching multiple Codex threads, worktrees, or agents
-against one repository objective. The goal is parallel discovery without public
-PR sprawl.
-
-This is repo-maintainer guidance. It is not installed into a live Codex home,
-user skill home, or Claude home.
-Use it from this checkout when coordinating local branches, scratch notes, and
-reviewable upstream PRs.
-
-## Coordinator Stance
-
-The coordinator is not a passive tracker. It protects the public review surface
-while workers do the ground work. Local notes can be messy and provisional.
-Public PRs should be focused, verified, and useful to future reviewers.
-
-## Default Shape
-
-- One coordinator thread owns public branch and PR hygiene.
-- Worker threads use their own branches and worktrees outside this checkout.
-- Tracking notes stay local by default, under `.local/` or another ignored
-  private note.
-- Repo-local `.local/` is for ignored notes and scratch evidence, not nested
-  worktrees.
-- Public PRs are only for independently reviewable upstream changes.
-
-## Before Launching Workers
-
-1. Write a short coordinator goal: what success means, what is in scope, and
-   what is out of scope.
-2. Decide where local tracking lives. Prefer `.local/<topic>/` when the notes
-   are not useful upstream. Put worker worktrees outside this checkout.
-3. Set a PR budget, usually no more than three active PRs from the workstream.
-4. Tell workers whether they may open PRs, or whether coordinator approval is
-   required first. Default to coordinator approval when the workstream could
-   produce tracker notes, broad audits, or overlapping fixes.
-5. Tell workers how to report findings:
-   - finding;
-   - files affected;
-   - risk;
-   - verification available;
-   - recommended target branch.
-
-## Worker Rules
-
-Workers should not open a PR for tracker notes, partial findings, broad audits,
-or speculative fixes. They should update local evidence and report back to the
-coordinator.
-
-Workers may open a PR only when all are true:
-
-- the change is focused;
-- the target branch is clear;
-- the diff is not mixed with tracker notes;
-- verification is listed or the verification gap is explicit;
-- the coordinator has approved opening that PR.
-
-## PR Types
-
-Keep each PR in exactly one class:
-
-- behavior fix;
-- guard or check improvement;
-- docs intended for upstream readers;
-- eval or fixture update;
-- preservation branch for a specific known risk.
-
-Do not mix audit tracking, tool code, eval changes, and local evidence in one
-PR. If a finding needs both a fix and documentation, prefer one fix PR and one
-small upstream-doc PR only when the docs are useful to future readers.
-
-## Consolidation Loop
-
-During active parallel work, the coordinator should periodically inspect PRs
-created by the current workstream:
-
-Mutate current-workstream PRs only when the user granted that authority for the
-workstream. Otherwise, report the recommended cleanup and ask before closing,
-rebasing, retargeting, or refreshing.
-
-1. List current-workstream PRs and classify them.
-2. Close duplicate, scratch, or mixed workstream PRs with a short comment.
-3. Rebase or refresh viable workstream PRs on current main.
-4. Keep the PR budget visible to the workers.
-5. Preserve local evidence without pushing it upstream.
-
-Treat unrelated PRs as context only. Do not close, rebase, retarget, or refresh
-an unrelated PR without explicit owner approval.
-
-## When To Keep Tracking Local
-
-Keep tracking local when it contains:
-
-- scratch findings;
-- temporary matrices;
-- local ports, paths, containers, screenshots, or logs;
-- seeded benchmark values used only for setup;
-- notes useful only to the current operator.
-
-Promote tracking upstream only when it becomes durable documentation for future
-contributors.
+Use this workflow when one repository objective benefits from parallel Codex
+contexts, worktrees, or agents while the public review surface remains coherent.
+
+The principal owns the objective, assignments, integration map, and public PR
+authority. Workers own reviewed slices and return artifacts plus evidence.
+
+## Establish The Control Packet
+
+Before dispatch, the principal authors a compact goal and catalog that name:
+
+- the finished state and evidence required;
+- current base branch and authoritative repository state;
+- active worktrees and their exact scope;
+- reviewed worker assignments;
+- dependencies and collision boundaries;
+- the public PR budget;
+- the return channel;
+- public mutation authority.
+
+Keep private operational state under `.local/` or another ignored project
+surface. Keep worker worktrees outside the principal checkout.
+
+## Prepare Reviewed Assignments
+
+Each assignment states:
+
+- one bounded outcome;
+- relevant goal assertion identifiers;
+- authoritative anchors;
+- exact worktree and branch;
+- allowed edits and actions;
+- integration target;
+- checks and evidence required;
+- whether a PR may be opened;
+- return conditions and channel.
+
+The principal reviews the assignment before launch. Give the user an opportunity
+to review material slice boundaries and public authority unless prior authority
+or an explicit waiver covers the dispatch.
+
+Workers report through the assignment return shape. They do not invent separate
+tracking systems or rewrite the principal catalog.
+
+## Preserve Worktree Independence
+
+Use one editing owner per worktree. Start production-bound branches from the
+intended current base, usually `origin/main`, after refreshing refs. Preserve
+unrelated user work and keep experiments outside PR worktrees.
+
+Parallelize slices only when their files, state, and integration order remain
+clear. Keep coupled changes with one owner.
+
+## Keep Public Review Focused
+
+Set a visible PR budget, usually no more than three active PRs for one workstream.
+A worker opens a PR only when the assignment grants that action and the change is:
+
+- independently reviewable;
+- scoped to one purpose;
+- free of private tracking notes;
+- based on the intended branch;
+- accompanied by current verification or an explicit evidence gap.
+
+The principal classifies each public change as a behavior fix, guard, durable
+documentation change, eval or fixture update, or a narrowly justified
+preservation branch. Mixed audit notes and speculative fixes remain local.
+
+## Reconcile Returns
+
+After a worker returns:
+
+1. inspect the artifact and current branch state;
+2. map evidence to the parent goal;
+3. update the principal catalog and checkpoint;
+4. identify integration dependencies and stale assignments;
+5. prepare repair, review, or the next dispatch;
+6. recompute the active PR budget.
+
+A worker completion claim advances the objective only after the principal checks
+the returned evidence.
+
+## Consolidate With Authority
+
+Inspect current-workstream PRs at meaningful decision points. Close duplicates,
+refresh branches, retarget, or rewrite public state only within granted
+authority. Treat unrelated PRs as context and preserve their owner boundaries.
+
+Keep local tracking local when it contains scratch findings, temporary matrices,
+ports, machine paths, logs, screenshots, seeded values, or notes useful only to
+the current operator. Promote material upstream only when it becomes durable
+project guidance or reviewable product work.
diff --git a/workflows/orchestration-ledger.md b/workflows/orchestration-ledger.md
index 6c54b262..0696d799 100644
--- a/workflows/orchestration-ledger.md
+++ b/workflows/orchestration-ledger.md
@@ -1,210 +1,270 @@
 # Orchestration Ledger
 
-Use this workflow when a controller needs durable local control state across
-sessions, workers, checks, or decision points. The ledger records authority, current state, evidence, and recovery gates. It does not execute work or replace
-the worker that owns delivery.
+Use this workflow when a long-running objective needs a compact mechanical index
+across contexts, compactions, delegates, checks, or recovery decisions. The
+principal authors the durable goal, plan, catalog, assignments, and checkpoints
+in Markdown. The JSON ledger points to those control documents and records
+principal-verified evidence, current routing, timestamps, and recovery gates.
 
 This is repo-maintainer state. It is not installed into a Codex home, user skill
 home, or Claude home.
 
+## Purpose
+
+A conversation is not a durable control surface. Contexts end, compactions lose
+detail, and delegation changes the reader. The ledger makes the current control
+state observable without asking every fresh context to reconstruct it from chat.
+
+The ledger stays mechanical. The Markdown control documents carry meaning.
+
+- **Goal document:** stable finished state, evidence standard, constraints, and
+  amendment authority.
+- **Plan and catalog:** approved route, active assignments, artifact locations,
+  dependencies, and current decisions.
+- **Assignment:** reviewed work packet given to a delegate.
+- **Checkpoint:** principal-authored resume point before compaction or handoff.
+- **JSON ledger:** links, phase, state, current owner, verified evidence,
+  timestamps, mutation authority, and recovery circuits.
+
+A delegate returns artifacts and evidence. The principal verifies that return and
+records any resulting control-state change. Delegates do not invent ledger
+formats or mutate the principal's control record.
+
 ## Local Boundary
 
 The supported location is under `.local/`, with
 `.local/orchestration-ledger.json` as the default. The directory is ignored and
-listed as local-only. Do not copy the ledger into commits, prompts, PR bodies,
-MCP responses, or installed guidance.
+listed as local-only. Keep durable project control documents in the project
+location selected by its workspace guidance, usually under `local-docs/`.
 
-The ledger may contain compact goal labels, worker labels, evidence locators,
-and prepared decisions. It must not contain credentials, tokens, cookies,
-private message content, raw logs, or copied source artifacts.
+The ledger may contain compact goal labels, file or URL locators, worker labels,
+evidence summaries, and prepared decisions. Keep credentials, tokens, cookies,
+private message content, raw logs, and copied source artifacts out of it.
 
-## Control Record
+## One Logical Principal
 
-Each goal records:
+Every goal names one `control_writer`. That identity is the logical principal,
+not a permanent process. A fresh context may assume the role only after reading
+and verifying the named anchors and control documents.
 
-- the outcome to pursue;
-- execution owner and worker identity;
-- current state and next action;
-- compact completion evidence;
-- public-mutation authority and the exact named action;
-- one prepared human decision, when needed;
-- one control writer and optimistic revision;
-- exact delegated mutation grants;
-- per-slice recovery circuits.
+Every mutation supplies:
 
-A recovery circuit records whether a successor is unclaimed, claimed, or open,
-plus the latest failure evidence and the evidence that permits another attempt.
-It does not count retries. A failed successor must declare one of two states:
+- the principal identity;
+- the expected control revision;
+- the exact goal being changed.
 
-- new discriminating evidence changed the diagnosis, inputs, or runtime path, so
-  another bounded successor may be claimed;
-- no new discriminating evidence exists, so the circuit opens and another
-  symptom-level successor is refused.
+A non-principal actor or stale revision fails before writing. The tool does not
+support delegated edit grants. This preserves one reviewed interpretation of the
+objective across finite contexts.
 
-Resetting an open circuit is control-writer-only and requires root-cause
-evidence.
+## Goal Record
 
-Schema version 3 replaces the successor failure counter with evidence fields.
-The runtime reads schema versions 1 and 2 and migrates them on the next
-successful write. A version 2 count becomes a compact migration evidence
-locator, while its prior open or closed state is preserved.
+Each goal records:
 
-## Authority
+- the stable goal statement;
+- authoritative anchors;
+- principal-authored control documents;
+- phase: `planning` or `implementation`;
+- execution owner and current worker identity;
+- current state and next judgment point;
+- principal-verified evidence with producer and observation time;
+- public-mutation authority and the exact named action;
+- one prepared human decision, when needed;
+- one principal writer and optimistic revision;
+- per-slice recovery circuits;
+- created, updated, and last-verified timestamps.
 
-Every mutation of an existing goal declares the actor and expected control
-revision. The control writer may perform any mutation. Another actor needs a
-grant naming the exact mutation. A successful mutation increments the revision.
-A stale revision or missing grant fails before any write.
+Changing `phase` to `implementation` records authority that already exists. It
+does not create implementation authority by itself. The approved goal or plan
+remains the source of that authority.
 
-The public-mutation gate records authority that already exists:
+## Initialize A Goal
 
-- `closed`: no public mutation is authorized;
-- `authorized`: the user or repository workflow granted the recorded action;
-- `in_flight`: the authorized public sequence started;
-- `complete`: the authorized sequence finished and was verified.
+Create the Markdown control documents first, then initialize the index:
 
-Changing the field does not grant permission.
+```powershell
+.\scripts\orchestration-ledger.ps1 -Action init `
+  -GoalId release-42 `
+  -Goal "Ship the reviewed release" `
+  -Anchor "product-requirements.md" `
+  -ControlDocument "local-docs/control/goal.md" `
+  -ControlDocument "local-docs/control/catalog.md" `
+  -ExecutionOwner principal `
+  -ControlWriter principal `
+  -Phase planning `
+  -State planned
+```
 
-## Commands
+The goal statement is not mutable through this CLI. Amend the authoritative goal
+document under its declared authority, then create a new goal record or use the
+project's explicit amendment procedure.
 
-Read the ledger:
+## Read And Validate
 
 ```powershell
 .\scripts\compass.ps1 orchestration
 .\scripts\compass.ps1 orchestration -GoalId release-42 -Json
+.\scripts\orchestration-ledger.ps1 -Action validate
 ```
 
-Initialize a goal:
+Before a fresh context continues work, it should be able to answer from the goal,
+control documents, and current ledger:
 
-```powershell
-.\scripts\orchestration-ledger.ps1 init `
-  -GoalId release-42 `
-  -Goal "Ship the reviewed release" `
-  -ExecutionOwner release-worker `
-  -ControlWriter controller `
-  -WorkerId thread-123 `
-  -State active
-```
+- What finished state remains authoritative?
+- Which source documents establish it?
+- What phase is authorized?
+- What evidence is current?
+- What remains unresolved?
+- What action can produce the next useful proof?
+
+That is the fresh-context resume test.
 
-Grant a recovery worker only the mutations it needs:
+## Record Phase And Routing
+
+After an approved transition to implementation:
 
 ```powershell
-.\scripts\orchestration-ledger.ps1 set-grant `
+.\scripts\orchestration-ledger.ps1 -Action set-phase `
   -GoalId release-42 `
-  -Actor controller `
+  -Actor principal `
   -ExpectedRevision 1 `
-  -GrantActor recovery-worker `
-  -Mutation claim-successor `
-  -Mutation record-successor-failure `
-  -Mutation record-successor-success
+  -Phase implementation
 ```
 
-Claim a slice as the atomic prelaunch gate:
+Record a current owner or worker without transferring control authorship:
 
 ```powershell
-.\scripts\orchestration-ledger.ps1 claim-successor `
+.\scripts\orchestration-ledger.ps1 -Action set-owner `
   -GoalId release-42 `
-  -Actor recovery-worker `
+  -Actor principal `
   -ExpectedRevision 2 `
-  -SliceLabel magento-checkout
+  -ExecutionOwner principal `
+  -WorkerId implementation-auth-01
 ```
 
-Record a failed attempt that produced new discriminating evidence:
+Update links when a reviewed control document supersedes an older one:
 
 ```powershell
-.\scripts\orchestration-ledger.ps1 record-successor-failure `
+.\scripts\orchestration-ledger.ps1 -Action set-links `
   -GoalId release-42 `
-  -Actor recovery-worker `
+  -Actor principal `
   -ExpectedRevision 3 `
-  -SliceLabel magento-checkout `
-  -FailureEvidence run:842 `
-  -DiscriminatingEvidence "trace isolates provider startup"
+  -Anchor "product-requirements.md#revision-4" `
+  -ControlDocument "local-docs/control/checkpoint.md"
 ```
 
-The slice closes and may be claimed again because the next attempt has a changed
-basis.
+## Record Verified Evidence
 
-Record a failed attempt that did not improve the diagnosis:
+A delegate may produce the observation. The principal inspects it and records
+what it proves:
 
 ```powershell
-.\scripts\orchestration-ledger.ps1 record-successor-failure `
+.\scripts\orchestration-ledger.ps1 -Action add-evidence `
   -GoalId release-42 `
-  -Actor recovery-worker `
-  -ExpectedRevision 5 `
-  -SliceLabel magento-checkout `
-  -FailureEvidence run:843 `
-  -NoNewEvidence
+  -Actor principal `
+  -ExpectedRevision 4 `
+  -EvidenceKind test `
+  -EvidenceSummary "Portable checks passed on the current head" `
+  -EvidenceLocator "run:835" `
+  -EvidenceProducer "implementation-auth-01" `
+  -EvidenceObservedAt "2026-07-17T09:15:00-06:00"
 ```
 
-The slice opens. `check-recovery` and `claim-successor` then fail for that slice.
+The record distinguishes:
+
+- who produced the evidence;
+- when the state was observed;
+- which principal verified and recorded it.
+
+A worker's confident completion claim is a locator for inspection, not evidence
+by itself.
+
+## Recovery Circuits
 
-Reset after root-cause evidence changes the route:
+A recovery circuit protects one slice from unchanged repeated attempts.
+
+Begin an approved recovery assignment:
 
 ```powershell
-.\scripts\orchestration-ledger.ps1 reset-recovery `
+.\scripts\orchestration-ledger.ps1 -Action begin-recovery `
   -GoalId release-42 `
-  -Actor controller `
-  -ExpectedRevision 6 `
-  -SliceLabel magento-checkout `
-  -RootCauseEvidence review:runtime-child-path
+  -Actor principal `
+  -ExpectedRevision 5 `
+  -SliceLabel checkout `
+  -WorkerId recovery-01
 ```
 
-Record success only from the actor that owns the claim:
+Record a failure that changed the diagnosis or route:
 
 ```powershell
-.\scripts\orchestration-ledger.ps1 record-successor-success `
+.\scripts\orchestration-ledger.ps1 -Action record-recovery-failure `
   -GoalId release-42 `
-  -Actor recovery-worker `
-  -ExpectedRevision 8 `
-  -SliceLabel magento-checkout
+  -Actor principal `
+  -ExpectedRevision 6 `
+  -SliceLabel checkout `
+  -FailureEvidence "run:842" `
+  -DiscriminatingEvidence "trace isolates provider startup"
 ```
 
-Record a next action only when a future wake needs judgment:
+The circuit closes because another bounded attempt has a changed basis.
+
+Record a failure that produced no new discriminating evidence:
 
 ```powershell
-.\scripts\orchestration-ledger.ps1 set-next `
+.\scripts\orchestration-ledger.ps1 -Action record-recovery-failure `
   -GoalId release-42 `
-  -Actor controller `
-  -ExpectedRevision 9 `
-  -NextAction "Inspect hosted checks and current-head review" `
-  -NextCheckAt "2026-07-12T12:00:00Z"
+  -Actor principal `
+  -ExpectedRevision 7 `
+  -SliceLabel checkout `
+  -FailureEvidence "run:843" `
+  -NoNewEvidence
 ```
 
-Append compact evidence:
+The circuit opens. Another attempt requires a changed hypothesis, input, runtime
+path, or root-cause finding:
 
 ```powershell
-.\scripts\orchestration-ledger.ps1 add-evidence `
+.\scripts\orchestration-ledger.ps1 -Action reset-recovery `
   -GoalId release-42 `
-  -Actor controller `
-  -ExpectedRevision 10 `
-  -EvidenceKind test `
-  -EvidenceSummary "Portable checks passed on the current head" `
-  -EvidenceLocator "run:835"
+  -Actor principal `
+  -ExpectedRevision 8 `
+  -SliceLabel checkout `
+  -RootCauseEvidence "review:provider-startup"
 ```
 
-Validate the stored shape:
+`check-recovery` is an observation. It never claims or launches a worker.
 
-```powershell
-.\scripts\orchestration-ledger.ps1 validate
-```
+## Public Mutation Gate
+
+The gate records authority already granted by the user or repository workflow:
+
+- `closed`: no public mutation is authorized;
+- `authorized`: the exact recorded action is authorized;
+- `in_flight`: that authorized sequence started;
+- `complete`: that authorized sequence finished and was verified.
+
+Changing the field does not grant permission.
 
 ## Operating Discipline
 
-- Keep one execution owner per goal.
-- Use the ledger for control state, not narrative history.
-- Put mechanical waits inside one bounded command.
-- Append evidence that can support or falsify completion.
+- Keep one logical principal writer per goal.
+- Let delegates own assigned artifacts and return evidence.
+- Keep objective meaning in reviewed Markdown control documents.
+- Keep the JSON ledger compact and mechanical.
+- Put pure waiting inside one bounded command.
+- Use a monitor agent only when each observation requires limited judgment.
+- Record absolute timestamps with time zones.
 - Open recovery when another unchanged attempt would repeat motion without
   learning.
-- Resume only when a changed hypothesis, input, runtime path, or root-cause
-  finding is named.
-- Mark a goal complete only when evidence matches the outcome or the user
-  explicitly accepts an incomplete endpoint.
+- Complete only when current evidence verifies the authoritative finished state,
+  or the authorized owner amends that state.
 
 ## Verification
 
-`manifests/orchestration-ledger.schema.json` documents the stored shape.
-`scripts/orchestration-ledger.py` validates it without an external schema
-dependency, writes atomically, and restricts paths to `.local/`.
-`scripts/test-orchestration-ledger.py` covers lifecycle, authority, migration,
-and evidence-based recovery behavior.
+- `manifests/orchestration-ledger.schema.json` documents schema version 4.
+- `scripts/orchestration-ledger.py` validates and writes the ledger atomically.
+- The path is restricted to `.local/` and rejects symlink traversal.
+- `scripts/test-orchestration-ledger.py` covers principal authority, optimistic
+  revision, evidence provenance, phase and link updates, recovery, migration,
+  and path boundaries.
+- `scripts/test-orchestration-ledger-lock.py` covers single-writer locking.
diff --git a/workflows/plan-template.md b/workflows/plan-template.md
index d522c7a6..e763f89f 100644
--- a/workflows/plan-template.md
+++ b/workflows/plan-template.md
@@ -1,56 +1,79 @@
-# Plan Template
+# Durable Plan Template
 
-Use this template only when Compass needs a written plan artifact that will be
-reviewed, handed off, or kept with repo-local evidence.
+Use this template when a plan must survive review, compaction, delegation, or a
+fresh principal context. The user-facing principal, or the user directly,
+authors and maintains it.
 
-This is repo-maintainer guidance and is not installed into a live Codex home,
-user skill home, or Claude home.
-Put reusable agent behavior in installed agents or skills instead.
+This is maintainer guidance. It is not installed into runtime homes.
 
-Do not use this for normal in-chat planning. Prefer Plan mode or `update_plan`
-when the work is interactive. Use `using-codex-goals` when the user asks for a
-durable Codex goal. Use this file only when a plan itself is an artifact.
+A plan is the current route, not the stable goal. Link the authoritative goal
+and update the plan when evidence changes. Keep implementation authority
+explicit so planning cannot silently become production mutation.
 
-Keep the plan short enough to guide execution. If a section does not change a
-future decision, cut it.
+```markdown
+# Plan: <name>
 
-## Goal
+Created at: <ISO 8601 timestamp with timezone>
+Last verified at: <ISO 8601 timestamp with timezone>
+Principal: <logical principal identity>
+Status: draft | reviewed | approved | superseded | complete
+Implementation authority: withheld | granted
+Authority source: <user statement, issue, workflow, or none>
 
-State the end state in one or two paragraphs. Include what must be true for the
-work to count as done.
+## Goal Anchor
 
-## Scope
+- Goal document:
+- Goal revision:
+- Other authoritative sources, in precedence order:
 
-- In scope:
-- Out of scope:
-- Repos or paths:
-- Existing branches or PRs:
+## Desired Result
 
-## Context To Gather
+State what this route is intended to produce. Keep completion meaning in the
+goal document rather than rewriting it here.
 
-- Files, docs, issues, logs, or commands that must be inspected first:
-- External docs or APIs that may need verification:
-- Assumptions to challenge or verify:
+## Observed State
 
-## Execution Steps
+Record current facts with evidence locators. Separate direct observation from
+inference.
 
-Use numbered steps only when order matters. Each step should name an action and
-the evidence it should produce.
+## Decisions
+
+Record decisions already made, why they matter, and who had authority.
+
+## Route
+
+Describe the smallest coherent route from observed state to the goal. Use
+numbered steps only when order is real. For each material step, name the evidence
+it should produce.
+
+## Assignments
+
+List reviewed delegate packets by locator. The principal owns this index;
+delegates return artifacts and evidence.
 
 ## Verification
 
-- Required commands:
-- Runtime or browser checks:
-- GitHub checks or review path (CI, requested reviewers, `@codex review`):
-- Artifacts to inspect:
-- Evidence that proves completion:
+- Required checks:
+- Runtime or browser evidence:
+- Independent review:
+- Evidence that closes each goal assertion:
+
+## Risks And Recovery
+
+Name credible failure modes, preservation boundaries, and the smallest
+reversible recovery action.
+
+## Open Decisions
 
-## Rollback
+List only choices that materially change outcome, scope, interface, authority,
+or risk. Include options and a recommendation.
 
-- Files or config that would need to be reverted:
-- Data, containers, branches, or services that need cleanup:
+## Next Principal Action
 
-## Open Questions
+Name the next judgment-bearing action. Put pure waiting in a bounded command or
+monitor.
+```
 
-List only questions that block useful progress. Make reasonable assumptions for
-everything else and state them before editing.
+Before implementation begins, verify that the plan is reviewed, the goal is
+anchored, the mutation boundary is explicit, and a fresh context can understand
+the route without the conversation that produced it.
diff --git a/workflows/portable-config.md b/workflows/portable-config.md
index 874a6f4e..dbe08ddc 100644
--- a/workflows/portable-config.md
+++ b/workflows/portable-config.md
@@ -1,185 +1,101 @@
-# Portable Codex Config Workflow
+# Portable Config Workflow
 
-Use this workflow when changing Codex setup that should survive a new machine,
-fresh profile, or copied repo checkout.
+Use this workflow to diff, install, snapshot, verify, or update the reviewed
+Compass allowlist.
 
-This is repo-maintainer guidance. It is not installed into a live Codex home,
-user skill home, or Claude home.
-Installed agentic guidance source lives under `codex/AGENTS.md`,
-`codex/agents/`, and `codex/skills/`. Claude guidance derives from those
-sources at install time.
+This is maintainer guidance. It is not installed into a Codex home, user-skill
+home, or Claude home.
 
-These scripts use `-CodexHome` for Codex-home files, otherwise
-`$env:CODEX_HOME`, otherwise the default `%USERPROFILE%\.codex` home. They use
-`-AgentsHome` for user skills, otherwise `$HOME\.agents`. They use `-ClaudeHome`
-for Claude-home files, otherwise `$HOME\.claude`.
+## Reviewed Sources
 
-For the Claude Code mirror of this flow, see [claude-config.md](claude-config.md).
-The same `install.ps1`, `verify-live.ps1`, `diff-live.ps1`, and `update-live.ps1`
-scripts install the `claude/` surface into `$HOME/.claude` alongside the Codex
-surface.
-Claude skills listed in `[claude].derived_skills` are generated from the
-reviewed `codex/skills/<name>` source during install instead of being duplicated
-under `claude/skills/`.
+- Codex global guidance: `codex/AGENTS.md`
+- Claude global guidance: `claude/CLAUDE.md`
+- Shared agents and skills: `codex/agents/` and `codex/skills/`
+- Direct Claude agents: `claude/agents/`
+- Codex hooks, keybindings, and config fragment: `codex/`
+- Install and retirement boundaries: `manifests/portable-files.toml`
+- Ownership and provenance: `manifests/skill-sources.json`
 
-## Change flow
+Claude global guidance is separately authored. Runtime-neutral skills and most
+agents derive from Codex source during installation.
 
-1. Edit files in this repo first.
-2. Run `.\scripts\doctor.ps1`.
-3. Run `.\scripts\verify-live.ps1 -SkipCodexCommand` when you need a quick
-   drift report.
-4. Run `.\scripts\diff-live.ps1` when you need a full diff against live files.
-5. Review the diff and the planned reviewed-config key changes.
-6. Run `.\scripts\install.ps1 -Apply` only after the plan is accepted.
+## Preview First
 
-## Latest-to-live flow
+```powershell
+.\scripts\diff-live.ps1
+.\scripts\install.ps1
+.\scripts\snapshot.ps1
+```
+
+Without `-Apply`, install and snapshot report exact planned changes. Inspect the
+copy, retirement, and reviewed-config overlay plan before mutation.
+
+## Validate
+
+```powershell
+.\scripts\doctor.ps1
+.\scripts\verify-live.ps1 -SkipCodexCommand
+```
+
+Use `-RequireInSync` when drift should fail the command. Doctor validates source
+boundaries, manifests, skills, agents, policies, hooks, Claude derivation, and
+required files.
+
+## Apply
+
+```powershell
+.\scripts\install.ps1 -Apply
+```
 
-Use `.\scripts\update-live.ps1` when the live Codex home, user skill home, and
-Claude home should track the latest reviewed portable setup from `origin/main`.
+The installer:
 
-The script refuses dirty checkouts, fetches the remote branch, fast-forwards the
-local branch only when Git can do so without a merge, refuses to overwrite
-ignored files during branch updates, runs `doctor.ps1`, runs `install.ps1 -Apply`,
-and finishes with
-`verify-live.ps1 -SkipCodexCommand -RequireInSync`.
+- copies reviewed Codex and Claude global files;
+- installs Compass-owned user skills;
+- derives selected Claude skills and agents;
+- copies direct Claude agents;
+- backs up and removes explicitly retired Compass-owned paths;
+- overlays every reviewed Codex config key;
+- preserves generated and machine-local live config keys.
 
-For unattended use, schedule this exact command from a trusted local checkout:
+## Update
 
 ```powershell
-powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\update-live.ps1
+.\scripts\update-live.ps1
+.\scripts\update-live.ps1 -Ref <tag-or-commit>
 ```
 
-If the script stops on local changes or a non-fast-forward branch, inspect the
-checkout manually. Do not make automation resolve those cases.
-
-## Snapshot flow
-
-1. Run `.\scripts\snapshot.ps1` to see the allowlist.
-2. Run `.\scripts\snapshot.ps1 -Apply` to copy live allowlisted files into this
-   repo.
-3. Review the git diff before committing.
-
-## Config handling
-
-Treat `codex/config.review.toml` as the authoritative contract for the settings
-it contains. Normal install and update flows structurally overlay every reviewed
-scalar key into the live `config.toml`; they do not replace the live file.
-Review mode lists the exact managed key paths that would change. Apply mode backs
-up an existing live file before a changed overlay, writes atomically, and skips
-both backup and rewrite when the reviewed keys already match.
-
-Keys absent from the reviewed fragment are not managed and remain in the live
-file. This includes `service_tier`, generated marketplace state, MCP wiring,
-runtime paths, project trust entries, app-local settings, migration markers, and
-plugin state. Verification compares every reviewed key and ignores unrelated
-live keys.
-
-The current reviewed fragment intentionally reflects a trusted-machine default
-for this user's local work, including `danger-full-access`. Treat that as a
-personal default, not as a claim that every task should run fully trusted.
-Lower-trust work should still use bounded flows such as
-`workflows/read-only-research.md`, read-only helper agents, or narrower runtime
-flags.
-
-Keep the reviewed fragment internally consistent. If it stays on the older
-`sandbox_mode` path, do not mix in the newer `default_permissions` and
-`[permissions]` profile system without a deliberate migration.
-
-Keep portable intent separate from app-shaped local state. Session-wide writing,
-Git, and review preferences belong in `codex/AGENTS.md`. Desktop-only UI state,
-undocumented helper fields, and one-machine app toggles do not belong in the
-reviewed config fragment.
-
-## Durable Guidance Edits
-
-When the change affects future installed behavior across sessions or machines:
-
-1. Read the current portable files first.
-2. Draft the exact patch set before editing unless direct edits were explicitly
-   requested.
-3. Prefer default locations and copy-based sync over symlink or installer
-   indirection.
-4. Run `.\scripts\doctor.ps1` after the draft becomes a real change.
-
-Do not copy these live `config.toml` sections into the portable file without
-review:
-
-- generated marketplace timestamps and local cache paths;
-- app runtime and MCP binary paths;
-- MCP server transport wiring, URLs, OAuth callback overrides, and token or
-  header config;
-- desktop UI state, app-only helper text blocks, and undocumented app-local
-  toggles;
-- `AGENTS.override.md` behavior or local `rules/` approvals that were accepted
-  interactively on one machine;
-- project trust entries for one machine;
-- plugin cache paths;
-- migration prompts and generated state;
-- auth, browser, or connector state.
-
-Do not treat live `automations/` state as the portable form of a reusable
-workflow. If an automation pattern should survive across machines, capture it
-as a skill, workflow doc, or reviewed config change instead.
-
-For restart-only local recovery of unfinished sessions, use
-`workflows/codex-restart-recovery.md` and
-`scripts/codex-restart-recovery.ps1`. The scheduled task remains machine-local,
-while the reviewable recovery logic lives in this repo.
-
-## Skill Discovery Targets
-
-Current Codex docs describe repo skills under `.agents/skills` while walking
-from the current working directory up to the repo root, user skills under
-`$HOME/.agents/skills`, admin skills under `/etc/codex/skills`, and plugins as
-the distribution unit for reusable skills outside one repo. See
-https://developers.openai.com/codex/skills.
-
-Compass keeps `codex/skills/` as the reviewed repo source tree, but installs
-those user skills into `$HOME/.agents/skills`. That is the direction of the
-current Codex skill model. Target projects should use their own
-`.agents/skills` folders for project-specific skills.
-
-The old `$CODEX_HOME/skills` copies of Compass-owned skills are retired install
-artifacts. Explicitly retired user skills in `$HOME/.agents/skills` are too.
-`install.ps1 -Apply` backs them up and removes them after installing the
-reviewed copies into `$HOME/.agents/skills`.
-
-Before changing `scripts/common.ps1`, `manifests/portable-files.toml`, or these
-skill install paths again:
-
-1. Run current Codex in the target environment and confirm which skill roots
-   appear in the active instruction list.
-2. Check `$CODEX_HOME/skills` for stale owned copies that would create duplicate
-   active skills.
-3. Update README, manifest comments, and this workflow in the same PR as any
-   install map change.
-
-## New machines
-
-1. Install Codex normally.
-2. Clone this repo.
-3. Run `.\scripts\doctor.ps1`.
-4. Run `.\scripts\install.ps1` and inspect the planned copies and reviewed key
-   changes.
-5. Run `.\scripts\install.ps1 -Apply`.
-6. Run `.\scripts\verify-live.ps1 -SkipCodexCommand -RequireInSync` to confirm
-   every reviewed key was overlaid while machine-local config remained present.
-
-## Related Workflows
-
-- [addition-intake.md](addition-intake.md): promoting new portable artifacts and
-  checking related stale guidance.
-- [compass-review-program.md](compass-review-program.md): auditing installed
-  skills, agents, hooks, and maintainer guidance for audience fit, pruning,
-  rerouting, and global-install eligibility.
-- [codex-restart-recovery.md](codex-restart-recovery.md): installing a
-  restart-only local recovery task for unfinished Codex sessions.
-- [which-llm-plugin.md](which-llm-plugin.md): installing and refreshing the
-  separately owned `which-llm` plugin without tracking generated cache state.
-- [plan-template.md](plan-template.md): durable written plan artifacts.
-- [multi-thread-pr-coordination.md](multi-thread-pr-coordination.md): keeping
-  parallel audit threads out of public PR sprawl.
-- [read-only-research.md](read-only-research.md): mapping code paths before
-  edits.
-- [agent-failures.md](agent-failures.md): converting repeated failures into
-  durable improvements.
+Branch refs remain fast-forward only. Tags and commit SHAs resolve to an exact
+detached commit before installation.
+
+## Snapshot
+
+```powershell
+.\scripts\snapshot.ps1 -Apply
+```
+
+Snapshot only the current allowlist. Runtime-generated state, secrets, sessions,
+caches, local overrides, and plugin caches remain local.
+
+## Path Resolution
+
+Scripts use:
+
+- `-CodexHome`, then `$env:CODEX_HOME`, then `%USERPROFILE%\.codex`;
+- `-AgentsHome`, then `$HOME\.agents`;
+- `-ClaudeHome`, then `$HOME\.claude`.
+
+## Ownership Changes
+
+A rename, move, or retirement updates in one reviewed change:
+
+- source path;
+- install manifest;
+- skill-source catalog;
+- derivation transform;
+- retired live paths;
+- policy contracts and required-file checks;
+- install round-trip tests;
+- nearby documentation and MCP catalog expectations.
+
+Use [addition-intake.md](addition-intake.md) before promoting a new durable
+surface and [claude-config.md](claude-config.md) for Claude-specific routing.
diff --git a/workflows/read-only-research.md b/workflows/read-only-research.md
index b5caa253..c98ecf78 100644
--- a/workflows/read-only-research.md
+++ b/workflows/read-only-research.md
@@ -1,50 +1,49 @@
 # Read-Only Research Workflow
 
-Use this workflow when the next best step is understanding rather than editing:
-large repo orientation, unclear bug ownership, unfamiliar runtime paths, branch
-reviews, API discovery, or workflow tracing.
+Use this workflow when the next useful product is understanding: repository
+orientation, unclear bug ownership, unfamiliar runtime paths, branch review, API
+discovery, or execution-flow tracing.
 
-This is repo-maintainer guidance. It is not installed into a live Codex home,
-user skill home, or Claude home.
-Use installed agents or skills when the behavior should travel with future
-agent sessions.
+The principal prepares one bounded research question. A fresh explorer returns a
+compact evidence packet that strengthens the principal's plan without importing
+the whole research transcript.
 
-## When To Use
+## Assignment Shape
 
-- The task crosses several modules or repos.
-- The likely fix is unclear.
-- A live behavior needs to be tied back to source.
-- The parent context is already noisy and needs a compact evidence packet.
-- A second perspective would reduce risk before implementation.
+Name:
 
-## How To Run
+- the question that must be answered;
+- authoritative repositories, branches, and documents;
+- allowed read-only tools;
+- material unknowns that would change the route;
+- evidence and citation expectations;
+- the return channel;
+- the stopping condition.
 
-Ask Codex to use the `repo-explorer` agent, or ask directly for read-only
-research:
+For Codex, `repo-explorer` is the default role. Claude uses its configured
+GLM-5.2 delegation route with the same read-only assignment boundary.
 
-```text
-Spawn repo-explorer to map the affected code path. It should not edit files.
-Return files inspected, confirmed execution path, risks, and recommended next
-step.
-```
+## Research Stance
 
-## Research Rules
+Map the smallest complete path that lets the principal act without guessing.
+Use targeted search, bounded reads, and compact command output. Trace actual
+entry points to behavior. Separate direct observation from inference.
 
-- Read first, edit later.
-- Prefer `rg`, targeted file reads, and small command outputs.
-- Cite exact files and symbols.
-- Separate facts from inferences.
-- Do not start services unless the user asked for runtime validation.
-- Do not mutate git state.
+Keep git, files, dependencies, services, and external state unchanged. Runtime
+validation belongs in a separately authorized assignment.
 
-## Output Shape
+## Return Packet
 
-- Question answered:
-- Evidence:
-- Execution path:
-- Risks:
-- Unknowns:
-- Recommended next step:
+```text
+Question answered:
+Authoritative state inspected:
+Confirmed execution path:
+Evidence and locators:
+Material unknowns:
+Risks:
+Recommended next proof-producing action:
+```
 
-The parent agent should use the report to plan or implement, not paste the whole
-research transcript into future context.
+The principal verifies the returned locators, updates its own plan or control
+documents, and dispatches implementation only after the applicable planning
+authority is open.
diff --git a/workflows/templates/assignment.md b/workflows/templates/assignment.md
new file mode 100644
index 00000000..0ec9e336
--- /dev/null
+++ b/workflows/templates/assignment.md
@@ -0,0 +1,54 @@
+# Assignment: <name>
+
+Assignment ID: <stable-id>
+Prepared by: <principal>
+Prepared at: <ISO-8601 timestamp with timezone>
+Review state: draft | approved | user-waived
+Parent goal: <goal-id>
+Parent assertions advanced: <ids>
+Return channel: <thread, agent handle, or named location>
+
+## Slice Outcome
+
+<One observable postcondition for this assignment.>
+
+## Integration Target
+
+<How the returned artifact or evidence advances the parent goal.>
+
+## Authoritative Anchors
+
+Read in this order:
+
+1. <anchor>
+2. <anchor>
+
+## Scope And Authority
+
+- Owned artifact or investigation: <boundary>
+- Allowed edits or actions: <exact grant>
+- Production mutation authority: yes | no | exact paths
+- Public mutation authority: none | exact action
+- State to preserve: <unrelated work, services, branches, or data>
+
+## Evidence Required
+
+- <command, artifact, review, observation, or result>
+
+## Return Conditions
+
+Return once when the slice outcome is verified or one exact missing decision,
+authority boundary, external event, or exhausted recovery path prevents further
+safe useful work.
+
+## Return Record
+
+- Result: completed | needs decision | waiting external | failed
+- Slice outcome claimed:
+- Artifact or files changed:
+- Checks and observations:
+- Evidence mapped to parent assertions:
+- Remaining slice gap:
+- Recovery attempted:
+- Exact next action and owner:
+- Residual concerns, separate from completion:
diff --git a/workflows/templates/catalog.md b/workflows/templates/catalog.md
new file mode 100644
index 00000000..1fef6350
--- /dev/null
+++ b/workflows/templates/catalog.md
@@ -0,0 +1,29 @@
+# Work Catalog
+
+Goal: <goal-id> revision <n>
+Control author: <principal>
+Updated at: <ISO-8601 timestamp with timezone>
+Last verified at: <ISO-8601 timestamp with timezone>
+Applies to commit or runtime identity: <locator>
+
+## Current State
+
+<Compact description of what exists now.>
+
+## Remaining Gap
+
+- <assertion or decision still unresolved>
+
+## Active Work
+
+| ID | Role | Assignment | Worker or process | Worktree or artifact root | State | Return channel | Last evidence |
+| --- | --- | --- | --- | --- | --- | --- | --- |
+| <id> | <role> | <path> | <identity> | <locator> | <state> | <locator> | <evidence> |
+
+## Current Decisions
+
+- <decision, owner, and consequence of delay, or none>
+
+## Next Proof
+
+<Smallest action that can reduce the remaining gap.>
diff --git a/workflows/templates/checkpoint.md b/workflows/templates/checkpoint.md
new file mode 100644
index 00000000..14b461ef
--- /dev/null
+++ b/workflows/templates/checkpoint.md
@@ -0,0 +1,44 @@
+# Checkpoint
+
+Goal: <goal-id> revision <n>
+Principal role: <identity>
+Written at: <ISO-8601 timestamp with timezone>
+Last verified at: <ISO-8601 timestamp with timezone>
+Reason: compaction | restart | handoff | pause | milestone
+
+## Reopen First
+
+1. <goal path>
+2. <authoritative anchor>
+3. <catalog path>
+4. <current repository or runtime locator>
+
+## Observed State
+
+<What current evidence says exists now.>
+
+## Accepted Evidence
+
+- <assertion>: <locator and observation>
+
+## Remaining Gap
+
+- <unmet assertion, decision, or proof>
+
+## Active Work
+
+- <worker, process, worktree, assignment, state, and return channel>
+
+## Risks And Decisions
+
+- <material item or none>
+
+## Next Proof-Producing Action
+
+<One concrete next action.>
+
+## Successor Verification
+
+Before continuing, verify:
+
+- <branch, process, artifact, check, or other state that may have changed>
diff --git a/workflows/templates/decision.md b/workflows/templates/decision.md
new file mode 100644
index 00000000..53d82bb7
--- /dev/null
+++ b/workflows/templates/decision.md
@@ -0,0 +1,34 @@
+# Decision: <name>
+
+Decision ID: <stable-id>
+Goal: <goal-id> revision <n>
+Prepared by: <principal>
+Prepared at: <ISO 8601 timestamp with timezone>
+Decision owner: <identity>
+State: proposed | decided | superseded
+
+## Question
+
+<One exact choice that materially changes outcome, scope, interface, authority,
+or risk.>
+
+## Why It Matters
+
+<Assertion, constraint, dependency, or irreversible consequence affected.>
+
+## Evidence
+
+- <current fact or locator>
+
+## Options
+
+1. <option and consequence>
+2. <option and consequence>
+
+## Recommendation
+
+<Recommended option and reason.>
+
+## Decision
+
+<Chosen option, authority, timestamp, and any superseded decision locator.>
diff --git a/workflows/templates/goal.md b/workflows/templates/goal.md
new file mode 100644
index 00000000..30e6eac8
--- /dev/null
+++ b/workflows/templates/goal.md
@@ -0,0 +1,44 @@
+# Goal: <name>
+
+Goal ID: <stable-id>
+Revision: 1
+Created at: <ISO-8601 timestamp with timezone>
+Principal: <logical principal identity>
+Amendment authority: <user or named authority>
+
+## Finished State
+
+<Describe the state that exists when the objective is complete.>
+
+## Required Assertions
+
+- A1: <observable assertion>
+  - Pass evidence: <exact evidence surface>
+- A2: <observable assertion>
+  - Pass evidence: <exact evidence surface>
+
+## Constraints
+
+- <scope, safety, compatibility, budget, and authority limits>
+
+## Exclusions
+
+- <work deliberately outside this goal>
+
+## Authoritative Anchors
+
+Read in this order:
+
+1. <user-approved brief, PRD, issue, or contract>
+2. <repository or runtime source of truth>
+3. <other authoritative source>
+
+## Implementation Authority
+
+Phase: planning | implementation
+Production edits authorized by: <identity or none>
+Public mutations authorized: <exact actions or none>
+
+## Live State
+
+See `catalog.md` and `checkpoint.md`.
diff --git a/workflows/templates/plan.md b/workflows/templates/plan.md
new file mode 100644
index 00000000..6e9e4fd5
--- /dev/null
+++ b/workflows/templates/plan.md
@@ -0,0 +1,35 @@
+# Plan: <name>
+
+Plan ID: <stable-id>
+Goal: <goal-id> revision <n>
+Authored by: <principal>
+Created at: <ISO 8601 timestamp with timezone>
+Updated at: <ISO 8601 timestamp with timezone>
+Review state: draft | approved | user-waived
+Implementation authority: withheld | granted by <identity>
+
+## Current Understanding
+
+<Confirmed facts, evidence-backed inferences, and material assumptions.>
+
+## Intended Route
+
+1. <proof-producing phase or workstream>
+2. <proof-producing phase or workstream>
+
+## Assignment Boundaries
+
+- <bounded slice, integration target, and dependency>
+
+## Verification
+
+- <evidence that proves each phase or slice advanced the goal>
+
+## Risks And Decisions
+
+- <material risk, mitigation, owner, or decision locator>
+
+## Change Rule
+
+Update this route when current evidence changes the gap. Amend the goal only
+through its named authority.