@sema-agent/core 7.11.1 → 7.12.0

package/dist/core/runner/run-reasoning-seat.d.ts

@@ -0,0 +1,27 @@
+/**
+ * design/393 S5 — the run body's REASONING seat (R5), verbatim from `Runner.runLocked`: the leg-entry resolution of
+ * the requested reasoning intensity against the model's real capability, the ONE publisher that writes both faces
+ * (the `reasoning.resolved` trace frame and the `TaskResult.effectiveReasoning` seat on the backstop carrier), and
+ * the wire-facts consumer that lets the leg's FIRST committed request correct the cap-blind mint (once; foreign
+ * reports are contained at their call sites, not here).
+ */
+import { type ReasoningWireFacts, type ResolvedReasoning } from "../../brain/reasoning.js";
+import type { Prepared, RunState, TaskIdRef } from "./contracts.js";
+export interface RunReasoningSeatInput {
+    /** borrowed-readonly — the leg's prepared seat: the requested thinking level and the model. */
+    prepared: Prepared;
+    /** borrowed-readonly — the run's mutable state, read for the trace frames' tracer and task id. */
+    rs: RunState;
+    /** borrowed-mutable — the stream layer's backstop carrier: `effectiveReasoning` is published here at every mint. */
+    taskIdRef: TaskIdRef | undefined;
+}
+export interface RunReasoningSeatResult {
+    /** The CONSUMPTION half of {@link ReasoningWireFacts} — installed as the third brain ALS sink. */
+    observeReasoningWireFacts: (facts: ReasoningWireFacts) => void;
+    /** #327 — the leg's resolution as a READ FACE over this lane's own `let` (the leg-entry mint, then at most one
+     *  first-committed-request correction): the settle lane's result assembly reads it for `effectiveReasoning`. */
+    reasoningResolution: {
+        readonly current: ResolvedReasoning | undefined;
+    };
+}
+export declare function runReasoningSeat(input: RunReasoningSeatInput): RunReasoningSeatResult;

package/dist/core/runner/run-reasoning-seat.js

@@ -0,0 +1,48 @@
+import { resolveReasoning } from "../../brain/reasoning.js";
+import { emitTrace } from "../trace.js";
+export function runReasoningSeat(input) {
+    const { prepared, rs, taskIdRef } = input;
+    let reasoningResolution = prepared.thinking && prepared.thinking !== "off" ? resolveReasoning(prepared.thinking, prepared.model) : undefined;
+    const publishReasoningResolution = (r) => {
+        reasoningResolution = r;
+        if (taskIdRef)
+            taskIdRef.effectiveReasoning = r;
+        emitTrace(rs.telemetry.tracer, () => ({
+            kind: "reasoning.resolved",
+            version: 1,
+            taskId: rs.telemetry.taskId,
+            model: prepared.model.id,
+            requested: r.requested,
+            effective: r.effective,
+            graded: r.graded,
+            clamped: r.clamped,
+            format: r.format,
+            endpoint: r.endpoint,
+            ...(r.dropped === true ? { dropped: true } : {}),
+            ts: Date.now(),
+        }));
+    };
+    if (reasoningResolution !== undefined)
+        publishReasoningResolution(reasoningResolution);
+    let reasoningFactsConsumed = false;
+    const observeReasoningWireFacts = (facts) => {
+        if (reasoningFactsConsumed)
+            return;
+        reasoningFactsConsumed = true;
+        if (prepared.thinking === undefined || prepared.thinking === "off")
+            return;
+        const next = resolveReasoning(prepared.thinking, prepared.model, facts);
+        const current = reasoningResolution;
+        if (current !== undefined &&
+            current.effective === next.effective &&
+            current.graded === next.graded &&
+            current.clamped === next.clamped &&
+            current.format === next.format &&
+            current.endpoint === next.endpoint &&
+            current.dropped === next.dropped) {
+            return;
+        }
+        publishReasoningResolution(next);
+    };
+    return { observeReasoningWireFacts, reasoningResolution: { get current() { return reasoningResolution; } } };
+}

package/dist/core/runner/run-recovery-lanes.d.ts

