@sema-agent/server 7.142.0 → 7.144.0

package/dist/http/resume-legs.js

@@ -4,7 +4,7 @@ import { uuidv7, resumeWithVerification, CheckpointError, defaultTaskRegistry, t
 import { decideParkedAgent, denyWorkflowParkForked, denyWorkflowParksUnreadable, findParkOrigin, heldWorkflowParkDecisions, planWorkflowParkedDecide } from "../parked-decide.js";
 import { parkDecisionFingerprint } from "../orchestration/workflow-park-decision.js";
 import { headReadOf } from "../session-incarnation.js";
-import { createSessionWorkspaceRecorder, legSessionWitnessOf, sessionWorkspaceStoreOf } from "../session-workspace.js";
+import { createSessionWorkspaceRecorder, sessionWorkspaceStoreOf } from "../session-workspace.js";
 const DELIVERY_NOT_RECORDED = "workflow park decide: this delivery no longer holds the host session (its claim was released) — the decision was not recorded and this delivery was not started";
 import { HttpError, decodeCheckpointScope, CHECKPOINT_PUBLIC_SCOPE } from "../security.js";
 import { graftParkToolCallId, parkToolCallId, TurnAnchorCapture, HEARTBEAT_MS, markChildrenStoppedByUserOnAbort, voidHeldParkCard } from "../runs.js";
@@ -15,7 +15,7 @@ import { isTerminalRunStatus } from "../plugins/store-contracts.js";
 import { readTurnActivityMs, recordTurnActivity } from "../turn-activity.js";
 import { recordResumeResourceWindow } from "../resource-window.js";
 import { emitPendingWorkflowCompletions, taskNotificationInboxEntry, taskNotificationStreamKeyOf, NotifiedKeys } from "../orchestration/workflow-completion-inbox.js";
-import { fleetRunPublisher, fleetRunLabels, fleetRunResiduals, isFleetAgentTerminalNotification } from "../fleet/fleet-bus.js";
+import { fleetRunPublisher, fleetRunLabels, fleetRunResiduals } from "../fleet/fleet-bus.js";
 import { defaultSubagentTailBus } from "../fleet/subagent-tail-bus.js";
 import { currentApprovalGateToken, currentGateFacesOf, sightsCurrentGate } from "../approval-gate-currency.js";
 import { approverFacingArgs, createApprovalCardEmitter, declaredApprovalFrameFamilies, parkRowStandingAnswerFacts, resolveApprovalLeg, resolveStreamApprovalGate, standingAnswerDurablyRecordable } from "../tool-approval.js";
@@ -25,14 +25,14 @@ import { serviceVersion } from "../service-version.js";
 import { TERMINAL_PARK_GATE_KINDS } from "../plugins/checkpoint-store-sql.js";
 import { withPrincipal } from "../observability/principal-context.js";
 import { withModelReachScope } from "../model-reach-scope.js";
-import { runSkillsOf } from "../capabilities/skills.js";
+import { legFactsOf } from "../leg-facts.js";
 import { createInstructionSelectionLeg } from "../instruction-selection.js";
 import { modelTextEventData, appendParkRow, turnEndEventData, contextUsageEventData, toolStartEventData, toolEndEventData, taskProgressEventData, taskStartedEventData, taskNotificationEventData, compactedEventData, diagnosticsEventData, brainStatusEventData, steeringInjectedEventData, compactionOutcomeEventData, compactionStartedEventData, workspaceChangedEventData, wiringManifestEventData, toolRosterDeltaEventData, toolDisclosureEventData, humanInputEventData, appendModelUsageDelta, appendPromptManifest, attachModelUsage } from "../trace/project.js";
 import { redactSecrets } from "../trace/redact.js";
 import { buildRunObjectivePreview } from "../user-authored-text.js";
 import { createForwardAppendFailedNote, createLedgerSink, createSerialLedgerAppend } from "../trace/ledger-sink.js";
 import { registerEngineNoticeLeg } from "../trace/engine-notice-wire.js";
-import { reasoningDeltaBytes, reasoningSegmentEventId } from "../trace/model-segment.js";
+import { blockText, reasoningDeltaBytes, reasoningSegmentEventId } from "../trace/model-segment.js";
 import { errorText } from "../observability/err-text.js";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { verifyRoundsFromBody } from "./verify-rounds.js";
@@ -57,9 +57,11 @@ import { readResumeCtx, resumeCtxCorruptAnswer, resumeCtxUnsealableAnswer } from
 import { buildCheckpointVersionKeys, resumeBlockedByPolicyAnswer, resumeRefusalWithCard, sealCheckpointCtx, storedBodyReplayAnswer, storedBodyReplayLogFields, withPermissionModeRewritten } from "./checkpoint-ctx.js";
 import { refusalBody, resumeRefusalFacts } from "./refusal-body.js";
 import { storedBodyReplayRefusal } from "./stored-body-replay.js";
+import { restateResumeCtx } from "./resume-restatement.js";
 import { httpErrorRefusal } from "./send.js";
 import { createRunAcceptance } from "../run-acceptance.js";
 import { fieldConflictFacts } from "../field-conflict.js";
+import { createSessionNotifyDoor } from "../session-notify-door.js";
 function legMayHaveReopenedCheckpoint(r) {
     return r.terminal.kind === "failed" && nestedPauseOf(r.terminal) === undefined;
 }
@@ -107,6 +109,8 @@ const CHECKPOINT_ERROR_DISPOSITION = {
     "checkpoint.reopened_concurrently": "retriable",
     "resume.parent_constraint_missing": "retriable",
     "resume.parent_constraint_mismatch": "retriable",
+    "resume.composition_mismatch": "retriable",
+    "checkpoint.void_unpin_failed": "terminal",
     "resume.constraint_rejected": "retriable",
     "resume.constraint_unprojectable": "retriable",
     "resume.usage_window_exhausted": "retriable",
@@ -230,14 +234,19 @@ export function checkpointRefusalAnswer(e, at) {
         }),
     }, at.retriable);
 }
