claude-dev-env 8.15.0 → 8.15.1

package/audit-rubrics/prompts/category-n-test-name-scenario-verifier.md

@@ -1,139 +0,0 @@
-Audit [REPO/ARTIFACT] [TARGET_ID] for **Category N only** (test-name scenario verifier). Skip A–M, O, P. Sub-bucket forced-exhaustion mode: Category N is decomposed into 10 sub-buckets below. Each sub-bucket REQUIRES at least one Shape A finding OR exactly one Shape B proof-of-absence with **at least 3 adversarial probes** specific to that sub-bucket. A sub-bucket returning neither is a protocol gap.
-
-[ARTIFACT METADATA — include every changed test alongside the production code path it claims to cover]
-
-- Title / one-line summary: [TITLE]
-- Head ref / SHA at audit time: [HEAD_SHA]
-- Changed test functions (file + line range + test name + first-line assertion): [CHANGED_TESTS]
-- Production functions the tests claim to cover (file + line range + symbol name + branch structure): [PRODUCTION_TARGETS]
-- Scenario fixtures / monkeypatches in scope (`monkeypatch.setattr`, `pytest.mark.skipif`, `freezegun.freeze_time`, `mock.patch`): [SCENARIO_GATES]
-- Stated intent of each scenario-named test (what condition the test name claims to exercise): [INTENT]
-
-ID prefix: `find`.
-
-[ONE-PARAGRAPH FRAME: enumerate every test whose name includes a scenario claim (`_when_*`, `_at_*`, `_under_*`, `_with_*`, `_on_*`, `_after_*`, `_during_*`). State the audit goal: for each scenario-named test, verify the body sets up the named condition via fixture / monkeypatch / environment gate so the production code's scenario-named branch runs during the act phase.]
-
-## Source material ([N] files/sections, all lines in scope)
-
-[INLINE every changed test function alongside the production function it claims to cover. Include the production function's branch structure so the audit can identify the no-op / early-return / default branches that scenario-named tests must NOT silently pass against.]
-
-## Sub-buckets (each requires Shape A finding OR Shape B with ≥3 adversarial probes)
-
-**N1. Scenario-named tests demonstrate the scenario** ⭐ canonical N case
-- For every test whose name contains `_when_X` / `_at_X` / `_under_X` / `_with_X` / `_on_X` / `_after_X` / `_during_X`, verify the body sets up condition X via fixture, monkeypatch, or environment gate before calling the system under test.
-- Adversarial probes: (a) construct an input that satisfies the test's assertion but does NOT trigger the scenario-named code path — does the test still pass; (b) trace the production function's code path under the test's input — which branch executes during the act phase; (c) inspect the test's setup-phase for monkeypatch / fixture calls that gate the scenario.
-
-**N2. Path-decision parametric matrices**
-- For tests of `is_*_path` / `_resolve_*_path` / `*_path_exemptions` modules, verify the test corpus ships a parametric matrix covering: empty string, single filename, tilde-prefix, UNC path, drive-letter path, symlinked path, `..`-containing path, trailing-slash path.
-- Adversarial probes: (a) walk the production function's path-classification branches — which branch does each input class hit; (b) check the test corpus for input shapes that hit only the default / no-classification branch; (c) for each input class missing from the matrix, construct a probe input and trace which branch executes.
-
-**N3. Tests that pass "for the wrong reason"**
-- For every assertion of the shape `assert <substring> in result`, verify the substring shape is unique to the scenario-named branch's output.
-- Adversarial probe: walk the production function's branches; for each branch, build the output and test the substring against it. If the substring matches more than one branch's output, the assertion cannot discriminate which branch ran.
-
-**N4. No-op branch exercised by scenario name**
-- For every scenario-named test, identify the production function's no-op / early-return / no-feature-installed branch. Verify the test's constructed input does NOT hit that branch.
-- Adversarial probes: (a) any test whose input fails the production function's first guard returns the no-op default and the assertion checks the default; (b) any test whose input is empty / None / missing returns early; (c) any test whose fixture is not installed at the test runtime hits the "feature missing" branch.
-
-**N5. Assertion shape mismatch**
-- For every assertion, verify the assertion's shape can fail by construction. `assert <substring> not in result` where the substring is misspelled relative to the production output, or `assert result == ""` when the production function returns `None` on the negative case, or `len(result) > 0` when the production function returns an empty list on the no-feature path.
-- Adversarial probes: (a) inspect each assertion's shape against the production function's return-value space; (b) check for assertions where the substring shape never appears in the production output by construction; (c) check for `assert x is True` where the production function returns truthy non-bool values.
-
-**N6. Cross-platform scenario gating**
-- For every test named `_on_windows` / `_on_linux` / `_on_macos`, verify the body gates on `sys.platform`, `monkeypatch.setattr(os, "name", ...)`, or `@pytest.mark.skipif`.
-- Bare scenario names that run unchanged across platforms claim more than they prove.
-- Adversarial probes: (a) does the production function's platform-specific branch get skipped on the CI runner's platform; (b) does the test pass against the platform fallback rather than the platform-specific code; (c) is the platform fixture installed and respected by the test runner.
-
-**N7. Time / clock scenario gating**
-- For every test named `_after_<duration>` / `_at_midnight` / `_during_business_hours`, verify the body injects a frozen clock (`freezegun.freeze_time`, `monkeypatch.setattr(time, "time", ...)`, `unittest.mock.patch("datetime.now")`).
-- Wall-clock tests are non-deterministic and may pass against the wrong scenario.
-- Adversarial probes: (a) does the test's act phase depend on the system clock being at a specific value; (b) does any timezone shift cause the test to flake; (c) does the production function read the clock during the act phase.
-
-**N8. Concurrent / load scenario gating**
-- For every test named `_under_load` / `_with_concurrent_writers` / `_under_contention`, verify the body spawns the concurrent workers and `wait()`s on them.
-- Single-threaded tests cannot claim concurrent-scenario coverage.
-- Adversarial probes: (a) does the test spawn `threading.Thread` / `multiprocessing.Process` / `asyncio.gather` / `concurrent.futures.ThreadPoolExecutor`; (b) does the test's act phase exercise the concurrency primitive the production function relies on; (c) does the test introduce a race window the production function's lock should serialize.
-
-**N9. Neutral-named tests (out of scope)**
-- Tests named `test_returns_empty_list_for_unknown_key` / `test_handles_y` / `test_raises_value_error` (no scenario claim in the name) are NOT subject to N1–N8.
-- For neutral-named tests, only N5 (assertion shape mismatch) applies.
-
-**N10. Test fixture wiring correctness**
-- For every test, verify the fixture / path / import wiring resolves to the artifact the test name claims.
-- Path arithmetic: walk every `Path(__file__).parents[k]` chain symbolically and confirm it reaches the directory the assertion expects — a `parents[3]` that stops at `skills/` while the test expects the package root cannot fail for the right reason.
-- Same-symbol dual imports: `from module import helper` plus `from module import helper as helper_alias` bind two names to the same function object, so any parity assertion between the two bound names is true by construction and proves nothing.
-- Fixture file lookups: confirm every `open(Path(__file__).parent / "fixture.txt")` (or equivalent) reaches a file that exists in the repo.
-- Adversarial probes: (a) re-derive each `parents[k]` index against the directory depth and flag any off-by-k; (b) check whether two imports in the test resolve to the same object before trusting a cross-name comparison; (c) confirm each referenced fixture path exists on disk at the depth the arithmetic produces.
-
-## Cross-bucket questions to answer at the end
-
-Q1: Across all 10 sub-buckets, is there a scenario-named test that does not exercise the named scenario? Cite the test's file:line and the production function's scenario-named branch that should have been exercised.
-
-Q2: What's the worst false-coverage signal introduced by the diff? Evaluate by (a) whether the test's name is load-bearing in the suite's coverage report, (b) whether the named scenario has any other coverage; (c) whether removing the test would change the coverage percentage.
-
-Q3: Which scenario-named test most likely will start passing for the wrong reason in a future refactor? Identify tests whose assertions match substrings that could appear in multiple branches — these are time bombs.
-
-## Output
-
-Lead: `Total: N (P0=N, P1=N, P2=N)`. For each sub-bucket N1-N10, produce Shape A or Shape B (with ≥3 probes). Each Shape A finding must cite the test's file:line AND the production function's branch the test's name claims to cover. Cross-bucket Q1-Q3 answers after the per-sub-bucket walk. Adversarial second pass: "assume your first pass missed at least 3 scenario-named tests that exercise the no-op branch — find them." Open Questions section for ambiguities. Read-only. No edits, no commits.
-
----
-
-# Worked example: jl-cmd/claude-dev-env PR #476
-
-Audit jl-cmd/claude-dev-env PR #476 for **Category N only** (test-name scenario verifier). Skip A–M. Sub-bucket forced-exhaustion mode: Category N is decomposed into 9 sub-buckets below.
-
-PR: refactor(hooks): cross-platform path resolution for windows-rmtree-blocker
-Head SHA: (the commit that landed the platform-conditional logic)
-ID prefix: `find`.
-
-The PR adds platform-conditional path-resolution logic to `windows_rmtree_blocker.py` and ships 5 new tests named `test_*_on_windows` and `test_*_on_linux` across `test_windows_rmtree_blocker.py`. The audit goal: verify each scenario-named test sets up the named platform via monkeypatch or skipif gate so the production function's platform-specific branch runs during the act phase.
-
-## Sub-buckets (each requires Shape A finding OR Shape B with ≥3 adversarial probes)
-
-**N1. Scenario-named tests demonstrate the scenario** ⭐ canonical N case — Shape A findings F5, F21, F23, F26, F27
-- `test_resolves_path_on_windows` calls `windows_rmtree_blocker.resolve_path("C:/Users/test")` and asserts the result equals `Path("C:/Users/test")`. The body does NOT call `monkeypatch.setattr(sys, "platform", "win32")` or `@pytest.mark.skipif(sys.platform != "win32")`. On a Linux CI runner, `sys.platform == "linux"` is in effect when the test runs; the production function's `if sys.platform == "win32":` branch is skipped, and the assertion succeeds against the Linux fallback branch's output (which happens to match `Path("C:/Users/test")` because `pathlib.PurePath` accepts Windows-style strings on Linux without normalization).
-- The test's NAME claims Windows-branch coverage; the test's BODY exercises the Linux fallback. This is the canonical N1 finding shape.
-- Adversarial probe (a): construct an input that the Windows branch would handle differently from the Linux branch — does the test catch the divergence? In F5's case, no: the assertion uses a string that both branches happen to produce, so the test cannot discriminate.
-- Adversarial probe (b): the production function's `sys.platform == "win32"` branch performs UNC-prefix stripping; the Linux fallback does not. Inputs containing `\\?\` would yield different outputs on the two branches. The test does not use such inputs.
-- Adversarial probe (c): the test runtime's `sys.platform` is `"linux"` on the CI runner. The act phase hits the fallback, full stop.
-- **Severity P1** for each of F5, F21, F23, F26, F27: scenario-named tests claim platform-specific coverage they do not provide.
-- **Fix**: wrap each `_on_windows`-named test in `@pytest.mark.skipif(sys.platform != "win32", reason="windows-specific path resolution")` AND duplicate as `_on_linux` for the Linux fallback branch; OR use `monkeypatch.setattr(sys, "platform", "win32")` to force the named platform during the act phase.
-
-**N2. Path-decision parametric matrices**
-- The production function `resolve_path` is a path-classifier — it qualifies for N2 coverage. The PR ships 5 inputs: drive-letter, UNC-prefix, tilde-prefix, `..`-containing, and trailing-slash. Missing: empty string, single filename, symlinked path. These three input classes have no test in the diff.
-- Adversarial probes: (a) construct an empty-string input — does any branch handle it; (b) construct a single-filename input (no directory component) — does the function return as-is or attempt to resolve against cwd; (c) construct a symlinked path — does the function resolve through the symlink or preserve it.
-
-**N3. Tests that pass "for the wrong reason"**
-- See N1 findings F5, F21, F23, F26, F27 — each passes because the assertion's substring matches both the Windows-branch output and the Linux-fallback output. The assertion shape cannot discriminate which branch ran.
-
-**N4. No-op branch exercised by scenario name**
-- F5 finding above: the scenario-named test exercises the Linux-fallback no-op branch on the CI runner.
-
-**N5. Assertion shape mismatch**
-- All five tests use `assert result == Path(<expected>)`. The shape can fail by construction (Path equality is strict). N5 verified clean.
-
-**N6. Cross-platform scenario gating** ⭐
-- Five `_on_windows`-named tests have zero platform gating. Five `_on_linux`-named tests have zero platform gating. N6 is the structural lens on the N1 findings — every test's NAME claims platform coverage, every test's BODY ignores the platform gate.
-- See N1 F5 / F21 / F23 / F26 / F27.
-
-**N7. Time / clock scenario gating**
-- No time-named tests in scope. N7 verified clean.
-
-**N8. Concurrent / load scenario gating**
-- No concurrency-named tests in scope. N8 verified clean.
-
-**N9. Neutral-named tests (out of scope)**
-- One test in the diff is neutrally named (`test_returns_path_unchanged_when_already_absolute`). N9 marks it out of scope for N1-N4 / N6-N8; only N5 applies. The assertion is `assert result == input_path` — shape clean. Verified clean.
-
-## Cross-bucket questions to answer at the end
-
-Q1: Five scenario-named tests (F5, F21, F23, F26, F27) do not gate on `sys.platform` and pass against the Linux-fallback branch on the CI runner. The Windows-specific code path has zero coverage despite the test names claiming it. Cite `test_windows_rmtree_blocker.py:42` (F5 first test) and `windows_rmtree_blocker.py:67` (the `if sys.platform == "win32":` branch) as the misclaim pair.
-
-Q2: Worst false-coverage signal: F5 — the test's name `test_resolves_path_on_windows` reads as Windows-branch coverage in the PR review, but the act phase exercises the Linux fallback. A reviewer reading the test name during PR review would assume Windows coverage exists; it does not.
-
-Q3: Once the Windows branch and the Linux branch diverge in their output for the same input — for example, a future PR that adds normalization to the Windows branch only — these five tests will start failing on Windows CI, exposing the false coverage retroactively.
-
-## Output
-
-Lead: `Total: 5 (P0=0, P1=5, P2=0)`. F5, F21, F23, F26, F27 are the N1+N6 scenario-gate-missing findings. N2 has one finding (parametric matrix incomplete) at P2. N3 / N4 are subsumed by N1. N5 / N7 / N8 / N9 verified clean. Adversarial second pass: scan for any non-`_on_<platform>`-named test that exercises the platform-conditional branch — verified none in this diff. Open Questions: whether the PR author intended any of the `_on_<platform>` tests to be platform-gated; resolve via reply on the audit thread. Read-only. No edits, no commits.

package/audit-rubrics/prompts/category-p-name-vs-behavior-contract.md

@@ -1,89 +0,0 @@
-Audit [REPO/ARTIFACT] [TARGET_ID] for **Category P only** (name / regex / word-list vs behavior-contract precision). Skip A–O. Sub-bucket forced-exhaustion mode: Category P is decomposed into 7 sub-buckets below. Each sub-bucket REQUIRES at least one Shape A finding OR exactly one Shape B proof-of-absence with **at least 3 adversarial probes** specific to that sub-bucket. A sub-bucket returning neither is a protocol gap.
-
-[ARTIFACT METADATA — every newly-added or renamed identifier plus the body code that implements its contract]
-
-- Title / one-line summary: [TITLE]
-- Head ref / SHA at audit time: [HEAD_SHA]
-- New / renamed boolean flags (file:line + identifier + lifecycle sites): [NEW_FLAGS]
-- New / renamed predicate helpers (file:line + identifier + body + return contract): [NEW_PREDICATES]
-- New / renamed regex constants (file:line + identifier + regex source + anchors): [NEW_REGEXES]
-- New / renamed word-lists or replacement tables (file:line + identifier + entries): [NEW_LISTS]
-- New / renamed helper-function names (file:line + identifier + signature + return): [NEW_HELPERS]
-- Stated intent of each new identifier: [INTENT]
-
-ID prefix: `find`.
-
-[ONE-PARAGRAPH FRAME: list every fresh identifier introduced by the diff. State the audit goal: for each identifier, verify the body's behavior matches the contract the name asserts — not broader, not narrower.]
-
-## Source material ([N] files/sections, all lines in scope)
-
-[INLINE each fresh identifier in context — the constant declaration with the value, the function signature with the body, the flag with every assignment / reset site, the regex source with surrounding usage.]
-
-## Binding counterexample protocol (run before every Shape B "clean" verdict)
-
-For every regex, brace or token scanner, or word-list the diff adds or edits, build at least three concrete inputs and trace each one through the pattern by hand:
-
-- One intended match the pattern must catch.
-- One near-miss the pattern must reject (hyphen vs underscore, a value reference vs a declaration, a substring of a longer word).
-- One structural edge that stresses the scanner: a destructured parameter, a quoted key, a nested brace, an escaped delimiter.
-
-Record what the pattern returns for each input. A wrong answer on any input is a Shape A finding, cited with the breaking input; a clean verdict is earned only after all three inputs return the contract's answer. `hooks/blocking/` is the priority surface — its patterns gate every write.
-
-Two canonical failures to probe for:
-- A brace scan that counts from the signature `(` and reads a destructured parameter (`renderRow({ id, label })`) as the start of the function body.
-- A `\bschema\b` pattern that matches the value in `{ label: schema }`, not just the `schema` declaration it targets.
-
-## Sub-buckets (each requires Shape A finding OR Shape B with ≥3 adversarial probes)
-
-**P1. Boolean / flag names assert state the body keeps**
-- For every new `is_*` / `has_*` / `was_*` / `should_*` flag, trace the body. Every set site must be paired with a reset site that fires when the named condition becomes false.
-- Adversarial probes: (a) grep every assignment to the flag — count set-true vs set-false; (b) for AST-driven flags, walk the visit method and confirm scope-exit semantics (def visited → flag set; dedent / function-exit → flag reset); (c) construct an input where the flag should be false after a region that set it true — does the code agree.
-
-**P2. Predicate-name breadth matches body coverage**
-- For every new `_is_*` / `_has_*` / `_can_*` predicate function, list the body's `return True` branches. The named predicate must hold on the union of those branches and nothing else.
-- Adversarial probes: (a) construct an input that satisfies the name but returns False — that is a P2 narrowness finding; (b) construct an input that does not satisfy the name but returns True — that is a P2 breadth finding; (c) check neighbor predicates — is the body's contract the responsibility of a different helper.
-
-**P3. Regex name vs regex shape** ⭐ canonical P case
-- For every new `*_PATTERN` / `*_REGEX` constant, read the regex source. Confirm the anchors (`^`, `$`, `\b`, lookarounds) match the name's promised shape. `FILE_PATH_PATTERN` implies path shape; the regex must include path-shape anchors (slash count, segment shape, length bounds) enough to reject non-path inputs.
-- Adversarial probes: (a) construct 3 non-matching inputs that the regex's name says it should reject — does the regex reject them; (b) construct 3 inputs that satisfy the regex but violate the name — those are P3 findings; (c) check sibling regexes in the same module — is the new regex anchored consistently with them.
-
-**P4. Helper-function name vs return contract**
-- For every new helper function, compare the name to the return shape AND the matching semantics. `_split_module_stem_prefix` should split on a stem-prefix boundary; if the returned prefix substring-matches unrelated stems, the matching semantics diverge from the name.
-- Adversarial probes: (a) feed the helper an input class the name names — is the return what the name implies; (b) feed it an input the name excludes — does the helper still produce output; (c) check downstream callers — do they consume the return on the contract the name implies.
-
-**P5. Word-list / replacement-table precision**
-- For every new reference list, walk each entry. Every entry must satisfy the named class. A list named `HEAVY_WORDS_TO_REPLACE` may not contain words that are ordinary in legitimate user inputs.
-- Adversarial probes: (a) for each entry, construct 3 legitimate-looking inputs containing it — would the gate fire on legitimate writing; (b) check entry density against the named class — is the list curated or kitchen-sink; (c) propose 3 entries that fit the named class better and 3 entries that do not fit — does the list match the proposed-good or the proposed-bad set.
-
-**P6. Class / module name vs scope**
-- For every new class or module, list the responsibilities (exported symbols, dispatched calls). Confirm each fits the named scope.
-- Adversarial probes: (a) list exported symbols and ask whether each matches the named scope; (b) check imports — does the module pull in unrelated subsystems; (c) check call-graph centrality — does the class own one thing or many.
-
-**P7. Reverse: name understates what the body does**
-- For every new identifier, ask whether the body produces effects the name does not promise (side effects, more return values, broader input acceptance, hidden state mutation). A future caller relying on the narrow name will be surprised.
-- Adversarial probes: (a) walk side effects (writes, network calls, global mutation) — are they named in the contract; (b) walk return tuples / objects — is every component named; (c) walk input acceptance — does the helper silently accept inputs outside its named class.
-
-## Cross-bucket questions to answer at the end
-
-Q1: Across all 7 sub-buckets, which identifier's name-vs-body gap is most likely to cause false positives in a production gate? Cite the identifier and the input class that trips it.
-
-Q2: Which identifier is at highest risk of being relied on by a future caller based on the name alone, with the broader / narrower body causing a regression? Cite the identifier and the assumed contract.
-
-Q3: Which identifier most clearly shows the body should be renamed (the name is honest about intent and the body is wrong) vs the name should be tightened (the body is the contract and the name overpromises)? Cite the identifier and the recommended direction.
-
-## Output
-
-Lead: `Total: N (P0=N, P1=N, P2=N)`. For each sub-bucket P1-P7, produce Shape A or Shape B (with ≥3 probes). Each Shape A finding must cite (a) the identifier file:line, (b) one concrete input that shows the name-vs-body gap, and (c) the recommended fix direction (rename vs body-tighten). Cross-bucket Q1-Q3 answers after the per-sub-bucket walk. Adversarial second pass: "assume your first pass missed at least 3 identifiers whose names overstate what the body does — find them." Open Questions section for ambiguities. Read-only. No edits, no commits.
-
----
-
-# Worked example: jl-cmd/claude-dev-env PR #508
-
-Audit jl-cmd/claude-dev-env PR #508 for **Category P only** (name / regex / word-list vs behavior-contract precision). Skip A-O.
-
-PR #508 ships the plain-language blocker hook. Two fresh identifiers in `plain_language_blocker_constants.py` show the canonical P shapes:
-
-- `FILE_PATH_PATTERN` (line 286) — a regex of shape `(\S+/\S+)` named for file paths but unanchored. Probes: `client/server`, `and/or`, `TCP/IP`, `lookup/replace` all match and are silently exempted from the plain-language scan even though none is a file path. **P3 finding.**
-- `HARD_DENY_REPLACEMENT_TERMS` (line 247) — a hard-deny replacement-by-term list named for ban-worthy heavy words but containing `command`, `address`, `function`, `subject`, `same`, `such`, `said`, `it is`, `there is`, `however`, `forward`. Each entry trips on ordinary technical English (`run the command`, `the address bar`, `validate the function`). **P5 finding.**
-
-Expected output: two P-class findings with cited file:line of the constant, cited example inputs (`client/server`, `run the command`), and recommended direction (anchor the regex to need repo-relative paths; curate the deny-list to drop dev-domain false positives).

package/audit-rubrics/prompts/category-q-cross-surface-claims.md

@@ -1,51 +0,0 @@
-Audit [REPO/ARTIFACT] [TARGET_ID] for **Category Q only** (cross-surface claim consistency — terminology, PR-description claims, message-vs-guard). Skip A–P. Sub-bucket forced-exhaustion mode: Category Q is decomposed into 3 sub-buckets below. Each sub-bucket needs at least one Shape A finding OR exactly one Shape B proof-of-absence with **at least 3 adversarial probes** specific to that sub-bucket. A sub-bucket returning neither is a protocol gap.
-
-[ARTIFACT METADATA]
-
-- Title / one-line summary: [TITLE]
-- Base ref / SHA (state before the change): [BASE_SHA]
-- Head ref / SHA at audit time (state after the change): [HEAD_SHA]
-- Changed surfaces (file + line range + symbol/region name): [CHANGED_SURFACES]
-- New or read identifiers, API fields, and config keys the diff touches: [DIFF_TERMS]
-- Changed prose surfaces (README, doc tables, inline prose, log and error strings): [CHANGED_PROSE_SURFACES]
-- PR description body text: [PR_BODY]
-- Stated intent of the change: [INTENT]
-
-ID prefix: `find`.
-
-[ONE-PARAGRAPH FRAME: describe what the diff changed in plain English, naming the identifiers and config keys it introduces, the PR-body claims it makes, and the messages it adds or edits. State the audit goal: find any surface whose wording contradicts another surface that must agree with it — a prose term that misspells a code field, a PR-body claim the diff or repo does not bear out, or a message that asserts more than the guard gating it guarantees.]
-
-## Source material ([N] files/sections, all lines in scope)
-
-[INLINE THE FULL DIFF — the changed lines and enough surrounding context to show each identifier's definition and each message's guard.]
-
-[ALSO INLINE the PR description body text and every changed prose surface — README sections, doc tables, runbooks, log and error strings — so the agent can pair each claim with the code it names.]
-
-## Sub-buckets (each needs a Shape A finding OR Shape B with ≥3 adversarial probes)
-
-**Q1. Term sweep**
-- Pull out every identifier, API field, and config key the diff introduces or reads. For each, sweep all changed prose surfaces for a near-miss variant — a hyphen or a space in place of an underscore, a singular where the code is plural (or the reverse), a shared prefix with a divergent tail.
-- Run `packages/claude-dev-env/_shared/pr-loop/scripts/terminology_sweep.py` for mechanical recall. It reads a unified diff on stdin or via `--diff-file`, prints one `file:line` finding per near-miss, exits 1 when findings exist and 0 when clean. Feed it the PR diff, then adjudicate each finding: a near-miss can be an intentional distinct term, so cite the code definition and the prose line and judge whether they name the same thing.
-- Adversarial probes when the sweep is clean: (a) check camelCase versus snake_case spellings of the same field across code and docs; (b) check singular/plural drift on collection field names; (c) check a shared-prefix family (`retry_budget`, `retry_count`, `retry_limit`) for a doc that names the wrong member.
-
-**Q2. PR-description claim verification**
-- Read the PR body. List each falsifiable claim — a dead-code removal, a performance or ceiling number, a "last caller" assertion, a "no remaining X" cleanup claim.
-- Verify each claim two ways against the diff and the repo. A dead-code claim gets a reference search across the repo for the named symbol. A ceiling or performance claim gets checked against the config value the diff sets and the call sites it touches. Cite the PR-body line and the diff or repo line that confirms or contradicts it.
-- Adversarial probes when the body looks correct: (a) search the repo for a surviving caller of any symbol the body calls dead; (b) compare each stated number against the config constant the diff sets; (c) check whether a "this finishes the cleanup" claim leaves a matching pattern in an unchanged sibling file.
-
-**Q3. Message-vs-guard consistency**
-- For every log, error, and evidence string the diff adds or edits, read the branch condition that gates it. The message text matches what that guard guarantees: a string asserting an outcome fires only on a branch that reaches the outcome.
-- Check temporal wording against the lifetime of the state variable the message names: "this run" versus "this round", "is open" versus "was opened", "reached" versus "attempted". Cite the message line and the guard or state-variable line.
-- Adversarial probes when messages look aligned: (a) trace each success message back to the return value or flag it claims and confirm the branch cannot reach it with the opposite value; (b) check every "missing" / "not found" error against the exception class the branch catches; (c) check every counter-based message against where the counter resets.
-
-## Cross-bucket questions to answer at the end
-
-Q-a: Which single claim in this change is most likely to mislead a reader at runtime — a prose term that names a field the code does not define, a PR-body fact the diff contradicts, or a message that overstates its guard? Cite both surfaces by `path:line`.
-
-Q-b: Which surface is the strongest witness to the contradiction — the doc, PR body, or message a reader would trust while the code says otherwise?
-
-Q-c: Is there a term the diff introduces that appears correct in the code yet drifts across two or more prose surfaces at once? Cite each prose line and the code definition.
-
-## Output
-
-Lead: `Total: N (P0=N, P1=N, P2=N)`. For each sub-bucket Q1-Q3, produce Shape A or Shape B (with ≥3 probes). Each Shape A finding cites BOTH surfaces — the claim and the surface that contradicts it — by `path:line`. The `failure_mode` describes the contradiction between the two surfaces. Cross-bucket Q-a through Q-c answers after the per-sub-bucket walk. Adversarial second pass: "assume your first pass missed at least 3 cross-surface contradictions — find them." Open Questions section for ambiguities. Read-only. No edits, no commits.

package/hooks/hooks_constants/style_reminder_prompt_constants.py

@@ -1,9 +0,0 @@
-"""The style reminder text for the style_reminder_prompt hook."""
-
-from __future__ import annotations
-
-__all__ = [
-    "STYLE_REMINDER_PROMPT",
-]
-
-STYLE_REMINDER_PROMPT = "small words. few words. always. forever."

package/hooks/session/style_reminder_prompt.py

@@ -1,55 +0,0 @@
-#!/usr/bin/env python3
-"""UserPromptSubmit hook. Adds the style reminder to every message.
-
-::
-
-    user sends a message
-             |
-             v
-    UserPromptSubmit fires -> additionalContext: "small words. few words. always. forever."
-             |
-             v
-    the model sees the reminder this turn, and each turn after
-
-Claude Code and Codex CLI both read the same ``additionalContext`` shape on
-their ``UserPromptSubmit`` event. The Claude hook includes the skill reminder
-when its flag is present. The unflagged Codex hook prints style alone.
-"""
-
-from __future__ import annotations
-
-import json
-import sys
-
-import _path_setup  # noqa: F401
-
-from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
-from hooks_constants.style_reminder_prompt_constants import STYLE_REMINDER_PROMPT
-from skill_loaded_reminder import reminder_for
-
-
-def _additional_context_for_prompt() -> str:
-    if "--include-skill-reminder" not in sys.argv[1:]:
-        return STYLE_REMINDER_PROMPT
-    hook_input = read_hook_input_dictionary_from_stdin()
-    if hook_input is None:
-        return STYLE_REMINDER_PROMPT
-    skill_reminder = reminder_for(hook_input)
-    if skill_reminder is None:
-        return STYLE_REMINDER_PROMPT
-    return STYLE_REMINDER_PROMPT + "\n" + skill_reminder
-
-
-def main() -> None:
-    """Print ordered UserPromptSubmit additionalContext."""
-    payload = {
-        "hookSpecificOutput": {
-            "hookEventName": "UserPromptSubmit",
-            "additionalContext": _additional_context_for_prompt(),
-        }
-    }
-    sys.stdout.write(json.dumps(payload) + "\n")
-
-
-if __name__ == "__main__":
-    main()

package/hooks/session/test_style_reminder_prompt.py

@@ -1,86 +0,0 @@
-"""Tests for style_reminder_prompt. Checks the hook adds the style reminder."""
-
-import json
-import sys
-from io import StringIO
-from pathlib import Path
-from unittest.mock import patch
-
-_SESSION_DIR = Path(__file__).resolve().parent
-_HOOKS_ROOT = _SESSION_DIR.parent
-for each_sys_path_entry in (str(_SESSION_DIR), str(_HOOKS_ROOT)):
-    if each_sys_path_entry not in sys.path:
-        sys.path.insert(0, each_sys_path_entry)
-
-import style_reminder_prompt as reminder
-from hooks_constants.skill_loaded_reminder_constants import NOT_LOADED_REMINDER
-from hooks_constants.style_reminder_prompt_constants import STYLE_REMINDER_PROMPT
-
-
-def _run_main(all_arguments: list[str], hook_input: str) -> str:
-    """Return the text main() prints."""
-    captured_stdout = StringIO()
-    with (
-        patch("sys.argv", ["style_reminder_prompt.py", *all_arguments]),
-        patch("sys.stdin", StringIO(hook_input)),
-        patch("sys.stdout", captured_stdout),
-    ):
-        reminder.main()
-    return captured_stdout.getvalue()
-
-
-class TestStyleReminderPrompt:
-    def test_main_emits_user_prompt_submit_hook_specific_output(self) -> None:
-        emitted = json.loads(_run_main([], ""))
-        hook_output = emitted["hookSpecificOutput"]
-        assert hook_output["hookEventName"] == "UserPromptSubmit"
-        assert hook_output["additionalContext"] == STYLE_REMINDER_PROMPT
-
-    def test_unflagged_invocation_keeps_style_only_with_hook_input(self) -> None:
-        emitted = json.loads(_run_main([], json.dumps({"hook_event_name": "UserPromptSubmit"})))
-        assert emitted["hookSpecificOutput"]["additionalContext"] == STYLE_REMINDER_PROMPT
-
-    def test_flagged_invocation_combines_style_and_missing_skill_reminder(self) -> None:
-        emitted = json.loads(
-            _run_main(
-                ["--include-skill-reminder"],
-                json.dumps({"hook_event_name": "UserPromptSubmit"}),
-            )
-        )
-        assert emitted["hookSpecificOutput"]["additionalContext"] == (
-            STYLE_REMINDER_PROMPT + "\n" + NOT_LOADED_REMINDER
-        )
-
-    def test_flagged_invocation_keeps_style_only_after_skill_load(self, tmp_path: Path) -> None:
-        transcript_path = tmp_path / "session.jsonl"
-        transcript_path.write_text(
-            json.dumps(
-                {
-                    "type": "assistant",
-                    "message": {
-                        "content": [
-                            {
-                                "type": "tool_use",
-                                "name": "Skill",
-                                "input": {"skill": "pstack:poteto-mode"},
-                            }
-                        ]
-                    },
-                }
-            )
-            + "\n",
-            encoding="utf-8",
-        )
-        emitted = json.loads(
-            _run_main(
-                ["--include-skill-reminder"],
-                json.dumps(
-                    {"hook_event_name": "UserPromptSubmit", "transcript_path": str(transcript_path)}
-                ),
-            )
-        )
-        assert emitted["hookSpecificOutput"]["additionalContext"] == STYLE_REMINDER_PROMPT
-
-    def test_flagged_invocation_without_hook_input_keeps_style_only(self) -> None:
-        emitted = json.loads(_run_main(["--include-skill-reminder"], ""))
-        assert emitted["hookSpecificOutput"]["additionalContext"] == STYLE_REMINDER_PROMPT