@gi4nks/ph 1.3.2

package/dist/cli.js

@@ -0,0 +1,3885 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import os6 from "os";
+import path6 from "path";
+import fs7 from "fs";
+import { spawnSync } from "child_process";
+import React7 from "react";
+import { render } from "ink";
+
+// src/config/index.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+var CONFIG_PATH = path.join(os.homedir(), ".ph_config.json");
+function load() {
+  try {
+    if (fs.existsSync(CONFIG_PATH)) {
+      return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
+    }
+  } catch (_) {
+  }
+  return {};
+}
+function save(cfg) {
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2), { mode: 384 });
+}
+
+// src/db/index.ts
+import Database from "better-sqlite3";
+import path2 from "path";
+import os2 from "os";
+import { createHash } from "crypto";
+function defaultPath() {
+  return path2.join(os2.homedir(), ".prompt_history.db");
+}
+var PhDB = class {
+  db;
+  constructor(dbPath) {
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.migrate();
+  }
+  migrate() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS prompts (
+        id        INTEGER PRIMARY KEY AUTOINCREMENT,
+        timestamp TEXT    NOT NULL,
+        tool      TEXT    NOT NULL,
+        prompt    TEXT    NOT NULL,
+        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 '{}'
+      );
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS prompts_fts USING fts5(
+        prompt,
+        tool UNINDEXED,
+        content='prompts',
+        content_rowid='id'
+      );
+
+      CREATE TRIGGER IF NOT EXISTS prompts_ai AFTER INSERT ON prompts BEGIN
+        INSERT INTO prompts_fts(rowid, prompt, tool) VALUES (new.id, new.prompt, new.tool);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS prompts_ad AFTER DELETE ON prompts BEGIN
+        INSERT INTO prompts_fts(prompts_fts, rowid, prompt, tool)
+          VALUES('delete', old.id, old.prompt, old.tool);
+      END;
+
+      CREATE INDEX IF NOT EXISTS idx_prompts_tool      ON prompts(tool);
+      CREATE INDEX IF NOT EXISTS idx_prompts_timestamp ON prompts(timestamp);
+
+      CREATE TABLE IF NOT EXISTS embeddings (
+        prompt_id INTEGER PRIMARY KEY,
+        vector    BLOB    NOT NULL,
+        FOREIGN KEY(prompt_id) REFERENCES prompts(id) ON DELETE CASCADE
+      );
+    `);
+    try {
+      this.db.exec("ALTER TABLE prompts ADD COLUMN metadata TEXT NOT NULL DEFAULT '{}'");
+    } catch {
+    }
+    try {
+      this.db.exec("ALTER TABLE prompts ADD COLUMN response TEXT NOT NULL DEFAULT ''");
+    } catch {
+    }
+    const ftsRow = this.db.prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='prompts_fts'").get();
+    if (!ftsRow?.sql?.includes("response")) {
+      this.db.exec(`
+        DROP TABLE IF EXISTS prompts_fts;
+        DROP TRIGGER IF EXISTS prompts_ai;
+        DROP TRIGGER IF EXISTS prompts_ad;
+
+        CREATE VIRTUAL TABLE prompts_fts USING fts5(
+          prompt,
+          response,
+          tool UNINDEXED,
+          content='prompts',
+          content_rowid='id'
+        );
+
+        CREATE TRIGGER prompts_ai AFTER INSERT ON prompts BEGIN
+          INSERT INTO prompts_fts(rowid, prompt, response, tool)
+            VALUES (new.id, new.prompt, new.response, new.tool);
+        END;
+
+        CREATE TRIGGER prompts_ad AFTER DELETE ON prompts BEGIN
+          INSERT INTO prompts_fts(prompts_fts, rowid, prompt, response, tool)
+            VALUES('delete', old.id, old.prompt, old.response, old.tool);
+        END;
+
+        INSERT INTO prompts_fts(prompts_fts) VALUES('rebuild');
+      `);
+    }
+  }
+  insert(entry) {
+    const meta = entry.metadata || "{}";
+    const response = entry.response ?? "";
+    const info = this.db.prepare(
+      `INSERT INTO prompts (timestamp, tool, prompt, response, args, workdir, hostname, exit_code, metadata)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      entry.timestamp,
+      entry.tool,
+      entry.prompt,
+      response,
+      entry.args,
+      entry.workdir,
+      entry.hostname,
+      entry.exit_code,
+      meta
+    );
+    return info.lastInsertRowid;
+  }
+  updateExitCode(id, code) {
+    this.db.prepare("UPDATE prompts SET exit_code = ? WHERE id = ?").run(code, id);
+  }
+  updateMetadata(id, metadata) {
+    this.db.prepare("UPDATE prompts SET metadata = ? WHERE id = ?").run(metadata, id);
+  }
+  updateResponse(id, response) {
+    this.db.prepare("UPDATE prompts SET response = ? WHERE id = ?").run(response, id);
+  }
+  getById(id) {
+    return this.db.prepare("SELECT * FROM prompts WHERE id = ?").get(id);
+  }
+  search(opts) {
+    const ftsArgs = [];
+    const ftsFilters = [];
+    const scanArgs = [];
+    const scanFilters = [];
+    if (opts.tool) {
+      ftsFilters.push("p.tool = ?");
+      ftsArgs.push(opts.tool);
+      scanFilters.push("tool = ?");
+      scanArgs.push(opts.tool);
+    }
+    if (opts.project) {
+      ftsFilters.push("json_extract(p.metadata, '$.project') = ?");
+      ftsArgs.push(opts.project);
+      scanFilters.push("json_extract(metadata, '$.project') = ?");
+      scanArgs.push(opts.project);
+    }
+    if (opts.language) {
+      ftsFilters.push("json_extract(p.metadata, '$.language') = ?");
+      ftsArgs.push(opts.language);
+      scanFilters.push("json_extract(metadata, '$.language') = ?");
+      scanArgs.push(opts.language);
+    }
+    if (opts.role) {
+      ftsFilters.push("json_extract(p.metadata, '$.role') = ?");
+      ftsArgs.push(opts.role);
+      scanFilters.push("json_extract(metadata, '$.role') = ?");
+      scanArgs.push(opts.role);
+    }
+    if (opts.tag) {
+      ftsFilters.push("json_extract(p.metadata, '$.tags') LIKE ?");
+      ftsArgs.push(`%"${opts.tag}"%`);
+      scanFilters.push("json_extract(metadata, '$.tags') LIKE ?");
+      scanArgs.push(`%"${opts.tag}"%`);
+    }
+    if (opts.starred) {
+      ftsFilters.push("json_extract(p.metadata, '$.starred') = 1");
+      scanFilters.push("json_extract(metadata, '$.starred') = 1");
+    }
+    if (opts.minQuality !== void 0) {
+      ftsFilters.push("json_extract(p.metadata, '$.quality') >= ?");
+      ftsArgs.push(opts.minQuality);
+      scanFilters.push("json_extract(metadata, '$.quality') >= ?");
+      scanArgs.push(opts.minQuality);
+    }
+    if (opts.minRelevance !== void 0) {
+      ftsFilters.push("json_extract(p.metadata, '$.relevance') >= ?");
+      ftsArgs.push(opts.minRelevance);
+      scanFilters.push("json_extract(metadata, '$.relevance') >= ?");
+      scanArgs.push(opts.minRelevance);
+    }
+    if (opts.since) {
+      ftsFilters.push("p.timestamp >= ?");
+      ftsArgs.push(opts.since.toISOString());
+      scanFilters.push("timestamp >= ?");
+      scanArgs.push(opts.since.toISOString());
+    }
+    if (opts.until) {
+      ftsFilters.push("p.timestamp <= ?");
+      ftsArgs.push(opts.until.toISOString());
+      scanFilters.push("timestamp <= ?");
+      scanArgs.push(opts.until.toISOString());
+    }
+    if (opts.query) {
+      const sanitized = `"${opts.query.replace(/"/g, '""')}"`;
+      const filterClause = ftsFilters.length > 0 ? " AND " + ftsFilters.join(" AND ") : "";
+      const sql = `
+        SELECT p.*
+        FROM prompts_fts f
+        JOIN prompts p ON p.id = f.rowid
+        WHERE prompts_fts MATCH ?${filterClause}
+        ORDER BY p.timestamp DESC
+        LIMIT ?
+      `;
+      return this.db.prepare(sql).all(sanitized, ...ftsArgs, opts.limit);
+    } else {
+      const filterClause = scanFilters.length > 0 ? " AND " + scanFilters.join(" AND ") : "";
+      const sql = `
+        SELECT * FROM prompts
+        WHERE 1=1${filterClause}
+        ORDER BY timestamp DESC
+        LIMIT ?
+      `;
+      return this.db.prepare(sql).all(...scanArgs, opts.limit);
+    }
+  }
+  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);
+  }
+  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;
+  }
+  getPromptsWithoutEmbeddings() {
+    return this.db.prepare(
+      `SELECT p.* FROM prompts p
+         LEFT JOIN embeddings e ON e.prompt_id = p.id
+         WHERE e.prompt_id IS NULL`
+    ).all();
+  }
+  getAllPrompts(limit = 1e6) {
+    return this.db.prepare("SELECT * FROM prompts ORDER BY timestamp DESC LIMIT ?").all(limit);
+  }
+  getPromptsByRole(role) {
+    return this.db.prepare("SELECT * FROM prompts WHERE json_extract(metadata, '$.role') = ? ORDER BY timestamp DESC").all(role);
+  }
+  delete(id) {
+    this.db.prepare("DELETE FROM prompts WHERE id = ?").run(id);
+  }
+  deleteById(id) {
+    this.delete(id);
+  }
+  deleteByIds(ids) {
+    if (ids.length === 0) return 0;
+    const placeholders = ids.map(() => "?").join(",");
+    const info = this.db.prepare(`DELETE FROM prompts WHERE id IN (${placeholders})`).run(...ids);
+    return info.changes;
+  }
+  deleteOlderThan(days) {
+    const info = this.db.prepare("DELETE FROM prompts WHERE timestamp < datetime('now', ?)").run(`-${days} days`);
+    return info.changes;
+  }
+  vacuum() {
+    this.db.exec("VACUUM");
+  }
+  getAllPromptHashes() {
+    const rows = this.db.prepare("SELECT id, prompt FROM prompts").all();
+    const map = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const hash = createHash("sha256").update(row.prompt.trim().toLowerCase()).digest("hex");
+      map.set(hash, row.id);
+    }
+    return map;
+  }
+  close() {
+    this.db.close();
+  }
+};
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) return 0;
+  let dot = 0, normA = 0, normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  if (normA === 0 || normB === 0) return 0;
+  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+
+// src/runner/inline.ts
+import { spawn, execFileSync as execFileSync2 } from "child_process";
+import fs3 from "fs";
+import os3 from "os";
+
+// src/runner/project.ts
+import fs2 from "fs";
+import path3 from "path";
+var PROJECT_MARKERS = [
+  ".git",
+  "go.mod",
+  "package.json",
+  "Cargo.toml",
+  "Makefile",
+  "pyproject.toml",
+  "requirements.txt"
+];
+var LANGUAGE_MAP = {
+  "go.mod": "go",
+  "package.json": "javascript",
+  "Cargo.toml": "rust",
+  "pyproject.toml": "python",
+  "requirements.txt": "python",
+  "Makefile": "make",
+  "composer.json": "php",
+  "Gemfile": "ruby"
+};
+function detectProject(startDir) {
+  let curr = path3.resolve(startDir);
+  while (true) {
+    for (const marker of PROJECT_MARKERS) {
+      if (fs2.existsSync(path3.join(curr, marker))) {
+        return { rootDir: curr, projectName: path3.basename(curr) };
+      }
+    }
+    const parent = path3.dirname(curr);
+    if (parent === curr) break;
+    curr = parent;
+  }
+  return { rootDir: "", projectName: "" };
+}
+function detectLanguage(rootDir) {
+  if (!rootDir) return "";
+  for (const [marker, lang] of Object.entries(LANGUAGE_MAP)) {
+    if (fs2.existsSync(path3.join(rootDir, marker))) return lang;
+  }
+  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)";
+    }
+    return { branch, files, diff };
+  } catch {
+    return null;
+  }
+}
+
+// src/runner/inline.ts
+function extractPrompt(args) {
+  for (let i = args.length - 1; i >= 0; i--) {
+    if (!args[i].startsWith("-")) return args[i];
+  }
+  return args.join(" ");
+}
+function resolveRealBinary(tool) {
+  let found;
+  try {
+    found = execFileSync2("which", [tool], { encoding: "utf-8" }).trim();
+  } catch {
+    throw new Error(`command not found: ${tool}`);
+  }
+  const realFound = fs3.realpathSync(found);
+  const selfPath = fs3.realpathSync(process.execPath);
+  const scriptPath = process.argv[1] ? fs3.realpathSync(process.argv[1]) : "";
+  if (realFound === selfPath || realFound === scriptPath) {
+    throw new Error(
+      `resolved to ph itself \u2014 would loop. Place ph AFTER the real ${tool} in $PATH`
+    );
+  }
+  return realFound;
+}
+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(),
+    tool,
+    prompt: extractPrompt(args),
+    args: args.join(" "),
+    workdir,
+    hostname: os3.hostname(),
+    exit_code: 0,
+    metadata
+  });
+  if (onInserted) onInserted(id);
+  const child = spawn(realBin, args, { stdio: "inherit" });
+  child.on("error", (err) => {
+    process.stderr.write(`ph: spawn error: ${err.message}
+`);
+    process.exit(1);
+  });
+  child.on("exit", (code, signal) => {
+    const exitCode = code ?? (signal ? 1 : 0);
+    if (id > 0) db.updateExitCode(id, exitCode);
+    process.exit(exitCode);
+  });
+}
+
+// src/pty/wrapper.ts
+import pty from "@lydell/node-pty";
+import fs4 from "fs";
+function cleanLine(bytes) {
+  const s = Buffer.from(bytes).toString("utf-8");
+  return s.trim();
+}
+function stripAnsi(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) {
+  let dbgStream = null;
+  if (debugLog) {
+    dbgStream = fs4.createWriteStream(debugLog, { flags: "a" });
+    dbgStream.write(`
+=== session start: ${binary} ${args.join(" ")} @ ${(/* @__PURE__ */ new Date()).toISOString()} ===
+`);
+  }
+  const log = (msg) => {
+    if (dbgStream) dbgStream.write(`[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
+`);
+  };
+  const cols = process.stdout.columns || 80;
+  const rows = process.stdout.rows || 24;
+  const ptyProcess = pty.spawn(binary, args, {
+    name: "xterm-256color",
+    cols,
+    rows,
+    cwd: process.cwd(),
+    env: process.env
+  });
+  let currentPromptId = null;
+  let responseBuffer = "";
+  ptyProcess.onData((data) => {
+    process.stdout.write(data);
+    if (currentPromptId !== null) {
+      responseBuffer += data;
+    }
+  });
+  const onResize = () => {
+    ptyProcess.resize(process.stdout.columns || 80, process.stdout.rows || 24);
+  };
+  process.stdout.on("resize", onResize);
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+  process.stdin.resume();
+  let lineBuffer = [];
+  let escState = "NORMAL";
+  const onData = (chunk) => {
+    for (let i = 0; i < chunk.length; i++) {
+      const b = chunk[i];
+      ptyProcess.write(String.fromCharCode(b));
+      switch (escState) {
+        case "NORMAL":
+          if (b === 13 || b === 10) {
+            const prompt = cleanLine(lineBuffer);
+            log(`ENTER \u2192 prompt: ${JSON.stringify(prompt)}`);
+            if (prompt) {
+              if (currentPromptId !== null) {
+                onResponse(currentPromptId, stripAnsi(responseBuffer));
+              }
+              currentPromptId = onPrompt(prompt, /* @__PURE__ */ new Date());
+              responseBuffer = "";
+            }
+            lineBuffer = [];
+          } else if (b === 127 || b === 8) {
+            if (lineBuffer.length > 0) lineBuffer.pop();
+          } else if (b === 3 || b === 4) {
+            lineBuffer = [];
+          } else if (b === 27) {
+            escState = "ESC";
+          } else if (b >= 32) {
+            lineBuffer.push(b);
+          }
+          break;
+        case "ESC":
+          if (b === 91) {
+            escState = "CSI";
+          } else if (b === 93 || b === 80 || b === 95 || b === 94 || b === 88) {
+            escState = "OSC";
+          } else {
+            escState = "NORMAL";
+          }
+          break;
+        case "CSI":
+          if (b >= 65 && b <= 90 || b >= 97 && b <= 122 || b === 126) {
+            escState = "NORMAL";
+          }
+          break;
+        case "OSC":
+          if (b === 7) {
+            escState = "NORMAL";
+          } else if (b === 27) {
+            escState = "ESC";
+          }
+          break;
+      }
+    }
+  };
+  process.stdin.on("data", onData);
+  return new Promise((resolve) => {
+    ptyProcess.onExit(({ exitCode }) => {
+      if (currentPromptId !== null) {
+        onResponse(currentPromptId, stripAnsi(responseBuffer));
+      }
+      process.stdin.removeListener("data", onData);
+      process.stdout.removeListener("resize", onResize);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+      if (dbgStream) {
+        dbgStream.write(`=== session end exitCode=${exitCode} ===
+`);
+        dbgStream.end();
+      }
+      resolve(exitCode);
+    });
+  });
+}
+function isTerminal() {
+  return Boolean(process.stdin.isTTY);
+}
+
+// src/display/print.ts
+var C = {
+  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 truncatePrompt(s, max = 120) {
+  const flat = s.replace(/\n/g, " ");
+  if (flat.length > max) return flat.slice(0, max) + "\u2026";
+  return flat;
+}
+function formatTimestamp(ts) {
+  try {
+    const d = new Date(ts);
+    const pad = (n) => String(n).padStart(2, "0");
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+  } catch {
+    return ts;
+  }
+}
+function printResults(entries, showFull) {
+  if (entries.length === 0) {
+    console.log("No results found.");
+    return;
+  }
+  console.log(`${C.yellow}${entries.length} result(s)${C.reset}
+`);
+  for (const e of entries) {
+    printEntry(e, showFull);
+  }
+}
+function printEntry(e, showFull) {
+  let meta = {};
+  try {
+    meta = JSON.parse(e.metadata);
+  } catch (_) {
+  }
+  const exitColor = e.exit_code === 0 ? C.green : C.red;
+  const starStr = meta.starred ? `${C.yellow}\u2605${C.reset} ` : "";
+  let projectStr = "";
+  if (meta.project && meta.language) {
+    projectStr = `${C.blue}[${meta.project}:${meta.language}]${C.reset} `;
+  } else if (meta.project) {
+    projectStr = `${C.blue}[${meta.project}]${C.reset} `;
+  } else if (meta.language) {
+    projectStr = `${C.blue}[${meta.language}]${C.reset} `;
+  }
+  const roleStr = meta.role ? `${C.magenta}{${meta.role}}${C.reset} ` : "";
+  let tagsStr = "";
+  if (meta.tags && meta.tags.length > 0) {
+    tagsStr = `${C.cyan}(${meta.tags.join(",")})${C.reset} `;
+  }
+  process.stdout.write(
+    `${C.cyan}#${String(e.id).padEnd(4)}${C.reset}  ${starStr}${C.yellow}${e.tool.padEnd(8)}${C.reset}  ${C.gray}${formatTimestamp(e.timestamp)}${C.reset}  ${projectStr}${roleStr}${tagsStr}${exitColor}[exit:${e.exit_code}]${C.reset}
+`
+  );
+  if (e.workdir) {
+    process.stdout.write(`       ${C.gray}${e.workdir}${C.reset}
+`);
+  }
+  let prompt = e.prompt;
+  if (!showFull) {
+    prompt = truncatePrompt(prompt);
+  }
+  prompt = prompt.replace(/\n/g, "\n       ");
+  process.stdout.write(`       ${prompt}
+
+`);
+}
+
+// src/importer/gemini.ts
+import fs5 from "fs";
+import path4 from "path";
+import os4 from "os";
+
+// src/analyzer/index.ts
+var ANALYSIS_PROMPT = (text) => `Analyze this AI tool prompt and return ONLY a JSON object with these exact fields:
+{
+  "project": "<project name if clearly identifiable, else empty string>",
+  "language": "<programming language if identifiable, else empty string>",
+  "role": "<ONE of: debug, refactor, explain, review, architect, test, docs, generate, research \u2014 or empty string>",
+  "tags": ["<tag1>", "<tag2>"],
+  "relevance": <integer 0-10>,
+  "quality": <integer 0-10>
+}
+
+Rules:
+- tags: 1-3 short lowercase words describing what the prompt is about
+- role: pick the single best match, or "" if none fits
+- project/language: only fill if clearly inferrable from the prompt text
+- relevance: how informative/useful is this prompt for future reference?
+  0=completely useless (single word, greeting, yes/no), 5=average technical question, 10=highly detailed technical question
+- quality: how well-structured is the prompt?
+  0=messy/vague, 5=clear but simple, 10=professional prompt engineering (context, instructions, examples, constraints)
+- Return ONLY the JSON object \u2014 no markdown fences, no explanation, no other text
+
+Prompt to analyze:
+"""
+${text.slice(0, 1500)}
+"""`;
+function parseAnalysisResponse(raw) {
+  let cleaned = raw.replace(/```(?:json)?\s*/gi, "").replace(/```/g, "").trim();
+  const start = cleaned.indexOf("{");
+  const end = cleaned.lastIndexOf("}");
+  if (start === -1 || end === -1) return {};
+  cleaned = cleaned.slice(start, end + 1);
+  let parsed;
+  try {
+    parsed = JSON.parse(cleaned);
+  } catch {
+    return {};
+  }
+  const result = {};
+  if (typeof parsed["project"] === "string" && parsed["project"].trim()) {
+    result.project = parsed["project"].trim();
+  }
+  if (typeof parsed["language"] === "string" && parsed["language"].trim()) {
+    result.language = parsed["language"].trim().toLowerCase();
+  }
+  if (typeof parsed["role"] === "string" && parsed["role"].trim()) {
+    const validRoles = ["debug", "refactor", "explain", "review", "architect", "test", "docs", "generate", "research"];
+    const role = parsed["role"].trim().toLowerCase();
+    if (validRoles.includes(role)) result.role = role;
+  }
+  if (Array.isArray(parsed["tags"])) {
+    const tags = parsed["tags"].filter((t) => typeof t === "string" && t.trim().length > 0).map((t) => t.trim().toLowerCase()).slice(0, 5);
+    if (tags.length > 0) result.tags = tags;
+  }
+  if (typeof parsed["relevance"] === "number") {
+    result.relevance = Math.max(0, Math.min(10, Math.round(parsed["relevance"])));
+  }
+  if (typeof parsed["quality"] === "number") {
+    result.quality = Math.max(0, Math.min(10, Math.round(parsed["quality"])));
+  }
+  return result;
+}
+async function analyzePrompt(text, provider) {
+  try {
+    const raw = await provider.generate(ANALYSIS_PROMPT(text));
+    return parseAnalysisResponse(raw);
+  } catch {
+    return {};
+  }
+}
+function mergeMetadata(existing, result, force) {
+  const merged = { ...existing };
+  if (force || !merged.project) merged.project = result.project || merged.project;
+  if (force || !merged.language) merged.language = result.language || merged.language;
+  if (force || !merged.role) merged.role = result.role || merged.role;
+  if (force || !merged.tags?.length) merged.tags = result.tags ?? merged.tags;
+  if (result.relevance !== void 0 && (force || merged.relevance === void 0)) {
+    merged.relevance = result.relevance;
+  }
+  if (result.quality !== void 0 && (force || merged.quality === void 0)) {
+    merged.quality = result.quality;
+  }
+  if (!merged.project) delete merged.project;
+  if (!merged.language) delete merged.language;
+  if (!merged.role) delete merged.role;
+  if (!merged.tags?.length) delete merged.tags;
+  return merged;
+}
+function parseMeta(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function hasMetadata(entry) {
+  const meta = parseMeta(entry.metadata);
+  return Boolean(meta.role || meta.tags?.length || meta.project || meta.language);
+}
+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 };
+  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 = parseMeta(entry.metadata);
+      const merged = mergeMetadata(existing, result, force);
+      if (pruneBelow > 0 && result.relevance !== void 0 && result.relevance < pruneBelow) {
+        onPrune?.(entry, result.relevance);
+        if (!dryRun) {
+          db.deleteById(entry.id);
+        }
+        stats.pruned++;
+      } else {
+        db.updateMetadata(entry.id, JSON.stringify(merged));
+        stats.updated++;
+      }
+    } catch (e) {
+      errMsg = e.message;
+      stats.failed++;
+    }
+    onProgress?.(i + 1, toProcess.length, entry, result, errMsg);
+  }
+  return stats;
+}
+
+// src/importer/gemini.ts
+function getContent(msg) {
+  if (typeof msg.content === "string") return msg.content;
+  if (Array.isArray(msg.content)) {
+    return msg.content.map((c) => c.text || "").join("");
+  }
+  return "";
+}
+function findSessionFiles(tmpDir) {
+  const files = [];
+  if (!fs5.existsSync(tmpDir)) return files;
+  try {
+    const hashes = fs5.readdirSync(tmpDir);
+    for (const hash of hashes) {
+      const chatsDir = path4.join(tmpDir, hash, "chats");
+      if (!fs5.existsSync(chatsDir)) continue;
+      const sessions = fs5.readdirSync(chatsDir).filter(
+        (f) => f.startsWith("session-") && f.endsWith(".json")
+      );
+      for (const s of sessions) {
+        files.push(path4.join(chatsDir, s));
+      }
+    }
+  } catch (_) {
+  }
+  return files;
+}
+function inferWorkDir(sessionPath, geminiDir) {
+  const tmpDir = path4.join(geminiDir, "tmp");
+  const rel = path4.relative(tmpDir, sessionPath);
+  const parts = rel.split(path4.sep);
+  if (parts.length > 0) {
+    const hash = parts[0];
+    const historyDir = path4.join(geminiDir, "history", hash);
+    if (fs5.existsSync(path4.join(historyDir, ".git"))) {
+      return historyDir;
+    }
+  }
+  return "";
+}
+async function importGeminiHistory(db, geminiDir, dryRun, analyzer, onProgress, filter) {
+  const result = {
+    filesScanned: 0,
+    promptsFound: 0,
+    promptsImported: 0,
+    skipped: 0,
+    filtered: 0,
+    errors: []
+  };
+  const files = findSessionFiles(path4.join(geminiDir, "tmp"));
+  result.filesScanned = files.length;
+  const hostname = os4.hostname();
+  let totalPromptsToEvaluate = 0;
+  for (const filePath of files) {
+    try {
+      const raw = fs5.readFileSync(filePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      const messages = Array.isArray(parsed) ? parsed : parsed.messages || [];
+      totalPromptsToEvaluate += messages.filter((m) => (m.type === "human" || m.type === "user") && getContent(m) !== "").length;
+    } catch {
+    }
+  }
+  let promptsEvaluated = 0;
+  for (const filePath of files) {
+    try {
+      const raw = fs5.readFileSync(filePath, "utf-8");
+      let messages;
+      try {
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed)) {
+          messages = parsed;
+        } else {
+          messages = parsed.messages || [];
+        }
+      } catch {
+        result.errors.push(`${filePath}: JSON parse error`);
+        continue;
+      }
+      for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        if (!((msg.type === "human" || msg.type === "user") && getContent(msg) !== "")) continue;
+        result.promptsFound++;
+        promptsEvaluated++;
+        const content = getContent(msg);
+        onProgress?.(promptsEvaluated, result.promptsImported, totalPromptsToEvaluate, content.slice(0, 60));
+        if (dryRun) {
+          result.promptsImported++;
+          continue;
+        }
+        if (filter) {
+          const preCheck = filter.checkRules(content);
+          if (!preCheck.keep) {
+            result.filtered++;
+            continue;
+          }
+          const dupCheck = filter.checkDuplicate(content);
+          if (!dupCheck.keep) {
+            result.filtered++;
+            continue;
+          }
+        }
+        let metadata = "{}";
+        let analysis;
+        if (analyzer) {
+          try {
+            analysis = await analyzePrompt(content, analyzer);
+            if (filter && analysis) {
+              const relCheck = filter.checkRelevance(analysis);
+              if (!relCheck.keep) {
+                result.filtered++;
+                continue;
+              }
+            }
+            const merged = mergeMetadata({}, analysis, false);
+            if (Object.keys(merged).length > 0) metadata = JSON.stringify(merged);
+          } catch {
+          }
+        }
+        let response = "";
+        const nextMsg = messages[i + 1];
+        if (nextMsg && (nextMsg.type === "model" || nextMsg.type === "assistant")) {
+          response = getContent(nextMsg);
+          if (response.length > 8e3) response = response.slice(0, 8e3) + "\n... (truncated)";
+        }
+        try {
+          const id = db.insert({
+            timestamp: new Date(msg.timestamp).toISOString(),
+            tool: "gemini",
+            prompt: content,
+            response,
+            args: content,
+            workdir: inferWorkDir(filePath, geminiDir),
+            hostname,
+            exit_code: 0,
+            metadata
+          });
+          filter?.registerHash(content, id);
+          result.promptsImported++;
+        } catch (e) {
+          result.errors.push(`insert ${msg.id || "?"}: ${e.message}`);
+          result.skipped++;
+        }
+      }
+    } catch (e) {
+      result.errors.push(`${filePath}: ${e.message}`);
+    }
+  }
+  return result;
+}
+
+// src/importer/claude.ts
+import fs6 from "fs";
+import path5 from "path";
+import os5 from "os";
+var MAX_RESPONSE_LENGTH = 8e3;
+var TRUNCATION_SUFFIX = "\n... (truncated)";
+function slugToPath(slug) {
+  return slug.replace(/-/g, "/");
+}
+function extractAssistantText(parts) {
+  return parts.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join("");
+}
+function truncateResponse(text) {
+  if (text.length <= MAX_RESPONSE_LENGTH) return text;
+  return text.slice(0, MAX_RESPONSE_LENGTH - TRUNCATION_SUFFIX.length) + TRUNCATION_SUFFIX;
+}
+function parseTranscriptFile(filePath, errors) {
+  let raw;
+  try {
+    raw = fs6.readFileSync(filePath, "utf8");
+  } catch (e) {
+    errors.push(`read ${filePath}: ${e.message}`);
+    return [];
+  }
+  const messages = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      messages.push(JSON.parse(trimmed));
+    } catch {
+    }
+  }
+  return messages;
+}
+function findTranscriptFiles(claudeDir) {
+  const projectsDir = path5.join(claudeDir, "projects");
+  const result = [];
+  if (!fs6.existsSync(projectsDir)) return result;
+  let projectEntries;
+  try {
+    projectEntries = fs6.readdirSync(projectsDir, { withFileTypes: true });
+  } catch {
+    return result;
+  }
+  for (const entry of projectEntries) {
+    if (!entry.isDirectory()) continue;
+    const projectSlug = entry.name;
+    const projectDir = path5.join(projectsDir, projectSlug);
+    let sessionEntries;
+    try {
+      sessionEntries = fs6.readdirSync(projectDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const sessionEntry of sessionEntries) {
+      if (!sessionEntry.isFile() || !sessionEntry.name.endsWith(".jsonl")) continue;
+      result.push({
+        filePath: path5.join(projectDir, sessionEntry.name),
+        projectSlug
+      });
+    }
+  }
+  return result;
+}
+async function importClaudeHistory(db, claudeDir, dryRun, analyzer, onProgress, filter) {
+  const result = {
+    filesScanned: 0,
+    promptsFound: 0,
+    promptsImported: 0,
+    skipped: 0,
+    filtered: 0,
+    errors: []
+  };
+  const transcriptFiles = findTranscriptFiles(claudeDir);
+  result.filesScanned = transcriptFiles.length;
+  if (transcriptFiles.length === 0) return result;
+  const hostname = os5.hostname();
+  const pendingEntries = [];
+  for (const { filePath, projectSlug } of transcriptFiles) {
+    const messages = parseTranscriptFile(filePath, result.errors);
+    const workdir = slugToPath(projectSlug);
+    const sessionId = path5.basename(filePath, ".jsonl");
+    for (let i = 0; i < messages.length; i++) {
+      const msg = messages[i];
+      if (msg.type !== "user") continue;
+      const userMsg = msg;
+      const prompt = typeof userMsg.content === "string" ? userMsg.content.trim() : "";
+      if (!prompt) continue;
+      let response = "";
+      if (i + 1 < messages.length && messages[i + 1].type === "assistant") {
+        const assistantMsg = messages[i + 1];
+        const rawText = extractAssistantText(assistantMsg.content ?? []);
+        response = truncateResponse(rawText);
+      }
+      pendingEntries.push({
+        prompt,
+        response,
+        timestamp: userMsg.timestamp,
+        workdir,
+        sessionId
+      });
+    }
+  }
+  const totalPromptsToEvaluate = pendingEntries.length;
+  let promptsEvaluated = 0;
+  for (const entry of pendingEntries) {
+    promptsEvaluated++;
+    result.promptsFound++;
+    onProgress?.(promptsEvaluated, result.promptsImported, totalPromptsToEvaluate, entry.prompt.slice(0, 60));
+    if (dryRun) {
+      result.promptsImported++;
+      continue;
+    }
+    if (filter) {
+      const preCheck = filter.checkRules(entry.prompt);
+      if (!preCheck.keep) {
+        result.filtered++;
+        continue;
+      }
+      const dupCheck = filter.checkDuplicate(entry.prompt);
+      if (!dupCheck.keep) {
+        result.filtered++;
+        continue;
+      }
+    }
+    try {
+      let metadata = "{}";
+      if (analyzer) {
+        try {
+          const analysis = await analyzePrompt(entry.prompt, analyzer);
+          if (filter && analysis) {
+            const relCheck = filter.checkRelevance(analysis);
+            if (!relCheck.keep) {
+              result.filtered++;
+              continue;
+            }
+          }
+          const merged = mergeMetadata({}, analysis, false);
+          if (Object.keys(merged).length > 0) metadata = JSON.stringify(merged);
+        } catch {
+        }
+      }
+      const id = db.insert({
+        timestamp: entry.timestamp,
+        tool: "claude",
+        prompt: entry.prompt,
+        response: entry.response,
+        args: entry.prompt,
+        workdir: entry.workdir,
+        hostname,
+        exit_code: 0,
+        metadata
+      });
+      filter?.registerHash(entry.prompt, id);
+      result.promptsImported++;
+    } catch (e) {
+      result.errors.push(
+        `insert session ${entry.sessionId}: ${e.message}`
+      );
+      result.skipped++;
+    }
+  }
+  return result;
+}
+
+// src/embedding/index.ts
+async function getEmbeddings(texts, ollamaUrl, model, batchSize = 20) {
+  const results = [];
+  for (let i = 0; i < texts.length; i += batchSize) {
+    const batch = texts.slice(i, i + batchSize);
+    const res = await fetch(`${ollamaUrl}/api/embed`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model, input: batch })
+    });
+    if (!res.ok) {
+      const err = await res.text();
+      throw new Error(`Ollama embed error ${res.status}: ${err}`);
+    }
+    const data = await res.json();
+    for (const vec of data.embeddings) {
+      results.push(new Float32Array(vec));
+    }
+  }
+  return results;
+}
+
+// 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/analyzer/reusability.ts
+var ReusabilityAnalyzer = class _ReusabilityAnalyzer {
+  threshold;
+  constructor(threshold = 0.7) {
+    this.threshold = threshold;
+  }
+  analyze(entries, embeddings) {
+    const scores = entries.map((entry) => {
+      const meta = this.parseMeta(entry.metadata);
+      const embedding = embeddings.get(entry.id);
+      let maxSim = 0;
+      if (embedding) {
+        for (const [otherId, otherVec] of embeddings.entries()) {
+          if (otherId === entry.id) continue;
+          const sim = cosineSimilarity(embedding, otherVec);
+          if (sim > maxSim) maxSim = sim;
+        }
+      }
+      const roleScore = this.calculateRoleScore(meta.role);
+      const lengthScore = this.calculateLengthScore(entry.prompt.length);
+      const uniquenessScore = 1 - maxSim;
+      const recencyScore = this.calculateRecencyScore(entry.timestamp);
+      const finalScore = (roleScore * 0.4 + lengthScore * 0.2 + uniquenessScore * 0.25 + recencyScore * 0.15) * 10;
+      return {
+        id: entry.id,
+        prompt: entry.prompt,
+        role: meta.role || "other",
+        score: finalScore,
+        details: {
+          role: roleScore,
+          length: lengthScore,
+          uniqueness: uniquenessScore,
+          recency: recencyScore
+        }
+      };
+    });
+    const report = {
+      total: entries.length,
+      keep: [],
+      review: [],
+      remove: [],
+      byRole: {},
+      duplicates: { exact: 0, variants: 0 }
+    };
+    const keepThreshold = this.threshold * 10;
+    const removeThreshold = Math.max(0, this.threshold - 0.3) * 10;
+    for (const s of scores) {
+      const uniqueness = s.details.uniqueness;
+      const sim = 1 - uniqueness;
+      if (sim > 0.95) report.duplicates.exact++;
+      else if (sim > 0.85) report.duplicates.variants++;
+      if (s.score >= keepThreshold) report.keep.push(s);
+      else if (s.score >= removeThreshold) report.review.push(s);
+      else report.remove.push(s);
+      if (!report.byRole[s.role]) {
+        report.byRole[s.role] = { keep: 0, review: 0, remove: 0 };
+      }
+      if (s.score >= keepThreshold) report.byRole[s.role].keep++;
+      else if (s.score >= removeThreshold) report.byRole[s.role].review++;
+      else report.byRole[s.role].remove++;
+    }
+    report.keep.sort((a, b) => b.score - a.score);
+    report.remove.sort((a, b) => a.score - b.score);
+    return report;
+  }
+  getRemovalCandidates(entries, embeddings, threshold = 0.7) {
+    const removeThreshold = Math.max(0, threshold - 0.3) * 10;
+    const candidates = [];
+    const tempAnalyzer = new _ReusabilityAnalyzer(threshold);
+    const report = tempAnalyzer.analyze(entries, embeddings);
+    for (const s of report.remove) {
+      const entry = entries.find((e) => e.id === s.id);
+      if (!entry) continue;
+      const meta = this.parseMeta(entry.metadata);
+      if (meta.starred) continue;
+      const hasEmbedding = embeddings.has(entry.id);
+      candidates.push({
+        id: s.id,
+        score: s.score,
+        reason: `score ${s.score.toFixed(1)} < ${removeThreshold.toFixed(1)}`,
+        role: s.role,
+        promptSize: entry.prompt.length,
+        responseSize: (entry.response || "").length,
+        hasEmbedding
+      });
+    }
+    return candidates;
+  }
+  parseMeta(raw) {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return {};
+    }
+  }
+  calculateRoleScore(role) {
+    const scores = {
+      review: 0.9,
+      refactor: 0.9,
+      architect: 0.9,
+      debug: 0.5,
+      explain: 0.5,
+      generate: 0.2
+    };
+    return scores[role || ""] || 0.1;
+  }
+  calculateLengthScore(length) {
+    if (length > 300 && length < 2e3) {
+      return Math.min(1, Math.max(0, length / 1e3));
+    }
+    return 0.3;
+  }
+  calculateRecencyScore(timestamp) {
+    const date = new Date(timestamp);
+    const now = /* @__PURE__ */ new Date();
+    const diffTime = Math.abs(now.getTime() - date.getTime());
+    const diffDays = Math.ceil(diffTime / (1e3 * 60 * 60 * 24));
+    return Math.max(0, 1 - diffDays / 365);
+  }
+  toCSV(report) {
+    const all = [...report.keep, ...report.review, ...report.remove];
+    let csv = "id,score,role,length,uniqueness,recency,prompt\n";
+    for (const s of all) {
+      const cleanPrompt = s.prompt.replace(/"/g, '""').replace(/\n/g, " ");
+      csv += `${s.id},${s.score.toFixed(2)},${s.role},${s.prompt.length},${s.details.uniqueness.toFixed(4)},${s.details.recency.toFixed(4)},"${cleanPrompt.slice(0, 100)}"
+`;
+    }
+    return csv;
+  }
+};
+
+// src/background/analyzer.ts
+import { spawn as spawn2 } from "child_process";
+function spawnBackgroundAnalysis(id, dbPath) {
+  try {
+    const scriptPath = process.argv[1];
+    if (!scriptPath) return;
+    const nodePath = process.execPath;
+    const child = spawn2(nodePath, [scriptPath, "_bg-analyze", String(id), "--db", dbPath], {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.unref();
+  } catch (_err) {
+  }
+}
+
+// src/filter/index.ts
+import { createHash as createHash2 } 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 ORPHAN_CODE_PATTERN = /^([{}()[\]<>|&!=\-+*/%^~#@\\:;.,\s]+|\.\.\.|console\.log.*|print.*)$/i;
+var NON_PRINTABLE_PATTERN = /^[\x00-\x1f\x7f\x1b[\]()#;\d;A-Za-z]*$/;
+var FilterPipeline = class _FilterPipeline {
+  minLength;
+  minRelevance;
+  existingHashes;
+  constructor(opts = {}) {
+    this.minLength = opts.minLength ?? 15;
+    this.minRelevance = opts.minRelevance ?? 3;
+    this.existingHashes = opts.existingHashes ?? /* @__PURE__ */ new Map();
+  }
+  static hashPrompt(text) {
+    return createHash2("sha256").update(text.trim().toLowerCase()).digest("hex");
+  }
+  checkRules(text) {
+    const trimmed = text.trim();
+    if (trimmed.length < this.minLength) {
+      return { keep: false, reason: "too_short", details: `length ${trimmed.length} < ${this.minLength}` };
+    }
+    if (NON_PRINTABLE_PATTERN.test(trimmed)) {
+      return { keep: false, reason: "non_printable", details: "only control characters" };
+    }
+    if (TRIVIAL_PATTERN.test(trimmed)) {
+      return { keep: false, reason: "pattern_match", details: `matches trivial pattern: "${trimmed}"` };
+    }
+    if (ORPHAN_CODE_PATTERN.test(trimmed)) {
+      return { keep: false, reason: "pattern_match", details: `matches orphan code pattern: "${trimmed}"` };
+    }
+    return { keep: true };
+  }
+  checkDuplicate(text) {
+    const hash = _FilterPipeline.hashPrompt(text);
+    if (this.existingHashes.has(hash)) {
+      const existingId = this.existingHashes.get(hash);
+      return { keep: false, reason: "exact_duplicate", details: `duplicate of #${existingId}` };
+    }
+    return { keep: true };
+  }
+  /**
+   * Register a prompt hash after a successful insert to catch duplicates within the same batch.
+   */
+  registerHash(text, id) {
+    const hash = _FilterPipeline.hashPrompt(text);
+    this.existingHashes.set(hash, id);
+  }
+  checkRelevance(result) {
+    if (this.minRelevance <= 0) return { keep: true };
+    if (result.relevance === void 0) return { keep: true };
+    if (result.relevance < this.minRelevance) {
+      return {
+        keep: false,
+        reason: "low_relevance",
+        details: `relevance ${result.relevance} < ${this.minRelevance}`
+      };
+    }
+    return { keep: true };
+  }
+  /**
+   * Full pipeline check: rules → dedup → (relevance if provided).
+   * Short-circuits on first failure.
+   */
+  check(text, analysisResult) {
+    const rulesResult = this.checkRules(text);
+    if (!rulesResult.keep) return rulesResult;
+    const dupResult = this.checkDuplicate(text);
+    if (!dupResult.keep) return dupResult;
+    if (analysisResult !== void 0) {
+      const relResult = this.checkRelevance(analysisResult);
+      if (!relResult.keep) return relResult;
+    }
+    return { keep: true };
+  }
+};
+
+// src/ui/BrowseApp.tsx
+import React6, { useState as useState2, useCallback, useEffect as useEffect2, useMemo as useMemo2 } from "react";
+import { Box as Box4, Text as Text5, useInput as useInput2, useApp } from "ink";
+import { spawn as spawn3 } from "child_process";
+
+// src/ui/Header.tsx
+import React from "react";
+import { Text } from "ink";
+import { AppHeader, THEMES } from "@gi4nks/ink";
+
+// package.json
+var package_default = {
+  name: "@gi4nks/ph",
+  version: "1.3.2",
+  description: "Transparent CLI wrapper that captures and indexes AI prompts",
+  type: "module",
+  license: "MIT",
+  bin: {
+    ph: "dist/cli.js"
+  },
+  files: [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "docs",
+    "CHANGELOG.md",
+    "hooks"
+  ],
+  repository: {
+    type: "git",
+    url: "git+https://github.com/gi4nks/ph.git"
+  },
+  scripts: {
+    build: "tsup",
+    dev: "tsx src/cli.ts",
+    start: "node dist/cli.js",
+    test: "vitest run",
+    lint: "eslint src",
+    "release:patch": "standard-version --release-as patch",
+    "release:minor": "standard-version --release-as minor",
+    "release:major": "standard-version --release-as major"
+  },
+  dependencies: {
+    "@gi4nks/ink": "^1.5.0",
+    "@lydell/node-pty": "^1.2.0-beta.3",
+    "better-sqlite3": "^12.8.0",
+    ink: "^6.8.0",
+    react: "^19.2.4",
+    zod: "^4.3.6"
+  },
+  devDependencies: {
+    "@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",
+    "eslint-plugin-react": "^7.37.5",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "standard-version": "^9.5.0",
+    tsup: "^8.5.1",
+    tsx: "^4.21.0",
+    typescript: "^5.9.3",
+    vitest: "^4.1.0"
+  }
+};
+
+// src/ui/Header.tsx
+var ROLE_COLOR = {
+  debug: "red",
+  refactor: "yellow",
+  explain: "blue",
+  review: "magenta",
+  architect: "green",
+  test: "cyan",
+  docs: "white",
+  generate: "green",
+  research: "blue"
+};
+var FilterBadges = ({ active, textFilter }) => /* @__PURE__ */ React.createElement(React.Fragment, null, active.project && /* @__PURE__ */ React.createElement(Text, { color: "blue" }, "  proj:", active.project), active.language && /* @__PURE__ */ React.createElement(Text, { color: "green" }, "  lang:", active.language), active.role && /* @__PURE__ */ React.createElement(Text, { color: ROLE_COLOR[active.role] ?? "cyan" }, "  role:", active.role), active.tool && /* @__PURE__ */ React.createElement(Text, { color: "yellow" }, "  tool:", active.tool), active.tag && /* @__PURE__ */ React.createElement(Text, { color: "cyan" }, "  tag:", active.tag), active.starred && /* @__PURE__ */ React.createElement(Text, { color: "yellow" }, "  \u2605only"), active.minQuality !== void 0 && /* @__PURE__ */ React.createElement(Text, { color: "green" }, "  Q\u2265", active.minQuality), active.minRelevance !== void 0 && /* @__PURE__ */ React.createElement(Text, { color: "green" }, "  R\u2265", active.minRelevance), textFilter && /* @__PURE__ */ React.createElement(Text, { color: "yellow" }, "  /", textFilter));
+var Header = ({
+  entriesCount,
+  allEntriesCount,
+  activeFilters,
+  textFilter,
+  isTextFiltering,
+  theme: themeName = "dark"
+}) => {
+  const theme = THEMES[themeName] || THEMES.dark;
+  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 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,
+    {
+      appName: "ph",
+      version,
+      theme,
+      cwd,
+      leftExtra,
+      rightContent
+    }
+  );
+};
+
+// src/ui/Footer.tsx
+import React2 from "react";
+import { AppFooter, THEMES as THEMES2 } from "@gi4nks/ink";
+var HINTS = [
+  { key: "\u2191\u2193", description: "nav" },
+  { key: "Tab", description: "pane" },
+  { key: "1/2", description: "tab" },
+  { key: "y", description: "copy" },
+  { key: "s", description: "\u2605" },
+  { key: "e", description: "edit" },
+  { key: "r", description: "rerun" },
+  "|",
+  { key: "x", description: "del" },
+  { key: "/", description: "search" },
+  { key: "f", description: "filter" },
+  { key: "q", description: "quit" }
+];
+var Footer = ({
+  cursor,
+  total,
+  copiedId,
+  theme: themeName = "dark"
+}) => {
+  const theme = THEMES2[themeName] || THEMES2.dark;
+  const position = total > 0 ? `${cursor + 1}/${total}` : "0/0";
+  return /* @__PURE__ */ React2.createElement(
+    AppFooter,
+    {
+      theme,
+      hints: HINTS,
+      position,
+      toast: copiedId ? "Copied to clipboard" : void 0
+    }
+  );
+};
+
+// src/ui/themes.ts
+import { THEMES as THEMES3, THEME_NAMES } from "@gi4nks/ink";
+
+// src/ui/SearchBar.tsx
+import React3 from "react";
+import { Box, Text as Text2 } from "ink";
+var SearchBar = ({ value, isActive, theme }) => {
+  if (isActive) {
+    return /* @__PURE__ */ React3.createElement(Box, { paddingX: 1 }, /* @__PURE__ */ React3.createElement(Text2, { color: theme.primary }, "\u2315  ", value, "\u2588"));
+  }
+  const content = value === "" ? "type / to search\u2026" : value;
+  return /* @__PURE__ */ React3.createElement(Box, { paddingX: 1 }, /* @__PURE__ */ React3.createElement(Text2, { dimColor: true }, "\u2315  ", content));
+};
+
+// 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);
+  }
+  const originalTrimmed = text;
+  if (text.startsWith("#")) {
+    const headingMatch = text.match(/^#+\s+(.*?)(?:\s+#+)?(?:\n|$)/);
+    if (headingMatch && headingMatch[1]) {
+      text = headingMatch[1].trim();
+    }
+  }
+  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/ui/ListEntry.tsx
+var ROLE_COLOR2 = {
+  debug: "red",
+  refactor: "yellow",
+  explain: "blue",
+  review: "magenta",
+  architect: "green",
+  test: "cyan",
+  docs: "white",
+  generate: "green",
+  research: "blue"
+};
+function toolIndicator(tool) {
+  if (tool === "claude") return { char: "\u25CF", color: "#f5a623" };
+  if (tool === "gemini") return { char: "\u25CF", color: "#4fc3f7" };
+  return { char: "\u25CB", color: "gray" };
+}
+function truncate(str, width) {
+  if (str.length <= width) return str;
+  return str.slice(0, width - 1) + "\u2026";
+}
+var ListEntry = ({ entry, isSelected, paneWidth, theme }) => {
+  let meta = {};
+  try {
+    meta = JSON.parse(entry.metadata || "{}");
+  } catch {
+  }
+  const indicator = toolIndicator(entry.tool);
+  const date = new Date(entry.timestamp);
+  const hhmm = date.toLocaleTimeString([], {
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  });
+  const role = meta.role ? truncate(meta.role, 6) : "";
+  const roleColor = meta.role ? ROLE_COLOR2[meta.role] || "white" : "white";
+  const rawTitle = meta.title || extractTopic(entry.prompt);
+  const displayPrompt = truncate(rawTitle, paneWidth - 3);
+  return /* @__PURE__ */ React4.createElement(Box2, { flexDirection: "column" }, /* @__PURE__ */ React4.createElement(Box2, { flexDirection: "row", width: paneWidth, overflow: "hidden" }, /* @__PURE__ */ React4.createElement(Text3, { color: indicator.color }, indicator.char, " "), /* @__PURE__ */ React4.createElement(Text3, { dimColor: true }, entry.tool.padEnd(7)), meta.starred ? /* @__PURE__ */ React4.createElement(Text3, { color: theme.warning }, "\u2605 ") : /* @__PURE__ */ React4.createElement(Text3, null, "  "), /* @__PURE__ */ React4.createElement(Text3, { dimColor: true }, hhmm, "  "), role && /* @__PURE__ */ React4.createElement(Text3, { color: roleColor, dimColor: true }, role)), /* @__PURE__ */ React4.createElement(Box2, { flexDirection: "row" }, isSelected ? /* @__PURE__ */ React4.createElement(Text3, { inverse: true, bold: true }, " \u276F ", displayPrompt.padEnd(paneWidth - 3)) : /* @__PURE__ */ React4.createElement(Text3, null, "  ", displayPrompt)));
+};
+
+// src/ui/PreviewPane.tsx
+import React5, { useState, useEffect, useMemo } 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"
+};
+function wrapTextLines(text, width) {
+  const lines = text.split("\n");
+  const result = [];
+  for (const line of lines) {
+    if (line.length === 0) {
+      result.push("");
+      continue;
+    }
+    let current = line;
+    while (current.length > width) {
+      result.push(current.substring(0, width));
+      current = current.substring(width);
+    }
+    if (current.length > 0) result.push(current);
+  }
+  return result;
+}
+function formatTimestamp2(ts) {
+  try {
+    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}`;
+  } catch {
+    return ts.slice(0, 16);
+  }
+}
+function parseMeta2(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+var PreviewPane = ({
+  entry,
+  paneWidth,
+  paneHeight,
+  isFocused,
+  theme
+}) => {
+  const [activeTab, setActiveTab] = useState("prompt");
+  const [scrollOffset, setScrollOffset] = useState(0);
+  useEffect(() => {
+    setActiveTab("prompt");
+    setScrollOffset(0);
+  }, [entry?.id]);
+  useEffect(() => {
+    setScrollOffset(0);
+  }, [activeTab]);
+  const meta = useMemo(() => entry ? parseMeta2(entry.metadata) : {}, [entry]);
+  const contentWidth = Math.max(10, paneWidth - 4);
+  const contentHeight = Math.max(3, paneHeight - 6);
+  const allLines = useMemo(() => {
+    if (!entry) return [];
+    const text = activeTab === "prompt" ? entry.prompt : entry.response || "(no response captured)";
+    return wrapTextLines(text, contentWidth);
+  }, [entry, activeTab, contentWidth]);
+  const maxScroll = Math.max(0, allLines.length - contentHeight);
+  useInput((_char, key) => {
+    if (!isFocused) return;
+    if (_char === "1") {
+      setActiveTab("prompt");
+      return;
+    }
+    if (_char === "2") {
+      setActiveTab("response");
+      return;
+    }
+    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)"));
+  }
+  const visibleLines = allLines.slice(scrollOffset, scrollOffset + contentHeight);
+  const paddedLines = [...visibleLines];
+  while (paddedLines.length < contentHeight) paddedLines.push("");
+  const topIndicator = scrollOffset > 0 ? `  \u2191 ${scrollOffset} above` : "  ";
+  const remaining = allLines.length - scrollOffset - contentHeight;
+  const botIndicator = scrollOffset < maxScroll ? `  \u2193 ${remaining} more` : "  ";
+  const isPromptActive = activeTab === "prompt";
+  const isResponseActive = activeTab === "response";
+  const tabPromptColor = isPromptActive && isFocused ? theme.primary : theme.dim;
+  const tabResponseColor = isResponseActive && 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 ", formatTimestamp2(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,
+    {
+      color: tabPromptColor,
+      bold: isPromptActive && isFocused,
+      underline: isPromptActive && isFocused
+    },
+    isPromptActive ? "\u25CF " : "\u25CB ",
+    "PROMPT"
+  ), /* @__PURE__ */ React5.createElement(Text4, null, "   "), /* @__PURE__ */ React5.createElement(
+    Text4,
+    {
+      color: tabResponseColor,
+      bold: isResponseActive && isFocused,
+      underline: isResponseActive && isFocused
+    },
+    isResponseActive ? "\u25CF " : "\u25CB ",
+    "RESPONSE"
+  )), /* @__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));
+};
+
+// src/ui/BrowseApp.tsx
+var FILTER_CATEGORIES = ["project", "language", "role", "tool", "tag", "starred", "quality", "relevance"];
+var CATEGORY_LABEL = {
+  project: "Project",
+  language: "Language",
+  role: "Role",
+  tool: "Tool",
+  tag: "Tag",
+  starred: "Starred",
+  quality: "Quality",
+  relevance: "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;
+    let cmd = "";
+    let args = [];
+    if (platform === "darwin") {
+      cmd = "pbcopy";
+    } else if (platform === "win32") {
+      cmd = "clip";
+    } else {
+      cmd = "xclip";
+      args = ["-selection", "clipboard"];
+    }
+    const proc = spawn3(cmd, args);
+    proc.stdin.write(text);
+    proc.stdin.end();
+  } 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({
+    columns: process.stdout.columns || 120,
+    rows: process.stdout.rows || 24
+  });
+  useEffect2(() => {
+    const handler = () => {
+      setDimensions({
+        columns: process.stdout.columns || 120,
+        rows: process.stdout.rows || 24
+      });
+    };
+    process.stdout.on("resize", handler);
+    return () => {
+      process.stdout.off("resize", handler);
+    };
+  }, []);
+  return dimensions;
+}
+function formatTimestamp3(ts) {
+  try {
+    const d = new Date(ts);
+    const p = (n) => String(n).padStart(2, "0");
+    return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}`;
+  } catch {
+    return ts.slice(0, 16);
+  }
+}
+function parseMeta3(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function getDistinctValues(entries, category) {
+  const set = /* @__PURE__ */ new Set();
+  for (const e of entries) {
+    if (category === "tool") {
+      set.add(e.tool);
+      continue;
+    }
+    const meta = parseMeta3(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 = parseMeta3(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 = parseMeta3(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 = parseMeta3(entry.metadata);
+  const [activeTab, setActiveTab] = useState2(entry.response ? "response" : "prompt");
+  const [scrollOffset, setScrollOffset] = useState2(0);
+  const [copied, setCopied] = useState2(false);
+  useEffect2(() => {
+    setScrollOffset(0);
+  }, [activeTab]);
+  const contentWidth = Math.max(10, termWidth - 4);
+  const text = activeTab === "prompt" ? entry.prompt : entry.response || "(no response captured)";
+  const lines = useMemo2(() => wrapTextLines2(text, contentWidth), [text, contentWidth]);
+  const contentHeight = Math.max(1, termHeight - 10);
+  const maxScroll = Math.max(0, lines.length - contentHeight);
+  useInput2((char, key) => {
+    if (key.escape || key.return) onClose();
+    else if (char === "e") onEdit();
+    else if (key.tab || char === "1" || char === "2") {
+      if (char === "1") setActiveTab("prompt");
+      else if (char === "2") setActiveTab("response");
+      else setActiveTab((t) => t === "prompt" ? "response" : "prompt");
+    } else if (char === "y") {
+      copyToClipboard(text);
+      setCopied(true);
+      setTimeout(() => setCopied(false), 2e3);
+    } else if (key.upArrow) setScrollOffset((s) => Math.max(0, s - 1));
+    else if (key.downArrow) setScrollOffset((s) => Math.min(maxScroll, s + 1));
+    else if (key.pageUp) setScrollOffset((s) => Math.max(0, s - contentHeight));
+    else if (key.pageDown) setScrollOffset((s) => Math.min(maxScroll, s + contentHeight));
+  });
+  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 ", formatTimestamp3(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: true }, activeTab === "prompt" ? "\u25CF" : "\u25CB", " PROMPT"), /* @__PURE__ */ React6.createElement(Text5, null, "   "), /* @__PURE__ */ React6.createElement(Text5, { color: theme.primary, bold: true, underline: true }, activeTab === "response" ? "\u25CF" : "\u25CB", " RESPONSE")), /* @__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")));
+};
+var EditView = ({ entry, onSave, onClose, theme }) => {
+  const initMeta = parseMeta3(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) => {
+    if (key.escape) {
+      onClose();
+      return;
+    }
+    if (key.return) {
+      const newMeta = { ...initMeta };
+      const trimmedTitle = titleValue.trim();
+      newMeta.title = trimmedTitle || void 0;
+      const trimmedRole = roleValue.trim();
+      newMeta.role = trimmedRole || void 0;
+      const parsedTags = tagsValue.split(",").map((t) => t.trim()).filter(Boolean);
+      newMeta.tags = parsedTags.length > 0 ? parsedTags : void 0;
+      onSave(newMeta);
+      return;
+    }
+    if (key.tab) {
+      setField((f) => {
+        if (f === "title") return "role";
+        if (f === "role") return "tags";
+        return "title";
+      });
+      return;
+    }
+    const setter = field === "title" ? setTitleValue : field === "role" ? setRoleValue : setTagsValue;
+    if (key.backspace || key.delete) {
+      setter((v) => v.slice(0, -1));
+    } 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 = parseMeta3(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, formatTimestamp3(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 [catIdx, setCatIdx] = useState2(0);
+  const [itemIdx, setItemIdx] = useState2(0);
+  const category = FILTER_CATEGORIES[catIdx];
+  const isStarred = category === "starred";
+  const isQuality = category === "quality";
+  const isRelevance = category === "relevance";
+  const values = useMemo2(
+    () => {
+      if (isStarred) return [];
+      if (isQuality || isRelevance) return ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"];
+      return getDistinctValues(allEntries, category);
+    },
+    [allEntries, category, isStarred, isQuality, isRelevance]
+  );
+  const allValues = isStarred ? [] : ["(all)", ...values];
+  const currentCatValue = useMemo2(() => {
+    if (isStarred) return active.starred ? "yes" : void 0;
+    if (isQuality) return active.minQuality?.toString();
+    if (isRelevance) return active.minRelevance?.toString();
+    return active[category];
+  }, [active, category, isStarred, isQuality, isRelevance]);
+  const ITEMS_VISIBLE = 14;
+  const pageStart = Math.max(0, Math.min(itemIdx - Math.floor(ITEMS_VISIBLE / 2), allValues.length - ITEMS_VISIBLE));
+  const visibleValues = allValues.slice(pageStart, pageStart + ITEMS_VISIBLE);
+  useInput2((char, key) => {
+    if (key.escape) {
+      onClose();
+      return;
+    }
+    if (key.tab) {
+      const next = (catIdx + 1) % FILTER_CATEGORIES.length;
+      setCatIdx(next);
+      setItemIdx(0);
+      return;
+    }
+    if (key.leftArrow) {
+      setCatIdx((i) => (i - 1 + FILTER_CATEGORIES.length) % FILTER_CATEGORIES.length);
+      setItemIdx(0);
+    } else if (key.rightArrow) {
+      setCatIdx((i) => (i + 1) % FILTER_CATEGORIES.length);
+      setItemIdx(0);
+    } else if (key.upArrow) {
+      setItemIdx((i) => Math.max(0, i - 1));
+    } else if (key.downArrow) {
+      if (isStarred) {
+        onUpdate({ ...active, starred: !active.starred || void 0 });
+      } else {
+        setItemIdx((i) => Math.min(allValues.length - 1, i + 1));
+      }
+    } else if (key.return || char === " ") {
+      if (isStarred) {
+        onUpdate({ ...active, starred: !active.starred || void 0 });
+      } else {
+        const selected = allValues[itemIdx];
+        if (!selected) return;
+        if (selected === "(all)") {
+          const updated = { ...active };
+          if (isQuality) delete updated.minQuality;
+          else if (isRelevance) delete updated.minRelevance;
+          else delete updated[category];
+          onUpdate(updated);
+        } else {
+          if (isQuality) onUpdate({ ...active, minQuality: Number(selected) });
+          else if (isRelevance) onUpdate({ ...active, minRelevance: Number(selected) });
+          else onUpdate({ ...active, [category]: selected });
+        }
+      }
+    } else if (char === "c") {
+      onUpdate({});
+    }
+  });
+  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 }, "Filter Panel  "), activeCount > 0 ? /* @__PURE__ */ React6.createElement(Text5, { color: theme.warning }, activeCount, " active filter", activeCount > 1 ? "s" : "", "  ") : /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "no filters active  "), activeCount > 0 && /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "(c to clear all)")), /* @__PURE__ */ React6.createElement(Box4, { marginBottom: 1 }, FILTER_CATEGORIES.map((cat, i) => {
+    let catVal;
+    if (cat === "starred") catVal = active.starred ? "\u2605" : void 0;
+    else if (cat === "quality") catVal = active.minQuality ? `\u2265${active.minQuality}` : void 0;
+    else if (cat === "relevance") catVal = active.minRelevance ? `\u2265${active.minRelevance}` : void 0;
+    else catVal = active[cat];
+    const isActive = i === catIdx;
+    return /* @__PURE__ */ React6.createElement(Box4, { key: cat, marginRight: 2 }, /* @__PURE__ */ React6.createElement(Text5, { color: isActive ? theme.primary : catVal ? theme.warning : theme.dim, bold: isActive }, CATEGORY_LABEL[cat], catVal ? `[${catVal}]` : ""));
+  })), /* @__PURE__ */ React6.createElement(Box4, { borderStyle: "single", borderColor: theme.dim, flexDirection: "column", padding: 1, minHeight: 16 }, isStarred ? /* @__PURE__ */ React6.createElement(Box4, null, /* @__PURE__ */ React6.createElement(Text5, { color: active.starred ? theme.warning : theme.dim, bold: active.starred }, "\u276F ", active.starred ? "\u2605" : "\u2606", " Only starred prompts", active.starred ? " \u2713" : "")) : allValues.length === 0 ? /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "(no values found)") : visibleValues.map((val, i) => {
+    const absIdx = pageStart + i;
+    const isCurrent = val === currentCatValue || val === "(all)" && !currentCatValue;
+    return /* @__PURE__ */ React6.createElement(Box4, { key: val }, /* @__PURE__ */ React6.createElement(
+      Text5,
+      {
+        color: absIdx === itemIdx ? theme.primary : isCurrent ? theme.warning : theme.dim,
+        bold: absIdx === itemIdx
+      },
+      absIdx === itemIdx ? "\u276F " : "  ",
+      val,
+      isCurrent && val !== "(all)" ? " \u2713" : ""
+    ));
+  })), /* @__PURE__ */ React6.createElement(Box4, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "\u2190\u2192/Tab switch category \xB7 \u2191\u2193 navigate \xB7 Enter/Space select \xB7 c clear all \xB7 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 [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 currentThemeName = "dark";
+  const theme = THEMES3[currentThemeName] || THEMES3.dark;
+  const { columns: termWidth, rows: termHeight } = useStdoutDimensions();
+  const SPLIT_THRESHOLD = 100;
+  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) / 3));
+  const entries = useMemo2(
+    () => applyFilters(allEntries, activeFilters, textFilter),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [allEntries, activeFilters, textFilter, refreshKey]
+  );
+  useEffect2(() => {
+    setCursor((c) => Math.min(c, Math.max(0, entries.length - 1)));
+  }, [entries.length]);
+  useEffect2(() => {
+    setScrollOffset((prev) => {
+      const clamped = Math.max(0, Math.min(prev, Math.max(0, entries.length - PAGE_SIZE)));
+      if (cursor < clamped) return cursor;
+      if (cursor >= clamped + PAGE_SIZE) return cursor - PAGE_SIZE + 1;
+      return clamped;
+    });
+  }, [cursor, PAGE_SIZE, entries.length]);
+  const pageStart = scrollOffset;
+  const visible = entries.slice(pageStart, pageStart + PAGE_SIZE);
+  const triggerRefresh = useCallback(() => setRefreshKey((k) => k + 1), []);
+  const toggleStar = useCallback((entry) => {
+    const meta = parseMeta3(entry.metadata);
+    meta.starred = !meta.starred;
+    const newMeta = JSON.stringify(meta);
+    db.updateMetadata(entry.id, newMeta);
+    entry.metadata = newMeta;
+    triggerRefresh();
+  }, [db, triggerRefresh]);
+  const handleDelete = useCallback((entry) => {
+    db.deleteById(entry.id);
+    setAllEntries((prev) => prev.filter((e) => e.id !== entry.id));
+  }, [db]);
+  const handleSaveEdit = useCallback((entry, meta) => {
+    const newMeta = JSON.stringify(meta);
+    db.updateMetadata(entry.id, newMeta);
+    entry.metadata = newMeta;
+    setEditing(null);
+    triggerRefresh();
+  }, [db, triggerRefresh]);
+  const handleFilterUpdate = useCallback((filters) => {
+    setActiveFilters(filters);
+    setCursor(0);
+    setScrollOffset(0);
+  }, []);
+  useInput2((char, key) => {
+    if (detail || editing || showFilterPanel || rerunning) return;
+    if (isTextFiltering) {
+      if (key.escape) {
+        setTextFiltering(false);
+        setTextFilter("");
+      } else if (key.return) {
+        setTextFiltering(false);
+      } else if (key.backspace || key.delete) {
+        setTextFilter((v) => v.slice(0, -1));
+      } else if (char && !key.ctrl) {
+        setTextFilter((v) => v + char);
+      }
+      return;
+    }
+    if (key.escape) {
+      if (isWide && focusPane === "preview") {
+        setFocusPane("list");
+        return;
+      }
+      exit();
+      return;
+    } else if (char === "q") {
+      exit();
+    } else if (char === "/") {
+      setTextFiltering(true);
+    } else if (char === "s") {
+      if (entries[cursor]) toggleStar(entries[cursor]);
+    } else if (char === "e") {
+      if (entries[cursor]) setEditing(entries[cursor]);
+    } else if (char === "r") {
+      if (entries[cursor]) setRerunning(entries[cursor]);
+    } else if (char === "x") {
+      if (entries[cursor]) handleDelete(entries[cursor]);
+    } else if (char === "f") {
+      setFilterPanel(true);
+    } else if (char === "c") {
+      setActiveFilters({});
+      setTextFilter("");
+      setCursor(0);
+      setScrollOffset(0);
+    } else if (char === "y") {
+      if (entries[cursor]) {
+        copyToClipboard(entries[cursor].prompt);
+        setCopiedId(entries[cursor].id);
+        setTimeout(() => setCopiedId(null), 2e3);
+      }
+    } else if (key.tab && isWide) {
+      setFocusPane((p) => p === "list" ? "preview" : "list");
+    } else if (focusPane === "list" || !isWide) {
+      if (key.upArrow) {
+        setCursor((c) => Math.max(0, c - 1));
+      } else if (key.downArrow) {
+        setCursor((c) => Math.min(entries.length - 1, c + 1));
+      } else if (key.pageUp) {
+        setCursor((c) => Math.max(0, c - PAGE_SIZE));
+      } else if (key.pageDown) {
+        setCursor((c) => Math.min(entries.length - 1, c + PAGE_SIZE));
+      } else if (key.return) {
+        if (isWide) {
+          if (entries[cursor]) {
+            copyToClipboard(entries[cursor].prompt);
+            setCopiedId(entries[cursor].id);
+            setTimeout(() => setCopiedId(null), 2e3);
+          }
+        } else {
+          if (entries[cursor]) setDetail(entries[cursor]);
+        }
+      }
+    }
+  });
+  let mainContent;
+  if (showFilterPanel) {
+    mainContent = /* @__PURE__ */ React6.createElement(
+      FilterPanel,
+      {
+        allEntries,
+        active: activeFilters,
+        onUpdate: handleFilterUpdate,
+        onClose: () => setFilterPanel(false),
+        theme
+      }
+    );
+  } else if (rerunning) {
+    mainContent = /* @__PURE__ */ React6.createElement(
+      RerunView,
+      {
+        entry: rerunning,
+        onConfirm: (tool, prompt) => {
+          onRerun?.(tool, prompt);
+          setRerunning(null);
+          exit();
+        },
+        onClose: () => setRerunning(null),
+        theme
+      }
+    );
+  } else if (editing) {
+    mainContent = /* @__PURE__ */ React6.createElement(
+      EditView,
+      {
+        entry: editing,
+        onSave: (meta) => handleSaveEdit(editing, meta),
+        onClose: () => setEditing(null),
+        theme
+      }
+    );
+  } else if (detail && !isWide) {
+    mainContent = /* @__PURE__ */ React6.createElement(
+      DetailView,
+      {
+        entry: detail,
+        onClose: () => setDetail(null),
+        onEdit: () => {
+          setEditing(detail);
+          setDetail(null);
+        },
+        termWidth,
+        termHeight,
+        theme
+      }
+    );
+  } 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) => /* @__PURE__ */ React6.createElement(React6.Fragment, { key: entry.id }, /* @__PURE__ */ React6.createElement(
+      ListEntry,
+      {
+        entry,
+        isSelected: pageStart + i === cursor,
+        paneWidth: leftPaneWidth,
+        theme
+      }
+    ), i < visible.length - 1 && /* @__PURE__ */ React6.createElement(Box4, null, /* @__PURE__ */ React6.createElement(Text5, { color: theme.dim }, "\u2500".repeat(leftPaneWidth)))))), /* @__PURE__ */ React6.createElement(
+      Box4,
+      {
+        borderLeft: true,
+        borderStyle: "single",
+        borderColor: previewFocused ? theme.primary : theme.dim,
+        flexGrow: 1,
+        flexDirection: "column"
+      },
+      /* @__PURE__ */ React6.createElement(
+        PreviewPane,
+        {
+          entry: entries[cursor] ?? null,
+          paneWidth: termWidth - leftPaneWidth - 1,
+          paneHeight: termHeight - 3,
+          isFocused: previewFocused,
+          theme
+        }
+      )
+    ));
+  } 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) => /* @__PURE__ */ React6.createElement(React6.Fragment, { key: entry.id }, /* @__PURE__ */ React6.createElement(
+      ListEntry,
+      {
+        entry,
+        isSelected: pageStart + i === cursor,
+        paneWidth: termWidth,
+        theme
+      }
+    ), i < visible.length - 1 && /* @__PURE__ */ React6.createElement(Box4, null, /* @__PURE__ */ React6.createElement(Text5, { color: theme.dim }, "\u2500".repeat(termWidth))))));
+  }
+  return /* @__PURE__ */ React6.createElement(Box4, { flexDirection: "column", height: termHeight }, /* @__PURE__ */ React6.createElement(
+    Header,
+    {
+      entriesCount: entries.length,
+      allEntriesCount: allEntries.length,
+      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(
+    Footer,
+    {
+      cursor,
+      total: entries.length,
+      copiedId,
+      theme: currentThemeName
+    }
+  ));
+};
+
+// src/sessions/index.ts
+function groupIntoSessions(entries, gapHours) {
+  if (entries.length === 0) return [];
+  const sessions = [];
+  const gapMs = gapHours * 60 * 60 * 1e3;
+  let current = [entries[0]];
+  let lastTime = new Date(entries[0].timestamp).getTime();
+  for (let i = 1; i < entries.length; i++) {
+    const entry = entries[i];
+    const entryTime = new Date(entry.timestamp).getTime();
+    const gap = entryTime - lastTime;
+    if (gap > gapMs) {
+      sessions.push(makeSession(sessions.length + 1, current));
+      current = [entry];
+    } else {
+      current.push(entry);
+    }
+    lastTime = entryTime;
+  }
+  if (current.length > 0) {
+    sessions.push(makeSession(sessions.length + 1, current));
+  }
+  return sessions;
+}
+function makeSession(index, entries) {
+  return {
+    index,
+    entries,
+    startTime: new Date(entries[0].timestamp),
+    endTime: new Date(entries[entries.length - 1].timestamp),
+    cohesion: null
+  };
+}
+function computeSessionCohesion(session, embeddings) {
+  const vecs = [];
+  for (const entry of session.entries) {
+    const vec = embeddings.get(entry.id);
+    if (vec) vecs.push(vec);
+  }
+  if (vecs.length < 2) return null;
+  let sum = 0;
+  let count = 0;
+  for (let i = 0; i < vecs.length; i++) {
+    for (let j = i + 1; j < vecs.length; j++) {
+      sum += cosineSimilarity(vecs[i], vecs[j]);
+      count++;
+    }
+  }
+  return count > 0 ? sum / count : null;
+}
+
+// src/stats/index.ts
+function getStats(db) {
+  const all = db.search({ limit: 1e6 });
+  const stats = {
+    total: all.length,
+    byTool: {},
+    byProject: {},
+    byLanguage: {},
+    byRole: {},
+    analyzed: 0,
+    starred: 0,
+    avgRelevance: 0,
+    avgQuality: 0
+  };
+  let totalRel = 0;
+  let totalQual = 0;
+  let analyzedWithScores = 0;
+  for (const entry of all) {
+    stats.byTool[entry.tool] = (stats.byTool[entry.tool] ?? 0) + 1;
+    let meta = {};
+    try {
+      meta = JSON.parse(entry.metadata);
+    } catch {
+    }
+    if (meta.project) {
+      stats.byProject[meta.project] = (stats.byProject[meta.project] ?? 0) + 1;
+    }
+    if (meta.language) {
+      stats.byLanguage[meta.language] = (stats.byLanguage[meta.language] ?? 0) + 1;
+    }
+    if (meta.role) {
+      stats.byRole[meta.role] = (stats.byRole[meta.role] ?? 0) + 1;
+      stats.analyzed++;
+    }
+    if (meta.starred) {
+      stats.starred++;
+    }
+    if (meta.relevance !== void 0 || meta.quality !== void 0) {
+      totalRel += meta.relevance ?? 0;
+      totalQual += meta.quality ?? 0;
+      analyzedWithScores++;
+    }
+  }
+  if (analyzedWithScores > 0) {
+    stats.avgRelevance = totalRel / analyzedWithScores;
+    stats.avgQuality = totalQual / analyzedWithScores;
+  }
+  return stats;
+}
+
+// src/cluster/index.ts
+function kmeans(embeddings, k, maxIterations = 20) {
+  const ids = Array.from(embeddings.keys());
+  const vecs = Array.from(embeddings.values());
+  if (ids.length === 0 || k <= 0) return [];
+  if (ids.length <= k) {
+    return ids.map((id, i) => ({
+      centroid: vecs[i],
+      entryIds: [id]
+    }));
+  }
+  let centroids = vecs.slice(0, k).map((v) => new Float32Array(v));
+  let clusters = [];
+  for (let iter = 0; iter < maxIterations; iter++) {
+    clusters = centroids.map((c) => ({ centroid: c, entryIds: [] }));
+    for (let i = 0; i < ids.length; i++) {
+      const vec = vecs[i];
+      let bestSim = -1;
+      let bestIdx = 0;
+      for (let j = 0; j < k; j++) {
+        const sim = cosineSimilarity(vec, centroids[j]);
+        if (sim > bestSim) {
+          bestSim = sim;
+          bestIdx = j;
+        }
+      }
+      clusters[bestIdx].entryIds.push(ids[i]);
+    }
+    const nextCentroids = clusters.map((cluster) => {
+      if (cluster.entryIds.length === 0) return cluster.centroid;
+      const first = embeddings.get(cluster.entryIds[0]);
+      const sum = new Float32Array(first.length);
+      for (const id of cluster.entryIds) {
+        const v = embeddings.get(id);
+        for (let i = 0; i < v.length; i++) {
+          sum[i] += v[i];
+        }
+      }
+      for (let i = 0; i < sum.length; i++) {
+        sum[i] /= cluster.entryIds.length;
+      }
+      return sum;
+    });
+    let changed = false;
+    for (let i = 0; i < k; i++) {
+      if (cosineSimilarity(centroids[i], nextCentroids[i]) < 0.9999) {
+        changed = true;
+        break;
+      }
+    }
+    centroids = nextCentroids;
+    if (!changed) break;
+  }
+  return clusters;
+}
+
+// src/cli.ts
+var USAGE = `ph \u2014 prompt history tracker
+
+USAGE:
+  ph                                    Open interactive TUI browser (default)
+  ph <tool> [tool-args...]              Wrap a CLI tool, save prompt to history
+  ph search [options] [query]           Search saved prompts
+  ph last [n]                           Show last N prompts (default 10)
+  ph sessions [options]                 Group prompts into work sessions
+  ph stats                              Show history statistics
+  ph cluster [options]                  Cluster prompts by similarity
+  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 analyze [--limit n] [--force] [--prune] [--dry-run]  Analyze prompts with LLM
+  ph cleanup [--dry-run] [--min-length N] [--min-score N]  Remove useless prompts
+  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
+  ph config set <key> <value>           Save config value
+  ph browse                             Interactive TUI browser
+
+WRAP FLAGS (placed before the tool name):
+  --ph-tag <tag>                        Add a tag to the captured prompt
+  --ph-role <role>                      Set the prompt role (debug, refactor, explain, review, architect, test, docs, generate, research)
+  --ph-debug                            Write a debug log to ~/.ph_debug.log
+
+SEARCH OPTIONS:
+  -i, --interactive   Open results in interactive TUI browser
+  --tool <name>       Filter by tool name (claude, gemini, \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)
+  --tag <tag>         Filter by tag
+  --starred           Show only starred prompts
+  --min-quality <n>   Filter by min quality (0-10)
+  --min-relevance <n> Filter by min relevance (0-10)
+  --top               Show only top quality prompts (quality >= 8)
+  --semantic          Use semantic search (requires embeddings)
+  --since YYYY-MM-DD
+  --until YYYY-MM-DD
+  --limit <n>         Max results (default 50)
+  --full              Show full prompt without truncation
+
+SESSIONS OPTIONS:
+  --gap-hours <n>     Hours gap to split sessions (default 2)
+  --limit <n>         Max sessions to show (default 20)
+  --min-size <n>      Minimum prompts per session (default 1)
+  --no-cohesion       Skip semantic cohesion computation
+
+CLUSTER OPTIONS:
+  -k <number>         Number of clusters (default 5)
+  --limit <n>         Max prompts per cluster to show (default 3)
+
+ANALYZE-REUSABILITY OPTIONS:
+  --export-csv <file>  Export report to CSV
+  --threshold <n>      Scoring threshold (default 0.7)
+
+EXAMPLES:
+  ph claude "explain goroutines"
+  ph --ph-role debug --ph-tag auth claude "fix JWT expiration bug"
+  ph search "goroutines"
+  ph search --tool claude --role debug --since 2026-01-01 "error handling"
+  ph search --semantic "how to handle errors gracefully"
+  ph search -i "database"
+  ph last 20
+  ph sessions
+  ph sessions --gap-hours 4 --min-size 3
+  ph stats
+  ph cluster -k 10
+  ph export 5 --format md
+  ph import claude --analyze --filter
+  ph analyze --force --prune --min-score 3
+  ph cleanup --dry-run
+  ph embed-all
+  ph analyze-reusability --export-csv report.csv
+  ph cleanup-reusability --dry-run
+  ph config set analyze-provider gemini
+  ph config set background-analysis true
+  ph config set ollama-model llama3.2:latest
+  ph ollama-models                          List models available on the local Ollama instance
+`;
+function parseFlags(args) {
+  const flags = {};
+  const positional = [];
+  let i = 0;
+  while (i < args.length) {
+    const a = args[i];
+    if (a.startsWith("--")) {
+      const key = a.slice(2);
+      if (i + 1 < args.length && !args[i + 1].startsWith("--")) {
+        flags[key] = args[i + 1];
+        i += 2;
+      } else {
+        flags[key] = true;
+        i++;
+      }
+    } else {
+      positional.push(a);
+      i++;
+    }
+  }
+  return { flags, positional };
+}
+function parseDate(s, label) {
+  const d = new Date(s);
+  if (isNaN(d.getTime())) {
+    process.stderr.write(`ph: invalid ${label} date: ${s}
+`);
+    process.exit(1);
+  }
+  return d;
+}
+async function cmdSearch(db, cfg, args) {
+  const { flags, positional } = parseFlags(args);
+  const query = positional.join(" ");
+  if (flags["semantic"] && query) {
+    await cmdSearchSemantic(db, cfg, query, Number(flags["limit"] ?? 50), Boolean(flags["full"]));
+    return;
+  }
+  const opts = {
+    query,
+    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,
+    limit: Number(flags["limit"] ?? 50)
+  };
+  if (flags["since"]) opts.since = parseDate(flags["since"], "--since");
+  if (flags["until"]) {
+    const d = parseDate(flags["until"], "--until");
+    d.setHours(23, 59, 59, 999);
+    opts.until = d;
+  }
+  const results = db.search(opts);
+  printResults(results, Boolean(flags["full"]));
+}
+async function cmdSearchSemantic(db, cfg, query, limit, showFull) {
+  const ollamaUrl = cfg.ollamaUrl ?? "http://localhost:11434";
+  const model = cfg.ollamaEmbedModel ?? "nomic-embed-text-v2-moe";
+  process.stdout.write(`Searching semantically for: "${query}" (model: ${model})...
+`);
+  const [queryVec] = await getEmbeddings([query], ollamaUrl, model, 1);
+  if (!queryVec) {
+    process.stderr.write("ph: failed to get embedding for query\n");
+    process.exit(1);
+  }
+  const embeddings = db.getAllEmbeddings();
+  const scores = [];
+  for (const [id, vec] of embeddings) {
+    const sim = cosineSimilarity(queryVec, vec);
+    if (sim > 0.3) scores.push({ id, sim });
+  }
+  scores.sort((a, b) => b.sim - a.sim);
+  const topScores = scores.slice(0, limit);
+  const results = topScores.map(({ id }) => db.getById(id)).filter((e) => e !== void 0);
+  printResults(results, showFull);
+}
+async function cmdLast(db, args) {
+  const n = parseInt(args[0] ?? "10", 10);
+  const results = db.search({ limit: isNaN(n) ? 10 : n });
+  printResults(results, false);
+}
+async function cmdStar(db, args) {
+  const id = parseInt(args[0] ?? "", 10);
+  if (isNaN(id)) {
+    process.stderr.write("Usage: ph star <id>\n");
+    process.exit(1);
+  }
+  const entry = db.getById(id);
+  if (!entry) {
+    process.stderr.write(`ph: prompt #${id} not found
+`);
+    process.exit(1);
+  }
+  let meta = {};
+  try {
+    meta = JSON.parse(entry.metadata);
+  } catch {
+  }
+  const wasStarred = Boolean(meta.starred);
+  meta.starred = !wasStarred;
+  db.updateMetadata(id, JSON.stringify(meta));
+  if (meta.starred) {
+    console.log(`Prompt #${id} starred \u2605`);
+  } else {
+    console.log(`Prompt #${id} unstarred`);
+  }
+}
+async function cmdExport(db, args) {
+  const { flags, positional } = parseFlags(args);
+  const id = parseInt(positional[0] ?? "", 10);
+  if (isNaN(id)) {
+    process.stderr.write("Usage: ph export <id> [--format txt|json|md]\n");
+    process.exit(1);
+  }
+  const entry = db.getById(id);
+  if (!entry) {
+    process.stderr.write(`ph: prompt #${id} not found
+`);
+    process.exit(1);
+  }
+  const format = flags["format"] ?? "txt";
+  switch (format) {
+    case "txt":
+    case "text":
+      process.stdout.write(entry.prompt);
+      break;
+    case "json": {
+      const obj = {
+        id: entry.id,
+        timestamp: entry.timestamp,
+        tool: entry.tool,
+        prompt: entry.prompt,
+        metadata: JSON.parse(entry.metadata)
+      };
+      console.log(JSON.stringify(obj));
+      break;
+    }
+    case "md":
+    case "markdown": {
+      let meta = {};
+      try {
+        meta = JSON.parse(entry.metadata);
+      } catch {
+      }
+      let md = `# Prompt #${entry.id}
+
+`;
+      if (meta.starred) md += "\u2605 **Starred**\n\n";
+      md += `- **Tool**: ${entry.tool}
+`;
+      md += `- **Date**: ${entry.timestamp}
+`;
+      if (meta.project) md += `- **Project**: ${meta.project}
+`;
+      if (meta.language) md += `- **Language**: ${meta.language}
+`;
+      if (meta.role) md += `- **Role**: ${meta.role}
+`;
+      if (meta.tags && meta.tags.length > 0) md += `- **Tags**: ${meta.tags.join(", ")}
+`;
+      md += `- **Dir**: ${entry.workdir}
+
+---
+
+## Prompt
+
+${entry.prompt}
+`;
+      if (entry.response) {
+        md += `
+## Response
+
+${entry.response}
+`;
+      }
+      if (meta.git_context) {
+        md += `
+## Git Context
+
+`;
+        md += `**Branch**: ${meta.git_context.branch}
+`;
+        if (meta.git_context.files.length > 0) {
+          md += `**Modified files**: ${meta.git_context.files.join(", ")}
+`;
+        }
+        md += `
+\`\`\`diff
+${meta.git_context.diff}
+\`\`\`
+`;
+      }
+      process.stdout.write(md);
+      break;
+    }
+    default:
+      process.stderr.write(`ph: unknown format "${format}" \u2014 use txt, json, or md
+`);
+      process.exit(1);
+  }
+}
+async function cmdImport(db, cfg, args) {
+  if (args.length === 0) {
+    process.stderr.write("Usage: ph import <source> [--dry-run] [--analyze]\n");
+    process.exit(1);
+  }
+  const source = args[0];
+  const { flags } = parseFlags(args.slice(1));
+  const dryRun = Boolean(flags["dry-run"]);
+  const analyze = Boolean(flags["analyze"]);
+  const useFilter = Boolean(flags["filter"]);
+  const homeDir = os6.homedir();
+  if (dryRun) console.log("Dry run \u2014 nothing will be written to the database.");
+  let analyzer;
+  if (analyze) {
+    analyzer = getProvider(cfg);
+    if (!analyzer) {
+      process.stderr.write("ph: no LLM provider configured. Run: ph config set analyze-provider ollama\n");
+      process.exit(1);
+    }
+    console.log(`Analyzing with ${analyzer.name} during import...`);
+  }
+  let filter;
+  const existingHashes = dryRun ? /* @__PURE__ */ new Map() : db.getAllPromptHashes();
+  if (useFilter) {
+    filter = new FilterPipeline({
+      minLength: cfg.filterMinLength,
+      minRelevance: analyze ? cfg.filterMinRelevance ?? 3 : 0,
+      existingHashes
+    });
+    console.log(`Filtering enabled (min-length: ${cfg.filterMinLength ?? 15}${analyze ? `, min-relevance: ${cfg.filterMinRelevance ?? 3}` : ""}).`);
+  } else {
+    filter = new FilterPipeline({
+      minLength: 0,
+      minRelevance: 0,
+      existingHashes
+    });
+    filter.checkRules = () => ({ keep: true });
+  }
+  const onProgress = (evaluated, imported, total, current) => {
+    const text = current.length > 50 ? current.slice(0, 47) + "..." : current;
+    process.stdout.write(`\r  [${evaluated}/${total}] (imported: ${imported}) ${text.replace(/\n/g, " ")}`.padEnd(80));
+  };
+  let result;
+  switch (source) {
+    case "gemini":
+      result = await importGeminiHistory(db, path6.join(homeDir, ".gemini"), dryRun, analyzer, onProgress, filter);
+      break;
+    case "claude":
+      result = await importClaudeHistory(db, path6.join(homeDir, ".claude"), dryRun, analyzer, onProgress, filter);
+      break;
+    default:
+      process.stderr.write(`ph: unknown import source "${source}". Supported: gemini, claude
+`);
+      process.exit(1);
+  }
+  if (analyze) process.stdout.write("\n");
+  console.log(`Files scanned:    ${result.filesScanned}`);
+  console.log(`Prompts found:    ${result.promptsFound}`);
+  console.log(`Prompts imported: ${result.promptsImported}`);
+  if (result.filtered > 0) console.log(`Filtered out:     ${result.filtered}`);
+  if (analyze) console.log(`Analyzed:         ${result.promptsImported} prompts tagged`);
+  if (result.skipped > 0) console.log(`Skipped:          ${result.skipped}`);
+  if (result.errors.length > 0) {
+    console.log(`
+Warnings (${result.errors.length}):`);
+    for (const e of result.errors) console.log(`  - ${e}`);
+  }
+  if (!dryRun && result.promptsImported > 0) {
+    console.log(`
+Done! Run \`ph last ${Math.min(result.promptsImported, 20)}\` to review.`);
+  }
+}
+async function cmdAnalyze(db, cfg, args) {
+  const { flags } = parseFlags(args);
+  const force = Boolean(flags["force"]);
+  const dryRun = Boolean(flags["dry-run"]);
+  const prune = Boolean(flags["prune"]);
+  const limitFlag = flags["limit"] ? Number(flags["limit"]) : void 0;
+  const pruneBelow = prune ? flags["min-score"] ? Number(flags["min-score"]) : cfg.filterMinRelevance ?? 3 : 0;
+  const provider = getProvider(cfg);
+  if (!provider) {
+    process.stderr.write("ph: no LLM provider configured. Set analyze-provider in config.\n");
+    process.exit(1);
+  }
+  const allRows = db.search({ limit: 1e4 });
+  const limit = limitFlag ?? (force ? void 0 : 50);
+  const entries = limit !== void 0 ? allRows.slice(0, limit) : allRows;
+  let modeStr = force ? " (--force: reanalyze all)" : " (untagged only)";
+  if (prune) modeStr += dryRun ? ` + prune<${pruneBelow} [dry-run]` : ` + prune<${pruneBelow}`;
+  console.log(`Analyzing with ${provider.name}${modeStr}...`);
+  const stats = await analyzeAll(entries, provider, db, {
+    force,
+    pruneBelow,
+    dryRun,
+    onProgress: (done, total, entry, res, err) => {
+      const truncated = entry.prompt.replace(/\n/g, " ");
+      const short = truncated.length > 40 ? truncated.slice(0, 37) + "..." : truncated;
+      if (err) {
+        console.log(`  [${done}/${total}] #${entry.id} \u2192 error: ${err}`);
+      } else if (res) {
+        const role = res.role || "-";
+        const tags = (res.tags ?? []).join(",") || "-";
+        const relStr = res.relevance !== void 0 ? ` rel:${res.relevance}` : "";
+        console.log(`  [${done}/${total}] #${entry.id} \u2192 role:${role} tags:${tags}${relStr} | ${short}`);
+      }
+    },
+    onPrune: (entry, relevance) => {
+      const short = entry.prompt.replace(/\n/g, " ").slice(0, 50);
+      console.log(`  [prune${dryRun ? " DRY" : ""}] #${entry.id} rel:${relevance} | ${short}`);
+    }
+  });
+  let summary = `
+Done. Updated: ${stats.updated}, Skipped: ${stats.skipped}, Failed: ${stats.failed}`;
+  if (prune) summary += `, Pruned: ${stats.pruned}${dryRun ? " (dry-run, not deleted)" : ""}`;
+  console.log(summary);
+}
+async function cmdEmbedAll(db, cfg) {
+  const ollamaUrl = cfg.ollamaUrl ?? "http://localhost:11434";
+  const model = cfg.ollamaEmbedModel ?? "nomic-embed-text-v2-moe";
+  const toEmbed = db.getPromptsWithoutEmbeddings();
+  if (toEmbed.length === 0) {
+    console.log("No new prompts to embed.");
+    return;
+  }
+  const batchSize = 20;
+  console.log(
+    `Generating embeddings for ${toEmbed.length} prompts via Ollama (${model}), batches of ${batchSize}...`
+  );
+  for (let i = 0; i < toEmbed.length; i += batchSize) {
+    const batch = toEmbed.slice(i, i + batchSize);
+    const texts = batch.map((e) => e.response ? `${e.prompt}
+
+${e.response}` : e.prompt);
+    process.stdout.write(`\r\u2192 ${i + batch.length}/${toEmbed.length}...`);
+    try {
+      const vecs = await getEmbeddings(texts, ollamaUrl, model, batchSize);
+      for (let j = 0; j < vecs.length; j++) {
+        try {
+          db.saveEmbedding(batch[j].id, vecs[j]);
+        } catch (e) {
+          console.log(`
+  ! DB error for #${batch[j].id}: ${e.message}`);
+        }
+      }
+    } catch (e) {
+      console.log(`
+  ! Batch error: ${e.message}`);
+    }
+  }
+  console.log("\nDone!");
+}
+async function cmdLog(dbPath, cfg, args) {
+  let tool;
+  let prompt;
+  let response;
+  let workdir;
+  const { flags } = parseFlags(args);
+  if (flags["prompt"]) {
+    tool = flags["tool"] || "unknown";
+    prompt = flags["prompt"];
+    response = flags["response"] || "";
+    workdir = flags["workdir"] || process.cwd();
+  } else {
+    const chunks = [];
+    for await (const chunk of process.stdin) chunks.push(chunk);
+    const raw = Buffer.concat(chunks).toString("utf-8").trim();
+    if (!raw) {
+      process.stderr.write("ph log: no input (use --prompt or pipe JSON)\n");
+      process.exit(1);
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      process.stderr.write("ph log: invalid JSON on stdin\n");
+      process.exit(1);
+    }
+    tool = parsed["tool"] || flags["tool"] || "unknown";
+    prompt = parsed["prompt"] || "";
+    response = parsed["response"] || "";
+    workdir = parsed["workdir"] || flags["workdir"] || process.cwd();
+    if (!prompt) {
+      process.stderr.write('ph log: missing "prompt" field\n');
+      process.exit(1);
+    }
+  }
+  const { rootDir, projectName } = detectProject(workdir);
+  const language = detectLanguage(rootDir);
+  const metaObj = {};
+  if (projectName) metaObj.project = projectName;
+  if (language) metaObj.language = language;
+  const title = extractTopic(prompt);
+  if (title) metaObj.title = title;
+  const db = new PhDB(dbPath);
+  const id = db.insert({
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    tool,
+    prompt,
+    response,
+    args: "",
+    workdir,
+    hostname: os6.hostname(),
+    exit_code: 0,
+    metadata: JSON.stringify(metaObj)
+  });
+  db.close();
+  if (cfg.backgroundAnalysis) {
+    spawnBackgroundAnalysis(id, dbPath);
+  }
+}
+function cmdConfig(args) {
+  if (args.length < 3 || args[0] !== "set") {
+    console.log("Usage: ph config set <key> <value>");
+    console.log("Keys: gemini-api-key, db-path, analyze-provider, ollama-url, ollama-model,");
+    console.log("      ollama-embed-model, filter-min-length, filter-min-relevance, background-analysis");
+    process.exit(1);
+  }
+  const cfg = load();
+  const key = args[1];
+  const val = args[2];
+  switch (key) {
+    case "gemini-api-key":
+      cfg.geminiApiKey = val;
+      break;
+    case "db-path":
+      cfg.dbPath = val;
+      break;
+    case "analyze-provider":
+      if (val !== "ollama" && val !== "gemini") {
+        process.stderr.write('ph: analyze-provider must be "ollama" or "gemini"\n');
+        process.exit(1);
+      }
+      cfg.analyzeProvider = val;
+      break;
+    case "ollama-url":
+      cfg.ollamaUrl = val;
+      break;
+    case "ollama-model":
+      cfg.ollamaModel = val;
+      break;
+    case "ollama-embed-model":
+      cfg.ollamaEmbedModel = val;
+      break;
+    case "filter-min-length": {
+      const n = Number(val);
+      if (isNaN(n) || n < 0) {
+        process.stderr.write("ph: filter-min-length must be a non-negative integer\n");
+        process.exit(1);
+      }
+      cfg.filterMinLength = n;
+      break;
+    }
+    case "filter-min-relevance": {
+      const n = Number(val);
+      if (isNaN(n) || n < 0 || n > 10) {
+        process.stderr.write("ph: filter-min-relevance must be 0-10\n");
+        process.exit(1);
+      }
+      cfg.filterMinRelevance = n;
+      break;
+    }
+    case "background-analysis":
+      cfg.backgroundAnalysis = val === "true" || val === "1";
+      break;
+    default:
+      process.stderr.write(`ph: unknown config key "${key}"
+`);
+      process.exit(1);
+  }
+  save(cfg);
+  console.log(`Config "${key}" updated successfully.`);
+}
+async function cmdBackgroundAnalyze(dbPath, args) {
+  const id = parseInt(args[0], 10);
+  if (isNaN(id)) return;
+  let finalDbPath = dbPath;
+  const dbIdx = args.indexOf("--db");
+  if (dbIdx !== -1 && dbIdx + 1 < args.length) {
+    finalDbPath = args[dbIdx + 1];
+  }
+  const cfg = load();
+  const provider = getProvider(cfg);
+  if (!provider) return;
+  const db = new PhDB(finalDbPath);
+  try {
+    const entry = db.getById(id);
+    if (!entry) return;
+    const result = await analyzePrompt(entry.prompt, provider);
+    if (Object.keys(result).length === 0) return;
+    let existing = {};
+    try {
+      existing = JSON.parse(entry.metadata);
+    } catch {
+    }
+    const merged = mergeMetadata(existing, result, false);
+    db.updateMetadata(id, JSON.stringify(merged));
+  } catch (_err) {
+  } finally {
+    db.close();
+  }
+}
+async function cmdCleanup(db, cfg, args) {
+  const { flags } = parseFlags(args);
+  const dryRun = Boolean(flags["dry-run"]);
+  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;
+  if (days !== void 0) {
+    if (dryRun) {
+      console.log(`(dry-run) Would delete prompts older than ${days} days.`);
+    } else {
+      const deleted2 = db.deleteOlderThan(days);
+      console.log(`Deleted ${deleted2} prompts older than ${days} days.`);
+    }
+  }
+  const allEntries = db.search({ limit: 1e5 });
+  console.log(`Scanning ${allEntries.length} prompts for rule-based cleanup (min-length: ${minLength}, min-score: ${minScore})...`);
+  const toDelete = [];
+  const existingHashes = /* @__PURE__ */ new Map();
+  const filter = new FilterPipeline({ minLength, minRelevance: 0, existingHashes });
+  for (const entry of allEntries) {
+    const ruleResult = filter.checkRules(entry.prompt);
+    if (!ruleResult.keep) {
+      toDelete.push({ id: entry.id, prompt: entry.prompt, reason: `${ruleResult.reason}: ${ruleResult.details ?? ""}` });
+      continue;
+    }
+    const hash = FilterPipeline.hashPrompt(entry.prompt);
+    if (existingHashes.has(hash)) {
+      const dupId = existingHashes.get(hash);
+      toDelete.push({ id: entry.id, prompt: entry.prompt, reason: `exact_duplicate of #${dupId}` });
+      continue;
+    }
+    existingHashes.set(hash, entry.id);
+    if (minScore > 0) {
+      let meta = {};
+      try {
+        meta = JSON.parse(entry.metadata);
+      } catch {
+      }
+      if (meta.relevance !== void 0 && meta.relevance < minScore) {
+        toDelete.push({ id: entry.id, prompt: entry.prompt, reason: `low_relevance: ${meta.relevance} < ${minScore}` });
+      }
+    }
+  }
+  if (toDelete.length === 0) {
+    if (days === void 0) console.log("Nothing else to clean up.");
+    return;
+  }
+  console.log(`
+Candidates for rule-based deletion: ${toDelete.length}`);
+  for (const item of toDelete.slice(0, 30)) {
+    const short = item.prompt.replace(/\n/g, " ").slice(0, 60);
+    console.log(`  #${String(item.id).padEnd(5)} [${item.reason}] "${short}"`);
+  }
+  if (toDelete.length > 30) {
+    console.log(`  ... and ${toDelete.length - 30} more`);
+  }
+  if (dryRun) {
+    console.log(`
+(dry-run) Would delete ${toDelete.length} more prompts. Run without --dry-run to apply.`);
+    return;
+  }
+  const ids = toDelete.map((e) => e.id);
+  const deleted = db.deleteByIds(ids);
+  console.log(`
+Deleted ${deleted} prompts.`);
+}
+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 allEntries = db.search({ limit: 1e5 });
+  const entriesAsc = [...allEntries].reverse();
+  const sessions = groupIntoSessions(entriesAsc, gapHours);
+  let embeddings = null;
+  if (!noCohesion) {
+    embeddings = db.getAllEmbeddings();
+  }
+  for (const session of sessions) {
+    if (embeddings) {
+      session.cohesion = computeSessionCohesion(session, embeddings);
+    }
+  }
+  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;
+  }
+  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 {
+      }
+      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);
+    }
+    const total = session.entries.length;
+    let dominantProject = null;
+    let dominantLanguage = null;
+    for (const [proj, count] of projectCounts) {
+      if (count / total > 0.5) {
+        dominantProject = proj;
+        break;
+      }
+    }
+    for (const [lang, count] of languageCounts) {
+      if (count / total > 0.5) {
+        dominantLanguage = lang;
+        break;
+      }
+    }
+    const startStr = fmtDate(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}`;
+    header += `  ${C2.gray}\xB7${C2.reset}  ${startStr}  \u2192  ${endStr}`;
+    header += `  ${C2.gray}\xB7${C2.reset}  ${C2.yellow}${session.entries.length} ${promptWord}${C2.reset}`;
+    if (dominantProject && dominantLanguage) {
+      header += `  ${C2.gray}\xB7  [${dominantProject}:${dominantLanguage}]${C2.reset}`;
+    } else if (dominantProject) {
+      header += `  ${C2.gray}\xB7  [${dominantProject}]${C2.reset}`;
+    } else if (dominantLanguage) {
+      header += `  ${C2.gray}\xB7  [${dominantLanguage}]${C2.reset}`;
+    }
+    if (session.cohesion !== null) {
+      header += `  ${C2.gray}\xB7  cohesion: ${session.cohesion.toFixed(2)}${C2.reset}`;
+    }
+    process.stdout.write(header + "\n");
+    for (const entry of session.entries) {
+      let meta = {};
+      try {
+        meta = JSON.parse(entry.metadata);
+      } catch {
+      }
+      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}`;
+      let rolePart = "";
+      if (meta.role) rolePart = `  ${C2.magenta}{${meta.role}}${C2.reset}`;
+      let tagsPart = "";
+      if (meta.tags && meta.tags.length > 0) tagsPart = `  ${C2.cyan}(${meta.tags.join(", ")})${C2.reset}`;
+      const preview = entry.prompt.replace(/\n/g, " ").slice(0, 80);
+      process.stdout.write(`  ${idStr}  ${toolStr}  ${timeStr}${rolePart}${tagsPart}  ${preview}
+`);
+    }
+    process.stdout.write("\n");
+  }
+}
+async function cmdStats(db) {
+  const stats = getStats(db);
+  const C2 = {
+    reset: "\x1B[0m",
+    cyan: "\x1B[36m",
+    yellow: "\x1B[33m",
+    green: "\x1B[32m",
+    gray: "\x1B[90m",
+    magenta: "\x1B[35m"
+  };
+  console.log(`${C2.cyan}ph \u2014 Prompt History Statistics${C2.reset}
+`);
+  console.log(`  Total prompts:  ${C2.yellow}${stats.total}${C2.reset}`);
+  console.log(`  Analyzed:       ${C2.yellow}${stats.analyzed}${C2.reset} (${Math.round(stats.analyzed / (stats.total || 1) * 100)}%)`);
+  console.log(`  Starred:        ${C2.yellow}${stats.starred}${C2.reset}`);
+  if (stats.avgRelevance > 0 || stats.avgQuality > 0) {
+    console.log(`
+${C2.cyan}Global Scores:${C2.reset}`);
+    console.log(`  - Avg Relevance: ${C2.yellow}${stats.avgRelevance.toFixed(1)}/10${C2.reset}`);
+    console.log(`  - Avg Quality:   ${C2.yellow}${stats.avgQuality.toFixed(1)}/10${C2.reset}`);
+  }
+  console.log(`
+${C2.cyan}By Tool:${C2.reset}`);
+  Object.entries(stats.byTool).sort((a, b) => b[1] - a[1]).forEach(([tool, count]) => {
+    console.log(`  - ${tool.padEnd(12)}: ${C2.yellow}${count}${C2.reset}`);
+  });
+  if (Object.keys(stats.byProject).length > 0) {
+    console.log(`
+${C2.cyan}Top Projects:${C2.reset}`);
+    Object.entries(stats.byProject).sort((a, b) => b[1] - a[1]).slice(0, 10).forEach(([proj, count]) => {
+      console.log(`  - ${proj.padEnd(20)}: ${C2.yellow}${count}${C2.reset}`);
+    });
+  }
+  if (Object.keys(stats.byLanguage).length > 0) {
+    console.log(`
+${C2.cyan}Top Languages:${C2.reset}`);
+    Object.entries(stats.byLanguage).sort((a, b) => b[1] - a[1]).slice(0, 10).forEach(([lang, count]) => {
+      console.log(`  - ${lang.padEnd(12)}: ${C2.yellow}${count}${C2.reset}`);
+    });
+  }
+  if (Object.keys(stats.byRole).length > 0) {
+    console.log(`
+${C2.cyan}By Role:${C2.reset}`);
+    Object.entries(stats.byRole).sort((a, b) => b[1] - a[1]).forEach(([role, count]) => {
+      console.log(`  - ${role.padEnd(12)}: ${C2.yellow}${count}${C2.reset}`);
+    });
+  }
+  console.log();
+}
+async function cmdCluster(db, args) {
+  const { flags } = parseFlags(args);
+  const k = Number(flags["k"] ?? 5);
+  const limitPerCluster = Number(flags["limit"] ?? 3);
+  const embeddings = db.getAllEmbeddings();
+  if (embeddings.size === 0) {
+    console.error("ph: no embeddings found. Run `ph embed-all` first.");
+    return;
+  }
+  console.log(`Clustering ${embeddings.size} prompts into ${k} groups...`);
+  const clusters = kmeans(embeddings, k);
+  const C2 = {
+    reset: "\x1B[0m",
+    cyan: "\x1B[36m",
+    yellow: "\x1B[33m",
+    gray: "\x1B[90m"
+  };
+  clusters.forEach((cluster, i) => {
+    if (cluster.entryIds.length === 0) return;
+    console.log(`
+${C2.cyan}Cluster #${i + 1}${C2.reset} (${C2.yellow}${cluster.entryIds.length} prompts${C2.reset})`);
+    const examples = cluster.entryIds.slice(0, limitPerCluster);
+    examples.forEach((id) => {
+      const entry = db.getById(id);
+      if (entry) {
+        const preview = entry.prompt.replace(/\n/g, " ").slice(0, 80);
+        console.log(`  ${C2.gray}#${entry.id}${C2.reset}  ${preview}`);
+      }
+    });
+    if (cluster.entryIds.length > limitPerCluster) {
+      console.log(`  ${C2.gray}... and ${cluster.entryIds.length - limitPerCluster} more${C2.reset}`);
+    }
+  });
+  console.log();
+}
+async function cmdAnalyzeReusability(db, args) {
+  const { flags } = parseFlags(args);
+  const threshold = flags["threshold"] ? Number(flags["threshold"]) : 0.7;
+  const exportCsv = flags["export-csv"];
+  const entries = db.getAllPrompts();
+  const embeddings = db.getAllEmbeddings();
+  if (embeddings.size === 0) {
+    console.warn("ph: no embeddings found. Uniqueness score will be 1.0 for all. Run `ph embed-all` first.");
+  }
+  console.log(`Scanning ${entries.length} prompts...`);
+  const analyzer = new ReusabilityAnalyzer(threshold);
+  const report = analyzer.analyze(entries, embeddings);
+  const C2 = {
+    reset: "\x1B[0m",
+    cyan: "\x1B[36m",
+    yellow: "\x1B[33m",
+    green: "\x1B[32m",
+    red: "\x1B[31m",
+    gray: "\x1B[90m",
+    bold: "\x1B[1m"
+  };
+  console.log(`
+${C2.bold}SUMMARY:${C2.reset}`);
+  console.log(`  - ${C2.green}KEEP${C2.reset} (score 7+):     ${C2.yellow}${report.keep.length}${C2.reset} prompts (${(report.keep.length / report.total * 100).toFixed(1)}%)`);
+  console.log(`  - ${C2.cyan}REVIEW${C2.reset} (score 4-7):   ${C2.yellow}${report.review.length}${C2.reset} prompts (${(report.review.length / report.total * 100).toFixed(1)}%)`);
+  console.log(`  - ${C2.red}REMOVE${C2.reset} (score <4):   ${C2.yellow}${report.remove.length}${C2.reset} prompts (${(report.remove.length / report.total * 100).toFixed(1)}%)`);
+  console.log(`
+${C2.bold}BY ROLE:${C2.reset}`);
+  const roles = Object.keys(report.byRole).sort();
+  for (const role of roles) {
+    const r = report.byRole[role];
+    const roleStr = role.padEnd(12);
+    console.log(`  ${C2.gray}${roleStr}${C2.reset} | KEEP: ${C2.green}${r.keep.toString().padEnd(4)}${C2.reset} REVIEW: ${C2.cyan}${r.review.toString().padEnd(4)}${C2.reset} REMOVE: ${C2.red}${r.remove.toString().padEnd(4)}${C2.reset}`);
+  }
+  console.log(`
+${C2.bold}DUPLICATES FOUND:${C2.reset}`);
+  console.log(`  - Exact semantic (sim > 0.95): ${C2.yellow}${report.duplicates.exact}${C2.reset} prompts`);
+  console.log(`  - Variant clusters (sim 0.85-0.95): ${C2.yellow}${report.duplicates.variants}${C2.reset} prompts`);
+  console.log(`
+${C2.bold}TOP 10 KEEP (unique + high score):${C2.reset}`);
+  report.keep.slice(0, 10).forEach((s) => {
+    const scoreStr = s.score.toFixed(1).padStart(4);
+    console.log(`  [${C2.green}${scoreStr}${C2.reset}] ${s.prompt.replace(/\n/g, " ").slice(0, 80)}...`);
+  });
+  console.log(`
+${C2.bold}TOP 10 REMOVE (low score + duplicate):${C2.reset}`);
+  report.remove.slice(0, 10).forEach((s) => {
+    const scoreStr = s.score.toFixed(1).padStart(4);
+    console.log(`  [${C2.red}${scoreStr}${C2.reset}] ${s.prompt.replace(/\n/g, " ").slice(0, 80)}...`);
+  });
+  if (exportCsv) {
+    fs7.writeFileSync(exportCsv, analyzer.toCSV(report));
+    console.log(`
+${C2.green}\u2705 Report exported to ${exportCsv}${C2.reset}`);
+  }
+  console.log();
+}
+async function cmdCleanupReusability(db, cfg, args) {
+  const { flags } = parseFlags(args);
+  const threshold = flags["threshold"] ? parseFloat(flags["threshold"]) : 0.7;
+  const dryRun = Boolean(flags["dry-run"]);
+  const force = Boolean(flags["force"]);
+  const entries = db.getAllPrompts();
+  const embeddings = db.getAllEmbeddings();
+  const analyzer = new ReusabilityAnalyzer(threshold);
+  const candidates = analyzer.getRemovalCandidates(entries, embeddings, threshold);
+  if (candidates.length === 0) {
+    console.log("ph: no prompts match removal criteria");
+    return;
+  }
+  const totalSize = candidates.reduce((sum, c) => sum + c.promptSize + c.responseSize, 0);
+  const totalEmbeddingSize = candidates.filter((c) => c.hasEmbedding).length * 768 * 4;
+  const totalToFree = totalSize + totalEmbeddingSize;
+  const C2 = {
+    reset: "\x1B[0m",
+    cyan: "\x1B[36m",
+    yellow: "\x1B[33m",
+    red: "\x1B[31m",
+    gray: "\x1B[90m",
+    bold: "\x1B[1m"
+  };
+  const removeThreshold = Math.max(0, threshold - 0.3) * 10;
+  const dbCount = entries.length;
+  console.log(`
+Would delete ${C2.red}${candidates.length}${C2.reset} prompts (${(candidates.length / dbCount * 100).toFixed(1)}% of database):`);
+  console.log(`  - By score < ${removeThreshold.toFixed(1)}: ${candidates.length} prompts`);
+  const byRole = {};
+  for (const c of candidates) {
+    byRole[c.role] = (byRole[c.role] ?? 0) + 1;
+  }
+  const roleSummary = Object.entries(byRole).sort((a, b) => b[1] - a[1]).map(([role, count]) => `${role} (${count})`).join(", ");
+  console.log(`  - By role (mostly): ${roleSummary}`);
+  console.log(`
+Storage impact:`);
+  console.log(`  - Prompt text:   ~${(candidates.reduce((sum, c) => sum + c.promptSize, 0) / 1024 / 1024).toFixed(2)} MB`);
+  console.log(`  - Response text: ~${(candidates.reduce((sum, c) => sum + c.responseSize, 0) / 1024 / 1024).toFixed(2)} MB`);
+  console.log(`  - Embeddings:    ~${(totalEmbeddingSize / 1024 / 1024).toFixed(2)} MB`);
+  console.log(`  Total to free:   ~${(totalToFree / 1024 / 1024).toFixed(2)} MB`);
+  if (candidates.length > 0) {
+    console.log(`
+${C2.bold}Example candidates (top 20):${C2.reset}`);
+    candidates.slice(0, 20).forEach((c) => {
+      const entry = entries.find((e) => e.id === c.id);
+      if (entry) {
+        const preview = entry.prompt.replace(/\n/g, " ").slice(0, 80);
+        console.log(`  [${C2.red}${c.score.toFixed(1)}${C2.reset}] #${entry.id} ${preview}...`);
+      }
+    });
+  }
+  if (dryRun) {
+    console.log(`
+Run with ${C2.bold}--force${C2.reset} or without ${C2.bold}--dry-run${C2.reset} to proceed.`);
+    return;
+  }
+  if (!force) {
+    process.stdout.write(`
+Continue and delete ${candidates.length} prompts? (y/N) `);
+    const buffer = Buffer.alloc(16);
+    const bytesRead = fs7.readSync(0, buffer, 0, 16);
+    const answer = buffer.toString("utf8", 0, bytesRead).trim().toLowerCase();
+    if (answer !== "y" && answer !== "yes") {
+      console.log("Aborted.");
+      return;
+    }
+  }
+  let deleted = 0;
+  for (const candidate of candidates) {
+    db.delete(candidate.id);
+    deleted++;
+  }
+  console.log(`
+Deleted ${deleted} prompts, freed ~${(totalToFree / 1024 / 1024).toFixed(1)} MB`);
+  db.vacuum();
+  console.log("Database vacuumed.");
+}
+async function cmdWrap(dbPath, tool, args, cfg) {
+  let debugLog;
+  let role;
+  const tags = [];
+  const cleanArgs = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--ph-debug") {
+      debugLog = path6.join(os6.homedir(), ".ph_debug.log");
+      process.stderr.write(`ph: debug log \u2192 ${debugLog}
+`);
+    } else if (args[i] === "--ph-tag" && i + 1 < args.length) {
+      tags.push(args[i + 1]);
+      i++;
+    } else if (args[i].startsWith("--ph-tag=")) {
+      tags.push(args[i].slice("--ph-tag=".length));
+    } else if (args[i] === "--ph-role" && i + 1 < args.length) {
+      role = args[i + 1];
+      i++;
+    } else if (args[i].startsWith("--ph-role=")) {
+      role = args[i].slice("--ph-role=".length);
+    } else {
+      cleanArgs.push(args[i]);
+    }
+  }
+  let realBin;
+  try {
+    realBin = resolveRealBinary(tool);
+  } catch (e) {
+    process.stderr.write(`ph: cannot find "${tool}": ${e.message}
+`);
+    process.exit(1);
+  }
+  const interactive = cleanArgs.length === 0 && isTerminal();
+  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 = {};
+      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({
+        timestamp: ts.toISOString(),
+        tool,
+        prompt,
+        response: "",
+        args: prompt,
+        workdir,
+        hostname: os6.hostname(),
+        exit_code: 0,
+        metadata
+      });
+    };
+    const onResponse = (id, response) => {
+      if (!response.trim()) return;
+      db.updateResponse(id, response);
+      if (cfg.backgroundAnalysis) {
+        spawnBackgroundAnalysis(id, dbPath);
+      }
+    };
+    const exitCode = await runPTY(realBin, cleanArgs, onPrompt, onResponse, debugLog);
+    db.close();
+    process.exit(exitCode);
+  } else {
+    await runInline(realBin, cleanArgs, db, tool, tags, role, (id) => {
+      if (cfg.backgroundAnalysis) {
+        spawnBackgroundAnalysis(id, dbPath);
+      }
+    });
+  }
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  const cfg = load();
+  if (cfg.geminiApiKey) {
+    process.env.GEMINI_API_KEY = cfg.geminiApiKey;
+  }
+  const dbPath = process.env.PH_DB ?? cfg.dbPath ?? defaultPath();
+  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 = spawnSync(realBin, [prompt], { stdio: "inherit" });
+        process.exit(child.status ?? 0);
+      }
+      process.exit(0);
+    } else {
+      process.stdout.write(USAGE);
+      process.exit(0);
+    }
+  }
+  let cmdIdx = -1;
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i].startsWith("-")) {
+      if (argv[i] === "--ph-tag" || argv[i] === "--ph-role") i++;
+      continue;
+    }
+    cmdIdx = i;
+    break;
+  }
+  if (cmdIdx === -1) {
+    process.stdout.write(USAGE);
+    process.exit(0);
+  }
+  const command = argv[cmdIdx];
+  const cmdArgs = argv.slice(cmdIdx + 1);
+  const preArgs = argv.slice(0, cmdIdx);
+  switch (command) {
+    case "search": {
+      const { flags, positional } = parseFlags(cmdArgs);
+      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 = spawnSync(realBin, [prompt], { stdio: "inherit" });
+          process.exit(child.status ?? 0);
+        }
+        break;
+      }
+      const db = new PhDB(dbPath);
+      await cmdSearch(db, cfg, cmdArgs);
+      db.close();
+      break;
+    }
+    case "last": {
+      const db = new PhDB(dbPath);
+      await cmdLast(db, cmdArgs);
+      db.close();
+      break;
+    }
+    case "sessions": {
+      const db = new PhDB(dbPath);
+      await cmdSessions(db, cmdArgs);
+      db.close();
+      break;
+    }
+    case "stats": {
+      const db = new PhDB(dbPath);
+      await cmdStats(db);
+      db.close();
+      break;
+    }
+    case "cluster": {
+      const db = new PhDB(dbPath);
+      await cmdCluster(db, cmdArgs);
+      db.close();
+      break;
+    }
+    case "analyze-reusability": {
+      const db = new PhDB(dbPath);
+      await cmdAnalyzeReusability(db, cmdArgs);
+      db.close();
+      break;
+    }
+    case "cleanup-reusability": {
+      const db = new PhDB(dbPath);
+      await cmdCleanupReusability(db, cfg, cmdArgs);
+      db.close();
+      break;
+    }
+    case "star": {
+      const db = new PhDB(dbPath);
+      await cmdStar(db, cmdArgs);
+      db.close();
+      break;
+    }
+    case "export": {
+      const db = new PhDB(dbPath);
+      await cmdExport(db, cmdArgs);
+      db.close();
+      break;
+    }
+    case "import": {
+      const db = new PhDB(dbPath);
+      await cmdImport(db, cfg, cmdArgs);
+      db.close();
+      break;
+    }
+    case "analyze": {
+      const db = new PhDB(dbPath);
+      await cmdAnalyze(db, cfg, cmdArgs);
+      db.close();
+      break;
+    }
+    case "log": {
+      await cmdLog(dbPath, cfg, cmdArgs);
+      break;
+    }
+    case "embed-all": {
+      const db = new PhDB(dbPath);
+      await cmdEmbedAll(db, cfg);
+      db.close();
+      break;
+    }
+    case "cleanup": {
+      const db = new PhDB(dbPath);
+      await cmdCleanup(db, cfg, cmdArgs);
+      db.close();
+      break;
+    }
+    case "config":
+      cmdConfig(cmdArgs);
+      break;
+    case "_bg-analyze": {
+      await cmdBackgroundAnalyze(dbPath, cmdArgs);
+      break;
+    }
+    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 = spawnSync(realBin, [prompt], { stdio: "inherit" });
+        process.exit(child.status ?? 0);
+      }
+      break;
+    }
+    case "ollama-models": {
+      const ollamaUrl = cfg.ollamaUrl ?? "http://localhost:11434";
+      try {
+        const res = await fetch(`${ollamaUrl}/api/tags`);
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        const data = await res.json();
+        const models = (data.models ?? []).map((m) => m.name).filter(Boolean);
+        if (models.length === 0) {
+          console.log("No models found.");
+        } else {
+          console.log(`Available Ollama models at ${ollamaUrl}:`);
+          for (const m of models) console.log(`  ${m}`);
+        }
+      } catch (err) {
+        process.stderr.write(`ph: cannot reach Ollama at ${ollamaUrl}: ${err.message}
+`);
+        process.exit(1);
+      }
+      break;
+    }
+    case "help":
+    case "--help":
+    case "-h":
+      process.stdout.write(USAGE);
+      break;
+    default:
+      await cmdWrap(dbPath, command, [...preArgs, ...cmdArgs], cfg);
+      break;
+  }
+}
+main().catch((e) => {
+  process.stderr.write(`ph: ${e.message}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map