pi-session-memory 0.1.3 → 0.2.0

package/src/session-migration.ts

@@ -0,0 +1,188 @@
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+interface CodexMessage {
+  id: string;
+  role: "user" | "assistant";
+  text: string;
+  timestamp: number;
+}
+
+interface CodexSession {
+  id: string;
+  cwd: string;
+  timestamp: number;
+  messages: CodexMessage[];
+}
+
+export interface ProjectSessionMigrationStats {
+  scannedFiles: number;
+  migratedSessions: number;
+  skippedSessions: number;
+  migratedMessages: number;
+  issues: Array<{ path: string; error: string }>;
+}
+
+/** Convert every Codex session recorded for cwd into an independently resumable Pi session file. */
+export function migrateCodexProjectSessions(cwd: string): ProjectSessionMigrationStats {
+  const stats: ProjectSessionMigrationStats = {
+    scannedFiles: 0,
+    migratedSessions: 0,
+    skippedSessions: 0,
+    migratedMessages: 0,
+    issues: [],
+  };
+  for (const path of _jsonlFiles(join(homedir(), ".codex", "sessions"))) {
+    stats.scannedFiles++;
+    try {
+      const session = _parseCodexSession(path);
+      if (!session || session.cwd !== cwd) continue;
+      const outputPath = _targetPath(session);
+      if (existsSync(outputPath)) {
+        stats.skippedSessions++;
+        continue;
+      }
+      _writePiSession(session, outputPath);
+      stats.migratedSessions++;
+      stats.migratedMessages += session.messages.length;
+    } catch (error) {
+      stats.issues.push({ path, error: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  return stats;
+}
+
+/** Convert one supported Codex JSONL file into its session metadata and textual messages. */
+function _parseCodexSession(path: string): CodexSession | undefined {
+  const entries = readFileSync(path, "utf8").split("\n").filter(Boolean).map((line) => JSON.parse(line) as Record<string, unknown>);
+  const metadata = entries.find((entry) => entry.type === "session_meta")?.payload as Record<string, unknown> | undefined;
+  if (!metadata) return undefined;
+  const id = _string(metadata.session_id) ?? _string(metadata.id);
+  const cwd = _string(metadata.cwd);
+  const timestamp = _timestamp(_string(metadata.timestamp));
+  if (!id || !cwd || timestamp === undefined) throw new Error("Codex session_meta requires session_id/id, cwd, and timestamp");
+
+  const messages: CodexMessage[] = [];
+  for (const [index, entry] of entries.entries()) {
+    if (entry.type !== "response_item") continue;
+    const payload = entry.payload as Record<string, unknown> | undefined;
+    if (payload?.type !== "message") continue;
+    const role = _string(payload.role);
+    if (role !== "user" && role !== "assistant") continue;
+    const text = _text(payload.content);
+    if (!text) continue;
+    const messageId = _string(payload.id)
+      ?? _string(entry.id)
+      ?? _string((payload.internal_chat_message_metadata_passthrough as Record<string, unknown> | undefined)?.turn_id);
+    if (!messageId) throw new Error(`Codex textual message at entry ${index} has no stable native ID`);
+    messages.push({
+      id: messageId,
+      role,
+      text,
+      timestamp: _timestamp(_string(entry.timestamp)) ?? timestamp,
+    });
+  }
+  return { id, cwd, timestamp, messages };
+}
+
+/** Write a valid Pi v3 session with a linear message branch and an explicit migration name. */
+function _writePiSession(session: CodexSession, path: string): void {
+  mkdirSync(join(homedir(), ".pi", "agent", "sessions", _encodedCwd(session.cwd)), { recursive: true });
+  const lines: string[] = [JSON.stringify({
+    type: "session",
+    version: 3,
+    id: randomUUID(),
+    timestamp: new Date(session.timestamp).toISOString(),
+    cwd: session.cwd,
+  })];
+  let parentId: string | null = null;
+  const nameId = _entryId(session.id, "name");
+  lines.push(JSON.stringify({
+    type: "session_info",
+    id: nameId,
+    parentId,
+    timestamp: new Date(session.timestamp).toISOString(),
+    name: `Migrated from Codex: ${session.id}`,
+  }));
+  parentId = nameId;
+  for (const message of session.messages) {
+    const id = _entryId(session.id, message.id);
+    const timestamp = new Date(message.timestamp).toISOString();
+    lines.push(JSON.stringify({
+      type: "message",
+      id,
+      parentId,
+      timestamp,
+      message: message.role === "user"
+        ? { role: "user", content: [{ type: "text", text: message.text }], timestamp: message.timestamp }
+        : {
+          role: "assistant",
+          content: [{ type: "text", text: message.text }],
+          api: "codex-migration",
+          provider: "codex",
+          model: "unknown",
+          usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+          stopReason: "stop",
+          timestamp: message.timestamp,
+        },
+    }));
+    parentId = id;
+  }
+  const temporaryPath = `${path}.tmp-${randomUUID()}`;
+  try {
+    writeFileSync(temporaryPath, `${lines.join("\n")}\n`, { flag: "wx" });
+    renameSync(temporaryPath, path);
+  } finally {
+    if (existsSync(temporaryPath)) unlinkSync(temporaryPath);
+  }
+}
+
+/** Return the deterministic Pi session-file location for one Codex session. */
+function _targetPath(session: CodexSession): string {
+  return join(homedir(), ".pi", "agent", "sessions", _encodedCwd(session.cwd), `${new Date(session.timestamp).toISOString().replace(/[.:]/g, "-")}_codex-${session.id}.jsonl`);
+}
+
+/** Encode cwd exactly as Pi's default session directory convention. */
+function _encodedCwd(cwd: string): string {
+  return `--${cwd.split("/").filter(Boolean).join("-")}--`;
+}
+
+/** Create stable, Pi-safe entry IDs without fabricating source message identity. */
+function _entryId(sessionId: string, sourceId: string): string {
+  return createHash("sha256").update(`${sessionId}:${sourceId}`).digest("hex").slice(0, 16);
+}
+
+/** Extract non-empty string values only. */
+function _string(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value : undefined;
+}
+
+/** Parse an ISO timestamp only when it is valid. */
+function _timestamp(value: string | undefined): number | undefined {
+  if (!value) return undefined;
+  const timestamp = Date.parse(value);
+  return Number.isNaN(timestamp) ? undefined : timestamp;
+}
+
+/** Join supported Codex text content blocks. */
+function _text(content: unknown): string {
+  if (!Array.isArray(content)) return "";
+  return content
+    .filter((block): block is { type: string; text: string } => Boolean(block) && typeof block === "object" && typeof (block as { type?: unknown }).type === "string" && typeof (block as { text?: unknown }).text === "string")
+    .filter((block) => block.type === "input_text" || block.type === "output_text" || block.type === "text")
+    .map((block) => block.text)
+    .join("\n")
+    .trim();
+}
+
+/** Recursively enumerate source JSONL files. */
+function _jsonlFiles(root: string): string[] {
+  if (!existsSync(root)) return [];
+  return readdirSync(root, { withFileTypes: true }).flatMap((entry) => {
+    const path = join(root, entry.name);
+    if (entry.isDirectory()) return _jsonlFiles(path);
+    return entry.isFile() && path.endsWith(".jsonl") ? [path] : [];
+  });
+}

package/src/writer.ts

@@ -2,6 +2,7 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { AssistantMessage } from "@earendil-works/pi-ai";
 import { upsertSession, insertTurn } from "./db.ts";
 
+/** Persist the latest Pi user request and all following assistant output as one turn. */
 export function writeTurn(ctx: ExtensionContext): void {
   const sessionManager = ctx.sessionManager;
   const sessionId = `pi:${sessionManager.getSessionId()}`;
@@ -50,6 +51,7 @@ export function writeTurn(ctx: ExtensionContext): void {
   });
 }
 
+/** Join text blocks from a Pi message while ignoring non-text content. */
 function _extractText(message: { content: string | Array<{ type: string; text?: string }> }): string {
   if (typeof message.content === "string") return message.content.trim();
   return message.content
@@ -59,6 +61,7 @@ function _extractText(message: { content: string | Array<{ type: string; text?:
     .trim();
 }
 
+/** Calculate the zero-based user-turn position within the current session branch. */
 function _userTurnIndex(branch: ReturnType<ExtensionContext["sessionManager"]["getBranch"]>, userIndex: number): number {
   return branch.slice(0, userIndex + 1)
     .filter((entry) => entry.type === "message" && entry.message.role === "user")

package/tests/core.test.ts

@@ -1,19 +1,26 @@
 import assert from "node:assert/strict";
-import { existsSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
 const dbPath = join(tmpdir(), `pi-session-memory-${process.pid}.db`);
+const historyHome = join(tmpdir(), `pi-session-memory-home-${process.pid}`);
 process.env.MEMORY_DB_PATH = dbPath;
+process.env.HOME = historyHome;
 
-const { getDb, insertTurn, upsertSession } = await import("../src/db.ts");
-const { recallTurns } = await import("../src/retriever.ts");
+const { confirmMemory, createMemory, deleteMemory, deleteTurn, getDb, getMemoryHistory, getMemoryStats, getSession, insertTurn, listMemories, pinTurnAsMemory, supersedeMemory, upsertSession } = await import("../src/db.ts");
+const { formatRecallResults, recallMemories, recallTurns } = await import("../src/retriever.ts");
+const { HISTORY_SCHEMA_REFERENCE_VERSIONS, backfillAll } = await import("../src/backfill.ts");
+const { migrateCodexProjectSessions } = await import("../src/session-migration.ts");
+const { SessionManager } = await import("@earendil-works/pi-coding-agent");
 
+/** Remove the temporary SQLite database and its WAL sidecar files after this test. */
 function cleanup(): void {
   for (const suffix of ["", "-wal", "-shm"]) {
     const path = `${dbPath}${suffix}`;
     if (existsSync(path)) rmSync(path);
   }
+  if (existsSync(historyHome)) rmSync(historyHome, { recursive: true });
 }
 
 cleanup();
@@ -60,9 +67,221 @@ assert.equal(insertTurn({
   user_message_id: "user-1",
 }), false);
 
+assert.throws(() => insertTurn({
+  turn_id: "pi:test:invalid-message-id",
+  session_id: "pi:test",
+  turn_index: 2,
+  ts: 3,
+  user_text: "invalid SQLite parameter",
+  reply_text: "",
+  tool_names: null,
+  user_message_id: undefined as unknown as string,
+}), /SQLite parameter 8 must be string, number, bigint, Uint8Array, or null; received undefined/);
+
+mkdirSync(join(historyHome, ".pi", "agent", "sessions"), { recursive: true });
+mkdirSync(join(historyHome, ".claude", "projects"), { recursive: true });
+mkdirSync(join(historyHome, ".codex", "sessions"), { recursive: true });
+writeFileSync(join(historyHome, ".pi", "agent", "sessions", "invalid.jsonl"), [
+  JSON.stringify({ type: "session", id: "pi-invalid", timestamp: "2026-01-01T00:00:00.000Z", cwd: "/tmp" }),
+  JSON.stringify({ type: "message", message: { role: "user", timestamp: 1, content: [{ type: "text", text: "invalid Pi id" }] } }),
+].join("\n"));
+writeFileSync(join(historyHome, ".pi", "agent", "sessions", "valid.jsonl"), [
+  JSON.stringify({ type: "session", id: "pi-compatible", timestamp: "2026-01-01T00:00:00.000Z", cwd: "/tmp" }),
+  JSON.stringify({ type: "message", id: "pi-user", message: { role: "user", timestamp: 1, content: [{ type: "text", text: "schema normal Pi request" }] } }),
+  JSON.stringify({ type: "message", id: "pi-assistant", message: { role: "assistant", timestamp: 2, content: [{ type: "text", text: "schema normal Pi reply" }] } }),
+].join("\n"));
+writeFileSync(join(historyHome, ".claude", "projects", "invalid.jsonl"), [
+  JSON.stringify({ type: "user", sessionId: "claude-invalid", cwd: "/tmp", timestamp: "2026-01-01T00:00:00.000Z", message: { role: "user", content: "invalid Claude id" } }),
+].join("\n"));
+writeFileSync(join(historyHome, ".claude", "projects", "valid-old-schema.jsonl"), [
+  JSON.stringify({ type: "user", id: "claude-user", sessionId: "claude-compatible", cwd: "/tmp", timestamp: "2026-01-01T00:00:00.000Z", message: { role: "user", content: "schema normal Claude request" } }),
+  JSON.stringify({ type: "assistant", id: "claude-assistant", sessionId: "claude-compatible", cwd: "/tmp", timestamp: "2026-01-01T00:00:01.000Z", message: { role: "assistant", content: [{ type: "text", text: "schema normal Claude reply" }] } }),
+].join("\n"));
+writeFileSync(join(historyHome, ".codex", "sessions", "invalid.jsonl"), [
+  JSON.stringify({ type: "session_meta", payload: { session_id: "codex-invalid", cwd: "/tmp", timestamp: "2026-01-01T00:00:00.000Z" } }),
+  JSON.stringify({ type: "response_item", timestamp: "2026-01-01T00:00:00.000Z", payload: { type: "message", role: "user", content: [{ type: "input_text", text: "invalid Codex id" }] } }),
+].join("\n"));
+writeFileSync(join(historyHome, ".codex", "sessions", "valid.jsonl"), [
+  JSON.stringify({ type: "session_meta", payload: { session_id: "codex-compatible", cwd: "/tmp", timestamp: "2026-01-01T00:00:00.000Z" } }),
+  JSON.stringify({ type: "response_item", timestamp: "2026-01-01T00:00:00.000Z", payload: { type: "message", id: "codex-user", role: "user", content: [{ type: "input_text", text: "schema normal Codex request" }] } }),
+  JSON.stringify({ type: "response_item", timestamp: "2026-01-01T00:00:01.000Z", payload: { type: "message", id: "codex-assistant", role: "assistant", content: [{ type: "output_text", text: "schema normal Codex reply" }] } }),
+].join("\n"));
+writeFileSync(join(historyHome, ".codex", "sessions", "valid-legacy.jsonl"), [
+  JSON.stringify({ type: "session_meta", payload: { session_id: "codex-legacy", cwd: "/tmp", timestamp: "2026-07-17T03:03:23.000Z" } }),
+  JSON.stringify({ type: "response_item", timestamp: "2026-07-17T03:03:24.000Z", payload: { type: "message", role: "user", content: [{ type: "input_text", text: "schema legacy Codex request" }], internal_chat_message_metadata_passthrough: { turn_id: "legacy-codex-turn" } } }),
+  JSON.stringify({ type: "response_item", timestamp: "2026-07-17T03:03:25.000Z", payload: { type: "message", role: "assistant", content: [{ type: "output_text", text: "schema legacy Codex reply" }], internal_chat_message_metadata_passthrough: { turn_id: "legacy-codex-turn" } } }),
+].join("\n"));
+writeFileSync(join(historyHome, ".codex", "sessions", "other-project.jsonl"), [
+  JSON.stringify({ type: "session_meta", payload: { session_id: "codex-other-project", cwd: "/other-project", timestamp: "2026-01-01T00:00:00.000Z" } }),
+  JSON.stringify({ type: "response_item", timestamp: "2026-01-01T00:00:00.000Z", payload: { type: "message", id: "codex-other-user", role: "user", content: [{ type: "input_text", text: "other project request" }] } }),
+  JSON.stringify({ type: "response_item", timestamp: "2026-01-01T00:00:01.000Z", payload: { type: "message", id: "codex-other-assistant", role: "assistant", content: [{ type: "output_text", text: "other project reply" }] } }),
+].join("\n"));
+const migrationStats = migrateCodexProjectSessions("/tmp");
+assert.deepEqual({ scannedFiles: migrationStats.scannedFiles, migratedSessions: migrationStats.migratedSessions, skippedSessions: migrationStats.skippedSessions, migratedMessages: migrationStats.migratedMessages, issues: migrationStats.issues.length }, { scannedFiles: 4, migratedSessions: 2, skippedSessions: 0, migratedMessages: 4, issues: 1 });
+assert.match(migrationStats.issues[0].error, /no stable native ID/);
+const migratedSessionFiles = [...(await SessionManager.list("/tmp"))].filter((session) => session.name?.startsWith("Migrated from Codex:"));
+assert.deepEqual(migratedSessionFiles.map((session) => session.name).sort(), ["Migrated from Codex: codex-compatible", "Migrated from Codex: codex-legacy"]);
+const migrated = SessionManager.open(migratedSessionFiles.find((session) => session.name === "Migrated from Codex: codex-compatible")!.path);
+assert.deepEqual(migrated.getBranch().filter((entry) => entry.type === "message").map((entry) => entry.message.role), ["user", "assistant"]);
+assert.equal(migrateCodexProjectSessions("/tmp").skippedSessions, 2);
+assert.equal((await SessionManager.list("/other-project")).some((session) => session.name === "Migrated from Codex: codex-other-project"), false);
+const backfillStats = backfillAll();
+assert.deepEqual({ pi: backfillStats.pi, claude: backfillStats.claude, codex: backfillStats.codex, turns: backfillStats.turns }, { pi: 3, claude: 1, codex: 3, turns: 7 });
+assert.deepEqual(backfillStats.issues.map((issue) => issue.source), ["pi", "claude", "codex"]);
+for (const issue of backfillStats.issues) {
+  assert.match(issue.error, new RegExp(`${issue.source} history import failed[\\s\\S]*supported reference ${HISTORY_SCHEMA_REFERENCE_VERSIONS[issue.source]}`));
+}
+assert.deepEqual(HISTORY_SCHEMA_REFERENCE_VERSIONS, { pi: "0.85.1", claude: "2.1.234", codex: "0.154.0" });
+assert.deepEqual(recallTurns(["schema normal"], 10).map((result) => result.turn_id).filter((turnId) => !turnId.startsWith("pi:") || turnId === "pi:pi-compatible:pi-user"), [
+  "claude:claude-compatible:claude-user",
+  "codex:codex-compatible:codex-user",
+  "pi:pi-compatible:pi-user",
+]);
+assert.equal(recallTurns(["schema legacy Codex"], 10).some((result) => result.turn_id === "codex:codex-legacy:legacy-codex-turn"), true);
+
 assert.deepEqual(recallTurns(["100%"], 10).map((result) => result.turn_id), ["pi:test:user-1"]);
 assert.deepEqual(recallTurns(["a_b"], 10).map((result) => result.turn_id), ["pi:test:user-1"]);
-assert.equal(getDb().prepare("SELECT count(*) AS count FROM turns").get().count, 2);
+const thinRecall = formatRecallResults(recallMemories({ query: "literal", topK: 1 }));
+assert.match(thinRecall, /\*\*Session:\*\* pi:test · \*\*Turn:\*\* 0[\s\S]*\*\*Excerpt:\*\* literal 100% and a_b[\s\S]*Use `fetch_session`/);
+assert.doesNotMatch(thinRecall, /\*\*Assistant:\*\* first reply/);
+assert.match(
+  formatRecallResults([], { query: "SAP BTP", entities: ["BTP", "Business Technology Platform"], sources: ["pi"], cwd: "/tmp" }),
+  /\*\*Search query:\*\* `SAP BTP`[\s\S]*\*\*Filters:\*\* entities: `BTP`, `Business Technology Platform` · sources: pi · cwd: `\/tmp`[\s\S]*No relevant past conversations found\./,
+);
+upsertSession({
+  session_id: "claude:project-a",
+  source: "claude",
+  cwd: "/workspace/project-a",
+  started_at: 10,
+  model_id: null,
+  jsonl_path: "/tmp/project-a.jsonl",
+});
+upsertSession({
+  session_id: "codex:project-b",
+  source: "codex",
+  cwd: "/workspace/project-b",
+  started_at: 20,
+  model_id: null,
+  jsonl_path: "/tmp/project-b.jsonl",
+});
+for (const [turnId, sessionId, index, ts, text] of [
+  ["claude:project-a:user-1", "claude:project-a", 0, 1_000, "deploy memory ranking"],
+  ["claude:project-a:user-2", "claude:project-a", 1, 2_000, "deploy memory testing"],
+  ["claude:project-a:user-3", "claude:project-a", 2, 3_000, "deploy memory release"],
+  ["codex:project-b:user-1", "codex:project-b", 0, 4_000, "deploy memory ranking"],
+] as Array<[string, string, number, number, string]>) {
+  assert.equal(insertTurn({
+    turn_id: turnId,
+    session_id: sessionId,
+    turn_index: index,
+    ts,
+    user_text: text,
+    reply_text: "confirmed",
+    tool_names: null,
+    user_message_id: turnId.split(":").at(-1)!,
+  }), true);
+}
+
+assert.deepEqual(
+  recallMemories({ query: "deploy memory", cwd: "/workspace/project-a", topK: 10 }).map((result) => result.turn_id),
+  ["claude:project-a:user-3", "claude:project-a:user-2"],
+);
+assert.deepEqual(
+  recallMemories({ query: "deploy memory", sources: ["codex"], after: 4_000, topK: 10 }).map((result) => result.turn_id),
+  ["codex:project-b:user-1"],
+);
+assert.deepEqual(
+  recallMemories({ query: "deploy memory", topK: 10 }).map((result) => result.type === "turn" ? result.turn_id : result.memory_id),
+  ["codex:project-b:user-1", "claude:project-a:user-3", "claude:project-a:user-2"],
+);
+
+const explicitMemory = createMemory({
+  memory_id: "memory:explicit",
+  kind: "decision",
+  content: "Use SQLite durable memory for deploy decisions.",
+  project_key: "/workspace/project-a",
+  source_turn_id: null,
+  importance: 2,
+  created_at: 5_000,
+});
+const pinnedMemory = pinTurnAsMemory("claude:project-a:user-1");
+assert.equal(pinnedMemory.source_turn_id, "claude:project-a:user-1");
+assert.equal(pinnedMemory.source_session_id, "claude:project-a");
+assert.ok(pinnedMemory.source_content_hash);
+assert.deepEqual(listMemories("decision").map((memory) => memory.memory_id), [explicitMemory.memory_id]);
+const deployRecall = recallMemories({ query: "deploy", cwd: "/workspace/project-a", topK: 10 });
+assert.deepEqual(
+  deployRecall.map((result) => result.type === "memory" ? result.memory_id : result.turn_id),
+  [explicitMemory.memory_id, pinnedMemory.memory_id, "claude:project-a:user-3", "claude:project-a:user-2"],
+);
+assert.equal(deployRecall.find((result) => result.type === "memory" && result.memory_id === pinnedMemory.memory_id)?.freshness_candidate, true);
+const confirmedMemory = confirmMemory(pinnedMemory.memory_id);
+assert.ok(confirmedMemory.last_confirmed_at >= pinnedMemory.last_confirmed_at);
+const replacementMemory = createMemory({
+  memory_id: "memory:replacement",
+  kind: "decision",
+  content: "Use reviewed SQLite durable memory for deploy decisions.",
+  project_key: "/workspace/project-a",
+  source_turn_id: null,
+  importance: 2,
+});
+supersedeMemory(explicitMemory.memory_id, replacementMemory.memory_id);
+assert.deepEqual(getMemoryHistory(replacementMemory.memory_id).map((memory) => memory.memory_id), [explicitMemory.memory_id, replacementMemory.memory_id]);
+assert.deepEqual(
+  recallMemories({ query: "SQLite durable memory", cwd: "/workspace/project-a", topK: 10 }).filter((result) => result.type === "memory").map((result) => result.memory_id),
+  [replacementMemory.memory_id],
+);
+assert.throws(() => supersedeMemory(explicitMemory.memory_id, replacementMemory.memory_id), /already superseded/);
+upsertSession({
+  session_id: "pi:provenance",
+  source: "pi",
+  cwd: "/workspace/provenance",
+  started_at: 6_000,
+  model_id: null,
+  jsonl_path: "/tmp/provenance.jsonl",
+});
+assert.equal(insertTurn({
+  turn_id: "pi:provenance:user-1",
+  session_id: "pi:provenance",
+  turn_index: 0,
+  ts: 6_000,
+  user_text: "provenance deduplication",
+  reply_text: "original source evidence",
+  tool_names: null,
+  user_message_id: "user-1",
+}), true);
+const provenanceMemory = pinTurnAsMemory("pi:provenance:user-1");
+assert.deepEqual(
+  recallMemories({ query: "provenance deduplication", cwd: "/workspace/provenance", topK: 10 }).map((result) => result.type === "memory" ? result.memory_id : result.turn_id),
+  [provenanceMemory.memory_id],
+);
+getDb().prepare("UPDATE turns SET reply_text = ? WHERE turn_id = ?").run("changed source evidence", "pi:provenance:user-1");
+assert.deepEqual(
+  recallMemories({ query: "provenance deduplication", cwd: "/workspace/provenance", topK: 10 }).map((result) => result.type === "memory" ? result.memory_id : result.turn_id),
+  [provenanceMemory.memory_id, "pi:provenance:user-1"],
+);
+assert.deepEqual(
+  getSession("claude:project-a", 1, 2).turns.map((turn) => [turn.turn_index, turn.turn_id]),
+  [[1, "claude:project-a:user-2"], [2, "claude:project-a:user-3"]],
+);
+assert.throws(() => getSession("missing:session"), /Memory session not found/);
+assert.equal(deleteTurn("claude:project-a:user-1"), true);
+assert.equal(listMemories().some((memory) => memory.memory_id === pinnedMemory.memory_id), true);
+assert.equal(deleteMemory(pinnedMemory.memory_id), true);
+assert.equal(deleteMemory(pinnedMemory.memory_id), false);
+
+const stats = getMemoryStats();
+assert.equal(stats.sessions, 11);
+assert.equal(stats.turns, 13);
+assert.deepEqual([...stats.sources].map(({ source, sessions, turns }) => ({ source, sessions, turns })), [
+  { source: "claude", sessions: 2, turns: 3 },
+  { source: "codex", sessions: 4, turns: 4 },
+  { source: "pi", sessions: 5, turns: 6 },
+]);
+assert.equal(deleteTurn("codex:project-b:user-1"), true);
+assert.equal(deleteTurn("codex:project-b:user-1"), false);
+assert.equal(getDb().prepare("SELECT count(*) AS count FROM sessions WHERE session_id = 'codex:project-b'").get().count, 0);
+assert.equal(getDb().prepare("SELECT count(*) AS count FROM turns").get().count, 12);
 
 cleanup();
 console.log("core.test.ts: passed");