claude-dev-env 7.7.1 → 8.0.0

package/.agents/agents/clean-coder.md

@@ -22,7 +22,7 @@ Before writing a single line — **task-local discovery only** (no project-wide
 1. **Load scoped repository instructions first.** Starting at the repository root, read every applicable `AGENTS.md` on the path to the task file. Then read the applicable `CLAUDE.md` files. Apply nearer instructions after broader ones; the closest file wins.
 2. **Read the file you are about to edit** (when editing existing code). Note every existing comment so you can leave each one untouched on lines that remain otherwise unchanged.
 3. **Discover config only next to the task files.** From each file you will write or edit, walk up to the nearest package or repo root and inspect the target package's existing constants layout — such as `config/` or a sibling `*_constants` package. Keep this task-local constants search. Do **not** force a generic `config/` layout. Do **not** glob the whole tree for every config file. Do **not** glob or open `.env`, `.env.*`, or other secret files.
-4. **Reuse constants from that local table.** Reuse first: exact value match → import the existing name. Semantic match → reuse it. Add a shared constant only when the value is shared policy or has multiple consumers. When no match exists, use the target package's existing constants layout; a one-use value follows `file-global-constants` rather than becoming a new shared constant.
+4. **Reuse constants from that local table.** Reuse first: exact value match → import the existing name. Semantic match → reuse it. Add a shared constant only when the value is shared policy or has multiple consumers. When no match exists, use the target package's existing constants layout, and keep a one-use value in the scope that reads it rather than making it a new shared constant.
 5. **Search callers.** When a symbol, name, or signature changes, search its full caller boundary and update every consumer. This search may be wider than the constants search.
 
 ## Generation mindset (9 laws)
@@ -50,17 +50,16 @@ Installed paths use the active managed root and agents home resolved above; sour
 | Write-time gates | `<managed-root>/hooks/blocking/code_rules_enforcer.py` (source fallback: `packages/claude-dev-env/hooks/blocking/code_rules_enforcer.py`) |
 | Naming and abbreviations | `<managed-root>/docs/CODE_RULES.md#5-no-abbreviations` (source fallback: `packages/claude-dev-env/docs/CODE_RULES.md#5-no-abbreviations`) |
 | Policy surface map | `<managed-root>/rules/code-standards.md` (source fallback: `packages/claude-dev-env/rules/code-standards.md`) |
-| File-global constants | `<managed-root>/rules/file-global-constants.md` (source fallback: `packages/claude-dev-env/rules/file-global-constants.md`) |
 | Windows rmtree / mkdir | `<managed-root>/rules/windows-filesystem-safe.md` (source fallback: `packages/claude-dev-env/rules/windows-filesystem-safe.md`) |
 | `gh` body files | `<managed-root>/rules/gh-cli-conventions.md` (source fallback: `packages/claude-dev-env/rules/gh-cli-conventions.md`) |
 | Plain illustrative docstrings | `<managed-root>/rules/plain-illustrative-docstrings.md` (source fallback: `packages/claude-dev-env/rules/plain-illustrative-docstrings.md`) |
 | Tests / TDD | `<managed-root>/rules/testing.md` (source fallback: `packages/claude-dev-env/rules/testing.md`), `<managed-root>/rules/paired-test-coverage.md` (source fallback: `packages/claude-dev-env/rules/paired-test-coverage.md`), `<managed-root>/rules/bdd.md` (source fallback: `packages/claude-dev-env/rules/bdd.md`) |
-| Questions / task tracking | `<managed-root>/rules/ask-user-question-required.md` (source fallback: `packages/claude-dev-env/rules/ask-user-question-required.md`), `<managed-root>/rules/verify-before-asking.md` (source fallback: `packages/claude-dev-env/rules/verify-before-asking.md`) |
+| Questions / task tracking | `<managed-root>/rules/verify-before-asking.md` (source fallback: `packages/claude-dev-env/rules/verify-before-asking.md`) |
 | Runtime evidence | `<managed-root>/rules/verify-runtime-state.md` (source fallback: `packages/claude-dev-env/rules/verify-runtime-state.md`) |
 | Documentation / durable artifacts | `<managed-root>/rules/doc-inventory-integrity.md` (source fallback: `packages/claude-dev-env/rules/doc-inventory-integrity.md`), `<managed-root>/rules/durable-post-artifacts.md` (source fallback: `packages/claude-dev-env/rules/durable-post-artifacts.md`) |
 | Batch / failure blast radius | `<managed-root>/rules/failure-blast-radius.md` (source fallback: `packages/claude-dev-env/rules/failure-blast-radius.md`) |
 | Git / GitHub | `<managed-root>/rules/git-workflow.md` (source fallback: `packages/claude-dev-env/rules/git-workflow.md`), `<managed-root>/rules/gh-cli-conventions.md` (source fallback: `packages/claude-dev-env/rules/gh-cli-conventions.md`), `<managed-root>/rules/re-stage-before-commit.md` (source fallback: `packages/claude-dev-env/rules/re-stage-before-commit.md`) |
-| Workers / completion | `<managed-root>/rules/agent-spawn-protocol.md` (source fallback: `packages/claude-dev-env/rules/agent-spawn-protocol.md`), `<managed-root>/rules/workers-done-before-complete.md` (source fallback: `packages/claude-dev-env/rules/workers-done-before-complete.md`) |
+| Workers / completion | `<managed-root>/rules/workers-done-before-complete.md` (source fallback: `packages/claude-dev-env/rules/workers-done-before-complete.md`) |
 | TDD / right-size | Review contract Tests + Design; `CODE_RULES.md` §7–§8 |
 
 ## Session policy map (canonical links)
@@ -70,13 +69,13 @@ Load only the group that matches the task. Keep session policy details in these
 | Group | Canonical refs |
 |---|---|
 | Tests | `<managed-root>/rules/testing.md` (source fallback: `packages/claude-dev-env/rules/testing.md`); `<managed-root>/rules/anti-corollary-tests.md` (source fallback: `packages/claude-dev-env/rules/anti-corollary-tests.md`) |
-| Questions | `<managed-root>/rules/ask-user-question-required.md` (source fallback: `packages/claude-dev-env/rules/ask-user-question-required.md`); `<managed-root>/rules/verify-before-asking.md` (source fallback: `packages/claude-dev-env/rules/verify-before-asking.md`) |
+| Questions | `<managed-root>/rules/verify-before-asking.md` (source fallback: `packages/claude-dev-env/rules/verify-before-asking.md`) |
 | Search and shell | `<managed-root>/rules/filesystem-search.md` (source fallback: `packages/claude-dev-env/rules/filesystem-search.md`); `<managed-root>/rules/shell-invocation.md` (source fallback: `packages/claude-dev-env/rules/shell-invocation.md`) |
 | Runtime checks | `<managed-root>/rules/verify-runtime-state.md` (source fallback: `packages/claude-dev-env/rules/verify-runtime-state.md`) |
 | Documentation | `<managed-root>/rules/doc-inventory-integrity.md` (source fallback: `packages/claude-dev-env/rules/doc-inventory-integrity.md`); `<managed-root>/rules/docstring-prose-matches-implementation.md` (source fallback: `packages/claude-dev-env/rules/docstring-prose-matches-implementation.md`) |
 | Batch failures | `<managed-root>/rules/failure-blast-radius.md` (source fallback: `packages/claude-dev-env/rules/failure-blast-radius.md`) |
 | Git | `<managed-root>/rules/git-workflow.md` (source fallback: `packages/claude-dev-env/rules/git-workflow.md`); `<managed-root>/rules/re-stage-before-commit.md` (source fallback: `packages/claude-dev-env/rules/re-stage-before-commit.md`) |
-| Worker coordination | `<managed-root>/rules/agent-spawn-protocol.md` (source fallback: `packages/claude-dev-env/rules/agent-spawn-protocol.md`); `<managed-root>/rules/workers-done-before-complete.md` (source fallback: `packages/claude-dev-env/rules/workers-done-before-complete.md`) |
+| Worker coordination | `<managed-root>/rules/workers-done-before-complete.md` (source fallback: `packages/claude-dev-env/rules/workers-done-before-complete.md`) |
 
 Material implementation questions must return to the caller for `AskUserQuestion` handling; do not ask in plain text or guess.
 

package/.agents/agents/issue-tracker.md

@@ -19,7 +19,7 @@ Keep the same warm `issue-tracker` agent for follow-up actions on the **same iss
 
 ## Voice
 
-Use the `plain-brief` output style (`output-styles/plain-brief.md`). Final message is issue number(s) and URL(s) only.
+Keep the final message to the issue number(s) and URL(s) only.
 
 ## On each turn
 

package/.agents/agents/pr-description-writer.md

@@ -1,6 +1,6 @@
 ---
 name: pr-description-writer
-description: "Writes factual pull request titles, descriptions, and comments in plain illustrative language from the current diff. The `pr_description_writer_gate` PreToolUse hook requires a spawn of this agent before `gh pr create`."
+description: "Writes factual pull request titles, descriptions, and comments in plain illustrative language from the current diff. Spawn it when a pull request needs a body written from the diff or rewritten in full."
 tools: Read,Grep,Glob,Bash
 ---
 

package/.agents/agents/skill-writer-agent.md

@@ -30,18 +30,7 @@ A caller may bundle three of these fields — `Composition plan`, `Description`,
 
 A refine packet instead carries: the current SKILL.md, what was observed, what to change, new gotchas to add, what to preserve, a description rewrite, a composition change, and a deterministic fix.
 
-**Direct request.** A looser prompt names the skill to build or the file to edit. Fill the packet yourself from the references below, and ask the caller for any field only they hold, such as domain context or constraints.
-
-## Read first
-
-At the start of every job, read the live references at `~/.claude/skills/skill-builder/references/` so you author to current conventions:
-
-- `delegation-map.md` — the handoff packet and the Produce contract.
-- `deterministic-elements.md` — the rule that deterministic work ships as code, artifacts, or session tasks.
-- `description-field.md` — the trigger-catalog description shape.
-- `skill-modularity.md` — hub layout and compose-by-name.
-
-Read them fresh each run; they carry the rules you author to.
+**Direct request.** A looser prompt names the skill to build or the file to edit. Fill the packet yourself from the standards below, and ask the caller for any field only they hold, such as domain context or constraints.
 
 ## Standards every file meets
 

package/.agents/agents/test_agent_frontmatter.py

@@ -13,14 +13,14 @@ model on every spawn, so no agent definition names one, concrete or
 `inherit`::
 
     ok:   <no model key at all>
-    flag: model: inherit    <- caller can no longer choose the model
+    flag: model: inherit    <- caller cannot choose the model
     flag: model: opus       <- pinned concrete model, caller can't override
 
 Every block must also load through `yaml.safe_load`. An unquoted colon inside
 a plain scalar reads as a mapping key and makes the whole block unloadable::
 
     ok:   description: ... constraints. Examples are below.
-    flag: description: ... constraints. Examples:   <- block no longer loads
+    flag: description: ... constraints. Examples:   <- block does not load
 
 Two parsers read these files, and a block that satisfies one can still be
 unreadable by the other. `scripts/codex_compat_materializer.py` loads the
@@ -445,10 +445,6 @@ EXPECTED_SOURCE_LINK_PAIRS = {
             "<managed-root>/rules/code-standards.md",
             "packages/claude-dev-env/rules/code-standards.md",
         ),
-        (
-            "<managed-root>/rules/file-global-constants.md",
-            "packages/claude-dev-env/rules/file-global-constants.md",
-        ),
         (
             "<managed-root>/rules/windows-filesystem-safe.md",
             "packages/claude-dev-env/rules/windows-filesystem-safe.md",
@@ -477,10 +473,6 @@ EXPECTED_SOURCE_LINK_PAIRS = {
             "<managed-root>/rules/bdd.md",
             "packages/claude-dev-env/rules/bdd.md",
         ),
-        (
-            "<managed-root>/rules/ask-user-question-required.md",
-            "packages/claude-dev-env/rules/ask-user-question-required.md",
-        ),
         (
             "<managed-root>/rules/verify-before-asking.md",
             "packages/claude-dev-env/rules/verify-before-asking.md",
@@ -521,10 +513,6 @@ EXPECTED_SOURCE_LINK_PAIRS = {
             "<managed-root>/rules/re-stage-before-commit.md",
             "packages/claude-dev-env/rules/re-stage-before-commit.md",
         ),
-        (
-            "<managed-root>/rules/agent-spawn-protocol.md",
-            "packages/claude-dev-env/rules/agent-spawn-protocol.md",
-        ),
         (
             "<managed-root>/rules/workers-done-before-complete.md",
             "packages/claude-dev-env/rules/workers-done-before-complete.md",
@@ -797,7 +785,6 @@ def test_clean_coder_links_canonical_policy_areas() -> None:
     required_links = (
         "<managed-root>/docs/CODE_RULES.md#5-no-abbreviations",
         "<managed-root>/rules/testing.md",
-        "<managed-root>/rules/ask-user-question-required.md",
         "<managed-root>/rules/verify-runtime-state.md",
         "<managed-root>/rules/doc-inventory-integrity.md",
         "<managed-root>/rules/failure-blast-radius.md",
@@ -992,7 +979,6 @@ def test_clean_coder_follows_target_package_constant_layouts() -> None:
     assert "Reuse first" in body
     assert "shared policy" in body
     assert "multiple consumers" in body
-    assert "file-global-constants" in body
     assert "add the constant to the appropriate config file" not in body
 
 
@@ -1029,7 +1015,6 @@ def test_clean_coder_groups_session_policy_references() -> None:
         "Worker coordination",
     ):
         assert each_policy_group in body
-    assert "ask-user-question-required.md" in body
     assert "workers-done-before-complete.md" in body
     assert "verify-runtime-state.md" in body
     assert "Material implementation questions must return to the caller" in body
@@ -1039,7 +1024,6 @@ def test_clean_coder_groups_session_policy_references() -> None:
     expected_session_policy_files = (
         "testing.md",
         "anti-corollary-tests.md",
-        "ask-user-question-required.md",
         "verify-before-asking.md",
         "filesystem-search.md",
         "shell-invocation.md",
@@ -1049,7 +1033,6 @@ def test_clean_coder_groups_session_policy_references() -> None:
         "failure-blast-radius.md",
         "git-workflow.md",
         "re-stage-before-commit.md",
-        "agent-spawn-protocol.md",
         "workers-done-before-complete.md",
     )
     session_policy_map = body[body.index("## Session policy map") :]

package/.agents/skills/issue-tracker/SKILL.md

@@ -21,7 +21,7 @@ Prefer the **same warm** `issue-tracker` agent for follow-ups on the same issue
 
 ## Voice
 
-Use the `plain-brief` output style (`output-styles/plain-brief.md`). End with the issue number(s) and URL(s) the caller must keep.
+End with the issue number(s) and URL(s) the caller must keep, and nothing else.
 
 ## Gotchas
 

package/.agents/skills/orchestrator/SKILL.md

@@ -36,9 +36,8 @@ verification reads.
 ## status_gate (deterministic — not optional)
 
 **Prose does not keep the loop alive.** Re-arm and terminate are gated by
-`scripts/status_gate.py` (and, on Claude, the PreToolUse hook
-`orchestrator_refresh_reschedule_gate`). The gate is host-agnostic: a
-single pending re-arm latch in the status file, not host product names.
+`scripts/status_gate.py`. The gate is host-agnostic: a single pending re-arm
+latch in the status file, not host product names.
 
 ```
 python scripts/status_gate.py set --status active|done [--run-slug SLUG] [--status-file PATH]
@@ -158,8 +157,8 @@ in the repo the run works on (working files, not committed):
 - **One assignment file per task** — scope, file list, constraints, the
   acceptance check, baseline command output. The thick context goes
   here. `/prompt-generator` authors the assignment once at plan time,
-  and every ticket for that task reuses it — that reuse is what
-  satisfies the agent-spawn-protocol context check at each spawn.
+  and every ticket for that task reuses it, so each spawn starts from
+  the same named files, constraints, and acceptance check.
 - **Results merge into run state.** An executor's product is its
   artifact — the branch diff, the test output, the report its agent type
   may write — and its reply is thin: status, artifact paths, blockers.

package/.agents/skills/pull-request/SKILL.md

@@ -73,7 +73,7 @@ current process environment.
 
 | Skill | When | Produces | If missing |
 |---|---|---|---|
-| `pr-description-writer` | Before create or a full body rewrite | A reviewed title and body file | Stop the create or rewrite and report that authoring is required |
+| `pr-description-writer` | Create or a full body rewrite, when you want the body drafted for you | A reviewed title and body file | Write the title and body yourself |
 | `privacy-hygiene` | Before any durable GitHub post | A clean body and repository privacy sweep | Stop before publication and report the missing gate |
 | `issue-tracker` | Issue create, edit, or comment requests | Issue state and issue URLs | Route the request there. |
 | `e-code-review` | Review or review/fix loop requests | Structured findings or a clean review result | Route the request there. |
@@ -97,10 +97,10 @@ request target. Create actions publish drafts. Record the target before any writ
 
 ### 2. Author the title and body
 
-For create and full body rewrite, invoke the installed
-`pr-description-writer`. Require its title and body file as the authoring
-output. A comment or review may use a supplied body file when it does not
-rewrite the pull request description.
+For create and full body rewrite, write the title and a body file, or invoke
+the installed `pr-description-writer` to draft them from the diff. A comment or
+review may use a supplied body file when it does not rewrite the pull request
+description.
 
 ### 3. Run the local linter
 
@@ -122,8 +122,9 @@ permanent URLs. Rerun the linter after changing the body.
 
 ### 5. Resolve the process-local author
 
-Run `.agents/skills/pull-request/scripts/pull_request.py` with one structured
-action and the selected author. The command runs the linter again, resolves
+Run `~/.agents/skills/pull-request/scripts/pull_request.py` (under the agents
+home, not the repository; a worktree holds no `.agents/` copy) with one
+structured action and the selected author. The command runs the linter again, resolves
 the author value, and passes it only to the child `gh` process. It never
 changes the parent environment or calls `gh auth switch`.
 

package/.agents/skills/pull-request/reference/publication-tasks.md

@@ -6,7 +6,7 @@ reason when the task is conditional. This file is a task seed catalog, not a
 markdown progress board.
 
 1. Resolve one repository, action, and selected author. For create, resolve the source branch, base, and head. For other actions, resolve one existing pull request target. Create actions publish drafts.
-2. Invoke the required `pr-description-writer` for create or full body rewrite, then record its title and body file. Mark `N/A` for comment or review bodies that do not rewrite the pull request description.
+2. Record the title and body file for create or full body rewrite, written by you or drafted by `pr-description-writer`. Mark `N/A` for comment or review bodies that do not rewrite the pull request description.
 3. Validate every title, body, artifact, and local path input. Reject inline body input.
 4. Resolve the active managed root and run `<managed-root>/scripts/durable_post_lint.py` for the matching action. Record exit code `0` before credential lookup or network work.
 5. Run `privacy-hygiene` before the GitHub post and record its clean result.

package/.agents/skills/team-advisor/SKILL.md

@@ -26,9 +26,8 @@ One warm advisor at the strongest tier this session can reach. This session is t
 1. Name the session identity first (protocol **Host profiles**), then walk the model floor.
 2. Claude: Fable first in-session at `ADVISOR_EFFORT` (default low). When Fable is out of usage, bind Astra at the same effort. Codex: Astra in-session. Third-party: headless Fable then Astra. When the host's walk fails, fail closed.
 3. Name: `team-advisor-agent` on Claude (Agent spawn of `session-advisor`); a native Astra subagent on Codex; one CLI `session_id` on a third-party host via the protocol Claude-chain or Astra helper.
-4. A Fable-tier spawn or re-spawn carries the exact token `FABLE-SPAWN-AUTHORIZED` in its prompt (protocol warm-up; `fable_spawn_gate` requires it).
-5. Skip the multi-consumer "who you are" opener. This session is the sole consumer.
-6. When the bind or reply path fails, fail closed and report to the user. On a third-party host, only the bound advisor issues ENDORSE / CORRECTION / PLAN / STOP.
+4. Skip the multi-consumer "who you are" opener. This session is the sole consumer.
+5. When the bind or reply path fails, fail closed and report to the user. On a third-party host, only the bound advisor issues ENDORSE / CORRECTION / PLAN / STOP.
 
 **GOTCHA (Cursor / ThirdParty + Astra):** when the walk reaches Astra or the user asks for Astra, first tool call is `python ~/.claude/_shared/advisor/scripts/codex_astra_advisor.py --bind --enable-astra --cwd <repo-root>` with the charter on stdin. Do not use Agent or Task. Do not search for a probe path. Details: [`third-party-bind.md`](../../_shared/advisor/reference/third-party-bind.md) GOTCHA and [`astra-rung.md`](../../_shared/advisor/reference/astra-rung.md).
 

package/_shared/advisor/advisor-protocol.md

@@ -104,7 +104,6 @@ The validator checks ladder shape only; host policy sits on top.
 ## Warm-up (once per session)
 
 On a **Claude host**, spawn `session-advisor` at the Fable alias with the charter as its prompt. When Fable is out of usage and the Astra rung is open, bind Astra through the Codex helper instead.
-A **Fable**-tier try carries the exact token `FABLE-SPAWN-AUTHORIZED` in its prompt. `hooks/blocking/fable_spawn_gate.py` denies a Fable-tier spawn without it.
 Full spawn fields and the charter template: [`reference/warm-up.md`](reference/warm-up.md).
 
 On a **Codex host**, spawn a native in-session Astra subagent with the same charter. Bind fields: [`reference/identity.md`](reference/identity.md) and [`reference/warm-up.md`](reference/warm-up.md).

package/_shared/advisor/reference/lifecycle.md

@@ -10,7 +10,6 @@ Every other consumer (executors, or any other consulting session) reaches it by
 One shared advisor exists per orchestrated session, owned by the session that spawned it.
 
 **Re-spawn on drift.** If a reply shows the agent working from a stale picture, or the session pivots to an unrelated task, the owning session ends that agent and spawns a fresh one with a new charter.
-A **Fable**-tier re-spawn carries the exact token `FABLE-SPAWN-AUTHORIZED` in that fresh prompt, as a Fable-tier warm-up try does.
 
 ## Codex host
 

package/_shared/advisor/reference/warm-up.md

@@ -11,14 +11,13 @@ The consuming skill's session tries Fable first. Spawn with:
 - `model`: the short alias via `resolve_cli_model_id("Fable")` (alias table: [`cli-chain.md`](cli-chain.md)): `fable`. When Fable is out of usage and the Astra rung is open, continue with the Codex helper in [`astra-rung.md`](astra-rung.md) as the Astra fallback.
 - `name`: a name the session and every consumer will use to reach it (e.g. `team-advisor-agent`).
 - `run_in_background: true`.
-- `prompt`: the charter below. A **Fable**-tier try carries the exact token `FABLE-SPAWN-AUTHORIZED` in that prompt. `hooks/blocking/fable_spawn_gate.py` denies every `Agent` or `Task` spawn at `model: fable` whose prompt lacks that token. A try at any other tier needs no token.
+- `prompt`: the charter below.
 
 Stop at the first successful bind. That try's tier is `selected_tier`; the warm advisor lives at that tier for the rest of the session.
 
 ## Charter (the spawn prompt)
 
 The charter states the agent's role, the repo path, and the session's current goal in two or three sentences. The agent is a standing reviewer. It answers only via SendMessage. File edits and commands are out of its scope.
-On a Fable-tier try, include the exact token `FABLE-SPAWN-AUTHORIZED` as plain text in this prompt (substring match; the gate reads the token alone, wherever it came from).
 State plainly:
 
 - Every consult carries: who is asking (name and assignment), what changed since their last consult, the live decision or question, and any load-bearing paths or excerpts.

package/audit-rubrics/prompts/category-e-dead-code.md

@@ -59,7 +59,7 @@ Inline the artifact under this section using the section types defined in the ch
 
 **E7. Test fixtures / helpers defined but never used**
 - For every test file in scope, enumerate `@pytest.fixture`, `@pytest.fixture(scope=...)`, `setUp` / `tearDown` methods, factory helpers, mock builders, and module-level test constants. Verify each has at least one consumer test.
-- Module-level constants in test files: each must satisfy the file-global-constants use-count rule (≥2 references) OR be referenced by exactly one test plus one helper that the tests call.
+- Module-level constants in test files: each must be referenced by at least two callers, OR by exactly one test plus one helper that the tests call.
 - Helpers defined inside a single test body that are never called within that body are dead.
 - Adversarial probes for proof-of-absence: (a) any test that defines a local helper (e.g., `def make_dir(...):`) and never calls it? (b) any imported test name from the production module that no test exercises? (c) any module-level constant whose call graph collapses to zero references after the diff?
 
@@ -156,7 +156,7 @@ ID prefix: `find`.
 **E7. Test fixtures / helpers defined but never used**
 - `test_sweep_empty_dirs.py` defines no `@pytest.fixture` decorators. Nothing to flag under "fixture with no consumers".
 - `_set_creation_time_windows` is the only test helper; it has three call sites (E2 above). Used.
-- `_SCRIPTS_DIR` (line 12) is a module-level constant used at line 13 (`if str(_SCRIPTS_DIR) not in sys.path:`) and line 14 (`sys.path.insert(0, str(_SCRIPTS_DIR))`). Two references; satisfies the file-global-constants use-count rule.
+- `_SCRIPTS_DIR` (line 12) is a module-level constant used at line 13 (`if str(_SCRIPTS_DIR) not in sys.path:`) and line 14 (`sys.path.insert(0, str(_SCRIPTS_DIR))`). Two references; the constant earns its module scope.
 - No test data builders or mock factories are defined in this PR.
 - Adversarial probes for proof-of-absence: (a) does any of the five tests define a local helper inside its body that is then never called? (e.g., a `def make_dir(...):` defined but unused) — scan each test body. (b) does any test import a name from `sweep_empty_dirs` that it never uses? — only `sweep` is imported, and every test calls it. (c) does the `_SCRIPTS_DIR` block survive if pytest is invoked with `sweep_empty_dirs.py` already on `sys.path`? — yes, the membership-test guards the insert, so the constant is still meaningfully consumed even on the second run.
 
@@ -178,7 +178,7 @@ ID prefix: `find`.
 
 Q1: Are there imports unused locally but consumed by a re-export pattern in another file? Cite the cross-file pair if found. (Hypothesis: none — neither `sweep_empty_dirs.py` nor `test_sweep_empty_dirs.py` defines `__all__`, so re-export is not in play. `config/sweep_config.py` declares two constants that ARE consumed by `sweep_empty_dirs.py` lines 10-11; this is normal cross-file consumption, not a re-export.)
 Q2: What's the worst unused-code hazard introduced by this PR? Cite `<file>:<line>`. Candidates to evaluate: `arguments.interval` is parsed but unreachable on the `--once` path (line 57 short-circuits before the watch loop at line 67); the scheduled task always uses `--once`, so the `--interval` argparse declaration at line 45 is dead code on the only invocation path the installer creates. Decide: P2 (style) because the manual watch-mode path still uses it, vs P1 if you treat "the only installer path never exercises this branch" as functionally dead.
-Q3: Which symbol most likely will *become* dead code after a near-future refactor? Candidates: `_log_walk_error` (sole call site is the `os.walk(..., onerror=...)` kwarg — if a future refactor switches to `pathlib.Path.rglob` for walking, this helper has no other consumer and silently becomes orphaned); `DEFAULT_POLL_INTERVAL` (sole consumer is `_build_parser`'s `--interval` default — if Q2's hazard is resolved by removing `--interval` from the `--once`-only installer flow, this constant has zero consumers in the script and the file-global-constants use-count rule is broken).
+Q3: Which symbol most likely will *become* dead code after a near-future refactor? Candidates: `_log_walk_error` (sole call site is the `os.walk(..., onerror=...)` kwarg — if a future refactor switches to `pathlib.Path.rglob` for walking, this helper has no other consumer and silently becomes orphaned); `DEFAULT_POLL_INTERVAL` (sole consumer is `_build_parser`'s `--interval` default — if Q2's hazard is resolved by removing `--interval` from the `--once`-only installer flow, this constant has zero consumers in the script).
 
 ## Output
 

package/bin/install-constants.mjs

@@ -55,12 +55,7 @@ export const RUN_BACKUP_DIRECTORY_NAME_PATTERN =
  */
 export const PACKAGE_AGENTS_HOME_DIRECTORY_NAME = '.agents';
 
-export const PSTACK_MODEL_RULE_FILE_NAME = 'pstack-models.mdc';
 export const SUBAGENT_MODEL_POLICY_FILE_NAME = 'subagent-model-policy.json';
-export const PSTACK_SEEDED_MODEL_PREFERENCES_FILE_NAMES = Object.freeze([
-    'pstack-model-preferences.claude.json',
-    'pstack-model-preferences.codex.json',
-]);
 
 /**
  * The directory name skill directories carry in a package source and under

package/bin/install-pstack-plugin.mjs

@@ -0,0 +1,192 @@
+import { spawnSync } from 'node:child_process';
+
+export const PSTACK_MARKETPLACE_REPOSITORY = 'michael-denyer/pstack-claude';
+export const PSTACK_MARKETPLACE_NAME = 'pstack-claude';
+export const PSTACK_PLUGIN_IDENTIFIER = `pstack@${PSTACK_MARKETPLACE_NAME}`;
+export const PSTACK_PLUGIN_HOSTS = Object.freeze(['claude', 'codex']);
+
+export const PSTACK_PLUGIN_OPT_OUT_FLAG = '--no-pstack';
+export const PSTACK_PLUGIN_OPT_OUT_VARIABLE = 'CDE_INSTALL_PSTACK';
+
+const HOST_PLANS = Object.freeze({
+    claude: Object.freeze({
+        executable: 'claude',
+        executableVariable: 'CDE_CLAUDE_EXECUTABLE',
+        homeVariable: 'CLAUDE_CONFIG_DIR',
+        commands: Object.freeze([
+            Object.freeze(['plugin', 'marketplace', 'add', PSTACK_MARKETPLACE_REPOSITORY]),
+            Object.freeze(['plugin', 'install', PSTACK_PLUGIN_IDENTIFIER]),
+        ]),
+    }),
+    codex: Object.freeze({
+        executable: 'codex',
+        executableVariable: 'CDE_CODEX_EXECUTABLE',
+        homeVariable: 'CODEX_HOME',
+        commands: Object.freeze([
+            Object.freeze(['plugin', 'marketplace', 'add', PSTACK_MARKETPLACE_REPOSITORY]),
+            Object.freeze(['plugin', 'add', PSTACK_PLUGIN_IDENTIFIER]),
+        ]),
+    }),
+});
+
+/**
+ * Read the marketplace and plugin commands one host installs pstack with.
+ *
+ * Claude Code and Codex publish the same marketplace under different plugin
+ * verbs, so the command list belongs to the host rather than to the caller.
+ *
+ * @param {string} host Either `claude` or `codex`.
+ * @returns {{executable: string, executableVariable: string, homeVariable: string,
+ *   commands: ReadonlyArray<ReadonlyArray<string>>}} The host's install plan.
+ */
+export function pstackPluginPlan(host) {
+    const plan = HOST_PLANS[host];
+    if (!plan) {
+        throw new Error(
+            `Unsupported pstack plugin host ${host}: this installer knows ${PSTACK_PLUGIN_HOSTS.join(', ')}.`,
+        );
+    }
+    return plan;
+}
+
+/**
+ * Decide whether a full install also installs the pstack plugin.
+ *
+ * The step reaches the network for the marketplace repository. `--no-pstack`
+ * on the command line, or `CDE_INSTALL_PSTACK=0` in the environment, turns it
+ * off for an air-gapped or offline run.
+ *
+ * @param {string[]} [argumentList] The command-line arguments after the script.
+ * @param {Record<string, string|undefined>} [environment] The process environment.
+ * @returns {boolean} True when this run installs the pstack plugin.
+ */
+export function shouldInstallPstackPlugin(
+    argumentList = process.argv.slice(2),
+    environment = process.env,
+) {
+    if (argumentList.includes(PSTACK_PLUGIN_OPT_OUT_FLAG)) return false;
+    return environment[PSTACK_PLUGIN_OPT_OUT_VARIABLE] !== '0';
+}
+
+/**
+ * Build the process launch one platform needs to run a host command.
+ *
+ * Both hosts ship on Windows as a `.cmd` shim, and Node's synchronous spawn
+ * rejects a batch file with `EINVAL` unless a shell runs it, so Windows goes
+ * through `cmd.exe /d /s /c` with the whole command line as one verbatim
+ * argument. The executable carries its own quotes inside that line, which is
+ * why the line is passed verbatim rather than quoted again by Node. Every
+ * other platform launches the executable directly.
+ *
+ * @param {string} executable The host command, a bare name or a path.
+ * @param {string[]} commandArguments The arguments after the executable.
+ * @param {string} [platform] The platform to build for.
+ * @param {Record<string, string|undefined>} [environment] Supplies `ComSpec`.
+ * @returns {{file: string, args: string[], windowsVerbatimArguments: boolean}} The launch.
+ */
+export function hostCommandInvocation(
+    executable,
+    commandArguments,
+    platform = process.platform,
+    environment = process.env,
+) {
+    if (platform !== 'win32') {
+        return { file: executable, args: [...commandArguments], windowsVerbatimArguments: false };
+    }
+    const commandLine = [`"${executable}"`, ...commandArguments].join(' ');
+    return {
+        file: environment.ComSpec || 'cmd.exe',
+        args: ['/d', '/s', '/c', `"${commandLine}"`],
+        windowsVerbatimArguments: true,
+    };
+}
+
+function runHostCommand(executable, commandArguments, options) {
+    const invocation = hostCommandInvocation(executable, commandArguments);
+    const spawned = spawnSync(invocation.file, invocation.args, {
+        encoding: 'utf8',
+        env: { ...process.env, ...options.environment },
+        windowsVerbatimArguments: invocation.windowsVerbatimArguments,
+    });
+    return { status: spawned.status, stderr: spawned.stderr ?? '', error: spawned.error };
+}
+
+const COMMAND_NOT_FOUND_EXIT_CODE = 9009;
+const COMMAND_NOT_FOUND_PATTERN = /is not recognized as an internal or external command/;
+
+function namesAnAbsentCommand(outcome) {
+    if (outcome.error?.code === 'ENOENT') return true;
+    return outcome.status === COMMAND_NOT_FOUND_EXIT_CODE
+        && COMMAND_NOT_FOUND_PATTERN.test(outcome.stderr ?? '');
+}
+
+function firstLine(text) {
+    const trimmed = (text ?? '').trim();
+    if (!trimmed) return '';
+    return trimmed.split(/\r?\n/).filter(Boolean).at(-1);
+}
+
+function installForHost(host, homeDirectory, environment, runCommand) {
+    const plan = pstackPluginPlan(host);
+    const executable = environment[plan.executableVariable] || plan.executable;
+    const commandEnvironment = { [plan.homeVariable]: homeDirectory };
+    for (const commandArguments of plan.commands) {
+        const outcome = runCommand(executable, [...commandArguments], {
+            environment: commandEnvironment,
+        });
+        if (namesAnAbsentCommand(outcome)) {
+            return {
+                host,
+                executable,
+                status: 'skipped',
+                warning: `${executable} is not on PATH, so pstack was not installed for ${host}.`,
+            };
+        }
+        if (outcome.status !== 0 || outcome.error) {
+            const detail = firstLine(outcome.stderr) || outcome.error?.message || `exit ${outcome.status}`;
+            return {
+                host,
+                executable,
+                status: 'failed',
+                warning: `${executable} ${commandArguments.join(' ')} failed: ${detail}`,
+            };
+        }
+    }
+    return { host, executable, status: 'installed', warning: null };
+}
+
+/**
+ * Install the pstack plugin from its marketplace into each host's own home.
+ *
+ * Each host is one member of the batch. A host without its command-line tool
+ * is skipped and a host whose command fails is reported, so the rules, hooks,
+ * and skills this run already wrote still reach their durable places. An
+ * absent tool arrives as a spawn `ENOENT` on other platforms and as
+ * `cmd.exe`'s command-not-found exit code on Windows, and both read as
+ * skipped.
+ *
+ * @param {object} [options] Install targets.
+ * @param {string} [options.claudeRoot] The managed Claude root to install into.
+ * @param {string} [options.codexHome] The Codex home to install into.
+ * @param {string[]} [options.hosts] The hosts to install. Defaults to both.
+ * @param {Record<string, string|undefined>} [options.environment] The process environment.
+ * @param {object} [dependencies] Seams for the command runner.
+ * @returns {{status: string, hosts: object[], warning: string|null}} The outcome per host.
+ */
+export function installPstackPlugin(options = {}, dependencies = {}) {
+    const environment = options.environment ?? process.env;
+    const runCommand = dependencies.runCommand ?? runHostCommand;
+    const homeDirectories = { claude: options.claudeRoot, codex: options.codexHome };
+    const hosts = options.hosts ?? PSTACK_PLUGIN_HOSTS;
+    const hostOutcomes = hosts.map(host => installForHost(
+        host,
+        homeDirectories[host],
+        environment,
+        runCommand,
+    ));
+    const failedCount = hostOutcomes.filter(outcome => outcome.status === 'failed').length;
+    const installedCount = hostOutcomes.filter(outcome => outcome.status === 'installed').length;
+    const status = failedCount > 0 ? 'failed' : (installedCount > 0 ? 'installed' : 'skipped');
+    const warnings = hostOutcomes.map(outcome => outcome.warning).filter(Boolean);
+    return { status, hosts: hostOutcomes, warning: warnings.join(' ') || null };
+}