tinker-agent 2.11.0 → 2.13.0

package/src/memory/memory-search-tool.ts

@@ -1,189 +1,93 @@
-import { throwIfTurnCancelled } from "../agent/turn-cancellation";
-import {
-  defineToolExecutor,
-  type MemorySearchRawResult,
-  type ToolDefinition,
-  type ToolExecutor,
-} from "../tools/types";
-import {
-  MAX_MEMORY_KEYWORD_BYTES,
-  MAX_MEMORY_KEYWORDS,
-  MAX_MEMORY_QUERY_BYTES,
-  MEMORY_SEARCH_TOOL_NAME,
-} from "./contracts";
-
-export const MEMORY_SEARCH_TOOL_DEFINITION: ToolDefinition = Object.freeze({
-  name: MEMORY_SEARCH_TOOL_NAME,
-  description:
-    "Search memories retained from historical conversation turns across sessions and workspaces. Use this proactively when prior user preferences, project decisions, environment facts, or verified solutions may help. Put exact-match terms in `keywords`, put a concise semantic description in `query`, and provide both for hybrid recall. Each result is a historical record containing a one-line index text, a possibly truncated detailed summary, a `memoryId`, and a `sourceSessionId`. Results may be stale or incorrect, so verify current workspace facts with current tools. To read the full stored record for a result, call `MemoryGet` with its `memoryId`.",
-  parameters: {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-      query: {
-        type: "string",
-        minLength: 1,
-        maxLength: MAX_MEMORY_QUERY_BYTES,
-        description:
-          "A concise semantic description of the fact, preference, decision, or solution to recall. Drives vector similarity search.",
-      },
-      keywords: {
-        type: "array",
-        maxItems: MAX_MEMORY_KEYWORDS,
-        items: {
-          type: "string",
-          minLength: 1,
-          maxLength: MAX_MEMORY_KEYWORD_BYTES,
-        },
-        description:
-          "Exact terms to match literally, such as identifiers, error strings, paths, or project names. Drives keyword search. Keywords shorter than 3 characters cannot be matched.",
-      },
-    },
-    required: [],
-  },
-});
+import { defineToolExecutor, type ToolExecutor } from "../tools/types";
+import { boundedMemoryError } from "./contracts";
+import { ensureMemoryDirectory } from "./memory-files";
+import { searchMemoryFiles, type MemorySearchInput } from "./memory-search";
 
 export function createMemorySearchToolExecutor(options: {
-  readonly search: (
-    query: string | null,
-    keywords: readonly string[],
-    signal: AbortSignal,
-  ) => Promise<MemorySearchRawResult>;
-  readonly recordInvalidCall: (input: {
-    readonly queryBytes: number;
-    readonly keywordCount: number;
-  }) => Promise<void>;
+  homeRoot?: string;
 }): ToolExecutor {
   return defineToolExecutor("memory_search", {
-    definition: MEMORY_SEARCH_TOOL_DEFINITION,
-    async execute(args, _call, context): Promise<MemorySearchRawResult> {
-      throwIfTurnCancelled(context.signal);
-      const parsed = parseMemorySearchArgs(args);
-      if (!parsed.ok) {
-        await options.recordInvalidCall({
-          queryBytes: parsed.queryBytes,
-          keywordCount: parsed.keywordCount,
-        });
-        return { ok: false, error: parsed.error };
+    definition: {
+      name: "MemorySearch",
+      description:
+        "Search historical session records and saved notes across workspaces when earlier decisions, preferences, or work may help. Matches any keyword literally, ignoring case, within individual lines. Returns passages grouped by file with line numbers; > marks matching lines and … separates passages. Use Read with offset and limit to expand a passage. Continue using nextOffset with the same keywords and context.",
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          keywords: {
+            type: "array",
+            minItems: 1,
+            items: { type: "string", minLength: 1 },
+            description:
+              "Literal keywords; any one can match. No regular expressions or multiline keywords. A line matching multiple keywords counts once.",
+          },
+          context: {
+            type: "integer",
+            minimum: 0,
+            description:
+              "Lines before and after each matching line. Defaults to 3. Overlapping passages are merged.",
+          },
+          limit: {
+            type: "integer",
+            minimum: 1,
+            description:
+              "Maximum selected matching lines, excluding context. Defaults to 20.",
+          },
+          offset: {
+            type: "integer",
+            minimum: 0,
+            description:
+              "Matching lines to skip. Defaults to 0. Use nextOffset to continue; file changes between searches can affect pagination.",
+          },
+        },
+        required: ["keywords"],
+      },
+    },
+    async execute(args, _call, context) {
+      context.signal.throwIfAborted();
+      try {
+        const input = parseArgs(args);
+        const directory = await ensureMemoryDirectory(options.homeRoot);
+        return await searchMemoryFiles(directory, input, context.signal);
+      } catch (error) {
+        context.signal.throwIfAborted();
+        return { ok: false, error: boundedMemoryError(error) };
       }
-      const result = await options.search(
-        parsed.query,
-        parsed.keywords,
-        context.signal,
-      );
-      throwIfTurnCancelled(context.signal);
-      return result;
     },
   });
 }
 
