@sema-agent/core 7.11.1 → 7.12.0

package/dist/core/runner/run-telemetry-and-budget-seats.js

@@ -0,0 +1,159 @@
+import { remainingBudgetMicroUsd, remainingTokens } from "../checkpoint-store.js";
+import { computeCostMicroUsd, isModelPriced, malformedPricingField, modelCostToPricing } from "../pricing.js";
+import { resolveModel } from "../roles.js";
+import { emitTrace } from "../trace.js";
+import { resolveMaxTurns } from "./clock-and-limits.js";
+import { resolveOutputRetries } from "./synthetic-tools.js";
+import { cacheFamilyOf } from "./usage-accounting.js";
+export function runTelemetryAndBudgetSeats(input) {
+    const { spec, prepared, resume, stats, taskIdRef, entryTracer, modelCatalog, runSourceTaskId, rs, runner, sessions } = input;
+    prepared.liveSpendRef.get = () => ({ costMicroUsd: stats.costMicroUsd, tokens: stats.tokens, turns: stats.turns, walltimeMs: Math.round(performance.now() - rs.telemetry.taskStartMonotonic) });
+    if (resume &&
+        resume.cp.suspendedAt !== undefined &&
+        (resume.cp.gate.kind === "human" ||
+            resume.cp.gate.kind === "irreversible_ask" ||
+            resume.cp.gate.kind === "needs_review" ||
+            resume.cp.gate.kind === "plan_review")) {
+        const waitMs = Math.max(0, prepared.now() - resume.cp.suspendedAt);
+        const decision = resume.outcome.gate === "wake" ? undefined : resume.outcome.decision;
+        prepared.humanReviewRef.count += 1;
+        prepared.humanReviewRef.totalWaitMs += waitMs;
+        const gateToolName = "toolName" in resume.cp.gate ? resume.cp.gate.toolName : undefined;
+        prepared.humanReviewRef.gates.push({ kind: resume.cp.gate.kind, waitMs, ...(decision !== undefined ? { decision } : {}), ...(gateToolName !== undefined ? { toolName: gateToolName } : {}) });
+    }
+    if (resume !== undefined && resume.outcome.gate === "plan_review" && resume.outcome.decision === "reject") {
+        prepared.planModeRef.active = true;
+    }
+    rs.telemetry.cacheFamily = cacheFamilyOf(prepared.model);
+    rs.telemetry.pricing = runner.deps.pricing?.[prepared.model.id] ?? modelCostToPricing(prepared.model.cost);
+    rs.telemetry.pricingConfigured = isModelPriced(prepared.model, runner.deps.pricing);
+    if (spec.limits?.degrade) {
+        try {
+            rs.degrade.degradeToModel = resolveModel(spec.limits.degrade.to, modelCatalog);
+        }
+        catch (e) {
+            runner.deps.onError?.(e, { phase: "degraded", sessionId: prepared.sessionId });
+        }
+    }
+    const famOverride = prepared.model.params?.promptCacheFamily;
+    if (famOverride && !["input-includes-cached", "input-excludes-cached", "openai", "anthropic"].includes(famOverride)) {
+        runner.deps.onError?.(new Error(`prompt-cache: unrecognized model.params.promptCacheFamily "${famOverride}" — ignored (fell back to model.api inference). Use "input-includes-cached" | "input-excludes-cached" (aliases "openai" | "anthropic").`), { phase: "prompt-cache", sessionId: prepared.sessionId });
+    }
+    rs.limits.turnsExceeded = false;
+    rs.degrade.outputErrorStreak = 0;
+    rs.degrade.outputInvalid = false;
+    rs.telemetry.cacheBreakReported = false;
+    rs.limits.outputRetryCap = resolveOutputRetries(spec.outputRetries);
+    rs.limits.effectiveMaxTurns = resolveMaxTurns(spec.limits);
+    rs.telemetry.tracer = entryTracer !== undefined ? entryTracer.tracer : (spec.tracer ?? runner.deps.tracer);
+    rs.telemetry.taskId = runSourceTaskId;
+    rs.telemetry.runId = prepared.runId;
+    if (taskIdRef) {
+        taskIdRef.current = rs.telemetry.taskId;
+        taskIdRef.sessionId = prepared.sessionId;
+    }
+    rs.telemetry.taskStart = Date.now();
+    rs.telemetry.taskStartMonotonic = performance.now();
+    const discloseNoteTaskRunFailure = (err) => {
+        try {
+            runner.deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "config", sessionId: prepared.sessionId });
+        }
+        catch {
+        }
+    };
+    try {
+        void Promise.resolve(sessions.noteTaskRun?.(prepared.sessionId, rs.telemetry.taskId, rs.telemetry.runId)).catch(discloseNoteTaskRunFailure);
+    }
+    catch (err) {
+        discloseNoteTaskRunFailure(err);
+    }
+    const noteUnevaluablePriceTable = (p) => {
+        if (prepared.usageGovernance?.governsCost !== true)
+            return;
+        if (malformedPricingField(p) !== undefined)
+            rs.telemetry.unpricedSpend = true;
+    };
+    rs.degrade.recordDegraded = (info, toModel) => {
+        if (rs.degrade.degraded !== undefined)
+            return;
+        let m = toModel;
+        if (!m) {
+            try {
+                m = resolveModel(info.to, modelCatalog);
+            }
+            catch {
+                m = undefined;
+            }
+        }
+        if (m) {
+            rs.telemetry.pricing = runner.deps.pricing?.[m.id] ?? modelCostToPricing(m.cost);
+            rs.telemetry.pricingConfigured = isModelPriced(m, runner.deps.pricing);
+            noteUnevaluablePriceTable(rs.telemetry.pricing);
+            rs.telemetry.cacheFamily = cacheFamilyOf(m);
+        }
+        else {
+            if (runner.deps.pricing?.[info.to]) {
+                rs.telemetry.pricing = runner.deps.pricing[info.to];
+                rs.telemetry.pricingConfigured = true;
+                noteUnevaluablePriceTable(rs.telemetry.pricing);
+            }
+            else {
+                rs.telemetry.pricingConfigured = false;
+            }
+            rs.telemetry.cacheFamily = "input-excludes-cached";
+        }
+        rs.degrade.degraded = info;
+        emitTrace(rs.telemetry.tracer, () => ({ kind: "task.degraded", version: 1, taskId: rs.telemetry.taskId, from: info.from, to: info.to, reason: info.reason, atTurn: info.atTurn, ts: Date.now() }));
+        try {
+            runner.deps.onError?.(new Error(`degraded to a cheaper model: ${info.from} → ${info.to} (${info.reason}) at turn ${info.atTurn}`), { phase: "degraded", sessionId: prepared.sessionId });
+        }
+        catch {
+        }
+    };
+    const sliceWindowMicroUsd = spec.limits?.maxCostUsd !== undefined ? Math.round(spec.limits.maxCostUsd * 1e6) : undefined;
+    rs.budget.remainingMicroUsd = prepared.resourceLedger
+        ? remainingBudgetMicroUsd(prepared.resourceLedger)
+        : spec.resourceSuspend?.totalBudgetUsd !== undefined
+            ? Math.round(spec.resourceSuspend.totalBudgetUsd * 1e6)
+            : undefined;
+    rs.budget.maxCostMicroUsd =
+        sliceWindowMicroUsd !== undefined && rs.budget.remainingMicroUsd !== undefined
+            ? Math.min(sliceWindowMicroUsd, rs.budget.remainingMicroUsd)
+            : (sliceWindowMicroUsd ?? rs.budget.remainingMicroUsd);
+    rs.budget.remainingTokens = prepared.resourceLedger
+        ? remainingTokens(prepared.resourceLedger)
+        : spec.resourceSuspend?.totalTokens;
+    rs.budget.maxTokensWindow =
+        spec.limits?.maxTokens !== undefined && rs.budget.remainingTokens !== undefined
+            ? Math.min(spec.limits.maxTokens, rs.budget.remainingTokens)
+            : (spec.limits?.maxTokens ?? rs.budget.remainingTokens);
+    rs.budget.overBudget = () => {
+        if (rs.budget.maxTokensWindow !== undefined && stats.tokens > rs.budget.maxTokensWindow)
+            return "tokens";
+        if (rs.budget.maxCostMicroUsd !== undefined && stats.costMicroUsd > rs.budget.maxCostMicroUsd)
+            return "cost";
+        return undefined;
+    };
+    rs.budget.streamCancel =
+        (spec.limits?.budgetStreamCancel ?? rs.budget.maxCostMicroUsd !== undefined) && prepared.suspendForResource === undefined;
+    rs.budget.callOutputChars = 0;
+    rs.budget.lastStreamBudgetCheck = 0;
+    rs.budget.projectedOverBudget = () => {
+        const estOut = Math.ceil(rs.budget.callOutputChars / 4);
+        if (rs.budget.maxTokensWindow !== undefined && stats.tokens + estOut > rs.budget.maxTokensWindow)
+            return "tokens";
+        if (rs.budget.maxCostMicroUsd !== undefined) {
+            const estOutMicro = computeCostMicroUsd({ totalInputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, cacheWriteTokensLong: 0, outputTokens: estOut }, rs.telemetry.pricing);
+            if (stats.costMicroUsd + estOutMicro > rs.budget.maxCostMicroUsd)
+                return "cost";
+        }
+        return undefined;
+    };
+    rs.turn.turnUsageMissing = false;
+    rs.counters.repetitionCuts = 0;
+    rs.counters.repetitionSpared = 0;
+    rs.counters.repetitionEvents = [];
+    rs.counters.REPETITION_EVENTS_CAP = 20;
+    rs.counters.preemptIgnoredReported = false;
+    return { noteUnevaluablePriceTable };
+}

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

