@sema-agent/core 5.13.0 → 5.15.0

package/dist/core/runner/runtask.js

@@ -1,10 +1,12 @@
 import { AgentHarness, DEFAULT_COMPACTION_SETTINGS, uuidv7 } from "../../internal/harness.js";
-import { CheckpointError, BINDING_CHECKPOINT_VERSION, checkpointVersionOf, MAX_SUPPORTED_CHECKPOINT_VERSION, remainingBudgetMicroUsd, remainingTokens, validatePendingSteer, winnerFromOutcome, } from "../checkpoint-store.js";
+import { snapshotActorAssertion } from "../../internal/llm.js";
+import { CheckpointError, BINDING_CHECKPOINT_VERSION, checkpointVersionOf, MAX_SUPPORTED_CHECKPOINT_VERSION, remainingBudgetMicroUsd, readPendingSteerQueue, remainingTokens, validatePendingSteer, winnerFromOutcome, } from "../checkpoint-store.js";
 import { engineVersion } from "../version.js";
 import { CONFIG_CATALOG_VERSION, declarationReasons, resolveEffectiveConfig } from "../../config/catalog.js";
 import { eventDefaultOn } from "../../prompt-assembly/event-registry.js";
 import { DEFAULT_COMPACTION_INSTRUCTIONS, createRapidRefillState, isCompactionManualCancel, maybeCompact, nextTrimForceBackoff, recordCompactionAndCheckRapidRefill, sanitizeCompactionSettings } from "../auto-compaction.js";
-import { ASK_USER_QUESTION_TOOL_NAME, QUESTION_AWAITS_RESUME } from "../ask-question.js";
+import { ASK_USER_QUESTION_TOOL_NAME, canonicalizeCapturedPlainData, classifyQuestionOutcome, isLiveQuestionFace, markBoundOnlyQuestionFace } from "../ask-question.js";
+import { boundInputHashOf } from "../canonical-json.js";
 import { computeCostMicroUsd, modelCostToPricing } from "../pricing.js";
 import { emitTrace } from "../trace.js";
 import { emitTaskOutcome } from "../task-outcome.js";
@@ -31,6 +33,7 @@ import { hasVerifiableStructureSignal } from "./grounding-signal.js";
 import { hasDestroy, isIsolated } from "../remote-env.js";
 import { hasBackgroundShell, sweepBackgroundShells } from "../background-shell.js";
 import { formatHookFeedback } from "../hooks.js";
+import { buildHumanInputEvent, projectHumanInput } from "../human-input-projection.js";
 import { delimitUntrusted, inlineUntrusted, sanitizeUntrustedText } from "../untrusted-text.js";
 import { reconcileInterruptedSession } from "../session-reconcile.js";
 import { RunnerSharedToolResultStore } from "../tool-result-store.js";
@@ -52,6 +55,15 @@ function createRunState() {
         attach: { attachmentsCfg: undefined, agentListingOn: false, skillsListingOn: false, attachState: undefined, dateState: undefined, instrProbe: undefined, instrState: undefined, sizeGuidelineState: undefined, attachmentsInjected: 0 },
     };
 }
+const humanInputOrdinals = new WeakMap();
+function nextHumanInputSeq(key) {
+    let box = humanInputOrdinals.get(key);
+    if (box === undefined) {
+        box = { n: 0 };
+        humanInputOrdinals.set(key, box);
+    }
+    return ++box.n;
+}
 const MAX_CONSECUTIVE_COMPACTION_FAILURES = 3;
 const STOP_HOOK_BLOCK_CAP = 8;
 const COMPACTION_REGROWTH_FACTOR = 1.5;
