@sema-agent/core 1.451.0 → 2.0.0

package/dist/tools/scheduler-tools.js

@@ -1,5 +1,5 @@
 import { Type } from "typebox";
-import { defineTool } from "../core/tools.js";
+import { defineTool, errorResult } from "../core/tools.js";
 import { hasScheduler, isValidCronExpr, } from "../core/scheduler.js";
 export const SCHEDULE_WAKEUP_TOOL_NAME = "ScheduleWakeup";
 export const AUTONOMOUS_LOOP_SENTINEL = "<<autonomous-loop>>";
@@ -210,33 +210,33 @@ Only use minute 0 or 30 when the user names that exact time and clearly means it
         execute: async (args) => {
             const a = args;
             if (a.schedule !== undefined && a.cron !== undefined) {
-                return "Error (CronCreate): pass exactly one of `schedule` (object form) or `cron` (string form), not both.";
+                return errorResult("Error (CronCreate): pass exactly one of `schedule` (object form) or `cron` (string form), not both.");
             }
             if (a.schedule === undefined && a.cron === undefined) {
-                return "Error (CronCreate): a schedule is required — pass `schedule` (kinds cron/at/delay) or the shorthand `cron` string.";
+                return errorResult("Error (CronCreate): a schedule is required — pass `schedule` (kinds cron/at/delay) or the shorthand `cron` string.");
             }
             if (a.prompt === undefined) {
-                return "Error (CronCreate): `prompt` is required — the task runs unattended, so it needs self-contained instructions.";
+                return errorResult("Error (CronCreate): `prompt` is required — the task runs unattended, so it needs self-contained instructions.");
             }
             const when = a.schedule ?? { kind: "cron", expr: a.cron };
             if (when.kind === "cron") {
                 if (!isValidCronExpr(when.expr)) {
-                    return `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/6 space-separated cron fields (digits and * / , -) are allowed.`);
                 }
                 const deepErr = cronScheduleError(when.expr);
                 if (deepErr)
-                    return `Error (CronCreate): cron expression "${when.expr}" — ${deepErr}`;
+                    return errorResult(`Error (CronCreate): cron expression "${when.expr}" — ${deepErr}`);
             }
             else if (a.recurring !== undefined) {
-                return `Error (CronCreate): \`recurring\` only applies to cron schedules — "${when.kind}" fires once by nature; omit \`recurring\`.`;
+                return errorResult(`Error (CronCreate): \`recurring\` only applies to cron schedules — "${when.kind}" fires once by nature; omit \`recurring\`.`);
             }
             const durable = a.durable ?? a.schedule !== undefined;
             if (!durable) {
                 if (sched.schedulerCapabilities.supportsSessionLifetime !== true) {
-                    return "Error (CronCreate): this scheduler backend does not support session-scoped jobs (they could not be cleaned up when the session ends). Pass `durable: true` to schedule a persistent job instead.";
+                    return errorResult("Error (CronCreate): this scheduler backend does not support session-scoped jobs (they could not be cleaned up when the session ends). Pass `durable: true` to schedule a persistent job instead.");
                 }
                 if (ctx.sessionId === undefined) {
-                    return "Error (CronCreate): session-scoped jobs need a session to bind to, and this run has none. Pass `durable: true` to schedule a persistent job instead.";
+                    return errorResult("Error (CronCreate): session-scoped jobs need a session to bind to, and this run has none. Pass `durable: true` to schedule a persistent job instead.");
                 }
             }
             const intent = {
@@ -248,7 +248,7 @@ Only use minute 0 or 30 when the user names that exact time and clearly means it
             };
             const r = await sched.schedule(intent, schedCtx);
             if (!r.ok)
-                return `Error (CronCreate): ${r.error.message}`;
+                return errorResult(`Error (CronCreate): ${r.error.message}`);
             const humanSchedule = when.kind === "cron"
                 ? cronToHuman(when.expr)
                 : when.kind === "delay"
@@ -278,7 +278,7 @@ Only use minute 0 or 30 when the user names that exact time and clearly means it
             if (!r.ok) {
                 if (r.error.code === "not_found")
                     return `CronDelete: no scheduled task "${id}" (already gone or not yours).`;
-                return `Error (CronDelete): ${r.error.message}`;
+                return errorResult(`Error (CronDelete): ${r.error.message}`);
             }
             return { content: `Cancelled scheduled task ${id}.`, details: { type: "cron-delete", id } };
         },
