@sema-agent/core 2.12.0 → 3.0.0

package/dist/core/tool-policy.js

@@ -1,6 +1,7 @@
 import { homedir } from "node:os";
-import { isAbsolute, join, sep } from "node:path";
+import { isAbsolute, join, normalize as normalizePath, sep } from "node:path";
 import { BASH_READONLY_DEFAULT_ALLOW, parseLeadingCommandName } from "../tools/fs/index.js";
+import { writeTargetPath } from "../tools/fs/safety.js";
 import { canonicalToolName } from "./tool-name-aliases.js";
 export function decisionText(d) {
     return d.message ?? d.reason;
@@ -106,7 +107,7 @@ export function combinePolicies(...policies) {
                     current = { ...current, args: d.updatedInput };
                     rewrite = d;
                 }
-                if (d.action === "ask" && !asked) {
+                if (d.action === "ask" && (asked === undefined || (d.requiresRealApproval === true && asked.requiresRealApproval !== true))) {
                     asked = d;
                 }
             }
@@ -119,10 +120,13 @@ export function combinePolicies(...policies) {
     };
 }
 export const COARSE_SHELL_TOOLS = ["Bash", "Monitor"];
+function canonicalToolNameSet(tools) {
+    return new Set((tools ?? COARSE_SHELL_TOOLS).map(canonicalToolName));
+}
 export function createCoarseCommandNamePolicy(opts) {
     const allow = opts.allow ? new Set(opts.allow) : undefined;
     const deny = new Set(opts.deny ?? []);
-    const shellTools = new Set(opts.tools ?? COARSE_SHELL_TOOLS);
+    const shellTools = canonicalToolNameSet(opts.tools);
     const defaultAction = opts.defaultAction ?? "ask";
     const fallback = (reason) => defaultAction === "deny"
         ? { action: "deny", reason, decisionReason: "rule" }
@@ -154,6 +158,7 @@ const DELETE_HEADS = new Set(["rm", "xargs", "Remove-Item"]);
 const DELETE_WRAPPERS = new Set([
     "sudo", "command", "nohup", "time", "do", "then", "else",
     "env", "nice", "ionice", "exec", "doas", "setsid", "stdbuf", "chroot", "eval",
+    "sh", "bash", "zsh", "dash", "ksh", "ash", "timeout", "case",
 ]);
 const STATEMENT_SPLIT = /[;&|\n]+/;
 const stripTokenEdges = (t) => t.replace(/^[("'{]+|[)"'}]+$/g, "");
@@ -209,7 +214,7 @@ export function findUnverifiableRecursiveDelete(command, safeVars = new Set(UNVE
         }
         return false;
     };
-    const statements = command.split(STATEMENT_SPLIT);
+    const statements = command.replace(/\\\r?\n/g, " ").split(STATEMENT_SPLIT);
     for (const stmt of statements) {
         const tokens = stmt.trim().split(/\s+/).filter(Boolean);
         let i = 0;
@@ -230,6 +235,10 @@ export function findUnverifiableRecursiveDelete(command, safeVars = new Set(UNVE
         let sawWrapper = false;
         while (i < tokens.length) {
             const t = stripTokenEdges(tokens[i]).replace(/^\\/, "");
+            if (t === "") {
+                i++;
+                continue;
+            }
             if (DELETE_WRAPPERS.has(t)) {
                 sawWrapper = true;
                 i++;
@@ -237,8 +246,9 @@ export function findUnverifiableRecursiveDelete(command, safeVars = new Set(UNVE
                     i++;
                 continue;
             }
-            if (t === "timeout" && i + 1 < tokens.length) {
-                i += 2;
+            if (/\)$/.test(tokens[i]) && !DELETE_HEADS.has(t)) {
+                sawWrapper = true;
+                i++;
                 continue;
             }
             break;
@@ -368,7 +378,7 @@ function hasRecursiveForce(argvTail) {
 }
 export function createUnverifiableDeletePolicy(opts) {
     const safeVars = new Set([...UNVERIFIABLE_DELETE_SAFE_VARS, ...(opts?.safeVars ?? [])]);
-    const shellTools = new Set(opts?.tools ?? COARSE_SHELL_TOOLS);
+    const shellTools = canonicalToolNameSet(opts?.tools);
     return {
         check(req) {
             if (!shellTools.has(canonicalToolName(req.toolName)))
@@ -390,10 +400,28 @@ export function createUnverifiableDeletePolicy(opts) {
         },
     };
 }
+function pathSegments(p) {
+    return p.split(/[\\/]/).filter(Boolean);
+}
+function lexicalPath(p, home) {
+    const norm = p.normalize("NFC");
+    const expanded = norm === "~" ? home : /^~[\\/]/.test(norm) ? join(home, norm.slice(2)) : norm;
+    return normalizePath(expanded);
+}
+const RELATIVE_TAIL_MIN_SEGMENTS = 2;
+function relativeContinuesDirTail(segs, dirSegs) {
+    const from = Math.min(RELATIVE_TAIL_MIN_SEGMENTS, dirSegs.length);
+    for (let k = from; k <= Math.min(segs.length, dirSegs.length); k++) {
+        const tail = dirSegs.slice(dirSegs.length - k);
+        if (tail.every((s, i) => s === segs[i]))
+            return true;
+    }
+    return false;
+}
 export function createTranscriptIntegrityPolicy(opts) {
     const home = homedir();
     const defaultRoot = (process.env.AGENT_DATA_DIR ?? join(home, ".ai-agent")).normalize("NFC");
-    const dirs = (opts?.sessionsDirs ?? [join(defaultRoot, "sessions")]).map((d) => d.normalize("NFC").replace(/[\\/]+$/, ""));
+    const dirs = (opts?.sessionsDirs ?? [join(defaultRoot, "sessions")]).map((d) => lexicalPath(d, home).replace(/(?<=.)[\\/]+$/, ""));
     const textualForms = dirs.flatMap((d) => {
         const forms = [d];
         if (d.startsWith(home + sep)) {
@@ -403,13 +431,34 @@ export function createTranscriptIntegrityPolicy(opts) {
         return forms;
     });
     const readAllow = new Set(opts?.readAllow ?? BASH_READONLY_DEFAULT_ALLOW);
-    const shellTools = new Set(opts?.tools ?? COARSE_SHELL_TOOLS);
+    const shellTools = canonicalToolNameSet(opts?.tools);
+    const dirSegs = dirs.map(pathSegments);
     const inProtectedDir = (p) => {
-        const norm = p.normalize("NFC");
-        const abs = norm.startsWith("~" + sep) || norm === "~" ? join(home, norm.slice(1)) : norm;
-        if (!isAbsolute(abs))
-            return false;
-        return dirs.some((d) => abs === d || abs.startsWith(d + sep));
+        const abs = lexicalPath(p, home);
+        const segs = pathSegments(abs);
+        if (isAbsolute(abs)) {
+            return dirSegs.some((d) => d.length <= segs.length && d.every((s, i) => s === segs[i]));
+        }
+        return dirSegs.some((d) => relativeContinuesDirTail(segs, d));
+    };
+    const referencesProtectedDir = (cmd) => {
+        if (textualForms.some((f) => cmd.includes(f)))
+            return true;
+        for (const raw of cmd.split(/[\s;&|<>()]+/)) {
+            if (raw === "")
+                continue;
+            const unquoted = raw.replace(/["'`]/g, "");
+            if (unquoted === "")
+                continue;
+            const expanded = unquoted.startsWith("${HOME}")
+                ? home + unquoted.slice("${HOME}".length)
+                : unquoted.startsWith("$HOME")
+                    ? home + unquoted.slice("$HOME".length)
+                    : unquoted;
+            if (inProtectedDir(expanded))
+                return true;
+        }
+        return false;
     };
     const askReason = (what) => ({
         action: "ask",
@@ -428,7 +477,7 @@ export function createTranscriptIntegrityPolicy(opts) {
                 if (typeof command !== "string")
                     return ALLOW;
                 const cmd = command.normalize("NFC");
-                if (!textualForms.some((f) => cmd.includes(f)))
+                if (!referencesProtectedDir(cmd))
                     return ALLOW;
                 const parsed = parseLeadingCommandName(command);
                 if ("name" in parsed && readAllow.has(parsed.name))
@@ -438,8 +487,7 @@ export function createTranscriptIntegrityPolicy(opts) {
                     : "the command references the transcript directory and is not a single read-only command (fail-closed)");
             }
             if (toolName === "Write" || toolName === "Edit" || toolName === "NotebookEdit") {
-                const a = req.args;
-                const p = a?.file_path ?? a?.notebook_path;
+                const p = writeTargetPath(toolName, req.args);
                 if (typeof p === "string" && inProtectedDir(p)) {
                     return askReason(`"${p}" is inside the session-transcript directory`);
                 }

package/dist/core/trace.d.ts

@@ -140,6 +140,7 @@ export type TraceEvent = {
     provider?: string;
     turn?: number;
     promptTokens: number;
+    totalInputTokens: number;
     completionTokens: number;
     cacheRead: number;
     cacheWrite: number;

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> {
@@ -527,6 +524,7 @@ export type TaskEvent = ({
     type: "turn_end";
     usage?: {
         inputTokens: number;
+        totalInputTokens: number;
         outputTokens: number;
         cacheReadTokens: number;
         cacheWriteTokens: number;

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/engine/compaction/compaction.d.ts

@@ -78,3 +78,4 @@ export interface CompactionPreparation {
 export declare function prepareCompaction(pathEntries: SessionTreeEntry[], settings: CompactionSettings, charsPerToken?: number, windowTokens?: number): Result<CompactionPreparation | undefined, CompactionError>;
 export { computeFileLists, serializeConversation } from "./utils.js";
 export declare function compact(preparation: CompactionPreparation, model: Model, apiKey: string | undefined, headers?: Record<string, string>, customInstructions?: string, signal?: AbortSignal, thinkingLevel?: ThinkingLevel, streamFn?: StreamFn, runtime?: AgentCoreCompletionRuntimeDeps, charsPerToken?: number, onInputTruncated?: (info: SummarizationInputTruncation) => void, onPtlRetry?: () => void): Promise<Result<CompactionResult, CompactionError>>;
+export declare function turnPrefixSummarizationPrompt(customInstructions?: string): string;

package/dist/engine/compaction/compaction.js

@@ -132,6 +132,9 @@ export function shouldCompact(contextTokens, contextWindow, settings) {
     if (!settings.enabled) {
         return false;
     }
+    if (!Number.isFinite(contextWindow) || contextWindow <= 0) {
+        return false;
+    }
     return contextTokens > contextWindow - settings.reserveTokens;
 }
 export function estimateTokens(message, charsPerToken = DEFAULT_CHARS_PER_TOKEN) {
@@ -539,7 +542,7 @@ export function dryRunSummarizationClamp(preparation, model, customInstructions,
     if (isSplitTurn && turnPrefixMessages.length > 0) {
         const text = serializeConversation(convertToLlm(turnPrefixMessages));
         conversationChars += text.length;
-        const clamped = clampSummarizationConversation(text, model, cpt, SUMMARIZATION_SYSTEM_PROMPT.length + TURN_PREFIX_SUMMARIZATION_PROMPT.length + 128, Math.floor(0.5 * summaryBudget));
+        const clamped = clampSummarizationConversation(text, model, cpt, SUMMARIZATION_SYSTEM_PROMPT.length + turnPrefixSummarizationPrompt(customInstructions).length + 128, Math.floor(0.5 * summaryBudget));
         dropped += Math.max(0, clamped.droppedChars);
         kept += clamped.keptChars;
     }
@@ -879,7 +882,7 @@ export async function compact(preparation, model, apiKey, headers, customInstruc
                 ? generateSummary(messagesToSummarize, model, summaryBudget, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, runtime, charsPerToken, onInputTruncated, onPtlRetry)
                 :
                     Promise.resolve(ok(previousSummary ? stripFileOperationsFooter(previousSummary) : "No prior history.")),
-            generateTurnPrefixSummary(turnPrefixMessages, model, summaryBudget, apiKey, headers, signal, thinkingLevel, streamFn, runtime, charsPerToken, onInputTruncated, onPtlRetry),
+            generateTurnPrefixSummary(turnPrefixMessages, model, summaryBudget, apiKey, headers, signal, customInstructions, thinkingLevel, streamFn, runtime, charsPerToken, onInputTruncated, onPtlRetry),
         ]);
         if (!historyResult.ok) {
             return err(historyResult.error);
@@ -913,16 +916,22 @@ export async function compact(preparation, model, apiKey, headers, customInstruc
         },
     });
 }
-async function generateTurnPrefixSummary(messages, model, summaryBudgetTokens, apiKey, headers, signal, thinkingLevel, streamFn, runtime, charsPerToken, onInputTruncated, onPtlRetry) {
+export function turnPrefixSummarizationPrompt(customInstructions) {
+    return customInstructions
+        ? `${TURN_PREFIX_SUMMARIZATION_PROMPT}\n\nAdditional Instructions:\n${customInstructions}`
+        : TURN_PREFIX_SUMMARIZATION_PROMPT;
+}
+async function generateTurnPrefixSummary(messages, model, summaryBudgetTokens, apiKey, headers, signal, customInstructions, thinkingLevel, streamFn, runtime, charsPerToken, onInputTruncated, onPtlRetry) {
     const llmMessages = convertToLlm(messages);
+    const basePrompt = turnPrefixSummarizationPrompt(customInstructions);
     return summarizeWithPtlRetry({
         label: "Turn prefix summarization",
         truncationLabel: "turn_prefix",
         llmMessages,
-        buildPromptText: (conversationText) => `<conversation>\n${conversationText}\n</conversation>\n\n${TURN_PREFIX_SUMMARIZATION_PROMPT}`,
+        buildPromptText: (conversationText) => `<conversation>\n${conversationText}\n</conversation>\n\n${basePrompt}`,
         model,
         cpt: charsPerToken ?? model.charsPerToken ?? DEFAULT_CHARS_PER_TOKEN,
-        fixedPromptChars: SUMMARIZATION_SYSTEM_PROMPT.length + TURN_PREFIX_SUMMARIZATION_PROMPT.length + 128,
+        fixedPromptChars: SUMMARIZATION_SYSTEM_PROMPT.length + basePrompt.length + 128,
         baseMaxTokens: Math.floor(0.5 * summaryBudgetTokens),
         apiKey,
         headers,

package/dist/engine/lsp/frame-decoder.js

@@ -8,8 +8,7 @@ export function createFrameDecoder(maxBytes = 50 * 1024 * 1024) {
     return function decode(chunk) {
         const frames = [];
         buf = Buffer.concat([buf, chunk]);
-        if (buf.length > maxBytes + HEADER_SLACK)
-            buf = Buffer.alloc(0);
+        let awaiting;
         for (;;) {
             const he = buf.indexOf("\r\n\r\n");
             if (he === -1)
@@ -25,11 +24,15 @@ export function createFrameDecoder(maxBytes = 50 * 1024 * 1024) {
                 continue;
             }
             const start = he + 4;
-            if (buf.length < start + len)
+            if (buf.length < start + len) {
+                awaiting = start + len;
                 break;
+            }
             frames.push(buf.subarray(start, start + len).toString("utf8"));
             buf = buf.subarray(start + len);
         }
+        if (buf.length > (awaiting ?? maxBytes + HEADER_SLACK))
+            buf = Buffer.alloc(0);
         return frames;
     };
 }

package/dist/engine/lsp/node-lsp-manager.d.ts

@@ -29,6 +29,7 @@ export declare class NodeLspManager implements LspServerManager {
     private readonly cache;
     private readonly opening;
     private readonly failed;
+    private readonly initFailures;
     private disposed;
     constructor(opts?: NodeLspManagerOptions);
     private sweepIdle;
@@ -37,6 +38,7 @@ export declare class NodeLspManager implements LspServerManager {
     private evictOverCap;
     evict(root: string): Promise<void>;
     clearFailed(root?: string): void;
+    unavailableReason(filePath: string, env?: ExecutionEnv): string | undefined;
     private openSession;
     private serverCmd;
     dispose(): Promise<void>;

package/dist/engine/lsp/node-lsp-manager.js

@@ -1,13 +1,13 @@
 import { spawn } from "node:child_process";
 import { killProcessTree } from "../execution-env/kill-tree.js";
-import { readFile, stat } from "node:fs/promises";
+import { open, readFile, stat } from "node:fs/promises";
 import { basename, dirname, extname, resolve as resolvePath } from "node:path";
-import { existsSync } from "node:fs";
+import { constants as fsConstants, existsSync } from "node:fs";
 import { pathToUri } from "../../core/lsp-protocol.js";
 import { LspDiagnosticsRegistry } from "../../core/lsp-diagnostics.js";
 import { TransportLspSession } from "../../core/lsp-session.js";
 import { StdioLspTransport } from "./stdio-lsp-transport.js";
-import { MAX_LSP_FILE_BYTES } from "../../core/lsp.js";
+import { MAX_LSP_FILE_BYTES, SharedAbortScope, settleOnAbort } from "../../core/lsp.js";
 export const DEFAULT_LSP_SERVERS = {
     typescript: "typescript-language-server --stdio",
     javascript: "typescript-language-server --stdio",
@@ -46,6 +46,7 @@ const CLIENT_CAPABILITIES = {
     },
     workspace: { symbol: {}, workspaceFolders: false },
 };
+const INIT_FAILURE_LATCH = 2;
 export class NodeLspManager {
     servers;
     spawnFn;
@@ -60,6 +61,7 @@ export class NodeLspManager {
     cache = new Map();
     opening = new Map();
     failed = new Map();
+    initFailures = new Map();
     disposed = false;
     constructor(opts = {}) {
         this.servers = { ...DEFAULT_LSP_SERVERS, ...opts.servers };
@@ -79,6 +81,10 @@ export class NodeLspManager {
     sweepIdle() {
         const cutoff = Date.now() - this.idleTtlMs;
         for (const [key, e] of [...this.cache]) {
+            if (e.session.inFlight > 0) {
+                e.lastUsed = Date.now();
+                continue;
+            }
             if (e.lastUsed < cutoff) {
                 this.cache.delete(key);
                 this.log("lsp_evict_idle", { key });
@@ -106,19 +112,20 @@ export class NodeLspManager {
             this.cache.delete(key);
             const carry = cached.session.openedFiles();
             this.log("lsp_heal", { language, root, carried: carry.length });
-            const healed = await this.open(key, language, root, signal, env);
-            if (healed && carry.length)
-                await healed.warmOpen(carry, signal).catch(() => undefined);
-            return healed;
+            return this.open(key, language, root, signal, env, carry);
         }
         return this.open(key, language, root, signal, env);
     }
-    open(key, language, root, signal, env) {
+    open(key, language, root, signal, env, carry = []) {
         const inflight = this.opening.get(key);
-        if (inflight)
-            return inflight.job;
-        const entry = { root, cancelled: false, job: undefined };
-        entry.job = this.openSession(language, root, signal, env)
+        if (inflight && !inflight.scope.signal.aborted) {
+            inflight.scope.join(signal);
+            return settleOnAbort(inflight.job, signal, () => undefined);
+        }
+        const scope = new SharedAbortScope();
+        scope.join(signal);
+        const entry = { root, cancelled: false, scope, job: undefined };
+        entry.job = this.openSession(language, root, scope.signal, env)
             .then(async (session) => {
             if (!session)
                 return undefined;
@@ -126,26 +133,41 @@ export class NodeLspManager {
                 await session.close().catch(() => undefined);
                 return undefined;
             }
+            if (carry.length) {
+                const carried = await session.warmOpen(carry, scope.signal).catch(() => ({ opened: 0, failed: carry.length }));
+                this.log("lsp_heal_carried", { language, root, ...carried });
+                if (this.disposed || entry.cancelled) {
+                    await session.close().catch(() => undefined);
+                    return undefined;
+                }
+            }
             this.evictOverCap();
             this.cache.set(key, { session, root, lastUsed: Date.now() });
             return session;
         })
-            .finally(() => this.opening.delete(key));
+            .finally(() => {
+            if (this.opening.get(key) === entry)
+                this.opening.delete(key);
+        });
         this.opening.set(key, entry);
-        return entry.job;
+        return settleOnAbort(entry.job, signal, () => undefined);
     }
     evictOverCap() {
         while (this.cache.size >= this.maxSessions) {
             let lruKey;
             let lruTime = Infinity;
             for (const [k, e] of this.cache) {
+                if (e.session.inFlight > 0)
+                    continue;
                 if (e.lastUsed < lruTime) {
                     lruTime = e.lastUsed;
                     lruKey = k;
                 }
             }
-            if (lruKey === undefined)
+            if (lruKey === undefined) {
+                this.log("lsp_evict_deferred", { size: this.cache.size, maxSessions: this.maxSessions });
                 break;
+            }
             const evicted = this.cache.get(lruKey);
             this.cache.delete(lruKey);
             this.log("lsp_evict_lru", { key: lruKey });
@@ -154,6 +176,7 @@ export class NodeLspManager {
     }
     async evict(root) {
         const closing = [];
+        this.clearFailed(root);
         for (const [key, e] of [...this.cache]) {
             if (e.root === root) {
                 this.cache.delete(key);
@@ -174,8 +197,27 @@ export class NodeLspManager {
             if (root !== undefined && e.root !== root)
                 continue;
             this.failed.delete(key);
-            this.log("lsp_negative_cache_cleared", { key, attempts: e.attempts });
+            this.initFailures.delete(key);
+            this.log("lsp_negative_cache_cleared", { key, attempts: e.attempts, kind: e.kind });
         }
+        for (const [key, _n] of [...this.initFailures]) {
+            if (root === undefined || key.endsWith(` ${root}`))
+                this.initFailures.delete(key);
+        }
+    }
+    unavailableReason(filePath, env) {
+        const language = languageFor(filePath);
+        if (!language)
+            return undefined;
+        const cmd = this.serverCmd(language);
+        if (!cmd)
+            return `no ${language} language server is configured in this environment`;
+        const e = this.failed.get(`${language} ${this.resolveRootFn(filePath, env)}`);
+        if (e?.kind === "missing_binary")
+            return `the ${language} language server ("${e.command}") is not installed on this host`;
+        if (e?.kind === "initialize")
+            return `the ${language} language server ("${e.command}") is installed but failed to initialize`;
+        return undefined;
     }
     async openSession(language, root, signal, _env) {
         const cmd = this.serverCmd(language);
@@ -183,10 +225,18 @@ export class NodeLspManager {
             return undefined;
         const tokens = (cmd.match(/"[^"]*"|\S+/g) ?? []).map((t) => (t.startsWith('"') && t.endsWith('"') && t.length >= 2 ? t.slice(1, -1) : t));
         const [command, ...args] = tokens.length > 0 ? tokens : [""];
-        const child = await this.spawnFn(command, args, root, signal).catch(() => undefined);
+        const key = `${language} ${root}`;
+        let child;
+        try {
+            child = await this.spawnFn(command, args, root, signal);
+        }
+        catch (e) {
+            this.log("lsp_spawn_error", { language, root, command, err: e instanceof Error ? e.message : String(e) });
+            return undefined;
+        }
         if (!child) {
             if (signal?.aborted !== true)
-                this.failed.set(`${language} ${root}`, { root, attempts: 1 });
+                this.failed.set(key, { root, attempts: 1, kind: "missing_binary", command, language });
             this.log("lsp_spawn_degraded", { language, root, command });
             return undefined;
         }
@@ -204,9 +254,18 @@ export class NodeLspManager {
         }
         catch (e) {
             await transport.close();
-            this.log("lsp_init_degraded", { language, root, err: e instanceof Error ? e.message : String(e) });
+            const attempt = (this.initFailures.get(key) ?? 0) + 1;
+            const latched = attempt >= INIT_FAILURE_LATCH && signal?.aborted !== true;
+            if (latched) {
+                this.failed.set(key, { root, attempts: 1, kind: "initialize", command, language });
+                this.initFailures.delete(key);
+            }
+            else
+                this.initFailures.set(key, attempt);
+            this.log("lsp_init_degraded", { language, root, err: e instanceof Error ? e.message : String(e), attempt, latched });
             return undefined;
         }
+        this.initFailures.delete(key);
         this.log("lsp_open", { language, root });
         return new TransportLspSession(transport, language, this.readTextFn, this.log, this.warmup, this.diagnostics);
     }
@@ -249,33 +308,51 @@ export const defaultLspReadText = async (fp, signal) => {
         throw new Error(`not a regular file: ${fp}`);
     if (st.size > MAX_LSP_FILE_BYTES)
         throw new Error(`file too large for LSP analysis (${st.size} bytes exceeds ${MAX_LSP_FILE_BYTES})`);
-    return readFile(fp, { encoding: "utf8", signal });
+    const flags = fsConstants.O_RDONLY | (fsConstants.O_NONBLOCK ?? 0);
+    const fh = await open(fp, flags);
+    try {
+        const fst = await fh.stat();
+        if (!fst.isFile())
+            throw new Error(`not a regular file: ${fp}`);
+        if (fst.size > MAX_LSP_FILE_BYTES)
+            throw new Error(`file too large for LSP analysis (${fst.size} bytes exceeds ${MAX_LSP_FILE_BYTES})`);
+        return await readFile(fh, { encoding: "utf8", signal });
+    }
+    finally {
+        await fh.close().catch(() => undefined);
+    }
 };
 export function lspSpawnOptions(cwd) {
     return process.platform === "win32"
         ? { cwd, stdio: ["pipe", "pipe", "ignore"], shell: true }
         : { cwd, stdio: ["pipe", "pipe", "ignore"] };
 }
-export const defaultLspSpawn = (command, args, cwd, signal) => new Promise((resolve) => {
+export const defaultLspSpawn = (command, args, cwd, signal) => new Promise((resolve, reject) => {
     let child;
     try {
         child = spawn(command, args, lspSpawnOptions(cwd));
     }
-    catch {
-        return resolve(undefined);
+    catch (e) {
+        return reject(e instanceof Error ? e : new Error(String(e)));
     }
+    child.on("error", () => { });
     const onSpawn = () => {
         cleanup();
         resolve(child);
     };
-    const onError = () => {
+    const onError = (err) => {
         cleanup();
-        resolve(undefined);
+        if (err?.code === "ENOENT")
+            resolve(undefined);
+        else
+            reject(err instanceof Error ? err : new Error(String(err)));
     };
     const onAbort = () => {
         cleanup();
         try {
-            if (process.platform === "win32" && child.pid)
+            if (child.pid === undefined)
+                return resolve(undefined);
+            if (process.platform === "win32")
                 killProcessTree(child.pid, { force: true });
             else
                 child.kill();

package/dist/engine/lsp/stdio-lsp-transport.js

@@ -16,7 +16,17 @@ export class StdioLspTransport {
             for (const frame of this.decode(chunk))
                 this.onMessage(frame);
         });
-        child.stdin.on("error", () => { });
+        child.stdin.on("error", (e) => this.failAll(toError(e)));
+        const stdout = child.stdout;
+        if (typeof stdout.removeListener === "function" && typeof stdout.once === "function") {
+            for (const event of ["end", "close", "error"]) {
+                stdout.on(event, (arg) => {
+                    if (Buffer.isBuffer(arg))
+                        return;
+                    this.failAll(new Error(`LSP server stdout ${event}`));
+                });
+            }
+        }
         child.on("exit", () => this.failAll(new Error("LSP server exited")));
         child.on("error", (e) => this.failAll(toError(e)));
     }
@@ -36,7 +46,8 @@ export class StdioLspTransport {
                 try {
                     this.send({ jsonrpc: "2.0", id: msg.id, error: { code: -32601, message: `Method not found: ${String(msg.method)}` } });
                 }
-                catch {
+                catch (e) {
+                    this.failAll(toError(e));
                 }
             }
             return;
@@ -121,10 +132,7 @@ export class StdioLspTransport {
                 this.send({ jsonrpc: "2.0", id, method, params });
             }
             catch (e) {
-                if (this.pending.delete(id)) {
-                    cleanup();
-                    reject(brandLspFailure(e instanceof Error ? e : new Error(String(e)), "server_terminated"));
-                }
+                this.failAll(brandLspFailure(e instanceof Error ? e : new Error(String(e)), "server_terminated"));
             }
         });
     }
@@ -134,7 +142,8 @@ export class StdioLspTransport {
         try {
             this.send({ jsonrpc: "2.0", method, params });
         }
-        catch {
+        catch (e) {
+            this.failAll(toError(e));
         }
     }
     async close() {

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/harness.d.ts

@@ -2,7 +2,7 @@ export * from "./harness-types.js";
 export { AgentHarness } from "../engine/harness/agent-harness.js";
 export { CompactionError, ExecutionError, FileError, ok, err } from "../engine/harness/types.js";
 export { DEFAULT_CHARS_PER_TOKEN, DEFAULT_CLAMP_TOLERANCE, DEFAULT_COMPACTION_SETTINGS, compact, computeFileLists, dryRunSummarizationClamp, estimateContextTokens, estimateTokens, prepareCompaction, shouldCompact, summaryOutputBudgetTokens, } from "../engine/compaction/compaction.js";
-export { SKILL_RETENTION_PER_SKILL_MAX_CHARS, SKILL_RETENTION_TOTAL_MAX_CHARS, SKILL_RETENTION_TRUNCATION_MARKER, formatPersistedOutputRefs, readCompactionActiveTools, readRetainedInvokedSkills, renderInvokedSkillsRetention, } from "../engine/compaction/utils.js";
+export { SKILL_RETENTION_PER_SKILL_MAX_CHARS, SKILL_RETENTION_TOTAL_MAX_CHARS, SKILL_RETENTION_TRUNCATION_MARKER, formatFileOperations, formatPersistedOutputRefs, readCompactionActiveTools, readRetainedInvokedSkills, renderInvokedSkillsRetention, } from "../engine/compaction/utils.js";
 export { NodeExecutionEnv } from "../engine/execution-env/node-execution-env.js";
 export { StoredSession, buildSessionContext } from "../engine/session/session.js";
 export { getEntriesToFork } from "../engine/session/repo-utils.js";

package/dist/internal/harness.js

@@ -2,7 +2,7 @@ export * from "./harness-types.js";
 export { AgentHarness } from "../engine/harness/agent-harness.js";
 export { CompactionError, ExecutionError, FileError, ok, err } from "../engine/harness/types.js";
 export { DEFAULT_CHARS_PER_TOKEN, DEFAULT_CLAMP_TOLERANCE, DEFAULT_COMPACTION_SETTINGS, compact, computeFileLists, dryRunSummarizationClamp, estimateContextTokens, estimateTokens, prepareCompaction, shouldCompact, summaryOutputBudgetTokens, } from "../engine/compaction/compaction.js";
-export { SKILL_RETENTION_PER_SKILL_MAX_CHARS, SKILL_RETENTION_TOTAL_MAX_CHARS, SKILL_RETENTION_TRUNCATION_MARKER, formatPersistedOutputRefs, readCompactionActiveTools, readRetainedInvokedSkills, renderInvokedSkillsRetention, } from "../engine/compaction/utils.js";
+export { SKILL_RETENTION_PER_SKILL_MAX_CHARS, SKILL_RETENTION_TOTAL_MAX_CHARS, SKILL_RETENTION_TRUNCATION_MARKER, formatFileOperations, formatPersistedOutputRefs, readCompactionActiveTools, readRetainedInvokedSkills, renderInvokedSkillsRetention, } from "../engine/compaction/utils.js";
 export { NodeExecutionEnv } from "../engine/execution-env/node-execution-env.js";
 export { StoredSession, buildSessionContext } from "../engine/session/session.js";
 export { getEntriesToFork } from "../engine/session/repo-utils.js";