@sema-agent/core 2.13.0 → 4.0.0

package/dist/core/runner/turn-attachments.d.ts

@@ -1,3 +1,4 @@
+import type { McpDroppedTool } from "../mcp.js";
 import { type SkillListingEntry } from "./synthetic-tools.js";
 export declare const TODO_REMINDER_CONFIG: {
     readonly TURNS_SINCE_WRITE: 10;
@@ -112,11 +113,7 @@ export interface AttachmentInputs {
         }>;
         removed: readonly string[];
     };
-    mcpDroppedTools?: ReadonlyArray<{
-        server: string;
-        tool: string;
-        reason: string;
-    }>;
+    mcpDroppedTools?: ReadonlyArray<McpDroppedTool>;
 }
 export declare function collectDueAttachments(state: AttachmentState, inp: AttachmentInputs): readonly TurnAttachment[];
 export declare function renderToolSearchUsageReminder(undiscovered: readonly string[]): string;
@@ -178,14 +175,7 @@ export declare function renderMcpInstructionsDelta(added: ReadonlyArray<{
     server: string;
     text: string;
 }>, removed: readonly string[]): string | undefined;
-export declare function renderMcpDroppedTools(entries: ReadonlyArray<{
-    server: string;
-    tool: string;
-    reason: string;
-}>): string;
+export declare function renderMcpDroppedTools(entries: ReadonlyArray<McpDroppedTool>): string;
 export declare const MCP_DROPPED_BATCH_MAX_BYTES = 4096;
-export declare function selectMcpDroppedBatch<T extends {
-    server: string;
-    tool: string;
-    reason: string;
-}>(entries: ReadonlyArray<T>): T[];
+export declare function selectMcpDroppedBatch<T extends McpDroppedTool>(entries: ReadonlyArray<T>): T[];
+export declare function clipToBytes(s: string, maxBytes: number): string;

package/dist/core/runner/turn-attachments.js

@@ -634,7 +634,7 @@ function capAttachments(atts) {
     }
     return out;
 }