@@ -0,0 +1,99 @@
+/**
+ * design/393 S6 — the run body's TERMINAL ADOPTION (R14), verbatim from `Runner.runLocked`, between the leg's finally and
+ * the settle: the typed causes lifted over the leg's anonymous end (the brain-call guardrail's stall, the tool gate's own
+ * 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`).
+ *
+ * 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
+ * body — and returns what it returns. What crosses the boundary is exactly what the settle reads of this lane's work: the
+ * ADOPTED cause (`threw`, possibly lifted here) and the compaction outcome (`comp`); the pause / interruption / reconcile
+ * facts are consumed here.
+ */
+import type { AssistantMessage } from "../../internal/llm.js";
+import type { Model } from "../../internal/llm.js";
+import type { MaybeCompactOptions } from "../auto-compaction.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. */
+    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>;
+    /** borrowed-mutable — the leg's prepared seat: the guardrail / gate-stop / paused refs are read, the usage ledger charged, the session
+     *  reconciled and the marker appended, the harness's parkable inputs read and dropped. */
+    prepared: Prepared;
+    /** borrowed-readonly — the run's mutable state: the platform terminal, the limit flags, the attachment state and the telemetry seat. */
+    rs: RunState;
+    /** borrowed-readonly — this leg's usage counters (the final charge's cumulative total). */
+    stats: Stats;
+    /** borrowed-readonly — the run's event-identity mint (the synthetic `tool_end` frames, the compaction failure frame). */
+    ident: () => {
+        eventId: string;
+        parentToolCallId?: string;
+        sourceTaskId?: string;
+    };
+    /** borrowed-readonly — the `message_committed` mint (the reconcile's appended toolResults, the marker). */
+    emitCommitted: (entryId: string, role: "user" | "assistant" | "toolResult", toolCallId?: string) => void;
+    /** borrowed-readonly — the observed tool-start ids the reconcile splits orphans by (EMPTIED by the reconcile's commit). */
+    startedToolCallIds: Set<string>;
+    /** borrowed-readonly — the label map the synthetic `tool_end` frames carry. */
+    toolLabels: Map<string, string>;
+    /** borrowed-readonly — the hard walltime timer: `fired` is one of the interruption facts. */
+    timeout: {
+        readonly fired: boolean;
+    };
+    /** borrowed-readonly — the compaction machinery's accounted brain (the end-of-task summary call is accounted too). */
+    compactionBrain: Brain;
+    /** borrowed-readonly — the shared compaction breaker: an open breaker skips the end-of-task attempt. */
+    compactionBreaker: {
+        readonly failures: number;
+    };
+    /** borrowed-readonly — the window-safety builder the end-of-task lane shares with the boundary / PTL lanes. */
+    windowSafetyOptions: (mainModel: Model) => Pick<MaybeCompactOptions, "fallbackBudget" | "onWindowSafety">;
+    /** borrowed-readonly — the held agent_end account, as the read face on the identity lane's Result (backlog #389). */
+    undrainedUserAtEnd: {
+        readonly current: {
+            steer: number;
+            followUp: number;
+        } | undefined;
+    };
+    /** 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. */
+    threw: unknown;
+    /** borrowed-readonly — the live-abort flag the leg captured before its release-abort. */
+    abortedLive: boolean;
+    /** borrowed-readonly — the leg's snapshot of `loopLatch.userInterrupted` (gates the interruption marker). */
+    userInterruptedLive: boolean;
+    /** 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 settle lane, entered in this lane's last continuation with the adopted cause and the compaction outcome. */
+    next: (adopted: RunTerminalAdoptionResult) => Promise<R>;
+}
+/** What the settle reads of this lane's work. */
+export interface RunTerminalAdoptionResult {
+    /** The ADOPTED terminal cause: the leg's throw, or the typed cause lifted over it here (guardrail stall / gate stop / platform terminal). */
+    threw: unknown;
+    /** The end-of-task compaction pass's outcome. */
+    comp: EndOfTaskCompaction;
+}
+export declare function runTerminalAdoption<R>(input: RunTerminalAdoptionInput<R>): Promise<R>;

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

