pi-session-memory 0.1.0

package/.codegraph/.gitignore

@@ -0,0 +1,5 @@
+# CodeGraph data files — local to each machine, not for committing.
+# Ignore everything in .codegraph/ except this file itself, so transient
+# files (the database, daemon.pid, sockets, logs) never show up in git.
+*
+!.gitignore

package/extensions/index.ts

@@ -0,0 +1,66 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { writeTurn } from "../src/writer.ts";
+import { recallTurns, formatRecallResults } from "../src/retriever.ts";
+import { backfillAll } from "../src/backfill.ts";
+
+export default function (pi: ExtensionAPI) {
+
+  // ── Write: persist each completed agent run to SQLite ────────────────────
+  pi.on("agent_settled", async (_event, ctx) => {
+    try {
+      writeTurn(ctx);
+    } catch (err) {
+      ctx.ui.notify(`[session-memory] write failed: ${String(err)}`, "error");
+    }
+  });
+
+  pi.registerCommand("memory-backfill", {
+    description: "Import historical Pi, Claude Code, and Codex sessions into memory.db",
+    handler: async (_args, ctx) => {
+      const stats = backfillAll();
+      ctx.ui.notify(
+        `[session-memory] imported ${stats.turns} turns from ${stats.pi} Pi, ${stats.claude} Claude, ${stats.codex} Codex sessions`,
+        "info",
+      );
+    },
+  });
+
+  // ── Read: recall_memory tool ──────────────────────────────────────────────
+  pi.registerTool({
+    name: "recall_memory",
+    label: "Recall Memory",
+    description: `Search this user's past conversation history across Pi, Claude Code, and Codex.
+
+Invocation policy:
+1. Call this tool immediately when the user explicitly asks to review, remember, summarize, continue, or compare a previous discussion about a topic. Examples:
+   - "我之前关于 xxx 的实践" / "I previously worked on xxx"
+   - "上次我们讨论过..." / "last time we discussed..."
+   - "你还记得那个 xxx 项目吗" / "remember that xxx project?"
+   - "之前那个方案怎么说的" / "what was that plan we had?"
+2. When you cannot confidently answer from the current conversation and your general knowledge, but the user may have discussed the topic in prior sessions, first ask whether they want you to search their conversation history. Call this tool only after they agree.
+3. Do not search history merely because a question is difficult when the user's prior discussions are not relevant.
+
+Extract 2–5 specific entities from the user's topic: project names, tool names, technologies, domain terms, or identifiers.`, 
+
+    parameters: Type.Object({
+      entities: Type.Array(
+        Type.String({ minLength: 1 }),
+        {
+          description: 'Key technical terms from the query. E.g. ["payroll", "LangGraph", "A2A"]',
+          minItems: 1,
+          maxItems: 8,
+        },
+      ),
+    }),
+
+    async execute(_toolCallId, { entities }) {
+      const results = recallTurns(entities, 5);
+      const text = formatRecallResults(results);
+      return {
+        content: [{ type: "text" as const, text }],
+        details: { entities, resultCount: results.length },
+      };
+    },
+  });
+}

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "pi-session-memory",
+  "version": "0.1.0",
+  "description": "Pi extension: persists conversation turns to SQLite and exposes recall_memory tool for cross-session retrieval",
+  "keywords": ["pi-package"],
+  "type": "module",
+  "scripts": {
+    "test": "tsx tests/core.test.ts"
+  },
+  "devDependencies": {
+    "tsx": "^4.23.13"
+  },
+  "pi": {
+    "extensions": ["./extensions"]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*"
+  }
+}

package/spec.md

