okstra 0.223.2 → 0.224.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.223.2",
+  "version": "0.224.0",
   "description": "Host-aware multi-provider cross-verification orchestrator runtime and agent skills.",
   "license": "MIT",
   "author": "devonshin",

package/runtime/BUILD.json

@@ -1,5 +1,5 @@
 {
-  "package": "0.223.2",
-  "builtAt": "2026-10-22T08:47:32.015Z",
+  "package": "0.224.0",
+  "builtAt": "2026-10-23T03:44:32.161Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

package/runtime/prompts/coding-preflight/clean-code.md

@@ -20,7 +20,7 @@ Good:
 const sum = (arr) => arr.reduce((acc, x) => acc + x, 0);
 ```
 
-Caveat: do not extract until the duplication is real (rule of three). Premature abstraction is also a code smell.
+Caveat: do not extract until the duplication is real (rule of three). Premature abstraction is also a code smell. The caveat does not cover a literal copy: a new block byte-identical to one already in the repository — test helpers included — reuses or moves the existing one.
 
 Two more forms of duplication that hide from symbol-level grep:
 
@@ -325,6 +325,13 @@ For every source file this change touches, follow the paths the change creates o
 - **concurrent** — something else is still writing, or the deadline fired and the work did not stop.
 - **selection** — when several candidates fail, which one's evidence survives.
 
+The failures the plan names are where the trace starts, not where it stops. Two orderings produce most error-path defects:
+
+- **cleanup registered after a call that can throw** — inside a `try` whose `catch` / `finally` cleans up, the object to clean up must be registered before any call that can throw: a property write, a read, a call that starts other work whose completion the cleanup must wait for. Registered after it, the failure leaves the object behind or lets the cleanup run before that work settles.
+- **order changed by a move** — when the change moves or restructures existing code, compare the order of throwing calls and cleanup registration with the base version; a refactor that swaps them is a behaviour change.
+
+A failure the test fakes cannot produce is not covered by a passing test. Name it as unverified rather than calling the path clean.
+
 **A finding names the input or state that produces the wrong result.** *"If the archive yields no entries, line 42 reports success and stores an empty result"* is a finding. Code that works as written is `clean`, however you would have written it differently: alternative structures, guards for states no caller can reach, extra tests for covered paths, and "consider extracting / renaming / memoizing" are improvements, not findings. A real failure that is small and cheap to fix is still a finding.
 
 ## Untrusted input and security

package/runtime/python/okstra_ctl/incremental_carry.py

@@ -13,12 +13,13 @@ from .convergence_store import write_json_atomic
 from .final_report_schema import load_schema_version
 from .report_narrative import parse_narrative, writer_owned_data
 from .json_boundary import load_owned_object
+from .plan_item_evidence import dependency_scopes, reusable_item_ids
 from .plan_items import (
     PlanItemContractError,
     content_hash,
+    dispatch_item_ids,
     extract_plan_items,
     planning_stage_ledger,
-    reverify_item_ids,
 )
 
 
@@ -386,7 +387,6 @@ def _carry_unchanged_checklists(
 
 def _recompute_dispatch_queue(
     narrative: Mapping[str, Any],
-    state_items: dict[str, dict],
     stage_ledger: Mapping[str, Any] | None = None,
 ) -> list[str]:
     """이월 뒤 남은 디스패치 큐.
@@ -401,18 +401,6 @@ def _recompute_dispatch_queue(
         extracted = extract_plan_items(_planning(dict(narrative)))
     except (CarryError, PlanItemContractError, KeyError, TypeError):
         return []
-    by_id = {
-        item["id"]: item
-        for item in extracted
-        if isinstance(item.get("id"), str)
-    }
-    previous_hashes = {
-        item_id: content_hash(by_id[item_id])
-        for item_id, row in state_items.items()
-        if row.get("carriedForwardFromSeq") and item_id in by_id
-    }
-    if not previous_hashes:
-        return []
     ledger = planning_stage_ledger(
         _planning(dict(narrative)),
         {
@@ -420,7 +408,7 @@ def _recompute_dispatch_queue(
             for stage, status in (stage_ledger or {}).items()
         },
     )
-    return reverify_item_ids(extracted, previous_hashes, ledger)
+    return dispatch_item_ids(extracted, ledger)
 
 
 def _writer_stage_rows(data: Mapping[str, Any], *, snapshot: str) -> dict[int, dict]:
@@ -495,7 +483,7 @@ def merge_v3_plan_state(
         state_items[item_id] for item_id in sorted(state_items)
     ]
     queue = _recompute_dispatch_queue(
-        narrative, state_items, pbv.get("stageLedger"),
+        narrative, pbv.get("stageLedger"),
     )
     if queue:
         pbv["dispatchQueue"] = queue
@@ -533,6 +521,12 @@ def sync_prepared_dispatch_queue(state_path: Path, merged: Mapping[str, Any]) ->
     if not isinstance(envelope, dict):
         return
     envelope["dispatchQueue"] = queue
+    inputs = envelope.get("reviewInputs")
+    if isinstance(inputs, dict):
+        rows = merged.get("planBodyVerification", {}).get("planItems", [])
+        inputs["dependencies"] = dependency_scopes(rows)
+        inputs["priorReviewHashes"] = {str(row["id"]): str(row.get("verifiedReviewHash", "")) for row in rows}
+        envelope["reusedItems"] = sorted(reusable_item_ids(rows, inputs) - set(queue))
     write_json_atomic(prepared, envelope)
 
 

package/runtime/python/okstra_ctl/phases/final_verification/profile.md

@@ -14,7 +14,7 @@
     - no new defects introduced — the diff does not break previously-working behaviour and adds no new bug (logic/off-by-one, null/empty handling, resource leaks, broken error paths)
     - no security defect on input from outside the process — for every changed file that reads a request body, query, header, upload, message or webhook, or acts on its behalf: work that grows faster than the input (pairwise uniqueness, nested scans, a backtracking regex, input-driven recursion) runs only after a size/count bound has rejected oversized input — check the validation framework's configuration, since class-validator without `stopAtFirstError` still runs `@ArrayUnique` after `@ArrayMaxSize` fails and a byte-size body limit does not bound element count; input reaches SQL, shell commands, file paths, server-side fetch targets, templates and regexes only through parameters, allowlists or escaping; a new route / handler / resolver carries the project's auth guard and compares the caller with the owner of an input-chosen id; no secret, full token, password or personal data reaches source, logs, error messages or responses; nothing evaluates or unsafely deserializes input. Each hit is an Acceptance Blocker citing the triggering input and its effect. The same rules, with examples, are `clean-code.md` "Untrusted input and security" in the installed coding-preflight pack (`~/.okstra/prompts/coding-preflight/clean-code.md`).
     - scope conformance — the delivered diff stays within the approved plan's scope; flag out-of-scope edits, unrelated file changes, leftover debug/commented-out code, and unintended deletions
-    - project review-rule packs — a pack applies when either source names it: the task brief's `Source Material` / `Reporter Confirmations` cites its exact `SKILL.md` path, or `<PROJECT_ROOT>/.okstra/project.json` lists it under `reviewRulePacks` (the project's standing standard, applying whether or not the brief mentions it). The two sources are a union. Read only those files and the `references/*.md` files they directly name. Do not search parent directories or host skill catalogs. Apply the rules as an acceptance overlay (record `project-review-rules: <paths read>`, `project-review-rules: declared <path> unreadable`, or `project-review-rules: none declared or cited`). This is a static review pass, not a PR-comment workflow — do NOT dispatch reviewer subagents. Because this phase verifies the **whole-task merged diff**, it is the gate that catches **cross-stage findings a per-stage `implementation` verifier structurally cannot see** (each implementation run reviews only its own stage diff): most importantly two cross-stage conditions: (a) the same helper stack / transform / domain rule duplicated across stages or services — byte-identical duplication is always an Acceptance Blocker, and semantically-equivalent transforms across services are blockers unless the approved plan explicitly justified keeping them separate; (b) an API newly orphaned because its only caller was removed in a different stage. A confirmed cross-stage duplication of this kind is an Acceptance Blocker (`major`+) that cites every `path:line` location and names the shared-module location to converge on. (Single-stage scope sees only one stage, so it cannot raise cross-stage findings — note that limitation rather than implying coverage.)
+    - project review-rule packs — a pack applies when either source names it: the task brief's `Source Material` / `Reporter Confirmations` cites its exact `SKILL.md` path, or `<PROJECT_ROOT>/.okstra/project.json` lists it under `reviewRulePacks` (the project's standing standard, applying whether or not the brief mentions it). The two sources are a union. Read only those files and the `references/*.md` files they directly name. Do not search parent directories or host skill catalogs. Apply the rules as an acceptance overlay (record `project-review-rules: <paths read>`, `project-review-rules: declared <path> unreadable`, or `project-review-rules: none declared or cited`). This is a static review pass, not a PR-comment workflow — do NOT dispatch reviewer subagents. Because this phase verifies the **whole-task merged diff**, it is the gate that catches **cross-stage findings a per-stage `implementation` verifier can miss** (each implementation run reviews only its own stage diff; it compares new blocks with code already on its base, but not with stages that land after it): most importantly two cross-stage conditions: (a) the same helper stack / transform / domain rule duplicated across stages or services, test helpers and test support code included — byte-identical duplication is always an Acceptance Blocker, and semantically-equivalent transforms across services are blockers unless the approved plan explicitly justified keeping them separate; (b) an API newly orphaned because its only caller was removed in a different stage. A confirmed cross-stage duplication of this kind is an Acceptance Blocker (`major`+) that cites every `path:line` location and names the shared-module location to converge on. (Single-stage scope sees only one stage, so it cannot raise cross-stage findings — note that limitation rather than implying coverage.)
   - Residual-tracked — note as Residual Risk unless severe enough to block:
     - unresolved edge cases
     - regression risk in adjacent code paths not directly changed

package/runtime/python/okstra_ctl/phases/implementation/instructions/_implementation-diff-review.md

@@ -38,7 +38,7 @@ Do not scan holistically and stop when it "looks fine". Work the matrix exhausti
    - port / adapter / domain file, when the hexagonal overlay is loaded → `architectures/hexagonal.md`: no business logic in a port body, adapter methods are I/O only (no post-fetch filtering on domain state, no `findValid*`/`findActive*` names hiding a rule), domain objects declared under the domain boundary, no changed domain file importing an ORM / framework / adapter / service (read the import list — mechanical), and a service dependency you add or modify goes through a port rather than a concrete adapter (advisory only while the project has not declared `architecture.style = hexagonal` in `.okstra/project.json` — record it with the port sketch; blocking under that declaration, so fix it in place before the commit rather than record-and-pass, exactly as `_implementation-verifier.md` re-grades this same diff. Either way, the codebase already injecting concrete classes is the debt this pays down, not a reason to skip it).
    - a service file, when the hexagonal overlay is loaded → `architectures/hexagonal.md` Rule H6: a decision this diff puts in a service — an `if`/`else` chain over domain fields, a business formula, a private method named for a domain concept — belongs in a domain function. Orchestration control flow, DTO mapping and calling a domain predicate are not violations.
    - a file that reads input from outside the process (request body, query, header, upload, message, webhook) or acts on its behalf → `clean-code.md` "Untrusted input and security": a size/count bound rejects oversized input before any check that grows faster than the input (a validator that runs every rule, such as class-validator without `stopAtFirstError`, does not stop at a failed `@ArrayMaxSize`), input reaches SQL / shell / paths / server-side fetches / templates / regexes only through parameters, allowlists or escaping, a new entry point carries the auth guard and compares the caller with the owner of an input-chosen id, no secret or personal data reaches code, logs or responses, and nothing evaluates or unsafely deserializes input.
-   - every changed source file → `clean-code.md` "Trace what this change can do wrong": walk the error, partial, concurrent and selection paths this diff creates to their end and fix wherever a wrong result comes out. Name the input that produces it — if you cannot name one, there is nothing to fix here and you move on rather than restructuring code that works.
+   - every changed source file → `clean-code.md` "Trace what this change can do wrong": walk the error, partial, concurrent and selection paths this diff creates to their end — past the failures the plan lists, and including where a cleaning `try` registers its cleanup target relative to each call that can throw — and fix wherever a wrong result comes out. Name the input that produces it — if you cannot name one, there is nothing to fix here and you move on rather than restructuring code that works.
    A file can hold several roles — apply every rule set that fits it.
 3. **Decide clean-or-finding for each cell.** Read the full file when a rule needs context (never judge a port/adapter/domain or a naming rule from the hunk alone).
 4. **Fix each finding in place** before the commit. When a readability finding is real, the fix is a named helper or named intermediate value — sketch the cleaner shape (a few lines) in your audit note, then apply it. When the fix is genuinely out of this stage's scope, record it as an `Out-of-plan` note instead of silently leaving it.

package/runtime/python/okstra_ctl/phases/implementation/instructions/_implementation-verifier.md

@@ -194,12 +194,12 @@ Re-running commands proves the diff *builds and passes*; it does NOT prove the d
 - **Declared architecture style promotes the placement overlay from advisory to binding.** Take `Architecture style` from that projection and record `architecture-style: <hexagonal|layered|none>` in the worker result next to the `coding-conventions:` line. A declared `hexagonal` counts the overlay as loaded even when none of the router's Stage 3 layout signals matched, so the **Hexagonal** blocking check below applies in full, and the concrete-adapter injection listed under Advisory findings is promoted to a blocking finding → verdict `FAIL`, not a `should-fix`. A declared `layered` has no pack resource; its binding invariant is direction — an upper layer may import a lower one, never the reverse — so a changed file whose import list reaches back up a layer, or around a layer boundary, is a blocking placement violation cited `path:line` from that import list. The `layered` half is worker judgement: no machine check reads layer names, so a missed reverse dependency is a missed finding, not a validator failure. A `none` or absent projected style leaves Stage 3 detection-driven and the placement items advisory. **Enforced:** `scripts/okstra_project/resolver.py` `resolve_architecture` reads the same stored field for the planning-side rule in `scripts/okstra_ctl/phases/implementation_planning/plan_body.py` `_validate_variation_point_analysis`, and `_validate_verifier_fail_blocks_verdict` keeps the resulting `FAIL` from being dropped during synthesis.
 - **Blocking checks (any hit → verdict `FAIL`, cited `path:line` + rule name, recommended fix recorded — the verifier does NOT apply it):**
   - **Security (every changed file that reads input from outside the process or acts on its behalf — `clean-code.md` "Untrusted input and security"):** work that grows faster than the input — pairwise uniqueness, nested scans, a backtracking regex, input-driven recursion — reachable before a size/count bound has rejected oversized input (read the validation framework's configuration: class-validator without `stopAtFirstError` still runs `@ArrayUnique` after `@ArrayMaxSize` fails, and a byte-size body limit does not bound element count); input concatenated into SQL, a shell command, a file path, a server-side fetch target, a template or a regex; a new route / handler / resolver without the project's auth guard, or a lookup by an input-chosen id that never compares the caller with the owner; a secret, full token, password or personal data written to source, logs, an error message or a response; `eval`, dynamic code, or unsafe deserialization applied to input. Cite the input that triggers it and its effect — for unbounded work, the input size and the measured or derived cost.
-  - **New duplication / DRY:** two or more newly added or meaningfully modified blocks implement the same helper stack, transform, or domain rule. Literal copy-paste is always blocking; semantically equivalent transforms across services are blocking unless the approved plan explicitly justified keeping them separate. Recommend the shared module location.
+  - **New duplication / DRY:** two or more newly added or meaningfully modified blocks implement the same helper stack, transform, or domain rule. Literal copy-paste is always blocking; semantically equivalent transforms across services are blocking unless the approved plan explicitly justified keeping them separate. The comparison is not limited to this diff: a newly added block that is byte-identical to a block already in the repository — base code, or a copy an earlier stage landed — is the same blocking finding, cited at both the new `path:line` and the existing one, because `final-verification` grades that cross-stage copy as an Acceptance Blocker and a per-stage `clean` only defers it. Test helpers and test support code count. Recommend the shared module location.
   - **Self-mocking:** a test for `Foo` stubs/spies a method on the `Foo` instance under test (`jest.spyOn(sut, ...)`, `spyOn(FooService.prototype, ...)` in `foo.*.spec.*`, `vi.mocked(sut)` + stub). Mocking injected collaborators is fine.
   - **Interaction-only assertion:** a test whose only/primary assertion is `toHaveBeenCalled*` / `toHaveBeenCalledTimes` on an internal helper or a non-side-effecting collaborator, with no assertion on the returned value / resulting state / persisted row / emitted event.
   - **Tautological delegation assertion:** a test asserts the SUT result equals a direct call to the same pure helper/collaborator that the SUT delegates to, instead of asserting an independent literal value or observable state.
   - **Untruthful name:** a read-named function (`get*` / `find*` / `load*`) that writes/inserts/mutates; an adapter or repository name encoding the caller's use-case (`*ForInit`) or hiding a domain rule (`findValid*` / `findActive*`).
-  - **Wrong-result trace (every changed source file):** follow the paths this diff creates or alters to their end — error, partial, concurrent, selection — and name the input or state that produces a wrong result (`clean-code.md` §"Trace what this change can do wrong"). This one is an obligation, not a pattern: the defects that reach production are usually ordinary code with no name on this list. The bar is also the noise filter — a finding names the failing input; an alternative structure, a guard for a state no caller reaches, or a "consider extracting" is an improvement and verdicts `clean`. **The unit is the changed source file**: record `clean` or findings for each one, list every file you excluded with its reason (lockfiles, generated code, pure config), and close the section with `general: <N> files — all verdicted, <M> excluded`.
+  - **Wrong-result trace (every changed source file):** follow the paths this diff creates or alters to their end — error, partial, concurrent, selection — and name the input or state that produces a wrong result (`clean-code.md` §"Trace what this change can do wrong"). This one is an obligation, not a pattern: the defects that reach production are usually ordinary code with no name on this list. The bar is also the noise filter — a finding names the failing input; an alternative structure, a guard for a state no caller reaches, or a "consider extracting" is an improvement and verdicts `clean`. The failure modes the plan lists are the floor of this trace, not its ceiling: a verdict scoped to "the modeled failures" is not a verdict on the file. For every `try` whose `catch` / `finally` cleans up, check at each call inside it that can throw (a property write, a read, a call that starts other work) whether the thing to clean up is already registered at that point; when the diff moves or restructures existing code, compare that order with the base version and cite the base `path:line` when it changed. A failure the test fakes cannot produce (a throwing setter or read the fake does not model) is recorded as unverified with the failure named, never folded into `clean`. **The unit is the changed source file**: record `clean` or findings for each one, list every file you excluded with its reason (lockfiles, generated code, pure config), and close the section with `general: <N> files — all verdicted, <M> excluded`.
   - **Business rules in an application service (only when the hexagonal overlay is loaded):** changed service code that decides a business outcome inline — an `if`/`else` chain over domain fields, a business formula in arithmetic, a private method named for a domain concept — instead of calling a domain function (`architectures/hexagonal.md` Rule H6). Orchestration control flow, DTO mapping, and calling a domain predicate are not violations. Blocking when the embedded rule is substantial: money, permissions, a state machine.
   - **Hexagonal (only when the overlay is loaded):** business logic inside a port body; an adapter method that is not pure I/O (post-fetch JS filtering on domain state, domain-rule evaluation); a domain object declared outside the `domain/` boundary; a changed file under the domain folder importing an ORM / DB layer, a framework or its DI decorators, or anything under adapters / infrastructure / services (read the import list — this verdict is mechanical, not a judgment). **The routed pack's project-convention latitude does not reach this cell.** `architectures/hexagonal.md` lets a documented convention resolve conflicts in the project's favour elsewhere in that overlay; here the import list decides, and "matches existing convention" is not an answer to it (see that file's §"How far a project convention reaches"). A run that resolved exactly this finding as project convention returned `clean` and the team's PR review flagged the same import.
   - **gitignored file committed to the branch:** any path in the `git diff --name-only <base>...HEAD` enumeration that `.gitignore` excludes — enumerate them by piping that list through `git check-ignore --stdin --no-index`. A committed ignored file means the executor bulk-added (`git add .`/`-A`) or force-staged (`git add -f`) it, leaking build output, scratch files, or verification artifacts into the eventual PR. This explicitly includes `.okstra/` paths (and `.project-docs/` when the legacy symlink is present): `.okstra/**` is gitignored, so a committed okstra file (qa scripts, conformance results) is always this defect. Cite each path; recommend `git rm --cached <path>` to untrack it while keeping the file on disk. Conformance/qa evidence belongs in the carry sidecar / verifier result, never in git history.

package/runtime/python/okstra_ctl/phases/implementation_planning/authoring.py

@@ -54,6 +54,14 @@ from okstra_ctl.plan_items import (
     with_response_format,
 )
 from okstra_ctl.paths import RunRef
+from okstra_ctl.plan_item_evidence import (
+    capture_review_inputs,
+    dependency_scopes,
+    reusable_item_ids,
+    review_fingerprint,
+    review_files_unchanged,
+)
+from okstra_ctl.plan_review_context import render_review_context
 from okstra_ctl.stage_ledger import build_stage_ledger
 from okstra_ctl.claim_reproduction import NOT_RUNNABLE, reproduce
 from okstra_ctl.final_report_schema import load_schema_version
@@ -118,13 +126,39 @@ def _queue_for(
     run_manifest: Path | None,
     previous_hashes: Mapping[str, str] | None = None,
     tied_ids: Sequence[str] | None = None,
+    previous_rows: Sequence[Mapping[str, Any]] = (),
+    review_inputs: Mapping[str, Any] | None = None,
 ) -> list[str]:
     ledger = _merged_ledger(planning, run_manifest)
     if tied_ids is not None:
         return tie_vote_item_ids(items, ledger, tied_ids)
+    inputs = review_inputs or _review_inputs(items, planning, run_manifest, previous_rows)
+    reusable = reusable_item_ids(previous_rows, inputs)
+    candidates = set(dispatch_item_ids(items, ledger))
     if previous_hashes:
-        return reverify_item_ids(items, previous_hashes, ledger)
-    return dispatch_item_ids(items, ledger)
+        candidates.update(reverify_item_ids(items, previous_hashes, ledger))
+    return [item["id"] for item in items if item["id"] in candidates - reusable]
+
+
+def _review_inputs(
+    items: list[dict[str, Any]], planning: Mapping[str, Any],
+    run_manifest: Path | None, rows: Sequence[Mapping[str, Any]],
+) -> dict[str, Any]:
+    if run_manifest is None:
+        return {}
+    authority = validated_run_authority(run_manifest)
+    return capture_review_inputs(items, planning, authority.payload, authority.project_root, rows)
+
+
+def _checked_review_inputs(run_manifest: Path | None) -> dict[str, Any]:
+    root = _probe_project_root(run_manifest)
+    if root is None:
+        return {}
+    path = _prepared_items_path(run_manifest)
+    inputs = _load_json_object(path).get("reviewInputs", {}) if path.is_file() else {}
+    if not review_files_unchanged(inputs, root):
+        raise PlanItemContractError("review evidence changed during dispatch; prepare and verify again")
+    return inputs
 
 
 def _queue_kwargs(args: argparse.Namespace) -> dict[str, Any]:
@@ -133,7 +167,9 @@ def _queue_kwargs(args: argparse.Namespace) -> dict[str, Any]:
         if state is None:
             raise PlanItemContractError("--tie-vote requires --state")
         return {"tied_ids": _tied_ids(state)}
-    return {"previous_hashes": _previous_hashes(getattr(args, "state", None))}
+    state = getattr(args, "state", None)
+    rows = _state_plan_body_items(_load_json_object(state), state) if state and state.is_file() else []
+    return {"previous_hashes": _previous_hashes(state), "previous_rows": rows}
 
 
 def _tied_ids(state_path: Path) -> list[str]:
@@ -170,8 +206,8 @@ def _parser() -> argparse.ArgumentParser:
     prepare.add_argument(
         "--state",
         type=Path,
-        help="previous plan-body state; when it carries verifiedContentHash "
-        "rows the dispatch queue shrinks to the self-fix reverify set, and "
+        help="previous plan-body state; only matching body and complete "
+        "evidence fingerprints shrink the self-fix reverify queue, and "
         "each queued item's recorded votes and selfFixNote are carried "
         "into the prompt as its `**Prior round dissent**` block",
     )
@@ -251,8 +287,8 @@ def _parser() -> argparse.ArgumentParser:
         "--prior-state",
         type=Path,
         help="the previous run's plan-body-verification-<task-type>-<seq>.json. "
-        "A newly seeded item whose contentHash still equals that run's "
-        "verifiedContentHash inherits its verdicts and is tagged "
+        "A newly seeded item with matching body and complete evidence "
+        "fingerprints inherits its verdicts and is tagged "
         "carriedForwardFromSeq, so round 1 does not re-judge text nobody "
         "changed. Requires --state, refuses a state file belonging to "
         "another task, and never carries on a matching id alone",
@@ -474,12 +510,21 @@ def _prepare(args: argparse.Namespace) -> dict[str, Any]:
                 + "; correct the narrative in this run, then retry plan-items prepare"
             )
     envelope = _envelope(source)
+    kwargs = _queue_kwargs(args)
+    envelope["reviewInputs"] = _review_inputs(
+        envelope["items"], _planning(source), args.run_manifest,
+        kwargs.get("previous_rows", []),
+    )
     envelope["dispatchQueue"] = _queue_for(
         envelope["items"],
         _planning(source),
         args.run_manifest,
-        **_queue_kwargs(args),
+        **kwargs,
+        review_inputs=envelope["reviewInputs"],
     )
+    envelope["reusedItems"] = sorted(reusable_item_ids(
+        kwargs.get("previous_rows", []), envelope["reviewInputs"],
+    ))
     if getattr(args, "tie_vote", False):
         envelope["dispatchKind"] = "critic-tie"
         envelope["tieSplits"] = _tie_splits_from_state(
@@ -998,6 +1043,7 @@ def _render_inputs(run_manifest: Path) -> str:
 
 
 def _prompt(args: argparse.Namespace) -> str:
+    inputs = _checked_review_inputs(args.run_manifest)
     envelope = _load_json_object(
         _prepared_items_path(args.run_manifest, require_regular=True)
     )
@@ -1021,6 +1067,11 @@ def _prompt(args: argparse.Namespace) -> str:
         line("Item count", len(items)),
         _render_inputs(args.run_manifest),
     ]
+    authority = validated_run_authority(args.run_manifest)
+    rows.append(render_review_context(
+        [item["id"] for item in items], inputs, authority.payload, authority.project_root,
+    ))
+    _checked_review_inputs(args.run_manifest)
     for index, item in enumerate(items, 1):
         if not isinstance(item, Mapping):
             continue
@@ -1075,6 +1126,12 @@ def _validate_prepared(args: argparse.Namespace) -> dict[str, Any]:
     )
     if actual.get("dispatchQueue") != expected_queue:
         raise PlanItemContractError("prepared dispatch queue does not match")
+    current_inputs = _review_inputs(
+        expected["items"], _planning(source), args.run_manifest,
+        _queue_kwargs(args).get("previous_rows", []),
+    )
+    if actual.get("reviewInputs") != current_inputs:
+        raise PlanItemContractError("prepared review evidence changed; prepare again")
     if not getattr(args, "tie_vote", False):
         # 라운드 2+ 의 반대 의견 반입은 여기서만 검사된다. 봉투에서 빠지면
         # 프롬프트에도 빠지고, 반대한 워커는 자기 판정을 그대로 다시 적는다.
@@ -1134,6 +1191,7 @@ def _verdict_row(worker: str, block: VerdictBlock) -> dict[str, Any]:
         ("fixability", block.fixability),
         ("note", block.note),
         ("explanation", block.explanation),
+        ("dependencies", block.dependencies),
     ):
         if value:
             row[key] = value
@@ -1367,24 +1425,6 @@ def _carry_prior_run_verdicts(
     added: list[dict[str, Any]],
     hashes: Mapping[str, str],
 ) -> _PriorRunCarry | None:
-    """직전 run 이 같은 본문에 내린 판정을 새로 시드된 행에 옮긴다.
-
-    실패한 계획 run 을 다시 돌면 판정이 하나도 넘어오지 않았다. 이월은 답변된
-    clarification 이 있는 경로에만 있고(`incremental_scope.decide_scope` 는
-    답변된 `C-NNN` 이 없으면 `full` 을 되돌려 `incremental_carry` 를 도달 불가로
-    만든다), 그래서 아무도 고치지 않은 문장이 매 재실행마다 다시 채점됐다.
-
-    행 모양은 `incremental_carry._stamp_carried` 와 같다 — `verdicts` 를 그대로
-    옮기고, `carriedForwardFromSeq` 에 직전 seq 를 찍고, `verifiedContentHash` 를
-    이번 추출 해시로 맞춘다. 그 해시가 시드의 `dispatchQueue` 계산에 그대로
-    들어가므로(`_queue_for` → `reverify_item_ids`), 이월된 행은 라운드 1 큐에서
-    빠진다. 큐를 따로 줄이지 않는 이유가 이것이다: incremental 경로가
-    `incremental_carry._recompute_dispatch_queue` 에서 쓰는 것과 같은 장치다.
-
-    id 만 같은 행은 절대 이월하지 않는다. `P-*` id 는 위치에서 나오므로 계획이
-    한 줄만 밀려도 같은 번호가 다른 문장을 가리킨다. 해시가 같아야 그 문장이
-    같은 문장이다.
-    """
     prior = getattr(args, "prior_state", None)
     if prior is None:
         return None
@@ -1420,9 +1460,17 @@ def _carry_prior_run_verdicts(
         current_hash = hashes.get(item_id)
         if not current_hash or previous.get("verifiedContentHash") != current_hash:
             continue
+        manifest = getattr(args, "run_manifest", None)
+        inputs = (
+            _load_json_object(_prepared_items_path(manifest)).get("reviewInputs", {})
+            if manifest is not None else {}
+        )
+        if item_id not in reusable_item_ids([previous], inputs):
+            continue
         row["verdicts"] = copy.deepcopy(verdicts)
         row["carriedForwardFromSeq"] = prev_seq
         row["verifiedContentHash"] = current_hash
+        row["verifiedReviewHash"] = previous["verifiedReviewHash"]
         count += 1
     return _PriorRunCarry(prev_seq, count)
 
@@ -1526,6 +1574,7 @@ def _seed(args: argparse.Namespace) -> dict[str, Any]:
         _planning(source),
         getattr(args, "run_manifest", None),
         previous,
+        previous_rows=recorded,
     )
     verification["gating"] = (
         verification.get("gating") is True
@@ -1609,8 +1658,21 @@ def _apply_verdicts(args: argparse.Namespace) -> dict[str, Any]:
             f"gate is re-derived from that table, so a verdict with nowhere to "
             f"land would be scored as if it were never cast"
         )
+    review_inputs = _checked_review_inputs(getattr(args, "run_manifest", None))
     if args.round_number < 1:
         raise PlanItemContractError("--round must be 1 or greater")
+    _write_round_verdicts(args, data, recorded, rows, review_inputs)
+    if requires_plan_repair(verification):
+        verification["gating"] = True
+    _validate_advisory_round(verification, args.round_number)
+    write_json_atomic(target, data)
+    return {"ok": True, "operation": "apply-verdicts", "path": str(target)}
+
+
+def _write_round_verdicts(
+    args: argparse.Namespace, data: Mapping[str, Any], recorded: list[dict[str, Any]],
+    rows: Mapping[str, list[dict[str, Any]]], review_inputs: Mapping[str, Any],
+) -> None:
     project_root = _probe_project_root(getattr(args, "run_manifest", None))
     append = bool(getattr(args, "append", False))
     replaces_critic = append and any(
@@ -1627,18 +1689,20 @@ def _apply_verdicts(args: argparse.Namespace) -> dict[str, Any]:
             rows,
             data.get("roundHistory"),
             args.round_number,
-            target,
-            discard_open_rounds=discard_open_rounds,
+            args.state or args.data,
+            discard_open_rounds=bool(getattr(args, "discard_open_rounds", False)),
         )
     writer = _append_item_verdicts if append else _replace_item_verdicts
     for item in recorded:
         if isinstance(item, Mapping) and item.get("id") in rows:
             writer(item, rows[item["id"]], args.round_number, project_root)
-    if requires_plan_repair(verification):
-        verification["gating"] = True
-    _validate_advisory_round(verification, args.round_number)
-    write_json_atomic(target, data)
-    return {"ok": True, "operation": "apply-verdicts", "path": str(target)}
+    review_inputs = {**review_inputs, "dependencies": dependency_scopes(recorded)}
+    for item in recorded:
+        if isinstance(item, Mapping) and item.get("id") in rows:
+            item.pop("verifiedReviewHash", None)
+            fingerprint = review_fingerprint(item, review_inputs)
+            if fingerprint is not None:
+                item["verifiedReviewHash"] = fingerprint
 
 
 def _stamped_verdicts(
@@ -2110,6 +2174,7 @@ def _reject_unbacked_self_fix_stop(
 
 
 def _complete_round(args: argparse.Namespace) -> dict[str, Any]:
+    _checked_review_inputs(args.run_manifest)
     if args.round_number < 1:
         raise PlanItemContractError("--round must be 1 or greater")
     data, current, audit, history = _round_inputs(args)

package/runtime/python/okstra_ctl/phases/implementation_planning/instructions/plan-body-verification.md

@@ -413,11 +413,11 @@ round before any host or provider process starts.
 
 For contract 3.0, `prepare` checks the selected-direction draft with the same semantic validator as publication before writing the queue. Correct all reported references, coverage rows and planned commands through the writer correction procedure, then retry in this run. **Enforced:** `report_assembly.validate_plan_draft` and `plan_items_cli._prepare`; `tests/report/test_report_assembly.py` checks that invalid coverage creates no prepared queue.
 
-1. Lead runs `okstra plan-items prepare --narrative <report-writer-narrative.md> --run-manifest <run-manifest>`, places the fixed output of `okstra plan-items prompt --run-manifest <run-manifest>` verbatim in every verifier prompt, then runs `okstra plan-items validate-prepared --narrative <report-writer-narrative.md> --run-manifest <run-manifest>`. After a self-fix rewrite, pass `--state <plan-body-verification.json>` on prepare and validate-prepared so the dispatch queue is the changed items plus their stage closure, not the full extract, and so each re-dispatched item carries the previous round's dissent (§"Re-verification rounds (round 2+)"). Python resolves the one convergence-owned state path from that run identity. Dispatch only after that exact-match validation succeeds. The prompt is the dispatch queue: `observed` / `deferred` stages are omitted; plan-wide items (`P-Dir-1`, `P-Var-*`, `P-Dep-*`, `P-Opt-*`) stay. Unscoped `P-Val-*` / `P-Req-*` / `P-Rb-*` stay on the first round, then only when their own `contentHash` changed — a neighbour rewrite must not resweep them. **Enforced:** `okstra_ctl.plan_items.dispatch_item_ids` / `reverify_item_ids`. After `okstra incremental-carry`, the carry copies unchanged checklist verdicts, rewrites `dispatchQueue`, and updates the sibling `plan-items-*.json` so the next `okstra plan-items prompt` does not re-score a carried row.
+1. Lead runs `okstra plan-items prepare --narrative <report-writer-narrative.md> --run-manifest <run-manifest>`, places the fixed output of `okstra plan-items prompt --run-manifest <run-manifest>` verbatim in every verifier prompt, then runs `okstra plan-items validate-prepared --narrative <report-writer-narrative.md> --run-manifest <run-manifest>`. After a self-fix rewrite, pass `--state <plan-body-verification.json>` on prepare and validate-prepared. The runtime reuses a verdict only when its body, complete declared evidence closure, shared analysis packet, plan metadata, reviewer assignments and review contract have the same fingerprint. A missing or uncertain dependency declaration, unresolved reference, non-result or executable fact probe stays in the re-verification queue. Detailed verdicts and their original rounds remain unchanged for reused items. File dependencies cover whole files; step items also include preceding steps; plan-wide and preparation items include all plan items. Python resolves the one convergence-owned state path from that run identity. Dispatch only after exact-match validation succeeds. `observed` / `deferred` stages remain omitted. An empty queue opens no worker dispatch and creates no verification round. **Enforced:** `implementation_planning.authoring._queue_for`, `plan_item_evidence.review_fingerprint`, `_validate_prepared` and `tests/run/test_plan_items.py`. An incremental carry without evidence snapshots keeps active items queued until prepare can validate their dependencies.
 
    **Then seed the landing table (BLOCKING):** `okstra plan-items seed --narrative <report-writer-narrative.md> --state <plan-body-verification.json> --run-manifest <run-manifest.json>`. `apply-verdicts` in step 8 refuses a verdict whose item has no `planBodyVerification.planItems[]` row. The report writer never owns that state, so the deterministic seed is the only creator of its rows. The seed is idempotent by id and never touches existing verdicts, so it is safe to re-run between rounds and after a self-fix re-extraction. It does refresh `contentHash` from the current extract. Skipping it makes step 8 fail with `plan-body state has no row for [...]`.
 
-   **On a re-run, add `--prior-state <the previous run's plan-body-verification-<task-type>-<seq>.json>`.** A newly seeded item whose `contentHash` equals that run's `verifiedContentHash` for the same id inherits its verdicts, is tagged `carriedForwardFromSeq`, and drops out of round 1's `dispatchQueue` — in the state and in the sibling `plan-items-*.json` the next `okstra plan-items prompt` reads. Without it a re-run re-judges every line the previous run already settled, and the same dissent re-opens under a new `P-*` number. A matching id alone never carries: `P-*` ids are positional, so a plan that gained one line hands the old id to a different sentence. The flag requires `--state` and refuses a prior state file that sits under another task's root — a plan-body state carries no task identity of its own, so its path is the only identity there is. **Enforced:** `okstra_ctl.plan_items_cli._carry_prior_run_verdicts`.
+   **On a re-run, add `--prior-state <the previous run's plan-body-verification-<task-type>-<seq>.json>`.** A newly seeded item inherits verdicts only when its body and verified evidence fingerprint match the prepared snapshot for the same task. Reused rows carry `carriedForwardFromSeq`; their full verdicts are preserved. Legacy body-only records re-enter verification. A matching id alone never carries: `P-*` ids are positional. The flag requires `--state` and refuses another task's state. **Enforced:** `implementation_planning.authoring._carry_prior_run_verdicts` and `plan_item_evidence.reusable_item_ids`.
 
    **`--run-manifest` is what scopes the gate to the stage you are starting.** Seed uses it to overlay disk `done` / `active` onto `planBodyVerification.stageLedger`. The current plan's depends-on fills `ready` / `blocked` when no prior plan exists, so a first run does not treat every stage as in-scope. **Enforced:** `okstra_ctl.plan_items.planning_stage_ledger`.
 2. For each analyser worker in the roster, use `okstra plan-items prompt` output verbatim as the instruction body in the materialization sequence above. Read §"Re-verification rounds (round 2+)" before preparing a later round; read §"Plan-body reverify prompt" only when diagnosing a prompt-contract failure.
@@ -693,6 +693,23 @@ and a `- Plan narrative:` line from its `reportNarrativePath`. The worker's
 are what let a verifier read the requirement a selected-direction `P-Req-*` row
 names by `originalRequirementId`. The lead does not add them by hand.
 
+When a complete input snapshot is available, the renderer also provides inline
+review context. Read that context and the assigned payloads first. It preserves
+the packet except its navigation index and generated analysis Coverage Census,
+and carries plan metadata plus supporting items as lossless JSON. Supporting
+items are narrowed only when the previous dependency closure is complete and
+every body in that closure is unchanged; otherwise all other plan items are
+included. A changed body, missing declaration, unresolved reference or uncertain
+cross-item claim requires the full context or the original Inputs paths.
+Read those paths when the supplied context does not resolve a question, and
+record the additional dependencies. Omission never proves absence.
+Packets containing finding-like headings are quoted as source data, preserving
+their text without adding foreign items to the plan-verification queue.
+
+Enforcement: `render_review_context` in `okstra_ctl.plan_review_context` selects
+the context; `test_plan_review_context_preserves_facts_and_falls_back_for_unknown_dependencies`
+in `tests/run/test_plan_items.py` checks retained facts and conservative fallback.
+
 Carrying the packet does not license re-analysis. It is there so the verifier
 can resolve a plan item back to the requirement it claims to satisfy; the
 posture in §"Adversarial plan-body posture" still applies, and this round does
@@ -847,6 +864,9 @@ never recorded, and the round is scored on the items that remain.
 **Probe** (only when Claim is fact): <one line of JSON, e.g. {"kind": "path-absent", "path": "src/missing.ts"}>
 **Note**: <the falsification candidate considered and why it is excluded; required even for AGREE>
 **Explanation**: <2-3 sentences>
+**Dependencies**: {"complete": false, "itemIds": [], "paths": []}
+
+Keep the detailed Note and Explanation. Declare all direct and transitive plan-item and whole-file evidence dependencies. Set `complete` to true only when that boundary is known. Include source files behind references. External or dynamic evidence, unlisted narrative dependencies and unresolved references keep `complete` false. This declaration controls reuse eligibility, not the verdict itself. Missing and malformed declarations are treated as unknown by `verdict_blocks._block` and `plan_item_evidence.review_fingerprint`.
 
 ### P-Opt-2
 ...

package/runtime/python/okstra_ctl/phases/implementation_planning/plan_body.py

@@ -68,6 +68,7 @@ from okstra_ctl.design_surfaces import DesignSurfaceError  # noqa: E402
 
 from okstra_ctl.plan_items import (  # noqa: E402
     content_hash,
+    PlanItemContractError,
     expected_plan_item_ids,
     extract_plan_items,
 )
@@ -2543,6 +2544,7 @@ def validate_plan_body_section(
     _validate_round_recorded_verdicts(data, failures)
     _validate_verdicts_match_current_subjects(data, failures)
     _validate_verdict_rounds_outlive_self_fix(data, failures)
+    _validate_review_evidence(data, report_path, failures)
     _validate_unresolved_tie_was_reverified(data, failures)
     _validate_advisory_plan_body_gating(data, failures)
     _validate_plan_item_extraction_completeness(data, failures)
@@ -2553,6 +2555,37 @@ def validate_plan_body_section(
     return [*_detect_self_fix_recurrence(pbv), *_detect_uniform_verifier(pbv)]
 
 
+def _validate_review_evidence(data: dict, report_path: Path, failures: list[str]) -> None:
+    from okstra_ctl.convergence import validated_run_authority, ConvergenceContractError
+    from okstra_ctl.plan_item_evidence import capture_review_inputs, review_fingerprint
+
+    planning = data.get("implementationPlanning") or {}
+    pbv = planning.get("planBodyVerification") or {}
+    rows = pbv.get("planItems") or []
+    if not any(row.get("verifiedReviewHash") for row in rows):
+        return
+    sequences = _manifest_seq_for_report(report_path, "manifests")
+    if len(sequences) != 1:
+        failures.append("plan review evidence has no unambiguous run manifest")
+        return
+    path = report_path.parent.parent / "manifests" / (
+        f"run-manifest-implementation-planning-{next(iter(sequences))}.json"
+    )
+    try:
+        authority = validated_run_authority(path)
+        inputs = capture_review_inputs(
+            extract_plan_items(planning), planning, authority.payload, authority.project_root, rows,
+        )
+    except (ConvergenceContractError, PlanItemContractError) as exc:
+        failures.append(f"cannot validate plan review evidence: {exc}")
+        return
+    stale = [row["id"] for row in rows if _item_stage_scope_bucket(row, pbv) == "in-scope"
+             and row.get("verifiedReviewHash")
+             and row["verifiedReviewHash"] != review_fingerprint(row, inputs)]
+    if stale:
+        failures.append(f"plan review evidence changed for {stale}; prepare and re-verify those items")
+
+
 def _gate_summary_item(
     item: dict,
     pbv: dict,