Ports this branch's changes onto the refactor: review.ts edits into plan-gates/outside-voice-steps,
PTY changes into test/helpers/pty/*, the paid runner onto the shared shard engine with case, plan
and report code split into scripts/lib/paid-{cases,plan,report}.ts under the size ratchet, touchfile
deltas applied per key, and the flake ranker's cache onto lib/state-root.
* refactor(resolvers): split review.ts into MECE resolver modules (pure move)
Move every function from scripts/resolvers/review.ts, unchanged, into:
- review-dashboard.ts: review dashboard, plan-file review report
- plan-gates.ts: approval check, exit-plan-mode gate, plan-file discovery,
plan-completion audit/gate (ship + review), plan verification exec
- spec-review.ts: both spec review loops, benefits-from, anti-shortcut clause
- outside-voice-steps.ts: Codex second opinion, adversarial step, Codex plan
review, Codex doc review, disabled-outside record
- review-scope.ts: scope drift, cross-review dedup, shared-code reuse
review.ts is deleted; index.ts imports the new modules. gen-skill-docs
output is byte-identical for every host (--host all). Test imports and
source-path references are re-pointed; the two source-text report/gate
tests in gen-skill-docs.test.ts become behavioral renders across every
consuming skill and host. All 46 touchfile entries that named review.ts
now name all five modules, guarded by a recorded selection golden.
* test(browse): black-box auth matrix for every server route and both surfaces
Drives buildFetchHandler fetchLocal/fetchTunnel with no token, wrong token,
root token, scoped token and the SSE cookie for all 33 routes, plus unmatched
paths and wrong methods. Denials assert today's exact status, body and content
type; allowed credentials assert the handler was reached. Written against the
unchanged if-chain server so the W3 route-table refactor must keep it green.
* refactor(shard-engine): move scripts/test-strict-output.ts to scripts/lib/shard-engine.ts
The shared shard engine grows from the existing strict-output module
(runShardChild, killProcessGroup, signal forwarding, strict classifier).
scripts/test-strict-output.ts stays as a re-export so existing importers,
mock.module paths and the strict-output/run-shard-child tests are unchanged.
The engine inherits the global touchfile entry; the free runner's CLI-routing
fixture copies the new module.
* refactor(resolvers): decompose the three >150-line review resolvers (output-neutral)
Split generateAdversarialStep, generateCodexPlanReview and
generatePlanCompletionAuditInner into per-section helpers whose template
literals are copied verbatim, so every function in the new modules is at
or under 150 lines. gen-skill-docs output is byte-identical for every host
(--host all, compared against 96764e80 with a fixed --link-root).
* refactor(resolvers): one outside-voice failure policy (deliberate prose unification)
outsideVoiceFailurePolicy(ctx, opts) in outside-voice.ts now renders the
auth / timeout / empty-response bullets for all four call sites that
hand-typed them (Codex second opinion, adversarial step, Codex plan
review, design outside voices). Options are explicit per site
(timeoutMinutes, onTimeout, stderrOnEmpty, fallback, escape) with no
defaults.
Deliberate generated-prose changes (every host):
- office-hours: 'Fall back to <native> subagent.' becomes
'Fall back to the <native> subagent below.'
- plan-devex-review: the plain 'Auth failure (stderr contains ...)'
bullets become the canonical bold bullets; auth also triggers on
'API key'; 'auth failed' becomes 'authentication failed'.
- review/ship adversarial: 'exceeded 9 minutes and was terminated'
becomes 'timed out after 9 minutes and was terminated'; the timeout
is still MISSING COVERAGE.
- design outside voices: unchanged.
Adds ratchet (d) (test/outside-voice-failure-policy.test.ts) with a
reasoned allowlist for /codex's own CLI errors, the MISSING COVERAGE
retention test, refreshed codex/factory ship goldens, and outside-voice.ts
in every touchfile entry of review.ts and design.ts (selection golden
extended).
* test(pty): fake PTY session driver with an injectable clock through the runner launch seam
The three plan-skill runners take an optional PtyDriver (launch, now,
monotonic, sleep); omitted, they use the real launcher and clocks exactly as
before. test/helpers/pty/fake-session.ts feeds scripted frames through that
seam, and claude-pty-runner.runners.unit.test.ts runs observation, counting
and floor for success, deadline timeout, permission prompt and plan-ready
outcomes with no CLI or real timers. These cases must stay green unchanged
through the W4 split and the runPtySession extraction.
Touchfiles: every entry that lists claude-pty-runner.ts or pty-screen.ts now
also lists test/helpers/pty/**.
* refactor(shard-engine): run both lanes on the shared engine; lane policy injected
Engine (scripts/lib/shard-engine.ts) gains the W2 primitives: per-shard
tmp/Chromium sandbox + async cleanup backstop, log-path allocation and
full-stream log capture, one duration-seed reader/writer with a lane
predicate, LanePolicy (seed predicate + zero-execution verdict),
strictShardStatus, and the shared CLI flag loop. runShardChild takes an
optional companion (signal/settle) and waits a bounded 250ms to reap a
wall-killed child.
Free lane stops spawning shards itself: runFreeShard uses runShardChild
with trackShardBrowser as the companion (win32 path unchanged: no process
group, no negative-pid kill). Its sync state-dir removal stays lane policy.
Paid lane uses the sandbox, log, seed, verdict and flag primitives; the
hollow-shard guard applies PAID_LANE_POLICY. Lane outcomes are unchanged
(free keeps >= 0 seeds and file-count zero-exec rule; paid keeps > 0 seeds,
warning under selection and passed-empty under EVALS_ALL).
paid-free-boundary's closure assertion now names the engine module, where
the strict classifier lives.
* test(shard-engine): engine unit tests, fixture-corpus equivalence, per-lane CLI parity
- test/shard-engine.test.ts: failing/unhandled/module-load output fails both
lanes, per-lane zero-execution and seed rules, whole-group kill on a wall
timeout (both lanes), mocked-win32 path with no negative-pid kill,
companion settle order, log capture, sandbox isolation, flag loop.
- test/shard-engine-equivalence.test.ts + test/fixtures/shard-equivalence:
seven outcome fixtures plus one real shard, run through both lanes and
compared with classifications recorded from the base runners (96764e80).
- test/shard-cli-parity.test.ts + test/fixtures/shard-cli-parity: flag set,
defaults, validation errors and the Unknown argument error per lane match
the base runners.
* refactor(shard-engine): decompose runFreeShard and runPaidShard to <= 150 lines
Output-neutral extraction under the fixture-corpus equivalence and runner
tests: captureFreeStream, explainFreeVerdict and logFreeRecovery (free);
paidShardCommand, settleShardSpool, settleBootstrapRetention and
printLogTail (paid). The bootstrap scope-creation block that
bootstrap-retention.test.ts evaluates stays verbatim.
* refactor(pty): split claude-pty-runner.ts into test/helpers/pty/* behind a barrel
Pure move: every line of the former 5,047-line runner lands verbatim in one
module (four private helpers gain `export` for cross-module use):
binary, screen (absorbs test/helpers/pty-screen.ts, which now re-exports it),
launch, session (PtyDriver), judge, classify, auq, plan-native, boundaries,
runners/{observation,counting,floor}. claude-pty-runner.ts re-exports the
original public surface by name; pty/ modules import siblings directly.
Tests that read the runner's source text:
- rewritten as behavioral: the unit test's model-pin tripwire (fake CLI argv:
fallback chain, --model before extraArgs, hermetic --strict-mcp-config),
pty-skill-seeding-wiring (runners through the fake driver; launcher through
a fake CLI reporting CLAUDE_CONFIG_DIR). The "three wrappers forward model"
grep is replaced by the runners' fake-driver launch assertions.
- pty-screen-session / pty-screen-supervision: stop copying runner source;
they mock.module the real pty/screen.ts (and the fixture cleanup) instead.
- re-pointed to the owning module (they execute a sliced runner body with
injected boundaries; no seam exists for those boundaries yet):
eng-seeded-completion-ai, plan-floor-permission, plan-create-prepublication,
plan-count-completion; hermetic-wiring's source guard now reads pty/launch.ts
and scans every pty/ module for raw process.env spreads.
- plan-count-timeout and pty-output-wake mock the viewport at pty/screen.ts.
* test(ratchet-c): enforcing module/function size ratchet and moved-code touchfile coverage
Ratchet (c) ships enforcing: test/helpers/module-size.ts counts file and
top-level function lengths by brace matching over masked source (strings,
comments, regex literals and template text masked; ${} expressions kept),
covering function declarations, arrow functions assigned to consts and
route-table handler properties, with no parser dependency. Its self-test
uses template literals and code-fence braces copied from
scripts/resolvers/review.ts and design.ts. test/fixtures/module-size-ratchet.json
binds scripts/lib/shard-engine.ts (<= 800 lines, <= 150 per function) and
records the residual runner sizes (free 2352, paid 1921) as non-growth caps;
allowlist entries are keyed on file plus matched text and need a reason.
Failure output lists file:line, the rule, Fix: and the allowlist path.
touchfiles.test.ts gains the moved-code superset check over
test/fixtures/touchfile-move-goldens/ (W2 golden recorded at 96764e80:
test-strict-output.ts and test-paid-shards.ts global, test-free-shards.ts none).
* refactor(browse): declared route table replaces the buildFetchHandler if-chain
The ~1,300-line if-chain in buildFetchHandler becomes a route table:
each entry declares method, path, auth kind and surfaces, and one auth
gate in browse/src/routes/table.ts returns the per-kind denial (root-bearer,
scoped, root-or-sse-cookie: 401 Unauthorized; root-token: 403 Root token
required; extension-origin: 403 Forbidden). Unmatched requests take the
declared fallthrough (root-bearer check, then plain-text 404). Handlers move
to browse/src/routes/{core,pairing,pty,tokens,tunnel,activity,commands,files,
inspector}.ts and receive a RouteContext with auth checks as functions
instead of closing over factory locals. Dispatch order is unchanged:
tunnel filter, beforeRoute overlay, gate, handler. TUNNEL_PATHS stays a
literal in server.ts.
Behavior-preserving: the black-box auth matrix from the previous commit
passes unchanged. /memory and /inspector/events are declared root-bearer
because the blanket check always ran before their SSE-cookie branch.
Source-text route tests are rewritten as behavioral tests through
buildFetchHandler or a route's real handler with a stub RouteContext
(browse/test/route-test-harness.ts). Checks with no runtime seam are
re-pointed to the route modules: Surface type, /inspector/events SSE
helper, sanitizeReplacer imports, /pty-inject-scan sidecar-client import,
and the ngrok config lookup and startTunnel wiring that stay in server.ts.
* test(browse): stubbed-handler auth matrix and route inventory for the route table
Every ROUTES entry runs through the real dispatcher and gate with stub
handlers on each declared surface and six credentials; denials assert the
exact status and body each auth kind returned at 96764e8, admitted
credentials assert the handler ran (with the gate's TokenInfo for scoped
routes). Also pins the reviewed route inventory (method, path, auth kind,
surfaces), that every entry declares auth and surfaces, that the table's
tunnel paths equal the TUNNEL_PATHS literal with GET /connect admitted, the
unmatched fallthrough, and that the root token is rejected on every tunnel
route through buildFetchHandler.
* test(browse): ratchet (b) keeps route dispatch inside the route table
Scans browse/src/server.ts and browse/src/routes/*.ts for pathname
comparisons; only the table matcher and the tunnel-surface filter are
allowed, listed with reasons in browse/test/fixtures/route-dispatch-allowlist.json
(keyed on file plus line text). Also checks every entry declares auth and
surfaces and that gstack registers no beforeRoute overlay itself. Self-tests
plant a violation and assert the file:line, Fix: and allowlist path in the
message, that a shifted line stays allowlisted, and that a reasonless entry
is rejected.
* test: touchfile superset check for modules moved out of browse/src/server.ts
Records the paid evals selected by touching browse/src/server.ts at 96764e80
(17 E2E, 1 LLM judge) and asserts every browse/src/routes/*.ts module selects
a superset. The test reads every golden in test/fixtures/moved-module-selection/
so other moved-code goldens can sit beside it.
* test(shard-engine): give non-timeout corpus fixtures CI headroom; keep the POSIX golden off the Windows lane
Only the wall-timeout fixture keeps a 3s wall; the rest get 60s so a loaded
host cannot turn a pass into a timeout. Base and branch runners still agree
on every classification under the new walls. The Windows exclusion entry
moves the free runner's ratchet (c) residual cap to 2356 lines.
* refactor(pty): one runPtySession loop drives observation, counting and floor
test/helpers/pty/session.ts owns launch -> start -> (poll -> tick)* ->
timeout and the failure contract the three runners each hand-rolled: the
run's own error wins over capture and close errors, close always runs, owned
fixture cleanup runs last (also when launch fails). Each runner now supplies a
PtySessionPlan: its boot/command step, poll cadence (2s observation/floor
sleep; counting's output wake + 250ms coalesce), tick policy (permission
handling, native identity, terminal rules stay per runner because they differ)
and capture hooks. The runner bodies are decomposed into top-level steps so no
function exceeds 150 lines; behavior is unchanged and the fake-driver cases
from the first W4 commit pass unmodified.
The counting capture step and the native completion-summary predicate are now
named functions (countingCapture, isNativeCompletionSummary), so
plan-create-prepublication and plan-count-completion call them directly
instead of executing sliced source. The two harnesses that still execute a
sliced runner body with injected boundaries (eng-seeded-completion-ai,
plan-floor-permission) pass the PtyDriver seam instead of overriding
Date/Bun.sleep.
* test(ratchet-c): register route modules, review resolver modules and server.ts residual cap
* refactor(pty): decompose launchClaudePty and engNumberedFindingAUQ under 150 lines
launchClaudePty (349 lines) becomes launch preparation (args, hermetic
child env, owned state roots), recorder creation, spawn, the trust-dialog
watcher, close, and the session handle over one PtyProcess state object. The
failure order is unchanged: abort the viewport, dispose any recorders created
so far, dispose the viewport, rethrow. The --model / --strict-mcp-config
ordering and seedSkills wiring stay pinned by the behavioral fake-CLI tests.
engNumberedFindingAUQ (345 lines) keeps its guards and dispatch; each
self-contained issue family (declared cache, library retry hooks, cache
owner, injected singleton, shared writers, injected export) moves verbatim
into its own function. Every pty/ module is now <= 800 lines and every
top-level function <= 150 lines.
* test(pty): split claude-pty-runner.unit.test.ts along the pty/ module seams
The 188 unit tests move verbatim into claude-pty-runner.{screen,classify,
auq,launch,plan-native,boundaries}.unit.test.ts (test names unchanged; each
file imports only what it uses from the barrel). The five files that no longer
read a SKILL.md template join the test-of-test ratchet baseline with a reason.
* test(touchfiles): moved PTY modules keep their paid-eval selection
test/fixtures/touchfile-selection/w4-pty.json records, at 96764e8, the paid
evals selected by touching test/helpers/claude-pty-runner.ts (20) and
test/helpers/pty-screen.ts (20). touchfiles.test.ts now asserts every .ts file
under test/helpers/pty/ (and pty/screen.ts for both sources) selects a
superset, reading every golden in that directory so later moves can add one;
a planted-violation case pins the report and its Fix line.
* fix(browse): unexchanged pair setup keys no longer authenticate bearer requests
validateToken accepted a gsk_setup_ key as a bearer on /command, /batch and
/file (found while building the W3 auth matrix). A setup key now only
authenticates the /connect exchange.
* W1: one state-root owner (lib/state-root.ts + bin/gstack-state-root.sh), gstack-paths --explain and fail-stop, parity tests
* W1: guarded migration of every executable state-root site; uninstall deletes only ~/.gstack
Bins, careful/freeze hooks, setup, upgrade migrations, browse/src, design,
ios-qa daemon, lib and scripts resolve the state root through
bin/gstack-state-root.sh (bash) or lib/state-root.ts (TS). Bins source the
twin and stop with a reinstall message when it is missing; hooks source it
and never spawn gstack-paths. browse/src/config.ts and lib/cso/state.ts
delegate to resolveStateRoot. Analytics writers and readers move together
so the usage log stays one file. gstack-uninstall deletes state only at
~/.gstack, refuses (exit 2) when it resolves to /, $HOME or an ancestor,
the checkout or the git root, and leaves any other resolved root in place
with the removal command. Fixtures that copy single bins now copy the twin.
* W1: privacy keys and trust-policy deny tiers merge across state roots; gstack-config reporting; test hermeticity
readConfigKey / gstack_read_config_key return the most restrictive
telemetry, memorable_recall, codex_reviews and update_check across the
resolved root and ~/.gstack; other keys read the resolved root only.
gstack-config set reports an overriding root with the exact override
command, list shows the winning root and a root-variable disagreement line.
gstack-gbrain-repo-policy get merges deny/read-only tiers. gstack-egress
reads through readConfigKey. test-setup.ts strips inherited
GSTACK_STATE_ROOT/GSTACK_STATE_DIR and redirects the legacy root.
* W1: shared hook logging helper (hosts/claude/hooks/hook-log.ts)
One hook-errors.log writer: root from resolveStateRoot, 0600 on every
append, opt-in rate limit used only by memorable-user-prompt. The five
hooks route through it.
* W1: docs/state-root.md and README troubleshooting pointer
Precedence table, a real --explain example, the move-your-state recipe,
merged privacy keys, the uninstall rule, the resolver-failure fix, and the
plugin-mode note (evidence gate: no official plugin distribution).
* W1b: template and resolver prose resolve state through guarded gstack-paths; ratchet (a)
Every gstack-paths eval in templates and resolvers carries the fail-stop
guard; executable ~/.gstack paths in bash blocks (context recovery preamble,
eureka log, analytics, project artifacts, upgrade snooze, setup-gbrain lock,
retro snapshots, ship consent marker) use $GSTACK_STATE_ROOT, and the writer
prose that pairs with them points at the printed PROJECT_DIR / RETRO_FILE.
ship drops export GSTACK_STATE_ROOT. SKILL.md regenerated (claude + codex),
ship goldens re-pinned, parity and context-budget caps raised to the measured
sizes with notes. test/state-root-ratchet.test.ts enforces the rule with a
reasoned allowlist; W1 touchfile entries plus a superset golden.
* refactor: apply W1 state-root edits in W2/W3/W5-owned files; one moved-code touchfile golden for all workstreams
* test: fold the moved-code touchfile golden into touchfiles.test.ts; fix integration fixture closure and caps
* v1.91.11.0: CHANGELOG, TODOS, docs and conventions for the refactor wave
* test: re-measure plan-ceo/design-consultation caps and ship goldens after the guarded plan-discovery and spec-review blocks; add the state-root twin to the workflow-boundaries fixture
* fix(windows): migrations resolve their directory with either path separator; state-root parity compares under the HOME Git Bash actually sees
* fix(review,ship): state plan-check timing after smoke expiry and test_stub Skip semantics (review workflow judge clarity)
* test(qa-eval): webhook fix eval asks for the fix loop's post-repair probes; eight-scenario coverage stays in the report-only case and the harness recheck
* test(qa-eval): re-pin the webhook prompt contract to the fix-loop stage; R29 coverage omissions stay bound by the report-only case
* fix(review,ship): plan checks publish a checkpoint before each probe; only the smoke expiry stop is skipped
* fix(qa): carry #2999's checkpoint receipt link, report-template line and full-revision placeholder (identical hunks)
* test(qa-callers): disable git auto maintenance in the caller fixture
Git 2.47+ runs auto maintenance detached after commit; on the CI runner's git
2.55 it rewrote .git/objects fan-out directories while the write observer was
running, which surfaced as unauthorized mutations. Same gc.auto=0 /
maintenance.auto=false guard the shared-libs fixture already uses.
* test(plan-mode-no-op): require prose evidence for the prose-fallback members so a spinner-frame judge verdict cannot end the run as asked
* test(ship-docsync): carry #2999's seeded-attempt docsync harness (identical files)
The doc-sync fault cases replayed attempt 1 before reaching their gate and ran
out of their 285s budget. The fixture now seeds attempt 1 and the parent starts
at the gate under test. Taken byte-identical from origin/capy/audit-fix-wave
(fb526898, e6ac813d, 6ce10ff7, d0c53577, 77cce3be). Local: stale-before,
recovery and late-result 6/6 PASS (97-164s); the whole file 12/12 PASS.
materialize requires an old-snapshot row to be classified superseded, and its verdict kept every
superseded row open, so rerunning the probe (what its own error tells the model to do) could never
reach pass; late-input reran 3 and 9 on the new snapshot and still got inconclusive. A superseded
row now closes only when a non-superseded row with the same captured argv observed the current
snapshot. Re-materializing an already-published evidence.json names the cause instead of failing
generically.
capture R NNN [--public] (--deadline D|--timeout-ms MS) --after PREV --hypothesis 'TEXT' -- CMD
publishes exploration-NNN.json {observationCapture, observationArgv, observed, hypothesis,
nextCapture, nextArgv} before running CMD, refusing unless PREV is the latest complete capture.
The receipt carries checkpoint/checkpointSha256; validators bind the note to the transcript's
capture calls by capture ID and receipt hash instead of exact command strings. The separate
checkpoint command and the capture guard keep working; materialize learning accepts both note
shapes and still rejects same-probe replays. Prose and eval fixture prompts teach the merged form.
PR lane 36794871032: the case timed out at its 120 s budget after 7 turns
(previous lane passed in 45 s). The session read the 46 KB extracted SKILL in
three passes (cat to persisted output, grep, sed), ran its own git reads,
wrote a 74-line report, then inspected and ran gstack-learnings-log and
rewrote the report's Learnings section. As in the Step 4.5 cases
(17ee2e54/2bd4651c), the fixture now stages only
review/sections/plan-completion.md, hands the session the recorded
git log and diff, declares the HIGH-impact question, its Scope Check,
learnings logging and later steps outside the capture, and caps the report
at the audit block and its DISCREPANCY entries (30 lines). The NOT DONE and
email assertions are unchanged.
PR lane 36794871032: every behavioral check passed except noInstallOrOverride,
which matched "no `npx impeccable`" inside the quoted heredoc that wrote
detector-output.md. Nothing was installed or downloaded. The check now drops
quoted-delimiter heredoc bodies (literal data) before matching; unquoted
bodies, which can expand $(...), and unterminated bodies stay checked. Free
controls cover the captured write, bare npx, an IMPECCABLE_BIN override, an
unquoted $(npx ...), npx after the delimiter and an unterminated body.
PR lane 36794871032: the DX floor asked its D1 narrative confirmation
(Accurate, proceed / Partly wrong, correct it / Way off, actual is...). The
deterministic setup rule accepted only 'Some ... wrong', so the question went
to the LLM assessor, which hit its 30 s spawnSync cap (ETIMEDOUT) and ended
the case as assessment_error at 141 s, the same failure as census
36641820398. The rule now accepts 'partly' beside 'some'; the captured
question is a free regression and the remedy-option controls still go to
the assessor.
PR lane 36794871032 (head 20d6e98f): the CEO floor ran 608 s without a
question. Its Step 0 recorded the premise gap and approach choice as
unresolved ledger rows, then said "this session supplies all answers up
front, so no decision brief was dispatched" and wrote Sections 1-11.
2734e203 stopped scope preservation from approving the premise; this time
the actor block (declined setup, recall, outside voices, HOLD SCOPE) and the
fixture's "complete user request is available from the start" were read
as pre-answering every review question. The CEO actor now states that the
request answers only the routing, recall, outside-reviewer and review-mode
questions it names.
Told "under 150 words", the ship judge's reasoning landed at 130-156 words
(3 of 18 probe samples at 152-156), so the structured-response check failed
about one panel in three independent of effort. The prompt's frontier block
and the response schema description now say under 120 words; the validator
still rejects 150 words or more. The changed prompt bytes reach only the two
frontier judges: ship/SKILL.md workflow (prompt and schema) and
review/SKILL.md workflow (prompt).
claude-fable-5-1 accepts only adaptive thinking (thinking.type.enabled with
budget_tokens returns 400), so effort is the available thinking control.
Measured on the exact ship judge request (105,301 input tokens):
- default effort, 18 samples: thinking 5,086-10,881 tokens, 75.9-144.7 s;
3 of 18 passed the 120 s deadline (about 42% of 3-sample panels).
- medium effort, 18 samples: thinking 2,749-5,762, output at most 6,144
tokens, 43.1-77.9 s; scores 4/4/4 in 16 of 18 (clarity 3 in two), versus
14 of 18 at default.
callJudge gains an effort option sent as output_config.effort; only the ship
judge sets it. Rubric, floors, panel size, deadline, model and max_tokens are
unchanged. The cache identity records effort.
Approved by Garry: the helper, not the model, decides whether evidence can
pass. materialize writes verdict {status, open} into evidence.json and prints
it: fail or blocked from row classifications, inconclusive while any row is
superseded, a complete capture is withheld, a declared required probe is
unrun or there is no evidence, else pass. The caller fixture requires
receipt.status to equal that verdict. CI late-input kept reporting pass with a
superseded happy probe.
With the prose fallback forced, the gate renders as a lettered menu; a judge
'waiting' verdict on a spinner-only frame ended the run as 'asked' before the
menu rendered, so the scope-gate check failed on unchanged behavior.
At 6fcb0981 plan-design-review-plan-mode timed out at 300 s (9 turns): 22 cat/sed
chunk reads (~50 s), then a 28 KB plan Write (~150 s), before the read-back
finished. The 9a7a7e54 pass took 240 s with a 24.6 KB Write. Read SKILL.md,
review-sections.md and plan.md natively in one response, keep additions under
14,000 characters and the summary within ten lines. Budgets unchanged.
The 6fcb0981 census failed hasStaleFillRaceFinding (line 98), but the case
records nothing beyond junit, so the report the detector judged is gone.
Return the SkillTestResult from captureSectionReads and record it, with the
full saved report, through the eval collector on pass and fail.
The census unknown actor wrote 'nothing about read, search, or write capability
is confirmed either way' after a YELLOW/WARN verdict. The claim window started
at 'write', so the leading 'nothing' was outside it. Check the clause subject for
nothing/neither/none/no; keep the original in-claim negations. Replay of the
captured output passes; positive controls still flag an unnegated claim.
- CI launch-failure retried after the seeded attempt 1 as if that attempt were
the fixture's; the seeded prompt now says attempt 1 is this invocation's and
a further attempt needs what Blocked recovery requires.
- A late-result run typo'd the state path once (ENOENT, the actor never ran),
then repeated the call correctly; the per-action count compared both calls
with one actor event. Only calls naming the real state file are counted.
qa-only judges cited 'next section' pointing at the wrong heading, an exploratory
trigger that contradicted its read point, clock ownership in mixed runs and the
unstated order of exploratory section 4 vs reporting. The qa judge penalized the
absent qa-report-template and issue-taxonomy that qa-patterns loads; with them
in, it found issue-taxonomy's dangling 'rule 13' (the consent rule is browser rule 3).
Census 36776104571's question preserved the contract ('behaving exactly like the
scheduler', 'scheduler parity holds by construction') and excluded work with
'Existing copies and helper hardening stay unchanged'. Accept exactly/parity as
preservation (negated forms refuse) and a bare noun list that stays unchanged as
an exclusion for the expansion scan only; verb-led clauses still refuse.
The output template had no rule-id slot, so rows merged with checklist items
dropped the detector id (census t2, local t1). Rows now carry [rule-id]. The
fake engine's sample rows named a foreign fixture path at line 0; the e2e remaps
them to landing.html/styles.css so trials stop spending turns reconciling it.
Census trials 1-2 captured complete Phase 4 forks (A) Server-side B) Client-side
C) Hybrid, recommendation with because) whose prose used none of the vocabulary
words. Accept two seeded shapes as outer options as Phase 4 specificity; the
earlier-phase, nested, fenced and single-shape controls still fail.
Census 36776104571 plan-eng capture read both owned files with cat -n in one
successful && chain; the caption 'echo "=== git diff main --stat ==="' fell
outside the two-token caption grammar, so both reads lost credit. Accept a fenced
caption of plain words; unfenced command strings, expansions, redirection,
-e escapes and ; / || tails stay rejected.
CI late-input spent a turn rewriting limits as an array after materialize
refused a string, and a ten-read sweep hunting for the changed input before it
read reports/HANDOFF.md, then timed out at 300 s.
windows-free-tests failed on 9a7a7e54: the 150 ms shared deadline raced Bun
startup on Windows, so the child was killed mid-write and the spool held a
partial payload. Only the never-released extra stream should time out; the
child now has 3 s.
review-army-consensus (periodic) timed out in 2 of 13 census sessions; passing
runs took 213-297 s of 300. Like N+1 it spent ~30-50 s reading the whole
extracted SKILL, checklist and every specialist file, sometimes dispatched an
unrequested Maintainability specialist, then ran a Red Team (60-70 s) and a
second merge before writing a 9-15 KB report.
The N+1 staging and scope text move into stageReviewArmySession /
reviewArmyScope / reviewArmyChecklists (the N+1 prompt renders byte-identical).
Consensus now records its detect-scope, stats, learnings and diff, stages the
Review Army section with the security and testing checklists, forces
--security --testing, and caps the report like N+1. Its Red Team is outside
the multi-specialist contract, so the fixture supplies a labeled synthetic
NO FINDINGS result instead of a dispatch. The existing SQL-finding and
browser-error assertions are unchanged; the lifecycle adapter's spawnSync now
returns the git output the staging reads.
review-army-perf-n-plus-one timed out in 7 of 13 CI runs on this branch (passing
245-280 s of 300). Each session spent ~95 s on setup (the full extracted SKILL,
checklist, section greps, exploratory.md, diff-scope/stats/learnings, tooling
checks), ran Step 4's core pass, a search-before-recommending WebSearch, and
wrote a 10-16 KB report (~100 s after the Red Team returned).
The fixture now stages only review/sections/review-army.md plus the performance
and red-team checklists, and hands the session the recorded detect-scope,
specialist-stats and learnings outputs and the diff. The caller passes
--performance (every CI parent already treated the prompt as that force flag
against the <50-line skip), declares the core pass, QA, adversarial review, web
research, Fix-First and persistence out of scope, and caps the report at the
selection line, the SPECIALIST REVIEW block and the Red Team result (30 lines).
The Performance specialist and the conditional Red Team are still real
foreground subagents, and the report still has to surface the N+1.
New assertion: a foreground Performance specialist dispatch precedes the Red
Team dispatch. Free controls omit the Performance dispatch or background it, and
both fail; the budget lifecycle adapter supplies the current result shape.
Touchfiles now include the .rb fixture the case reads.
GSTACK_QA_REQUIRED_PROBES (a JSON array of native child commands) makes every
capture print requiredRemaining; it never judges pass or fail. The functional
eval passes the webhook list from QA_WEBHOOK_REQUIRED_SCENARIOS, which the
verdict now reads too, so the nudge and the verdict share one source (agreed
with #3002's owner). CI webhook-report kept stopping with scenarios unrun.
A CI webhook-fix run spent three turns reading lib/qa-evidence.ts to learn the
interface and timed out just before materialize (agreed with #3002's owner).
When native probe output declares a top-level input snapshot, materialize
compares each evidence row with the latest capture's snapshot and refuses
stale rows unless they are classified superseded, naming the captures to
rerun. ship-exploratory-late-input kept reporting a pre-change adverse probe
green after the input changed.
garrytan