@gi4nks/ph 1.4.0 → 1.6.0

package/dist/cli.js

@@ -2,7 +2,7 @@
 
 // src/cli.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import React7 from "react";
+import React8 from "react";
 import { render } from "ink";
 
 // src/config/index.ts
@@ -29,15 +29,103 @@ import path2 from "path";
 import os2 from "os";
 import { createHash } from "crypto";
 import * as sqliteVec from "sqlite-vec";
+
+// src/db/semantic-index.ts
+var SemanticIndex = class {
+  constructor(db) {
+    this.db = db;
+  }
+  save(promptId, vector) {
+    const encoded = this.encode(vector);
+    this.db.prepare("INSERT OR REPLACE INTO embeddings (prompt_id, vector) VALUES (?, ?)").run(promptId, encoded);
+    this.db.prepare("INSERT OR REPLACE INTO vec_embeddings(rowid, embedding) VALUES (?, vec_f32(?))").run(BigInt(promptId), encoded);
+  }
+  search(query, limit, project) {
+    const encodedQuery = this.encode(query);
+    const projectFilter = project ? "AND json_extract(p.metadata, '$.project') = ?" : "";
+    const candidateLimit = project ? Math.max(1, this.db.prepare("SELECT count(*) AS count FROM vec_embeddings").get().count) : limit;
+    const sql = `
+      SELECT p.*, v.distance
+      FROM vec_embeddings v
+      JOIN prompts p ON p.id = v.rowid
+      WHERE v.embedding MATCH vec_f32(?) AND k = ?
+      ${projectFilter}
+      ORDER BY v.distance ASC
+    `;
+    return this.db.prepare(project ? `${sql} LIMIT ?` : sql).all(
+      encodedQuery,
+      candidateLimit,
+      ...project ? [project, limit] : []
+    );
+  }
+  loadAll() {
+    const rows = this.db.prepare("SELECT prompt_id, vector FROM embeddings").all();
+    return new Map(rows.map((row) => [row.prompt_id, this.decode(row.vector)]));
+  }
+  findMissingPrompts() {
+    return this.db.prepare(
+      `SELECT p.* FROM prompts p
+       LEFT JOIN vec_embeddings e ON e.rowid = p.id
+       WHERE e.rowid IS NULL`
+    ).all();
+  }
+  encode(vector) {
+    const buffer = Buffer.alloc(vector.length * 4);
+    for (let i = 0; i < vector.length; i++) buffer.writeFloatLE(vector[i], i * 4);
+    return buffer;
+  }
+  decode(buffer) {
+    const vector = new Float32Array(buffer.length / 4);
+    for (let i = 0; i < vector.length; i++) vector[i] = buffer.readFloatLE(i * 4);
+    return vector;
+  }
+};
+
+// src/db/index.ts
 function defaultPath() {
   return path2.join(os2.homedir(), ".prompt_history.db");
 }
-var PhDB = class {
+var PhDB = class _PhDB {
+  static PROJECT_SUMMARIES_SCHEMA = `
+    CREATE TABLE IF NOT EXISTS project_summaries (
+      project     TEXT    PRIMARY KEY,
+      summary     TEXT    NOT NULL DEFAULT '',
+      key_insights TEXT   NOT NULL DEFAULT '[]',
+      technical_decisions TEXT NOT NULL DEFAULT '[]',
+      prompt_count INTEGER NOT NULL DEFAULT 0,
+      first_analyzed TEXT  NOT NULL,
+      last_analyzed TEXT   NOT NULL,
+      git_context_snapshot TEXT
+    );
+  `;
+  static ARCHIVE_SCHEMA = `
+    CREATE TABLE IF NOT EXISTS prompts_archive (
+      id        INTEGER PRIMARY KEY AUTOINCREMENT,
+      timestamp TEXT    NOT NULL,
+      tool      TEXT    NOT NULL,
+      prompt    TEXT    NOT NULL,
+      response  TEXT    NOT NULL DEFAULT '',
+      args      TEXT    NOT NULL DEFAULT '',
+      workdir   TEXT    NOT NULL DEFAULT '',
+      hostname  TEXT    NOT NULL DEFAULT '',
+      exit_code INTEGER NOT NULL DEFAULT 0,
+      metadata  TEXT    NOT NULL DEFAULT '{}',
+      archived_at TEXT   NOT NULL,
+      original_id INTEGER
+    );
+    CREATE INDEX IF NOT EXISTS idx_archive_timestamp ON prompts_archive(timestamp);
+    CREATE INDEX IF NOT EXISTS idx_archive_original_id ON prompts_archive(original_id);
+  `;
   db;
+  semanticIndex;
+  /** Absolute path of the SQLite file (used by the HTTP server health endpoint). */
+  dbPath;
   constructor(dbPath) {
+    this.dbPath = dbPath;
     this.db = new Database(dbPath);
     this.db.pragma("journal_mode = WAL");
     sqliteVec.load(this.db);
+    this.semanticIndex = new SemanticIndex(this.db);
     this.migrate();
   }
   migrate() {
@@ -104,6 +192,8 @@ var PhDB = class {
       );
       CREATE INDEX IF NOT EXISTS idx_memories_project ON memories(project);
     `);
+    this.db.exec(_PhDB.PROJECT_SUMMARIES_SCHEMA);
+    this.db.exec(_PhDB.ARCHIVE_SCHEMA);
     const rowsWithoutSchema = this.db.prepare("SELECT id, metadata FROM prompts WHERE json_extract(metadata, '$.\\$schema_version') IS NULL").all();
     for (const row of rowsWithoutSchema) {
       try {
@@ -163,6 +253,7 @@ var PhDB = class {
       `);
     }
   }
+  /** `response` is optional at the call site (runtime defaults to ''). */
   insert(entry) {
     const meta = entry.metadata || "{}";
     const response = entry.response ?? "";
@@ -281,45 +372,16 @@ var PhDB = class {
     }
   }
   saveEmbedding(id, vector) {
-    const buf = Buffer.alloc(vector.length * 4);
-    for (let i = 0; i < vector.length; i++) {
-      buf.writeFloatLE(vector[i], i * 4);
-    }
-    this.db.prepare("INSERT OR REPLACE INTO embeddings (prompt_id, vector) VALUES (?, ?)").run(id, buf);
-    this.db.prepare("INSERT OR REPLACE INTO vec_embeddings(rowid, embedding) VALUES (?, vec_f32(?))").run(BigInt(id), buf);
+    this.semanticIndex.save(id, vector);
   }