-function clipToBytes(s, maxBytes) {
+export function clipToBytes(s, maxBytes) {
     if (Buffer.byteLength(s, "utf8") <= maxBytes)
         return s;
     let lo = 0;

package/dist/core/runner/usage-accounting.d.ts

@@ -7,6 +7,11 @@ export declare function promptTokensOf(family: CacheFamily, u: {
     cacheRead: number;
     cacheWrite: number;
 }): number;
+export declare function uncachedInputTokensOf(family: CacheFamily, u: {
+    input: number;
+    cacheRead: number;
+    cacheWrite: number;
+}): number;
 export declare function usageCostMicroUsd(family: CacheFamily, u: {
     input?: number;
     output?: number;
@@ -14,5 +19,6 @@ export declare function usageCostMicroUsd(family: CacheFamily, u: {
     cacheWrite?: number;
 }, pricing: ModelPricing): {
     totalInputTokens: number;
+    uncachedInputTokens: number;
     costMicroUsd: number;
 };

package/dist/core/runner/usage-accounting.js

@@ -12,18 +12,19 @@ export function cacheFamilyOf(model) {
 export function promptTokensOf(family, u) {
     return family === "input-excludes-cached" ? u.input + u.cacheRead + u.cacheWrite : u.input;
 }
+export function uncachedInputTokensOf(family, u) {
+    return Math.max(0, promptTokensOf(family, u) - u.cacheRead - u.cacheWrite);
+}
 export function usageCostMicroUsd(family, u, pricing) {
-    const totalInputTokens = promptTokensOf(family, {
-        input: u.input || 0,
-        cacheRead: u.cacheRead || 0,
-        cacheWrite: u.cacheWrite || 0,
-    });
+    const normalized = { input: u.input || 0, cacheRead: u.cacheRead || 0, cacheWrite: u.cacheWrite || 0 };
+    const totalInputTokens = promptTokensOf(family, normalized);
+    const uncachedInputTokens = uncachedInputTokensOf(family, normalized);
     const costMicroUsd = computeCostMicroUsd({
         totalInputTokens,
-        cacheReadTokens: u.cacheRead || 0,
-        cacheWriteTokens: u.cacheWrite || 0,
+        cacheReadTokens: normalized.cacheRead,
+        cacheWriteTokens: normalized.cacheWrite,
         cacheWriteTokensLong: 0,
         outputTokens: u.output || 0,
     }, pricing);
-    return { totalInputTokens, costMicroUsd };
+    return { totalInputTokens, uncachedInputTokens, costMicroUsd };
 }

package/dist/core/safe-notify.d.ts

@@ -0,0 +1,17 @@
+export interface SafeNotifyFailure {
+    readonly site: string;
+    readonly error: Error;
+    readonly failures: number;
+}
+export interface SafeNotifierOptions {
+    readonly onError?: (failure: SafeNotifyFailure) => void;
+}
+export interface SafeNotifier {
+    notify(run: () => void, site: string): boolean;
+    notifyAsync(run: () => unknown, site: string): Promise<boolean>;
+    readonly failures: number;
+    failuresAt(site: string): number;
+    lastErrorAt(site: string): Error | undefined;
+    failedSites(): readonly string[];
+}
+export declare function createSafeNotifier(opts?: SafeNotifierOptions): SafeNotifier;

package/dist/core/safe-notify.js

@@ -0,0 +1,59 @@
+export function createSafeNotifier(opts) {
+    const onError = opts?.onError;
+    let sites;
+    let total = 0;
+    const record = (site, thrown) => {
+        const error = thrown instanceof Error ? thrown : new Error(String(thrown));
+        total += 1;
+        if (sites === undefined)
+            sites = new Map();
+        const state = sites.get(site);
+        if (state !== undefined) {
+            state.count += 1;
+            state.last = error;
+            return;
+        }
+        sites.set(site, { count: 1, last: error });
+        if (onError === undefined)
+            return;
+        try {
+            onError({ site, error, failures: 1 });
+        }
+        catch {
+        }
+    };
+    return {
+        notify(run, site) {
+            try {
+                run();
+                return true;
+            }
+            catch (e) {
+                record(site, e);
+                return false;
+            }
+        },
+        async notifyAsync(run, site) {
+            try {
+                await run();
+                return true;
+            }
+            catch (e) {
+                record(site, e);
+                return false;
+            }
+        },
+        get failures() {
+            return total;
+        },
+        failuresAt(site) {
+            return sites?.get(site)?.count ?? 0;
+        },
+        lastErrorAt(site) {
+            return sites?.get(site)?.last;
+        },
+        failedSites() {
+            return sites === undefined ? [] : [...sites.keys()];
+        },
+    };
+}

package/dist/core/secret-env.js

@@ -1,5 +1,9 @@
 const SECRET_ENV_RE = /(^|_)(KEY|TOKEN|SECRET|SECRETS|PASSWORD|PASSWD|CREDENTIAL|CREDENTIALS|PRIVATEKEY|APIKEY|ACCESS_KEY|SESSION_TOKEN)(?:_(?:\d+|ID))?$/i;
-const SECRET_ENV_EXACT_NAMES = new Set(["DATABASE_URL", "CONNECTION_STRING", "DSN", "NPM_AUTH"]);
+const SECRET_ENV_EXACT_NAMES = new Set([
+    "DATABASE_URL", "CONNECTION_STRING", "DSN", "NPM_AUTH",
+    "PGPASSWORD", "MYSQL_PWD", "SSHPASS", "GPG_PASSPHRASE", "GH_PAT", "GITHUB_PAT",
+    "NPM_CONFIG__AUTH", "NPM_CONFIG__AUTHTOKEN",
+]);
 export function isSecretEnvKey(key) {
     return SECRET_ENV_RE.test(key) || SECRET_ENV_EXACT_NAMES.has(key.toUpperCase());
 }

package/dist/core/sensitive-path-policy.js

@@ -14,6 +14,9 @@ export const RECOMMENDED_SENSITIVE_PATTERNS = [
     ".ssh",
     ".git/hooks",
     ".git/config",
+    ".git/modules",
+    ".mcp.json",
+    ".claude*",
     ".aws",
     ".config/gcloud",
     ".azure",
@@ -24,15 +27,19 @@ export const RECOMMENDED_SENSITIVE_PATTERNS = [
     ".zsh_history",
 ];
 function segmentGlobToRegExp(segment) {
-    const escaped = segment.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*");
-    return new RegExp(`^${escaped}$`);
+    const escaped = segment.replace(/[.+^${}()|[\]\\?]/g, "\\$&").replace(/\*/g, "[^/]*");
+    return new RegExp(`^${escaped}$`, CASE_INSENSITIVE_FS ? "i" : "");
 }
+const CASE_INSENSITIVE_FS = process.platform === "darwin" || process.platform === "win32";
 function compilePatterns(patterns) {
     const out = [];
     for (const raw of patterns) {
         const segments = raw.split("/").filter(Boolean).map(segmentGlobToRegExp);
-        if (segments.length > 0)
-            out.push({ raw, segments });
+        if (segments.length === 0) {
+            throw new Error(`createSensitivePathPolicy: pattern ${JSON.stringify(raw)} contains no path segments and would guard nothing. ` +
+                `Patterns are "/"-separated runs of path SEGMENTS (e.g. ".ssh", ".git/hooks", "*.pem"); remove the entry or spell the segments.`);
+        }
+        out.push({ raw, segments });
     }
     return out;
 }

package/dist/core/store-contracts/checkpoint-store-contract.js

@@ -20,7 +20,7 @@ export function createCheckpointFixture(over = {}) {
         },
         state: {
             activeTools: [],
-            nestedStats: { tokens: 0, turns: 0, tasks: 0, costMicroUsd: 0 },
+            nestedStats: { tokens: 0, turns: 0, tasks: 0, costMicroUsd: 0, anyUnpriced: false },
         },
         status: "pending",
         createdAt: 1_700_000_000_000,

package/dist/core/store-contracts/session-repo-contract.js

@@ -32,5 +32,45 @@ export async function sessionRepoContract(make, runAssertion) {
         const repo = make();
         await assert.rejects(repo.open({ id: "0198fa00-0000-7000-8000-0000000000ff", createdAt: "" }), /not.?found/i);
     });
+    run("delete() makes the id not_found — the history is gone, not merely hidden from open()", async () => {
+        const repo = make();
+        const sess = await repo.create({ id: A });
+        await sess.getStorage().appendEntry(SESSION_ENTRY("e1", null));
+        await repo.delete({ id: A, createdAt: "" });
+        await assert.rejects(repo.open({ id: A, createdAt: "" }), /not.?found/i);
+        const fresh = await repo.create({ id: A });
+        assert.deepEqual((await fresh.getStorage().getEntries()).map((e) => e.id), []);
+    });
+    run("fork() copies the log, stamps forkedFrom, and leaves the SOURCE untouched", async () => {
+        const repo = make();
+        const src = await repo.create({ id: A });
+        await src.getStorage().appendEntry(SESSION_ENTRY("e1", null));
+        await src.getStorage().appendEntry(SESSION_ENTRY("e2", "e1"));
+        const B = "0198fa00-0000-7000-8000-00000000000b";
+        const forked = await repo.fork({ id: A, createdAt: "" }, { id: B });
+        assert.deepEqual((await forked.getStorage().getEntries()).map((e) => e.id), ["e1", "e2"]);
+        assert.equal((await forked.getMetadata()).forkedFrom, A, "fork lineage must be stamped (a reap walks it)");
+        await src.getStorage().appendEntry(SESSION_ENTRY("e3", "e2"));
+        assert.deepEqual((await (await repo.open({ id: A, createdAt: "" })).getStorage().getEntries()).map((e) => e.id), ["e1", "e2", "e3"]);
+        assert.deepEqual((await (await repo.open({ id: B, createdAt: "" })).getStorage().getEntries()).map((e) => e.id), ["e1", "e2"]);
+    });
+    run("exportEntries → importEntries round-trips the log verbatim, and the imported session REPLACES what was there", async () => {
+        const repo = make();
+        if (repo.exportEntries === undefined || repo.importEntries === undefined)
+            return;
+        const src = await repo.create({ id: A });
+        await src.getStorage().appendEntry(SESSION_ENTRY("e1", null));
+        await src.getStorage().appendEntry(SESSION_ENTRY("e2", "e1"));
+        const donor = await repo.exportEntries(A);
+        assert.deepEqual(donor.map((e) => e.id), ["e1", "e2"]);
+        const C = "0198fa00-0000-7000-8000-00000000000c";
+        const target = await repo.create({ id: C });
+        await target.getStorage().appendEntry(SESSION_ENTRY("old", null));
+        await repo.importEntries(C, undefined, donor);
+        const after = await repo.exportEntries(C);
+        assert.deepEqual(after.map((e) => e.id), ["e1", "e2"]);
+        assert.deepEqual(after.map((e) => e.parentId), [null, "e1"]);
+        assert.equal((await repo.exportEntries(A)).length, 2, "importing into C must not disturb the donor session");
+    });
     await settle();
 }

package/dist/core/stub-env.d.ts

@@ -1,4 +1,4 @@
-import { type ExecutionEnv, ExecutionError, FileError, type FileInfo, type Result } from "../internal/harness.js";
+import { type ExecResult, type ExecutionEnv, ExecutionError, FileError, type FileInfo, type Result } from "../internal/harness.js";
 export declare class StubExecutionEnv implements ExecutionEnv {
     cwd: string;
     constructor(cwd?: string);
@@ -18,10 +18,6 @@ export declare class StubExecutionEnv implements ExecutionEnv {
     remove(path: string): Promise<Result<void, FileError>>;
     createTempDir(): Promise<Result<string, FileError>>;
     createTempFile(): Promise<Result<string, FileError>>;
-    exec(): Promise<Result<{
-        stdout: string;
-        stderr: string;
-        exitCode: number;
-    }, ExecutionError>>;
+    exec(): Promise<Result<ExecResult, ExecutionError>>;
     cleanup(): Promise<void>;
 }

package/dist/core/surrogate-safe-slice.d.ts

@@ -0,0 +1,4 @@
+export declare const isHighSurrogate: (c: number) => boolean;
+export declare const isLowSurrogate: (c: number) => boolean;
+export declare function sliceHeadSafe(s: string, keep: number): string;
+export declare function sliceTailSafe(s: string, keep: number): string;

package/dist/core/surrogate-safe-slice.js

@@ -0,0 +1,18 @@
+export const isHighSurrogate = (c) => c >= 0xd800 && c <= 0xdbff;
+export const isLowSurrogate = (c) => c >= 0xdc00 && c <= 0xdfff;
+export function sliceHeadSafe(s, keep) {
+    if (keep <= 0)
+        return "";
+    if (s.length <= keep)
+        return s;
+    const head = s.slice(0, keep);
+    return keep > 0 && isHighSurrogate(head.charCodeAt(keep - 1)) ? head.slice(0, -1) : head;
+}
+export function sliceTailSafe(s, keep) {
+    if (keep <= 0)
+        return "";
+    if (s.length <= keep)
+        return s;
+    const tail = s.slice(-keep);
+    return keep > 0 && isLowSurrogate(tail.charCodeAt(0)) ? tail.slice(1) : tail;
+}

package/dist/core/task-registry-monitor.js

@@ -1,5 +1,5 @@
 import { delimitUntrusted } from "./untrusted-text.js";
-import { assertOwnership, defaultMonitorTimers, MONITOR_MAX_TIMEOUT_MS, MONITOR_DEFAULT_TIMEOUT_MS, MONITOR_BATCH_WINDOW_MS, MONITOR_MAX_BATCHES_PER_MINUTE, MONITOR_STORM_BURST, MONITOR_STORM_KILL_AFTER_MS, MONITOR_LINE_BUF_CAP, MONITOR_SPILL_CAP_CHARS, TASK_OUTPUT_MAX_CHARS, mintCompletionId, clipMonitorEvent, clipMonitorLine, terminalTaskSummary, accountDroppedBytes, rollSpoolText, statusFromBackground, droppedGapNote, firstDropNote, alreadyTerminalStopNote, clipTaskOutput, sleepPollStep, } from "./task-registry-shared.js";
+import { assertOwnership, defaultMonitorTimers, MONITOR_MAX_TIMEOUT_MS, MONITOR_DEFAULT_TIMEOUT_MS, MONITOR_BATCH_WINDOW_MS, MONITOR_MAX_BATCHES_PER_MINUTE, MONITOR_STORM_BURST, MONITOR_STORM_KILL_AFTER_MS, MONITOR_LINE_BUF_CAP, MONITOR_SPILL_CAP_CHARS, TASK_OUTPUT_MAX_CHARS, mintCompletionId, clipMonitorEvent, clipMonitorLine, terminalTaskSummary, accountDroppedBytes, renderSpoolBody, rollSpoolText, statusFromBackground, droppedGapNote, firstDropNote, alreadyTerminalStopNote, clipTaskOutput, sleepPollStep, } from "./task-registry-shared.js";
 import { buildToolResultRef, OFFLOAD_TOOL_NAME } from "./tool-result-store.js";
 export function registerMonitorLane(core, input) {
     assertOwnership(input, "registerMonitor");
@@ -42,7 +42,13 @@ export function registerMonitorLane(core, input) {
         ...(input.sessionId !== undefined ? { spillSessionId: input.sessionId } : {}),
     };
     core.handles.set(id, handle);
-    startMonitorWatcherLane(core, id);
+    try {
+        startMonitorWatcherLane(core, id);
+    }
+    catch (e) {
+        core.handles.delete(id);
+        throw e;
+    }
     return id;
 }
 function spillRolledMonitorChunk(handle, stream, dropped) {
@@ -312,18 +318,13 @@ export async function pollMonitorLane(handle, filter, deadline, signal) {
     const shape = (text) => clipTaskOutput(rx ? text.split(/\r?\n/).filter((l) => rx.test(l)).join("\n") : text, handle.outputFile);
     const running = handle.status === "running";
     const retrieval = running && deadline !== undefined && Date.now() >= deadline ? "timeout" : "success";
-    const timedOutClause = spool.timedOut === true ? ` (timed out after ${spool.timeoutSec !== undefined ? `${spool.timeoutSec}s` : "its background time budget"})` : "";
-    const displayStatus = (spool.exitCode !== undefined ? `exited(code ${spool.exitCode})` : running ? "running" : handle.status) + timedOutClause;
-    const rolledNote = spool.rolledChars > 0 ? `[!] ${spool.rolledChars} earlier char(s) dropped from the spool (memory bound)${monitorSpillNote(handle)}\n` : "";
-    const droppedNote = (spool.droppedBytes ?? 0) > 0
-        ? `[!] ${spool.droppedBytes} earlier byte(s) permanently dropped before this window (8MB buffer evicted)\n`
-        : spool.dropUnknown === true
-            ? "[!] an unknown amount of earlier output was permanently dropped before this window (buffer evicted)\n"
-            : "";
-    const drainNote = spool.drainFailed === true ? "[!] the final output drain at stop failed — the tail of the output may be missing\n" : "";
-    const stdoutHeading = droppedNote !== "" || drainNote !== "" ? "stdout (re-readable spool — INCOMPLETE, see note above)" : "stdout (full, re-readable)";
-    const body = `status: ${displayStatus}\n${rolledNote}${droppedNote}${drainNote}--- ${stdoutHeading} ---\n${shape(spool.stdout) || "(none)"}\n` +
-        `--- stderr ---\n${shape(spool.stderr) || "(none)"}`;
+    const body = renderSpoolBody(spool, {
+        running,
+        handleStatus: handle.status,
+        shape,
+        rolledExtraClause: monitorSpillNote(handle),
+        drainNote: spool.drainFailed === true ? "[!] the final output drain at stop failed — the tail of the output may be missing\n" : "",
+    });
     return {
         content: delimitUntrusted(`TaskOutput ${handle.id}`, body),
         details: {

package/dist/core/task-registry-shared.d.ts

@@ -252,6 +252,28 @@ export declare function accountDroppedBytes(spool: {
     truncated?: boolean;
     bytesDroppedBeforeCursor?: number;
 }): void;
+export declare function spoolDropNote(acct: {
+    droppedBytes?: number;
+    dropUnknown?: true;
+}): string;
+export interface RenderableSpool {
+    stdout: string;
+    stderr: string;
+    rolledChars: number;
+    exitCode?: number;
+    timedOut?: boolean;
+    timeoutSec?: number;
+    droppedBytes?: number;
+    dropUnknown?: true;
+}
+export interface SpoolBodyOptions {
+    running: boolean;
+    handleStatus: SemaTaskStatus;
+    shape: (text: string) => string;
+    rolledExtraClause: string;
+    drainNote: string;
+}
+export declare function renderSpoolBody(spool: RenderableSpool, opts: SpoolBodyOptions): string;
 export declare function droppedGapNote(spool: {
     droppedBytes?: number;
     dropUnknown?: true;

package/dist/core/task-registry-shared.js

@@ -102,6 +102,22 @@ export function accountDroppedBytes(spool, poll) {
     else if (poll.truncated === true)
         spool.dropUnknown = true;
 }
+export function spoolDropNote(acct) {
+    if ((acct.droppedBytes ?? 0) > 0)
+        return `[!] ${acct.droppedBytes} earlier byte(s) permanently dropped before this window (8MB buffer evicted)\n`;
+    if (acct.dropUnknown === true)
+        return "[!] an unknown amount of earlier output was permanently dropped before this window (buffer evicted)\n";
+    return "";
+}
+export function renderSpoolBody(spool, opts) {
+    const timedOutClause = spool.timedOut === true ? ` (timed out after ${spool.timeoutSec !== undefined ? `${spool.timeoutSec}s` : "its background time budget"})` : "";
+    const displayStatus = (spool.exitCode !== undefined ? `exited(code ${spool.exitCode})` : opts.running ? "running" : opts.handleStatus) + timedOutClause;
+    const rolledNote = spool.rolledChars > 0 ? `[!] ${spool.rolledChars} earlier char(s) dropped from the spool (memory bound)${opts.rolledExtraClause}\n` : "";
+    const droppedNote = spoolDropNote(spool);
+    const stdoutHeading = droppedNote !== "" || opts.drainNote !== "" ? "stdout (re-readable spool — INCOMPLETE, see note above)" : "stdout (full, re-readable)";
+    return (`status: ${displayStatus}\n${rolledNote}${droppedNote}${opts.drainNote}--- ${stdoutHeading} ---\n${opts.shape(spool.stdout) || "(none)"}\n` +
+        `--- stderr ---\n${opts.shape(spool.stderr) || "(none)"}`);
+}
 export function droppedGapNote(spool) {
     if ((spool.droppedBytes ?? 0) > 0)
         return ` [!] ${spool.droppedBytes} earlier byte(s) of output were permanently dropped before this window (execution-environment tail buffer evicted) — the event stream and this spool are INCOMPLETE.`;

package/dist/core/task-registry.d.ts

@@ -69,6 +69,7 @@ export declare class TaskRegistry {
     private sessionReapHooks;
     private bgQuiescenceWatchers;
     private legacyToTaskId;
+    private readonly notifier;
     private readonly core;
     durableAgentArmed(id: string): boolean;
     durableAgentRowProbe(id: string): (() => Promise<boolean>) | undefined;

package/dist/core/task-registry.js

@@ -4,9 +4,10 @@ import { hasBackgroundShell } from "./background-shell.js";
 import { shutdownDebug } from "./shutdown-debug.js";
 import { canAccessAgentRecord, } from "./background-agent-store.js";
 import { delimitUntrusted } from "./untrusted-text.js";
+import { createSafeNotifier } from "./safe-notify.js";
 import { registerMonitorLane, pollMonitorLane, stopMonitorLane } from "./task-registry-monitor.js";
 import { registerWorkflowLane, pollWorkflowLane, stopWorkflowLane } from "./task-registry-workflow.js";
-import { mintCompletionId, canAccessWorkflowRun, formatWorkflowRun, clipTaskOutput, assertOwnership, sleepPollStep, statusFromBackground, rollSpoolText, accountDroppedBytes, droppedGapNote, alreadyTerminalStopNote, terminalTaskSummary, TASK_OUTPUT_MAX_CHARS, MONITOR_BATCH_WINDOW_MS, MONITOR_DEFAULT_TIMEOUT_MS, MONITOR_MAX_TIMEOUT_MS, MONITOR_MAX_BATCHES_PER_MINUTE, canAccess, DURABLE_AGENT_HANDLE_RE, } from "./task-registry-shared.js";
+import { mintCompletionId, canAccessWorkflowRun, formatWorkflowRun, clipTaskOutput, assertOwnership, sleepPollStep, statusFromBackground, rollSpoolText, accountDroppedBytes, renderSpoolBody, spoolDropNote, droppedGapNote, alreadyTerminalStopNote, terminalTaskSummary, TASK_OUTPUT_MAX_CHARS, MONITOR_BATCH_WINDOW_MS, MONITOR_DEFAULT_TIMEOUT_MS, MONITOR_MAX_TIMEOUT_MS, MONITOR_MAX_BATCHES_PER_MINUTE, canAccess, DURABLE_AGENT_HANDLE_RE, } from "./task-registry-shared.js";
 export { normalizeAgentName, DURABLE_AGENT_HEARTBEAT_MS, DURABLE_AGENT_HANDLE_RE, BG_AGENT_REAP_STOP_ERROR } from "./task-registry-shared.js";
 import { TASK_OUTPUT_TOOL_NAME, TASK_STOP_TOOL_NAME, TASK_OUTPUT_ALIASES, TASK_STOP_ALIASES, TASK_OUTPUT_CONTRACT, TASK_STOP_CONTRACT, TASK_OUTPUT_MISSING_ID_MESSAGE, TASK_STOP_MISSING_ID_MESSAGE, TASK_STOP_PARAMS, resolveTaskIdArg, REGISTRY_TASK_TOOL_CAPS, composeTaskOutputDescription, composeTaskOutputParams, composeTaskStopDescription, } from "./task-tool-shape.js";
 import { durableAgentArmedLane, durableAgentRowProbeLane, beginDurableClaimLane, endDurableClaimLane, reapDurableAgentsLane, releaseDurableTranscriptAnchorLane, bindBackgroundAgentSessionLane, registerBackgroundAgentLane, parkBackgroundAgentLane, reconcileParkedAgentsLane, claimParkedAgentLane, rollbackParkedClaimLane, consumeParkedFlipLane, finalizeParkedResumeLane, settleBackgroundAgentLane, abortBackgroundAgentsForOwnerLane, serveDurableAgentRowLane, resolveBackgroundAgentByNameLane, markRetainedContinuationLane, reviveBackgroundAgentLane, settleRevivedAgentLane, unmarkRetainedContinuationLane, attachAgentNotifyLane, deliverToRunningAgentLane, runningBackgroundAgentLabelsLane, runningAgentFooterLane, notFoundRunningAgentsTail, pollBackgroundAgentLane, stopBackgroundAgentLane, } from "./task-registry-agent.js";
@@ -47,6 +48,31 @@ function bashTerminalResult(spool) {
     const err = spool.stderr.slice(-2_000);
     return err.length > 0 ? `${out}${out.length > 0 ? "\n" : ""}--- stderr (tail) ---\n${err}` : out;
 }
+async function drainBashTailBestEffort(handle) {
+    if (handle.outputFile === undefined)
+        return;
+    try {
+        const drained = await handle.env.pollBackground(handle.shellId);
+        if (drained.ok && handle.spool !== undefined)
+            accountDroppedBytes(handle.spool, drained.value);
+        if (drained.ok && (drained.value.stdout.length > 0 || drained.value.stderr.length > 0)) {
+            if (handle.spool !== undefined) {
+                const spool = handle.spool;
+                const cap = 2 * TASK_OUTPUT_MAX_CHARS;
+                spool.stdout = rollSpoolText(spool, spool.stdout + drained.value.stdout, cap);
+                spool.stderr = rollSpoolText(spool, spool.stderr + drained.value.stderr, cap);
+                const ap = await handle.env.appendFile(handle.outputFile, drained.value.stdout + drained.value.stderr);
+                if (!ap.ok)
+                    spool.mirrorFailed = true;
+            }
+            else {
+                await handle.env.appendFile(handle.outputFile, drained.value.stdout + drained.value.stderr);
+            }
+        }
+    }
+    catch {
+    }
+}
 function bashMirrorGapNote(handle) {
     return handle.outputFile !== undefined && handle.spool?.mirrorFailed === true
         ? " [!] The output file is INCOMPLETE (one or more writes to it failed) — trust the result text / TaskOutput over the file."
@@ -77,6 +103,7 @@ export class TaskRegistry {
     sessionReapHooks = new Set();
     bgQuiescenceWatchers = new Map();
     legacyToTaskId = new Map();
+    notifier = createSafeNotifier();
     core = (() => {
         const self = this;
         return {
@@ -407,22 +434,7 @@ export class TaskRegistry {
                 handle.stoppedBy = handle.stopSource ?? source;
                 handle.updatedAt = Date.now();
                 mintCompletionId(handle);
-                if (handle.outputFile !== undefined) {
-                    try {
-                        const drained = await handle.env.pollBackground(handle.shellId);
-                        if (drained.ok && (drained.value.stdout.length > 0 || drained.value.stderr.length > 0)) {
-                            const spool = (handle.spool ??= { stdout: "", stderr: "", rolledChars: 0 });
-                            const cap = 2 * TASK_OUTPUT_MAX_CHARS;
-                            spool.stdout = rollSpoolText(spool, spool.stdout + drained.value.stdout, cap);
-                            spool.stderr = rollSpoolText(spool, spool.stderr + drained.value.stderr, cap);
-                            const ap = await handle.env.appendFile(handle.outputFile, drained.value.stdout + drained.value.stderr);
-                            if (!ap.ok)
-                                spool.mirrorFailed = true;
-                        }
-                    }
-                    catch {
-                    }
-                }
+                await drainBashTailBestEffort(handle);
                 const resultText = handle.spool !== undefined ? bashTerminalResult(handle.spool) : "";
                 this.notifyTerminalOnce(handle, () => handle.onTerminal?.({
                     task_id: handle.id,
@@ -521,21 +533,13 @@ export class TaskRegistry {
             this.settleBackgroundAgent(handle.id, { status: "killed", error: "session released", cycle: handle.reviveCycle ?? 0 });
             if (reapTerminalNote !== undefined && handle.terminalNotified !== true) {
                 handle.terminalNotified = true;
-                try {
-                    reapTerminalNote();
-                }
-                catch {
-                }
+                this.notifier.notify(() => reapTerminalNote(), "taskRegistry.reapTerminalNote");
             }
             reaped++;
         }
         this.pokeBgQuiescence(sessionId);
         for (const hook of this.sessionReapHooks) {
-            try {
-                hook(sessionId, scope);
-            }
-            catch {
-            }
+            this.notifier.notify(() => hook(sessionId, scope), "taskRegistry.onSessionReap");
         }
         return reaped;
     }
@@ -585,11 +589,7 @@ export class TaskRegistry {
                     this.bgQuiescenceWatchers.delete(oldest);
                     queueMicrotask(() => {
                         for (const victim of victims) {
-                            try {
-                                victim("evicted");
-                            }
-                            catch {
-                            }
+                            this.notifier.notify(() => victim("evicted"), "taskRegistry.bgQuiescence.evicted");
                         }
                     });
                 }
@@ -617,22 +617,14 @@ export class TaskRegistry {
             return;
         this.bgQuiescenceWatchers.delete(owner);
         for (const cb of set) {
-            try {
-                cb("quiescent");
-            }
-            catch {
-            }
+            this.notifier.notify(() => cb("quiescent"), "taskRegistry.bgQuiescence.quiescent");
         }
     }
     notifyTerminalOnce(handle, send) {
         if (handle.terminalNotified === true)
             return;
         handle.terminalNotified = true;
-        try {
-            send();
-        }
-        catch {
-        }
+        this.notifier.notify(() => send(), "taskRegistry.notifyTerminalOnce");
         this.pokeBgQuiescence(handle.owner);
     }
     startBashWatcher(id, onTerminal) {
@@ -1049,17 +1041,7 @@ The durable record is still marked running (last update ${new Date(row.updatedAt
             const shape = (text) => clipTaskOutput(rx ? text.split(/\r?\n/).filter((l) => rx.test(l)).join("\n") : text, handle.outputFile);
             const running = handle.status === "running";
             const retrieval = running && deadline !== undefined && Date.now() >= deadline ? "timeout" : "success";
-            const timedOutClause = spool.timedOut === true ? ` (timed out after ${spool.timeoutSec !== undefined ? `${spool.timeoutSec}s` : "its background time budget"})` : "";
-            const displayStatus = (spool.exitCode !== undefined ? `exited(code ${spool.exitCode})` : running ? "running" : handle.status) + timedOutClause;
-            const rolledNote = spool.rolledChars > 0 ? `[!] ${spool.rolledChars} earlier char(s) dropped from the spool (memory bound)\n` : "";
-            const droppedNote = (spool.droppedBytes ?? 0) > 0
-                ? `[!] ${spool.droppedBytes} earlier byte(s) permanently dropped before this window (8MB buffer evicted)\n`
-                : spool.dropUnknown === true
-                    ? "[!] an unknown amount of earlier output was permanently dropped before this window (buffer evicted)\n"
-                    : "";
-            const stdoutHeading = droppedNote !== "" ? "stdout (re-readable spool — INCOMPLETE, see note above)" : "stdout (full, re-readable)";
-            const body = `status: ${displayStatus}\n${rolledNote}${droppedNote}--- ${stdoutHeading} ---\n${shape(spool.stdout) || "(none)"}\n` +
-                `--- stderr ---\n${shape(spool.stderr) || "(none)"}`;
+            const body = renderSpoolBody(spool, { running, handleStatus: handle.status, shape, rolledExtraClause: "", drainNote: "" });
             return {
                 content: delimitUntrusted(`TaskOutput ${handle.id}`, body),
                 details: {
@@ -1089,7 +1071,7 @@ The durable record is still marked running (last update ${new Date(row.updatedAt
         };
         let stdout = "";
         let stderr = "";
-        let dropped = 0;
+        const dropAcct = {};
         for (;;) {
             const r = await handle.env.pollBackground(handle.shellId);
             if (!r.ok) {
@@ -1107,7 +1089,7 @@ The durable record is still marked running (last update ${new Date(row.updatedAt
             }
             stdout = roll(stdout + r.value.stdout);
             stderr = roll(stderr + r.value.stderr);
-            dropped += r.value.bytesDroppedBeforeCursor ?? 0;
+            accountDroppedBytes(dropAcct, r.value);
             handle.status = statusFromBackground(r.value.status, r.value.exitCode);
             if (handle.status === "killed" && handle.stoppedBy === undefined)
                 handle.stoppedBy = handle.stopSource ?? (r.value.timedOut === true ? "timeout" : "system");
@@ -1120,7 +1102,7 @@ The durable record is still marked running (last update ${new Date(row.updatedAt
                 const shape = (text) => clipTaskOutput(rx ? text.split(/\r?\n/).filter((l) => rx.test(l)).join("\n") : text, handle.outputFile);
                 const timedOutClause = r.value.timedOut === true ? ` (timed out after ${r.value.timeoutSec !== undefined ? `${r.value.timeoutSec}s` : "its background time budget"})` : "";
                 const displayStatus = (r.value.status === "exited" ? `exited(code ${r.value.exitCode})` : r.value.status) + timedOutClause;
-                const droppedNote = (dropped > 0 ? `[!] ${dropped} earlier byte(s) permanently dropped before this window (8MB buffer evicted)\n` : "") +
+                const droppedNote = spoolDropNote(dropAcct) +
                     (rolledChars > 0 ? `[!] ${rolledChars} accumulated char(s) dropped from the middle during the blocked wait (memory bound)\n` : "");
                 const body = `status: ${displayStatus}\n${droppedNote}--- new stdout ---\n${shape(stdout) || "(none)"}\n` +
                     `--- new stderr ---\n${shape(stderr) || "(none)"}`;
@@ -1136,7 +1118,7 @@ The durable record is still marked running (last update ${new Date(row.updatedAt
                         details: {
                             status: r.value.status,
                             exitCode: r.value.exitCode,
-                            bytesDroppedBeforeCursor: dropped,
+                            bytesDroppedBeforeCursor: dropAcct.droppedBytes ?? 0,
                             ...(r.value.timedOut === true ? { timedOut: true, ...(r.value.timeoutSec !== undefined ? { timeoutSec: r.value.timeoutSec } : {}) } : {}),
                         },
                     },
@@ -1205,6 +1187,7 @@ The durable record is still marked running (last update ${new Date(row.updatedAt
         handle.status = "killed";
         handle.updatedAt = Date.now();
         mintCompletionId(handle);
+        await drainBashTailBestEffort(handle);
         this.notifyTerminalOnce(handle, () => explicitStopBashTerminalNote(handle, false));
         return {
             content: `Terminated ${handle.id}.`,