opencode-plugin-flow 6.1.0 → 6.3.0

package/dist/index.js

@@ -7,10 +7,12 @@ description: Manage a Flow goal from planning through implementation, validation
 # Flow
 
 Flow is a small state ledger around ordinary coding work. The root manager owns
-the session, every state-changing \`flow_*\` call, integration, validation,
-review dispatch, reset, and closure. Bounded \`flow-worker\` instances may
-contribute disjoint work inside the active feature. The reserved \`flow-reviewer\`
-independently reviews; it never edits or mutates Flow state.
+the session, integration, validation, review dispatch, reset, closure, and every
+lifecycle mutation except review submission. Bounded \`flow-worker\`
+instances may contribute disjoint work inside the active feature. The reserved
+\`flow-reviewer\` independently reviews and submits its own result through
+\`flow_feature_complete\`; it cannot edit the workspace or make any other
+lifecycle mutation.
 
 ## Route from status
 
@@ -37,9 +39,10 @@ report that the plugin is not fully loaded instead of simulating state changes.
 - Only one durable feature run is active at a time. Conversation-local worker
   waves do not create additional runs or Flow state.
 - Work stays inside the active feature and preserves unrelated user changes.
-- A passing feature needs successful current-source validation and one
-  independent reviewer assignment. The final feature uses broad validation and
-  a final review; it does not add a second review pass.
+- A passing feature needs successful current-source validation and one result
+  submitted directly by the assigned independent reviewer. The final feature
+  uses broad validation and a final review; it does not add a second review
+  pass.
 - A failed review is recorded honestly. Any retry is a fresh run with full
   validation and review.
 - Use runtime revisions and operation ids for ordering and idempotency. Supply
@@ -53,7 +56,13 @@ report that the plugin is not fully loaded instead of simulating state changes.
 
 On confusion or interruption, read compact status and follow its next action.
 Use execution status for the active feature and reviewer status for a returned
-assignment id. If status is closed with \`archiveRetry\`, call
+assignment id. Redispatch a pending assignment after interruption or an
+unconfirmed reviewer return; the manager never invents or submits a verdict. If
+completion reports \`Workspace content changed after review started\`, call
+\`flow_feature_reset\`; that source-stale assignment must not be redispatched.
+Start a fresh run and repeat full validation and review. After the reviewer
+returns, read compact status to learn the durable outcome. If status is closed
+with \`archiveRetry\`, call
 \`flow_session_close\` with that projected request byte-for-byte; do not create a
 new operation id or revision. Never infer completion, retry count, or closure
 from prose.
@@ -126,26 +135,30 @@ document in the repository unless the user explicitly requests one.
 // skills/flow-review/SKILL.md
 var SKILL_default3 = `---
 name: flow-review
