@sema-agent/core 7.11.2 → 7.13.0

package/dist/core/runner/run-terminal-adoption.js

@@ -0,0 +1,200 @@
+import { DEFAULT_COMPACTION_INSTRUCTIONS, maybeCompact } from "../auto-compaction.js";
+import { DEFAULT_COMPACTION_SETTINGS } from "../../internal/harness.js";
+import { eventDefaultOn } from "../../prompt-assembly/event-registry.js";
+import { appendInterruptionMarker, reconcileInterruptedSession } from "../session-reconcile.js";
+import { emitTrace } from "../trace.js";
+import { deliverEngineNotice, undrainedUserInputNotices } from "../types.js";
+import { answerSettled, errorCodeOf } from "./assemble-result.js";
+import { awaitChargeWithSlowDisclosure, discloseUnevaluableWindow } from "./clock-and-limits.js";
+import { buildWorkingFileAttachments, centerAdoptionOption, contextInstructionFilesOption, emitInputTruncated, forkContextOption } from "./compaction-call-options.js";
+import { compactionHookOptions, recordCompactionReuse, seamCCompactionOptions } from "./compaction-seams.js";
+import { gitRestateOption } from "./git-leg-delivery.js";
+import { MAX_CONSECUTIVE_COMPACTION_FAILURES } from "./compaction-knobs.js";
+import { reconciledToolEndBody } from "./tool-end-body.js";
+export async function runTerminalAdoption(input) {
+    const { spec, queue, prepared, rs, stats, ident, emitCommitted, startedToolCallIds, toolLabels, timeout, compactionBrain, compactionBreaker, windowSafetyOptions, undrainedUserAtEnd, userInputLostAtEnd, final, abortedLive, userInterruptedLive, runner, sessions, next } = input;
+    let { threw } = input;
+    const settled = answerSettled(final, userInputLostAtEnd.current || prepared.workCutRef.continuation || prepared.workCutRef.abortedBeforeTurnEnd);
+    if (threw === undefined && prepared.brainCallGuardrailRef.timedOut !== undefined) {
+        threw = prepared.brainCallGuardrailRef.timedOut;
+    }
+    if (threw === undefined && prepared.gateStopRef.terminal !== undefined) {
+        threw = prepared.gateStopRef.terminal;
+    }
+    if (rs.limits.platformTerminal !== undefined) {
+        threw = rs.limits.platformTerminal;
+    }
+    if (prepared.usageGovernance !== undefined) {
+        try {
+            await awaitChargeWithSlowDisclosure(prepared.usageGovernance.commit(stats.tokens, rs.telemetry.unpricedSpend ? undefined : stats.costMicroUsd, Date.now()), () => runner.deps.onError?.(new Error("the usage ledger's FINAL charge has not settled after 10s — still waiting (a charge is never abandoned: walking away would double-charge on a later flush). A wedged ledger store wedges this teardown, now visibly."), { phase: "config", sessionId: prepared.sessionId }));
+        }
+        catch (flushErr) {
+            runner.deps.onError?.(flushErr, { phase: "config", sessionId: prepared.sessionId });
+        }
+    }
+    const committedPause = prepared.pausedRef.current;
+    const durablyPaused = committedPause !== undefined;
+    const interrupted = !durablyPaused &&
+        (threw !== undefined || timeout.fired || rs.limits.turnsExceeded || rs.limits.budgetHit !== undefined || abortedLive || final?.stopReason === "aborted");
+    let orphansClosed = 0;
+    let reconcileComplete = false;
+    if (interrupted) {
+        try {
+            const report = await reconcileInterruptedSession(prepared.session, prepared.toolEffects, undefined, startedToolCallIds);
+            orphansClosed = report.recovered.length;
+            for (const orphan of report.recovered) {
+                queue.push({ type: "tool_end", toolCallId: orphan.toolCallId, toolName: orphan.toolName, ...(toolLabels.has(orphan.toolName) ? { label: toolLabels.get(orphan.toolName) } : {}), isError: true, ...reconciledToolEndBody(orphan, prepared.structuredProjector), ...ident() });
+                emitCommitted(orphan.entryId, "toolResult", orphan.toolCallId);
+            }
+            reconcileComplete = true;
+        }
+        catch (reconcileErr) {
+            runner.deps.onError?.(reconcileErr instanceof Error ? reconcileErr : new Error(String(reconcileErr)), {
+                phase: "interrupt-reconcile",
+                sessionId: prepared.sessionId,
+            });
+        }
+        try {
+            await prepared.harness.flushQueuedSessionWrites();
+        }
+        catch (flushErr) {
+            runner.deps.onError?.(flushErr instanceof Error ? flushErr : new Error(String(flushErr)), {
+                phase: "interrupt-reconcile",
+                sessionId: prepared.sessionId,
+            });
+        }
+    }
+    if (interrupted && userInterruptedLive && reconcileComplete && !settled) {
+        try {
+            const entryId = await appendInterruptionMarker(prepared.session, { toolUseInFlight: orphansClosed > 0 });
+            emitCommitted(entryId, "user");
+        }
+        catch (markerErr) {
+            runner.deps.onError?.(markerErr instanceof Error ? markerErr : new Error(String(markerErr)), {
+                phase: "interrupt-reconcile",
+                sessionId: prepared.sessionId,
+            });
+        }
+    }
+    let migratedParked = { steer: 0, followUp: 0 };
+    if (committedPause !== undefined && runner.deps.checkpointStore !== undefined) {
+        const parkToken = committedPause.cause.token;
+        const parkScope = committedPause.scope;
+        const store = runner.deps.checkpointStore;
+        const carried = [];
+        for (const record of prepared.harness.readParkableUserInputs()) {
+            try {
+                if (!(await store.setPendingSteer(parkToken, parkScope, record)))
+                    break;
+                carried.push(record);
+            }
+            catch (parkErr) {
+                runner.deps.onError?.(parkErr instanceof Error ? parkErr : new Error(String(parkErr)), {
+                    phase: "config",
+                    sessionId: prepared.sessionId,
+                });
+                const parkCode = errorCodeOf(parkErr);
+                if (parkCode === "steering.invalid_content" || parkCode === "steering.queue_full")
+                    continue;
+                break;
+            }
+        }
+        migratedParked = prepared.harness.dropParkedUserInputs(carried);
+    }
+    if (undrainedUserAtEnd.current !== undefined) {
+        const remaining = {
+            steer: Math.max(0, undrainedUserAtEnd.current.steer - migratedParked.steer),
+            followUp: Math.max(0, undrainedUserAtEnd.current.followUp - migratedParked.followUp),
+        };
+        for (const notice of undrainedUserInputNotices(remaining, spec.taskId ?? prepared.sessionId, prepared.sessionId, prepared.runId)) {
+            deliverEngineNotice(runner.deps.onNotice, notice);
+        }
+    }
+    if (rs.attach.attachState?.postCompactPending === true && (rs.attach.attachmentsCfg?.backgroundTasks ?? eventDefaultOn("background_tasks")) === true) {
+        emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.announce_dropped", version: 1, taskId: rs.telemetry.taskId, ts: Date.now() }));
+    }
+    const comp = await finish(spec, prepared, {
+        telemetry: { tracer: rs.telemetry.tracer, taskId: rs.telemetry.taskId },
+        skipCompaction: durablyPaused || (abortedLive && settled) || compactionBreaker.failures >= MAX_CONSECUTIVE_COMPACTION_FAILURES,
+        minTokens: rs.counters.compactionFloor,
+        brain: compactionBrain,
+        windowSafety: windowSafetyOptions(prepared.model),
+        onCompactionFailed: (reason) => queue.push({ type: "compaction_outcome", outcome: "failed", trigger: "auto", reason, ...ident() }),
+        cancelled: abortedLive,
+    }, runner, sessions);
+    return await next({ threw, comp, answerSettled: settled });
+}
+async function finish(spec, prepared, opts, runner, sessions) {
+    let comp;
+    if (!opts?.skipCompaction) {
+        try {
+            const finishComp = await maybeCompact({
+                session: prepared.session,
+                epochDeclaredSections: prepared.epochDeclaredSections,
+                ...centerAdoptionOption(prepared),
+                model: prepared.model,
+                compactionModel: prepared.compModel,
+                ...forkContextOption(prepared, false),
+                brain: opts?.brain ?? runner.deps.brain,
+                getApiKeyAndHeaders: spec.getApiKeyAndHeaders,
+                thinking: prepared.thinking,
+                settings: { ...DEFAULT_COMPACTION_SETTINGS, ...spec.compaction },
+                customInstructions: spec.compaction?.instructions ?? DEFAULT_COMPACTION_INSTRUCTIONS,
+                minTokens: opts?.minTokens,
+                overheadTokens: prepared.promptOverheadTokens,
+                ...(prepared.activeTools.size > 0 ? { activeTools: [...prepared.activeTools] } : {}),
+                onInputTruncated: emitInputTruncated(opts?.telemetry?.tracer ?? spec.tracer ?? runner.deps.tracer, opts?.telemetry?.taskId ?? spec.taskId ?? prepared.sessionId),
+                ...(opts?.windowSafety ?? {}),
+                workingFileAttachments: buildWorkingFileAttachments(spec, prepared),
+                ...contextInstructionFilesOption(prepared),
+                ...(prepared.onCompactionApplied ? { onApplied: prepared.onCompactionApplied } : {}),
+                ...seamCCompactionOptions(runner, prepared),
+                ...gitRestateOption(prepared),
+                ...compactionHookOptions(runner, spec, prepared.sessionId, "auto", prepared.hookIdentity, {
+                    timeoutMs: prepared.hookTimeoutMs,
+                    ...(opts?.cancelled === true ? { signal: prepared.abortController.signal } : {}),
+                }),
+            });
+            recordCompactionReuse(runner, prepared, finishComp);
+            if (finishComp.unevaluableWindow) {
+                discloseUnevaluableWindow(finishComp.unevaluableWindow, prepared, opts?.telemetry?.tracer ?? spec.tracer ?? runner.deps.tracer, opts?.telemetry?.taskId ?? spec.taskId ?? prepared.sessionId, runner.deps.onError);
+            }
+            comp = finishComp;
+        }
+        catch (err) {
+            const failMsg = String(err instanceof Error ? err.message : err);
+            const failReason = failMsg.length > 512 ? `${failMsg.slice(0, 512)}…` : failMsg;
+            emitTrace(opts?.telemetry?.tracer ?? spec.tracer ?? runner.deps.tracer, () => ({
+                kind: "compaction.failed",
+                version: 1,
+                taskId: opts?.telemetry?.taskId ?? spec.taskId ?? prepared.sessionId,
+                trigger: "auto",
+                reason: failReason,
+                ts: Date.now(),
+            }));
+            opts?.onCompactionFailed?.(failReason);
+            runner.deps.onError?.(err, { phase: "compaction", sessionId: prepared.sessionId });
+        }
+    }
+    try {
+        await sessions.touch(prepared.sessionId);
+    }
+    catch (err) {
+        runner.deps.onError?.(err, { phase: "config", sessionId: prepared.sessionId });
+    }
+    try {
+        await prepared.mcp.dispose();
+    }
+    catch (err) {
+        runner.deps.onError?.(err, { phase: "mcp", sessionId: prepared.sessionId });
+    }
+    if (prepared.a2a !== undefined) {
+        try {
+            await prepared.a2a.dispose();
+        }
+        catch (err) {
+            runner.deps.onError?.(err, { phase: "a2a", sessionId: prepared.sessionId });
+        }
+    }
+    return comp;
+}

