@sema-agent/server 7.140.0 → 7.141.0

package/dist/http/routes/tasks.js

@@ -1,8 +1,9 @@
 import { redactErrorMessage, redactHead, redactTerminalResult } from "../../observability/run-terminal.js";
 import { runWithVerification, runCascade, taskNotificationDedupKey, uuidv7 } from "@sema-agent/core";
 import { heldFor } from "../../peer-seat.js";
-import { graftParkToolCallId, markChildrenStoppedByUserOnAbort, syncRefusalHttpStatus, zeroWorkRefusalFacts, releaseKeyIfZeroWorkRefusal, createPromptCommitReader, HEARTBEAT_MS } from "../../runs.js";
+import { graftParkToolCallId, markChildrenStoppedByUserOnAbort, syncRefusalHttpStatus, zeroWorkRefusalFacts, releaseKeyIfZeroWorkRefusal, createPromptCommitReader, settleResumeAnchor, HEARTBEAT_MS } from "../../runs.js";
 import { atHostBoundary, sealResultForExit, outwardPlane } from "../../terminal.js";
+import { voidVerifierPauseCard } from "../../verifier-pause-card.js";
 import { withPrincipal } from "../../observability/principal-context.js";
 import { fleetRunPublisher, fleetRunLabels, fleetRunResiduals, isFleetAgentTerminalNotification } from "../../fleet/fleet-bus.js";
 import { defaultSubagentTailBus } from "../../fleet/subagent-tail-bus.js";
@@ -14,14 +15,14 @@ import { clearTurnActivity, readTurnActivityMs, recordTurnActivity } from "../..
 import { buildCancelledLedgerRow, createRunAbort, mintCancelledResult } from "../../run-cancel-context.js";
 import { recordResourceWindow } from "../../resource-window.js";
 import { redactSecrets } from "../../trace/redact.js";
-import { liveToolEndForBacklog } from "../../trace/tool-output-media.js";
+import { writeLiveFrame, writeLiveHeartbeat } from "../live-frame.js";
 import { contextUsageEventData, turnEndEventData, toolStartEventData, toolEndEventData, taskProgressEventData, taskStartedEventData, taskNotificationEventData, compactedEventData, diagnosticsEventData, brainStatusEventData, steeringInjectedEventData, compactionOutcomeEventData, compactionStartedEventData, workspaceChangedEventData, wiringManifestFaceEventData, toolRosterDeltaEventData, toolProgressEventData, toolDisclosureEventData, humanInputEventData, appendModelUsageDelta, attachModelUsage, textEndEventData, liveIdentityFields } from "../../trace/project.js";
 import { cascadeConfig, runMeta } from "../run-meta.js";
 import { idemCallerOf, inflightKeyOf, submissionIdemOf } from "../idempotency.js";
 import { replayOfExistingRun } from "../submit-replay.js";
 import { httpErrorCode, sendJson, sendError, sseHeaders } from "../send.js";
 import { collectSsePreamble } from "../sse-log.js";
-import { buildApprovalPreamble, buildApprovalPreambleSseFrames } from "../../approval-card.js";
+import { buildApprovalPreamble } from "../../approval-card.js";
 import { approvalPreambleReplays, createApprovalCardEmitter, declaredApprovalFrameFamilies, resolveApprovalLeg, resolveStreamApprovalGate } from "../../tool-approval.js";
 import { buildActiveRunConflict, isActiveRunConflictBody, toDoneFrameResult } from "../active-run-conflict.js";
 import { commitExecutionContext } from "../execution-context.js";
@@ -42,12 +43,6 @@ import { refusalBody } from "../refusal-body.js";
 import { heldWorkflowParkDecisions } from "../../parked-decide.js";
 import { createSessionWorkspaceRecorder, legSessionWitnessOf, sessionWorkspaceStoreOf } from "../../session-workspace.js";
 const DISCONNECT_PARK_GRACE_MS = 10_000;
-function sseData(res, payload) {
-    const anchor = payload.eventId;
-    const idLine = typeof anchor === "string" && anchor.length > 0 ? `id: ${anchor}\n` : "";
-    const frame = payload.type === "tool_end" ? liveToolEndForBacklog(payload, res.writableLength) : payload;
-    res.write(`${idLine}data: ${JSON.stringify(frame)}\n\n`);
-}
 async function mintSubmitExitResult(result, checkpoints) {
     return redactTerminalResult(sealResultForExit(await graftParkToolCallId(result, checkpoints)));
 }