@@ -0,0 +1,153 @@
+# pi-session-memory — Spec
+
+## Goal
+
+A pi extension that persists every conversation turn to SQLite and exposes a
+`recall_memory` tool so the LLM can retrieve relevant past turns when the user
+references previous discussions.
+
+## Architecture
+
+```
+pi turn_end event ──────────────────────────┐
+                                             ▼
+                                 Writer (src/writer.ts)
+                                 - writes current pi turns
+                                             │
+/backfill command ────────┐                 │
+                           ▼                 ▼
+                    Source adapters → SQLite ~/.pi/agent/memory.db
+                    - Pi JSONL        sessions + turns
+                    - Claude JSONL
+                    - Codex JSONL
+                                             │
+                                             ▼
+                                 recall_memory tool
+                                 - LLM supplies entities[]
+                                 - LIKE substring match + hit-score ranking
+                                 - returns top-5 turns
+```
+
+## Tables
+
+### sessions
+| column     | type    | note                          |
+|------------|---------|-------------------------------|
+| session_id | TEXT PK | native source session ID (UUID) |
+| source     | TEXT    | `pi`, `claude`, or `codex`     |
+| cwd        | TEXT    | working directory             |
+| started_at | INTEGER | unix ms                       |
+| model_id   | TEXT    | first model_change value      |
+| jsonl_path | TEXT    | absolute path to source file  |
+
+### turns
+| column      | type    | note                                      |
+|-------------|---------|-------------------------------------------|
+| turn_id     | TEXT PK | `{session_id}:{user_message_id}` — stable across live write and backfill |
+| session_id  | TEXT FK |                                           |
+| turn_index  | INTEGER | display order within session; never used as identity |
+| ts          | INTEGER | user message timestamp (unix ms)          |
+| user_text   | TEXT    | user message content                      |
+| reply_text  | TEXT    | assistant final text (all text blocks)    |
+| tool_names  | TEXT    | JSON array e.g. `["bash","read"]`         |
+
+There is intentionally no full-text virtual table. Retrieval uses escaped
+SQLite `LIKE` against the complete `user_text` and `reply_text`, because literal
+substring coverage and retrieval quality are prioritized over index performance.
+
+## Write Path
+
+Trigger: `agent_settled` event, after the agent run and any automatic
+continuations have completed.
+
+Steps:
+1. Locate the latest user `SessionEntry` in `ctx.sessionManager.getBranch()` and
+   use its stable entry ID as `user_message_id`; do not use pi's transient `turnIndex`.
+2. Extract `user_text` from that user entry's text content blocks.
+3. Walk branch entries after that user entry to collect assistant text blocks →
+   `reply_text`, and toolCall names → `tool_names`.
+4. Upsert source=`pi` session row (INSERT OR IGNORE).
+5. Insert turn by stable ID (INSERT OR IGNORE — live writing and backfill target
+   the same row).
+
+## Retrieval Path (recall_memory tool)
+
+### Tool Invocation Policy
+
+- **Direct recall:** Call `recall_memory` immediately when the user explicitly
+  asks to review, remember, summarize, continue, or compare a prior discussion
+  about a topic.
+- **Knowledge-gap recall:** When the user asks about a topic you cannot answer
+  confidently from the current conversation and your general knowledge, but it
+  may have been discussed in the user's past sessions, ask the user whether they
+  want you to search their conversation history. Call `recall_memory` only after
+  the user agrees.
+- Do not search history merely because a question is difficult when the user has
+  not indicated that their own prior work or discussions are relevant.
+
+Input: `{ entities: string[] }` — 2-5 key terms extracted by LLM from user query.
+
+Steps:
+1. Build per-entity LIKE hit score:
+   - `user_text` match = 2 points
+   - `reply_text` match = 1 point
+2. `SELECT ... WHERE (LOWER(user_text) LIKE ? OR LOWER(reply_text) LIKE ?) OR ...`
+3. Escape `%`, `_`, and `\\` in every entity, then use `LIKE ? ESCAPE '\\'` so
+   technical names containing LIKE wildcards remain literal substring matches.
+4. `ORDER BY hits DESC, ts DESC LIMIT 5`
+
+No FTS5 or write-time preprocessing. LIKE is a literal substring match after
+escaping, so it does not lose substring matches through tokenization.
+
+## Backfill
+
+`/memory-backfill` scans and imports all historical records. All writes use
+`INSERT OR IGNORE`, so it is safe and idempotent to run repeatedly.
+
+| source | scan root | accepted user/assistant records | excluded records |
+|---|---|---|---|
+| pi | `~/.pi/agent/sessions/**/*.jsonl` | `message.role=user|assistant` | thinking, tool results, non-text content |
+| claude | `~/.claude/projects/**/*.jsonl` | `type=user|assistant`, `message.role=user|assistant` | `isMeta`, sidechains, slash commands, local-command tags, continuation summaries, system/snapshot/attachments |
+| codex | `~/.codex/sessions/**/*.jsonl` | `type=response_item`, `payload.type=message`, `role=user|assistant` | developer/system context, AGENTS.md and environment-context injection, IDE/image context, reasoning and tool events |
+
+Each adapter outputs the common `ImportedSession` / `ImportedTurn` model.
+Turns pair one accepted user message with all following accepted assistant text
+until the next accepted user message. Each source adapter preserves the native
+user-message ID (`pi entry.id`, Claude `uuid`, Codex `payload.id`) so rerunning
+backfill never creates a duplicate of an already live-written pi turn.
+
+## Acceptance Criteria
+
+- A pi session with multiple user turns produces one distinct `turns` row per
+  user message; no row is dropped because `turnIndex` restarts.
+- Running backfill after live pi writing does not duplicate those pi turns.
+- Claude and Codex injected context records listed above are absent from
+  `turns.user_text`.
+- Entity text containing `%`, `_`, or `\\` only matches its literal occurrence.
+- Automated tests cover stable turn identity, LIKE escaping/ranking, and
+  cross-source backfill parsing.
+
+## File Structure
+
+```
+pi-session-memory/
+├── spec.md
+├── package.json
+├── tsconfig.json
+├── extensions/
+│   └── index.ts       ← extension entry: tool + /memory-backfill
+├── tests/
+│   └── core.test.ts   ← persistence identity and literal-LIKE tests
+└── src/
+    ├── db.ts          ← DatabaseSync schema + upsert helpers
+    ├── writer.ts      ← live pi turn_end writer
+    ├── retriever.ts   ← LIKE query + hit-score ranking
+    └── backfill.ts    ← Pi / Claude / Codex adapters and import runner
+```
+
+## Constraints
+
+- Zero external dependencies (use `node:sqlite`, `node:fs`, `node:path`, `node:os`)
+- Idempotent writes (INSERT OR IGNORE on turn_id)
+- DB path: `~/.pi/agent/memory.db`
+- No fallback / silent failure — let errors surface

