Bounded Chunk Path

For a supported first-run, pinned-base text scope, the scoped evidence contract provides source-bound component reviews and independent interaction-inventory audits without requiring every pair's full union. Use that route only when its stated pre-dispatch and final checks pass. The schema-1 exhaustive route below remains available for its supported cases, including continuations; never present an unsupported scoped case as clean.

Use chunk_diff.py plan --repository <root> --out <coordinator-run>/chunks --goal <goal> --specification <criteria> --done-when <condition> [--scope-path <requested-path> ...] [--scope-mode changed|all] --budget-bytes <route-budget> after reading its --help. For remediation continuing an earlier authenticated run, also pass --caller-run <earlier-run> --prior-ledger <earlier-run>/loop-ledger.json --prior-coverage <coverage.json>; the coverage list assigns every final-round signature to source_paths, one review_kind (chunk, interaction, or group), and sorted chunk_ids. Retain the original validated reviewer receipt and select source paths that include the implementation, validator, next consumer, and relevant tests for each defect. The planner copies and hashes the earlier ledger and appends its canonical signature, tier, structural flag, evidence, and declared source-path block to the specification; use the resulting manifest request for the coordinator and every child. The checker rereads the declared caller run ledger and compares its exact bytes with the copy. The schema-1 manifest declares first-run or continuation origin; a declared continuation cannot omit prior ledger and coverage, and candidate and final coordinator results must copy the exact origin into metadata.challenge_origin. The copied ledger's structural validity does not reauthenticate historical reviewer provenance. Without an authenticated earlier ledger or defensible source assignment, stop the prior-finding closure claim. For a first review, pass the same exact nonblank request fields to coordinator and children. Select changed for a diff or all for a whole requested file or plugin scope; omitting --scope-path selects the repository. Choose a conservative budget for source JSON plus patch while reserving room for role card, instructions, and output; a plan measures input, not reviewer comprehension or host capacity. The helper inventories selected tracked, deleted, and non-ignored untracked files, writes exact source and supporting diff bytes per whole-file chunk, and records disjoint coverage in chunks.json. Never choose files or examples from a previous task. An oversized single file remains an explicit chunk; attempt a permitted route for it and continue independent chunks even if it needs separate remediation.

Before paid dispatch, estimate each planned context's source, diff, supporting source, role card, request and output budget; record the chunk count, projected page reads when known, and the number of pair decisions n * (n - 1) / 2. Pair decisions are not necessarily separate runs: one admitted union can cover several. An estimate is not evidence of admission or a universal host limit. Run the no-model plan and applicable route preflights before dispatch; do not spend a paid turn on an input already known to be unadmitted. Preserve the failed evidence and use a supported, admitted plan with the same required coverage, or leave that coverage unreviewed and keep the overall clean claim blocked.

Before adopting a different challenge route, compare its behavior and affected existing tests with the current route, including source and interaction coverage, prior findings, provenance, and recovery. Record new failures or lost coverage and resolve them before completion; a requirement change needs the user's explicit decision, reusing any applicable decision already given. Never describe an unimplemented or unvalidated route as an available replacement.

Run chunk_diff.py check --manifest <coordinator-run>/chunks/chunks.json before dispatch. Treat chunking as an internal division of the already authorized scope: no new scope approval is needed when the union equals the original request and no excluded file is added. Create separate ordinary challenge-resolve runs under the coordinator's chunks/runs/ root. When runtime capacity and route rules permit, dispatch independent disjoint chunks in parallel against the same frozen snapshot; otherwise run them sequentially. Gather the initial independent challenge for every admitted chunk and known interaction before changing source when the route and authority permit; then triage the union and assign fixes. Each run receives its chunk's complete source JSON and diff, relevant unchanged callers/consumers, the same specification in a schema-2 loop-evidence.request, and an independent Code Review challenger. The unchanged-scope strictly decreasing integer-score rule, progress timing, action ledger, reviewer provenance, recurrence, stricter caller budgets, gates, and result validation apply to each run; chunk count does not reset any run's obligations. The coordinator parent owns edits and every solver dispatch: child chunk runs stop after triage and return their findings and loop-actions.json without dispatching solvers. Serialize source changes and acceptance; pause dispatch while source changes, then replan, recheck, and independently review every affected final chunk and interaction. Reuse only evidence that remains valid for the final source, request, supporting context, and coverage; do not reuse stale child results.

After all child runs, assess every unordered pair of chunks for changed interfaces, producers/consumers, shared state, and other material interactions. Record reviewed for a material interaction or no-interaction with concrete source-based rationale. Also declare each known material interaction spanning three or more chunks as a group. Each pair decision and declared group needs an ordinary independent challenge-resolve run whose frozen scope contains every file in every member chunk, including files the parent considers unrelated. One run may assess several decisions and groups when it admits their complete union; separate runs may cover smaller unions. A child result, summary-only context, parent-only reconciliation, or one file per chunk cannot substitute. Send each assigned decision, its chunk IDs and exact rationale in the run's request.specification as Interaction assessment: followed by a newline and json.dumps(decisions, sort_keys=True, ensure_ascii=True), where decisions are ordered pair entries followed by group entries, each containing chunk_ids, decision, and evidence. Ask the challenger to examine whether the decisions are correct and whether additional multi-chunk groups are material; any identified omission is a finding and requires a new declared group and fresh review. The parent owns semantic judgment; no checker can prove an undeclared interaction absent. If complete input cannot be admitted or plausible higher-order interactions remain unassessed, keep overall clean blocked. Resolve findings through the parent, then replan and rerun affected current-source reviews.

