@sema-agent/core 2.13.0 → 4.0.0

package/dist/agents/cascade.d.ts

@@ -14,6 +14,7 @@ export interface CascadeConfig {
         index: number;
         model: ModelRef;
     }) => GateVerdict | Promise<GateVerdict>;
+    acceptPartial?: boolean;
     maxEscalations?: number;
     costCeilingMicroUsd?: number;
     totalTimeoutMs?: number;
@@ -28,14 +29,18 @@ export interface CascadeAttempt {
     index: number;
     model: ModelRef;
     passed: boolean;
-    costMicroUsd: number;
+    costMicroUsd?: number;
     status: TaskResult["status"];
     errorCode?: string;
     gateError?: string;
+    timedOut?: true;
+    cancelled?: true;
+    statusRejected?: true;
     diagnostics?: string;
 }
 export interface CascadeRunResult extends TaskResult {
     cascadeOutcome: "passed" | "exhausted";
+    costCeilingUnenforceable?: true;
     escalated: boolean;
     finalRung: number;
     attempts: CascadeAttempt[];

package/dist/agents/cascade.js

@@ -1,5 +1,8 @@
 import { releaseSession } from "./session-util.js";
 import { mapNestedSuspend, isDurablePause } from "./suspend-guard.js";
+import { buildCumulativeStats } from "./cumulative-stats.js";
+import { createSafeNotifier } from "../core/safe-notify.js";
+const CASCADE_ON_RUNG_SITE = "cascade.onRung";
 function createDefaultGate(spec) {
     const requiresStructured = spec.outputSchema != null;
     return (result) => result.status === "completed" && (!requiresStructured || result.structuredOutput !== undefined);
@@ -13,61 +16,86 @@ export async function runCascade(runner, spec, config) {
     const maxRungs = Math.min(ladder.length, Math.max(0, maxEscalations) + 1);
     const gate = config.gate ?? createDefaultGate(spec);
     const startedAt = Date.now();
+    const deadlineAt = config.totalTimeoutMs != null ? startedAt + config.totalTimeoutMs : undefined;
+    const notifier = createSafeNotifier();
     const attempts = [];
     let totalCost = 0;
+    let ceilingCostKnown = true;
     let ownTokens = 0, ownTurns = 0, ownPrompt = 0, ownCached = 0, ownOutput = 0, ownCostMicro = 0;
+    let ownTotalInput = 0;
     let ownCacheWrite = 0, ownCacheWriteLong = 0;
     let nestedTokens = 0, nestedTurns = 0, nestedTasks = 0, nestedCostMicro = 0;
     let ownLlmRootMicro = 0, ownCompactionMicro = 0;
+    let anyRungUnpriced = false;
     let hrCount = 0, hrWaitMs = 0;
     const hrGates = [];
-    const cumulativeStats = (baseStats) => ({
-        ...baseStats,
+    const cumulativeStats = (baseStats) => buildCumulativeStats(baseStats, {
         tokens: ownTokens,
         turns: ownTurns,
-        promptTokens: ownPrompt || undefined,
-        totalInputTokens: ownPrompt || undefined,
-        cachedTokens: ownCached || undefined,
-        outputTokens: ownOutput || undefined,
-        cacheWriteTokens: ownCacheWrite || undefined,
-        cacheWriteTokensLong: ownCacheWriteLong || undefined,
-        cacheHitRate: ownPrompt > 0 ? ownCached / ownPrompt : undefined,
+        promptTokens: ownPrompt,
+        totalInputTokens: ownTotalInput,
+        cachedTokens: ownCached,
+        outputTokens: ownOutput,
+        cacheWriteTokens: ownCacheWrite,
+        cacheWriteTokensLong: ownCacheWriteLong,
         costMicroUsd: ownCostMicro,
-        nested: nestedTokens > 0 || nestedTasks > 0
-            ? { tokens: nestedTokens, turns: nestedTurns, tasks: nestedTasks, costMicroUsd: nestedCostMicro || undefined }
-            : undefined,
-        costBreakdown: {
-            llmRootMicroUsd: ownLlmRootMicro,
-            nestedSubagentMicroUsd: nestedCostMicro,
-            memoryConsolidationMicroUsd: 0,
-            compactionMicroUsd: ownCompactionMicro,
-        },
-        humanReview: hrCount > 0 ? { count: hrCount, totalWaitMs: hrWaitMs, gates: hrGates } : undefined,
+        anyLegUnpriced: anyRungUnpriced,
+        llmRootMicroUsd: ownLlmRootMicro,
+        compactionMicroUsd: ownCompactionMicro,
+        nested: { tokens: nestedTokens, turns: nestedTurns, tasks: nestedTasks, costMicroUsd: nestedCostMicro },
+        humanReview: { count: hrCount, totalWaitMs: hrWaitMs, gates: hrGates },
     });
     let lastResult;
     let passedRung = -1;
     const { sessionId: _drop, ...specBase } = spec;
     for (let i = 0; i < maxRungs; i++) {
-        if (i > 0) {
-            if (config.totalTimeoutMs != null && Date.now() - startedAt >= config.totalTimeoutMs)
-                break;
-            if (config.costCeilingMicroUsd != null && totalCost >= config.costCeilingMicroUsd)
-                break;
+        if (deadlineAt !== undefined && Date.now() >= deadlineAt)
+            break;
+        if (i > 0 && config.costCeilingMicroUsd != null && (totalCost >= config.costCeilingMicroUsd || !ceilingCostKnown)) {
+            break;
         }
         const rung = ladder[i];
-        const result = await runner.runTask({ ...specBase, model: rung.model, ...(rung.overrides ?? {}) });
+        let deadlineFired = false;
+        const rungAbort = new AbortController();
+        let deadlineTimer;
+        if (deadlineAt !== undefined) {
+            deadlineTimer = setTimeout(() => {
+                deadlineFired = true;
+                rungAbort.abort(new Error(`runCascade: totalTimeoutMs (${config.totalTimeoutMs}ms) reached`));
+            }, Math.max(0, deadlineAt - Date.now()));
+            deadlineTimer.unref?.();
+        }
+        const rungSignal = deadlineAt === undefined
+            ? specBase.signal
+            : specBase.signal
+                ? AbortSignal.any([specBase.signal, rungAbort.signal])
+                : rungAbort.signal;
+        let result;
+        try {
+            result = await runner.runTask({ ...specBase, model: rung.model, ...(rung.overrides ?? {}), ...(rungSignal ? { signal: rungSignal } : {}) });
+        }
+        finally {
+            if (deadlineTimer !== undefined)
+                clearTimeout(deadlineTimer);
+        }
         lastResult = result;
         const s = result.stats;
-        const rungCost = (s.costMicroUsd ?? 0) + (s.nested?.costMicroUsd ?? 0);
-        totalCost += rungCost;
+        const rungCostKnown = s.costMicroUsd !== undefined && (s.nested === undefined || s.nested.costMicroUsd !== undefined);
+        const rungCost = rungCostKnown ? (s.costMicroUsd ?? 0) + (s.nested?.costMicroUsd ?? 0) : undefined;
+        totalCost += rungCost ?? 0;
+        if (!rungCostKnown)
+            ceilingCostKnown = false;
         ownTokens += s.tokens;
         ownTurns += s.turns;
         ownPrompt += s.promptTokens ?? 0;
+        ownTotalInput += s.totalInputTokens ?? 0;
         ownCached += s.cachedTokens ?? 0;
         ownOutput += s.outputTokens ?? 0;
         ownCacheWrite += s.cacheWriteTokens ?? 0;
         ownCacheWriteLong += s.cacheWriteTokensLong ?? 0;
         ownCostMicro += s.costMicroUsd ?? 0;
+        if (s.costMicroUsd === undefined)
+            anyRungUnpriced = true;
         if (s.costBreakdown) {
             ownLlmRootMicro += s.costBreakdown.llmRootMicroUsd;
             ownCompactionMicro += s.costBreakdown.compactionMicroUsd;
@@ -90,11 +118,26 @@ export async function runCascade(runner, spec, config) {
                 ...mapped,
                 stats: cumulativeStats(result.stats),
                 cascadeOutcome: "exhausted",
+                ...(config.costCeilingMicroUsd != null && !ceilingCostKnown ? { costCeilingUnenforceable: true } : {}),
                 escalated: i > 0,
                 finalRung: i,
                 attempts,
             };
         }
+        if (deadlineFired || specBase.signal?.aborted === true) {
+            attempts.push({
+                index: i,
+                model: rung.model,
+                passed: false,
+                costMicroUsd: rungCost,
+                status: result.status,
+                errorCode: result.errorCode,
+                ...(deadlineFired ? { timedOut: true } : { cancelled: true }),
+            });
+            notifier.notify(() => config.onRung?.({ index: i, model: rung.model, passed: false, result }), CASCADE_ON_RUNG_SITE);
+            await releaseSession(runner, result.sessionId);
+            break;
+        }
         let passed = false;
         let gateError;
         let diagnostics;
@@ -112,6 +155,9 @@ export async function runCascade(runner, spec, config) {
                 passed = false;
                 gateError = e instanceof Error ? e.message : String(e);
             }
+            const statusRejected = passed && config.acceptPartial !== true && result.status !== "completed";
+            if (statusRejected)
+                passed = false;
             attempts.push({
                 index: i,
                 model: rung.model,
@@ -121,12 +167,9 @@ export async function runCascade(runner, spec, config) {
                 errorCode: result.errorCode,
                 gateError,
                 diagnostics,
+                ...(statusRejected ? { statusRejected: true } : {}),
             });
-            try {
-                config.onRung?.({ index: i, model: rung.model, passed, result });
-            }
-            catch {
-            }
+            notifier.notify(() => config.onRung?.({ index: i, model: rung.model, passed, result }), CASCADE_ON_RUNG_SITE);
         }
         finally {
             await releaseSession(runner, result.sessionId);
@@ -142,6 +185,7 @@ export async function runCascade(runner, spec, config) {
         ...base,
         stats: cumulativeStats(base.stats),
         cascadeOutcome: passedRung >= 0 ? "passed" : "exhausted",
+        ...(config.costCeilingMicroUsd != null && !ceilingCostKnown ? { costCeilingUnenforceable: true } : {}),
         escalated: finalRung > 0,
         finalRung,
         attempts,

package/dist/agents/cumulative-stats.d.ts

@@ -0,0 +1,29 @@
+import type { TaskResult } from "../core/types.js";
+export interface CumulativeNestedTotals {
+    tokens: number;
+    turns: number;
+    tasks: number;
+    costMicroUsd: number;
+}
+export interface CumulativeHumanReviewTotals {
+    count: number;
+    totalWaitMs: number;
+    gates: NonNullable<TaskResult["stats"]["humanReview"]>["gates"];
+}
+export interface CumulativeStatsAccumulator {
+    tokens: number;
+    turns: number;
+    promptTokens: number;
+    totalInputTokens: number;
+    cachedTokens: number;
+    outputTokens: number;
+    cacheWriteTokens: number;
+    cacheWriteTokensLong: number;
+    costMicroUsd: number | undefined;
+    anyLegUnpriced: boolean;
+    llmRootMicroUsd: number;
+    compactionMicroUsd: number;
+    nested: CumulativeNestedTotals;
+    humanReview: CumulativeHumanReviewTotals;
+}
+export declare function buildCumulativeStats(base: TaskResult["stats"], acc: CumulativeStatsAccumulator): TaskResult["stats"];

package/dist/agents/cumulative-stats.js

@@ -0,0 +1,29 @@
+export function buildCumulativeStats(base, acc) {
+    return {
+        ...base,
+        tokens: acc.tokens,
+        turns: acc.turns,
+        promptTokens: acc.promptTokens || undefined,
+        totalInputTokens: acc.totalInputTokens || undefined,
+        cachedTokens: acc.cachedTokens || undefined,
+        outputTokens: acc.outputTokens || undefined,
+        cacheWriteTokens: acc.cacheWriteTokens || undefined,
+        cacheWriteTokensLong: acc.cacheWriteTokensLong || undefined,
+        cacheHitRate: acc.totalInputTokens > 0 ? Math.min(1, acc.cachedTokens / acc.totalInputTokens) : undefined,
+        costMicroUsd: acc.anyLegUnpriced ? undefined : acc.costMicroUsd,
+        nested: acc.nested.tokens > 0 || acc.nested.tasks > 0
+            ? { tokens: acc.nested.tokens, turns: acc.nested.turns, tasks: acc.nested.tasks, costMicroUsd: acc.nested.costMicroUsd || undefined }
+            : undefined,
+        costBreakdown: acc.anyLegUnpriced
+            ? undefined
+            : {
+                llmRootMicroUsd: acc.llmRootMicroUsd,
+                nestedSubagentMicroUsd: acc.nested.costMicroUsd,
+                memoryConsolidationMicroUsd: 0,
+                compactionMicroUsd: acc.compactionMicroUsd,
+            },
+        humanReview: acc.humanReview.count > 0
+            ? { count: acc.humanReview.count, totalWaitMs: acc.humanReview.totalWaitMs, gates: acc.humanReview.gates }
+            : undefined,
+    };
+}

package/dist/agents/observer.d.ts

@@ -63,7 +63,9 @@ export declare class ObserverDigestTap {
     constructor(flush: (activity: ObserverDigestEvent[]) => void);
     record(e: TaskEvent): void;
     private flushText;
+    private readonly notifier;
     private safeFlush;
+    get flushFailures(): number;
     flushSegment(): void;
     finish(reason: string): void;
 }
@@ -112,7 +114,9 @@ export declare class ObserverPairing {
     });
     enqueueSegment(activity: ObserverDigestEvent[], trigger?: string): void;
     private pumping?;
+    private readonly notifier;
     private safeOnError;
+    get onErrorFailures(): number;
     drain(): Promise<void>;
     private pump;
     private deliverBatch;

package/dist/agents/observer.js

@@ -1,5 +1,6 @@
 import { Type } from "typebox";
 import { defineTool } from "../core/tools.js";
+import { createSafeNotifier } from "../core/safe-notify.js";
 export const OBSERVER_EVENT_TAGS = ["tool-call", "user-message", "tool-result", "turn-ended"];
 const TAG_ESCAPE_RE = new RegExp(`<(?=/?(?:${OBSERVER_EVENT_TAGS.join("|")})(?:[>\\s/]|$))`, "gi");
 export function escapeObserverTags(text) {
@@ -181,12 +182,12 @@ export class ObserverDigestTap {
             this.pending.push({ type: "assistant_text", text: this.textBuf });
         this.textBuf = "";
     }
+    notifier = createSafeNotifier();
     safeFlush(slice) {
-        try {
-            this.flush(slice);
-        }
-        catch {
-        }
+        this.notifier.notify(() => this.flush(slice), "observer.digestTap.flush");
+    }
+    get flushFailures() {
+        return this.notifier.failuresAt("observer.digestTap.flush");
     }
     flushSegment() {
         if (this.finished)
@@ -270,12 +271,12 @@ export class ObserverPairing {
         }).catch(() => undefined);
     }
     pumping;
+    notifier = createSafeNotifier();
     safeOnError(err) {
-        try {
-            this.onError?.(err);
-        }
-        catch {
-        }
+        this.notifier.notify(() => this.onError?.(err), "observer.pairing.onError");
+    }
+    get onErrorFailures() {
+        return this.notifier.failuresAt("observer.pairing.onError");
     }
     async drain() {
         while (this.pumping) {

package/dist/agents/repair-loop.d.ts

@@ -12,6 +12,7 @@ export interface OracleResult {
     trace?: string;
     flaky: boolean;
     retries: number;
+    costMicroUsd?: number;
 }
 export type RepairOracle = (graderEnv: ExecutionEnv, evidence: string | undefined) => Promise<OracleResult>;
 export interface RepairBundle {
@@ -41,6 +42,7 @@ export interface RepairResult extends VerificationResult {
     terminal: RepairTerminal;
     bundle: RepairBundle;
     isolationClass?: OracleIsolationVerdict["isolationClass"];
+    oracleCostMicroUsd: number;
 }
 export declare function isolationPermitsAutoAccept(verdict: OracleIsolationVerdict): boolean;
 export declare function repairBundleFromCheckpoint(cp: Checkpoint): RepairBundle | undefined;

package/dist/agents/repair-loop.js

@@ -1,6 +1,7 @@
 import { isDurablePause } from "./suspend-guard.js";
 import { delimitUntrusted, sanitizeUntrustedText } from "../core/untrusted-text.js";
 import { assertOracleIsolation } from "../core/oracle-isolation.js";
+import { buildCumulativeStats } from "./cumulative-stats.js";
 export function isolationPermitsAutoAccept(verdict) {
     return verdict.protected && verdict.isolationClass === "out_of_process";
 }
@@ -55,6 +56,7 @@ export async function runRepairLoop(runner, implSpec, config) {
             terminal: "oracle.unprotected",
             ...(isolationClass ? { isolationClass } : {}),
             bundle: { ...freshBundle(), attemptCount: config.resumeBundle?.attemptCount ?? 0 },
+            oracleCostMicroUsd: 0,
             verification: outcomeFor("oracle.unprotected", oracle, 0),
         };
     };
@@ -77,7 +79,10 @@ export async function runRepairLoop(runner, implSpec, config) {
     else if (config.workerEnv !== undefined && config.workerEnv === config.graderEnv) {
         return unprotectedResult("graderEnv must not be the worker env");
     }
-    const maxAttempts = Math.max(1, Math.floor(config.maxAttempts));
+    const maxAttempts = Number.isFinite(config.maxAttempts) ? Math.max(1, Math.floor(config.maxAttempts)) : 1;
+    if (!Number.isFinite(config.maxAttempts)) {
+        config.onWarn?.(new Error(`repair-loop: maxAttempts must be a finite number (got ${config.maxAttempts}) — falling back to 1 attempt`));
+    }
     const bundle = config.resumeBundle
         ? { ...config.resumeBundle, diagnostics: [...config.resumeBundle.diagnostics], rejectedHypotheses: [...config.resumeBundle.rejectedHypotheses] }
         : freshBundle();
@@ -85,34 +90,126 @@ export async function runRepairLoop(runner, implSpec, config) {
     let spend = 0;
     let lastResult;
     let lastOracle;
+    let ownTokens = 0, ownTurns = 0, ownPrompt = 0, ownTotalInput = 0, ownCached = 0, ownOutput = 0;
+    let ownCacheWrite = 0, ownCacheWriteLong = 0, ownCostMicro = 0;
+    let ownLlmRootMicro = 0, ownCompactionMicro = 0;
+    let anyAttemptUnpriced = false;
+    let nestedTokens = 0, nestedTurns = 0, nestedTasks = 0, nestedCostMicro = 0;
+    let hrCount = 0, hrWaitMs = 0;
+    const hrGates = [];
+    let oracleCostMicroUsd = 0;
+    const accumulate = (s) => {
+        ownTokens += s.tokens;
+        ownTurns += s.turns;
+        ownPrompt += s.promptTokens ?? 0;
+        ownTotalInput += s.totalInputTokens ?? 0;
+        ownCached += s.cachedTokens ?? 0;
+        ownOutput += s.outputTokens ?? 0;
+        ownCacheWrite += s.cacheWriteTokens ?? 0;
+        ownCacheWriteLong += s.cacheWriteTokensLong ?? 0;
+        ownCostMicro += s.costMicroUsd ?? 0;
+        if (s.costMicroUsd === undefined)
+            anyAttemptUnpriced = true;
+        if (s.costBreakdown) {
+            ownLlmRootMicro += s.costBreakdown.llmRootMicroUsd;
+            ownCompactionMicro += s.costBreakdown.compactionMicroUsd;
+        }
+        if (s.humanReview) {
+            hrCount += s.humanReview.count;
+            hrWaitMs += s.humanReview.totalWaitMs;
+            hrGates.push(...s.humanReview.gates);
+        }
+        if (s.nested) {
+            nestedTokens += s.nested.tokens;
+            nestedTurns += s.nested.turns;
+            nestedTasks += s.nested.tasks;
+            nestedCostMicro += s.nested.costMicroUsd ?? 0;
+        }
+    };
+    const cumulativeStats = (base) => buildCumulativeStats(base, {
+        tokens: ownTokens,
+        turns: ownTurns,
+        promptTokens: ownPrompt,
+        totalInputTokens: ownTotalInput,
+        cachedTokens: ownCached,
+        outputTokens: ownOutput,
+        cacheWriteTokens: ownCacheWrite,
+        cacheWriteTokensLong: ownCacheWriteLong,
+        costMicroUsd: ownCostMicro,
+        anyLegUnpriced: anyAttemptUnpriced,
+        llmRootMicroUsd: ownLlmRootMicro,
+        compactionMicroUsd: ownCompactionMicro,
+        nested: { tokens: nestedTokens, turns: nestedTurns, tasks: nestedTasks, costMicroUsd: nestedCostMicro },
+        humanReview: { count: hrCount, totalWaitMs: hrWaitMs, gates: hrGates },
+    });
     let restartedOnce = false;
     let restartUsed = false;
     const cleanRestartSpec = () => {
         const { sessionId: _drop, ...rest } = implSpec;
         return { ...rest, objective: `${implSpec.objective}\n\n${repairObjective(bundle)}` };
     };
+    const exhaustedBeforeDispatch = () => ({
+        taskId: implSpec.taskId ?? "",
+        status: "failed",
+        result: `repair loop: attempt budget already spent (attemptCount ${bundle.attemptCount} >= maxAttempts ${maxAttempts}) — no attempt dispatched`,
+        errorCode: "repair.attempts_exhausted",
+        sessionId: implSpec.sessionId ?? "",
+        stats: { tokens: 0, turns: 0, costMicroUsd: 0 },
+        terminal: "gave_up",
+        bundle,
+        ...(isolationClass ? { isolationClass } : {}),
+        oracleCostMicroUsd,
+        verification: outcomeFor("gave_up", undefined, bundle.attemptCount),
+    });
     while (true) {
+        if (!restartedOnce && bundle.attemptCount >= maxAttempts)
+            return exhaustedBeforeDispatch();
         const isRepair = bundle.attemptCount > 0 && lastResult !== undefined && !restartedOnce;
+        const isSeededResume = !restartedOnce &&
+            lastResult === undefined &&
+            config.resumeBundle !== undefined &&
+            (bundle.failureTrace.trim() !== "" || bundle.diagnostics.length > 0);
         const spec = restartedOnce
             ? cleanRestartSpec()
             : isRepair
                 ? { ...implSpec, sessionId: lastResult.sessionId, objective: repairObjective(bundle) }
-                : implSpec;
+                : isSeededResume
+                    ? {
+                        ...implSpec,
+                        objective: implSpec.sessionId ? repairObjective(bundle) : `${implSpec.objective}\n\n${repairObjective(bundle)}`,
+                    }
+                    : implSpec;
         restartedOnce = false;
         const result = await runner.runTask(spec, { repairBundle: bundle });
         spend += (result.stats.costMicroUsd ?? 0) + (result.stats.nested?.costMicroUsd ?? 0);
+        accumulate(result.stats);
         lastResult = result;
         bundle.attemptCount += 1;
         if (isDurablePause(result.status)) {
             return {
                 ...result,
+                stats: cumulativeStats(result.stats),
                 terminal: "gave_up",
                 bundle,
                 ...(isolationClass ? { isolationClass } : {}),
+                oracleCostMicroUsd,
                 verification: { verdict: "unverified", unverifiedReason: result.status === "needs_review" ? "needs_review" : "suspended", rounds: bundle.attemptCount, findings: [] },
             };
         }
+        if (result.status !== "completed") {
+            return {
+                ...result,
+                stats: cumulativeStats(result.stats),
+                terminal: "gave_up",
+                bundle,
+                ...(isolationClass ? { isolationClass } : {}),
+                oracleCostMicroUsd,
+                verification: { verdict: "unverified", unverifiedReason: "impl_incomplete", rounds: bundle.attemptCount, findings: [] },
+            };
+        }
         const oracle = await config.oracle(config.graderEnv, result.result);
+        oracleCostMicroUsd += oracle.costMicroUsd ?? 0;
+        spend += oracle.costMicroUsd ?? 0;
         lastOracle = oracle;
         bundle.oracleTier = oracle.tier;
         const projected = terminalForTier(oracle);
@@ -120,9 +217,11 @@ export async function runRepairLoop(runner, implSpec, config) {
         if (projected !== undefined) {
             return {
                 ...result,
+                stats: cumulativeStats(result.stats),
                 terminal: projected,
                 bundle,
                 ...(isolationClass ? { isolationClass } : {}),
+                oracleCostMicroUsd,
                 verification: outcomeFor(projected, oracle, bundle.attemptCount),
             };
         }
@@ -140,7 +239,15 @@ export async function runRepairLoop(runner, implSpec, config) {
                 continue;
             }
             const terminal = "gave_up";
-            return { ...lastResult, terminal, bundle, ...(isolationClass ? { isolationClass } : {}), verification: outcomeFor(terminal, lastOracle, bundle.attemptCount) };
+            return {
+                ...lastResult,
+                stats: cumulativeStats(lastResult.stats),
+                terminal,
+                bundle,
+                ...(isolationClass ? { isolationClass } : {}),
+                oracleCostMicroUsd,
+                verification: outcomeFor(terminal, lastOracle, bundle.attemptCount),
+            };
         }
     }
 }

package/dist/agents/retain-ledger.d.ts

@@ -22,6 +22,14 @@ export interface SubagentRetainEntry {
     activeAbort?: AbortController;
     release: () => Promise<void>;
 }
+export type RetainEvictionTrigger = "ttl_sweep" | "ttl_timer" | "lru_overflow" | "session_ledger_lru" | "session_reap";
+export interface RetainLedgerHooks {
+    onEvictionError?: (info: {
+        parentToolCallId?: string;
+        trigger: RetainEvictionTrigger;
+        error: Error;
+    }) => void;
+}
 export declare class SubagentRetainLedger {
     readonly ttlMs: number;
     readonly max: number;
@@ -29,10 +37,20 @@ export declare class SubagentRetainLedger {
     private evictedIds;
     private ttlTimers;
     private isDisposed;
+    private readonly hooks;
+    private failedEvictions;
+    private lastFailure;
+    private readonly notifier;
     constructor(config: true | {
         ttlMs?: number;
         max?: number;
-    });
+    }, hooks?: RetainLedgerHooks);
+    get evictionFailureCount(): number;
+    get lastEvictionError(): Error | undefined;
+    get evictionSinkFailureCount(): number;
+    noteDetachedFailure(trigger: RetainEvictionTrigger, error: unknown, parentToolCallId?: string): void;
+    private evictDetached;
+    disposeAllDetached(trigger: RetainEvictionTrigger): void;
     private static readonly TOMBSTONES_MAX;
     private tombstone;
     private effectiveTtlMs;
@@ -54,7 +72,7 @@ export declare function getSessionRetainLedger(sessionId: string): SubagentRetai
 export declare function getOrCreateSessionRetainLedger(sessionId: string, config: {
     ttlMs: number;
     max: number;
-}): SubagentRetainLedger;
+}, hooks?: RetainLedgerHooks): SubagentRetainLedger;
 export declare function releaseSessionRetainLedger(sessionId: string): Promise<void>;
 export declare function ensureSessionReapHook(registry: import("../core/task-registry.js").TaskRegistry): void;
 export declare function createResumePrompt(marker: string, content: string): string;