@sema-agent/core 7.10.0 → 7.11.1

package/dist/core/runner/stream-halt-verbs.js

@@ -0,0 +1,82 @@
+import { deliverEngineNotice } from "../types.js";
+export function streamHaltVerbs(input) {
+    const { spec, live, ready, orTimeout, readyTimeoutMs: READY_TIMEOUT_MS, run, reapSuspended, runner } = input;
+    let destroyOnce;
+    const halt = async () => {
+        const haltRefused = (msg) => {
+            const e = new Error(`cannot halt: ${msg}`);
+            e.code = "steering.not_running";
+            return e;
+        };
+        if (live.resultValue)
+            throw haltRefused("the task has already finished");
+        const h = live.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(runner.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(runner.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 (live.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 (live.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");
+    };
+    const destroy = () => (destroyOnce ??= (async () => {
+        const h = live.handle ?? (await orTimeout(ready));
+        if (h) {
+            h.abortController.abort();
+            void h.harness.abort();
+        }
+        await orTimeout(run.catch(() => { }));
+        await reapSuspended();
+    })());
+    return { halt, destroy };
+}

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

@@ -0,0 +1,34 @@
+import type { ToolDetachHub } from "../tool-detach.js";
+import type { TaskStream } from "../types.js";
+import type { CaptureOptOutRef, LiveHandle, ManualCompactRef, NotifyRef, TaskStreamLiveSeat } from "./contracts.js";
+export interface StreamLifecycleVerbsInput {
+    /** borrowed-readonly — the stream's live state: `resultValue` (the finished-task refusals) and `handle`, read at each call. */
+    live: TaskStreamLiveSeat;
+    /** borrowed-readonly — the readiness promise the four async verbs await before they touch the handle. */
+    ready: Promise<LiveHandle | undefined>;
+    /** borrowed-readonly — the driver's timeout race: a wedged prepare cannot hang a verb on `ready`. */
+    orTimeout: <T>(p: Promise<T>) => Promise<T | undefined>;
+    /** borrowed-readonly — the driver's typed steering refusal (`steering.not_running` by default); the opt-out and compact verbs share it. */
+    steeringError: (msg: string, code?: string) => Error;
+    /** borrowed-readonly — the notify bridge; `inject` is bound by the run body once the notification lane exists. */
+    notifyRef: NotifyRef;
+    /** borrowed-readonly — the capture opt-out bridge; `flip` is bound by the run body when a memory session mounted. */
+    captureOptOutRef: CaptureOptOutRef;
+    /** borrowed-mutable — the manual-compaction request seat: the compact verb arms it and parks its waiter here. */
+    manualCompactRef: ManualCompactRef;
+    /** borrowed-readonly — the run-local detach hub the detach verb requests through. */
+    detachHub: ToolDetachHub;
+}
+export interface StreamLifecycleVerbsResult {
+    /** The stream's `notify` verb. */
+    notify: TaskStream["notify"];
+    /** The stream's `optOutMemoryCapture` verb. */
+    optOutMemoryCapture: TaskStream["optOutMemoryCapture"];
+    /** The stream's `compact` verb. */
+    compact: TaskStream["compact"];
+    /** The stream's `detach` verb. */
+    detach: TaskStream["detach"];
+    /** The stream's `interrupt` verb. */
+    interrupt: TaskStream["interrupt"];
+}
+export declare function streamLifecycleVerbs(input: StreamLifecycleVerbsInput): StreamLifecycleVerbsResult;

package/dist/core/runner/stream-lifecycle-verbs.js

@@ -0,0 +1,126 @@
+import { isSystemInjectionPriority, SYSTEM_INJECTION_PRIORITIES } from "../task-notification.js";
+export function streamLifecycleVerbs(input) {
+    const { live, ready, orTimeout, steeringError, notifyRef, captureOptOutRef, manualCompactRef, detachHub } = input;
+    const 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 = live.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);
+    };
+    const 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 (live.resultValue)
+            throw steeringError("the task has already finished");
+        const h = live.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);
+    };
+    const compact = async (opts) => {
+        if (live.resultValue)
+            throw steeringError("the task has already finished");
+        if (opts?.signal?.aborted)
+            return "mooted";
+        const h = live.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);
+        });
+    };
+    const detach = (toolCallId) => {
+        detachHub.request(toolCallId);
+    };
+    const interrupt = async () => {
+        const h = live.handle ?? (await orTimeout(ready));
+        if (!h)
+            return;
+        if (!h.abortController.signal.aborted)
+            h.loop.userInterrupted = true;
+        h.abortController.abort();
+        void h.harness.abort();
+    };
+    return { notify, optOutMemoryCapture, compact, detach, interrupt };
+}

package/dist/core/runner/stream-reap.d.ts