package/src/backfill.ts

@@ -0,0 +1,262 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { insertTurn, upsertSession } from "./db.ts";
+
+type Source = "pi" | "claude" | "codex";
+type Role = "user" | "assistant";
+
+interface ImportedMessage {
+  id: string;
+  role: Role;
+  text: string;
+  ts: number;
+  toolNames: string[];
+}
+
+interface ImportedSession {
+  source: Source;
+  nativeSessionId: string;
+  cwd: string;
+  startedAt: number;
+  modelId: string | null;
+  jsonlPath: string;
+  messages: ImportedMessage[];
+}
+
+export interface BackfillStats {
+  pi: number;
+  claude: number;
+  codex: number;
+  turns: number;
+}
+
+export function backfillAll(): BackfillStats {
+  const stats: BackfillStats = { pi: 0, claude: 0, codex: 0, turns: 0 };
+
+  for (const jsonlPath of _jsonlFiles(join(homedir(), ".pi", "agent", "sessions"))) {
+    const session = _parsePi(jsonlPath);
+    if (session) {
+      stats.pi++;
+      stats.turns += _persist(session);
+    }
+  }
+
+  for (const jsonlPath of _jsonlFiles(join(homedir(), ".claude", "projects"))) {
+    const session = _parseClaude(jsonlPath);
+    if (session) {
+      stats.claude++;
+      stats.turns += _persist(session);
+    }
+  }
+
+  for (const jsonlPath of _jsonlFiles(join(homedir(), ".codex", "sessions"))) {
+    const session = _parseCodex(jsonlPath);
+    if (session) {
+      stats.codex++;
+      stats.turns += _persist(session);
+    }
+  }
+
+  return stats;
+}
+
+function _persist(session: ImportedSession): number {
+  const sessionId = `${session.source}:${session.nativeSessionId}`;
+  upsertSession({
+    session_id: sessionId,
+    source: session.source,
+    cwd: session.cwd,
+    started_at: session.startedAt,
+    model_id: session.modelId,
+    jsonl_path: session.jsonlPath,
+  });
+
+  let turnIndex = 0;
+  let user: ImportedMessage | undefined;
+  let replyText = "";
+  const toolNames: string[] = [];
+  let persisted = 0;
+
+  const flush = () => {
+    if (!user || !replyText.trim()) return;
+    const inserted = insertTurn({
+      turn_id: `${sessionId}:${user.id}`,
+      session_id: sessionId,
+      turn_index: turnIndex++,
+      ts: user.ts,
+      user_text: user.text,
+      reply_text: replyText.trim(),
+      tool_names: toolNames.length ? JSON.stringify([...new Set(toolNames)]) : null,
+      user_message_id: user.id,
+    });
+    if (inserted) persisted++;
+  };
+
+  for (const message of session.messages) {
+    if (message.role === "user") {
+      flush();
+      user = message;
+      replyText = "";
+      toolNames.length = 0;
+      continue;
+    }
+    if (!user) continue;
+    if (message.text) replyText += (replyText ? "\n" : "") + message.text;
+    toolNames.push(...message.toolNames);
+  }
+  flush();
+  return persisted;
+}
+
+function _parsePi(jsonlPath: string): ImportedSession | undefined {
+  const entries = _readJsonl(jsonlPath);
+  const header = entries.find((entry) => entry.type === "session");
+  if (!header) return undefined;
+  const model = entries.find((entry) => entry.type === "model_change");
+  const messages: ImportedMessage[] = [];
+
+  for (const entry of entries) {
+    if (entry.type !== "message") continue;
+    const message = entry.message;
+    if (message?.role !== "user" && message?.role !== "assistant") continue;
+    const text = _piText(message);
+    if (!text) continue;
+    const toolNames = message.role === "assistant"
+      ? message.content.filter((block: any) => block.type === "toolCall").map((block: any) => block.name)
+      : [];
+    messages.push({ id: entry.id, role: message.role, text, ts: message.timestamp, toolNames });
+  }
+
+  return {
+    source: "pi",
+    nativeSessionId: header.id,
+    cwd: header.cwd,
+    startedAt: Date.parse(header.timestamp),
+    modelId: model?.modelId ?? null,
+    jsonlPath,
+    messages,
+  };
+}
+
+function _parseClaude(jsonlPath: string): ImportedSession | undefined {
+  const entries = _readJsonl(jsonlPath);
+  const firstConversation = entries.find((entry) =>
+    (entry.type === "user" || entry.type === "assistant") && !entry.isMeta && !entry.isSidechain,
+  );
+  if (!firstConversation?.sessionId) return undefined;
+
+  const messages: ImportedMessage[] = [];
+  for (const entry of entries) {
+    if ((entry.type !== "user" && entry.type !== "assistant") || entry.isMeta || entry.isSidechain) continue;
+    const role = entry.message?.role;
+    if (role !== "user" && role !== "assistant") continue;
+    const text = _claudeText(entry.message);
+    if (!text || (role === "user" && _isClaudeInjectedContext(text))) continue;
+    const toolNames = role === "assistant"
+      ? entry.message.content.filter((block: any) => block.type === "tool_use").map((block: any) => block.name)
+      : [];
+    messages.push({ id: entry.uuid, role, text, ts: Date.parse(entry.timestamp), toolNames });
+  }
+
+  return {
+    source: "claude",
+    nativeSessionId: firstConversation.sessionId,
+    cwd: firstConversation.cwd ?? "",
+    startedAt: Date.parse(firstConversation.timestamp),
+    modelId: null,
+    jsonlPath,
+    messages,
+  };
+}
+
+function _parseCodex(jsonlPath: string): ImportedSession | undefined {
+  const entries = _readJsonl(jsonlPath);
+  const meta = entries.find((entry) => entry.type === "session_meta")?.payload;
+  if (!meta?.session_id) return undefined;
+
+  const messages: ImportedMessage[] = [];
+  for (const entry of entries) {
+    if (entry.type !== "response_item") continue;
+    const payload = entry.payload;
+    if (payload?.type !== "message" || (payload.role !== "user" && payload.role !== "assistant")) continue;
+    const text = _codexText(payload);
+    if (!text || (payload.role === "user" && _isCodexInjectedContext(text))) continue;
+    messages.push({
+      id: payload.id,
+      role: payload.role,
+      text,
+      ts: Date.parse(entry.timestamp),
+      toolNames: [],
+    });
+  }
+
+  return {
+    source: "codex",
+    nativeSessionId: meta.session_id,
+    cwd: meta.cwd ?? "",
+    startedAt: Date.parse(meta.timestamp),
+    modelId: meta.model_provider ?? null,
+    jsonlPath,
+    messages,
+  };
+}
+
+function _piText(message: any): string {
+  if (typeof message.content === "string") return message.content.trim();
+  return message.content
+    .filter((block: any) => block.type === "text")
+    .map((block: any) => block.text ?? "")
+    .join("\n")
+    .trim();
+}
+
+function _claudeText(message: any): string {
+  if (typeof message.content === "string") return message.content.trim();
+  if (!Array.isArray(message.content)) return "";
+  return message.content
+    .filter((block: any) => block.type === "text")
+    .map((block: any) => block.text ?? "")
+    .join("\n")
+    .trim();
+}
+
+function _codexText(message: any): string {
+  return message.content
+    .filter((block: any) => block.type === "input_text" || block.type === "output_text")
+    .map((block: any) => block.text ?? "")
+    .join("\n")
+    .trim();
+}
+
+function _isClaudeInjectedContext(text: string): boolean {
+  return text.startsWith("<command-name>")
+    || text.startsWith("<command-message>")
+    || text.startsWith("<local-command-")
+    || text.startsWith("<task-notification>")
+    || text.startsWith("This session is being continued from a previous conversation");
+}
+
+function _isCodexInjectedContext(text: string): boolean {
+  return text.startsWith("# AGENTS.md instructions")
+    || text.startsWith("<environment_context>")
+    || text.startsWith("# Context from my IDE setup:")
+    || text.startsWith("<image name=");
+}
+
+function _readJsonl(jsonlPath: string): any[] {
+  return readFileSync(jsonlPath, "utf8")
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => JSON.parse(line));
+}
+
+function _jsonlFiles(root: string): string[] {
+  const files: string[] = [];
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    const path = join(root, entry.name);
+    if (entry.isDirectory()) files.push(..._jsonlFiles(path));
+    if (entry.isFile() && entry.name.endsWith(".jsonl")) files.push(path);
+  }
+  return files;
+}

