@sema-agent/core 7.10.0 → 7.11.1

package/dist/core/runner/runtask.js

@@ -4,7 +4,7 @@ import { deliverDelegationLifecycle, deliverEngineNotice, undrainedUserInputNoti
 import { planRejectionClears, resolveTriggerWindow } from "../context-edit.js";
 import { AgentHarness, DEFAULT_COMPACTION_SETTINGS, isSyntheticApiErrorMessage, uuidv7 } from "../../internal/harness.js";
 import { snapshotActorAssertion } from "../../internal/llm.js";
-import { CheckpointError, remainingBudgetMicroUsd, readPendingSteerQueue, remainingTokens, resolveCheckpointStore, LEGACY_PENDING_STEER_INPUT_ID, MAX_STEER_INPUT_ID_CHARS, realApprovalOrgFact } from "../checkpoint-store.js";
+import { CheckpointError, remainingBudgetMicroUsd, readPendingSteerQueue, remainingTokens, resolveCheckpointStore, realApprovalOrgFact } from "../checkpoint-store.js";
 import { GIT_STATUS_ECHO_PREVIEW, stripGitStatusUnits } from "./git-status-frame.js";
 import { settleExecutionRecord } from "./execution-record.js";
 import { engineVersion } from "../version.js";
@@ -46,7 +46,7 @@ import { settleTeardownLeg } from "./teardown-bounded.js";
 import { hasDestroy, isIsolated } from "../remote-env.js";
 import { hasBackgroundShell, sweepBackgroundShells } from "../background-shell.js";
 import { formatHookFeedback, hookSeatExpiredError, resolveHookTimeoutMs, runHookSeat } from "../hooks.js";
-import { buildHumanInputEvent, frameMidTurnUserInput, projectHumanInput } from "../human-input-projection.js";
+import { buildHumanInputEvent, projectHumanInput } from "../human-input-projection.js";
 import { delimitUntrusted, inlineUntrusted, REVIEWER_NOTE_MAX_BODY, sanitizeUntrustedText } from "../untrusted-text.js";
 import { appendInterruptionMarker, reconcileInterruptedSession } from "../session-reconcile.js";
 import { RunnerSharedToolResultStore } from "../tool-result-store.js";
@@ -54,11 +54,11 @@ import { PAUSE_REGISTRY } from "../pause-registry.js";
 import { refuseOutOfContractDecision, toolPolicyNameSets } from "../tool-policy.js";
 import { mintGateOutcome } from "./gate-exit.js";
 import { defaultTaskRegistry } from "../task-registry.js";
-import { discloseDroppedPending, isDelegatedAgentTerminal, isSystemInjectionPriority, isTerminalTaskNotification, PendingSessionNotifications, renderTaskNotificationXml, SYSTEM_INJECTION_PRIORITIES, SystemInjectionQueue, taskNotificationDedupKey } from "../task-notification.js";
+import { discloseDroppedPending, isDelegatedAgentTerminal, isTerminalTaskNotification, PendingSessionNotifications, renderTaskNotificationXml, SystemInjectionQueue, taskNotificationDedupKey } from "../task-notification.js";
 import { ToolDetachHub } from "../tool-detach.js";
 import { createPeerInboundChainRef, createPeerSelfRef } from "../../agents/peer-admission.js";
 import { createRunState } from "./initial-run-state.js";
-import { nextHumanInputSeq, sameAcceptedSteerInput } from "./steer-admission.js";
+import { nextHumanInputSeq } from "./steer-admission.js";
 import { reconciledToolEndBody, toolEndBodyFrom, toolResultMsg, writeFamilyOfCanonical } from "./tool-end-body.js";
 import { answerFaceForRedeemedCall, deepJsonEqual, DEFERRED_REISSUE, pendingContentAskCallId, resumeContinuation, resumeDecisionWasNegative } from "./decide-continuation.js";
 import { awaitChargeWithSlowDisclosure, DEFAULT_PRECALL_OUTPUT_TOKENS, discloseUnevaluableWindow, platformLimitTerminal, resolveMaxTurns, startTimeout, TIMER_LATENESS_REPORT_MS } from "./clock-and-limits.js";
@@ -73,6 +73,11 @@ import { resumeInternalsAndConfig } from "./resume-internals-and-config.js";
 import { resumeApply } from "./resume-apply.js";
 import { resumePreflight } from "./resume-preflight.js";
 import { resumeClaim } from "./resume-claim.js";
+import { streamSettleBackstop } from "./stream-settle-backstop.js";
+import { streamReap } from "./stream-reap.js";
+import { streamSteerVerb } from "./stream-steer-verb.js";
+import { streamLifecycleVerbs } from "./stream-lifecycle-verbs.js";
+import { streamHaltVerbs } from "./stream-halt-verbs.js";
 const STOP_HOOK_BLOCK_CAP = 8;
 const ORG_DISCLOSURE_MAX_CHARS = 600;
 const SUGGESTIONS_DEFAULT_COUNT = 3;
@@ -308,7 +313,6 @@ export class Runner {
             return Promise.race([p, timeout]).finally(() => clearTimeout(t));
         };
         let reapHandle;
-        let steerChain = Promise.resolve();
         const acceptedSteerInputs = new Map();
         const notifyRef = {};
         const captureOptOutRef = {};
@@ -363,149 +367,29 @@ export class Runner {
                 drainManualCompactWaiters("mooted");
             }
         })();