@@ -0,0 +1,30 @@
+/**
+ * design/393 S4 — the TaskStream façade's REAP lane (T4), verbatim from `Runner.runTaskStream`: `destroy()`'s
+ * once-memoized work for a run that SUSPENDED. Runs AFTER `run` has settled (the destroy verb awaits the run before
+ * calling it), fences any concurrent resume first (the single-shot `expire` CAS — only the winner destroys the
+ * paused env; a loser retires its reap record only when no same-Runner claimant is in flight), evicts the
+ * terminally expired token's parked-constraint entry, and destroys the paused env best-effort behind a
+ * swallow-guarded onError sink so the memoized `destroy()` promise keeps its "never throws" contract.
+ *
+ * The lane returns the same async function the one-file façade declared; the destroy verb still calls it in the
+ * same position (after its own `await orTimeout(run.catch(…))`), so every await inside it sits on the tick it did.
+ */
+import type { CheckpointToken } from "../checkpoint-store.js";
+import type { InheritedGate, RunnerDepsSeat, SuspendReap, TaskStreamLiveSeat } from "./contracts.js";
+export interface StreamReapInput {
+    /** borrowed-readonly — the stream's live state; `reapHandle` is read ONCE at the call (the run has settled, so it is the terminal fact). */
+    live: TaskStreamLiveSeat;
+    /** borrowed-readonly — the Runner's deployment deps, read LIVE (`onError`, after the fence's await too). */
+    runner: RunnerDepsSeat;
+    /** borrowed-readonly — the Runner's same-Runner claim marks: a lost fence preserves the reap record only while one is in flight. */
+    locallyClaimedTokens: Set<CheckpointToken>;
+    /** borrowed-mutable — the Runner's parked-constraint registry: the expired token's entry is evicted. */
+    parentConstraintRegistry: Map<CheckpointToken, NonNullable<InheritedGate["parentConstraints"]>>;
+    /** borrowed-mutable — the Runner's suspended-env reap handles: the winner (and an unclaimed loser) retires this token's record. */
+    suspendedEnvReaps: Map<CheckpointToken, SuspendReap>;
+}
+export interface StreamReapResult {
+    /** The reap step the destroy verb runs after the run settled: fence, evict, destroy the paused env — never throws. */
+    reapSuspended: () => Promise<void>;
+}
+export declare function streamReap(input: StreamReapInput): StreamReapResult;

package/dist/core/runner/stream-reap.js

@@ -0,0 +1,40 @@
+import { hasDestroy } from "../remote-env.js";
+export function streamReap(input) {
+    const { live, runner, locallyClaimedTokens, parentConstraintRegistry, suspendedEnvReaps } = input;
+    const reapSuspended = async () => {
+        const rh = live.reapHandle;
+        if (!rh)
+            return;
+        const reportErr = (err) => {
+            try {
+                runner.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 (!locallyClaimedTokens.has(rh.token))
+                suspendedEnvReaps.delete(rh.token);
+            return;
+        }
+        parentConstraintRegistry.delete(rh.token);
+        suspendedEnvReaps.delete(rh.token);
+        if (rh.env && hasDestroy(rh.env)) {
+            try {
+                await rh.env.destroy();
+            }
+            catch (err) {
+                reportErr(err);
+            }
+        }
+    };
+    return { reapSuspended };
+}

package/dist/core/runner/stream-settle-backstop.d.ts

@@ -0,0 +1,38 @@
+import type { CheckpointToken } from "../checkpoint-store.js";
+import type { PushQueue } from "../push-queue.js";
+import type { SessionStore } from "../session.js";
+import { type TaskEvent, type TaskSpec } from "../types.js";
+import type { InheritedGate, ResumeRun, RunnerDepsSeat, SuspendReap, TaskIdRef, TaskStreamLiveSeat } from "./contracts.js";
+export interface StreamSettleBackstopInput {
+    /** borrowed-readonly — the task spec (read for the subagent-forwarding predicate the terminal push drains under). */
+    spec: TaskSpec;
+    /** borrowed-readonly — the resume plan when this leg is a resume: its token, the reopen compensation, the delivered-decision facts. */
+    resume: ResumeRun | undefined;
+    /** borrowed-mutable — the stream's event queue: the backstop pushes the `done` frame and closes it. */
+    queue: PushQueue<TaskEvent>;
+    /** borrowed-mutable — the run body's backstop carrier (effective ids + post-prepare observations); the owed delegation terminal is cleared here once delivered. */
+    taskIdRef: TaskIdRef;
+    /** borrowed-readonly — the invocation's frozen tracer (one sink for the start↔end pair). */
+    entryTracer: {
+        tracer: TaskSpec["tracer"];
+    };
+    /** borrowed-readonly — the stream's construction instant, for the backstop `task.end`'s durationMs. */
+    runStartedAt: number;
+    /** borrowed-mutable — the stream's live state: `resultValue` is read (an already-minted terminal is kept) and written (the failed terminal is minted onto it). */
+    live: TaskStreamLiveSeat;
+    /** borrowed-readonly — the Runner's deployment deps, read LIVE (`onError`, `onDelegationLifecycle`, after awaits too). */
+    runner: RunnerDepsSeat;
+    /** borrowed-readonly — the Runner's session store (the terminal resume-failure arm's `unpin`). */
+    sessions: SessionStore;
+    /** borrowed-mutable — the Runner's same-Runner claim marks: every failure leg releases the resume token's claim. */
+    locallyClaimedTokens: Set<CheckpointToken>;
+    /** borrowed-mutable — the Runner's parked-constraint registry: the reopen-failure and terminal-failure arms evict the consumed resume token's entry. */
+    parentConstraintRegistry: Map<CheckpointToken, NonNullable<InheritedGate["parentConstraints"]>>;
+    /** borrowed-mutable — the Runner's suspended-env reap handles: the terminal resume-failure arm takes and destroys this token's. */
+    suspendedEnvReaps: Map<CheckpointToken, SuspendReap>;
+}
+export interface StreamSettleBackstopResult {
+    /** The rejection handler for `run.catch(…)` — the driver installs it; awaiting `run.catch(onRunRejected)` is awaiting the settled result. */
+    onRunRejected: (err: unknown) => Promise<void>;
+}
+export declare function streamSettleBackstop(input: StreamSettleBackstopInput): StreamSettleBackstopResult;

package/dist/core/runner/stream-settle-backstop.js

@@ -0,0 +1,113 @@
+import { errorCodeOf } from "./assemble-result.js";
+import { resumeDecisionWasNegative } from "./decide-continuation.js";
+import { drainForwardedFramesBeforeDone, forwardsSubagentEvents } from "./prepare-run-refs.js";
+import { hasDestroy } from "../remote-env.js";
+import { createSafeNotifier } from "../safe-notify.js";
+import { settleTeardownLeg } from "./teardown-bounded.js";
+import { emitTrace } from "../trace.js";
+import { deliverDelegationLifecycle } from "../types.js";
+export function streamSettleBackstop(input) {
+    const { spec, resume, queue, taskIdRef, entryTracer, runStartedAt, live, runner, sessions, locallyClaimedTokens, parentConstraintRegistry, suspendedEnvReaps } = input;
+    const onRunRejected = 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) {
+                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)
+            locallyClaimedTokens.delete(resume.cp.token);
+        if (resume && !reopenCommitted) {
+            parentConstraintRegistry.delete(resume.cp.token);
+            await settleTeardownLeg(() => sessions.unpin?.(resume.cp.sessionId), "sessions.unpin (resume-failure leg)", (e) => runner.deps.onError?.(e, { phase: "config", sessionId: resume.cp.sessionId }));
+            if (!reopenStateUnknown) {
+                const failedReap = suspendedEnvReaps.get(resume.cp.token);
+                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) => runner.deps.onError?.(e, { phase: "config", sessionId: resume.cp.sessionId }));
+                }
+            }
+        }
+        if (live.resultValue !== undefined) {
+            try {
+                runner.deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "config", sessionId: live.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;
+        })();
+        live.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(runner.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: live.resultValue });
+        queue.close();
+    };
+    return { onRunRejected };
+}