package/src/db.ts

@@ -0,0 +1,99 @@
+import { DatabaseSync } from "node:sqlite";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { mkdirSync } from "node:fs";
+
+const DB_PATH = process.env.MEMORY_DB_PATH ?? join(homedir(), ".pi", "agent", "memory.db");
+
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS sessions (
+  session_id  TEXT PRIMARY KEY,
+  source      TEXT NOT NULL DEFAULT 'pi',
+  cwd         TEXT NOT NULL,
+  started_at  INTEGER NOT NULL,
+  model_id    TEXT,
+  jsonl_path  TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_sessions_time ON sessions(started_at DESC);
+
+CREATE TABLE IF NOT EXISTS turns (
+  turn_id     TEXT PRIMARY KEY,
+  session_id  TEXT NOT NULL REFERENCES sessions(session_id),
+  turn_index  INTEGER NOT NULL,
+  ts          INTEGER NOT NULL,
+  user_text   TEXT NOT NULL,
+  reply_text  TEXT NOT NULL,
+  tool_names  TEXT,
+  user_message_id TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_turns_session ON turns(session_id, turn_index);
+CREATE INDEX IF NOT EXISTS idx_turns_ts      ON turns(ts DESC);
+`;
+
+let _db: DatabaseSync | undefined;
+
+export function getDb(): DatabaseSync {
+  if (_db) return _db;
+  mkdirSync(join(homedir(), ".pi", "agent"), { recursive: true });
+  _db = new DatabaseSync(DB_PATH);
+  _db.exec("PRAGMA journal_mode = WAL");
+  _db.exec("PRAGMA synchronous = NORMAL");
+  _db.exec(SCHEMA);
+  _migrate(_db);
+  return _db;
+}
+
+function _migrate(db: DatabaseSync): void {
+  const sessionColumns = db.prepare("PRAGMA table_info(sessions)").all() as Array<{ name: string }>;
+  if (!sessionColumns.some((column) => column.name === "source")) {
+    db.exec("ALTER TABLE sessions ADD COLUMN source TEXT NOT NULL DEFAULT 'pi'");
+  }
+
+  const turnColumns = db.prepare("PRAGMA table_info(turns)").all() as Array<{ name: string }>;
+  if (!turnColumns.some((column) => column.name === "user_message_id")) {
+    db.exec("ALTER TABLE turns ADD COLUMN user_message_id TEXT");
+    db.exec("DELETE FROM turns WHERE user_message_id IS NULL");
+    db.exec("DELETE FROM sessions WHERE session_id NOT IN (SELECT DISTINCT session_id FROM turns)");
+  }
+}
+
+export interface SessionRow {
+  session_id: string;
+  source:     "pi" | "claude" | "codex";
+  cwd:        string;
+  started_at: number;
+  model_id:   string | null;
+  jsonl_path: string;
+}
+
+export interface TurnRow {
+  turn_id:    string;
+  session_id: string;
+  turn_index: number;
+  ts:         number;
+  user_text:  string;
+  reply_text: string;
+  tool_names: string | null;
+  user_message_id: string;
+}
+
+export function upsertSession(row: SessionRow): void {
+  getDb().prepare(`
+    INSERT OR IGNORE INTO sessions (session_id, source, cwd, started_at, model_id, jsonl_path)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `).run(row.session_id, row.source, row.cwd, row.started_at, row.model_id, row.jsonl_path);
+}
+
+export function insertTurn(row: TurnRow): boolean {
+  const result = getDb().prepare(`
+    INSERT OR IGNORE INTO turns
+      (turn_id, session_id, turn_index, ts, user_text, reply_text, tool_names, user_message_id)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    row.turn_id, row.session_id, row.turn_index, row.ts,
+    row.user_text, row.reply_text, row.tool_names, row.user_message_id,
+  );
+  return result.changes === 1;
+}