@@ -292,7 +292,7 @@ Only use minute 0 or 30 when the user names that exact time and clearly means it
         execute: async () => {
             const r = await sched.list(schedCtx);
             if (!r.ok)
-                return `Error (CronList): ${r.error.message}`;
+                return errorResult(`Error (CronList): ${r.error.message}`);
             if (r.value.length === 0) {
                 return { content: "No scheduled tasks.", details: { type: "cron-list", jobs: [] } };
             }
@@ -367,7 +367,7 @@ Only use minute 0 or 30 when the user names that exact time and clearly means it
             if (a.stop === true) {
                 const pending = await listPendingWakeups();
                 if ("err" in pending)
-                    return `Error (${SCHEDULE_WAKEUP_TOOL_NAME}): ${pending.err}`;
+                    return errorResult(`Error (${SCHEDULE_WAKEUP_TOOL_NAME}): ${pending.err}`);
                 const cancelledWakeups = await cancelWakeups(pending.ids);
                 return {
                     content: `Loop stopped. Cancelled ${cancelledWakeups} pending wakeup(s); recurring cron tasks are unaffected.`,
@@ -375,10 +375,10 @@ Only use minute 0 or 30 when the user names that exact time and clearly means it
                 };
             }
             if (a.delaySeconds === undefined || a.reason === undefined || a.prompt === undefined) {
-                return `Error (${SCHEDULE_WAKEUP_TOOL_NAME}): delaySeconds, reason and prompt are required unless \`stop\` is true.`;
+                return errorResult(`Error (${SCHEDULE_WAKEUP_TOOL_NAME}): delaySeconds, reason and prompt are required unless \`stop\` is true.`);
             }
             if (sched.schedulerCapabilities.supportsSessionWakeup === false) {
-                return `Error (${SCHEDULE_WAKEUP_TOOL_NAME}): this environment has no resident scheduler that can honor a session wakeup — the wakeup would never fire. Wait in the foreground instead, or start the work in a self-detaching form.`;
+                return errorResult(`Error (${SCHEDULE_WAKEUP_TOOL_NAME}): this environment has no resident scheduler that can honor a session wakeup — the wakeup would never fire. Wait in the foreground instead, or start the work in a self-detaching form.`);
             }
             const clampedDelaySeconds = Math.min(3600, Math.max(60, Math.round(a.delaySeconds)));
             const wasClamped = clampedDelaySeconds !== a.delaySeconds;
@@ -387,7 +387,7 @@ Only use minute 0 or 30 when the user names that exact time and clearly means it
                 await cancelWakeups(pending.ids);
             const r = await sched.schedule({ prompt: a.prompt, when: { kind: "delay", delaySec: clampedDelaySeconds }, label: WAKEUP_LABEL, mode: "session-wakeup" }, schedCtx);
             if (!r.ok)
-                return `Error (${SCHEDULE_WAKEUP_TOOL_NAME}): ${r.error.message}`;
+                return errorResult(`Error (${SCHEDULE_WAKEUP_TOOL_NAME}): ${r.error.message}`);
             const scheduledFor = Date.now() + clampedDelaySeconds * 1000;
             const hhmmss = new Date(scheduledFor).toTimeString().slice(0, 8);
             const clampNote = wasClamped ? ` (clamped to ${clampedDelaySeconds}s from your requested value)` : "";

package/dist/tools/task-list.js

@@ -326,22 +326,41 @@ export function createTaskListTools(store) {
                         t.metadata[k] = v;
                 }
             }
