okstra 0.166.0 → 0.166.2

package/docs/cli.md

@@ -130,7 +130,7 @@ For standard values and phase-specific responsibilities, see [Task type](#--task
   - `out-of-scope`: optional.
   - `candidate-cap`: 1–12; default 8.
 - Output: the `## 5.9 Improvement Candidates` table with 11 columns: Cand ID / Lens / Title / Scope / Severity / Effort / Consensus / Source workers / Recommended next-phase / Expected behavior after / Evidence.
-- Verdict Token: `candidates-ready` / `no-candidates` / `blocked`.
+- Verdict Token: `analysis-complete` / `analysis-partial` / `blocked` — the shared analysis enum, which is what `schemas/final-report-v2.0.schema.json` admits. Finding no candidates is not a verdict: the run stays `analysis-complete` and records an empty candidate set with a `no-candidate` row per lens. (`candidates-ready` / `no-candidates` appear only in a schema-v1 legacy report's `## 7. Final Verdict`.)
 - Routing: there is no automatic spin-off. The user selects candidates and starts each under a new task ID with `requirements-discovery`, `implementation-planning`, or `error-analysis`.
 - Workers: claude + codex + antigravity + report-writer are all required.
 - Primary-pass assignment: selected analyser instances are enumerated in `requiredWorkerRoles` order, then the lead rotates the primary pass across the resolved priority lenses. Provider/model names do not affect the order, and every analyser still covers every resolved lens after its primary pass.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.166.0",
+  "version": "0.166.2",
   "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.166.0",
-  "builtAt": "2026-08-11T10:29:58.327Z",
+  "package": "0.166.2",
+  "builtAt": "2026-08-11T13:40:27.396Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

package/runtime/prompts/profiles/implementation-planning.md

@@ -132,7 +132,7 @@
         unavailable environment is a user-owned follow-up, never a plan approval or
         later run blocker. `requires=[]` and `requires=[io]` remain blocking.
         Remote IO should also declare `external`.
-      The manifest lives at the **task level** (`<task_root>/qa/`, path token `TASK_QA_PATH`) and is shared across planning → implementation → final-verification. Layout split: executable scripts (conformance + any real-IO test) live under `<task_root>/qa/scripts/`; data sidecars (`conformance-manifest.json`, `result-*.json`) stay at the `qa/` root. This declaration is enforced at four layers: `validators/validate-implementation-plan-stages.py` check **S11** forces every stage to carry one of the two lines; at the planning boundary `validators/validate-run.py` `_validate_planning_conformance_declared` fails when a stage that declared `Conformance tests:` has no matching `-stage-<N>` entry in the shared manifest (a declaration that was never materialized); the manifest JSON structure — including each entry's `script` living under `qa/scripts/` — is enforced by `validate_conformance_manifest` (called from both the run path and validate-run); and the result policy is evaluated by `conformance.py` and `validate-run.py`.
+      The manifest lives at the **task level** (`<task_root>/qa/`, path token `TASK_QA_PATH`) and is shared across planning → implementation → final-verification. The verifier runs `runCommand` from the **worktree cwd**, and that cwd is the tree under test — it is what makes the script see this stage's diff. So `runCommand` MUST NOT repoint it: a leading `cd <checkout> &&` sends the script at whichever tree it names, which at implementation time is a checkout without the stage's changes and at final-verification is not the integrated tree either. Absolute paths are fine and usually necessary — the script and its `tsconfig` live under `<task_root>/qa/scripts/`, i.e. under `.okstra/`, and a worktree does not carry `.okstra/` (worker preamble: "`.okstra/**` artifacts remain anchored at `**Project Root:**`; the worktree may not contain them"). Point at those by absolute path; leave the cwd alone. **Enforced:** `scripts/okstra_ctl/conformance.py` `_check_entry` rejects a `runCommand` whose first word in any `&&` / `;` segment changes directory. Layout split: executable scripts (conformance + any real-IO test) live under `<task_root>/qa/scripts/`; data sidecars (`conformance-manifest.json`, `result-*.json`) stay at the `qa/` root. This declaration is enforced at four layers: `validators/validate-implementation-plan-stages.py` check **S11** forces every stage to carry one of the two lines; at the planning boundary `validators/validate-run.py` `_validate_planning_conformance_declared` fails when a stage that declared `Conformance tests:` has no matching `-stage-<N>` entry in the shared manifest (a declaration that was never materialized); the manifest JSON structure — including each entry's `script` living under `qa/scripts/` — is enforced by `validate_conformance_manifest` (called from both the run path and validate-run); and the result policy is evaluated by `conformance.py` and `validate-run.py`.
     - `### Stage Exit Contract` — predicted added/modified files, newly exposed identifiers/types/endpoints, downstream-usable resources.
     - `### Stage Validation` — pre / mid / post exact commands or observable outcomes for this stage only.
       - **Dependency precondition (stages that run the project toolchain).** The planning worktree is created without installed dependencies, so a stage whose steps call `npm` / `yarn` / `pytest` / `cargo` / equivalent cannot have those commands succeed at plan time — they exit `127`, not RED/GREEN. Declare the install **once** as a `phase: pre` row in `### Validation Checklist` (e.g. `VC-008 — the implementation run's stage worktree has workspace dependencies installed`) and have every such stage's `Stage Validation` cite that `VC-NNN` in its `pre:` line. Do not repeat the install commands per stage, and do not silently assume the tooling is present: a plan that never states the precondition produces steps whose commands never resolve, which the §5.5.9 round then reports as unverifiable. **Enforced (advisory):** `validators/validate-run.py` `_detect_missing_dependency_precondition` warns when a toolchain-invoking stage cites no `VC-NNN`, or cites one that is not `phase: pre`. Whether the cited row genuinely covers dependencies is a §5.5.9 judgement, not a machine check. Detection uses the token allowlist in `scripts/okstra_ctl/build_tools.py`; a project overrides it with `buildToolTokens` in `.okstra/project.json`.

package/runtime/prompts/profiles/improvement-discovery.md

@@ -54,7 +54,7 @@
   - v1 legacy branch: when validating or rerendering an existing schema-v1 report, preserve its `## 5.9 Improvement Candidates` table and legacy Markdown contract; do not rewrite that historical data into v2 implicitly.
   - the `## 5.9 Improvement Candidates` table populated with rows that obey the 11-column schema from `validators/validate_improvement_report.py` (Cand ID `I-NNN`, Lens from whitelist, Title, Scope ⊆ scan-scope, Severity, Effort, Consensus, Source workers `<worker>:<id>` from {claude, codex, antigravity}, Recommended next-phase ∈ {requirements-discovery, implementation-planning, error-analysis}, Expected behavior after, Evidence as path:line list). `Expected behavior after` states, in one observable sentence, what becomes different once the candidate is applied — it is the seed of the downstream brief's `EB-NNN` / `EO-NNN`. A candidate you cannot write this cell for is a preference, not a finding: drop it rather than filling the cell with a restatement of the title.
   - `Consensus` cells in `## 5.9 Improvement Candidates` use the table enum exactly: `full`, `partial`, `contested`, `worker-unique`. Map convergence's `full-consensus` / `partial-consensus` labels to `full` / `partial` before writing the table.
-  - `## 7. Final Verdict` Verdict Token ∈ {`candidates-ready`, `no-candidates`, `blocked`}; Direction `routing`; Next Step "ask the user to select K candidates (see the ## 5.9 table)"
+  - Verdict Token — **branch-specific, and the two branches do not share a vocabulary.** On the current v2 branch use the shared analysis enum: `analysis-complete` when every resolved lens was examined, `analysis-partial` when one could not be, `blocked` when the scan itself could not run. `schemas/final-report-v2.0.schema.json` admits only those three for `verdictCard.verdictToken` / `finalVerdict.verdictToken`, so a v2 report carrying `candidates-ready` fails Phase 7. **Finding no candidates is not a verdict**: it is an empty `candidates[]` plus a `lensCoverage[]` row per lens with `status: no-candidate` and its evidence-backed rationale — the verdict stays `analysis-complete`. `candidates-ready` / `no-candidates` belong to the v1 legacy `## 7. Final Verdict` Markdown alone, where `validators/validate_improvement_report.py` enforces them. Both branches: Direction `routing`; Next Step "ask the user to select K candidates (see the ## 5.9 table)".
   - `## 3. Recommended Next Steps` first entry summarises per-candidate routing and proposes new task-key names of the form `<task-group>/imp-<Cand-ID>`
   - author the shared schema-v2 report fields plus `improvementDiscovery.candidates[]`, `improvementDiscovery.lensCoverage[]`, `improvementDiscovery.selectionLimit`, and `improvementDiscovery.userNarrative` in data.json. `candidates[]` carries the same 11 logical fields described above; `lensCoverage[]` records either candidate IDs or an evidence-backed no-candidate rationale for every resolved lens. `schemas/final-report-v2.0.schema.json` and `validators/validate_improvement_report.py` enforce this contract. The renderers independently derive AI handoff Markdown and human HTML; never author a free-form report.
 - Clarification request policy (phase-specific addenda — shared policy is in `_common-contract.md`):

package/runtime/python/okstra_ctl/analysis_packet.py

@@ -44,7 +44,13 @@ PROFILE_SECTIONS = (
     "Non-goals",
 )
 WORKER_PROFILE_SECTIONS_BY_TASK_TYPE = {
+    # `Brief consumption` carries the reporter-confirmation rules — do not infer an
+    # unconfirmed `intent-check:` / `conversion-block:`, carry it forward as a
+    # blocker instead. Those bind the analysis worker, and the packet is the only
+    # profile text a worker receives, so a phase that omits the section ships a
+    # worker that can turn an unconfirmed intent into a settled requirement.
     "requirements-discovery": (
+        "Brief consumption",
         "Worker discovery procedure",
     ),
     "error-analysis": (
@@ -52,6 +58,7 @@ WORKER_PROFILE_SECTIONS_BY_TASK_TYPE = {
         "Worker diagnosis procedure",
     ),
     "implementation-planning": (
+        "Brief consumption",
         "Worker planning procedure",
         "Pre-planning context exploration",
         "Design principles applied when scoring options",
@@ -60,7 +67,13 @@ WORKER_PROFILE_SECTIONS_BY_TASK_TYPE = {
         "Worker verification procedure",
     ),
     "improvement-discovery": (
+        "Brief consumption",
         "Worker candidate procedure",
+        # Every analyser examines every resolved lens but leads with its own, and
+        # keeps duplicate / conflicting relations. Held only in the lead's profile,
+        # the workers converge on the same easy lens and the cross-check thins out
+        # while the aggregate still looks complete.
+        "Worker diversity rule",
     ),
 }
 CLARIFICATION_SECTIONS = (

package/runtime/python/okstra_ctl/conformance.py

@@ -14,6 +14,10 @@ import fnmatch
 import re
 from dataclasses import dataclass
 
+# 셸에서 프로세스의 cwd 를 바꾸는 명령. verifier 가 워크트리 cwd 에서 실행하는
+# 계약이 이것들로 무력화된다.
+_CWD_CHANGING_COMMANDS: frozenset[str] = frozenset({"cd", "pushd", "popd", "chdir"})
+
 # diff 가 건드린 표면과 대조할 capability 태그 화이트리스트.
 CAPABILITY_WHITELIST: tuple[str, ...] = ("db", "io", "http", "external")
 EXTERNAL_ADVISORY_CAPABILITIES: frozenset[str] = frozenset(
@@ -89,6 +93,25 @@ def _check_entry(entry: object, idx: int, errors: list[str]) -> None:
     if isinstance(script, str) and script.strip() and "qa/scripts/" not in script:
         errors.append(f"{path}.script must live under the task qa scripts dir (qa/scripts/), got {script!r}")
     _check_nonempty_str(entry.get("runCommand"), f"{path}.runCommand", errors)
+    run_command = entry.get("runCommand")
+    # 이 명령은 워크트리 cwd 에서 verbatim 실행되고(_implementation-verifier.md
+    # "Otherwise run runCommand in the worktree cwd"), **그 cwd 가 곧 검사 대상**이다.
+    # 스크립트·tsconfig 는 `.okstra/` 아래 사는데 워크트리에는 `.okstra/` 가 없으므로
+    # (implementation-worker-preamble.md "the worktree may not contain them")
+    # 그것들을 절대경로로 가리키는 것은 정상이고 사실상 필수다. 금지되는 것은 cwd
+    # 를 옮기는 일뿐이다 — 선행 `cd <메인 체크아웃>` 은 stage diff 가 없는 트리에서
+    # 검사를 돌려 미변경 코드를 통과시킨다.
+    if isinstance(run_command, str):
+        for segment in re.split(r"&&|\|\||;|\|", run_command):
+            words = segment.split()
+            if words and words[0] in _CWD_CHANGING_COMMANDS:
+                errors.append(
+                    f"{path}.runCommand must run in the worktree cwd — that cwd is "
+                    f"the tree under test; a leading `{words[0]}` repoints it, so "
+                    "the script checks whichever checkout it lands in instead of "
+                    "this stage's diff"
+                )
+                break
     _check_nonempty_str(entry.get("passContract"), f"{path}.passContract", errors)
     req_ids = entry.get("requirementIds")
     if (

package/runtime/python/okstra_ctl/initial_prompt_materialization.py

@@ -392,9 +392,33 @@ def _resource_lines(
     )
     if clarification:
         bodies.append(clarification)
+    carry = _stage_fix_carry_body(context, item.plan)
+    if carry:
+        bodies.append(carry)
     return ["", "\n\n".join(bodies)]
 
 
+def _stage_fix_carry_body(
+    context: _MaterializationContext,
+    plan: PromptPlan,
+) -> str:
+    """The fix-run carry block, for the two audiences that act on it.
+
+    The executor's scope is the carried blocking findings, and the verifier MUST
+    cite each of them as resolved or still-failing — a fix-run verifier result
+    citing none is recorded as a contract violation. Both facts live in the
+    rendered analysis profile, which no CLI worker can read, so the block used to
+    reach them only if the lead transcribed it by hand. A missed transcription
+    made the worker answerable for a list it was never given.
+    """
+    if plan.audience not in ("implementation-executor", "implementation-verifier"):
+        return ""
+    run = context.active_context.get("run")
+    if not isinstance(run, Mapping):
+        return ""
+    return _string_value(run.get("fixRunCarry")).strip()
+
+
 def _resolve_clarification_input(
     context: _MaterializationContext,
     plan: PromptPlan,

package/runtime/python/okstra_ctl/path_hints.py

@@ -58,6 +58,7 @@ def compact_active_run_context(
         "workflow": dict(_mapping(payload.get("workflow"))),
         "run": {
             "stage": ctx.get("RUN_STAGE", ""),
+            "fixRunCarry": ctx.get("FIX_RUN_CONTEXT", ""),
         },
         "inputs": _compact_active_inputs(payload),
         "workers": _compact_active_workers(payload),
@@ -186,12 +187,13 @@ def _hydrate_active_run(
     payload: Mapping[str, Any],
     ctx: Mapping[str, str],
 ) -> dict[str, str]:
-    # `stage` is a run input, not a derived path, so pathHints cannot rebuild
-    # it — it survives the round trip only by being read back off the compact
-    # payload.
+    # `stage` and `fixRunCarry` are run inputs / derived content, not paths, so
+    # pathHints cannot rebuild them — they survive the round trip only by being
+    # read back off the compact payload.
     run = _mapping(payload.get("run"))
     return {
         "stage": str(run.get("stage", "") or ""),
+        "fixRunCarry": str(run.get("fixRunCarry", "") or ""),
         "runDirectoryPath": ctx.get("RUN_DIR_RELATIVE_PATH", ""),
         "runManifestPath": ctx.get("RUN_MANIFEST_RELATIVE_PATH", ""),
         "teamStatePath": ctx.get("TEAM_STATE_RELATIVE_PATH", ""),

package/runtime/python/okstra_ctl/render.py

@@ -511,6 +511,13 @@ def _active_run(ctx: dict) -> dict:
         # stage from `consumers.jsonl`. Feeds the implementation prompt anchor
         # in `initial_prompt_materialization`.
         "stage": ctx.get("RUN_STAGE", ""),
+        # A fix run's carried findings decide what the executor fixes and what
+        # the verifier MUST cite as resolved / still-failing. The rendered
+        # analysis profile holds the same block, but no CLI worker can read that
+        # file, so this copy is what `initial_prompt_materialization` inlines
+        # into their prompts. Derived once at prepare: re-deriving it later would
+        # read a worktree HEAD the executor may have already moved.
+        "fixRunCarry": ctx.get("FIX_RUN_CONTEXT", ""),
         "runDirectoryPath": ctx.get("RUN_DIR_RELATIVE_PATH", ""),
         "runManifestPath": ctx.get("RUN_MANIFEST_RELATIVE_PATH", ""),
         "teamStatePath": ctx.get("TEAM_STATE_RELATIVE_PATH", ""),

package/runtime/python/okstra_ctl/stage_fix_carry.py

@@ -45,10 +45,10 @@ class StageFixCarry:
             "Scope rules for this fix run live in the implementation sidecars "
             "(`_implementation-verifier.md` § Fix-run incremental scope, "
             "`report-writer.md` § Fix-run incremental authoring).",
-            "Lead duties: transcribe this block verbatim into every CLI "
-            "executor/verifier prompt (CLI processes cannot read this file), "
-            "and pass the previous data.json path above to the report-writer "
-            "dispatch so it authors incrementally.",
+            "This block is inlined into the executor and verifier prompts by "
+            "`initial_prompt_materialization`; do not transcribe it by hand. "
+            "Lead duties: pass the previous data.json path above to the "
+            "report-writer dispatch so it authors incrementally.",
         ])
         return "\n".join(lines)
 

package/runtime/schemas/final-report-v2.0.schema.json

@@ -726,9 +726,10 @@
       "type": "object",
       "description": "RENDER_IF taskType == release-handoff. §5.6 deliverables.",
       "required": [
-        "sourceVerificationReport",
+        "handoffScope",
         "featureBranchState",
         "userSelections",
+        "localCheckoutOutcome",
         "executedCommands",
         "commitList",
         "mergeConflictProbe",
@@ -737,6 +738,37 @@
         "userNarrative"
       ],
       "additionalProperties": false,
+      "allOf": [
+        {
+          "if": {
+            "properties": {
+              "handoffScope": {
+                "properties": {
+                  "mode": {
+                    "const": "stage-group"
+                  }
+                },
+                "required": [
+                  "mode"
+                ]
+              }
+            },
+            "required": [
+              "handoffScope"
+            ]
+          },
+          "then": {
+            "required": [
+              "sourceVerificationReports"
+            ]
+          },
+          "else": {
+            "required": [
+              "sourceVerificationReport"
+            ]
+          }
+        }
+      ],
       "properties": {
         "handoffScope": {
           "type": "object",
@@ -761,11 +793,25 @@
             },
             "collectorBranch": {
               "type": "string"
+            },
+            "mergeCommits": {
+              "type": "array",
+              "description": "Assemble's merge commit SHAs, in the order the stages were merged into the collector branch. Without them the collector branch's contents cannot be traced back to the stages that produced them once the branch moves on.",
+              "items": {
+                "type": "string",
+                "minLength": 7
+              }
+            },
+            "dependencyClosureVerdict": {
+              "type": "string",
+              "minLength": 1,
+              "description": "Whether the selected stages are closed under their dependencies, and on what basis. A stage-group PR that ships a stage without its predecessor is the failure this records."
             }
           }
         },
         "sourceVerificationReport": {
           "type": "object",
+          "description": "whole-task mode: the one final-verification report this handoff ships. Required unless handoffScope.mode is stage-group.",
           "required": [
             "path",
             "verdictTokenQuote"
@@ -782,6 +828,59 @@
             }
           }
         },
+        "sourceVerificationReports": {
+          "type": "array",
+          "description": "stage-group mode: one row per selected stage, because that handoff ships several verified stages and a single report path cannot say which stage each verdict belongs to.",
+          "minItems": 1,
+          "items": {
+            "type": "object",
+            "required": [
+              "stage",
+              "path",
+              "verdictTokenQuote"
+            ],
+            "additionalProperties": false,
+            "properties": {
+              "stage": {
+                "type": "integer",
+                "minimum": 1
+              },
+              "path": {
+                "type": "string",
+                "minLength": 1
+              },
+              "verdictTokenQuote": {
+                "type": "string",
+                "minLength": 1
+              }
+            }
+          }
+        },
+        "localCheckoutOutcome": {
+          "type": "object",
+          "description": "What the `local checkout` action did, including when it was not taken. `removedWorktree` is the command's own field: a non-empty path means the okstra worktree was removed, an empty string means it was already gone and the branch survived. Recording a removal that did not happen is the error this shape exists to prevent.",
+          "required": [
+            "status"
+          ],
+          "additionalProperties": false,
+          "properties": {
+            "status": {
+              "enum": [
+                "not-run",
+                "checked-out"
+              ]
+            },
+            "branch": {
+              "type": "string"
+            },
+            "mainWorktreePath": {
+              "type": "string"
+            },
+            "removedWorktree": {
+              "type": "string"
+            }
+          }
+        },
         "featureBranchState": {
           "type": "object",
           "required": [
@@ -835,7 +934,9 @@
               ]
             },
             "h3": {
+              "description": "The PR title/body confirmation. `not-run` when H1 was `local checkout` or `skip` — those routes never reach the question, and inventing an answer for a question that was never asked is the failure this value prevents.",
               "enum": [
+                "not-run",
                 "use as-is",
                 "edit then proceed",
                 "cancel"

package/runtime/templates/reports/final-report.template.md

@@ -544,13 +544,22 @@ Carried-forward plan items retain their prior verdicts verbatim; each such item
 - Mode: `{{ releaseHandoff.handoffScope.mode | mdcell }}`
 {% if releaseHandoff.handoffScope.stages %}- Stages: {{ releaseHandoff.handoffScope.stages | join(', ') | mdcell }}
 {% endif %}{% if releaseHandoff.handoffScope.collectorBranch %}- Collector branch: `{{ releaseHandoff.handoffScope.collectorBranch | mdcell }}`
+{% endif %}{% if releaseHandoff.handoffScope.mergeCommits %}- Assemble merge commits: {{ releaseHandoff.handoffScope.mergeCommits | join(', ') | mdcell }}
+{% endif %}{% if releaseHandoff.handoffScope.dependencyClosureVerdict %}- Dependency closure: {{ releaseHandoff.handoffScope.dependencyClosureVerdict | mdcell }}
 {% endif %}
 {% endif %}
 ### 5.6.1 Source Verification Report
-
+{% if releaseHandoff.sourceVerificationReports %}
+| Stage | Report path (project-relative) | Quoted `Verdict Token` row |
+|-------|--------------------------------|----------------------------|
+{% for row in releaseHandoff.sourceVerificationReports -%}
+| {{ row.stage | mdcell }} | `{{ row.path | mdcell }}` | {{ row.verdictTokenQuote | mdcell }} |
+{% endfor %}
+{%- else %}
 - Path (project-relative): `{{ releaseHandoff.sourceVerificationReport.path }}`
 - Quoted `Verdict Token` row from that report's `## 7.` table:
   > {{ releaseHandoff.sourceVerificationReport.verdictTokenQuote | mdquote(2) }}
+{% endif %}
 
 ### 5.6.2 Feature Branch & Working-Tree State{% if t("releaseHandoff.branchStateAside") != "captured at run start" %} ({{ t("releaseHandoff.branchStateAside") }}){% endif %}
 
@@ -571,7 +580,7 @@ Carried-forward plan items retain their prior verdicts verbatim; each such item
 {% endif %}
 | H2 | {{ t("releaseHandoff.h2Body") }} | `{{ (releaseHandoff.userSelections.h2 or t("releaseHandoff.h2DefaultLabel")) | mdcell }}` | {{ t("releaseHandoff.h2OptionsLabel") }} |
 | H2b | Merge conflict probe | `{{ (releaseHandoff.userSelections.h2b or releaseHandoff.mergeConflictProbe.kind) | mdcell }}` | `not-run` / `clean` / `proceed anyway` / `change base branch` / `cancel` |
-| H3 | {{ t("releaseHandoff.h3Body") }} | `{{ releaseHandoff.userSelections.h3 | mdcell }}` | `use as-is` / `edit then proceed` / `cancel` |
+| H3 | {{ t("releaseHandoff.h3Body") }} | `{{ releaseHandoff.userSelections.h3 | mdcell }}` | `not-run` / `use as-is` / `edit then proceed` / `cancel` |
 
 ### 5.6.4 Executed Commands
 
@@ -623,6 +632,12 @@ Carried-forward plan items retain their prior verdicts verbatim; each such item
 
 {{ releaseHandoff.routingRecommendation }}
 
+### 5.6.9 Local Checkout Outcome
+
+- Status: `{{ releaseHandoff.localCheckoutOutcome.status | mdcell }}`
+{% if releaseHandoff.localCheckoutOutcome.status == 'checked-out' %}- Checked out `{{ releaseHandoff.localCheckoutOutcome.branch | mdcell }}` into `{{ releaseHandoff.localCheckoutOutcome.mainWorktreePath | mdcell }}`
+- okstra worktree: {% if releaseHandoff.localCheckoutOutcome.removedWorktree %}`{{ releaseHandoff.localCheckoutOutcome.removedWorktree | mdcell }}` removed{% else %}none removed — already torn down, so the branch survived{% endif %}
+{% endif %}
 {% endif %}
 {% if header.taskType == 'implementation' %}
 ## 5.7 Implementation Deliverables

package/runtime/templates/reports/html/tasks/release-handoff.template.html

@@ -39,7 +39,8 @@
   <h2>{{ t('tasks.release-handoff.commits-delivered') }}</h2>
   {% if handoff.commitList is mapping %}<p>{{ t('tasks.release-handoff.there-are-no-commits') }}</p>{% else %}
   <table><thead><tr><th>{{ t('tasks.release-handoff.commit') }}</th><th>{{ t('tasks.release-handoff.subject') }}</th><th>{{ t('tasks.release-handoff.files') }}</th></tr></thead><tbody>{% for row in handoff.commitList %}<tr>{{ row_key(pairs=[("SHA", row.shortSha), ("Order", loop.index)]) }}<td>{{ row.subject | inline_code }}</td><td>{% for file in row.files %}<code>{{ file }}</code>{% if not loop.last %} {% endif %}{% endfor %}</td></tr>{% endfor %}</tbody></table>{% endif %}
-  <p data-report-field="releaseHandoff.sourceVerificationReport"><strong>{{ t('tasks.release-handoff.the-verification-report-this-rests-on') }}</strong> — <code>{{ handoff.sourceVerificationReport.path }}</code> · {{ handoff.sourceVerificationReport.verdictTokenQuote | inline_code }}</p>
+  {% if handoff.sourceVerificationReports %}<p data-report-field="releaseHandoff.sourceVerificationReports"><strong>{{ t('tasks.release-handoff.the-verification-report-this-rests-on') }}</strong>{% for row in handoff.sourceVerificationReports %} — stage {{ row.stage }}: <code>{{ row.path }}</code> · {{ row.verdictTokenQuote | inline_code }}{% endfor %}</p>
+  {% else %}<p data-report-field="releaseHandoff.sourceVerificationReport"><strong>{{ t('tasks.release-handoff.the-verification-report-this-rests-on') }}</strong> — <code>{{ handoff.sourceVerificationReport.path }}</code> · {{ handoff.sourceVerificationReport.verdictTokenQuote | inline_code }}</p>{% endif %}
 </section>
 
 <section data-report-section="next-action">

package/src/commands/lifecycle/install.mjs

@@ -915,7 +915,14 @@ export async function runInstall(args) {
     await writeFileAtomic(join(paths.home, "version"), paths.package + "\n", 0o644);
   }
   if (!opts.quiet) {
-    process.stdout.write(`  version stamp: ${paths.package}\n`);
+    // The source is already named at the top of the run; what the stamp line
+    // could not say is whether this install moved anything. `copied=0 skipped=N`
+    // plus a bare version reads identically for "already current" and "an older
+    // payload just landed over a newer home" — the latter cost a full run,
+    // caught only by hand-diffing installed files.
+    process.stdout.write(
+      `  version stamp: ${formatVersionTransition(paths.version, paths.package)}\n`,
+    );
     process.stdout.write("done.\n");
     process.stdout.write(
       "\nNext step: register the current project.\n" +
@@ -1011,6 +1018,15 @@ async function agentDriftReasons(paths) {
   return reasons;
 }
 
+// What the stamp did, not just where it landed: `0.165.3 -> 0.166.0` and
+// `0.166.0 (unchanged)` are the two cases a bare version line cannot tell apart,
+// and they mean opposite things about whether the install did anything.
+export function formatVersionTransition(previous, next) {
+  const from = String(previous ?? "").trim();
+  if (!from) return next;
+  return from === next ? `${next} (unchanged)` : `${from} -> ${next}`;
+}
+
 function summarise(label, result, target) {
   if (result.missingSource) {
     process.stdout.write(`  ${label}: source directory missing — skipped\n`);