@@ -0,0 +1,120 @@
+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 { 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;
+    let { threw } = input;
+    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) {
+        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 || 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 });
+}

package/dist/core/runner/run-tool-mount-facts.d.ts

@@ -0,0 +1,26 @@
+import type { TaskSpec } from "../types.js";
+import type { WriteFamily } from "./turn-attachments.js";
+import type { Prepared, RunState } from "./contracts.js";
+export interface RunToolMountFactsInput {
+    /** borrowed-readonly — the task spec: the config overrides the manifest frame reports. */
+    spec: TaskSpec;
+    /** borrowed-mutable — the leg's prepared seat: `turnSnapshot.onChange` is installed; the roster, the model and the
+     *  prompt manifest are read. */
+    prepared: Prepared;
+    /** borrowed-readonly — the run's mutable state: the attachment state's presence gates the mount facts; the
+     *  telemetry is read for the frames. */
+    rs: RunState;
+}
+export interface RunToolMountFactsResult {
+    /** Whether TodoWrite is mounted (and the attachment state exists) — the todo reminder's gate. */
+    todoToolMounted: boolean;
+    /** Whether TaskCreate is mounted (and the attachment state exists) — the task reminder's gate. */
+    taskToolsMounted: boolean;
+    /** task #51 F2: the alias-aware write-family resolver (mounted name + aliases → canonical family). */
+    writeFamilyOf: (name: string) => WriteFamily | undefined;
+    /** Per tool-call id: the execution start time (for the tool_end duration). */
+    toolStartAt: Map<string, number>;
+    /** Every tool-call id whose start was observed this run and whose result has not been committed yet. */
+    startedToolCallIds: Set<string>;
+}
+export declare function runToolMountFacts(input: RunToolMountFactsInput): RunToolMountFactsResult;