@@ -0,0 +1,54 @@
+import type { Model } from "../../internal/llm.js";
+import { type MaybeCompactOptions } from "../auto-compaction.js";
+import type { HookInvocationIdentity } from "../hooks.js";
+import type { PushQueue } from "../push-queue.js";
+import type { Brain, TaskEvent, TaskSpec } from "../types.js";
+import type { Prepared, RunnerDepsSeat, RunState } from "./contracts.js";
+export interface RunRecoveryLanesInput {
+    /** borrowed-readonly — the task spec: the compaction settings / instructions and the key-and-headers seat. */
+    spec: TaskSpec;
+    /** borrowed-mutable — the leg's prepared seat: the loop recovery chain is installed on its harness, the arm-B seat
+     *  on `microCompact.inTurnCompactionRef`, the MC-R clears on `microCompact.ledger`; the abort signal, the pause
+     *  holder, the session, the compaction model and the cache-break detector are read. */
+    prepared: Prepared;
+    /** borrowed-mutable — the run's event queue: the `compacted` and `compaction_outcome` frames of both arms. */
+    queue: PushQueue<TaskEvent>;
+    /** borrowed-mutable — the run's mutable state: the anti-thrash floor (`counters.compactionFloor`) is raised and
+     *  consulted, the post-compact announce latch armed and the cadence windows rebased on `attach.attachState`. */
+    rs: RunState;
+    /** borrowed-readonly — the run's event-identity mint. */
+    ident: () => {
+        eventId: string;
+        parentToolCallId?: string;
+        sourceTaskId?: string;
+    };
+    /** borrowed-readonly — the ACCOUNTED compaction brain (the compaction-machinery lane's), handed to every pass. */
+    compactionBrain: Brain;
+    /** borrowed-mutable — the shared consecutive-failure breaker: read by the gates, zeroed on a landing (and on a
+     *  noop), bumped on a burned pass. */
+    compactionBreaker: {
+        failures: number;
+    };
+    /** borrowed-readonly — the window-safety option builder (the compaction-machinery lane's), per pass. */
+    windowSafetyOptions: (mainModel: Model) => Pick<MaybeCompactOptions, "fallbackBudget" | "onWindowSafety">;
+    /** borrowed-readonly — the Runner's deployment deps, read LIVE (`onError`). */
+    runner: RunnerDepsSeat;
+    /** borrowed-readonly — the Runner's three compaction methods as delegates: the Seam C reuse options, the hook
+     *  option wrapper and the reuse counter. The method bodies stay the Runner's; the pass calls them as the run body did. */
+    compactionSeats: {
+        seamCCompactionOptions: (prepared: Prepared) => Pick<MaybeCompactOptions, "summaryProvider" | "onCompaction" | "maxConsecutiveProviderReuse" | "consecutiveProviderReuse"> | undefined;
+        compactionHookOptions: (spec: TaskSpec, sessionId: string, trigger: "auto" | "manual" | "forced", identity?: HookInvocationIdentity, seatBound?: {
+            timeoutMs: number;
+            signal?: AbortSignal;
+        }) => Pick<MaybeCompactOptions, "trigger" | "preCompact" | "postCompact">;
+        recordCompactionReuse: (prepared: Prepared, comp: {
+            compacted: boolean;
+            reused?: boolean;
+        }) => void;
+    };
+}
+/** Nothing comes back: the lane's products are INSTALLED on the seats it borrowed — the harness's loop recovery
+ *  chain and the microCompact arm-B seat — and the shared pass is read by those two installations alone. */
+export interface RunRecoveryLanesResult {
+}
+export declare function runRecoveryLanes(input: RunRecoveryLanesInput): RunRecoveryLanesResult;

package/dist/core/runner/run-recovery-lanes.js

