@sema-agent/core 2.12.0 → 2.13.0

package/dist/agents/agent-transcript-tool.d.ts

@@ -8,6 +8,7 @@ export interface AgentTranscriptToolOptions {
     owner?: string;
     scope?: string;
     sessionId?: string;
+    enrichCtx?: import("../core/tools.js").ToolCtxEnricher;
 }
 export declare function createAgentTranscriptTool(opts: AgentTranscriptToolOptions): import("../internal/harness-types.js").AgentTool<Type.TObject<{
     id: Type.TString;

package/dist/agents/agent-transcript-tool.js

@@ -118,5 +118,5 @@ export function createAgentTranscriptTool(opts) {
                 details: { type: "agent-transcript", id, steps },
             };
         },
-    });
+    }, opts.enrichCtx !== undefined ? { enrichCtx: opts.enrichCtx } : {});
 }

package/dist/brain/stream-engine.js

@@ -43,6 +43,9 @@ function emptyAssistant(model) {
 function isAbortError(err) {
     return err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError");
 }
+function isWalltimeCutoff(err) {
+    return err instanceof Error && err.message === WALLTIME_CUTOFF_MESSAGE;
+}
 function sleep(ms, signal) {
     return new Promise((resolve) => {
         if (signal?.aborted)
@@ -85,7 +88,7 @@ export function runStreamingBrain(args) {
         .catch((err) => {
         const aborted = signal?.aborted === true || isAbortError(err);
         terminalRetryPhase = "gave_up";
-        terminalRetryDetail = aborted ? "cancelled while retrying" : "retries exhausted";
+        terminalRetryDetail = aborted ? "cancelled while retrying" : isWalltimeCutoff(err) ? "wall-clock deadline reached while retrying" : "retries exhausted";
         const errorMsg = emptyAssistant(model);
         errorMsg.stopReason = aborted ? "aborted" : "error";
         errorMsg.errorMessage = err instanceof Error ? err.message : String(err);

package/dist/core/auto-promote.js

@@ -1,4 +1,5 @@
 import { extractSymbols } from "../tools/fs/repo-map.js";
+import { parseSkillToolEntry } from "./skill-tool-specifier.js";
 export function decideAutoPromote(i) {
     if (i.tripwire.escalate)
         return "needs_human";
@@ -58,7 +59,7 @@ export function deriveTripwire(artifactText, declared, profileTokens) {
     const reasons = [];
     let escalate = false;
     try {
-        const allow = new Set(declared.allowTools ?? []);
+        const allow = new Set((declared.allowTools ?? []).map((entry) => parseSkillToolEntry(entry).name));
         const symbols = extractSymbols(artifactText);
         for (const sym of symbols) {
             if (!allow.has(sym)) {

package/dist/core/git-worktree-env.js

@@ -28,6 +28,11 @@ export async function addWorktree(baseEnv, opts) {
         const detail = add.ok ? add.value.stderr || add.value.stdout : String(add.error);
         throw new Error(`git worktree add failed: ${detail}`);
     }
+    const excludeLine = shq(`/${WORKTREE_PARENT}/`);
+    await baseEnv
+        .exec(`ex="$(git rev-parse --git-path info/exclude)" && mkdir -p "$(dirname "$ex")" && ` +
+        `{ grep -qxF ${excludeLine} "$ex" 2>/dev/null || printf '%s\\n' ${excludeLine} >> "$ex"; }`, { cwd: opts.repoRoot })
+        .catch(() => undefined);
     let inner;
     try {
         inner = await opts.rootEnvAt(worktreeDir);

package/dist/core/mcp.d.ts

@@ -71,6 +71,7 @@ export declare const MCP_IDLE_TIMEOUT_HTTP_DEFAULT_MS: number;
 export declare function mcpIdleTimeoutMs(kind: "stdio" | "http"): number;
 export declare function describeMcpSpecErrorCode(code: unknown): string | undefined;
 export declare function collapseMcpErrorPrefix(message: string): string;
+export declare function networkErrorCode(err: unknown, depth?: number): string | undefined;
 export declare function normalizeMcpName(name: string): string;
 export declare function clampNameSegment(seg: string, max?: number): string;
 export * from "./image-downsample.js";

package/dist/core/mcp.js

@@ -179,11 +179,11 @@ const NETWORK_CODES_NEVER_DELIVERED = new Set([
     "ENETUNREACH",
     "UND_ERR_CONNECT_TIMEOUT",
 ]);
-function networkErrorCode(err, depth = 0) {
+export function networkErrorCode(err, depth = 0) {
     if (depth > 5 || !(err instanceof Error))
         return undefined;
     const code = err.code;
-    if (typeof code === "string" && /^(?:E[A-Z]+|UND_ERR_[A-Z_]+)$/.test(code))
+    if (typeof code === "string" && /^(?:E[A-Z_]+|UND_ERR_[A-Z_]+)$/.test(code))
         return code;
     if (err instanceof AggregateError) {
         for (const inner of err.errors) {
@@ -786,7 +786,8 @@ async function readDirViaExtension(rs, uri, signal, timeoutMs, watchdog) {
             if (err instanceof McpError && err.code === ErrorCode.InvalidParams) {
                 if (pages > 0)
                     return { kind: "ok", resources, cursorInvalid: true };
-                return { kind: classifyDirReadInvalidParams(err.message), detail: err.message };
+                const detail = collapseMcpErrorPrefix(err.message);
+                return { kind: classifyDirReadInvalidParams(detail), detail };
             }
             if (err instanceof McpError && err.code === ErrorCode.MethodNotFound)
                 return { kind: "unsupported" };

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

@@ -1,5 +1,6 @@
 import { canonicalizeTarget, fileArgPath } from "../../tools/fs/safety.js";
 import { canonicalToolName } from "../tool-name-aliases.js";
+import { parseSkillToolEntry, skillSpecifierRejection } from "../skill-tool-specifier.js";
 export class ActiveSkillScope {
     frames = [];
     push(frame) {
@@ -47,12 +48,19 @@ export function createActiveSkillScopePolicy(opts) {
                 };
             }
             const manifests = frames.flatMap((f) => (f.kind === "manifest" ? [f.manifest] : []));
-            let allowed;
-            for (const m of manifests) {
-                const here = new Set(m.allowTools.map(canonicalToolName));
-                allowed = allowed === undefined ? here : new Set([...allowed].filter((t) => here.has(t)));
-            }
-            if (!allowed || !allowed.has(toolName)) {
+            const perFrame = manifests.map((m) => {
+                const byName = new Map();
+                for (const raw of m.allowTools) {
+                    const entry = parseSkillToolEntry(raw);
+                    const bucket = byName.get(entry.name);
+                    if (bucket)
+                        bucket.push(entry);
+                    else
+                        byName.set(entry.name, [entry]);
+                }
+                return { manifest: m, byName };
+            });
+            if (perFrame.length === 0 || perFrame.some((f) => !f.byName.has(toolName))) {
                 const ids = manifests.map((m) => m.lineageId).join(", ");
                 return {
                     action: "deny",
@@ -60,6 +68,26 @@ export function createActiveSkillScopePolicy(opts) {
                     decisionReason: "safety",
                 };
             }
+            for (const frame of perFrame) {
+                const alternatives = frame.byName.get(toolName) ?? [];
+                const rejections = [];
+                let admitted = false;
+                for (const entry of alternatives) {
+                    const rejection = skillSpecifierRejection(entry, req.args);
+                    if (rejection === undefined) {
+                        admitted = true;
+                        break;
+                    }
+                    rejections.push(rejection);
+                }
+                if (!admitted) {
+                    return {
+                        action: "deny",
+                        reason: `tool "${req.toolName}" is narrowed by skill manifest "${frame.manifest.lineageId}": ${rejections.join("; ")}`,
+                        decisionReason: "safety",
+                    };
+                }
+            }
             const pathConstrainingActive = manifests.some((m) => m.allowPaths && m.allowPaths.length > 0);
             if (pathConstrainingActive && !PATH_WRITE_TOOLS.has(toolName)) {
                 const eff = toolEffects?.get(toolName) ?? "write";

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

@@ -432,6 +432,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         }
     }
     const taskScope = internals?.registryScope ?? spec.principal ?? "default";
+    const offloadScope = spec.principal ?? "default";
     defaultTaskRegistry.maybeGc();
     const forgetOnThrow = () => forgetQuietly(sessions, sessionId);
     const extraBodyCollisions = reservedCollisions(model.extraBody, reservedFor(model.api));
@@ -456,7 +457,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
     const offloadEnabled = Number.isFinite(offloadThreshold) && offloadThreshold > 0;
     const rawOffloadStore = offloadEnabled ? (deps.toolResultStore ?? new InMemoryToolResultStore()) : undefined;
     const offloadStore = rawOffloadStore instanceof RunnerSharedToolResultStore
-        ? new ScopedToolResultStore(rawOffloadStore, taskScope)
+        ? new ScopedToolResultStore(rawOffloadStore, offloadScope)
         : rawOffloadStore;
     const offloadReachableToolsRef = {};
     const maybeOffload = (tool, perTool) => {
@@ -1384,6 +1385,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                         owner: hostTaskId,
                         scope: taskScope,
                         ...(sessionId !== undefined ? { sessionId } : {}),
+                        enrichCtx: enrichSpecToolCtx,
                     })));
                 }
             }
@@ -1915,6 +1917,12 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 throw e;
             }
             const registry = buildDeferredRegistry(deferred, tools);
+            let activationChain = Promise.resolve();
+            const serializeActivation = (section) => {
+                const p = activationChain.then(section);
+                activationChain = p.then(() => undefined, () => undefined);
+                return p;
+            };
             const directCallFor = (name) => {
                 if (spec.deferSelfResolve === false)
                     return undefined;
@@ -1930,7 +1938,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                         };
                     },
                     ...(executionMode !== undefined ? { executionMode } : {}),
-                    activate: async () => {
+                    activate: async () => serializeActivation(async () => {
                         if (activeTools.has(name))
                             return undefined;
                         activeTools.add(name);
@@ -1942,7 +1950,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                             throw e;
                         }
                         return listingRideRef.current?.([name]);
-                    },
+                    }),
                 };
             };
             const placeholders = new Map([...registry.values()].map((i) => [i.name, createPlaceholderTool(i, directCallFor(i.name))]));
@@ -2016,6 +2024,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 listingRide: (newly) => listingRideRef.current?.(newly),
                 mountedNames: callableToolNames,
                 directCallEnabled: spec.deferSelfResolve !== false,
+                serializeActivation,
             });
             harnessTools = buildToolList(activeTools);
         }

package/dist/core/runner/runtask.js

@@ -222,6 +222,7 @@ function resumeContinuation(resume) {
 }
 function makeTurnBoundary(prepared, stats, rs, deps) {
     const { spec, queue, manualCompactRef, todoToolMounted, taskToolsMounted, turnToolSpan, walltimeDeadlineMs, walltimeMonotonicDeadline, nudgeSchedule, buildFinalizeText, timeout, ident, postToolBatchHook, batchArgs, compactionBrain, withinTaskCompaction, compactionBreaker, windowSafetyOptions, rapidRefill, drainManualCompact, runnerHooks } = deps;
+    let finalVerifySeenAtLastBoundary = 0;
     const onTurnBoundary = async (event) => {
         if (prepared.callCapRef && turnToolSpan.startMin !== undefined && turnToolSpan.endMax !== undefined) {
             recordToolCycleSample(prepared.callCapRef.state, turnToolSpan.endMax - turnToolSpan.startMin);
@@ -499,11 +500,13 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
             }
         }
         let batchContextBlock;
+        const finalVerifyInjectedThisTurn = rs.counters.finalVerifyInjections !== finalVerifySeenAtLastBoundary;
+        finalVerifySeenAtLastBoundary = rs.counters.finalVerifyInjections;
         if (postToolBatchHook !== undefined && rs.turn.toolBatch.length > 0) {
             const batch = rs.turn.toolBatch;
             rs.turn.toolBatch = [];
             batchArgs?.clear();
-            if (!boundarySteered && !rs.counters.finalizeInjected && rs.counters.finalVerifyInjections === 0 && !prepared.abortController.signal.aborted) {
+            if (!boundarySteered && !rs.counters.finalizeInjected && !finalVerifyInjectedThisTurn && !prepared.abortController.signal.aborted) {
                 try {
                     const r = await postToolBatchHook(batch);
                     if (r?.additionalContext) {
@@ -1662,6 +1665,9 @@ export class Runner {
             const gateToolName = "toolName" in resume.cp.gate ? resume.cp.gate.toolName : undefined;
             prepared.humanReviewRef.gates.push({ kind: resume.cp.gate.kind, waitMs, ...(decision !== undefined ? { decision } : {}), ...(gateToolName !== undefined ? { toolName: gateToolName } : {}) });
         }
+        if (resume !== undefined && resume.outcome.gate === "plan_review" && resume.outcome.decision === "reject") {
+            prepared.planModeRef.active = true;
+        }
         const rs = createRunState();
         rs.telemetry.cacheFamily = cacheFamilyOf(prepared.model);
         rs.telemetry.pricing = this.deps.pricing?.[prepared.model.id] ?? modelCostToPricing(prepared.model.cost);
@@ -2531,13 +2537,26 @@ export class Runner {
                 let promptBlocked = false;
                 const userPromptSubmit = (spec.hooks ?? this.deps.hooks)?.userPromptSubmit;
                 if (userPromptSubmit) {
-                    const decision = await userPromptSubmit(spec.objective);
-                    if (decision?.block) {
-                        prepared.blockedRef.reason = formatHookFeedback(decision.block);
-                        promptBlocked = true;
+                    try {
+                        const decision = await userPromptSubmit(spec.objective);
+                        if (decision?.block) {
+                            prepared.blockedRef.reason = formatHookFeedback(decision.block);
+                            promptBlocked = true;
+                        }
+                        else if (decision?.additionalContext) {
+                            effectiveObjective = `${formatHookFeedback(decision.additionalContext)}\n\n${spec.objective}`;
+                        }
                     }
-                    else if (decision?.additionalContext) {
-                        effectiveObjective = `${formatHookFeedback(decision.additionalContext)}\n\n${spec.objective}`;
+                    catch (hookErr) {
+                        const err = hookErr instanceof Error ? hookErr : new Error(String(hookErr));
+                        try {
+                            this.deps.onError?.(err, { phase: "hook", sessionId: prepared.sessionId });
+                        }
+                        catch {
+                        }
+                        prepared.blockedRef.reason = formatHookFeedback(`the deployment's userPromptSubmit hook crashed while screening this prompt (${err.message}); ` +
+                            `the prompt was NOT submitted (fail-closed)`);
+                        promptBlocked = true;
                     }
                 }
                 const firstFrames = [];
@@ -3102,7 +3121,7 @@ export class Runner {
             if (!r.ok) {
                 const tooLarge = r.error.code === "too_large";
                 const refusedAt = Date.now();
-                if (tooLarge)
+                if (tooLarge && !this.snapshotTooLargeRoots.has(root))
                     this.snapshotTooLargeRoots.set(root, { refusedAt, skipAnnounced: false });
                 try {
                     this.deps.onError?.(new Error(`rewind-files snapshot failed (${r.error.code}): ${r.error.message}` +

package/dist/core/runner/tool-disclosure.d.ts

@@ -57,4 +57,5 @@ export declare function createToolSearchTool(opts: {
     listingRide?: (newlyActivated: readonly string[]) => string | undefined;
     mountedNames?: () => ReadonlySet<string>;
     directCallEnabled?: boolean;
+    serializeActivation?: <T>(section: () => Promise<T>) => Promise<T>;
 }): AgentTool;

package/dist/core/runner/tool-disclosure.js

@@ -172,11 +172,22 @@ export function resolveToolSearch(args, registry) {
 export function extractDiscoveredToolNames(messages, registry) {
     const names = new Set();
     const pendingDirect = new Map();
+    const pendingSearch = new Map();
     for (const m of messages) {
         if (m.role === "toolResult") {
             const name = pendingDirect.get(m.toolCallId);
-            if (name !== undefined && m.isError !== true)
-                names.add(name);
+            if (name !== undefined) {
+                pendingDirect.delete(m.toolCallId);
+                if (m.isError !== true)
+                    names.add(name);
+            }
+            const searched = pendingSearch.get(m.toolCallId);
+            if (searched !== undefined) {
+                pendingSearch.delete(m.toolCallId);
+                if (m.isError !== true)
+                    for (const n of searched)
+                        names.add(n);
+            }
             continue;
         }
         if (m.role !== "assistant")
@@ -185,15 +196,18 @@ export function extractDiscoveredToolNames(messages, registry) {
             if (part.type !== "toolCall")
                 continue;
             if (part.name === TOOL_SEARCH_NAME) {
-                for (const n of resolveToolSearch(part.arguments, registry)) {
-                    names.add(n);
-                }
+                const prior = pendingSearch.get(part.id);
+                const resolved = resolveToolSearch(part.arguments, registry);
+                pendingSearch.set(part.id, prior === undefined ? resolved : [...prior, ...resolved]);
             }
             else if (registry.has(part.name)) {
                 pendingDirect.set(part.id, part.name);
             }
         }
     }
+    for (const list of pendingSearch.values())
+        for (const n of list)
+            names.add(n);
     return [...names];
 }
 export function createToolSearchTool(opts) {
@@ -209,6 +223,12 @@ export function createToolSearchTool(opts) {
             "first. When any instruction, reminder, or another tool's description names a deferred tool, activate it " +
             'with query "select:<name>" before calling it. ';
     let activationChain = Promise.resolve();
+    const serializeActivation = opts.serializeActivation ??
+        ((section) => {
+            const p = activationChain.then(section);
+            activationChain = p.then(() => undefined, () => undefined);
+            return p;
+        });
     return defineTool({
         name: TOOL_SEARCH_NAME,
         contract: { contractId: "core.tool_search@1", implementationRevision: "1" },
@@ -259,7 +279,7 @@ export function createToolSearchTool(opts) {
                     },
                 };
             }
-            const section = activationChain.then(async () => {
+            const section = serializeActivation(async () => {
                 const newly = matched.filter((n) => !active.has(n));
                 if (newly.length > 0) {
                     for (const n of newly)
@@ -275,7 +295,6 @@ export function createToolSearchTool(opts) {
                 }
                 return { newly, ride: newly.length > 0 ? listingRide?.(newly) : undefined };
             });
-            activationChain = section.then(() => undefined, () => undefined);
             const { newly, ride } = await section;
             const lines = matched.map((n) => {
                 const info = registry.get(n);

package/dist/core/session-store.js

@@ -114,6 +114,11 @@ export class TtlSessionStore {
         }
         const forked = await this.repo.fork(await source.getMetadata(), forkParams);
         const meta = await forked.getMetadata();
+        const inherited = this.owners.has(sourceId) ? this.owners.get(sourceId) : undefined;
+        const forkOwner = owner ?? inherited;
+        if (forkOwner !== undefined && !this.owners.has(meta.id)) {
+            this.owners.set(meta.id, forkOwner);
+        }
         this.entries.set(meta.id, {
             session: forked,
             lastActiveAt: Date.now(),
@@ -149,8 +154,13 @@ export class TtlSessionStore {
         return this.owners.has(sessionId) ? this.owners.get(sessionId) : undefined;
     }
     async register(sessionId, owner) {
-        if (!this.owners.has(sessionId))
-            this.owners.set(sessionId, owner);
+        if (this.owners.has(sessionId)) {
+            return;
+        }
+        if (owner !== null && typeof owner !== "string") {
+            throw new TypeError(`SessionStore.register: owner must be a string (owned) or null (anonymous), got ${owner === undefined ? "undefined" : typeof owner}`);
+        }
+        this.owners.set(sessionId, owner);
     }
     sweep(now = Date.now()) {
         for (const [id, e] of this.entries) {
@@ -160,8 +170,9 @@ export class TtlSessionStore {
             if (now - e.lastActiveAt > this.defaultTtlMs) {
                 this.entries.delete(id);
                 if (this.evictPolicy === "delete") {
-                    void this.repo.delete({ id, createdAt: "" });
-                    this.owners.delete(id);
+                    void this.repo.delete({ id, createdAt: "" }).then(() => {
+                        this.owners.delete(id);
+                    }, () => { });
                 }
             }
         }

package/dist/core/skill-tool-specifier.d.ts

@@ -0,0 +1,8 @@
+export interface SkillToolEntry {
+    readonly raw: string;
+    readonly name: string;
+    readonly specifier?: string;
+}
+export declare function parseSkillToolEntry(entry: string): SkillToolEntry;
+export declare function isSkillSpecifierEnforced(canonicalName: string): boolean;
+export declare function skillSpecifierRejection(entry: SkillToolEntry, args: unknown): string | undefined;

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

@@ -0,0 +1,58 @@
+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));
+export function parseSkillToolEntry(entry) {
+    const parsed = parsePermissionRule(entry);
+    const name = canonicalToolName(parsed.toolName);
+    return parsed.ruleContent === undefined ? { raw: entry, name } : { raw: entry, name, specifier: parsed.ruleContent };
+}
+export function isSkillSpecifierEnforced(canonicalName) {
+    return SPECIFIER_ENFORCED_TOOLS.has(canonicalName);
+}
+function normalizeSpacing(s) {
+    return s.trim().replace(/[ \t]+/g, " ");
+}
+function hasUnescapedStar(content) {
+    for (let i = 0; i < content.length; i++) {
+        if (content[i] !== "*")
+            continue;
+        let backslashes = 0;
+        for (let j = i - 1; j >= 0 && content[j] === "\\"; j--)
+            backslashes++;
+        if (backslashes % 2 === 0)
+            return true;
+    }
+    return false;
+}
+function specifierMatchesCommand(specifier, command) {
+    const spec = normalizeSpacing(specifier);
+    const prefix = /^(.+):\*$/.exec(spec)?.[1];
+    if (prefix !== undefined) {
+        return command === prefix || command.startsWith(prefix + " ");
+    }
+    if (hasUnescapedStar(spec))
+        return wildcardMatch(spec, command);
+    return command === spec;
+}
+export function skillSpecifierRejection(entry, args) {
+    const { specifier } = entry;
+    if (specifier === undefined)
+        return undefined;
+    if (!isSkillSpecifierEnforced(entry.name)) {
+        return `entry "${entry.raw}" narrows a tool whose calls this gate cannot match against a command pattern — only the shell tools (${[...SPECIFIER_ENFORCED_TOOLS].join(", ")}) carry a command string, so the entry admits nothing`;
+    }
+    const command = args?.command;
+    if (typeof command !== "string") {
+        return `entry "${entry.raw}" requires a command string to match against, and this call has none`;
+    }
+    const parsedCommand = parseLeadingCommandName(command);
+    if ("reject" in parsedCommand) {
+        return `entry "${entry.raw}" only admits a single simple command (${parsedCommand.reject})`;
+    }
+    if (!specifierMatchesCommand(specifier, normalizeSpacing(command))) {
+        return `command "${command.trim()}" is not admitted by entry "${entry.raw}"`;
+    }
+    return undefined;
+}

package/dist/core/skills-directory.d.ts

@@ -1,5 +1,5 @@
 import type { SkillSpec } from "./types.js";
-export type SkillsDirectoryWarningCode = "no_skill_file" | "no_frontmatter" | "missing_name" | "invalid_name" | "name_mismatch" | "missing_description" | "description_too_long" | "allowed_tool_not_mounted" | "disallowed_tools_unenforced" | "attachment_skipped" | "read_failed";
+export type SkillsDirectoryWarningCode = "no_skill_file" | "no_frontmatter" | "missing_name" | "invalid_name" | "name_mismatch" | "missing_description" | "allowed_tool_pattern_unsupported" | "description_too_long" | "allowed_tool_not_mounted" | "disallowed_tools_unenforced" | "attachment_skipped" | "read_failed";
 export interface SkillsDirectoryWarning {
     code: SkillsDirectoryWarningCode;
     skill: string;

package/dist/core/skills-directory.js

@@ -1,6 +1,7 @@
 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"];
 const NAME_MAX_CHARS = 64;
@@ -316,12 +317,23 @@ function manifestFromAllowedTools(declared, disallowed, skillName, deployedTools
     const names = [];
     const seen = new Set();
     for (const n of splitToolNames(declared)) {
-        const key = canonicalToolName(n);
+        const entry = parseSkillToolEntry(n);
+        const key = entry.specifier === undefined ? entry.name : `${entry.name}(${entry.specifier})`;
         if (seen.has(key))
             continue;
         seen.add(key);
         names.push(n);
     }
+    for (const n of names) {
+        const entry = parseSkillToolEntry(n);
+        if (entry.specifier !== undefined && !isSkillSpecifierEnforced(entry.name)) {
+            warn({
+                code: "allowed_tool_pattern_unsupported",
+                skill: skillName,
+                detail: `allowed-tools entry "${n}" narrows a tool whose calls cannot be matched against a command pattern — only shell tools carry one, so the entry is not enforced and the tool is DISABLED inside this skill frame. Use the bare tool name to allow it fully.`,
+            });
+        }
+    }
     if (names.length === 0)
         return undefined;
     if (names.some((n) => n === ALL_TOOLS_WILDCARD))
@@ -329,9 +341,9 @@ function manifestFromAllowedTools(declared, disallowed, skillName, deployedTools
     let allowTools = names;
     if (deployedTools !== undefined) {
         const mounted = new Set(deployedTools.map(canonicalToolName));
-        allowTools = names.filter((n) => mounted.has(canonicalToolName(n)));
+        allowTools = names.filter((n) => mounted.has(parseSkillToolEntry(n).name));
         for (const n of names) {
-            if (!mounted.has(canonicalToolName(n))) {
+            if (!mounted.has(parseSkillToolEntry(n).name)) {
                 warn({
                     code: "allowed_tool_not_mounted",
                     skill: skillName,
@@ -342,7 +354,7 @@ function manifestFromAllowedTools(declared, disallowed, skillName, deployedTools
     }
     if (disallowed.length > 0) {
         const denied = new Set(disallowed.map(canonicalToolName));
-        allowTools = allowTools.filter((n) => !denied.has(canonicalToolName(n)));
+        allowTools = allowTools.filter((n) => !denied.has(parseSkillToolEntry(n).name));
     }
     return { allowTools, lineageId: `skill:${skillName}` };
 }

package/dist/core/types.d.ts

@@ -1,6 +1,6 @@
 import type { TSchema } from "typebox";
 import type { AgentTool, ThinkingLevel } from "../internal/harness.js";
-import type { DocumentContent, ImageContent, Model, ResilienceOptions, StreamFn, TextContent } from "../internal/llm.js";
+import type { CompleteSimpleFn, DocumentContent, ImageContent, Model, ResilienceOptions, StreamFn, TextContent } from "../internal/llm.js";
 import type { TaskNotificationPayload } from "./task-notification.js";
 export type ModelRef = string | Model;
 export type ModelRole = "default" | "summarize" | "subagent" | "team" | "synthesize" | "advisor" | "verifier" | "classifier";
@@ -13,10 +13,7 @@ export type RoleSpec = ModelRef | {
 export type ModelRoles = Partial<Record<ModelRole, RoleSpec>>;
 export interface Brain {
     stream: StreamFn;
-    complete?: (model: Model, context: {
-        systemPrompt?: string;
-        messages: unknown[];
-    }, options?: unknown) => Promise<unknown>;
+    complete?: CompleteSimpleFn;
 }
 export type ToolEffect = "read" | "write" | "idempotent";
 export interface ToolSpec<TParams extends TSchema = TSchema> {

package/dist/core/with-retry.js

@@ -13,7 +13,6 @@ export async function withRetry(op, policy, opts = {}) {
                 opts.signal?.removeEventListener("abort", onAbort);
                 resolve();
             }, ms);
-            timer.unref?.();
             opts.signal?.addEventListener("abort", onAbort, { once: true });
         }));
     let last = await op(1);

package/dist/index.d.ts

@@ -188,7 +188,7 @@ export { createDegradingBrain, readDegradation, DEGRADED_DIAGNOSTIC_TYPE, type D
 export { retryBackoffMs, parseRetryAfter } from "./brain/retry.js";
 export { type BrainTimeoutConfig } from "./brain/timeout.js";
 export { createAssistantMessageEventStream } from "./internal/llm.js";
-export type { AssistantMessage, AssistantMessageEvent, Context, DocumentContent, ImageContent, Message, StopReason, StreamFn, TextContent, ThinkingContent, ToolCall, ToolResultMessage, Usage, UserMessage, } from "./internal/llm.js";
+export type { AssistantMessage, AssistantMessageEvent, CompleteSimpleFn, Context, DocumentContent, ImageContent, Message, StopReason, StreamFn, TextContent, ThinkingContent, ToolCall, ToolResultMessage, Usage, UserMessage, } from "./internal/llm.js";
 export type { AgentDefinition, BeforeWriteHook, BeforeWriteRequest, BeforeWriteResult, HandsBandOptions, Brain, BrainStatus, BrainStatusPhase, ImageInput, McpElicitRequest, McpElicitResponse, McpServerSpec, OnElicit, Model, ModelRef, ProjectMemoryLoad, RunnerDeps, RuntimeCaps, BackgroundChildEvent, SkillManifest, SkillSpec, TaskEvent, TaskEventIdentity, ToolActivity, TaskResult, RemoteEnvFailureNote, TaskSpec, TaskStatus, TaskStream, CompactOutcome, ThinkingLevel, ToolExecuteContext, ToolReturn, ToolSpec, ToolEffect, WorkflowGovernanceBaseline, } from "./core/types.js";
 export { Type } from "typebox";
 export type { TSchema, Static } from "typebox";

package/dist/internal/llm.d.ts

@@ -1,2 +1,2 @@
 export { createAssistantMessageEventStream, stripEngineMetadata } from "../engine/llm/index.js";
-export type { AnthropicMessagesCompat, AssistantMessage, AssistantMessageDiagnostic, AssistantMessageEvent, Context, DocumentContent, ImageContent, Message, Model, ResilienceOptions, SimpleStreamOptions, StallTimeouts, StopReason, StreamFn, TextContent, ThinkingContent, Tool, ToolCall, ToolResultMessage, Usage, UserMessage, } from "../engine/llm/index.js";
+export type { AnthropicMessagesCompat, AssistantMessage, AssistantMessageDiagnostic, AssistantMessageEvent, CompleteSimpleFn, Context, DocumentContent, ImageContent, Message, Model, ResilienceOptions, SimpleStreamOptions, StallTimeouts, StopReason, StreamFn, TextContent, ThinkingContent, Tool, ToolCall, ToolResultMessage, Usage, UserMessage, } from "../engine/llm/index.js";

package/dist/orchestration/workflow.js

@@ -480,13 +480,15 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
         if (row !== undefined)
             row.sessionId = sessionId;
     };
-    const bceTick = (callKey, e) => {
+    const bceTick = (callKey, e, fromSessionId) => {
         if (!bceSink)
             return;
         const id = waIdOf(callKey);
         const row = bceLive.get(id);
         if (row === undefined)
             return;
+        if (fromSessionId !== undefined && row.sessionId !== undefined && fromSessionId !== row.sessionId)
+            return;
         bceEmit({
             kind: "tick",
             taskId: id,
@@ -507,8 +509,10 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
         if (!bceSink)
             return;
         const id = waIdOf(callKey);
+        const row = bceLive.get(id);
         if (!bceLive.delete(id))
             return;
+        const coord = sessionId ?? row?.sessionId;
         bceEmit({
             kind: "terminal",
             taskId: id,
@@ -516,7 +520,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
             owner: runId,
             workflowRunId: runId,
             ...(scope !== undefined ? { scope } : {}),
-            ...(sessionId !== undefined ? { sessionId, transcriptId: sessionId } : {}),
+            ...(coord !== undefined ? { sessionId: coord, transcriptId: coord } : {}),
             status,
             summary: boundedRedactedSummary(summary, 300),
             ...(stats !== undefined ? { usage: { tokens: stats.tokens, turns: stats.turns, ...(stats.costMicroUsd !== undefined ? { costMicroUsd: stats.costMicroUsd } : {}) } } : {}),
@@ -873,7 +877,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                             ? {
                                 onForwardEvent: (e) => {
                                     if (e.type === "task_progress")
-                                        bceTick(callKey, e);
+                                        bceTick(callKey, e, attemptSessionId);
                                     try {
                                         baseInternals.onForwardEvent?.(e);
                                     }
@@ -1181,7 +1185,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                         ? {
                             onForwardEvent: (e) => {
                                 if (e.type === "task_progress")
-                                    bceTick(callKey, e);
+                                    bceTick(callKey, e, childSessionId);
                                 try {
                                     enrichedForwardS?.(e);
                                 }

package/dist/tools/fs/bash-readonly-classifier.js

@@ -107,10 +107,42 @@ function hasUnquotedExpansionMetachar(rawToken) {
     }
     return false;
 }
+function longOptionNameOf(tok) {
+    if (!tok.startsWith("--") || tok.length === 2)
+        return undefined;
+    const body = tok.slice(2);
+    const eq = body.indexOf("=");
+    const name = eq >= 0 ? body.slice(0, eq) : body;
+    return name.length > 0 ? name : undefined;
+}
+function isLongOptionAbbrevOf(name, full) {
+    return full.startsWith(name);
+}
 function isGrepPatternFlagToken(tok) {
-    if (tok.startsWith("--"))
-        return tok.startsWith("--regexp") || tok.startsWith("--file");
-    return /^-[A-Za-z]*[ef]/.test(tok);
+    if (tok.startsWith("--")) {
+        const long = longOptionNameOf(tok);
+        return long !== undefined && (isLongOptionAbbrevOf(long, "regexp") || isLongOptionAbbrevOf(long, "file"));
+    }
+    return /^-[A-Za-z0-9]*[ef]/.test(tok);
+}
+function isGrepPatternPayloadLongOption(tok) {
+    if (!tok.includes("="))
+        return false;
+    const name = longOptionNameOf(tok);
+    return name !== undefined && isLongOptionAbbrevOf(name, "regexp");
+}
+function isCutDelimiterPayloadLongOption(tok) {
+    if (!tok.includes("="))
+        return false;
+    const name = longOptionNameOf(tok);
+    return name !== undefined && (isLongOptionAbbrevOf(name, "delimiter") || isLongOptionAbbrevOf(name, "output-delimiter"));
+}
+function isGrepFileStdinLongOption(tok) {
+    const eq = tok.indexOf("=");
+    if (eq < 0 || tok.slice(eq + 1) !== "-")
+        return false;
+    const name = longOptionNameOf(tok);
+    return name !== undefined && isLongOptionAbbrevOf(name, "file");
 }
 function grepClusterValueOwner(tok) {
     if (!/^-[A-Za-z]/.test(tok) || tok.startsWith("--"))
@@ -176,9 +208,9 @@ function collectSegmentBoundaryFindings(tokens, boundary) {
                 k++;
                 continue;
             }
-            if (name === "cut" && (/^-d./.test(t) || /^--(output-)?delimiter=/.test(t)))
+            if (name === "cut" && (/^-d./.test(t) || isCutDelimiterPayloadLongOption(t)))
                 continue;
-            if (name === "grep" && (grepClusterValueOwner(t) === "e" || /^--regexp=/.test(t)))
+            if (name === "grep" && (grepClusterValueOwner(t) === "e" || isGrepPatternPayloadLongOption(t)))
                 continue;
             if (t.startsWith("-") && t !== "-") {
                 for (const payload of attachedOptionPayloads(t)) {
@@ -312,7 +344,7 @@ export function classifyCompoundReadonlyDetailed(command, allow, boundary) {
                         k++;
                         continue;
                     }
-                    if (name === "grep" && (t === "-f-" || t === "--file=-")) {
+                    if (name === "grep" && (t === "-f-" || isGrepFileStdinLongOption(t))) {
                         hasStdinDash = true;
                         break;
                     }

package/dist/tools/scheduler-tools.js

@@ -158,6 +158,12 @@ export function createSchedulerTools(env, ctx) {
         return [];
     const sched = env;
     const schedCtx = toSchedulerContext(ctx);
+    let cronCreateChain = Promise.resolve();
+    const serializedCronCreateOp = (fn) => {
+        const next = cronCreateChain.then(fn, fn);
+        cronCreateChain = next.then(() => undefined, () => undefined);
+        return next;
+    };
     const cronCreateDescription = `Schedule a prompt to be enqueued at a future time. Use for both recurring schedules and one-shot reminders. The task runs UNATTENDED when it fires, so write a fully self-contained \`prompt\` (it will not see this conversation). Use CronList to see what you've scheduled, CronDelete to remove one.
 
 ## One-shot tasks (schedule kind "delay" or "at")
@@ -210,7 +216,7 @@ Only use minute 0 or 30 when the user names that exact time and clearly means it
             label: Type.Optional(Type.String({ description: "Short label (also a dedup key with the schedule)." })),
         }),
         effect: "write",
-        execute: async (args) => {
+        execute: async (args) => serializedCronCreateOp(async () => {
             const a = args;
             if (a.schedule !== undefined && a.cron !== undefined) {
                 return errorResult("Error (CronCreate): pass exactly one of `schedule` (object form) or `cron` (string form), not both.");
@@ -224,7 +230,7 @@ Only use minute 0 or 30 when the user names that exact time and clearly means it
             const when = a.schedule ?? { kind: "cron", expr: a.cron };
             if (when.kind === "cron") {
                 if (!isValidCronExpr(when.expr)) {
-                    return errorResult(`Error (CronCreate): invalid cron expression "${when.expr}" — only 5/6 space-separated cron fields (digits and * / , -) are allowed.`);
+                    return errorResult(`Error (CronCreate): invalid cron expression "${when.expr}" — only 5 space-separated cron fields (digits and * / , -) are allowed (a 6th leading seconds field is parsed but always rejected next — this scheduler has no seconds hand).`);
                 }
                 const deepErr = cronScheduleError(when.expr);
                 if (deepErr)
@@ -277,7 +283,7 @@ Only use minute 0 or 30 when the user names that exact time and clearly means it
                     ...(replaced !== undefined ? { replaced } : {}),
                 },
             };
-        },
+        }),
     });
     const cronCancel = defineTool({
         name: "CronDelete",

package/dist/tools/web.d.ts

@@ -6,7 +6,10 @@ export interface WebFetchConfig {
     fetchImpl?: typeof fetch;
     maxBytes?: number;
     timeoutMs?: number;
-    summarize?: (content: string, prompt: string, signal?: AbortSignal) => Promise<string>;
+    summarize?: (content: string, prompt: string, signal?: AbortSignal) => Promise<string | {
+        text: string;
+        truncated?: boolean;
+    }>;
     userAgent?: string;
 }
 export declare function htmlToText(html: string): string;
@@ -14,7 +17,10 @@ export declare function webFetchToolSpec(config?: WebFetchConfig): ToolSpec;
 export declare function createWebFetchTool(config?: WebFetchConfig): AgentTool;
 export declare const WEBFETCH_SUMMARY_MAX_CONTENT = 100000;
 export declare const WEBFETCH_SUMMARY_GUIDELINES: string;
-export declare function createWebFetchSummarizer(brain: Brain, model: Model): (content: string, prompt: string, signal?: AbortSignal) => Promise<string>;
+export declare function createWebFetchSummarizer(brain: Brain, model: Model): (content: string, prompt: string, signal?: AbortSignal) => Promise<string | {
+    text: string;
+    truncated?: boolean;
+}>;
 export interface WebSearchConfig {
     search: (query: string, signal?: AbortSignal, opts?: {
         allowedDomains?: string[];

package/dist/tools/web.js

@@ -495,6 +495,7 @@ export function webFetchToolSpec(config = {}) {
             }
             const text = /html/i.test(contentType) || /^\s*</.test(raw) ? htmlToText(raw) : raw;
             let out = text;
+            let summaryTruncated = false;
             let note;
             if (prompt && bodyCut) {
                 note =
@@ -503,7 +504,17 @@ export function webFetchToolSpec(config = {}) {
             }
             else if (prompt && config.summarize) {
                 try {
-                    out = await config.summarize(text, prompt, ctx.signal);
+                    const summarized = await config.summarize(text, prompt, ctx.signal);
+                    if (typeof summarized === "string") {
+                        out = summarized;
+                    }
+                    else {
+                        out = summarized.text;
+                        if (summarized.truncated) {
+                            summaryTruncated = true;
+                            note = `[note: the summary below is INCOMPLETE — the summarizer hit its output limit before finishing]`;
+                        }
+                    }
                 }
                 catch (e) {
                     out = text;
@@ -534,7 +545,7 @@ export function webFetchToolSpec(config = {}) {
                     bytes: bodyBytes ? bodyBytes.length : raw.length,
                     result: out.length > RESULT_PREVIEW_CHARS ? `${out.slice(0, RESULT_PREVIEW_CHARS)}\n…[${out.length - RESULT_PREVIEW_CHARS} chars truncated — full text in the tool output]` : out,
                     durationMs: Date.now() - startedAt,
-                    ...(truncationNote ? { truncated: true } : {}),
+                    ...(truncationNote || summaryTruncated ? { truncated: true } : {}),
                     ...transferStateDetails,
                 },
             };
@@ -560,18 +571,17 @@ export function createWebFetchSummarizer(brain, model) {
         const msg = brain.complete
             ? await brain.complete(model, context, { signal })
             : await (await Promise.resolve(brain.stream(model, context, { signal }))).result();
-        const am = msg;
-        if (am?.stopReason === "error" || am?.stopReason === "aborted") {
-            throw new Error(am.errorMessage ?? `summarizer stopped with ${am.stopReason}`);
+        if (msg.stopReason === "error" || msg.stopReason === "aborted") {
+            throw new Error(msg.errorMessage ?? `summarizer stopped with ${msg.stopReason}`);
         }
-        const text = (am?.content ?? [])
-            .filter((b) => b?.type === "text" && typeof b.text === "string")
+        const text = msg.content
+            .filter((b) => b.type === "text" && typeof b.text === "string")
             .map((b) => b.text)
             .join("\n")
             .trim();
         if (!text)
             throw new Error("summarizer returned no text");
-        return text;
+        return msg.stopReason === "length" || msg.partialFinalized === true ? { text, truncated: true } : text;
     };
 }
 const DEFAULT_SEARCH_TIMEOUT_MS = 30_000;
@@ -801,25 +811,27 @@ export function createWebSearchTool(config) {
 export function createSearxngSearchBackend(baseUrl, options = {}) {
     const doFetch = options.fetchImpl ?? globalThis.fetch;
     const timeoutMs = options.timeoutMs ?? 10_000;
-    const base = baseUrl.replace(/\/+$/, "");
+    const parsedBase = new URL(baseUrl);
+    parsedBase.hash = "";
+    parsedBase.pathname = `${parsedBase.pathname.replace(/\/+$/, "")}/search`;
     return async (query, signal, opts) => {
         const q = opts?.allowedDomains && opts.allowedDomains.length > 0
             ? `${opts.allowedDomains.map((d) => `site:${d}`).join(" OR ")} ${query}`
             : query;
-        const url = new URL(`${base}/search`);
-        url.searchParams.set("q", q);
-        url.searchParams.set("format", "json");
+        const url = new URL(parsedBase);
         for (const [k, v] of Object.entries(options.extraParams ?? {}))
             url.searchParams.set(k, v);
+        url.searchParams.set("q", q);
+        url.searchParams.set("format", "json");
         const timeout = AbortSignal.timeout(timeoutMs);
         const res = await doFetch(url, { signal: signal ? AbortSignal.any([signal, timeout]) : timeout, headers: { accept: "application/json" } });
         if (!res.ok)
-            throw new Error(`SearXNG ${res.status} ${res.statusText} from ${base}/search`);
+            throw new Error(`SearXNG ${res.status} ${res.statusText} from ${url.origin}${url.pathname}`);
         const body = (await res.json());
         if (!Array.isArray(body.results))
-            throw new Error(`SearXNG returned no results array from ${base}/search — is format=json enabled on this instance?`);
+            throw new Error(`SearXNG returned no results array from ${url.origin}${url.pathname} — is format=json enabled on this instance?`);
         return body.results
-            .filter((r) => typeof r.url === "string" && r.url !== "")
+            .filter((r) => typeof r === "object" && r !== null && typeof r.url === "string" && r.url !== "")
             .map((r) => ({
             title: typeof r.title === "string" && r.title !== "" ? r.title : r.url,
             url: r.url,
@@ -829,14 +841,31 @@ export function createSearxngSearchBackend(baseUrl, options = {}) {
 }
 export async function probeSearchBackend(search, options) {
     const budget = options?.timeoutMs ?? 15_000;
+    let timer;
     try {
         const results = await Promise.race([
             search("connectivity probe", AbortSignal.timeout(budget)),
-            new Promise((_, reject) => setTimeout(() => reject(new Error(`probe timed out after ${budget}ms`)), budget)),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(`probe timed out after ${budget}ms`)), budget);
+            }),
         ]);
         return { ok: true, results: results.length };
     }
     catch (e) {
-        return { ok: false, error: e instanceof Error ? e.message : String(e) };
+        let text;
+        if (e instanceof Error)
+            text = e.message;
+        else {
+            try {
+                text = String(e);
+            }
+            catch {
+                text = Object.prototype.toString.call(e);
+            }
+        }
+        return { ok: false, error: text };
+    }
+    finally {
+        clearTimeout(timer);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/core",
-  "version": "2.12.0",
+  "version": "2.13.0",
   "description": "Stateless, task-oriented AI agent core",
   "type": "module",
   "license": "BUSL-1.1",