opencode-plugin-flow 7.3.2 → 8.1.0

package/dist/index.js

@@ -109,7 +109,8 @@ If a Flow tool is absent, report an incomplete plugin load; never simulate state
 ## Recovery
 
 On interruption, read compact status; load \`flow-run\` for an active or blocked feature
-and use execution or reviewer status, never prose, for lifecycle truth.
+and use execution or reviewer status, never prose, for lifecycle truth. At a
+checkpoint or lease stop, print compact \`findingsDigest\` before any delivery map.
 
 Summaries keep plan/source IDs \`verified\` or \`incomplete\`. A prior finding is
 terminally \`fixed\` only when review passes with current evidence. A failed
@@ -187,21 +188,19 @@ Save one plan with:
 - \`overview\`: the implementation approach and important boundaries.
 - \`requirements\`: acceptance criteria, constraints, and non-goals.
 - \`decisions\`: assumptions and architecture or scope choices already made.
-- \`gate\`: the canonical whole-repository command, read from repository
-  configuration. Broad evidence later runs this command byte-for-byte, so a check
-  too weak to fail forecloses broad evidence for the session.
-- \`externalEvidence\`: each acceptance observation needing an operating system,
-  architecture, service, credential, setting, or hardware this host may lack, as
-  \`requirement\`, \`environment\`, the exact \`command\` whose passing is that observation,
-  \`platform\`: \`win32\`, \`darwin\`, \`linux\`, or \`other\` for a non-OS environment, and
-  \`assertions\`: the test case names whose passing is that observation, empty for
-  evidence that is not a test result. Empty list when the goal is fully observable
-  here. That command, on that platform, reporting those cases passing is what
-  satisfies it: final review and completed closure stay refused until then. A skipped
-  case exits zero and satisfies nothing, and recording the gap as a \`requirements\`
-  non-goal declares nothing.
+- \`evidence\`: one \`scope: "gate"\` entry for the canonical whole-repository
+  command, plus \`scope: "extra"\` entries for observations this host may lack.
+  Each entry names \`requirement\`, \`environment\`, \`command\`, \`platform\`
+  (\`win32\`, \`darwin\`, \`linux\`, or \`other\`), and \`assertions\` (empty when the
+  evidence is not a test result). Broad observations run the gate command
+  byte-for-byte. Extra entries may be omitted when the goal is fully observable
+  here. Final review and completed closure stay refused until every extra
+  entry is satisfied on its declared platform with named cases passing. The
+  gate is the command every broad observation must run; a failed or
+  claimed-broad gate still vetoes review.
 - \`features\`: ordered outcome slices, each with a stable \`id\`, \`title\`,
-  \`summary\`, bounded \`targets\`, concrete \`validation\`, and \`dependsOn\` ids.
+  \`summary\`, bounded \`targets\`, concrete \`validation\`, \`dependsOn\` ids, and
+  optional \`kind\`.
 
 Each feature needs one observable outcome judgeable from bounded evidence and
 focused validation. Split only independent failures or true dependencies; file
@@ -216,6 +215,13 @@ outcome and its evidence.
 A \`validation\` entry naming a command is recorded byte-for-byte; prose there stays
 reviewer judgment, never a fabricated result.
 
+If the request is inspect-only (review, audit, survey, no promised edit), invent
+no repair features. Save at most a small set of inspect features with
+\`kind: "inspect"\`, whose \`validation\` is reviewer inspection, whose \`targets\`
+are existing paths, and whose \`decisions\` state that no source edit is
+authorized. The gate may be the repo's existing check. Ask before turning an
+inspect request into repairs.
+
 Before saving, confirm:
 
 - every requirement maps to a feature or an explicit non-goal;
@@ -280,17 +286,15 @@ the manager's summary. Check that:
 - changed behavior is correct at public and downstream call sites;
 - validation is strong enough for the behavior and main failure modes;
 - scope did not drift and unrelated user work was preserved;
-- relevant adjacent states, failure/cleanup ordering, repetition, retry,
-  interruption, reentrancy, concurrency, and overlapping invariants still work;
 - the feature's actual base diff includes no unexplained deletion, rename, file
   type, generated artifact, or executable/file-mode change; and
 - persistence, concurrency, security, migration, compatibility, package, UI,
   and recovery risks were examined when relevant.
 
-Finish the supplied feature-specific risk checklist, represented by a bounded
-matrix for concurrency or state-machine work. Continue that matrix after finding
-one blocker so independently detectable interleavings arrive in the same review
-cohort.
+Finish the supplied feature-specific risk checklist. Continue a concurrency or
+state-machine matrix after one blocker only when \`assignment.packet.riskLenses\`
+is non-empty or the packet summary includes a matrix. Otherwise inspect the
+changed artifacts, the supplied validation, and live \`priorFindings\`.
 
 Scope plan/source IDs by assignment kind. An ordinary feature review records
 dispositions only for IDs mapped to the active feature or explicitly supplied
@@ -314,8 +318,8 @@ not a failure; a missing or conflicting baseline fact, or a material mode,
 platform, race, or failure-path claim without proof, is.
 
 Flow deliberately projects no raw command output; use the durable command, exit
-code, completeness, digest, source binding, and your workspace inspection. A weak or
-unclear coverage claim is an evidence gap.
+code, completeness, digest, source binding, and your workspace inspection. A weak
+coverage claim is an evidence gap.
 
 For a final assignment, also inspect broad validation and confirm docs,
 commands, package surfaces, and remaining gaps are consistent with completion.
@@ -329,8 +333,8 @@ IDs in summary or evidence.
 
 Report every problem you find. Severity is a routing decision the runtime acts
 on, not a filter on what to mention: \`blocking\` when the issue invalidates the
-approved outcome, \`advisory\` otherwise. When you are unsure, report it as
-\`advisory\` rather than omitting it.
+approved outcome, \`advisory\` otherwise. If unsure, report it as
+\`advisory\` rather than omitting it. Inspect kind completes with blockers.
 
 Set \`scopeBlocker: true\` on a blocking finding whose repair requires material
 work outside the approved plan, and identify the boundary in \`evidence\`. The
@@ -406,14 +410,14 @@ description: Implement, validate, independently review, and record one approved
 
 Work on exactly one approved feature.
 
-## Start and scope
+## Start
 
 1. Call \`flow_status { request: { view: "compact" } }\` first. Treat
-   \`nextAction\` as the durable default workflow direction, not as permission.
+   \`nextAction\` as the durable default, not as permission.
 2. If the top-level response status is \`error\`, report its exact summary and
    recovery when present and, if \`workflowData.delivery\` exists, the handoff
-   below. State this initial read made no lifecycle, Git, or release mutation;
-   stop and never route its \`nextAction\`.
+   below. This read made no lifecycle, Git, or release mutation. Stop. Do not
+   route its \`nextAction\`.
 3. If compact status contains \`archiveRetry\`, call \`flow_session_close\` once
    with the projected request byte-for-byte. Report delivery under the contract
    below. Refresh only if publication is unconfirmed. Stop after this cleanup
@@ -421,9 +425,9 @@ Work on exactly one approved feature.
 4. When the projection contains an active goal, align it with the current
    \`/flow-run\` request before another manager lifecycle mutation. Continue only
    for the same goal or a method/emphasis narrowing that preserves all outcomes;
-   close completed work. Unless step 5 applies, new/expanded work makes no
-   mutation: report that it has not started and offer continue, defer, or
-   abandon.
+   close completed work. Unless the next step applies, new or expanded work
+   makes no mutation: report that it has not started and offer continue, defer,
+   or abandon.
 5. If the aligned request explicitly chooses deferred or abandoned closure for
    a non-completed session, call \`flow_session_close\` with compact session id and
    revision, fresh operation id, that kind, and optional summary. Report delivery
@@ -432,226 +436,113 @@ Work on exactly one approved feature.
    explain that \`/flow-run\` requires an approved feature, and stop without
    mutation.
 
-Route every compact projection in this order:
+Delivery handoff: report \`workflowData.delivery.report\` verbatim. Map IDs only
+from delivery \`outcomeSummary\`/\`terminalFindings\`. Requirements are \`verified\`,
+\`incomplete\`, or explicitly \`deferred\`, and \`abandoned\` remains the kind. If
+delivery is absent, report exact recovery and no map. On revision conflict,
+refresh compact; retry only for the same session and goal while status still
+permits the selected closure kind; never close a replacement.
+
+## Route
+
+Follow compact \`nextAction\` in this order:
 
 - \`flow_session_close\`: close completed work with its projected session
-  id/revision, fresh operation id, and \`kind: "completed"\`. Report delivery
-  under the contract below, follow one exact \`archiveRetry\` if needed, and stop.
-  New work may enter planning afterward; do not fabricate a run.
+  id/revision, fresh operation id, and \`kind: "completed"\`. Report delivery,
+  follow one exact \`archiveRetry\` if needed, and stop.
 - \`await-user-direction\` or blocked \`flow_feature_reset\`: call
-  \`flow_status { request: { view: "detail" } }\` exactly once, then distinguish
-  the projected status:
-  - Ready \`await-user-direction\` has no blocked run left to reset. Identify the
-    planned feature whose latest relevant reviewed outcome remains failed and
-    checkpoint unless the current aligned request explicitly authorizes its
-    retry. When authorized, call \`flow_run_start\` with that exact \`featureId\`;
-    never call \`flow_feature_reset\` from ready status or rely on default
-    selection.
-  - For blocked status, apply **Blocked review** below. If it permits another
-    feature run, pass that exact choice as \`nextFeatureId\` to
-    \`flow_feature_reset\` so reset and run start are atomic, then route its
-    returned projection; otherwise report the checkpoint and stop.
+  \`flow_status { request: { view: "detail" } }\` exactly once, then apply
+  **Blocked review**.
 - Running \`flow_feature_reset\`: the pending review is source-stale. Reset with
-  the same feature as \`nextFeatureId\` when continuing it, then route the returned
-  projection. Never redispatch that assignment.
+  the same feature as \`nextFeatureId\` when continuing it. Never redispatch that
+  assignment.
 - \`dispatch-flow-reviewer\`: read execution status. If that read errors, report
-  its exact summary and recovery when present and stop without dispatching; do
-  not infer a projection. Otherwise route that refreshed projection before
-  acting. Dispatch the recovered pending assignment under **Review and record**
-  only if \`nextAction\` is still \`dispatch-flow-reviewer\`. If it is now running
-  \`flow_feature_reset\`, follow the source-stale reset route and never dispatch
-  that assignment. Skip run start, implementation, and validation.
+  its exact summary and recovery when present and stop. Otherwise route that
+  refreshed projection. Dispatch under **Review** only if \`nextAction\` is still
+  \`dispatch-flow-reviewer\`. If it is now running \`flow_feature_reset\`, follow
+  the source-stale reset route.
 - \`flow_run_start\`: start the ready feature, refresh compact status, and read
   execution status.
-- \`flow_validation_start\`: read execution status and resume integration or
-  validation from the current worktree.
-- \`flow_review_start\`: read execution status and continue at **Review and
-  record** without fabricating another validation.
-- Any other action: report it and stop unless the runtime explicitly identifies
-  an active execution path.
-
-Use execution status for active scope/revision guards. Before editing, read the
-feature summary, targets, validation, dependencies, requirements, and decisions.
-If a projected action fails an environment-sensitive guard, refresh compact and
-handle that rejection; never force it.
-
-Summaries keep plan/source IDs \`verified\` or \`incomplete\`.
-Delivery handoff: report \`workflowData.delivery.report\` verbatim. Map IDs only from
-delivery \`outcomeSummary\`/\`terminalFindings\`; requirements are \`verified\`,
-\`incomplete\`, or explicitly \`deferred\`, and \`abandoned\` remains the kind.
-If delivery is absent, report exact recovery and no map; never invent or read
-detail solely for closure. On revision conflict, refresh compact; retry only for
-the same session and goal while status still permits the selected closure kind;
-never close a replacement.
-
-Preserve unrelated work and stay inside the feature. Out-of-plan work stops;
-finish or obtain explicit deferred/abandoned closure before a new plan. Never
-replan in place. Use \`flow_feature_reset\` for a wrong design or assumption; do
-not layer retries.
-
-## Evidence and risk preflight
-
-Before editing or dispatching a worker, perform one preflight from the approved
-feature and current worktree:
-
-- Preserve every named finding/requirement; map each to an observable acceptance
-  outcome.
-- Inventory each \`externalEvidence\` command, its platform, and where it writes a
-  JUnit report: arm it with \`resultsPath\` naming that file, or its declared cases go
-  unobserved and the entry stays open on exit zero.
-- Reuse one conversational run baseline of unrelated work, deletions, renames,
-  file types, and executable modes. Refresh changed facts; give each review only
-  facts the feature changes or depends on, and give final review the full
-  inventory.
-- Write one concise adversarial checklist covering failure and cleanup ordering,
-  adjacent states, repetition, retry, interruption, concurrency, overlapping
-  invariants, and relevant platform or persistence risks. For concurrency or
-  state-machine work, express it as a compact matrix with \`state/interleaving\`,
-  \`event\`, \`expected outcome\`, \`cleanup/invariant\`, and \`evidence\` columns.
-
-Carry the checklist/IDs through workers and review. Evidence needing user or
-external authority stops before implementation.
+- \`flow_validation_start\`: read execution status and resume from the current
+  worktree.
+- \`flow_review_start\`: read execution status and continue at **Review**.
+- Any other action: report it and stop.
+
+Use execution status for active scope and revision. Stay inside the feature.
+Out-of-plan work stops. Use \`flow_feature_reset\` for a wrong design; do not
+layer retries.
 
 ## Implement
 
-Make the smallest change satisfying the approved outcome and repository
-boundaries. Create no lifecycle, validation, audit, or handoff sidecars. A
-durable user-requested report is normally one stable Markdown artifact; JSON
-requires an explicit request.
+Make the smallest change that satisfies the approved outcome. Create no
+lifecycle or handoff sidecars. Do not stage, commit, push, publish, or mutate
+releases unless asked separately.
 
-Do not stage, commit, push, publish, or mutate releases unless asked separately.
+Work serially. After a feature run is active, dispatch \`flow-worker\` only for
+two or three genuinely independent slices with clear benefit. Workers call no
+Flow tools, spawn no children, and run no Bash. Integrate and inspect the
+combined diff before validation.
 
-## Bounded worker waves
+## Validate
 
-Work serially by default; existing authority covers a qualifying worker wave.
-After manager orientation, fan out only two or three genuinely independent,
-non-overlapping slices with clear benefit. Dispatch one cohort together if the
-host runs concurrent tasks, otherwise sequentially; report serial either way. Each
-assignment names a stable id, exact outcome/read-write scope, coverage, manager
-checks, dependencies, stop condition, and preflight risk checklist. The worker
-must receive the checklist before it codes. Shared contracts, lockfiles, and generated
-output stay manager-owned unless wholly assigned to one worker.
+Arm each evidence Bash command with \`flow_validation_start\` (current revision,
+feature id, exact command, \`scope\`) immediately before running it byte-for-byte.
+Flow records the host observation; copy no host-observed fields.
 
-Workers call no Flow tools, spawn no children, and run no Bash. Each returns
-status, scope/coverage, evidence/changed paths, manager checks, gaps/risks, and
-integration notes; missing or blocked output is a coverage gap.
+\`scope: "broad"\` runs the plan's gate evidence command and nothing else.
 
-After workers stop, reconcile paths/scopes and inspect combined diff/evidence
-before validation. At most one targeted follow-up wave may repair a slice,
-unlock a dependency, or verify a material claim; never a third. Create no
-coordination ledger/sidecar. After interruption, inspect status/worktree and
-treat partial worker edits as untrusted.
+A failed, incomplete, or source-drifted observation of a plan-listed command or
+of the declared gate command blocks review until that same command passes for
+current source.
 
-## Validate
+Every host-observed validation advances revision. The \`[flow-validation]\`
+marker reports \`passed\`, \`recordedRevision\`, and declared \`assertions\`. Use
+\`recordedRevision\` for the next \`flow_validation_start\`, or for
+\`flow_review_start\` only when \`passed: true\`. If the marker is absent, refresh
+compact status before mutating.
 
-Only validate after every worker has stopped and integration is settled. Choose
-checks from the changed behavior and risk:
-
-- Prefer focused behavioral tests that would fail without the change.
-- Cover persistence, integration, API, browser, accessibility, package, or
-  build paths when the feature touches them.
-- Typecheck, lint, build, and static inspection are indirect evidence; they are
-  sufficient alone only for genuinely mechanical or documentation-only work.
-- UI claims need visual inspection when a runnable target is available.
-- Cleanup claims need behavior-preservation evidence, not formatting alone.
-- \`scope: "broad"\` runs the plan's declared \`gate\` and nothing else; the runtime
-  refuses any other command at that scope.
-
-Immediately before each evidence Bash command, call \`flow_validation_start\`
-with current revision, feature id, exact command, and \`scope\` (\`focused\` or
-\`broad\`). Run it byte-for-byte next and inspect the complete outcome. Flow
-records the host observation; copy no host-observed fields into a later request.
-The command is durable, so include no secrets.
-
-A failed, incomplete, or source-drifted observation of a plan-listed command or of
-the declared \`gate\` blocks review until that same command passes for current
-source. No substitute discharges it; reverting the source revives nothing.
-
-A gate or \`externalEvidence\` command that cannot pass withholds completed closure,
-and reporting the blocker is half the move. Reach the passing command, or ask the
-user to choose deferred or abandoned closure. Ending the turn having done neither
-leaves the workflow with no next step, whatever the blocker was.
-
-Every host-observed validation advances the session revision, so the revision
-that armed a completed command is stale. The \`[flow-validation]\` marker reports
-\`passed\`, \`recordedRevision\`, and any declared \`assertions\` with what the report
-said about each. Use \`recordedRevision\` for the next
-\`flow_validation_start\`, or for \`flow_review_start\` only when \`passed: true\`. If
-the marker is absent or malformed, refresh compact status before mutating.
-
-Use focused validation for ordinary features. For the final feature, run the
-plan's declared \`gate\` at broad scope after the last relevant edit. A source edit
-invalidates earlier applicability. Failed or unavailable checks are blockers, not
-passing evidence.
-
-Immediately before review admission, reconcile the preflight inventory against the
-recorded current-source observations.
-
-## Review and record
+For the final feature, run the plan's gate command at broad scope after the
+last relevant edit.
+
+An evidence command that cannot pass withholds completed closure. Reach the
+passing command, or ask the user to choose deferred or abandoned closure.
+
+## Review
 
 After successful applicable validation, call \`flow_review_start\` with a fresh
-operation id, current revision, feature id, \`artifactsChanged\` listing every
-changed workspace-relative artifact path, and a bounded packet summary plus risk
-lenses.
-
-Keep the packet bounded. Map IDs to current-source commands or scenarios,
-environment, and results. Put the feature-specific risk checklist under
-\`Risks/Matrix:\`, representing it as a transition matrix for concurrency or
-state-machine work. Include \`Baseline:\` facts only when this feature changes or
-depends on them, except that final review receives the full inventory.
-Ordinary-review plan/source IDs are limited to active-feature mappings or IDs
-explicitly supplied for its packet; final review includes every approved
-requirement/feature ID. Omit empty optional sections; state \`none\` only for a relevant
-inspected absence. Never hide a gap.
-
-Dispatch only to reserved \`flow-reviewer\`; never review, copy, or submit its
-verdict in manager context. It reads the assignment/workspace and calls
-\`flow_feature_complete\` directly; runtime verifies the caller. It stays
-workspace-read-only, with that result submission as its sole lifecycle mutation.
+operation id, current revision, feature id, \`artifactsChanged\`, and a bounded
+packet. Dispatch only reserved \`flow-reviewer\`. Never review or submit its
+verdict in manager context.
 
 After dispatch, read compact status. On top-level error, report exact
-summary/recovery, say the latest lifecycle state could not be confirmed, and
-stop without further mutation. Do not claim this invocation made no lifecycle
-mutation: review may have started or recorded a result. Never invent or submit a
-verdict. If status remains running, apply the
-\`dispatch-flow-reviewer\` or running \`flow_feature_reset\` route above. If status
-is blocked, load detail through the single blocked route above. A recorded pass
-completes the feature.
+summary/recovery and stop without further mutation. If status remains running,
+apply the \`dispatch-flow-reviewer\` or running \`flow_feature_reset\` route. If
+status is blocked, apply **Blocked review**. A recorded pass completes the
+feature.
 
 ### Blocked review
 
-Follow \`nextAction\` with the one detail projection. The runtime already weighs
+Follow \`nextAction\` with the one detail projection for routing, then print
+compact \`findingsDigest\` as the user-facing list. The runtime already weighs
 \`failedReviewCount\` and \`blockedFeature.scopeBlocker\`.
 
-- \`await-user-direction\` means checkpoint. Do not reset.
-- \`flow_feature_reset\` permits one automatic reset under existing
-  implementation authority, with the blocked \`featureId\` as \`nextFeatureId\`.
-  That call atomically starts the fresh full retry. Fix only its blocking
+- Ready \`await-user-direction\` has no blocked run left to reset. Identify the
+  planned feature whose latest relevant reviewed outcome remains failed and
+  checkpoint unless the current aligned request explicitly authorizes its
+  retry. When authorized, call \`flow_run_start\` with that exact \`featureId\`.
+  Never call \`flow_feature_reset\` from ready status.
+- For blocked \`await-user-direction\`, checkpoint. Do not reset.
+- For blocked \`flow_feature_reset\`, one automatic reset is allowed under
+  existing implementation authority. Pass the blocked \`featureId\` as
+  \`nextFeatureId\` so reset and run start are atomic. Fix only its blocking
   findings, then run full validation and full independent review.
-- A feature whose latest relevant reviewed outcome remains failed is never
-  selected implicitly. \`/flow-auto\` may still continue an untouched,
-  dependency-independent feature. When every runnable candidate requires a
-  retry, compact status is \`ready\` with \`await-user-direction\`, handled by the
-  ready route above.
 - When \`failedReviewCount >= 2\`, retry only when the current aligned request
-  explicitly authorizes one additional attempt. Pass the blocked feature as
-  \`nextFeatureId\` on \`flow_feature_reset\`; if that attempt fails, checkpoint
-  again.
-- If explicit direction instead selects another planned,
-  dependency-independent feature, pass that feature's exact \`featureId\` as
-  \`nextFeatureId\` on \`flow_feature_reset\`. Reset supersedes the affected
-  attempts and starts that exact run in one transaction. Do not reset first,
-  call \`flow_run_start\` separately, or rely on default selection.
-
-When stopping blocked, label overall incomplete. Report the latest repair proved
-pending a passing review; recurring and new blockers; goal/progress; blocked
-feature, attempt, and failure count; completed/untouched features; latest
-validations and \`artifactsChanged\` as Flow-reported artifact evidence; Git/release
-mutation status; whether this request started and matched the goal; exact
-\`nextAction\`; and whether another attempt requires explicit authorization.
-
-Use that already-loaded compact status after every recorded outcome. Direct
-\`/flow-run\` reports this one feature's cumulative outcome and \`nextAction\`, then
+  explicitly authorizes one additional attempt.
+- If explicit direction selects another planned, dependency-independent
+  feature, pass that exact \`featureId\` as \`nextFeatureId\` on
+  \`flow_feature_reset\`.
+
+Direct \`/flow-run\` reports compact \`findingsDigest\` and \`nextAction\`, then
 stops. Under \`/flow-auto\`, return to its lifecycle loop.
 `;
 
