@sema-agent/server 7.140.0 → 7.142.0

package/dist/http/routes/tasks.js

@@ -1,27 +1,28 @@
 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";
 import { createReasoningSegments, reasoningStreamOfTask } from "../../trace/model-segment.js";
 import { emitPendingWorkflowCompletions, taskNotificationInboxEntry, taskNotificationStreamKeyOf, NotifiedKeys } from "../../orchestration/workflow-completion-inbox.js";
-import { createLedgerSink, createLedgerTwinEmit } from "../../trace/ledger-sink.js";
+import { createForwardAppendFailedNote, createLedgerSink, createLedgerTwinEmit } from "../../trace/ledger-sink.js";
 import { registerEngineNoticeLeg } from "../../trace/engine-notice-wire.js";
 import { clearTurnActivity, readTurnActivityMs, recordTurnActivity } from "../../turn-activity.js";
 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;
                         }
                     }
@@ -346,7 +342,7 @@ export async function handleTasks(req, res, match, ctx) {
                     if (durableTaskId && deps.runStore) {
                         const rs = deps.runStore;
                         const tid = durableTaskId;
-                        ledgerSink = createLedgerSink({ appendEvent: (seq, type, data) => rs.appendEvent(tid, seq, type, data), persistThinking: deps.config.traceThinking, onActivity: (kind, statusData) => recordTurnActivity(tid, kind, statusData), legSections: legWiringSections });
+                        ledgerSink = createLedgerSink({ appendEvent: (seq, type, data) => rs.appendEvent(tid, seq, type, data), persistThinking: deps.config.traceThinking, onActivity: (kind, statusData) => recordTurnActivity(tid, kind, statusData), legSections: legWiringSections, usage: { modelUsage: deps.modelUsage, taskId: tid } });
                         usageKey = tid;
                         deps.modelUsage?.register(tid);
                         const owner = principal ?? null;
@@ -404,10 +400,11 @@ export async function handleTasks(req, res, match, ctx) {
                         ...(prepared.engineNotices !== undefined ? { pending: prepared.engineNotices } : {}),
                         live: (row) => {
                             if (res.writableEnded || res.destroyed) {
-                                recordFailOpen(failOpenTagForDroppedFrame("engine_notice"), "frame=engine_notice");
+                                if (noticeLedger === undefined)
+                                    recordFailOpen(failOpenTagForDroppedFrame("engine_notice"), "frame=engine_notice");
                                 return;
                             }
-                            sseData(res, { type: "engine_notice", ...row });
+                            writeLiveFrame(res, { type: "engine_notice", ...row });
                         },
                         ...(noticeLedger
                             ? {
@@ -437,34 +434,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 +469,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 +485,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 +502,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 +525,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 +537,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 +549,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 +566,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 +634,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 +649,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 +666,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)
@@ -746,10 +743,11 @@ export async function handleTasks(req, res, match, ctx) {
                             ? deps.sendUserFile.runWithContext({
                                 taskId: askTaskId,
                                 emit: async (f) => {
-                                    void (await emitAsk(f));
+                                    if (ledgerSink === undefined || faceAlive())
+                                        void (await emitAsk(f));
                                     if (ledgerSink) {
                                         const { type, ...rest } = f;
-                                        await ledgerSink.append(type, rest).catch(() => undefined);
+                                        await ledgerSink.append(type, rest).catch(createForwardAppendFailedNote(type));
                                     }
                                 },
                             }, withApproval)
@@ -765,7 +763,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 +883,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 +977,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.d.ts

@@ -5,6 +5,13 @@ import type { ServiceConfig } from "../config-types.js";
 export interface RunFaceDeps {
     config: Pick<ServiceConfig, "runStaleSec" | "infraCostRates">;
 }
+/** 一条行是不是「看起来失联」:盘上 `running`、而最后一次心跳早于 `runStaleSec` —— 读面把它折成 `failed`(`run.stalled`)。读它的人只此一只判据(读面与同步重放回执同读)。 */
+export declare function runRowStale(deps: RunFaceDeps, run: RunRecord): boolean;
+/**
+ * 一条行上的结果**当作出口结果读**(封口 + 脱敏的读入口)—— 读面的 `result` 与同步提交的重放体读的是同一只:
+ * 终局行按 taskId+updatedAt 记忆的读入口,非终局行(停驻 / 在跑)走店入口那一套封口的读入口;行上没有结果 ⇒ `undefined`。
+ */
+export declare function runRowExitResult(run: RunRecord): import("../plugins/store-contracts.js").PersistedTaskResult | undefined;
 export declare function readRunFace(deps: RunFaceDeps, runStore: RunStore, run: RunRecord): Promise<{
     result: import("../plugins/store-contracts.js").PersistedTaskResult | undefined;
     supervisorCost: import("../observability/cost-taxonomy.js").SupervisorCostBreakdown | undefined;

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

@@ -1,13 +1,19 @@
 import { persistedPlaneOf } from "../terminal.js";
-import { memoRedactedRead, memoRedactTerminalResult, redactErrorMessage, redactTerminalResult } from "../observability/run-terminal.js";
+import { memoRedactedRead, memoRedactTerminalResult, redactErrorMessage, sealStoredRunRowResult } 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";
 import { readTurnActivityMs } from "../turn-activity.js";
 import { buildCrossSliceUsage, readResourceWindow } from "../resource-window.js";
+export function runRowStale(deps, run) {
+    return run.status === "running" && Date.now() - new Date(run.updatedAt).getTime() > deps.config.runStaleSec * 1000;
+}
+export function runRowExitResult(run) {
+    return isTerminalRunStatus(run.status) ? memoRedactTerminalResult("run.result", run.result ?? undefined) : (sealStoredRunRowResult(run.result ?? null, "run.result") ?? undefined);
+}
 export async function readRunFace(deps, runStore, run) {
     const taskId = run.taskId;
-    const stale = run.status === "running" && Date.now() - new Date(run.updatedAt).getTime() > deps.config.runStaleSec * 1000;
+    const stale = runRowStale(deps, run);
     const infraRates = deps.config.infraCostRates;
     const needCost = Boolean(run.result?.stats && !stale && infraRates && hasInfraPricing(infraRates));
     const needSuggestions = !stale && run.status === "completed";
@@ -53,14 +59,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: runRowExitResult(run),
         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`,或这个词在这一面上是登记过的留白(站点的既有
  * 处置照旧 —— 通常是继续上抛到全局兜底)。
  *
@@ -123,6 +123,11 @@ export declare function sendSessionPolicyError(res: ServerResponse, e: unknown,
  * (路径只进运维面:`server.session-repo.corrupt-record-skipped` 的探针行,[ref];SQL 两店走各自的拒绝句)。
  */
 export declare function sendSessionError(res: ServerResponse, e: unknown, face: SessionErrorFace): boolean;
+/**
+ * 全局兜底的 open 面一臂(`http/server.ts`:路由里逃出来的、不是 `HttpError` 的故障)—— 码经 {@link openFaceFaultWire}(会话列表行的 `unreadable` 同读这一只:
+ * 列表说的码就是读口答的码,`session-error-wire.ts` 头注「一张表、两个读者」)。有臂的 `SessionError` 同 {@link sendSessionError};其余落通用 500,固定句。
+ */
+export declare function sendOpenFaceFault(res: ServerResponse, e: unknown): void;
 export declare function msg(e: unknown): string;
 /**
  * 路由抛出的未归类错误的运维行 `request_error` —— **唯一写者**。外层兜底(`server.ts`)与「就地经映射下发」的站点(会话同步的暂存提交 catch)同调它:

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 { openFaceFaultWire, 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,12 +79,19 @@ 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 });
+    sendSessionWire(res, e, wire);
     return true;
 }
+export function sendOpenFaceFault(res, e) {
+    sendSessionWire(res, e, openFaceFaultWire(e));
+}
+function sendSessionWire(res, e, wire) {
+    const sentence = wire.sentence ?? (e instanceof SessionError ? redactErrorMessage(e.message) : undefined) ?? "session store error";
+    sendError(res, wire.status, wire.errorCode, sentence, wire.detail === undefined ? undefined : { detail: wire.detail });
+}
 export function msg(e) {
     return e instanceof Error ? e.message : String(e);
 }