@@ -139,7 +151,15 @@ function deepJsonEqual(a, b) {
     if (aArr && bArr) {
         if (a.length !== b.length)
             return false;
-        return a.every((v, i) => deepJsonEqual(v, b[i]));
+        for (let i = 0; i < a.length; i++) {
+            if (!deepJsonEqual(a[i], b[i]))
+                return false;
+        }
+        const aExtra = Object.keys(a).filter((k) => !isCanonicalIndexKey(k, a.length));
+        const bExtra = Object.keys(b).filter((k) => !isCanonicalIndexKey(k, b.length));
+        if (aExtra.length !== bExtra.length)
+            return false;
+        return aExtra.every((k) => Object.prototype.hasOwnProperty.call(b, k) && deepJsonEqual(Reflect.get(a, k), Reflect.get(b, k)));
     }
     const ao = a;
     const bo = b;
@@ -149,6 +169,9 @@ function deepJsonEqual(a, b) {
         return false;
     return aKeys.every((k) => Object.prototype.hasOwnProperty.call(bo, k) && deepJsonEqual(ao[k], bo[k]));
 }
+function isCanonicalIndexKey(key, length) {
+    return /^(0|[1-9]\d*)$/.test(key) && Number(key) < length;
+}
 function sameWinner(a, b) {
     return (a.boundCallId === b.boundCallId &&
         a.decision === b.decision &&
@@ -160,14 +183,18 @@ function pendingContentAskCallId(cp) {
         ? cp.pendingAction.toolCallId
         : undefined;
 }
-function answerFaceForRedeemedCall(answer, redeemedCallId, base) {
-    return async (req, signal) => {
-        if (req.toolCallId === redeemedCallId)
+function answerFaceForRedeemedCall(answer, redeemedCallId, base, redeemedQuestionsHash) {
+    let consumed = false;
+    const face = async (req, signal) => {
+        if (!consumed && req.toolCallId === redeemedCallId && boundInputHashOf(req.questions) === redeemedQuestionsHash) {
+            consumed = true;
             return answer;
+        }
         if (base !== undefined)
             return base(req, signal);
         throw new Error("this resumed leg's answer was bound to the decided question only — a new question has no answer on this leg");
     };
+    return isLiveQuestionFace(base) ? face : markBoundOnlyQuestionFace(face);
 }
 function writeFamilyOfCanonical(name) {
     if (name === "TaskCreate" || name === "TaskUpdate")
@@ -188,6 +215,14 @@ function toolResultMsg(toolCallId, toolName, text, isError) {
         timestamp: Date.now(),
     };
 }
+function describeSuppliedValue(value) {
+    return typeof value === "string" ? value : value === null ? "null" : typeof value;
+}
+function assertReviewText(value, field) {
+    if (value !== undefined && typeof value !== "string") {
+        throw new CheckpointError("checkpoint.invalid_outcome", `resume \`${field}\` is not a plain string (got ${typeof value}) — a review verdict's text is an operator's plain data, not a live object; refusing pre-CAS, the checkpoint stays pending`);
+    }
+}
 function resumeContinuation(resume) {
     if (resume.outcome.gate === "wake") {
         return formatHookFeedback("You were WOKEN from a parked pause by an operator. Before continuing, re-orient from the workspace: " +
@@ -548,6 +583,12 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
                     ...(bgTasks !== undefined ? { backgroundTasks: bgTasks } : {}),
                     ...(pendingTools !== undefined ? { newTools: pendingTools } : {}),
                     ...(prepared.toolMaterializeStatic ? { newToolsStaticFace: true } : {}),
+                    ...(prepared.toolMaterializeStatic && pendingTools !== undefined
+                        ? { newToolsSwappedUnderStatic: pendingTools.filter((n) => prepared.staticFaceFor?.(n) !== true) }
+                        : {}),
+                    ...(prepared.toolMaterializeStatic && pendingReaddedTools !== undefined
+                        ? { readdedToolsSwappedUnderStatic: pendingReaddedTools.filter((n) => prepared.staticFaceFor?.(n) !== true) }
+                        : {}),
                     ...(mcpToolsDelta !== undefined ? { mcpToolsDelta } : {}),
                     ...(rs.attach.agentListingOn && prepared.agentListing !== undefined
                         ? {
@@ -566,6 +607,12 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
                     const exact = renderToolsDelta({
                         ...(pendingTools !== undefined ? { added: pendingTools } : {}),
                         ...(prepared.toolMaterializeStatic ? { staticFace: true } : {}),
+                        ...(prepared.toolMaterializeStatic && pendingTools !== undefined
+                            ? { swappedUnderStatic: pendingTools.filter((n) => prepared.staticFaceFor?.(n) !== true) }
+                            : {}),
+                        ...(prepared.toolMaterializeStatic && pendingReaddedTools !== undefined
+                            ? { readdedSwappedUnderStatic: pendingReaddedTools.filter((n) => prepared.staticFaceFor?.(n) !== true) }
+                            : {}),
                         ...(mcpToolsDelta ?? {}),
                     });
                     if (exact !== undefined && due.some((a) => a.source === "tools_delta" && a.body === exact)) {
@@ -1166,6 +1213,7 @@ function makeHarnessHandlers(prepared, stats, rs, deps) {
             const progress = {
                 type: "task_progress",
                 taskId: rs.telemetry.taskId,
+                ...(internals?.delegationTaskType !== undefined ? { taskType: internals.delegationTaskType } : {}),
                 ...(internals?.parentTaskId !== undefined ? { parentTaskId: internals.parentTaskId } : {}),
                 ...(subagentName ? { name: subagentName } : {}),
                 usage: { totalTokens: stats.tokens, toolUses: stats.toolCalls, durationMs: Date.now() - rs.telemetry.taskStart },
@@ -1332,6 +1380,7 @@ export class Runner {
         return runSideQuery(spec, { brain: this.deps.brain, models: this.deps.models, roles: this.deps.roles });
     }
     runTaskStream(spec, resume, internals) {
+        const entryActor = spec.actor === undefined ? undefined : snapshotActorAssertion(spec.actor);
         const queue = new PushQueue();
         const detachHub = new ToolDetachHub();
         let resultValue;
@@ -1386,7 +1435,7 @@ export class Runner {
                     publishReady(h);
                 }, (s) => {
                     reapHandle = s;
-                }, manualCompactRef, taskIdRef, resume, { ...(internals ?? {}), detachHub }, notifyRef);
+                }, manualCompactRef, taskIdRef, resume, { ...(internals ?? {}), detachHub }, notifyRef, entryActor);
             }
             finally {
                 releaseLock?.();
@@ -1523,7 +1572,29 @@ export class Runner {
                 if (options?.trusted && sanitizeUntrustedText(text) !== text) {
                     throw steeringError("trusted steering text must not contain a </system-reminder> tag", "steering.invalid_content");
                 }
-                const payload = options?.trusted ? formatHookFeedback(text) : text;
+                const actor = options?.actor === undefined ? undefined : snapshotActorAssertion(options.actor);
+                const projected = projectHumanInput({ text, actor, source: "steer" });
+                const payload = options?.trusted ? formatHookFeedback(projected) : projected;
+                const mintsAFrame = payload.trim().length !== 0;
+                const emitAccepted = (h) => {
+                    if (!mintsAFrame)
+                        return;
+                    queue.push({
+                        ...buildHumanInputEvent({
+                            carrier: "steer",
+                            source: "steer",
+                            delivery: "queued",
+                            sessionSeq: nextHumanInputSeq(h.harness),
+                            ...(actor !== undefined ? { actor } : {}),
+                            ...(actor?.issuer !== undefined ? { issuer: actor.issuer } : {}),
+                            ...(spec.principal !== undefined ? { principal: spec.principal } : {}),
+                        }),
+                        eventId: uuidv7(),
+                        ...(internals?.parentToolCallId !== undefined
+                            ? { parentToolCallId: internals.parentToolCallId, ...(spec.taskId !== undefined ? { sourceTaskId: spec.taskId } : {}) }
+                            : {}),
+                    });
+                };
                 const deliver = async () => {
                     if (resultValue)
                         throw steeringError("the task has already finished");
@@ -1531,7 +1602,8 @@ export class Runner {
                     if (!h)
                         throw steeringError("the task is not running");
                     try {
-                        await h.harness.steer(payload, { provenance: "engine-note" });
+                        await h.harness.steer(payload, { provenance: "engine-note", ...(actor !== undefined ? { actor } : {}) });
+                        emitAccepted(h);
                         return;
                     }
                     catch (e) {
@@ -1541,7 +1613,8 @@ export class Runner {
                     const birthDeadline = Date.now() + READY_TIMEOUT_MS;
                     while (resultValue === undefined && !h.loop.ended && Date.now() < birthDeadline) {
                         try {
-                            await h.harness.steer(payload, { provenance: "engine-note" });
+                            await h.harness.steer(payload, { provenance: "engine-note", ...(actor !== undefined ? { actor } : {}) });
+                            emitAccepted(h);
                             return;
                         }
                         catch (e2) {
@@ -1658,7 +1731,7 @@ export class Runner {
             })()),
         };
     }
-    async runLocked(spec, queue, setResult, onSuggestions, onReady, onSuspend, manualCompactRef, taskIdRef, resume, internals, notifyRef) {
+    async runLocked(spec, queue, setResult, onSuggestions, onReady, onSuspend, manualCompactRef, taskIdRef, resume, internals, notifyRef, entryActor) {
         const prepareResume = resume
             ? {
                 leafId: resume.cp.leafId,
@@ -1671,6 +1744,12 @@ export class Runner {
                 executesApprovedAction: resume.cp.pendingAction.kind === "tool_approval" &&
                     resume.outcome.gate !== "wake" &&
                     resume.outcome.decision === "allow",
+                ...(resume.outcome.gate !== "wake" && resume.outcome.decision === "allow" && pendingContentAskCallId(resume.cp) !== undefined
+                    ? {
+                        redeemedContentAskCallId: pendingContentAskCallId(resume.cp),
+                        redeemedContentAskQuestionsHash: boundInputHashOf(resume.cp.pendingAction.args?.questions),
+                    }
+                    : {}),
             }
             : undefined;
         const taskNotificationQueue = new SystemInjectionQueue();
@@ -1759,6 +1838,7 @@ export class Runner {
         const parentToolCallId = internals?.parentToolCallId;
         const ident = () => parentToolCallId !== undefined ? { eventId: uuidv7(), parentToolCallId, sourceTaskId: runSourceTaskId } : { eventId: uuidv7() };
         notificationIdent = ident;
+        queue.push({ type: "wiring_manifest", manifest: prepared.wiringManifest, ...ident() });
         manualCompactRef.emitMooted = (reason) => {
             queue.push({ type: "compaction_outcome", outcome: "mooted", trigger: "manual", reason, ...ident() });
         };
@@ -2133,6 +2213,7 @@ export class Runner {
             ...(prepared.promptManifest.tools ? { tools: prepared.promptManifest.tools } : {}),
             ...(prepared.promptManifest.snapshot ? { snapshot: prepared.promptManifest.snapshot } : {}),
             ...(prepared.promptManifest.lowering ? { lowering: prepared.promptManifest.lowering } : {}),
+            ...(prepared.promptManifest.toolDisclosure ? { toolDisclosure: prepared.promptManifest.toolDisclosure } : {}),
             totalChars: prepared.promptManifest.blocks.reduce((n, b) => n + b.chars, 0),
             ts: rs.telemetry.taskStart,
         }));
@@ -2595,6 +2676,7 @@ export class Runner {
         let final;
         let threw;
         let abortedLive = false;
+        let strandedHumanAnswers = [];
         try {
             if (prepared.abortController.signal.aborted) {
                 const e = new Error("run aborted");
@@ -2647,15 +2729,31 @@ export class Runner {
                         }
                     }
                     const engineSegments = continuation.length > 0 ? [{ start: 0, end: continuation.length }] : [];
-                    for (const steer of [resume.cp.state.pendingSteer, resume.wakeMessage]) {
-                        if (steer === undefined)
-                            continue;
+                    const resumeFrames = [
+                        ...readPendingSteerQueue(resume.cp.state).map((entry) => ({ entry, source: "steer" })),
+                        ...(resume.wakeMessage !== undefined ? [{ entry: resume.wakeMessage, source: "wake" }] : []),
+                    ];
+                    for (const { entry: steer, source } of resumeFrames) {
                         const start = continuation.length;
+                        const projected = projectHumanInput({ text: steer.text, actor: steer.actor, source });
                         continuation +=
                             "\n\n" +
-                                (steer.trusted ? formatHookFeedback(steer.text) : delimitUntrusted("supervisor steering message", steer.text));
+                                (steer.trusted ? formatHookFeedback(projected) : delimitUntrusted("supervisor steering message", projected));
                         if (steer.trusted)
                             engineSegments.push({ start, end: continuation.length });
+                        queue.push({
+                            ...buildHumanInputEvent({
+                                carrier: source,
+                                source,
+                                delivery: "applied",
+                                sessionSeq: nextHumanInputSeq(prepared.harness),
+                                inputId: steer.inputId,
+                                ...(steer.actor !== undefined ? { actor: steer.actor } : {}),
+                                ...(steer.actor?.issuer !== undefined ? { issuer: steer.actor.issuer } : {}),
+                                ...(spec.principal !== undefined ? { principal: spec.principal } : {}),
+                            }),
+                            ...ident(),
+                        });
                     }
                     if (resume !== undefined)
                         resume.decisionDelivered = true;
@@ -2663,7 +2761,9 @@ export class Runner {
                 }
             }
             else {
-                let effectiveObjective = spec.objective;
+                const objectiveActor = entryActor;
+                const projectedObjective = projectHumanInput({ text: spec.objective, actor: objectiveActor, source: "objective" });
+                let effectiveObjective = projectedObjective;
                 let promptBlocked = false;
                 const userPromptSubmit = (spec.hooks ?? this.deps.hooks)?.userPromptSubmit;
                 if (userPromptSubmit) {
@@ -2674,7 +2774,7 @@ export class Runner {
                             promptBlocked = true;
                         }
                         else if (decision?.additionalContext) {
-                            effectiveObjective = `${formatHookFeedback(decision.additionalContext)}\n\n${spec.objective}`;
+                            effectiveObjective = `${formatHookFeedback(decision.additionalContext)}\n\n${projectedObjective}`;
                         }
                     }
                     catch (hookErr) {
@@ -2775,10 +2875,23 @@ export class Runner {
                     rs.attach.attachmentsInjected += firstFrames.length;
                     if (firstFrames.length > 0)
                         await prepared.session.appendAnnouncedListing(prepared.announcedListingsRef).catch(() => undefined);
-                    const enginePrefixChars = effectiveObjective.length - spec.objective.length;
+                    const enginePrefixChars = effectiveObjective.length - projectedObjective.length;
+                    queue.push({
+                        ...buildHumanInputEvent({
+                            carrier: "objective",
+                            source: "objective",
+                            delivery: "applied",
+                            sessionSeq: nextHumanInputSeq(prepared.harness),
+                            ...(objectiveActor !== undefined ? { actor: objectiveActor } : {}),
+                            ...(objectiveActor?.issuer !== undefined ? { issuer: objectiveActor.issuer } : {}),
+                            ...(spec.principal !== undefined ? { principal: spec.principal } : {}),
+                        }),
+                        ...ident(),
+                    });
                     final = await withBrainSinks(() => prepared.harness.prompt(effectiveObjective, {
                         ...(images && images.length > 0 ? { images } : {}),
                         ...(enginePrefixChars > 0 ? { enginePrefixChars } : {}),
+                        ...(objectiveActor !== undefined ? { actor: objectiveActor } : {}),
                     }));
                 }
             }
@@ -2801,6 +2914,7 @@ export class Runner {
             prepared.lspDiagnostics?.registry.releaseRun(prepared.lspDiagnostics.runIdent);
             prepared.abortController.abort();
             prepared.releaseSignal();
+            strandedHumanAnswers = prepared.settleContentAskBindings();
             try {
                 prepared.harness.recoverUndrainedEngineNotes();
             }
@@ -2939,6 +3053,7 @@ export class Runner {
                 model: prepared.model.id,
                 unpricedSpend: rs.telemetry.unpricedSpend,
                 rewindNotes: prepared.rewindNotes,
+                strandedHumanAnswers,
                 remoteEnvFailures: prepared.remoteEnvFailures,
                 retryAfterMs: rs.limits.platformTerminal?.retryAfterMs,
                 abortedForTimeout: timeout.fired,
@@ -3075,6 +3190,7 @@ export class Runner {
                 const terminalTick = {
                     type: "task_progress",
                     taskId: rs.telemetry.taskId,
+                    ...(internals?.delegationTaskType !== undefined ? { taskType: internals.delegationTaskType } : {}),
                     ...(internals?.parentTaskId !== undefined ? { parentTaskId: internals.parentTaskId } : {}),
                     ...(subagentName ? { name: subagentName } : {}),
                     usage: { totalTokens: stats.tokens, toolUses: stats.toolCalls, durationMs: Date.now() - rs.telemetry.taskStart },
@@ -3281,6 +3397,9 @@ export class Runner {
         return stream.result();
     }
     async resumeStream(token, outcome, taskConfig, internals) {
+        if (outcome === null || typeof outcome !== "object") {
+            throw new CheckpointError("checkpoint.invalid_outcome", `resume outcome must be an object naming its gate (got ${outcome === null ? "null" : typeof outcome})`);
+        }
         const store = resolveCheckpointStore(taskConfig, this.deps);
         if (!store) {
             throw new CheckpointError("checkpoint.not_found", "no CheckpointStore wired — cannot resume (set RunnerDeps.checkpointStore or taskConfig.checkpointStore)");
@@ -3299,7 +3418,10 @@ export class Runner {
             }
         }
         let wakeMessage;
-        if (outcome.gate === "wake") {
+        const outcomeGate = outcome.gate;
+        let suppliedMessage;
+        if (outcomeGate === "wake") {
+            suppliedMessage = outcome.message;
             const gk = cp.gate.kind;
             const decideEntry = gk === "human" || gk === "irreversible_ask"
                 ? 'a `policy_ask` outcome (decision allow/deny bound to the pending tool call)'
@@ -3332,56 +3454,147 @@ export class Runner {
                         `(newer-version row?) — fail-closed: wake only serves a pure park (pendingAction "task_done")`);
                 }
             }
-            if (outcome.message !== undefined) {
-                wakeMessage = validatePendingSteer(outcome.message);
+            if (suppliedMessage !== undefined) {
+                wakeMessage = validatePendingSteer(suppliedMessage);
             }
-            else if (cp.state.pendingSteer === undefined) {
+            else if (readPendingSteerQueue(cp.state).length === 0) {
                 throw new CheckpointError("wake.nothing_to_deliver", "cannot wake: no message was supplied and the checkpoint holds no parked pendingSteer — an empty " +
                     "wake would burn the checkpoint on a blank continuation; supply `message` or park a steer first");
             }
         }
-        const gateMatch = outcome.gate === "wake" ||
-            (cp.gate.kind === "human" && outcome.gate === "policy_ask") ||
-            (cp.gate.kind === "irreversible_ask" && outcome.gate === "policy_ask") ||
-            (cp.gate.kind === "resource_limit" && outcome.gate === "resource_limit") ||
-            (cp.gate.kind === "needs_review" && outcome.gate === "dry_run_review") ||
-            (cp.gate.kind === "plan_review" && outcome.gate === "plan_review");
+        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");
         if (!gateMatch) {
-            throw new CheckpointError("checkpoint.gate_mismatch", `resume outcome (gate "${outcome.gate}") 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`);
-        }
-        const reasonBearing = (outcome.gate === "policy_ask" && outcome.decision === "deny") ||
-            (outcome.gate === "dry_run_review" && outcome.decision === "reject") ||
-            (outcome.gate === "plan_review" && outcome.decision === "reject");
-        if (reasonBearing && outcome.reason && sanitizeUntrustedText(outcome.reason) !== outcome.reason) {
-            throw new CheckpointError("checkpoint.invalid_outcome", "resume deny/reject reason must not contain a </system-reminder> tag");
+            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`);
+        }
+        let plainReviewOutcome;
+        if (cp.gate.kind === "plan_review") {
+            const decide = outcome;
+            const decision = decide.decision;
+            const editedPlan = decide.editedPlan;
+            const reason = decide.reason;
+            if (decision !== "approve" && decision !== "edit" && decision !== "reject") {
+                throw new CheckpointError("checkpoint.invalid_outcome", `resume decision "${describeSuppliedValue(decision)}" is outside the plan_review domain — a plan review is exactly "approve", "edit" or "reject"; refusing pre-CAS, the checkpoint stays pending`);
+            }
+            assertReviewText(editedPlan, "editedPlan");
+            assertReviewText(reason, "reason");
+            plainReviewOutcome = {
+                gate: "plan_review",
+                decision,
+                ...(editedPlan !== undefined ? { editedPlan } : {}),
+                ...(reason !== undefined ? { reason } : {}),
+            };
         }
-        if (outcome.gate === "plan_review" &&
-            outcome.decision === "edit" &&
-            outcome.editedPlan &&
-            sanitizeUntrustedText(outcome.editedPlan) !== outcome.editedPlan) {
-            throw new CheckpointError("checkpoint.invalid_outcome", "resume editedPlan must not contain a </system-reminder> tag");
+        else if (cp.gate.kind === "needs_review") {
+            const decide = outcome;
+            const decision = decide.decision;
+            const reason = decide.reason;
+            if (decision !== "approve" && decision !== "reject") {
+                throw new CheckpointError("checkpoint.invalid_outcome", `resume decision "${describeSuppliedValue(decision)}" is outside the dry_run_review domain — a dry-run review is exactly "approve" or "reject"; refusing pre-CAS, the checkpoint stays pending`);
+            }
+            assertReviewText(reason, "reason");
+            plainReviewOutcome = {
+                gate: "dry_run_review",
+                decision,
+                ...(reason !== undefined ? { reason } : {}),
+            };
         }
-        if ((outcome.gate === "plan_review" || outcome.gate === "dry_run_review") && cp.reopenReason === "env_failed") {
-            const winner = cp.resolvedOutcome;
-            if (winner === undefined) {
-                throw new CheckpointError("checkpoint.reopen_revote", "review checkpoint was reopened after an env-restore failure (env_failed) but carries no persisted winner to replay — refusing to resume (inconsistent row, fail-closed)");
+        if (plainReviewOutcome !== undefined) {
+            const reason = plainReviewOutcome.reason;
+            if (plainReviewOutcome.decision === "reject" && reason && sanitizeUntrustedText(reason) !== reason) {
+                throw new CheckpointError("checkpoint.invalid_outcome", "resume deny/reject reason must not contain a </system-reminder> tag");
+            }
+            const capturedPlan = plainReviewOutcome.gate === "plan_review" ? plainReviewOutcome.editedPlan : undefined;
+            if (plainReviewOutcome.decision === "edit" &&
+                capturedPlan &&
+                sanitizeUntrustedText(capturedPlan) !== capturedPlan) {
+                throw new CheckpointError("checkpoint.invalid_outcome", "resume editedPlan must not contain a </system-reminder> tag");
+            }
+            if (cp.reopenReason === "env_failed") {
+                const winner = cp.resolvedOutcome;
+                if (winner === undefined) {
+                    throw new CheckpointError("checkpoint.reopen_revote", "review checkpoint was reopened after an env-restore failure (env_failed) but carries no persisted winner to replay — refusing to resume (inconsistent row, fail-closed)");
+                }
+                if (winner.decision !== plainReviewOutcome.decision) {
+                    throw new CheckpointError("checkpoint.reopen_revote", `an env_failed reopen replays the ALREADY-RECORDED review decision ("${winner.decision}") — refusing a re-vote with a different decision ("${plainReviewOutcome.decision}")`);
+                }
+                if (winner.updatedInput !== capturedPlan) {
+                    throw new CheckpointError("checkpoint.reopen_revote", "an env_failed reopen replays the ALREADY-RECORDED review decision — refusing a re-vote whose edited plan differs from the recorded one");
+                }
             }
-            if (winner.decision !== outcome.decision) {
-                throw new CheckpointError("checkpoint.reopen_revote", `an env_failed reopen replays the ALREADY-RECORDED review decision ("${winner.decision}") — refusing a re-vote with a different decision ("${outcome.decision}")`);
+        }
+        let plainParkOutcome;
+        if (outcomeGate === "wake") {
+            plainParkOutcome = {
+                gate: "wake",
+                ...(wakeMessage !== undefined ? { message: wakeMessage } : {}),
+            };
+        }
+        else if (outcomeGate === "resource_limit") {
+            const decision = outcome.decision;
+            if (decision !== "continue") {
+                throw new CheckpointError("checkpoint.invalid_outcome", `resume decision "${describeSuppliedValue(decision)}" is outside the resource_limit domain — a slice resume is exactly "continue"; refusing pre-CAS, the checkpoint stays pending`);
+            }
+            plainParkOutcome = { gate: "resource_limit", decision };
+        }
+        let suppliedAnswer;
+        let redeemedAnswer;
+        let plainPolicyOutcome;
+        if (cp.gate.kind === "human" || cp.gate.kind === "irreversible_ask") {
+            const decide = outcome;
+            suppliedAnswer = decide.answer;
+            if (suppliedAnswer !== undefined) {
+                const reading = classifyQuestionOutcome(suppliedAnswer);
+                if (reading.shape !== "answered") {
+                    throw new CheckpointError("checkpoint.invalid_outcome", "resume carried a content-ask `answer` that does not read as an answer (malformed, sparse, or not capturable as plain data) — " +
+                        "refusing pre-CAS rather than fabricating an empty human response; the checkpoint stays pending", { field: "answer" });
+                }
+                redeemedAnswer = reading.answer;
+            }
+            const updatedInputRaw = decide.updatedInput;
+            let updatedInput;
+            try {
+                updatedInput = updatedInputRaw === undefined ? undefined : structuredClone(updatedInputRaw);
             }
-            const replayedPlan = outcome.gate === "plan_review" ? outcome.editedPlan : undefined;
-            if (winner.updatedInput !== replayedPlan) {
-                throw new CheckpointError("checkpoint.reopen_revote", "an env_failed reopen replays the ALREADY-RECORDED review decision — refusing a re-vote whose edited plan differs from the recorded one");
+            catch {
+                throw new CheckpointError("checkpoint.invalid_outcome", "resume carried an `updatedInput` that could not be captured as plain data — refusing pre-CAS; the checkpoint stays pending");
+            }
+            if (Object.is(updatedInput, -0))
+                updatedInput = 0;
+            if (updatedInput !== undefined && !canonicalizeCapturedPlainData(updatedInput)) {
+                throw new CheckpointError("checkpoint.invalid_outcome", "resume carried an `updatedInput` outside the plain-JSON value domain (a Map/Set/Date/buffer, a sparse or expando-carrying array, a non-finite number, or a cycle) — " +
+                    "such a value reads differently on the two sides of the durable store; refusing pre-CAS, the checkpoint stays pending");
+            }
+            const decision = decide.decision;
+            if (decision !== "allow" && decision !== "deny") {
+                throw new CheckpointError("checkpoint.invalid_outcome", `resume decision "${String(decision)}" is outside the policy_ask domain — a decide is exactly "allow" or "deny"; refusing pre-CAS, the checkpoint stays pending`);
+            }
+            const reason = decide.reason;
+            plainPolicyOutcome = {
+                gate: "policy_ask",
+                boundCallId: decide.boundCallId,
+                boundInputHash: decide.boundInputHash,
+                decision,
+                ...(updatedInput !== undefined ? { updatedInput } : {}),
+                ...(reason !== undefined ? { reason } : {}),
+                ...(redeemedAnswer !== undefined ? { answer: redeemedAnswer } : {}),
+            };
+            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");
             }
         }
-        if (outcome.gate === "policy_ask") {
+        if (plainPolicyOutcome !== undefined) {
             const boundTo = cp.pendingAction.kind === "tool_approval" ? cp.pendingAction.toolCallId : undefined;
-            if (outcome.boundCallId !== boundTo) {
-                throw new CheckpointError("checkpoint.invalid_outcome", `resume boundCallId "${outcome.boundCallId}" does not match the checkpoint's pending tool call "${boundTo ?? "(none)"}" — the decision-action binding (design/80 D-1) failed; refusing to apply a decision bound to a different action`, { field: "boundCallId" });
+            if (plainPolicyOutcome.boundCallId !== boundTo) {
+                throw new CheckpointError("checkpoint.invalid_outcome", `resume boundCallId "${plainPolicyOutcome.boundCallId}" does not match the checkpoint's pending tool call "${boundTo ?? "(none)"}" — the decision-action binding (design/80 D-1) failed; refusing to apply a decision bound to a different action`, { field: "boundCallId" });
             }
             const boundHash = cp.pendingAction.kind === "tool_approval" ? cp.pendingAction.boundInputHash : undefined;
             if (boundHash !== undefined) {
-                if (outcome.boundInputHash !== boundHash) {
+                if (plainPolicyOutcome.boundInputHash !== boundHash) {
                     throw new CheckpointError("checkpoint.invalid_outcome", "resume boundInputHash does not match the checkpoint's pending tool call input — the decision-action input binding (design/80 D-1 §2) failed; refusing to apply an approval bound to a different input (TOCTOU re-mint guard)", { field: "boundInputHash" });
                 }
             }
@@ -3392,20 +3605,26 @@ export class Runner {
                 if (cp.resolvedOutcome === undefined) {
                     throw new CheckpointError("checkpoint.reopen_revote", "checkpoint was reopened after an env-restore failure (env_failed) but carries no persisted winner to replay — refusing to resume (inconsistent row, fail-closed)");
                 }
-                const incoming = winnerFromOutcome(outcome);
-                if (incoming === undefined || !sameWinner(incoming, cp.resolvedOutcome)) {
+                const incoming = winnerFromOutcome(plainPolicyOutcome);
+                const persistedWinner = (() => {
+                    const w = cp.resolvedOutcome;
+                    if (w?.answer === undefined)
+                        return w;
+                    const reading = classifyQuestionOutcome(w.answer);
+                    return reading.shape === "answered" ? { ...w, answer: reading.answer } : w;
+                })();
+                if (incoming === undefined || !sameWinner(incoming, persistedWinner)) {
                     throw new CheckpointError("checkpoint.reopen_revote", `this checkpoint was reopened after an env-restore failure (env_failed) — a re-resume is a system retry of the already-approved action, not a re-vote; the supplied decision must replay the persisted winner (boundCallId "${cp.resolvedOutcome.boundCallId}", decision "${cp.resolvedOutcome.decision}"), refusing a different decision`);
                 }
             }
             const contentAskCallId = pendingContentAskCallId(cp);
-            if (outcome.answer !== undefined && (contentAskCallId === undefined || outcome.decision !== "allow")) {
+            if (suppliedAnswer !== undefined && (contentAskCallId === undefined || plainPolicyOutcome.decision !== "allow")) {
                 throw new CheckpointError("checkpoint.invalid_outcome", contentAskCallId === undefined
                     ? "resume carried a content-ask `answer` but the checkpoint's pending call is not the reserved question tool — an answer has no consumer on a side-effecting tool's approval; refusing rather than dropping it silently"
                     : "resume carried a content-ask `answer` on a `deny` — a denial injects a refusal, never an answer; refusing rather than dropping it silently", { field: "answer" });
             }
-            if (contentAskCallId !== undefined && outcome.decision === "allow" && outcome.answer === undefined) {
-                const liveFace = taskConfig.onQuestion ?? this.deps.onQuestion;
-                if (liveFace === undefined || liveFace === QUESTION_AWAITS_RESUME) {
+            if (contentAskCallId !== undefined && plainPolicyOutcome.decision === "allow" && suppliedAnswer === undefined) {
+                if (!isLiveQuestionFace(taskConfig.onQuestion ?? this.deps.onQuestion)) {
                     throw new CheckpointError("checkpoint.invalid_outcome", "resume approved a content-ask (the reserved question tool) without an `answer`, and this resume has no live answering face — " +
                         'executing the question against nothing would hand the model a fabricated "no human is available" default while consuming the approval; ' +
                         "re-resume with the operator's answer on the outcome (or deny it), the checkpoint stays pending", { field: "answer" });
@@ -3442,7 +3661,11 @@ export class Runner {
                     "rejected pre-CAS (the checkpoint stays pending) — re-resume with the full original chain");
             }
         }
-        const won = await store.resolve(token, cp.scope, outcome, { rev: cp.rev ?? 0 });
+        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`);
+        }
+        const won = await store.resolve(token, cp.scope, outcomeForStore, { rev: cp.rev ?? 0 });
         if (!won) {
             const live = await store.get(token);
             if (live?.status === "pending") {
@@ -3456,8 +3679,8 @@ export class Runner {
             await internals.afterCheckpointResolve();
             consumeFlipDone = true;
         }
-        const answerFace = outcome.gate === "policy_ask" && outcome.answer !== undefined
-            ? answerFaceForRedeemedCall(outcome.answer, outcome.boundCallId, taskConfig.onQuestion ?? this.deps.onQuestion)
+        const answerFace = plainPolicyOutcome !== undefined && redeemedAnswer !== undefined
+            ? answerFaceForRedeemedCall(redeemedAnswer, plainPolicyOutcome.boundCallId, taskConfig.onQuestion ?? this.deps.onQuestion, boundInputHashOf(cp.pendingAction.args?.questions))
             : undefined;
         const spec = {
             ...taskConfig,
@@ -3496,7 +3719,7 @@ export class Runner {
                     ? new CheckpointError("checkpoint.reopen_failed", "the resume was aborted before the approved action could run AND the store refused to reopen the checkpoint — the approval is terminally consumed and the suspended work was not executed; a retry needs a fresh approval")
                     : new CheckpointError("checkpoint.reopen_failed", "the resume was aborted before the approved action could run and the reopen attempt FAILED IN FLIGHT — the checkpoint's state is unprovable from here: it may already be pending again. Re-read it before deciding; do NOT issue a fresh approval on the assumption the old one is dead (the approved action did NOT run either way)");
         }
-        return this.runTaskStream(spec, { cp, outcome, onEnvRestoreFailed, ...(wakeMessage !== undefined ? { wakeMessage } : {}) }, internals);
+        return this.runTaskStream(spec, { cp, outcome: outcomeForStore, onEnvRestoreFailed, ...(wakeMessage !== undefined ? { wakeMessage } : {}) }, internals);
     }
     async applyResumeDecision(prepared, resume, emit, emitCommitted, onResolvedToolSuccess, onExecuteStart) {
         const { pendingAction } = resume.cp;
@@ -3552,7 +3775,7 @@ export class Runner {
         const { outcome } = resume;
         if (pendingAction.kind !== "tool_approval" || outcome.gate !== "policy_ask")
             return;
-        const resolvedArgs = pendingAction.toolName === ASK_USER_QUESTION_TOOL_NAME ? pendingAction.args : (outcome.updatedInput ?? pendingAction.args);
+        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) });
@@ -3563,6 +3786,9 @@ export class Runner {
             emitCommitted(eid, "toolResult", pendingAction.toolCallId);
             return;
         }
+        if (outcome.decision !== "allow") {
+            throw new CheckpointError("checkpoint.invalid_outcome", `pending action reached the resolver with decision "${String(outcome.decision)}" — only "allow" executes and only "deny" injects a denial; refusing to execute`);
+        }
         if (outcome.decision === "allow" && outcome.updatedInput !== undefined && prepared.basePolicyForResumeEdit) {
             const rechecked = refuseOutOfContractDecision(await prepared.basePolicyForResumeEdit.check({ toolName: pendingAction.toolName, args: resolvedArgs, toolCallId: pendingAction.toolCallId }, prepared.abortController.signal));
             if (rechecked.action === "deny") {