@@ -677,7 +568,9 @@ var FLOW_MANAGER_KERNEL = [
   ].join(" "),
   [
     "- Make one automatic fresh full retry only when the projected `nextAction`",
-    "is `flow_feature_reset`; otherwise checkpoint."
+    "is `flow_feature_reset`; otherwise checkpoint.",
+    "On `await-user-direction` or a lease stop, print compact `findingsDigest`",
+    "without inventing ids."
   ].join(" "),
   [
     "- Before review, require current-source evidence appropriate to the changed outcome,",
@@ -725,9 +618,8 @@ var FLOW_WORKER_PROMPT = [
   "- Never edit .flow or .git metadata paths; the host denies those paths.",
   "- A read-only evidence slice must not edit files.",
   [
-    "- The assignment must include an adversarial acceptance and risk checklist,",
-    "represented as a transition matrix for concurrency or state-machine work, prepared before coding.",
-    "If it is missing, stop without editing and report the gap."
+    "- If the assignment includes a risk checklist or matrix, apply it before coding.",
+    "If required work would escape the assigned paths, stop and report the gap."
   ].join(" "),
   [
     "- An implementation slice may edit only the exact, non-overlapping write paths explicitly assigned by the manager.",
@@ -738,13 +630,7 @@ var FLOW_WORKER_PROMPT = [
     "- The manager owns integration, focused checks, and authoritative combined validation",
     "after all workers have stopped."
   ].join(" "),
-  [
-    "Before editing, apply the supplied risk coverage through its matrix rows when present:",
-    "primary behavior, failure and cleanup ordering, adjacent state transitions,",
-    "repeated or interrupted operation, overlapping invariants, and relevant persistence,",
-    "concurrency, security, compatibility, or file-metadata risks.",
-    "Preserve every named finding, requirement, or prior review ID in your handoff."
-  ].join(" "),
+  "- Preserve every named finding, requirement, or prior review ID in your handoff.",
   "## Handoff",
   [
     "Return exactly one concise handoff with `Status` (success, partial, or blocked),",
@@ -1089,6 +975,54 @@ function isFeatureId(value) {
   return FEATURE_ID_PATTERN.test(value);
 }
 
+// src/domain/session.ts
+function planEvidence(plan) {
+  return plan?.evidence ?? [];
+}
+function planGate(plan) {
+  return planEvidence(plan).find((entry) => entry.scope === "gate")?.command;
+}
+function featureKind(feature) {
+  return feature?.kind === "inspect" ? "inspect" : "change";
+}
+function reviewResultSemanticIssues(result) {
+  const issues = [];
+  const blocking = result.findings.some((finding) => finding.severity === "blocking");
+  for (const [index, finding] of result.findings.entries()) {
+    if (finding.severity === "blocking" && !finding.evidence?.trim()) {
+      issues.push({
+        path: ["findings", index, "evidence"],
+        message: "A blocking finding requires concrete evidence."
+      });
+    }
+    if (finding.scopeBlocker && finding.severity !== "blocking") {
+      issues.push({
+        path: ["findings", index, "scopeBlocker"],
+        message: "Only a blocking finding can be a scope blocker."
+      });
+    }
+  }
+  if (result.verdict === "failed" && !blocking) {
+    issues.push({
+      path: ["findings"],
+      message: "A failed review requires a blocking finding."
+    });
+  }
+  if (result.verdict === "passed" && blocking) {
+    issues.push({
+      path: ["findings"],
+      message: "A passed review cannot contain blocking findings."
+    });
+  }
+  if (result.terminalDisposition === "observed_unsubmitted" && result.verdict !== "failed") {
+    issues.push({
+      path: ["terminalDisposition"],
+      message: "Observed-but-unsubmitted review work must fail closed."
+    });
+  }
+  return issues;
+}
+
 // src/domain/test-results.ts
 var TESTCASE = /<testcase\b([^>]*?)(\/>|>([\s\S]*?)<\/testcase\s*>)/g;
 var ATTRIBUTE = /([\w:.-]+)\s*=\s*"([^"]*)"/g;
@@ -1202,7 +1136,7 @@ function narrowingArguments(command) {
 }
 function declaredAssertions(session, command) {
   return [
-    ...new Set((session.plan?.externalEvidence ?? []).filter((entry) => entry.command === command).flatMap((entry) => entry.assertions ?? []))
+    ...new Set(planEvidence(session.plan).filter((entry) => entry.command === command).flatMap((entry) => entry.assertions ?? []))
   ];
 }
 function sameAssertions(left, right) {
@@ -1241,7 +1175,7 @@ function recordValidation(session, input) {
     if (narrowing.length > 0) {
       throw new FlowTransitionError(`A broad observation cannot select which tests it runs (${narrowing.join(", ")}). Arm the repository's canonical gate, or record this command as focused.`);
     }
-    const gate = session.plan?.gate;
+    const gate = planGate(session.plan);
     if (gate !== undefined && input.command !== gate) {
       throw new FlowTransitionError(`A broad observation must run the plan-declared canonical gate (${gate}). Arm that exact command, or record this one as focused.`);
     }
@@ -1282,7 +1216,7 @@ function isObservedOnDeclaredPlatform(entry, observation) {
     return true;
   return observation.hostPlatform === entry.platform;
 }
-function externalEvidenceRefusal(session, entry, sourceDigest) {
+function evidenceRefusal(session, entry, sourceDigest) {
   const eligible = session.runs.flatMap((run) => run.validations).filter((observation) => observation.command === entry.command && isValidationEligible(observation, sourceDigest));
   const wrongHosts = [
     ...new Set(eligible.filter((observation) => !isObservedOnDeclaredPlatform(entry, observation)).map((observation) => observation.hostPlatform ?? "an unrecorded host"))
@@ -1292,18 +1226,21 @@ function externalEvidenceRefusal(session, entry, sourceDigest) {
   const detail = wrongHosts.length > 0 ? `passed on ${wrongHosts.join(", ")} but this entry declares ${entry.platform}, so that run observed something else — a skipped case exits zero too` : unmet ? `passed on ${entry.platform ?? "the declared host"} but reported no passing result for ${unmet.join(", ")}; arm it again with \`resultsPath\` naming the report the command writes, and make those cases run` : `needs ${needs}`;
   return `${JSON.stringify(entry.command)} (${detail}, for ${entry.requirement})`;
 }
-function unsatisfiedExternalEvidence(session, sourceDigest) {
-  const declared = session.plan?.externalEvidence ?? [];
+function unsatisfiedEvidence(session, sourceDigest) {
+  const declared = planEvidence(session.plan);
   if (declared.length === 0)
     return [];
   const observed = session.runs.flatMap((run) => run.validations);
   return declared.filter((entry) => !observed.some((observation) => observation.command === entry.command && isObservedOnDeclaredPlatform(entry, observation) && assertionsSatisfied(entry.assertions ?? [], observation.observedAssertions) && isValidationEligible(observation, sourceDigest)));
 }
+function unsatisfiedExtraEvidence(session, sourceDigest) {
+  return unsatisfiedEvidence(session, sourceDigest).filter((entry) => entry.scope === "extra");
+}
 function isValidationFresh(session, run, observation) {
   return session.runs.filter((candidate) => candidate.featureId === run.featureId).flatMap((candidate) => candidate.validations).every((candidate) => candidate.command !== observation.command || isValidationEligible(candidate) || candidate.recordedRevision < observation.recordedRevision);
 }
 function unresolvedVetoedCommands(session, run, sourceDigest) {
-  const gate = session.plan?.gate;
+  const gate = planGate(session.plan);
   const planned = session.approval === "approved" ? [
     ...session.plan?.features.find((candidate) => candidate.id === run.featureId)?.validation ?? [],
     ...gate === undefined ? [] : [gate]
@@ -1321,8 +1258,9 @@ function gateIssue(gate) {
   return narrowing.length === 0 ? null : `The plan's canonical gate cannot select which tests it runs (${narrowing.join(", ")}).`;
 }
 function planIssue(plan) {
-  if (plan.gate !== undefined) {
-    const issue = gateIssue(plan.gate);
+  const gate = planGate(plan);
+  if (gate !== undefined) {
+    const issue = gateIssue(gate);
     if (issue)
       return issue;
   }
@@ -1436,45 +1374,6 @@ function droppedFindingIds(session, featureId, findings) {
   return liveFindingIds(session, featureId).filter((id) => !submitted.has(id));
 }
 
-// src/domain/session.ts
-function reviewResultSemanticIssues(result) {
-  const issues = [];
-  const blocking = result.findings.some((finding) => finding.severity === "blocking");
-  for (const [index, finding] of result.findings.entries()) {
-    if (finding.severity === "blocking" && !finding.evidence?.trim()) {
-      issues.push({
-        path: ["findings", index, "evidence"],
-        message: "A blocking finding requires concrete evidence."
-      });
-    }
-    if (finding.scopeBlocker && finding.severity !== "blocking") {
-      issues.push({
-        path: ["findings", index, "scopeBlocker"],
-        message: "Only a blocking finding can be a scope blocker."
-      });
-    }
-  }
-  if (result.verdict === "failed" && !blocking) {
-    issues.push({
-      path: ["findings"],
-      message: "A failed review requires a blocking finding."
-    });
-  }
-  if (result.verdict === "passed" && blocking) {
-    issues.push({
-      path: ["findings"],
-      message: "A passed review cannot contain blocking findings."
-    });
-  }
-  if (result.terminalDisposition === "observed_unsubmitted" && result.verdict !== "failed") {
-    issues.push({
-      path: ["terminalDisposition"],
-      message: "Observed-but-unsubmitted review work must fail closed."
-    });
-  }
-  return issues;
-}
-
 // src/domain/transitions.ts
 function fail(message) {
   throw new FlowTransitionError(message);
@@ -1530,20 +1429,19 @@ function assertPlan(plan) {
   if (issue)
     fail(issue);
 }
-function assertDeclaredGate(plan) {
-  if (plan.gate === undefined) {
-    fail("A saved plan must declare `gate`: the exact canonical command that validates the whole repository, which every broad observation then has to run.");
+function assertDeclaredEvidence(plan) {
+  if (plan.evidence === undefined) {
+    fail('A saved plan must declare `evidence`: one `scope: "gate"` command that validates the whole repository, plus every extra observation this host may be unable to produce. Extra entries may be an empty list when the goal is fully observable here.');
   }
-}
-function assertDeclaredExternalEvidence(plan) {
-  if (plan.externalEvidence === undefined) {
-    fail("A saved plan must declare `externalEvidence`: every acceptance observation needing an environment this host may not be, each with the exact command whose passing is that observation. Declare an empty list when the goal is fully observable here.");
+  const gates = planEvidence(plan).filter((entry) => entry.scope === "gate");
+  if (gates.length !== 1) {
+    fail('A saved plan must declare exactly one `evidence` entry with `scope: "gate"`: the exact canonical command every broad observation then has to run.');
   }
-  if (plan.externalEvidence?.some((entry) => entry.platform === undefined)) {
-    fail("Every `externalEvidence` entry must declare `platform`: the operating system that can observe it (`win32`, `darwin`, or `linux`), or `other` when the missing environment is a service, credential, setting, or device rather than an OS. Flow compares an OS against the host the command actually ran on.");
+  if (plan.evidence.some((entry) => entry.platform === undefined)) {
+    fail("Every `evidence` entry must declare `platform`: the operating system that can observe it (`win32`, `darwin`, or `linux`), or `other` when the missing environment is a service, credential, setting, or device rather than an OS.");
   }
-  if (plan.externalEvidence?.some((entry) => entry.assertions === undefined)) {
-    fail("Every `externalEvidence` entry must declare `assertions`: the test case names whose passing is that observation, so a run cannot discharge it by exiting zero for a case that was skipped. Declare an empty list when the evidence is not a test result — a credential, a device, or a setting has no case names.");
+  if (plan.evidence.some((entry) => entry.assertions === undefined)) {
+    fail("Every `evidence` entry must declare `assertions`: the test case names whose passing is that observation. Declare an empty list when the evidence is not a test result.");
   }
 }
 function assertArtifacts(artifacts) {
@@ -1578,8 +1476,7 @@ function sessionStatus(session) {
 function savePlan(session, input, environment) {
   assertPlan(input.plan);
   if (!session) {
-    assertDeclaredGate(input.plan);
-    assertDeclaredExternalEvidence(input.plan);
+    assertDeclaredEvidence(input.plan);
     if (input.expectedRevision !== 0) {
       fail("A new Flow session must start from expectedRevision 0.");
     }
@@ -1609,8 +1506,7 @@ function savePlan(session, input, environment) {
   const replay = existingOperation(session, "plan-save", input.operationId, input);
   if (replay)
     return { session, value: null, replayed: true };
-  assertDeclaredGate(input.plan);
-  assertDeclaredExternalEvidence(input.plan);
+  assertDeclaredEvidence(input.plan);
   assertRevision(session, input.expectedRevision);
   assertMutable(session);
   if (session.approval === "approved")
@@ -1753,9 +1649,9 @@ function startReview(session, input, environment) {
   }
   const kind = isFinalFeatureRun(session, run) ? "final" : "feature";
   if (kind === "final") {
-    const unsatisfied = unsatisfiedExternalEvidence(session, input.sourceDigest);
+    const unsatisfied = unsatisfiedExtraEvidence(session, input.sourceDigest);
     if (unsatisfied.length > 0) {
-      fail(`Final review requires the plan's declared external evidence to pass for the current workspace content: ${unsatisfied.map((entry) => externalEvidenceRefusal(session, entry, input.sourceDigest)).join(", ")}. A substitute observation cannot discharge it. If the environment is unavailable, ask the user to choose deferred or abandoned closure.`);
+      fail(`Final review requires the plan's declared evidence to pass for the current workspace content: ${unsatisfied.map((entry) => evidenceRefusal(session, entry, input.sourceDigest)).join(", ")}. A substitute observation cannot discharge it. If the environment is unavailable, ask the user to choose deferred or abandoned closure.`);
     }
   }
   const applicable = run.validations.filter((validation) => isValidationEligible(validation, input.sourceDigest) && isValidationFresh(session, run, validation));
@@ -1830,6 +1726,7 @@ function completeFeature(session, input) {
     }
   }
   const findings = assignFindingIds(input.result.findings, findingIdPrefix(run.featureId, assignment.createdRevision));
+  const inspect = featureKind(session.plan?.features.find((feature) => feature.id === run.featureId)) === "inspect";
   const next = commit(session, "feature-complete", input.operationId, input, (draft, revision) => ({
     ...draft,
     runs: draft.runs.map((item) => {
@@ -1837,7 +1734,7 @@ function completeFeature(session, input) {
         return item;
       return {
         ...item,
-        state: input.result.verdict === "passed" ? "completed" : "blocked",
+        state: input.result.verdict === "passed" || inspect ? "completed" : "blocked",
         summary: input.summary,
         reviews: item.reviews.map((review) => review.id === assignment.id ? {
           ...review,
@@ -1932,12 +1829,12 @@ function closeSession(session, input) {
     fail("sessionId does not match active state.");
   assertMutable(session);
   if (input.kind === "completed" && sessionStatus(session) !== "completed") {
-    fail("A completed close requires every planned feature to pass review.");
+    fail("A completed close requires every planned feature to be complete.");
   }
   if (input.kind === "completed") {
-    const unsatisfied = unsatisfiedExternalEvidence(session);
+    const unsatisfied = unsatisfiedExtraEvidence(session);
     if (unsatisfied.length > 0) {
-      fail(`A completed close requires the plan's declared external evidence to have passed: ${unsatisfied.map((entry) => externalEvidenceRefusal(session, entry)).join(", ")}. Close deferred or abandoned instead.`);
+      fail(`A completed close requires the plan's declared evidence to have passed: ${unsatisfied.map((entry) => evidenceRefusal(session, entry)).join(", ")}. Close deferred or abandoned instead.`);
     }
   }
   let closure = null;
@@ -1992,8 +1889,14 @@ class ArchiveCollisionError extends Error {
 import { z } from "zod";
 
 // src/domain/session-invariants.ts
-function featurePassedBefore(session, featureId, revision) {
-  return session.runs.some((run) => run.featureId === featureId && run.reviews.some((review) => review.result?.verdict === "passed" && review.result.recordedRevision < revision));
+function featureSettledBefore(session, featureId, revision) {
+  const inspect = featureKind(session.plan?.features.find((feature) => feature.id === featureId)) === "inspect";
+  return session.runs.some((run) => run.featureId === featureId && run.reviews.some((review) => {
+    const result = review.result;
+    if (!result || result.recordedRevision >= revision)
+      return false;
+    return result.verdict === "passed" || inspect;
+  }));
 }
 function sessionInvariantIssues(session) {
   const issues = [];
@@ -2110,7 +2013,7 @@ function sessionInvariantIssues(session) {
       if (referenced.some((validation) => validation.recordedRevision >= review.createdRevision)) {
         issues.push(`Review '${review.id}' references later validation.`);
       }
-      const expectedKind = session.plan.features.every((feature) => feature.id === run.featureId || featurePassedBefore(session, feature.id, review.createdRevision)) ? "final" : "feature";
+      const expectedKind = session.plan.features.every((feature) => feature.id === run.featureId || featureSettledBefore(session, feature.id, review.createdRevision)) ? "final" : "feature";
       if (review.kind !== expectedKind) {
         issues.push(`Review '${review.id}' has the wrong derived kind.`);
       }
@@ -2128,7 +2031,10 @@ function sessionInvariantIssues(session) {
       issues.push(`Active run '${run.id}' contains a recorded outcome.`);
     }
     if (run.state === "completed" && last?.result?.verdict !== "passed") {
-      issues.push(`Completed run '${run.id}' lacks a passing review.`);
+      const inspect = featureKind(session.plan?.features.find((feature) => feature.id === run.featureId)) === "inspect";
+      if (!(inspect && last?.result?.verdict === "failed")) {
+        issues.push(`Completed run '${run.id}' lacks a passing review.`);
+      }
     }
     if (run.state === "blocked" && last?.result?.verdict !== "failed") {
       issues.push(`Blocked run '${run.id}' lacks a failed review.`);
@@ -2167,14 +2073,16 @@ var PlanFeatureSchema = z.object({
   summary: boundedText("Feature summary"),
   targets: z.array(boundedText("Feature target")).max(MAX_PLAN_FEATURES).default([]),
   validation: z.array(boundedText("Feature validation")).max(MAX_PLAN_FEATURES).default([]),
-  dependsOn: z.array(FeatureIdSchema).max(MAX_PLAN_FEATURES).default([])
+  dependsOn: z.array(FeatureIdSchema).max(MAX_PLAN_FEATURES).default([]),
+  kind: z.enum(["change", "inspect"]).optional()
 }).strict();
-var ExternalEvidenceSchema = z.object({
-  requirement: boundedText("External evidence requirement"),
-  environment: boundedText("External evidence environment"),
-  command: boundedText("External evidence command"),
+var EvidenceEntrySchema = z.object({
+  requirement: boundedText("Evidence requirement"),
+  environment: boundedText("Evidence environment"),
+  command: boundedText("Evidence command"),
+  scope: z.enum(["gate", "extra"]),
   platform: z.enum(EVIDENCE_PLATFORMS).optional(),
-  assertions: z.array(boundedText("External evidence assertion")).max(MAX_DECLARED_ASSERTIONS).optional()
+  assertions: z.array(boundedText("Evidence assertion")).max(MAX_DECLARED_ASSERTIONS).optional()
 }).strict();
 var ObservedAssertionSchema = z.object({
   name: boundedText("Observed assertion name"),
@@ -2186,8 +2094,7 @@ var PlanSchema = z.object({
   requirements: z.array(boundedText("Plan requirement")).max(MAX_PLAN_FEATURES).default([]),
   decisions: z.array(boundedText("Plan decision")).max(MAX_PLAN_FEATURES).default([]),
   features: z.array(PlanFeatureSchema).min(1).max(MAX_PLAN_FEATURES),
-  gate: boundedText("Plan gate").optional(),
-  externalEvidence: z.array(ExternalEvidenceSchema).max(MAX_PLAN_FEATURES).optional()
+  evidence: z.array(EvidenceEntrySchema).max(MAX_PLAN_FEATURES).optional()
 }).strict().superRefine((plan, context) => {
   if (encoder.encode(JSON.stringify(plan)).byteLength > MAX_PLAN_BYTES) {
     context.addIssue({
@@ -2377,6 +2284,69 @@ var StatusInputSchema = z.object({
   ])
 }).strict();
 
+// src/application/findings-digest.ts
+function plannedFeatureIds(session) {
+  if (session.plan)
+    return session.plan.features.map((feature) => feature.id);
+  const ids = [];
+  for (const run of session.runs) {
+    if (ids.includes(run.featureId))
+      continue;
+    ids.push(run.featureId);
+  }
+  return ids;
+}
+function findingsDigest(session) {
+  const rows = [];
+  const indexById = new Map;
+  for (const featureId of plannedFeatureIds(session)) {
+    for (const run of session.runs) {
+      if (run.featureId !== featureId)
+        continue;
+      for (const review of run.reviews) {
+        const result = review.result;
+        if (!result)
+          continue;
+        for (const finding of result.findings) {
+          if (!finding.findingId)
+            continue;
+          const row = {
+            featureId,
+            findingId: finding.findingId,
+            severity: finding.severity,
+            summary: finding.summary,
+            attempt: run.attempt,
+            verdict: result.verdict,
+            live: false,
+            ...finding.evidence === undefined ? {} : { evidence: finding.evidence }
+          };
+          const existing = indexById.get(finding.findingId);
+          if (existing === undefined) {
+            indexById.set(finding.findingId, rows.length);
+            rows.push(row);
+          } else {
+            rows[existing] = row;
+          }
+        }
+      }
+    }
+  }
+  return rows.map((row) => ({
+    ...row,
+    live: liveFindingIds(session, row.featureId).includes(row.findingId)
+  }));
+}
+function digestReportLines(digest) {
+  if (digest.length === 0)
+    return ["Findings digest: none"];
+  const line = (row, kind) => `- ${kind} ${row.featureId} ${row.findingId} ${row.severity}: ${row.summary}`;
+  return [
+    "Findings digest:",
+    ...digest.filter((row) => row.live).map((row) => line(row, "live")),
+    ...digest.filter((row) => !row.live).map((row) => line(row, "historical"))
+  ];
+}
+
 // src/application/delivery.ts
 var LIMITATIONS = [
   "Artifact paths and the canonical gate are caller declarations; Flow validates binding, not completeness or fitness.",
@@ -2413,23 +2383,23 @@ function assuranceProjection(session) {
     check("recorded-completion", "Recorded completion", "ts-enforced", structural, `${completed}/${features.length} features and ${passing}/${features.length} independent reviews pass, including a final review with no terminal blocker.`),
     check("accepted-validation", "Accepted validation", "host-attested", runs.length === features.length && runs.every((run) => accepted.some((observation) => observation.runId === run.id)), `${runs.filter((run) => accepted.some((item) => item.runId === run.id)).length}/${features.length} terminal runs have eligible host evidence accepted by review.`)
   ];
-  const gate = session.plan?.gate;
+  const gate = planGate(session.plan);
   checks.push(gate === undefined ? {
     id: "canonical-gate",
     label: "Canonical gate",
     tier: "caller-declared",
     status: "not-applicable",
-    explanation: "This legacy plan declared no canonical gate."
+    explanation: "This plan declared no canonical gate."
   } : check("canonical-gate", "Canonical gate", "host-attested", accepted.some((observation) => observation.command === gate && observation.scope === "broad"), `${JSON.stringify(gate)} must have eligible broad evidence accepted by review.`));
-  const declared = session.plan?.externalEvidence;
-  const missing = unsatisfiedExternalEvidence(session).length;
+  const declared = session.plan?.evidence;
+  const missing = unsatisfiedEvidence(session).length;
   checks.push(declared === undefined ? {
-    id: "external-evidence",
-    label: "Declared external evidence",
+    id: "declared-evidence",
+    label: "Declared evidence",
     tier: "caller-declared",
     status: "not-applicable",
-    explanation: "This legacy plan declared no external-evidence obligations."
-  } : check("external-evidence", "Declared external evidence", declared.length === 0 ? "caller-declared" : "host-attested", missing === 0, `${declared.length - missing}/${declared.length} declared obligations have eligible evidence on their declared host with named cases passing.`));
+    explanation: "This plan declared no evidence obligations."
+  } : check("declared-evidence", "Declared evidence", declared.length === 0 ? "caller-declared" : "host-attested", missing === 0, `${declared.length - missing}/${declared.length} declared obligations have eligible evidence on their declared host with named cases passing.`));
   return {
     conclusion: !complete ? "completion-not-claimed" : checks.some((item) => item.status === "unsatisfied") ? "completion-unsupported" : "completion-supported",
     checks,
@@ -2457,6 +2427,7 @@ function formatReport(delivery) {
     `Progress: ${delivery.progress.completed} of ${delivery.progress.total} features complete`,
     "Features:",
     ...lines,
+    ...digestReportLines(delivery.findingsDigest),
     `Assurance: ${delivery.assurance.conclusion.replaceAll("-", " ")}`,
     "Assurance checks:",
     ...delivery.assurance.checks.map((item) => `- ${item.status} [${TIER_LABELS[item.tier]}] ${item.label}: ${item.explanation}`),
@@ -2478,6 +2449,7 @@ function deliveryProjection(session) {
   const latest = grouped.flatMap(({ runs }) => runs.slice(-1));
   const latestArtifacts = new Set(latest.flatMap((run) => run.artifactsChanged.map((item) => item.path)));
   const allArtifacts = new Set(session.runs.flatMap((run) => run.artifactsChanged.map((item) => item.path)));
+  const digest = findingsDigest(session);
   const delivery = {
     goal: session.goal,
     closure: { kind: session.closure.kind, summary: session.closure.summary },
@@ -2493,17 +2465,15 @@ function deliveryProjection(session) {
         attempts: runs.length,
         latestState: run?.state ?? "not-started",
         outcomeSummary: run?.summary ?? null,
-        terminalFindings: run?.reviews.at(-1)?.result?.findings.map(({ severity, summary }) => ({
-          severity,
-          summary
-        })) ?? []
+        terminalFindings: digest.filter((row) => row.featureId === feature.id && row.live).map(({ severity, summary }) => ({ severity, summary }))
       };
     }),
     reportedArtifacts: {
       latestAttempts: [...latestArtifacts].sort(),
       supersededAttemptsOnly: [...allArtifacts].filter((path) => !latestArtifacts.has(path)).sort()
     },
-    assurance: assuranceProjection(session)
+    assurance: assuranceProjection(session),
+    findingsDigest: digest
   };
   return { ...delivery, report: formatReport(delivery) };
 }
@@ -2579,7 +2549,8 @@ function compactProjection(session, pendingReviewSourceStale = false) {
     blockedFeature,
     progress: featureProgress(session),
     nextAction: nextAction(session, pendingReviewSourceStale, blockedFeature),
-    archiveRetry: retryRequest ? { request: retryRequest } : null
+    archiveRetry: retryRequest ? { request: retryRequest } : null,
+    findingsDigest: findingsDigest(session)
   };
 }
 function archivedProjection(session) {
@@ -2637,9 +2608,8 @@ function reviewerProjection(session, assignmentId) {
         validation: [...candidate.validation],
         dependsOn: [...candidate.dependsOn]
       })),
-      ...plan.gate === undefined ? {} : { gate: plan.gate },
-      ...plan.externalEvidence === undefined ? {} : {
-        externalEvidence: plan.externalEvidence.map((entry) => ({
+      ...plan.evidence === undefined ? {} : {
+        evidence: plan.evidence.map((entry) => ({
           ...entry
         }))
       }
@@ -2668,7 +2638,8 @@ function idleProjection(view) {
     view,
     status: "idle",
     revision: 0,
-    nextAction: "flow_plan_save"
+    nextAction: "flow_plan_save",
+    findingsDigest: []
   };
 }
 function project(session, request, pendingReviewSourceStale = false) {
@@ -3919,6 +3890,10 @@ var CONTINUATION_ROUTE = [
   "for a fresh close use compact session id/revision plus a fresh operation id,",
   "and replay archiveRetry exactly from its projected request."
 ].join(" ");
+var HANDBACK_ROUTE = [
+  "Call flow_status with the compact view first.",
+  "Print findingsDigest as the user-facing list. Do not invent ids."
+].join(" ");
 function inspectMessage(parts) {
   let token = null;
   let text = "";
@@ -3944,6 +3919,9 @@ function isCheckpoint(projection) {
 function isPendingReviewer(projection) {
   return projection.status === "running" && projection.nextAction === "dispatch-flow-reviewer";
 }
+function isHandback(projection) {
+  return projection.status === "blocked" || projection.nextAction === "flow_feature_reset" || projection.nextAction === "dispatch-flow-reviewer";
+}
 
 class AutoDriveCoordinator {
   #lease = null;
@@ -3993,6 +3971,31 @@ class AutoDriveCoordinator {
     lease.lastPromptedRevision = null;
     this.#setTiming("waiting-for-user");
   }
+  async#promptHandback(lease, projection) {
+    if (!isHandback(projection))
+      return;
+    if (lease.handbackPromptedRevision === projection.revision)
+      return;
+    if (!lease.delivery)
+      return;
+    lease.handbackPromptedRevision = projection.revision;
+    lease.messageId = null;
+    this.#setTiming("active");
+    lease.inFlight = "prompt";
+    try {
+      const handback = [
+        `Flow is handing control back at compact revision ${projection.revision}.`,
+        HANDBACK_ROUTE,
+        `Then follow ${projection.nextAction} or stop at await-user-direction.`,
+        "Do not expand the approved goal."
+      ].join(" ");
+      await this.#options.prompt(lease.hostSessionId, `${handback}
+
+${FLOW_MANAGER_KERNEL}`, lease.delivery, { [FLOW_AUTO_METADATA_KEY]: lease.token });
+    } catch (error) {
+      this.#stop(lease, `Flow auto prompt failed: ${String(error)}`);
+    }
+  }
   async#read(lease) {
     try {
       return await this.#options.readProjection();
@@ -4015,6 +4018,7 @@ class AutoDriveCoordinator {
       baseline: null,
       delivery: null,
       lastPromptedRevision: null,
+      handbackPromptedRevision: null,
       checkpoint: null,
       pendingReply: false,
       inFlight: null,
@@ -4211,8 +4215,12 @@ ${FLOW_MANAGER_KERNEL}`;
       const mutationAdvanced = advance !== undefined && projection.revision === advance && isMechanical(projection);
       if (lease.pendingReply) {
         lease.pendingReply = false;
-        if (boundary && (!checkpoint || projection.revision > checkpoint.revision))
+        if (boundary && (!checkpoint || projection.revision > checkpoint.revision)) {
+          await this.#promptHandback(lease, projection);
+          if (this.#lease !== lease)
+            return;
           return void this.#waitAt(lease, projection.revision);
+        }
         if (!checkpoint || !boundary && !mutationAdvanced)
           return void this.deactivate(hostSessionId);
         checkpoint.answered = true;
@@ -4222,15 +4230,27 @@ ${FLOW_MANAGER_KERNEL}`;
       if (boundary) {
         if (checkpoint && projection.revision < checkpoint.revision)
           return void this.deactivate(hostSessionId);
+        await this.#promptHandback(lease, projection);
+        if (this.#lease !== lease)
+          return;
         return void this.#waitAt(lease, projection.revision);
       }
+      if (!isMechanical(projection)) {
+        const already = lease.handbackPromptedRevision === projection.revision;
+        await this.#promptHandback(lease, projection);
+        if (this.#lease !== lease)
+          return;
+        if (!already && lease.handbackPromptedRevision === projection.revision) {
+          this.#setTiming("paused");
+          return;
+        }
+        return void this.deactivate(hostSessionId);
+      }
       if (checkpoint) {
         if (projection.revision <= checkpoint.revision || !mutationAdvanced)
           return void this.deactivate(hostSessionId);
         lease.checkpoint = null;
       }
-      if (!isMechanical(projection))
-        return void this.deactivate(hostSessionId);
       if (lease.lastPromptedRevision === projection.revision) {
         this.#setTiming("paused");
         return this.#warn(`Flow auto-drive paused after revision ${projection.revision} made no lifecycle progress.`);
@@ -4498,7 +4518,8 @@ var planFeature = host.object({
   summary: text,
   targets: host.array(text).max(MAX_PLAN_FEATURES).default([]),
   validation: host.array(text).max(MAX_PLAN_FEATURES).default([]),
-  dependsOn: host.array(featureId).max(MAX_PLAN_FEATURES).default([])
+  dependsOn: host.array(featureId).max(MAX_PLAN_FEATURES).default([]),
+  kind: host.enum(["change", "inspect"]).optional()
 }).strict();
 var plan = host.object({
   summary: text,
@@ -4506,11 +4527,11 @@ var plan = host.object({
   requirements: host.array(text).max(MAX_PLAN_FEATURES).default([]),
   decisions: host.array(text).max(MAX_PLAN_FEATURES).default([]),
   features: host.array(planFeature).min(1).max(MAX_PLAN_FEATURES),
-  gate: text.optional(),
-  externalEvidence: host.array(host.object({
+  evidence: host.array(host.object({
     requirement: text,
     environment: text,
     command: text,
+    scope: host.enum(["gate", "extra"]),
     platform: host.enum(EVIDENCE_PLATFORMS).optional(),
     assertions: host.array(text).max(MAX_DECLARED_ASSERTIONS).optional()
   }).strict()).max(MAX_PLAN_FEATURES).optional()
@@ -4617,12 +4638,14 @@ function toolError(error) {
     }
   });
 }
-function withAutoContext(response, options) {
+function withAutoContext(response, options, view) {
   let workflowData = response.workflowData;
   try {
-    const timing = options.autoTimingSnapshot?.();
-    if (timing)
-      workflowData = { ...workflowData, autoTiming: timing };
+    if (view === "detail") {
+      const timing = options.autoTimingSnapshot?.();
+      if (timing)
+        workflowData = { ...workflowData, autoTiming: timing };
+    }
   } catch {}
   try {
     const support = options.autoContinuationSupport?.();
@@ -4669,7 +4692,7 @@ function createTools(_ctx, options) {
     flow_status: tool({
       description: "Read compact, execution, detail, or reviewer Flow state.",
       args: StatusArgs,
-      execute: (args, context) => execute(context, async (workspace) => withAutoContext(await flowStatus(workspace, args), options))
+      execute: (args, context) => execute(context, async (workspace) => withAutoContext(await flowStatus(workspace, args), options, args.request.view))
     }),
     flow_plan_save: tool({
       description: "Create or replace the active draft plan.",
@@ -5139,4 +5162,4 @@ export {
   plugin_default as default
 };
 
-//# debugId=719465FC0656BBA564756E2164756E21
+//# debugId=4CB19287BD614D3B64756E2164756E21