+export function decidedActionOf(binding) {
+    const { boundCallId, boundInputHash } = binding;
+    const missingKeys = [...(typeof boundCallId === "string" && boundCallId.length > 0 ? [] : ["boundCallId"]), ...(typeof boundInputHash === "string" && boundInputHash.length > 0 ? [] : ["boundInputHash"])];
+    return missingKeys.length === 0 ? { action: { boundCallId: boundCallId, boundInputHash: boundInputHash } } : { missingKeys };
+}
 export function createResumeLegs(ctx) {
     const { deps, runnerFor, idemCache, inflightRuns, preemptableRuns, steerableRuns, wakeParkMints, counters, readJson, readRawBody, rateLimited, quotaExceeded, ownerQuotaDenied, leaseDenied, ownerLeaseDenied, usageWindowDenied, safeDecode, runOwnerOk, sessionOwnerOk, runSessionAcceptOk, prepareSpec, finalizeTaskResult, ownerCostQuotaDenied, ownerFleetLeaseDenied, usageWindowDenialFor } = ctx;
     const ctxOpening = (sessionId) => ({ sessionId, opener: deps.checkpointCtxSealing });
     const resumeFleetScope = (req, auth) => req ? (gatedPrincipal(req, deps.config) ?? "default") : (auth.principal ?? "default");
-    async function resumeCheckpoint(sessionId, decision, reason, hostDecision, req, answer, binding, onResumeCommitted, acceptEarly, decider) {
+    async function resumeCheckpoint(sessionId, decision, reason, hostDecision, req, answer, binding, onResumeCommitted, acceptEarly, decider, restatement) {
         const cs = deps.checkpointStore;
         const token = await currentApprovalGateToken(cs, sessionId);
-        if (binding?.checkpointToken && !sightsCurrentGate({ face: "checkpointToken", value: binding.checkpointToken }, token ? { checkpointToken: token } : null)) {
+        if (binding.checkpointToken && !sightsCurrentGate({ face: "checkpointToken", value: binding.checkpointToken }, token ? { checkpointToken: token } : null)) {
             let seenUnreadable = false;
             const seen = await cs.get(binding.checkpointToken).catch((e) => {
                 seenUnreadable = true;
@@ -326,20 +335,23 @@ export function createResumeLegs(ctx) {
                 }),
             };
         }
-        if (req !== undefined && !binding?.checkpointToken && !binding?.boundCallId) {
+        const decided = decidedActionOf(binding);
+        if (decided.action === undefined) {
             return {
                 status: 400,
                 body: refusalBody({
                     errorCode: "decide_requires_binding",
-                    message: "decide requires the decision-action binding — echo checkpointToken and/or boundCallId from the pending approval (GET /v1/approvals)",
+                    message: "decide requires the decision-action binding — echo boundCallId and boundInputHash exactly as the pending approval you are deciding shows them (GET /v1/approvals), so a decision on a view that has since been replaced is refused instead of landing on the gate that replaced it",
                     facts: {
                         bindingEnforced: true,
+                        missingKeys: decided.missingKeys,
                     },
                 }),
             };
         }
+        const action = decided.action;
         const s57RowCallId = cp.pendingAction.kind === "tool_approval" ? cp.pendingAction.toolCallId : undefined;
-        if (binding?.boundCallId !== undefined && s57RowCallId && binding.boundCallId !== s57RowCallId) {
+        if (s57RowCallId && action.boundCallId !== s57RowCallId) {
             let s57CurrentPending;
             if (decider !== undefined && cp.status === "pending" && cp.sessionId === sessionId && cp.pendingAction.kind === "tool_approval") {
                 s57CurrentPending = {
@@ -400,8 +412,9 @@ export function createResumeLegs(ctx) {
             const parkedReq = {
                 token, scope: cp.scope, sessionId: cp.sessionId, pendingAction: cp.pendingAction,
                 decision, hostDecision, ...(reason !== undefined ? { reason } : {}),
-                ...(binding !== undefined ? { binding: (({ checkpointToken: _staleGuardOnly, ...rest }) => rest)(binding) } : {}),
+                binding: { ...(({ checkpointToken: _staleGuardOnly, ...rest }) => rest)(binding), ...action },
                 ...(answer !== undefined ? { answer } : {}),
+                ...(restatement !== undefined ? { restatement } : {}),
                 ...(boundGrant ? { grantRemember: (rootSessionId) => boundGrant(rootSessionId) } : {}),
             };
             if (origin?.kind === "background" && parkedAgentStore !== undefined && parkedSurface !== undefined) {
@@ -458,7 +471,7 @@ export function createResumeLegs(ctx) {
                 if (decisions === undefined || runStore === undefined) {
                     return { status: 501, body: refusalBody({ errorCode: "capability.run_store_required", message: "delivering this decision requires a durable run store (DB_BACKEND=mysql|pg|local)" }) };
                 }
-                const fingerprint = parkDecisionFingerprint(plan.outcome);
+                const fingerprint = parkDecisionFingerprint(plan.outcome, restatement);
                 const liveReceiptOf = async (held) => {
                     if (held === null || held.fingerprint !== fingerprint)
                         return undefined;
@@ -488,8 +501,8 @@ export function createResumeLegs(ctx) {
                     .catch(() => undefined);
                 const admittedPayer = decodeCheckpointScope(cp.scope);
                 const out = hostToken
-                    ? await resumeWake(plan.hostSessionId, plan.message, decider?.principal, req, acceptEarly, delivery, admittedPayer)
-                    : await startFreshHostTurn(plan.hostSessionId, plan.message, admittedPayer, req, delivery, plan.runId);
+                    ? await resumeWake(plan.hostSessionId, plan.message, decider?.principal, req, acceptEarly, delivery, admittedPayer, restatement)
+                    : await startFreshHostTurn(plan.hostSessionId, plan.message, admittedPayer, req, delivery, plan.runId, restatement);
                 if (recordFailure !== undefined)
                     throw recordFailure.err;
                 if (acceptedTaskIdOf(out) === undefined)
@@ -502,9 +515,10 @@ export function createResumeLegs(ctx) {
             return resumeCtxCorruptAnswer(ctxRead0.where);
         if (ctxRead0.kind === "unsealable")
             return resumeCtxUnsealableAnswer(ctxRead0);
-        const ctx = ctxRead0.kind === "ok" ? ctxRead0.ctx : null;
-        if (!ctx)
+        const storedCtx = ctxRead0.kind === "ok" ? ctxRead0.ctx : null;
+        if (!storedCtx)
             return { status: 409, body: refusalBody({ errorCode: "conflict.resume_context_unavailable", message: "resume context missing — cannot rebuild task config" }) };
+        const ctx = restateResumeCtx(storedCtx, restatement);
         const auth = { sessionId: cp.sessionId, principal: decodeCheckpointScope(cp.scope), memoryScope: ctx.memoryScope };
         const resolved = await resolveResumeSpecOrBlocked(ctx, req, auth);
         if (!resolved.ok)
@@ -520,21 +534,19 @@ export function createResumeLegs(ctx) {
             }
             const { objective: resumeObjective, sessionId: _sessionId, ...taskConfig } = spec;
             const pa = cp.pendingAction;
-            const persistedCallId = pa.kind === "tool_approval" ? pa.toolCallId : "";
-            const persistedHash = pa.kind === "tool_approval" ? (pa.boundInputHash ?? "") : "";
             const outcome = {
                 gate: "policy_ask",
-                boundCallId: binding?.boundCallId ?? persistedCallId,
-                boundInputHash: binding?.boundInputHash ?? persistedHash,
+                boundCallId: action.boundCallId,
+                boundInputHash: action.boundInputHash,
                 decision: decision === "approve" ? "allow" : "deny",
-                ...(decision === "approve" && !isEngineQuestionRow(pa) && binding?.updatedInput !== undefined ? { updatedInput: binding.updatedInput } : {}),
+                ...(decision === "approve" && !isEngineQuestionRow(pa) && binding.updatedInput !== undefined ? { updatedInput: binding.updatedInput } : {}),
                 ...(reason ? { reason } : {}),
-                ...(binding?.feedback !== undefined ? { feedback: binding.feedback } : {}),
+                ...(binding.feedback !== undefined ? { feedback: binding.feedback } : {}),
                 ...(answer !== undefined ? { answer } : {}),
                 hostDecision,
             };
             const verifyRounds = verifyRoundsFromBody(ctx.body);
-            const driven = await driveResumeIntoRunLog({ peerLease: resolved.peerLease, execution: resolved.execution, runner: runnerFor(spec), token, sessionId: cp.sessionId, principal: auth.principal, fleetScope: resumeFleetScope(req, auth), taskConfig, resumeObjective, outcome, commitment: { kind: "gate_resolved", ...captureSelectedGate() }, verifyRounds, resumeCtx: { sessionId, ctx }, ...(engineNotices.length > 0 ? { engineNotices } : {}), ...(boundGrant ? { onResumeCommitted: boundGrant } : {}), ...(acceptEarly === true ? { acceptEarly: true } : {}), ...(req !== undefined ? { callerInitiated: true } : {}), ...(ownerLeaseAdmittedHere ? { ownerLeaseAdmitted: true } : {}) });
+            const driven = await driveResumeIntoRunLog({ peerLease: resolved.peerLease, execution: resolved.execution, runner: resolved.runner, legFacts: resolved.legFacts, token, sessionId: cp.sessionId, principal: auth.principal, fleetScope: resumeFleetScope(req, auth), taskConfig, resumeObjective, outcome, commitment: { kind: "gate_resolved", ...captureSelectedGate() }, verifyRounds, resumeCtx: { sessionId, ctx }, ...(engineNotices.length > 0 ? { engineNotices } : {}), ...(boundGrant ? { onResumeCommitted: boundGrant } : {}), ...(acceptEarly === true ? { acceptEarly: true } : {}), ...(req !== undefined ? { callerInitiated: true } : {}), ...(ownerLeaseAdmittedHere ? { ownerLeaseAdmitted: true } : {}) });
             noteLateSettleIfAccepted(driven);
             return driven;
         }
@@ -547,14 +559,17 @@ export function createResumeLegs(ctx) {
     const resolveResumeSpec = async (ctx, req, auth, lease) => {
         const engineNotices = [];
         const execution = await resolveExecutionContext(deps, { kind: "continuation", root: auth.sessionId, principal: auth.principal });
-        const spec = stampSpecRoot(await deps.resolveSpec({ ...ctx.body, ...ONE_SHOT_SUBMIT_STRIP }, req, auth, {
+        const resolved = await deps.resolveSpec({ ...ctx.body, ...ONE_SHOT_SUBMIT_STRIP }, req, auth, {
             leg: "resume",
             onNotice: (n) => engineNotices.push(n),
             ...(ctx.unattendedLeg === true ? { unattendedLeg: true } : {}),
             lease,
             execution,
-        }), execution);
-        return { spec, engineNotices, execution };
+        });
+        const legFacts = legFactsOf(resolved);
+        const runner = runnerFor(resolved);
+        const spec = stampSpecRoot(resolved, execution);
+        return { spec, runner, legFacts, engineNotices, execution };
     };
     const refuseStoredBodyReplay = (sessionId, refusal) => {
         deps.logger?.warn?.("resume_refused_stored_body", { sessionId, ...storedBodyReplayLogFields(refusal) });
@@ -566,8 +581,8 @@ export function createResumeLegs(ctx) {
             return { ok: false, answer: refuseStoredBodyReplay(auth.sessionId, replay) };
         const lease = deps.peerDesk.lease("resume");
         try {
-            const { spec, engineNotices, execution } = await resolveResumeSpec(ctx, req, auth, lease);
-            return { ok: true, spec, engineNotices, execution, peerLease: lease };
+            const { spec, runner, legFacts, engineNotices, execution } = await resolveResumeSpec(ctx, req, auth, lease);
+            return { ok: true, spec, runner, legFacts, engineNotices, execution, peerLease: lease };
         }
         catch (e) {
             lease.release();
@@ -603,7 +618,7 @@ export function createResumeLegs(ctx) {
         const reparkStatus = outcome.gate === "plan_review" ? "needs_review" : "suspended";
         const commitResumeCtx = () => Promise.resolve().then(() => deps.checkpointStore.putCtx(resumeCtx.sessionId, sealCheckpointCtx({ ...resumeCtx.ctx, writerVersion: serviceVersion() }, deps.checkpointCtxSealing, resumeCtx.sessionId))).catch((e) => {
             deps.metrics?.inc("resume_ctx_not_persisted_total");
-            deps.logger?.warn?.("resume_ctx_not_persisted", { sessionId: resumeCtx.sessionId, gate: outcome.gate, error: errorText(e), note: "this continuation runs with the body it was given; the durable rebuild input still holds the PREVIOUS body, so the NEXT continuation of this session rebuilds from that one (never wider than this leg's)" });
+            deps.logger?.warn?.("resume_ctx_not_persisted", { sessionId: resumeCtx.sessionId, gate: outcome.gate, error: errorText(e), note: "this continuation runs with the body it was given; the durable rebuild input still holds the PREVIOUS body, so the NEXT continuation of this session rebuilds from that one — its permission mode is never wider than this leg's, but if this leg restated its MCP / A2A peer tables (mcpServers / a2aPeers on the resume request), a later continuation that does not restate them runs with the previous tables again" });
         });
         const legKey = createHash("sha256").update(String(token)).digest("hex");
         const streamApprovalOn = resolveStreamApprovalGate({
@@ -777,7 +792,7 @@ export function createResumeLegs(ctx) {
         let unregisterEngineNotice;
         try {
             const instructionLeg = createInstructionSelectionLeg();
-            const legWiringSections = () => ({ instructions: instructionLeg.segment(), skills: runSkillsOf(taskConfig) });
+            const legWiringSections = () => ({ instructions: instructionLeg.segment(), skills: args.legFacts?.skills });
             result = await instructionLeg.run(sessionId, () => withModelReachScope({ sessionId, taskId }, () => withPrincipal(principal, async () => {
                 const resumeNotifiedKeys = new NotifiedKeys();
                 if (deps.runStore && taskId) {
@@ -832,9 +847,8 @@ export function createResumeLegs(ctx) {
                             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) } : {}) });
                             }
-                            const hadRow = isFleetAgentTerminalNotification(n) ? (fleetPub?.onChildTerminal(n.sessionId ?? n.task_id, n.status, n.task_id, n.toolUseId) ?? false) : false;
                             const parked = !resumeLegLive && Boolean(deps.workflowCompletionInbox && sessionId);
-                            deps.logger?.info?.("task_notification_observed", { route: "resume-verify", taskId: n.task_id, taskType: n.task_type, status: n.status, hadFleetRow: hadRow, legLive: resumeLegLive, parkedDurable: parked });
+                            deps.logger?.info?.("task_notification_observed", { route: "resume-verify", taskId: n.task_id, taskType: n.task_type, status: n.status, legLive: resumeLegLive, parkedDurable: parked });
                             if (parked) {
                                 void deps.workflowCompletionInbox.enqueue(taskNotificationInboxEntry(sessionId, principal ?? null, n, Date.now(), taskId, opts?.priority)).catch((err) => deps.logger?.warn?.("park_enqueue_failed", { route: "resume-verify", taskId: n.task_id, err: err instanceof Error ? err.message : String(err) }));
                             }
@@ -856,7 +870,7 @@ export function createResumeLegs(ctx) {
                     resumeLegLive = true;
                     const vrEngine = await resumeWithVerification(legRunner, token, outcome, { ...resumeTaskConfig, signal: cancelCtrl.signal, preemptSignal: preemptCtrl.signal }, resumeObjective, verifyRounds, verifyInternals);
                     const vrCause = cancelCtrl.cause();
-                    await voidVerifierPauseCard(vrEngine, deps.checkpointStore);
+                    await voidVerifierPauseCard(vrEngine, legRunner);
                     const vrJudged = atHostBoundary(vrEngine, sessionId);
                     if (vrJudged.terminal.kind === "paused")
                         heldPark = vrJudged;
@@ -898,6 +912,7 @@ export function createResumeLegs(ctx) {
                 const rs = deps.runStore;
                 const startSeq = rs && taskId ? await rs.maxSeq(taskId) : 0;
                 let text = "";
+                let block = "";
                 let reasoning = "";
                 let reasoningEventId;
                 const persistThinking = deps.config.traceThinking;
@@ -931,15 +946,17 @@ export function createResumeLegs(ctx) {
                         reasoning = "";
                         reasoningEventId = undefined;
                     }
-                    if (text) {
-                        await append("text", modelTextEventData({ text, eventId: anchor.firstTextEventId }));
+                    const segment = text + blockText(block);
+                    if (segment) {
+                        await append("text", modelTextEventData({ text: segment, eventId: anchor.firstTextEventId }));
                         text = "";
+                        block = "";
                     }
                 };
                 const driveResume = async () => {
                     resumeLegLive = true;
                     const tailContentMode = resumeTaskConfig.forwardSubagentEvents === true ? "on" : "progress_only";
-                    const resumeWorkspace = createSessionWorkspaceRecorder(sessionWorkspaceStoreOf(deps.sessionStorage), legSessionWitnessOf(resumeTaskConfig));
+                    const resumeWorkspace = createSessionWorkspaceRecorder(sessionWorkspaceStoreOf(deps.sessionStorage), args.legFacts?.sessionWitness);
                     const stream = await legRunner.resumeStream(token, outcome, { ...resumeTaskConfig, signal: cancelCtrl.signal, preemptSignal: preemptCtrl.signal }, {
                         ...launchInternals,
                         onForwardEvent: (e) => {
@@ -976,9 +993,8 @@ export function createResumeLegs(ctx) {
                             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) } : {}) });
                             }
-                            const hadRow = isFleetAgentTerminalNotification(n) ? (fleetPub?.onChildTerminal(n.sessionId ?? n.task_id, n.status, n.task_id, n.toolUseId) ?? false) : false;
                             const parked = !resumeLegLive && Boolean(deps.workflowCompletionInbox && sessionId);
-                            deps.logger?.info?.("task_notification_observed", { route: "resume", taskId: n.task_id, taskType: n.task_type, status: n.status, hadFleetRow: hadRow, legLive: resumeLegLive, parkedDurable: parked });
+                            deps.logger?.info?.("task_notification_observed", { route: "resume", taskId: n.task_id, taskType: n.task_type, status: n.status, legLive: resumeLegLive, parkedDurable: parked });
                             if (parked) {
                                 void deps.workflowCompletionInbox.enqueue(taskNotificationInboxEntry(sessionId, principal ?? null, n, Date.now(), taskId, opts?.priority)).catch((err) => deps.logger?.warn?.("park_enqueue_failed", { route: "resume", taskId: n.task_id, err: err instanceof Error ? err.message : String(err) }));
                             }
@@ -1024,9 +1040,13 @@ export function createResumeLegs(ctx) {
                         await appendPromptManifest(append, deps.promptManifests, taskId);
                         switch (ev.type) {
                             case "text_delta":
-                                text += ev.delta;
+                                block += ev.delta;
                                 anchor.onText(ev.eventId);
                                 break;
+                            case "text_end":
+                                text += blockText(block, ev);
+                                block = "";
+                                break;
                             case "reasoning_delta": {
                                 const rb = reasoningDeltaBytes(ev);
                                 if (persistThinking && rb !== undefined) {
@@ -1307,7 +1327,7 @@ export function createResumeLegs(ctx) {
         const owner = decodeCheckpointScope(scope ?? CHECKPOINT_PUBLIC_SCOPE);
         return owner === undefined || owner === decider.principal;
     }
-    async function resumePreempted(sessionId, req, acceptEarly, decider) {
+    async function resumePreempted(sessionId, req, acceptEarly, decider, restatement) {
         const cs = deps.checkpointStore;
         const RESUMABLE_GATE_KIND = "resource_limit";
         const preemptBinding = { gateKinds: [RESUMABLE_GATE_KIND] };
@@ -1357,7 +1377,7 @@ export function createResumeLegs(ctx) {
             return resumeCtxUnsealableAnswer(ctxRead);
         if (ctxRead.kind === "absent")
             return { status: 409, body: refusalBody({ errorCode: "conflict.resume_context_unavailable", message: "resume context missing — cannot rebuild task config" }) };
-        const ctx = ctxRead.ctx;
+        const ctx = restateResumeCtx(ctxRead.ctx, restatement);
         const auth = { sessionId: cp.sessionId, principal: decodeCheckpointScope(cp.scope), memoryScope: ctx.memoryScope };
         const resolved = await resolveResumeSpecOrBlocked(ctx, req, auth);
         if (!resolved.ok)
@@ -1367,13 +1387,13 @@ export function createResumeLegs(ctx) {
             const { objective: resumeObjective, sessionId: _sessionId, ...taskConfig } = spec;
             const verifyRounds = verifyRoundsFromBody(ctx.body);
             const selectedGate = durableRowIdentity("decision-receipt", cp.checkpointId, token);
-            return await driveResumeIntoRunLog({ peerLease: resolved.peerLease, execution: resolved.execution, runner: runnerFor(spec), token, sessionId: cp.sessionId, principal: auth.principal, fleetScope: resumeFleetScope(req, auth), taskConfig, resumeObjective, outcome: { gate: "resource_limit", decision: "continue" }, commitment: { kind: "gate_resolved", ...selectedGate }, verifyRounds, resumeCtx: { sessionId, ctx }, ...(engineNotices.length > 0 ? { engineNotices } : {}), ...(acceptEarly === true ? { acceptEarly: true } : {}), ...(req !== undefined ? { callerInitiated: true } : {}) });
+            return await driveResumeIntoRunLog({ peerLease: resolved.peerLease, execution: resolved.execution, runner: resolved.runner, legFacts: resolved.legFacts, token, sessionId: cp.sessionId, principal: auth.principal, fleetScope: resumeFleetScope(req, auth), taskConfig, resumeObjective, outcome: { gate: "resource_limit", decision: "continue" }, commitment: { kind: "gate_resolved", ...selectedGate }, verifyRounds, resumeCtx: { sessionId, ctx }, ...(engineNotices.length > 0 ? { engineNotices } : {}), ...(acceptEarly === true ? { acceptEarly: true } : {}), ...(req !== undefined ? { callerInitiated: true } : {}) });
         }
         finally {
             resolved.peerLease.release();
         }
     }
-    async function startFreshHostTurn(sessionId, objective, principal, req, workflowDecision, runId) {
+    async function startFreshHostTurn(sessionId, objective, principal, req, workflowDecision, runId, restatement) {
         const cs = deps.checkpointStore;
         if (!deps.runStore) {
             return { status: 501, body: refusalBody({ errorCode: "capability.run_store_required", message: "delivering this decision requires a durable run store (DB_BACKEND=mysql|pg|local)" }) };
@@ -1383,8 +1403,8 @@ export function createResumeLegs(ctx) {
             return resumeCtxCorruptAnswer(ctxRead.where);
         if (ctxRead.kind === "unsealable")
             return resumeCtxUnsealableAnswer(ctxRead);
-        const ctx = ctxRead.kind === "ok" ? ctxRead.ctx : null;
-        if (!ctx) {
+        const storedCtx = ctxRead.kind === "ok" ? ctxRead.ctx : null;
+        if (!storedCtx) {
             return {
                 status: 409,
                 body: refusalBody({
@@ -1397,6 +1417,7 @@ export function createResumeLegs(ctx) {
                 }),
             };
         }
+        const ctx = restateResumeCtx(storedCtx, restatement);
         const windowDenial = await usageWindowDenialFor(principal || GLOBAL_USAGE_KEY);
         if (windowDenial)
             return { status: windowDenial.status, body: windowDenial.body };
@@ -1408,7 +1429,7 @@ export function createResumeLegs(ctx) {
             const { spec, engineNotices } = resolved;
             const hostSpec = { ...spec, objective };
             const out = await mintAndDriveDurableRun(routeCtxBase, deps.runStore, {
-                prepared: { spec: hostSpec, runner: runnerFor(hostSpec), auth, body: ctx.body, acceptance: createRunAcceptance({}, { objective }), peerLease: resolved.peerLease, execution: resolved.execution, ...(engineNotices.length > 0 ? { engineNotices } : {}) },
+                prepared: { spec: hostSpec, runner: resolved.runner, legFacts: resolved.legFacts, auth, body: ctx.body, acceptance: createRunAcceptance({}, { objective }), peerLease: resolved.peerLease, execution: resolved.execution, ...(engineNotices.length > 0 ? { engineNotices } : {}) },
                 fleetScope: resumeFleetScope(req, auth),
                 elicitOwner: principal ?? null,
                 source: "workflow_parked_decide",
@@ -1427,7 +1448,7 @@ export function createResumeLegs(ctx) {
             resolved.peerLease.release();
         }
     }
-    async function resumeWake(sessionId, message, caller, req, acceptEarly, workflowDecision, ownerLeaseAdmittedFor) {
+    async function resumeWake(sessionId, message, caller, req, acceptEarly, workflowDecision, ownerLeaseAdmittedFor, restatement) {
         const cs = deps.checkpointStore;
         const wakeBinding = { gateKinds: TERMINAL_PARK_GATE_KINDS, pick: "oldest" };
         const token = (await cs.findPendingTokenBySession(sessionId, undefined, wakeBinding)) ?? (await cs.findPendingTokenBySession(sessionId));
@@ -1484,7 +1505,7 @@ export function createResumeLegs(ctx) {
             return resumeCtxUnsealableAnswer(ctxRead);
         if (ctxRead.kind === "absent")
             return { status: 409, body: refusalBody({ errorCode: "conflict.resume_context_unavailable", message: "resume context missing — cannot rebuild task config" }) };
-        const ctx = ctxRead.ctx;
+        const ctx = restateResumeCtx(ctxRead.ctx, restatement);
         const auth = { sessionId: cp.sessionId, principal: decodeCheckpointScope(cp.scope), memoryScope: ctx.memoryScope };
         const resolved = await resolveResumeSpecOrBlocked(ctx, req, auth);
         if (!resolved.ok)
@@ -1495,7 +1516,8 @@ export function createResumeLegs(ctx) {
             return await driveResumeIntoRunLog({
                 peerLease: resolved.peerLease,
                 execution: resolved.execution,
-                runner: runnerFor(spec),
+                runner: resolved.runner,
+                legFacts: resolved.legFacts,
                 token,
                 sessionId: cp.sessionId,
                 principal: auth.principal,
@@ -1595,8 +1617,9 @@ export function createResumeLegs(ctx) {
             return refuse(refuseStoredBodyReplay(sessionId, replay));
         return { ok: true, prepared: { sessionId, token, cp, ctx: ctxRead.ctx } };
     }
-    async function drivePlanReview(prepared, decision, editedPlan, reason, hostDecision, req, acceptEarly, permissionModeAfter) {
-        const { sessionId, token, cp, ctx } = prepared;
+    async function drivePlanReview(prepared, decision, editedPlan, reason, hostDecision, req, acceptEarly, permissionModeAfter, restatement) {
+        const { sessionId, token, cp } = prepared;
+        const ctx = restateResumeCtx(prepared.ctx, restatement);
         if ((await deps.checkpointStore.findPendingTokenBySession(sessionId, undefined, { gateKinds: ["plan_review"] })) !== token)
             return notResumableAnswer();
         const auth = { sessionId: cp.sessionId, principal: decodeCheckpointScope(cp.scope), memoryScope: ctx.memoryScope };
@@ -1621,20 +1644,26 @@ export function createResumeLegs(ctx) {
                 hostDecision,
             };
             const selectedGate = durableRowIdentity("decision-receipt", cp.checkpointId, token);
-            const out = await driveResumeIntoRunLog({ peerLease: resolved.peerLease, execution: resolved.execution, runner: runnerFor(spec), token, sessionId: cp.sessionId, principal: auth.principal, fleetScope: resumeFleetScope(req, auth), taskConfig, resumeObjective, outcome, commitment: { kind: "gate_resolved", ...selectedGate }, verifyRounds, resumeCtx: { sessionId, ctx: rebuildCtx }, ...(engineNotices.length > 0 ? { engineNotices } : {}), ...(acceptEarly === true ? { acceptEarly: true } : {}), ...(req !== undefined ? { callerInitiated: true } : {}) });
+            const out = await driveResumeIntoRunLog({ peerLease: resolved.peerLease, execution: resolved.execution, runner: resolved.runner, legFacts: resolved.legFacts, token, sessionId: cp.sessionId, principal: auth.principal, fleetScope: resumeFleetScope(req, auth), taskConfig, resumeObjective, outcome, commitment: { kind: "gate_resolved", ...selectedGate }, verifyRounds, resumeCtx: { sessionId, ctx: rebuildCtx }, ...(engineNotices.length > 0 ? { engineNotices } : {}), ...(acceptEarly === true ? { acceptEarly: true } : {}), ...(req !== undefined ? { callerInitiated: true } : {}) });
             return out;
         }
         finally {
             resolved.peerLease.release();
         }
     }
+    const sessionNotifyDoor = createSessionNotifyDoor({
+        activeTaskIdOf: async (sessionId) => deps.runStore?.getActiveTaskId?.(sessionId),
+        liveRuns: steerableRuns,
+        inbox: deps.workflowCompletionInbox,
+        headOf: headReadOf(deps.sessionStorage),
+    });
     const routeCtxBase = {
         deps,
         registry: { idemCache, inflightRuns, preemptableRuns, steerableRuns, wakeParkMints, counters },
         helpers: { readJson, readRawBody, rateLimited, quotaExceeded, ownerQuotaDenied, leaseDenied, ownerLeaseDenied, usageWindowDenied, safeDecode, runOwnerOk, sessionOwnerOk, runSessionAcceptOk },
         local: { images: createImagesLocal(deps), sessions: createSessionsLocal(), sessionSync: createSessionSyncLocal(), capabilities: createCapabilitiesLocal() },
-        legs: { prepareSpec, finalizeTaskResult, resumeCheckpoint, driveResumeIntoRunLog, resumePreempted, resumeWake, preparePlanReview, drivePlanReview },
+        legs: { prepareSpec, finalizeTaskResult, resumeCheckpoint, driveResumeIntoRunLog, resumePreempted, resumeWake, preparePlanReview, drivePlanReview, sessionNotify: sessionNotifyDoor },
     };
-    return { routeCtxBase, resumeCheckpoint, driveResumeIntoRunLog, driveResumeLeg, mayDiscloseRowError, resumePreempted, startFreshHostTurn, resumeWake, preparePlanReview, drivePlanReview };
+    return { routeCtxBase, resumeCheckpoint, driveResumeIntoRunLog, driveResumeLeg, mayDiscloseRowError, resumePreempted, startFreshHostTurn, resumeWake, preparePlanReview, drivePlanReview, sessionNotifyDoor };
 }
 //# sourceMappingURL=resume-legs.js.map

package/dist/http/resume-restatement.d.ts

@@ -0,0 +1,39 @@
+/**
+ * 续跑请求的**重述键** —— 「我此刻的对端表」随续跑请求一起说出来(唯一属主)。
+ *
+ * ## 律(一条)
+ * 续跑请求体可带 {@link RESUME_RESTATABLE_KEYS} 里的键(今天两只:`mcpServers` / `a2aPeers`),键名与值形 = 提交体(`POST /v1/tasks`)的同一键:
+ *  · **在场**(值不是 `undefined` / `null`)⇒ 先过提交腿**同一只**判官(`assertRequestMcpEntries` / `assertRequestA2aEntries`;坏形 = 与提交腿同码同句的
+ *    400,判在续跑腿任何状态改动之前),再**取代**续跑重建输入(`checkpoint_ctx` 体)里的那一键:本次重建读它,续跑赢下 CAS 之后随重建输入一起写回
+ *    (`DriveResumeArgs.resumeCtx` 那一只写点)⇒ 之后的续跑在没有新重述时重放的也是它;
+ *  · **缺席**(或 `null`,与提交体「缺席或 `null` = 没声明」同一读法)⇒ 存量体那一键原样重放(冻结读法)。
+ * 重建之后的路与存量体逐字同一条(`resolveSpec` 的续跑腿:部署锁、闸、部署保留名、合并、对端座登记、用户面通告),所以一份重述在本部署上能挂上什么,
+ * 与它作为一次新提交能挂上什么是同一个答案;引擎从 `ResumeTaskConfig.mcp` / `.a2a`(与 `TaskSpec` 同键)收到的就是这张表。
+ *
+ * ## 不在本仓判的
+ * 「停驻快照里那一只调用的目标台还在不在当前表里」是引擎续跑准入的判(引擎 7.61.0 起三码各答各形,以 core 为准:工具不在了 ⇒ `resume.tool_unavailable`、同名而已不是批准时那一只 ⇒ `resume.tool_contract_mismatch`(两者重开检查点)、还是那一只而面或声明变了 ⇒ `resume.target_moved`(否决);本服务逐字过境)—— 本服务只负责把当前表送到,不自判、不预拒。
+ *
+ * ## 为什么是一张闭表
+ * 与提交腿的一次性动作那张闭表(`resume-legs.ts` 的 `ONE_SHOT_SUBMIT_KEYS`:重建时剥掉)对称 —— 那张说「哪些提交键不随重建走」,这张说「哪些提交键由续跑请求重述」。
+ * 加一键 = 改这条律本身:判官表 {@link RESTATEMENT_JUDGES} 缺行即编译红,接收它的续跑门各自在键闭集里声明它。
+ */
+import type { TaskRequestBody } from "./wire-types.js";
+import type { CheckpointCtx } from "./route-ctx.js";
+/** 续跑请求可重述的提交键(闭集;`satisfies` 钉在提交体的具名键上 —— 写一个提交体上没有的词 = 编译红)。 */
+export declare const RESUME_RESTATABLE_KEYS: readonly ["a2aPeers", "mcpServers"];
+export type ResumeRestatableKey = (typeof RESUME_RESTATABLE_KEYS)[number];
+/** 一次续跑请求读出的重述(只含在场的键;读者 {@link readResumeRestatement},用者 {@link restateResumeCtx})。 */
+export type ResumeRestatement = {
+    readonly [K in ResumeRestatableKey]?: TaskRequestBody[K];
+};
+/**
+ * 从一份续跑请求体里读出重述:在场的键逐一过判官,全部过 ⇒ 交回只含在场键的重述;一键都不在 ⇒ `undefined`(冻结读法)。
+ * 判官的拒原样抛出(调用方是路由,`HttpError` 由分发器按提交腿同一只渲染器落 wire)。体不是对象 ⇒ `undefined`(体形由各门自己的根形门答)。
+ */
+export declare function readResumeRestatement(body: unknown): ResumeRestatement | undefined;
+/**
+ * 把重述盖进续跑重建输入:在场的键取代体里的同名键,其余位(记忆域 / 无人值守标 / 读法记号 / 写者版本)原样随行。`undefined` ⇒ 原 ctx 原样(同一个对象)。
+ * 各续跑腿在读出 ctx 的那一拍调一次,之后重建(`resolveResumeSpecOrBlocked`)与写回(`resumeCtx`)读的都是这一份。
+ */
+export declare function restateResumeCtx(ctx: CheckpointCtx, restatement: ResumeRestatement | undefined): CheckpointCtx;
+//# sourceMappingURL=resume-restatement.d.ts.map

package/dist/http/resume-restatement.js

@@ -0,0 +1,25 @@
+import { assertRequestMcpEntries } from "../task-mcp.js";
+import { assertRequestA2aEntries } from "../task-a2a.js";
+export const RESUME_RESTATABLE_KEYS = ["a2aPeers", "mcpServers"];
+const RESTATEMENT_JUDGES = {
+    a2aPeers: assertRequestA2aEntries,
+    mcpServers: assertRequestMcpEntries,
+};
+export function readResumeRestatement(body) {
+    if (body === null || typeof body !== "object" || Array.isArray(body))
+        return undefined;
+    const raw = body;
+    let out;
+    for (const key of RESUME_RESTATABLE_KEYS) {
+        const value = Object.hasOwn(raw, key) ? raw[key] : undefined;
+        if (value === undefined || value === null)
+            continue;
+        RESTATEMENT_JUDGES[key](value);
+        (out ??= {})[key] = value;
+    }
+    return out;
+}
+export function restateResumeCtx(ctx, restatement) {
+    return restatement === undefined ? ctx : { ...ctx, body: { ...ctx.body, ...restatement } };
+}
+//# sourceMappingURL=resume-restatement.js.map