@sema-agent/core 4.0.0 → 5.0.0

package/dist/core/permission-rules.js

@@ -1,4 +1,3 @@
-import { canonicalToolName } from "./tool-name-aliases.js";
 export const BASH_GENERIC_PARAMS = new Set(["command", "timeout", "description", "run_in_background"]);
 const DEFAULT_CAPS = {
     maxRules: 256,
@@ -142,7 +141,7 @@ function compile(rules, caps, primaryFieldGeneric) {
                 continue;
             }
         }
-        const toolName = canonicalToolName(parsed.toolName);
+        const toolName = parsed.toolName;
         if (toolName.startsWith("mcp__") && (parsed.ruleContent !== undefined || indexOfUnescaped(text, "(") !== -1)) {
             bad(text, "unsupported.mcp_paren", "MCP rules do not support patterns in parentheses (CC parity); use the toolAxes system");
             continue;
@@ -262,7 +261,7 @@ export function createPermissionRulePolicy(rules, opts) {
     const defaultAction = opts?.defaultAction ?? "allow";
     return {
         check(req) {
-            const entry = byTool.get(canonicalToolName(req.toolName));
+            const entry = byTool.get(req.toolName);
             if (entry) {
                 if (entry.bare.deny) {
                     return { action: "deny", reason: ruleMessage("denied", entry.bare.deny.ruleText, entry.bare.deny.source) };

package/dist/core/runner/active-skill-scope.js

@@ -1,6 +1,5 @@
 import { canonicalizeTarget, fileArgPath } from "../../tools/fs/safety.js";
 import { PATH_WRITE_TOOLS, isWithin } from "./session-rule-policy.js";
-import { canonicalToolName } from "../tool-name-aliases.js";
 import { parseSkillToolEntry, skillSpecifierRejection } from "../skill-tool-specifier.js";
 export class ActiveSkillScope {
     frames = [];
@@ -21,7 +20,7 @@ export function createActiveSkillScopePolicy(opts) {
     const { scope, env, rootPath, toolEffects } = opts;
     return {
         async check(req, signal) {
-            const toolName = canonicalToolName(req.toolName);
+            const toolName = req.toolName;
             const frames = scope.active();
             if (frames.length === 0)
                 return { action: "allow" };

package/dist/core/runner/prepare-task.js

@@ -29,7 +29,7 @@ import { reconcileInterruptedSession } from "../session-reconcile.js";
 import { CacheBreakDetector, toolsToFingerprintInputs } from "../cache-break-detector.js";
 import { reservedCollisions, reservedFor } from "../../brain/request-params.js";
 import { defineTool, isDefineToolProduct } from "../tools.js";
-import { canonicalToolName } from "../tool-name-aliases.js";
+import { RETIRED_TOOL_NAMES } from "../tool-name-aliases.js";
 import { pathToUri } from "../lsp-protocol.js";
 import { DEFAULT_TOOL_RESULT_THRESHOLD_CHARS, createOffloadPersist, firstPartyOffloadPolicy, InMemoryToolResultStore, RunnerSharedToolResultStore, ScopedToolResultStore, isVolatileOffloadStore, OFFLOAD_TOOL_NAME, createReadToolResultTool, withToolResultOffload, } from "../tool-result-store.js";
 import { OUTPUT_TOOL_NAME, REPORT_FINDINGS_TOOL_NAME, SKILL_CONTENT_MAX_CHARS, SKILL_TOOL_NAME, createOutputTool, createReportBlockedTool, createReportFindingsTool, createSkillTool, normalizeSkills } from "./synthetic-tools.js";
@@ -2018,9 +2018,9 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             };
         }
         if (spec.agents !== undefined && spec.agents.length > 0) {
-            const known = new Set(tools.flatMap((t) => [canonicalToolName(t.name), ...(t.aliases ?? []).map((a) => canonicalToolName(a))]));
+            const known = new Set(tools.flatMap((t) => [t.name, ...(t.aliases ?? [])]));
             for (const def of spec.agents) {
-                const unknownAllow = (def.allowTools ?? []).filter((n) => n !== "*" && !known.has(canonicalToolName(n)));
+                const unknownAllow = (def.allowTools ?? []).filter((n) => n !== "*" && !known.has(n));
                 if (unknownAllow.length > 0) {
                     try {
                         deps.onError?.(new Error(`TaskSpec.agents: agent "${def.name}" allows tool(s) ${unknownAllow.join(", ")} not present in this task's assembled roster — likely a typo (the entry would be item-filtered at spawn; the agent stays usable). Advisory only: the delegation pool can differ from this roster, so a tool mounted only on the delegation tool or produced by per-spawn extraTools makes this spurious.`), { phase: "config", sessionId });
@@ -2031,7 +2031,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 for (const n of def.denyTools ?? []) {
                     if (n === "*")
                         continue;
-                    if (!known.has(canonicalToolName(n))) {
+                    if (!known.has(n)) {
                         const e = new Error(`TaskSpec.agents: agent "${def.name}" declares tool "${n}" in its denied tools, but no such tool exists in this deployment — fix the agent's tools list or mount the tool.`);
                         e.code = "config.agent.unknown_tool";
                         throw e;
@@ -2193,15 +2193,22 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         {
             const nameGroups = toolPolicyNameSets(policy);
             if (nameGroups.length > 0) {
-                const known = new Set(tools.flatMap((t) => [canonicalToolName(t.name), ...(t.aliases ?? []).map((a) => canonicalToolName(a))]));
+                const known = new Set(tools.flatMap((t) => [t.name, ...(t.aliases ?? [])]));
                 for (const t of harnessTools)
-                    known.add(canonicalToolName(t.name));
+                    known.add(t.name);
                 const unmatched = new Set();
                 for (const g of nameGroups) {
                     for (const [kind, list] of [["deny", g.deny], ["ask", g.ask], ["allow", g.allow]]) {
                         for (const n of list ?? []) {
-                            if (!known.has(canonicalToolName(n)))
-                                unmatched.add(`"${n}" (${kind})`);
+                            if (known.has(n))
+                                continue;
+                            const retired = RETIRED_TOOL_NAMES.get(n);
+                            if (retired !== undefined) {
+                                const err = new Error(`tool policy ${kind}-list entry "${n}" is a RETIRED tool name (${retired}) and matches nothing in this run's roster — legacy-name normalization was removed (RB-476-A), so this entry would silently guard nothing. Update the deployment's rule to the current name.`);
+                                err.code = "config.legacy_tool_name";
+                                throw err;
+                            }
+                            unmatched.add(`"${n}" (${kind})`);
                         }
                     }
                 }
@@ -3160,6 +3167,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                     let result;
                     try {
                         result = await runToolGate({
+                            onNotifyError: (f) => emitTrace(deps.tracer, () => ({ kind: "observer.notify_failed", version: 1, taskId: spec.taskId ?? sessionId, site: f.site, message: f.error.message, ts: Date.now() })),
                             event: e,
                             preToolUse: hooks?.preToolUse,
                             adjudicate,

package/dist/core/runner/runtask.js

@@ -36,7 +36,6 @@ import { delimitUntrusted, inlineUntrusted, sanitizeUntrustedText } from "../unt
 import { reconcileInterruptedSession } from "../session-reconcile.js";
 import { RunnerSharedToolResultStore } from "../tool-result-store.js";
 import { formatDiagnosticsBlock } from "../lsp-diagnostics.js";
-import { canonicalToolName } from "../tool-name-aliases.js";
 import { toolPolicyNameSets } from "../tool-policy.js";
 import { defaultTaskRegistry } from "../task-registry.js";
 import { discloseDroppedPending, PendingSessionNotifications, renderTaskNotificationXml, SystemInjectionQueue, taskNotificationDedupKey } from "../task-notification.js";
@@ -748,6 +747,13 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
 function makeHarnessHandlers(prepared, stats, rs, deps) {
     const { spec, queue, internals, buildFinalizeText, ident, nudgeSchedule, parentToolCallId, subagentName, pushContent, emitCommitted, startedToolCallIds, toolStartAt, turnToolSpan, writeFamilyOf, toolLabels, postToolBatchHook, batchArgs } = deps;
     let lastWorkspaceCwd = prepared.cwdRef?.current;
+    const announceWorkspaceMove = () => {
+        const cwdNow = prepared.cwdRef?.current;
+        if (cwdNow !== undefined && cwdNow !== lastWorkspaceCwd) {
+            lastWorkspaceCwd = cwdNow;
+            queue.push({ type: "workspace_changed", cwd: cwdNow, ...ident() });
+        }
+    };
     const onMessageUpdate = (event) => {
         const ev = event.assistantMessageEvent;
         if (rs.turn.callStartAt === undefined)
@@ -1000,7 +1006,7 @@ function makeHarnessHandlers(prepared, stats, rs, deps) {
         }));
         internals?.onActivity?.({ phase: "end", toolCallId: event.toolCallId, toolName: event.toolName, isError: event.isError, at: toolNow });
         if (prepared.lspDiagnostics && !event.isError) {
-            const name = canonicalToolName(event.toolName);
+            const name = event.toolName;
             if (name === "Edit" || name === "Write" || name === "NotebookEdit") {
                 const d = event.result?.details;
                 const p = typeof d?.filePath === "string" ? d.filePath : typeof d?.notebookPath === "string" ? d.notebookPath : undefined;
@@ -1026,11 +1032,7 @@ function makeHarnessHandlers(prepared, stats, rs, deps) {
             })(),
             ...ident(),
         });
-        const cwdNow = prepared.cwdRef?.current;
-        if (cwdNow !== undefined && cwdNow !== lastWorkspaceCwd) {
-            lastWorkspaceCwd = cwdNow;
-            queue.push({ type: "workspace_changed", cwd: cwdNow, ...ident() });
-        }
+        announceWorkspaceMove();
         if (spec.outputSchema && event.toolName === OUTPUT_TOOL_NAME) {
             if (event.isError) {
                 rs.degrade.outputErrorStreak += 1;
@@ -1108,7 +1110,7 @@ function makeHarnessHandlers(prepared, stats, rs, deps) {
             }
         }
     };
-    return { onMessageUpdate, onMessageEnd, onToolStart, onToolEnd, onTurnEnd };
+    return { onMessageUpdate, onMessageEnd, onToolStart, onToolEnd, onTurnEnd, announceWorkspaceMove };
 }
 export class Runner {
     deps;
@@ -1914,18 +1916,18 @@ export class Runner {
             }
         }
         rs.attach.attachmentsInjected = 0;
-        const todoToolMounted = rs.attach.attachState !== undefined && prepared.tools.some((t) => canonicalToolName(t.name) === "TodoWrite");
-        const taskToolsMounted = rs.attach.attachState !== undefined && prepared.tools.some((t) => canonicalToolName(t.name) === "TaskCreate");
+        const todoToolMounted = rs.attach.attachState !== undefined && prepared.tools.some((t) => t.name === "TodoWrite");
+        const taskToolsMounted = rs.attach.attachState !== undefined && prepared.tools.some((t) => t.name === "TaskCreate");
         const writeFamilyByName = new Map();
         if (rs.attach.attachState !== undefined) {
             for (const t of prepared.tools) {
-                const family = writeFamilyOfCanonical(canonicalToolName(t.name));
+                const family = writeFamilyOfCanonical(t.name);
                 if (family !== undefined)
                     for (const n of [t.name, ...(t.aliases ?? [])])
                         writeFamilyByName.set(n, family);
             }
         }
-        const writeFamilyOf = (name) => writeFamilyByName.get(name) ?? writeFamilyOfCanonical(canonicalToolName(name));
+        const writeFamilyOf = (name) => writeFamilyByName.get(name) ?? writeFamilyOfCanonical(name);
         const toolStartAt = new Map();
         const turnToolSpan = {};
         const startedToolCallIds = new Set();
@@ -2091,7 +2093,7 @@ export class Runner {
         const postToolBatchHook = (spec.hooks ?? this.deps.hooks)?.postToolBatch;
         const batchArgs = postToolBatchHook ? new Map() : undefined;
         rs.turn.toolBatch = [];
-        const { onMessageUpdate, onMessageEnd, onToolStart, onToolEnd, onTurnEnd } = makeHarnessHandlers(prepared, stats, rs, {
+        const { onMessageUpdate, onMessageEnd, onToolStart, onToolEnd, onTurnEnd, announceWorkspaceMove } = makeHarnessHandlers(prepared, stats, rs, {
             spec, queue, internals, buildFinalizeText, ident, nudgeSchedule, parentToolCallId, subagentName,
             pushContent, emitCommitted, startedToolCallIds, toolStartAt, turnToolSpan, writeFamilyOf,
             toolLabels, postToolBatchHook, batchArgs,
@@ -2461,6 +2463,7 @@ export class Runner {
                     });
                     if (resume.outcome.gate === "policy_ask")
                         resume.decisionDelivered = true;
+                    announceWorkspaceMove();
                 }
                 if (walltimeExhaustedResume) {
                     timeout.fired = true;
@@ -3290,7 +3293,7 @@ export class Runner {
             return;
         if (resume.outcome.gate === "policy_ask" &&
             resume.outcome.decision === "allow" &&
-            !prepared.tools.some((t) => t.name === canonicalToolName(pendingAction.toolName))) {
+            !prepared.tools.some((t) => t.name === pendingAction.toolName)) {
             const e = new Error(`the approved tool "${pendingAction.toolName}" is no longer available on resume — refusing to continue as if it ran; the checkpoint is reopened for a retry with the tool present`);
             e.code = "resume.tool_unavailable";
             throw e;
@@ -3355,7 +3358,7 @@ export class Runner {
                 return;
             }
         }
-        const tool = prepared.tools.find((t) => t.name === canonicalToolName(pendingAction.toolName));
+        const tool = prepared.tools.find((t) => t.name === pendingAction.toolName);
         if (!tool) {
             const e = new Error(`the approved tool "${pendingAction.toolName}" is no longer available on resume`);
             e.code = "resume.tool_unavailable";
@@ -3375,7 +3378,7 @@ export class Runner {
         }
         const executedIsError = res.isError === true;
         emitEnd(executedIsError);
-        onResolvedToolSuccess?.(canonicalToolName(pendingAction.toolName), executedIsError ? undefined : res.details);
+        onResolvedToolSuccess?.(pendingAction.toolName, executedIsError ? undefined : res.details);
         const eid = await prepared.session.appendMessage({
             role: "toolResult",
             toolCallId: pendingAction.toolCallId,

package/dist/core/runner/session-rule-policy.js

@@ -1,7 +1,6 @@
 import { canonicalizeTarget, fileArgPath } from "../../tools/fs/safety.js";
 import { isWinFormPath } from "../../tools/fs/safety.js";
 import { createCoarseCommandNamePolicy } from "../tool-policy.js";
-import { canonicalToolName } from "../tool-name-aliases.js";
 export const PATH_WRITE_TOOLS = new Set(["Write", "Edit", "MultiEdit"]);
 export function isWithin(root, p) {
     if (!root)
@@ -22,8 +21,8 @@ export function isWithin(root, p) {
 const deny = (reason) => ({ action: "deny", reason, decisionReason: "rule" });
 export function createSessionRulePolicy(rules, opts) {
     const { env, rootPath, toolEffects } = opts;
-    const toolDeny = new Set((rules.toolDeny ?? []).map(canonicalToolName));
-    const toolAllow = rules.toolAllow ? new Set(rules.toolAllow.map(canonicalToolName)) : undefined;
+    const toolDeny = new Set(rules.toolDeny ?? []);
+    const toolAllow = rules.toolAllow ? new Set(rules.toolAllow) : undefined;
     const cmdPolicy = rules.commandAllow || rules.commandDeny
         ? createCoarseCommandNamePolicy({
             ...(rules.commandAllow ? { allow: rules.commandAllow } : {}),
@@ -34,7 +33,7 @@ export function createSessionRulePolicy(rules, opts) {
     const allowDirs = rules.allowDirs && rules.allowDirs.length > 0 ? rules.allowDirs : undefined;
     return {
         async check(req, signal) {
-            const toolName = canonicalToolName(req.toolName);
+            const toolName = req.toolName;
             if (toolDeny.has(toolName))
                 return deny(`tool "${req.toolName}" is denied by a session rule`);
             if (toolAllow && !toolAllow.has(toolName)) {

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

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

@@ -63,13 +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;

package/dist/core/task-registry.js

@@ -9,7 +9,7 @@ import { registerMonitorLane, pollMonitorLane, stopMonitorLane } from "./task-re
 import { registerWorkflowLane, pollWorkflowLane, stopWorkflowLane } from "./task-registry-workflow.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 { TASK_OUTPUT_TOOL_NAME, TASK_STOP_TOOL_NAME, 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";
 export { canAccessWorkflowRun, clipTaskOutput, MONITOR_BATCH_WINDOW_MS, MONITOR_DEFAULT_TIMEOUT_MS, MONITOR_MAX_TIMEOUT_MS, MONITOR_MAX_BATCHES_PER_MINUTE };
 const BLOCK_DEFAULT_TIMEOUT_MS = 30_000;
@@ -102,8 +102,10 @@ export class TaskRegistry {
     handles = new Map();
     sessionReapHooks = new Set();
     bgQuiescenceWatchers = new Map();
-    legacyToTaskId = new Map();
     notifier = createSafeNotifier();
+    notifierFailureCounts() {
+        return this.notifier.failedSites().map((site) => ({ site, count: this.notifier.failuresAt(site) }));
+    }
     core = (() => {
         const self = this;
         return {
@@ -226,7 +228,7 @@ export class TaskRegistry {
         const prefix = TASK_PREFIX[type];
         for (let i = 0; i < 32; i++) {
             const id = `${prefix}${randomBytes(8).toString("hex")}`;
-            if (!this.handles.has(id) && !this.legacyToTaskId.has(id))
+            if (!this.handles.has(id))
                 return id;
         }
         throw new Error(`TaskRegistry: exhausted task id mint retries for ${type}`);
@@ -253,7 +255,6 @@ export class TaskRegistry {
             ...(input.onTerminal !== undefined ? { onTerminal: input.onTerminal } : {}),
             ...(input.outputFile !== undefined ? { outputFile: input.outputFile } : {}),
         });
-        this.legacyToTaskId.set(String(input.shellId), id);
         if (input.onTerminal)
             this.startBashWatcher(id, input.onTerminal);
         return id;
@@ -290,6 +291,7 @@ export class TaskRegistry {
             ...(hb.parentTaskId !== undefined ? { parentTaskId: hb.parentTaskId } : {}),
             ...(hb.parentSessionId !== undefined ? { parentSessionId: hb.parentSessionId } : {}),
             ...(hb.rootSessionId !== undefined ? { rootSessionId: hb.rootSessionId } : {}),
+            createdAt: h.createdAt,
         };
     }
     markStopSource(id, source) {
@@ -318,17 +320,9 @@ export class TaskRegistry {
         return marked;
     }
     markStopSourceByShellId(shellId, source, env) {
-        const sid = String(shellId);
-        const taskId = this.legacyToTaskId.get(sid);
-        if (taskId !== undefined) {
-            const handle = this.handles.get(taskId);
-            if (handle && handle.type === "background_bash" && (env === undefined || handle.env === env)) {
-                this.markStopSource(taskId, source);
-                return;
-            }
-        }
         if (env === undefined)
             return;
+        const sid = String(shellId);
         for (const [id, handle] of this.handles) {
             if (handle.type === "background_bash" && String(handle.shellId) === sid && handle.env === env) {
                 this.markStopSource(id, source);
@@ -349,9 +343,6 @@ export class TaskRegistry {
             }
             return true;
         };
-        const taskId = this.legacyToTaskId.get(sid);
-        if (taskId !== undefined && clear(taskId))
-            return;
         if (env === undefined)
             return;
         for (const [id, handle] of this.handles) {
@@ -958,11 +949,8 @@ The durable record is still marked running (last update ${new Date(row.updatedAt
             if (now - handle.updatedAt < terminalTtlMs)
                 continue;
             this.handles.delete(id);
-            if (handle.type === "background_bash") {
-                this.legacyToTaskId.delete(String(handle.shellId));
-                if (handle.watcher !== undefined)
-                    clearInterval(handle.watcher);
-            }
+            if (handle.type === "background_bash" && handle.watcher !== undefined)
+                clearInterval(handle.watcher);
             if (handle.type === "monitor" && handle.watcher !== undefined) {
                 handle.timers.clearInterval(handle.watcher);
                 handle.watcher = undefined;
@@ -999,7 +987,6 @@ The durable record is still marked running (last update ${new Date(row.updatedAt
             this.handles.delete(id);
             if (handle.status === "running" && handle.owner !== undefined)
                 evictedRunningOwners.add(handle.owner);
-            this.legacyToTaskId.delete(String(handle.shellId));
             if (handle.watcher !== undefined)
                 clearInterval(handle.watcher);
             deleted++;
@@ -1009,10 +996,7 @@ The durable record is still marked running (last update ${new Date(row.updatedAt
         return deleted;
     }
     resolveInternal(id, access) {
-        const taskId = this.handles.has(id) ? id : this.legacyToTaskId.get(id);
-        if (!taskId)
-            return undefined;
-        const handle = this.handles.get(taskId);
+        const handle = this.handles.get(id);
         if (!handle || !canAccess(handle, access))
             return undefined;
         return handle;
@@ -1216,14 +1200,13 @@ export function createTaskOutputTool(opts) {
     const caps = { ...REGISTRY_TASK_TOOL_CAPS, notification: opts.notificationWired !== false };
     return defineTool({
         name: TASK_OUTPUT_TOOL_NAME,
-        aliases: [...TASK_OUTPUT_ALIASES],
         contract: TASK_OUTPUT_CONTRACT,
         description: composeTaskOutputDescription(caps),
         parameters: composeTaskOutputParams(caps),
         effect: "read",
         execute: async (rawArgs, ctx) => {
             const args = rawArgs;
-            const id = resolveTaskIdArg(args.task_id, args.bash_id, args.runId);
+            const id = resolveTaskIdArg(args.task_id);
             if (!id)
                 return errorResult(TASK_OUTPUT_MISSING_ID_MESSAGE);
             const requestedMs = typeof args.timeout === "number" ? args.timeout : undefined;
@@ -1266,14 +1249,13 @@ export function createTaskOutputTool(opts) {
 export function createTaskStopTool(opts) {
     return defineTool({
         name: TASK_STOP_TOOL_NAME,
-        aliases: [...TASK_STOP_ALIASES],
         contract: TASK_STOP_CONTRACT,
         description: composeTaskStopDescription(REGISTRY_TASK_TOOL_CAPS),
         parameters: TASK_STOP_PARAMS,
         effect: "write",
         execute: async (rawArgs, ctx) => {
             const args = rawArgs;
-            const id = resolveTaskIdArg(args.task_id, args.shell_id, args.runId);
+            const id = resolveTaskIdArg(args.task_id, args.shell_id);
             if (!id)
                 return errorResult(TASK_STOP_MISSING_ID_MESSAGE);
             const r = await opts.registry.stopTask(id, { owner: ctx.taskId ?? opts.owner, scope: ctx.principal ?? opts.scope, ...((ctx.sessionId ?? opts.sessionId) !== undefined ? { sessionId: ctx.sessionId ?? opts.sessionId } : {}) }, { workflowStore: opts.workflowStore, agentStore: opts.agentStore });

package/dist/core/task-tool-shape.d.ts

@@ -1,8 +1,6 @@
 import { Type } from "typebox";
 export declare const TASK_OUTPUT_TOOL_NAME = "TaskOutput";
 export declare const TASK_STOP_TOOL_NAME = "TaskStop";
-export declare const TASK_OUTPUT_ALIASES: readonly ["BashOutput", "AgentOutputTool", "BashOutputTool", "AgentOutput", "WorkflowStatus"];
-export declare const TASK_STOP_ALIASES: readonly ["KillShell", "KillBash"];
 export declare const TASK_OUTPUT_CONTRACT: {
     readonly contractId: "core.task_output@1";
     readonly implementationRevision: "1";

package/dist/core/task-tool-shape.js

@@ -1,8 +1,6 @@
 import { Type } from "typebox";
 export const TASK_OUTPUT_TOOL_NAME = "TaskOutput";
 export const TASK_STOP_TOOL_NAME = "TaskStop";
-export const TASK_OUTPUT_ALIASES = ["BashOutput", "AgentOutputTool", "BashOutputTool", "AgentOutput", "WorkflowStatus"];
-export const TASK_STOP_ALIASES = ["KillShell", "KillBash"];
 export const TASK_OUTPUT_CONTRACT = { contractId: "core.task_output@1", implementationRevision: "1" };
 export const TASK_STOP_CONTRACT = { contractId: "core.task_stop@1", implementationRevision: "1" };
 export const TASK_OUTPUT_MISSING_ID_MESSAGE = "Error (TaskOutput): Missing required parameter: task_id";
@@ -50,9 +48,8 @@ export function composeTaskOutputDescription(caps) {
             "poll captures any final output. ");
     }
     if (!caps.lanes)
-        parts.push("Optional `filter` is a regex keeping only matching lines. ");
-    parts.push("Legacy bash_id and runId arguments are accepted for compatibility.");
-    return parts.join("");
+        parts.push("Optional `filter` is a regex keeping only matching lines.");
+    return parts.join("").trimEnd();
 }
 export function composeTaskStopDescription(caps) {
     return [

package/dist/core/tool-name-aliases.d.ts

@@ -1,2 +1 @@
-export declare const TOMBSTONED_TOOLS: Readonly<Record<string, string>>;
-export declare function canonicalToolName(name: string): string;
+export declare const RETIRED_TOOL_NAMES: ReadonlyMap<string, string>;