package/dist/core/runner/run-tool-mount-facts.js

@@ -0,0 +1,58 @@
+import { CONFIG_CATALOG_VERSION, declarationReasons, resolveEffectiveConfig } from "../../config/catalog.js";
+import { engineVersion } from "../version.js";
+import { emitTrace } from "../trace.js";
+import { writeFamilyOfCanonical } from "./tool-end-body.js";
+export function runToolMountFacts(input) {
+    const { spec, prepared, rs } = input;
+    const todoToolMounted = rs.attach.attachState !== undefined && prepared.tools.some((t) => t.name === "TodoWrite");
+    const taskToolsMounted = rs.attach.attachState !== undefined && prepared.tools.some((t) => t.name === "TaskCreate");
+    const writeFamilyByName = new Map();
+    if (rs.attach.attachState !== undefined) {
+        for (const t of prepared.tools) {
+            const family = writeFamilyOfCanonical(t.name);
+            if (family !== undefined)
+                for (const n of [t.name, ...(t.aliases ?? [])])
+                    writeFamilyByName.set(n, family);
+        }
+    }
+    const writeFamilyOf = (name) => writeFamilyByName.get(name) ?? writeFamilyOfCanonical(name);
+    const toolStartAt = new Map();
+    const startedToolCallIds = new Set();
+    emitTrace(rs.telemetry.tracer, () => ({ kind: "task.start", version: 1, taskId: rs.telemetry.taskId, runId: rs.telemetry.runId, model: prepared.model.id, engineVersion: engineVersion(), ts: rs.telemetry.taskStart }));
+    emitTrace(rs.telemetry.tracer, () => ({
+        kind: "prompt.assembled",
+        version: 1,
+        taskId: rs.telemetry.taskId,
+        constitution: prepared.promptManifest.constitution,
+        blocks: prepared.promptManifest.blocks,
+        ...(prepared.promptManifest.sections ? { sections: prepared.promptManifest.sections } : {}),
+        ...(prepared.promptManifest.tools ? { tools: prepared.promptManifest.tools } : {}),
+        ...(prepared.promptManifest.snapshot ? { snapshot: prepared.promptManifest.snapshot } : {}),
+        ...(prepared.promptManifest.lowering ? { lowering: prepared.promptManifest.lowering } : {}),
+        ...(prepared.promptManifest.toolDisclosure ? { toolDisclosure: prepared.promptManifest.toolDisclosure } : {}),
+        totalChars: prepared.promptManifest.blocks.reduce((n, b) => n + b.chars, 0),
+        ts: rs.telemetry.taskStart,
+    }));
+    emitTrace(rs.telemetry.tracer, () => {
+        const reasons = declarationReasons(spec.configOverrides);
+        return {
+            kind: "config.assembled",
+            version: 1,
+            taskId: rs.telemetry.taskId,
+            catalogVersion: CONFIG_CATALOG_VERSION,
+            fields: resolveEffectiveConfig(spec, { modelMaxTokens: prepared.model.maxTokens }),
+            ...(Object.keys(reasons).length > 0 ? { overrideReasons: reasons } : {}),
+            ts: rs.telemetry.taskStart,
+        };
+    });
+    if (prepared.turnSnapshot !== undefined) {
+        prepared.turnSnapshot.onChange = (snap) => emitTrace(rs.telemetry.tracer, () => ({
+            kind: "prompt.snapshot_changed",
+            version: 1,
+            taskId: rs.telemetry.taskId,
+            snapshot: { cacheIdentity: snap.cacheIdentity, elements: { ...snap.elements } },
+            ts: Date.now(),
+        }));
+    }
+    return { todoToolMounted, taskToolsMounted, writeFamilyOf, toolStartAt, startedToolCallIds };
+}