-  searchSemantic(queryVector, limit) {
-    const buf = Buffer.alloc(queryVector.length * 4);
-    for (let i = 0; i < queryVector.length; i++) {
-      buf.writeFloatLE(queryVector[i], i * 4);
-    }
-    const sql = `
-      SELECT p.*, v.distance
-      FROM vec_embeddings v
-      JOIN prompts p ON p.id = v.rowid
-      WHERE v.embedding MATCH vec_f32(?) AND k = ?
-      ORDER BY v.distance ASC
-    `;
-    return this.db.prepare(sql).all(buf, limit);
+  searchSemantic(queryVector, limit, project) {
+    return this.semanticIndex.search(queryVector, limit, project);
   }
   getAllEmbeddings() {
-    const rows = this.db.prepare("SELECT prompt_id, vector FROM embeddings").all();
-    const map = /* @__PURE__ */ new Map();
-    for (const row of rows) {
-      const vec = new Float32Array(row.vector.length / 4);
-      for (let i = 0; i < vec.length; i++) {
-        vec[i] = row.vector.readFloatLE(i * 4);
-      }
-      map.set(row.prompt_id, vec);
-    }
-    return map;
+    return this.semanticIndex.loadAll();
   }
   getPromptsWithoutEmbeddings() {
-    return this.db.prepare(
-      `SELECT p.* FROM prompts p
-         LEFT JOIN vec_embeddings e ON e.rowid = p.id
-         WHERE e.rowid IS NULL`
-    ).all();
+    return this.semanticIndex.findMissingPrompts();
   }
   getAllPrompts(limit = 1e6) {
     return this.db.prepare("SELECT * FROM prompts ORDER BY timestamp DESC LIMIT ?").all(limit);
@@ -330,6 +392,15 @@ var PhDB = class {
   getPromptCount() {
     return this.db.prepare("SELECT count(*) as c FROM prompts").get().c;
   }
+  getPromptCountSince(timestamp) {
+    return this.db.prepare("SELECT count(*) as c FROM prompts WHERE timestamp > ?").get(timestamp).c;
+  }
+  getStats() {
+    const total = this.db.prepare("SELECT count(*) as c FROM prompts").get().c;
+    const totalMemories = this.db.prepare("SELECT count(*) as c FROM memories").get().c;
+    const byTool = this.db.prepare("SELECT tool, count(*) as count FROM prompts GROUP BY tool ORDER BY count DESC").all();
+    return { total, totalMemories, byTool };
+  }
   getPromptBySyncHash(hash) {
     return this.db.prepare("SELECT * FROM prompts WHERE json_extract(metadata, '$.sync_hash') = ?").get(hash);
   }
@@ -369,6 +440,72 @@ var PhDB = class {
     }
     return 0;
   }
+  archivePrompts(ids) {
+    if (ids.length === 0) return 0;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const select = this.db.prepare(`
+      SELECT id, timestamp, tool, prompt, response, args, workdir, hostname, exit_code, metadata
+      FROM prompts WHERE id = ?
+    `);
+    const insert = this.db.prepare(`
+      INSERT INTO prompts_archive (timestamp, tool, prompt, response, args, workdir, hostname, exit_code, metadata, archived_at, original_id)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const del = this.db.prepare("DELETE FROM prompts WHERE id = ?");
+    const transaction = this.db.transaction((toArchive) => {
+      let count = 0;
+      for (const id of toArchive) {
+        const row = select.get(id);
+        if (!row) continue;
+        insert.run(
+          row.timestamp,
+          row.tool,
+          row.prompt,
+          row.response,
+          row.args,
+          row.workdir,
+          row.hostname,
+          row.exit_code,
+          row.metadata,
+          now,
+          id
+        );
+        del.run(id);
+        count++;
+      }
+      return count;
+    });
+    return transaction(ids);
+  }
+  searchArchive(opts) {
+    let sql = "SELECT * FROM prompts_archive WHERE 1=1";
+    const params = [];
+    if (opts.since) {
+      sql += " AND timestamp >= ?";
+      params.push(opts.since);
+    }
+    if (opts.until) {
+      sql += " AND timestamp <= ?";
+      params.push(opts.until);
+    }
+    sql += " ORDER BY timestamp DESC";
+    if (opts.limit) {
+      sql += " LIMIT ?";
+      params.push(opts.limit);
+    }
+    return this.db.prepare(sql).all(...params);
+  }
+  purgeArchive(beforeDate) {
+    const result = this.db.prepare("DELETE FROM prompts_archive WHERE archived_at < ?").run(beforeDate);
+    return result.changes;
+  }
+  getArchiveStats() {
+    const row = this.db.prepare(`
+      SELECT COUNT(*) as total, MIN(timestamp) as oldest, MAX(timestamp) as newest
+      FROM prompts_archive
+    `).get();
+    return row;
+  }
   vacuum() {
     this.db.exec("VACUUM");
   }
@@ -460,10 +597,62 @@ var PhDB = class {
       last_accessed: void 0
     });
   }
+  getLastMemoryForProject(project) {
+    const row = this.db.prepare("SELECT * FROM memories WHERE project = ? ORDER BY updated_at DESC LIMIT 1").get(project);
+    if (!row) return void 0;
+    return this.hydrateMemory(row);
+  }
   getAllProjectsWithMemories() {
     const rows = this.db.prepare("SELECT DISTINCT project FROM memories ORDER BY project").all();
     return rows.map((r) => r.project);
   }
+  upsertProjectSummary(params) {
+    const existing = this.getProjectSummary(params.project);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (existing) {
+      const allInsights = /* @__PURE__ */ new Set([...existing.key_insights, ...params.key_insights]);
+      const allDecisions = /* @__PURE__ */ new Set([...existing.technical_decisions, ...params.technical_decisions]);
+      this.db.prepare(`
+        UPDATE project_summaries
+        SET summary = ?,
+            key_insights = ?,
+            technical_decisions = ?,
+            prompt_count = prompt_count + 1,
+            last_analyzed = ?,
+            git_context_snapshot = COALESCE(?, git_context_snapshot)
+        WHERE project = ?
+      `).run(
+        params.summary,
+        JSON.stringify([...allInsights]),
+        JSON.stringify([...allDecisions]),
+        now,
+        params.git_context_snapshot || null,
+        params.project
+      );
+    } else {
+      this.db.prepare(`
+        INSERT INTO project_summaries (project, summary, key_insights, technical_decisions, prompt_count, first_analyzed, last_analyzed, git_context_snapshot)
+        VALUES (?, ?, ?, ?, 1, ?, ?, ?)
+      `).run(
+        params.project,
+        params.summary,
+        JSON.stringify(params.key_insights),
+        JSON.stringify(params.technical_decisions),
+        now,
+        now,
+        params.git_context_snapshot || null
+      );
+    }
+  }
+  getProjectSummary(project) {
+    const row = this.db.prepare("SELECT * FROM project_summaries WHERE project = ?").get(project);
+    if (!row) return null;
+    return this.hydrateProjectSummary(row);
+  }
+  getAllProjectsWithSummaries() {
+    const rows = this.db.prepare("SELECT project FROM project_summaries ORDER BY project").all();
+    return rows.map((r) => r.project);
+  }
   recordMemoryAccess(id) {
     this.db.prepare("UPDATE memories SET access_count = access_count + 1, last_accessed = ? WHERE id = ?").run((/* @__PURE__ */ new Date()).toISOString(), id);
   }
@@ -485,6 +674,43 @@ var PhDB = class {
       last_accessed: row.last_accessed
     };
   }
+  hydrateProjectSummary(row) {
+    return {
+      project: row.project,
+      summary: row.summary,
+      key_insights: JSON.parse(row.key_insights),
+      technical_decisions: JSON.parse(row.technical_decisions),
+      prompt_count: row.prompt_count,
+      first_analyzed: row.first_analyzed,
+      last_analyzed: row.last_analyzed,
+      git_context_snapshot: row.git_context_snapshot
+    };
+  }
+  getAllPromptsByProject(project) {
+    return this.db.prepare(`
+        SELECT * FROM prompts
+        WHERE json_extract(metadata, '$.project') = ?
+        ORDER BY timestamp ASC
+      `).all(project);
+  }
+  getPromptsByProjectPaginated(project, page, pageSize) {
+    const total = this.db.prepare("SELECT COUNT(*) as count FROM prompts WHERE json_extract(metadata, '$.project') = ?").get(project);
+    const entries = this.db.prepare(`
+        SELECT * FROM prompts
+        WHERE json_extract(metadata, '$.project') = ?
+        ORDER BY timestamp DESC
+        LIMIT ? OFFSET ?
+      `).all(project, pageSize, (page - 1) * pageSize);
+    return { entries, total: total.count };
+  }
+  getPromptCountByProject(project) {
+    const row = this.db.prepare("SELECT COUNT(*) as count FROM prompts WHERE json_extract(metadata, '$.project') = ?").get(project);
+    return row.count;
+  }
+  getAllMemoriesByProject(project) {
+    const rows = this.db.prepare("SELECT * FROM memories WHERE project = ? ORDER BY created_at ASC").all(project);
+    return rows.map((r) => this.hydrateMemory(r));
+  }
   close() {
     this.db.close();
   }
@@ -504,6 +730,34 @@ function cosineSimilarity(a, b) {
 // src/runner/inline.ts
 import { spawn, execFileSync as execFileSync2 } from "child_process";
 import fs3 from "fs";
+
+// src/runner/git-context.ts
+import { execFileSync } from "child_process";
+function captureGitContext(workdir) {
+  try {
+    const branch = execFileSync("git", ["-C", workdir, "rev-parse", "--abbrev-ref", "HEAD"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+    const filesRaw = execFileSync("git", ["-C", workdir, "diff", "--name-only", "HEAD"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+    const files = filesRaw ? filesRaw.split("\n").filter(Boolean) : [];
+    let diff = execFileSync("git", ["-C", workdir, "diff", "HEAD"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (diff.length > 4e3) {
+      diff = diff.slice(0, 4e3) + "\n... (truncated)";
+    }
+    return { branch, files, diff };
+  } catch {
+    return null;
+  }
+}
+
+// src/capture/index.ts
 import os3 from "os";
 
 // src/runner/project.ts
@@ -550,30 +804,119 @@ function detectLanguage(rootDir) {
   return "";
 }
 
-// src/runner/git-context.ts
-import { execFileSync } from "child_process";
-function captureGitContext(workdir) {
-  try {
-    const branch = execFileSync("git", ["-C", workdir, "rev-parse", "--abbrev-ref", "HEAD"], {
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "pipe"]
-    }).trim();
-    const filesRaw = execFileSync("git", ["-C", workdir, "diff", "--name-only", "HEAD"], {
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "pipe"]
-    }).trim();
-    const files = filesRaw ? filesRaw.split("\n").filter(Boolean) : [];
-    let diff = execFileSync("git", ["-C", workdir, "diff", "HEAD"], {
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    if (diff.length > 4e3) {
-      diff = diff.slice(0, 4e3) + "\n... (truncated)";
+// src/utils/extractTopic.ts
+function extractTopic(prompt) {
+  let text = prompt.trim();
+  if (!text) {
+    return "(empty prompt)";
+  }
+  if (text.startsWith("```") || text.startsWith("`")) {
+    return truncateAtWordBoundary(text, 72);
+  }
+  const originalTrimmed = text;
+  if (text.startsWith("#")) {
+    const headingMatch = text.match(/^#+\s+(.*?)(?:\s+#+)?(?:\n|$)/);
+    if (headingMatch && headingMatch[1]) {
+      text = headingMatch[1].trim();
     }
-    return { branch, files, diff };
-  } catch {
-    return null;
   }
+  const prefixes = [
+    // English
+    "please, ",
+    "please ",
+    "can you please ",
+    "could you please ",
+    "can you ",
+    "could you ",
+    "would you ",
+    "i need you to ",
+    "i need to ",
+    "i want you to ",
+    "i want to ",
+    "i'd like you to ",
+    "i'd like to ",
+    "help me to ",
+    "help me ",
+    "i need ",
+    "claude, ",
+    "gemini, ",
+    "chatgpt, ",
+    // Italiano
+    "puoi ",
+    "potresti ",
+    "potreste ",
+    "per favore ",
+    "per piacere ",
+    "ho bisogno che ",
+    "ho bisogno di ",
+    "voglio che ",
+    "vorrei che ",
+    "voglio ",
+    "vorrei ",
+    "aiutami a ",
+    "aiutami ",
+    "fammi vedere ",
+    "fammi ",
+    "si prega di ",
+    "si "
+  ];
+  let changed = true;
+  while (changed) {
+    changed = false;
+    const lowerText = text.toLowerCase();
+    for (const prefix of prefixes) {
+      if (lowerText.startsWith(prefix.toLowerCase())) {
+        text = text.slice(prefix.length).trim();
+        changed = true;
+        break;
+      }
+    }
+  }
+  const sentenceEndMatch = text.match(/[\n.?!`]/);
+  if (sentenceEndMatch && sentenceEndMatch.index !== void 0) {
+    text = text.slice(0, sentenceEndMatch.index).trim();
+  }
+  if (!text) {
+    return truncateAtWordBoundary(originalTrimmed, 72);
+  }
+  text = truncateAtWordBoundary(text, 72);
+  return text.charAt(0).toUpperCase() + text.slice(1);
+}
+function truncateAtWordBoundary(str, limit) {
+  const clean = str.replace(/\s+/g, " ").trim();
+  if (clean.length <= limit) return clean;
+  const sub = clean.slice(0, limit);
+  const lastSpace = sub.lastIndexOf(" ");
+  if (lastSpace > 0) {
+    return sub.slice(0, lastSpace);
+  }
+  return sub;
+}
+
+// src/capture/index.ts
+function createCaptureRecord(input) {
+  const { rootDir, projectName } = detectProject(input.workdir);
+  const language = detectLanguage(rootDir);
+  const title = extractTopic(input.prompt);
+  const metadata = {
+    $schema_version: 1,
+    ...projectName ? { project: projectName } : {},
+    ...language ? { language } : {},
+    ...title ? { title } : {},
+    ...input.gitContext ? { git_context: input.gitContext } : {},
+    ...input.metadata
+  };
+  return {
+    timestamp: input.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+    tool: input.tool,
+    prompt: input.prompt,
+    response: input.response ?? "",
+    args: input.args ?? "",
+    workdir: input.workdir,
+    hostname: input.hostname ?? os3.hostname(),
+    exit_code: input.exit_code ?? 0,
+    metadata: JSON.stringify(metadata)
+  };
 }
 
 // src/runner/inline.ts
@@ -602,26 +945,15 @@ function resolveRealBinary(tool) {
 }
 async function runInline(realBin, args, db, tool, tags, role, onInserted) {
   const workdir = process.cwd();
-  const { rootDir, projectName } = detectProject(workdir);
-  const language = detectLanguage(rootDir);
   const gitContext = captureGitContext(workdir);
-  const metaObj = {};
-  if (projectName) metaObj.project = projectName;
-  if (language) metaObj.language = language;
-  if (role) metaObj.role = role;
-  if (tags.length > 0) metaObj.tags = tags;
-  if (gitContext) metaObj.git_context = gitContext;
-  const metadata = Object.keys(metaObj).length > 0 ? JSON.stringify(metaObj) : "{}";
-  const id = db.insert({
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+  const id = db.insert(createCaptureRecord({
     tool,
     prompt: extractPrompt(args),
     args: args.join(" "),
     workdir,
-    hostname: os3.hostname(),
-    exit_code: 0,
-    metadata
-  });
+    gitContext,
+    metadata: { ...role ? { role } : {}, ...tags.length > 0 ? { tags } : {} }
+  }));
   if (onInserted) onInserted(id);
   const child = spawn(realBin, args, { stdio: "inherit" });
   child.on("error", (err) => {
@@ -643,7 +975,7 @@ function cleanLine(bytes) {
   const s = Buffer.from(bytes).toString("utf-8");
   return s.trim();
 }
-function stripAnsi(text) {
+function stripPtyControlSequences(text) {
   return text.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, "");
 }
 async function runPTY(binary, args, onPrompt, onResponse, debugLog) {
@@ -696,7 +1028,7 @@ async function runPTY(binary, args, onPrompt, onResponse, debugLog) {
             log(`ENTER \u2192 prompt: ${JSON.stringify(prompt)}`);
             if (prompt) {
               if (currentPromptId !== null) {
-                onResponse(currentPromptId, stripAnsi(responseBuffer));
+                onResponse(currentPromptId, stripPtyControlSequences(responseBuffer));
               }
               currentPromptId = onPrompt(prompt, /* @__PURE__ */ new Date());
               responseBuffer = "";
@@ -740,7 +1072,7 @@ async function runPTY(binary, args, onPrompt, onResponse, debugLog) {
   return new Promise((resolve) => {
     ptyProcess.onExit(({ exitCode }) => {
       if (currentPromptId !== null) {
-        onResponse(currentPromptId, stripAnsi(responseBuffer));
+        onResponse(currentPromptId, stripPtyControlSequences(responseBuffer));
       }
       process.stdin.removeListener("data", onData);
       process.stdout.removeListener("resize", onResize);
@@ -790,26 +1122,169 @@ async function getEmbeddings(texts, ollamaUrl, model, batchSize = 20) {
   return results;
 }
 
-// src/mcp/server.ts
-import { z } from "zod";
-async function runMCPServer() {
-  const cfg = load();
-  const dbPath = process.env.PH_DB ?? cfg.dbPath ?? defaultPath();
-  const db = new PhDB(dbPath);
-  const server = new Server(
-    {
-      name: "ph-memory",
-      version: "1.0.0"
-    },
-    {
-      capabilities: {
-        tools: {}
+// src/context/index.ts
+async function getProjectContext(db, options, embedQuery) {
+  const limit = Math.max(1, Math.floor(options.limit ?? 5));
+  const memoryLimit = Math.max(1, Math.floor(options.memoryLimit ?? limit));
+  const includeSummary = options.includeSummary ?? true;
+  const includeMemories = options.includeMemories ?? true;
+  const includePrompts = options.includePrompts ?? true;
+  const summary = includeSummary ? db.getProjectSummary(options.project) : null;
+  const memories = includeMemories ? db.searchMemories(options.project, memoryLimit) : [];
+  let prompts = [];
+  if (includePrompts) {
+    const query = options.query?.trim();
+    if (query) {
+      if (!embedQuery) throw new Error("Semantic context requires an embedding provider.");
+      const vector = await embedQuery(query);
+      prompts = vector ? db.searchSemantic(vector, limit, options.project) : [];
+    } else {
+      prompts = db.getProjectMemory(options.project, limit);
+    }
+  }
+  return { project: options.project, summary, memories, prompts };
+}
+function formatProjectContext(context, options = {}) {
+  const parts = [];
+  const { summary, memories, prompts, project } = context;
+  if (summary || memories.length > 0) {
+    parts.push(`## Project Knowledge: ${project}
+`);
+    if (summary?.summary) parts.push(`${summary.summary}
+`);
+    if (summary?.key_insights.length) {
+      parts.push("Key Insights:");
+      for (const insight of summary.key_insights) parts.push(`  - ${insight}`);
+      parts.push("");
+    }
+    if (summary?.technical_decisions.length) {
+      parts.push("Technical Decisions:");
+      for (const decision of summary.technical_decisions) parts.push(`  - ${decision}`);
+      parts.push("");
+    }
+    if (!summary && memories.length > 0) {
+      for (const memory of memories) {
+        parts.push(`### Memory #${memory.id}`);
+        if (memory.summary) parts.push(`${memory.summary}
+`);
+        if (memory.key_insights.length) {
+          parts.push("Key Insights:");
+          for (const insight of memory.key_insights) parts.push(`  - ${insight}`);
+          parts.push("");
+        }
+        if (memory.technical_decisions.length) {
+          parts.push("Technical Decisions:");
+          for (const decision of memory.technical_decisions) parts.push(`  - ${decision}`);
+          parts.push("");
+        }
+      }
+    }
+    if (summary && memories.length > 0) {
+      parts.push("Recent Memory Entries:");
+      for (const memory of memories) {
+        if (memory.summary) parts.push(`  - [memory #${memory.id}] ${memory.summary}`);
+      }
+      parts.push("");
+    }
+  }
+  if (prompts.length > 0) {
+    if (parts.length > 0) parts.push("---\n");
+    parts.push("## Recent Context\n");
+    for (const entry of prompts) {
+      let metadata = {};
+      try {
+        metadata = JSON.parse(entry.metadata);
+      } catch {
+      }
+      parts.push(`### Interaction #${entry.id} \u2014 ${entry.tool} (${new Date(entry.timestamp).toLocaleDateString()})`);
+      if (metadata.role) parts.push(`Role: ${metadata.role}`);
+      const promptSummary = metadata.summary || (options.includePromptText || options.promptExcerptLength ? "" : entry.prompt.slice(0, 100).replace(/\n/g, " "));
+      if (promptSummary) parts.push(promptSummary);
+      if (metadata.key_insights?.length) {
+        for (const insight of metadata.key_insights) parts.push(`  - ${insight}`);
+      }
+      if (options.includePromptText) {
+        parts.push("```\n" + entry.prompt.slice(0, 1e3) + (entry.prompt.length > 1e3 ? "\n..." : "") + "\n```");
+      } else if (options.promptExcerptLength) {
+        const excerpt = entry.prompt.slice(0, options.promptExcerptLength);
+        parts.push(`Prompt: ${excerpt}${entry.prompt.length > options.promptExcerptLength ? "..." : ""}`);
+      }
+      if (options.responseExcerptLength && entry.response) {
+        const response = entry.response.slice(0, options.responseExcerptLength);
+        parts.push(`Response: ${response}${entry.response.length > options.responseExcerptLength ? "..." : ""}`);
+      }
+      parts.push("");
+    }
+  }
+  if (parts.length === 0) return options.emptyMessage ?? `No relevant context found for project "${project}".`;
+  return parts.join("\n").trimEnd();
+}
+
+// src/mcp/server.ts
+import { z } from "zod";
+function createMCPServer(db, cfg = load()) {
+  const server = new Server(
+    {
+      name: "ph-memory",
+      version: "1.0.0"
+    },
+    {
+      capabilities: {
+        tools: {}
       }
     }
   );
   server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {
       tools: [
+        {
+          name: "list_prompts",
+          description: "List prompts for a project with pagination. Use page=1, pageSize=10 to browse.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              project: { type: "string", description: "Project name to list prompts for" },
+              page: { type: "number", description: "Page number (1-based)", default: 1 },
+              pageSize: { type: "number", description: "Results per page (max 100)", default: 20 }
+            },
+            required: ["project"]
+          }
+        },
+        {
+          name: "save_decision",
+          description: "Save an architectural decision or key insight to project memory.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              project: { type: "string", description: "Project name" },
+              summary: { type: "string", description: "Brief summary of the decision" },
+              keyInsights: {
+                type: "array",
+                items: { type: "string" },
+                description: "Key insights or takeaways"
+              },
+              technicalDecisions: {
+                type: "array",
+                items: { type: "string" },
+                description: "Technical decisions made"
+              }
+            },
+            required: ["project", "summary"]
+          }
+        },
+        {
+          name: "get_project_diff",
+          description: "Compare project state between two points in time. Shows prompts and memory entries created in the date range.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              project: { type: "string", description: "Project name" },
+              since: { type: "string", description: "Start date (ISO 8601, e.g. 2026-01-01)" },
+              until: { type: "string", description: "End date (ISO 8601, defaults to now)" }
+            },
+            required: ["project", "since"]
+          }
+        },
         {
           name: "search_project_memory",
           description: "Search for past interactions and technical decisions in a specific project using semantic search.",
@@ -886,6 +1361,33 @@ async function runMCPServer() {
             },
             required: ["query"]
           }
+        },
+        {
+          name: "get_project_timeline",
+          description: "Get full chronological timeline of a project: all prompts, analysis summaries, key insights, and technical decisions in sequence.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              project: { type: "string", description: "The project name" },
+              since: { type: "string", description: "Start date (ISO 8601, optional)" },
+              until: { type: "string", description: "End date (ISO 8601, optional)" },
+              limit: { type: "number", description: "Max events to return (default 100)", default: 100 }
+            },
+            required: ["project"]
+          }
+        },
+        {
+          name: "check_project_knowledge",
+          description: "Before implementing a feature, check if it already exists in project history. Searches memories and prompts for previous implementations, discussions, and technical decisions related to a task.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              project: { type: "string", description: "The project name" },
+              task: { type: "string", description: "Description of the feature or task to check" },
+              limit: { type: "number", description: "Max results per search (default 5)", default: 5 }
+            },
+            required: ["project", "task"]
+          }
         }
       ]
     };
@@ -893,6 +1395,115 @@ async function runMCPServer() {
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     try {
+      if (name === "list_prompts") {
+        const { project, page = 1, pageSize = 20 } = z.object({
+          project: z.string(),
+          page: z.number().optional(),
+          pageSize: z.number().max(100).optional()
+        }).parse(args);
+        const result = db.getPromptsByProjectPaginated(project, page, pageSize);
+        const totalPages = Math.ceil(result.total / pageSize);
+        const text = [
+          `## Prompts for "${project}"`,
+          `Page ${page}/${totalPages} (${result.total} total)
+`,
+          ...result.entries.map((e) => {
+            let meta = {};
+            try {
+              meta = JSON.parse(e.metadata);
+            } catch {
+            }
+            const date = new Date(e.timestamp).toLocaleString();
+            const title = meta.title ? ` \u2014 ${meta.title}` : "";
+            const roleStr = meta.role ? ` (${meta.role})` : "";
+            return `### #${e.id} \u2014 ${e.tool}${roleStr} (${date})${title}
+${meta.summary ? `Summary: ${meta.summary}
+` : ""}Prompt: ${e.prompt.slice(0, 200)}${e.prompt.length > 200 ? "..." : ""}`;
+          }).join("\n\n"),
+          "",
+          `Page ${page}/${totalPages} | ${result.total} total prompts`
+        ].join("\n");
+        return { content: [{ type: "text", text }] };
+      }
+      if (name === "save_decision") {
+        const { project, summary, keyInsights, technicalDecisions } = z.object({
+          project: z.string(),
+          summary: z.string(),
+          keyInsights: z.array(z.string()).optional(),
+          technicalDecisions: z.array(z.string()).optional()
+        }).parse(args);
+        const id = db.insertMemory({
+          project,
+          prompt_ids: [],
+          summary,
+          key_insights: keyInsights ?? [],
+          technical_decisions: technicalDecisions ?? [],
+          created_at: (/* @__PURE__ */ new Date()).toISOString(),
+          updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+          access_count: 0
+        });
+        db.upsertProjectSummary({
+          project,
+          summary,
+          key_insights: keyInsights ?? [],
+          technical_decisions: technicalDecisions ?? []
+        });
+        return {
+          content: [{ type: "text", text: `Decision saved as memory #${id} for project "${project}".
+
+Summary: ${summary}
+Key Insights: ${(keyInsights ?? []).length}
+Technical Decisions: ${(technicalDecisions ?? []).length}` }]
+        };
+      }
+      if (name === "get_project_diff") {
+        const { project, since, until } = z.object({
+          project: z.string(),
+          since: z.string(),
+          until: z.string().optional()
+        }).parse(args);
+        const sinceDate = new Date(since);
+        const untilDate = until ? new Date(until) : /* @__PURE__ */ new Date();
+        const prompts = db.search({
+          project,
+          since: sinceDate,
+          until: untilDate,
+          limit: 1e3
+        });
+        const memories = db.getAllMemoriesByProject(project).filter((m) => {
+          const created = new Date(m.created_at);
+          return created >= sinceDate && created <= untilDate;
+        });
+        const lines = [
+          `## Project Diff: ${project}`,
+          `From: ${since}  To: ${until || "now"}`,
+          `Prompts: ${prompts.length}  Memories: ${memories.length}
+`
+        ];
+        if (prompts.length > 0) {
+          lines.push("### Prompts\n");
+          for (const p of prompts.reverse()) {
+            let meta = {};
+            try {
+              meta = JSON.parse(p.metadata);
+            } catch {
+            }
+            const title = meta.title ? ` \u2014 ${meta.title}` : "";
+            const roleStr = meta.role ? ` (${meta.role})` : "";
+            lines.push(`- **#${p.id}** ${p.tool}${roleStr}${title} (${new Date(p.timestamp).toLocaleDateString()})`);
+            if (meta.summary) lines.push(`  Summary: ${meta.summary}`);
+          }
+        }
+        if (memories.length > 0) {
+          lines.push("\n### Memory Entries\n");
+          for (const m of memories) {
+            lines.push(`- **Memory #${m.id}**: ${m.summary}`);
+            for (const i of m.key_insights) lines.push(`  - Insight: ${i}`);
+            for (const d of m.technical_decisions) lines.push(`  - Decision: ${d}`);
+          }
+        }
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      }
       if (name === "search_project_memory") {
         const { query, project, limit = 5 } = z.object({
           query: z.string(),
@@ -905,15 +1516,30 @@ async function runMCPServer() {
         if (!queryVec) {
           throw new Error("Failed to generate embedding for query");
         }
-        const results = db.searchSemantic(queryVec, limit * 2);
-        const filtered = results.filter((e) => {
-          try {
-            const meta = JSON.parse(e.metadata);
-            return meta.project === project;
-          } catch {
-            return false;
+        const filtered = db.searchSemantic(queryVec, limit, project);
+        if (filtered.length === 0) {
+          const merged = db.getProjectSummary(project);
+          if (merged) {
+            const parts = [
+              `## Project Knowledge: ${project}
+`,
+              `Based on ${merged.prompt_count} interactions.
+`
+            ];
+            if (merged.summary) parts.push(`${merged.summary}
+`);
+            if (merged.key_insights.length > 0) {
+              parts.push("\n**Key Insights:**");
+              for (const i of merged.key_insights) parts.push(`- ${i}`);
+            }
+            if (merged.technical_decisions.length > 0) {
+              parts.push("\n**Technical Decisions:**");
+              for (const d of merged.technical_decisions) parts.push(`- ${d}`);
+            }
+            return { content: [{ type: "text", text: parts.join("\n") }] };
           }
-        }).slice(0, limit);
+          return { content: [{ type: "text", text: `No relevant memory found for project "${project}".` }] };
+        }
         return {
           content: [{ type: "text", text: formatResultsAsMarkdown(filtered) }]
         };
@@ -923,59 +1549,39 @@ async function runMCPServer() {
           project: z.string(),
           limit: z.number().optional()
         }).parse(args);
-        const memories = db.searchMemories(project, 3);
-        const prompts = db.getProjectMemory(project, limit);
-        const parts = [];
-        if (memories.length > 0) {
-          parts.push("## Project Knowledge\n");
-          for (const mem of memories) {
-            if (mem.summary) parts.push(`${mem.summary}
-`);
-            if (mem.key_insights.length > 0) {
-              parts.push("Key Insights:");
-              for (const i of mem.key_insights) parts.push(`  - ${i}`);
-              parts.push("");
-            }
-            if (mem.technical_decisions.length > 0) {
-              parts.push("Technical Decisions:");
-              for (const d of mem.technical_decisions) parts.push(`  - ${d}`);
-              parts.push("");
-            }
-          }
-        }
-        if (prompts.length > 0) {
-          if (parts.length > 0) parts.push("---\n");
-          parts.push("## Recent Interactions\n");
-          parts.push(formatResultsAsMarkdown(prompts));
-        }
+        const context = await getProjectContext(db, { project, limit, memoryLimit: 3 });
         return {
-          content: [{ type: "text", text: parts.join("\n") || "No context found for this project." }]
+          content: [{ type: "text", text: formatProjectContext(context, {
+            promptExcerptLength: 300,
+            responseExcerptLength: 200,
+            emptyMessage: "No context found for this project."
+          }) }]
         };
       }
       if (name === "get_project_summary") {
         const { project } = z.object({
           project: z.string()
         }).parse(args);
-        const memories = db.searchMemories(project, 5);
-        if (memories.length === 0) {
+        const summary = db.getProjectSummary(project);
+        if (!summary) {
           return {
             content: [{ type: "text", text: `No accumulated knowledge for project "${project}". Run "ph analyze" to generate insights.` }]
           };
         }
         const parts = [];
-        for (const mem of memories) {
-          parts.push(`## ${mem.summary || "Project Memory"}
+        parts.push(`## ${summary.summary || "Project Memory"}
 `);
-          if (mem.key_insights.length > 0) {
-            parts.push("**Key Insights:**");
-            for (const i of mem.key_insights) parts.push(`- ${i}`);
-            parts.push("");
-          }
-          if (mem.technical_decisions.length > 0) {
-            parts.push("**Technical Decisions:**");
-            for (const d of mem.technical_decisions) parts.push(`- ${d}`);
-            parts.push("");
-          }
+        parts.push(`Based on ${summary.prompt_count} interactions.
+`);
+        if (summary.key_insights.length > 0) {
+          parts.push("**Key Insights:**");
+          for (const i of summary.key_insights) parts.push(`- ${i}`);
+          parts.push("");
+        }
+        if (summary.technical_decisions.length > 0) {
+          parts.push("**Technical Decisions:**");
+          for (const d of summary.technical_decisions) parts.push(`- ${d}`);
+          parts.push("");
         }
         return {
           content: [{ type: "text", text: parts.join("\n") }]
@@ -1032,17 +1638,153 @@ async function runMCPServer() {
         if (!queryVec) {
           throw new Error("Failed to generate embedding for query");
         }
-        const results = db.searchSemantic(queryVec, limit * 2);
-        const filtered = project ? results.filter((e) => {
+        const filtered = db.searchSemantic(queryVec, limit, project);
+        return {
+          content: [{ type: "text", text: formatPromptList(filtered, query) }]
+        };
+      }
+      if (name === "get_project_timeline") {
+        const { project, since, until, limit = 100 } = z.object({
+          project: z.string(),
+          since: z.string().optional(),
+          until: z.string().optional(),
+          limit: z.number().optional()
+        }).parse(args);
+        let allPrompts = db.getAllPromptsByProject(project);
+        let memories = db.getAllMemoriesByProject(project);
+        if (since) {
+          const sinceDate = new Date(since);
+          allPrompts = allPrompts.filter((p) => new Date(p.timestamp) >= sinceDate);
+          memories = memories.filter((m) => new Date(m.created_at) >= sinceDate);
+        }
+        if (until) {
+          const untilDate = new Date(until);
+          allPrompts = allPrompts.filter((p) => new Date(p.timestamp) <= untilDate);
+          memories = memories.filter((m) => new Date(m.created_at) <= untilDate);
+        }
+        if (allPrompts.length === 0 && memories.length === 0) {
+          return {
+            content: [{ type: "text", text: `No history found for project "${project}"${since ? ` since ${since}` : ""}${until ? ` until ${until}` : ""}.` }]
+          };
+        }
+        const events = [];
+        for (const p of allPrompts.slice(0, limit)) {
+          let meta = {};
           try {
-            const meta = JSON.parse(e.metadata);
-            return meta.project === project;
+            meta = JSON.parse(p.metadata);
           } catch {
-            return false;
           }
-        }).slice(0, limit) : results.slice(0, limit);
+          events.push({
+            timestamp: p.timestamp,
+            text: [
+              `### #${p.id} \u2014 ${p.tool}`,
+              meta.role ? `Role: ${meta.role}` : "",
+              meta.title ? `Title: ${meta.title}` : "",
+              meta.tags?.length ? `Tags: ${meta.tags.join(", ")}` : "",
+              meta.summary ? `Summary: ${meta.summary}` : "",
+              `Prompt: ${p.prompt.slice(0, 500)}${p.prompt.length > 500 ? "..." : ""}`,
+              p.response ? `Response: ${p.response.slice(0, 300)}${p.response.length > 300 ? "..." : ""}` : "",
+              meta.key_insights?.length ? `Insights:
+${meta.key_insights.map((i) => `- ${i}`).join("\n")}` : ""
+            ].filter(Boolean).join("\n")
+          });
+        }
+        for (const m of memories) {
+          events.push({
+            timestamp: m.created_at,
+            text: [
+              `\u{1F4CC} Memory #${m.id}`,
+              m.prompt_ids.length > 0 ? `From prompts: #${m.prompt_ids.join(", #")}` : "",
+              m.summary ? `Summary: ${m.summary}` : "",
+              m.key_insights.length > 0 ? `Key Insights:
+${m.key_insights.map((i) => `- ${i}`).join("\n")}` : "",
+              m.technical_decisions.length > 0 ? `Technical Decisions:
+${m.technical_decisions.map((d) => `- ${d}`).join("\n")}` : ""
+            ].filter(Boolean).join("\n")
+          });
+        }
+        events.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+        const range = since || until ? ` (${since || "\u2026"} \u2192 ${until || "now"})` : "";
+        const header = `# Timeline: ${project}${range}
+
+${allPrompts.length} prompts \xB7 ${memories.length} memory entries
+
+`;
+        const body = events.map((e) => {
+          const date = new Date(e.timestamp).toLocaleDateString("en-CA");
+          const time = new Date(e.timestamp).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+          return `## ${date} ${time}
+
+${e.text}
+`;
+        }).join("---\n");
         return {
-          content: [{ type: "text", text: formatPromptList(filtered, query) }]
+          content: [{ type: "text", text: header + body }]
+        };
+      }
+      if (name === "check_project_knowledge") {
+        const { project, task, limit = 5 } = z.object({
+          project: z.string(),
+          task: z.string(),
+          limit: z.number().optional()
+        }).parse(args);
+        const parts = [];
+        parts.push(`# Knowledge Check: "${task}" in ${project}
+`);
+        const memories = db.searchMemories(project, limit);
+        const relevantMemories = memories.filter(
+          (m) => m.summary.toLowerCase().includes(task.toLowerCase()) || m.key_insights.some((k) => k.toLowerCase().includes(task.toLowerCase())) || m.technical_decisions.some((d) => d.toLowerCase().includes(task.toLowerCase()))
+        );
+        if (relevantMemories.length > 0) {
+          parts.push(`## Found in Project Memories
+`);
+          for (const m of relevantMemories) {
+            parts.push(`### Memory #${m.id}`);
+            if (m.summary) parts.push(`Summary: ${m.summary}`);
+            if (m.key_insights.length > 0) {
+              parts.push(`Key Insights:
+${m.key_insights.map((i) => `- ${i}`).join("\n")}`);
+            }
+            if (m.technical_decisions.length > 0) {
+              parts.push(`Technical Decisions:
+${m.technical_decisions.map((d) => `- ${d}`).join("\n")}`);
+            }
+            parts.push("");
+          }
+        }
+        const ollamaUrl = cfg.ollamaUrl ?? "http://localhost:11434";
+        const embedModel = cfg.ollamaEmbedModel ?? "nomic-embed-text-v2-moe";
+        try {
+          const [queryVec] = await getEmbeddings([`${project}: ${task}`], ollamaUrl, embedModel, 1);
+          if (queryVec) {
+            const projectPrompts = db.searchSemantic(queryVec, limit, project);
+            if (projectPrompts.length > 0) {
+              parts.push(`## Related Prompts
+`);
+              for (const p of projectPrompts) {
+                let meta = {};
+                try {
+                  meta = JSON.parse(p.metadata);
+                } catch {
+                }
+                parts.push(`### #${p.id} \u2014 ${p.tool} (${new Date(p.timestamp).toLocaleDateString()})`);
+                if (meta.role) parts.push(`Role: ${meta.role}`);
+                if (meta.summary) parts.push(`Summary: ${meta.summary}`);
+                parts.push(`Prompt: ${p.prompt.slice(0, 400)}${p.prompt.length > 400 ? "..." : ""}`);
+                parts.push("");
+              }
+            }
+          }
+        } catch {
+          parts.push("(Semantic search unavailable \u2014 Ollama may not be running)\n");
+        }
+        if (relevantMemories.length === 0 && !parts.some((p) => p.startsWith("## Related Prompts"))) {
+          parts.push("No existing knowledge found for this task. This appears to be new work.\n");
+        }
+        parts.push("---\n");
+        parts.push("**Recommendation**: Review the above before implementing. If a previous implementation exists, consider reusing or adapting it.\n");
+        return {
+          content: [{ type: "text", text: parts.join("\n") }]
         };
       }
       throw new Error(`Unknown tool: ${name}`);
@@ -1053,6 +1795,13 @@ async function runMCPServer() {
       };
     }
   });
+  return server;
+}
+async function runMCPServer() {
+  const cfg = load();
+  const dbPath = process.env.PH_DB ?? cfg.dbPath ?? defaultPath();
+  const db = new PhDB(dbPath);
+  const server = createMCPServer(db, cfg);
   const transport = new StdioServerTransport();
   await server.connect(transport);
   console.error("ph MCP server running on stdio");
@@ -1154,12 +1903,31 @@ function formatSinglePrompt(e) {
 
 // src/server/index.ts
 import http from "http";
+import { URL } from "url";
+
+// src/utils/syncHash.ts
 import { createHash as createHash2 } from "crypto";
+function syncHash(entry) {
+  const body = entry.args ? `${entry.tool}|${entry.prompt}|${entry.response}|${entry.args}` : `${entry.tool}|${entry.prompt}|${entry.response}`;
+  return createHash2("sha256").update(body).digest("hex");
+}
+
+// src/server/index.ts
+import { timingSafeEqual } from "crypto";
 async function runServer(port = 3001, host = "0.0.0.0") {
   const cfg = load();
   const dbPath = process.env.PH_DB ?? cfg.dbPath ?? defaultPath();
   const db = new PhDB(dbPath);
-  const server = http.createServer(async (req, res) => {
+  const server = http.createServer(createRequestHandler(db, cfg));
+  return new Promise((resolve) => {
+    server.listen(port, host, () => {
+      console.error(`ph server listening on http://${host}:${port}`);
+      resolve();
+    });
+  });
+}
+function createRequestHandler(db, cfg) {
+  return async (req, res) => {
     res.setHeader("Access-Control-Allow-Origin", "*");
     res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
     res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
@@ -1168,28 +1936,34 @@ async function runServer(port = 3001, host = "0.0.0.0") {
       res.end();
       return;
     }
+    const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+    if (url.pathname !== "/health" && !authorized(req, cfg)) {
+      json(res, 401, { error: "unauthorized" });
+      return;
+    }
     try {
       const body = await readBody(req);
       await route(req, res, body, db, cfg);
     } catch (err) {
       json(res, 500, { error: err.message });
     }
-  });
-  return new Promise((resolve) => {
-    server.listen(port, host, () => {
-      console.error(`ph server listening on http://${host}:${port}`);
-      resolve();
-    });
-  });
+  };
+}
+function authorized(req, cfg) {
+  if (!cfg.remoteApiKey) return true;
+  const expected = `Bearer ${cfg.remoteApiKey}`;
+  const a = Buffer.from(req.headers.authorization ?? "");
+  const b = Buffer.from(expected);
+  return a.length === b.length && timingSafeEqual(a, b);
 }
 async function route(req, res, body, db, cfg) {
   const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
-  const path9 = url.pathname;
+  const path10 = url.pathname;
   const method = req.method || "GET";
-  if (method === "GET" && path9 === "/health") {
-    return json(res, 200, { status: "ok", dbPath: db.db?.name || "unknown" });
+  if (method === "GET" && path10 === "/health") {
+    return json(res, 200, { status: "ok", dbPath: db.dbPath });
   }
-  if (method === "POST" && path9 === "/api/prompts/search") {
+  if (method === "POST" && path10 === "/api/prompts/search") {
     const { query, tool, project, role, tag, since, until, limit = 10 } = JSON.parse(body);
     const results = db.search({
       query,
@@ -1203,31 +1977,23 @@ async function route(req, res, body, db, cfg) {
     });
     return json(res, 200, { prompts: results });
   }
-  if (method === "POST" && path9 === "/api/prompts/by-id") {
+  if (method === "POST" && path10 === "/api/prompts/by-id") {
     const { id } = JSON.parse(body);
     const entry = db.getById(id);
     if (!entry) return json(res, 404, { error: `Prompt #${id} not found` });
     return json(res, 200, { prompt: entry });
   }
-  if (method === "POST" && path9 === "/api/prompts/semantic") {
+  if (method === "POST" && path10 === "/api/prompts/semantic") {
     const { query, project, limit = 5 } = JSON.parse(body);
     if (!query) return json(res, 400, { error: "query is required" });
     const ollamaUrl = cfg.ollamaUrl ?? "http://localhost:11434";
     const model = cfg.ollamaEmbedModel ?? "nomic-embed-text-v2-moe";
     const [queryVec] = await getEmbeddings([query], ollamaUrl, model, 1);
     if (!queryVec) return json(res, 500, { error: "Failed to generate embedding" });
-    const results = db.searchSemantic(queryVec, limit * 2);
-    const filtered = project ? results.filter((e) => {
-      try {
-        const meta = JSON.parse(e.metadata);
-        return meta.project === project;
-      } catch {
-        return false;
-      }
-    }).slice(0, limit) : results.slice(0, limit);
+    const filtered = db.searchSemantic(queryVec, limit, project);
     return json(res, 200, { prompts: filtered });
   }
-  if (method === "POST" && path9 === "/api/sync/push") {
+  if (method === "POST" && path10 === "/api/sync/push") {
     const { prompts } = JSON.parse(body);
     if (!Array.isArray(prompts)) return json(res, 400, { error: "prompts must be an array" });
     let imported = 0;
@@ -1235,8 +2001,8 @@ async function route(req, res, body, db, cfg) {
     const errors = [];
     for (const p of prompts) {
       try {
-        const hash = sha256(`${p.tool}|${p.prompt}|${p.response}`);
-        const existing = db.db.prepare("SELECT id FROM prompts WHERE json_extract(metadata, '$.sync_hash') = ?").get(hash);
+        const hash = syncHash(p);
+        const existing = db.getPromptBySyncHash(hash);
         if (existing) {
           skipped++;
           continue;
@@ -1260,35 +2026,28 @@ async function route(req, res, body, db, cfg) {
     }
     return json(res, 200, { imported, skipped, errors });
   }
-  if (method === "POST" && path9 === "/api/sync/pull") {
+  if (method === "POST" && path10 === "/api/sync/pull") {
     const { since } = JSON.parse(body);
     const limit = 1e4;
-    let results;
-    if (since) {
-      results = db.db.prepare("SELECT * FROM prompts WHERE timestamp > ? ORDER BY timestamp ASC LIMIT ?").all(since, limit);
-    } else {
-      results = db.db.prepare("SELECT * FROM prompts ORDER BY timestamp ASC LIMIT ?").all(limit);
-    }
+    const results = since ? db.getPromptsSince(since, limit) : db.getAllPrompts(limit);
     return json(res, 200, { prompts: results, hasMore: results.length >= limit });
   }
-  if (method === "POST" && path9 === "/api/memories/search") {
+  if (method === "POST" && path10 === "/api/memories/search") {
     const { project, limit = 10 } = JSON.parse(body);
     const memories = project ? db.searchMemories(project, limit) : [];
     return json(res, 200, { memories });
   }
-  if (method === "POST" && path9 === "/api/memories/summary") {
+  if (method === "POST" && path10 === "/api/memories/summary") {
     const { project } = JSON.parse(body);
     if (!project) return json(res, 400, { error: "project is required" });
     const memories = db.searchMemories(project, 5);
     return json(res, 200, { memories });
   }
-  if (method === "GET" && path9 === "/api/stats") {
-    const total = db.db.prepare("SELECT count(*) as c FROM prompts").get().c;
-    const totalMemories = db.db.prepare("SELECT count(*) as c FROM memories").get().c;
-    const byTool = db.db.prepare("SELECT tool, count(*) as count FROM prompts GROUP BY tool ORDER BY count DESC").all();
+  if (method === "GET" && path10 === "/api/stats") {
+    const { total, totalMemories, byTool } = db.getStats();
     return json(res, 200, { total, totalMemories, byTool });
   }
-  json(res, 404, { error: `Not found: ${method} ${path9}` });
+  json(res, 404, { error: `Not found: ${method} ${path10}` });
 }
 function json(res, status2, data) {
   res.writeHead(status2, { "Content-Type": "application/json" });
@@ -1303,12 +2062,8 @@ function readBody(req) {
     req.on("error", reject);
   });
 }
-function sha256(s) {
-  return createHash2("sha256").update(s).digest("hex");
-}
 
 // src/commands/remote.ts
-import { createHash as createHash3 } from "crypto";
 function remoteUrl(cfg) {
   return process.env.PH_REMOTE_URL || cfg.remoteUrl || "";
 }
@@ -1411,7 +2166,7 @@ async function pull(dbPath, cfg, url) {
     let imported = 0;
     let skipped = 0;
     for (const p of result.prompts) {
-      const hash = sha2562(`${p.tool}|${p.prompt}|${p.response}`);
+      const hash = syncHash(p);
       const existing = db.getPromptBySyncHash(hash);
       if (existing) {
         skipped++;
@@ -1449,7 +2204,7 @@ async function status(dbPath, cfg, url) {
   const localTotal = db.getPromptCount();
   const lastPush = cfg.remoteLastPush || "never";
   const lastPull = cfg.remoteLastPull || "never";
-  const pending = cfg.remoteLastPush ? db.db.prepare("SELECT count(*) as c FROM prompts WHERE timestamp > ?").get(cfg.remoteLastPush).c : localTotal;
+  const pending = cfg.remoteLastPush ? db.getPromptCountSince(cfg.remoteLastPush) : localTotal;
   process.stdout.write(`Remote:      ${url}
 `);
   process.stdout.write(`Local total: ${localTotal} prompts
@@ -1462,13 +2217,10 @@ async function status(dbPath, cfg, url) {
 `);
   db.close();
 }
-function sha2562(s) {
-  return createHash3("sha256").update(s).digest("hex");
-}
 
 // src/ui/BrowseApp.tsx
-import React6, { useState as useState2, useCallback, useEffect as useEffect2, useMemo as useMemo3 } from "react";
-import { Box as Box4, Text as Text5, useInput as useInput2, useApp } from "ink";
+import React7, { useState as useState3, useCallback, useEffect, useMemo as useMemo4 } from "react";
+import { Box as Box5, Text as Text6, useInput as useInput3, useApp } from "ink";
 import { spawn as spawn2 } from "child_process";
 
 // src/ui/Header.tsx
@@ -1479,7 +2231,7 @@ import { AppHeader, THEMES } from "@gi4nks/ink";
 // package.json
 var package_default = {
   name: "@gi4nks/ph",
-  version: "2.0.1",
+  version: "1.5.0",
   description: "Transparent CLI wrapper that captures and indexes AI prompts",
   type: "module",
   license: "MIT",
@@ -1530,37 +2282,38 @@ var package_default = {
     dev: "tsx src/cli.ts",
     start: "node dist/cli.js",
     test: "vitest run",
-    lint: "eslint src"
+    lint: "eslint src",
+    "eval:retrieval": "tsx scripts/eval-context-retrieval.ts"
   },
   dependencies: {
     "@gi4nks/ink": "^1.5.0",
     "@lydell/node-pty": "^1.2.0-beta.3",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "better-sqlite3": "^12.8.0",
-    ink: "^6.8.0",
-    react: "^19.2.4",
+    ink: "^7.0.5",
+    react: "^19.2.7",
     "sqlite-vec": "^0.1.9",
     zod: "^4.3.6"
   },
   devDependencies: {
+    "@eslint/js": "^9.39.5",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
     "@semantic-release/github": "^12.0.8",
     "@semantic-release/npm": "^13.1.5",
     "@types/better-sqlite3": "^7.6.13",
-    "@types/node": "^25.5.0",
-    "@types/react": "^19.2.14",
-    "@typescript-eslint/eslint-plugin": "^8.57.2",
-    "@typescript-eslint/parser": "^8.57.2",
-    eslint: "^9.39.4",
+    "@types/node": "^25.9.3",
+    "@types/react": "^19.2.7",
+    "@typescript-eslint/eslint-plugin": "^8.58.2",
+    "@typescript-eslint/parser": "^8.58.2",
+    eslint: "^9.39.5",
     "eslint-plugin-react": "^7.37.5",
     "eslint-plugin-react-hooks": "^7.0.1",
     "semantic-release": "^25.0.3",
-    "standard-version": "^9.5.0",
     tsup: "^8.5.1",
     tsx: "^4.21.0",
-    typescript: "^5.9.3",
-    vitest: "^4.1.0"
+    typescript: "^6.0.3",
+    vitest: "^4.1.8"
   }
 };
 
@@ -1580,6 +2333,7 @@ var FilterBadges = ({ active, textFilter }) => /* @__PURE__ */ React.createEleme
 var Header = ({
   entriesCount,
   allEntriesCount,
+  archiveCount,
   activeFilters,
   textFilter,
   isTextFiltering,
@@ -1589,7 +2343,7 @@ var Header = ({
   const version = package_default.version;
   const rawCwd = process.cwd();
   const cwd = rawCwd.replace(process.env.HOME || "", "~");
-  const leftExtra = /* @__PURE__ */ React.createElement(Text, { color: "white", dimColor: true }, "  ", entriesCount, entriesCount < allEntriesCount ? `/${allEntriesCount}` : "", " prompts");
+  const leftExtra = /* @__PURE__ */ React.createElement(Text, { color: "white", dimColor: true }, "  ", entriesCount, entriesCount < allEntriesCount ? `/${allEntriesCount}` : "", " prompts", archiveCount !== void 0 && archiveCount > 0 ? /* @__PURE__ */ React.createElement(Text, { color: "yellow" }, " (", archiveCount, " archived)") : null);
   const rightContent = /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(FilterBadges, { active: activeFilters, textFilter }), isTextFiltering && /* @__PURE__ */ React.createElement(Text, { color: theme.success }, "  [typing\u2026]"));
   return /* @__PURE__ */ React.createElement(
     AppHeader,
@@ -1631,6 +2385,7 @@ var Footer = ({
     );
     if (hasProject2) base.push({ key: "C", description: "chat" });
     base.push({ key: "r", description: "rerun" });
+    base.push({ key: "p", description: "provider" });
     base.push("|");
     base.push(
       { key: "x", description: "del" },
@@ -1652,113 +2407,217 @@ var Footer = ({
   );
 };
 
-// src/ui/themes.ts
-import { THEMES as THEMES3, THEME_NAMES } from "@gi4nks/ink";
+// src/ui/FilterPanel.tsx
+import React3, { useMemo as useMemo2, useState } from "react";
+import { Box, Text as Text2, useInput } from "ink";
 
-// src/ui/SearchBar.tsx
-import React3 from "react";
-import { Box, Text as Text2 } from "ink";
-var SearchBar = ({ value, isActive, theme }) => {
-  const isEmpty = value === "";
-  const bgColor = isActive ? theme.primary : theme.dim;
-  return /* @__PURE__ */ React3.createElement(Box, { paddingX: 1, paddingY: 0 }, /* @__PURE__ */ React3.createElement(Text2, { color: bgColor, bold: isActive }, isActive ? "\u2315" : "\u2315"), /* @__PURE__ */ React3.createElement(Text2, { color: isActive ? "white" : theme.dim }, " ", isEmpty ? isActive ? "" : "search (/)" : value, isActive ? "\u2588" : ""));
+// src/ui/filtering.ts
+var FILTER_CATEGORIES = ["project", "language", "role", "tool", "tag", "starred", "quality", "relevance"];
+var ROLE_COLOR2 = {
+  debug: "red",
+  refactor: "yellow",
+  explain: "blue",
+  review: "magenta",
+  architect: "green",
+  test: "cyan",
+  docs: "white",
+  generate: "green",
+  research: "blue"
 };
-
-// src/ui/ListEntry.tsx
-import React4 from "react";
-import { Box as Box2, Text as Text3 } from "ink";
-
-// src/utils/extractTopic.ts
-function extractTopic(prompt) {
-  let text = prompt.trim();
-  if (!text) {
-    return "(empty prompt)";
-  }
-  if (text.startsWith("```") || text.startsWith("`")) {
-    return truncateAtWordBoundary(text, 72);
+function parseMetadata(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
   }
-  const originalTrimmed = text;
-  if (text.startsWith("#")) {
-    const headingMatch = text.match(/^#+\s+(.*?)(?:\s+#+)?(?:\n|$)/);
-    if (headingMatch && headingMatch[1]) {
-      text = headingMatch[1].trim();
+}
+var CODEX_RETRY_WINDOW_MS = 2 * 60 * 1e3;
+var CODEX_RETRY_MIN_PREFIX_LENGTH = 80;
+function displayTitle(entry) {
+  return parseMetadata(entry.metadata).title || extractTopic(entry.prompt);
+}
+function normalizedPrompt(prompt) {
+  return prompt.trim().replace(/\s+/g, " ");
+}
+function collapseCodexRetries(entries) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.tool.toLowerCase() !== "codex") continue;
+    const key = `${entry.workdir}\0${displayTitle(entry)}`;
+    const bucket = buckets.get(key) ?? [];
+    bucket.push(entry);
+    buckets.set(key, bucket);
+  }
+  const hidden = /* @__PURE__ */ new Set();
+  for (const bucket of buckets.values()) {
+    const incomplete = bucket.filter((entry) => !entry.response.trim());
+    const completed = bucket.filter((entry) => !!entry.response.trim());
+    for (const pending of incomplete) {
+      const pendingPrompt = normalizedPrompt(pending.prompt);
+      if (pendingPrompt.length < CODEX_RETRY_MIN_PREFIX_LENGTH) continue;
+      const pendingTime = Date.parse(pending.timestamp);
+      if (!Number.isFinite(pendingTime)) continue;
+      const retried = completed.some((candidate) => {
+        const candidateTime = Date.parse(candidate.timestamp);
+        const candidatePrompt = normalizedPrompt(candidate.prompt);
+        const delta = Math.abs(candidateTime - pendingTime);
+        return Number.isFinite(candidateTime) && delta <= CODEX_RETRY_WINDOW_MS && candidatePrompt.length > pendingPrompt.length && candidatePrompt.startsWith(pendingPrompt);
+      });
+      if (retried) hidden.add(pending.id);
     }
   }
-  const prefixes = [
-    // English
-    "please, ",
-    "please ",
-    "can you please ",
-    "could you please ",
-    "can you ",
-    "could you ",
-    "would you ",
-    "i need you to ",
-    "i need to ",
-    "i want you to ",
-    "i want to ",
-    "i'd like you to ",
-    "i'd like to ",
-    "help me to ",
-    "help me ",
-    "i need ",
-    "claude, ",
-    "gemini, ",
-    "chatgpt, ",
-    // Italiano
-    "puoi ",
-    "potresti ",
-    "potreste ",
-    "per favore ",
-    "per piacere ",
-    "ho bisogno che ",
-    "ho bisogno di ",
-    "voglio che ",
-    "vorrei che ",
-    "voglio ",
-    "vorrei ",
-    "aiutami a ",
-    "aiutami ",
-    "fammi vedere ",
-    "fammi ",
-    "si prega di ",
-    "si "
-  ];
-  let changed = true;
-  while (changed) {
-    changed = false;
-    const lowerText = text.toLowerCase();
-    for (const prefix of prefixes) {
-      if (lowerText.startsWith(prefix.toLowerCase())) {
-        text = text.slice(prefix.length).trim();
-        changed = true;
-        break;
-      }
+  return hidden.size ? entries.filter((entry) => !hidden.has(entry.id)) : entries;
+}
+function getDistinctValues(entries, category) {
+  const values = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (category === "tool") {
+      values.add(entry.tool);
+      continue;
     }
+    const metadata = parseMetadata(entry.metadata);
+    if (category === "project" && metadata.project) values.add(metadata.project);
+    if (category === "language" && metadata.language) values.add(metadata.language);
+    if (category === "role" && metadata.role) values.add(metadata.role);
+    if (category === "tag") metadata.tags?.forEach((tag) => values.add(tag));
   }
-  const sentenceEndMatch = text.match(/[\n.?!`]/);
-  if (sentenceEndMatch && sentenceEndMatch.index !== void 0) {
-    text = text.slice(0, sentenceEndMatch.index).trim();
+  return [...values].sort();
+}
+function applyFilters(entries, active, textFilter) {
+  let result = collapseCodexRetries(entries);
+  const hasActiveFilter = Object.values(active).some((value) => value !== void 0 && value !== false);
+  if (hasActiveFilter) {
+    result = result.filter((entry) => {
+      const metadata = parseMetadata(entry.metadata);
+      if (active.tool && entry.tool !== active.tool) return false;
+      if (active.project && metadata.project !== active.project) return false;
+      if (active.language && metadata.language !== active.language) return false;
+      if (active.role && metadata.role !== active.role) return false;
+      if (active.tag && !metadata.tags?.includes(active.tag)) return false;
+      if (active.starred && !metadata.starred) return false;
+      if (active.minQuality !== void 0 && (metadata.quality ?? 0) < active.minQuality) return false;
+      if (active.minRelevance !== void 0 && (metadata.relevance ?? 0) < active.minRelevance) return false;
+      return true;
+    });
   }
-  if (!text) {
-    return truncateAtWordBoundary(originalTrimmed, 72);
+  if (textFilter) {
+    const query = textFilter.toLowerCase();
+    result = result.filter((entry) => {
+      const metadata = parseMetadata(entry.metadata);
+      return entry.prompt.toLowerCase().includes(query) || entry.tool.toLowerCase().includes(query) || (metadata.project?.toLowerCase().includes(query) ?? false) || (metadata.role?.toLowerCase().includes(query) ?? false) || (metadata.tags?.some((tag) => tag.toLowerCase().includes(query)) ?? false);
+    });
   }
-  text = truncateAtWordBoundary(text, 72);
-  return text.charAt(0).toUpperCase() + text.slice(1);
+  return result;
 }
-function truncateAtWordBoundary(str, limit) {
-  const clean = str.replace(/\s+/g, " ").trim();
-  if (clean.length <= limit) return clean;
-  const sub = clean.slice(0, limit);
-  const lastSpace = sub.lastIndexOf(" ");
-  if (lastSpace > 0) {
-    return sub.slice(0, lastSpace);
+function toggleFilter(active, option) {
+  if (option.category === "starred") return { ...active, starred: !option.active || void 0 };
+  if (option.category === "quality" || option.category === "relevance") {
+    const value = parseInt(option.label.replace(option.category === "quality" ? "Q \u2265 " : "R \u2265 ", ""), 10);
+    return option.category === "quality" ? { ...active, minQuality: option.active ? void 0 : value } : { ...active, minRelevance: option.active ? void 0 : value };
+  }
+  const filterKey = option.category;
+  if (option.active) {
+    const updated = { ...active };
+    delete updated[filterKey];
+    return updated;
+  }
+  return { ...active, [filterKey]: option.label };
+}
+function buildFilterOptions(entries, active) {
+  const options = [];
+  for (const category of FILTER_CATEGORIES) {
+    if (category === "starred") {
+      const count = entries.filter((entry) => parseMetadata(entry.metadata).starred).length;
+      options.push({ category, label: "\u2605 Only starred", count, active: !!active.starred });
+      continue;
+    }
+    if (category === "quality" || category === "relevance") {
+      const isQuality = category === "quality";
+      const activeValue = isQuality ? active.minQuality : active.minRelevance;
+      const prefix = isQuality ? "Q \u2265 " : "R \u2265 ";
+      options.push({ category, label: `${prefix}${activeValue ?? "?"}`, count: 0, active: activeValue !== void 0 });
+      for (const value of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) {
+        const count = entries.filter((entry) => {
+          const metadata = parseMetadata(entry.metadata);
+          return ((isQuality ? metadata.quality : metadata.relevance) ?? 0) >= value;
+        }).length;
+        options.push({ category, label: `${prefix}${value}`, count, active: activeValue === value });
+      }
+      continue;
+    }
+    for (const value of getDistinctValues(entries, category)) {
+      const count = entries.filter((entry) => {
+        const metadata = parseMetadata(entry.metadata);
+        if (category === "project") return metadata.project === value;
+        if (category === "language") return metadata.language === value;
+        if (category === "role") return metadata.role === value;
+        if (category === "tool") return entry.tool === value;
+        if (category === "tag") return metadata.tags?.includes(value) ?? false;
+        return false;
+      }).length;
+      const activeValue = active[category];
+      options.push({ category, label: value, count, active: activeValue === value });
+    }
   }
-  return sub;
+  return options;
 }
 
+// src/ui/FilterPanel.tsx
+var FilterPanel = ({ allEntries, active, onUpdate, onClose, theme }) => {
+  const options = useMemo2(() => buildFilterOptions(allEntries, active), [allEntries, active]);
+  const [cursor, setCursor] = useState(0);
+  const visibleCount = Math.min(options.length, 16);
+  const scrollOffset = Math.max(0, Math.min(cursor - Math.floor(visibleCount / 2), options.length - visibleCount));
+  const visible = options.slice(Math.max(0, scrollOffset), scrollOffset + visibleCount);
+  useInput((char, key) => {
+    if (key.escape) {
+      onClose();
+      return;
+    }
+    if (char === "c") {
+      onUpdate({});
+      return;
+    }
+    if (key.return || char === " ") {
+      const option = options[cursor];
+      if (!option) return;
+      onUpdate(toggleFilter(active, option));
+      return;
+    }
+    if (key.upArrow) setCursor((value) => Math.max(0, value - 1));
+    if (key.downArrow) setCursor((value) => Math.min(options.length - 1, value + 1));
+    if (key.pageUp) setCursor((value) => Math.max(0, value - visibleCount));
+    if (key.pageDown) setCursor((value) => Math.min(options.length - 1, value + visibleCount));
+    if (char && /^[a-z]$/.test(char)) {
+      const index = options.findIndex((option, i) => i > cursor && option.category[0] === char);
+      if (index !== -1) setCursor(index);
+    }
+  });
+  const activeCount = Object.values(active).filter((value) => value !== void 0 && value !== false).length;
+  return /* @__PURE__ */ React3.createElement(Box, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React3.createElement(Box, { marginBottom: 1 }, /* @__PURE__ */ React3.createElement(Text2, { color: theme.primary, bold: true }, "Filters  "), activeCount > 0 ? /* @__PURE__ */ React3.createElement(Text2, { color: theme.warning }, activeCount, " active  ") : /* @__PURE__ */ React3.createElement(Text2, { dimColor: true }, "none active  "), activeCount > 0 && /* @__PURE__ */ React3.createElement(Text2, { dimColor: true }, "(c clear)")), /* @__PURE__ */ React3.createElement(Box, { borderStyle: "single", borderColor: theme.dim, flexDirection: "column", padding: 1, minHeight: 18 }, /* @__PURE__ */ React3.createElement(Box, { flexDirection: "column" }, visible.map((option, index) => {
+    const absoluteIndex = Math.max(0, scrollOffset) + index;
+    const isCurrent = absoluteIndex === cursor;
+    const categoryColor = option.category === "project" ? "blue" : option.category === "language" ? "green" : option.category === "role" ? ROLE_COLOR2[option.label] || "cyan" : option.category === "tool" ? "yellow" : option.category === "tag" ? "cyan" : "white";
+    return /* @__PURE__ */ React3.createElement(Box, { key: `${option.category}-${option.label}` }, /* @__PURE__ */ React3.createElement(Text2, { bold: isCurrent, color: isCurrent ? theme.primary : theme.dim }, isCurrent ? "\u276F " : "  "), /* @__PURE__ */ React3.createElement(Text2, { color: option.active ? theme.warning : categoryColor, bold: option.active || isCurrent }, option.category, ":", option.label), /* @__PURE__ */ React3.createElement(Text2, { dimColor: true }, " [", option.count, "]"), option.active && /* @__PURE__ */ React3.createElement(Text2, { color: theme.success }, " \u2713"));
+  })), options.length > visibleCount && /* @__PURE__ */ React3.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React3.createElement(Text2, { dimColor: true }, "  ", cursor + 1, "/", options.length, " \xB7 \u2191\u2193 navigate \xB7 Enter toggle \xB7 c clear \xB7 ESC close"))), /* @__PURE__ */ React3.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React3.createElement(Text2, { dimColor: true }, "\u2191\u2193 navigate \xB7 Enter toggle \xB7 c clear all \xB7 ESC close \xB7 letter jumps to category")));
+};
+
+// src/ui/themes.ts
+import { THEMES as THEMES3, THEME_NAMES } from "@gi4nks/ink";
+
+// src/ui/SearchBar.tsx
+import React4 from "react";
+import { Box as Box2, Text as Text3 } from "ink";
+var SearchBar = ({ value, isActive, theme }) => {
+  const isEmpty = value === "";
+  const bgColor = isActive ? theme.primary : theme.dim;
+  return /* @__PURE__ */ React4.createElement(Box2, { paddingX: 1, paddingY: 0 }, /* @__PURE__ */ React4.createElement(Text3, { color: bgColor, bold: isActive }, isActive ? "\u2315" : "\u2315"), /* @__PURE__ */ React4.createElement(Text3, { color: isActive ? "white" : theme.dim }, " ", isEmpty ? isActive ? "" : "search (/)" : value, isActive ? "\u2588" : ""));
+};
+
 // src/ui/ListEntry.tsx
-var ROLE_COLOR2 = {
+import React5 from "react";
+import { Box as Box3, Text as Text4 } from "ink";
+var ROLE_COLOR3 = {
   debug: "red",
   refactor: "yellow",
   explain: "blue",
@@ -1773,6 +2632,7 @@ function toolIndicator(tool) {
   if (tool === "claude") return { char: "\u25CF", color: "#f5a623" };
   if (tool === "gemini") return { char: "\u25CF", color: "#4fc3f7" };
   if (tool === "opencode") return { char: "\u25CF", color: "#e040fb" };
+  if (tool === "codex") return { char: "\u25CF", color: "#74aa9c" };
   return { char: "\u25CB", color: "gray" };
 }
 function truncate(str, width) {
@@ -1793,32 +2653,195 @@ var ListEntry = ({ entry, isSelected, paneWidth, theme }) => {
     hour12: false
   });
   const role = meta.role ? truncate(meta.role, 6) : "";
-  const roleColor = meta.role ? ROLE_COLOR2[meta.role] || "white" : "white";
+  const roleColor = meta.role ? ROLE_COLOR3[meta.role] || "white" : "white";
   const hasAnalysis = Boolean(meta.summary || meta.role || meta.tags && meta.tags.length > 0);
-  const roleBar = meta.role ? ROLE_COLOR2[meta.role] || theme.dim : theme.dim;
+  const roleBar = meta.role ? ROLE_COLOR3[meta.role] || theme.dim : theme.dim;
   const rawTitle = meta.title || extractTopic(entry.prompt);
   const displayPrompt = truncate(rawTitle, paneWidth - 5);
   let summaryLine = "";
   if (meta.summary) {
     summaryLine = truncate(meta.summary.replace(/\n/g, " "), paneWidth - 5);
   }
-  return /* @__PURE__ */ React4.createElement(Box2, { flexDirection: "column" }, /* @__PURE__ */ React4.createElement(Box2, { flexDirection: "row", width: paneWidth, overflow: "hidden" }, /* @__PURE__ */ React4.createElement(Text3, { color: roleBar }, "\u2502"), /* @__PURE__ */ React4.createElement(Text3, { color: indicator.color }, " ", indicator.char), /* @__PURE__ */ React4.createElement(Text3, { dimColor: true }, " ", entry.tool.padEnd(8)), meta.starred ? /* @__PURE__ */ React4.createElement(Text3, { color: theme.warning }, "\u2605") : /* @__PURE__ */ React4.createElement(Text3, null, " "), hasAnalysis ? /* @__PURE__ */ React4.createElement(Text3, { color: theme.success }, "\u25CF") : /* @__PURE__ */ React4.createElement(Text3, { dimColor: true }, "\u25CB"), /* @__PURE__ */ React4.createElement(Text3, null, " "), /* @__PURE__ */ React4.createElement(Text3, { dimColor: true }, hhmm, "  "), role && /* @__PURE__ */ React4.createElement(Text3, { color: roleColor }, role), meta.quality !== void 0 && /* @__PURE__ */ React4.createElement(Text3, { color: theme.success }, " Q", meta.quality), meta.relevance !== void 0 && /* @__PURE__ */ React4.createElement(Text3, { color: theme.warning }, " R", meta.relevance)), /* @__PURE__ */ React4.createElement(Box2, { flexDirection: "row" }, /* @__PURE__ */ React4.createElement(Text3, { color: roleBar }, "\u2502"), isSelected ? /* @__PURE__ */ React4.createElement(Text3, { inverse: true, bold: true }, " ", displayPrompt.padEnd(paneWidth - 3)) : /* @__PURE__ */ React4.createElement(Text3, null, " ", displayPrompt)), summaryLine && /* @__PURE__ */ React4.createElement(Box2, { flexDirection: "row" }, /* @__PURE__ */ React4.createElement(Text3, { color: roleBar }, "\u2502"), /* @__PURE__ */ React4.createElement(Text3, { dimColor: true }, " ", summaryLine)));
+  return /* @__PURE__ */ React5.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React5.createElement(Box3, { flexDirection: "row", width: paneWidth, overflow: "hidden" }, /* @__PURE__ */ React5.createElement(Text4, { color: roleBar }, "\u2502"), /* @__PURE__ */ React5.createElement(Text4, { color: indicator.color }, " ", indicator.char), /* @__PURE__ */ React5.createElement(Text4, { dimColor: true }, " ", entry.tool.padEnd(8)), meta.starred ? /* @__PURE__ */ React5.createElement(Text4, { color: theme.warning }, "\u2605") : /* @__PURE__ */ React5.createElement(Text4, null, " "), hasAnalysis ? /* @__PURE__ */ React5.createElement(Text4, { color: theme.success }, "\u25CF") : /* @__PURE__ */ React5.createElement(Text4, { dimColor: true }, "\u25CB"), /* @__PURE__ */ React5.createElement(Text4, null, " "), /* @__PURE__ */ React5.createElement(Text4, { dimColor: true }, hhmm, "  "), role && /* @__PURE__ */ React5.createElement(Text4, { color: roleColor }, role), meta.quality !== void 0 && /* @__PURE__ */ React5.createElement(Text4, { color: theme.success }, " Q", meta.quality), meta.relevance !== void 0 && /* @__PURE__ */ React5.createElement(Text4, { color: theme.warning }, " R", meta.relevance)), /* @__PURE__ */ React5.createElement(Box3, { flexDirection: "row" }, /* @__PURE__ */ React5.createElement(Text4, { color: roleBar }, "\u2502"), isSelected ? /* @__PURE__ */ React5.createElement(Text4, { inverse: true, bold: true }, " ", displayPrompt.padEnd(paneWidth - 3)) : /* @__PURE__ */ React5.createElement(Text4, null, " ", displayPrompt)), summaryLine && /* @__PURE__ */ React5.createElement(Box3, { flexDirection: "row" }, /* @__PURE__ */ React5.createElement(Text4, { color: roleBar }, "\u2502"), /* @__PURE__ */ React5.createElement(Text4, { dimColor: true }, " ", summaryLine)));
 };
 
 // src/ui/PreviewPane.tsx
-import React5, { useState, useEffect, useMemo as useMemo2 } from "react";
-import { Box as Box3, Text as Text4, useInput } from "ink";
-var ROLE_COLOR3 = {
-  debug: "red",
-  refactor: "yellow",
-  explain: "blue",
-  review: "magenta",
-  architect: "green",
-  test: "cyan",
-  docs: "white",
-  generate: "green",
-  research: "blue"
-};
+import React6, { useState as useState2, useMemo as useMemo3 } from "react";
+import { Box as Box4, Text as Text5, useInput as useInput2 } from "ink";
+
+// src/utils/syntaxHighlight.ts
+var KEYWORDS = /* @__PURE__ */ new Set([
+  "if",
+  "else",
+  "for",
+  "while",
+  "do",
+  "switch",
+  "case",
+  "break",
+  "continue",
+  "return",
+  "function",
+  "class",
+  "struct",
+  "interface",
+  "enum",
+  "type",
+  "const",
+  "let",
+  "var",
+  "import",
+  "export",
+  "from",
+  "default",
+  "async",
+  "await",
+  "yield",
+  "throw",
+  "try",
+  "catch",
+  "finally",
+  "new",
+  "delete",
+  "typeof",
+  "instanceof",
+  "void",
+  "null",
+  "undefined",
+  "true",
+  "false",
+  "this",
+  "super",
+  "extends",
+  "implements",
+  "package",
+  "namespace",
+  "using",
+  "def",
+  "in",
+  "not",
+  "is",
+  "and",
+  "or",
+  "with",
+  "as",
+  "pass",
+  "raise",
+  "lambda",
+  "pub",
+  "fn",
+  "let",
+  "mut",
+  "impl",
+  "trait",
+  "use",
+  "mod",
+  "where",
+  "ref",
+  "func",
+  "go",
+  "defer",
+  "select",
+  "chan",
+  "range",
+  "map",
+  "SELECT",
+  "FROM",
+  "WHERE",
+  "INSERT",
+  "UPDATE",
+  "DELETE",
+  "CREATE",
+  "TABLE",
+  "INTO",
+  "VALUES",
+  "SET",
+  "JOIN",
+  "LEFT",
+  "RIGHT",
+  "INNER",
+  "OUTER",
+  "ON",
+  "AND",
+  "OR",
+  "NOT",
+  "IN",
+  "AS",
+  "ORDER",
+  "BY",
+  "GROUP",
+  "HAVING",
+  "LIMIT",
+  "OFFSET",
+  "static",
+  "public",
+  "private",
+  "protected",
+  "readonly",
+  "abstract",
+  "virtual",
+  "override",
+  "final",
+  "sealed",
+  "internal",
+  "extern",
+  "module",
+  "requires",
+  "exports",
+  "opens",
+  "provides",
+  "to",
+  "transitive",
+  "match",
+  "enum",
+  "macro",
+  "unsafe"
+]);
+function tokenizeLine(line) {
+  const segments = [];
+  let i = 0;
+  while (i < line.length) {
+    const rest = line.slice(i);
+    const strMatch = rest.match(/^("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`)/);
+    if (strMatch) {
+      segments.push({ text: strMatch[1], color: "green" });
+      i += strMatch[1].length;
+      continue;
+    }
+    const commentMatch = rest.match(/^(\/\/.*)/);
+    if (commentMatch) {
+      segments.push({ text: commentMatch[1], dim: true });
+      i += commentMatch[1].length;
+      continue;
+    }
+    if (rest[0] === "#") {
+      segments.push({ text: rest.slice(i), dim: true });
+      break;
+    }
+    const numMatch = rest.match(/^(\d+(?:\.\d+)?)/);
+    if (numMatch) {
+      segments.push({ text: numMatch[1], color: "yellow" });
+      i += numMatch[1].length;
+      continue;
+    }
+    const wordMatch = rest.match(/^([a-zA-Z_][a-zA-Z0-9_]*)/);
+    if (wordMatch) {
+      const word = wordMatch[1];
+      if (KEYWORDS.has(word)) {
+        segments.push({ text: word, color: "blue" });
+      } else if (/^[A-Z]/.test(word)) {
+        segments.push({ text: word, color: "cyan" });
+      } else {
+        segments.push({ text: word });
+      }
+      i += word.length;
+      continue;
+    }
+    segments.push({ text: rest[0] });
+    i++;
+  }
+  return segments;
+}
 function wrapTextLines(text, width) {
   const lines = text.split("\n");
   const result = [];
@@ -1829,13 +2852,77 @@ function wrapTextLines(text, width) {
     }
     let current = line;
     while (current.length > width) {
-      result.push(current.substring(0, width));
-      current = current.substring(width);
+      result.push(current.slice(0, width));
+      current = current.slice(width);
     }
     if (current.length > 0) result.push(current);
   }
   return result;
 }
+function wrapRichLines(lines, width) {
+  const result = [];
+  for (const line of lines) {
+    const totalLen = line.segments.reduce((sum, s) => sum + s.text.length, 0);
+    if (totalLen <= width) {
+      result.push(line);
+      continue;
+    }
+    let currentSegs = [];
+    let currentLen = 0;
+    for (const seg of line.segments) {
+      let remaining = seg.text;
+      while (remaining.length > 0) {
+        const space = width - currentLen;
+        if (remaining.length <= space) {
+          currentSegs.push({ text: remaining, color: seg.color, dim: seg.dim });
+          currentLen += remaining.length;
+          remaining = "";
+        } else {
+          currentSegs.push({ text: remaining.slice(0, space), color: seg.color, dim: seg.dim });
+          result.push({ segments: currentSegs });
+          currentSegs = [];
+          currentLen = 0;
+          remaining = remaining.slice(space);
+        }
+      }
+    }
+    if (currentLen > 0) {
+      result.push({ segments: currentSegs });
+    }
+  }
+  return result;
+}
+function buildRichLines(text, width) {
+  const rawLines = text.split("\n");
+  let inCode = false;
+  const parsed = [];
+  for (const rawLine of rawLines) {
+    const trimmed = rawLine.trim();
+    if (trimmed.startsWith("```")) {
+      inCode = !inCode;
+      continue;
+    }
+    if (inCode) {
+      parsed.push({ segments: tokenizeLine(rawLine) });
+    } else {
+      parsed.push({ segments: [{ text: rawLine }] });
+    }
+  }
+  return wrapRichLines(parsed, width);
+}
+
+// src/ui/PreviewPane.tsx
+var ROLE_COLOR4 = {
+  debug: "red",
+  refactor: "yellow",
+  explain: "blue",
+  review: "magenta",
+  architect: "green",
+  test: "cyan",
+  docs: "white",
+  generate: "green",
+  research: "blue"
+};
 function formatTimestamp(ts) {
   try {
     const d = new Date(ts);
@@ -1864,80 +2951,78 @@ var PreviewPane = ({
   theme,
   getProjectMemories
 }) => {
-  const [activeTab, setActiveTab] = useState("prompt");
-  const [scrollOffset, setScrollOffset] = useState(0);
-  useEffect(() => {
-    setActiveTab(entry?.response ? "response" : "prompt");
-    setScrollOffset(0);
-  }, [entry?.id]);
-  useEffect(() => {
+  const [activeTab, setActiveTab] = useState2(
+    entry?.response ? "response" : "prompt"
+  );
+  const [scrollOffset, setScrollOffset] = useState2(0);
+  const switchTab = (tab) => {
+    setActiveTab(tab);
     setScrollOffset(0);
-  }, [activeTab]);
-  const meta = useMemo2(() => entry ? parseMeta(entry.metadata) : {}, [entry]);
+  };
+  const meta = useMemo3(() => entry ? parseMeta(entry.metadata) : {}, [entry]);
   const contentWidth = Math.max(10, paneWidth - 4);
   const contentHeight = Math.max(3, paneHeight - 6);
-  const allLines = useMemo2(() => {
+  const allLines = useMemo3(() => {
     if (!entry) return [];
-    if (activeTab === "prompt") return wrapTextLines(entry.prompt, contentWidth);
-    if (activeTab === "response") return wrapTextLines(entry.response || "(no response captured)", contentWidth);
+    if (activeTab === "prompt") return buildRichLines(entry.prompt, contentWidth);
+    if (activeTab === "response") return buildRichLines(entry.response || "(no response captured)", contentWidth);
     const lines = [];
+    const push2 = (text) => lines.push({ segments: [{ text }] });
     if (meta.project && getProjectMemories) {
       const memories = getProjectMemories(meta.project);
       if (memories.length > 0) {
-        lines.push(`\u2500\u2500 Project Knowledge: ${meta.project} \u2500\u2500`);
-        lines.push("");
+        push2(`\u2500\u2500 Project Knowledge: ${meta.project} \u2500\u2500`);
+        push2("");
         for (const mem of memories) {
           if (mem.summary) {
-            lines.push(...wrapTextLines(mem.summary, contentWidth));
-            lines.push("");
+            for (const l of wrapTextLines(mem.summary, contentWidth)) push2(l);
+            push2("");
           }
           if (mem.key_insights.length > 0) {
-            lines.push("Key Insights:");
-            for (const i of mem.key_insights) lines.push(...wrapTextLines(`  \u2022 ${i}`, contentWidth));
-            lines.push("");
+            push2("Key Insights:");
+            for (const i of mem.key_insights) for (const l of wrapTextLines(`  \u2022 ${i}`, contentWidth)) push2(l);
+            push2("");
           }
           if (mem.technical_decisions.length > 0) {
-            lines.push("Technical Decisions:");
-            for (const d of mem.technical_decisions) lines.push(...wrapTextLines(`  \u2022 ${d}`, contentWidth));
-            lines.push("");
+            push2("Technical Decisions:");
+            for (const d of mem.technical_decisions) for (const l of wrapTextLines(`  \u2022 ${d}`, contentWidth)) push2(l);
+            push2("");
           }
         }
-        lines.push("\u2500\u2500 This Entry \u2500\u2500");
-        lines.push("");
+        push2("\u2500\u2500 This Entry \u2500\u2500");
+        push2("");
       }
     }
     if (meta.summary) {
-      lines.push(...wrapTextLines(meta.summary, contentWidth));
-      lines.push("");
+      for (const l of wrapTextLines(meta.summary, contentWidth)) push2(l);
+      push2("");
     }
     if (meta.key_insights && meta.key_insights.length > 0) {
       for (const insight of meta.key_insights) {
-        lines.push(...wrapTextLines(`\u2022 ${insight}`, contentWidth));
+        for (const l of wrapTextLines(`\u2022 ${insight}`, contentWidth)) push2(l);
       }
-      lines.push("");
-    }
-    if (lines.length === 0) {
-      lines.push("(no AI analysis - run ph analyze)");
+      push2("");
     }
+    if (lines.length === 0) push2("(no AI analysis - run ph analyze)");
     return lines;
   }, [entry, activeTab, contentWidth, meta, getProjectMemories]);
   const maxScroll = Math.max(0, allLines.length - contentHeight);
-  useInput((_char, key) => {
+  useInput2((_char, key) => {
     if (!isFocused) return;
-    if (_char === "1") setActiveTab("prompt");
-    if (_char === "2") setActiveTab("response");
-    if (_char === "3") setActiveTab("memory");
+    if (_char === "1") switchTab("prompt");
+    if (_char === "2") switchTab("response");
+    if (_char === "3") switchTab("memory");
     if (key.upArrow) setScrollOffset((s) => Math.max(0, s - 1));
     if (key.downArrow) setScrollOffset((s) => Math.min(maxScroll, s + 1));
     if (key.pageUp) setScrollOffset((s) => Math.max(0, s - contentHeight));
     if (key.pageDown) setScrollOffset((s) => Math.min(maxScroll, s + contentHeight));
   });
   if (!entry) {
-    return /* @__PURE__ */ React5.createElement(Box3, { width: paneWidth, height: paneHeight, paddingX: 2, flexDirection: "column", justifyContent: "center" }, /* @__PURE__ */ React5.createElement(Text4, { dimColor: true }, "(select an entry to preview)"));
+    return /* @__PURE__ */ React6.createElement(Box4, { width: paneWidth, height: paneHeight, paddingX: 2, flexDirection: "column", justifyContent: "center" }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "(select an entry to preview)"));
   }
   const visibleLines = allLines.slice(scrollOffset, scrollOffset + contentHeight);
   const paddedLines = [...visibleLines];
-  while (paddedLines.length < contentHeight) paddedLines.push("");
+  while (paddedLines.length < contentHeight) paddedLines.push({ segments: [{ text: " " }] });
   const topIndicator = scrollOffset > 0 ? `  \u2191 ${scrollOffset} above` : "  ";
   const remaining = allLines.length - scrollOffset - contentHeight;
   const botIndicator = scrollOffset < maxScroll ? `  \u2193 ${remaining} more` : "  ";
@@ -1947,8 +3032,8 @@ var PreviewPane = ({
   const tabPromptColor = isPromptActive && isFocused ? theme.primary : theme.dim;
   const tabResponseColor = isResponseActive && isFocused ? theme.primary : theme.dim;
   const tabMemoryColor = isMemoryActive && isFocused ? theme.primary : theme.dim;
-  return /* @__PURE__ */ React5.createElement(Box3, { flexDirection: "column", paddingX: 2 }, /* @__PURE__ */ React5.createElement(Box3, null, /* @__PURE__ */ React5.createElement(Text4, { color: theme.primary, bold: true }, "#", entry.id), /* @__PURE__ */ React5.createElement(Text4, { dimColor: true }, " \xB7 ", entry.tool, " \xB7 ", formatTimestamp(entry.timestamp)), meta.starred && /* @__PURE__ */ React5.createElement(Text4, { color: theme.warning }, "  \u2605")), /* @__PURE__ */ React5.createElement(Box3, { marginBottom: 1 }, meta.project && /* @__PURE__ */ React5.createElement(Text4, { color: theme.accent }, "proj:", meta.project, "  "), meta.language && /* @__PURE__ */ React5.createElement(Text4, { color: theme.dim }, "lang:", meta.language, "  "), meta.role && /* @__PURE__ */ React5.createElement(Text4, { color: ROLE_COLOR3[meta.role] || theme.primary }, "role:", meta.role, "  "), meta.quality !== void 0 && /* @__PURE__ */ React5.createElement(Text4, { color: theme.success }, "Q:", meta.quality, "  "), meta.relevance !== void 0 && /* @__PURE__ */ React5.createElement(Text4, { color: theme.warning }, "R:", meta.relevance, "  "), /* @__PURE__ */ React5.createElement(Text4, { color: entry.exit_code === 0 ? theme.dim : theme.error }, "exit:", entry.exit_code)), /* @__PURE__ */ React5.createElement(Box3, null, /* @__PURE__ */ React5.createElement(
-    Text4,
+  return /* @__PURE__ */ React6.createElement(Box4, { flexDirection: "column", paddingX: 2 }, /* @__PURE__ */ React6.createElement(Box4, null, /* @__PURE__ */ React6.createElement(Text5, { color: theme.primary, bold: true }, "#", entry.id), /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, " \xB7 ", entry.tool, " \xB7 ", formatTimestamp(entry.timestamp)), meta.starred && /* @__PURE__ */ React6.createElement(Text5, { color: theme.warning }, "  \u2605")), /* @__PURE__ */ React6.createElement(Box4, { marginBottom: 1 }, meta.project && /* @__PURE__ */ React6.createElement(Text5, { color: theme.accent }, "proj:", meta.project, "  "), meta.language && /* @__PURE__ */ React6.createElement(Text5, { color: theme.dim }, "lang:", meta.language, "  "), meta.role && /* @__PURE__ */ React6.createElement(Text5, { color: ROLE_COLOR4[meta.role] || theme.primary }, "role:", meta.role, "  "), meta.quality !== void 0 && /* @__PURE__ */ React6.createElement(Text5, { color: theme.success }, "Q:", meta.quality, "  "), meta.relevance !== void 0 && /* @__PURE__ */ React6.createElement(Text5, { color: theme.warning }, "R:", meta.relevance, "  "), /* @__PURE__ */ React6.createElement(Text5, { color: entry.exit_code === 0 ? theme.dim : theme.error }, "exit:", entry.exit_code)), /* @__PURE__ */ React6.createElement(Box4, null, /* @__PURE__ */ React6.createElement(
+    Text5,
     {
       color: tabPromptColor,
       bold: isPromptActive && isFocused,
@@ -1956,8 +3041,8 @@ var PreviewPane = ({
     },
     isPromptActive ? "\u25CF " : "\u25CB ",
     "1:PROMPT"
-  ), /* @__PURE__ */ React5.createElement(Text4, null, "   "), /* @__PURE__ */ React5.createElement(
-    Text4,
+  ), /* @__PURE__ */ React6.createElement(Text5, null, "   "), /* @__PURE__ */ React6.createElement(
+    Text5,
     {
       color: tabResponseColor,
       bold: isResponseActive && isFocused,
@@ -1965,8 +3050,8 @@ var PreviewPane = ({
     },
     isResponseActive ? "\u25CF " : "\u25CB ",
     "2:RESPONSE"
-  ), /* @__PURE__ */ React5.createElement(Text4, null, "   "), /* @__PURE__ */ React5.createElement(
-    Text4,
+  ), /* @__PURE__ */ React6.createElement(Text5, null, "   "), /* @__PURE__ */ React6.createElement(
+    Text5,
     {
       color: tabMemoryColor,
       bold: isMemoryActive && isFocused,
@@ -1974,22 +3059,10 @@ var PreviewPane = ({
     },
     isMemoryActive ? "\u25CF " : "\u25CB ",
     "3:MEMORY"
-  )), /* @__PURE__ */ React5.createElement(Text4, { dimColor: true }, topIndicator), paddedLines.map((line, i) => /* @__PURE__ */ React5.createElement(Text4, { key: i }, line || " ")), /* @__PURE__ */ React5.createElement(Text4, { dimColor: true }, botIndicator));
+  )), /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, topIndicator), paddedLines.map((line, i) => /* @__PURE__ */ React6.createElement(Text5, { key: i }, line.segments.length > 0 ? line.segments.map((seg, j) => /* @__PURE__ */ React6.createElement(Text5, { key: j, color: seg.color, dimColor: seg.dim }, seg.text)) : " ")), /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, botIndicator));
 };
 
 // src/ui/BrowseApp.tsx
-var FILTER_CATEGORIES = ["project", "language", "role", "tool", "tag", "starred", "quality", "relevance"];
-var ROLE_COLOR4 = {
-  debug: "red",
-  refactor: "yellow",
-  explain: "blue",
-  review: "magenta",
-  architect: "green",
-  test: "cyan",
-  docs: "white",
-  generate: "green",
-  research: "blue"
-};
 function copyToClipboard(text) {
   try {
     const platform = process.platform;
@@ -2009,28 +3082,12 @@ function copyToClipboard(text) {
   } catch {
   }
 }
-function wrapTextLines2(text, width) {
-  const result = [];
-  for (const line of text.split("\n")) {
-    let current = line;
-    if (current.length === 0) {
-      result.push("");
-      continue;
-    }
-    while (current.length > width) {
-      result.push(current.slice(0, width));
-      current = current.slice(width);
-    }
-    if (current.length > 0) result.push(current);
-  }
-  return result;
-}
 function useStdoutDimensions() {
-  const [dimensions, setDimensions] = useState2({
+  const [dimensions, setDimensions] = useState3({
     columns: process.stdout.columns || 120,
     rows: process.stdout.rows || 24
   });
-  useEffect2(() => {
+  useEffect(() => {
     const handler = () => {
       setDimensions({
         columns: process.stdout.columns || 120,
@@ -2053,16 +3110,9 @@ function formatTimestamp2(ts) {
     return ts.slice(0, 16);
   }
 }
-function parseMeta2(raw) {
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return {};
-  }
-}
 function hasProject(entry) {
   if (!entry) return false;
-  const meta = parseMeta2(entry.metadata);
+  const meta = parseMetadata(entry.metadata);
   return Boolean(meta.project);
 }
 var SESSION_GAP_MS = 2 * 60 * 60 * 1e3;
@@ -2081,94 +3131,49 @@ function needsSessionSeparator(entries, idx) {
   const curr = new Date(entries[idx].timestamp).getTime();
   return prev - curr > SESSION_GAP_MS;
 }
-function getDistinctValues(entries, category) {
-  const set = /* @__PURE__ */ new Set();
-  for (const e of entries) {
-    if (category === "tool") {
-      set.add(e.tool);
-      continue;
-    }
-    const meta = parseMeta2(e.metadata);
-    if (category === "project" && meta.project) set.add(meta.project);
-    if (category === "language" && meta.language) set.add(meta.language);
-    if (category === "role" && meta.role) set.add(meta.role);
-    if (category === "tag") meta.tags?.forEach((t) => set.add(t));
-  }
-  return [...set].sort();
-}
-function applyFilters(entries, active, textFilter) {
-  let result = entries;
-  const hasActiveFilter = Object.values(active).some((v) => v !== void 0 && v !== false);
-  if (hasActiveFilter) {
-    result = result.filter((e) => {
-      const meta = parseMeta2(e.metadata);
-      if (active.tool && e.tool !== active.tool) return false;
-      if (active.project && meta.project !== active.project) return false;
-      if (active.language && meta.language !== active.language) return false;
-      if (active.role && meta.role !== active.role) return false;
-      if (active.tag && !meta.tags?.includes(active.tag)) return false;
-      if (active.starred && !meta.starred) return false;
-      if (active.minQuality !== void 0 && (meta.quality ?? 0) < active.minQuality) return false;
-      if (active.minRelevance !== void 0 && (meta.relevance ?? 0) < active.minRelevance) return false;
-      return true;
-    });
-  }
-  if (textFilter) {
-    const lq = textFilter.toLowerCase();
-    result = result.filter((e) => {
-      const meta = parseMeta2(e.metadata);
-      return e.prompt.toLowerCase().includes(lq) || e.tool.toLowerCase().includes(lq) || (meta.project?.toLowerCase().includes(lq) ?? false) || (meta.role?.toLowerCase().includes(lq) ?? false) || (meta.tags?.some((t) => t.toLowerCase().includes(lq)) ?? false);
-    });
-  }
-  return result;
-}
 var DetailView = ({ entry, onClose, onEdit, termWidth, termHeight, theme }) => {
-  const meta = parseMeta2(entry.metadata);
-  const [activeTab, setActiveTab] = useState2(entry.response ? "response" : "prompt");
-  const [scrollOffset, setScrollOffset] = useState2(0);
-  const [copied, setCopied] = useState2(false);
-  useEffect2(() => {
+  const meta = parseMetadata(entry.metadata);
+  const [activeTab, setActiveTab] = useState3(entry.response ? "response" : "prompt");
+  const [scrollOffset, setScrollOffset] = useState3(0);
+  const [copied, setCopied] = useState3(false);
+  const switchTab = (tab) => {
+    setActiveTab(tab);
     setScrollOffset(0);
-  }, [activeTab]);
+  };
   const contentWidth = Math.max(10, termWidth - 4);
   const text = activeTab === "prompt" ? entry.prompt : entry.response || "(no response captured)";
-  const lines = useMemo3(() => {
+  const lines = useMemo4(() => {
     if (activeTab === "prompt" || activeTab === "response") {
-      return wrapTextLines2(text, contentWidth);
+      return buildRichLines(text, contentWidth);
     }
     const memLines = [];
+    const push2 = (t) => memLines.push({ segments: [{ text: t }] });
     if (meta.summary) {
-      memLines.push("SUMMARY:");
-      memLines.push(...wrapTextLines2(meta.summary, contentWidth));
-      memLines.push("");
+      push2("SUMMARY:");
+      for (const l of wrapTextLines(meta.summary, contentWidth)) push2(l);
+      push2("");
     }
     if (meta.key_insights && meta.key_insights.length > 0) {
-      memLines.push("KEY INSIGHTS:");
+      push2("KEY INSIGHTS:");
       for (const insight of meta.key_insights) {
-        memLines.push(...wrapTextLines2(`\u2022 ${insight}`, contentWidth));
+        for (const l of wrapTextLines(`\u2022 ${insight}`, contentWidth)) push2(l);
       }
     }
-    if (memLines.length === 0) {
-      memLines.push("(no AI analysis found - run ph analyze)");
-    }
+    if (memLines.length === 0) push2("(no AI analysis found - run ph analyze)");
     return memLines;
   }, [activeTab, text, contentWidth, meta]);
   const contentHeight = Math.max(1, termHeight - 10);
   const maxScroll = Math.max(0, lines.length - contentHeight);
-  useInput2((char, key) => {
+  useInput3((char, key) => {
     if (key.escape || key.return) onClose();
     else if (char === "e") onEdit();
     else if (key.tab || char === "1" || char === "2" || char === "3") {
-      if (char === "1") setActiveTab("prompt");
-      else if (char === "2") setActiveTab("response");
-      else if (char === "3") setActiveTab("memory");
-      else setActiveTab((t) => {
-        if (t === "prompt") return "response";
-        if (t === "response") return "memory";
-        return "prompt";
-      });
+      if (char === "1") switchTab("prompt");
+      else if (char === "2") switchTab("response");
+      else if (char === "3") switchTab("memory");
+      else switchTab(activeTab === "prompt" ? "response" : activeTab === "response" ? "memory" : "prompt");
     } else if (char === "y") {
-      const copyText = activeTab === "memory" ? lines.join("\n") : text;
+      const copyText = activeTab === "memory" ? lines.map((l) => l.segments.map((s) => s.text).join("")).join("\n") : text;
       copyToClipboard(copyText);
       setCopied(true);
       setTimeout(() => setCopied(false), 2e3);
@@ -2179,15 +3184,15 @@ var DetailView = ({ entry, onClose, onEdit, termWidth, termHeight, theme }) => {
   });
   const visibleLines = lines.slice(scrollOffset, scrollOffset + contentHeight);
   const remaining = lines.length - (scrollOffset + contentHeight);
-  return /* @__PURE__ */ React6.createElement(Box4, { flexDirection: "column", paddingX: 2, paddingTop: 1, flexGrow: 1 }, /* @__PURE__ */ React6.createElement(Box4, null, /* @__PURE__ */ React6.createElement(Text5, { color: theme.primary, bold: true }, "#", entry.id), /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, " \xB7 ", entry.tool, " \xB7 ", formatTimestamp2(entry.timestamp), "  "), meta.starred && /* @__PURE__ */ React6.createElement(Text5, { color: theme.warning }, "\u2605")), /* @__PURE__ */ React6.createElement(Box4, null, meta.project && /* @__PURE__ */ React6.createElement(Text5, { color: theme.accent }, "proj:", meta.project, "  "), meta.language && /* @__PURE__ */ React6.createElement(Text5, { color: theme.dim }, "lang:", meta.language, "  "), meta.role && /* @__PURE__ */ React6.createElement(Text5, { color: ROLE_COLOR4[meta.role] ?? theme.primary }, "role:", meta.role, "  "), meta.quality !== void 0 && /* @__PURE__ */ React6.createElement(Text5, { color: theme.success }, "Q:", meta.quality, "  "), meta.relevance !== void 0 && /* @__PURE__ */ React6.createElement(Text5, { color: theme.warning }, "R:", meta.relevance, "  "), /* @__PURE__ */ React6.createElement(Text5, { color: entry.exit_code === 0 ? theme.dim : theme.error }, "exit:", entry.exit_code)), /* @__PURE__ */ React6.createElement(Box4, { height: 1 }), /* @__PURE__ */ React6.createElement(Box4, { marginBottom: 0, justifyContent: "space-between" }, /* @__PURE__ */ React6.createElement(Box4, null, /* @__PURE__ */ React6.createElement(Text5, { color: theme.primary, bold: true, underline: activeTab === "prompt" }, activeTab === "prompt" ? "\u25CF" : "\u25CB", " 1:PROMPT"), /* @__PURE__ */ React6.createElement(Text5, null, "   "), /* @__PURE__ */ React6.createElement(Text5, { color: theme.primary, bold: true, underline: activeTab === "response" }, activeTab === "response" ? "\u25CF" : "\u25CB", " 2:RESPONSE"), /* @__PURE__ */ React6.createElement(Text5, null, "   "), /* @__PURE__ */ React6.createElement(Text5, { color: theme.primary, bold: true, underline: activeTab === "memory" }, activeTab === "memory" ? "\u25CF" : "\u25CB", " 3:MEMORY")), /* @__PURE__ */ React6.createElement(Box4, null, copied && /* @__PURE__ */ React6.createElement(Text5, { color: theme.success }, "Copied! "), /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "[y:copy  e:edit  ESC:back]"))), /* @__PURE__ */ React6.createElement(Box4, { height: 1 }, scrollOffset > 0 && /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "  \u2191 ", scrollOffset, " above")), /* @__PURE__ */ React6.createElement(Box4, { flexDirection: "column", flexGrow: 1 }, visibleLines.map((line, i) => /* @__PURE__ */ React6.createElement(Text5, { key: i }, line || " ")), Array.from({ length: Math.max(0, contentHeight - visibleLines.length) }).map((_, i) => /* @__PURE__ */ React6.createElement(Text5, { key: `pad-${i}` }, " "))), /* @__PURE__ */ React6.createElement(Box4, { height: 1 }, remaining > 0 && /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "  \u2193 ", remaining, " more")));
+  return /* @__PURE__ */ React7.createElement(Box5, { flexDirection: "column", paddingX: 2, paddingTop: 1, flexGrow: 1 }, /* @__PURE__ */ React7.createElement(Box5, null, /* @__PURE__ */ React7.createElement(Text6, { color: theme.primary, bold: true }, "#", entry.id), /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, " \xB7 ", entry.tool, " \xB7 ", formatTimestamp2(entry.timestamp), "  "), meta.starred && /* @__PURE__ */ React7.createElement(Text6, { color: theme.warning }, "\u2605")), /* @__PURE__ */ React7.createElement(Box5, null, meta.project && /* @__PURE__ */ React7.createElement(Text6, { color: theme.accent }, "proj:", meta.project, "  "), meta.language && /* @__PURE__ */ React7.createElement(Text6, { color: theme.dim }, "lang:", meta.language, "  "), meta.role && /* @__PURE__ */ React7.createElement(Text6, { color: ROLE_COLOR2[meta.role] ?? theme.primary }, "role:", meta.role, "  "), meta.quality !== void 0 && /* @__PURE__ */ React7.createElement(Text6, { color: theme.success }, "Q:", meta.quality, "  "), meta.relevance !== void 0 && /* @__PURE__ */ React7.createElement(Text6, { color: theme.warning }, "R:", meta.relevance, "  "), /* @__PURE__ */ React7.createElement(Text6, { color: entry.exit_code === 0 ? theme.dim : theme.error }, "exit:", entry.exit_code)), /* @__PURE__ */ React7.createElement(Box5, { height: 1 }), /* @__PURE__ */ React7.createElement(Box5, { marginBottom: 0, justifyContent: "space-between" }, /* @__PURE__ */ React7.createElement(Box5, null, /* @__PURE__ */ React7.createElement(Text6, { color: theme.primary, bold: true, underline: activeTab === "prompt" }, activeTab === "prompt" ? "\u25CF" : "\u25CB", " 1:PROMPT"), /* @__PURE__ */ React7.createElement(Text6, null, "   "), /* @__PURE__ */ React7.createElement(Text6, { color: theme.primary, bold: true, underline: activeTab === "response" }, activeTab === "response" ? "\u25CF" : "\u25CB", " 2:RESPONSE"), /* @__PURE__ */ React7.createElement(Text6, null, "   "), /* @__PURE__ */ React7.createElement(Text6, { color: theme.primary, bold: true, underline: activeTab === "memory" }, activeTab === "memory" ? "\u25CF" : "\u25CB", " 3:MEMORY")), /* @__PURE__ */ React7.createElement(Box5, null, copied && /* @__PURE__ */ React7.createElement(Text6, { color: theme.success }, "Copied! "), /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, "[y:copy  e:edit  ESC:back]"))), /* @__PURE__ */ React7.createElement(Box5, { height: 1 }, scrollOffset > 0 && /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, "  \u2191 ", scrollOffset, " above")), /* @__PURE__ */ React7.createElement(Box5, { flexDirection: "column", flexGrow: 1 }, visibleLines.map((line, i) => /* @__PURE__ */ React7.createElement(Text6, { key: i }, line.segments.length > 0 ? line.segments.map((seg, j) => /* @__PURE__ */ React7.createElement(Text6, { key: j, color: seg.color, dimColor: seg.dim }, seg.text)) : " ")), Array.from({ length: Math.max(0, contentHeight - visibleLines.length) }).map((_, i) => /* @__PURE__ */ React7.createElement(Text6, { key: `pad-${i}` }, " "))), /* @__PURE__ */ React7.createElement(Box5, { height: 1 }, remaining > 0 && /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, "  \u2193 ", remaining, " more")));
 };
 var EditView = ({ entry, onSave, onClose, theme }) => {
-  const initMeta = parseMeta2(entry.metadata);
-  const [field, setField] = useState2("title");
-  const [titleValue, setTitleValue] = useState2(initMeta.title ?? extractTopic(entry.prompt));
-  const [roleValue, setRoleValue] = useState2(initMeta.role ?? "");
-  const [tagsValue, setTagsValue] = useState2(initMeta.tags?.join(", ") ?? "");
-  useInput2((char, key) => {
+  const initMeta = parseMetadata(entry.metadata);
+  const [field, setField] = useState3("title");
+  const [titleValue, setTitleValue] = useState3(initMeta.title ?? extractTopic(entry.prompt));
+  const [roleValue, setRoleValue] = useState3(initMeta.role ?? "");
+  const [tagsValue, setTagsValue] = useState3(initMeta.tags?.join(", ") ?? "");
+  useInput3((char, key) => {
     if (key.escape) {
       onClose();
       return;
@@ -2217,152 +3222,58 @@ var EditView = ({ entry, onSave, onClose, theme }) => {
     } else if (char && !key.ctrl && !key.meta) {
       setter((v) => v + char);
     }
-  });
-  const ROLES = "debug \xB7 refactor \xB7 explain \xB7 review \xB7 architect \xB7 test \xB7 docs \xB7 generate \xB7 research";
-  return /* @__PURE__ */ React6.createElement(Box4, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React6.createElement(Box4, { marginBottom: 1 }, /* @__PURE__ */ React6.createElement(Text5, { color: theme.primary, bold: true }, "Edit Metadata \u2014 Prompt #", entry.id)), /* @__PURE__ */ React6.createElement(Box4, { flexDirection: "column", borderStyle: "single", borderColor: theme.dim, padding: 1 }, /* @__PURE__ */ React6.createElement(Box4, { marginBottom: 1 }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "Title: "), /* @__PURE__ */ React6.createElement(Text5, { color: field === "title" ? theme.primary : "white", bold: field === "title" }, titleValue || "(none)", field === "title" ? "\u2588" : "")), /* @__PURE__ */ React6.createElement(Box4, { marginBottom: 1 }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "Role:  "), /* @__PURE__ */ React6.createElement(Text5, { color: field === "role" ? theme.primary : "white", bold: field === "role" }, roleValue || "(none)", field === "role" ? "\u2588" : "")), /* @__PURE__ */ React6.createElement(Box4, null, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "Tags:  "), /* @__PURE__ */ React6.createElement(Text5, { color: field === "tags" ? theme.primary : "white", bold: field === "tags" }, tagsValue || "(none)", field === "tags" ? "\u2588" : ""))), /* @__PURE__ */ React6.createElement(Box4, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "Roles: ", ROLES)), /* @__PURE__ */ React6.createElement(Box4, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "Tab switch field \xB7 Enter save \xB7 ESC cancel")));
-};
-var RerunView = ({ entry, onConfirm, onClose, theme }) => {
-  const [field, setField] = useState2("prompt");
-  const [toolValue, setToolValue] = useState2(entry.tool);
-  const [promptValue, setPromptValue] = useState2(entry.prompt);
-  const meta = parseMeta2(entry.metadata);
-  const git = meta.git_context;
-  useInput2((char, key) => {
-    if (key.escape) {
-      onClose();
-      return;
-    }
-    if (key.return) {
-      onConfirm(toolValue.trim(), promptValue.trim());
-      return;
-    }
-    if (key.tab) {
-      setField((f) => f === "tool" ? "prompt" : "tool");
-      return;
-    }
-    const setter = field === "tool" ? setToolValue : setPromptValue;
-    if (key.backspace || key.delete) {
-      setter((v) => v.slice(0, -1));
-    } else if (char && !key.ctrl && !key.meta) {
-      setter((v) => v + char);
-    }
-  });
-  return /* @__PURE__ */ React6.createElement(Box4, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React6.createElement(Box4, { marginBottom: 1 }, /* @__PURE__ */ React6.createElement(Text5, { color: theme.primary, bold: true }, "Rerun Prompt #", entry.id)), /* @__PURE__ */ React6.createElement(Box4, { flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "Tool:      ", /* @__PURE__ */ React6.createElement(Text5, { color: theme.warning }, entry.tool)), /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "Date:      ", /* @__PURE__ */ React6.createElement(Text5, null, formatTimestamp2(entry.timestamp))), meta.project && /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "Project:   ", /* @__PURE__ */ React6.createElement(Text5, { color: theme.accent }, meta.project)), git && /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "Git:       ", /* @__PURE__ */ React6.createElement(Text5, { color: theme.warning }, "Captured on branch: ", git.branch, ", ", git.files?.length || 0, " files modified"))), /* @__PURE__ */ React6.createElement(Box4, { flexDirection: "column", borderStyle: "single", borderColor: theme.dim, padding: 1 }, /* @__PURE__ */ React6.createElement(Box4, { marginBottom: 1 }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "Tool:   "), /* @__PURE__ */ React6.createElement(Text5, { color: field === "tool" ? theme.primary : "white", bold: field === "tool" }, toolValue, field === "tool" ? "\u2588" : "")), /* @__PURE__ */ React6.createElement(Box4, { flexDirection: "column" }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "Prompt: "), /* @__PURE__ */ React6.createElement(Box4, { borderStyle: "round", borderColor: field === "prompt" ? theme.primary : theme.dim, paddingX: 1 }, /* @__PURE__ */ React6.createElement(Text5, { color: field === "prompt" ? theme.primary : "white" }, promptValue, field === "prompt" ? "\u2588" : "")))), /* @__PURE__ */ React6.createElement(Box4, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "Tab switch \xB7 Enter run \xB7 ESC cancel")));
-};
-var FilterPanel = ({ allEntries, active, onUpdate, onClose, theme }) => {
-  const options = useMemo3(() => {
-    const opts = [];
-    for (const cat of FILTER_CATEGORIES) {
-      if (cat === "starred") {
-        const count = allEntries.filter((e) => {
-          try {
-            return JSON.parse(e.metadata).starred;
-          } catch {
-            return false;
-          }
-        }).length;
-        opts.push({ category: "starred", label: "\u2605 Only starred", count, active: !!active.starred });
-      } else if (cat === "quality") {
-        const qActive = active.minQuality !== void 0;
-        opts.push({ category: "quality", label: `Q \u2265 ${active.minQuality ?? "?"}`, count: 0, active: qActive });
-        for (const v of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) {
-          const c = allEntries.filter((e) => {
-            try {
-              return (JSON.parse(e.metadata).quality ?? 0) >= v;
-            } catch {
-              return false;
-            }
-          }).length;
-          opts.push({ category: "quality", label: `Q \u2265 ${v}`, count: c, active: active.minQuality === v });
-        }
-      } else if (cat === "relevance") {
-        const rActive = active.minRelevance !== void 0;
-        opts.push({ category: "relevance", label: `R \u2265 ${active.minRelevance ?? "?"}`, count: 0, active: rActive });
-        for (const v of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) {
-          const c = allEntries.filter((e) => {
-            try {
-              return (JSON.parse(e.metadata).relevance ?? 0) >= v;
-            } catch {
-              return false;
-            }
-          }).length;
-          opts.push({ category: "relevance", label: `R \u2265 ${v}`, count: c, active: active.minRelevance === v });
-        }
-      } else {
-        const vals = getDistinctValues(allEntries, cat);
-        for (const v of vals) {
-          const c = allEntries.filter((e) => {
-            try {
-              const m = JSON.parse(e.metadata);
-              if (cat === "project") return m.project === v;
-              if (cat === "language") return m.language === v;
-              if (cat === "role") return m.role === v;
-              if (cat === "tool") return e.tool === v;
-              if (cat === "tag") return m.tags?.includes(v);
-              return false;
-            } catch {
-              return false;
-            }
-          }).length;
-          const currentVal = active[cat];
-          opts.push({ category: cat, label: v, count: c, active: currentVal === v });
-        }
-      }
-    }
-    return opts;
-  }, [allEntries, active]);
-  const [cursor, setCursor] = useState2(0);
-  const visibleCount = Math.min(options.length, 16);
-  const scrollOffset = Math.max(0, Math.min(cursor - Math.floor(visibleCount / 2), options.length - visibleCount));
-  const visible = options.slice(Math.max(0, scrollOffset), scrollOffset + visibleCount);
-  useInput2((char, key) => {
+  });
+  const ROLES = "debug \xB7 refactor \xB7 explain \xB7 review \xB7 architect \xB7 test \xB7 docs \xB7 generate \xB7 research";
+  return /* @__PURE__ */ React7.createElement(Box5, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React7.createElement(Box5, { marginBottom: 1 }, /* @__PURE__ */ React7.createElement(Text6, { color: theme.primary, bold: true }, "Edit Metadata \u2014 Prompt #", entry.id)), /* @__PURE__ */ React7.createElement(Box5, { flexDirection: "column", borderStyle: "single", borderColor: theme.dim, padding: 1 }, /* @__PURE__ */ React7.createElement(Box5, { marginBottom: 1 }, /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, "Title: "), /* @__PURE__ */ React7.createElement(Text6, { color: field === "title" ? theme.primary : "white", bold: field === "title" }, titleValue || "(none)", field === "title" ? "\u2588" : "")), /* @__PURE__ */ React7.createElement(Box5, { marginBottom: 1 }, /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, "Role:  "), /* @__PURE__ */ React7.createElement(Text6, { color: field === "role" ? theme.primary : "white", bold: field === "role" }, roleValue || "(none)", field === "role" ? "\u2588" : "")), /* @__PURE__ */ React7.createElement(Box5, null, /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, "Tags:  "), /* @__PURE__ */ React7.createElement(Text6, { color: field === "tags" ? theme.primary : "white", bold: field === "tags" }, tagsValue || "(none)", field === "tags" ? "\u2588" : ""))), /* @__PURE__ */ React7.createElement(Box5, { marginTop: 1 }, /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, "Roles: ", ROLES)), /* @__PURE__ */ React7.createElement(Box5, { marginTop: 1 }, /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, "Tab switch field \xB7 Enter save \xB7 ESC cancel")));
+};
+var RerunView = ({ entry, onConfirm, onClose, theme }) => {
+  const [field, setField] = useState3("prompt");
+  const [toolValue, setToolValue] = useState3(entry.tool);
+  const [promptValue, setPromptValue] = useState3(entry.prompt);
+  const meta = parseMetadata(entry.metadata);
+  const git = meta.git_context;
+  useInput3((char, key) => {
     if (key.escape) {
       onClose();
       return;
     }
-    if (char === "c") {
-      onUpdate({});
+    if (key.return) {
+      onConfirm(toolValue.trim(), promptValue.trim());
       return;
     }
-    if (key.return || char === " ") {
-      const opt = options[cursor];
-      if (!opt) return;
-      if (opt.category === "starred") {
-        onUpdate({ ...active, starred: !opt.active || void 0 });
-      } else if (opt.category === "quality") {
-        const v = parseInt(opt.label.replace("Q \u2265 ", ""), 10);
-        onUpdate({ ...active, minQuality: opt.active ? void 0 : v });
-      } else if (opt.category === "relevance") {
-        const v = parseInt(opt.label.replace("R \u2265 ", ""), 10);
-        onUpdate({ ...active, minRelevance: opt.active ? void 0 : v });
-      } else {
-        const key2 = opt.category;
-        if (opt.active) {
-          const updated = { ...active };
-          delete updated[key2];
-          onUpdate(updated);
-        } else {
-          onUpdate({ ...active, [key2]: opt.label });
-        }
-      }
+    if (key.tab) {
+      setField((f) => f === "tool" ? "prompt" : "tool");
       return;
     }
-    if (key.upArrow) setCursor((c) => Math.max(0, c - 1));
-    if (key.downArrow) setCursor((c) => Math.min(options.length - 1, c + 1));
-    if (key.pageUp) setCursor((c) => Math.max(0, c - visibleCount));
-    if (key.pageDown) setCursor((c) => Math.min(options.length - 1, c + visibleCount));
-    if (char && /^[a-z]$/.test(char)) {
-      const idx = options.findIndex((o, i) => i > cursor && o.category[0] === char);
-      if (idx !== -1) setCursor(idx);
+    const setter = field === "tool" ? setToolValue : setPromptValue;
+    if (key.backspace || key.delete) {
+      setter((v) => v.slice(0, -1));
+    } else if (char && !key.ctrl && !key.meta) {
+      setter((v) => v + char);
+    }
+  });
+  return /* @__PURE__ */ React7.createElement(Box5, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React7.createElement(Box5, { marginBottom: 1 }, /* @__PURE__ */ React7.createElement(Text6, { color: theme.primary, bold: true }, "Rerun Prompt #", entry.id)), /* @__PURE__ */ React7.createElement(Box5, { flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, "Tool:      ", /* @__PURE__ */ React7.createElement(Text6, { color: theme.warning }, entry.tool)), /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, "Date:      ", /* @__PURE__ */ React7.createElement(Text6, null, formatTimestamp2(entry.timestamp))), meta.project && /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, "Project:   ", /* @__PURE__ */ React7.createElement(Text6, { color: theme.accent }, meta.project)), git && /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, "Git:       ", /* @__PURE__ */ React7.createElement(Text6, { color: theme.warning }, "Captured on branch: ", git.branch, ", ", git.files?.length || 0, " files modified"))), /* @__PURE__ */ React7.createElement(Box5, { flexDirection: "column", borderStyle: "single", borderColor: theme.dim, padding: 1 }, /* @__PURE__ */ React7.createElement(Box5, { marginBottom: 1 }, /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, "Tool:   "), /* @__PURE__ */ React7.createElement(Text6, { color: field === "tool" ? theme.primary : "white", bold: field === "tool" }, toolValue, field === "tool" ? "\u2588" : "")), /* @__PURE__ */ React7.createElement(Box5, { flexDirection: "column" }, /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, "Prompt: "), /* @__PURE__ */ React7.createElement(Box5, { borderStyle: "round", borderColor: field === "prompt" ? theme.primary : theme.dim, paddingX: 1 }, /* @__PURE__ */ React7.createElement(Text6, { color: field === "prompt" ? theme.primary : "white" }, promptValue, field === "prompt" ? "\u2588" : "")))), /* @__PURE__ */ React7.createElement(Box5, { marginTop: 1 }, /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, "Tab switch \xB7 Enter run \xB7 ESC cancel")));
+};
+var KNOWN_PROVIDERS = [
+  { key: "1", label: "claude", tool: "claude" },
+  { key: "2", label: "gemini", tool: "gemini" },
+  { key: "3", label: "opencode", tool: "opencode" },
+  { key: "4", label: "codex", tool: "codex" },
+  { key: "5", label: "ollama", tool: "ollama" },
+  { key: "6", label: "chatgpt", tool: "chatgpt" }
+];
+var ProviderPicker = ({ entry, onPick, onClose, theme }) => {
+  useInput3((char) => {
+    if (char === "q" || char === "\x1B") {
+      onClose();
+      return;
+    }
+    const provider = KNOWN_PROVIDERS.find((p) => p.key === char);
+    if (provider) {
+      onPick(provider.tool, entry.prompt);
     }
   });
-  const activeCount = Object.values(active).filter((v) => v !== void 0 && v !== false).length;
-  return /* @__PURE__ */ React6.createElement(Box4, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React6.createElement(Box4, { marginBottom: 1 }, /* @__PURE__ */ React6.createElement(Text5, { color: theme.primary, bold: true }, "Filters  "), activeCount > 0 ? /* @__PURE__ */ React6.createElement(Text5, { color: theme.warning }, activeCount, " active  ") : /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "none active  "), activeCount > 0 && /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "(c clear)")), /* @__PURE__ */ React6.createElement(Box4, { borderStyle: "single", borderColor: theme.dim, flexDirection: "column", padding: 1, minHeight: 18 }, /* @__PURE__ */ React6.createElement(Box4, { flexDirection: "column" }, visible.map((opt, i) => {
-    const absIdx = Math.max(0, scrollOffset) + i;
-    const isCur = absIdx === cursor;
-    const catColor = opt.category === "project" ? "blue" : opt.category === "language" ? "green" : opt.category === "role" ? ROLE_COLOR4[opt.label] || "cyan" : opt.category === "tool" ? "yellow" : opt.category === "tag" ? "cyan" : "white";
-    return /* @__PURE__ */ React6.createElement(Box4, { key: `${opt.category}-${opt.label}` }, /* @__PURE__ */ React6.createElement(Text5, { bold: isCur, color: isCur ? theme.primary : theme.dim }, isCur ? "\u276F " : "  "), /* @__PURE__ */ React6.createElement(Text5, { color: opt.active ? theme.warning : catColor, bold: opt.active || isCur }, opt.category, ":", opt.label), /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, " [", opt.count, "]"), opt.active && /* @__PURE__ */ React6.createElement(Text5, { color: theme.success }, " \u2713"));
-  })), options.length > visibleCount && /* @__PURE__ */ React6.createElement(Box4, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "  ", cursor + 1, "/", options.length, " \xB7 \u2191\u2193 navigate \xB7 Enter toggle \xB7 c clear \xB7 ESC close"))), /* @__PURE__ */ React6.createElement(Box4, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "\u2191\u2193 navigate \xB7 Enter toggle \xB7 c clear all \xB7 ESC close \xB7 letter jumps to category")));
+  return /* @__PURE__ */ React7.createElement(Box5, { flexDirection: "column", padding: 2 }, /* @__PURE__ */ React7.createElement(Text6, { bold: true, color: theme.primary }, "Send prompt #", entry.id, " to:"), /* @__PURE__ */ React7.createElement(Box5, { marginTop: 1, flexDirection: "column" }, KNOWN_PROVIDERS.map((p) => /* @__PURE__ */ React7.createElement(Text6, { key: p.key }, /* @__PURE__ */ React7.createElement(Text6, { color: theme.warning }, p.key), /* @__PURE__ */ React7.createElement(Text6, null, ": ", p.label)))), /* @__PURE__ */ React7.createElement(Box5, { marginTop: 1 }, /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, "Pick a number \xB7 q to cancel")));
 };
 var SETTING_FIELDS = [
   { key: "backgroundAnalysis", label: "Auto-analysis on capture", type: "boolean" },
@@ -2374,10 +3285,10 @@ var SETTING_FIELDS = [
   { key: "filterMinRelevance", label: "Min relevance filter", type: "number" }
 ];
 var SettingsView = ({ onClose, theme }) => {
-  const [cfg, setCfg] = useState2(() => load());
-  const [cursor, setCursor] = useState2(0);
-  const [dirty, setDirty] = useState2(false);
-  const [saved, setSaved] = useState2(false);
+  const [cfg, setCfg] = useState3(() => load());
+  const [cursor, setCursor] = useState3(0);
+  const [dirty, setDirty] = useState3(false);
+  const [saved, setSaved] = useState3(false);
   const toggleField = (key) => {
     const updated = { ...cfg };
     if (key === "backgroundAnalysis") {
@@ -2393,7 +3304,7 @@ var SettingsView = ({ onClose, theme }) => {
     setSaved(true);
     setTimeout(() => setSaved(false), 2e3);
   };
-  useInput2((char, key) => {
+  useInput3((char, key) => {
     if (key.escape) {
       onClose();
       return;
@@ -2416,7 +3327,7 @@ var SettingsView = ({ onClose, theme }) => {
       }
     }
   });
-  return /* @__PURE__ */ React6.createElement(Box4, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React6.createElement(Box4, { marginBottom: 1 }, /* @__PURE__ */ React6.createElement(Text5, { color: theme.primary, bold: true }, "Settings  "), dirty && /* @__PURE__ */ React6.createElement(Text5, { color: theme.warning }, "modified  "), saved && /* @__PURE__ */ React6.createElement(Text5, { color: theme.success }, "\u2713 saved")), /* @__PURE__ */ React6.createElement(Box4, { borderStyle: "single", borderColor: theme.dim, flexDirection: "column", padding: 1 }, SETTING_FIELDS.map((field, i) => {
+  return /* @__PURE__ */ React7.createElement(Box5, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React7.createElement(Box5, { marginBottom: 1 }, /* @__PURE__ */ React7.createElement(Text6, { color: theme.primary, bold: true }, "Settings  "), dirty && /* @__PURE__ */ React7.createElement(Text6, { color: theme.warning }, "modified  "), saved && /* @__PURE__ */ React7.createElement(Text6, { color: theme.success }, "\u2713 saved")), /* @__PURE__ */ React7.createElement(Box5, { borderStyle: "single", borderColor: theme.dim, flexDirection: "column", padding: 1 }, SETTING_FIELDS.map((field, i) => {
     const isCur = i === cursor;
     const val = cfg[field.key];
     let display;
@@ -2426,25 +3337,27 @@ var SettingsView = ({ onClose, theme }) => {
       display = val !== void 0 ? String(val) : "(default)";
     }
     const valColor = field.type === "boolean" ? val ? theme.success : theme.dim : val !== void 0 ? "white" : theme.dim;
-    return /* @__PURE__ */ React6.createElement(Box4, { key: field.key }, /* @__PURE__ */ React6.createElement(Text5, { bold: isCur, color: isCur ? theme.primary : theme.dim }, isCur ? "\u276F " : "  "), /* @__PURE__ */ React6.createElement(Text5, { color: isCur ? theme.primary : "white" }, field.label), /* @__PURE__ */ React6.createElement(Text5, null, "  ".repeat(Math.max(1, 30 - field.label.length))), /* @__PURE__ */ React6.createElement(Text5, { color: valColor, bold: field.type === "boolean" && isCur }, display), field.type === "boolean" && isCur && /* @__PURE__ */ React6.createElement(Text5, { color: theme.warning }, "  [Enter toggle]"));
-  })), /* @__PURE__ */ React6.createElement(Box4, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "\u2191\u2193 navigate \xB7 Enter toggle boolean \xB7 ", dirty ? "s save \xB7 " : "", "q/ESC close")));
+    return /* @__PURE__ */ React7.createElement(Box5, { key: field.key }, /* @__PURE__ */ React7.createElement(Text6, { bold: isCur, color: isCur ? theme.primary : theme.dim }, isCur ? "\u276F " : "  "), /* @__PURE__ */ React7.createElement(Text6, { color: isCur ? theme.primary : "white" }, field.label), /* @__PURE__ */ React7.createElement(Text6, null, "  ".repeat(Math.max(1, 30 - field.label.length))), /* @__PURE__ */ React7.createElement(Text6, { color: valColor, bold: field.type === "boolean" && isCur }, display), field.type === "boolean" && isCur && /* @__PURE__ */ React7.createElement(Text6, { color: theme.warning }, "  [Enter toggle]"));
+  })), /* @__PURE__ */ React7.createElement(Box5, { marginTop: 1 }, /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, "\u2191\u2193 navigate \xB7 Enter toggle boolean \xB7 ", dirty ? "s save \xB7 " : "", "q/ESC close")));
 };
 var BrowseApp = ({ db, initialTextFilter, initialFilters, onRerun }) => {
   const { exit } = useApp();
-  const [allEntries, setAllEntries] = useState2(() => db.search({ limit: 1e3 }));
-  const [refreshKey, setRefreshKey] = useState2(0);
-  const [textFilter, setTextFilter] = useState2(initialTextFilter ?? "");
-  const [isTextFiltering, setTextFiltering] = useState2(false);
-  const [activeFilters, setActiveFilters] = useState2(initialFilters ?? {});
-  const [showFilterPanel, setFilterPanel] = useState2(false);
-  const [showSettings, setShowSettings] = useState2(false);
-  const [cursor, setCursor] = useState2(0);
-  const [detail, setDetail] = useState2(null);
-  const [editing, setEditing] = useState2(null);
-  const [rerunning, setRerunning] = useState2(null);
-  const [copiedId, setCopiedId] = useState2(null);
-  const [focusPane, setFocusPane] = useState2("list");
-  const [scrollOffset, setScrollOffset] = useState2(0);
+  const [allEntries, setAllEntries] = useState3(() => db.search({ limit: 1e3 }));
+  const [refreshKey, setRefreshKey] = useState3(0);
+  const [archiveCount] = useState3(() => db.getArchiveStats().total);
+  const [textFilter, setTextFilter] = useState3(initialTextFilter ?? "");
+  const [isTextFiltering, setTextFiltering] = useState3(false);
+  const [activeFilters, setActiveFilters] = useState3(initialFilters ?? {});
+  const [showFilterPanel, setFilterPanel] = useState3(false);
+  const [showSettings, setShowSettings] = useState3(false);
+  const [cursor, setCursor] = useState3(0);
+  const [detail, setDetail] = useState3(null);
+  const [editing, setEditing] = useState3(null);
+  const [rerunning, setRerunning] = useState3(null);
+  const [providerPicking, setProviderPicking] = useState3(null);
+  const [copiedId, setCopiedId] = useState3(null);
+  const [focusPane, setFocusPane] = useState3("list");
+  const [scrollOffset, setScrollOffset] = useState3(0);
   const currentThemeName = "dark";
   const theme = THEMES3[currentThemeName] || THEMES3.dark;
   const { columns: termWidth, rows: termHeight } = useStdoutDimensions();
@@ -2452,15 +3365,15 @@ var BrowseApp = ({ db, initialTextFilter, initialFilters, onRerun }) => {
   const isWide = termWidth >= SPLIT_THRESHOLD;
   const leftPaneWidth = isWide ? Math.max(32, Math.min(50, Math.floor(termWidth * 0.33))) : termWidth;
   const PAGE_SIZE = Math.max(1, Math.floor((termHeight - 3) / 4));
-  const entries = useMemo3(
+  const entries = useMemo4(
     () => applyFilters(allEntries, activeFilters, textFilter),
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [allEntries, activeFilters, textFilter, refreshKey]
   );
-  useEffect2(() => {
+  useEffect(() => {
     setCursor((c) => Math.min(c, Math.max(0, entries.length - 1)));
   }, [entries.length]);
-  useEffect2(() => {
+  useEffect(() => {
     setScrollOffset((prev) => {
       const clamped = Math.max(0, Math.min(prev, Math.max(0, entries.length - PAGE_SIZE)));
       if (cursor < clamped) return cursor;
@@ -2472,7 +3385,7 @@ var BrowseApp = ({ db, initialTextFilter, initialFilters, onRerun }) => {
   const visible = entries.slice(pageStart, pageStart + PAGE_SIZE);
   const triggerRefresh = useCallback(() => setRefreshKey((k) => k + 1), []);
   const toggleStar = useCallback((entry) => {
-    const meta = parseMeta2(entry.metadata);
+    const meta = parseMetadata(entry.metadata);
     meta.starred = !meta.starred;
     const newMeta = JSON.stringify(meta);
     db.updateMetadata(entry.id, newMeta);
@@ -2495,8 +3408,8 @@ var BrowseApp = ({ db, initialTextFilter, initialFilters, onRerun }) => {
     setCursor(0);
     setScrollOffset(0);
   }, []);
-  useInput2((char, key) => {
-    if (detail || editing || showFilterPanel || showSettings || rerunning) return;
+  useInput3((char, key) => {
+    if (detail || editing || showFilterPanel || showSettings || rerunning || providerPicking) return;
     if (isTextFiltering) {
       if (key.escape) {
         setTextFiltering(false);
@@ -2527,6 +3440,8 @@ var BrowseApp = ({ db, initialTextFilter, initialFilters, onRerun }) => {
       if (entries[cursor]) setEditing(entries[cursor]);
     } else if (char === "r") {
       if (entries[cursor]) setRerunning(entries[cursor]);
+    } else if (char === "p") {
+      if (entries[cursor]) setProviderPicking(entries[cursor]);
     } else if (char === "x") {
       if (entries[cursor]) handleDelete(entries[cursor]);
     } else if (char === "f") {
@@ -2541,7 +3456,7 @@ var BrowseApp = ({ db, initialTextFilter, initialFilters, onRerun }) => {
     } else if (char === "C") {
       const entry = entries[cursor];
       if (!entry) return;
-      const meta = parseMeta2(entry.metadata);
+      const meta = parseMetadata(entry.metadata);
       const project = meta.project;
       if (!project) return;
       const memories = db.searchMemories(project, 3);
@@ -2565,7 +3480,7 @@ ${mem.summary}`);
       if (recent.length > 0) {
         ctx.push("\n---\n## Recent Context");
         for (const p of recent) {
-          const pm = parseMeta2(p.metadata);
+          const pm = parseMetadata(p.metadata);
           ctx.push(`
 - #${p.id}: ${pm.summary || p.prompt.slice(0, 100).replace(/\n/g, " ")}`);
         }
@@ -2611,7 +3526,7 @@ ${entry.prompt}`;
   });
   let mainContent;
   if (showSettings) {
-    mainContent = /* @__PURE__ */ React6.createElement(
+    mainContent = /* @__PURE__ */ React7.createElement(
       SettingsView,
       {
         onClose: () => setShowSettings(false),
@@ -2619,7 +3534,7 @@ ${entry.prompt}`;
       }
     );
   } else if (showFilterPanel) {
-    mainContent = /* @__PURE__ */ React6.createElement(
+    mainContent = /* @__PURE__ */ React7.createElement(
       FilterPanel,
       {
         allEntries,
@@ -2629,8 +3544,22 @@ ${entry.prompt}`;
         theme
       }
     );
+  } else if (providerPicking) {
+    mainContent = /* @__PURE__ */ React7.createElement(
+      ProviderPicker,
+      {
+        entry: providerPicking,
+        onPick: (tool, prompt) => {
+          onRerun?.(tool, prompt);
+          setProviderPicking(null);
+          exit();
+        },
+        onClose: () => setProviderPicking(null),
+        theme
+      }
+    );
   } else if (rerunning) {
-    mainContent = /* @__PURE__ */ React6.createElement(
+    mainContent = /* @__PURE__ */ React7.createElement(
       RerunView,
       {
         entry: rerunning,
@@ -2644,7 +3573,7 @@ ${entry.prompt}`;
       }
     );
   } else if (editing) {
-    mainContent = /* @__PURE__ */ React6.createElement(
+    mainContent = /* @__PURE__ */ React7.createElement(
       EditView,
       {
         entry: editing,
@@ -2654,7 +3583,7 @@ ${entry.prompt}`;
       }
     );
   } else if (detail && !isWide) {
-    mainContent = /* @__PURE__ */ React6.createElement(
+    mainContent = /* @__PURE__ */ React7.createElement(
       DetailView,
       {
         entry: detail,
@@ -2671,10 +3600,10 @@ ${entry.prompt}`;
   } else if (isWide) {
     const listFocused = focusPane === "list";
     const previewFocused = focusPane === "preview";
-    mainContent = /* @__PURE__ */ React6.createElement(Box4, { flexDirection: "row", flexGrow: 1 }, /* @__PURE__ */ React6.createElement(Box4, { flexDirection: "column", width: leftPaneWidth }, /* @__PURE__ */ React6.createElement(Box4, { paddingX: 1 }, /* @__PURE__ */ React6.createElement(Text5, { color: listFocused ? theme.primary : theme.dim, bold: listFocused }, listFocused ? "\u276F " : "  ", "HISTORY"), entries.length > 0 && /* @__PURE__ */ React6.createElement(Text5, { color: theme.dim }, "  ", cursor + 1, "/", entries.length)), entries.length === 0 ? /* @__PURE__ */ React6.createElement(Box4, { paddingX: 1 }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "(no results)")) : visible.map((entry, i) => {
+    mainContent = /* @__PURE__ */ React7.createElement(Box5, { flexDirection: "row", flexGrow: 1 }, /* @__PURE__ */ React7.createElement(Box5, { flexDirection: "column", width: leftPaneWidth }, /* @__PURE__ */ React7.createElement(Box5, { paddingX: 1 }, /* @__PURE__ */ React7.createElement(Text6, { color: listFocused ? theme.primary : theme.dim, bold: listFocused }, listFocused ? "\u276F " : "  ", "HISTORY"), entries.length > 0 && /* @__PURE__ */ React7.createElement(Text6, { color: theme.dim }, "  ", cursor + 1, "/", entries.length)), entries.length === 0 ? /* @__PURE__ */ React7.createElement(Box5, { paddingX: 1 }, /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, "(no results)")) : visible.map((entry, i) => {
       const absIdx = pageStart + i;
       const isNewSession = needsSessionSeparator(entries, absIdx);
-      return /* @__PURE__ */ React6.createElement(React6.Fragment, { key: entry.id }, isNewSession && /* @__PURE__ */ React6.createElement(Box4, null, /* @__PURE__ */ React6.createElement(Text5, { color: theme.dim }, "\u254C".repeat(2), " ", formatDateLabel(entry.timestamp), " ", "\u254C".repeat(leftPaneWidth - 4 - formatDateLabel(entry.timestamp).length))), /* @__PURE__ */ React6.createElement(
+      return /* @__PURE__ */ React7.createElement(React7.Fragment, { key: entry.id }, isNewSession && /* @__PURE__ */ React7.createElement(Box5, null, /* @__PURE__ */ React7.createElement(Text6, { color: theme.dim }, "\u254C".repeat(2), " ", formatDateLabel(entry.timestamp), " ", "\u254C".repeat(leftPaneWidth - 4 - formatDateLabel(entry.timestamp).length))), /* @__PURE__ */ React7.createElement(
         ListEntry,
         {
           entry,
@@ -2682,9 +3611,9 @@ ${entry.prompt}`;
           paneWidth: leftPaneWidth,
           theme
         }
-      ), i < visible.length - 1 && !needsSessionSeparator(entries, absIdx + 1) && /* @__PURE__ */ React6.createElement(Box4, null, /* @__PURE__ */ React6.createElement(Text5, { color: theme.dim }, "\xB7".repeat(Math.max(1, leftPaneWidth - 2)))));
-    })), /* @__PURE__ */ React6.createElement(
-      Box4,
+      ), i < visible.length - 1 && !needsSessionSeparator(entries, absIdx + 1) && /* @__PURE__ */ React7.createElement(Box5, null, /* @__PURE__ */ React7.createElement(Text6, { color: theme.dim }, "\xB7".repeat(Math.max(1, leftPaneWidth - 2)))));
+    })), /* @__PURE__ */ React7.createElement(
+      Box5,
       {
         borderLeft: true,
         borderStyle: "single",
@@ -2692,9 +3621,10 @@ ${entry.prompt}`;
         flexGrow: 1,
         flexDirection: "column"
       },
-      /* @__PURE__ */ React6.createElement(
+      /* @__PURE__ */ React7.createElement(
         PreviewPane,
         {
+          key: entries[cursor]?.id ?? "empty",
           entry: entries[cursor] ?? null,
           paneWidth: termWidth - leftPaneWidth - 1,
           paneHeight: termHeight - 3,
@@ -2705,10 +3635,10 @@ ${entry.prompt}`;
       )
     ));
   } else {
-    mainContent = /* @__PURE__ */ React6.createElement(Box4, { flexDirection: "column", paddingX: 1, flexGrow: 1 }, entries.length === 0 ? /* @__PURE__ */ React6.createElement(Box4, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text5, { color: theme.dim }, "(no results)")) : visible.map((entry, i) => {
+    mainContent = /* @__PURE__ */ React7.createElement(Box5, { flexDirection: "column", paddingX: 1, flexGrow: 1 }, entries.length === 0 ? /* @__PURE__ */ React7.createElement(Box5, { marginTop: 1 }, /* @__PURE__ */ React7.createElement(Text6, { color: theme.dim }, "(no results)")) : visible.map((entry, i) => {
       const absIdx = pageStart + i;
       const isNewSession = needsSessionSeparator(entries, absIdx);
-      return /* @__PURE__ */ React6.createElement(React6.Fragment, { key: entry.id }, isNewSession && /* @__PURE__ */ React6.createElement(Box4, null, /* @__PURE__ */ React6.createElement(Text5, { color: theme.dim }, "\u254C".repeat(2), " ", formatDateLabel(entry.timestamp), " ", "\u254C".repeat(termWidth - 4 - formatDateLabel(entry.timestamp).length))), /* @__PURE__ */ React6.createElement(
+      return /* @__PURE__ */ React7.createElement(React7.Fragment, { key: entry.id }, isNewSession && /* @__PURE__ */ React7.createElement(Box5, null, /* @__PURE__ */ React7.createElement(Text6, { color: theme.dim }, "\u254C".repeat(2), " ", formatDateLabel(entry.timestamp), " ", "\u254C".repeat(termWidth - 4 - formatDateLabel(entry.timestamp).length))), /* @__PURE__ */ React7.createElement(
         ListEntry,
         {
           entry,
@@ -2716,20 +3646,21 @@ ${entry.prompt}`;
           paneWidth: termWidth,
           theme
         }
-      ), i < visible.length - 1 && !needsSessionSeparator(entries, absIdx + 1) && /* @__PURE__ */ React6.createElement(Box4, null, /* @__PURE__ */ React6.createElement(Text5, { color: theme.dim }, "\xB7".repeat(Math.max(1, termWidth - 2)))));
+      ), i < visible.length - 1 && !needsSessionSeparator(entries, absIdx + 1) && /* @__PURE__ */ React7.createElement(Box5, null, /* @__PURE__ */ React7.createElement(Text6, { color: theme.dim }, "\xB7".repeat(Math.max(1, termWidth - 2)))));
     }));
   }
-  return /* @__PURE__ */ React6.createElement(Box4, { flexDirection: "column", height: termHeight }, /* @__PURE__ */ React6.createElement(
+  return /* @__PURE__ */ React7.createElement(Box5, { flexDirection: "column", height: termHeight }, /* @__PURE__ */ React7.createElement(
     Header,
     {
       entriesCount: entries.length,
       allEntriesCount: allEntries.length,
+      archiveCount,
       activeFilters,
       textFilter,
       isTextFiltering: false,
       theme: currentThemeName
     }
-  ), /* @__PURE__ */ React6.createElement(SearchBar, { value: textFilter, isActive: isTextFiltering, theme }), /* @__PURE__ */ React6.createElement(Box4, { flexGrow: 1 }, mainContent), /* @__PURE__ */ React6.createElement(
+  ), /* @__PURE__ */ React7.createElement(SearchBar, { value: textFilter, isActive: isTextFiltering, theme }), /* @__PURE__ */ React7.createElement(Box5, { flexGrow: 1 }, mainContent), /* @__PURE__ */ React7.createElement(
     Footer,
     {
       cursor,
@@ -2855,6 +3786,32 @@ function parseDate(s, label) {
 async function cmdSearch(db, cfg, args) {
   const { flags, positional } = parseFlags(args);
   const query = positional.join(" ");
+  if (flags["archive"]) {
+    const archiveResults = db.searchArchive({
+      since: flags["since"] ? new Date(flags["since"]).toISOString() : void 0,
+      until: flags["until"] ? new Date(flags["until"]).toISOString() : void 0,
+      limit: Number(flags["limit"] ?? 50)
+    });
+    if (archiveResults.length === 0) {
+      console.log("No archived prompts found.");
+      return;
+    }
+    console.log(`Found ${archiveResults.length} archived prompts:
+`);
+    for (const r of archiveResults) {
+      const date = new Date(r.timestamp).toLocaleString();
+      const id = r.original_id ?? r.id;
+      const prompt = r.prompt.replace(/\n/g, " ").slice(0, 120);
+      console.log(`  #${id} [${r.tool}] (${date})`);
+      console.log(`    ${prompt}${r.prompt.length > 120 ? "..." : ""}`);
+      if (r.response) {
+        const resp = r.response.replace(/\n/g, " ").slice(0, 80);
+        console.log(`    Response: ${resp}${r.response.length > 80 ? "..." : ""}`);
+      }
+      console.log();
+    }
+    return;
+  }
   if (flags["semantic"] && query) {
     await cmdSearchSemantic(db, cfg, query, Number(flags["limit"] ?? 50), Boolean(flags["full"]));
     return;
@@ -3034,8 +3991,8 @@ ${meta.git_context.diff}
 }
 
 // src/commands/import.ts
-import path7 from "path";
-import os7 from "os";
+import path8 from "path";
+import os8 from "os";
 
 // src/importer/gemini.ts
 import fs5 from "fs";
@@ -3043,6 +4000,7 @@ import path4 from "path";
 import os4 from "os";
 
 // src/analyzer/index.ts
+import { createHash as createHash3 } from "crypto";
 var ANALYSIS_PROMPT = (text) => `Analyze this AI tool prompt and response and return ONLY a JSON object with these exact fields:
 {
   "project": "<project name if clearly identifiable, else empty string>",
@@ -3152,7 +4110,7 @@ function mergeMetadata(existing, result, force) {
   if (!merged.tags?.length) delete merged.tags;
   return merged;
 }
-function parseMeta3(raw) {
+function parseMeta2(raw) {
   try {
     return JSON.parse(raw);
   } catch {
@@ -3160,20 +4118,28 @@ function parseMeta3(raw) {
   }
 }
 function hasMetadata(entry) {
-  const meta = parseMeta3(entry.metadata);
+  const meta = parseMeta2(entry.metadata);
   return Boolean(meta.role || meta.tags?.length || meta.project || meta.language);
 }
+function gitFingerprint(ctx) {
+  const hash = createHash3("sha256");
+  hash.update(ctx.branch);
+  hash.update(ctx.diff);
+  return `git:${hash.digest("hex").slice(0, 14)}`;
+}
 async function analyzeAll(entries, provider, db, opts = {}) {
   const { force = false, pruneBelow = 0, dryRun = false, onProgress, onPrune } = opts;
   const toProcess = force ? entries : entries.filter((e) => !hasMetadata(e));
   const stats = { updated: 0, skipped: entries.length - toProcess.length, failed: 0, pruned: 0 };
+  const gitCtx = captureGitContext(process.cwd());
+  const gitFp = gitCtx ? gitFingerprint(gitCtx) : void 0;
   for (let i = 0; i < toProcess.length; i++) {
     const entry = toProcess[i];
     let result = null;
     let errMsg;
     try {
       result = await analyzePrompt(entry.prompt, provider);
-      const existing = parseMeta3(entry.metadata);
+      const existing = parseMeta2(entry.metadata);
       const merged = mergeMetadata(existing, result, force);
       if (pruneBelow > 0 && result.relevance !== void 0 && result.relevance < pruneBelow) {
         onPrune?.(entry, result.relevance);
@@ -3184,11 +4150,25 @@ async function analyzeAll(entries, provider, db, opts = {}) {
       } else {
         db.updateMetadata(entry.id, JSON.stringify(merged));
         if (result.project && result.summary) {
+          if (gitFp) {
+            const lastMem = db.getLastMemoryForProject(result.project);
+            if (lastMem?.git_context_snapshot === gitFp) {
+              stats.updated++;
+              continue;
+            }
+          }
           db.upsertProjectMemory({
             project: result.project,
             prompt_id: entry.id,
             summary: result.summary,
             key_insights: result.key_insights ?? [],
+            technical_decisions: result.technical_decisions ?? [],
+            git_context_snapshot: gitFp
+          });
+          db.upsertProjectSummary({
+            project: result.project,
+            summary: result.summary,
+            key_insights: result.key_insights ?? [],
             technical_decisions: result.technical_decisions ?? []
           });
         }
@@ -3328,7 +4308,7 @@ async function importGeminiHistory(db, geminiDir, dryRun, analyzer, onProgress,
           if (response.length > 8e3) response = response.slice(0, 8e3) + "\n... (truncated)";
         }
         try {
-          const id = db.insert({
+          const id = db.insert(createCaptureRecord({
             timestamp: new Date(msg.timestamp).toISOString(),
             tool: "gemini",
             prompt: content,
@@ -3337,8 +4317,8 @@ async function importGeminiHistory(db, geminiDir, dryRun, analyzer, onProgress,
             workdir: inferWorkDir(filePath, geminiDir),
             hostname,
             exit_code: 0,
-            metadata
-          });
+            metadata: JSON.parse(metadata)
+          }));
           filter?.registerHash(content, id);
           result.promptsImported++;
         } catch (e) {
@@ -3496,7 +4476,7 @@ async function importClaudeHistory(db, claudeDir, dryRun, analyzer, onProgress,
         } catch {
         }
       }
-      const id = db.insert({
+      const id = db.insert(createCaptureRecord({
         timestamp: entry.timestamp,
         tool: "claude",
         prompt: entry.prompt,
@@ -3505,8 +4485,8 @@ async function importClaudeHistory(db, claudeDir, dryRun, analyzer, onProgress,
         workdir: entry.workdir,
         hostname,
         exit_code: 0,
-        metadata
-      });
+        metadata: JSON.parse(metadata)
+      }));
       filter?.registerHash(entry.prompt, id);
       result.promptsImported++;
     } catch (e) {
@@ -3679,7 +4659,7 @@ async function importOpenCodeHistory(db, opencodeDir, dryRun, analyzer, onProgre
           metadata.tokens = entry.tokens;
         }
       }
-      const id = db.insert({
+      const id = db.insert(createCaptureRecord({
         timestamp: entry.timestamp,
         tool: "opencode",
         prompt: entry.prompt,
@@ -3688,8 +4668,8 @@ async function importOpenCodeHistory(db, opencodeDir, dryRun, analyzer, onProgre
         workdir: entry.workdir,
         hostname,
         exit_code: 0,
-        metadata: Object.keys(metadata).length > 0 ? JSON.stringify(metadata) : "{}"
-      });
+        metadata
+      }));
       filter?.registerHash(entry.prompt, id);
       result.promptsImported++;
     } catch (e) {
@@ -3700,90 +4680,16 @@ async function importOpenCodeHistory(db, opencodeDir, dryRun, analyzer, onProgre
   return result;
 }
 
-// src/ai/ollama.ts
-var OllamaProvider = class {
-  constructor(url, model) {
-    this.url = url;
-    this.model = model;
-  }
-  name = "ollama";
-  async generate(prompt) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 6e4);
-    let res;
-    try {
-      res = await fetch(`${this.url}/api/generate`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ model: this.model, prompt, stream: false }),
-        signal: controller.signal
-      });
-    } catch (err) {
-      clearTimeout(timer);
-      const msg = err.message ?? String(err);
-      if (msg.includes("abort") || msg.includes("timeout")) {
-        throw new Error(`Ollama request timed out (60s). Is Ollama running at ${this.url}?`);
-      }
-      throw new Error(`Ollama unreachable at ${this.url}: ${msg}`);
-    } finally {
-      clearTimeout(timer);
-    }
-    if (!res.ok) {
-      const body = await res.text().catch(() => "");
-      throw new Error(`Ollama error ${res.status}: ${body}`);
-    }
-    const data = await res.json();
-    return data.response ?? "";
-  }
-};
-
-// src/ai/gemini.ts
-var GENERATE_API = "https://generativelanguage.googleapis.com/v1beta/models";
-async function generateContent(prompt, model, apiKey) {
-  const res = await fetch(`${GENERATE_API}/${model}:generateContent?key=${apiKey}`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      contents: [{ parts: [{ text: prompt }] }]
-    })
-  });
-  if (!res.ok) {
-    const err = await res.text();
-    throw new Error(`Gemini API error ${res.status}: ${err}`);
-  }
-  const data = await res.json();
-  return data.candidates[0]?.content?.parts[0]?.text ?? "";
-}
-var GeminiProvider = class {
-  constructor(model, apiKey) {
-    this.model = model;
-    this.apiKey = apiKey;
-  }
-  name = "gemini";
-  generate(prompt) {
-    return generateContent(prompt, this.model, this.apiKey);
-  }
-};
-
-// src/ai/provider.ts
-function getProvider(cfg) {
-  const provider = cfg.analyzeProvider ?? "ollama";
-  if (provider === "gemini") {
-    const apiKey = process.env.GEMINI_API_KEY ?? cfg.geminiApiKey;
-    if (!apiKey) return null;
-    return new GeminiProvider("gemini-2.5-flash", apiKey);
-  }
-  return new OllamaProvider(
-    cfg.ollamaUrl ?? "http://localhost:11434",
-    cfg.ollamaModel ?? "llama3.1:latest"
-  );
-}
+// src/importer/codex.ts
+import fs8 from "fs";
+import path7 from "path";
+import os7 from "os";
 
 // src/filter/index.ts
 import { createHash as createHash4 } from "crypto";
-var TRIVIAL_PATTERN = /^(yes|no|ok|okay|sure|thanks|thank you|continue|go on|next|exit|quit|stop|help|y|n|👍|👎|che dici\??|dimmi|vai|go|do it|tell me|vadi|procedi|aspetta|wait|[.!?,;:]+|\s*)$/i;
+var TRIVIAL_PATTERN = /^(yes|no|ok|okay|sure|thanks|thank you|continue|go on|next|exit|quit|stop|help|y|n|👍|👎|che dici\??|dimmi|vai|go|do it|tell me|vadi|procedi|grazie|aspetta|wait|[.!?,;:]+|\s*)$/i;
 var ORPHAN_CODE_PATTERN = /^([{}()[\]<>|&!=\-+*/%^~#@\\:;.,\s]+|\.\.\.|console\.log.*|print.*)$/i;
-var NON_PRINTABLE_PATTERN = /^[\x00-\x1f\x7f\x1b[\]()#;\d;A-Za-z]*$/;
+var NON_PRINTABLE_PATTERN = /^(?=.*[\x00-\x1f\x7f])[\x00-\x1f\x7f\x1b[\]()#;\d;A-Za-z]*$/;
 var FilterPipeline = class _FilterPipeline {
   minLength;
   minRelevance;
@@ -3856,11 +4762,209 @@ var FilterPipeline = class _FilterPipeline {
   }
 };
 
+// src/importer/codex.ts
+function textFromContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.flatMap((part) => {
+    if (!part || typeof part !== "object") return [];
+    const item = part;
+    return typeof item.text === "string" && ["output_text", "input_text", "text"].includes(String(item.type)) ? [item.text] : [];
+  }).join("");
+}
+function rolloutFiles(sessionsDir) {
+  if (!fs8.existsSync(sessionsDir)) return [];
+  const files = [];
+  const visit = (dir) => {
+    for (const entry of fs8.readdirSync(dir, { withFileTypes: true })) {
+      const full = path7.join(dir, entry.name);
+      if (entry.isDirectory()) visit(full);
+      else if (entry.isFile() && /^rollout-.*\.jsonl$/.test(entry.name)) files.push(full);
+    }
+  };
+  visit(sessionsDir);
+  return files;
+}
+async function importCodexHistory(db, codexDir, dryRun, analyzer, onProgress, filter, transcriptFile) {
+  const result = { filesScanned: 0, promptsFound: 0, promptsImported: 0, skipped: 0, filtered: 0, errors: [] };
+  const dedupFilter = filter ?? new FilterPipeline({ minLength: 0, minRelevance: 0, existingHashes: db.getAllPromptHashes() });
+  const files = transcriptFile ? [transcriptFile] : rolloutFiles(path7.join(codexDir, "sessions"));
+  result.filesScanned = files.length;
+  const hostname = os7.hostname();
+  const entries = [];
+  for (const file of files) {
+    let lines;
+    try {
+      lines = fs8.readFileSync(file, "utf8").split("\n");
+    } catch (error) {
+      result.errors.push(`read ${file}: ${error.message}`);
+      continue;
+    }
+    let workdir = "";
+    let sessionId = path7.basename(file, ".jsonl").replace(/^rollout-.*?-/, "");
+    const events = [];
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const event = JSON.parse(line);
+        events.push(event);
+        if (event.type === "session_meta" && event.payload) {
+          if (typeof event.payload.cwd === "string") workdir = event.payload.cwd;
+          if (typeof event.payload.id === "string") sessionId = event.payload.id;
+        }
+      } catch {
+      }
+    }
+    for (let i = 0; i < events.length; i++) {
+      const event = events[i];
+      const payload = event.payload ?? {};
+      const isUserMessage = event.type === "event_msg" && payload.type === "user_message" || event.type === "response_item" && payload.type === "message" && payload.role === "user";
+      const prompt = !isUserMessage ? "" : typeof payload.message === "string" ? payload.message.trim() : textFromContent(payload.content).trim();
+      if (!prompt) continue;
+      const agentMessages = [];
+      const assistantItems = [];
+      const finalAssistantItems = [];
+      for (let j = i + 1; j < events.length; j++) {
+        const candidate = events[j].payload ?? {};
+        const nextIsUserMessage = events[j].type === "event_msg" && candidate.type === "user_message" || events[j].type === "response_item" && candidate.type === "message" && candidate.role === "user";
+        if (nextIsUserMessage) break;
+        if (events[j].type === "event_msg" && candidate.type === "agent_message" && typeof candidate.message === "string") agentMessages.push(candidate.message);
+        if (events[j].type === "response_item" && candidate.type === "message" && candidate.role === "assistant") {
+          const text = textFromContent(candidate.content);
+          assistantItems.push(text);
+          if (candidate.phase === "final_answer") finalAssistantItems.push(text);
+        }
+      }
+      const response = agentMessages.length > 0 ? agentMessages.join("") : finalAssistantItems.length > 0 ? finalAssistantItems.join("") : assistantItems.join("");
+      entries.push({ prompt, response: response.slice(0, 8e3), timestamp: event.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString(), workdir, sessionId });
+    }
+  }
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    result.promptsFound++;
+    onProgress?.(i + 1, result.promptsImported, entries.length, entry.prompt.slice(0, 60));
+    if (dryRun) {
+      result.promptsImported++;
+      continue;
+    }
+    const rules = dedupFilter.checkRules(entry.prompt);
+    if (!rules.keep || !dedupFilter.checkDuplicate(entry.prompt).keep) {
+      result.filtered++;
+      continue;
+    }
+    try {
+      let metadata = {};
+      if (analyzer) {
+        try {
+          metadata = mergeMetadata({}, await analyzePrompt(entry.prompt, analyzer), false);
+        } catch {
+        }
+      }
+      const id = db.insert(createCaptureRecord({
+        timestamp: entry.timestamp,
+        tool: "codex",
+        prompt: entry.prompt,
+        response: entry.response,
+        args: entry.prompt,
+        workdir: entry.workdir,
+        hostname,
+        exit_code: 0,
+        metadata: { ...metadata }
+      }));
+      dedupFilter.registerHash(entry.prompt, id);
+      result.promptsImported++;
+    } catch (error) {
+      result.errors.push(`insert session ${entry.sessionId}: ${error.message}`);
+      result.skipped++;
+    }
+  }
+  return result;
+}
+
+// src/ai/ollama.ts
+var OllamaProvider = class {
+  constructor(url, model) {
+    this.url = url;
+    this.model = model;
+  }
+  name = "ollama";
+  async generate(prompt) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 6e4);
+    let res;
+    try {
+      res = await fetch(`${this.url}/api/generate`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ model: this.model, prompt, stream: false }),
+        signal: controller.signal
+      });
+    } catch (err) {
+      clearTimeout(timer);
+      const msg = err.message ?? String(err);
+      if (msg.includes("abort") || msg.includes("timeout")) {
+        throw new Error(`Ollama request timed out (60s). Is Ollama running at ${this.url}?`, { cause: err });
+      }
+      throw new Error(`Ollama unreachable at ${this.url}: ${msg}`, { cause: err });
+    } finally {
+      clearTimeout(timer);
+    }
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`Ollama error ${res.status}: ${body}`);
+    }
+    const data = await res.json();
+    return data.response ?? "";
+  }
+};
+
+// src/ai/gemini.ts
+var GENERATE_API = "https://generativelanguage.googleapis.com/v1beta/models";
+async function generateContent(prompt, model, apiKey) {
+  const res = await fetch(`${GENERATE_API}/${model}:generateContent?key=${apiKey}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      contents: [{ parts: [{ text: prompt }] }]
+    })
+  });
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`Gemini API error ${res.status}: ${err}`);
+  }
+  const data = await res.json();
+  return data.candidates[0]?.content?.parts[0]?.text ?? "";
+}
+var GeminiProvider = class {
+  constructor(model, apiKey) {
+    this.model = model;
+    this.apiKey = apiKey;
+  }
+  name = "gemini";
+  generate(prompt) {
+    return generateContent(prompt, this.model, this.apiKey);
+  }
+};
+
+// src/ai/provider.ts
+function getProvider(cfg) {
+  const provider = cfg.analyzeProvider ?? "ollama";
+  if (provider === "gemini") {
+    const apiKey = process.env.GEMINI_API_KEY ?? cfg.geminiApiKey;
+    if (!apiKey) return null;
+    return new GeminiProvider("gemini-2.5-flash", apiKey);
+  }
+  return new OllamaProvider(
+    cfg.ollamaUrl ?? "http://localhost:11434",
+    cfg.ollamaModel ?? "llama3.1:latest"
+  );
+}
+
 // src/commands/import.ts
 async function cmdImport(db, cfg, args) {
   if (args.length === 0) {
     process.stderr.write("Usage: ph import <source> [--dry-run] [--analyze]\n");
-    process.stderr.write("Supported sources: gemini, claude, opencode\n");
+    process.stderr.write("Supported sources: gemini, claude, opencode, codex\n");
     process.exit(1);
   }
   const source = args[0];
@@ -3868,7 +4972,8 @@ async function cmdImport(db, cfg, args) {
   const dryRun = Boolean(flags["dry-run"]);
   const analyze = Boolean(flags["analyze"]);
   const useFilter = Boolean(flags["filter"]);
-  const homeDir = os7.homedir();
+  const transcriptFile = typeof flags.file === "string" ? flags.file : void 0;
+  const homeDir = os8.homedir();
   if (dryRun) console.log("Dry run \u2014 nothing will be written to the database.");
   let analyzer;
   if (analyze) {
@@ -3903,16 +5008,19 @@ async function cmdImport(db, cfg, args) {
   let result;
   switch (source) {
     case "gemini":
-      result = await importGeminiHistory(db, path7.join(homeDir, ".gemini"), dryRun, analyzer, onProgress, filter);
+      result = await importGeminiHistory(db, path8.join(homeDir, ".gemini"), dryRun, analyzer, onProgress, filter);
       break;
     case "claude":
-      result = await importClaudeHistory(db, path7.join(homeDir, ".claude"), dryRun, analyzer, onProgress, filter);
+      result = await importClaudeHistory(db, path8.join(homeDir, ".claude"), dryRun, analyzer, onProgress, filter);
       break;
     case "opencode":
-      result = await importOpenCodeHistory(db, path7.join(homeDir, ".local", "share", "opencode", "storage"), dryRun, analyzer, onProgress, filter);
+      result = await importOpenCodeHistory(db, path8.join(homeDir, ".local", "share", "opencode", "storage"), dryRun, analyzer, onProgress, filter);
+      break;
+    case "codex":
+      result = await importCodexHistory(db, path8.join(homeDir, ".codex"), dryRun, analyzer, onProgress, filter, transcriptFile);
       break;
     default:
-      process.stderr.write(`ph: unknown import source "${source}". Supported: gemini, claude, opencode
+      process.stderr.write(`ph: unknown import source "${source}". Supported: gemini, claude, opencode, codex
 `);
       process.exit(1);
   }
@@ -4017,9 +5125,6 @@ ${e.response}` : e.prompt);
   console.log("\nDone!");
 }
 
-// src/commands/log.ts
-import os8 from "os";
-
 // src/background/analyzer.ts
 import { spawn as spawn3 } from "child_process";
 function spawnBackgroundAnalysis(id, dbPath) {
@@ -4072,32 +5177,16 @@ async function cmdLog(dbPath, cfg, args) {
       process.exit(1);
     }
   }
-  const { rootDir, projectName } = detectProject(workdir);
-  const language = detectLanguage(rootDir);
-  const metaObj = { $schema_version: 1 };
-  if (projectName) metaObj.project = projectName;
-  if (language) metaObj.language = language;
-  const title = extractTopic(prompt);
-  if (title) metaObj.title = title;
+  const record = createCaptureRecord({ tool, prompt, response, args: "", workdir });
   const db = new PhDB(dbPath);
-  const id = db.insert({
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    tool,
-    prompt,
-    response,
-    args: "",
-    workdir,
-    hostname: os8.hostname(),
-    exit_code: 0,
-    metadata: JSON.stringify(metaObj)
-  });
+  const id = db.insert(record);
   db.close();
   if (cfg.backgroundAnalysis) {
     spawnBackgroundAnalysis(id, dbPath);
   }
   const pushUrl = process.env.PH_REMOTE_URL || cfg.remoteUrl;
   if (pushUrl) {
-    pushToRemote(pushUrl, cfg.remoteApiKey, { timestamp: (/* @__PURE__ */ new Date()).toISOString(), tool, prompt, response, args: "", workdir, hostname: os8.hostname(), exit_code: 0, metadata: JSON.stringify(metaObj) }).catch(() => {
+    pushToRemote(pushUrl, cfg.remoteApiKey, record).catch(() => {
     });
   }
 }
@@ -4188,6 +5277,13 @@ function cmdConfig(args) {
 }
 
 // src/commands/background-analyze.ts
+import { createHash as createHash5 } from "crypto";
+function gitFingerprint2(ctx) {
+  const hash = createHash5("sha256");
+  hash.update(ctx.branch);
+  hash.update(ctx.diff);
+  return `git:${hash.digest("hex").slice(0, 14)}`;
+}
 async function cmdBackgroundAnalyze(dbPath, args) {
   const id = parseInt(args[0], 10);
   if (isNaN(id)) return;
@@ -4213,11 +5309,24 @@ async function cmdBackgroundAnalyze(dbPath, args) {
     const merged = mergeMetadata(existing, result, false);
     db.updateMetadata(id, JSON.stringify(merged));
     if (result.project && result.summary) {
+      const gitCtx = captureGitContext(process.cwd());
+      const gitFp = gitCtx ? gitFingerprint2(gitCtx) : void 0;
+      if (gitFp) {
+        const lastMem = db.getLastMemoryForProject(result.project);
+        if (lastMem?.git_context_snapshot === gitFp) return;
+      }
       db.upsertProjectMemory({
         project: result.project,
         prompt_id: id,
         summary: result.summary,
         key_insights: result.key_insights ?? [],
+        technical_decisions: result.technical_decisions ?? [],
+        git_context_snapshot: gitFp
+      });
+      db.upsertProjectSummary({
+        project: result.project,
+        summary: result.summary,
+        key_insights: result.key_insights ?? [],
         technical_decisions: result.technical_decisions ?? []
       });
     }
@@ -4231,6 +5340,11 @@ async function cmdBackgroundAnalyze(dbPath, args) {
 async function cmdCleanup(db, cfg, args) {
   const { flags } = parseFlags(args);
   const dryRun = Boolean(flags["dry-run"]);
+  const retention = Boolean(flags["retention"]);
+  if (retention) {
+    await runRetention(db, cfg, dryRun);
+    return;
+  }
   const minLength = flags["min-length"] ? Number(flags["min-length"]) : cfg.filterMinLength ?? 15;
   const minScore = flags["min-score"] ? Number(flags["min-score"]) : cfg.filterMinRelevance ?? 3;
   const days = flags["days"] ? Number(flags["days"]) : void 0;
@@ -4294,6 +5408,71 @@ Candidates for rule-based deletion: ${toDelete.length}`);
   console.log(`
 Deleted ${deleted} prompts.`);
 }
+async function runRetention(db, cfg, dryRun) {
+  const retentionDays = cfg.retentionDays ?? 90;
+  const minStarred = cfg.retentionMinStarred ?? true;
+  const minAnalyzed = cfg.retentionMinAnalyzed ?? true;
+  const minRelevance = cfg.retentionMinRelevance ?? 3;
+  const cutoff = /* @__PURE__ */ new Date();
+  cutoff.setDate(cutoff.getDate() - retentionDays);
+  const cutoffStr = cutoff.toISOString();
+  const allEntries = db.search({ limit: 1e5 });
+  const stats = db.getArchiveStats();
+  console.log(`Retention policy: ${retentionDays} days, minRelevance=${minRelevance}, keepStarred=${minStarred}, keepAnalyzed=${minAnalyzed}`);
+  console.log(`Archive: ${stats.total} entries (${stats.oldest ? `oldest ${stats.oldest}` : "empty"})`);
+  console.log(`Scanning ${allEntries.length} prompts...
+`);
+  const toArchive = [];
+  for (const entry of allEntries) {
+    let meta = {};
+    try {
+      meta = JSON.parse(entry.metadata);
+    } catch {
+    }
+    const age = entry.timestamp;
+    const isOld = age < cutoffStr;
+    const isStarred = meta.starred === true;
+    const isAnalyzed = Boolean(meta.summary || meta.role);
+    const relevance = meta.relevance ?? 5;
+    if (!isOld) continue;
+    if (relevance < minRelevance) {
+      toArchive.push({ id: entry.id, prompt: entry.prompt, reason: `low_relevance(${relevance})`, meta });
+      continue;
+    }
+    if (!(minStarred && isStarred) && !(minAnalyzed && isAnalyzed)) {
+      toArchive.push({ id: entry.id, prompt: entry.prompt, reason: `old(>${retentionDays}d)`, meta });
+    }
+  }
+  if (toArchive.length === 0) {
+    console.log("No prompts match retention criteria.");
+    return;
+  }
+  console.log(`Candidates for archiving: ${toArchive.length}`);
+  for (const item of toArchive.slice(0, 20)) {
+    const short = item.prompt.replace(/\n/g, " ").slice(0, 60);
+    const starred = item.meta.starred ? " *" : "";
+    const analyzed = item.meta.summary ? " [A]" : "";
+    console.log(`  #${String(item.id).padEnd(5)} [${item.reason}]${starred}${analyzed} "${short}"`);
+  }
+  if (toArchive.length > 20) {
+    console.log(`  ... and ${toArchive.length - 20} more`);
+  }
+  if (dryRun) {
+    console.log(`
+(dry-run) Would archive ${toArchive.length} prompts. Run without --dry-run to apply.`);
+    return;
+  }
+  const ids = toArchive.map((e) => e.id);
+  const archived = db.archivePrompts(ids);
+  console.log(`
+Archived ${archived} prompts.`);
+  const purgeCutoff = /* @__PURE__ */ new Date();
+  purgeCutoff.setDate(purgeCutoff.getDate() - retentionDays * 2);
+  const purged = db.purgeArchive(purgeCutoff.toISOString());
+  if (purged > 0) {
+    console.log(`Purged ${purged} archived entries older than ${retentionDays * 2} days.`);
+  }
+}
 
 // src/commands/vacuum.ts
 async function cmdVacuum(db) {
@@ -4317,75 +5496,20 @@ async function cmdContext(db, cfg, args) {
     process.stderr.write("ph: could not detect project. Use --project <name>\n");
     process.exit(1);
   }
-  const memories = !promptsOnly ? db.searchMemories(project, limit) : [];
-  let prompts = [];
-  if (!memoriesOnly) {
-    if (query) {
-      const ollamaUrl = cfg.ollamaUrl ?? "http://localhost:11434";
-      const model = cfg.ollamaEmbedModel ?? "nomic-embed-text-v2-moe";
-      const [queryVec] = await getEmbeddings([query], ollamaUrl, model, 1);
-      if (queryVec) {
-        const semResults = db.searchSemantic(queryVec, limit * 3);
-        prompts = semResults.filter((e) => {
-          try {
-            const meta = JSON.parse(e.metadata);
-            return meta.project === project;
-          } catch {
-            return false;
-          }
-        }).slice(0, limit);
-      }
-    } else {
-      prompts = db.getProjectMemory(project, limit);
-    }
-  }
-  if (memories.length === 0 && prompts.length === 0) {
-    process.stdout.write(`No relevant context found for project "${project}".
-`);
-    return;
-  }
-  const output = [];
-  if (memories.length > 0) {
-    output.push(`## Project Knowledge: ${project}
-`);
-    for (const mem of memories) {
-      if (mem.summary) output.push(`${mem.summary}
-`);
-      if (mem.key_insights.length > 0) {
-        output.push("Key Insights:");
-        for (const insight of mem.key_insights) output.push(`  - ${insight}`);
-        output.push("");
-      }
-      if (mem.technical_decisions.length > 0) {
-        output.push("Technical Decisions:");
-        for (const dec of mem.technical_decisions) output.push(`  - ${dec}`);
-        output.push("");
-      }
-    }
-  }
-  if (prompts.length > 0) {
-    output.push("---\n");
-    output.push(`## Recent Context
-`);
-    for (const e of prompts) {
-      let meta = {};
-      try {
-        meta = JSON.parse(e.metadata);
-      } catch {
-      }
-      output.push(`### #${e.id}`);
-      if (meta.role) output.push(`Role: ${meta.role}`);
-      if (meta.summary) output.push(`${meta.summary}`);
-      if (meta.key_insights && meta.key_insights.length > 0) {
-        for (const i of meta.key_insights) output.push(`  - ${i}`);
-      }
-      if (verbose) {
-        output.push("```\n" + e.prompt.slice(0, 1e3) + (e.prompt.length > 1e3 ? "\n..." : "") + "\n```");
-      }
-      output.push("");
-    }
-  }
-  process.stdout.write(output.join("\n"));
+  const ollamaUrl = cfg.ollamaUrl ?? "http://localhost:11434";
+  const model = cfg.ollamaEmbedModel ?? "nomic-embed-text-v2-moe";
+  const context = await getProjectContext(db, {
+    project,
+    query,
+    limit,
+    includeSummary: !promptsOnly,
+    includeMemories: !promptsOnly,
+    includePrompts: !memoriesOnly
+  }, async (text) => {
+    const [vector] = await getEmbeddings([text], ollamaUrl, model, 1);
+    return vector;
+  });
+  process.stdout.write(formatProjectContext(context, { includePromptText: verbose }) + "\n");
 }
 
 // src/sessions/index.ts
@@ -4440,42 +5564,100 @@ function computeSessionCohesion(session, embeddings) {
 }
 
 // src/commands/sessions.ts
+function formatTimestamp4(ts) {
+  const d = new Date(ts);
+  const Y = d.getFullYear();
+  const M = String(d.getMonth() + 1).padStart(2, "0");
+  const D = String(d.getDate()).padStart(2, "0");
+  const h = String(d.getHours()).padStart(2, "0");
+  const m = String(d.getMinutes()).padStart(2, "0");
+  return `${Y}-${M}-${D} ${h}:${m}`;
+}
+function fmtTime(ts) {
+  const d = new Date(ts);
+  const hh = String(d.getHours()).padStart(2, "0");
+  const mm = String(d.getMinutes()).padStart(2, "0");
+  return `${hh}:${mm}`;
+}
+function parseMeta3(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function exportSessionMarkdown(session) {
+  const lines = [];
+  const dateStr = formatTimestamp4(session.startTime.toISOString());
+  const endStr = fmtTime(session.endTime.toISOString());
+  lines.push(`# Session ${session.index} \u2014 ${dateStr} \u2192 ${endStr}`);
+  lines.push("");
+  lines.push(`**${session.entries.length} prompts**`);
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  for (const entry of session.entries) {
+    const meta = parseMeta3(entry.metadata);
+    const ts = formatTimestamp4(entry.timestamp);
+    const title = meta.title || entry.prompt.replace(/\n/g, " ").slice(0, 60);
+    lines.push(`## #${entry.id} \u2014 ${entry.tool} \u2014 ${ts}`);
+    if (title) lines.push(`**${title}**`);
+    lines.push("");
+    const metaLine = [];
+    if (meta.role) metaLine.push(`Role: ${meta.role}`);
+    if (meta.project) metaLine.push(`Project: ${meta.project}`);
+    if (meta.language) metaLine.push(`Language: ${meta.language}`);
+    if (meta.tags?.length) metaLine.push(`Tags: ${meta.tags.join(", ")}`);
+    if (meta.relevance !== void 0) metaLine.push(`Relevance: ${meta.relevance}/10`);
+    if (meta.quality !== void 0) metaLine.push(`Quality: ${meta.quality}/10`);
+    if (metaLine.length > 0) {
+      lines.push(metaLine.join(" \xB7 "));
+      lines.push("");
+    }
+    if (meta.summary) {
+      lines.push(`> ${meta.summary}`);
+      lines.push("");
+    }
+    lines.push("### Prompt");
+    lines.push("");
+    lines.push("```");
+    lines.push(entry.prompt);
+    lines.push("```");
+    lines.push("");
+    if (entry.response) {
+      lines.push("### Response");
+      lines.push("");
+      lines.push("```");
+      lines.push(entry.response.slice(0, 2e3));
+      lines.push("```");
+      lines.push("");
+    }
+    if (meta.key_insights?.length) {
+      lines.push("**Insights:**");
+      for (const ins of meta.key_insights) lines.push(`- ${ins}`);
+      lines.push("");
+    }
+    if (meta.git_context) {
+      lines.push(`*Git: ${meta.git_context.branch}, ${meta.git_context.files?.length || 0} files modified*`);
+      lines.push("");
+    }
+    lines.push("---");
+    lines.push("");
+  }
+  return lines.join("\n");
+}
 async function cmdSessions(db, args) {
   const { flags } = parseFlags(args);
   const gapHours = Number(flags["gap-hours"] ?? 2);
   const limit = Number(flags["limit"] ?? 20);
   const minSize = Number(flags["min-size"] ?? 1);
   const noCohesion = Boolean(flags["no-cohesion"]);
-  const C2 = {
-    reset: "\x1B[0m",
-    cyan: "\x1B[36m",
-    yellow: "\x1B[33m",
-    green: "\x1B[32m",
-    gray: "\x1B[90m",
-    red: "\x1B[31m",
-    blue: "\x1B[34m",
-    magenta: "\x1B[35m"
-  };
-  function fmtDate(ts) {
-    const d = new Date(ts);
-    const yr = d.getFullYear();
-    const mo = String(d.getMonth() + 1).padStart(2, "0");
-    const dy = String(d.getDate()).padStart(2, "0");
-    const hh = String(d.getHours()).padStart(2, "0");
-    const mm = String(d.getMinutes()).padStart(2, "0");
-    return `${yr}-${mo}-${dy} ${hh}:${mm}`;
-  }
-  function fmtTime(ts) {
-    const d = new Date(ts);
-    const hh = String(d.getHours()).padStart(2, "0");
-    const mm = String(d.getMinutes()).padStart(2, "0");
-    return `${hh}:${mm}`;
-  }
+  const exportIndex = flags["export"] !== void 0 ? Number(flags["export"]) : void 0;
   const allEntries = db.search({ limit: 1e5 });
   const entriesAsc = [...allEntries].reverse();
   const sessions = groupIntoSessions(entriesAsc, gapHours);
   let embeddings = null;
-  if (!noCohesion) {
+  if (!noCohesion && exportIndex === void 0) {
     embeddings = db.getAllEmbeddings();
   }
   for (const session of sessions) {
@@ -4483,21 +5665,37 @@ async function cmdSessions(db, args) {
       session.cohesion = computeSessionCohesion(session, embeddings);
     }
   }
+  if (exportIndex !== void 0) {
+    const session = sessions.find((s) => s.index === exportIndex);
+    if (!session) {
+      process.stderr.write(`Session ${exportIndex} not found.
+`);
+      return;
+    }
+    process.stdout.write(exportSessionMarkdown(session));
+    return;
+  }
   const filtered = sessions.filter((s) => s.entries.length >= minSize);
   const visible = filtered.slice(-limit);
   if (visible.length === 0) {
     process.stdout.write("No sessions found.\n");
     return;
   }
+  const C2 = {
+    reset: "\x1B[0m",
+    cyan: "\x1B[36m",
+    yellow: "\x1B[33m",
+    green: "\x1B[32m",
+    gray: "\x1B[90m",
+    red: "\x1B[31m",
+    blue: "\x1B[34m",
+    magenta: "\x1B[35m"
+  };
   for (const session of visible) {
     const projectCounts = /* @__PURE__ */ new Map();
     const languageCounts = /* @__PURE__ */ new Map();
     for (const entry of session.entries) {
-      let meta = {};
-      try {
-        meta = JSON.parse(entry.metadata);
-      } catch {
-      }
+      const meta = parseMeta3(entry.metadata);
       if (meta.project) projectCounts.set(meta.project, (projectCounts.get(meta.project) ?? 0) + 1);
       if (meta.language) languageCounts.set(meta.language, (languageCounts.get(meta.language) ?? 0) + 1);
     }
@@ -4516,7 +5714,7 @@ async function cmdSessions(db, args) {
         break;
       }
     }
-    const startStr = fmtDate(session.startTime.toISOString());
+    const startStr = formatTimestamp4(session.startTime.toISOString());
     const endStr = fmtTime(session.endTime.toISOString());
     const promptWord = session.entries.length === 1 ? "prompt" : "prompts";
     let header = `${C2.cyan}Session ${session.index}${C2.reset}`;
@@ -4534,11 +5732,7 @@ async function cmdSessions(db, args) {
     }
     process.stdout.write(header + "\n");
     for (const entry of session.entries) {
-      let meta = {};
-      try {
-        meta = JSON.parse(entry.metadata);
-      } catch {
-      }
+      const meta = parseMeta3(entry.metadata);
       const idStr = `${C2.cyan}#${entry.id}${C2.reset}`;
       const toolStr = `${C2.yellow}${entry.tool.padEnd(8)}${C2.reset}`;
       const timeStr = `${C2.gray}${fmtTime(entry.timestamp)}${C2.reset}`;
@@ -4749,7 +5943,7 @@ ${C2.cyan}Cluster #${i + 1}${C2.reset} (${C2.yellow}${cluster.entryIds.length} p
 }
 
 // src/commands/analyze-reusability.ts
-import fs8 from "fs";
+import fs9 from "fs";
 
 // src/analyzer/reusability.ts
 var ReusabilityAnalyzer = class _ReusabilityAnalyzer {
@@ -4934,7 +6128,7 @@ ${C2.bold}TOP 10 REMOVE (low score + duplicate):${C2.reset}`);
     console.log(`  [${C2.red}${scoreStr}${C2.reset}] ${s.prompt.replace(/\n/g, " ").slice(0, 80)}...`);
   });
   if (exportCsv) {
-    fs8.writeFileSync(exportCsv, analyzer.toCSV(report));
+    fs9.writeFileSync(exportCsv, analyzer.toCSV(report));
     console.log(`
 ${C2.green}\u2705 Report exported to ${exportCsv}${C2.reset}`);
   }
@@ -4942,7 +6136,7 @@ ${C2.green}\u2705 Report exported to ${exportCsv}${C2.reset}`);
 }
 
 // src/commands/cleanup-reusability.ts
-import fs9 from "fs";
+import fs10 from "fs";
 async function cmdCleanupReusability(db, _cfg, args) {
   const { flags } = parseFlags(args);
   const threshold = flags["threshold"] ? parseFloat(flags["threshold"]) : 0.7;
@@ -5004,7 +6198,7 @@ Run with ${C2.bold}--force${C2.reset} or without ${C2.bold}--dry-run${C2.reset}
     process.stdout.write(`
 Continue and delete ${candidates.length} prompts? (y/N) `);
     const buffer = Buffer.alloc(16);
-    const bytesRead = fs9.readSync(0, buffer, 0, 16);
+    const bytesRead = fs10.readSync(0, buffer, 0, 16, null);
     const answer = buffer.toString("utf8", 0, bytesRead).trim().toLowerCase();
     if (answer !== "y" && answer !== "yes") {
       console.log("Aborted.");
@@ -5022,8 +6216,137 @@ Deleted ${deleted} prompts, freed ~${(totalToFree / 1024 / 1024).toFixed(1)} MB`
   console.log("Database vacuumed.");
 }
 
+// src/commands/timeline.ts
+async function cmdTimeline(db, cfg, args) {
+  const { flags, positional } = parseFlags(args);
+  const project = flags["project"] || positional.join(" ") || detectProject(process.cwd()).projectName;
+  if (!project) {
+    process.stderr.write("ph: could not detect project. Use --project <name> or pass a project name.\n");
+    process.exit(1);
+  }
+  const prompts = db.getAllPromptsByProject(project);
+  const memories = db.getAllMemoriesByProject(project);
+  if (prompts.length === 0 && memories.length === 0) {
+    process.stdout.write(`No history found for project "${project}".
+`);
+    return;
+  }
+  const output = [];
+  output.push(`# Timeline: ${project}
+`);
+  output.push(`**${prompts.length} prompts** \xB7 **${memories.length} memory entries**
+`);
+  const events = [
+    ...prompts.map((p) => ({ type: "prompt", timestamp: p.timestamp, prompt: p })),
+    ...memories.map((m) => ({ type: "memory", timestamp: m.created_at, memory: m }))
+  ];
+  events.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+  let currentDate = "";
+  for (const event of events) {
+    const date = new Date(event.timestamp).toLocaleDateString("en-CA");
+    if (date !== currentDate) {
+      currentDate = date;
+      output.push(`
+## ${date}
+`);
+    }
+    if (event.type === "prompt" && event.prompt) {
+      output.push(formatPromptEntry(event.prompt));
+    }
+    if (event.type === "memory" && event.memory) {
+      output.push(formatMemoryEntry(event.memory));
+    }
+  }
+  process.stdout.write(output.join("\n"));
+}
+function formatPromptEntry(e) {
+  let meta = {};
+  try {
+    meta = JSON.parse(e.metadata);
+  } catch {
+  }
+  const time = new Date(e.timestamp).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+  const lines = [];
+  lines.push(`### #${e.id} \u2014 ${e.tool} \u2014 ${time}`);
+  if (meta.role) lines.push(`**Role**: ${meta.role}`);
+  if (meta.title) lines.push(`**Title**: ${meta.title}`);
+  if (meta.tags?.length) lines.push(`**Tags**: ${meta.tags.join(", ")}`);
+  if (meta.summary) lines.push(`**Summary**: ${meta.summary}`);
+  if (meta.relevance !== void 0) lines.push(`**Relevance**: ${meta.relevance}/10`);
+  lines.push("");
+  lines.push("**Prompt**:");
+  lines.push("```");
+  lines.push(e.prompt.slice(0, 500) + (e.prompt.length > 500 ? "\n..." : ""));
+  lines.push("```");
+  if (e.response) {
+    lines.push("");
+    lines.push("**Response**:");
+    lines.push("```");
+    lines.push(e.response.slice(0, 300) + (e.response.length > 300 ? "\n..." : ""));
+    lines.push("```");
+  }
+  if (meta.key_insights?.length) {
+    lines.push("");
+    lines.push("**Insights**:");
+    for (const i of meta.key_insights) lines.push(`- ${i}`);
+  }
+  lines.push("---\n");
+  return lines.join("\n");
+}
+function formatMemoryEntry(m) {
+  const time = new Date(m.created_at).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+  const lines = [];
+  lines.push(`> \u{1F4CC} **Memory #${m.id} \u2014 ${time}**`);
+  if (m.prompt_ids.length > 0) {
+    lines.push(`> _Derived from prompts: #${m.prompt_ids.join(", #")}_`);
+  }
+  if (m.summary) lines.push(`> **Summary**: ${m.summary}`);
+  if (m.key_insights.length > 0) {
+    lines.push(`> **Insights**:`);
+    for (const i of m.key_insights) lines.push(`> - ${i}`);
+  }
+  if (m.technical_decisions.length > 0) {
+    lines.push(`> **Technical Decisions**:`);
+    for (const d of m.technical_decisions) lines.push(`> - ${d}`);
+  }
+  lines.push("---\n");
+  return lines.join("\n");
+}
+
+// src/commands/memory-migrate.ts
+function cmdMemoryMigrate(db) {
+  const projects = db.getAllProjectsWithMemories();
+  if (projects.length === 0) {
+    console.log("No memories found. Nothing to migrate.");
+    return;
+  }
+  let count = 0;
+  for (const project of projects) {
+    const memories = db.searchMemories(project, 1e3);
+    const allInsights = /* @__PURE__ */ new Set();
+    const allDecisions = /* @__PURE__ */ new Set();
+    let lastSummary = "";
+    let gitCtx;
+    for (const mem of memories) {
+      if (mem.summary) lastSummary = mem.summary;
+      for (const i of mem.key_insights) allInsights.add(i);
+      for (const d of mem.technical_decisions) allDecisions.add(d);
+      if (mem.git_context_snapshot) gitCtx = mem.git_context_snapshot;
+    }
+    db.upsertProjectSummary({
+      project,
+      summary: lastSummary,
+      key_insights: [...allInsights],
+      technical_decisions: [...allDecisions],
+      git_context_snapshot: gitCtx
+    });
+    count++;
+  }
+  console.log(`Migrated ${count} project(s) into project_summaries.`);
+}
+
 // src/commands/wrap.ts
-import path8 from "path";
+import path9 from "path";
 import os9 from "os";
 async function cmdWrap(dbPath, tool, args, cfg) {
   let debugLog;
@@ -5032,7 +6355,7 @@ async function cmdWrap(dbPath, tool, args, cfg) {
   const cleanArgs = [];
   for (let i = 0; i < args.length; i++) {
     if (args[i] === "--ph-debug") {
-      debugLog = path8.join(os9.homedir(), ".ph_debug.log");
+      debugLog = path9.join(os9.homedir(), ".ph_debug.log");
       process.stderr.write(`ph: debug log \u2192 ${debugLog}
 `);
     } else if (args[i] === "--ph-tag" && i + 1 < args.length) {
@@ -5061,28 +6384,17 @@ async function cmdWrap(dbPath, tool, args, cfg) {
   const db = new PhDB(dbPath);
   if (interactive) {
     const workdir = process.cwd();
-    const { rootDir, projectName } = detectProject(workdir);
-    const language = detectLanguage(rootDir);
     const gitContext = captureGitContext(workdir);
     const onPrompt = (prompt, ts) => {
-      const metaObj = { $schema_version: 1 };
-      if (projectName) metaObj.project = projectName;
-      if (language) metaObj.language = language;
-      if (role) metaObj.role = role;
-      if (tags.length > 0) metaObj.tags = tags;
-      if (gitContext) metaObj.git_context = gitContext;
-      const metadata = Object.keys(metaObj).length > 0 ? JSON.stringify(metaObj) : "{}";
-      return db.insert({
+      return db.insert(createCaptureRecord({
         timestamp: ts.toISOString(),
         tool,
         prompt,
-        response: "",
         args: prompt,
         workdir,
-        hostname: os9.hostname(),
-        exit_code: 0,
-        metadata
-      });
+        gitContext,
+        metadata: { ...role ? { role } : {}, ...tags.length > 0 ? { tags } : {} }
+      }));
     };
     const onResponse = (id, response) => {
       if (!response.trim()) return;
@@ -5122,41 +6434,14 @@ async function cmdChat(dbPath, cfg, args) {
     process.exit(1);
   }
   const db = new PhDB(dbPath);
-  const memories = db.searchMemories(project, 3);
-  const recentPrompts = db.getProjectMemory(project, 5);
-  const contextParts = [];
-  if (memories.length > 0) {
-    contextParts.push(`## Project Knowledge: ${project}`);
-    for (const mem of memories) {
-      if (mem.summary) contextParts.push(`
-${mem.summary}`);
-      if (mem.key_insights.length > 0) {
-        contextParts.push("\nKey Insights:");
-        for (const i of mem.key_insights) contextParts.push(`  - ${i}`);
-      }
-      if (mem.technical_decisions.length > 0) {
-        contextParts.push("\nTechnical Decisions:");
-        for (const d of mem.technical_decisions) contextParts.push(`  - ${d}`);
-      }
-    }
-  }
-  if (recentPrompts.length > 0) {
-    contextParts.push(`
----
-## Recent Context`);
-    for (const p of recentPrompts) {
-      let meta = {};
-      try {
-        meta = JSON.parse(p.metadata);
-      } catch {
-      }
-      const summary = meta.summary || p.prompt.slice(0, 100).replace(/\n/g, " ");
-      contextParts.push(`
-- #${p.id}: ${summary}`);
-    }
-  }
+  const ollamaUrl = cfg.ollamaUrl ?? "http://localhost:11434";
+  const model = cfg.ollamaEmbedModel ?? "nomic-embed-text-v2-moe";
+  const context = await getProjectContext(db, { project, limit: 5, memoryLimit: 3 }, async (query) => {
+    const [vector] = await getEmbeddings([query], ollamaUrl, model, 1);
+    return vector;
+  });
   db.close();
-  const contextStr = contextParts.join("\n");
+  const contextStr = formatProjectContext(context);
   const fullPrompt = `Context from project "${project}":
 
 ${contextStr}
@@ -5185,13 +6470,16 @@ USAGE:
   ph analyze-reusability [options]      Analyze prompt reusability
   ph star <id>                          Toggle star on a prompt
   ph export <id> [--format txt|json|md] Export a single prompt
-  ph import gemini [--dry-run] [--analyze] [--filter]  Import from Gemini CLI sessions
-  ph import claude [--dry-run] [--analyze] [--filter]  Import from Claude CLI sessions
+  ph import <source> [--dry-run] [--analyze] [--filter] [--file <path>]
+                                                Import from Gemini, Claude, OpenCode, or Codex history
   ph analyze [--limit n] [--force] [--prune] [--dry-run]  Analyze prompts with LLM
   ph mcp                                Start MCP server (Stdio)
   ph server [--port 3001]               Start HTTP REST server for remote sync
+  ph timeline [project]                 Show full project history with prompts and memories
+  ph memory-migrate                      Merge existing memories into project_summaries
   ph remote push|pull|status            Sync prompts with remote ph server
   ph cleanup [--dry-run] [--min-length N] [--min-score N]  Remove useless prompts
+  ph cleanup --retention [--dry-run]          Archive prompts per retention policy
   ph cleanup-reusability [--dry-run] [--threshold 0.7] [--force]  Cleanup based on reusability
   ph embed-all                          Generate embeddings for all prompts
   ph log --tool <name> --prompt <text> [--response <text>]  Log a prompt+response directly
@@ -5205,7 +6493,7 @@ WRAP FLAGS (placed before the tool name):
 
 SEARCH OPTIONS:
   -i, --interactive   Open results in interactive TUI browser
-  --tool <name>       Filter by tool name (claude, gemini, \u2026)
+  --tool <name>       Filter by tool name (claude, gemini, opencode, codex, \u2026)
   --project <name>    Filter by project name
   --language <lang>   Filter by language (go, typescript, python, \u2026)
   --role <role>       Filter by role (debug, refactor, explain, \u2026)
@@ -5215,6 +6503,7 @@ SEARCH OPTIONS:
   --min-relevance <n> Filter by min relevance (0-10)
   --top               Show only top quality prompts (quality >= 8)
   --semantic          Use semantic search (requires embeddings)
+  --archive           Search archived prompts
   --since YYYY-MM-DD
   --until YYYY-MM-DD
   --limit <n>         Max results (default 50)
@@ -5232,6 +6521,7 @@ SESSIONS OPTIONS:
   --limit <n>         Max sessions to show (default 20)
   --min-size <n>      Minimum prompts per session (default 1)
   --no-cohesion       Skip semantic cohesion computation
+  --export <n>        Export session N as markdown
 
 CLUSTER OPTIONS:
   -k <number>         Number of clusters (default 5)
@@ -5268,6 +6558,31 @@ EXAMPLES:
   ph config set ollama-model llama3.2:latest
   ph ollama-models                          List models available on the local Ollama instance
 `;
+async function openBrowser(db, opts = {}) {
+  let pendingRerun = null;
+  process.stdout.write("\x1B[?1049h");
+  try {
+    const { waitUntilExit } = render(
+      React8.createElement(BrowseApp, {
+        db,
+        ...opts,
+        onRerun: (tool, prompt) => {
+          pendingRerun = { tool, prompt };
+        }
+      })
+    );
+    await waitUntilExit();
+  } finally {
+    process.stdout.write("\x1B[?1049l");
+  }
+  return pendingRerun;
+}
+function runRerun(rerun) {
+  if (!rerun) return;
+  const realBin = resolveRealBinary(rerun.tool);
+  const child = spawnSync2(realBin, [rerun.prompt], { stdio: "inherit" });
+  process.exit(child.status ?? 0);
+}
 async function main() {
   const argv = process.argv.slice(2);
   const cfg = load();
@@ -5278,28 +6593,9 @@ async function main() {
   if (argv.length === 0) {
     if (isTerminal()) {
       const db = new PhDB(dbPath);
-      process.stdout.write("\x1B[?1049h");
-      let pendingRerun = null;
-      try {
-        const { waitUntilExit } = render(
-          React7.createElement(BrowseApp, {
-            db,
-            onRerun: (tool, prompt) => {
-              pendingRerun = { tool, prompt };
-            }
-          })
-        );
-        await waitUntilExit();
-      } finally {
-        process.stdout.write("\x1B[?1049l");
-        db.close();
-      }
-      if (pendingRerun) {
-        const { tool, prompt } = pendingRerun;
-        const realBin = resolveRealBinary(tool);
-        const child = spawnSync2(realBin, [prompt], { stdio: "inherit" });
-        process.exit(child.status ?? 0);
-      }
+      const rerun = await openBrowser(db);
+      db.close();
+      runRerun(rerun);
       process.exit(0);
     } else {
       process.stdout.write(USAGE);
@@ -5328,39 +6624,21 @@ async function main() {
       const query = positional.join(" ");
       if (flags["i"] || flags["interactive"]) {
         const db2 = new PhDB(dbPath);
-        process.stdout.write("\x1B[?1049h");
-        let pendingRerun = null;
-        try {
-          const { waitUntilExit } = render(
-            React7.createElement(BrowseApp, {
-              db: db2,
-              initialTextFilter: query,
-              initialFilters: {
-                tool: flags["tool"],
-                project: flags["project"],
-                language: flags["language"],
-                role: flags["role"],
-                tag: flags["tag"],
-                starred: Boolean(flags["starred"]),
-                minQuality: flags["top"] ? 8 : flags["min-quality"] ? Number(flags["min-quality"]) : void 0,
-                minRelevance: flags["min-relevance"] ? Number(flags["min-relevance"]) : void 0
-              },
-              onRerun: (tool, prompt) => {
-                pendingRerun = { tool, prompt };
-              }
-            })
-          );
-          await waitUntilExit();
-        } finally {
-          process.stdout.write("\x1B[?1049l");
-          db2.close();
-        }
-        if (pendingRerun) {
-          const { tool, prompt } = pendingRerun;
-          const realBin = resolveRealBinary(tool);
-          const child = spawnSync2(realBin, [prompt], { stdio: "inherit" });
-          process.exit(child.status ?? 0);
-        }
+        const rerun = await openBrowser(db2, {
+          initialTextFilter: query,
+          initialFilters: {
+            tool: flags["tool"],
+            project: flags["project"],
+            language: flags["language"],
+            role: flags["role"],
+            tag: flags["tag"],
+            starred: Boolean(flags["starred"]),
+            minQuality: flags["top"] ? 8 : flags["min-quality"] ? Number(flags["min-quality"]) : void 0,
+            minRelevance: flags["min-relevance"] ? Number(flags["min-relevance"]) : void 0
+          }
+        });
+        db2.close();
+        runRerun(rerun);
         break;
       }
       const db = new PhDB(dbPath);
@@ -5434,6 +6712,12 @@ async function main() {
       db.close();
       break;
     }
+    case "memory-migrate": {
+      const db = new PhDB(dbPath);
+      cmdMemoryMigrate(db);
+      db.close();
+      break;
+    }
     case "mcp": {
       await runMCPServer();
       break;
@@ -5480,34 +6764,21 @@ async function main() {
     }
     case "browse": {
       const db = new PhDB(dbPath);
-      process.stdout.write("\x1B[?1049h");
-      let pendingRerun = null;
-      try {
-        const { waitUntilExit } = render(
-          React7.createElement(BrowseApp, {
-            db,
-            onRerun: (tool, prompt) => {
-              pendingRerun = { tool, prompt };
-            }
-          })
-        );
-        await waitUntilExit();
-      } finally {
-        process.stdout.write("\x1B[?1049l");
-        db.close();
-      }
-      if (pendingRerun) {
-        const { tool, prompt } = pendingRerun;
-        const realBin = resolveRealBinary(tool);
-        const child = spawnSync2(realBin, [prompt], { stdio: "inherit" });
-        process.exit(child.status ?? 0);
-      }
+      const rerun = await openBrowser(db);
+      db.close();
+      runRerun(rerun);
       break;
     }
     case "chat": {
       await cmdChat(dbPath, cfg, cmdArgs);
       break;
     }
+    case "timeline": {
+      const db = new PhDB(dbPath);
+      await cmdTimeline(db, cfg, cmdArgs);
+      db.close();
+      break;
+    }
     case "ollama-models": {
       const ollamaUrl = cfg.ollamaUrl ?? "http://localhost:11434";
       try {