@sema-agent/core 7.11.2 → 7.12.0

package/dist/core/runner/run-identity-wiring.js

@@ -3,7 +3,7 @@ import { createSafeNotifier } from "../safe-notify.js";
 import { discloseDroppedPending, renderTaskNotificationXml, taskNotificationDedupKey } from "../task-notification.js";
 import { deliverDelegationLifecycle, deliverEngineNotice, undrainedUserInputNotices } from "../types.js";
 export function runIdentityWiring(input) {
-    const { spec, queue, prepared, internals, taskIdRef, onReady, manualCompactRef, notifyRef, captureOptOutRef, injectTaskNotification, deliveredAtTurnOpen, peerInboundChainRef, notificationLane, undrainedUserAtEnd, pendingSessionNotifications, runner } = input;
+    const { spec, queue, prepared, internals, taskIdRef, onReady, manualCompactRef, notifyRef, captureOptOutRef, injectTaskNotification, deliveredAtTurnOpen, peerInboundChainRef, notificationLane, pendingSessionNotifications, runner } = input;
     notificationLane.harness = prepared.harness;
     notificationLane.sessionId = prepared.sessionId;
     if (taskIdRef)
@@ -40,9 +40,10 @@ export function runIdentityWiring(input) {
             pendingSessionNotifications.pend(notificationLane.sessionId, p);
     };
     prepared.harness.engineInjectionsHeld = () => prepared.batchHaltRef.current !== undefined;
+    let undrainedUserAtEnd;
     prepared.harness.onUndrainedUserInputs = (counts) => {
         if (prepared.pausedRef.current !== undefined) {
-            undrainedUserAtEnd.current = counts;
+            undrainedUserAtEnd = counts;
             return;
         }
         for (const notice of undrainedUserInputNotices(counts, spec.taskId ?? prepared.sessionId, prepared.sessionId, prepared.runId)) {
@@ -80,5 +81,5 @@ export function runIdentityWiring(input) {
     const loopLatch = { ended: false, userInterrupted: false, userHalted: false };
     onReady({ harness: prepared.harness, abortController: prepared.abortController, loop: loopLatch, reminderMark: prepared.reminderMark, sessionId: prepared.sessionId, runId: prepared.runId, hookTimeoutMs: prepared.hookTimeoutMs, hookIdentity: prepared.hookIdentity });
     const stats = { turns: 0, tokens: 0, toolCalls: 0, promptTokens: 0, totalInputTokens: 0, cachedTokens: 0, cacheWriteTokens: 0, cacheWriteTokensLong: 0, outputTokens: 0, costMicroUsd: 0 };
-    return { runSourceTaskId, parentToolCallId, ident, emitDelegationLifecycle, loopLatch, stats };
+    return { runSourceTaskId, parentToolCallId, ident, emitDelegationLifecycle, loopLatch, stats, undrainedUserAtEnd: { get current() { return undrainedUserAtEnd; } } };
 }

package/dist/core/runner/run-leg.d.ts

@@ -0,0 +1,106 @@
+/**
+ * design/393 S6 — the run body's LEG (R13), verbatim from `Runner.runLocked`: the one `harness.prompt` of the leg and
+ * everything that decides whether it is issued. Two legs behind one try / catch / finally: the RESUME leg (the walltime
+ * and governance-window entrance claims, the gated decision's application, the exhaustion arms, the continuation prompt's
+ * assembly — orphaned background tasks, the git frame, the parked steer queue and the wake message each under its own trust
+ * framing and redelivery screen — and the prompt itself) and the OBJECTIVE leg (the UserPromptSubmit screen, the git
+ * frame's primary delivery, the first-frame listings, the pre-call budget / token / entry-governance gates, the image
+ * conversion, the objective's human-input frame and the prompt itself). The tail captures the abort facts; the catch
+ * re-throws the resume-equivalent env failures after a bounded teardown and adopts everything else as the leg's throw;
+ * the finally releases the timer, the diagnostics, the signal, the content-ask bindings, flips the notification lane
+ * and releases the four subscriptions in their order.
+ *
+ * Async (twenty first-level awaits, the same awaits at the same positions). It ends by entering the terminal adoption
+ * (`next`) in its LAST continuation — the adoption's first read sits on the tick the finally ran on, as it did in the
+ * one-function body — and returns what it returns. The two legs stay ONE function on purpose: splitting them into two
+ * async functions (the design's "internal split") costs a microtask on the leg → tail edge, and the tail's first reads
+ * there — `abortController.signal.aborted`, `loopLatch.userInterrupted` — are host-mutable attribution facts a late read
+ * would mis-sign (the adversarial r2 HIGH-1 finding recorded on them); the forwarded-frame depth ratchet measured the
+ * extra hop (58 → 59) when the split was tried.
+ */
+import type { AssistantMessage } from "../../internal/llm.js";
+import { type ActorAssertion } from "../checkpoint-store.js";
+import type { PushQueue } from "../push-queue.js";
+import { type TaskEvent, type TaskSpec } from "../types.js";
+import { type WriteFamily } from "./turn-attachments.js";
+import type { NotificationLaneBindings, Prepared, ResumeRun, RunnerDepsSeat, RunState } from "./contracts.js";
+export interface RunLegInput<R> {
+    /** borrowed-readonly — the task spec: the objective, the images, the hooks slot, the principal, the task id. */
+    spec: TaskSpec;
+    /** borrowed-mutable — the run's event queue: the human-input frames, the git echo frames, the listing echo frames. */
+    queue: PushQueue<TaskEvent>;
+    /** borrowed-mutable — the leg's prepared seat: the harness is prompted, the blocked / git / listing refs written, the abort controller aborted and the signal released in the finally. */
+    prepared: Prepared;
+    /** borrowed-readonly — the resume plan when this leg resumes a checkpoint: chooses the resume leg; its delivery bits are written. */
+    resume: ResumeRun | undefined;
+    /** borrowed-mutable — the run's mutable state: the limit flags and the platform terminal are written by the entrance gates. */
+    rs: RunState;
+    /** borrowed-readonly — the API-boundary attribution snapshot of the objective's actor (the objective leg's speaker envelope). */
+    entryActor: ActorAssertion | undefined;
+    /** borrowed-readonly — the effective walltime window (undefined = unbounded): `<= 0` refuses the first turn. */
+    effectiveTimeoutMs: number | undefined;
+    /** borrowed-mutable — the hard walltime timer: claimed (`fired`) and cleared by the exhausted arms and the finally. */
+    timeout: {
+        fired: boolean;
+        clear: () => void;
+    };
+    /** borrowed-readonly — the content push (the resumed batch's frames ride it with the leg's identity). */
+    pushContent: (e: TaskEvent) => void;
+    /** borrowed-readonly — the run's event-identity mint. */
+    ident: () => {
+        eventId: string;
+        parentToolCallId?: string;
+        sourceTaskId?: string;
+    };
+    /** borrowed-readonly — the `message_committed` mint (the resumed batch's re-applied tool results). */
+    emitCommitted: (entryId: string, role: "user" | "assistant" | "toolResult", toolCallId?: string) => void;
+    /** borrowed-readonly — the write-family resolver (the resume-executed gated write's attachment anchor). */
+    writeFamilyOf: (name: string) => WriteFamily | undefined;
+    /** borrowed-mutable — the observed tool-start ids: the resume-executed gated call registers itself here. */
+    startedToolCallIds: Set<string>;
+    /** borrowed-readonly — the harness-handlers lane's workspace-move announcer (the approved `cd`'s frame). */
+    announceWorkspaceMove: () => void;
+    /** borrowed-readonly — the brain-sinks composition the leg's prompt runs under. */
+    withBrainSinks: <T>(fn: () => Promise<T>) => Promise<T>;
+    /** borrowed-readonly — the git lane's parked-mirror flush, settled after the prompt (single-turn legs reach no boundary). */
+    flushGitMirror: () => Promise<void>;
+    /** borrowed-mutable — the loop-liveness latch: `ended` flips when the prompt settles (or a no-prompt / throw arm is taken); `userInterrupted` is snapshotted. */
+    loopLatch: {
+        ended: boolean;
+        readonly userInterrupted: boolean;
+    };
+    /** borrowed-mutable — the notification lane's bindings seat: `live` flips false in the finally (every later notification parks). */
+    notificationLane: NotificationLaneBindings;
+    /** borrowed-readonly — the notification lane's subscription release, called in the finally right after the flip. */
+    unsubscribeTaskNotifications: () => void;
+    /** borrowed-readonly — the git lane's owed-frame retry release, called in the finally first of the three. */
+    unsubGitRetry: () => void;
+    /** borrowed-readonly — the git lane's boundary-handler release, called second. */
+    unsubBoundary: () => void;
+    /** borrowed-readonly — the git lane's harness-event release, called third. */
+    unsub: () => void;
+    /** borrowed-readonly — the Runner's deployment deps, read LIVE (`onError`, `hooks`, `onNotice`, `allowImageUrl`); the one home of
+     *  why it is a seat and not a captured object is {@link RunnerDepsSeat}. */
+    runner: RunnerDepsSeat;
+    /** borrowed-readonly — the Runner's application of the resumed decision (its private method, as a delegate). */
+    applyResumeDecision: (prepared: Prepared, resume: ResumeRun, emit: (e: TaskEvent) => void, emitCommitted: (entryId: string, role: "user" | "assistant" | "toolResult", toolCallId?: string) => void, onResolvedToolSuccess?: (toolName: string, details: unknown) => void, onExecuteStart?: (toolCallId: string) => void) => Promise<void>;
+    /** borrowed-readonly — the terminal adoption, entered in this lane's last continuation with the leg's facts. */
+    next: (leg: RunLegResult) => Promise<R>;
+}
+/** The leg's facts — what the terminal adoption and the settle read. */
+export interface RunLegResult {
+    /** The final assistant message; undefined on every no-prompt arm (blocked, refused, exhausted). */
+    final: AssistantMessage | undefined;
+    /** What the leg threw (undefined on a clean end); the terminal adoption may lift a typed cause over it. */
+    threw: unknown;
+    /** The live-abort flag, captured before the finally's unconditional release-abort. */
+    abortedLive: boolean;
+    /** The snapshot of `loopLatch.userInterrupted`, taken with `abortedLive`. */
+    userInterruptedLive: boolean;
+    /** design/174: the answered-but-never-collected deliveries the finally settled. */
+    strandedHumanAnswers: ReadonlyArray<{
+        deliveryId: string;
+        toolCallId: string;
+    }>;
+}
+export declare function runLeg<R>(input: RunLegInput<R>): Promise<R>;

package/dist/core/runner/run-leg.js

@@ -0,0 +1,462 @@
+import { snapshotActorAssertion } from "../../internal/llm.js";
+import { redactThenCut } from "../../agents/subagent-steps.js";
+import { readPendingSteerQueue } from "../checkpoint-store.js";
+import { formatHookFeedback, hookSeatExpiredError, runHookSeat } from "../hooks.js";
+import { buildHumanInputEvent, projectHumanInput } from "../human-input-projection.js";
+import { computeCostMicroUsd } from "../pricing.js";
+import { mintSystemReminder } from "../reminder-mint.js";
+import { hasDestroy } from "../remote-env.js";
+import { deliverEngineNotice } from "../types.js";
+import { delimitUntrusted, inlineUntrusted, sanitizeUntrustedText } from "../untrusted-text.js";
+import { errorCodeOf } from "./assemble-result.js";
+import { DEFAULT_PRECALL_OUTPUT_TOKENS, platformLimitTerminal } from "./clock-and-limits.js";
+import { resumeContinuation } from "./decide-continuation.js";
+import { resolveGitLegDelivery, wrapGitFrame } from "./git-leg-delivery.js";
+import { GIT_STATUS_ECHO_PREVIEW } from "./git-status-frame.js";
+import { toImageContent } from "./image.js";
+import { nextHumanInputSeq } from "./steer-admission.js";
+import { settleTeardownLeg } from "./teardown-bounded.js";
+import { attachmentEnvelopeTags, commitAgentListing, commitSkillsListing, reduceToolEnd, renderAgentListingDelta, renderOrphanedBackgroundTasks, renderSkillsListingDelta, stampWriteAnchor } from "./turn-attachments.js";
+export async function runLeg(input) {
+    const { spec, queue, prepared, resume, rs, entryActor, effectiveTimeoutMs, timeout, pushContent, ident, emitCommitted, writeFamilyOf, startedToolCallIds, announceWorkspaceMove, withBrainSinks, flushGitMirror, loopLatch, notificationLane, unsubscribeTaskNotifications, unsubGitRetry, unsubBoundary, unsub, runner, applyResumeDecision, next } = input;
+    let final;
+    let threw;
+    let abortedLive = false;
+    let userInterruptedLive = false;
+    let strandedHumanAnswers = [];
+    try {
+        if (prepared.abortController.signal.aborted) {
+            const e = new Error("run aborted");
+            e.name = "AbortError";
+            throw e;
+        }
+        if (resume) {
+            const walltimeExhaustedResume = effectiveTimeoutMs !== undefined && effectiveTimeoutMs <= 0;
+            const resumeWindowRetryAfterMs = !walltimeExhaustedResume && prepared.usageGovernance !== undefined ? await prepared.usageGovernance.check(Date.now()) : undefined;
+            if (resumeWindowRetryAfterMs !== undefined) {
+                const owesNothing = resume.outcome.gate === "resource_limit" &&
+                    readPendingSteerQueue(resume.cp.state).length === 0 &&
+                    (resume.cp.state.runningBackgroundTasks?.length ?? 0) === 0;
+                const committed = owesNothing &&
+                    prepared.suspendForPlatformLimit !== undefined &&
+                    (await prepared.suspendForPlatformLimit("usage_window", { costMicroUsd: 0, tokens: 0, turns: 0, walltimeMs: Math.round(performance.now() - rs.telemetry.taskStartMonotonic) }, { resumeAfterMs: resumeWindowRetryAfterMs }));
+                if (committed) {
+                    rs.limits.turnsExceeded = false;
+                    rs.limits.budgetHit = undefined;
+                }
+                else {
+                    const terminal = platformLimitTerminal("usage_window", resumeWindowRetryAfterMs, "resume");
+                    rs.limits.platformTerminal = terminal;
+                    try {
+                        runner.deps.onError?.(terminal, { phase: "config", sessionId: prepared.sessionId });
+                    }
+                    catch {
+                    }
+                }
+            }
+            if (resumeWindowRetryAfterMs === undefined && !walltimeExhaustedResume && resume.outcome.gate !== "wake") {
+                await applyResumeDecision(prepared, resume, (e) => pushContent({ ...e, ...ident() }), emitCommitted, (toolName, details) => {
+                    if (rs.attach.attachState === undefined)
+                        return;
+                    const family = writeFamilyOf(toolName);
+                    if (family !== undefined)
+                        stampWriteAnchor(rs.attach.attachState, family, rs.counters.cadenceTurns);
+                    if (details !== undefined)
+                        reduceToolEnd(rs.attach.attachState, details);
+                }, (toolCallId) => {
+                    startedToolCallIds.add(toolCallId);
+                    if (resume !== undefined && resume.cp.pendingAction.kind === "tool_approval" && toolCallId === resume.cp.pendingAction.toolCallId) {
+                        resume.pendingActionStarted = true;
+                    }
+                });
+                if (resume.outcome.gate === "policy_ask")
+                    resume.decisionDelivered = true;
+                announceWorkspaceMove();
+            }
+            if (resumeWindowRetryAfterMs !== undefined) {
+            }
+            else if (walltimeExhaustedResume) {
+                timeout.fired = true;
+                timeout.clear();
+                void prepared.harness.abort();
+                prepared.abortController.abort();
+            }
+            else if (rs.budget.maxTokensWindow !== undefined && rs.budget.maxTokensWindow <= 0) {
+                rs.limits.budgetHit = "exceeded";
+                rs.limits.budgetAxis = "tokens";
+            }
+            else if (rs.budget.maxCostMicroUsd !== undefined && rs.budget.maxCostMicroUsd <= 0) {
+                rs.limits.budgetHit = "exceeded";
+                rs.limits.budgetAxis = "cost";
+            }
+            else {
+                let continuation = resumeContinuation(resume, prepared.reminderMark);
+                const bgSnapshot = resume.cp.state.runningBackgroundTasks;
+                if (bgSnapshot !== undefined && bgSnapshot.length > 0) {
+                    const alive = new Set(prepared.listBackgroundTasks().map((t) => t.id));
+                    const orphans = bgSnapshot.filter((t) => !alive.has(t.id));
+                    if (orphans.length > 0) {
+                        continuation += "\n\n" + formatHookFeedback(renderOrphanedBackgroundTasks(orphans), prepared.reminderMark);
+                    }
+                }
+                let gitResumeDelivered;
+                {
+                    const gitBody = await resolveGitLegDelivery(prepared, resume.cp.state.gitAnnouncement, (err) => {
+                        try {
+                            runner.deps.onError?.(new Error(`git announcement ladder unreadable (conservative re-announce): ${err.message}`), { phase: "degraded", sessionId: prepared.sessionId });
+                        }
+                        catch {
+                        }
+                    });
+                    const gitFrame = prepared.gitStatusRef.frame;
+                    if (gitBody !== undefined && gitFrame !== undefined) {
+                        const wrappedGit = wrapGitFrame(gitBody, prepared.reminderMark);
+                        continuation += "\n\n" + wrappedGit;
+                        gitResumeDelivered = { kind: gitFrame.kind, hash: gitFrame.hash, wrapped: wrappedGit };
+                        if (gitFrame.kind === "full" && gitFrame.shrunk !== undefined) {
+                            prepared.gitStatusRef.wrappedShrink = { find: wrappedGit, replace: wrapGitFrame(gitFrame.shrunk.body, prepared.reminderMark) };
+                        }
+                    }
+                }
+                const engineSegments = continuation.length > 0 ? [{ start: 0, end: continuation.length }] : [];
+                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) {
+                    if (source === "wake" && resume.wakeMessageHookContext !== undefined) {
+                        const hookStart = continuation.length;
+                        continuation += "\n\n" + formatHookFeedback(resume.wakeMessageHookContext, prepared.reminderMark);
+                        engineSegments.push({ start: hookStart, end: continuation.length });
+                    }
+                    if (source === "steer") {
+                        const parkedScreen = (spec.hooks ?? runner.deps.hooks)?.userPromptSubmit;
+                        if (parkedScreen !== undefined) {
+                            let outcome;
+                            try {
+                                const seat = await runHookSeat("userPromptSubmit", { timeoutMs: prepared.hookTimeoutMs, signal: prepared.abortController.signal, abortEnds: true }, (sig) => parkedScreen(steer.text, {
+                                    identity: prepared.hookIdentity,
+                                    signal: sig,
+                                    source: "parked_redelivery",
+                                    ...(steer.inputId !== undefined ? { inputId: steer.inputId } : {}),
+                                    ...(steer.actor !== undefined ? { actor: snapshotActorAssertion(steer.actor) } : {}),
+                                }));
+                                outcome = seat.expired
+                                    ? { blocked: seat.cause === "timeout" ? `the screen did not answer within its ${prepared.hookTimeoutMs}ms bound (fail-closed)` : "the run was cancelled while the screen was still deciding (fail-closed)" }
+                                    : seat.value?.block !== undefined && seat.value.block !== ""
+                                        ? { blocked: inlineUntrusted(seat.value.block) }
+                                        : { ...(seat.value?.additionalContext !== undefined && seat.value.additionalContext !== "" ? { context: seat.value.additionalContext } : {}) };
+                            }
+                            catch (hookErr) {
+                                const err = hookErr instanceof Error ? hookErr : new Error(String(hookErr));
+                                try {
+                                    runner.deps.onError?.(err, { phase: "hook", sessionId: prepared.sessionId });
+                                }
+                                catch {
+                                }
+                                outcome = { blocked: `the screen crashed (${inlineUntrusted(err.message)}; fail-closed)` };
+                            }
+                            if ("blocked" in outcome) {
+                                deliverEngineNotice(runner.deps.onNotice, {
+                                    code: "steering.parked_input_blocked",
+                                    message: "a parked steering input was withheld by the deployment's userPromptSubmit screen when this resume redelivered it: " +
+                                        `${outcome.blocked}. The parked row was consumed with the checkpoint; the instruction never reached the model — ` +
+                                        "re-issue it if it still applies.",
+                                    detail: {
+                                        ...(steer.inputId !== undefined ? { inputId: steer.inputId } : {}),
+                                        sessionId: prepared.sessionId,
+                                        runId: prepared.runId,
+                                        ...(spec.taskId !== undefined ? { taskId: spec.taskId } : {}),
+                                    },
+                                });
+                                queue.push({
+                                    ...buildHumanInputEvent({
+                                        carrier: source,
+                                        source,
+                                        delivery: "blocked",
+                                        sessionSeq: nextHumanInputSeq(prepared.harness),
+                                        ...(steer.inputId !== undefined ? { inputId: steer.inputId } : {}),
+                                        ...(steer.actor !== undefined ? { actor: steer.actor } : {}),
+                                        ...(steer.actor?.issuer !== undefined ? { issuer: steer.actor.issuer } : {}),
+                                        ...(spec.principal !== undefined ? { principal: spec.principal } : {}),
+                                    }),
+                                    ...ident(),
+                                });
+                                continue;
+                            }
+                            if ("context" in outcome && outcome.context !== undefined) {
+                                const hookStart = continuation.length;
+                                continuation += "\n\n" + formatHookFeedback(outcome.context, prepared.reminderMark);
+                                engineSegments.push({ start: hookStart, end: continuation.length });
+                            }
+                        }
+                    }
+                    const start = continuation.length;
+                    const projected = projectHumanInput({ text: steer.text, actor: steer.actor, source });
+                    continuation +=
+                        "\n\n" +
+                            (steer.trusted ? formatHookFeedback(projected, prepared.reminderMark) : 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;
+                if (gitResumeDelivered !== undefined) {
+                    const delivered = gitResumeDelivered;
+                    prepared.gitStatusRef.protectedText = delivered.wrapped;
+                    prepared.gitStatusRef.pendingReceipt = {
+                        text: continuation,
+                        commit: (entryId) => {
+                            prepared.gitStatusRef.announced = { kind: delivered.kind, hash: delivered.hash, entryId };
+                            queue.push({ type: "steering_injected", source: "git_status", preview: GIT_STATUS_ECHO_PREVIEW[delivered.kind], ...ident() });
+                            rs.attach.attachmentsInjected += 1;
+                            prepared.gitStatusRef.mirrorOwed = { kind: delivered.kind, hash: delivered.hash, entryId };
+                        },
+                    };
+                }
+                final = await withBrainSinks(() => prepared.harness.prompt(continuation, { engineSegments }));
+                await flushGitMirror();
+                if (prepared.gitStatusRef.announced?.pending === true)
+                    await prepared.gitStatusRef.reassert?.();
+            }
+        }
+        else {
+            const objectiveActor = entryActor;
+            const projectedObjective = projectHumanInput({ text: spec.objective, actor: objectiveActor, source: "objective" });
+            let effectiveObjective = projectedObjective;
+            let promptBlocked = false;
+            const userPromptSubmit = (spec.hooks ?? runner.deps.hooks)?.userPromptSubmit;
+            if (userPromptSubmit) {
+                try {
+                    const promptSeat = await runHookSeat("userPromptSubmit", { timeoutMs: prepared.hookTimeoutMs, signal: prepared.abortController.signal, abortEnds: true }, (sig) => userPromptSubmit(spec.objective, { identity: prepared.hookIdentity, signal: sig, source: "objective", ...(objectiveActor !== undefined ? { actor: snapshotActorAssertion(objectiveActor) } : {}) }));
+                    if (promptSeat.expired) {
+                        if (promptSeat.cause === "timeout") {
+                            try {
+                                runner.deps.onError?.(hookSeatExpiredError("userPromptSubmit", prepared.hookTimeoutMs, promptSeat.cause, "the prompt was NOT submitted (fail-closed) and the task ends blocked"), { phase: "hook", sessionId: prepared.sessionId });
+                            }
+                            catch {
+                            }
+                        }
+                        prepared.blockedRef.reason = formatHookFeedback(promptSeat.cause === "timeout"
+                            ? `the deployment's userPromptSubmit hook did not answer within its ${prepared.hookTimeoutMs}ms bound while screening this prompt; ` +
+                                `the prompt was NOT submitted (fail-closed)`
+                            : `the task was cancelled while the deployment's userPromptSubmit hook was still screening this prompt; ` +
+                                `the prompt was NOT submitted (fail-closed)`, prepared.reminderMark);
+                        promptBlocked = true;
+                    }
+                    const decision = promptSeat.expired ? undefined : promptSeat.value;
+                    if (decision?.block) {
+                        prepared.blockedRef.reason = formatHookFeedback(decision.block, prepared.reminderMark);
+                        promptBlocked = true;
+                    }
+                    else if (decision?.additionalContext) {
+                        effectiveObjective = `${formatHookFeedback(decision.additionalContext, prepared.reminderMark)}\n\n${projectedObjective}`;
+                    }
+                }
+                catch (hookErr) {
+                    const err = hookErr instanceof Error ? hookErr : new Error(String(hookErr));
+                    try {
+                        runner.deps.onError?.(err, { phase: "hook", sessionId: prepared.sessionId });
+                    }
+                    catch {
+                    }
+                    prepared.blockedRef.reason = formatHookFeedback(`the deployment's userPromptSubmit hook crashed while screening this prompt (${err.message}); ` +
+                        `the prompt was NOT submitted (fail-closed)`, prepared.reminderMark);
+                    promptBlocked = true;
+                }
+            }
+            let gitLegDelivered;
+            if (!promptBlocked) {
+                const gitBody = await resolveGitLegDelivery(prepared, undefined, (err) => {
+                    try {
+                        runner.deps.onError?.(new Error(`git announcement ladder unreadable (conservative re-announce): ${err.message}`), { phase: "degraded", sessionId: prepared.sessionId });
+                    }
+                    catch {
+                    }
+                });
+                const gitFrame = prepared.gitStatusRef.frame;
+                if (gitBody !== undefined && gitFrame !== undefined) {
+                    const wrappedGit = wrapGitFrame(gitBody, prepared.reminderMark);
+                    const standalone = spec.images !== undefined && spec.images.length > 0;
+                    if (!standalone)
+                        effectiveObjective = `${wrappedGit}\n${effectiveObjective}`;
+                    gitLegDelivered = { kind: gitFrame.kind, hash: gitFrame.hash, standalone, wrapped: wrappedGit };
+                    if (gitFrame.kind === "full" && gitFrame.shrunk !== undefined) {
+                        prepared.gitStatusRef.wrappedShrink = { find: wrappedGit, replace: wrapGitFrame(gitFrame.shrunk.body, prepared.reminderMark) };
+                    }
+                }
+            }
+            const firstFrames = [];
+            if (rs.attach.attachState !== undefined) {
+                const attach = rs.attach.attachState;
+                if (rs.attach.agentListingOn && prepared.agentListing !== undefined) {
+                    const listing = prepared.agentListing;
+                    const body = renderAgentListingDelta(attach, listing.entries, listing.toolName, listing.models);
+                    if (body !== undefined) {
+                        firstFrames.push({
+                            source: "agent_listing",
+                            body,
+                            commit: () => {
+                                commitAgentListing(attach, listing.entries, listing.models);
+                                prepared.announcedListingsRef.agents = listing.entries.map((e) => e.name);
+                                if (listing.models !== undefined)
+                                    prepared.announcedListingsRef.models = [...listing.models];
+                            },
+                        });
+                    }
+                }
+                if (rs.attach.skillsListingOn && prepared.skillsListing !== undefined) {
+                    const listing = prepared.skillsListing;
+                    const body = renderSkillsListingDelta(attach, listing.entries);
+                    if (body !== undefined) {
+                        firstFrames.push({
+                            source: "skills_listing",
+                            body,
+                            commit: () => {
+                                commitSkillsListing(attach, listing.entries);
+                                prepared.announcedListingsRef.skills = listing.entries.map((e) => e.name);
+                            },
+                        });
+                    }
+                }
+                if (firstFrames.length > 0) {
+                    effectiveObjective = `${firstFrames.map((f) => mintSystemReminder(sanitizeUntrustedText(f.body, attachmentEnvelopeTags(f.source)), prepared.reminderMark)).join("\n")}\n${effectiveObjective}`;
+                }
+            }
+            const gitQueuedChars = gitLegDelivered !== undefined && gitLegDelivered.standalone ? gitLegDelivered.wrapped.length : 0;
+            const precallMicroUsd = rs.budget.maxCostMicroUsd === undefined
+                ? 0
+                : computeCostMicroUsd({
+                    totalInputTokens: Math.ceil((effectiveObjective.length + gitQueuedChars) / 4),
+                    cacheReadTokens: 0,
+                    cacheWriteTokens: 0,
+                    cacheWriteTokensLong: 0,
+                    outputTokens: prepared.model.maxTokens ?? DEFAULT_PRECALL_OUTPUT_TOKENS,
+                }, rs.telemetry.pricing);
+            const precallCeilingMicroUsd = prepared.suspendForResource !== undefined ? rs.budget.remainingMicroUsd : rs.budget.maxCostMicroUsd;
+            const precallTokens = Math.ceil((effectiveObjective.length + gitQueuedChars) / 4) + (prepared.model.maxTokens ?? DEFAULT_PRECALL_OUTPUT_TOKENS);
+            const precallCeilingTokens = prepared.suspendForResource !== undefined ? rs.budget.remainingTokens : rs.budget.maxTokensWindow;
+            const entryUsageRetryAfterMs = prepared.usageGovernance !== undefined ? await prepared.usageGovernance.check(Date.now()) : undefined;
+            if (promptBlocked) {
+            }
+            else if (entryUsageRetryAfterMs !== undefined) {
+                const terminal = platformLimitTerminal("usage_window", entryUsageRetryAfterMs, "entry");
+                rs.limits.platformTerminal = terminal;
+                try {
+                    runner.deps.onError?.(terminal, { phase: "config", sessionId: prepared.sessionId });
+                }
+                catch {
+                }
+            }
+            else if (precallCeilingTokens !== undefined && precallTokens > precallCeilingTokens) {
+                rs.limits.budgetHit = "precall";
+                rs.limits.budgetAxis = "tokens";
+            }
+            else if (precallCeilingMicroUsd !== undefined && precallMicroUsd > precallCeilingMicroUsd) {
+                rs.limits.budgetHit = "precall";
+                rs.limits.budgetAxis = "cost";
+            }
+            else if (effectiveTimeoutMs !== undefined && effectiveTimeoutMs <= 0) {
+                timeout.fired = true;
+                timeout.clear();
+                void prepared.harness.abort();
+                prepared.abortController.abort();
+            }
+            else {
+                const images = spec.images
+                    ? await Promise.all(spec.images.map((img) => toImageContent(img, runner.deps.allowImageUrl)))
+                    : undefined;
+                if (gitLegDelivered !== undefined) {
+                    const delivered = gitLegDelivered;
+                    if (delivered.standalone)
+                        await prepared.harness.nextTurn(delivered.wrapped, { engineMinted: true });
+                    prepared.gitStatusRef.protectedText = delivered.wrapped;
+                    prepared.gitStatusRef.pendingReceipt = {
+                        text: delivered.standalone ? delivered.wrapped : effectiveObjective,
+                        commit: (entryId) => {
+                            prepared.gitStatusRef.announced = { kind: delivered.kind, hash: delivered.hash, entryId };
+                            queue.push({ type: "steering_injected", source: "git_status", preview: GIT_STATUS_ECHO_PREVIEW[delivered.kind], ...ident() });
+                            rs.attach.attachmentsInjected += 1;
+                            prepared.gitStatusRef.mirrorOwed = { kind: delivered.kind, hash: delivered.hash, entryId };
+                        },
+                    };
+                }
+                for (const f of firstFrames) {
+                    f.commit();
+                    queue.push({ type: "steering_injected", source: f.source, preview: redactThenCut(f.body, 220), ...ident() });
+                }
+                rs.attach.attachmentsInjected += firstFrames.length;
+                if (firstFrames.length > 0 && prepared.announcedSnapshotRecovered)
+                    await prepared.session.appendAnnouncedListing(prepared.announcedListingsRef).catch(() => undefined);
+                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 } : {}),
+                }));
+                await flushGitMirror();
+                if (prepared.gitStatusRef.announced?.pending === true)
+                    await prepared.gitStatusRef.reassert?.();
+            }
+        }
+        loopLatch.ended = true;
+        abortedLive = prepared.abortController.signal.aborted;
+        userInterruptedLive = loopLatch.userInterrupted;
+    }
+    catch (err) {
+        loopLatch.ended = true;
+        if (errorCodeOf(err) === "resume.tool_unavailable" || errorCodeOf(err) === "resume.tool_contract_mismatch") {
+            await settleTeardownLeg(() => prepared.mcp.dispose(), "mcp.dispose (tool_unavailable leg)", (e) => runner.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId }));
+            await settleTeardownLeg(() => prepared.a2a?.dispose(), "a2a.dispose (tool_unavailable leg)", (e) => runner.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId }));
+            await settleTeardownLeg(() => (prepared.ownedEnv && hasDestroy(prepared.ownedEnv) ? prepared.ownedEnv.destroy() : undefined), "ownedEnv.destroy (tool_unavailable leg)", (e) => runner.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId }));
+            throw err;
+        }
+        threw = err;
+        abortedLive = prepared.abortController.signal.aborted;
+        userInterruptedLive = loopLatch.userInterrupted;
+    }
+    finally {
+        timeout.clear();
+        prepared.lspDiagnostics?.registry.releaseRun(prepared.lspDiagnostics.runIdent);
+        prepared.abortController.abort();
+        prepared.releaseSignal();
+        strandedHumanAnswers = prepared.settleContentAskBindings();
+        try {
+            prepared.harness.recoverUndrainedEngineNotes();
+        }
+        catch {
+        }
+        notificationLane.live = false;
+        unsubscribeTaskNotifications();
+        prepared.toolRosterDeltas.unsubscribe();
+        unsubGitRetry();
+        unsubBoundary();
+        unsub();
+    }
+    return await next({ final, threw, abortedLive, userInterruptedLive, strandedHumanAnswers });
+}