@@ -0,0 +1,180 @@
+import { DEFAULT_COMPACTION_SETTINGS } from "../../internal/harness.js";
+import { planRejectionClears } from "../context-edit.js";
+import { DEFAULT_COMPACTION_INSTRUCTIONS, maybeCompact } from "../auto-compaction.js";
+import { emitTrace } from "../trace.js";
+import { isDegenerateCutMessage } from "../../brain/terminal-cause.js";
+import { rebaseCadenceWindows } from "./turn-attachments.js";
+import { buildWorkingFileAttachments, centerAdoptionOption, contextInstructionFilesOption, emitInputTruncated, forkContextOption } from "./compaction-call-options.js";
+import { gitRestateOption } from "./git-leg-delivery.js";
+import { COMPACTION_FREED_EPSILON, COMPACTION_REGROWTH_FACTOR, MAX_CONSECUTIVE_COMPACTION_FAILURES } from "./compaction-knobs.js";
+export function runRecoveryLanes(input) {
+    const { spec, prepared, queue, rs, ident, compactionBrain, compactionBreaker, windowSafetyOptions, runner, compactionSeats } = input;
+    const runForcedCompactionPass = async (lane, turnSignal) => {
+        if (!(spec.compaction?.enabled ?? true))
+            return false;
+        if (compactionBreaker.failures >= MAX_CONSECUTIVE_COMPACTION_FAILURES)
+            return false;
+        const passSignal = turnSignal !== undefined ? AbortSignal.any([prepared.abortController.signal, turnSignal]) : prepared.abortController.signal;
+        try {
+            const comp = await maybeCompact({
+                session: prepared.session,
+                epochDeclaredSections: prepared.epochDeclaredSections,
+                ...centerAdoptionOption(prepared),
+                model: prepared.harness.getModel(),
+                compactionModel: prepared.compModel,
+                ...forkContextOption(prepared, true),
+                brain: compactionBrain,
+                getApiKeyAndHeaders: spec.getApiKeyAndHeaders,
+                thinking: prepared.thinking,
+                settings: { ...DEFAULT_COMPACTION_SETTINGS, ...spec.compaction },
+                customInstructions: spec.compaction?.instructions ?? DEFAULT_COMPACTION_INSTRUCTIONS,
+                signal: passSignal,
+                minTokens: 0,
+                force: true,
+                overheadTokens: prepared.promptOverheadTokens,
+                ...(prepared.activeTools.size > 0 ? { activeTools: [...prepared.activeTools] } : {}),
+                onInputTruncated: emitInputTruncated(rs.telemetry.tracer, rs.telemetry.taskId),
+                workingFileAttachments: buildWorkingFileAttachments(spec, prepared),
+                ...contextInstructionFilesOption(prepared),
+                ...(prepared.onCompactionApplied ? { onApplied: prepared.onCompactionApplied } : {}),
+                ...compactionSeats.seamCCompactionOptions(prepared),
+                ...gitRestateOption(prepared),
+                ...windowSafetyOptions(prepared.harness.getModel()),
+                ...compactionSeats.compactionHookOptions(spec, prepared.sessionId, "forced", prepared.hookIdentity, { timeoutMs: prepared.hookTimeoutMs, signal: passSignal }),
+            });
+            if (comp.compacted) {
+                compactionBreaker.failures = 0;
+                compactionSeats.recordCompactionReuse(prepared, comp);
+                if ((comp.freedTokens ?? 0) >= COMPACTION_FREED_EPSILON) {
+                    const postSize = comp.postTriggerTokens ?? Math.max(0, (comp.triggerTokens ?? comp.tokensBefore ?? 0) - (comp.freedTokens ?? 0));
+                    rs.counters.compactionFloor = Math.ceil(postSize * COMPACTION_REGROWTH_FACTOR);
+                }
+                queue.push({
+                    type: "compacted",
+                    trigger: "forced",
+                    tokensBefore: comp.tokensBefore ?? 0,
+                    ...(comp.postTriggerTokens !== undefined ? { tokensAfter: comp.postTriggerTokens } : {}),
+                    ...(comp.triggerTokens !== undefined ? { triggerTokensBefore: comp.triggerTokens } : {}),
+                    ...(comp.durationMs !== undefined ? { durationMs: comp.durationMs } : {}),
+                    ...(comp.phaseDurations !== undefined ? { phaseDurations: comp.phaseDurations } : {}),
+                    ...(comp.firstKeptEntryId !== undefined ? { preserved_segment: { firstKeptEntryId: comp.firstKeptEntryId } } : {}),
+                    ...(comp.attachedFiles !== undefined ? { attachedFiles: comp.attachedFiles } : {}),
+                    ...(comp.modelFallback ? { modelFallback: true } : {}),
+                    ...(comp.fallbackReason !== undefined ? { fallbackReason: comp.fallbackReason } : {}),
+                    ...(comp.clampedRatio !== undefined ? { clampedRatio: comp.clampedRatio } : {}),
+                    ...(comp.clampReason !== undefined ? { clampReason: comp.clampReason } : {}),
+                    ...ident(),
+                });
+                if (comp.phaseDurations !== undefined && comp.durationMs !== undefined) {
+                    const pd = comp.phaseDurations;
+                    const pdDur = comp.durationMs;
+                    emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.phase_timings", version: 1, taskId: rs.telemetry.taskId, ...pd, durationMs: pdDur, ts: Date.now() }));
+                }
+                prepared.cacheBreakDetector?.notifyCompaction();
+                if (rs.attach.attachState !== undefined) {
+                    rs.attach.attachState.postCompactPending = true;
+                    rebaseCadenceWindows(rs.attach.attachState, rs.counters.cadenceTurns);
+                }
+            }
+            else {
+                if (comp.noop) {
+                    compactionBreaker.failures = 0;
+                }
+                else {
+                    compactionBreaker.failures += 1;
+                }
+                const declineReason = lane === "rejection" ? "prompt-too-long recovery pass did not land" : "guard-chain forced compaction pass did not land";
+                if (!comp.noop) {
+                    runner.deps.onError?.(new Error(declineReason), { phase: "compaction", sessionId: prepared.sessionId });
+                }
+                queue.push({
+                    type: "compaction_outcome",
+                    outcome: comp.noop ? "noop" : "failed",
+                    trigger: "forced",
+                    reason: declineReason,
+                    ...ident(),
+                });
+            }
+            return comp.compacted === true;
+        }
+        catch (err) {
+            if (turnSignal?.aborted === true && !prepared.abortController.signal.aborted) {
+                const interruptReason = lane === "rejection"
+                    ? "prompt-too-long recovery pass cut short by a turn interrupt"
+                    : "guard-chain forced compaction cut short by a turn interrupt";
+                queue.push({ type: "compaction_outcome", outcome: "failed", trigger: "forced", reason: interruptReason, ...ident() });
+                return false;
+            }
+            compactionBreaker.failures += 1;
+            runner.deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "compaction", sessionId: prepared.sessionId });
+            const msg = String(err instanceof Error ? err.message : err);
+            queue.push({ type: "compaction_outcome", outcome: "failed", trigger: "forced", reason: msg.length > 512 ? `${msg.slice(0, 512)}…` : msg, ...ident() });
+            return false;
+        }
+    };
+    prepared.harness.setLoopRecovery({
+        truncatedOutput: {},
+        malformedToolUse: {},
+        thinkingOnly: {},
+        degenerateOutput: { detect: (m) => isDegenerateCutMessage(m) },
+        promptTooLong: {
+            recover: async (attempt, turnSignal) => {
+                if (prepared.abortController.signal.aborted || prepared.pausedRef.current !== undefined)
+                    return false;
+                if (turnSignal?.aborted === true)
+                    return false;
+                if (prepared.microCompact.clearOnRejection && attempt === 1) {
+                    const proj = prepared.microCompact.projectionRef.current;
+                    const compactionAvailable = (spec.compaction?.enabled ?? true) && compactionBreaker.failures < MAX_CONSECUTIVE_COMPACTION_FAILURES;
+                    const declineArm = compactionAvailable ? "forced_compaction" : "none";
+                    const plan = proj === undefined
+                        ? { declined: "no_candidates" }
+                        : planRejectionClears(proj.messages, {
+                            keyOf: proj.keyOf,
+                            ...(prepared.microCompact.offloadPersist ? { offload: { persist: prepared.microCompact.offloadPersist } } : {}),
+                        });
+                    if ("declined" in plan) {
+                        emitTrace(rs.telemetry.tracer, () => ({
+                            kind: "context.mc_null",
+                            version: 1,
+                            taskId: rs.telemetry.taskId,
+                            reason: plan.declined,
+                            nextArm: declineArm,
+                            ts: Date.now(),
+                        }));
+                    }
+                    else {
+                        for (const e of plan.cleared) {
+                            prepared.microCompact.ledger.entries.set(e.key, { marker: e.marker, groupCount: e.groupCount, fp: e.fp });
+                        }
+                        emitTrace(rs.telemetry.tracer, () => ({
+                            kind: "context.mc_clear",
+                            version: 1,
+                            taskId: rs.telemetry.taskId,
+                            clearedCount: plan.cleared.length,
+                            tokensSavedEstimate: plan.tokensSavedEstimate,
+                            trigger: "refusal",
+                            ts: Date.now(),
+                        }));
+                        return true;
+                    }
+                }
+                return runForcedCompactionPass("rejection", turnSignal);
+            },
+        },
+    });
+    prepared.microCompact.inTurnCompactionRef.current = async (turnSignal, anchoredEstimate) => {
+        if (prepared.abortController.signal.aborted || prepared.pausedRef.current !== undefined)
+            return false;
+        if (turnSignal?.aborted === true)
+            return false;
+        if (anchoredEstimate !== undefined && rs.counters.compactionFloor > 0 && anchoredEstimate < rs.counters.compactionFloor) {
+            const floor = rs.counters.compactionFloor;
+            emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.suppressed", version: 1, taskId: rs.telemetry.taskId, estTokens: anchoredEstimate, floor, ts: Date.now() }));
+            queue.push({ type: "compaction_outcome", outcome: "suppressed", trigger: "forced", ...ident() });
+            return false;
+        }
+        return runForcedCompactionPass("guard", turnSignal);
+    };
+    return {};
+}