package/dist/core/runner/run-turn-boundary.js

@@ -14,11 +14,12 @@ import { workflowSizeGuidelineChangeNotice } from "../../orchestration/workflow-
 import { awaitChargeWithSlowDisclosure, discloseUnevaluableWindow, ENV_DUE_GOVERNANCE_READ_BUDGET_MS, GOVERNANCE_READ_STALLED, LIMIT_APPROACH_DEFAULT_THRESHOLDS, limitApproachFrames, platformLimitTerminal, raceUntilDeadline } from "./clock-and-limits.js";
 import { gitRestateOption } from "./git-leg-delivery.js";
 import { COMPACTION_FREED_EPSILON, COMPACTION_REGROWTH_FACTOR, MAX_CONSECUTIVE_COMPACTION_FAILURES } from "./compaction-knobs.js";
+import { compactionHookOptions, recordCompactionReuse, seamCCompactionOptions } from "./compaction-seams.js";
 const BATCH_CONTEXT_MIN_KEEP_BYTES = 160;
 const BATCH_TRUNCATION_MARKER = "\n…[truncated]";
 export function createTurnBoundary(input) {
     const { prepared, stats, rs, deps } = input;
-    const { spec, queue, manualCompactRef, todoToolMounted, taskToolsMounted, walltimeMonotonicDeadline, timeout, ident, postToolBatchHook, batchArgs, compactionBrain, withinTaskCompaction, compactionBreaker, windowSafetyOptions, rapidRefill, drainManualCompact, runnerHooks } = deps;
+    const { spec, queue, manualCompactRef, todoToolMounted, taskToolsMounted, walltimeMonotonicDeadline, timeout, ident, postToolBatchHook, batchArgs, compactionBrain, withinTaskCompaction, compactionBreaker, windowSafetyOptions, rapidRefill, drainManualCompact, runnerHooks, runner } = deps;
     let finalVerifySeenAtLastBoundary = 0;
     const onTurnBoundary = async (event) => {
         let boundarySteered = false;
@@ -560,10 +561,10 @@ export function createTurnBoundary(input) {
                 workingFileAttachments: buildWorkingFileAttachments(spec, prepared),
                 ...contextInstructionFilesOption(prepared),
                 ...(prepared.onCompactionApplied ? { onApplied: prepared.onCompactionApplied } : {}),
-                ...runnerHooks.seamCCompactionOptions(prepared),
+                ...seamCCompactionOptions(runner, prepared),
                 ...gitRestateOption(prepared),
                 ...windowSafetyOptions(event.model),
-                ...runnerHooks.compactionHookOptions(spec, prepared.sessionId, passTrigger),
+                ...compactionHookOptions(runner, spec, prepared.sessionId, passTrigger, prepared.hookIdentity, { timeoutMs: prepared.hookTimeoutMs, signal: prepared.abortController.signal }),
             });
             if (comp.blocked) {
                 emitTrace(rs.telemetry.tracer, () => ({
@@ -618,7 +619,7 @@ export function createTurnBoundary(input) {
                     queue.push({ type: "compaction_outcome", outcome, trigger: passTrigger, ...ident() });
                 }
             }
-            runnerHooks.recordCompactionReuse(prepared, comp);
+            recordCompactionReuse(runner, prepared, comp);
             if (comp.compacted) {
                 queue.push({
                     type: "compacted",

package/dist/core/runner/runtask.d.ts

@@ -21,9 +21,6 @@ export declare class Runner implements RunnerSelfSeat {
      *  authority: a durable resume's checkpoint seed wins on its leg, and a miss (cross-process,
      *  evicted) falls back to the transcript-replay rung. See {@link SessionReadFileStates}. */
     private readonly sessionReadStates;
-    /** #616 — the per-session breaker read face's record (see {@link RunInternals.autoModeBreakerLedger}). Runner-lived:
-     *  a trip in one leg is what the session's next leg reports. */
-    private readonly autoModeBreakerLedger;
     /** task notifications born BETWEEN turns (run torn down / harness already idle), parked
      *  per session and drained into the session's next run at its first boundary. Runner-lived (outlives any
      *  single run, like the registry handles that produce into it); bounded + drop-disclosing, see
@@ -135,13 +132,18 @@ export declare class Runner implements RunnerSelfSeat {
      *  on first iteration — you do NOT need to pull events for the run (and its `finish()`/env teardown) to
      *  happen. Iterating just observes events (the buffer is backpressure-free); `.result()` awaits completion. */
     runTaskStream(spec: TaskSpec, resume?: ResumeRun, internals?: RunInternals): TaskStream;
-    private runLocked;
     /**
-     * design/100 §E12 — the post-completion prompt-suggestion pass. Never throws (failures route to
-     * `onError(phase:"suggestions")` and resolve to `[]`), so it is fire-and-forget safe and `suggestions()`
-     * never rejects. Also fills the budget-excluded `stats.suggestions` line.
+     * design/393 S7 (#674) — the run body as ONE driver method: `runLocked`'s signature, the lane order, and the two assemblies
+     * the driver keeps (the harness handlers, the turn boundary). The lanes' products are threaded under the names they hand
+     * back; the two continuations the S6 driver spelled as private methods (`runSeatLanes` / `runAssembliesAndLegs`, joined by
+     * a `RunSeatsHandoff` re-spelling of two lanes' Results) are the `next` closures of the two async lanes they follow — the
+     * notification lane's (R0) and the attachment seats' (R3) — because a closure sees what the lanes before it bound, so
+     * nothing is re-spelled and nothing is re-destructured. Neither this method nor either closure is `async`: each lane's
+     * own promise IS this method's, so a prepare that throws reaches the run IIFE's catch / finally (the failure backstop,
+     * the session lock's release) on the tick it did, and each successor is entered on the tick its lane's last await
+     * resolved on (the S6 TICKS pin holds unchanged: no first host read moved off the tick the one-function body read it on).
      */
-    private suggestNextPrompts;
+    private runLocked;
     /** Run a task to completion and return a machine-readable result. */
     runTask(spec: TaskSpec, internals?: RunInternals): Promise<TaskResult>;
     /**
@@ -249,77 +251,6 @@ export declare class Runner implements RunnerSelfSeat {
      * twin. Entered in the claim rung's last continuation, so its first statement runs on the tick the win was read.
      */
     private resumeHandoff;
-    /**
-     * design/45 resume step: with the harness idle and the branch rewound to the suspension leaf, resolve
-     * the gated tool call and close the rest of the suspended batch, all by appending `toolResult`s to the
-     * session (the next `harness.prompt(continuation)` replays them as context).
-     *  - `allow` → execute the pending tool ONCE (re-validating `updatedInput`/captured post-hook args),
-     *    append its real result. This deliberately bypasses the tool gate (the human already adjudicated)
-     *    and the PostToolUse hook (documented v1 gap — rare, acceptable).
-     *  - `deny` → append a model-readable denial result instead.
-     *  - the remaining batch siblings (#k+1..N) → deferred-reissue results (v1 doesn't blind-run them).
-     */
-    private applyResumeDecision;
-    /** Resolve the single gated call of a resumed batch (design/45): execute it once on `allow`, or inject
-     *  a model-readable denial on `deny`. Appends exactly one `toolResult` for `pendingAction.toolCallId`.
-     *  `emit` streams `tool_start`/`tool_end` for the resolved call so a `resumeStream` observer sees the
-     *  approved tool actually execute (API#2 observability parity — service [15]/[37]; the gated call never
-     *  emitted execution events in the original run, it suspended at the gate before running).
-     *
-     *  RB-22 RULING (2026-07-18, deliberate — the $ counterpart of RB-21's walltime question): a HUMAN-
-     *  APPROVED call executes even when the $ budget is already exhausted (`maxCostMicroUsd` ≤ spent).
-     *  The tool execution itself consumes no model spend — the budget's coordinate is LLM cost, and the
-     *  very next turn boundary's budget gate stops the run — so the overrun is ≈0 while refusing would
-     *  WASTE the human approval (the review effort is already sunk). This deliberately differs from the
-     *  walltime ruling (RB-21: NOT exempt) on principle: wall-clock exhaustion endangers the write-out
-     *  window (time cannot be clawed back), $ exhaustion after an approved no-spend action endangers
-     *  nothing. Pinned in resume tests; do not "fix" this into a pre-execution budget check. */
-    private resolvePendingCall;
-    /**
-     * design/84 Seam C — the cost-optimization compaction options threaded into BOTH `maybeCompact` call
-     * sites (within-task turn boundary + `finish()`). All three fields come from `RunnerDeps` (a trusted
-     * FUNCTION seam — never `TaskSpec`, which is serializable/durable-resumable/untrusted-caller). The
-     * Runner OWNS the consecutive-reuse counter (`prepared.compactionReuseRef`) so the
-     * `maxConsecutiveProviderReuse` drift guard spans the whole task across both sites: it FEEDS the current
-     * count in as `consecutiveProviderReuse`, and {@link recordCompactionReuse} updates it from the result.
-     * Returns `undefined` when no provider is wired (so the call site spreads nothing → byte-identical to
-     * the pre-design/84 behavior).
-     */
-    private seamCCompactionOptions;
-    /** design/134 §3.2 — resolve the pre/postCompact lifecycle callbacks (whole-slot `spec.hooks ??
-     *  deps.hooks`, same resolution as the stop hook) and wrap each in a SWALLOW+TRACE shell before
-     *  threading them into maybeCompact. The wrapper owns the observability half of the R3 MED contract
-     *  (maybeCompact swallows defensively too, but has no sink): a throwing callback is reported via
-     *  `onError(phase:"hook")` and treated as absent; a `block` returned under a "forced" trigger is
-     *  reported as ignored (maybeCompact enforces the ignore — blocking a compaction the provider/trim
-     *  layer already demanded would kill the run). */
-    private compactionHookOptions;
-    /** design/84 Seam C — fold a finished compaction's `reused` flag into the run-scoped consecutive-reuse
-     *  counter: a reused (provider) summary increments it, a real (LLM) summary resets it to 0. A no-op
-     *  compaction (`compacted:false`) leaves the counter untouched. No-op when no provider is wired. */
-    private recordCompactionReuse;
-    private finish;
-    /**
-     * design/48 remote seam +: tear down a per-task env minted by `executionEnvFactory` (e.g. a
-     * remote container, or a `withWorktreeIsolation` worktree) — this task owned its lifetime. Best-effort, like
-     * `mcp.dispose`: a `destroy()` failure must not break the run. Only `ownedEnv` (factory-produced) is destroyed;
-     * a caller-owned static `deps.executionEnv` outlives the task and is left untouched. The service control plane's
-     * reaper is the backstop for an env orphaned by a rare pre-teardown throw (same posture as `mcp`).
-     *
-     * Runs from the run-loop tail AFTER every env-reader (finish()'s compaction `attachWorkingFiles` +
-     * the file-history boundary settle), so the working tree is still readable when they run. This ORDER is
-     * the fix for a teardown-order defect: the old in-`finish` destroy ran BEFORE the capture seat, so a
-     * factory-minted remote/worktree lane captured an already-destroyed env (plain host/static lanes were
-     * false-green).
-     *
-     * design/49 v1.5 / design/76 §2.5: a committed durable pause (`pausedRef.current`, any gate kind)
-     * `suspendVM`-paused the env and persisted its `workspaceHandle` into the checkpoint — destroying it would
-     * discard the paused VM and make resume fail to restore. Skip teardown; `resume()` rebuilds + `resumeVM`s it. A
-     * cancelled pause is reaped via `TaskStream.destroy()` (design/51); an abandoned one is the service container
-     * reaper's backstop. The gate here MIRRORS the tail's reap-stash (same durable fact
-     * `pausedRef.current === undefined`), so exactly one path owns the env's fate.
-     */
-    private teardownOwnedEnv;
 }
 /** Convenience: one-shot run with explicit deps (creates a throwaway Runner). */
 export declare function runTask(spec: TaskSpec, deps: RunnerDeps): Promise<TaskResult>;