@sema-agent/core 1.451.0 → 2.0.0

package/dist/core/exec-output-tail.js

@@ -1,9 +1,11 @@
+import { StringDecoder } from "node:string_decoder";
 export const MAX_EXEC_OUTPUT_BYTES = 8 * 1024 * 1024;
 export class RollingTailBuffer {
     maxBytes;
     chunks = [];
     size = 0;
-    dropped = 0;
+    headDropped = 0;
+    sourceSkipped = 0;
     constructor(maxBytes = MAX_EXEC_OUTPUT_BYTES) {
         this.maxBytes = maxBytes;
     }
@@ -18,25 +20,62 @@ export class RollingTailBuffer {
             if (over >= head.length) {
                 this.chunks.shift();
                 this.size -= head.length;
-                this.dropped += head.length;
+                this.headDropped += head.length;
             }
             else {
                 this.chunks[0] = head.subarray(over);
                 this.size -= over;
-                this.dropped += over;
+                this.headDropped += over;
             }
         }
     }
     recordSkippedBytes(n) {
         if (n > 0)
-            this.dropped += n;
+            this.sourceSkipped += n;
     }
     result() {
-        return { text: Buffer.concat(this.chunks).toString("utf8"), droppedBytes: this.dropped };
+        return { text: Buffer.concat(this.chunks).toString("utf8"), droppedBytes: this.headDropped + this.sourceSkipped };
     }
+    bytes() {
+        return Buffer.concat(this.chunks);
+    }
+    headDroppedBytes() {
+        return this.headDropped;
+    }
+    sourceSkippedBytes() {
+        return this.sourceSkipped;
+    }
+}
+export function newStreamCursorState(tail = new RollingTailBuffer()) {
+    return { tail, cursorBytes: 0, acceptedBytes: 0, disclosedSkippedBytes: 0, decoder: new StringDecoder("utf8") };
+}
+export function sliceStreamIncrement(s, terminal) {
+    const headDropped = s.tail.headDroppedBytes();
+    const sourceSkipped = s.tail.sourceSkippedBytes();
+    const newSkipped = Math.max(0, sourceSkipped - s.disclosedSkippedBytes);
+    s.disclosedSkippedBytes = sourceSkipped;
+    const droppedBeforeCursor = Math.max(0, headDropped - s.cursorBytes) + newSkipped;
+    const buf = s.tail.bytes();
+    const startInTail = Math.min(Math.max(s.cursorBytes, headDropped) - headDropped, buf.length);
+    const incBuf = startInTail <= 0 ? buf : buf.subarray(startInTail);
+    if (droppedBeforeCursor > 0)
+        s.decoder = new StringDecoder("utf8");
+    let inc = s.decoder.write(incBuf);
+    if (terminal) {
+        inc += s.decoder.end();
+        s.decoder = new StringDecoder("utf8");
+    }
+    s.cursorBytes = s.acceptedBytes;
+    return { inc, droppedBeforeCursor };
 }
 export function markTruncated(text, droppedBytes) {
     return droppedBytes > 0
         ? `[... ${droppedBytes} earlier byte(s) truncated; showing last ${Buffer.byteLength(text, "utf8")} ...]\n${text}`
         : text;
 }
+export function markLiveSpoolRotations(text, liveRotations) {
+    if (liveRotations <= 0)
+        return text;
+    const note = `[spool reclaimed ${liveRotations} time(s) while the process was still writing; bytes appended during those windows may be missing beyond any counted truncation]`;
+    return text === "" ? note : `${text}${text.endsWith("\n") ? "" : "\n"}${note}`;
+}

package/dist/core/file-snapshot-store.d.ts

