@sema-agent/core 1.451.0 → 1.452.0

package/dist/core/lsp-session.js

@@ -1,4 +1,5 @@
 import { uriToPath, buildRequest, callHierarchyMethod, parseResult, pathToUri } from "./lsp-protocol.js";
+import { lspFailureOf } from "./lsp.js";
 export class TransportLspSession {
     transport;
     languageId;
@@ -37,7 +38,7 @@ export class TransportLspSession {
     async request(op, params, signal) {
         const built = buildRequest(op, params);
         if (!built)
-            return { kind: "none" };
+            return { kind: "none", reason: "unsupported_operation" };
         await this.syncOpenedFiles(params.filePath, signal);
         if (!this.warmupBarrierDone && this.warmup.windowMs > 0) {
             this.warmupBarrierDone = true;
@@ -49,18 +50,23 @@ export class TransportLspSession {
         }
         for (let attempt = 0;; attempt++) {
             let raw;
+            let noHierarchyItem = false;
             try {
                 raw = await this.transport.request(built.method, built.params, signal);
                 if (op === "incomingCalls" || op === "outgoingCalls") {
                     const items = Array.isArray(raw) ? raw : raw != null ? [raw] : [];
-                    raw = items.length === 0 ? null : await this.transport.request(callHierarchyMethod(op), { item: items[0] }, signal);
+                    noHierarchyItem = items.length === 0;
+                    raw = noHierarchyItem ? null : await this.transport.request(callHierarchyMethod(op), { item: items[0] }, signal);
                 }
             }
             catch (e) {
-                this.log("lsp_op_degraded", { op, file: params.filePath, err: e instanceof Error ? e.message : String(e) });
-                return { kind: "none" };
+                const f = lspFailureOf(e) ?? TransportLspSession.classifyUnbranded(signal, this.transport);
+                this.log("lsp_op_degraded", { op, file: params.filePath, reason: f.reason, err: e instanceof Error ? e.message : String(e) });
+                return { kind: "none", reason: f.reason, ...(f.detail !== undefined ? { detail: f.detail } : {}) };
             }
-            const result = parseResult(op, raw);
+            const result = noHierarchyItem
+                ? { kind: "none", reason: "no_call_hierarchy_item" }
+                : parseResult(op, raw);
             if (result.kind === "none" && this.warmup.windowMs > 0 && Date.now() - this.createdAt < this.warmup.windowMs && !signal?.aborted) {
                 await new Promise((r) => setTimeout(r, this.warmup.retryMs));
                 continue;
@@ -92,7 +98,12 @@ export class TransportLspSession {
             try {
                 text = await this.readText(filePath, signal);
             }
-            catch {
+            catch (e) {
+                this.log("lsp_sync_skipped", {
+                    file: filePath,
+                    error: e instanceof Error ? e.message : String(e),
+                    opened: this.opened.has(filePath),
+                });
                 return;
             }
             const cur = this.opened.get(filePath);
@@ -115,6 +126,13 @@ export class TransportLspSession {
         this.syncing.set(filePath, job);
         return job.finally(() => this.syncing.delete(filePath));
     }
+    static classifyUnbranded(signal, transport) {
+        if (signal?.aborted)
+            return { reason: "cancelled" };
+        if (transport.closed === true)
+            return { reason: "server_terminated" };
+        return { reason: "server_error" };
+    }
     get closed() {
         return this.transport.closed === true;
     }

package/dist/core/lsp.d.ts

@@ -14,6 +14,7 @@ export interface LspSymbolInfo {
     line: number;
     character: number;
 }
+export type LspNoneReason = "unsupported_operation" | "server_error" | "timeout" | "cancelled" | "server_terminated" | "no_call_hierarchy_item";
 export type LspResult = {
     kind: "locations";
     locations: LspLocation[];
@@ -25,7 +26,15 @@ export type LspResult = {
     contents: string;
 } | {
     kind: "none";
+    reason?: LspNoneReason;
+    detail?: string;
 };
+export declare const LSP_FAILURE_BRAND = "lspFailureReason";
+export declare function brandLspFailure<E extends Error>(e: E, reason: LspNoneReason, detail?: string): E;
+export declare function lspFailureOf(e: unknown): {
+    reason: LspNoneReason;
+    detail?: string;
+} | undefined;
 export interface LspRequestParams {
     filePath: string;
     line?: number;
@@ -43,6 +52,7 @@ export interface LspTransport {
     readonly closed?: boolean;
 }
 export type LspReadText = (filePath: string, signal?: AbortSignal) => Promise<string>;
+export declare const MAX_LSP_FILE_BYTES: number;
 export interface LspServerManager {
     sessionFor(filePath: string, signal?: AbortSignal, env?: ExecutionEnv): Promise<LspSession | undefined>;
     readonly diagnostics?: import("./lsp-diagnostics.js").LspDiagnosticsRegistry;

package/dist/core/lsp.js

@@ -1,11 +1,30 @@
 import { uriToPath } from "./lsp-protocol.js";
 import { Type } from "typebox";
-import { defineTool } from "./tools.js";
+import { defineTool, errorResult } from "./tools.js";
 export const LSP_OPERATIONS = [
     "goToDefinition", "findReferences", "hover", "documentSymbol", "workspaceSymbol",
     "goToImplementation", "prepareCallHierarchy", "incomingCalls", "outgoingCalls",
 ];
-function fmt(result) {
+export const LSP_FAILURE_BRAND = "lspFailureReason";
+const LSP_NONE_REASONS = new Set([
+    "unsupported_operation", "server_error", "timeout", "cancelled", "server_terminated", "no_call_hierarchy_item",
+]);
+export function brandLspFailure(e, reason, detail) {
+    const carrier = e;
+    carrier[LSP_FAILURE_BRAND] = reason;
+    if (detail !== undefined)
+        carrier.lspFailureDetail = detail;
+    return e;
+}
+export function lspFailureOf(e) {
+    const r = e?.[LSP_FAILURE_BRAND];
+    if (typeof r !== "string" || !LSP_NONE_REASONS.has(r))
+        return undefined;
+    const d = e.lspFailureDetail;
+    return { reason: r, ...(typeof d === "string" ? { detail: d } : {}) };
+}
+export const MAX_LSP_FILE_BYTES = 10 * 1000 * 1000;
+function fmt(result, ctx) {
     switch (result.kind) {
         case "hover":
             return result.contents.trim() || "(no hover information)";
@@ -20,9 +39,30 @@ function fmt(result) {
                 : `Found ${result.symbols.length} symbol(s):\n` +
                     result.symbols.map((s) => `- ${s.name}${s.kind ? ` (${s.kind})` : ""} — ${s.uri}:${s.line}:${s.character}`).join("\n");
         case "none":
+            return fmtNone(result, ctx);
+    }
+}
+function fmtNone(result, ctx) {
+    const { operation, filePath } = ctx;
+    const detail = result.detail;
+    switch (result.reason) {
+        case undefined:
             return "No results.";
+        case "no_call_hierarchy_item":
+            return "No call hierarchy item found at this position";
+        case "unsupported_operation":
+            return `The language server for "${filePath}" does not support ${operation}${detail ? ` (${detail})` : ""}. Fall back to Grep/Read for this lookup.`;
+        case "timeout":
+            return `Error performing ${operation}: the language server did not respond in time. This is NOT an empty result — do not conclude the symbol has no ${operation === "findReferences" ? "references" : "results"}; retry or fall back to Grep/Read.`;
+        case "server_terminated":
+            return `Error performing ${operation}: the language server exited before answering. This is NOT an empty result — retry (a fresh server is spawned on the next call) or fall back to Grep/Read.`;
+        case "cancelled":
+            return `Error performing ${operation}: the request was cancelled before the language server answered. This is NOT an empty result.`;
+        case "server_error":
+            return `Error performing ${operation}: ${detail ?? "the language server returned an error"}. This is NOT an empty result — fall back to Grep/Read.`;
     }
 }
+const LSP_ERROR_REASONS = new Set(["server_error", "timeout", "cancelled", "server_terminated"]);
 async function filterIgnored(result, isIgnored) {
     if (!isIgnored)
         return result;
@@ -80,14 +120,29 @@ export function createLspTool(manager, opts = {}) {
         execute: async (args, ctx) => {
             const { operation, filePath, line, character, query, symbol } = args;
             if (POSITION_OPS.has(operation) && (line === undefined || character === undefined)) {
-                return `Error (LSP): the "${operation}" operation needs both line and character.`;
+                return errorResult(`Error (LSP): the "${operation}" operation needs both line and character.`);
             }
             if (POSITION_OPS.has(operation) && (!Number.isInteger(line) || line < 1 || !Number.isInteger(character) || character < 1)) {
-                return `Error (LSP): line and character are 1-based integers (as shown in editors); got line=${line}, character=${character}.`;
+                return errorResult(`Error (LSP): line and character are 1-based integers (as shown in editors); got line=${line}, character=${character}.`);
             }
             const wsQuery = query ?? symbol;
             if (operation === "workspaceSymbol" && wsQuery === undefined) {
-                return `Error (LSP): the "workspaceSymbol" operation needs a query.`;
+                return errorResult(`Error (LSP): the "workspaceSymbol" operation needs a query.`);
+            }
+            if (opts.env) {
+                const isAbsForm = filePath.startsWith("/") || /^[A-Za-z]:[\\/]/.test(filePath);
+                const cwd = opts.env.cwd;
+                const probe = isAbsForm || !cwd ? filePath : cwd.replace(/[\\/]+$/, "") + (cwd.includes("\\") ? "\\" : "/") + filePath;
+                const info = await opts.env.fileInfo(probe, ctx.signal);
+                if (!info.ok && info.error.code === "not_found")
+                    return errorResult(`Error (LSP): File does not exist: ${filePath}`);
+                if (!info.ok && info.error.code === "invalid")
+                    return errorResult(`Error (LSP): Path is not a file: ${filePath}`);
+                if (info.ok && info.value.kind === "directory")
+                    return errorResult(`Error (LSP): Path is not a file: ${filePath}`);
+                if (info.ok && info.value.kind === "file" && info.value.size > MAX_LSP_FILE_BYTES) {
+                    return `File too large for LSP analysis (${Math.ceil(info.value.size / 1e6)}MB exceeds 10MB limit)`;
+                }
             }
             const session = await manager.sessionFor(filePath, ctx.signal, opts.env);
             if (!session) {
@@ -95,7 +150,9 @@ export function createLspTool(manager, opts = {}) {
             }
             const seamCharacter = character !== undefined ? character - 1 : undefined;
             const result = await session.request(operation, { filePath, line, character: seamCharacter, symbol: wsQuery }, ctx.signal);
-            return fmt(toModelBase(await filterIgnored(result, opts.isPathIgnored)));
+            const final = toModelBase(await filterIgnored(result, opts.isPathIgnored));
+            const text = fmt(final, { operation, filePath });
+            return final.kind === "none" && final.reason !== undefined && LSP_ERROR_REASONS.has(final.reason) ? errorResult(text) : text;
         },
     });
 }

package/dist/core/mailbox-store.d.ts

@@ -15,7 +15,7 @@ export interface MailboxStore {
         sentAt: number;
     }): Promise<number>;
     claimLease(scope: string, handle: string, owner: string, ttlMs: number, now?: number): Promise<MailboxLease | null>;
-    ack(scope: string, handle: string, upToSeq: number): Promise<void>;
+    ack(scope: string, handle: string, owner: string, upToSeq: number): Promise<void>;
     releaseLease(scope: string, handle: string, owner: string): Promise<void>;
     peekCount(scope: string, handle: string): Promise<number>;
     drop(scope: string, handle: string): Promise<void>;
@@ -23,6 +23,7 @@ export interface MailboxStore {
         maxAgeMs?: number;
     }): Promise<number>;
 }
+export declare function newestSentAt(messages: readonly MailboxMessage[]): number | undefined;
 export declare class InMemoryMailboxStore implements MailboxStore {
     private boxes;
     private key;
@@ -33,7 +34,7 @@ export declare class InMemoryMailboxStore implements MailboxStore {
         sentAt: number;
     }): Promise<number>;
     claimLease(scope: string, handle: string, owner: string, ttlMs: number, now?: number): Promise<MailboxLease | null>;
-    ack(scope: string, handle: string, upToSeq: number): Promise<void>;
+    ack(scope: string, handle: string, owner: string, upToSeq: number): Promise<void>;
     releaseLease(scope: string, handle: string, owner: string): Promise<void>;
     peekCount(scope: string, handle: string): Promise<number>;
     drop(scope: string, handle: string): Promise<void>;

package/dist/core/mailbox-store.js

@@ -1,6 +1,19 @@
+export function newestSentAt(messages) {
+    let newest;
+    for (const m of messages) {
+        if (!Number.isFinite(m.sentAt))
+            return undefined;
+        if (newest === undefined || m.sentAt > newest)
+            newest = m.sentAt;
+    }
+    return newest;
+}
 export class InMemoryMailboxStore {
     boxes = new Map();
     key(scope, handle) {
+        if (handle.includes("\u0000")) {
+            throw new Error(`MailboxStore: unsafe handle ${JSON.stringify(handle)} — a NUL byte makes the composite key ambiguous`);
+        }
         return `${scope}\u0000${handle.toLowerCase()}`;
     }
     box(scope, handle) {
@@ -30,12 +43,14 @@ export class InMemoryMailboxStore {
         b.lease = { owner, expiresAt: now + ttlMs, maxSeq };
         return { messages: b.messages.map((m) => ({ ...m })), maxSeq };
     }
-    async ack(scope, handle, upToSeq) {
+    async ack(scope, handle, owner, upToSeq) {
         const b = this.boxes.get(this.key(scope, handle));
         if (!b)
             return;
+        if (b.lease === undefined || b.lease.owner !== owner)
+            return;
         b.messages = b.messages.filter((m) => m.seq > upToSeq);
-        if (b.lease !== undefined && b.lease.maxSeq <= upToSeq)
+        if (b.lease.maxSeq <= upToSeq)
             b.lease = undefined;
     }
     async releaseLease(scope, handle, owner) {
@@ -56,8 +71,8 @@ export class InMemoryMailboxStore {
         for (const b of this.boxes.values()) {
             if (b.scope !== scope)
                 continue;
-            const newest = b.messages[b.messages.length - 1];
-            if (newest !== undefined && newest.sentAt < now - opts.maxAgeMs) {
+            const newest = newestSentAt(b.messages);
+            if (newest !== undefined && newest < now - opts.maxAgeMs) {
                 b.messages = [];
                 b.lease = undefined;
                 dropped++;

package/dist/core/memory.js

@@ -486,7 +486,7 @@ export function createRememberTool(store, scope, onRemembered) {
             const a = args;
             const note = String(a.note ?? "").trim();
             if (!note) {
-                return { content: "Nothing remembered (empty note).", details: { ok: false } };
+                return { content: "Nothing remembered (empty note).", details: { ok: false }, isError: true };
             }
             const oneLine = (v, cap) => {
                 if (typeof v !== "string")

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

@@ -999,9 +999,12 @@ export async function prepareTask(spec, deps, sessions, resume, _memorySelector,
                     const results = await mcp.refresh(typeof serverArg === "string" && serverArg.length > 0 ? serverArg : undefined);
                     const lines = [];
                     let changed = false;
+                    let anyActiveFailure = false;
                     for (const r of results) {
                         if (r.status !== "refreshed" || r.tools === undefined) {
                             lines.push(`${r.server}: ${r.status}${r.error !== undefined ? ` (${r.error})` : ""}`);
+                            if (r.status === "failed")
+                                anyActiveFailure = true;
                             continue;
                         }
                         const excludedSet = new Set(toolFaceSnapshot.exclude ?? []);
@@ -1012,6 +1015,7 @@ export async function prepareTask(spec, deps, sessions, resume, _memorySelector,
                         }
                         catch (foldErr) {
                             lines.push(`${r.server}: failed (${foldErr instanceof Error ? foldErr.message : String(foldErr)})`);
+                            anyActiveFailure = true;
                             continue;
                         }
                         for (let i = tools.length - 1; i >= 0; i--) {
@@ -1041,7 +1045,12 @@ export async function prepareTask(spec, deps, sessions, resume, _memorySelector,
                         lines.push("WARNING: refreshed tools declare irreversible/egress safety hints, but this task started with no approval gate registered (no policy/hooks and no gated tools at start) — these hints cannot arm a gate mid-task (RB-46); the refreshed tools run ungated on this deployment shape.");
                     }
                     const text = lines.length === 0 ? "No connected MCP servers to refresh." : lines.join("\n");
-                    return { content: [{ type: "text", text }], details: { results }, terminate: false };
+                    return {
+                        content: [{ type: "text", text }],
+                        details: { results },
+                        terminate: false,
+                        ...(anyActiveFailure && !changed ? { isError: true } : {}),
+                    };
                 },
             });
             toolEffects.set("RefreshMcpTools", "read");

package/dist/core/runner/runtask.js

@@ -1243,7 +1243,7 @@ export class Runner {
             return { output: raw, truncated: true, totalChars };
         };
         const CC_DETAIL_TYPES = new Set([
-            "edit", "multiedit", "create", "update", "bash", "notebook-edit", "text", "grep", "glob", "mcp",
+            "edit", "multiedit", "create", "update", "bash", "notebook-edit", "notebook", "text", "grep", "glob", "mcp",
             "agent", "task", "task-list", "task-output", "memory-saved", "workflow-run",
             "web-fetch", "web-search", "todo", "cron-create", "cron-delete", "cron-list", "image",
             "task-stop", "tool-search", "memory-recall", "repo-map", "fork", "enter-plan-mode", "exit-plan-mode",

package/dist/core/session-reconcile.js

@@ -6,6 +6,9 @@ const INTERRUPTED_UNKNOWN = "[INTERRUPTED] The previous run ended before this to
 const INTERRUPTED_SAFE = "[INTERRUPTED] The previous run ended before this tool call's result was recorded. This tool is " +
     "read-only/idempotent, so its outcome carries no risk: simply call it again if you still need " +
     "the result.";
+const INTERRUPTED_IDEMPOTENT = "[INTERRUPTED] The previous run ended before this tool call's result was recorded. The call may or " +
+    "may not have taken effect. It is safe to REPLAY: re-issuing the same call converges the state to " +
+    "what you intended. If you decide not to re-issue it, verify the current state first.";
 const INTERRUPTED_NEVER_STARTED = "[INTERRUPTED] The run was aborted before this tool call started. It was never executed and had " +
     "no side effects — it is safe to re-issue this call if you still need it.";
 export function findOrphanToolCalls(messages, suspendedBatch) {
@@ -50,9 +53,9 @@ export async function reconcileInterruptedSession(session, toolEffects, suspende
     const recovered = [];
     for (const orphan of orphans) {
         const effect = toolEffects?.get(canonicalToolName(orphan.toolName)) ?? "write";
-        const safe = effect === "read" || effect === "idempotent";
+        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 : safe ? INTERRUPTED_SAFE : INTERRUPTED_UNKNOWN;
+        const text = neverStarted ? INTERRUPTED_NEVER_STARTED : effectText;
         const entryId = await session.appendMessage({
             role: "toolResult",
             toolCallId: orphan.toolCallId,

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

@@ -20,6 +20,7 @@ export interface TaskNotificationPayload {
     recentSteps?: import("../agents/subagent-steps.js").SubagentStep[];
     editedFiles?: import("../agents/subagent-steps.js").SubagentEditedFile[];
     resumable?: boolean;
+    completionId?: string;
 }
 export interface ExternalNotificationInput {
     task_id: string;

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

@@ -27,8 +27,14 @@ export interface UnifiedTaskOutput {
     stoppedBy?: StopSource;
     seq?: number;
     partial_result?: boolean;
+    completionId?: string;
     details?: unknown;
 }
+type UnifiedTaskResult = {
+    content: string;
+    details: UnifiedTaskOutput;
+    isError?: boolean;
+};
 export interface SemaTaskHandle {
     id: string;
     type: SemaTaskType;
@@ -41,6 +47,7 @@ export interface SemaTaskHandle {
     updatedAt: number;
     outputFile?: string;
     outputOffset?: number;
+    completionId?: string;
 }
 export interface TaskKind {
     type: SemaTaskType;
@@ -257,6 +264,7 @@ export declare class TaskRegistry {
     markStopSourceByShellId(shellId: string, source: StopSource, env?: unknown): void;
     clearPendingStopSourceByShellId(shellId: string, source: StopSource, env?: unknown): void;
     getStopAttribution(id: string): StopSource | undefined;
+    getCompletionId(id: string): string | undefined;
     parkBackgroundAgent(id: string, park: {
         checkpointToken: string;
         seq?: number;
@@ -323,18 +331,16 @@ export declare class TaskRegistry {
     timeoutResidentShellIds(env: unknown): BackgroundShellId[];
     retainedShellIds(env: unknown): BackgroundShellId[];
     registerMonitor(input: RegisterMonitorInput): string;
+    private absorbMonitorPoll;
+    private emitMonitorEvent;
     private startMonitorWatcher;
     registerWorkflow(input: RegisterWorkflowInput): string;
-    pollTask(id: string, access: TaskAccess, opts?: TaskPollOptions): Promise<{
-        content: string;
-        details: UnifiedTaskOutput;
-    }>;
+    pollTask(id: string, access: TaskAccess, opts?: TaskPollOptions): Promise<UnifiedTaskResult>;
     private serveDurableAgentRow;
-    stopTask(id: string, access: TaskAccess, opts?: TaskStopOptions): Promise<{
-        content: string;
-        details: UnifiedTaskOutput;
-    }>;
-    resolveBackgroundAgentByName(name: string, access: TaskAccess): {
+    stopTask(id: string, access: TaskAccess, opts?: TaskStopOptions): Promise<UnifiedTaskResult>;
+    resolveBackgroundAgentByName(name: string, access: TaskAccess, opts?: {
+        preferRunning?: boolean;
+    }): {
         status: "found";
         handle: BackgroundAgentTaskHandle;
     } | {