-description: Independently review one runtime-owned Flow assignment. Reserved for the read-only flow-reviewer; managers dispatch assignments but do not perform this review themselves.
+description: Independently review one runtime-owned Flow assignment. Reserved for the workspace-read-only flow-reviewer; managers dispatch assignments but do not perform this review themselves.
 ---
 
 # Flow Review
 
 You are the independent \`flow-reviewer\`. Review the assigned work; do not fix
 it. You may read relevant files and supplied evidence, but must not edit files,
-read outside the workspace, run commands, launch workers, or call any
-state-changing \`flow_*\` tool. Only the root manager records the result.
+read outside the workspace, run commands, or launch workers. You may call only
+\`flow_status\` to read this assignment and \`flow_feature_complete\` to submit its
+exact result. The latter is your sole lifecycle mutation.
 
 ## Recover the assignment
 
 When given an assignment id, call only
 \`flow_status { request: { view: "reviewer", assignmentId: "..." } }\`. Use its
-bounded packet and approved-plan context instead of reconstructing feature,
-source, revision, validation, or lifecycle data from conversation memory.
+bounded packet, assignment-linked validations, approved-plan context, and
+completed feature IDs instead of reconstructing feature, source,
+revision, validation, or lifecycle data from conversation memory.
 
-If the assignment or evidence required to justify a verdict is unavailable,
-return a failed result with a blocking evidence-gap finding. Never invent
-validation, identity, or time.
+If the reviewer projection is available but evidence required to justify a
+verdict is missing, submit a failed result with a blocking evidence-gap finding.
+If the assignment itself is unavailable, report that failure without another
+state change so the manager can inspect compact status. Never invent validation,
+identity, revision, or time.
 
 ## Review
 
@@ -160,6 +173,12 @@ the manager's summary. Check that:
 - persistence, concurrency, security, migration, package, UI, and recovery
   risks were examined when relevant.
 
+Validation scope is a claim. Treat \`broad\` as adequate only when the durable
+command is the repository's canonical applicable gate or a justified equivalent
+for the delivered state. 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.
+
 For a final assignment, also trace every approved requirement and feature to
 the delivered result, inspect broad validation, and confirm docs, commands,
 package surfaces, and remaining gaps are consistent with completion. The final
@@ -170,25 +189,40 @@ approved outcome; otherwise use \`advisory\`. Every blocker needs a precise
 summary. Every blocker must cite a changed artifact and location, or identify
 the exact missing evidence or unmet approved requirement in \`evidence\`.
 
-## Return one result
+## Submit one result
 
-Return exactly one assignment result:
+Call \`flow_feature_complete\` directly with the assignment id, current reviewer
+projection revision and feature id, a fresh operation id, a concise summary,
+and exactly one assignment result:
 
 \`\`\`json
 {
-  "assignmentId": "review-assignment:runtime-id",
-  "verdict": "passed",
-  "findings": [],
-  "terminalDisposition": "submitted"
+  "request": {
+    "operationId": "review-submit:fresh-id",
+    "expectedRevision": 12,
+    "featureId": "approved-feature-id",
+    "assignmentId": "review-assignment:runtime-id",
+    "summary": "Concise reviewed outcome.",
+    "result": {
+      "verdict": "passed",
+      "findings": [],
+      "terminalDisposition": "submitted"
+    }
+  }
 }
 \`\`\`
 
 Each finding contains \`severity\`, \`summary\`, and optional \`evidence\`. Use
-\`verdict: "failed"\` whenever any blocking finding remains. The manager copies
-\`verdict\`, \`findings\`, and \`terminalDisposition\` under
-\`flow_feature_complete.request.result\` and supplies \`assignmentId\` beside that
-result. Do not return or invent run ids, revisions, source hashes, validation
-records, timestamps, review modes, or attempt fields.
+\`verdict: "failed"\` whenever any blocking finding remains. Do not return or
+invent run ids, source hashes, validation records, timestamps, review modes, or
+attempt fields. Never ask the manager to copy or submit your verdict.
+
+After the tool returns, report its durable outcome concisely. If submission
+fails, report the exact failure. For \`Workspace content changed after review
+started\`, tell the manager to reset the feature and do not recommend redispatch;
+the source-stale assignment cannot complete. After an interruption with no
+accepted result, the manager may recover the pending assignment. Never
+downgrade, fabricate, or hand off a result for manager submission.
 
 Approve only what you actually inspected. Missing coverage is a finding, never
 a reason to lower the bar.
@@ -202,10 +236,11 @@ description: Implement, validate, independently review, and record one approved
 
 # Flow Run
 
-Work on exactly one approved feature. The root manager owns the session, every
-state-changing \`flow_*\` call, integration, validation, review dispatch, reset,
-and closure. Bounded \`flow-worker\` instances may contribute disjoint work; the
-reserved \`flow-reviewer\` owns the independent review.
+Work on exactly one approved feature. The root manager owns the session,
+integration, validation, review dispatch, reset, closure, and every
+lifecycle mutation except review submission. Bounded \`flow-worker\`
+instances may contribute disjoint work; the reserved \`flow-reviewer\` owns the
+independent review and submits its own result.
 
 ## Start and scope
 
@@ -235,26 +270,29 @@ that separate action.
 
 Work serially by default. After manager orientation, fan out only when at least
 two genuinely independent slices can be named. Run one cohort of two or three
-\`flow-worker\` instances at a time. Launch the cohort concurrently through
-OpenCode's native task/subagent facility; do not wait for one slice before
-launching the next. Each prompt must name a stable slice id, the exact outcome
-and read or write scope, expected coverage and checks, dependencies, and a stop
-condition. Edit scopes must be exact and non-overlapping. Shared contracts,
-lockfiles, and generated outputs remain manager-owned unless one worker
-receives the whole relevant scope.
+\`flow-worker\` instances at a time. Issue every cohort Task call in the same
+assistant tool-use turn before consuming any result. If the host or model
+serializes those calls, treat and report that execution as serial instead of
+claiming parallelism. Each prompt must name a stable slice id, the exact outcome
+and read or write scope, expected coverage, recommended manager checks,
+dependencies, and a stop condition. Edit scopes must be exact and
+non-overlapping. Shared contracts, lockfiles, and generated outputs remain
+manager-owned unless one worker receives the whole relevant scope.
 
 Workers cannot call Flow tools or spawn children. Each returns one concise
 handoff containing status, scope and coverage, evidence or changed paths,
-checks, gaps and risks, and integration notes. Missing, partial, or blocked
-output remains an explicit coverage gap; worker checks are advisory.
+recommended manager checks, gaps and risks, and integration notes. Workers do
+not run Bash; all executable checks remain manager-owned. Missing, partial, or
+blocked output remains an explicit coverage gap.
 
-After all workers stop, inspect the combined diff and evidence and reconcile
+After all workers stop, compare actual changed paths with every assigned scope,
+then inspect the combined diff and evidence and reconcile unexpected paths or
 conflicts before validation. At most one targeted follow-up wave may address a
-failed slice, newly unlocked dependency, or material claim verification. Do not
-start an automatic third wave. Coordination stays in the conversation: create
-no manifest, sidecar, Session field, durable handoff, or recovery ledger. After
-an interruption, inspect Flow status and the worktree and treat partial worker
-edits as untrusted.
+failed slice, newly unlocked dependency, or material claim verification. Do
+not start an automatic third wave. Coordination stays in the conversation:
+create no manifest, sidecar, Session field, durable handoff, or recovery ledger.
+After an interruption, inspect Flow status and the worktree and treat partial
+worker edits as untrusted.
 
 ## Validate
 
@@ -268,17 +306,25 @@ checks from the changed behavior and risk:
   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"\` is a claim about coverage, not a stronger label. Use it only
+  for the repository's canonical applicable gate or a justified equivalent
+  that covers the delivered repository state.
 
 Immediately before each Bash command used as evidence, call
 \`flow_validation_start\` with the current revision, feature id, the exact
 command, and \`scope\` (\`focused\` or \`broad\`). Run that byte-for-byte command next
 and inspect its complete outcome. Flow records the host-observed result directly
-in the session; do not copy host-observed fields into a later request.
+in the session; do not copy host-observed fields into a later request. The exact
+command is durable, so never inline tokens, passwords, credentials, or other
+secrets. Raw output is deliberately neither persisted nor projected: the
+durable evidence is the command, exit code, output completeness, and output
+digest, while the manager must inspect the live output.
 
 Use focused validation for ordinary features. For the final feature, run the
 repository's broad applicable gate after the last relevant edit. A source edit
 invalidates earlier applicability. Failed or unavailable checks are blockers,
-not passing evidence.
+not passing evidence. If the canonical gate cannot run, explain why the chosen
+equivalent is broad enough; otherwise record the narrower evidence as focused.
 
 ## Review and record
 
@@ -292,9 +338,19 @@ automatically and derives \`feature\` versus \`final\` review from plan progress
 callers do not supply the review kind.
 
 Dispatch the returned assignment only to the reserved \`flow-reviewer\`. Do not
-perform the independent review in manager context. Submit its exact assignment
-result through \`flow_feature_complete\` with fresh guards. A pass completes the
-feature; a blocking finding records a blocked outcome.
+perform the independent review in manager context and never copy or submit its
+verdict. The reviewer reads its assignment, inspects the workspace, and calls
+\`flow_feature_complete\` directly; the runtime verifies the calling agent. The
+reviewer remains workspace-read-only and may make only this exact result
+submission as its sole lifecycle mutation.
+
+After the reviewer returns, read compact status rather than treating prose as
+the outcome. Redispatch the same pending assignment after interruption or an
+unconfirmed reviewer return. If submission reports \`Workspace content changed
+after review started\`, call \`flow_feature_reset\` and do not redispatch that
+source-stale assignment; start a fresh run and repeat full validation and
+review. Never fabricate a verdict. A submitted pass completes the feature; a
+submitted blocking finding records a blocked outcome.
 
 If repair is authorized after a failed review, reset the feature, fix it, and
 repeat full validation and full review in a fresh run.
@@ -348,9 +404,11 @@ You may run concurrently with sibling workers. Do not enter their scopes, assume
 - Use the manager assignment as your only source of Flow lifecycle context. Do not call any \`flow_*\` tool, including \`flow_status\`.
 - Do not delegate, spawn subtasks, or load skills.
 - Do not stage, commit, push, publish, or create a release.
+- Do not run Bash commands. The manager owns every executable check.
+- Never edit .flow or .git metadata paths; the host denies those paths.
 - A read-only evidence slice must not edit files.
 - An implementation slice may edit only the exact, non-overlapping write paths explicitly assigned by the manager. If required work would escape those paths, stop and return a partial or blocked handoff instead of expanding scope.
-- Run only checks relevant to the assigned slice. These checks are advisory: the manager owns integration and performs authoritative combined validation after all workers have stopped.
+- Use only non-shell inspection relevant to the assigned slice. The manager owns integration, focused checks, and authoritative combined validation after all workers have stopped.
 
 ## Handoff
 
@@ -365,8 +423,8 @@ success | partial | blocked
 ## Findings / changed paths
 - Evidence found or exact paths changed
 
-## Checks
-- Commands run and outcomes, or not run with reason
+## Recommended manager checks
+- Exact checks the manager should run, or none
 
 ## Gaps & risks
 - Missing coverage, blockers, conflicts, or none
@@ -410,7 +468,7 @@ function compileFlowPromptSurface(surface) {
       return [
         "# Flow review command",
         "",
-        "Run this assignment only as the reserved `flow-reviewer`. The reviewer is independent and read-only; it must not edit files or mutate Flow state.",
+        "Run this assignment only as the reserved `flow-reviewer`. The reviewer is independent and workspace-read-only; it may read reviewer status and submit only its own result through `flow_feature_complete`.",
         "",
         "Assignment: $ARGUMENTS"
       ].join(`