-        const settled = run.catch(async (err) => {
-            let code = errorCodeOf(err);
-            const reopenReason = code === "resume.tool_unavailable" || code === "resume.tool_contract_mismatch" ? "tool_unavailable" : "env_failed";
-            const reopenable = resume !== undefined && resume.pendingActionStarted !== true && reopenReason !== undefined && !(resumeDecisionWasNegative(resume) && resume.decisionDelivered === true);
-            let reopenCommitted = false;
-            let reopenStateUnknown = false;
-            if (reopenable && resume?.onEnvRestoreFailed) {
-                try {
-                    await resume.onEnvRestoreFailed(reopenReason);
-                    reopenCommitted = true;
-                }
-                catch (reopenErr) {
-                    this.parentConstraintRegistry.delete(resume.cp.token);
-                    const original = err instanceof Error ? err : new Error(String(err));
-                    const reopenMsg = reopenErr instanceof Error ? reopenErr.message : String(reopenErr);
-                    const definitive = errorCodeOf(reopenErr) === "checkpoint.reopen_failed";
-                    reopenStateUnknown = !definitive;
-                    err = Object.assign(new Error(definitive
-                        ? `${reopenMsg} (original resume failure: ${original.message})`
-                        : `checkpoint reopen threw mid-flight — state UNKNOWN, confirm via the checkpoint store before retrying: ${reopenMsg} (original resume failure: ${original.message})`, { cause: original }), { code: "checkpoint.reopen_failed" });
-                    code = "checkpoint.reopen_failed";
-                }
-            }
-            if (resume)
-                this.locallyClaimedTokens.delete(resume.cp.token);
-            if (resume && !reopenCommitted) {
-                this.parentConstraintRegistry.delete(resume.cp.token);
-                await settleTeardownLeg(() => this.sessions.unpin?.(resume.cp.sessionId), "sessions.unpin (resume-failure leg)", (e) => this.deps.onError?.(e, { phase: "config", sessionId: resume.cp.sessionId }));
-                if (!reopenStateUnknown) {
-                    const failedReap = this.suspendedEnvReaps.get(resume.cp.token);
-                    this.suspendedEnvReaps.delete(resume.cp.token);
-                    if (failedReap?.env !== undefined && hasDestroy(failedReap.env)) {
-                        const failedEnv = failedReap.env;
-                        await settleTeardownLeg(() => failedEnv.destroy(), "terminal resume-failure env destroy", (e) => this.deps.onError?.(e, { phase: "config", sessionId: resume.cp.sessionId }));
-                    }
-                }
-            }
-            if (resultValue !== undefined) {
-                try {
-                    this.deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "config", sessionId: resultValue.sessionId });
-                }
-                catch {
-                }
-                queue.close();
-                return;
-            }
-            const remoteEnvFailure = (() => {
-                let cur = err;
-                for (let depth = 0; cur && typeof cur === "object" && depth < 8; depth++) {
-                    const note = cur.remoteEnvFailure;
-                    if (note !== undefined)
-                        return [note];
-                    cur = cur.cause;
-                }
-                return undefined;
-            })();
-            resultValue = {
-                taskId: taskIdRef.current ?? "unknown",
-                sessionId: taskIdRef.sessionId ?? "unknown",
-                ...(taskIdRef.runId !== undefined ? { runId: taskIdRef.runId } : {}),
-                terminal: { kind: "failed", ...(code !== undefined ? { code } : {}), message: err instanceof Error ? err.message : String(err) },
-                result: "",
-                ...(remoteEnvFailure !== undefined ? { remoteEnvFailures: remoteEnvFailure } : {}),
-                ...(taskIdRef.effectiveMemoryScopes !== undefined ? { effectiveMemoryScopes: taskIdRef.effectiveMemoryScopes } : {}),
-                ...(taskIdRef.effectiveReasoning !== undefined ? { effectiveReasoning: taskIdRef.effectiveReasoning } : {}),
-                ...(() => {
-                    const observed = taskIdRef.editedFiles?.();
-                    return observed !== undefined && observed.length > 0 ? { editedFiles: observed } : {};
-                })(),
-                ...(() => {
-                    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(entryTracer.tracer, () => ({
-                kind: "task.end",
-                version: 1,
-                taskId: taskIdRef.current ?? "unknown",
-                ...(taskIdRef.runId !== undefined ? { runId: taskIdRef.runId } : {}),
-                status: "failed",
-                errorCode: code,
-                turns: 0,
-                tokens: 0,
-                durationMs: Date.now() - runStartedAt,
-                ts: Date.now(),
-            }));
-            const owedTerminal = taskIdRef.delegationTerminalOwed;
-            if (owedTerminal !== undefined) {
-                taskIdRef.delegationTerminalOwed = undefined;
-                deliverDelegationLifecycle(this.deps.onDelegationLifecycle, { phase: "terminal", identity: owedTerminal, status: "failed", turns: 0, ...(code !== undefined ? { errorCode: code } : {}) }, createSafeNotifier({
-                    onError: (f) => console.warn(`[sema-core] ${f.site}: delegation-lifecycle observer threw (contained; further failures counted, not re-disclosed): ${f.error.message}`),
-                }), "runtask.onDelegationLifecycle");
-            }
-            if (forwardsSubagentEvents(spec))
-                await drainForwardedFramesBeforeDone();
-            queue.push({ type: "done", result: resultValue });
-            queue.close();
-        });
+        const live = {
+            get resultValue() { return resultValue; },
+            set resultValue(v) { resultValue = v; },
+            get handle() { return handle; },
+            get reapHandle() { return reapHandle; },
+        };
+        const settled = run.catch(streamSettleBackstop({
+            spec, resume, queue, taskIdRef, entryTracer, runStartedAt, live, runner: this.depsSeat, sessions: this.sessions,
+            locallyClaimedTokens: this.locallyClaimedTokens, parentConstraintRegistry: this.parentConstraintRegistry, suspendedEnvReaps: this.suspendedEnvReaps,
+        }).onRunRejected);
         void settled.then(() => acceptedSteerInputs.clear(), () => acceptedSteerInputs.clear());
         const steeringError = (msg, code = "steering.not_running") => {
             const e = new Error(`cannot steer: ${msg}`);
             e.code = code;
             return e;
         };
-        let destroyOnce;
-        const reapSuspended = async () => {
-            const rh = reapHandle;
-            if (!rh)
-                return;
-            const reportErr = (err) => {
-                try {
-                    this.deps.onError?.(err, { phase: "config", sessionId: rh.sessionId });
-                }
-                catch {
-                }
-            };
-            let won;
-            try {
-                won = await rh.store.expire(rh.token, rh.scope);
-            }
-            catch (err) {
-                reportErr(err);
-                return;
-            }
-            if (!won) {
-                if (!this.locallyClaimedTokens.has(rh.token))
-                    this.suspendedEnvReaps.delete(rh.token);
-                return;
-            }
-            this.parentConstraintRegistry.delete(rh.token);
-            this.suspendedEnvReaps.delete(rh.token);
-            if (rh.env && hasDestroy(rh.env)) {
-                try {
-                    await rh.env.destroy();
-                }
-                catch (err) {
-                    reportErr(err);
-                }
-            }
-        };
+        const { reapSuspended } = streamReap({
+            live, runner: this.depsSeat,
+            locallyClaimedTokens: this.locallyClaimedTokens, parentConstraintRegistry: this.parentConstraintRegistry, suspendedEnvReaps: this.suspendedEnvReaps,
+        });
+        const { steer } = streamSteerVerb({ spec, internals, queue, acceptedSteerInputs, live, ready, orTimeout, readyTimeoutMs: READY_TIMEOUT_MS, steeringError, runner: this.depsSeat });
+        const { notify, optOutMemoryCapture, compact, detach, interrupt } = streamLifecycleVerbs({ live, ready, orTimeout, steeringError, notifyRef, captureOptOutRef, manualCompactRef, detachHub });
+        const { halt, destroy } = streamHaltVerbs({ spec, live, ready, orTimeout, readyTimeoutMs: READY_TIMEOUT_MS, run, reapSuspended, runner: this.depsSeat });
         return {
             [Symbol.asyncIterator]: () => queue[Symbol.asyncIterator](),
             result: async () => {
@@ -516,374 +400,14 @@ export class Runner {
                 await run.catch(() => { });
                 return suggestionsDone.catch(() => []);
             },
-            steer: async (text, options) => {
-                const trusted = options?.trusted ? true : false;
-                if (trusted && sanitizeUntrustedText(text) !== text) {
-                    throw steeringError("trusted steering text must not contain a </system-reminder> tag", "steering.invalid_content");
-                }
-                const inputId = options?.inputId;
-                if (inputId !== undefined) {
-                    if (typeof inputId !== "string") {
-                        throw steeringError("inputId must be a string when supplied", "steering.invalid_content");
-                    }
-                    if (inputId === "" || inputId.length > MAX_STEER_INPUT_ID_CHARS) {
-                        throw steeringError(`inputId must be a non-empty string of at most ${MAX_STEER_INPUT_ID_CHARS} characters`, "steering.invalid_content");
-                    }
-                    if (inputId === LEGACY_PENDING_STEER_INPUT_ID) {
-                        throw steeringError(`inputId "${LEGACY_PENDING_STEER_INPUT_ID}" is reserved for a pre-queue parked steer and cannot be supplied by a caller`, "steering.invalid_content");
-                    }
-                }
-                const priorityIn = options?.priority;
-                if (priorityIn !== undefined && !isSystemInjectionPriority(priorityIn)) {
-                    throw steeringError(`priority must be one of ${SYSTEM_INJECTION_PRIORITIES.join("/")} when supplied`, "steering.invalid_content");
-                }
-                const priority = priorityIn ?? "next";
-                const actorIn = options?.actor;
-                const actor = actorIn === undefined ? undefined : snapshotActorAssertion(actorIn);
-                const projected = projectHumanInput({ text, actor, source: "steer" });
-                const effectiveInputId = typeof inputId === "string" ? inputId : uuidv7();
-                const parkRecord = {
-                    text,
-                    trusted,
-                    inputId: effectiveInputId,
-                    ...(priorityIn !== undefined ? { priority } : {}),
-                    ...(actor !== undefined ? { actor } : {}),
-                };
-                let payload;
-                let mintsAFrame;
-                let replay;
-                const noteAccepted = (h) => {
-                    if (!mintsAFrame)
-                        return;
-                    if (typeof inputId === "string")
-                        acceptedSteerInputs.set(inputId, replay);
-                    queue.push({
-                        ...buildHumanInputEvent({
-                            carrier: "steer",
-                            source: "steer",
-                            delivery: "queued",
-                            sessionSeq: nextHumanInputSeq(h.harness),
-                            inputId: effectiveInputId,
-                            ...(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");
-                    const h = handle ?? (await orTimeout(ready));
-                    if (!h)
-                        throw steeringError("the task is not running");
-                    payload = trusted ? formatHookFeedback(projected, h.reminderMark) : frameMidTurnUserInput(projected);
-                    mintsAFrame = payload.trim().length !== 0;
-                    replay = { payload, trusted, priority, ...(actor !== undefined ? { actor } : {}) };
-                    if (typeof inputId === "string") {
-                        const prior = acceptedSteerInputs.get(inputId);
-                        if (prior !== undefined) {
-                            if (resultValue !== undefined || h.loop.ended)
-                                throw steeringError("the task is no longer running");
-                            if (!sameAcceptedSteerInput(prior, replay)) {
-                                throw steeringError("a different steering instruction was already accepted under this inputId — re-issue this one with a fresh inputId " +
-                                    "(an identical payload would have been an idempotent retry)", "steering.duplicate_input_id");
-                            }
-                            return;
-                        }
-                    }
-                    if (resultValue !== undefined || h.loop.ended)
-                        throw steeringError("the task is no longer running");
-                    if (mintsAFrame) {
-                        const screen = (spec.hooks ?? this.deps.hooks)?.userPromptSubmit;
-                        if (screen !== undefined) {
-                            let decision;
-                            try {
-                                const seat = await runHookSeat("userPromptSubmit", { timeoutMs: h.hookTimeoutMs, signal: h.abortController.signal, abortEnds: true }, (sig) => screen(text, { identity: h.hookIdentity, signal: sig, source: "steer", inputId: effectiveInputId, ...(actor !== undefined ? { actor: snapshotActorAssertion(actor) } : {}) }));
-                                if (seat.expired) {
-                                    if (seat.cause === "timeout") {
-                                        try {
-                                            this.deps.onError?.(hookSeatExpiredError("userPromptSubmit", h.hookTimeoutMs, seat.cause, "the steering input was NOT accepted (fail-closed) and the caller was refused typed"), { phase: "hook", sessionId: h.sessionId });
-                                        }
-                                        catch {
-                                        }
-                                    }
-                                    throw steeringError(seat.cause === "timeout"
-                                        ? `the deployment's userPromptSubmit hook did not answer within its ${h.hookTimeoutMs}ms bound while screening this steering input; the input was NOT accepted (fail-closed)`
-                                        : `the task was cancelled while the deployment's userPromptSubmit hook was still screening this steering input; the input was NOT accepted (fail-closed)`, "steering.blocked_by_hook");
-                                }
-                                decision = seat.value;
-                            }
-                            catch (hookErr) {
-                                if (hookErr instanceof Error && hookErr.code === "steering.blocked_by_hook")
-                                    throw hookErr;
-                                const err = hookErr instanceof Error ? hookErr : new Error(String(hookErr));
-                                try {
-                                    this.deps.onError?.(err, { phase: "hook", sessionId: h.sessionId });
-                                }
-                                catch {
-                                }
-                                throw steeringError(`the deployment's userPromptSubmit hook crashed while screening this steering input (${inlineUntrusted(err.message)}); the input was NOT accepted (fail-closed)`, "steering.blocked_by_hook");
-                            }
-                            if (decision?.block !== undefined && decision.block !== "") {
-                                throw steeringError(`the deployment's userPromptSubmit hook blocked this steering input: ${inlineUntrusted(decision.block)}`, "steering.blocked_by_hook");
-                            }
-                            if (decision?.additionalContext !== undefined && decision.additionalContext !== "") {
-                                payload = `${formatHookFeedback(decision.additionalContext, h.reminderMark)}\n\n${payload}`;
-                            }
-                        }
-                    }
-                    const injectFramed = async () => {
-                        const noteOptions = { provenance: "engine-note", callerAuthored: true, parkRecord, ...(actor !== undefined ? { actor } : {}) };
-                        if (priority === "later") {
-                            await h.harness.followUp(payload, noteOptions);
-                            noteAccepted(h);
-                            return;
-                        }
-                        const frame = await h.harness.steer(payload, { ...noteOptions, ...(priority === "now" ? { immediate: true } : {}) });
-                        noteAccepted(h);
-                        if (priority === "now" && frame !== undefined && h.harness.interruptTurn(frame)) {
-                            deliverEngineNotice(this.deps.onNotice, {
-                                code: "task.turn_interrupted",
-                                message: "a caller-provenance steer with priority \"now\" interrupted the running turn: in-flight work was cut at " +
-                                    "a manufactured boundary (finished tool calls keep their real results; never-started ones settle as " +
-                                    "interrupted) and the run continues with the steer at the queue head.",
-                                detail: {
-                                    inputId: effectiveInputId,
-                                    sessionId: h.sessionId,
-                                    runId: h.runId,
-                                    ...(actor?.id !== undefined ? { actorId: actor.id } : {}),
-                                    ...(spec.taskId !== undefined ? { taskId: spec.taskId } : {}),
-                                },
-                            });
-                        }
-                    };
-                    try {
-                        await injectFramed();
-                        return;
-                    }
-                    catch (e) {
-                        if (!(e instanceof Error && e.code === "invalid_state"))
-                            throw e;
-                    }
-                    const birthDeadline = Date.now() + READY_TIMEOUT_MS;
-                    while (resultValue === undefined && !h.loop.ended && Date.now() < birthDeadline) {
-                        try {
-                            await injectFramed();
-                            return;
-                        }
-                        catch (e2) {
-                            if (!(e2 instanceof Error && e2.code === "invalid_state"))
-                                throw e2;
-                        }
-                        await new Promise((r) => setTimeout(r, 10));
-                    }
-                    throw steeringError("the task is no longer running");
-                };
-                const p = steerChain.then(deliver);
-                steerChain = p.then(() => undefined, () => undefined);
-                return p;
-            },
-            notify: async (input, opts) => {
-                const notifyError = (msg, code) => {
-                    const e = new Error(`cannot notify: ${msg}`);
-                    e.code = code;
-                    return e;
-                };
-                if (typeof input?.task_id !== "string" || input.task_id.trim() === "") {
-                    throw notifyError("input.task_id must be a non-empty string", "notify.invalid_payload");
-                }
-                const VALID_STATUSES = new Set(["completed", "failed", "killed", "cancelled", "event"]);
-                if (!VALID_STATUSES.has(input.status)) {
-                    throw notifyError(`input.status must be one of ${[...VALID_STATUSES].join("/")}`, "notify.invalid_payload");
-                }
-                if (typeof input.summary !== "string" || input.summary.trim() === "") {
-                    throw notifyError("input.summary must be a non-empty string", "notify.invalid_payload");
-                }
-                if (input.result !== undefined && typeof input.result !== "string") {
-                    throw notifyError("input.result must be a string when present", "notify.invalid_payload");
-                }
-                if (input.seq !== undefined && (typeof input.seq !== "number" || !Number.isFinite(input.seq))) {
-                    throw notifyError("input.seq must be a finite number when present", "notify.invalid_payload");
-                }
-                if (input.source !== undefined && typeof input.source !== "string") {
-                    throw notifyError("input.source must be a string when present", "notify.invalid_payload");
-                }
-                const priorityIn = opts?.priority;
-                if (priorityIn !== undefined && !isSystemInjectionPriority(priorityIn)) {
-                    throw notifyError(`opts.priority must be one of ${SYSTEM_INJECTION_PRIORITIES.join("/")} when present`, "notify.invalid_payload");
-                }
-                const priority = priorityIn;
-                if (priority === "now") {
-                    throw notifyError('priority "now" (turn interrupt) is not a notification-lane power — it belongs to the steer face; use "next" for earliest-boundary delivery', "notify.invalid_priority");
-                }
-                const payload = {
-                    task_id: input.task_id,
-                    task_type: "external",
-                    status: input.status,
-                    summary: input.summary,
-                    ...(input.result !== undefined ? { result: input.result } : {}),
-                    ...(input.seq !== undefined ? { seq: input.seq } : {}),
-                    ...(input.source !== undefined ? { source: input.source } : {}),
-                };
-                const h = handle ?? (await orTimeout(ready));
-                if (!h || notifyRef.inject === undefined) {
-                    throw notifyError("the task is not running", "notify.not_running");
-                }
-                notifyRef.inject(payload, priority !== undefined ? { priority } : undefined);
-            },
-            optOutMemoryCapture: async (options) => {
-                const reasonIn = options?.reason;
-                if (reasonIn !== undefined && typeof reasonIn !== "string") {
-                    const e = new Error(`cannot opt out of memory capture: options.reason must be a string when present`);
-                    e.code = "steering.invalid_content";
-                    throw e;
-                }
-                const reason = reasonIn;
-                if (resultValue)
-                    throw steeringError("the task has already finished");
-                const h = handle ?? (await orTimeout(ready));
-                if (!h)
-                    throw steeringError("the task is not running");
-                if (captureOptOutRef.flip === undefined) {
-                    const e = new Error(`cannot opt out of memory capture: this run mounted no memory session (no memory spec / no backend / prepare degraded memory-less) — there is nothing to opt out of`);
-                    e.code = "memory.capture_optout_unavailable";
-                    throw e;
-                }
-                return captureOptOutRef.flip(reason);
-            },
-            compact: async (opts) => {
-                if (resultValue)
-                    throw steeringError("the task has already finished");
-                if (opts?.signal?.aborted)
-                    return "mooted";
-                const h = handle ?? (await orTimeout(ready));
-                if (!h)
-                    throw steeringError("the task is not running");
-                if (opts?.signal?.aborted)
-                    return "mooted";
-                if (manualCompactRef.closed)
-                    return "mooted";
-                return new Promise((resolve) => {
-                    const signal = opts?.signal;
-                    const entry = {
-                        resolve,
-                        ...(signal !== undefined ? { signal } : {}),
-                        ...(opts?.instructions !== undefined ? { instructions: opts.instructions } : {}),
-                    };
-                    if (signal !== undefined) {
-                        const onAbort = () => {
-                            const i = manualCompactRef.waiters.indexOf(entry);
-                            if (i >= 0) {
-                                manualCompactRef.waiters.splice(i, 1);
-                                if (manualCompactRef.waiters.length === 0) {
-                                    manualCompactRef.requested = false;
-                                }
-                                manualCompactRef.emitMooted?.("cancelled");
-                                entry.resolve("mooted");
-                            }
-                        };
-                        entry.resolve = (outcome) => {
-                            signal.removeEventListener("abort", onAbort);
-                            resolve(outcome);
-                        };
-                        signal.addEventListener("abort", onAbort, { once: true });
-                    }
-                    manualCompactRef.requested = true;
-                    manualCompactRef.waiters.push(entry);
-                });
-            },
-            detach: (toolCallId) => {
-                detachHub.request(toolCallId);
-            },
-            interrupt: async () => {
-                const h = handle ?? (await orTimeout(ready));
-                if (!h)
-                    return;
-                if (!h.abortController.signal.aborted)
-                    h.loop.userInterrupted = true;
-                h.abortController.abort();
-                void h.harness.abort();
-            },
-            halt: async () => {
-                const haltRefused = (msg) => {
-                    const e = new Error(`cannot halt: ${msg}`);
-                    e.code = "steering.not_running";
-                    return e;
-                };
-                if (resultValue)
-                    throw haltRefused("the task has already finished");
-                const h = handle ?? (await orTimeout(ready));
-                if (!h)
-                    throw haltRefused("the task is not running");
-                const apply = () => {
-                    const abortOwnedBeforeHalt = h.abortController.signal.aborted;
-                    const receipt = h.harness.halt();
-                    if (receipt.accepted && !abortOwnedBeforeHalt) {
-                        h.loop.userHalted = true;
-                    }
-                    else {
-                        deliverEngineNotice(this.deps.onNotice, {
-                            code: "task.halt_unconsumed",
-                            message: "a user halt arrived while the run was already ending for its own reason: nothing was cut or stopped " +
-                                "by it — the run's own ending stands, and the result will not carry haltedByUser for this halt.",
-                            detail: {
-                                sessionId: h.sessionId,
-                                runId: h.runId,
-                                ...(spec.taskId !== undefined ? { taskId: spec.taskId } : {}),
-                            },
-                        });
-                    }
-                    if (receipt.turnCut) {
-                        deliverEngineNotice(this.deps.onNotice, {
-                            code: "task.turn_interrupted",
-                            message: "a bare user halt cut the running turn: in-flight work was cut at a manufactured boundary " +
-                                "(finished tool calls keep their real results; never-started ones settle as interrupted) and " +
-                                "the run is collecting to a clean, resumable stop — no further model turn will start.",
-                            detail: {
-                                cause: "user_halt",
-                                sessionId: h.sessionId,
-                                runId: h.runId,
-                                ...(spec.taskId !== undefined ? { taskId: spec.taskId } : {}),
-                            },
-                        });
-                    }
-                    return { turnCut: receipt.turnCut };
-                };
-                try {
-                    if (resultValue !== undefined || h.loop.ended)
-                        throw haltRefused("the task is no longer running");
-                    return apply();
-                }
-                catch (e) {
-                    if (!(e instanceof Error && e.code === "invalid_state"))
-                        throw e;
-                }
-                const birthDeadline = Date.now() + READY_TIMEOUT_MS;
-                while (resultValue === undefined && !h.loop.ended && Date.now() < birthDeadline) {
-                    try {
-                        return apply();
-                    }
-                    catch (e2) {
-                        if (!(e2 instanceof Error && e2.code === "invalid_state"))
-                            throw e2;
-                    }
-                    await new Promise((r) => setTimeout(r, 10));
-                }
-                throw haltRefused("the task is no longer running");
-            },
-            destroy: () => (destroyOnce ??= (async () => {
-                const h = handle ?? (await orTimeout(ready));
-                if (h) {
-                    h.abortController.abort();
-                    void h.harness.abort();
-                }
-                await orTimeout(run.catch(() => { }));
-                await reapSuspended();
-            })()),
+            steer,
+            notify,
+            optOutMemoryCapture,
+            compact,
+            detach,
+            interrupt,
+            halt,
+            destroy,
         };
     }
     async runLocked(spec, queue, setResult, onSuggestions, onReady, onSuspend, manualCompactRef, taskIdRef, resume, internals, notifyRef, captureOptOutRef, entryActor, entryTracer) {

package/dist/core/runner/stream-halt-verbs.d.ts

@@ -0,0 +1,38 @@
+/**
+ * design/393 S4 — the TaskStream façade's HALT verbs (T7), verbatim from `Runner.runTaskStream`: `halt` (the bare
+ * user interrupt — the finished-task refusal, the fresh liveness test on the resolved handle, `apply` with its
+ * pre-abort ownership snapshot, the conjunctive attribution seat, the unconsumed-halt and turn-cut notices, and
+ * the birth-window poll; never on the steer FIFO chain) and `destroy` (the once-memoized reap: abort, await the
+ * run's settle bounded, then the reap lane's step). Two Runner reads, both the deployment's notice sink.
+ *
+ * Both closures are the ones the one-file façade returned, installed by the driver under their old names — no
+ * await inside either moved off its tick. `destroyOnce` (the verb's memo) moved with the verb: it is written and
+ * read by `destroy` alone.
+ */
+import { type TaskSpec, type TaskStream } from "../types.js";
+import type { LiveHandle, RunnerDepsSeat, TaskStreamLiveSeat } from "./contracts.js";
+export interface StreamHaltVerbsInput {
+    /** borrowed-readonly — the task spec (`taskId` on the notices' detail). */
+    spec: TaskSpec;
+    /** borrowed-readonly — the stream's live state: `resultValue` (the finished-task refusal, the liveness tests) and `handle`. */
+    live: TaskStreamLiveSeat;
+    /** borrowed-readonly — the readiness promise; halt and destroy resolve the handle through it while the run body has not published one. */
+    ready: Promise<LiveHandle | undefined>;
+    /** borrowed-readonly — the driver's timeout race, used for the readiness wait and for destroy's wait on the run's settle. */
+    orTimeout: <T>(p: Promise<T>) => Promise<T | undefined>;
+    /** borrowed-readonly — the readiness bound in ms; the halt's birth-window poll reads it. */
+    readyTimeoutMs: number;
+    /** borrowed-readonly — the run promise: `destroy` awaits its settle (bounded) before reaping. */
+    run: Promise<void>;
+    /** borrowed-readonly — the reap lane's step, run after the run settled (the suspended-run env + checkpoint reap). */
+    reapSuspended: () => Promise<void>;
+    /** borrowed-readonly — the Runner's deployment deps, read LIVE (`onNotice`, after the readiness await). */
+    runner: RunnerDepsSeat;
+}
+export interface StreamHaltVerbsResult {
+    /** The stream's `halt` verb. */
+    halt: TaskStream["halt"];
+    /** The stream's `destroy` verb (idempotent at the promise level; never throws). */
+    destroy: TaskStream["destroy"];
+}
+export declare function streamHaltVerbs(input: StreamHaltVerbsInput): StreamHaltVerbsResult;