tinker-agent 2.11.0 → 2.12.0

package/src/cli/tui-runner.tsx

@@ -46,7 +46,7 @@ import { loadSkillCatalog } from "../skills/skill-loader";
 import { loadProjectSlashCommands } from "../tui/project-slash-commands";
 import { createWorkspaceFileLister } from "../tui/workspace-file-search";
 import { clipboardWriterForEnvironment } from "../tui/clipboard";
-import { initializeTuiMemory } from "./tui-memory";
+import { listMemoryFiles } from "../memory/memory-files";
 import { prepareShikiHighlighter } from "../tui/shiki-highlighter";
 import { createReasoningEffortController } from "../model/reasoning-effort";
 
@@ -63,13 +63,6 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
     options.publicConfig.mode === "profile" ? options.publicConfig.profiles : undefined;
   const config = options.initialRunnerConfig;
   const workspaceRoot = await realpath(config.workspaceRoot);
-  const memory = await initializeTuiMemory({
-    config:
-      options.publicConfig.mode === "profile" ? options.publicConfig.memory : undefined,
-    env: options.env,
-  });
-  const memoryCoordinator = memory.coordinator;
-  const memoryNotice = memory.notice;
   let controller: DefaultTuiSessionController | undefined;
   let instance: ReturnType<typeof render> | undefined;
   let disposeReason: SessionDisposeReason = { type: "tui_exit" };
@@ -125,31 +118,6 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
           source: sessionConfig.bashGuardSource,
           surface: "tui" as const,
         },
-        ...(memoryCoordinator === undefined
-          ? {}
-          : {
-              memorySearch: memoryCoordinator.createSearchToolExecutor({
-                workspaceRoot,
-                sessionId,
-              }),
-              memoryGet: memoryCoordinator.createGetToolExecutor({
-                workspaceRoot,
-                sessionId,
-              }),
-              memoryCreate: memoryCoordinator.createCreateToolExecutor({
-                workspaceRoot,
-                sessionId,
-              }),
-              memoryUpdate: memoryCoordinator.createUpdateToolExecutor({
-                workspaceRoot,
-                sessionId,
-              }),
-              memoryDelete: memoryCoordinator.createDeleteToolExecutor({
-                workspaceRoot,
-                sessionId,
-              }),
-              completedTurnHook: memoryCoordinator,
-            }),
       };
       if (mode === "resume") {
         return createRuntimeSession({
@@ -320,13 +288,7 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
         onQuit={() => {
           quitRequested = true;
         }}
-        initialNotice={memoryNotice}
-        memoryDisabledNotice={memoryNotice}
-        listStoredMemories={
-          memoryCoordinator === undefined
-            ? undefined
-            : () => memoryCoordinator.listStoredMemories()
-        }
+        listStoredMemories={() => listMemoryFiles()}
       />,
       { incrementalRendering: true },
     );
@@ -350,7 +312,6 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
               );
       }
     }