@@ -68,7 +63,7 @@ function sendSubmitResult(res, resp) {
     sendJson(res, 200, body);
 }
 function writeMetaFrame(res, taskId, sessionId, warnings) {
-    res.write(`event: meta\ndata: ${JSON.stringify({ type: "meta", taskId, ...(sessionId ? { sessionId } : {}), ...(warnings !== undefined ? { warnings } : {}) })}\n\n`);
+    writeLiveFrame(res, { type: "meta", taskId, ...(sessionId ? { sessionId } : {}), ...(warnings !== undefined ? { warnings } : {}) });
 }
 function refusalDoneResult(body) {
     if (isActiveRunConflictBody(body))
@@ -116,7 +111,7 @@ export async function handleTasks(req, res, match, ctx) {
             if (liveStream && replay.status === 200) {
                 sseHeaders(res, { "x-task-id": keyedRow.taskId });
                 writeMetaFrame(res, keyedRow.taskId, keyedRow.sessionId);
-                sseData(res, { type: "done", result: replay.body, replay: true });
+                writeLiveFrame(res, { type: "done", result: replay.body, replay: true });
                 res.end();
             }
             else {
@@ -129,14 +124,14 @@ export async function handleTasks(req, res, match, ctx) {
                 sseHeaders(res);
                 const hb = setInterval(() => {
                     if (!res.writableEnded)
-                        res.write(`event: heartbeat\ndata: {}\n\n`);
+                        writeLiveHeartbeat(res);
                 }, 15_000);
                 hb.unref?.();
                 res.on("close", () => clearInterval(hb));
                 try {
                     const resp = await cached;
                     if (!res.writableEnded)
-                        sseData(res, { type: "done", result: doneResultOfOutcome(resp), replay: true });
+                        writeLiveFrame(res, { type: "done", result: doneResultOfOutcome(resp), replay: true });
                 }
                 finally {
                     clearInterval(hb);
@@ -260,18 +255,18 @@ export async function handleTasks(req, res, match, ctx) {
                             deps.logger?.warn?.("approval_preamble_row_skipped", { sessionId: replaySessionId, skipped, face: "tasks.stream" });
                         if (dropped > 0)
                             deps.logger?.warn?.("approval_preamble_capped", { sessionId: replaySessionId, dropped, replayMax: deps.config.streamApproval.replayMax, face: "tasks.stream" });
-                        return buildApprovalPreambleSseFrames(frames);
+                        return frames;
                     }, (reason, err) => deps.logger?.warn?.("approval_preamble_failed", { sessionId: replaySessionId, reason, face: "tasks.stream", error: err instanceof Error ? err.message : String(err ?? "") }));
                     if (!res.writableEnded && !res.destroyed) {
                         for (const f of preambleFrames)
-                            res.write(`event: ${f.event}\ndata: ${JSON.stringify(f.data)}\n\n`);
+                            writeLiveFrame(res, { ...f });
                         if (deps.toolApproval && preambleFrames.length > 0) {
                             for (const askId of presentedAskIds)
                                 presentedOnConnection.add(askId);
                             const unwatch = deps.toolApproval.watchPresentedCards(presentedAskIds, (frame) => {
                                 if (res.writableEnded || res.destroyed || !admitPresentedComplete(frame.askId))
                                     return;
-                                res.write(`event: ${frame.type}\ndata: ${JSON.stringify(frame)}\n\n`);
+                                writeLiveFrame(res, { ...frame });
                             });
                             res.once("close", unwatch);
                         }
@@ -279,7 +274,7 @@ export async function handleTasks(req, res, match, ctx) {
                 }
                 const hb = setInterval(() => {
                     if (!res.writableEnded && !res.destroyed)
-                        res.write(`event: heartbeat\ndata: {}\n\n`);
+                        writeLiveHeartbeat(res);
                 }, 15_000);
                 hb.unref?.();
                 let ranLive = false;
@@ -294,13 +289,14 @@ export async function handleTasks(req, res, match, ctx) {
                     let userMsgEntryId;
                     const promptCommit = createPromptCommitReader();
                     let anchorPut = false;
-                    const putRewindAnchor = () => {
-                        if (anchorPut || !userMsgEntryId || !durableTaskId || !deps.resumeAnchorStore)
+                    const putRewindAnchor = async () => {
+                        const store = deps.resumeAnchorStore;
+                        const key = durableTaskId;
+                        const entryId = userMsgEntryId;
+                        if (anchorPut || !entryId || !key || !store)
                             return;
                         anchorPut = true;
-                        void deps.resumeAnchorStore
-                            .put(prepared.spec.sessionId, durableTaskId, userMsgEntryId, principal ?? null)
-                            .catch(() => deps.metrics?.inc("resume_anchor_capture_failed"));
+                        await settleResumeAnchor(() => store.put(prepared.spec.sessionId, key, entryId, principal ?? null), { leg: "stream", kind: "prompt" });
                     };
                     if (deps.runStore) {
                         const tid = earlyDurableTid ?? uuidv7();
@@ -311,23 +307,23 @@ export async function handleTasks(req, res, match, ctx) {
                             recordResourceWindow(tid, prepared.spec.resourceSuspend);
                         if (created.existing) {
                             const replay = await replayOfExistingRun(created.existing, { principal: submitter, idem }, "sync", deps, deps.runStore);
-                            sseData(res, { type: "done", result: doneResultOfOutcome(replay), replay: true });
+                            writeLiveFrame(res, { type: "done", result: doneResultOfOutcome(replay), replay: true });
                             return replay;
                         }
                         if (created.sessionAbsent) {
                             const refused = rootSessionAbsentAnswer();
-                            sseData(res, { type: "done", result: doneResultOfOutcome(refused) });
+                            writeLiveFrame(res, { type: "done", result: doneResultOfOutcome(refused) });
                             return refused;
                         }
                         if (!created.ok) {
                             const conflict = await buildActiveRunConflict({ runStore: deps.runStore, checkpointStore: deps.checkpointStore, governance: deps.config, runStaleSec: deps.config.runStaleSec, turnActivity: readTurnActivityMs }, prepared.spec.sessionId, created.activeTaskId);
                             const refused = { status: 409, body: conflict };
-                            sseData(res, { type: "done", result: doneResultOfOutcome(refused) });
+                            writeLiveFrame(res, { type: "done", result: doneResultOfOutcome(refused) });
                             return refused;
                         }
                         const placementReject = await commitExecutionContext(deps, { kind: "run", runStore: deps.runStore, taskId: tid }, prepared.execution);
                         if (placementReject) {
-                            sseData(res, { type: "done", result: doneResultOfOutcome(placementReject) });
+                            writeLiveFrame(res, { type: "done", result: doneResultOfOutcome(placementReject) });
                             return placementReject;
                         }
                         durableTaskId = tid;
@@ -335,7 +331,7 @@ export async function handleTasks(req, res, match, ctx) {
                     if (deps.checkpointStore) {
                         const ctxRefusal = await persistSubmitCtx(deps.checkpointStore, deps, durableTaskId !== undefined && deps.runStore ? { runStore: deps.runStore, taskId: durableTaskId } : undefined, prepared.spec.sessionId, { body: prepared.body, memoryScope: prepared.auth?.memoryScope, writerVersion: serviceVersion() });
                         if (ctxRefusal) {
-                            sseData(res, { type: "done", result: doneResultOfOutcome(ctxRefusal) });
+                            writeLiveFrame(res, { type: "done", result: doneResultOfOutcome(ctxRefusal) });
                             return ctxRefusal;
                         }
                     }
@@ -407,7 +403,7 @@ export async function handleTasks(req, res, match, ctx) {
                                 recordFailOpen(failOpenTagForDroppedFrame("engine_notice"), "frame=engine_notice");
                                 return;
                             }
-                            sseData(res, { type: "engine_notice", ...row });
+                            writeLiveFrame(res, { type: "engine_notice", ...row });
                         },
                         ...(noticeLedger
                             ? {
@@ -437,34 +433,34 @@ export async function handleTasks(req, res, match, ctx) {
                                         if (res.writableEnded)
                                             return;
                                         for (const end of childReasoning.onEvent(e))
-                                            sseData(res, end);
+                                            writeLiveFrame(res, end);
                                         const t = e.type;
                                         if (t === "task_progress") {
-                                            sseData(res, { type: "task_progress", ...taskProgressEventData(e) });
+                                            writeLiveFrame(res, { type: "task_progress", ...taskProgressEventData(e) });
                                         }
                                         else if (t === "task_started") {
-                                            sseData(res, { type: "task_started", ...taskStartedEventData(e) });
+                                            writeLiveFrame(res, { type: "task_started", ...taskStartedEventData(e) });
                                         }
                                         else if (t === "tool_start") {
                                             const tsv = e;
-                                            sseData(res, { type: "tool_start", ...toolStartEventData(tsv) });
+                                            writeLiveFrame(res, { type: "tool_start", ...toolStartEventData(tsv) });
                                         }
                                         else if (t === "tool_end") {
                                             const te = e;
-                                            sseData(res, { type: "tool_end", ...toolEndEventData(te) });
+                                            writeLiveFrame(res, { type: "tool_end", ...toolEndEventData(te) });
                                         }
                                         else if (t === "text_delta") {
                                             const td = e;
-                                            sseData(res, { type: "text_delta", delta: td.delta, ...(td.eventId ? { eventId: td.eventId } : {}), ...(td.parentToolCallId ? { parentToolCallId: td.parentToolCallId } : {}) });
+                                            writeLiveFrame(res, { type: "text_delta", delta: td.delta, ...(td.eventId ? { eventId: td.eventId } : {}), ...(td.parentToolCallId ? { parentToolCallId: td.parentToolCallId } : {}) });
                                         }
                                         else if (t === "text_end") {
                                             const tend = textEndEventData(e);
                                             if (tend !== null)
-                                                sseData(res, { type: "text_end", ...tend });
+                                                writeLiveFrame(res, { type: "text_end", ...tend });
                                         }
                                         else if (t === "reasoning_delta") {
                                             const rd = e;
-                                            sseData(res, { type: "reasoning_delta", delta: redactSecrets(rd.delta), ...(rd.eventId ? { eventId: rd.eventId } : {}), ...(rd.parentToolCallId ? { parentToolCallId: rd.parentToolCallId } : {}) });
+                                            writeLiveFrame(res, { type: "reasoning_delta", delta: redactSecrets(rd.delta), ...(rd.eventId ? { eventId: rd.eventId } : {}), ...(rd.parentToolCallId ? { parentToolCallId: rd.parentToolCallId } : {}) });
                                         }
                                     },
                                     onTaskNotification: (n, opts) => {
@@ -472,7 +468,7 @@ export async function handleTasks(req, res, match, ctx) {
                                             return;
                                         if (!res.writableEnded)
                                             for (const end of childReasoning.cut(reasoningStreamOfTask(n.task_id, n.sessionId)))
-                                                sseData(res, end);
+                                                writeLiveFrame(res, end);
                                         defaultSubagentTailBus.forgetHandle(n.task_id);
                                         if (defaultSubagentTailBus.hasSubscribers(n.task_id)) {
                                             defaultSubagentTailBus.publish(n.task_id, { type: "task_settled", taskId: n.task_id, status: n.status, ...(typeof n.seq === "number" ? { seq: n.seq } : {}), ...(n.summary ? { summary: redactSecrets(n.summary) } : {}) });
@@ -488,7 +484,7 @@ export async function handleTasks(req, res, match, ctx) {
                                             const key = taskNotificationDedupKey(n);
                                             if (syncNotifiedKeys.get(key) === undefined) {
                                                 syncNotifiedKeys.set(key, Promise.resolve(true));
-                                                sseData(res, { type: "task_notification", ...taskNotificationEventData({ notification: n, ...(opts?.priority !== undefined ? { priority: opts.priority } : {}) }) });
+                                                writeLiveFrame(res, { type: "task_notification", ...taskNotificationEventData({ notification: n, ...(opts?.priority !== undefined ? { priority: opts.priority } : {}) }) });
                                             }
                                         }
                                     },
@@ -505,13 +501,13 @@ export async function handleTasks(req, res, match, ctx) {
                                 void heldFor(prepared.peerLease, () => Promise.allSettled([Promise.resolve().then(() => liveStream.result())]));
                                 if (durableTaskId)
                                     steerableRuns.set(durableTaskId, liveStream);
-                                prepared.acceptance.attachStream({ reachable: () => !closed && !res.writableEnded && !res.destroyed, write: (frame) => sseData(res, { ...frame }) });
+                                prepared.acceptance.attachStream({ reachable: () => !closed && !res.writableEnded && !res.destroyed, write: (frame) => writeLiveFrame(res, { ...frame }) });
                                 const liveWorkspace = createSessionWorkspaceRecorder(sessionWorkspaceStoreOf(deps.sessionStorage), legSessionWitnessOf(prepared.spec));
                                 for await (const ev of liveStream) {
                                     if (closed)
                                         break;
                                     for (const end of ev.type === "done" ? [...childReasoning.cut(), ...topReasoning.cut()] : topReasoning.onEvent(ev))
-                                        sseData(res, end);
+                                        writeLiveFrame(res, end);
                                     const promptEntryId = promptCommit(ev);
                                     if (promptEntryId !== undefined)
                                         userMsgEntryId = promptEntryId;
@@ -528,7 +524,7 @@ export async function handleTasks(req, res, match, ctx) {
                                         }
                                         finalizeTaskResult(ev.result, principal, prepared.spec.objective);
                                         noteRunOutcome(finalResult);
-                                        putRewindAnchor();
+                                        await putRewindAnchor();
                                         settleFleet(outwardPlane(finalResult.terminal).status, fleetRunResiduals(finalResult));
                                         if (ledgerSink && finalResult) {
                                             if (usageKey && deps.modelUsage && deps.runStore && durableTaskId) {
@@ -540,7 +536,7 @@ export async function handleTasks(req, res, match, ctx) {
                                             await ledgerSink.onDone(finalResult);
                                             ledgerTerminal = true;
                                         }
-                                        sseData(res, { ...ev, result: finalResult });
+                                        writeLiveFrame(res, { ...ev, result: finalResult });
                                         continue;
                                     }
                                     if (ledgerSink) {
@@ -552,15 +548,15 @@ export async function handleTasks(req, res, match, ctx) {
                                     if (ev.type === "status")
                                         deps.metrics?.inc("brain_retry_total", { phase: String(ev.phase) });
                                     if (ev.type === "status") {
-                                        sseData(res, { type: "status", ...brainStatusEventData(ev) });
+                                        writeLiveFrame(res, { type: "status", ...brainStatusEventData(ev) });
                                     }
                                     else if (ev.type === "tool_end") {
                                         const te = ev;
-                                        sseData(res, { type: "tool_end", ...toolEndEventData(te) });
+                                        writeLiveFrame(res, { type: "tool_end", ...toolEndEventData(te) });
                                     }
                                     else if (ev.type === "tool_start") {
                                         const tsv = ev;
-                                        sseData(res, { type: "tool_start", ...toolStartEventData(tsv) });
+                                        writeLiveFrame(res, { type: "tool_start", ...toolStartEventData(tsv) });
                                     }
                                     else if (ev.type === "task_notification") {
                                         const tnv = ev.notification;
@@ -569,58 +565,58 @@ export async function handleTasks(req, res, match, ctx) {
                                         if (tnvPrior === undefined || !(await tnvPrior)) {
                                             if (tnvKey !== undefined)
                                                 syncNotifiedKeys.set(tnvKey, Promise.resolve(true));
-                                            sseData(res, { type: "task_notification", ...taskNotificationEventData(ev) });
+                                            writeLiveFrame(res, { type: "task_notification", ...taskNotificationEventData(ev) });
                                         }
                                     }
                                     else if (ev.type === "reasoning_delta" && typeof ev.delta === "string") {
-                                        sseData(res, { type: "reasoning_delta", delta: redactSecrets(ev.delta), ...(ev.eventId ? { eventId: ev.eventId } : {}), ...(ev.parentToolCallId ? { parentToolCallId: ev.parentToolCallId } : {}) });
+                                        writeLiveFrame(res, { type: "reasoning_delta", delta: redactSecrets(ev.delta), ...(ev.eventId ? { eventId: ev.eventId } : {}), ...(ev.parentToolCallId ? { parentToolCallId: ev.parentToolCallId } : {}) });
                                     }
                                     else if (ev.type === "task_progress") {
-                                        sseData(res, { type: "task_progress", ...taskProgressEventData(ev) });
+                                        writeLiveFrame(res, { type: "task_progress", ...taskProgressEventData(ev) });
                                     }
                                     else if (ev.type === "task_started") {
-                                        sseData(res, { type: "task_started", ...taskStartedEventData(ev) });
+                                        writeLiveFrame(res, { type: "task_started", ...taskStartedEventData(ev) });
                                     }
                                     else if (ev.type === "compacted") {
-                                        sseData(res, { type: "compacted", ...compactedEventData(ev) });
+                                        writeLiveFrame(res, { type: "compacted", ...compactedEventData(ev) });
                                     }
                                     else if (ev.type === "diagnostics") {
-                                        sseData(res, { type: "diagnostics", ...diagnosticsEventData(ev) });
+                                        writeLiveFrame(res, { type: "diagnostics", ...diagnosticsEventData(ev) });
                                     }
                                     else if (ev.type === "steering_injected") {
-                                        sseData(res, { type: "steering_injected", ...steeringInjectedEventData(ev) });
+                                        writeLiveFrame(res, { type: "steering_injected", ...steeringInjectedEventData(ev) });
                                     }
                                     else if (ev.type === "workspace_changed") {
-                                        sseData(res, { type: "workspace_changed", ...workspaceChangedEventData(ev) });
+                                        writeLiveFrame(res, { type: "workspace_changed", ...workspaceChangedEventData(ev) });
                                     }
                                     else if (ev.type === "compaction_outcome") {
-                                        sseData(res, { type: "compaction_outcome", ...compactionOutcomeEventData(ev) });
+                                        writeLiveFrame(res, { type: "compaction_outcome", ...compactionOutcomeEventData(ev) });
                                     }
                                     else if (ev.type === "compaction_started") {
-                                        sseData(res, { type: "compaction_started", ...compactionStartedEventData(ev) });
+                                        writeLiveFrame(res, { type: "compaction_started", ...compactionStartedEventData(ev) });
                                     }
                                     else if (ev.type === "wiring_manifest") {
                                         const wiringFace = wiringManifestFaceEventData(ev, wiringOperatorFace, legWiringSections());
                                         wiringReceipt ??= wiringFace;
-                                        sseData(res, { type: "wiring_manifest", ...wiringFace });
+                                        writeLiveFrame(res, { type: "wiring_manifest", ...wiringFace });
                                     }
                                     else if (ev.type === "tool_roster_delta") {
                                         const rosterDelta = toolRosterDeltaEventData(ev);
                                         if (rosterDelta !== undefined)
-                                            sseData(res, { type: "tool_roster_delta", ...rosterDelta });
+                                            writeLiveFrame(res, { type: "tool_roster_delta", ...rosterDelta });
                                     }
                                     else if (ev.type === "tool_progress") {
                                         const progress = toolProgressEventData(ev);
                                         if (progress !== undefined)
-                                            sseData(res, { type: "tool_progress", ...progress });
+                                            writeLiveFrame(res, { type: "tool_progress", ...progress });
                                     }
                                     else if (ev.type === "tool_disclosure") {
                                         const disclosure = toolDisclosureEventData(ev);
                                         if (disclosure !== undefined)
-                                            sseData(res, { type: "tool_disclosure", ...disclosure });
+                                            writeLiveFrame(res, { type: "tool_disclosure", ...disclosure });
                                     }
                                     else if (ev.type === "human_input") {
-                                        sseData(res, { type: "human_input", ...humanInputEventData(ev) });
+                                        writeLiveFrame(res, { type: "human_input", ...humanInputEventData(ev) });
                                     }
                                     else if (ev.type === "text_delta" || ev.type === "text_end" || ev.type === "turn_end" || ev.type === "message_committed" || ev.type === "context_usage") {
                                         const e = ev;
@@ -637,10 +633,10 @@ export async function handleTasks(req, res, match, ctx) {
                                                         ? { type: "message_committed", entryId: e.entryId, role: e.role, ...(e.toolCallId !== undefined ? { toolCallId: e.toolCallId } : {}), ...ident }
                                                         : { type: "context_usage", ...contextUsageEventData(ev), ...ident };
                                         if (arm !== null)
-                                            sseData(res, arm);
+                                            writeLiveFrame(res, arm);
                                     }
                                     else {
-                                        sseData(res, { ...ev });
+                                        writeLiveFrame(res, { ...ev });
                                     }
                                 }
                             });
@@ -652,7 +648,7 @@ export async function handleTasks(req, res, match, ctx) {
                                 recordFailOpen(failOpenTagForDroppedFrame(frame.type), `frame=${frame.type}`);
                                 return;
                             }
-                            res.write(`event: ${frame.type}\ndata: ${JSON.stringify(frame)}\n\n`);
+                            writeLiveFrame(res, { ...frame });
                         };
                         const faceAlive = () => !res.writableEnded && !res.destroyed;
                         const emitElicitation = createLedgerTwinEmit({ sink: ledgerSink, writeLive: emitAsk, liveReachable: faceAlive });
@@ -669,7 +665,7 @@ export async function handleTasks(req, res, match, ctx) {
                             const fKey = f.type === "task_notification" ? taskNotificationStreamKeyOf(f) : undefined;
                             if (fKey !== undefined)
                                 syncNotifiedKeys.set(fKey, Promise.resolve(true));
-                            sseData(res, frame);
+                            writeLiveFrame(res, frame);
                         }, { route: "sync-stream-open", connection: "live-sse", log: (m, x) => deps.logger?.info?.(m, x) });
                         const withElicit = deps.elicitation
                             ? () => deps.elicitation.runWithContext({ taskId: askTaskId, owner: askOwner, emit: emitElicitation, abortSignal: ac.signal }, streamBody)
@@ -765,7 +761,7 @@ export async function handleTasks(req, res, match, ctx) {
                                 await releaseKeyIfZeroWorkRefusal(deps.runStore, durableTaskId, finalResult);
                             }
                             else {
-                                putRewindAnchor();
+                                await putRewindAnchor();
                                 const pending = await deps.checkpointStore?.findPendingTokenBySession(prepared.spec.sessionId);
                                 const dcCause = ac.cause();
                                 if (pending) {
@@ -885,7 +881,7 @@ export async function handleTasks(req, res, match, ctx) {
                         deps.modelUsage?.clear(usageKey);
                 }
                 if (!ranLive && resp && !res.writableEnded) {
-                    sseData(res, { type: "done", result: doneResultOfOutcome(resp), replay: true });
+                    writeLiveFrame(res, { type: "done", result: doneResultOfOutcome(resp), replay: true });
                 }
                 res.end();
             }
@@ -979,6 +975,7 @@ export async function handleTasks(req, res, match, ctx) {
                             inflightRuns.delete(durableTaskId);
                     }
                     const syncAbortCause = syncCancelCtrl.cause();
+                    await voidVerifierPauseCard(result, deps.checkpointStore);
                     if (syncAbortCause !== undefined) {
                         result = mintCancelledResult({
                             taskId: durableTaskId ?? "",

package/dist/http/run-read-face.js

@@ -1,5 +1,5 @@
 import { persistedPlaneOf } from "../terminal.js";
-import { memoRedactedRead, memoRedactTerminalResult, redactErrorMessage, redactTerminalResult } from "../observability/run-terminal.js";
+import { memoRedactedRead, memoRedactTerminalResult, redactErrorMessage, sealRunRowResult } from "../observability/run-terminal.js";
 import { RUN_HOLDER_DEATH_CODES, isTerminalRunStatus } from "../plugins/store-contracts.js";
 import { composeSupervisorCost, infraCost, infraUsageFromEvents, hasInfraPricing } from "../observability/cost-taxonomy.js";
 import { recordFailOpen } from "../observability/fail-open.js";
@@ -53,14 +53,14 @@ export async function readRunFace(deps, runStore, run) {
         status: stale ? "failed" : run.status,
         ...(lastActivityAt !== undefined ? { msSinceLastActivity: Math.max(0, Date.now() - lastActivityAt) } : {}),
         ...(crossSliceUsage !== undefined ? { crossSliceUsage } : {}),
-        result: isTerminalRunStatus(run.status) ? memoRedactTerminalResult("run.result", run.result ?? undefined) : redactTerminalResult(run.result ?? undefined),
+        result: isTerminalRunStatus(run.status) ? memoRedactTerminalResult("run.result", run.result ?? undefined) : (sealRunRowResult(run.result ?? null, "run.result") ?? undefined),
         supervisorCost,
         suggestions,
         errorCode: stale ? RUN_HOLDER_DEATH_CODES.stalled : (persistedPlaneOf(run.result).errorCode ?? run.errorCode ?? undefined),
         error: stale ? "run stalled (instance lost?)" : isTerminalRunStatus(run.status) ? memoRedactedRead("run.error", run.error ?? undefined, redactErrorMessage) : redactErrorMessage(run.error ?? undefined),
         jobId: run.jobId ?? undefined,
         source: run.source ?? undefined,
-        heldBy: run.instanceId ?? null,
+        heldBy: isTerminalRunStatus(run.status) ? null : (run.instanceId ?? null),
         cancelRequested: run.cancelRequested,
     };
 }

package/dist/http/send.d.ts

@@ -113,7 +113,7 @@ export declare function sendHttpError(res: ServerResponse, e: HttpError): void;
  */
 export declare function sendSessionPolicyError(res: ServerResponse, e: unknown, sentencePrefix?: string): boolean;
 /**
- * [ref] —— core `SessionError` → 应答,经 {@link sessionErrorHttp} 那**一只**映射(`src/session-error-wire.ts`)。
+ * [ref] —— core `SessionError` → 应答,经 {@link sessionErrorWireOf} 那**一只**映射(`src/session-error-wire.ts`;本服务自铸的同码具名拒按型先认,其余按码)。
  * 回 `true` = 已应答,调用点 `return`;`false` = 不是 `SessionError`,或这个词在这一面上是登记过的留白(站点的既有
  * 处置照旧 —— 通常是继续上抛到全局兜底)。
  *

package/dist/http/send.js

@@ -1,6 +1,6 @@
 import { SessionError, SessionPolicyError } from "@sema-agent/core";
 import { sessionPolicyErrorFacts, sessionPolicyErrorHttp, sessionPolicyErrorSentence } from "../session-policy-wire.js";
-import { sessionErrorHttp } from "../session-error-wire.js";
+import { sessionErrorWireOf } from "../session-error-wire.js";
 import { redactErrorMessage, redactHead } from "../observability/run-terminal.js";
 import { createCodedHttpError } from "../security.js";
 import { refusalBody } from "./refusal-body.js";
@@ -79,7 +79,7 @@ export function sendSessionPolicyError(res, e, sentencePrefix = "") {
 export function sendSessionError(res, e, face) {
     if (!(e instanceof SessionError))
         return false;
-    const wire = sessionErrorHttp(e.code, face);
+    const wire = sessionErrorWireOf(e, face);
     if (wire === undefined)
         return false;
     sendError(res, wire.status, wire.errorCode, wire.sentence ?? redactErrorMessage(e.message) ?? "session store error", wire.detail === undefined ? undefined : { detail: wire.detail });

package/dist/http/server.d.ts

@@ -13,6 +13,7 @@ import type { ExecutionRoot, ResolvedTaskSpec } from "./execution-context.js";
 import type { RunStore, ImageIndex, ImageBake, CheckpointStoreFull, ResumeAnchorStore, ApprovalExemptionStore, ApprovalNonceStore, ServiceSessionPolicyStore, ServiceFileHistoryStore, ToolResultStoreFull, StoreBackend } from "../plugins/store-backend.js";
 import type { RuleConsentLane } from "../rules-consent.js";
 import { type MemorySyncRequest, type MemorySyncResponse } from "../memory-sync.js";
+import type { MemorySyncRunner } from "../memory-sync-client.js";
 import type { TaskAttachmentStore } from "../plugins/task-attachment-store.js";
 import type { LeaderEndpoint } from "../leader/endpoint.js";
 import { type WorkflowAgentRegistry } from "../orchestration/workflow-agent-steer.js";
@@ -463,7 +464,7 @@ export interface ServiceSeamDeps {
     }>;
     /** 142-S5 §1.4: per-scope memory export reader (main.ts wires `exportMemoryScope` over the DB memory
      *  backend). Enables GET /v1/memory/export — present ONLY on a DB memory plane (MEMORY_ENGINE_BACKEND=
-     *  pg|tidb); absent / file posture ⇒ 501 (single-user file memory exports by copying the memory dir). */
+     *  pg|mysql); absent / file posture ⇒ 501 (single-user file memory exports by copying the memory dir). */
     memoryExport?: (scope: string) => Promise<MemoryEntry[]>;
     /**
      * [ref](core 5.57.0 `routePairingStatus`)—— **key↔URL 配对读面**:`GET /v1/models` 每行的
@@ -479,7 +480,7 @@ export interface ServiceSeamDeps {
     /** 142-S2.5(设计 §2.5;裁定 plan 随数据走,core 零运行时半场):one full sync round for one
      *  (scope, peer) — main.ts wires `performMemorySync` over the DB memory backend + the sync-cursor
      *  store. Enables POST /v1/memory/sync/:scope — present ONLY on a DB memory plane
-     *  (MEMORY_ENGINE_BACKEND=pg|tidb); absent / file posture ⇒ 501 honestly (a single-user file plane
+     *  (MEMORY_ENGINE_BACKEND=pg|mysql); absent / file posture ⇒ 501 honestly (a single-user file plane
      *  IS the TOC side of a sync — it has no central-authority half to serve). */
     memorySync?: (scope: string, syncReq: MemorySyncRequest) => Promise<MemorySyncResponse>;
     /** [ref] v2-c(core 5.40.0 `MemoryEngine.exportMemoryScopes`):治理完备包的**携出**面。main.ts 把它接到
@@ -533,6 +534,12 @@ export interface ServiceSeamDeps {
      * 装配漏接 ⇒ tsc 红(本行就是通知);测试桩在 `test/helpers/boot.ts` 显式给 false。
      */
     memoryAutoConsolidationArmed: boolean;
+    /**
+     * [ref] —— 本**部署**的记忆同步腿(客户端半场):`MEMORY_SYNC_URL` 设了且 file 记忆引擎亮着、执行器起了才在场(`boot/stores.ts`)。
+     * `GET /v1/sessions/:id/memory-status` 的 `memorySync` 格只读它的 `parked()` —— 停驻事实的唯一读口(写者 = 执行器的轮,运维行 `memory_sync_layer_parked` 读同一份);
+     * 缺席 ⇒ 那一格缺席(没有同步腿)。与 `memoryAutoConsolidationArmed` 同类:部署事实,不随会话、不随层座。
+     */
+    memorySyncLeg?: Pick<MemorySyncRunner, "parked">;
     /**
      * [ref] / [ref] + 车PI 修复轮 ④ —— 记忆整理阀门的**生效判决**(boot 第 4 段 `createConsolidationValve`:显式词,或出厂缺省按
      * 装配结果派生)。配置目录那一行(`GET /v1/config/catalog` 的 `MEMORY_CONSOLIDATION_DRIVER` `effectiveValue`)读它 —— 那一列的契约是

package/dist/http/sse-log.d.ts

@@ -70,15 +70,10 @@ export declare const SSE_PREAMBLE_TIMEOUT_MS = 2000;
  * `ApprovalAskStore.listPendingBySession` 的注)。丢结果这条语义不变:preamble 只读,丢弃零副作用。
  *
  * 导出给 `routes/tasks.ts` 的 sync 腿直接用 —— 那条腿不走 `streamSseLog`(它不是账本 tail),但
- * 「有界 + fail-open」这条判据必须是**同一份实现**,不能各腿各写一遍。
+ * 「有界 + fail-open」这条判据必须是**同一份实现**,不能各腿各写一遍。帧型是调用方的(本泵写 `{ event, data }`,
+ * sync 腿把卡帧原样交给它自己的写口 `http/live-frame.ts`),所以按帧型泛化。
  */
-export declare function collectSsePreamble(preamble: (signal: AbortSignal) => Promise<Array<{
-    event: string;
-    data: unknown;
-}>>, onFailure?: (reason: "timeout" | "error", err?: unknown) => void, timeoutMs?: number): Promise<Array<{
-    event: string;
-    data: unknown;
-}>>;
+export declare function collectSsePreamble<F>(preamble: (signal: AbortSignal) => Promise<F[]>, onFailure?: (reason: "timeout" | "error", err?: unknown) => void, timeoutMs?: number): Promise<F[]>;
 /** The shared resumable SSE pump (P2.8) — provider supplies the log-specific differences; the liveness/
  *  heartbeat/terminal-re-fetch/15-min-cap logic is identical for task_run + image_bake.
  *

package/dist/http/stored-body-replay.d.ts

@@ -9,7 +9,7 @@
  */
 import type { PermissionMode } from "@sema-agent/core";
 import { type Autonomy } from "../runtime-governance.js";
-import { type LaneHomeDeployment } from "../execution-lane-caps.js";
+import { type ExecutionConfigRootDeployment } from "../execution-config-root.js";
 import { type StoredBodyReplayRefusal } from "./checkpoint-ctx.js";
 import type { CheckpointCtx } from "./route-ctx.js";
 /**
@@ -22,9 +22,9 @@ export declare function permissionModeReadingUnstated(ctx: CheckpointCtx, floor:
     floor: PermissionMode;
 } | undefined;
 /**
- * 预判读的部署配置:`autonomy`(第三问的模式词地板)与执行车道的 home 两位(`~/` 形规则那一问)。`ServiceConfig` 结构上满足,四个问点传 `deps.config` 整份。
+ * 预判读的部署配置:`autonomy`(第三问的模式词地板)、执行车道的 home 两位(`~/` 形规则那一问)与配置根的几位(user 设置层 `/` 规则那一问)。`ServiceConfig` 结构上满足,四个问点传 `deps.config` 整份。
  */
-export type StoredReplayDeployment = LaneHomeDeployment & {
+export type StoredReplayDeployment = ExecutionConfigRootDeployment & {
     readonly autonomy?: Autonomy | undefined;
 };
 /**

package/dist/http/stored-body-replay.js

@@ -4,6 +4,7 @@ import { entryProblemsFacts } from "../entry-problems.js";
 import { autonomyModeFloor, entryPermissionMode } from "../runtime-governance.js";
 import { inertToolListEntryOf, replayInertEntry } from "../rule-entry-list.js";
 import { executionLaneHomeDir } from "../execution-lane-caps.js";
+import { executionConfigRootOf } from "../execution-config-root.js";
 import { migrationWindowEnd } from "../plugins/one-time-migrations.js";
 import { allowListReadingEraOf, allowListReadingUnstated, permissionModeReadingStated, retiredRequestKeyOf } from "./checkpoint-ctx.js";
 export function permissionModeReadingUnstated(ctx, floor) {
@@ -35,7 +36,8 @@ function storedRulePolicyRefusal(body, deployment) {
     if (permissions === undefined)
         return undefined;
     const home = executionLaneHomeDir(deployment);
-    const refused = rulePolicyBucketsRefusal({ ...(Array.isArray(permissions["ask"]) ? { ask: permissions["ask"] } : {}), ...(Array.isArray(permissions["deny"]) ? { deny: permissions["deny"] } : {}) }, home !== undefined ? { home } : {});
+    const configRoot = executionConfigRootOf(deployment);
+    const refused = rulePolicyBucketsRefusal({ ...(Array.isArray(permissions["ask"]) ? { ask: permissions["ask"] } : {}), ...(Array.isArray(permissions["deny"]) ? { deny: permissions["deny"] } : {}) }, { ...(home !== undefined ? { home } : {}), ...(configRoot !== undefined ? { configRoot } : {}) });
     if (refused !== undefined)
         return replayInertEntry(`settings.permissions.${refused.bucket}`, "deny", SETTINGS_RULE_REFUSAL_CODE, `${REQUEST_SETTINGS_REFUSAL_PREFIX}${refused.message}`, { ...entryProblemsFacts(refused.problems) });
     const neverAuto = readTightenOnlySeats({ permissions }).values.neverAuto;

package/dist/instruction-source-notice.d.ts

@@ -79,8 +79,15 @@ export declare function createInstructionSourceSeat(sessionStore: unknown, emit:
  * 超时**(codex che-NM r2 [high];S-9 `write-behind-counter.ts` 先例:mysql2 `{sql, timeout}` / pg `query_timeout`,pg-pool
  * 超时即销毁那条连接)—— 只放手不截断,卡住的查询会一直占着池里的连接。超期后仍在飞的写由 CAS 挡住,不会盖掉更新的基线。
  * 数值与 core 给 `probeInstructionSources` 的 2s 天花板同量级:一行 PK 读写在健康库上是毫秒级。
+ * 第二个读者:回退锚写入(`runs.ts` 的 `settleResumeAnchor`)—— 同为单行 PK 写、同在腿的关键路径上(流式腿的终帧等它),
+ * 同为披露类(F)放手,所以读同一只数、同一只 {@link withinIoDeadline}。
  */
 export declare const BASELINE_IO_DEADLINE_MS = 2000;
+/** {@link withinIoDeadline} 到点放手。**具名型**:调用方据它分诊「超期」与「店报错」,不比对文案。 */
+export declare class IoDeadlineExceeded extends Error {
+}
+/** 单行店操作的有界等待:`op` 在 {@link BASELINE_IO_DEADLINE_MS} 内落定就原样交出,否则 reject {@link IoDeadlineExceeded}。只放手不取消 —— 超期后仍在飞的那次操作照常落定(迟到的 reject 被吞,不成未处理拒绝)。 */
+export declare function withinIoDeadline<T>(op: () => Promise<T>): Promise<T>;
 /**
  * **唯一铸点**:本次 prepare 选中的来源 `current`(链成员相对路径;没有 = `null`)与基线比。
  *  · 没有基线 ⇒ 只写不发(新会话首 run);