package/dist/core/runner/run-settle-and-teardown.d.ts

@@ -0,0 +1,109 @@
+/**
+ * design/393 S6 — the run body's SETTLE AND TEARDOWN (R15), verbatim from `Runner.runLocked`: the end-of-task
+ * compaction's frames and detector reset, the nested-stats fold, the prefix-cache observability and its loud
+ * mismatch / low-hit disclosures, the cross-slice cumulative spend fold, the human-review and mechanism counters,
+ * the result assembly (`assembleResult` — the one place the leg's facts become a TaskResult), the resume leg's
+ * unstarted-action reopen compensation, the read-state seal and the settle-time workspace-state write, the
+ * StopFailure observer, the delegation-lifecycle terminal, the reap-stash for a committed pause, the resumed-terminal
+ * unpin, the memory harvest, the `task.end` trace, `setResult`, the sub-agent's terminal tick, the mooted manual
+ * compaction, the forwarded-frame drain and the queue's `done` + close, the file-history boundary settle and the
+ * prompt-suggestion kickoff — then, in its finally, the four teardown legs in the order they were: the shell-lane
+ * children settle, the background-shell sweep, the registry clears / the background-agent abort / the retained
+ * child sessions, and the owned env's teardown.
+ *
+ * Async (eleven first-level awaits, all of them the same awaits at the same positions). The `queue.push("done")` and
+ * the teardown legs' order are contract (the forwarded-frame drain lands before `done`; the env is torn down after
+ * every reader of it); nothing here reorders them. Products: the result is PUBLISHED through `setResult` and the
+ * effects are installed on the borrowed seats — nothing comes back to the driver (the same empty Result the seat
+ * lanes whose products are all installations carry).
+ */
+import type { AssistantMessage } from "../../internal/llm.js";
+import type { ResolvedReasoning } from "../../brain/reasoning.js";
+import type { PushQueue } from "../push-queue.js";
+import type { SessionStore } from "../session.js";
+import type { CompactOutcome, DelegationLifecycleEvent, TaskEvent, TaskResult, TaskSpec } from "../types.js";
+import { type Stats } from "./assemble-result.js";
+import type { EndOfTaskCompaction, ManualCompactRef, Prepared, ResumeRun, RunInternals, RunnerDepsSeat, RunState, SuspendReap, TaskIdRef } from "./contracts.js";
+export interface RunSettleAndTeardownInput {
+    /** borrowed-readonly — the task spec: the hooks slot, the suggestion opt-in, the retain / forward flags, the task id and principal. */
+    spec: TaskSpec;
+    /** borrowed-mutable — the run's event queue: the compaction / human-input / task_progress / done frames, then CLOSED here. */
+    queue: PushQueue<TaskEvent>;
+    /** borrowed-mutable — the leg's prepared seat: the settle-time seal and workspace write, the refs the result assembly reads, the env the teardown reaps. */
+    prepared: Prepared;
+    /** borrowed-readonly — the resume plan when this leg resumed a checkpoint (the reopen compensation and the unpin read it). */
+    resume: ResumeRun | undefined;
+    /** borrowed-readonly — the trusted run-scoped channel: the delegation task type, cycle seq, parent task id and the display-sink forward. */
+    internals: RunInternals | undefined;
+    /** borrowed-readonly — the run's mutable state, read for the telemetry / degrade / limits / counters the result and the frames report. */
+    rs: RunState;
+    /** borrowed-mutable — this leg's usage counters: the nested / cumulative folds, the cache-hit rate, the mechanism counters are written here. */
+    stats: Stats;
+    /** borrowed-readonly — the run's event-identity mint. */
+    ident: () => {
+        eventId: string;
+        parentToolCallId?: string;
+        sourceTaskId?: string;
+    };
+    /** borrowed-readonly — the spawning tool call's id when this task runs AS A SUB-AGENT (gates the terminal tick). */
+    parentToolCallId: string | undefined;
+    /** borrowed-readonly — the sub-agent display name for the terminal tick. */
+    subagentName: string | undefined;
+    /** borrowed-readonly — the loop-liveness latch: `userHalted` signs the result's halt seat. */
+    loopLatch: {
+        readonly userHalted: boolean;
+    };
+    /** borrowed-readonly — the hard walltime timer: `fired` and `latenessMs` ride the result and the `task.end` frame. */
+    timeout: {
+        readonly fired: boolean;
+        readonly latenessMs?: number;
+    };
+    /** borrowed-readonly — the run's own committed tail (the read-state seal). */
+    ownCommittedTailRef: {
+        readonly current: string | undefined;
+    };
+    /** borrowed-readonly — the delegation-lifecycle emission closure (the terminal station is here). */
+    emitDelegationLifecycle: (event: DelegationLifecycleEvent) => void;
+    /** borrowed-mutable — the stream layer's backstop carrier: the owed delegation terminal is cleared here. */
+    taskIdRef: TaskIdRef | undefined;
+    /** borrowed-mutable — the manual /compact seat: the parked waiters are mooted and the channel closed before `done`. */
+    manualCompactRef: ManualCompactRef;
+    /** borrowed-readonly — the boundary lane's drain of the manual-compact waiters (with the outcome every waiter receives). */
+    drainManualCompact: (outcome: CompactOutcome) => void;
+    /** borrowed-readonly — the leg lane's final assistant message (undefined on every no-prompt arm). */
+    final: AssistantMessage | undefined;
+    /** borrowed-readonly — the adopted terminal cause (the leg's throw, or what the terminal-adoption lane lifted over it). */
+    threw: unknown;
+    /** borrowed-readonly — the live-abort flag captured before the leg's release-abort. */
+    abortedLive: boolean;
+    /** borrowed-readonly — design/174: the answered-but-never-collected deliveries the leg's finally settled. */
+    strandedHumanAnswers: ReadonlyArray<{
+        deliveryId: string;
+        toolCallId: string;
+    }>;
+    /** borrowed-readonly — the reasoning seat's resolution, as the read face on its Result (the result's `effectiveReasoning`). */
+    reasoningResolution: {
+        readonly current: ResolvedReasoning | undefined;
+    };
+    /** borrowed-readonly — the end-of-task compaction's outcome (the terminal-adoption lane's `finish` call). */
+    comp: EndOfTaskCompaction;
+    /** borrowed-readonly — the stream's result setter: the assembled TaskResult is published through it exactly once. */
+    setResult: (r: TaskResult) => void;
+    /** borrowed-readonly — the stream's suggestions seat: the fire-and-forget suggestion pass's promise is handed to it. */
+    onSuggestions: (p: Promise<string[]>) => void;
+    /** borrowed-readonly — the stream's reap-stash for a committed pause (what `destroy()` reaps when the run SUSPENDED). */
+    onSuspend: (reap: SuspendReap) => void;
+    /** borrowed-readonly — the Runner's deployment deps, read LIVE (`onError`, `hooks`, `checkpointStore`, `executionEnv`, `onNotice`);
+     *  the one home of why it is a seat and not a captured object is {@link RunnerDepsSeat}. */
+    runner: RunnerDepsSeat;
+    /** borrowed-readonly — the session store: the resumed-terminal leg unpins the checkpoint's session through it. */
+    sessions: SessionStore;
+    /** borrowed-readonly — the Runner's post-completion prompt-suggestion pass (its private method, as a delegate). */
+    suggestNextPrompts: (spec: TaskSpec, prepared: Prepared, result: TaskResult) => Promise<string[]>;
+    /** borrowed-readonly — the Runner's owned-env teardown (its private method, as a delegate; its gate mirrors the reap-stash's). */
+    teardownOwnedEnv: (prepared: Prepared) => Promise<void>;
+}
+/** Nothing comes back: the result is published through `setResult`, the queue is closed, the teardown legs ran. */
+export interface RunSettleAndTeardownResult {
+}
+export declare function runSettleAndTeardown(input: RunSettleAndTeardownInput): Promise<RunSettleAndTeardownResult>;