-    memoryCoordinator?.dispose();
   }
 
   if (primaryError !== undefined) {

package/src/events/observation-text-log.ts

@@ -197,6 +197,13 @@ function toolCallSummary(call: ToolCall): string {
       .join("\n");
   }
 
+  if (call.name === "MemorySearch" && Array.isArray(args.keywords)) {
+    return [
+      `Call ID: ${call.toolCallId}`,
+      `Keywords: ${JSON.stringify(args.keywords)}`,
+    ].join("\n");
+  }
+
   const filePath = stringProperty(args, "file_path");
   const pattern = stringProperty(args, "pattern");
   return [

package/src/memory/contracts.ts

@@ -1,106 +1,6 @@
-import type { SessionId, TurnId } from "../ids/runtime-id";
-
-export const MEMORY_SEARCH_TOOL_NAME = "MemorySearch" as const;
-export const MEMORY_GET_TOOL_NAME = "MemoryGet" as const;
 export const MEMORY_CREATE_TOOL_NAME = "MemoryCreate" as const;
-export const MEMORY_UPDATE_TOOL_NAME = "MemoryUpdate" as const;
-export const MEMORY_DELETE_TOOL_NAME = "MemoryDelete" as const;
-export const MEMORY_SCHEMA_VERSION = 2 as const;
 export const MAX_MEMORY_TEXT_BYTES = 512;
 export const MAX_MEMORY_SUMMARY_BYTES = 4_096;
-export const MAX_SEARCH_RESULT_SUMMARY_BYTES = 1_536;
-export const MAX_MEMORY_QUERY_BYTES = 1_024;
-export const MAX_MEMORY_ID_BYTES = 64;
-export const MEMORY_SEARCH_LIMIT = 5;
-export const MEMORY_RECALL_CANDIDATE_LIMIT = 20;
-export const MAX_MEMORY_KEYWORDS = 8;
-export const MAX_MEMORY_KEYWORD_BYTES = 128;
-export const MEMORY_RRF_K = 60;
-export const MEMORY_EXTRACTION_QUEUE_CAPACITY = 64;
-export const MEMORY_SEARCH_DIAGNOSTIC_VECTOR_SCORES_LIMIT = 10;
-
-export type MemoryEmbeddingKind = "openai-compatible";
-
-export type MemoryEmbeddingConfig = {
-  readonly name: string;
-  readonly kind: MemoryEmbeddingKind;
-  readonly model: string;
-  readonly apiBase: string;
-  readonly apiKey: string;
-  readonly dimensions: number;
-};
-
-export type MemoryEmbeddingIdentity = Pick<
-  MemoryEmbeddingConfig,
-  "name" | "kind" | "model" | "dimensions"
->;
-
-export type MemoryPaths = {
-  readonly directory: string;
-  readonly database: string;
-  readonly log: string;
-  readonly extractedLog: string;
-};
-
-export type MemoryWriteCandidate = {
-  readonly text: string;
-  readonly summary: string;
-  readonly embedding: Float32Array;
-};
-
-export type MemoryWriteBatch = {
-  readonly workspaceRoot: string;
-  readonly sessionId: SessionId;
-  readonly turnId: TurnId;
-  readonly candidates: readonly MemoryWriteCandidate[];
-};
-
-export type MemoryWriteResult = {
-  readonly written: number;
-  readonly duplicate: number;
-  readonly inserted: readonly MemoryInsertedRecord[];
-};
-
-export type MemoryInsertedRecord = {
-  readonly memoryId: string;
-  readonly text: string;
-  readonly createdAt: string;
-};
-
-export type MemorySearchMatch = {
-  readonly memoryId: string;
-  readonly text: string;
-  readonly summary: string;
-  readonly score: number;
-  readonly sourceWorkspace: string;
-  readonly sourceSessionId: string;
-  readonly createdAt: string;
-};
-
-export type MemoryRecallPath = "vector" | "fts";
-
-export type MemoryFtsMatch = {
-  readonly memoryId: string;
-  readonly text: string;
-  readonly summary: string;
-  readonly bm25: number;
-  readonly sourceWorkspace: string;
-  readonly sourceSessionId: string;
-  readonly createdAt: string;
-};
-
-export type MemoryHybridMatch = {
-  readonly memoryId: string;
-  readonly text: string;
-  readonly summary: string;
-  readonly score: number;
-  readonly via: readonly MemoryRecallPath[];
-  readonly sourceWorkspace: string;
-  readonly sourceSessionId: string;
-  readonly createdAt: string;
-};
-
-export type MemoryRecallDegraded = "vector" | "fts";
 
 export type StoredMemorySummary = {
   readonly memoryId: string;
@@ -111,168 +11,12 @@ export type StoredMemorySummary = {
   readonly createdAt: string;
 };
 
-export type StoredMemoryRecord = StoredMemorySummary & {
-  readonly sourceTurnId: string;
-};
-
-export type StoredMemoryMutationRecord = StoredMemoryRecord & {
-  readonly embedding: Float32Array;
-};
-
-export type MemoryUpdateStoreResult =
-  | {
-      readonly ok: true;
-      readonly memoryId: string;
-    }
-  | {
-      readonly ok: false;
-      readonly code: "memory_not_found";
-    }
-  | {
-      readonly ok: false;
-      readonly code: "memory_duplicate";
-      readonly conflictMemoryId: string;
-    };
-
-export type MemoryDeleteStoreResult =
-  | {
-      readonly ok: true;
-      readonly memoryId: string;
-    }
-  | {
-      readonly ok: false;
-      readonly code: "memory_not_found";
-    };
-
-export type MemoryExtractionRejectedCounts = {
-  readonly duplicate: number;
-  readonly secret: number;
-  readonly invalid: number;
-  readonly embedding: number;
-};
-
-export type MemoryExtractionDiagnostic = {
-  readonly at: string;
-  readonly kind: "extraction";
-  readonly outcome: "ok" | "failed" | "skipped";
-  readonly reason: string | null;
-  readonly workspace: string;
-  readonly turnId: string;
-  readonly inputTokens: number;
-  readonly returned: number;
-  readonly written: number;
-  readonly rejected: MemoryExtractionRejectedCounts;
-  readonly ms: number;
-  /**
-   * Bounded single-line error detail (message plus cause chain) recorded for
-   * failed and skipped outcomes so provider/parse failures are diagnosable
-   * from the log alone. Absent on success.
-   */
-  readonly detail?: string;
-};
-
-export type MemorySearchDiagnostic = {
-  readonly at: string;
-  readonly kind: "search";
-  readonly outcome: "ok" | "failed" | "skipped";
-  readonly reason: string | null;
-  readonly workspace: string;
-  readonly sessionId: string;
-  readonly queryBytes: number;
-  readonly keywordCount: number;
-  readonly returned: number;
-  readonly vectorReturned: number;
-  readonly ftsReturned: number;
-  readonly degraded: MemoryRecallDegraded | null;
-  readonly scores: readonly number[];
-  readonly vectorScores: readonly number[];
-  readonly ms: number;
-};
-
-export type MemoryInitDiagnostic = {
-  readonly at: string;
-  readonly kind: "init";
-  readonly outcome: "failed";
-  readonly reason: string;
-};
-
-export type MemoryGetDiagnostic = {
-  readonly at: string;
-  readonly kind: "get";
-  readonly outcome: "ok" | "failed";
-  readonly reason: string | null;
-  readonly workspace: string;
-  readonly sessionId: string;
-  readonly found: boolean;
-  readonly ms: number;
-};
-
-export type MemoryMutationDiagnostic = {
-  readonly at: string;
-  readonly kind: "create" | "update" | "delete";
-  readonly outcome: "ok" | "failed" | "skipped";
-  readonly reason: string | null;
-  readonly workspace: string;
-  readonly sessionId: string;
-  readonly turnId: string;
-  readonly toolCallId: string;
-  readonly memoryId: string | null;
-  readonly ms: number;
-};
-
-export type MemoryDiagnostic =
-  | MemoryExtractionDiagnostic
-  | MemorySearchDiagnostic
-  | MemoryGetDiagnostic
-  | MemoryMutationDiagnostic
-  | MemoryInitDiagnostic;
-
-export class MemoryError extends Error {
-  constructor(
-    readonly code: string,
-    message: string,
-    options?: ErrorOptions,
-  ) {
-    super(message, options);
-    this.name = "MemoryError";
-  }
-}
-
-export function memoryErrorCode(error: unknown, fallback: string): string {
-  return error instanceof MemoryError ? error.code : fallback;
-}
-
 export function boundedMemoryError(error: unknown): string {
   const raw = error instanceof Error ? error.message : String(error);
   const singleLine = raw.replaceAll(/\s+/g, " ").trim() || "unknown memory error";
   return truncateUtf8(singleLine, 400);
 }
 
-export function boundedMemoryErrorDetail(error: unknown): string {
-  const parts: string[] = [];
-  let current: unknown = error;
-  for (
-    let depth = 0;
-    depth < 4 && current !== undefined && current !== null;
-    depth += 1
-  ) {
-    const raw =
-      current instanceof Error
-        ? current.message
-        : typeof current === "string" ||
-            typeof current === "number" ||
-            typeof current === "boolean"
-          ? String(current)
-          : "unknown non-error cause";
-    const singleLine = raw.replaceAll(/\s+/g, " ").trim();
-    if (singleLine !== "" && !parts.includes(singleLine)) {
-      parts.push(singleLine);
-    }
-    current = current instanceof Error ? current.cause : undefined;
-  }
-  return truncateUtf8(parts.join(" | ") || "unknown memory error", 400);
-}
-
 export function truncateUtf8(value: string, maxBytes: number): string {
   if (Buffer.byteLength(value, "utf8") <= maxBytes) {
     return value;

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

@@ -14,7 +14,8 @@ import {
 
 export const MEMORY_CREATE_TOOL_DEFINITION: ToolDefinition = Object.freeze({
   name: MEMORY_CREATE_TOOL_NAME,
-  description: "Create one global memory shared across sessions and workspaces.",
+  description:
+    "Save an explicit memory as a Markdown note shared across sessions and workspaces. Returns a file path that Read can open.",
   parameters: {
     type: "object",
     additionalProperties: false,
@@ -23,7 +24,7 @@ export const MEMORY_CREATE_TOOL_DEFINITION: ToolDefinition = Object.freeze({
         type: "string",
         minLength: 1,
         maxLength: MAX_MEMORY_TEXT_BYTES,
-        description: "A one-line searchable index for this memory.",
+        description: "A one-line Markdown heading for this memory.",
       },
       summary: {
         type: "string",
@@ -43,15 +44,12 @@ export function createMemoryCreateToolExecutor(options: {
     call: ToolCall,
     signal: AbortSignal,
   ) => Promise<MemoryCreateRawResult>;
-  readonly recordInvalidCall: (call: ToolCall) => Promise<void>;
 }): ToolExecutor {
   return defineToolExecutor("memory_create", {
     definition: MEMORY_CREATE_TOOL_DEFINITION,
     async execute(args, call, context): Promise<MemoryCreateRawResult> {
       const parsed = parseMemoryCreateArgs(args);
       if (!parsed.ok) {
-        throwIfTurnCancelled(context.signal);
-        await options.recordInvalidCall(call);
         throwIfTurnCancelled(context.signal);
         return { ok: false, error: parsed.error };
       }

package/src/memory/memory-files.ts

@@ -0,0 +1,145 @@
+import { defaultHomeRoot } from "../session/workspace-storage";
+import path from "node:path";
+import { access, mkdir, open, readdir, rename, writeFile } from "node:fs/promises";
+import { createUuidV7 } from "../ids/uuid-v7";
+import { throwIfTurnCancelled } from "../agent/turn-cancellation";
+import type { ToolExecutor } from "../tools/types";
+import { boundedMemoryError, type StoredMemorySummary } from "./contracts";
+import { createMemoryCreateToolExecutor } from "./memory-create-tool";
+
+export function memoryDirectory(homeRoot = defaultHomeRoot()): string {
+  return path.resolve(homeRoot, ".tinker", "memory");
+}
+
+export function sessionMemoryPath(sessionId: string, homeRoot?: string): string {
+  return path.join(memoryDirectory(homeRoot), "records", `${sessionId}.md`);
+}
+
+/** Old database and diagnostic files are retained outside the searchable directory. */
+export async function ensureMemoryDirectory(homeRoot?: string): Promise<string> {
+  const directory = memoryDirectory(homeRoot);
+  await mkdir(directory, { recursive: true, mode: 0o700 });
+  const legacy = (await readdir(directory)).filter((name) =>
+    [
+      "memory.sqlite",
+      "memory.sqlite-wal",
+      "memory.sqlite-shm",
+      "memory-log.jsonl",
+      "extracted-memories.log",
+    ].includes(name),
+  );
+  if (legacy.length > 0) {
+    const archive = path.join(path.dirname(directory), "memory-legacy", createUuidV7());
+    await mkdir(archive, { recursive: true, mode: 0o700 });
+    for (const name of legacy) {
+      await rename(path.join(directory, name), path.join(archive, name)).catch(
+        (error: unknown) => {
+          if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+        },
+      );
+    }
+  }
+  return directory;
+}
+
+export function createFileMemoryCreateToolExecutor(input: {
+  workspaceRoot: string;
+  homeRoot?: string;
+  clock?: () => string;
+}): ToolExecutor {
+  return createMemoryCreateToolExecutor({
+    async create(text, summary, _call, signal) {
+      throwIfTurnCancelled(signal);
+      try {
+        const directory = path.join(
+          await ensureMemoryDirectory(input.homeRoot),
+          "notes",
+        );
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+        const memoryId = createUuidV7();
+        const createdAt = (input.clock ?? (() => new Date().toISOString()))();
+        const filePath = path.join(directory, `${memoryId}.md`);
+        const title = text.replaceAll(/\s*\r?\n\s*/g, " ");
+        const heading = title.startsWith("# ") ? title : `# ${title}`;
+        const markdown = `${heading}\n\nCreated: ${createdAt}\nWorkspace: ${input.workspaceRoot}\n${summary === "" ? "" : `\n${summary}\n`}`;
+        throwIfTurnCancelled(signal);
+        await writeFile(filePath, markdown, { flag: "wx", mode: 0o600 });
+        return { ok: true, status: "created", memoryId, createdAt, filePath };
+      } catch (error) {
+        throwIfTurnCancelled(signal);
+        return { ok: false, error: boundedMemoryError(error) };
+      }
+    },
+  });
+}
+
+/** The browser shows a bounded preview; Read can open the complete file. */
+export async function listMemoryFiles(
+  homeRoot?: string,
+): Promise<readonly StoredMemorySummary[]> {
+  const directory = await ensureMemoryDirectory(homeRoot);
+  const memories: StoredMemorySummary[] = [];
+  for (const folder of ["notes", "records"]) {
+    const entries = await readdir(path.join(directory, folder), {
+      withFileTypes: true,
+    }).catch((error: unknown) => {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") return [];
+      throw error;
+    });
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+      const filePath = path.join(directory, folder, entry.name);
+      const handle = await open(filePath, "r");
+      let content: string;
+      try {
+        const buffer = Buffer.alloc(4_096);
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+        content = buffer.subarray(0, bytesRead).toString("utf8");
+      } finally {
+        await handle.close();
+      }
+      const lines = content.split("\n");
+      const id = entry.name.slice(0, -3);
+      memories.push({
+        memoryId: id,
+        text: lines[0]?.replace(/^# /, "") ?? entry.name,
+        summary: lines
+          .slice(1)
+          .filter(
+            (line) => !/^(Created|Started|Workspace|Model|Max iterations): /.test(line),
+          )
+          .join("\n")
+          .trim(),
+        sourceWorkspace: /^Workspace: (.*)$/m.exec(content)?.[1] ?? "",
+        sourceSessionId: folder === "records" ? id : "",
+        createdAt: /^(?:Created|Started): (.*)$/m.exec(content)?.[1] ?? "",
+      });
+    }
+  }
+  return memories.sort(
+    (a, b) =>
+      b.createdAt.localeCompare(a.createdAt) || b.memoryId.localeCompare(a.memoryId),
+  );
+}
+
+/** Move an older session-local transcript when reopening or publishing a clone. */
+export async function prepareSessionMemory(
+  sessionDirectory: string,
+  sessionId: string,
+  homeRoot?: string,
+): Promise<void> {
+  const directory = await ensureMemoryDirectory(homeRoot);
+  await mkdir(path.join(directory, "records"), { recursive: true, mode: 0o700 });
+  const target = sessionMemoryPath(sessionId, homeRoot);
+  try {
+    await access(target);
+    return;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+  }
+  await rename(path.join(sessionDirectory, "observations.md"), target).catch(
+    (error: unknown) => {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    },
+  );
+}

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

@@ -0,0 +1,23 @@
+import type { MemoryTextSearchResult } from "../tools/types";
+
+export function renderMemoryTextSearch(result: MemoryTextSearchResult): string {
+  const sections = result.files.map(({ filePath, lines }) => {
+    const path = /[\p{Cc}\p{Cf}"\\\u2028\u2029]/u.test(filePath)
+      ? JSON.stringify(filePath)
+      : filePath;
+    const output = [`File: ${path}`, ""];
+    let previous: number | undefined;
+    for (const line of lines) {
+      if (previous !== undefined && line.lineNumber > previous + 1)
+        output.push("", "…", "");
+      output.push(`${line.match ? ">" : " "} ${line.lineNumber} | ${line.text}`);
+      previous = line.lineNumber;
+    }
+    return output.join("\n");
+  });
+  if (sections.length === 0) sections.push("No matches found on this page.");
+  if (result.hasMore)
+    sections.push(`More results available; nextOffset=${result.nextOffset}.`);
+  else sections.push("End of results.");
+  return sections.join("\n\n");
+}