opencode-plugin-flow 6.2.0 → 6.3.1

package/CHANGELOG.md

@@ -6,6 +6,52 @@ One short entry per release, written for users deciding whether to upgrade.
 
 No changes yet.
 
+## [6.3.1] - 2026-07-21
+
+Read-only retry lore closes the recovery and documentation gaps in 6.3.0:
+
+- While Session v5 remains active, every caller with tool access now receives an
+  exact accepted completion through the read-only replay path before a new
+  reviewer submission is considered. Reviewer retries no longer cancel
+  validation capture or write session state.
+- Replay documentation now states the active Session v5 boundary, and release
+  language accurately describes secret avoidance as manager guidance rather
+  than runtime filtering or redaction.
+- The documentation contract keeps the rolling `Unreleased` changelog heading
+  without requiring its contents to remain `No changes yet.`
+
+Install or update:
+
+```bash
+opencode plugin opencode-plugin-flow@6.3.1 --global --force
+```
+
+## [6.3.0] - 2026-07-21
+
+Reviewer-owned submission lore strengthens independent review without turning
+Flow back into a heavy orchestration framework:
+
+- The reserved reviewer now submits its own result through
+  `flow_feature_complete`. The host authorizes new completions by agent identity,
+  while exact previously accepted requests remain read-only replays for active
+  Session v5 workflows.
+- Pending-review recovery is source-aware: current assignments can be
+  redispatched after interruption, stale source routes to reset and full
+  revalidation, and fingerprint failures fail closed with repair guidance.
+- Final reviewers receive the approved plan targets and validation intent,
+  completed feature IDs, and only assignment-linked evidence. Broad validation
+  is treated as a coverage claim; manager guidance warns against putting secrets
+  in durable commands, and raw output is reduced to completeness plus a digest.
+- Closed-world permission tests and the pinned OpenCode host smoke cover every
+  registered Flow tool. Documentation distinguishes lifecycle mutation from
+  fail-closed quarantine maintenance.
+
+Install or update:
+
+```bash
+opencode plugin opencode-plugin-flow@6.3.0 --global --force
+```
+
 ## [6.2.0] - 2026-07-21
 
 Low-friction bounded-wave lore keeps Flow small while making parallel

package/README.md

@@ -16,11 +16,11 @@ parallel before it validates and reviews the combined result.
 Install the exact npm release through OpenCode:
 
 ```bash
-opencode plugin opencode-plugin-flow@6.2.0 --global --force
+opencode plugin opencode-plugin-flow@6.3.1 --global --force
 ```
 
 Omit `--global` for project scope. Exact version pins do not update
-automatically. To update, replace `6.2.0` with the new release and rerun the
+automatically. To update, replace `6.3.1` with the new release and rerun the
 command.
 
 Before upgrading from Flow v5 or earlier, finish or explicitly close any active
@@ -32,7 +32,7 @@ The equivalent manual project configuration is:
 ```json
 {
   "$schema": "https://opencode.ai/config.json",
-  "plugin": ["opencode-plugin-flow@6.2.0"]
+  "plugin": ["opencode-plugin-flow@6.3.1"]
 }
 ```
 

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
 
@@ -271,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
 
@@ -295,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.
@@ -415,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(`
@@ -436,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",
@@ -445,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": {
@@ -486,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")
@@ -1453,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({
@@ -1508,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),
@@ -1606,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()
@@ -1637,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();
@@ -2472,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";
@@ -2488,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) {
@@ -2512,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
   };
 }
@@ -2524,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,
@@ -2553,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,
@@ -2567,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,
@@ -2603,6 +2666,23 @@ 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)
+  });
+}
+function exactFeatureCompleteReplay(session, request) {
+  const priorOperation = session.operations.find((operation) => operation.id === request.operationId);
+  if (priorOperation?.kind !== "feature-complete" || priorOperation.inputDigest !== operationInputDigest(request)) {
+    return null;
+  }
+  const result = completeFeature(session, request);
+  if (!result.replayed) {
+    throw new Error("Expected an exact feature-completion replay.");
+  }
+  return { session: result.session, run: result.value };
+}
 async function loadExactArchivedClose(transaction, request) {
   const archived = await transaction.loadArchive(request.sessionId);
   const operation = archived?.operations.find((item) => item.id === request.operationId);
@@ -2660,6 +2740,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)
         });
@@ -2760,30 +2867,53 @@ function createFlowService(repository, environment) {
     async featureComplete(input) {
       try {
         const request = FeatureCompleteInputSchema.parse(input).request;
+        const current = await repository.read();
+        if (current) {
+          const replay = exactFeatureCompleteReplay(current, request);
+          if (replay) {
+            return featureCompleteResponse(replay.session, request, replay.run, true);
+          }
+        }
         return await repository.transact(async (transaction) => {
           const session = await transaction.load();
           if (!session)
             throw new Error("No active Flow session exists.");
+          const racedReplay = exactFeatureCompleteReplay(session, request);
+          if (racedReplay) {
+            return featureCompleteResponse(racedReplay.session, request, racedReplay.run, true);
+          }
           const priorOperation = session.operations.find((operation) => operation.id === request.operationId);
           if (!priorOperation) {
             const assignment = session.runs.flatMap((run) => run.reviews).find((review) => review.id === request.assignmentId);
             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 replay = exactFeatureCompleteReplay(session, request);
+        if (!replay) {
+          throw new Error("Only the Flow reviewer may submit a new feature completion; other agents may replay only an exact previously accepted request.");
+        }
+        return featureCompleteResponse(replay.session, request, replay.run, true);
+      } catch (error) {
+        return errorResponse(error);
+      }
+    },
     async featureReset(input) {
       try {
         const request = FeatureResetInputSchema.parse(input).request;
@@ -2850,6 +2980,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);
 
@@ -2863,6 +2994,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({
@@ -2909,7 +3041,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 = {
@@ -2942,7 +3077,7 @@ var FeatureCompleteArgs = {
   request: host.object({
     ...guard,
     featureId,
-    assignmentId: text.max(256),
+    assignmentId: reviewAssignmentId,
     summary: text,
     result: reviewResult
   }).strict()
@@ -2984,6 +3119,12 @@ function executeMutation(context, validation, handler) {
   validation.cancel(context.sessionID);
   return execute(context, handler);
 }
+function executeReviewerMutation(context, handler, replayHandler) {
+  if (context.agent !== "flow-reviewer") {
+    return execute(context, replayHandler);
+  }
+  return execute(context, handler);
+}
 function createTools(_ctx, options) {
   return {
     flow_guidance: tool({
@@ -3039,9 +3180,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 for an active Session v5 workflow.",
       args: FeatureCompleteArgs,
-      execute: (args, context) => executeMutation(context, options.validation, (workspace) => flowFeatureComplete(workspace, args))
+      execute: (args, context) => executeReviewerMutation(context, (workspace) => flowFeatureComplete(workspace, args), (workspace) => flowFeatureCompleteReplay(workspace, args))
     }),
     flow_feature_reset: tool({
       description: "Reset a feature and dependents for a fresh full retry.",
@@ -3307,4 +3448,4 @@ export {
   plugin_default as default
 };
 
-//# debugId=48BDB7D8B1F2A60764756E2164756E21
+//# debugId=6D57AB8590A9BCD164756E2164756E21