-type ParsedMemorySearchArgs =
-  | {
-      readonly ok: true;
-      readonly query: string | null;
-      readonly keywords: readonly string[];
-    }
-  | {
-      readonly ok: false;
-      readonly queryBytes: number;
-      readonly keywordCount: number;
-      readonly error: string;
-    };
-
-function invalidMemorySearchArgs(
-  args: Record<string, unknown>,
-  error: string,
-  queryBytes?: number,
-): ParsedMemorySearchArgs {
-  return {
-    ok: false,
-    queryBytes:
-      queryBytes ??
-      (typeof args.query === "string" ? Buffer.byteLength(args.query, "utf8") : 0),
-    keywordCount: Array.isArray(args.keywords) ? args.keywords.length : 0,
-    error,
-  };
-}
-
-function parseMemorySearchArgs(args: unknown): ParsedMemorySearchArgs {
-  if (!isRecord(args)) {
-    return {
-      ok: false,
-      queryBytes: 0,
-      keywordCount: 0,
-      error:
-        "MemorySearch arguments must be an object containing only query and keywords.",
-    };
-  }
-  const unexpected = Object.keys(args).find(
-    (key) => key !== "query" && key !== "keywords",
-  );
-  if (unexpected !== undefined) {
-    return invalidMemorySearchArgs(
-      args,
-      `MemorySearch received unexpected field: ${unexpected}.`,
+function parseArgs(args: unknown): MemorySearchInput {
+  if (args === null || typeof args !== "object" || Array.isArray(args))
+    throw new Error(
+      "MemorySearch requires keywords, with optional context, limit and offset.",
     );
+  const value = args as Record<string, unknown>;
+  for (const name of Object.keys(value)) {
+    if (!["keywords", "context", "limit", "offset"].includes(name))
+      throw new Error(`MemorySearch received unexpected field: ${name}.`);
   }
-
-  let query: string | null = null;
-  if (args.query !== undefined) {
-    if (typeof args.query !== "string") {
-      return invalidMemorySearchArgs(args, "MemorySearch.query must be a string.");
-    }
-    const trimmed = args.query.trim();
-    const bytes = Buffer.byteLength(trimmed, "utf8");
-    if (bytes < 1 || bytes > MAX_MEMORY_QUERY_BYTES) {
-      return invalidMemorySearchArgs(
-        args,
-        `MemorySearch.query must be 1 to ${MAX_MEMORY_QUERY_BYTES} UTF-8 bytes after trimming.`,
-        bytes,
+  if (!Array.isArray(value.keywords) || value.keywords.length === 0)
+    throw new Error("MemorySearch.keywords must be a non-empty array of strings.");
+  const keywords = value.keywords.map((word: unknown) => {
+    if (typeof word !== "string" || word.trim() === "" || /[\r\n]/.test(word))
+      throw new Error("MemorySearch keywords must be non-empty single-line strings.");
+    return word.trim();
+  });
+  const integers = { context: 3, limit: 20, offset: 0 };
+  for (const name of ["context", "limit", "offset"] as const) {
+    const number = value[name];
+    if (number === undefined) continue;
+    if (
+      typeof number !== "number" ||
+      !Number.isSafeInteger(number) ||
+      number < (name === "limit" ? 1 : 0)
+    )
+      throw new Error(
+        `MemorySearch.${name} must be a safe integer >= ${name === "limit" ? 1 : 0}.`,
       );
-    }
-    query = trimmed;
+    integers[name] = number;
   }
-
-  const keywords: string[] = [];
-  if (args.keywords !== undefined) {
-    if (!Array.isArray(args.keywords)) {
-      return invalidMemorySearchArgs(
-        args,
-        "MemorySearch.keywords must be an array of strings.",
-      );
-    }
-    if (args.keywords.length > MAX_MEMORY_KEYWORDS) {
-      return invalidMemorySearchArgs(
-        args,
-        `MemorySearch.keywords may contain at most ${MAX_MEMORY_KEYWORDS} entries.`,
-      );
-    }
-    for (const entry of args.keywords) {
-      if (typeof entry !== "string") {
-        return invalidMemorySearchArgs(
-          args,
-          "Every MemorySearch keyword must be a string.",
-        );
-      }
-      const trimmed = entry.trim();
-      const bytes = Buffer.byteLength(trimmed, "utf8");
-      if (bytes < 1 || bytes > MAX_MEMORY_KEYWORD_BYTES) {
-        return invalidMemorySearchArgs(
-          args,
-          `Every MemorySearch keyword must be 1 to ${MAX_MEMORY_KEYWORD_BYTES} UTF-8 bytes after trimming.`,
-        );
-      }
-      keywords.push(trimmed);
-    }
-  }
-
-  if (query === null && keywords.length === 0) {
-    return invalidMemorySearchArgs(
-      args,
-      "MemorySearch requires a non-empty query or at least one keyword.",
-    );
-  }
-  return { ok: true, query, keywords: Object.freeze(keywords) };
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+  return { keywords, ...integers };
 }

package/src/memory/memory-search.ts

@@ -0,0 +1,115 @@
+import { createReadStream } from "node:fs";
+import { readdir } from "node:fs/promises";
+import path from "node:path";
+import { createInterface } from "node:readline";
+import type { MemoryTextSearchResult, MemorySearchLine } from "../tools/types";
+
+export type MemorySearchInput = {
+  keywords: string[];
+  context: number;
+  limit: number;
+  offset: number;
+};
+
+export async function searchMemoryFiles(
+  directory: string,
+  input: MemorySearchInput,
+  signal: AbortSignal,
+): Promise<MemoryTextSearchResult> {
+  const paths = await markdownFiles(directory, signal);
+  const keywords = input.keywords.map((word) => word.toLowerCase());
+  const files: MemoryTextSearchResult["files"][number][] = [];
+  let seen = 0;
+  let returnedResults = 0;
+  let hasMore = false;
+  for (const filePath of paths) {
+    signal.throwIfAborted();
+    const stream = createReadStream(filePath, { encoding: "utf8", signal });
+    const reader = createInterface({ input: stream, crlfDelay: Infinity });
+    const before: MemorySearchLine[] = [];
+    const selected = new Map<number, MemorySearchLine>();
+    let lineNumber = 0;
+    let through = 0;
+    try {
+      for await (const text of reader) {
+        signal.throwIfAborted();
+        lineNumber++;
+        const folded = text.toLowerCase();
+        let matchAt = -1;
+        for (const keyword of keywords) {
+          const position = folded.indexOf(keyword);
+          if (position >= 0 && (matchAt < 0 || position < matchAt)) matchAt = position;
+        }
+        const match = matchAt >= 0;
+        const line = { lineNumber, match, text: excerpt(text, matchAt) };
+        if (match) {
+          if (seen >= input.offset && returnedResults < input.limit) {
+            returnedResults++;
+            for (const previous of before) selected.set(previous.lineNumber, previous);
+            through = lineNumber + input.context;
+          } else if (returnedResults === input.limit) {
+            hasMore = true;
+          }
+          seen++;
+        }
+        if (lineNumber <= through) selected.set(lineNumber, line);
+        if (hasMore && lineNumber >= through) break;
+        if (input.context > 0) {
+          before.push(line);
+          if (before.length > input.context) before.shift();
+        }
+      }
+    } finally {
+      reader.close();
+      stream.destroy();
+    }
+    if (selected.size > 0)
+      files.push({
+        filePath,
+        lines: [...selected.values()].sort((a, b) => a.lineNumber - b.lineNumber),
+      });
+    if (hasMore) break;
+  }
+  signal.throwIfAborted();
+  return {
+    ok: true,
+    format: "text",
+    files,
+    returnedResults,
+    hasMore,
+    ...(hasMore ? { nextOffset: input.offset + returnedResults } : {}),
+  };
+}
+
+async function markdownFiles(
+  directory: string,
+  signal: AbortSignal,
+): Promise<string[]> {
+  signal.throwIfAborted();
+  const files: string[] = [];
+  for (const entry of await readdir(directory, { withFileTypes: true })) {
+    signal.throwIfAborted();
+    const filePath = path.join(directory, entry.name);
+    if (entry.isDirectory()) files.push(...(await markdownFiles(filePath, signal)));
+    else if (entry.isFile() && entry.name.toLowerCase().endsWith(".md"))
+      files.push(filePath);
+  }
+  return files.sort();
+}
+
+/** Keep up to 500 original code points around the earliest literal match. */
+function excerpt(text: string, foldedMatchOffset: number): string {
+  const points = [...text];
+  if (points.length <= 500) return text;
+  let matchPoint = 0;
+  let foldedOffset = 0;
+  if (foldedMatchOffset >= 0) {
+    while (matchPoint < points.length && foldedOffset < foldedMatchOffset) {
+      foldedOffset += points[matchPoint].toLowerCase().length;
+      matchPoint++;
+    }
+  }
+  const start = Math.max(0, matchPoint - 100);
+  const end = Math.min(points.length, start + 500);
+  return `${start > 0 ? `[... ${start} code points omitted ...]` : ""}${points.slice(start, end).join("")}${end < points.length ? `[... ${points.length - end} code points omitted ...]` : ""}`;
+}

package/src/observation/observation-builder.ts

@@ -1,3 +1,4 @@
+import { renderMemoryTextSearch } from "../memory/memory-search-output";
 import type { ToolCall } from "../agent/types";
 import type { ToolResultContent } from "../agent/types";
 import {
@@ -410,6 +411,7 @@ function renderMemorySearchObservation(raw: MemorySearchRawResult): string {
   if (!raw.ok) {
     return `MemorySearch unavailable: ${raw.error}`;
   }
+  if ("format" in raw) return renderMemoryTextSearch(raw);
   const degradedNote =
     raw.degraded === "vector"
       ? " vector search unavailable; keyword results only."
@@ -467,7 +469,9 @@ function renderMemoryCreateObservation(
   }
   const text = memoryMutationText(call);
   const result = `MemoryCreate ${raw.status} memory=${raw.memoryId} created_at=${raw.createdAt}.`;
-  return text === undefined ? result : `${result}\ntext: ${text}`;
+  const location =
+    raw.filePath === undefined ? result : `${result}\nPath: ${raw.filePath}`;
+  return text === undefined ? location : `${location}\ntext: ${text}`;
 }
 
 function renderMemoryUpdateObservation(

package/src/session/session-store-contracts.ts

@@ -28,29 +28,6 @@ export type SessionMediaCompatibility = {
   readonly toolResultModalities: readonly ("text" | "image")[];
 };
 
-export type CompletedTurnMessageSnapshot =
-  | {
-      readonly ordinal: number;
-      readonly role: "user";
-      readonly content: string;
-    }
-  | {
-      readonly ordinal: number;
-      readonly role: "assistant";
-      readonly content: string | null;
-      readonly reasoningContent?: string | null;
-    }
-  | {
-      readonly ordinal: number;
-      readonly role: "tool";
-      readonly name: string;
-      readonly content: string;
-    };
-
-export type CompletedTurnSnapshot = {
-  readonly messages: readonly CompletedTurnMessageSnapshot[];
-};
-
 export type SessionCompatibilityContract = {
   modelName: string;
   profileName?: string;

package/src/session/session-store.ts

@@ -1,3 +1,4 @@
+import { prepareSessionMemory } from "../memory/memory-files";
 import { Database } from "bun:sqlite";
 import { ScopedQueryDatabase } from "./scoped-query-database";
 import { randomUUID } from "node:crypto";
@@ -88,8 +89,6 @@ import {
   type CommitSurfaceRefreshOptions,
   type CommitSwapRevisionInput,
   type CommitSwapRevisionOptions,
-  type CompletedTurnMessageSnapshot,
-  type CompletedTurnSnapshot,
   type CreateNewSessionStoreInput,
   type OpenSessionStoreInput,
   type SessionCloseReason,
@@ -132,9 +131,7 @@ import { requireItem, requireSingleChange, runTransaction } from "./session-stor
 import { SessionStoreValidation } from "./session-store-validation";
 import {
   assertMeasuredContextAnchor,
-  enumFromSql,
   nullableStringFromSql,
-  nullableTextFromSql,
   numberFromSql,
   recordFromSql,
   stringFromSql,
@@ -886,105 +883,6 @@ export class SessionStore implements SessionLedgerCommitter {
     });
   }
 
-  readCompletedTurnSnapshot(turnId: TurnId): CompletedTurnSnapshot {
-    this.requireOpen();
-    const turnRow = this.database
-      .query("SELECT status FROM turns WHERE turn_id = ?")
-      .get(turnId);
-    const status = enumFromSql(
-      recordFromSql(turnRow, "completed turn").status,
-      ["open", "completed", "failed", "cancelled", "interrupted"] as const,
-      "turn status",
-    );
-    if (status !== "completed") {
-      throw new Error(`Turn ${turnId} is not completed.`);
-    }
-
-    const rows = this.database
-      .query(
-        `SELECT ordinal, role, content, reasoning_content,
-                reasoning_content_present, name
-         FROM messages
-         WHERE turn_id = ?
-         ORDER BY ordinal`,
-      )
-      .all(turnId);
-    if (rows.length === 0) {
-      throw new Error(`Completed turn ${turnId} has no messages.`);
-    }
-
-    let previousOrdinal = 0;
-    const messages = rows.map((value): CompletedTurnMessageSnapshot => {
-      const row = recordFromSql(value, "completed turn message");
-      const ordinal = numberFromSql(row.ordinal, "completed turn ordinal");
-      if (ordinal < 1 || ordinal <= previousOrdinal) {
-        throw new Error("Completed turn message ordinals are invalid.");
-      }
-      previousOrdinal = ordinal;
-      const role = enumFromSql(
-        row.role,
-        ["user", "assistant", "tool"] as const,
-        "completed turn message role",
-      );
-      if (role === "user") {
-        if (
-          row.reasoning_content !== null ||
-          numberFromSql(row.reasoning_content_present, "reasoning_content_present") !==
-            0 ||
-          row.name !== null
-        ) {
-          throw new Error("Completed user message fields are invalid.");
-        }
-        return Object.freeze({
-          ordinal,
-          role,
-          content: stringFromSql(row.content, "completed user content"),
-        });
-      }
-      if (role === "assistant") {
-        if (row.name !== null) {
-          throw new Error("Completed assistant message name must be null.");
-        }
-        const reasoningPresent = numberFromSql(
-          row.reasoning_content_present,
-          "reasoning_content_present",
-        );
-        if (reasoningPresent !== 0 && reasoningPresent !== 1) {
-          throw new Error("reasoning_content_present must be 0 or 1.");
-        }
-        if (reasoningPresent === 0 && row.reasoning_content !== null) {
-          throw new Error("Absent assistant reasoning content must be null.");
-        }
-        return Object.freeze({
-          ordinal,
-          role,
-          content: nullableTextFromSql(row.content, "completed assistant content"),
-          ...(reasoningPresent === 0
-            ? {}
-            : {
-                reasoningContent: nullableTextFromSql(
-                  row.reasoning_content,
-                  "completed assistant reasoning content",
-                ),
-              }),
-        });
-      }
-      if (
-        row.reasoning_content !== null ||
-        numberFromSql(row.reasoning_content_present, "reasoning_content_present") !== 0
-      ) {
-        throw new Error("Completed tool message reasoning fields are invalid.");
-      }
-      return Object.freeze({
-        ordinal,
-        role,
-        name: stringFromSql(row.name, "completed tool name"),
-        content: stringFromSql(row.content, "completed tool content"),
-      });
-    });
-    return Object.freeze({ messages: Object.freeze(messages) });
-  }
-
   loadProtocolView(): ProtocolContextView {
     this.requireOpen();
     const imageAttachments = loadMessageImageAttachments(this.database);
@@ -1404,6 +1302,7 @@ export class SessionStore implements SessionLedgerCommitter {
       input.faultInjector?.("before_publish_rename");
       await rename(stagingDirectory, targetDirectory);
       published = true;
+      await prepareSessionMemory(targetDirectory, input.targetSessionId, this.homeRoot);
     } finally {
       if (stagingDatabase !== undefined) {
         try {

package/src/tools/bash.ts

@@ -48,7 +48,15 @@ export function createBashToolExecutor(options: BashToolOptions): ToolExecutor {
     definition: {
       name: "Bash",
       description:
-        "Run a shell command locally. If the foreground timeout expires while the command is still running, it continues as a background task and returns a task ID; it is not killed. Use TaskOutput to inspect progress, then decide whether to keep waiting or stop it with TaskStop.",
+        "Run a shell command locally. " +
+        "If the foreground timeout expires while the command is still running, " +
+        "it continues as a background task and returns a task ID; it is not killed. " +
+        "Use TaskOutput to inspect progress, then decide whether to keep waiting or stop it with TaskStop. " +
+        "Use run_in_background=true for persistent processes such as dev servers and watch commands, " +
+        "or when you have independent work to do while a command runs. " +
+        "For finite commands whose result is needed next, such as builds, tests, and checks, " +
+        "prefer foreground execution when no independent work remains. " +
+        "Set a sufficient foreground timeout; the call returns as soon as the command finishes.",
       parameters: {
         type: "object",
         additionalProperties: false,

package/src/tools/bounded-output-preview.ts

@@ -1,7 +1,7 @@
 import { Buffer } from "node:buffer";
 
-export const MAX_PREVIEW_LINES = 200;
-export const PREVIEW_EDGE_LINES = 100;
+export const MAX_PREVIEW_LINES = 50;
+export const PREVIEW_EDGE_LINES = 25;
 export const MAX_PREVIEW_BYTES = 32 * 1024;
 export const MAX_PREVIEW_LINE_BYTES = 8 * 1024;
 

package/src/tools/registry.ts

@@ -1,3 +1,5 @@
+import { createMemorySearchToolExecutor } from "../memory/memory-search-tool";
+import { createFileMemoryCreateToolExecutor } from "../memory/memory-files";
 import { createAskUserToolExecutor } from "./ask-user";
 import { createBashToolExecutor } from "./bash";
 import { ShellTaskManager } from "./bash-task";
@@ -182,10 +184,7 @@ export function createDefaultTooling(options: {
   skillCoordinator?: SkillActivationCoordinator;
   toolingConfig?: PublicToolingConfig;
   memorySearch?: ToolExecutor;
-  memoryGet?: ToolExecutor;
   memoryCreate?: ToolExecutor;
-  memoryUpdate?: ToolExecutor;
-  memoryDelete?: ToolExecutor;
   enableTurnUndo?: boolean;
   imageAssetStore?: ImageAssetStore;
   supportsViewImage?: boolean;
@@ -259,21 +258,19 @@ export function createDefaultTooling(options: {
   registry.register(createContextStatusToolExecutor());
   registry.register(createContextSwapCandidatesToolExecutor());
   registry.register(createContextSwapToolExecutor());
-  if (options.memorySearch !== undefined) {
-    registry.register(options.memorySearch);
-  }
-  if (options.memoryGet !== undefined) {
-    registry.register(options.memoryGet);
-  }
-  if (options.memoryCreate !== undefined) {
-    registry.register(options.memoryCreate);
-  }
-  if (options.memoryUpdate !== undefined) {
-    registry.register(options.memoryUpdate);
-  }
-  if (options.memoryDelete !== undefined) {
-    registry.register(options.memoryDelete);
-  }
+  registry.register(
+    options.memorySearch ??
+      createMemorySearchToolExecutor({
+        homeRoot: options.homeRoot,
+      }),
+  );
+  registry.register(
+    options.memoryCreate ??
+      createFileMemoryCreateToolExecutor({
+        workspaceRoot: options.workspaceRoot,
+        homeRoot: options.homeRoot,
+      }),
+  );
   if (options.skillCatalog !== undefined) {
     if (options.skillCatalog.skills.size === 0) {
       throw new Error("An empty Agent Skill catalog must not register tooling.");

package/src/tools/types.ts

@@ -427,7 +427,18 @@ export type ContextMaintenanceHandle = {
   ): Promise<ContextSwapRawResult>;
 };
 
+export type MemorySearchLine = { lineNumber: number; match: boolean; text: string };
+export type MemoryTextSearchResult = {
+  ok: true;
+  format: "text";
+  files: readonly { filePath: string; lines: readonly MemorySearchLine[] }[];
+  returnedResults: number;
+  hasMore: boolean;
+  nextOffset?: number;
+};
+
 export type MemorySearchRawResult =
+  | MemoryTextSearchResult
   | {
       ok: true;
       degraded: "vector" | "fts" | null;
@@ -469,6 +480,7 @@ export type MemoryCreateRawResult =
   | {
       ok: true;
       status: "created" | "already_exists";
+      filePath?: string;
       memoryId: string;
       createdAt: string;
     }