@sema-agent/core 1.452.0 → 2.0.0

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.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 {

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 {};

package/dist/core/mcp.js

@@ -6,6 +6,7 @@ import { lstat, mkdir, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { ElicitRequestSchema, ErrorCode, ListResourcesResultSchema, McpError } from "@modelcontextprotocol/sdk/types.js";
+import { MCP_IMAGE_MAX_BASE64, sharpImageResizer } from "./image-downsample.js";
 import { truncateError } from "./tool-errors.js";
 import { delimitUntrusted, inlineUntrusted, sanitizeUntrustedText } from "./untrusted-text.js";
 import { validateJsonSchemaShape } from "./runner/strict-output-schema.js";
@@ -204,10 +205,7 @@ export function clampNameSegment(seg, max = 64) {
     const keep = max - digest.length - 1;
     return keep > 0 ? `${seg.slice(0, keep)}_${digest}` : digest.slice(0, max);
 }
-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 * from "./image-downsample.js";
 const MCP_BLOB_DIR = join(tmpdir(), "sema-mcp-blobs");
 function extensionForMime(mimeType) {
     if (!mimeType)
@@ -267,99 +265,6 @@ async function blobToTextBlock(base64Data, mimeType, server, prefix, refetchHint
     }
     return { type: "text", text: `${prefix}Binary content (${mt}, ${r.bytes} bytes) saved to ${r.filePath}` };
 }
-export function makeImageDownsampler(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 makeImageDownsampler((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 };
-    };
-}
 async function boundedImageBlock(data, mimeType, server, resizer) {
     if (data.length <= MCP_IMAGE_MAX_BASE64)
         return { type: "image", data, mimeType };

package/dist/core/media-byte-cap.d.ts

@@ -1,4 +1,4 @@
-import type { AgentMessage } from "../internal/harness.js";
+import type { AgentMessage } from "../internal/harness-types.js";
 export declare const AGGREGATE_MEDIA_BUDGET_BYTES: number;
 export interface MediaStripInfo {
     totalBytes: number;

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

@@ -1,5 +1,4 @@
 import type { MemoryNoteHeader, MemoryNoteRecord, MemoryStore } from "./memory.js";
-import type { ModelRef, TaskSpec, TaskResult } from "./types.js";
 export declare const DEFAULT_MAX_SELECTED = 5;
 export declare const DEFAULT_MAX_LINKED = 3;
 export declare const DEFAULT_SELECT_TIMEOUT_MS = 5000;
@@ -38,8 +37,6 @@ export declare function resolveLinkedIds(headers: MemoryNoteHeader[], selected:
 export declare function buildManifestText(headers: MemoryNoteHeader[]): string;
 export declare function validateSelectedIds(headers: MemoryNoteHeader[], ids: string[], max: number): string[];
 export declare function composeSelectiveBody(manifestText: string, selected: MemoryNoteRecord[], nowMs: number, linked?: MemoryNoteRecord[], recallable?: boolean): string;
-export declare function composeSelectiveMemoryBlock(scope: string, manifestText: string, selected: MemoryNoteRecord[], nowMs: number, linked?: MemoryNoteRecord[]): string;
-export declare function selectAndComposeMemory(opts: SelectiveRecallOptions): Promise<SelectiveRecallResult>;
 export declare function encodeSurfacedKey(scope: string, id: string): string;
 export interface ScopedNoteHeader extends MemoryNoteHeader {
     scope: string;
@@ -70,12 +67,3 @@ export type LayeredRecallResult = {
     degrade: true;
     surfacedKeys: string[];
 };
-export declare function selectAndComposeLayeredMemory(opts: LayeredRecallOptions): Promise<LayeredRecallResult>;
-export interface MemorySelectorRunner {
-    runTask(spec: TaskSpec): Promise<TaskResult>;
-}
-export declare function createBrainMemorySelector(runner: MemorySelectorRunner, opts?: {
-    model?: ModelRef;
-    timeoutSec?: number;
-    release?: (sessionId: string) => Promise<void> | void;
-}): MemorySelector;

package/dist/core/memory-recall.js

@@ -1,4 +1,3 @@
-import { Type } from "typebox";
 import { sanitizeUntrustedText } from "./untrusted-text.js";
 export const DEFAULT_MAX_SELECTED = 5;
 export const DEFAULT_MAX_LINKED = 3;
@@ -125,227 +124,6 @@ export function composeSelectiveBody(manifestText, selected, nowMs, linked = [],
         : "";
     return `${manifestSection}${selectedSection}`;
 }
-export function composeSelectiveMemoryBlock(scope, manifestText, selected, nowMs, linked = []) {
-    return (`<user_memory scope="${scope}" mode="selective">\n` +
-        `${RECALL_CAVEAT}\n\n` +
-        `${composeSelectiveBody(manifestText, selected, nowMs, linked)}\n` +
-        `</user_memory>`);
-}
-export async function selectAndComposeMemory(opts) {
-    if (!opts.store.listStructuredNotes || !opts.store.getByIds)
-        return { degrade: true, surfacedIds: [] };
-    const allHeaders = await opts.store.listStructuredNotes(opts.scope);
-    if (allHeaders.length === 0)
-        return { degrade: true, surfacedIds: [] };
-    const headers = opts.priorSurfacedIds?.size
-        ? allHeaders.filter((h) => !opts.priorSurfacedIds.has(h.id))
-        : allHeaders;
-    if (headers.length === 0)
-        return { block: undefined, surfacedIds: [] };
-    const manifestText = buildManifestText(headers);
-    const max = opts.maxSelected ?? DEFAULT_MAX_SELECTED;
-    const timeoutMs = opts.timeoutMs ?? DEFAULT_SELECT_TIMEOUT_MS;
-    const ac = new AbortController();
-    if (opts.signal?.aborted)
-        ac.abort();
-    const onOuterAbort = () => ac.abort();
-    opts.signal?.addEventListener("abort", onOuterAbort, { once: true });
-    let ids;
-    try {
-        ids = await withTimeout(opts.selector({ objective: opts.objective, manifest: headers, recentTools: opts.recentTools }, ac.signal), timeoutMs, () => ac.abort());
-    }
-    catch {
-        return { degrade: true, surfacedIds: [] };
-    }
-    finally {
-        opts.signal?.removeEventListener("abort", onOuterAbort);
-    }
-    const chosen = validateSelectedIds(headers, ids, max);
-    const records = chosen.length > 0 ? await opts.store.getByIds(opts.scope, chosen) : [];
-    let linked = [];
-    const maxLinked = opts.maxLinked ?? DEFAULT_MAX_LINKED;
-    if (records.length > 0 && maxLinked > 0) {
-        try {
-            const linkedIds = resolveLinkedIds(headers, records, maxLinked);
-            if (linkedIds.length > 0)
-                linked = await opts.store.getByIds(opts.scope, linkedIds);
-        }
-        catch {
-            linked = [];
-        }
-    }
-    const surfacedIds = [...records.map((r) => r.id), ...linked.map((r) => r.id)];
-    return {
-        block: composeSelectiveMemoryBlock(opts.scope, manifestText, records, opts.nowMs ?? Date.now(), linked),
-        surfacedIds,
-    };
-}
 export function encodeSurfacedKey(scope, id) {
     return `${scope.length}:${scope}:${id}`;
 }
-export async function selectAndComposeLayeredMemory(opts) {
-    if (!opts.store.listStructuredNotes || !opts.store.getByIds)
-        return { degrade: true, surfacedKeys: [] };
-    const listStructuredNotes = opts.store.listStructuredNotes.bind(opts.store);
-    const getByIds = opts.store.getByIds.bind(opts.store);
-    const perScope = await Promise.all(opts.scopes.map(async (scope) => {
-        const headers = await listStructuredNotes(scope);
-        return headers.map((h) => ({ ...h, scope }));
-    }));
-    const allScoped = perScope.flat();
-    if (allScoped.length === 0)
-        return { degrade: true, surfacedKeys: [] };
-    const scoped = opts.priorSurfacedKeys?.size
-        ? allScoped.filter((h) => !opts.priorSurfacedKeys.has(encodeSurfacedKey(h.scope, h.id)))
-        : allScoped;
-    if (scoped.length === 0)
-        return { block: undefined, surfacedKeys: [] };
-    const scopeIndex = new Map();
-    opts.scopes.forEach((s, i) => scopeIndex.set(s, i));
-    const tokenOf = (h) => `s${scopeIndex.get(h.scope) ?? 0}#${h.id}`;
-    const byToken = new Map();
-    const manifestHeaders = scoped.map((h) => {
-        const token = tokenOf(h);
-        byToken.set(token, h);
-        return { ...h, id: token, description: `[${h.scope}] ${h.description}` };
-    });
-    const max = opts.maxSelected ?? DEFAULT_MAX_SELECTED;
-    const timeoutMs = opts.timeoutMs ?? DEFAULT_SELECT_TIMEOUT_MS;
-    const ac = new AbortController();
-    if (opts.signal?.aborted)
-        ac.abort();
-    const onOuterAbort = () => ac.abort();
-    opts.signal?.addEventListener("abort", onOuterAbort, { once: true });
-    let chosenTokens;
-    try {
-        const ids = await withTimeout(opts.selector({ objective: opts.objective, manifest: manifestHeaders, recentTools: opts.recentTools }, ac.signal), timeoutMs, () => ac.abort());
-        chosenTokens = validateSelectedIds(manifestHeaders, ids, max);
-    }
-    catch {
-        return { degrade: true, surfacedKeys: [] };
-    }
-    finally {
-        opts.signal?.removeEventListener("abort", onOuterAbort);
-    }
-    const wantByScope = new Map();
-    for (const token of chosenTokens) {
-        const h = byToken.get(token);
-        if (!h)
-            continue;
-        const arr = wantByScope.get(h.scope) ?? [];
-        arr.push(h.id);
-        wantByScope.set(h.scope, arr);
-    }
-    const maxLinked = opts.maxLinked ?? DEFAULT_MAX_LINKED;
-    const recordsByScope = new Map();
-    const linkedByScope = new Map();
-    const scopedHeadersByScope = new Map();
-    for (const h of scoped) {
-        const arr = scopedHeadersByScope.get(h.scope) ?? [];
-        arr.push(h);
-        scopedHeadersByScope.set(h.scope, arr);
-    }
-    for (const [scope, ids] of wantByScope) {
-        const records = ids.length > 0 ? await getByIds(scope, ids) : [];
-        recordsByScope.set(scope, records);
-        if (records.length > 0 && maxLinked > 0) {
-            try {
-                const linkedIds = resolveLinkedIds(scopedHeadersByScope.get(scope) ?? [], records, maxLinked);
-                if (linkedIds.length > 0)
-                    linkedByScope.set(scope, await getByIds(scope, linkedIds));
-            }
-            catch {
-            }
-        }
-    }
-    const nowMs = opts.nowMs ?? Date.now();
-    const recallableScope = opts.scopes[0];
-    const surfacedKeys = [];
-    const subsections = [];
-    for (const scope of opts.scopes) {
-        const records = recordsByScope.get(scope) ?? [];
-        const linked = linkedByScope.get(scope) ?? [];
-        if (records.length === 0 && linked.length === 0)
-            continue;
-        for (const r of records)
-            surfacedKeys.push(encodeSurfacedKey(scope, r.id));
-        for (const r of linked)
-            surfacedKeys.push(encodeSurfacedKey(scope, r.id));
-        const recallable = scope === recallableScope;
-        const body = composeSelectiveBody(recallable ? buildManifestText(scopedHeadersByScope.get(scope) ?? []) : "", records, nowMs, linked, recallable);
-        subsections.push(`<scope name="${sanitizeUntrustedText(scope, ["user_memory"])}">\n${body}\n</scope>`);
-    }
-    if (subsections.length === 0)
-        return { block: undefined, surfacedKeys: [] };
-    return {
-        block: `<user_memory mode="selective">\n${RECALL_CAVEAT}\n\n${subsections.join("\n")}\n</user_memory>`,
-        surfacedKeys,
-    };
-}
-const SELECT_PROMPT = "You choose which long-term memory notes are relevant to the current task. You are given the task and a " +
-    "numbered manifest of note ids + descriptions. Return ONLY the ids that are clearly useful for this task " +
-    "(at most a handful). If you are unsure, leave it out — an empty list is fine. For any tool the task will " +
-    "use, keep notes about its gotchas/warnings/known-issues but skip pure usage/API notes (that is when " +
-    "gotchas matter most). Never invent an id that is not in the manifest.";
-export function createBrainMemorySelector(runner, opts = {}) {
-    const schema = Type.Object({ ids: Type.Array(Type.String()) });
-    return async (req, signal) => {
-        const manifest = sanitizeUntrustedText(buildManifestText(req.manifest), ["user_memory"]);
-        const tools = req.recentTools?.length ? `\n\nTools this task will use: ${req.recentTools.join(", ")}.` : "";
-        const objective = `TASK:\n${req.objective}${tools}\n\nMEMORY MANIFEST (id: description):\n${manifest}\n\nReturn the relevant note ids.`;
-        const selectorSessionId = `memsel-${globalThis.crypto.randomUUID()}`;
-        let r;
-        try {
-            r = await runner.runTask({
-                objective,
-                systemPrompt: SELECT_PROMPT,
-                ...(opts.model ? { model: opts.model } : {}),
-                sessionId: selectorSessionId,
-                tools: [],
-                outputSchema: schema,
-                enableBlockedReport: false,
-                memory: undefined,
-                limits: { timeoutSec: opts.timeoutSec ?? 20, maxTurns: 2 },
-                signal,
-            });
-        }
-        catch (e) {
-            try {
-                if (opts.release)
-                    await opts.release(selectorSessionId);
-            }
-            catch {
-            }
-            throw e;
-        }
-        try {
-            if (r.status !== "completed") {
-                throw new Error(`memory-select sub-task did not complete (status=${r.status}) — degrading to inject-all`);
-            }
-            const out = r.structuredOutput;
-            if (!out || !Array.isArray(out.ids)) {
-                throw new Error("memory-select sub-task produced no { ids } output — degrading to inject-all");
-            }
-            return out.ids.filter((x) => typeof x === "string");
-        }
-        finally {
-            if (opts.release)
-                await opts.release(r.sessionId);
-        }
-    };
-}
-function withTimeout(p, ms, onTimeout) {
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
-            onTimeout?.();
-            reject(new Error("memory-select timeout"));
-        }, ms);
-        p.then((v) => {
-            clearTimeout(timer);
-            resolve(v);
-        }, (e) => {
-            clearTimeout(timer);
-            reject(e);
-        });
-    });
-}

package/dist/core/memory.d.ts

@@ -1,4 +1,3 @@
-import type { AgentTool } from "../internal/harness.js";
 export interface ScoredMemory {
     id: string;
     text: string;
@@ -104,8 +103,3 @@ export declare function composeLayeredMemoryBlock(layers: ReadonlyArray<{
     scope: string;
     content: string | null | undefined;
 }>): string | undefined;
-export declare function createRecallTool(store: MemoryStore, scope: string): AgentTool;
-export declare function createRememberTool(store: MemoryStore, scope: string, onRemembered?: (note: {
-    id?: string;
-    text: string;
-}) => void): AgentTool;

package/dist/core/memory.js

@@ -1,6 +1,4 @@
-import { Type } from "typebox";
 import { uuidv7 } from "../internal/harness.js";
-import { defineTool } from "./tools.js";
 import { parseScopeKey } from "./memory-engine/scope-contract.js";
 import { sanitizeUntrustedText } from "./untrusted-text.js";
 export function supportsConsolidation(store) {
@@ -425,89 +423,3 @@ export function composeLayeredMemoryBlock(layers) {
         return undefined;
     return `<user_memory>\n${sections.join("\n")}\n</user_memory>`;
 }
-const REMEMBER_DESCRIPTION = "Append a durable note to long-term memory so it survives across sessions. Use this when you " +
-    "notice a stable preference, convention, or fact worth keeping (e.g. 'User prefers concise " +
-    "answers', 'The orders table is read-only'). Phrase it as a declarative fact, NOT an instruction " +
-    "to your future self, and NOT transient task state. Single, durable sentences only. Optionally tag " +
-    "it with a `type` (user | feedback | project | reference) so it can be recalled more precisely. " +
-    "For feedback/project notes, include WHY (the reason is what makes the note applicable later).";
-export function createRecallTool(store, scope) {
-    return defineTool({
-        name: "Recall",
-        aliases: ["recall"],
-        contract: { contractId: "core.recall@1", implementationRevision: "1" },
-        description: "Search your long-term memory for durable facts/preferences relevant to a query. Use this " +
-            "to retrieve a specific remembered detail on demand (in addition to what is already in your " +
-            "system prompt). Returns matching notes, or nothing if none match. Pass \"*\" (or an empty " +
-            "query) to LIST the most recent memories instead of keyword-matching.",
-        effect: "read",
-        parameters: Type.Object({
-            query: Type.String({ description: "Keywords to search remembered notes for, or \"*\" to list recent memories." }),
-        }),
-        execute: async (args) => {
-            const query = String(args.query ?? "").trim();
-            if (query === "" || query === "*" || query.toLowerCase() === "all") {
-                const full = await store.read(scope);
-                const text = (full ?? "").trim();
-                const entries = text
-                    ? (/^- /m.test(text) ? text.split(/\n(?=- )/) : text.split("\n")).map((l) => l.trim()).filter(Boolean)
-                    : [];
-                if (entries.length === 0) {
-                    return { content: "No memories stored yet.", details: { type: "memory-recall", count: 0 } };
-                }
-                const recent = entries.slice(-20);
-                const header = entries.length > recent.length ? `[showing the ${recent.length} most recent of ${entries.length} memories]\n` : "";
-                return { content: header + sanitizeUntrustedText(recent.join("\n")), details: { type: "memory-recall", count: recent.length } };
-            }
-            if (!store.search) {
-                return { content: "No memory matches.", details: { type: "memory-recall", count: 0 } };
-            }
-            const matches = await store.search(scope, query);
-            return {
-                content: matches.length ? sanitizeUntrustedText(matches.join("\n")) : "No memory matches.",
-                details: { type: "memory-recall", count: matches.length },
-            };
-        },
-    });
-}
-export function createRememberTool(store, scope, onRemembered) {
-    return defineTool({
-        name: "Remember",
-        aliases: ["remember"],
-        contract: { contractId: "core.remember@1", implementationRevision: "1" },
-        effect: "write",
-        description: REMEMBER_DESCRIPTION,
-        parameters: Type.Object({
-            note: Type.String({ description: "A single durable, declarative fact or preference to remember." }),
-            type: Type.Optional(Type.String({ description: "Optional category: user | feedback | project | reference (default project)." })),
-            description: Type.Optional(Type.String({ description: "Optional one-line summary for the memory index (default: the note's first sentence)." })),
-        }),
-        execute: async (args) => {
-            const a = args;
-            const note = String(a.note ?? "").trim();
-            if (!note) {
-                return { content: "Nothing remembered (empty note).", details: { ok: false }, isError: true };
-            }
-            const oneLine = (v, cap) => {
-                if (typeof v !== "string")
-                    return undefined;
-                const t = v.replace(/\s+/g, " ").trim();
-                return t ? t.slice(0, cap) : undefined;
-            };
-            const type = oneLine(a.type, 32);
-            const description = oneLine(a.description, 300);
-            let id;
-            if (store.appendStructured) {
-                id = await store.appendStructured(scope, { body: note, type, description });
-            }
-            else {
-                id = await store.append(scope, note);
-            }
-            onRemembered?.({ id: typeof id === "string" ? id : undefined, text: note });
-            return {
-                content: `Remembered: ${note}`,
-                details: { type: "memory-saved", ok: true, note, memoryType: type, description, ...(typeof id === "string" ? { id } : {}) },
-            };
-        },
-    });
-}

package/dist/core/message-utils.d.ts

@@ -1,3 +1,3 @@
-import type { AgentMessage } from "../internal/harness.js";
+import type { AgentMessage } from "../internal/harness-types.js";
 export declare function messageRole(m: AgentMessage): string | undefined;
 export declare function isToolResult(m: AgentMessage): boolean;