@sema-agent/core 7.5.2 → 7.6.0

package/dist/core/runner/runtask.js

@@ -6,7 +6,7 @@ import { deliverDelegationLifecycle, deliverEngineNotice, undrainedUserInputNoti
 import { planRejectionClears, resolveTriggerWindow } from "../context-edit.js";
 import { AgentHarness, DEFAULT_COMPACTION_SETTINGS, isSyntheticApiErrorMessage, uuidv7 } from "../../internal/harness.js";
 import { snapshotActorAssertion } from "../../internal/llm.js";
-import { CheckpointError, BINDING_CHECKPOINT_VERSION, checkpointVersionOf, F012_CHECKPOINT_VERSION, MAX_SUPPORTED_CHECKPOINT_VERSION, REAL_APPROVAL_CHECKPOINT_VERSION, FACE_CHECKPOINT_VERSION, remainingBudgetMicroUsd, readPendingSteerQueue, remainingTokens, LEGACY_PENDING_STEER_INPUT_ID, MAX_STEER_INPUT_ID_CHARS, validatePendingSteer, winnerFromOutcome, } from "../checkpoint-store.js";
+import { CheckpointError, BINDING_CHECKPOINT_VERSION, checkpointVersionOf, F012_CHECKPOINT_VERSION, MAX_SUPPORTED_CHECKPOINT_VERSION, REAL_APPROVAL_CHECKPOINT_VERSION, FACE_CHECKPOINT_VERSION, remainingBudgetMicroUsd, readPendingSteerQueue, remainingTokens, LEGACY_PENDING_STEER_INPUT_ID, MAX_STEER_INPUT_ID_CHARS, validatePendingSteer, winnerFromOutcome, realApprovalOrgFact } from "../checkpoint-store.js";
 import { GIT_STATUS_ECHO_PREVIEW, branchCarriesVisiblePositiveGitFrame, newestEngineGitFrame, stripGitStatusUnits } from "./git-status-frame.js";
 import { gitFrameContextVisible, normalizeGitAnnouncement } from "../../internal/harness.js";
 import { engineVersion } from "../version.js";
@@ -35,6 +35,7 @@ import { toImageContent } from "./image.js";
 import { OUTPUT_TOOL_NAME, SKILLS_LISTING_PROBE_HEADER, resolveOutputRetries } from "./synthetic-tools.js";
 import { cacheFamilyOf, usageCostMicroUsd } from "./usage-accounting.js";
 import { assembleResult, errorCodeOf } from "./assemble-result.js";
+import { amendTerminal, terminalProjection } from "./terminal-projection.js";
 import { ATTACHMENT_BYTE_CAP, CHANGED_FILES_MAX, TOTAL_TOKENS_REMINDER_DEFAULT_MODE, AGENT_LISTING_REMOVED_HEADER, SKILLS_LISTING_DELTA_HEADER, SKILLS_LISTING_REMOVED_HEADER, advanceCadenceClock, agentListingDeltaHeader, attachmentEnvelopeTags, agentListingInitialHeader, replayAnnouncedListing, replayAnnouncedModels, clipToBytes, collectDateChange, collectDueAttachments, collectInstructionsChange, commitAgentListing, commitInstructionsChange, commitSkillsListing, createAttachmentState, rebaseCadenceWindows, reduceToolEnd, renderAgentListingDelta, renderMcpDroppedTools, renderMcpInstructionsDelta, renderOrphanedBackgroundTasks, selectMcpDroppedBatch, renderSkillsListingDelta, renderToolsDelta, stampWriteAnchor } from "./turn-attachments.js";
 import { buildWorkingFileAttachments, centerAdoptionOption, contextInstructionFilesOption, emitInputTruncated, forkContextOption } from "./compaction-call-options.js";
 import { effectiveDelegationFacts, gatedCallIdOf, placementValueOrAbsent, prepareTask, resolveCheckpointStore } from "./prepare-task.js";
@@ -51,7 +52,11 @@ import { droppedToolDigest, withAnnounceDigests } from "./announce-once-ledger.j
 import { appendInterruptionMarker, reconcileInterruptedSession } from "../session-reconcile.js";
 import { RunnerSharedToolResultStore } from "../tool-result-store.js";
 import { formatDiagnosticsBlock } from "../lsp-diagnostics.js";
-import { checkToolPolicyProjection, constraintChainDigest, constraintChainEntryOfSuppliedLayer, isApprovalSettledBy, refuseOutOfContractDecision, screenApproverAttribution, toolPolicyNameSets } from "../tool-policy.js";
+import { isAskOrigin } from "../ask-origin.js";
+import { isGateKind, PAUSE_REGISTRY, resumeGateMatches } from "../pause-registry.js";
+import { checkToolPolicyProjection, constraintChainDigest, constraintChainEntryOfSuppliedLayer, refuseOutOfContractDecision, screenApproverAttribution, toolPolicyNameSets } from "../tool-policy.js";
+import { mintGateOutcome } from "./gate-exit.js";
+import { MCP_DELIVERY_VERDICTS } from "../mcp-failure.js";
 import { defaultTaskRegistry } from "../task-registry.js";
 import { discloseDroppedPending, isDelegatedAgentTerminal, isSystemInjectionPriority, isTerminalTaskNotification, PendingSessionNotifications, renderTaskNotificationXml, SYSTEM_INJECTION_PRIORITIES, SystemInjectionQueue, taskNotificationDedupKey } from "../task-notification.js";
 import { ToolDetachHub } from "../tool-detach.js";
@@ -147,23 +152,23 @@ function resumeDecisionWasNegative(resume) {
 }
 const DEFERRED_REISSUE = "[DEFERRED] This tool call shared a batch with a call that suspended for durable approval, so it was " +
     "NOT executed on resume. If you still need it, issue it again now.";
-function toolEndBodyFrom(result, isError, settledBy, approver, resolution, gatedCallIdOfRun, autoDenied) {
+function toolEndBodyFrom(result, isError, gate, gatedCallIdOfRun) {
     const o = toolOutputFrom(result);
     const st = structuredFrom(result);
     const det = isError ? result?.details : undefined;
     const codeRaw = det?.code;
     const kindRaw = det?.errorKind;
     const code = typeof codeRaw === "string" ? codeRaw : typeof kindRaw === "string" ? kindRaw : undefined;
+    const deliveredRaw = det?.delivered;
+    const delivered = typeof deliveredRaw === "string" && MCP_DELIVERY_VERDICTS.includes(deliveredRaw) ? deliveredRaw : undefined;
     const gatedCallId = code === "gate.parked" ? gatedCallIdOfRun : undefined;
     return {
         ...(o !== undefined ? { output: o.output, ...(o.truncated ? { truncated: true } : {}), ...(o.totalChars !== undefined ? { totalChars: o.totalChars } : {}) } : {}),
         ...(st !== undefined ? { structured: st } : {}),
         ...(typeof code === "string" ? { errorCode: code } : {}),
+        ...(delivered !== undefined ? { delivered } : {}),
         ...(gatedCallId !== undefined ? { gatedCallId } : {}),
-        ...(settledBy !== undefined ? { settledBy } : {}),
-        ...(approver !== undefined ? { approver } : {}),
-        ...(resolution !== undefined ? { resolution } : {}),
-        ...(autoDenied !== undefined ? { autoDenied } : {}),
+        ...(gate !== undefined ? { gate } : {}),
     };
 }
 export function reconciledToolEndBody(orphan) {
@@ -393,7 +398,7 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
         let platformCause;
         let platformRetryAfterMs;
         const preemptWillSuspend = preemptHit && prepared.suspendForResource !== undefined;
-        if (!preemptWillSuspend && prepared.suspendRef.token === undefined && !prepared.abortController.signal.aborted) {
+        if (!preemptWillSuspend && prepared.pausedRef.current === undefined && !prepared.abortController.signal.aborted) {
             const ledgerReadDeadline = prepared.envLifetimeSuspendAt !== undefined ? prepared.envLifetimeSuspendAt + ENV_DUE_GOVERNANCE_READ_BUDGET_MS : undefined;
             if (prepared.usageGovernance !== undefined) {
                 const governance = prepared.usageGovernance;
@@ -461,7 +466,7 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
         }
         if (prepared.suspendForResource &&
             (rs.limits.turnsExceeded || rs.limits.budgetHit !== undefined || walltimeHit || preemptHit) &&
-            prepared.suspendRef.token === undefined) {
+            prepared.pausedRef.current === undefined) {
             const reason = preemptHit
                 ? "preempt"
                 : rs.limits.budgetHit !== undefined
@@ -540,8 +545,7 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
             prepared.reviewRequestRef.pending = undefined;
             const honorable = prepared.suspendForReview !== undefined &&
                 !prepared.abortController.signal.aborted &&
-                prepared.suspendRef.token === undefined &&
-                prepared.reviewRef.token === undefined;
+                prepared.pausedRef.current === undefined;
             if (honorable && prepared.suspendForReview) {
                 await prepared.suspendForReview(reason);
                 return undefined;
@@ -838,8 +842,7 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
         const forceManual = manualCompactRef.requested;
         if ((!withinTaskCompaction && !forceManual) ||
             prepared.abortController.signal.aborted ||
-            prepared.suspendRef.token !== undefined ||
-            prepared.reviewRef.token !== undefined) {
+            prepared.pausedRef.current !== undefined) {
             if (forceManual) {
                 emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.mooted", version: 1, taskId: rs.telemetry.taskId, reason: "task_ending", ts: Date.now() }));
                 queue.push({ type: "compaction_outcome", outcome: "mooted", trigger: "manual", reason: "task_ending", ...ident() });
@@ -1386,16 +1389,16 @@ function makeHarnessHandlers(prepared, stats, rs, deps) {
                     prepared.lspDiagnostics.nudge(p);
             }
         }
-        const settlement = prepared.approvalSettlement.get(event.toolCallId);
-        if (settlement !== undefined)
-            prepared.approvalSettlement.delete(event.toolCallId);
+        const gate = prepared.gateOutcomes.get(event.toolCallId);
+        if (gate !== undefined)
+            prepared.gateOutcomes.delete(event.toolCallId);
         pushContent({
             type: "tool_end",
             toolCallId: event.toolCallId,
             toolName: event.toolName,
             ...(toolLabels.get(event.toolName) !== undefined ? { label: toolLabels.get(event.toolName) } : {}),
             isError: event.isError,
-            ...toolEndBodyFrom(event.result, event.isError, settlement?.settledBy, settlement?.approver, settlement?.resolution, prepared.abortController.signal.aborted ? gatedCallIdOf(prepared) : undefined, settlement?.autoDenied),
+            ...toolEndBodyFrom(event.result, event.isError, gate, prepared.abortController.signal.aborted ? gatedCallIdOf(prepared) : undefined),
             ...ident(),
         });
         announceWorkspaceMove();
@@ -1698,17 +1701,18 @@ export class Runner {
                     const pcs = internals?.inheritedGate?.parentConstraints;
                     if (resume !== undefined)
                         this.locallyClaimedTokens.delete(resume.cp.token);
-                    if (resume !== undefined && r.checkpointToken !== resume.cp.token) {
+                    const rToken = r.terminal.kind === "paused" ? r.terminal.token : undefined;
+                    if (resume !== undefined && rToken !== resume.cp.token) {
                         this.parentConstraintRegistry.delete(resume.cp.token);
                         this.suspendedEnvReaps.delete(resume.cp.token);
                     }
-                    if (r.status === "suspended" && r.checkpointToken !== undefined && pcs !== undefined && pcs.length > 0) {
+                    if (r.terminal.kind === "paused" && PAUSE_REGISTRY[r.terminal.gate.kind].taskStatus === "suspended" && pcs !== undefined && pcs.length > 0) {
                         if (this.parentConstraintRegistry.size >= Runner.PARENT_CONSTRAINT_REGISTRY_CAP) {
                             const oldest = this.parentConstraintRegistry.keys().next().value;
                             if (oldest !== undefined)
                                 this.parentConstraintRegistry.delete(oldest);
                         }
-                        this.parentConstraintRegistry.set(r.checkpointToken, pcs);
+                        this.parentConstraintRegistry.set(r.terminal.token, pcs);
                     }
                 }, (p) => {
                     suggestionsDone = p;
@@ -1790,10 +1794,8 @@ export class Runner {
                 taskId: taskIdRef.current ?? "unknown",
                 sessionId: taskIdRef.sessionId ?? "unknown",
                 ...(taskIdRef.runId !== undefined ? { runId: taskIdRef.runId } : {}),
-                status: "failed",
+                terminal: { kind: "failed", ...(code !== undefined ? { code } : {}), message: err instanceof Error ? err.message : String(err) },
                 result: "",
-                errorMessage: err instanceof Error ? err.message : String(err),
-                errorCode: code,
                 ...(remoteEnvFailure !== undefined ? { remoteEnvFailures: remoteEnvFailure } : {}),
                 ...(taskIdRef.effectiveMemoryScopes !== undefined ? { effectiveMemoryScopes: taskIdRef.effectiveMemoryScopes } : {}),
                 ...(taskIdRef.effectiveReasoning !== undefined ? { effectiveReasoning: taskIdRef.effectiveReasoning } : {}),
@@ -2404,7 +2406,7 @@ export class Runner {
         prepared.harness.engineInjectionsHeld = () => prepared.batchHaltRef.current !== undefined;
         let undrainedUserAtEnd;
         prepared.harness.onUndrainedUserInputs = (counts) => {
-            if (prepared.suspendRef.token !== undefined || prepared.reviewRef.token !== undefined) {
+            if (prepared.pausedRef.current !== undefined) {
                 undrainedUserAtEnd = counts;
                 return;
             }
@@ -3059,7 +3061,7 @@ export class Runner {
         if (stopHook || finalVerificationOn) {
             let consecutiveBlocks = 0;
             prepared.harness.setStopGate(async () => {
-                if (prepared.abortController.signal.aborted || prepared.suspendRef.token !== undefined || prepared.batchHaltRef.current !== undefined)
+                if (prepared.abortController.signal.aborted || prepared.pausedRef.current !== undefined || prepared.batchHaltRef.current !== undefined)
                     return [];
                 if (finalVerificationOn &&
                     (rs.counters.finalVerifyInjections === 0 || (rs.counters.finalVerifyInjections === 1 && rs.counters.groundingSignalPreR9 && !rs.counters.groundingSignalPostR9)) &&
@@ -3300,7 +3302,7 @@ export class Runner {
             degenerateOutput: { detect: (m) => isDegenerateCutMessage(m) },
             promptTooLong: {
                 recover: async (attempt, turnSignal) => {
-                    if (prepared.abortController.signal.aborted || prepared.suspendRef.token !== undefined)
+                    if (prepared.abortController.signal.aborted || prepared.pausedRef.current !== undefined)
                         return false;
                     if (turnSignal?.aborted === true)
                         return false;
@@ -3345,7 +3347,7 @@ export class Runner {
             },
         });
         prepared.microCompact.inTurnCompactionRef.current = async (turnSignal, anchoredEstimate) => {
-            if (prepared.abortController.signal.aborted || prepared.suspendRef.token !== undefined)
+            if (prepared.abortController.signal.aborted || prepared.pausedRef.current !== undefined)
                 return false;
             if (turnSignal?.aborted === true)
                 return false;
@@ -3926,9 +3928,8 @@ export class Runner {
                 this.deps.onError?.(flushErr, { phase: "config", sessionId: prepared.sessionId });
             }
         }
-        const suspended = prepared.suspendRef.token !== undefined && prepared.suspendRef.gate !== undefined;
-        const reviewPaused = prepared.reviewRef.token !== undefined && prepared.reviewRef.gate !== undefined;
-        const durablyPaused = suspended || reviewPaused;
+        const committedPause = prepared.pausedRef.current;
+        const durablyPaused = committedPause !== undefined;
         const interrupted = !durablyPaused &&
             (threw !== undefined || timeout.fired || rs.limits.turnsExceeded || rs.limits.budgetHit !== undefined || abortedLive || final?.stopReason === "aborted");
         let orphansClosed = 0;
@@ -3972,9 +3973,9 @@ export class Runner {
             }
         }
         let migratedParked = { steer: 0, followUp: 0 };
-        const parkToken = prepared.suspendRef.token ?? prepared.reviewRef.token;
-        const parkScope = prepared.suspendRef.token !== undefined ? prepared.suspendRef.scope : prepared.reviewRef.scope;
-        if (durablyPaused && parkToken !== undefined && parkScope !== undefined && this.deps.checkpointStore !== undefined) {
+        if (committedPause !== undefined && this.deps.checkpointStore !== undefined) {
+            const parkToken = committedPause.cause.token;
+            const parkScope = committedPause.scope;
             const store = this.deps.checkpointStore;
             const carried = [];
             for (const record of prepared.harness.readParkableUserInputs()) {
@@ -4067,7 +4068,7 @@ export class Runner {
                 }
             }
             if (prepared.resourceLedger &&
-                (resume?.cp.gate.kind === "resource_limit" || prepared.suspendRef.gate?.kind === "resource_limit")) {
+                (resume?.cp.gate.kind === "resource_limit" || prepared.pausedRef.current?.cause.gate.kind === "resource_limit")) {
                 stats.costMicroUsd += prepared.resourceLedger.spentMicroUsd;
                 stats.tokens += prepared.resourceLedger.spentTokens;
                 stats.turns += prepared.resourceLedger.spentTurns;
@@ -4118,46 +4119,26 @@ export class Runner {
                 gitCoreOverBudget: prepared.gitStatusRef.terminalCode === "irreducible_core_over_budget",
                 outputInvalid: rs.degrade.outputInvalid,
                 suspendLoop: prepared.suspendLoopRef.hit,
-                suspendRef: prepared.suspendRef.token !== undefined && prepared.suspendRef.gate !== undefined
-                    ? {
-                        token: prepared.suspendRef.token,
-                        ...(prepared.suspendRef.checkpointId !== undefined ? { checkpointId: prepared.suspendRef.checkpointId } : {}),
-                        gate: prepared.suspendRef.gate,
-                        ...(prepared.suspendRef.restoreMode !== undefined ? { restoreMode: prepared.suspendRef.restoreMode } : {}),
-                    }
-                    : undefined,
-                reviewRef: prepared.reviewRef.token !== undefined && prepared.reviewRef.gate !== undefined
-                    ? {
-                        token: prepared.reviewRef.token,
-                        ...(prepared.reviewRef.checkpointId !== undefined ? { checkpointId: prepared.reviewRef.checkpointId } : {}),
-                        gate: prepared.reviewRef.gate,
-                        ...(prepared.reviewRef.restoreMode !== undefined ? { restoreMode: prepared.reviewRef.restoreMode } : {}),
-                    }
-                    : undefined,
+                ...(prepared.pausedRef.current !== undefined ? { paused: prepared.pausedRef.current.cause } : {}),
             });
             if (resume !== undefined &&
                 resume.pendingActionStarted !== true &&
-                result.status !== "completed" &&
-                result.status !== "suspended" &&
-                result.status !== "needs_review" &&
+                result.terminal.kind !== "completed" &&
+                result.terminal.kind !== "paused" &&
                 !(resumeDecisionWasNegative(resume) && resume.decisionDelivered === true) &&
                 resume.onEnvRestoreFailed !== undefined) {
                 try {
                     await resume.onEnvRestoreFailed("env_failed");
-                    const r = result;
-                    r.errorCode ??= "resume.reopened_unstarted";
-                    r.errorMessage = `${r.errorMessage ?? "the resume leg did not complete"} — the approved action never started, so the checkpoint was REOPENED (pending): the same approval can be resumed again, do not ask for a fresh one`;
+                    amendTerminal(result, "resume.reopened_unstarted", (m) => `${m ?? "the resume leg did not complete"} — the approved action never started, so the checkpoint was REOPENED (pending): the same approval can be resumed again, do not ask for a fresh one`);
                 }
                 catch {
-                    const r = result;
-                    r.errorCode ??= "resume.reopen_failed_unstarted";
-                    r.errorMessage = `${r.errorMessage ?? "the resume leg did not complete"} — the approved action never started, and reopening the checkpoint FAILED: its state is unprovable from here. Re-read it before deciding; do NOT issue a fresh approval on the assumption the old one is dead`;
+                    amendTerminal(result, "resume.reopen_failed_unstarted", (m) => `${m ?? "the resume leg did not complete"} — the approved action never started, and reopening the checkpoint FAILED: its state is unprovable from here. Re-read it before deciding; do NOT issue a fresh approval on the assumption the old one is dead`);
                 }
             }
             prepared.sealReadStateSeat?.(ownCommittedTailRef.current);
             {
                 const wss = prepared.workspaceStateSettle;
-                if (wss !== undefined && result.status !== "suspended" && result.status !== "needs_review") {
+                if (wss !== undefined && result.terminal.kind !== "paused") {
                     const curCwd = prepared.cwdRef?.current !== undefined && prepared.cwdRef.current !== wss.rootCanonical ? prepared.cwdRef.current : undefined;
                     const curWt = prepared.worktreeSessionRef?.current;
                     const changed = curCwd !== wss.restoredHandsCwd || curWt?.worktreeDir !== wss.restoredWorktreeDir;
@@ -4172,7 +4153,7 @@ export class Runner {
             }
             const stopFailureHook = (spec.hooks ?? this.deps.hooks)?.stopFailure;
             if (stopFailureHook !== undefined &&
-                result.status === "failed" &&
+                result.terminal.kind === "failed" &&
                 final?.stopReason === "error" &&
                 !isDegenerateCutMessage(final) &&
                 threw === undefined &&
@@ -4180,12 +4161,13 @@ export class Runner {
                 !rs.degrade.outputInvalid &&
                 !prepared.suspendLoopRef.hit &&
                 !abortedLive &&
-                result.errorCode !== "conflict") {
+                result.terminal.code !== "conflict") {
+                const failedCause = result.terminal;
                 try {
                     const failureSeat = await runHookSeat("stopFailure", { timeoutMs: prepared.hookTimeoutMs }, (sig) => stopFailureHook({
                         identity: prepared.hookIdentity,
-                        error: result.errorMessage ?? "model error",
-                        ...(result.errorCode !== undefined ? { errorKind: result.errorCode } : {}),
+                        error: failedCause.message ?? "model error",
+                        ...(failedCause.code !== undefined ? { errorKind: failedCause.code } : {}),
                         turns: stats.turns,
                         signal: sig,
                     }));
@@ -4205,12 +4187,13 @@ export class Runner {
                     }
                 }
             }
+            const terminalFace = terminalProjection(result.terminal);
             emitDelegationLifecycle({
                 phase: "terminal",
                 identity: prepared.hookIdentity,
-                status: result.status,
+                status: terminalFace.status,
                 turns: stats.turns,
-                ...(result.errorCode !== undefined ? { errorCode: result.errorCode } : {}),
+                ...(terminalFace.errorCode !== undefined ? { errorCode: terminalFace.errorCode } : {}),
             });
             if (taskIdRef !== undefined)
                 taskIdRef.delegationTerminalOwed = undefined;
@@ -4218,8 +4201,8 @@ export class Runner {
                 result.degraded = rs.degrade.degraded;
             if (prepared.outputRef.set)
                 result.structuredOutput = prepared.outputRef.value;
-            const committedToken = prepared.suspendRef.token ?? prepared.reviewRef.token;
-            const committedScope = prepared.suspendRef.scope ?? prepared.reviewRef.scope;
+            const committedToken = prepared.pausedRef.current?.cause.token;
+            const committedScope = prepared.pausedRef.current?.scope;
             if (committedToken !== undefined) {
                 const store = resolveCheckpointStore(spec, this.deps);
                 if (store && committedScope !== undefined) {
@@ -4244,8 +4227,8 @@ export class Runner {
                 version: 1,
                 taskId: rs.telemetry.taskId,
                 runId: rs.telemetry.runId,
-                status: result.status,
-                errorCode: result.errorCode,
+                status: terminalFace.status,
+                errorCode: terminalFace.errorCode,
                 turns: stats.turns,
                 tokens: stats.tokens,
                 ...(rs.telemetry.unpricedSpend ? {} : { costMicroUsd: stats.costMicroUsd }),
@@ -4261,7 +4244,7 @@ export class Runner {
                 ts: Date.now(),
             }));
             setResult(result);
-            if (parentToolCallId !== undefined && (result.status === "completed" || result.status === "failed" || result.status === "blocked")) {
+            if (parentToolCallId !== undefined && result.terminal.kind !== "paused") {
                 const terminalTick = {
                     type: "task_progress",
                     taskId: rs.telemetry.taskId,
@@ -4271,7 +4254,7 @@ export class Runner {
                     ...(subagentName ? { name: subagentName } : {}),
                     model: prepared.model.id,
                     usage: { totalTokens: stats.tokens, toolUses: stats.toolCalls, durationMs: Date.now() - rs.telemetry.taskStart },
-                    status: result.status === "completed" ? "completed" : "failed",
+                    status: result.terminal.kind === "completed" ? "completed" : "failed",
                     ...ident(),
                 };
                 queue.push(terminalTick);
@@ -4289,7 +4272,7 @@ export class Runner {
             queue.push({ type: "done", result });
             queue.close();
             await prepared.fileHistoryBoundary?.settle();
-            if (spec.suggestNextPrompts && result.status === "completed") {
+            if (spec.suggestNextPrompts && result.terminal.kind === "completed") {
                 onSuggestions(this.suggestNextPrompts(spec, prepared, result));
             }
         }
@@ -4297,15 +4280,13 @@ export class Runner {
             const ownedEnvDying = prepared.ownedEnv !== undefined &&
                 hasDestroy(prepared.ownedEnv) &&
                 isIsolated(prepared.ownedEnv) &&
-                prepared.suspendRef.token === undefined &&
-                prepared.reviewRef.token === undefined;
+                prepared.pausedRef.current === undefined;
             await settleTeardownLeg(() => defaultTaskRegistry.settleKilledForOwner({ owner: spec.taskId ?? prepared.sessionId, scope: spec.principal ?? "default", sessionId: prepared.sessionId }, {
                 source: abortedLive &&
                     !timeout.fired &&
                     !rs.limits.turnsExceeded &&
                     rs.limits.budgetHit === undefined &&
-                    prepared.suspendRef.token === undefined &&
-                    prepared.reviewRef.token === undefined
+                    prepared.pausedRef.current === undefined
                     ? "user"
                     : "parent",
                 skipSessionScoped: true,
@@ -4485,6 +4466,7 @@ export class Runner {
                     break;
                 case "tool_approval":
                 case "resource_limit":
+                case "review":
                 case "plan_review": {
                     throw new CheckpointError("wake.gate_pending", `cannot wake: this checkpoint still carries a pending gate-typed action (pendingAction "${pa.kind}" ` +
                         `on a "${gk}" gate — inconsistent row) — wake is not a decision channel; resolve it through its ` +
@@ -4505,14 +4487,12 @@ export class Runner {
                     "wake would burn the checkpoint on a blank continuation; supply `message` or park a steer first");
             }
         }
-        const gateMatch = outcomeGate === "wake" ||
-            (cp.gate.kind === "human" && outcomeGate === "policy_ask") ||
-            (cp.gate.kind === "irreversible_ask" && outcomeGate === "policy_ask") ||
-            (cp.gate.kind === "resource_limit" && outcomeGate === "resource_limit") ||
-            (cp.gate.kind === "needs_review" && outcomeGate === "dry_run_review") ||
-            (cp.gate.kind === "plan_review" && outcomeGate === "plan_review");
+        const gateMatch = isGateKind(cp.gate.kind) && resumeGateMatches(cp.gate.kind, outcomeGate);
         if (!gateMatch) {
-            throw new CheckpointError("checkpoint.gate_mismatch", `resume outcome (gate "${describeSuppliedValue(outcomeGate)}") does not match checkpoint gate "${cp.gate.kind}" — resume serves human/policy_ask, irreversible_ask/policy_ask, resource_limit/resource_limit, needs_review/dry_run_review, and plan_review/plan_review`);
+            throw new CheckpointError("checkpoint.gate_mismatch", `resume outcome (gate "${describeSuppliedValue(outcomeGate)}") does not match checkpoint gate "${cp.gate.kind}" — resume serves ${Object.entries(PAUSE_REGISTRY)
+                .filter(([, row]) => !row.terminal)
+                .map(([k, row]) => `${k}/${row.resume}`)
+                .join(", ")}`);
         }
         let plainReviewOutcome;
         if (cp.gate.kind === "plan_review") {
@@ -4619,25 +4599,27 @@ export class Runner {
             if (decision !== "allow" && decision !== "deny") {
                 throw new CheckpointError("checkpoint.invalid_outcome", `resume decision "${describeSuppliedValue(decision)}" is outside the policy_ask domain — a decide is exactly "allow" or "deny"; refusing pre-CAS, the checkpoint stays pending`);
             }
-            const settledBy = decide.settledBy;
-            if (settledBy !== undefined && !isApprovalSettledBy(settledBy)) {
-                throw new CheckpointError("checkpoint.invalid_outcome", `resume settledBy "${describeSuppliedValue(settledBy)}" is outside the settlement vocabulary — it is exactly "human", "timeout" or "aborted" (or omitted); refusing pre-CAS, the checkpoint stays pending`, { field: "settledBy" });
+            const hostDecisionRaw = decide.hostDecision;
+            if (typeof hostDecisionRaw !== "object" || hostDecisionRaw === null) {
+                throw new CheckpointError("checkpoint.invalid_outcome", `resume carries no hostDecision — a policy_ask decide names who decided it ({ decidedBy: "person" | "sla_timeout", approver? }); refusing pre-CAS, the checkpoint stays pending`, { field: "hostDecision" });
+            }
+            const decidedBy = hostDecisionRaw.decidedBy;
+            if (decidedBy !== "person" && decidedBy !== "sla_timeout") {
+                throw new CheckpointError("checkpoint.invalid_outcome", `resume hostDecision.decidedBy "${describeSuppliedValue(decidedBy)}" is outside the closed set — it is exactly "person" or "sla_timeout"; refusing pre-CAS, the checkpoint stays pending`, { field: "hostDecision" });
             }
-            if (settledBy !== undefined && settledBy !== "human" && decision === "allow") {
-                throw new CheckpointError("checkpoint.invalid_outcome", `resume carries decision "allow" with settledBy "${settledBy}" — a non-human settlement is a fail-closed end (nobody answered), so it cannot be the source of an approval that EXECUTES; ` +
-                    "supply \"human\", or omit the field if the allow came from configuration rather than a person; refusing pre-CAS, the checkpoint stays pending", { field: "settledBy" });
+            if (decidedBy === "sla_timeout" && decision === "allow") {
+                throw new CheckpointError("checkpoint.invalid_outcome", `resume carries decision "allow" decided by "sla_timeout" — an elapsed SLA window cannot be what approved an action that EXECUTES; refusing pre-CAS, the checkpoint stays pending`, { field: "hostDecision" });
             }
-            const approver = decide.approver;
-            const attribution = screenApproverAttribution(approver);
+            if (decide.gateOutcome !== undefined) {
+                throw new CheckpointError("checkpoint.invalid_outcome", "resume carries a gateOutcome — the settlement record is minted by core from the host's decision facts and the row's origin, never supplied; refusing pre-CAS, the checkpoint stays pending", { field: "hostDecision" });
+            }
+            const attribution = screenApproverAttribution(hostDecisionRaw.approver);
             if (attribution.defect !== undefined) {
                 throw new CheckpointError("checkpoint.invalid_outcome", `resume carries an approver attribution this engine refuses: ${attribution.defect}; refusing pre-CAS, the checkpoint stays pending`, { field: "approver" });
             }
-            if (attribution.approver !== undefined && settledBy === undefined) {
-                throw new CheckpointError("checkpoint.invalid_outcome", `resume names an approver but no settledBy — an attribution says WHOSE settlement it was and needs the word that says what KIND of end it was beside it; ` +
-                    `supply settledBy ("human" / "timeout" / "aborted"), or omit the approver; refusing pre-CAS, the checkpoint stays pending`, { field: "approver" });
-            }
             const reason = decide.reason;
             assertOutcomeText(reason, "reason");
+            const approverCell = attribution.approver !== undefined ? { approver: attribution.approver } : {};
             plainPolicyOutcome = {
                 gate: "policy_ask",
                 boundCallId: decide.boundCallId,
@@ -4646,8 +4628,7 @@ export class Runner {
                 ...(updatedInput !== undefined ? { updatedInput } : {}),
                 ...(reason !== undefined ? { reason } : {}),
                 ...(redeemedAnswer !== undefined ? { answer: redeemedAnswer } : {}),
-                ...(settledBy !== undefined ? { settledBy } : {}),
-                ...(attribution.approver !== undefined ? { approver: attribution.approver } : {}),
+                hostDecision: { decidedBy, ...approverCell },
             };
             if (plainPolicyOutcome.decision === "deny" && plainPolicyOutcome.reason && sanitizeUntrustedText(plainPolicyOutcome.reason) !== plainPolicyOutcome.reason) {
                 throw new CheckpointError("checkpoint.invalid_outcome", "resume deny/reject reason must not contain a </system-reminder> tag");
@@ -4701,11 +4682,7 @@ export class Runner {
             throw new CheckpointError("checkpoint.unsupported_version", `checkpoint version ${checkpointVersionOf(cp)} is newer than this worker supports (max ${MAX_SUPPORTED_CHECKPOINT_VERSION})`, { reason: "version_newer" });
         }
         const preCasGateBit = cp.gate.kind === "irreversible_ask" ? cp.gate.realApproval : undefined;
-        const preCasBitWellFormed = preCasGateBit !== undefined &&
-            typeof preCasGateBit === "object" &&
-            (preCasGateBit.origin === "org_rule" ||
-                preCasGateBit.origin === "org_unavailable" ||
-                preCasGateBit.origin === "policy");
+        const preCasBitWellFormed = preCasGateBit !== undefined && typeof preCasGateBit === "object" && isAskOrigin(preCasGateBit.origin);
         const faceSaysGoverned = (cp.state.readFace?.realApproval) === true;
         const preCasBitViolation = checkpointVersionOf(cp) === REAL_APPROVAL_CHECKPOINT_VERSION
             ? !preCasBitWellFormed
@@ -4716,7 +4693,7 @@ export class Runner {
                     : preCasGateBit !== undefined && !preCasBitWellFormed;
         if (preCasBitViolation) {
             throw new CheckpointError("checkpoint.invalid_outcome", checkpointVersionOf(cp) >= REAL_APPROVAL_CHECKPOINT_VERSION
-                ? `a v${checkpointVersionOf(cp)} checkpoint's realApproval gate bit must be well-formed (origin org_rule/org_unavailable/policy)${checkpointVersionOf(cp) === REAL_APPROVAL_CHECKPOINT_VERSION ? " and present on an irreversible_ask gate" : ""} — this row's is not; refusing to resume a damaged real-approval row (corruption / downgrade guard), the checkpoint stays pending`
+                ? `a v${checkpointVersionOf(cp)} checkpoint's realApproval gate bit must be well-formed (origin a member of the closed ask-origin set)${checkpointVersionOf(cp) === REAL_APPROVAL_CHECKPOINT_VERSION ? " and present on an irreversible_ask gate" : ""} — this row's is not; refusing to resume a damaged real-approval row (corruption / downgrade guard), the checkpoint stays pending`
                 : `a v${checkpointVersionOf(cp)} checkpoint carries a realApproval gate bit no release of that version ever minted — refusing to honor a fabricated origin (corruption / forgery guard), the checkpoint stays pending`, { reason: checkpointVersionOf(cp) >= REAL_APPROVAL_CHECKPOINT_VERSION ? "real_approval_damaged" : "real_approval_forged" });
         }
         {
@@ -4736,9 +4713,8 @@ export class Runner {
                     : `a v${checkpointVersionOf(cp)} checkpoint carries a read-face section no release of that version ever minted — refusing to honor a fabricated read-face state (corruption / forgery guard), the checkpoint stays pending`, { reason: checkpointVersionOf(cp) >= FACE_CHECKPOINT_VERSION ? "read_face_damaged" : "read_face_forged" });
             }
         }
-        if ((preCasGateBit?.origin === "org_rule" || preCasGateBit?.origin === "org_unavailable") &&
-            this.deps.permissionRuleStore?.partitions.org !== true) {
-            throw new CheckpointError("checkpoint.unsupported_version", `this checkpoint's approval was minted under organization governance (${preCasGateBit.origin}) and this worker has no org adjudication wiring (its permission-rule store carries no org partition) — a governed approval may only be redeemed where governance can be enforced; the checkpoint stays pending, resume it on an org-wired worker`, { reason: "governed_unwired" });
+        if (realApprovalOrgFact(preCasGateBit) !== undefined && this.deps.permissionRuleStore?.partitions.org !== true) {
+            throw new CheckpointError("checkpoint.unsupported_version", `this checkpoint's approval was minted under organization governance (org ${String(realApprovalOrgFact(preCasGateBit))}, routed as ${String(preCasGateBit?.origin)}) and this worker has no org adjudication wiring (its permission-rule store carries no org partition) — a governed approval may only be redeemed where governance can be enforced; the checkpoint stays pending, resume it on an org-wired worker`, { reason: "governed_unwired" });
         }
         const retiredWalltimeTotal = cp.resourceLedger?.totalWalltimeSec;
         if (retiredWalltimeTotal !== undefined) {
@@ -4995,6 +4971,18 @@ export class Runner {
                 }
             }
         }
+        if (plainPolicyOutcome !== undefined) {
+            const parkedOrigin = cp.pendingAction.kind === "tool_approval" ? cp.pendingAction.origin : undefined;
+            if (!isAskOrigin(parkedOrigin)) {
+                throw new CheckpointError("checkpoint.unsupported_version", "this checkpoint's pending approval carries no origin word (a row minted before the ask's origin was persisted on the park) — its settlement cannot be recorded; the checkpoint stays pending");
+            }
+            const facts = plainPolicyOutcome.hostDecision;
+            const approverCell = facts.approver !== undefined ? { approver: facts.approver } : {};
+            const settlement = facts.decidedBy === "sla_timeout"
+                ? { kind: "park_sla_expired", who: { party: "host", ...approverCell }, when: Date.now() }
+                : { kind: plainPolicyOutcome.decision === "allow" ? "human_allowed" : "human_refused", who: { party: "person", ...approverCell }, when: Date.now(), ...(plainPolicyOutcome.decision === "deny" && plainPolicyOutcome.reason !== undefined ? { note: plainPolicyOutcome.reason } : {}) };
+            plainPolicyOutcome = { ...plainPolicyOutcome, gateOutcome: mintGateOutcome({ ...(plainPolicyOutcome.decision === "deny" ? { deniedBy: "ask_resolution" } : {}), settled: { settlement, origin: parkedOrigin } }) };
+        }
         const outcomeForStore = plainPolicyOutcome ?? plainReviewOutcome ?? plainParkOutcome;
         if (outcomeForStore === undefined) {
             throw new CheckpointError("checkpoint.invalid_outcome", `resume outcome (gate "${describeSuppliedValue(outcomeGate)}") matched the checkpoint gate but no lane captured it — refusing pre-CAS rather than passing the caller's live object to the store and the resumed run`);
@@ -5237,13 +5225,15 @@ export class Runner {
         const resolvedArgs = pendingAction.toolName === ASK_USER_QUESTION_TOOL_NAME ? pendingAction.args : (outcome.updatedInput !== undefined ? outcome.updatedInput : pendingAction.args);
         const pendingLabel = (() => { const l = prepared.tools.find((t) => t.name === pendingAction.toolName)?.label; return l !== undefined && l !== pendingAction.toolName ? { label: l } : {}; })();
         emit({ type: "tool_start", toolCallId: pendingAction.toolCallId, toolName: pendingAction.toolName, ...pendingLabel, args: resolvedArgs });
-        const emitEnd = (isError, result) => emit({ type: "tool_end", toolCallId: pendingAction.toolCallId, toolName: pendingAction.toolName, ...pendingLabel, isError, ...toolEndBodyFrom(result, isError, outcome.settledBy, outcome.approver) });
+        const emitEnd = (isError, result, gate = outcome.gateOutcome) => emit({ type: "tool_end", toolCallId: pendingAction.toolCallId, toolName: pendingAction.toolName, ...pendingLabel, isError, ...toolEndBodyFrom(result, isError, gate) });
+        const vetoed = (layer) => mintGateOutcome({
+            deniedBy: layer,
+            ...(outcome.gateOutcome?.settlement !== undefined && outcome.gateOutcome.origin !== undefined ? { settled: { settlement: outcome.gateOutcome.settlement, origin: outcome.gateOutcome.origin } } : {}),
+        });
         if (outcome.decision === "deny") {
-            const defaultDenial = outcome.settledBy === "timeout"
+            const defaultDenial = outcome.gateOutcome?.settlement?.kind === "park_sla_expired"
                 ? `No one answered the approval request for the pending tool call "${pendingAction.toolName}" — the approval window elapsed with no answer, so it was not executed.`
-                : outcome.settledBy === "aborted"
-                    ? `The approval for the pending tool call "${pendingAction.toolName}" ended without anyone deciding it (it was cancelled or could not be delivered), so it was not executed.`
-                    : `The pending tool call "${pendingAction.toolName}" was denied by an approver.`;
+                : `The pending tool call "${pendingAction.toolName}" was denied by an approver.`;
             const reason = outcome.reason ? delimitUntrusted("reviewer note", outcome.reason, REVIEWER_NOTE_MAX_BODY) : defaultDenial;
             emitEnd(true, { content: formatHookFeedback(reason, prepared.reminderMark) });
             const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, formatHookFeedback(reason, prepared.reminderMark), true));
@@ -5270,17 +5260,17 @@ export class Runner {
                 (rechecked.updatedInput !== undefined && !deepJsonEqual(rechecked.updatedInput, resolvedArgs));
             if (beltUnsafe) {
                 const editedDenial = formatHookFeedback(`The approver EDITED this call's input; the edited call is refused by the deployment's tool policy and was not executed${rechecked.action === "deny" && rechecked.message ? `: ${rechecked.message}` : " (the policy rewrote the edit to a value that was not approved)"}.`, prepared.reminderMark);
-                emitEnd(true, { content: editedDenial });
+                emitEnd(true, { content: editedDenial }, vetoed("policy"));
                 const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, editedDenial, true));
                 emitCommitted(eid, "toolResult", pendingAction.toolCallId);
                 return;
             }
         }
         const gateRealApproval = resume.cp.gate.kind === "irreversible_ask" ? resume.cp.gate.realApproval : undefined;
-        const gateOrgGoverned = gateRealApproval?.origin === "org_rule" || gateRealApproval?.origin === "org_unavailable";
+        const gateOrgGoverned = realApprovalOrgFact(gateRealApproval) !== undefined;
         if (gateOrgGoverned && prepared.permissionRuleOrg === undefined) {
             const unwiredDenial = formatHookFeedback(`The approved tool call "${pendingAction.toolName}" was not executed: its approval was minted under organization governance (${gateRealApproval.origin}), and this worker has no org adjudication wiring — a governed approval may only be redeemed where governance can be enforced. This approval is spent; re-issue the call on an org-wired worker.`, prepared.reminderMark);
-            emitEnd(true, { content: unwiredDenial });
+            emitEnd(true, { content: unwiredDenial }, vetoed("org"));
             const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, unwiredDenial, true));
             emitCommitted(eid, "toolResult", pendingAction.toolCallId);
             return;
@@ -5298,7 +5288,7 @@ export class Runner {
                 },
             });
             const blocked = org.status === "unavailable"
-                ? gateRealApproval?.origin === "org_unavailable"
+                ? realApprovalOrgFact(gateRealApproval) === "unavailable"
                     ? undefined
                     : orgWaitCancelled
                         ? "this deployment is org-governed and the task was cancelled before the organization policy snapshot could be adjudicated"
@@ -5311,7 +5301,7 @@ export class Runner {
                     ? ` Governance disclosures: ${inlineUntrusted(org.disclosures.join("; "), ORG_DISCLOSURE_MAX_CHARS)}.`
                     : "";
                 const orgDenial = formatHookFeedback(`The approved tool call "${pendingAction.toolName}" was not executed: ${blocked}.${orgDisclosures} This approval is spent — the call has to be re-issued and approved again once organization policy permits it.`, prepared.reminderMark);
-                emitEnd(true, { content: orgDenial });
+                emitEnd(true, { content: orgDenial }, vetoed("org"));
                 const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, orgDenial, true));
                 emitCommitted(eid, "toolResult", pendingAction.toolCallId);
                 return;
@@ -5327,7 +5317,7 @@ export class Runner {
             }, prepared.abortController.signal));
             if (narrowed.action === "deny") {
                 const narrowedDenial = formatHookFeedback(`The approved tool call "${pendingAction.toolName}" is now denied by a session rule and was not executed${narrowed.message ? `: ${narrowed.message}` : ""}.`, prepared.reminderMark);
-                emitEnd(true, { content: narrowedDenial });
+                emitEnd(true, { content: narrowedDenial }, vetoed("policy"));
                 const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, narrowedDenial, true));
                 emitCommitted(eid, "toolResult", pendingAction.toolCallId);
                 return;
@@ -5535,8 +5525,7 @@ export class Runner {
     async teardownOwnedEnv(prepared) {
         if (prepared.ownedEnv &&
             hasDestroy(prepared.ownedEnv) &&
-            prepared.suspendRef.token === undefined &&
-            prepared.reviewRef.token === undefined) {
+            prepared.pausedRef.current === undefined) {
             try {
                 await prepared.ownedEnv.destroy();
             }

package/dist/core/runner/terminal-projection.d.ts

@@ -0,0 +1,22 @@
+import type { CheckpointGate, CheckpointToken } from "../checkpoint-store.js";
+import type { TaskResult, TaskStatus, TerminalCause } from "../types.js";
+/** The plane words a {@link TerminalCause} reads as — one derivation, called by the faces that speak
+ *  them. The paused arm's `status` is its gate kind's registry row (`suspended` for an approval,
+ *  a resource slice or a platform pause; `needs_review` for a plan or dry-run review, which also
+ *  carries the `review.pending` code the review consumers key on). */
+export declare function terminalProjection(terminal: TerminalCause): {
+    status: TaskStatus;
+    errorCode?: string;
+    errorMessage?: string;
+    blockedReason?: string;
+    checkpointToken?: CheckpointToken;
+    checkpointId?: string;
+    checkpointGate?: CheckpointGate;
+    workspaceRestoreMode?: "snapshot" | "park_only";
+};
+/**
+ * A compensation that changes WHY a settled result ended (a resume leg's approval reopened / could not
+ * be reopened) amends the CAUSE — the one record there is. The code fills only an empty seat (the leg's
+ * own terminal code, when it had one, still names the ending); the message is extended, not replaced.
+ */
+export declare function amendTerminal(result: TaskResult, code: string, message: (prior: string | undefined) => string): void;