package/dist/core/runner/stream-steer-verb.d.ts

@@ -0,0 +1,30 @@
+import type { PushQueue } from "../push-queue.js";
+import { type TaskEvent, type TaskSpec, type TaskStream } from "../types.js";
+import type { AcceptedSteerInput, LiveHandle, RunInternals, RunnerDepsSeat, TaskStreamLiveSeat } from "./contracts.js";
+export interface StreamSteerVerbInput {
+    /** borrowed-readonly — the task spec (the hooks seat, `principal`, `taskId`). */
+    spec: TaskSpec;
+    /** borrowed-readonly — the trusted run-internals channel (the spawning tool id the ledger frame carries). */
+    internals: RunInternals | undefined;
+    /** borrowed-mutable — the stream's event queue: the `human_input` receipt is pushed here on acceptance. */
+    queue: PushQueue<TaskEvent>;
+    /** borrowed-mutable — this stream's accepted-input dedup domain (the SAME Map the driver clears when the run settles). */
+    acceptedSteerInputs: Map<string, AcceptedSteerInput>;
+    /** borrowed-readonly — the stream's live state: `resultValue` and `handle`, read at each liveness test. */
+    live: TaskStreamLiveSeat;
+    /** borrowed-readonly — the readiness promise (settles to the live handle, or `undefined` when the run ended first). */
+    ready: Promise<LiveHandle | undefined>;
+    /** borrowed-readonly — the driver's bounded race over a promise (the wedged-prepare guard). */
+    orTimeout: <T>(p: Promise<T>) => Promise<T | undefined>;
+    /** borrowed-readonly — the readiness bound in ms; the birth-window poll's deadline reads it too. */
+    readyTimeoutMs: number;
+    /** borrowed-readonly — the driver's typed steering refusal (`steering.not_running` by default). */
+    steeringError: (msg: string, code?: string) => Error;
+    /** borrowed-readonly — the Runner's deployment deps, read LIVE (`hooks`, `onError`, `onNotice`, after awaits too). */
+    runner: RunnerDepsSeat;
+}
+export interface StreamSteerVerbResult {
+    /** The stream's `steer` verb. */
+    steer: TaskStream["steer"];
+}
+export declare function streamSteerVerb(input: StreamSteerVerbInput): StreamSteerVerbResult;