+            const ignoredDeps = [];
+            let linkedBlocks = false;
+            let linkedBlockedBy = false;
             for (const b of a.addBlocks ?? []) {
-                if (!t.blocks.includes(b))
-                    t.blocks.push(b);
                 const other = b === id ? t : await tx.get(b);
-                if (other && !other.blockedBy.includes(id)) {
+                if (!other) {
+                    if (!ignoredDeps.includes(b))
+                        ignoredDeps.push(b);
+                    continue;
+                }
+                if (!t.blocks.includes(b)) {
+                    t.blocks.push(b);
+                    linkedBlocks = true;
+                }
+                if (!other.blockedBy.includes(id)) {
                     other.blockedBy.push(id);
+                    linkedBlocks = true;
                     if (other !== t)
                         await tx.set(b, other);
                 }
             }
             for (const b of a.addBlockedBy ?? []) {
-                if (!t.blockedBy.includes(b))
-                    t.blockedBy.push(b);
                 const other = b === id ? t : await tx.get(b);
-                if (other && !other.blocks.includes(id)) {
+                if (!other) {
+                    if (!ignoredDeps.includes(b))
+                        ignoredDeps.push(b);
+                    continue;
+                }
+                if (!t.blockedBy.includes(b)) {
+                    t.blockedBy.push(b);
+                    linkedBlockedBy = true;
+                }
+                if (!other.blocks.includes(id)) {
                     other.blocks.push(id);
+                    linkedBlockedBy = true;
                     if (other !== t)
                         await tx.set(b, other);
                 }
@@ -354,10 +373,13 @@ export function createTaskListTools(store) {
                 a.activeForm !== undefined ? "activeForm" : "",
                 a.owner !== undefined ? "owner" : "",
                 a.metadata ? "metadata" : "",
-                a.addBlocks?.length ? "blocks" : "",
-                a.addBlockedBy?.length ? "blockedBy" : "",
+                linkedBlocks ? "blocks" : "",
+                linkedBlockedBy ? "blockedBy" : "",
             ].filter(Boolean);
-            return { content: `Updated task #${id}${changed.length ? ` ${changed.join(", ")}` : ""}`, details: { type: "task", task: snapTask(t) } };
+            const ignoredNote = ignoredDeps.length
+                ? ` (ignored: no such task ${ignoredDeps.map((x) => `#${x}`).join(", ")})`
+                : "";
+            return { content: `Updated task #${id}${changed.length ? ` ${changed.join(", ")}` : ""}${ignoredNote}`, details: { type: "task", task: snapTask(t) } };
         }),
     };
     const taskList = {
@@ -393,12 +415,12 @@ export function createTaskListTools(store) {
             if (all.length === 0) {
                 return { content: "The task list is empty.", details: { type: "task-list", tasks: [] } };
             }
-            const completed = new Set(all.filter((t) => t.status === "completed").map((t) => t.id));
+            const openIds = new Set(all.filter((x) => x.status !== "completed").map((x) => x.id));
             const lines = all.map((t) => {
-                const liveBlockers = t.blockedBy.filter((b) => !completed.has(b));
+                const liveBlockers = t.blockedBy.filter((b) => openIds.has(b));
                 return `#${t.id} [${t.status}] ${t.subject}${t.owner ? ` (owner: ${t.owner})` : ""}${liveBlockers.length ? ` (blocked by: ${liveBlockers.join(", ")})` : ""}`;
             });
-            const open = all.filter((t) => t.status !== "completed").length;
+            const open = openIds.size;
             return {
                 content: `${lines.join("\n")}\n(${all.length} total, ${open} open)`,
                 details: { type: "task-list", tasks: all.map(snapTask) },

package/dist/tools/web.d.ts

@@ -1,4 +1,4 @@
-import type { AgentTool } from "../internal/harness.js";
+import type { AgentTool } from "../internal/harness-types.js";
 import type { Brain, ToolSpec } from "../core/types.js";
 import type { Model } from "../internal/llm.js";
 export interface WebFetchConfig {
@@ -14,7 +14,7 @@ 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 makeWebFetchSummarizer(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>;
 export interface WebSearchConfig {
     search: (query: string, signal?: AbortSignal, opts?: {
         allowedDomains?: string[];
@@ -25,5 +25,7 @@ export interface WebSearchConfig {
         snippet: string;
     }>>;
     maxResults?: number;
+    timeoutMs?: number;
 }
+export declare function clipCodePoints(s: string, max: number): string;
 export declare function createWebSearchTool(config: WebSearchConfig): ToolSpec;

package/dist/tools/web.js

@@ -1,6 +1,7 @@
 import { Type } from "typebox";
-import { defineTool } from "../core/tools.js";
+import { defineTool, errorResult } from "../core/tools.js";
 import { delimitUntrusted, inlineUntrusted } from "../core/untrusted-text.js";
+import { redactSecrets } from "../core/untrusted-egress.js";
 import { isPrivateHost } from "../core/runner/image.js";
 const MAX_REDIRECTS = 10;
 const MAX_URL_LENGTH = 2048;
@@ -229,10 +230,7 @@ export function webFetchToolSpec(config = {}) {
             const { url, prompt } = args;
             const startedAt = Date.now();
             let urlForDetails = url.length > MAX_URL_LENGTH ? url.slice(0, MAX_URL_LENGTH) : url;
-            const failure = (message, extra = {}) => ({
-                content: message,
-                details: { type: "web-fetch", url: urlForDetails, bytes: 0, durationMs: Date.now() - startedAt, ...extra },
-            });
+            const failure = (message, extra = {}) => errorResult(message, { type: "web-fetch", url: urlForDetails, bytes: 0, durationMs: Date.now() - startedAt, ...extra });
             if (url.length > MAX_URL_LENGTH) {
                 return failure(`Error (WebFetch): URL is ${url.length} characters — the limit is ${MAX_URL_LENGTH}.`);
             }
@@ -381,6 +379,7 @@ export function webFetchToolSpec(config = {}) {
                     return {
                         content: `Error (WebFetch): the request was interrupted (aborted) before completion${finalResponse ? " while reading the response body" : ""}. No content was retrieved.`,
                         details: { ...errDetails, aborted: true },
+                        isError: true,
                     };
                 }
                 if (timedOut) {
@@ -391,11 +390,13 @@ export function webFetchToolSpec(config = {}) {
                                 ? `Error (WebFetch): the server responded (HTTP ${connectedMeta.status}) to a redirect hop, but the request stalled while following the redirect — timed out after ${timeoutMs}ms. The host IS reachable; retry only if the stall was likely transient, or fetch the redirect target directly.`
                                 : `Error (WebFetch): timed out after ${timeoutMs}ms while connecting — the host did not respond or the connection stalled before any response arrived. Do not retry the same URL; continue without it or try a different source.`,
                         details: { ...errDetails, timedOut: true },
+                        isError: true,
                     };
                 }
                 return {
                     content: `Error (WebFetch): request failed: ${e instanceof Error ? e.message : String(e)}`,
                     details: errDetails,
+                    isError: true,
                 };
             }
             finally {
@@ -447,6 +448,7 @@ export function webFetchToolSpec(config = {}) {
                         durationMs: Date.now() - startedAt,
                         ...transferStateDetails,
                     },
+                    isError: true,
                 };
             }
             if (bodyBytes) {
@@ -474,6 +476,7 @@ export function webFetchToolSpec(config = {}) {
                             durationMs: Date.now() - startedAt,
                             ...transferStateDetails,
                         },
+                        isError: true,
                     };
                 }
             }
@@ -547,7 +550,7 @@ export const WEBFETCH_SUMMARY_GUIDELINES = `Provide a concise response based onl
     ` - Use quotation marks for exact language from articles; any language outside of the quotation should never be word-for-word the same.\n` +
     ` - You are not a lawyer and never comment on the legality of your own prompts and responses.\n` +
     ` - Never produce or reproduce exact song lyrics.\n`;
-export function makeWebFetchSummarizer(brain, model) {
+export function createWebFetchSummarizer(brain, model) {
     return async (content, prompt, signal) => {
         const truncated = content.length > WEBFETCH_SUMMARY_MAX_CONTENT
             ? content.slice(0, WEBFETCH_SUMMARY_MAX_CONTENT) + "\n\n[Content truncated due to length...]"
@@ -571,20 +574,36 @@ export function makeWebFetchSummarizer(brain, model) {
         return text;
     };
 }
+const DEFAULT_SEARCH_TIMEOUT_MS = 30_000;
+const SEARCH_ERROR_EXCERPT_CHARS = 2048;
+const SEARCH_TITLE_MAX_CHARS = 300;
+const SEARCH_SNIPPET_MAX_CHARS = 1_000;
+const SEARCH_BODY_MAX_CHARS = 100_000;
+export function clipCodePoints(s, max) {
+    const cps = [...s];
+    return cps.length > max ? cps.slice(0, max).join("") + "…" : s;
+}
 function hostMatchesDomain(host, domain) {
-    const d = domain.toLowerCase().replace(/^\*\./, "").replace(/^\.+|\.+$/g, "");
-    if (!d)
+    const norm = (s) => s.toLowerCase().replace(/^\*\./, "").replace(/^\.+|\.+$/g, "");
+    const h = norm(host);
+    const d = norm(domain);
+    if (!d || !h)
         return false;
-    return host === d || host.endsWith("." + d);
+    return h === d || h.endsWith("." + d);
 }
 function webSearchResultAllowed(url, allowed, blocked) {
     let host;
     try {
-        host = new URL(url).hostname.toLowerCase();
+        const u = new URL(url);
+        if (u.protocol !== "http:" && u.protocol !== "https:")
+            return false;
+        host = u.hostname.toLowerCase();
     }
     catch {
-        return !(allowed && allowed.length);
+        return false;
     }
+    if (!host)
+        return false;
     if (blocked && blocked.some((d) => hostMatchesDomain(host, d)))
         return false;
     if (allowed && allowed.length && !allowed.some((d) => hostMatchesDomain(host, d)))
@@ -612,27 +631,94 @@ export function createWebSearchTool(config) {
         effect: "read",
         execute: async (args, ctx) => {
             const { query, allowed_domains, blocked_domains } = args;
+            const startedAt = Date.now();
+            const failCard = (extra = {}) => ({
+                type: "web-search",
+                query,
+                results: [],
+                durationSeconds: (Date.now() - startedAt) / 1000,
+                searchCount: 0,
+                ...extra,
+            });
             if (allowed_domains?.length && blocked_domains?.length) {
-                return "Error: Cannot specify both allowed_domains and blocked_domains in the same request";
+                return errorResult("Error: Cannot specify both allowed_domains and blocked_domains in the same request", failCard());
             }
-            const startedAt = Date.now();
+            const timeoutMs = config.timeoutMs ?? DEFAULT_SEARCH_TIMEOUT_MS;
+            const ac = new AbortController();
+            const timer = setTimeout(() => ac.abort(), timeoutMs);
+            const onOuterAbort = () => ac.abort();
+            if (ctx.signal?.aborted)
+                ac.abort();
+            else
+                ctx.signal?.addEventListener("abort", onOuterAbort, { once: true });
+            const TIMED_OUT = Symbol("websearch-timeout");
+            const abortedFrame = () => errorResult("Error (WebSearch): the search was interrupted (aborted) before completion. No results were retrieved.", failCard({ aborted: true }));
+            const timedOutFrame = () => errorResult(`Error (WebSearch): the search backend did not respond within ${timeoutMs}ms. The tool stopped waiting; the backend may still be executing the request.`, failCard({ timedOut: true }));
             let results;
             try {
-                results = await config.search(query, ctx.signal, { allowedDomains: allowed_domains, blockedDomains: blocked_domains });
+                const work = Promise.resolve(config.search(query, ac.signal, { allowedDomains: allowed_domains, blockedDomains: blocked_domains }));
+                work.catch(() => { });
+                let fireDeadline;
+                const deadline = new Promise((res) => {
+                    fireDeadline = () => res(TIMED_OUT);
+                });
+                const deadlineTimer = setTimeout(() => fireDeadline(), timeoutMs);
+                deadlineTimer.unref?.();
+                try {
+                    const raced = await Promise.race([work, deadline]);
+                    if (raced === TIMED_OUT) {
+                        return ctx.signal?.aborted ? abortedFrame() : timedOutFrame();
+                    }
+                    results = raced;
+                }
+                finally {
+                    clearTimeout(deadlineTimer);
+                }
             }
             catch (e) {
-                return `Error (WebSearch): ${e instanceof Error ? e.message : String(e)}`;
+                if (ctx.signal?.aborted)
+                    return abortedFrame();
+                if (ac.signal.aborted)
+                    return timedOutFrame();
+                const msg = redactSecrets(e instanceof Error ? e.message : String(e)).trim();
+                const headline = "Error (WebSearch): the search backend failed.";
+                return errorResult(msg
+                    ? `${headline} The backend's error text follows:\n\n${delimitUntrusted("WebSearch backend error", msg, SEARCH_ERROR_EXCERPT_CHARS)}`
+                    : headline, failCard());
             }
-            results = results.filter((r) => webSearchResultAllowed(r.url, allowed_domains, blocked_domains)).slice(0, max);
-            const body = results.map((r, i) => `${i + 1}. ${r.title}\n   ${r.url}\n   ${r.snippet}`).join("\n");
-            const fenced = delimitUntrusted(`WebSearch ${JSON.stringify(query)}`, body || "(no results)");
-            const modelText = `${fenced}\n\nREMINDER: You MUST include the sources above in your response to the user using markdown hyperlinks.`;
+            finally {
+                clearTimeout(timer);
+                ctx.signal?.removeEventListener("abort", onOuterAbort);
+            }
+            const usable = results.filter((r) => webSearchResultAllowed(r.url));
+            const droppedUnusable = results.length - usable.length;
+            results = usable.filter((r) => webSearchResultAllowed(r.url, allowed_domains, blocked_domains)).slice(0, max);
+            let clipped = false;
+            const shown = results.map((r) => {
+                const title = clipCodePoints(r.title, SEARCH_TITLE_MAX_CHARS);
+                const url = clipCodePoints(r.url, MAX_URL_LENGTH);
+                const snippet = clipCodePoints(r.snippet, SEARCH_SNIPPET_MAX_CHARS);
+                if (title !== r.title || url !== r.url || snippet !== r.snippet)
+                    clipped = true;
+                return { title, url, snippet };
+            });
+            const body = shown.map((r, i) => `${i + 1}. ${r.title}\n   ${r.url}\n   ${r.snippet}`).join("\n");
+            if (body.length > SEARCH_BODY_MAX_CHARS)
+                clipped = true;
+            const fenced = delimitUntrusted(`WebSearch ${JSON.stringify(query)}`, body || "(no results)", SEARCH_BODY_MAX_CHARS);
+            const dropNote = droppedUnusable > 0
+                ? `\n\n[WebSearch: ${droppedUnusable} result(s) returned by the backend were dropped — their URL was not a usable http(s) link]`
+                : "";
+            const clipNote = clipped
+                ? "\n\n[WebSearch: one or more result fields exceeded the display limits and were truncated — treat the text above as an excerpt, not the backend's full result.]"
+                : "";
+            const modelText = `${fenced}${dropNote}${clipNote}\n\nREMINDER: You MUST include the sources above in your response to the user using markdown hyperlinks.`;
             return {
                 content: modelText,
                 details: {
                     type: "web-search",
                     query,
-                    results: [{ tool_use_id: ctx.toolCallId, content: results.map((r) => ({ title: r.title, url: r.url })) }],
+                    results: [{ tool_use_id: ctx.toolCallId, content: shown.map((r) => ({ title: r.title, url: r.url })) }],
                     durationSeconds: (Date.now() - startedAt) / 1000,
                     searchCount: 1,
                 },

package/dist/tools/worktree.d.ts

@@ -1,4 +1,4 @@
-import type { AgentTool, ExecutionEnv } from "../internal/harness.js";
+import type { AgentTool, ExecutionEnv } from "../internal/harness-types.js";
 import type { CwdRef } from "./fs/index.js";
 export interface ActiveWorktreeSession {
     worktreeDir: string;

package/dist/tools/worktree.js

@@ -1,6 +1,6 @@
 import { resolve } from "node:path";
 import { Type } from "typebox";
-import { defineTool } from "../core/tools.js";
+import { defineTool, errorResult } from "../core/tools.js";
 import { addWorktree, pruneWorktrees, WORKTREE_PARENT } from "../core/git-worktree-env.js";
 const ENTER_DESCRIPTION = "Use this tool ONLY when explicitly instructed to work in a worktree — either by the user directly, or by " +
     "project instructions. This tool creates an isolated git worktree and switches the current session into it.\n" +
@@ -113,20 +113,20 @@ export function createWorktreeTools(env, opts) {
         execute: async (args) => {
             const { name, path, baseRef } = args;
             if (path !== undefined && name !== undefined) {
-                return "Error (EnterWorktree): `name` and `path` are mutually exclusive — `path` enters an existing worktree, `name` creates a new one.";
+                return errorResult("Error (EnterWorktree): `name` and `path` are mutually exclusive — `path` enters an existing worktree, `name` creates a new one.");
             }
             if (path !== undefined && baseRef !== undefined) {
-                return "Error (EnterWorktree): `baseRef` only applies when creating a new worktree — an existing worktree entered via `path` keeps whatever state it has.";
+                return errorResult("Error (EnterWorktree): `baseRef` only applies when creating a new worktree — an existing worktree entered via `path` keeps whatever state it has.");
             }
             if (session.current && path === undefined) {
-                return (`Error (EnterWorktree): already in a worktree session (${session.current.worktreeDir}). ` +
+                return errorResult(`Error (EnterWorktree): already in a worktree session (${session.current.worktreeDir}). ` +
                     "Use ExitWorktree to leave it before creating a new worktree, or pass `path` to switch into an " +
                     "existing worktree of this repository.");
             }
             const probe = await env.exec("git rev-parse --is-inside-work-tree", { cwd: repoRoot });
             if (!probe.ok || probe.value.exitCode !== 0) {
                 const detail = probe.ok ? (probe.value.stderr || probe.value.stdout).trim().split("\n")[0] : String(probe.error);
-                return (`Error (EnterWorktree): the working directory ${repoRoot} is not a git repository` +
+                return errorResult(`Error (EnterWorktree): the working directory ${repoRoot} is not a git repository` +
                     `${detail ? ` (${detail})` : ""}. This deployment has no VCS-agnostic worktree extension point, ` +
                     "so worktree isolation is unavailable here.");
             }
@@ -134,31 +134,31 @@ export function createWorktreeTools(env, opts) {
                 const candidate = resolve(cwdRef.current, path);
                 const top = await env.exec("git rev-parse --show-toplevel", { cwd: candidate });
                 if (!top.ok || top.value.exitCode !== 0) {
-                    return `Error (EnterWorktree): ${candidate} is not an accessible git worktree (cannot resolve its top-level directory).`;
+                    return errorResult(`Error (EnterWorktree): ${candidate} is not an accessible git worktree (cannot resolve its top-level directory).`);
                 }
                 const target = top.value.stdout.trim();
                 const list = await env.exec("git worktree list --porcelain", { cwd: repoRoot });
                 if (!list.ok || list.value.exitCode !== 0) {
-                    return "Error (EnterWorktree): could not read `git worktree list` for this repository.";
+                    return errorResult("Error (EnterWorktree): could not read `git worktree list` for this repository.");
                 }
                 const registered = list.value.stdout
                     .split("\n")
                     .filter((l) => l.startsWith("worktree "))
                     .map((l) => l.slice("worktree ".length).trim());
                 if (!registered.includes(target)) {
-                    return (`Error (EnterWorktree): ${target} is not a registered worktree of this repository ` +
+                    return errorResult(`Error (EnterWorktree): ${target} is not a registered worktree of this repository ` +
                         "(it does not appear in `git worktree list`).");
                 }
                 if (target === registered[0]) {
-                    return `Error (EnterWorktree): ${target} is the main working tree, not a linked worktree — nothing to enter.`;
+                    return errorResult(`Error (EnterWorktree): ${target} is the main working tree, not a linked worktree — nothing to enter.`);
                 }
                 if (target !== repoRoot && !target.startsWith(repoRoot.endsWith("/") ? repoRoot : `${repoRoot}/`)) {
-                    return (`Error (EnterWorktree): the worktree ${target} lives outside the task root ${repoRoot}; ` +
+                    return errorResult(`Error (EnterWorktree): the worktree ${target} lives outside the task root ${repoRoot}; ` +
                         "file containment stays anchored at the task root, so it cannot be entered from this session.");
                 }
                 const head = await env.exec("git rev-parse HEAD", { cwd: target });
                 if (!head.ok || head.value.exitCode !== 0) {
-                    return `Error (EnterWorktree): cannot resolve HEAD of the worktree ${target}.`;
+                    return errorResult(`Error (EnterWorktree): cannot resolve HEAD of the worktree ${target}.`);
                 }
                 const previous = session.current;
                 const originalCwd = previous ? previous.originalCwd : cwdRef.current;
@@ -172,7 +172,7 @@ export function createWorktreeTools(env, opts) {
             }
             const base = await resolveBaseCommit(env, repoRoot, baseRef ?? "fresh");
             if ("error" in base)
-                return `Error (EnterWorktree): ${base.error}.`;
+                return errorResult(`Error (EnterWorktree): ${base.error}.`);
             let createdDir;
             try {
                 const { worktreeDir } = await addWorktree(env, {
@@ -187,7 +187,7 @@ export function createWorktreeTools(env, opts) {
                 createdDir = worktreeDir;
             }
             catch (e) {
-                return `Error (EnterWorktree): ${e instanceof Error ? e.message : String(e)}`;
+                return errorResult(`Error (EnterWorktree): ${e instanceof Error ? e.message : String(e)}`);
             }
             session.current = {
                 worktreeDir: createdDir,
@@ -227,7 +227,7 @@ export function createWorktreeTools(env, opts) {
             const discardChanges = raw.discardChanges ?? raw.discard_changes;
             const wantsRemove = raw.action === "remove";
             if (keep === true && discardChanges === true) {
-                return "Error (ExitWorktree): `keep: true` and `discardChanges: true` contradict each other — pick one.";
+                return errorResult("Error (ExitWorktree): `keep: true` and `discardChanges: true` contradict each other — pick one.");
             }
             if (!session.current) {
                 return ("No-op: there is no active EnterWorktree session to exit. This tool only operates on the " +

package/package.json

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

package/dist/core/dynamic-recall.d.ts

@@ -1,32 +0,0 @@
-import type { AgentMessage } from "../internal/harness.js";
-import { type MemorySelector, encodeSurfacedKey } from "./memory-recall.js";
-import type { MemoryStore } from "./memory.js";
-export interface DynamicRecallConfig {
-    enabled?: boolean;
-    recentMessageWindow?: number;
-    maxQueryChars?: number;
-}
-export declare const DEFAULT_RECENT_MESSAGE_WINDOW = 6;
-export declare const DEFAULT_MAX_QUERY_CHARS = 4000;
-export declare function buildRecallQuery(messages: readonly AgentMessage[], window?: number, maxChars?: number): string;
-export interface DynamicRecallOutcome {
-    block: string | undefined;
-    surfacedIds: readonly string[];
-    surfacedKeys: readonly string[];
-}
-export interface DynamicRecallInput {
-    store: MemoryStore;
-    scopes: readonly string[];
-    selector: MemorySelector;
-    query: string;
-    recentTools?: string[];
-    maxSelected?: number;
-    maxLinked?: number;
-    timeoutMs?: number;
-    signal?: AbortSignal;
-    nowMs?: number;
-    priorSurfacedIds?: ReadonlySet<string>;
-    priorSurfacedKeys?: ReadonlySet<string>;
-}
-export declare function runDynamicRecall(input: DynamicRecallInput): Promise<DynamicRecallOutcome>;
-export { encodeSurfacedKey };

package/dist/core/dynamic-recall.js

@@ -1,76 +0,0 @@
-import { encodeSurfacedKey, selectAndComposeLayeredMemory, selectAndComposeMemory, } from "./memory-recall.js";
-export const DEFAULT_RECENT_MESSAGE_WINDOW = 6;
-export const DEFAULT_MAX_QUERY_CHARS = 4_000;
-export function buildRecallQuery(messages, window = DEFAULT_RECENT_MESSAGE_WINDOW, maxChars = DEFAULT_MAX_QUERY_CHARS) {
-    if (window <= 0 || maxChars <= 0)
-        return "";
-    const recent = messages.slice(-window);
-    const parts = [];
-    for (const m of recent) {
-        const text = messageText(m);
-        if (text)
-            parts.push(text);
-    }
-    const joined = parts.join("\n").trim();
-    if (joined.length <= maxChars)
-        return joined;
-    return joined.slice(joined.length - maxChars);
-}
-function messageText(m) {
-    const content = m.content;
-    if (typeof content === "string")
-        return content.trim();
-    if (Array.isArray(content)) {
-        const out = [];
-        for (const c of content) {
-            if (typeof c.text === "string" && c.text.length > 0)
-                out.push(c.text);
-        }
-        return out.join(" ").trim();
-    }
-    return "";
-}
-const EMPTY_OUTCOME = { block: undefined, surfacedIds: [], surfacedKeys: [] };
-export async function runDynamicRecall(input) {
-    if (input.scopes.length === 0 || input.query.trim().length === 0)
-        return EMPTY_OUTCOME;
-    if (input.scopes.length === 1) {
-        const res = await selectAndComposeMemory({
-            store: input.store,
-            scope: input.scopes[0],
-            objective: input.query,
-            selector: input.selector,
-            recentTools: input.recentTools,
-            maxSelected: input.maxSelected,
-            maxLinked: input.maxLinked,
-            timeoutMs: input.timeoutMs,
-            signal: input.signal,
-            nowMs: input.nowMs,
-            priorSurfacedIds: input.priorSurfacedIds,
-        });
-        if ("degrade" in res)
-            return EMPTY_OUTCOME;
-        if (res.block === undefined || res.surfacedIds.length === 0)
-            return EMPTY_OUTCOME;
-        return { block: res.block, surfacedIds: res.surfacedIds, surfacedKeys: [] };
-    }
-    const res = await selectAndComposeLayeredMemory({
-        store: input.store,
-        scopes: [...input.scopes],
-        objective: input.query,
-        selector: input.selector,
-        recentTools: input.recentTools,
-        maxSelected: input.maxSelected,
-        maxLinked: input.maxLinked,
-        timeoutMs: input.timeoutMs,
-        signal: input.signal,
-        nowMs: input.nowMs,
-        priorSurfacedKeys: input.priorSurfacedKeys,
-    });
-    if ("degrade" in res)
-        return EMPTY_OUTCOME;
-    if (res.block === undefined || res.surfacedKeys.length === 0)
-        return EMPTY_OUTCOME;
-    return { block: res.block, surfacedIds: [], surfacedKeys: res.surfacedKeys };
-}
-export { encodeSurfacedKey };