@sema-agent/core 3.0.0 → 4.0.0

package/dist/agents/cascade.d.ts

@@ -29,7 +29,7 @@ export interface CascadeAttempt {
     index: number;
     model: ModelRef;
     passed: boolean;
-    costMicroUsd: number;
+    costMicroUsd?: number;
     status: TaskResult["status"];
     errorCode?: string;
     gateError?: string;
@@ -40,6 +40,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();
     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.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,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();
@@ -89,7 +93,10 @@ export async function runRepairLoop(runner, implSpec, config) {
     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 +108,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 +126,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;

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.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();
     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));
 }