Write chunks/results.json as {"schema_version":1,"chunks":[{"id":"chunk-001","result_path":"runs/challenge-resolve/<child-run>/result.json"}],"interactions":[{"chunk_ids":["chunk-001","chunk-002"],"decision":"reviewed","evidence":"specific interface and why these chunks interact","result_path":"runs/challenge-resolve/<interaction-run>/result.json"}],"groups":[{"chunk_ids":["chunk-001","chunk-002","chunk-003"],"evidence":"specific three-chunk contract","result_path":"runs/challenge-resolve/<group-run>/result.json"}]} with one ordered child entry per planned chunk, one ordered decision per chunk pair, and sorted unique group entries of three or more chunk IDs. Use groups: [] when no group is declared. A no-interaction pair retains its result_path and an evidence rationale so an independent challenger assesses it. The checker binds each child request to the exact coordinator goal, specification, and done_when; an interaction request keeps the same goal and done_when and appends exactly the canonical assessment block to the coordinator specification. It also binds each interaction run to the exact union of complete member chunks, then revalidates the ordinary clean result. Run chunk_diff.py check --manifest <coordinator-run>/chunks/chunks.json --results <coordinator-run>/chunks/results.json; it checks current source, disjoint inventory coverage, complete pair decisions, declared groups, request delivery, source/diff binding, clean loop status, and artifact validation. Set new coordinator candidate metadata to "challenge_scope":{"mode":"chunked","manifest_path":"chunks/chunks.json","results_path":"chunks/results.json"}; the final result validator reruns this check. A missing decision, stale or unadmitted assessment, or non-clean run keeps the overall request open. Reconcile interfaces and producer/consumer behavior across chunks with source context and relevant project gates; an omitted group remains a semantic limit even when the checker passes. Parallel independent read passes require immutable source for every run and serialized fixes and acceptance.

For a stopped coordinator with at least one validated child or interaction result and pending or non-clean work, use the separate schema-1 partial chunks/results.json map with the same chunks, interactions, and groups lists. Include every completed run's result path; omit pending chunk entries, and use null result paths for declared pending interactions or groups. Run chunk_diff.py check-stopped --manifest <coordinator-run>/chunks/chunks.json --results <coordinator-run>/chunks/results.json --summary; copy its exact status: stopped summary, validated run score series and decisions, pending_chunks, pending_interactions, pending_groups, and pending_prior_signatures lists into metadata.chunked_review. An assigned earlier signature absent from an authenticated supplied reviewer result stays pending even when all supplied child runs are otherwise clean. The result validator reruns this stopped check and accepts only a failed coordinator and failed review gate. This path records a truthful partial stop; it never satisfies the schema-1 manifest clean coverage check. With no validated child or interaction result, retain the ordinary no-independent-review stop and do not invent a child-backed summary. Chunk manifest version 1 is required for source, complete, and stopped checks; changing the version cannot bypass continuation obligations.

In chunk mode, each child and interaction run produces its ordinary validated result.json and final.md; the coordinator reports those results and the coverage check without fabricating a combined W score or a full-scope reviewer receipt. Do not call the original request clean until every child, pair assessment, and declared group run is independently clean on current source, the parent has examined all interaction rationales and possible undeclared groups, the results check passes, cross-chunk behavior has evidence, and normal project gates pass. A passed checker establishes coverage of declared decisions and groups, not mathematical proof that no other group exists. The coordinator's summary names any remaining decision, group, or semantic coverage limit and its exact stop reason. No run result substitutes for a caller's separate completion gate.

When chunking resumes an earlier validated review loop, retain that loop's score series and finding signatures as historical evidence. Before dispatch, use the schema-1 plan's prior coverage assignment; inspect each assigned run's frozen primary and supporting source and run its no-model input preflight to confirm the declared paths and prior-evidence block are present. check --results rejects a clean coordinator unless the assigned authenticated current reviewer returns each exact prior signature with its original tier and structural flag as verified-fixed or rejected and its declared source paths were delivered. The declaration is supplied by the caller, so an undeclared or false caller history remains outside local artifact proof. A path list cannot prove all semantic dependencies were chosen; missing or uncertain source stays unassessed and blocks closure. Each chunk has its own local round index, so introduce every child progress table with its chunk ID and the earlier run's score series; never show an unqualified Iteration 1 that appears to reset the original loop. Keep a coordinator cross-run-history.md with one chronological row per validated original, child, and interaction review: identify the run and local round, source scope, retained ledger, six severity counts and weighted score as old + new, where old means the same underlying defect appeared in any earlier validated row across these runs. Preserve verified-fixed, rejected, and unassessed earlier signatures in that history even though they add zero to an inspected chunk's score. Do not convert an unassessed signature into an open finding merely because its validating module was omitted. This comparison describes finding recurrence across different scopes; it is not a combined score, a convergence ratio, or an overall verdict. Report both the local checker table and the cross-run comparison, with their different old definitions stated beside them. A rejected receipt stays advisory and never becomes a history row. A stopped parent loop retains its stop and prior-finding obligations until a complete current-source review of those obligations validates their disposition; new chunk baselines do not reset its stop, score or recurrence history.