@sema-agent/core 5.12.0 → 5.14.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")
@@ -1166,6 +1193,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 +1360,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 +1415,7 @@ export class Runner {
                     publishReady(h);
                 }, (s) => {
                     reapHandle = s;
-                }, manualCompactRef, taskIdRef, resume, { ...(internals ?? {}), detachHub }, notifyRef);
+                }, manualCompactRef, taskIdRef, resume, { ...(internals ?? {}), detachHub }, notifyRef, entryActor);
             }
             finally {
                 releaseLock?.();
@@ -1450,6 +1479,12 @@ export class Runner {
                 errorMessage: err instanceof Error ? err.message : String(err),
                 errorCode: code,
                 ...(remoteEnvFailure !== undefined ? { remoteEnvFailures: remoteEnvFailure } : {}),
+                ...(() => {
+                    const hinted = err.retryAfterMs;
+                    return code === "memory.admission_required" && typeof hinted === "number" && Number.isFinite(hinted) && hinted > 0
+                        ? { retryAfterMs: hinted }
+                        : {};
+                })(),
                 stats: { turns: 0, tokens: 0, toolCalls: 0, cachedTokens: 0, costMicroUsd: 0 },
             };
             emitTrace(spec.tracer ?? this.deps.tracer, () => ({
@@ -1517,7 +1552,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");
@@ -1525,7 +1582,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) {
@@ -1535,7 +1593,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) {
@@ -1652,7 +1711,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,
@@ -1665,6 +1724,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();
@@ -1703,9 +1768,7 @@ export class Runner {
             queue.push({ type: "task_notification", notification: item.payload, ...notificationIdent() });
             if (notificationHarness) {
                 const xml = renderTaskNotificationXml(item.payload);
-                const deliver = item.priority === "later"
-                    ? notificationHarness.followUp(xml, { provenance: "engine-note", enginePayload: item.payload })
-                    : notificationHarness.steer(xml, { provenance: "engine-note", enginePayload: item.payload });
+                const deliver = notificationHarness.steer(xml, { provenance: "engine-note", enginePayload: item.payload });
                 void deliver.then(() => item.onDisposition?.("queued"), () => {
                     parkTaskNotification(item.payload, item.priority);
                     item.onDisposition?.("parked");
@@ -1755,6 +1818,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() });
         };
@@ -2323,6 +2387,22 @@ export class Runner {
         });
         const stopHook = (spec.hooks ?? this.deps.hooks)?.stop;
         const finalVerificationOn = spec.finalVerification === true;
+        const finalVerifyBudgetFill = () => {
+            let worst = 0;
+            if (rs.budget.maxTokensWindow !== undefined && rs.budget.maxTokensWindow > 0)
+                worst = Math.max(worst, stats.tokens / rs.budget.maxTokensWindow);
+            if (rs.budget.maxCostMicroUsd !== undefined && rs.budget.maxCostMicroUsd > 0)
+                worst = Math.max(worst, stats.costMicroUsd / rs.budget.maxCostMicroUsd);
+            if (walltimeMonotonicDeadline !== undefined && prepared.suspendForResource === undefined) {
+                const windowMs = walltimeMonotonicDeadline - rs.telemetry.taskStartMonotonic;
+                if (windowMs > 0)
+                    worst = Math.max(worst, (performance.now() - rs.telemetry.taskStartMonotonic) / windowMs);
+            }
+            return worst;
+        };
+        const emitFinalVerifyEcho = (body) => {
+            queue.push({ type: "steering_injected", source: "final_verification", preview: body.slice(0, 220), ...ident() });
+        };
         if (stopHook || finalVerificationOn) {
             let consecutiveBlocks = 0;
             prepared.harness.setStopGate(async () => {
@@ -2332,58 +2412,69 @@ export class Runner {
                     (rs.counters.finalVerifyInjections === 0 || (rs.counters.finalVerifyInjections === 1 && rs.counters.groundingSignalPreR9 && !rs.counters.groundingSignalPostR9)) &&
                     rs.counters.wroteThisRun &&
                     prepared.outputRef.set !== true &&
-                    !(rs.limits.effectiveMaxTurns !== undefined && rs.limits.effectiveMaxTurns > 0 && stats.turns >= rs.limits.effectiveMaxTurns - 1)) {
+                    !(rs.limits.effectiveMaxTurns !== undefined && rs.limits.effectiveMaxTurns > 0 && stats.turns >= rs.limits.effectiveMaxTurns - 1) &&
+                    finalVerifyBudgetFill() < 0.9) {
                     rs.counters.finalVerifyInjections += 1;
                     if (rs.counters.finalVerifyInjections === 2) {
+                        const reentryBody = "<system-reminder>[final verification] Your tool calls in this run worked with raw bytes, structural parsing, " +
+                            "or checksum/digest computation — the deliverable very likely embeds verifiable structure (structural fields, an " +
+                            "embedded checksum-family value, reference data it must match, or a replayable deterministic path). You MUST " +
+                            "execute the grounding check that structure supports — recompute the embedded value and compare it against the " +
+                            "declared one, re-parse the structure from the raw bytes and reconcile it with your output, compare against the " +
+                            "reference data, or replay the deterministic path — and REPORT the check's concrete result before finishing. " +
+                            "A closing statement without a reported check result is not verification. If you already ran such a check, state " +
+                            "its concrete result now; if the check mismatches, fix the deliverable first. This is the final reminder from " +
+                            "this verification gate — it will not intervene again.</system-reminder>";
+                        emitFinalVerifyEcho(reentryBody);
                         return [
                             {
                                 role: "user",
                                 engineMinted: true,
-                                content: "<system-reminder>[final verification] Your tool calls in this run worked with raw bytes, structural parsing, " +
-                                    "or checksum/digest computation — the deliverable very likely embeds verifiable structure (structural fields, an " +
-                                    "embedded checksum-family value, reference data it must match, or a replayable deterministic path). You MUST " +
-                                    "execute the grounding check that structure supports — recompute the embedded value and compare it against the " +
-                                    "declared one, re-parse the structure from the raw bytes and reconcile it with your output, compare against the " +
-                                    "reference data, or replay the deterministic path — and REPORT the check's concrete result before finishing. " +
-                                    "A closing statement without a reported check result is not verification. If you already ran such a check, state " +
-                                    "its concrete result now; if the check mismatches, fix the deliverable first. This is the final reminder from " +
-                                    "this verification gate — it will not intervene again.</system-reminder>",
+                                content: reentryBody,
                                 timestamp: Date.now(),
                             },
                         ];
                     }
+                    const nudgeBody = "<system-reminder>[final verification] Before finishing: re-verify the FINAL deliverable through its REAL entry point, " +
+                        "exactly as the acceptance criteria would exercise it — execute the binary/function/endpoint directly and read the ACTUAL " +
+                        "output and exit code. Do NOT rely on earlier self-tests, shell redirections, or assumptions (a program that prints to " +
+                        "stdout is not a program that writes the required file). If anything mismatches the task's requirements, fix it before " +
+                        "finishing. " +
+                        "Treat verification writes as state-harmless: when the deliverable itself is a persisted final " +
+                        "state (for example a committed or pushed file, a deployed artifact, or a required output file), " +
+                        "do not change that state merely to test it. This constrains HOW you verify — it is never a " +
+                        "license to skip the real acceptance path or to check a substitute of your own making: expected " +
+                        "values must come from the task's requirements, never from content you generated. If the real " +
+                        "acceptance path requires a write, use disposable inputs or an isolated target, end in the exact " +
+                        "required final state, and verify that final state before finishing. " +
+                        "If the work relied on a third-party API, library, or model, check the usage contract the object itself declares " +
+                        "(docstrings, metadata, configuration — e.g. prompt conventions shipped with a model) and confirm your calls follow " +
+                        "it rather than a default symmetric usage. Verify not only that the deliverable EXISTS but that the METHOD that " +
+                        "produced it matches the task's requirements. " +
+                        "Choose the verification SURFACE deliberately: check against the reference data, oracle, or evaluation tooling the " +
+                        "task itself provides — re-running your own implementation and getting the same answer is self-consistency, not " +
+                        "correctness — and cross-check through an independent second path where the task or environment offers one " +
+                        "(checksums, runtime artifacts). Verify the PERSISTED artifact — re-read what is actually on disk or committed, " +
+                        "not in-memory state — against every hard constraint from the original task text (numeric bounds, allowed-value " +
+                        "lists, naming semantics, required files), reconciling whole-set completeness: nothing missing, nothing duplicated. " +
+                        "If the deliverable embeds verifiable structure — structural fields, an embedded checksum-family value, " +
+                        "reference data it must match, or a replayable deterministic path — you MUST execute the grounding check " +
+                        "that structure supports and REPORT its concrete result in your closing summary: for such a deliverable, " +
+                        "no reported check result means the work is not finished. " +
+                        "If the task produced neither an executable deliverable nor any verifiable structure or acceptance " +
+                        "oracle to check against, briefly confirm completion and stop. " +
+                        "Residue YOUR OWN testing created (scratch files, running processes, generated outputs the task does not ask for) " +
+                        "is not protected state — if the task's required final state is a clean target, removing your own residue is part " +
+                        "of delivering it. " +
+                        "Verification must never LAUNDER uncertainty: if part of your conclusion was uncertain before this check, keep " +
+                        "reporting it as uncertain unless the check you actually ran resolved it — a re-stated conclusion is not new " +
+                        "evidence.</system-reminder>";
+                    emitFinalVerifyEcho(nudgeBody);
                     return [
                         {
                             role: "user",
                             engineMinted: true,
-                            content: "<system-reminder>[final verification] Before finishing: re-verify the FINAL deliverable through its REAL entry point, " +
-                                "exactly as the acceptance criteria would exercise it — execute the binary/function/endpoint directly and read the ACTUAL " +
-                                "output and exit code. Do NOT rely on earlier self-tests, shell redirections, or assumptions (a program that prints to " +
-                                "stdout is not a program that writes the required file). If anything mismatches the task's requirements, fix it before " +
-                                "finishing. " +
-                                "Treat verification writes as state-harmless: when the deliverable itself is a persisted final " +
-                                "state (for example a committed or pushed file, a deployed artifact, or a required output file), " +
-                                "do not change that state merely to test it. This constrains HOW you verify — it is never a " +
-                                "license to skip the real acceptance path or to check a substitute of your own making: expected " +
-                                "values must come from the task's requirements, never from content you generated. If the real " +
-                                "acceptance path requires a write, use disposable inputs or an isolated target, end in the exact " +
-                                "required final state, and verify that final state before finishing. " +
-                                "If the work relied on a third-party API, library, or model, check the usage contract the object itself declares " +
-                                "(docstrings, metadata, configuration — e.g. prompt conventions shipped with a model) and confirm your calls follow " +
-                                "it rather than a default symmetric usage. Verify not only that the deliverable EXISTS but that the METHOD that " +
-                                "produced it matches the task's requirements. " +
-                                "Choose the verification SURFACE deliberately: check against the reference data, oracle, or evaluation tooling the " +
-                                "task itself provides — re-running your own implementation and getting the same answer is self-consistency, not " +
-                                "correctness — and cross-check through an independent second path where the task or environment offers one " +
-                                "(checksums, runtime artifacts). Verify the PERSISTED artifact — re-read what is actually on disk or committed, " +
-                                "not in-memory state — against every hard constraint from the original task text (numeric bounds, allowed-value " +
-                                "lists, naming semantics, required files), reconciling whole-set completeness: nothing missing, nothing duplicated. " +
-                                "If the deliverable embeds verifiable structure — structural fields, an embedded checksum-family value, " +
-                                "reference data it must match, or a replayable deterministic path — you MUST execute the grounding check " +
-                                "that structure supports and REPORT its concrete result in your closing summary: for such a deliverable, " +
-                                "no reported check result means the work is not finished. " +
-                                "If the task produced neither an executable deliverable nor any verifiable structure or acceptance " +
-                                "oracle to check against, briefly confirm completion and stop.</system-reminder>",
+                            content: nudgeBody,
                             timestamp: Date.now(),
                         },
                     ];
@@ -2564,6 +2655,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");
@@ -2616,15 +2708,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;
@@ -2632,7 +2740,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) {
@@ -2643,7 +2753,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) {
@@ -2744,10 +2854,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 } : {}),
                     }));
                 }
             }
@@ -2770,6 +2893,7 @@ export class Runner {
             prepared.lspDiagnostics?.registry.releaseRun(prepared.lspDiagnostics.runIdent);
             prepared.abortController.abort();
             prepared.releaseSignal();
+            strandedHumanAnswers = prepared.settleContentAskBindings();
             try {
                 prepared.harness.recoverUndrainedEngineNotes();
             }
@@ -2908,6 +3032,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,
@@ -3044,6 +3169,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 },
@@ -3304,7 +3430,7 @@ export class Runner {
             if (outcome.message !== undefined) {
                 wakeMessage = validatePendingSteer(outcome.message);
             }
-            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");
             }
@@ -3318,8 +3444,7 @@ export class Runner {
         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") ||
+        const reasonBearing = (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");
@@ -3343,14 +3468,60 @@ export class Runner {
                 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 (outcome.gate === "policy_ask") {
+        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);
+            }
+            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 (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" });
                 }
             }
@@ -3361,20 +3532,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" });
@@ -3411,7 +3588,8 @@ 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 ?? outcome;
+        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") {
@@ -3425,8 +3603,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,
@@ -3465,7 +3643,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: plainPolicyOutcome ?? outcome, onEnvRestoreFailed, ...(wakeMessage !== undefined ? { wakeMessage } : {}) }, internals);
     }
     async applyResumeDecision(prepared, resume, emit, emitCommitted, onResolvedToolSuccess, onExecuteStart) {
         const { pendingAction } = resume.cp;
@@ -3521,7 +3699,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) });
@@ -3532,6 +3710,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") {

package/dist/core/runner/tool-output-projection.js

@@ -57,6 +57,7 @@ export const toolOutputFrom = (result) => {
     return { output: raw, truncated: true, totalChars };
 };
 const CC_DETAIL_TYPES = new Set([
+    "ask-question",
     "edit", "create", "update", "bash", "notebook-edit", "notebook", "file_unchanged", "worktree", "text", "grep", "glob", "mcp",
     "agent", "task", "task-list", "task-output", "workflow-run",
     "web-fetch", "web-search", "todo", "cron-create", "cron-delete", "cron-list", "image",