@tea-agent/loop-agent 0.39.0-next.20 → 0.39.0-next.21

package/dist/worker/console/static-src/operator-chat/useChatStream.js

@@ -1,8 +1,8 @@
 import { useCallback, useEffect } from "react";
 import { formatOperatorUserError } from "../../operator-user-error.js";
 import { confirmationToken, requestId, sleep } from "./format.js";
-import { classifyCreateTurnNetworkFailure, classifyCreateTurnResponse, createPendingSubmission, isRuntimeBusyUnion, isSubmissionCurrent, isTerminalTurnState, keepAmbiguousAfterRetry, reconcilePendingSubmissionFromState, resolveAmbiguousFromState, } from "./turn-submission.js";
-import { applyAbortDecision, applyPendingReconcileDecision, classifyAbortResponse, markStopRequested, operatorChatAbortUrl, operatorChatEventsUrl, operatorChatStateUrl, operatorChatTurnsUrl, releaseOwnershipOnTerminalEvidence, releaseSubmitOwnership as releaseOwnershipBag, requestStopOnOwnership, settleCreateTurnOutcome, } from "./turn-stream-controller.js";
+import { classifyCreateTurnNetworkFailure, classifyCreateTurnResponse, createPendingSubmission, decideSubmissionRoute, isRuntimeBusyUnion, isSubmissionCurrent, isTerminalTurnState, keepAmbiguousAfterRetry, reconcileDeferredSubmissionFromState, reconcilePendingSubmissionFromState, resolveAmbiguousFromState, } from "./turn-submission.js";
+import { applyAbortDecision, applyPendingReconcileDecision, classifyAbortResponse, markStopRequested, operatorChatAbortUrl, operatorChatEventsUrl, operatorChatStateUrl, operatorChatTurnsUrl, releaseOwnershipOnTerminalEvidence, releaseSubmitOwnership as releaseOwnershipBag, requestStopOnOwnership, settleCreateTurnOutcome, turnPhaseFromOwnership, } from "./turn-stream-controller.js";
 /** Project ChatRefs into the executable ownership bag used by the controller. */
 function ownershipBagFromRefs(refs) {
     return {
@@ -57,7 +57,7 @@ function clearEmptyAssistant(setMessages, assistantId) {
  * detached Turn resource only; it never opens a second inline SSE consumer. */
 export function useChatStream(params) {
     const { origin, refs, session, thread, composer, setError, setAutoScroll, setNotice, recoveryVersion = 0, watchSessionTitle, } = params;
-    const { applySseBlock, setMessages, setStreaming, setStreamingAssistantId, streaming, } = thread;
+    const { applySseBlock, setMessages, setStreaming, setStreamingAssistantId, streaming, setTurnPhase, setDeferredTurn, } = thread;
     const { setInput, setPendingImages } = composer;
     const showNotice = useCallback((message) => {
         if (!setNotice)
@@ -78,9 +78,10 @@ export function useChatStream(params) {
         refs.assistantIdRef.current = null;
         refs.stoppingTurnIdRef.current = null;
         setStreaming(false);
+        setTurnPhase("idle");
         setStreamingAssistantId(null);
         clearEmptyAssistant(setMessages, assistantId);
-    }, [refs, setStreaming, setStreamingAssistantId, setMessages]);
+    }, [refs, setStreaming, setTurnPhase, setStreamingAssistantId, setMessages]);
     /** Follow one session's event stream until it is explicitly aborted. The
      * server's `stream_ready` marker separates replay from live events; this
      * means replay cannot render duplicate messages while live text remains
@@ -242,13 +243,12 @@ export function useChatStream(params) {
     /** Issue real POST /abort for a known turnId (Stop never disposes Session). */
     const postAbortForTurn = useCallback(async (sessionId, generation, turnId) => {
         refs.stoppingTurnIdRef.current = turnId;
-        // Optimistic stop (pi-web parity): the abort signal kills the SDK
-        // process tree promptly, so flip the UI idle NOW instead of holding
-        // the busy spinner through the whole POST /abort round-trip. If the
-        // server later reports the turn still running (TURN_ABORT_PENDING
-        // or owner-lost reconcile), applyAbortDecision restores busy state.
+        // Optimistic visual stop: remove the running spinner immediately, but
+        // retain ownership as `stopping` until the server proves a terminal state.
+        // This keeps the composer responsive without falsely advertising idle.
         refs.streamingRef.current = false;
         setStreaming(false);
+        setTurnPhase("stopping");
         setStreamingAssistantId(null);
         try {
             const res = await fetch(operatorChatAbortUrl(origin, sessionId, turnId), {
@@ -283,6 +283,7 @@ export function useChatStream(params) {
                     markIdle: () => markIdleIfCurrent(sessionId, generation, refs.assistantIdRef.current),
                 });
                 applyOwnershipBagToRefs(refs, bag);
+                setTurnPhase(turnPhaseFromOwnership(bag));
                 return;
             }
             applyAbortDecision(bag, decision, noticeSink(), {
@@ -290,6 +291,7 @@ export function useChatStream(params) {
                 markIdle: () => markIdleIfCurrent(sessionId, generation, refs.assistantIdRef.current),
             });
             applyOwnershipBagToRefs(refs, bag);
+            setTurnPhase(turnPhaseFromOwnership(bag));
             // Sync the post-decision busy state back to React: optimistic stop
             // flipped it idle up front; pending/keep-busy outcomes restore it.
             if (bag.streaming)
@@ -310,11 +312,13 @@ export function useChatStream(params) {
             // so the turn is not silently dropped; /state reconcile converges.
             refs.streamingRef.current = true;
             setStreaming(true);
+            setTurnPhase("stopping");
         }
     }, [
         origin,
         refs,
         setStreaming,
+        setTurnPhase,
         markIdleIfCurrent,
         fetchSessionState,
         noticeSink,
@@ -364,10 +368,12 @@ export function useChatStream(params) {
             },
         });
         applyOwnershipBagToRefs(refs, bag);
+        setTurnPhase(turnPhaseFromOwnership(bag));
     }, [
         refs,
         noticeSink,
         setStreaming,
+        setTurnPhase,
         setStreamingAssistantId,
         setPendingImages,
         watchSessionTitle,
@@ -376,10 +382,190 @@ export function useChatStream(params) {
         setError,
         postAbortForTurn,
     ]);
+    const queueDeferredTurn = useCallback(async (input) => {
+        const activeSession = refs.sessionRef.current;
+        if (!activeSession || (!input.text.trim() && input.images.length === 0))
+            return { action: "handled" };
+        const existing = thread.deferredTurn;
+        showNotice("正在排队…");
+        const acceptDeferred = (deferredTurn) => {
+            setDeferredTurn(deferredTurn);
+            setInput("");
+            setPendingImages([]);
+            setError(null);
+            showNotice(existing ? "已更新停止后发送的消息" : "已排队，将在上一轮停止后自动发送");
+        };
+        const acceptDispatched = () => {
+            setDeferredTurn(null);
+            setInput("");
+            setPendingImages([]);
+            setError(null);
+            showNotice("消息已进入发送");
+        };
+        const putOnce = async () => {
+            const response = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(activeSession.sessionId)}/deferred-turn`, {
+                method: "PUT",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-loop-console-confirmation": confirmationToken(),
+                },
+                credentials: "include",
+                body: JSON.stringify({
+                    clientRequestId: input.clientRequestId,
+                    blockedByTurnId: input.blockedByTurnId,
+                    text: input.text,
+                    images: input.images,
+                    ...(existing ? { expectedRevision: existing.revision } : {}),
+                }),
+            });
+            const body = (await response.json().catch(() => ({})));
+            return { response, body };
+        };
+        try {
+            for (let attempt = 0; attempt < 2; attempt += 1) {
+                const { response, body } = await putOnce();
+                if (response.ok && body.accepted && body.deferredTurn) {
+                    acceptDeferred(body.deferredTurn);
+                    return { action: "handled" };
+                }
+                if (body.deferredTurn)
+                    setDeferredTurn(body.deferredTurn);
+                if (body.error?.code !== "TURN_NOT_STOPPING") {
+                    setError(body.error?.message ??
+                        `待发送消息未被服务端接受（HTTP ${response.status}）`);
+                    return { action: "handled" };
+                }
+                const canonical = await fetchSessionState(activeSession.sessionId);
+                const decision = reconcileDeferredSubmissionFromState({
+                    clientRequestId: input.clientRequestId,
+                    blockedByTurnId: input.blockedByTurnId,
+                    state: canonical ?? undefined,
+                });
+                if (decision.action === "deferred") {
+                    acceptDeferred(decision.deferredTurn);
+                    return { action: "handled" };
+                }
+                if (decision.action === "accepted") {
+                    acceptDispatched();
+                    return { action: "handled" };
+                }
+                if (decision.action === "retry-deferred" && attempt === 0)
+                    continue;
+                if (decision.action === "send-now" && !existing) {
+                    showNotice("上一轮已停止，正在发送当前消息…");
+                    return { action: "send-now" };
+                }
+                setError(body.error?.message ?? "停止状态已变化，当前消息仍保留在输入框");
+                return { action: "handled" };
+            }
+            return { action: "handled" };
+        }
+        catch (error) {
+            const canonical = await fetchSessionState(activeSession.sessionId);
+            const decision = reconcileDeferredSubmissionFromState({
+                clientRequestId: input.clientRequestId,
+                blockedByTurnId: input.blockedByTurnId,
+                state: canonical ?? undefined,
+            });
+            if (decision.action === "deferred") {
+                acceptDeferred(decision.deferredTurn);
+                return { action: "handled" };
+            }
+            if (decision.action === "accepted") {
+                acceptDispatched();
+                return { action: "handled" };
+            }
+            if (decision.action === "send-now" && !existing) {
+                showNotice("上一轮已停止，正在发送当前消息…");
+                return { action: "send-now" };
+            }
+            setError(error instanceof Error
+                ? `无法确认消息是否已排队：${error.message}`
+                : "无法确认消息是否已排队，请刷新后查看服务端状态");
+            return { action: "handled" };
+        }
+    }, [
+        origin,
+        refs,
+        thread.deferredTurn,
+        setDeferredTurn,
+        setInput,
+        setPendingImages,
+        setError,
+        showNotice,
+        fetchSessionState,
+    ]);
+    const cancelDeferredTurn = useCallback(async () => {
+        const activeSession = refs.sessionRef.current;
+        const deferred = thread.deferredTurn;
+        if (!activeSession || !deferred)
+            return;
+        try {
+            const response = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(activeSession.sessionId)}/deferred-turn`, {
+                method: "DELETE",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-loop-console-confirmation": confirmationToken(),
+                },
+                credentials: "include",
+                body: JSON.stringify({
+                    clientRequestId: deferred.clientRequestId,
+                    expectedRevision: deferred.revision,
+                }),
+            });
+            const body = (await response.json().catch(() => ({})));
+            if (!response.ok || !body.cancelled) {
+                setError(body.error?.message ?? "待发送消息撤回失败");
+                return;
+            }
+            setDeferredTurn(null);
+            setInput(body.deferredTurn?.text ?? "");
+            setPendingImages(body.deferredTurn?.images ?? []);
+            setError(null);
+            showNotice("待发送消息已移回输入框");
+        }
+        catch (error) {
+            setError(error instanceof Error ? error.message : String(error));
+        }
+    }, [
+        origin,
+        refs,
+        thread.deferredTurn,
+        setDeferredTurn,
+        setInput,
+        setPendingImages,
+        setError,
+        showNotice,
+    ]);
     const sendPrompt = useCallback(async (text, images) => {
+        const initialSession = refs.sessionRef.current;
+        if (!initialSession || (!text.trim() && images.length === 0))
+            return;
+        const ownership = ownershipBagFromRefs(refs);
+        const route = decideSubmissionRoute({
+            turnPhase: turnPhaseFromOwnership(ownership),
+            blockedByTurnId: ownership.stoppingTurnId ?? ownership.activeTurnId,
+        });
+        const clientRequestId = requestId("chat-submit");
+        if (route.action === "hold") {
+            if (turnPhaseFromOwnership(ownership) === "stopping")
+                showNotice("正在确认上一轮停止状态，当前消息已保留");
+            return;
+        }
+        if (route.action === "queue-deferred") {
+            const deferred = await queueDeferredTurn({
+                text,
+                images,
+                clientRequestId,
+                blockedByTurnId: route.blockedByTurnId,
+            });
+            if (deferred.action !== "send-now")
+                return;
+        }
         const activeSession = refs.sessionRef.current;
         const generation = refs.sessionGenerationRef.current;
         if (!activeSession ||
+            activeSession.sessionId !== initialSession.sessionId ||
             (!text.trim() && images.length === 0) ||
             refs.streamingRef.current ||
             refs.submitInFlightRef.current ||
@@ -389,7 +575,6 @@ export function useChatStream(params) {
         // AC-001: acquire synchronous submit ownership before the first await.
         refs.submitInFlightRef.current = true;
         const submitGeneration = ++refs.submitGenerationRef.current;
-        const clientRequestId = requestId("chat-submit");
         const userMessageId = requestId("u");
         const assistantId = requestId("a");
         const draftText = text.trim();
@@ -437,6 +622,7 @@ export function useChatStream(params) {
         setAutoScroll(true);
         setError(null);
         refs.streamingRef.current = true;
+        setTurnPhase("running");
         refs.assistantIdRef.current = assistantId;
         setStreaming(true);
         setStreamingAssistantId(assistantId);
@@ -532,7 +718,9 @@ export function useChatStream(params) {
         setAutoScroll,
         setError,
         setStreaming,
+        setTurnPhase,
         setStreamingAssistantId,
+        queueDeferredTurn,
     ]);
     const handleStop = useCallback(async () => {
         // AC-R5-001: durable stopRequested is set synchronously before any await so
@@ -548,6 +736,7 @@ export function useChatStream(params) {
             notice: noticeSink(),
         });
         applyOwnershipBagToRefs(refs, bag);
+        setTurnPhase("stopping");
         // Immediate abort already scheduled for a known turnId — coalesce via
         // abortPostedTurnIds; stopInFlight only gates concurrent in-flight POSTs.
         if (stopResult.abortedTurnId) {
@@ -656,6 +845,9 @@ export function useChatStream(params) {
                         },
                     });
                     applyOwnershipBagToRefs(refs, bag);
+                    setTurnPhase(turnPhaseFromOwnership(bag));
+                    if (state && "deferredTurn" in state)
+                        setDeferredTurn(state.deferredTurn ?? null);
                     if (result === "bound") {
                         // US-BUSY-ACTIVE-BOUND: keep streaming/busy with same id.
                         setStreaming(true);
@@ -755,6 +947,7 @@ export function useChatStream(params) {
         refs,
         session,
         streaming,
+        setTurnPhase,
         markIdleIfCurrent,
         releaseSubmitOwnership,
         postAbortForTurn,
@@ -776,5 +969,5 @@ export function useChatStream(params) {
             }
         };
     }, [session, recoveryVersion, refs, startEventsStream]);
-    return { sendPrompt, handleStop, openEventsStream };
+    return { sendPrompt, handleStop, cancelDeferredTurn, openEventsStream };
 }

package/dist/worker/console/static-src/operator-chat/useChatThread.js

@@ -31,6 +31,8 @@ export function useChatThread(params) {
     const [contextLoading, setContextLoading] = useState(false);
     const [usage, setUsage] = useState(EMPTY_USAGE);
     const [streaming, setStreaming] = useState(false);
+    const [turnPhase, setTurnPhase] = useState("idle");
+    const [deferredTurn, setDeferredTurn] = useState(null);
     /** Assistant bubble id for the in-flight turn; only this row shows the streaming cursor. */
     const [streamingAssistantId, setStreamingAssistantId] = useState(null);
     const [showSystemInMessages] = useState(false);
@@ -44,6 +46,8 @@ export function useChatThread(params) {
         setHumanGateCards,
         setArtifactCards,
         setStreaming,
+        setTurnPhase,
+        setDeferredTurn,
         setStreamingAssistantId,
         setUnread,
         setOperationCards,
@@ -190,6 +194,8 @@ export function useChatThread(params) {
         setTaskContext(null);
         setUsage(EMPTY_USAGE);
         setStreaming(false);
+        setTurnPhase("idle");
+        setDeferredTurn(null);
         setStreamingAssistantId(null);
         setUnread(0);
         setHistoryLimit(50);
@@ -207,6 +213,8 @@ export function useChatThread(params) {
         setUsage(EMPTY_USAGE);
         refs.usageResponseKeysRef.current = new Set();
         setStreaming(next.streaming);
+        setTurnPhase(next.turnPhase ?? (next.streaming ? "running" : "idle"));
+        setDeferredTurn(next.deferredTurn ?? null);
         setStreamingAssistantId(null);
         setUnread(0);
         setHistoryLimit(50);
@@ -228,6 +236,8 @@ export function useChatThread(params) {
             const activeTurnId = body.session.activeTurnId ?? null;
             refs.activeTurnIdRef.current = activeTurnId;
             refs.streamingRef.current = Boolean(activeTurnId);
+            setTurnPhase(body.session.turnPhase ?? (activeTurnId ? "running" : "idle"));
+            setDeferredTurn(body.session.deferredTurn ?? null);
             // Resume the events stream from the snapshot tail so the next
             // reconnect never immediately re-expires (AC-003). The refs below
             // are reset so any follow-up tail replay re-applies cleanly.
@@ -246,7 +256,15 @@ export function useChatThread(params) {
             // trigger another reconcile and retry (best-effort recovery).
             return false;
         }
-    }, [origin, refs, setMessages, setToolCalls, setStreamingAssistantId]);
+    }, [
+        origin,
+        refs,
+        setMessages,
+        setToolCalls,
+        setStreamingAssistantId,
+        setTurnPhase,
+        setDeferredTurn,
+    ]);
     return {
         messages,
         setMessages,
@@ -265,6 +283,10 @@ export function useChatThread(params) {
         usage,
         streaming,
         setStreaming,
+        turnPhase,
+        setTurnPhase,
+        deferredTurn,
+        setDeferredTurn,
         streamingAssistantId,
         setStreamingAssistantId,
         visibleMessages,

package/dist/workflows/dag/convergence/controller.js

@@ -21,6 +21,17 @@ const REVIEW_VERDICT_NODE_ID = "review-verdict-recovery-pi";
 const INITIAL_REVIEW_NODE_ID = "initial-review-pi";
 const INITIAL_REVIEW_GATE_NODE_ID = "initial-review-gate-shell";
 const INITIAL_REVIEW_PASS_NODE_ID = "initial-review-pass-shell";
+/**
+ * Standard-dag governance verify chain ids. When the convergence chain
+ * observes the governance standard gate, a legitimate verify-pi
+ * `request-revision` re-enters a bounded implement-repair loop instead of
+ * terminating the run at the gate, mirroring the review-chain re-entry
+ * semantics (AC3/AC4). Protocol/provider/safety failures on verify-pi keep
+ * failing closed; only a safe `request-revision` drives code repair here.
+ */
+const GOVERNANCE_VERIFY_GATE_NODE_ID = "governance-standard-gate-shell";
+const GOVERNANCE_VERIFY_NODE_ID = "verify-pi";
+const GOVERNANCE_VERIFY_WRITER_NODE_ID = "implement-pi";
 // Automatic code repair is authorized only for an ordinary command/test
 // failure. Unknown, protocol, validation, provider, safety, governance, and
 // human-decision categories all fail closed instead of reaching a writer.
@@ -57,6 +68,15 @@ export async function runConvergencePassController(input) {
     }
     const chain = getConvergenceChain(input.spec);
     const observesReview = chain.includes(REVIEW_GATE_NODE_ID);
+    const observesGovernanceVerify = chain.includes(GOVERNANCE_VERIFY_GATE_NODE_ID);
+    // Standard-dag governance verify convergence: verify-pi drives a bounded
+    // implement-repair loop on `request-revision`. This shape has no
+    // hard-verify/review nodes; dispatch before the legacy hard-verify logic so
+    // the standard governance DAG never falls into `unsupported-dag-shape`/
+    // `non-retry-failure` dead ends.
+    if (observesGovernanceVerify && !observesReview) {
+        return handleGovernanceVerifyConvergence(input);
+    }
     if (input.tasksById.has(INITIAL_REVIEW_NODE_ID)) {
         const initialReview = input.state.nodes[INITIAL_REVIEW_NODE_ID];
         const initialGate = input.state.nodes[INITIAL_REVIEW_GATE_NODE_ID];
@@ -397,6 +417,127 @@ async function handleReviewRequestRevision(input, reviewGate) {
 function getConvergenceChain(spec) {
     return spec.convergence?.chainNodeIds ?? DEFAULT_CONVERGENCE_CHAIN_NODE_IDS;
 }
+/**
+ * Legitimate governance verify revision: verify-pi finished and emitted
+ * `request-revision`. No secondary verdict-recovery node exists on the
+ * standard dag, so the single verify-pi verdict plus a non-transport failure
+ * category is the legitimacy bar (protocol-invalid/invalid-output/timeout on
+ * verify-pi fail closed instead of driving repair).
+ */
+function isLegitimateGovernanceVerifyRevision(state) {
+    const verifyNode = state.nodes[GOVERNANCE_VERIFY_NODE_ID];
+    return (verifyNode?.status === "FINISHED" &&
+        parseProcessVerdict(verifyNode) === "request-revision");
+}
+function isLegitimateGovernanceVerifyPass(state) {
+    const verifyNode = state.nodes[GOVERNANCE_VERIFY_NODE_ID];
+    return (verifyNode?.status === "FINISHED" &&
+        parseProcessVerdict(verifyNode) === "pass");
+}
+/**
+ * Standard-dag governance verify convergence loop. Terminal pass when
+ * verify-pi passes; bounded re-entry (reset implement-pi + verify chain) when
+ * verify-pi legitimately requests revision. The reset lets the next
+ * implement-pi pass consume the prior verify findings through the structured
+ * convergence feedback block (node-execution injects it for implementer
+ * roles), so `already-satisfied` no-ops are explicitly contradicted by the
+ * preserved verify-pi evidence refs.
+ */
+async function handleGovernanceVerifyConvergence(input) {
+    const convergence = input.state.convergence;
+    const currentPass = convergence.currentPass || 1;
+    const verifyNode = input.state.nodes[GOVERNANCE_VERIFY_NODE_ID];
+    const verifyShell = input.state.nodes["verify-shell"];
+    // Hard verify commands failed: not a governance verdict issue. Without a
+    // supervised repair chain, this stays terminal so the failure-aware
+    // closeout reports it truthfully.
+    if (verifyShell?.status === "ERROR") {
+        const passRecord = await buildConvergencePassRecord({
+            pass: currentPass,
+            status: "terminal",
+            reason: "hard-verify-failed",
+            state: input.state,
+            runDir: input.runDir,
+            spec: input.spec,
+        });
+        convergence.passHistory.push(passRecord);
+        convergence.terminalReason = "hard-verify-failed";
+        await input.persistState();
+        return { retry: false };
+    }
+    if (isLegitimateGovernanceVerifyPass(input.state)) {
+        convergence.terminalReason = "hard-verify-pass";
+        await appendConvergenceKnowledgePattern({
+            cwd: input.cwd,
+            state: input.state,
+        });
+        return { retry: false };
+    }
+    const verifyFailureCategory = verifyNode?.failureCategory;
+    const legitimateRevision = isLegitimateGovernanceVerifyRevision(input.state);
+    if (!legitimateRevision ||
+        (verifyFailureCategory &&
+            REVIEW_SOURCE_NON_RETRY_FAILURES.has(verifyFailureCategory))) {
+        const passRecord = await buildConvergencePassRecord({
+            pass: currentPass,
+            status: "terminal",
+            reason: "non-retry-failure",
+            state: input.state,
+            runDir: input.runDir,
+            spec: input.spec,
+        });
+        convergence.passHistory.push(passRecord);
+        convergence.terminalReason = "non-retry-failure";
+        await input.persistState();
+        return { retry: false };
+    }
+    const passRecord = await buildConvergencePassRecord({
+        pass: currentPass,
+        status: "retrying",
+        reason: "verify-request-revision",
+        state: input.state,
+        runDir: input.runDir,
+        spec: input.spec,
+    });
+    if (currentPass >= convergence.maxPasses) {
+        passRecord.status = "terminal";
+        passRecord.reason = "max-passes";
+        convergence.passHistory.push(passRecord);
+        convergence.terminalReason = "max-passes";
+        await input.persistState();
+        return { retry: false };
+    }
+    convergence.passHistory.push(passRecord);
+    convergence.currentPass = currentPass + 1;
+    // Reset the writer plus the governance verify chain: the next implement-pi
+    // pass must consume the preserved verify-pi findings (injected as
+    // convergence feedback) instead of returning already-satisfied.
+    for (const id of collectGovernanceVerifyResetIds(input.spec)) {
+        const task = input.tasksById.get(id);
+        if (!task)
+            continue;
+        input.state.nodes[id] = freshNodeRecord(task);
+    }
+    await input.persistState();
+    return { retry: true };
+}
+/**
+ * Reset set for the governance verify loop: the exclusive writer and the
+ * verify chain closure (verify-shell, verify-pi, governance gate, and every
+ * transitive descendant so closeout re-adjudicates from fresh evidence).
+ */
+function collectGovernanceVerifyResetIds(spec) {
+    const resetIds = new Set([
+        GOVERNANCE_VERIFY_WRITER_NODE_ID,
+        "verify-shell",
+        GOVERNANCE_VERIFY_NODE_ID,
+        GOVERNANCE_VERIFY_GATE_NODE_ID,
+    ]);
+    for (const id of collectTransitiveDescendantTaskIds(spec, GOVERNANCE_VERIFY_GATE_NODE_ID)) {
+        resetIds.add(id);
+    }
+    return resetIds;
+}
 function hasConvergenceChain(tasksById, spec) {
     const chain = getConvergenceChain(spec);
     return chain.every((id) => tasksById.has(id));

package/dist/workflows/dag/init-hybrid.js

@@ -5,6 +5,7 @@ import path from "node:path";
 import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
 import { assertValidDagSpec } from "./validate.js";
 import { DAG_AGENT_RUNTIME_PI_ONLY, DAG_REPAIR_WRITER_PROTOCOL_EXPLICIT_NODE_V1, DAG_RUNTIME_CONTRACT_SCHEMA_VERSION, DEFAULT_DAG_OUTPUT_LANGUAGE, DEFAULT_DAG_EXECUTOR_MODELS, parseDagSpec, } from "./types.js";
+import { bindDagRerunFeedback } from "./rerun-feedback.js";
 import { planMavenVerification, } from "../../verification/maven/index.js";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
 import { extractTaskSourceOpenspecPaths } from "../../shared/openspec-spec.js";
@@ -6739,6 +6740,12 @@ function buildGovernanceStandardGateNode(sources) {
             verdictGate: {
                 fromNodeId: "verify-pi",
                 accept: ["VERDICT: pass"],
+                // A legitimate request-revision is a convergence routing result only
+                // when the task actually has a bounded fix loop. Without that loop the
+                // gate must fail closed instead of letting closeout run.
+                ...((sources.taskConfig.maxFixLoops ?? 0) > 0
+                    ? { routingAccept: ["VERDICT: request-revision"] }
+                    : {}),
                 label: "governance-standard",
                 lineMode: "first-verdict-line",
             },
@@ -6764,6 +6771,33 @@ function insertGovernanceStandardGate(spec, sources) {
     spec.tasks.splice(closeoutIndex, 0, gate);
     closeout.depends_on = ["governance-standard-gate-shell"];
     closeout.failureAwareDependsOn = ["governance-standard-gate-shell"];
+    // Governance verify convergence: when the task's bounded-repair budget
+    // allows it, a legitimate verify-pi `request-revision` re-enters a bounded
+    // implement-repair loop (see convergence controller) instead of terminating
+    // the run at the gate. The gate routes `request-revision` as a non-error
+    // result so closeout stays failure-aware rather than cascade-skipped.
+    const maxFixLoops = sources.taskConfig.maxFixLoops ?? 0;
+    if (maxFixLoops > 0) {
+        // verify-shell exists only when the task planned final verify commands;
+        // build the chain from nodes this spec actually contains so
+        // hasConvergenceChain never rejects the governance shape.
+        const governanceChainIds = [
+            "implement-pi",
+            ...(spec.tasks.some((task) => task.id === "verify-shell")
+                ? ["verify-shell"]
+                : []),
+            "verify-pi",
+            "governance-standard-gate-shell",
+        ];
+        spec.convergence = {
+            enabled: true,
+            maxPasses: maxFixLoops + 1,
+            stopOnVerdictPass: true,
+            stopOnHardVerifyPass: true,
+            pauseOnRegression: sources.taskConfig.convergence?.pauseOnRegression ?? true,
+            chainNodeIds: governanceChainIds,
+        };
+    }
 }
 function buildReviewGatedHybridDag(standard, sources) {
     const spec = {
@@ -7314,6 +7348,11 @@ export async function writeHybridDagDraft(sources, outputPath, options = {}) {
         ? await prepareFrontendMockSources(sources, routingProjectCapability)
         : sources;
     const spec = await buildHybridDagForTemplate(preparedSources, template);
+    if (options.rerunFeedback) {
+        spec.rerunFeedback = bindDagRerunFeedback(options.rerunFeedback, spec);
+        parseDagSpec(spec);
+        assertValidDagSpec(spec);
+    }
     if (preparedSources.repoRoot && dagHasWriterExecution(spec)) {
         await requireManagedTaskContractBinding({
             repoRoot: preparedSources.repoRoot,
@@ -7341,5 +7380,6 @@ export async function initHybridDagFromTask(repoRoot, taskId, options = {}) {
     const outputPath = options.outputPath ?? getTaskPaths(repoRoot, taskId).dagDraftPath;
     return writeHybridDagDraft(sources, outputPath, {
         template: options.template,
+        rerunFeedback: options.rerunFeedback,
     });
 }