@sema-agent/core 3.0.0 → 5.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/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/sensitive-path-policy.js

@@ -1,5 +1,4 @@
 import { canonicalizeTarget, writeTargetPath } from "../tools/fs/safety.js";
-import { canonicalToolName } from "./tool-name-aliases.js";
 const DEFAULT_GUARDED_TOOLS = ["Write", "Edit", "MultiEdit", "NotebookEdit"];
 export const RECOMMENDED_SENSITIVE_PATTERNS = [
     ".env",
@@ -28,8 +27,9 @@ export const RECOMMENDED_SENSITIVE_PATTERNS = [
 ];
 function segmentGlobToRegExp(segment) {
     const escaped = segment.replace(/[.+^${}()|[\]\\?]/g, "\\$&").replace(/\*/g, "[^/]*");
-    return new RegExp(`^${escaped}$`);
+    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) {
@@ -55,10 +55,10 @@ function matchSensitive(canonicalKey, compiled) {
 }
 export function createSensitivePathPolicy(opts) {
     const compiled = compilePatterns(opts.patterns);
-    const guarded = new Set((opts.tools ?? DEFAULT_GUARDED_TOOLS).map(canonicalToolName));
+    const guarded = new Set(opts.tools ?? DEFAULT_GUARDED_TOOLS);
     return {
         async check(req, signal) {
-            const canonical = canonicalToolName(req.toolName);
+            const canonical = req.toolName;
             if (compiled.length === 0 || !guarded.has(canonical))
                 return { action: "allow" };
             const path = writeTargetPath(canonical, req.args);

package/dist/core/session-reconcile.js

@@ -1,4 +1,3 @@
-import { canonicalToolName } from "./tool-name-aliases.js";
 const INTERRUPTED_UNKNOWN = "[INTERRUPTED] The previous run ended before this tool call's result was recorded. Its outcome " +
     "is UNKNOWN — the action may have completed, partially completed, or never run. Do not assume " +
     "success or failure. Before relying on it: if it is safe to read, query the current state to " +
@@ -72,7 +71,7 @@ export async function reconcileInterruptedSession(session, toolEffects, suspende
     const orphans = findOrphanToolCalls(messages, suspendedBatch).filter((o) => o.kind !== "result");
     const recovered = [];
     for (const orphan of orphans) {
-        const effect = toolEffects?.get(canonicalToolName(orphan.toolName)) ?? "write";
+        const effect = toolEffects?.get(orphan.toolName) ?? "write";
         const effectText = effect === "read" ? INTERRUPTED_SAFE : effect === "idempotent" ? INTERRUPTED_IDEMPOTENT : INTERRUPTED_UNKNOWN;
         const neverStarted = startedToolCallIds !== undefined && !startedToolCallIds.has(orphan.toolCallId);
         const text = neverStarted ? INTERRUPTED_NEVER_STARTED : effectText;

package/dist/core/skill-tool-specifier.js

@@ -1,11 +1,10 @@
 import { parsePermissionRule, wildcardMatch } from "./permission-rules.js";
-import { canonicalToolName } from "./tool-name-aliases.js";
 import { COARSE_SHELL_TOOLS } from "./tool-policy.js";
 import { parseLeadingCommandName } from "../tools/fs/bash-readonly-classifier.js";
-const SPECIFIER_ENFORCED_TOOLS = new Set(COARSE_SHELL_TOOLS.map(canonicalToolName));
+const SPECIFIER_ENFORCED_TOOLS = new Set(COARSE_SHELL_TOOLS);
 export function parseSkillToolEntry(entry) {
     const parsed = parsePermissionRule(entry);
-    const name = canonicalToolName(parsed.toolName);
+    const name = parsed.toolName;
     return parsed.ruleContent === undefined ? { raw: entry, name } : { raw: entry, name, specifier: parsed.ruleContent };
 }
 export function isSkillSpecifierEnforced(canonicalName) {

package/dist/core/skills-directory.js

@@ -1,6 +1,5 @@
 import { readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
 import { isAbsolute, join, relative } from "node:path";
-import { canonicalToolName } from "./tool-name-aliases.js";
 import { isSkillSpecifierEnforced, parseSkillToolEntry } from "./skill-tool-specifier.js";
 const SKILL_FILE = "SKILL.md";
 const RESOURCE_DIRS = ["assets", "references", "scripts"];
@@ -340,7 +339,7 @@ function manifestFromAllowedTools(declared, disallowed, skillName, deployedTools
         return undefined;
     let allowTools = names;
     if (deployedTools !== undefined) {
-        const mounted = new Set(deployedTools.map(canonicalToolName));
+        const mounted = new Set(deployedTools);
         allowTools = names.filter((n) => mounted.has(parseSkillToolEntry(n).name));
         for (const n of names) {
             if (!mounted.has(parseSkillToolEntry(n).name)) {
@@ -353,7 +352,7 @@ function manifestFromAllowedTools(declared, disallowed, skillName, deployedTools
         }
     }
     if (disallowed.length > 0) {
-        const denied = new Set(disallowed.map(canonicalToolName));
+        const denied = new Set(disallowed);
         allowTools = allowTools.filter((n) => !denied.has(parseSkillToolEntry(n).name));
     }
     return { allowTools, lineageId: `skill:${skillName}` };

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/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");
@@ -318,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

@@ -104,7 +104,7 @@ export interface BackgroundAgentTaskHandle extends SemaTaskHandle {
     durable?: DurableAgentLane;
     notify?: (notification: import("./task-notification.js").TaskNotificationPayload, opts?: {
         priority?: import("./task-notification.js").SystemInjectionPriority;
-    }) => void | "queued" | "parked" | "dropped_duplicate" | Promise<"queued" | "parked" | "dropped_duplicate">;
+    }) => "queued" | "parked" | "dropped_duplicate" | Promise<"queued" | "parked" | "dropped_duplicate">;
     retainedContinuation?: boolean;
     reviveCycle?: number;
     cycleSeq?: number;
@@ -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

@@ -63,12 +63,17 @@ export interface AccessibleTaskRow {
     parentTaskId?: string;
     parentSessionId?: string;
     rootSessionId?: string;
+    createdAt?: number;
 }
 export declare class TaskRegistry {
     private handles;
     private sessionReapHooks;
     private bgQuiescenceWatchers;
-    private legacyToTaskId;
+    private readonly notifier;
+    notifierFailureCounts(): ReadonlyArray<{
+        site: string;
+        count: number;
+    }>;
     private readonly core;
     durableAgentArmed(id: string): boolean;
     durableAgentRowProbe(id: string): (() => Promise<boolean>) | undefined;