package/src/retriever.ts

@@ -0,0 +1,70 @@
+import { getDb } from "./db.ts";
+
+export interface RecallResult {
+  turn_id: string;
+  source: "pi" | "claude" | "codex";
+  ts: number;
+  user_text: string;
+  reply_text: string;
+  hits: number;
+}
+
+export function recallTurns(entities: string[], topK = 5): RecallResult[] {
+  if (entities.length === 0) return [];
+
+  const scoreExpression = entities.map(() => `(
+    CASE WHEN LOWER(turns.user_text) LIKE ? ESCAPE '\\' THEN 2 ELSE 0 END +
+    CASE WHEN LOWER(turns.reply_text) LIKE ? ESCAPE '\\' THEN 1 ELSE 0 END
+  )`).join(" + ");
+  const scoreParameters = entities.flatMap((entity) => {
+    const pattern = _likePattern(entity);
+    return [pattern, pattern];
+  });
+
+  const whereExpression = entities.map(() => `(
+    LOWER(turns.user_text) LIKE ? ESCAPE '\\' OR
+    LOWER(turns.reply_text) LIKE ? ESCAPE '\\'
+  )`).join(" OR ");
+  const whereParameters = entities.flatMap((entity) => {
+    const pattern = _likePattern(entity);
+    return [pattern, pattern];
+  });
+
+  return getDb().prepare(`
+    SELECT
+      turns.turn_id,
+      sessions.source,
+      turns.ts,
+      turns.user_text,
+      turns.reply_text,
+      (${scoreExpression}) AS hits
+    FROM turns
+    JOIN sessions ON sessions.session_id = turns.session_id
+    WHERE ${whereExpression}
+    ORDER BY hits DESC, turns.ts DESC
+    LIMIT ?
+  `).all(...scoreParameters, ...whereParameters, topK) as RecallResult[];
+}
+
+export function formatRecallResults(results: RecallResult[]): string {
+  if (results.length === 0) return "No relevant past conversations found.";
+
+  const lines = ["## Relevant past conversations\n"];
+  for (const result of results) {
+    const date = new Date(result.ts).toLocaleString();
+    lines.push(`### [${result.source} · ${date}]`);
+    lines.push(`**You:** ${result.user_text}`);
+    if (result.reply_text) {
+      const preview = result.reply_text.length > 500
+        ? `${result.reply_text.slice(0, 500)}…`
+        : result.reply_text;
+      lines.push(`**Assistant:** ${preview}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+function _likePattern(entity: string): string {
+  return `%${entity.toLowerCase().replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_")}%`;
+}

package/src/writer.ts

@@ -0,0 +1,66 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import { upsertSession, insertTurn } from "./db.ts";
+
+export function writeTurn(ctx: ExtensionContext): void {
+  const sessionManager = ctx.sessionManager;
+  const sessionId = `pi:${sessionManager.getSessionId()}`;
+  const branch = sessionManager.getBranch();
+  const userEntry = [...branch].reverse().find((entry) =>
+    entry.type === "message" && entry.message.role === "user",
+  );
+  if (!userEntry) throw new Error("Current session branch has no user message");
+
+  const userText = _extractText(userEntry.message);
+  if (!userText) return;
+
+  let replyText = "";
+  const toolNames: string[] = [];
+  const userIndex = branch.indexOf(userEntry);
+  for (const entry of branch.slice(userIndex + 1)) {
+    if (entry.type !== "message" || entry.message.role !== "assistant") continue;
+    const message = entry.message as AssistantMessage;
+    for (const block of message.content) {
+      if (block.type === "text" && block.text.trim()) {
+        replyText += (replyText ? "\n" : "") + block.text.trim();
+      }
+      if (block.type === "toolCall") toolNames.push(block.name);
+    }
+  }
+
+  const header = sessionManager.getHeader();
+  upsertSession({
+    session_id: sessionId,
+    source: "pi",
+    cwd: sessionManager.getCwd(),
+    started_at: header ? Date.parse(header.timestamp) : userEntry.message.timestamp,
+    model_id: null,
+    jsonl_path: sessionManager.getSessionFile() ?? "",
+  });
+
+  insertTurn({
+    turn_id: `${sessionId}:${userEntry.id}`,
+    session_id: sessionId,
+    turn_index: _userTurnIndex(branch, userIndex),
+    ts: userEntry.message.timestamp,
+    user_text: userText,
+    reply_text: replyText,
+    tool_names: toolNames.length ? JSON.stringify([...new Set(toolNames)]) : null,
+    user_message_id: userEntry.id,
+  });
+}
+
+function _extractText(message: { content: string | Array<{ type: string; text?: string }> }): string {
+  if (typeof message.content === "string") return message.content.trim();
+  return message.content
+    .filter((block) => block.type === "text")
+    .map((block) => block.text)
+    .join("\n")
+    .trim();
+}
+
+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")
+    .length - 1;
+}

package/tests/core.test.ts

@@ -0,0 +1,67 @@
+import assert from "node:assert/strict";
+import { existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+
+const dbPath = join("/tmp", `pi-session-memory-${process.pid}.db`);
+process.env.MEMORY_DB_PATH = dbPath;
+
+const { getDb, insertTurn, upsertSession } = await import("../src/db.ts");
+const { recallTurns } = await import("../src/retriever.ts");
+
+function cleanup(): void {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    const path = `${dbPath}${suffix}`;
+    if (existsSync(path)) rmSync(path);
+  }
+}
+
+cleanup();
+
+upsertSession({
+  session_id: "pi:test",
+  source: "pi",
+  cwd: "/tmp",
+  started_at: 1,
+  model_id: null,
+  jsonl_path: "/tmp/test.jsonl",
+});
+
+assert.equal(insertTurn({
+  turn_id: "pi:test:user-1",
+  session_id: "pi:test",
+  turn_index: 0,
+  ts: 1,
+  user_text: "literal 100% and a_b",
+  reply_text: "first reply",
+  tool_names: null,
+  user_message_id: "user-1",
+}), true);
+
+assert.equal(insertTurn({
+  turn_id: "pi:test:user-2",
+  session_id: "pi:test",
+  turn_index: 1,
+  ts: 2,
+  user_text: "wildcard 100x and acb",
+  reply_text: "second reply",
+  tool_names: null,
+  user_message_id: "user-2",
+}), true);
+
+assert.equal(insertTurn({
+  turn_id: "pi:test:user-1",
+  session_id: "pi:test",
+  turn_index: 0,
+  ts: 1,
+  user_text: "duplicate",
+  reply_text: "duplicate",
+  tool_names: null,
+  user_message_id: "user-1",
+}), false);
+
+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);
+
+cleanup();
+console.log("core.test.ts: passed");

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "allowImportingTsExtensions": true,
+    "noEmit": true
+  }
+}