@@ -431,7 +489,7 @@ var FLOW_CORE_AGENTS = {
   "flow-reviewer": {
     mode: "subagent",
     hidden: true,
-    description: "Independent read-only reviewer for one Flow assignment.",
+    description: "Independent workspace-read-only reviewer that submits one Flow result.",
     prompt: compileFlowPromptSurface("flow-reviewer"),
     permission: {
       edit: "deny",
@@ -440,7 +498,8 @@ var FLOW_CORE_AGENTS = {
       skill: "deny",
       task: { "*": "deny" },
       "flow_*": "deny",
-      flow_status: "allow"
+      flow_status: "allow",
+      flow_feature_complete: "allow"
     }
   },
   "flow-worker": {
@@ -449,8 +508,14 @@ var FLOW_CORE_AGENTS = {
     description: "Bounded worker for one read-only evidence or exact-scope implementation slice.",
     prompt: compileFlowPromptSurface("flow-worker"),
     permission: {
-      edit: "ask",
-      bash: "ask",
+      edit: {
+        "*": "allow",
+        ".flow": "deny",
+        ".flow/**": "deny",
+        ".git": "deny",
+        ".git/**": "deny"
+      },
+      bash: "deny",
       external_directory: "deny",
       skill: "deny",
       task: { "*": "deny" },
@@ -475,7 +540,7 @@ var FLOW_CORE_COMMANDS = {
     template: compileFlowPromptSurface("flow-run")
   },
   "flow-review": {
-    description: "Run one independent read-only Flow review",
+    description: "Run one independent workspace-read-only Flow review",
     agent: "flow-reviewer",
     subtask: true,
     template: compileFlowPromptSurface("flow-review")
@@ -695,6 +760,39 @@ function planIssue(plan) {
   return visited === plan.features.length ? null : "The plan dependency graph is cyclic.";
 }
 
+// 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 (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
 class FlowTransitionError extends Error {
   code = "FLOW_TRANSITION_REJECTED";
@@ -1030,19 +1128,9 @@ function assertReviewResult(result) {
   if (result.findings.length > MAX_REVIEW_FINDINGS) {
     fail(`A review may contain at most ${MAX_REVIEW_FINDINGS} findings.`);
   }
-  const blocking = result.findings.some((finding) => finding.severity === "blocking");
-  const unsupported = result.findings.some((finding) => finding.severity === "blocking" && !finding.evidence?.trim());
-  if (unsupported)
-    fail("A blocking finding requires concrete evidence.");
-  if (result.verdict === "failed" && !blocking) {
-    fail("A failed review requires a blocking finding.");
-  }
-  if (result.verdict === "passed" && blocking) {
-    fail("A passed review cannot contain a blocking finding.");
-  }
-  if (result.terminalDisposition === "observed_unsubmitted" && result.verdict !== "failed") {
-    fail("Observed-but-unsubmitted review work must fail closed.");
-  }
+  const issue = reviewResultSemanticIssues(result)[0];
+  if (issue)
+    fail(issue.message);
 }
 function completeFeature(session, input) {
   assertReviewResult(input.result);
@@ -1419,6 +1507,7 @@ function boundedText(label, options) {
 }
 var FeatureIdSchema = z.string().max(MAX_SESSION_ID_LENGTH).regex(FEATURE_ID_PATTERN, FEATURE_ID_MESSAGE);
 var OperationIdSchema = z.string().min(1).max(128).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]*$/);
+var ReviewAssignmentIdSchema = z.string().min(1).max(256);
 var RevisionSchema = z.number().int().safe().nonnegative();
 var SourceDigestSchema = z.custom((value) => typeof value === "string" && /^sha256:[a-f0-9]{64}$/.test(value), "Expected a sha256: content digest.");
 var PlanFeatureSchema = z.object({
@@ -1453,36 +1542,8 @@ var PublicReviewResultSchema = z.object({
   findings: z.array(ReviewFindingSchema).max(MAX_REVIEW_FINDINGS).default([]),
   terminalDisposition: z.enum(["submitted", "observed_unsubmitted"])
 }).strict().superRefine((result, context) => {
-  const blocking = result.findings.some((finding) => finding.severity === "blocking");
-  for (const [index, finding] of result.findings.entries()) {
-    if (finding.severity === "blocking" && !finding.evidence) {
-      context.addIssue({
-        code: "custom",
-        path: ["findings", index, "evidence"],
-        message: "A blocking finding requires concrete evidence."
-      });
-    }
-  }
-  if (result.verdict === "failed" && !blocking) {
-    context.addIssue({
-      code: "custom",
-      path: ["findings"],
-      message: "A failed review requires a blocking finding."
-    });
-  }
-  if (result.verdict === "passed" && blocking) {
-    context.addIssue({
-      code: "custom",
-      path: ["findings"],
-      message: "A passed review cannot contain blocking findings."
-    });
-  }
-  if (result.terminalDisposition === "observed_unsubmitted" && result.verdict !== "failed") {
-    context.addIssue({
-      code: "custom",
-      path: ["terminalDisposition"],
-      message: "Observed-but-unsubmitted review work must fail closed."
-    });
+  for (const issue of reviewResultSemanticIssues(result)) {
+    context.addIssue({ code: "custom", ...issue });
   }
 });
 var ValidationObservationSchema = z.object({
@@ -1502,7 +1563,7 @@ var ArtifactSchema = z.object({
   path: boundedText("Artifact path", { maxBytes: MAX_PATH_BYTES }).refine(isArtifactPath, ARTIFACT_PATH_MESSAGE)
 }).strict();
 var ReviewAssignmentSchema = z.object({
-  id: z.string().min(1).max(256),
+  id: ReviewAssignmentIdSchema,
   operationId: OperationIdSchema,
   featureId: FeatureIdSchema,
   runId: z.string().min(1).max(256),
@@ -1600,7 +1661,7 @@ var FeatureCompleteInputSchema = z.object({
   request: z.object({
     ...guarded,
     featureId: FeatureIdSchema,
-    assignmentId: z.string().min(1).max(256),
+    assignmentId: ReviewAssignmentIdSchema,
     summary: boundedText("Feature result summary"),
     result: PublicReviewResultSchema
   }).strict()
@@ -1631,7 +1692,7 @@ var StatusInputSchema = z.object({
     z.object({ view: z.literal("execution") }).strict(),
     z.object({
       view: z.literal("reviewer"),
-      assignmentId: z.string().min(1).max(256)
+      assignmentId: ReviewAssignmentIdSchema
     }).strict()
   ])
 }).strict();
@@ -2301,7 +2362,7 @@ function validIdentity(value) {
 }
 function canonicalProjectId(scopeId) {
   if (!boundedText2(scopeId))
-    throw new TypeError("Flow leadership scope ID must be a non-empty path.");
+    throw new TypeError("Flow runtime scope must be a non-empty path.");
   const projectId = resolve2(scopeId);
   try {
     return realpathSync2(projectId);
@@ -2349,17 +2410,11 @@ function acquireRegistry() {
 function snapshot(identity) {
   return Object.freeze({ ...identity });
 }
-function makeStatus(identity, reason, registrations = [], registered = false) {
+function makeStatus(reason) {
   const operational = reason === "sole-instance";
   return Object.freeze({
-    instanceId: identity.instanceId,
-    registered,
     operational,
-    role: operational ? "leader" : registered || reason === "incompatible-registry" ? "indeterminate" : "unregistered",
     reason,
-    registeredCount: reason === "incompatible-registry" && !registered ? null : registrations.length,
-    diagnosticLeader: operational ? identity : null,
-    registrations: Object.freeze([...registrations]),
     message: operational ? "Flow is active for this project." : `Flow is not operational (${reason}).`
   });
 }
@@ -2370,7 +2425,7 @@ var createFlowPluginInstanceId = () => globalThis.crypto.randomUUID();
 function registerFlowPluginInstance(scopeId, input) {
   const projectId = canonicalProjectId(scopeId);
   if (!validIdentity(input)) {
-    throw new TypeError("Flow leadership identity is invalid.");
+    throw new TypeError("Flow runtime identity is invalid.");
   }
   const identity = snapshot(input);
   const registry = acquireRegistry();
@@ -2383,7 +2438,7 @@ function registerFlowPluginInstance(scopeId, input) {
     }
     const existing = project.get(identity.instanceId);
     if (existing && !sameIdentity(existing, identity)) {
-      throw new Error(`Flow leadership instance ID '${identity.instanceId}' is already registered with different identity data.`);
+      throw new Error(`Flow runtime instance ID '${identity.instanceId}' is already registered with different identity data.`);
     }
     record = existing ?? identity;
     project.set(identity.instanceId, record);
@@ -2391,32 +2446,28 @@ function registerFlowPluginInstance(scopeId, input) {
   let released = false;
   const query = () => {
     if (released)
-      return makeStatus(identity, "released");
+      return makeStatus("released");
     const currentRegistry = readRegistry();
     if (!record)
-      return makeStatus(identity, "incompatible-registry");
+      return makeStatus("incompatible-registry");
     if (currentRegistry === undefined)
-      return makeStatus(identity, "not-registered");
+      return makeStatus("not-registered");
     if (!compatibleRegistry(currentRegistry))
-      return makeStatus(identity, "incompatible-registry");
+      return makeStatus("incompatible-registry");
     const project = currentRegistry.projects.get(projectId);
-    const registrations = project ? [...project.values()].map(snapshot) : [];
-    if (project?.get(identity.instanceId) !== record) {
-      return makeStatus(identity, "not-registered", registrations);
+    if (!project || project.get(identity.instanceId) !== record) {
+      return makeStatus("not-registered");
     }
     if (identity.protocolVersion !== FLOW_LEADERSHIP_PROTOCOL_VERSION) {
-      return makeStatus(identity, "incompatible-registry", registrations, true);
+      return makeStatus("incompatible-registry");
     }
-    if (registrations.length !== 1) {
-      return makeStatus(identity, "duplicate-instances", registrations, true);
+    if (project.size !== 1) {
+      return makeStatus("duplicate-instances");
     }
-    return makeStatus(identity, "sole-instance", registrations, true);
+    return makeStatus("sole-instance");
   };
   return Object.freeze({
-    identity,
-    scopeId: projectId,
     query,
-    isOperational: () => query().operational,
     assertOperational(action) {
       const current = query();
       if (!current.operational) {
@@ -2476,7 +2527,10 @@ function featureProgress(session) {
   const completed = session.plan?.features.filter((feature) => isFeatureComplete(session, feature.id)).length ?? 0;
   return { completed, total, remaining: total - completed };
 }
-function nextAction(session) {
+function activePendingReview(session) {
+  return activeRun(session)?.reviews.find((review) => review.result === null) ?? null;
+}
+function nextAction(session, pendingReviewSourceStale = false) {
   const status = sessionStatus(session);
   if (status === "planning") {
     return session.plan ? "flow_plan_approve" : "flow_plan_save";
@@ -2492,16 +2546,16 @@ function nextAction(session) {
   const run = activeRun(session);
   if (!run)
     return "flow_status";
-  const pending = run.reviews.find((review) => review.result === null);
-  if (pending)
-    return "dispatch-flow-reviewer";
+  if (activePendingReview(session)) {
+    return pendingReviewSourceStale ? "flow_feature_reset" : "dispatch-flow-reviewer";
+  }
   const finalRun = session.plan?.features.every((feature) => feature.id === run.featureId || isFeatureComplete(session, feature.id)) ?? false;
   const hasPassingValidation = run.validations.some((validation) => validation.exitCode === 0 && validation.outputComplete && (!finalRun || validation.scope === "broad"));
   if (!hasPassingValidation)
     return "flow_validation_start";
   return "flow_review_start";
 }
-function compactProjection(session) {
+function compactProjection(session, pendingReviewSourceStale = false) {
   const run = activeRun(session);
   const retryRequest = closureRetryRequest(session);
   if (session.closure && !retryRequest) {
@@ -2516,7 +2570,7 @@ function compactProjection(session) {
     activeFeatureId: run?.featureId ?? null,
     activeRunId: run?.id ?? null,
     progress: featureProgress(session),
-    nextAction: nextAction(session),
+    nextAction: nextAction(session, pendingReviewSourceStale),
     archiveRetry: retryRequest ? { request: retryRequest } : null
   };
 }
@@ -2528,11 +2582,11 @@ function archivedProjection(session) {
     archived: true
   };
 }
-function executionProjection(session) {
+function executionProjection(session, pendingReviewSourceStale = false) {
   const run = activeRun(session);
   const feature = session.plan?.features.find((item) => item.id === run?.featureId);
   return {
-    ...compactProjection(session),
+    ...compactProjection(session, pendingReviewSourceStale),
     view: "execution",
     goal: session.goal,
     feature: feature ?? null,
@@ -2557,6 +2611,7 @@ function reviewerProjection(session, assignmentId) {
   }
   const feature = session.plan?.features.find((item) => item.id === assignment?.featureId);
   const plan = session.plan;
+  const assignedValidationIds = new Set(assignment.validationIds);
   return {
     view: "reviewer",
     sessionId: session.id,
@@ -2571,26 +2626,30 @@ function reviewerProjection(session, assignmentId) {
         id: candidate.id,
         title: candidate.title,
         summary: candidate.summary,
+        targets: [...candidate.targets],
+        validation: [...candidate.validation],
         dependsOn: [...candidate.dependsOn]
       }))
     } : null,
     feature: feature ?? null,
     assignment,
     artifactsChanged: run.artifactsChanged,
-    validations: run.validations,
+    validations: run.validations.filter((validation) => assignedValidationIds.has(validation.id)),
     completedFeatureIds: plan?.features.filter((candidate) => isFeatureComplete(session, candidate.id)).map((candidate) => candidate.id) ?? []
   };
 }
-function project(session, request) {
-  if (request.view === "compact")
-    return compactProjection(session);
-  if (request.view === "execution")
-    return executionProjection(session);
+function project(session, request, pendingReviewSourceStale = false) {
+  if (request.view === "compact") {
+    return compactProjection(session, pendingReviewSourceStale);
+  }
+  if (request.view === "execution") {
+    return executionProjection(session, pendingReviewSourceStale);
+  }
   if (request.view === "reviewer") {
     return reviewerProjection(session, request.assignmentId);
   }
   return {
-    ...compactProjection(session),
+    ...compactProjection(session, pendingReviewSourceStale),
     view: "detail",
     goal: session.goal,
     plan: session.plan,
@@ -2607,6 +2666,12 @@ function operationResult(session, operationId, replayed, entity) {
     ...entity === undefined ? {} : { entity }
   };
 }
+function featureCompleteResponse(session, request, run, replayed) {
+  return ok(request.result.verdict === "passed" ? "Feature completed." : "Feature blocked by review.", {
+    operation: operationResult(session, request.operationId, replayed, run),
+    projection: compactProjection(session)
+  });
+}
 async function loadExactArchivedClose(transaction, request) {
   const archived = await transaction.loadArchive(request.sessionId);
   const operation = archived?.operations.find((item) => item.id === request.operationId);
@@ -2664,6 +2729,33 @@ function createFlowService(repository, environment) {
             }
           });
         }
+        if (request.view !== "reviewer" && activePendingReview(session)) {
+          return await repository.transact(async (transaction) => {
+            const current = await transaction.load();
+            if (!current) {
+              return ok("No active Flow session.", {
+                projection: {
+                  view: request.view,
+                  status: "idle",
+                  revision: 0,
+                  nextAction: "flow_plan_save"
+                }
+              });
+            }
+            const pending = activePendingReview(current);
+            let pendingReviewSourceStale = false;
+            if (pending) {
+              try {
+                pendingReviewSourceStale = await transaction.computeSourceDigest() !== pending.sourceDigest;
+              } catch (error) {
+                return errorResponse(error, "Repair workspace fingerprinting before recovering this pending review. Do not redispatch the assignment until its source can be checked.");
+              }
+            }
+            return ok("Flow status loaded.", {
+              projection: project(current, request, pendingReviewSourceStale)
+            });
+          });
+        }
         return ok("Flow status loaded.", {
           projection: project(session, request)
         });
@@ -2774,20 +2866,36 @@ function createFlowService(repository, environment) {
             if (!assignment)
               throw new Error("Unknown review assignment.");
             if (await transaction.computeSourceDigest() !== assignment.sourceDigest) {
-              throw new Error("Workspace content changed after review started; reset and rerun validation and review.");
+              return errorResponse(new Error("Workspace content changed after review started."), "Call flow_feature_reset, start a fresh run, and repeat full validation and review. Do not redispatch this source-stale assignment.");
             }
           }
           const result = completeFeature(session, request);
           await transaction.save(result.session);
-          return ok(request.result.verdict === "passed" ? "Feature completed." : "Feature blocked by review.", {
-            operation: operationResult(result.session, request.operationId, result.replayed, result.value),
-            projection: compactProjection(result.session)
-          });
+          return featureCompleteResponse(result.session, request, result.value, result.replayed);
         });
       } catch (error) {
         return errorResponse(error);
       }
     },
+    async featureCompleteReplay(input) {
+      try {
+        const request = FeatureCompleteInputSchema.parse(input).request;
+        const session = await repository.read();
+        if (!session)
+          throw new Error("No active Flow session exists.");
+        const priorOperation = session.operations.find((operation) => operation.id === request.operationId);
+        if (priorOperation?.kind !== "feature-complete" || priorOperation.inputDigest !== operationInputDigest(request)) {
+          throw new Error("Only the Flow reviewer may submit a new feature completion; other agents may replay only an exact previously accepted request.");
+        }
+        const result = completeFeature(session, request);
+        if (!result.replayed) {
+          throw new Error("Expected an exact feature-completion replay.");
+        }
+        return featureCompleteResponse(result.session, request, result.value, true);
+      } catch (error) {
+        return errorResponse(error);
+      }
+    },
     async featureReset(input) {
       try {
         const request = FeatureResetInputSchema.parse(input).request;
@@ -2854,6 +2962,7 @@ var flowPlanApprove = (workspace, input) => service(workspace).planApprove(input
 var flowRunStart = (workspace, input) => service(workspace).runStart(input);
 var flowReviewStart = (workspace, input) => service(workspace).reviewStart(input);
 var flowFeatureComplete = (workspace, input) => service(workspace).featureComplete(input);
+var flowFeatureCompleteReplay = (workspace, input) => service(workspace).featureCompleteReplay(input);
 var flowFeatureReset = (workspace, input) => service(workspace).featureReset(input);
 var flowSessionClose = (workspace, input) => service(workspace).sessionClose(input);
 
@@ -2867,6 +2976,7 @@ function boundedHostText(label, options) {
 var text = boundedHostText("Text");
 var featureId = host.string().max(MAX_SESSION_ID_LENGTH).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/);
 var operationId = host.string().min(1).max(128).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]*$/);
+var reviewAssignmentId = host.string().min(1).max(256);
 var revision = host.number().int().safe().nonnegative();
 var guard = { operationId, expectedRevision: revision };
 var artifact = host.object({
@@ -2904,36 +3014,8 @@ var reviewResult = host.object({
   findings: host.array(reviewFinding).max(MAX_REVIEW_FINDINGS).default([]),
   terminalDisposition: host.enum(["submitted", "observed_unsubmitted"])
 }).strict().superRefine((result, context) => {
-  const blocking = result.findings.some((finding) => finding.severity === "blocking");
-  for (const [index, finding] of result.findings.entries()) {
-    if (finding.severity === "blocking" && !finding.evidence) {
-      context.addIssue({
-        code: "custom",
-        path: ["findings", index, "evidence"],
-        message: "A blocking finding requires concrete evidence."
-      });
-    }
-  }
-  if (result.verdict === "failed" && !blocking) {
-    context.addIssue({
-      code: "custom",
-      path: ["findings"],
-      message: "A failed review requires a blocking finding."
-    });
-  }
-  if (result.verdict === "passed" && blocking) {
-    context.addIssue({
-      code: "custom",
-      path: ["findings"],
-      message: "A passed review cannot contain blocking findings."
-    });
-  }
-  if (result.terminalDisposition === "observed_unsubmitted" && result.verdict !== "failed") {
-    context.addIssue({
-      code: "custom",
-      path: ["terminalDisposition"],
-      message: "Observed-but-unsubmitted review work must fail closed."
-    });
+  for (const issue of reviewResultSemanticIssues(result)) {
+    context.addIssue({ code: "custom", ...issue });
   }
 });
 var StatusArgs = {
@@ -2941,7 +3023,10 @@ var StatusArgs = {
     host.object({ view: host.literal("compact") }).strict(),
     host.object({ view: host.literal("detail") }).strict(),
     host.object({ view: host.literal("execution") }).strict(),
-    host.object({ view: host.literal("reviewer"), assignmentId: text.max(256) }).strict()
+    host.object({
+      view: host.literal("reviewer"),
+      assignmentId: reviewAssignmentId
+    }).strict()
   ])
 };
 var PlanSaveArgs = {
@@ -2974,7 +3059,7 @@ var FeatureCompleteArgs = {
   request: host.object({
     ...guard,
     featureId,
-    assignmentId: text.max(256),
+    assignmentId: reviewAssignmentId,
     summary: text,
     result: reviewResult
   }).strict()
@@ -3016,6 +3101,12 @@ function executeMutation(context, validation, handler) {
   validation.cancel(context.sessionID);
   return execute(context, handler);
 }
+function executeReviewerMutation(context, validation, handler, replayHandler) {
+  if (context.agent !== "flow-reviewer") {
+    return execute(context, replayHandler);
+  }
+  return executeMutation(context, validation, handler);
+}
 function createTools(_ctx, options) {
   return {
     flow_guidance: tool({
@@ -3071,9 +3162,9 @@ function createTools(_ctx, options) {
       execute: (args, context) => executeMutation(context, options.validation, (workspace) => flowReviewStart(workspace, args))
     }),
     flow_feature_complete: tool({
-      description: "Atomically record the pending review result and feature outcome.",
+      description: "Submit a pending review result; only the reviewer may create a new completion, while exact accepted requests remain replayable.",
       args: FeatureCompleteArgs,
-      execute: (args, context) => executeMutation(context, options.validation, (workspace) => flowFeatureComplete(workspace, args))
+      execute: (args, context) => executeReviewerMutation(context, options.validation, (workspace) => flowFeatureComplete(workspace, args), (workspace) => flowFeatureCompleteReplay(workspace, args))
     }),
     flow_feature_reset: tool({
       description: "Reset a feature and dependents for a fresh full retry.",
@@ -3134,7 +3225,7 @@ class ValidationCaptureCoordinator {
   #prune() {
     const cutoff = this.#now() - CAPTURE_TTL_MS;
     for (const [sessionID, capture] of this.#pending) {
-      if (capture.armedAt < cutoff) {
+      if (capture.callID === null && capture.armedAt < cutoff) {
         this.#pending.delete(sessionID);
       }
     }
@@ -3263,17 +3354,18 @@ function createCommandHook(assertOperational) {
     }
   };
 }
-function guardTools(tools, leadership) {
+function guardTools(tools, runtimeGuard) {
   return Object.fromEntries(Object.entries(tools).map(([name, definition]) => [
     name,
     {
       ...definition,
       execute: async (...args) => {
-        if (!leadership.isOperational()) {
+        const status = runtimeGuard.query();
+        if (!status.operational) {
           return JSON.stringify({
             status: "error",
-            summary: "Flow is disabled because more than one runtime is registered for this project.",
-            workflowData: { runtimeGuard: leadership.query() }
+            summary: status.message,
+            workflowData: { runtimeGuard: status }
           });
         }
         return definition.execute(...args);
@@ -3284,13 +3376,13 @@ function guardTools(tools, leadership) {
 var FlowPlugin = async (ctx) => {
   const log = createFlowLog(ctx);
   const version = resolveFlowPluginVersion();
-  const leadership = registerFlowPluginInstance(ctx.worktree ?? ctx.directory, {
+  const runtimeGuard = registerFlowPluginInstance(ctx.worktree ?? ctx.directory, {
     packageName: "opencode-plugin-flow",
     version,
     protocolVersion: FLOW_LEADERSHIP_PROTOCOL_VERSION,
     instanceId: createFlowPluginInstanceId()
   });
-  const initial = leadership.query();
+  const initial = runtimeGuard.query();
   log(initial.operational ? "info" : "error", `Flow ${version}: ${initial.message}`);
   const validation = new ValidationCaptureCoordinator({
     persistObservation: persistWorkspaceValidation
@@ -3301,10 +3393,10 @@ var FlowPlugin = async (ctx) => {
   });
   return {
     config: createConfigHook(ctx, {
-      assertOperational: (action) => leadership.assertOperational(action)
+      assertOperational: (action) => runtimeGuard.assertOperational(action)
     }),
-    tool: guardTools(tools, leadership),
-    "command.execute.before": createCommandHook((action) => leadership.assertOperational(action)),
+    tool: guardTools(tools, runtimeGuard),
+    "command.execute.before": createCommandHook((action) => runtimeGuard.assertOperational(action)),
     event: async (input) => {
       const event = input.event;
       if (event.type !== "session.idle" && event.type !== "session.compacted") {
@@ -3329,7 +3421,7 @@ var FlowPlugin = async (ctx) => {
       }
     },
     dispose: async () => {
-      leadership.release();
+      runtimeGuard.release();
     }
   };
 };
@@ -3338,4 +3430,4 @@ export {
   plugin_default as default
 };
 
-//# debugId=D206226F320FFC7564756E2164756E21
+//# debugId=E5E0649B3D35337264756E2164756E21