package/dist/core/runner/run-turn-boundary.d.ts

@@ -1,41 +1,6 @@
 import type { Model } from "../../internal/llm.js";
 import type { Stats } from "./assemble-result.js";
 import type { Prepared, RunState, TurnBoundaryDeps } from "./contracts.js";
-/**
- * §17.4 (design/64 GAP-25): stop attempting within-task compaction after this many CONSECUTIVE
- * failures in one task — a never-recovering summary gateway must not burn an API call at every turn
- * boundary (CC: MAX_CONSECUTIVE_AUTOCOMPACT_FAILURES = 3). Reset on any success; an open breaker also
- * skips the end-of-task attempt in `finish()` (teardown unaffected). Per-task scope.
- *
- * RB-190 — this used to say "a flaky/never-recovering gateway", and the word `flaky` was not true. Because
- * any success zeroes the counter, a gateway that alternates never reaches three CONSECUTIVE failures and
- * the breaker never opens; it keeps paying for a call at every failed boundary, indefinitely.
- *
- * The behaviour is right and stays: a gateway succeeding half the time is compacting half the time, and
- * opening the breaker on it would disable compaction outright and let the context overflow — trading a
- * wasted call for a failed task. What was wrong is the comment claiming a guarantee the code does not
- * make. An alternating gateway is deliberately NOT caught here; if that ever needs catching it wants a
- * different signal (a failure RATE over a window), not a consecutive counter.
- */
-export declare const MAX_CONSECUTIVE_COMPACTION_FAILURES = 3;
-/**
- * §25.2 anti-thrash (LONGRUN-1b, search [84]): after a compaction, the context must regrow past
- * (tokensBefore − freed) × this factor — the post-compaction size in trigger units — before another
- * summary call fires. An EFFECTIVE compaction (freed large) leaves the floor far below the threshold,
- * so behavior is unchanged; an INEFFECTIVE one (small window, chunky turns, large summary ⇒ freed
- * small, still at/over the threshold) raises the floor so attempts space out instead of firing at
- * every boundary (measured: 26/39 boundaries, +135% wall). The floor binds only when post-compaction
- * size > threshold/1.5 ≈ compaction freed <33% headroom. Degrades gracefully: the retained summary
- * chain keeps early facts; only the un-summarized tail falls back to trim.
- */
-export declare const COMPACTION_REGROWTH_FACTOR = 1.5;
-/**
- * design/84 Seam C reuse guard (b): a compaction that frees fewer than this many (structural) tokens is
- * treated as NO-EFFECTIVE-COMPACTION and does NOT raise the anti-thrash floor. Guards against a reused
- * provider summary (or a pathological LLM summary) that reclaims no headroom yet suppresses the next real
- * summary by inflating the floor to trigger×factor.
- */
-export declare const COMPACTION_FREED_EPSILON = 256;
 /**
  * What the driver hands the turn-boundary lane, once per leg. The four seats are the four positional
  * parameters the factory used to take; the Input is a carrier of REFERENCES, not a snapshot — the handler

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

@@ -13,9 +13,7 @@ import { formatDiagnosticsBlock } from "../lsp-diagnostics.js";
 import { workflowSizeGuidelineChangeNotice } from "../../orchestration/workflow-size-guideline.js";
 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";
-export const MAX_CONSECUTIVE_COMPACTION_FAILURES = 3;
-export const COMPACTION_REGROWTH_FACTOR = 1.5;
-export const COMPACTION_FREED_EPSILON = 256;
+import { COMPACTION_FREED_EPSILON, COMPACTION_REGROWTH_FACTOR, MAX_CONSECUTIVE_COMPACTION_FAILURES } from "./compaction-knobs.js";
 const BATCH_CONTEXT_MIN_KEEP_BYTES = 160;
 const BATCH_TRUNCATION_MARKER = "\n…[truncated]";
 export function createTurnBoundary(input) {

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
@@ -136,6 +133,20 @@ export declare class Runner implements RunnerSelfSeat {
      *  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()`