@sema-agent/core 7.12.0 → 7.13.0

package/dist/core/runner/run-terminal-adoption.d.ts

@@ -4,7 +4,9 @@
  * stop, the platform lane's external cause — which alone overrides a real throw), the usage ledger's FINAL charge with its
  * slow-charge disclosure, the live-abort orphan reconcile and its synthetic `tool_end` frames, the held session-write
  * drain, the user-interruption marker, the durable park's carried caller input and the held agent_end account's settle,
- * the dropped post-compact announce disclosure, and the end-of-task compaction pass (`finish`).
+ * the dropped post-compact announce disclosure, and the end-of-task compaction pass (`finish` — since design/393 S7 the lane's
+ * own module-private function, verbatim from the Runner's private method: the pass has one caller, and a sibling file would be a
+ * lane-to-lane reach, the S6 legs' reading).
  *
  * Async (six first-level awaits, the same awaits at the same positions). It ends by entering the settle lane (`next`) in
  * its LAST continuation — the settle's first read sits on the tick `finish` resolved on, as it did in the one-function
@@ -14,13 +16,14 @@
  */
 import type { AssistantMessage } from "../../internal/llm.js";
 import type { Model } from "../../internal/llm.js";
-import type { MaybeCompactOptions } from "../auto-compaction.js";
+import { type MaybeCompactOptions } from "../auto-compaction.js";
+import type { SessionStore } from "../session.js";
 import type { PushQueue } from "../push-queue.js";
 import { type Brain, type TaskEvent, type TaskSpec } from "../types.js";
 import { type Stats } from "./assemble-result.js";
 import type { EndOfTaskCompaction, Prepared, RunnerDepsSeat, RunState } from "./contracts.js";
 export interface RunTerminalAdoptionInput<R> {
-    /** borrowed-readonly — the task spec: the task id the account's notices name; `finish`'s first argument. */
+    /** borrowed-readonly — the task spec: the task id the account's notices name; `finish`'s first argument (the end-of-task pass below). */
     spec: TaskSpec;
     /** borrowed-mutable — the run's event queue: the reconcile's synthetic `tool_end` frames and the end-of-task compaction's failure frame. */
     queue: PushQueue<TaskEvent>;
@@ -62,6 +65,11 @@ export interface RunTerminalAdoptionInput<R> {
             followUp: number;
         } | undefined;
     };
+    /** borrowed-readonly — #677: did the run end with a person's steer / follow-up still pending (the identity lane's read face)? Folded
+     *  into the answer-settled verdict this lane evaluates once. */
+    userInputLostAtEnd: {
+        readonly current: boolean;
+    };
     /** borrowed-readonly — the leg lane's final assistant message (its `stopReason` is one of the interruption facts). */
     final: AssistantMessage | undefined;
     /** borrowed-readonly — what the leg threw (undefined on a clean end); this lane may LIFT a typed cause over it and hands the adopted value on. */
@@ -73,19 +81,8 @@ export interface RunTerminalAdoptionInput<R> {
     /** borrowed-readonly — the Runner's deployment deps, read LIVE (`onError`, `checkpointStore`, `onNotice`); the one home of why it is
      *  a seat and not a captured object is {@link RunnerDepsSeat}. */
     runner: RunnerDepsSeat;
-    /** borrowed-readonly — the Runner's end-of-task compaction pass (its private method, as a delegate). */
-    finish: (spec: TaskSpec, prepared: Prepared, opts: {
-        skipCompaction?: boolean;
-        minTokens?: number;
-        brain?: Brain;
-        windowSafety?: Pick<MaybeCompactOptions, "fallbackBudget" | "onWindowSafety">;
-        onCompactionFailed?: (reason: string) => void;
-        telemetry?: {
-            tracer: TaskSpec["tracer"];
-            taskId: string;
-        };
-        cancelled?: boolean;
-    }) => Promise<EndOfTaskCompaction>;
+    /** borrowed-readonly — the session store: the end-of-task pass touches the leg's session through it (`finish`'s teardown legs). */
+    sessions: SessionStore;
     /** borrowed-readonly — the settle lane, entered in this lane's last continuation with the adopted cause and the compaction outcome. */
     next: (adopted: RunTerminalAdoptionResult) => Promise<R>;
 }
@@ -95,5 +92,8 @@ export interface RunTerminalAdoptionResult {
     threw: unknown;
     /** The end-of-task compaction pass's outcome. */
     comp: EndOfTaskCompaction;
+    /** #677 — this lane's ONE evaluation of {@link answerSettled}: a clean `"stop"` final with no queued continuation lost. The
+     *  settle lane hands it to the arbitration (`ResultFlags.answerSettled`), the teardown attribution and the notice. */
+    answerSettled: boolean;
 }
 export declare function runTerminalAdoption<R>(input: RunTerminalAdoptionInput<R>): Promise<R>;

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

@@ -1,14 +1,20 @@
+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 { errorCodeOf } from "./assemble-result.js";
-import { awaitChargeWithSlowDisclosure } from "./clock-and-limits.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, final, abortedLive, userInterruptedLive, runner, finish, next } = 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;
     }
@@ -58,7 +64,7 @@ export async function runTerminalAdoption(input) {
             });
         }
     }
-    if (interrupted && userInterruptedLive && reconcileComplete) {
+    if (interrupted && userInterruptedLive && reconcileComplete && !settled) {
         try {
             const entryId = await appendInterruptionMarker(prepared.session, { toolUseInFlight: orphansClosed > 0 });
             emitCommitted(entryId, "user");
@@ -109,12 +115,86 @@ export async function runTerminalAdoption(input) {
     }
     const comp = await finish(spec, prepared, {
         telemetry: { tracer: rs.telemetry.tracer, taskId: rs.telemetry.taskId },
-        skipCompaction: durablyPaused || compactionBreaker.failures >= MAX_CONSECUTIVE_COMPACTION_FAILURES,
+        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,
-    });
-    return await next({ threw, comp });
+    }, 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

@@ -132,27 +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/393 S6 — the run body after `prepared` exists: the seat lanes R1–R3 (design/393 S5) — the identity wiring, the
-     * telemetry and budget seats, and the attachment seats, whose continuation carries the rest. Entered by the notification
-     * lane in its last continuation, with what it prepared and bound. Not `async`: it hands back the attachment lane's own
-     * promise, so the driver adds no frame — and no microtask — of its own between the lanes and `runLocked`'s settlement.
-     */
-    private runSeatLanes;
-    /**
-     * design/393 S6 — the run body after the seat lanes' async rung: the seat lanes R4–R12 (design/393 S5), the two assemblies
-     * the driver keeps (the harness handlers, the turn boundary) and the leg lanes. Entered by the attachment-seats lane in
-     * its last continuation, with what the notification lane prepared and what the identity / budget lanes handed back.
-     * Not `async` for the same reason as `runSeatLanes`: the leg lane's promise IS this method's.
-     */
-    private runAssembliesAndLegs;
     /**
-     * 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>;
     /**
@@ -260,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>;