@@ -1,4 +1,4 @@
-import type { ExecutionEnv } from "../internal/harness.js";
+import type { ExecutionEnv } from "../internal/harness-types.js";
 export interface FileSnapshotError {
     code: "too_large" | "enumerate_failed" | "read_failed" | "restore_failed" | "not_found" | "aborted";
     message: string;

package/dist/core/fs-write-gate-policy.d.ts

@@ -1,4 +1,4 @@
-import type { ExecutionEnv } from "../internal/harness.js";
+import type { ExecutionEnv } from "../internal/harness-types.js";
 import type { ToolPolicy } from "./tool-policy.js";
 export interface FsWriteGatePolicyOptions {
     env: ExecutionEnv;

package/dist/core/git-worktree-env.d.ts

@@ -1,4 +1,4 @@
-import type { ExecutionEnv } from "../internal/harness.js";
+import type { ExecutionEnv } from "../internal/harness-types.js";
 export declare const WORKTREE_PARENT = ".sema-worktrees";
 export interface AddWorktreeOptions {
     repoRoot: string;

package/dist/core/hooks.d.ts

@@ -1,5 +1,5 @@
 import type { DocumentContent, ImageContent, TextContent } from "../internal/llm.js";
-import type { SessionTreeEntry } from "../internal/harness.js";
+import type { SessionTreeEntry } from "../internal/harness-types.js";
 import type { PermissionResult, ResolvedAsk, ToolCallRequest } from "./tool-policy.js";
 export interface Hooks {
     preToolUse?(toolName: string, input: unknown, ctx: HookToolContext): PreToolUseResult | undefined | Promise<PreToolUseResult | undefined>;

package/dist/core/image-downsample.d.ts

@@ -0,0 +1,44 @@
+export declare const MCP_IMAGE_MAX_BASE64: number;
+export declare const IMAGE_TARGET_RAW_SIZE: number;
+export declare const IMAGE_MAX_WIDTH = 2000;
+export declare const IMAGE_MAX_HEIGHT = 2000;
+export type McpImageResizer = (base64: string, mimeType: string) => Promise<{
+    base64: string;
+    mimeType: string;
+} | undefined>;
+export interface ImageDimensions {
+    originalWidth: number;
+    originalHeight: number;
+    displayWidth: number;
+    displayHeight: number;
+}
+export interface DownsampledImage {
+    base64: string;
+    mimeType: string;
+    dimensions?: ImageDimensions;
+}
+export type ImageDownsampler = (input: Buffer, mimeType: string) => Promise<DownsampledImage | undefined>;
+type SharpFactory = (input: Buffer) => SharpOps;
+interface SharpOps {
+    metadata: () => Promise<{
+        width?: number;
+        height?: number;
+        format?: string;
+    }>;
+    resize: (w: number, h: number, o: {
+        fit: "inside";
+        withoutEnlargement: boolean;
+    }) => SharpOps;
+    jpeg: (o: {
+        quality: number;
+    }) => SharpOps;
+    png: (o: {
+        compressionLevel: number;
+        palette: boolean;
+    }) => SharpOps;
+    toBuffer: () => Promise<Buffer>;
+}
+export declare function createImageDownsampler(sharp: SharpFactory): ImageDownsampler;
+export declare function sharpImageDownsampler(): Promise<ImageDownsampler | undefined>;
+export declare function sharpImageResizer(): Promise<McpImageResizer | undefined>;
+export {};

package/dist/core/image-downsample.js

@@ -0,0 +1,97 @@
+export const MCP_IMAGE_MAX_BASE64 = 5 * 1024 * 1024;
+export const IMAGE_TARGET_RAW_SIZE = (MCP_IMAGE_MAX_BASE64 * 3) / 4;
+export const IMAGE_MAX_WIDTH = 2000;
+export const IMAGE_MAX_HEIGHT = 2000;
+export function createImageDownsampler(sharp) {
+    const BOX = { fit: "inside", withoutEnlargement: true };
+    return async (input, mimeType) => {
+        if (input.length === 0)
+            return undefined;
+        try {
+            const meta = await sharp(input).metadata();
+            const fmt = meta.format === "jpg" ? "jpeg" : meta.format;
+            const passMime = fmt ? `image/${fmt}` : mimeType;
+            const originalSize = input.length;
+            if (!meta.width || !meta.height) {
+                if (originalSize > IMAGE_TARGET_RAW_SIZE) {
+                    const buf = await sharp(input).jpeg({ quality: 80 }).toBuffer();
+                    return { base64: buf.toString("base64"), mimeType: "image/jpeg" };
+                }
+                return { base64: input.toString("base64"), mimeType: passMime };
+            }
+            const originalWidth = meta.width;
+            const originalHeight = meta.height;
+            let width = originalWidth;
+            let height = originalHeight;
+            const dims = (dw, dh) => ({ originalWidth, originalHeight, displayWidth: dw, displayHeight: dh });
+            if (originalSize <= IMAGE_TARGET_RAW_SIZE && width <= IMAGE_MAX_WIDTH && height <= IMAGE_MAX_HEIGHT) {
+                return { base64: input.toString("base64"), mimeType: passMime, dimensions: dims(width, height) };
+            }
+            const needsDimensionResize = width > IMAGE_MAX_WIDTH || height > IMAGE_MAX_HEIGHT;
+            const isPng = fmt === "png";
+            if (!needsDimensionResize) {
+                if (isPng) {
+                    const png = await sharp(input).png({ compressionLevel: 9, palette: true }).toBuffer();
+                    if (png.length <= IMAGE_TARGET_RAW_SIZE)
+                        return { base64: png.toString("base64"), mimeType: "image/png", dimensions: dims(width, height) };
+                }
+                for (const quality of [80, 60, 40, 20]) {
+                    const buf = await sharp(input).jpeg({ quality }).toBuffer();
+                    if (buf.length <= IMAGE_TARGET_RAW_SIZE)
+                        return { base64: buf.toString("base64"), mimeType: "image/jpeg", dimensions: dims(width, height) };
+                }
+            }
+            if (width > IMAGE_MAX_WIDTH) {
+                height = Math.round((height * IMAGE_MAX_WIDTH) / width);
+                width = IMAGE_MAX_WIDTH;
+            }
+            if (height > IMAGE_MAX_HEIGHT) {
+                width = Math.round((width * IMAGE_MAX_HEIGHT) / height);
+                height = IMAGE_MAX_HEIGHT;
+            }
+            const resized = await sharp(input).resize(width, height, BOX).toBuffer();
+            if (resized.length <= IMAGE_TARGET_RAW_SIZE) {
+                return { base64: resized.toString("base64"), mimeType: passMime, dimensions: dims(width, height) };
+            }
+            if (isPng) {
+                const png = await sharp(input).resize(width, height, BOX).png({ compressionLevel: 9, palette: true }).toBuffer();
+                if (png.length <= IMAGE_TARGET_RAW_SIZE)
+                    return { base64: png.toString("base64"), mimeType: "image/png", dimensions: dims(width, height) };
+            }
+            for (const quality of [80, 60, 40, 20]) {
+                const buf = await sharp(input).resize(width, height, BOX).jpeg({ quality }).toBuffer();
+                if (buf.length <= IMAGE_TARGET_RAW_SIZE)
+                    return { base64: buf.toString("base64"), mimeType: "image/jpeg", dimensions: dims(width, height) };
+            }
+            const smallerWidth = Math.min(width, 1000);
+            const smallerHeight = Math.round((height * smallerWidth) / Math.max(width, 1));
+            const last = await sharp(input).resize(smallerWidth, smallerHeight, BOX).jpeg({ quality: 20 }).toBuffer();
+            return { base64: last.toString("base64"), mimeType: "image/jpeg", dimensions: dims(smallerWidth, smallerHeight) };
+        }
+        catch {
+            return undefined;
+        }
+    };
+}
+const SHARP_LIMIT_INPUT_PIXELS = 100_000_000;
+export async function sharpImageDownsampler() {
+    try {
+        const mod = (await import("sharp"));
+        const real = (mod.default ?? mod);
+        return createImageDownsampler((input) => real(input, { limitInputPixels: SHARP_LIMIT_INPUT_PIXELS }));
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function sharpImageResizer() {
+    const down = await sharpImageDownsampler();
+    if (!down)
+        return undefined;
+    return async (base64, mimeType) => {
+        const out = await down(Buffer.from(base64, "base64"), mimeType).catch(() => undefined);
+        if (!out || out.base64.length > MCP_IMAGE_MAX_BASE64)
+            return undefined;
+        return { base64: out.base64, mimeType: out.mimeType };
+    };
+}

package/dist/core/lsp-session.d.ts

@@ -18,6 +18,7 @@ export declare class TransportLspSession implements LspSession {
     request(op: LspOperation, params: LspRequestParams, signal?: AbortSignal): Promise<LspResult>;
     private syncOpenedFiles;
     private syncOne;
+    private static classifyUnbranded;
     get closed(): boolean;
     openedFiles(): string[];
     warmOpen(filePaths: string[], signal?: AbortSignal): Promise<void>;

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

@@ -1,4 +1,4 @@
-import type { AgentTool, ExecutionEnv } from "../internal/harness.js";
+import type { AgentTool, ExecutionEnv } from "../internal/harness-types.js";
 export type LspOperation = "goToDefinition" | "findReferences" | "hover" | "documentSymbol" | "workspaceSymbol" | "goToImplementation" | "prepareCallHierarchy" | "incomingCalls" | "outgoingCalls";
 export declare const LSP_OPERATIONS: readonly LspOperation[];
 export interface LspLocation {
@@ -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/mcp.d.ts

@@ -1,5 +1,6 @@
-import type { AgentTool } from "../internal/harness.js";
+import type { AgentTool } from "../internal/harness-types.js";
 import type { ImageContent, TextContent } from "../internal/llm.js";
+import { type McpImageResizer } from "./image-downsample.js";
 import type { McpServerSpec, OnElicit, ToolEffect } from "./types.js";
 export interface McpToolAxis {
     name: string;
@@ -69,49 +70,7 @@ export declare const MCP_IDLE_TIMEOUT_HTTP_DEFAULT_MS: number;
 export declare function mcpIdleTimeoutMs(kind: "stdio" | "http"): number;
 export declare function normalizeMcpName(name: string): string;
 export declare function clampNameSegment(seg: string, max?: number): string;
-export declare const MCP_IMAGE_MAX_BASE64: number;
-export declare const IMAGE_TARGET_RAW_SIZE: number;
-export declare const IMAGE_MAX_WIDTH = 2000;
-export declare const IMAGE_MAX_HEIGHT = 2000;
-export type McpImageResizer = (base64: string, mimeType: string) => Promise<{
-    base64: string;
-    mimeType: string;
-} | undefined>;
-export interface ImageDimensions {
-    originalWidth: number;
-    originalHeight: number;
-    displayWidth: number;
-    displayHeight: number;
-}
-export interface DownsampledImage {
-    base64: string;
-    mimeType: string;
-    dimensions?: ImageDimensions;
-}
-export type ImageDownsampler = (input: Buffer, mimeType: string) => Promise<DownsampledImage | undefined>;
-type SharpFactory = (input: Buffer) => SharpOps;
-interface SharpOps {
-    metadata: () => Promise<{
-        width?: number;
-        height?: number;
-        format?: string;
-    }>;
-    resize: (w: number, h: number, o: {
-        fit: "inside";
-        withoutEnlargement: boolean;
-    }) => SharpOps;
-    jpeg: (o: {
-        quality: number;
-    }) => SharpOps;
-    png: (o: {
-        compressionLevel: number;
-        palette: boolean;
-    }) => SharpOps;
-    toBuffer: () => Promise<Buffer>;
-}
-export declare function makeImageDownsampler(sharp: SharpFactory): ImageDownsampler;
-export declare function sharpImageDownsampler(): Promise<ImageDownsampler | undefined>;
-export declare function sharpImageResizer(): Promise<McpImageResizer | undefined>;
+export * from "./image-downsample.js";
 export declare function inferCompactSchema(value: unknown, depth?: number): string;
 export declare function resolveMcpHttpHeaders(t: {
     headers?: Record<string, string>;
@@ -147,4 +106,3 @@ export type McpSchemaNormalizeResult = {
 export declare function normalizeMcpToolSchema(schema: unknown): McpSchemaNormalizeResult;
 export declare function mcpToolSchemaProblem(schema: unknown): string | undefined;
 export declare function materializeMcpTools(specs: McpServerSpec[], principal?: string, onElicit?: OnElicit, imageResizer?: McpImageResizer): Promise<MaterializedMcp>;
-export {};