@sema-agent/core 1.451.0 → 1.452.0

package/dist/core/tool-result-store.js

@@ -1,5 +1,5 @@
 import { Type } from "typebox";
-import { defineTool } from "./tools.js";
+import { defineTool, errorResult } from "./tools.js";
 export class InMemoryToolResultStore {
     opts;
     map = new Map();
@@ -146,7 +146,7 @@ export function makeReadToolResultTool(store) {
             const lim = Math.min(READ_MAX_LIMIT, Math.max(1, intOr(limit, READ_DEFAULT_LIMIT)));
             const slice = await store.get(ref, { offset: off, limit: lim });
             if (!slice) {
-                return `No persisted output for ref "${ref}" — it may have expired, or this process has no durable tool-result store (the preview above is all that remains).`;
+                return errorResult(`No persisted output for ref "${ref}" — it may have expired, or this process has no durable tool-result store (the preview above is all that remains).`);
             }
             const end = slice.offset + slice.content.length;
             const more = end < slice.totalChars ? `\n…[${slice.totalChars - end} more chars — call again with offset=${end}.]` : "";

package/dist/core/tools.d.ts

@@ -1,5 +1,10 @@
 import type { TSchema } from "typebox";
 import type { AgentTool, Skill } from "../internal/harness.js";
 import type { SkillSpec, ToolSpec } from "./types.js";
+export declare function errorResult(text: string, details?: unknown): {
+    content: string;
+    isError: true;
+    details?: unknown;
+};
 export declare function defineTool<TParams extends TSchema = TSchema>(spec: ToolSpec<TParams>): AgentTool<TParams>;
 export declare function toSkill(spec: SkillSpec): Skill;

package/dist/core/tools.js

@@ -22,6 +22,9 @@ function isEmptyToolContent(content) {
         return true;
     return content.every((b) => b.type === "text" && (typeof b.text !== "string" || b.text.trim() === ""));
 }
+export function errorResult(text, details) {
+    return details === undefined ? { content: text, isError: true } : { content: text, isError: true, details };
+}
 export function defineTool(spec) {
     const executionMode = spec.executionMode ?? (spec.effect === "read" ? "parallel" : "sequential");
     const tool = {

package/dist/core/types.d.ts

@@ -664,6 +664,7 @@ export interface BackgroundChildEvent {
     resumable?: boolean;
     status?: "completed" | "killed" | "failed";
     seq?: number;
+    completionId?: string;
     stoppedBy?: "user" | "parent" | "system" | (string & {});
     summary?: string;
     usage?: {

package/dist/core/workflow-journal-store.d.ts

@@ -11,6 +11,8 @@ export interface WorkflowJournalStore {
 export declare const MAX_JOURNAL_RESULT_BYTES: number;
 export declare function oversizeJournalResult(serialized: string): boolean;
 export declare function callKeyOrdinal(callKey: string): number;
+export declare const JOURNAL_OVERSIZE_ERROR_CODE = "workflow.journal_oversize";
+export declare function journalOversizeTombstone(result: TaskResult, bytes: number): TaskResult;
 export declare class InMemoryWorkflowJournalStore implements WorkflowJournalStore {
     private readonly runs;
     load(runId: string, scope: string): Promise<WorkflowJournalEntry[]>;

package/dist/core/workflow-journal-store.js

@@ -7,6 +7,20 @@ export function callKeyOrdinal(callKey) {
     const n = Number.parseInt(i >= 0 ? callKey.slice(0, i) : callKey, 10);
     return Number.isFinite(n) ? n : 0;
 }
+export const JOURNAL_OVERSIZE_ERROR_CODE = "workflow.journal_oversize";
+export function journalOversizeTombstone(result, bytes) {
+    const message = `[journal] result omitted: ${bytes} bytes exceeds the ${MAX_JOURNAL_RESULT_BYTES}-byte per-entry journal cap; ` +
+        `the agent's real terminal status was "${result.status}". A resume re-runs this agent (and everything after it) live.`;
+    return {
+        taskId: result.taskId,
+        sessionId: result.sessionId,
+        status: "failed",
+        result: message,
+        errorCode: JOURNAL_OVERSIZE_ERROR_CODE,
+        errorMessage: message,
+        stats: result.stats,
+    };
+}
 function snapshot(entry) {
     try {
         return structuredClone(entry);

package/dist/engine/execution-env/node-execution-env.d.ts

@@ -71,6 +71,7 @@ export declare class NodeExecutionEnv implements ExecutionEnv, BackgroundShellCa
     }): Promise<Result<string[], FileError>>;
     readBinaryFile(path: string, abortSignal?: AbortSignal): Promise<Result<Uint8Array, FileError>>;
     writeFile(path: string, content: string | Uint8Array, abortSignal?: AbortSignal): Promise<Result<void, FileError>>;
+    private writeFileInPlace;
     writeFileExclusive(path: string, content: string | Uint8Array, abortSignal?: AbortSignal): Promise<Result<void, FileError>>;
     appendFile(path: string, content: string | Uint8Array): Promise<Result<void, FileError>>;
     fileInfo(path: string): Promise<Result<FileInfo, FileError>>;

package/dist/engine/execution-env/node-execution-env.js

@@ -1,14 +1,14 @@
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { closeSync, constants, createReadStream, mkdtempSync, openSync, readSync, statSync, truncateSync, unlinkSync } from "node:fs";
-import { access, appendFile, lstat, mkdir, mkdtemp, readdir, readFile, readlink, realpath, rm, writeFile, } from "node:fs/promises";
+import { access, appendFile, lstat, mkdir, mkdtemp, open, readdir, readFile, readlink, realpath, rename, rm, unlink, writeFile, } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
 import { createInterface } from "node:readline";
 import { ExecutionError, err, FileError, ok, toError, } from "../harness/types.js";
 import { killProcessTree, shutdownDebug } from "./kill-tree.js";
 import { scrubSecretEnv } from "../../core/secret-env.js";
-import { RollingTailBuffer, markTruncated } from "../../core/exec-output-tail.js";
+import { RollingTailBuffer, markTruncated, newStreamCursorState, sliceStreamIncrement, } from "../../core/exec-output-tail.js";
 import { BackgroundShellError } from "../../core/background-shell.js";
 import { SchedulerError } from "../../core/scheduler.js";
 const MAX_TIMER_TIMEOUT_MS = 2_147_000_000;
@@ -88,6 +88,11 @@ function toFileError(error, path) {
 function abortResult(signal, path) {
     return signal?.aborted ? err(new FileError("aborted", "aborted", path)) : undefined;
 }
+function isFsSupportError(error) {
+    const code = isNodeError(error) ? error.code : undefined;
+    return code === "EINVAL" || code === "ENOTSUP" || code === "EPERM" || code === "ENOSYS";
+}
+const RENAME_FALLBACK_CODES = new Set(["EXDEV", "EPERM", "EEXIST", "EBUSY"]);
 async function pathExists(path) {
     try {
         await access(path, constants.F_OK);
@@ -744,10 +749,116 @@ export class NodeExecutionEnv {
         }
         try {
             await mkdir(resolve(resolved, ".."), { recursive: true });
-            const afterMkdirAbort = abortResult(abortSignal, resolved);
-            if (afterMkdirAbort) {
-                return afterMkdirAbort;
+        }
+        catch (error) {
+            return err(toFileError(error, resolved));
+        }
+        const afterMkdirAbort = abortResult(abortSignal, resolved);
+        if (afterMkdirAbort) {
+            return afterMkdirAbort;
+        }
+        let target = resolved;
+        let existingMode;
+        let st;
+        try {
+            st = await lstat(resolved);
+        }
+        catch {
+            st = undefined;
+        }
+        if (st !== undefined) {
+            if (st.isSymbolicLink()) {
+                let hop;
+                try {
+                    const link = await readlink(resolved);
+                    const parentReal = await realpath(resolve(resolved, "..")).catch(() => resolve(resolved, ".."));
+                    hop = isAbsolute(link) ? link : resolve(parentReal, link);
+                }
+                catch {
+                    hop = undefined;
+                }
+                if (hop === undefined)
+                    return await this.writeFileInPlace(resolved, content, abortSignal);
+                let hopStat;
+                try {
+                    hopStat = await lstat(hop);
+                }
+                catch {
+                    hopStat = undefined;
+                }
+                if (hopStat !== undefined && !hopStat.isFile()) {
+                    return await this.writeFileInPlace(resolved, content, abortSignal);
+                }
+                target = hop;
+                existingMode = hopStat !== undefined ? hopStat.mode & 0o7777 : undefined;
+            }
+            else if (!st.isFile()) {
+                return await this.writeFileInPlace(resolved, content, abortSignal);
             }
+            else {
+                existingMode = st.mode & 0o7777;
+            }
+        }
+        const tmp = `${target}.tmp.${process.pid}.${randomUUID().replace(/-/g, "").slice(0, 12)}`;
+        let tmpDurable = false;
+        try {
+            const handle = await open(tmp, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | (constants.O_NOFOLLOW ?? 0));
+            try {
+                await handle.writeFile(content, { signal: abortSignal });
+                if (existingMode !== undefined) {
+                    try {
+                        await handle.chmod(existingMode);
+                    }
+                    catch (error) {
+                        if (!isFsSupportError(error))
+                            throw error;
+                    }
+                }
+                try {
+                    await handle.sync();
+                }
+                catch (error) {
+                    if (!isFsSupportError(error))
+                        throw error;
+                }
+                tmpDurable = true;
+            }
+            finally {
+                await handle.close().catch(() => { });
+            }
+        }
+        catch (error) {
+            await unlink(tmp).catch(() => { });
+            if (isNodeError(error) && error.code === "EACCES" && existingMode !== undefined) {
+                return await this.writeFileInPlace(resolved, content, abortSignal);
+            }
+            return err(toFileError(error, resolved));
+        }
+        const preRenameAbort = abortResult(abortSignal, resolved);
+        if (preRenameAbort) {
+            await unlink(tmp).catch(() => { });
+            return preRenameAbort;
+        }
+        try {
+            await rename(tmp, target);
+            return ok(undefined);
+        }
+        catch (error) {
+            const code = isNodeError(error) ? error.code : undefined;
+            if (tmpDurable && code !== undefined && RENAME_FALLBACK_CODES.has(code)) {
+                const inPlace = await this.writeFileInPlace(resolved, content, abortSignal);
+                if (inPlace.ok) {
+                    await unlink(tmp).catch(() => { });
+                    return inPlace;
+                }
+                return err(new FileError("unknown", `write to ${resolved} failed after the atomic rename was refused (${code}): ${inPlace.error.message}. The new content was preserved at ${tmp}`, resolved, inPlace.error));
+            }
+            await unlink(tmp).catch(() => { });
+            return err(toFileError(error, resolved));
+        }
+    }
+    async writeFileInPlace(resolved, content, abortSignal) {
+        try {
             await writeFile(resolved, content, { signal: abortSignal });
             return ok(undefined);
         }
@@ -913,8 +1024,8 @@ export class NodeExecutionEnv {
         const shellId = `bg_${++this.bgCounter}_${randomUUID()}`;
         const entry = {
             child,
-            stdout: { tail: new RollingTailBuffer(), totalBytes: 0, cursorBytes: 0 },
-            stderr: { tail: new RollingTailBuffer(), totalBytes: 0, cursorBytes: 0 },
+            stdout: { ...newStreamCursorState(), totalBytes: 0 },
+            stderr: { ...newStreamCursorState(), totalBytes: 0 },
             status: "running",
             ...(handover !== undefined
                 ? { spool: { outPath: handover.spool.outPath, errPath: handover.spool.errPath, fileCursor: { ...handover.cursors }, ephemeral: true } }
@@ -928,15 +1039,19 @@ export class NodeExecutionEnv {
         entry.stderr.tail.push(seedErr);
         entry.stdout.totalBytes += stdoutSoFar.droppedBytes + seedOut.length;
         entry.stderr.totalBytes += stderrSoFar.droppedBytes + seedErr.length;
+        entry.stdout.acceptedBytes += seedOut.length;
+        entry.stderr.acceptedBytes += seedErr.length;
         child.stdout?.on("data", (chunk) => {
             const buf = typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
             entry.stdout.tail.push(buf);
             entry.stdout.totalBytes += buf.length;
+            entry.stdout.acceptedBytes += buf.length;
         });
         child.stderr?.on("data", (chunk) => {
             const buf = typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
             entry.stderr.tail.push(buf);
             entry.stderr.totalBytes += buf.length;
+            entry.stderr.acceptedBytes += buf.length;
         });
         child.on("error", () => {
             if (entry.timer)
@@ -1040,8 +1155,8 @@ export class NodeExecutionEnv {
         const shellId = `bg_${++this.bgCounter}_${randomUUID()}`;
         const entry = {
             child,
-            stdout: { tail: new RollingTailBuffer(), totalBytes: 0, cursorBytes: 0 },
-            stderr: { tail: new RollingTailBuffer(), totalBytes: 0, cursorBytes: 0 },
+            stdout: { ...newStreamCursorState(), totalBytes: 0 },
+            stderr: { ...newStreamCursorState(), totalBytes: 0 },
             status: "running",
             ...(spool ? { spool } : {}),
         };
@@ -1051,11 +1166,13 @@ export class NodeExecutionEnv {
             const buf = Buffer.from(chunk, "utf8");
             entry.stdout.tail.push(buf);
             entry.stdout.totalBytes += buf.length;
+            entry.stdout.acceptedBytes += buf.length;
         });
         child.stderr?.on("data", (chunk) => {
             const buf = Buffer.from(chunk, "utf8");
             entry.stderr.tail.push(buf);
             entry.stderr.totalBytes += buf.length;
+            entry.stderr.acceptedBytes += buf.length;
         });
         child.stdout?.on("error", () => { });
         child.stderr?.on("error", () => { });
@@ -1098,17 +1215,9 @@ export class NodeExecutionEnv {
             return err(new BackgroundShellError("not_found", `Unknown background shell: ${shellId}`));
         }
         this.syncSpool(entry);
-        const slice = (s) => {
-            const { text, droppedBytes } = s.tail.result();
-            const droppedBeforeCursor = Math.max(0, droppedBytes - s.cursorBytes);
-            const startByte = Math.max(s.cursorBytes, droppedBytes);
-            const startInTail = startByte - droppedBytes;
-            const inc = startInTail <= 0 ? text : Buffer.from(text, "utf8").subarray(startInTail).toString("utf8");
-            s.cursorBytes = s.totalBytes;
-            return { inc, droppedBeforeCursor };
-        };
-        const out = slice(entry.stdout);
-        const er = slice(entry.stderr);
+        const terminal = entry.status !== "running";
+        const out = sliceStreamIncrement(entry.stdout, terminal);
+        const er = sliceStreamIncrement(entry.stderr, terminal);
         const droppedBeforeCursor = out.droppedBeforeCursor + er.droppedBeforeCursor;
         return ok({
             stdout: out.inc,
@@ -1165,6 +1274,7 @@ export class NodeExecutionEnv {
                         if (got > 0) {
                             stream.tail.push(buf.subarray(0, got));
                             stream.totalBytes += got;
+                            stream.acceptedBytes += got;
                             spool.fileCursor[lane] += got;
                         }
                     }

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

@@ -1,6 +1,6 @@
 import { type SessionWarmup } from "../../core/lsp-session.js";
 import { type LspChildProcess } from "./stdio-lsp-transport.js";
-import type { LspServerManager, LspSession, LspReadText } from "../../core/lsp.js";
+import { type LspServerManager, type LspSession, type LspReadText } from "../../core/lsp.js";
 import type { ExecutionEnv } from "../../internal/harness.js";
 export declare const DEFAULT_LSP_SERVERS: Readonly<Record<string, string>>;
 export type LspSpawn = (command: string, args: string[], cwd: string, signal?: AbortSignal) => Promise<LspChildProcess | undefined>;
@@ -40,6 +40,8 @@ export declare class NodeLspManager implements LspServerManager {
     dispose(): Promise<void>;
 }
 export declare function languageFor(filePath: string): string | undefined;
+export { MAX_LSP_FILE_BYTES } from "../../core/lsp.js";
+export declare const defaultLspReadText: LspReadText;
 export declare function lspSpawnOptions(cwd: string): {
     cwd: string;
     stdio: ["pipe", "pipe", "ignore"];

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

@@ -1,12 +1,13 @@
 import { spawn } from "node:child_process";
 import { killProcessTree } from "../execution-env/kill-tree.js";
-import { readFile } from "node:fs/promises";
-import { dirname, extname, resolve as resolvePath } from "node:path";
+import { readFile, stat } from "node:fs/promises";
+import { basename, dirname, extname, resolve as resolvePath } from "node:path";
 import { 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";
 export const DEFAULT_LSP_SERVERS = {
     typescript: "typescript-language-server --stdio",
     javascript: "typescript-language-server --stdio",
@@ -43,7 +44,7 @@ const CLIENT_CAPABILITIES = {
         definition: {}, references: {}, hover: {}, documentSymbol: {}, implementation: {}, callHierarchy: {},
         publishDiagnostics: { versionSupport: true },
     },
-    workspace: { symbol: {} },
+    workspace: { symbol: {}, workspaceFolders: false },
 };
 export class NodeLspManager {
     servers;
@@ -62,7 +63,7 @@ export class NodeLspManager {
     constructor(opts = {}) {
         this.servers = { ...DEFAULT_LSP_SERVERS, ...opts.servers };
         this.spawnFn = opts.spawn ?? defaultLspSpawn;
-        this.readTextFn = opts.readText ?? ((fp) => readFile(fp, "utf8"));
+        this.readTextFn = opts.readText ?? defaultLspReadText;
         this.resolveRootFn = opts.resolveRoot ?? defaultResolveRoot;
         this.log = opts.log ?? (() => { });
         this.warmup = opts.warmup;
@@ -175,7 +176,14 @@ export class NodeLspManager {
         }
         const transport = new StdioLspTransport(child);
         try {
-            await transport.request("initialize", { processId: null, rootUri: pathToUri(root), capabilities: CLIENT_CAPABILITIES }, signal);
+            const rootUri = pathToUri(root);
+            await transport.request("initialize", {
+                processId: null,
+                rootPath: root,
+                rootUri,
+                workspaceFolders: [{ uri: rootUri, name: basename(root) || root }],
+                capabilities: CLIENT_CAPABILITIES,
+            }, signal);
             transport.notify("initialized", {});
         }
         catch (e) {
@@ -218,6 +226,15 @@ function defaultResolveRoot(filePath, env) {
     }
     return dirname(resolvePath(filePath));
 }
+export { MAX_LSP_FILE_BYTES } from "../../core/lsp.js";
+export const defaultLspReadText = async (fp, signal) => {
+    const st = await stat(fp);
+    if (!st.isFile())
+        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 });
+};
 export function lspSpawnOptions(cwd) {
     return process.platform === "win32"
         ? { cwd, stdio: ["pipe", "pipe", "ignore"], shell: true }

package/dist/engine/lsp/stdio-lsp-transport.d.ts

@@ -1,4 +1,4 @@
-import type { LspTransport } from "../../core/lsp.js";
+import { type LspTransport } from "../../core/lsp.js";
 export interface LspChildProcess {
     stdin: {
         write(data: Buffer): void;

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

@@ -1,5 +1,6 @@
 import { encodeFrame, makeFrameDecoder } from "./frame-decoder.js";
 import { killProcessTree } from "../execution-env/kill-tree.js";
+import { brandLspFailure } from "../../core/lsp.js";
 export class StdioLspTransport {
     child;
     requestTimeoutMs;
@@ -44,8 +45,10 @@ export class StdioLspTransport {
             const p = this.pending.get(msg.id);
             if (p) {
                 this.pending.delete(msg.id);
-                if (msg.error)
-                    p.reject(new Error(msg.error.message ?? "LSP error"));
+                if (msg.error) {
+                    const message = msg.error.message ?? "LSP error";
+                    p.reject(brandLspFailure(new Error(message), jsonRpcReason(msg.error.code), message));
+                }
                 else
                     p.resolve(msg.result);
             }
@@ -68,6 +71,7 @@ export class StdioLspTransport {
     }
     failAll(err) {
         this.isClosed = true;
+        brandLspFailure(err, "server_terminated");
         for (const p of this.pending.values())
             p.reject(err);
         this.pending.clear();
@@ -77,13 +81,13 @@ export class StdioLspTransport {
     }
     request(method, params, signal) {
         if (this.isClosed)
-            return Promise.reject(new Error("LSP transport closed"));
+            return Promise.reject(brandLspFailure(new Error("LSP transport closed"), "server_terminated"));
         const id = ++this.nextId;
         return new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
                 if (this.pending.delete(id)) {
                     signal?.removeEventListener("abort", onAbort);
-                    reject(new Error(`LSP ${method} timed out after ${this.requestTimeoutMs}ms`));
+                    reject(brandLspFailure(new Error(`LSP ${method} timed out after ${this.requestTimeoutMs}ms`), "timeout"));
                 }
             }, this.requestTimeoutMs);
             timer.unref?.();
@@ -95,7 +99,7 @@ export class StdioLspTransport {
                 if (this.pending.delete(id)) {
                     cleanup();
                     this.notify("$/cancelRequest", { id });
-                    reject(new Error(`LSP ${method} aborted`));
+                    reject(brandLspFailure(new Error(`LSP ${method} aborted`), "cancelled"));
                 }
             };
             this.pending.set(id, {
@@ -119,7 +123,7 @@ export class StdioLspTransport {
             catch (e) {
                 if (this.pending.delete(id)) {
                     cleanup();
-                    reject(e instanceof Error ? e : new Error(String(e)));
+                    reject(brandLspFailure(e instanceof Error ? e : new Error(String(e)), "server_terminated"));
                 }
             }
         });
@@ -145,6 +149,13 @@ export class StdioLspTransport {
         }
     }
 }
+function jsonRpcReason(code) {
+    if (code === -32601)
+        return "unsupported_operation";
+    if (code === -32800 || code === -32802)
+        return "cancelled";
+    return "server_error";
+}
 function toError(e) {
     if (e instanceof Error)
         return e;

package/dist/index.d.ts

@@ -13,7 +13,7 @@ export { assembleCodeTools, type CodeToolsConfig, CODE_ROLE, assembleFullBodyToo
 export { capAggregateToolResults, AGGREGATE_TOOL_RESULT_BUDGET_CHARS, DEFAULT_BUDGET_EXEMPT_TOOLS, type AggregateBudgetOptions, } from "./core/tool-result-budget.js";
 export { capAggregateMediaBytes, AGGREGATE_MEDIA_BUDGET_BYTES, type MediaStripInfo } from "./core/media-byte-cap.js";
 export { createAskUserQuestionTool, createDurableQuestionPolicy, QUESTION_AWAITS_RESUME, type OnQuestion, type AskQuestion, type AskQuestionOption, type AskQuestionRequest, type QuestionAnswer, type QuestionAnswerItem, } from "./core/ask-question.js";
-export { createLspTool, gitCheckIgnoreFilter, LSP_OPERATIONS, type LspOperation, type LspServerManager, type LspSession, type LspResult, type LspLocation, type LspSymbolInfo, type LspRequestParams, type LspToolOptions, type LspTransport, type LspReadText, } from "./core/lsp.js";
+export { createLspTool, gitCheckIgnoreFilter, LSP_OPERATIONS, LSP_FAILURE_BRAND, brandLspFailure, lspFailureOf, type LspNoneReason, type LspOperation, type LspServerManager, type LspSession, type LspResult, type LspLocation, type LspSymbolInfo, type LspRequestParams, type LspToolOptions, type LspTransport, type LspReadText, } from "./core/lsp.js";
 export { buildRequest, parseResult, callHierarchyMethod, pathToUri } from "./core/lsp-protocol.js";
 export { TransportLspSession, type SessionWarmup } from "./core/lsp-session.js";
 export { LspDiagnosticsRegistry, formatDiagnosticsBlock, formatDiagnosticsSummary, type LspDiagnostic, type LspFileDiagnostics, } from "./core/lsp-diagnostics.js";
@@ -153,7 +153,7 @@ export { FileWorkflowRunStore, type FileWorkflowRunStoreOptions } from "./stores
 export { workflowRunStoreContract } from "./core/workflow-run-store-contract.js";
 export { type BackgroundAgentStore, type BackgroundAgentRecord, type BackgroundAgentRowSummary, type BackgroundAgentUsage, canAccessAgentRecord, BackgroundAgentStoreError, InMemoryBackgroundAgentStore, reconcileParkedAgents, } from "./core/background-agent-store.js";
 export { FileBackgroundAgentStore, type FileBackgroundAgentStoreOptions } from "./stores/file/background-agent-store.js";
-export { type WorkflowJournalStore, type WorkflowJournalEntry, InMemoryWorkflowJournalStore, callKeyOrdinal, } from "./core/workflow-journal-store.js";
+export { type WorkflowJournalStore, type WorkflowJournalEntry, InMemoryWorkflowJournalStore, callKeyOrdinal, JOURNAL_OVERSIZE_ERROR_CODE, } from "./core/workflow-journal-store.js";
 export { untrustedEgressForHuman, redactHostLeaks, redactSecrets, boundedRedactedSummary } from "./core/untrusted-egress.js";
 export { MemoryRosterStore, FileRosterStore, type RosterStore, type RosterEntry, type RosterAccess, type RosterGcOptions } from "./agents/roster-store.js";
 export { CONFIG_CATALOG_VERSION, describeConfigCatalog, resolveEffectiveConfig, type ConfigKnob, type ConfigOverrideDeclaration, type ConfigProvenance, type EffectiveConfigField, } from "./config/catalog.js";

package/dist/index.js

@@ -11,7 +11,7 @@ export { assembleCodeTools, CODE_ROLE, assembleFullBodyTools, FULL_BODY_ROLE } f
 export { capAggregateToolResults, AGGREGATE_TOOL_RESULT_BUDGET_CHARS, DEFAULT_BUDGET_EXEMPT_TOOLS, } from "./core/tool-result-budget.js";
 export { capAggregateMediaBytes, AGGREGATE_MEDIA_BUDGET_BYTES } from "./core/media-byte-cap.js";
 export { createAskUserQuestionTool, createDurableQuestionPolicy, QUESTION_AWAITS_RESUME, } from "./core/ask-question.js";
-export { createLspTool, gitCheckIgnoreFilter, LSP_OPERATIONS, } from "./core/lsp.js";
+export { createLspTool, gitCheckIgnoreFilter, LSP_OPERATIONS, LSP_FAILURE_BRAND, brandLspFailure, lspFailureOf, } from "./core/lsp.js";
 export { buildRequest, parseResult, callHierarchyMethod, pathToUri } from "./core/lsp-protocol.js";
 export { TransportLspSession } from "./core/lsp-session.js";
 export { LspDiagnosticsRegistry, formatDiagnosticsBlock, formatDiagnosticsSummary, } from "./core/lsp-diagnostics.js";
@@ -140,7 +140,7 @@ export { FileWorkflowRunStore } from "./stores/file/workflow-run-store.js";
 export { workflowRunStoreContract } from "./core/workflow-run-store-contract.js";
 export { canAccessAgentRecord, BackgroundAgentStoreError, InMemoryBackgroundAgentStore, reconcileParkedAgents, } from "./core/background-agent-store.js";
 export { FileBackgroundAgentStore } from "./stores/file/background-agent-store.js";
-export { InMemoryWorkflowJournalStore, callKeyOrdinal, } from "./core/workflow-journal-store.js";
+export { InMemoryWorkflowJournalStore, callKeyOrdinal, JOURNAL_OVERSIZE_ERROR_CODE, } from "./core/workflow-journal-store.js";
 export { untrustedEgressForHuman, redactHostLeaks, redactSecrets, boundedRedactedSummary } from "./core/untrusted-egress.js";
 export { MemoryRosterStore, FileRosterStore } from "./agents/roster-store.js";
 export { CONFIG_CATALOG_VERSION, describeConfigCatalog, resolveEffectiveConfig, } from "./config/catalog.js";

package/dist/orchestration/run-workflow-tool.d.ts

@@ -25,6 +25,7 @@ export interface WorkflowCompletionNotifier {
         result?: string;
         usage?: unknown;
         diagnostics?: string;
+        completionId?: string;
     }): Promise<void> | void;
     ackServed?(input: {
         runId: string;

package/dist/orchestration/run-workflow-tool.js

@@ -1,5 +1,5 @@
 import { Type } from "typebox";
-import { defineTool } from "../core/tools.js";
+import { defineTool, errorResult } from "../core/tools.js";
 import { redactSecrets, redactHostLeaks, boundedRedactedSummary } from "../core/untrusted-egress.js";
 import { startWorkflow } from "./workflow.js";
 import { buildWorkflowPrimitives } from "./workflow-primitives.js";
@@ -27,8 +27,19 @@ function completionSummary(name, run) {
     const failed = run.agents.filter((a) => a.status === "failed").length;
     const secs = run.endedAt !== undefined ? Math.max(0, Math.round((run.endedAt - run.startedAt) / 1000)) : undefined;
     const elapsed = secs === undefined ? "" : secs >= 60 ? ` in ${Math.floor(secs / 60)}m${secs % 60}s` : ` in ${secs}s`;
+    const resumeClause = run.resume === undefined
+        ? ""
+        : run.resume.journalEntries === 0
+            ? "; resume found NO journal entries — nothing replayed, the whole script re-ran live"
+            : `; resume: replayed ${run.resume.replayed} of ${run.resume.journalEntries} journaled results`;
     return (`workflow${cleanName ? ` "${cleanName}"` : ""} completed${elapsed} — agents ${done}/${run.agents.length} done` +
-        `${failed > 0 ? ` (${failed} failed)` : ""}; full result + per-agent rows via TaskOutput("${run.id}")`);
+        `${failed > 0 ? ` (${failed} failed)` : ""}${resumeClause}; full result + per-agent rows via TaskOutput("${run.id}")`);
+}
+function completionIdFromRejection(err) {
+    if (err === null || (typeof err !== "object" && typeof err !== "function"))
+        return undefined;
+    const run = err.workflowRun;
+    return run?.completionId;
 }
 function workflowUsageBlock(run) {
     const agents = run.agents;
@@ -38,19 +49,26 @@ function workflowUsageBlock(run) {
         agents_done: agents.filter((a) => a.status === "completed").length,
         agents_error: agents.filter((a) => a.status === "failed").length,
         agents_empty_result: agents.filter((a) => a.status === "completed" && (a.output === undefined || a.output === "")).length,
+        agents_replayed: agents.filter((a) => a.replayed === true).length,
+        ...(run.journalSkips !== undefined && run.journalSkips > 0 ? { journal_skipped: run.journalSkips } : {}),
+        ...(run.resume !== undefined ? { resume_journal_entries: run.resume.journalEntries } : {}),
         subagent_tokens: run.stats.tokens + run.stats.nested.tokens,
         tool_uses: agents.reduce((n, a) => n + (a.toolCalls ?? 0), 0),
         ...(run.endedAt !== undefined ? { duration_ms: run.endedAt - run.startedAt } : {}),
     };
 }
-function workflowDiagnostics(runId, journalRef) {
+function workflowDiagnostics(runId, journalRef, resumeMiss) {
     const journalTeach = journalRef === undefined
         ? ""
         : journalRef.includes("://")
             ? ` Full journal: ${journalRef}.`
             : ` Full journal: ${journalRef} (a deployment data path — if Read is denied there, use the TaskOutput route above instead).`;
+    const resumeMissTeach = resumeMiss
+        ? ` NOTE: this was a resume, but the prior run's journal was not usable under this scope — verify the runId and that this deployment wires a journalStore; the results above are from a full live re-run.`
+        : "";
     return (`Per-agent rows (status / error / elapsed): TaskOutput({ task_id: "${runId}" }) — read them before assuming an empty or unexpected result.` +
         journalTeach +
+        resumeMissTeach +
         ` To continue after editing the script: re-invoke with resumeFromRunId: "${runId}" (completed agents replay from the journal; only new/changed calls run).`);
 }
 const SCRIPT_ERROR_CODES = new Set([
@@ -151,7 +169,7 @@ export async function createRunWorkflowTool(d) {
     const builtinsEnabled = d.builtinWorkflows !== false;
     const namedWorkflowSection = renderNamedWorkflowListing(await collectNamedWorkflowListings(d.scriptStore, builtinsEnabled));
     const sizeGuidelineSection = workflowSizeGuidelineSection(d.sizeGuideline ?? lim.sizeGuideline);
-    const structuredError = (message) => ({ content: JSON.stringify({ error: message }) });
+    const structuredError = (message) => errorResult(JSON.stringify({ error: message }));
     return defineTool({
         name: RUN_WORKFLOW_TOOL_NAME,
         aliases: ["RunWorkflow", "run_workflow"],
@@ -460,6 +478,7 @@ export async function createRunWorkflowTool(d) {
                         ...(notification.result !== undefined ? { result: redactHostLeaks(notification.result) } : {}),
                         ...(notification.usage !== undefined ? { usage: notification.usage } : {}),
                         ...(notification.diagnostics !== undefined ? { diagnostics: redactHostLeaks(notification.diagnostics) } : {}),
+                        ...(notification.completionId !== undefined ? { completionId: notification.completionId } : {}),
                     }))
                         .catch(() => { });
                 };
@@ -472,7 +491,8 @@ export async function createRunWorkflowTool(d) {
                     summary: completionSummary(meta.name, res.run),
                     result: boundedRedactedSummary(res.result, 4000),
                     usage: workflowUsageBlock(res.run),
-                    diagnostics: workflowDiagnostics(runId, d.journalStore?.locator?.(runId, res.run.scope)),
+                    diagnostics: workflowDiagnostics(runId, d.journalStore?.locator?.(runId, res.run.scope), res.run.resume?.journalEntries === 0),
+                    completionId: res.run.completionId,
                 }), (err) => fire({
                     task_id: runId,
                     task_type: "workflow",
@@ -480,6 +500,7 @@ export async function createRunWorkflowTool(d) {
                     status: "failed",
                     summary: failureSummary(err, runId),
                     diagnostics: workflowDiagnostics(runId, undefined),
+                    ...(completionIdFromRejection(err) !== undefined ? { completionId: completionIdFromRejection(err) } : {}),
                 }))
                     .catch(() => { });
             }
@@ -504,7 +525,8 @@ export async function createRunWorkflowTool(d) {
                     summary: completionSummary(meta.name, res.run),
                     result: boundedRedactedSummary(res.result, 4000),
                     usage: workflowUsageBlock(res.run),
-                    diagnostics: workflowDiagnostics(runId, d.journalStore?.locator?.(runId, res.run.scope)),
+                    diagnostics: workflowDiagnostics(runId, d.journalStore?.locator?.(runId, res.run.scope), res.run.resume?.journalEntries === 0),
+                    completionId: res.run.completionId,
                 }), (err) => fire({
                     task_id: runId,
                     task_type: "workflow",
@@ -512,6 +534,7 @@ export async function createRunWorkflowTool(d) {
                     status: "failed",
                     summary: failureSummary(err, runId),
                     diagnostics: workflowDiagnostics(runId, undefined),
+                    ...(completionIdFromRejection(err) !== undefined ? { completionId: completionIdFromRejection(err) } : {}),
                 }))
                     .catch(() => { });
             }