@sema-agent/core 3.0.0 → 5.0.0

package/dist/agents/cascade.d.ts

@@ -9,6 +9,7 @@ export interface CascadeRung {
     overrides?: Partial<Pick<TaskSpec, "limits" | "degrade" | "systemPrompt">>;
 }
 export interface CascadeConfig {
+    onNotifyError?: (failure: import("../core/safe-notify.js").SafeNotifyFailure) => void;
     ladder: CascadeRung[];
     gate?: (result: TaskResult, rung: {
         index: number;
@@ -29,7 +30,7 @@ export interface CascadeAttempt {
     index: number;
     model: ModelRef;
     passed: boolean;
-    costMicroUsd: number;
+    costMicroUsd?: number;
     status: TaskResult["status"];
     errorCode?: string;
     gateError?: string;
@@ -40,6 +41,7 @@ export interface CascadeAttempt {
 }
 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);
@@ -14,37 +17,33 @@ export async function runCascade(runner, spec, config) {
     const gate = config.gate ?? createDefaultGate(spec);
     const startedAt = Date.now();
     const deadlineAt = config.totalTimeoutMs != null ? startedAt + config.totalTimeoutMs : undefined;
+    const notifier = createSafeNotifier(config.onNotifyError !== undefined ? { onError: config.onNotifyError } : undefined);
     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: ownTotalInput || undefined,
-        cachedTokens: ownCached || undefined,
-        outputTokens: ownOutput || undefined,
-        cacheWriteTokens: ownCacheWrite || undefined,
-        cacheWriteTokensLong: ownCacheWriteLong || undefined,
-        cacheHitRate: ownTotalInput > 0 ? Math.min(1, ownCached / ownTotalInput) : 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;
@@ -52,8 +51,9 @@ export async function runCascade(runner, spec, config) {
     for (let i = 0; i < maxRungs; i++) {
         if (deadlineAt !== undefined && Date.now() >= deadlineAt)
             break;
-        if (i > 0 && config.costCeilingMicroUsd != null && totalCost >= config.costCeilingMicroUsd)
+        if (i > 0 && config.costCeilingMicroUsd != null && (totalCost >= config.costCeilingMicroUsd || !ceilingCostKnown)) {
             break;
+        }
         const rung = ladder[i];
         let deadlineFired = false;
         const rungAbort = new AbortController();
@@ -80,8 +80,11 @@ export async function runCascade(runner, spec, config) {
         }
         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;
@@ -91,6 +94,8 @@ export async function runCascade(runner, spec, config) {
         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;
@@ -113,6 +118,7 @@ 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,
@@ -128,11 +134,7 @@ export async function runCascade(runner, spec, config) {
                 errorCode: result.errorCode,
                 ...(deadlineFired ? { timedOut: true } : { cancelled: true }),
             });
-            try {
-                config.onRung?.({ index: i, model: rung.model, passed: false, result });
-            }
-            catch {
-            }
+            notifier.notify(() => config.onRung?.({ index: i, model: rung.model, passed: false, result }), CASCADE_ON_RUNG_SITE);
             await releaseSession(runner, result.sessionId);
             break;
         }
@@ -167,11 +169,7 @@ export async function runCascade(runner, spec, config) {
                 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);
@@ -187,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

@@ -21,6 +21,8 @@ export interface RepairBundle {
     rejectedHypotheses: string[];
     attemptCount: number;
     oracleTier: OracleTier;
+    spentMicroUsd?: number;
+    activeElapsedMs?: number;
 }
 export interface RepairLoopConfig {
     oracle: RepairOracle;

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";
 }
@@ -78,18 +79,31 @@ 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();
     const startedAt = Date.now();
-    let spend = 0;
+    const seededSpend = config.resumeBundle?.spentMicroUsd;
+    const seededActiveMs = config.resumeBundle?.activeElapsedMs;
+    const priorActiveMs = typeof seededActiveMs === "number" && Number.isFinite(seededActiveMs) ? Math.max(0, seededActiveMs) : 0;
+    let spend = typeof seededSpend === "number" && Number.isFinite(seededSpend) ? Math.max(0, seededSpend) : 0;
+    const stampAccount = () => {
+        bundle.spentMicroUsd = spend;
+        bundle.activeElapsedMs = priorActiveMs + (Date.now() - startedAt);
+    };
     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;
@@ -101,10 +115,17 @@ export async function runRepairLoop(runner, implSpec, config) {
         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;
@@ -112,27 +133,21 @@ export async function runRepairLoop(runner, implSpec, config) {
             nestedCostMicro += s.nested.costMicroUsd ?? 0;
         }
     };
-    const cumulativeStats = (base) => ({
-        ...base,
+    const cumulativeStats = (base) => buildCumulativeStats(base, {
         tokens: ownTokens,
         turns: ownTurns,
-        promptTokens: ownPrompt || undefined,
-        totalInputTokens: ownTotalInput || undefined,
-        cachedTokens: ownCached || undefined,
-        outputTokens: ownOutput || undefined,
-        cacheWriteTokens: ownCacheWrite || undefined,
-        cacheWriteTokensLong: ownCacheWriteLong || undefined,
-        cacheHitRate: ownTotalInput > 0 ? Math.min(1, ownCached / ownTotalInput) : 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: base.costBreakdown?.memoryConsolidationMicroUsd ?? 0,
-            compactionMicroUsd: ownCompactionMicro,
-        },
+        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;
@@ -140,11 +155,11 @@ export async function runRepairLoop(runner, implSpec, config) {
         const { sessionId: _drop, ...rest } = implSpec;
         return { ...rest, objective: `${implSpec.objective}\n\n${repairObjective(bundle)}` };
     };
-    const exhaustedBeforeDispatch = () => ({
+    const exhaustedBeforeDispatch = (message, errorCode) => ({
         taskId: implSpec.taskId ?? "",
         status: "failed",
-        result: `repair loop: attempt budget already spent (attemptCount ${bundle.attemptCount} >= maxAttempts ${maxAttempts}) — no attempt dispatched`,
-        errorCode: "repair.attempts_exhausted",
+        result: message ?? `repair loop: attempt budget already spent (attemptCount ${bundle.attemptCount} >= maxAttempts ${maxAttempts}) — no attempt dispatched`,
+        errorCode: errorCode ?? "repair.attempts_exhausted",
         sessionId: implSpec.sessionId ?? "",
         stats: { tokens: 0, turns: 0, costMicroUsd: 0 },
         terminal: "gave_up",
@@ -156,6 +171,13 @@ export async function runRepairLoop(runner, implSpec, config) {
     while (true) {
         if (!restartedOnce && bundle.attemptCount >= maxAttempts)
             return exhaustedBeforeDispatch();
+        if (config.costCeilingMicroUsd != null && spend >= config.costCeilingMicroUsd) {
+            return exhaustedBeforeDispatch(`repair loop: cost ceiling already spent (carried ${spend} >= ceiling ${config.costCeilingMicroUsd} micro-USD) — no attempt dispatched`, "repair.budget_exhausted");
+        }
+        if (config.totalTimeoutMs != null && priorActiveMs + (Date.now() - startedAt) >= config.totalTimeoutMs) {
+            return exhaustedBeforeDispatch(`repair loop: active time budget already spent (carried ${priorActiveMs + (Date.now() - startedAt)}ms >= ${config.totalTimeoutMs}ms) — no attempt dispatched`, "repair.budget_exhausted");
+        }
+        stampAccount();
         const isRepair = bundle.attemptCount > 0 && lastResult !== undefined && !restartedOnce;
         const isSeededResume = !restartedOnce &&
             lastResult === undefined &&
@@ -174,6 +196,7 @@ export async function runRepairLoop(runner, implSpec, config) {
         restartedOnce = false;
         const result = await runner.runTask(spec, { repairBundle: bundle });
         spend += (result.stats.costMicroUsd ?? 0) + (result.stats.nested?.costMicroUsd ?? 0);
+        stampAccount();
         accumulate(result.stats);
         lastResult = result;
         bundle.attemptCount += 1;
@@ -202,6 +225,7 @@ export async function runRepairLoop(runner, implSpec, config) {
         const oracle = await config.oracle(config.graderEnv, result.result);
         oracleCostMicroUsd += oracle.costMicroUsd ?? 0;
         spend += oracle.costMicroUsd ?? 0;
+        stampAccount();
         lastOracle = oracle;
         bundle.oracleTier = oracle.tier;
         const projected = terminalForTier(oracle);
@@ -222,7 +246,7 @@ export async function runRepairLoop(runner, implSpec, config) {
             if (bundle.diagnostics.length < 3)
                 bundle.diagnostics.push(oracle.trace);
         }
-        const overTime = config.totalTimeoutMs != null && Date.now() - startedAt >= config.totalTimeoutMs;
+        const overTime = config.totalTimeoutMs != null && priorActiveMs + (Date.now() - startedAt) >= config.totalTimeoutMs;
         const overCost = config.costCeilingMicroUsd != null && spend >= config.costCeilingMicroUsd;
         if (bundle.attemptCount >= maxAttempts || overTime || overCost) {
             if (bundle.attemptCount >= maxAttempts && !overTime && !overCost && lastResult !== undefined && !restartUsed) {

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

@@ -40,12 +40,14 @@ export declare class SubagentRetainLedger {
     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;

package/dist/agents/retain-ledger.js

@@ -1,4 +1,5 @@
 import { delimitUntrusted } from "../core/untrusted-text.js";
+import { createSafeNotifier } from "../core/safe-notify.js";
 import { RETAIN_DEFAULT_TTL_MS, RETAIN_DEFAULT_MAX } from "../config/defaults.js";
 export const SUBAGENT_RESUME_CAP = 8;
 export class SubagentRetainLedger {
@@ -11,6 +12,7 @@ export class SubagentRetainLedger {
     hooks;
     failedEvictions = 0;
     lastFailure;
+    notifier = createSafeNotifier();
     constructor(config, hooks) {
         const cfg = config === true ? {} : config;
         this.ttlMs = cfg.ttlMs ?? RETAIN_DEFAULT_TTL_MS;
@@ -23,15 +25,14 @@ export class SubagentRetainLedger {
     get lastEvictionError() {
         return this.lastFailure;
     }
+    get evictionSinkFailureCount() {
+        return this.notifier.failuresAt("retainLedger.onEvictionError");
+    }
     noteDetachedFailure(trigger, error, parentToolCallId) {
         const err = error instanceof Error ? error : new Error(String(error));
         this.failedEvictions += 1;
         this.lastFailure = err;
-        try {
-            this.hooks?.onEvictionError?.({ ...(parentToolCallId !== undefined ? { parentToolCallId } : {}), trigger, error: err });
-        }
-        catch {
-        }
+        this.notifier.notify(() => this.hooks?.onEvictionError?.({ ...(parentToolCallId !== undefined ? { parentToolCallId } : {}), trigger, error: err }), "retainLedger.onEvictionError");
     }
     evictDetached(parentToolCallId, trigger) {
         void this.evict(parentToolCallId).catch((e) => this.noteDetachedFailure(trigger, e, parentToolCallId));

package/dist/agents/roster-store.d.ts

@@ -23,6 +23,7 @@ export interface RosterStore {
     releaseAgent(agentId: string): void | Promise<void>;
 }
 export interface RosterGcOptions {
+    onNotifyError?: (failure: import("../core/safe-notify.js").SafeNotifyFailure) => void;
     maxAgeMs?: number;
     maxEntries?: number;
     onEvicted?: (entry: RosterEntry) => void;

package/dist/agents/roster-store.js

@@ -2,6 +2,7 @@ import { mkdirSync, readFileSync } from "node:fs";
 import { atomicWriteFile } from "../stores/file/fs-atomic.js";
 import { dirname } from "node:path";
 import { normalizeAgentName } from "../core/task-registry.js";
+import { createSafeNotifier } from "../core/safe-notify.js";
 export function entryAccessible(e, access) {
     if (e.scope === undefined || access.scope === undefined || access.scope !== e.scope)
         return false;
@@ -35,15 +36,12 @@ function capped(entries, opts) {
     const max = opts?.maxEntries;
     if (max === undefined || entries.length <= max)
         return entries;
+    const notifier = createSafeNotifier(opts?.onNotifyError !== undefined ? { onError: opts.onNotifyError } : undefined);
     const byAge = [...entries].sort((a, b) => a.createdAt - b.createdAt);
     const dropCount = Math.max(0, entries.length - Math.max(0, max));
     const dropped = new Set(byAge.slice(0, dropCount));
     for (const e of dropped) {
-        try {
-            opts?.onEvicted?.(e);
-        }
-        catch {
-        }
+        notifier.notify(() => opts?.onEvicted?.(e), "rosterStore.onEvicted");
     }
     return entries.filter((e) => !dropped.has(e));
 }

package/dist/agents/send-message-tool.d.ts

@@ -36,6 +36,7 @@ export interface SendMessageToolOptions {
         content: string;
         details?: unknown;
     }>;
+    onNotifyError?: (failure: import("../core/safe-notify.js").SafeNotifyFailure) => void;
     enrichCtx?: ToolCtxEnricher;
 }
 export declare const SEND_MESSAGE_SUMMARY_MAX = 200;

package/dist/agents/send-message-tool.js

@@ -525,6 +525,8 @@ export function createSendMessageTool(opts) {
                     ...(row.parentTaskId !== undefined ? { rowParentTaskId: row.parentTaskId } : {}),
                     ...(row.parentSessionId !== undefined ? { rowParentSessionId: row.parentSessionId } : {}),
                     ...(row.rootSessionId !== undefined ? { rowRootSessionId: row.rootSessionId } : {}),
+                    ...(row.createdAt !== undefined ? { rowSpawnedAt: row.createdAt } : {}),
+                    ...(opts.onNotifyError !== undefined ? { onNotifyError: opts.onNotifyError } : {}),
                     ...(opts.notify ? { currentParentNotify: opts.notify } : {}),
                 });
                 const fromPrefix = senderIsChild ? `(message from teammate "${senderLabel}")\n` : "";

package/dist/agents/subagent.d.ts

@@ -10,7 +10,6 @@ export type { SubagentStep, SubagentEditedFile } from "./subagent-steps.js";
 export declare function notifyResultField(result: string | undefined): string | undefined;
 export declare function inheritedManifestScopeFor(snapshot: readonly unknown[] | undefined): RunInternals["inheritedManifestScope"];
 export declare const DEFAULT_SUBAGENT_TOOL_NAME = "Agent";
-export declare const LEGACY_SUBAGENT_TOOL_NAME = "Task";
 export declare const EXTRA_TOOLS_MAX_FACTORY_CALLS_PER_TREE = 64;
 export declare const DEFAULT_SUBAGENT_MAX_DEPTH = 3;
 export declare const EXTRA_TOOLS_FAILED_NOTE = "note: extraTools evaluation failed \u2014 the injected tool set was skipped for this spawn.";
@@ -76,6 +75,8 @@ export declare function createSubagentResume(deps: {
     rowParentTaskId?: string;
     rowParentSessionId?: string;
     rowRootSessionId?: string;
+    rowSpawnedAt?: number;
+    onNotifyError?: (failure: import("../core/safe-notify.js").SafeNotifyFailure) => void;
 }): (content: string) => Promise<string>;
 export interface SubagentToolOptions {
     runner: Runner;
@@ -109,6 +110,7 @@ export interface SubagentToolOptions {
     onObserverError?: (err: unknown, info: {
         observedAgent?: string;
         observerAgent?: string;
+        site?: string;
     }) => void;
     extraTools?: (ctx: SubagentSpawnContext) => ToolSpec[] | Promise<ToolSpec[]>;
     onExtraToolsError?: (err: unknown, info: {