@askexenow/exe-os 0.8.32 → 0.8.36

package/dist/bin/backfill-conversations.js

@@ -262,7 +262,7 @@ function listShards() {
 }
 async function ensureShardSchema(client) {
   await client.execute("PRAGMA journal_mode = WAL");
-  await client.execute("PRAGMA busy_timeout = 5000");
+  await client.execute("PRAGMA busy_timeout = 30000");
   try {
     await client.execute("PRAGMA libsql_vector_search_ef = 128");
   } catch {
@@ -446,124 +446,79 @@ var init_shard_manager = __esm({
   }
 });
 
-// src/lib/employees.ts
-var employees_exports = {};
-__export(employees_exports, {
-  EMPLOYEES_PATH: () => EMPLOYEES_PATH,
-  addEmployee: () => addEmployee,
-  getEmployee: () => getEmployee,
-  loadEmployees: () => loadEmployees,
-  registerBinSymlinks: () => registerBinSymlinks,
-  saveEmployees: () => saveEmployees,
-  validateEmployeeName: () => validateEmployeeName
-});
-import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { existsSync as existsSync5, symlinkSync, readlinkSync } from "fs";
-import { execSync } from "child_process";
-import path5 from "path";
-function validateEmployeeName(name) {
-  if (!name) {
-    return { valid: false, error: "Name is required" };
-  }
-  if (name.length > 32) {
-    return { valid: false, error: "Name must be 32 characters or fewer" };
-  }
-  if (!/^[a-z][a-z0-9]*$/.test(name)) {
-    return {
-      valid: false,
-      error: "Name must start with a letter and contain only lowercase alphanumeric characters"
-    };
-  }
-  return { valid: true };
-}
-async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync5(employeesPath)) {
-    return [];
-  }
-  const raw = await readFile3(employeesPath, "utf-8");
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return [];
-  }
-}
-async function saveEmployees(employees, employeesPath = EMPLOYEES_PATH) {
-  await mkdir3(path5.dirname(employeesPath), { recursive: true });
-  await writeFile3(employeesPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
-}
-function getEmployee(employees, name) {
-  return employees.find((e) => e.name.toLowerCase() === name.toLowerCase());
-}
-function addEmployee(employees, employee) {
-  const normalized = { ...employee, name: employee.name.toLowerCase() };
-  if (employees.some((e) => e.name.toLowerCase() === normalized.name)) {
-    throw new Error(`Employee '${normalized.name}' already exists`);
-  }
-  return [...employees, normalized];
-}
-function registerBinSymlinks(name) {
-  const created = [];
-  const skipped = [];
-  const errors = [];
-  let exeBinPath;
-  try {
-    exeBinPath = execSync("which exe", { encoding: "utf-8" }).trim();
-  } catch {
-    errors.push("Could not find 'exe' in PATH");
-    return { created, skipped, errors };
-  }
-  const binDir = path5.dirname(exeBinPath);
-  let target;
-  try {
-    target = readlinkSync(exeBinPath);
-  } catch {
-    errors.push("Could not read 'exe' symlink");
-    return { created, skipped, errors };
-  }
-  for (const suffix of ["", "-opencode"]) {
-    const linkName = `${name}${suffix}`;
-    const linkPath = path5.join(binDir, linkName);
-    if (existsSync5(linkPath)) {
-      skipped.push(linkName);
-      continue;
-    }
-    try {
-      symlinkSync(target, linkPath);
-      created.push(linkName);
-    } catch (err) {
-      errors.push(`${linkName}: ${err instanceof Error ? err.message : String(err)}`);
-    }
-  }
-  return { created, skipped, errors };
-}
-var EMPLOYEES_PATH;
-var init_employees = __esm({
-  "src/lib/employees.ts"() {
-    "use strict";
-    init_config();
-    EMPLOYEES_PATH = path5.join(EXE_AI_DIR, "exe-employees.json");
-  }
-});
-
 // src/bin/backfill-conversations.ts
 import crypto2 from "crypto";
 import { createReadStream } from "fs";
 import { readdir, stat } from "fs/promises";
-import path6 from "path";
+import path5 from "path";
 import { createInterface } from "readline";
 import { homedir } from "os";
+import { parseArgs } from "util";
 
 // src/types/memory.ts
 var EMBEDDING_DIM = 1024;
 
 // src/lib/database.ts
 import { createClient } from "@libsql/client";
+
+// src/lib/db-retry.ts
+var MAX_RETRIES = 3;
+var BASE_DELAY_MS = 200;
+var MAX_JITTER_MS = 300;
+function isBusyError(err) {
+  if (err instanceof Error) {
+    const msg = err.message.toLowerCase();
+    return msg.includes("sqlite_busy") || msg.includes("database is locked");
+  }
+  return false;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function retryOnBusy(fn, label) {
+  let lastError;
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (!isBusyError(err) || attempt === MAX_RETRIES) {
+        throw err;
+      }
+      const backoff = BASE_DELAY_MS * Math.pow(2, attempt);
+      const jitter = Math.floor(Math.random() * MAX_JITTER_MS);
+      process.stderr.write(
+        `[exe-os] SQLITE_BUSY ${label} retry ${attempt + 1}/${MAX_RETRIES} \u2014 waiting ${backoff + jitter}ms
+`
+      );
+      await delay(backoff + jitter);
+    }
+  }
+  throw lastError;
+}
+function wrapWithRetry(client) {
+  return new Proxy(client, {
+    get(target, prop, receiver) {
+      if (prop === "execute") {
+        return (sql) => retryOnBusy(() => target.execute(sql), "execute");
+      }
+      if (prop === "batch") {
+        return (stmts) => retryOnBusy(() => target.batch(stmts), "batch");
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+
+// src/lib/database.ts
 var _client = null;
+var _resilientClient = null;
 var initTurso = initDatabase;
 async function initDatabase(config) {
   if (_client) {
     _client.close();
     _client = null;
+    _resilientClient = null;
   }
   const opts = {
     url: `file:${config.dbPath}`
@@ -572,17 +527,24 @@ async function initDatabase(config) {
     opts.encryptionKey = config.encryptionKey;
   }
   _client = createClient(opts);
+  _resilientClient = wrapWithRetry(_client);
 }
 function getClient() {
+  if (!_resilientClient) {
+    throw new Error("Database client not initialized. Call initDatabase() first.");
+  }
+  return _resilientClient;
+}
+function getRawClient() {
   if (!_client) {
     throw new Error("Database client not initialized. Call initDatabase() first.");
   }
   return _client;
 }
 async function ensureSchema() {
-  const client = getClient();
+  const client = getRawClient();
   await client.execute("PRAGMA journal_mode = WAL");
-  await client.execute("PRAGMA busy_timeout = 5000");
+  await client.execute("PRAGMA busy_timeout = 30000");
   try {
     await client.execute("PRAGMA libsql_vector_search_ef = 128");
   } catch {
@@ -1831,11 +1793,11 @@ async function connectEmbedDaemon() {
     }
   }
   const start = Date.now();
-  let delay = 100;
+  let delay2 = 100;
   while (Date.now() - start < CONNECT_TIMEOUT_MS) {
-    await new Promise((r) => setTimeout(r, delay));
+    await new Promise((r) => setTimeout(r, delay2));
     if (await connectToSocket()) return true;
-    delay = Math.min(delay * 2, 3e3);
+    delay2 = Math.min(delay2 * 2, 3e3);
   }
   return false;
 }
@@ -1927,11 +1889,11 @@ async function embedViaClient(text, priority = "high") {
 `);
       killAndRespawnDaemon();
       const start = Date.now();
-      let delay = 200;
+      let delay2 = 200;
       while (Date.now() - start < CONNECT_TIMEOUT_MS) {
-        await new Promise((r) => setTimeout(r, delay));
+        await new Promise((r) => setTimeout(r, delay2));
         if (await connectToSocket()) break;
-        delay = Math.min(delay * 2, 3e3);
+        delay2 = Math.min(delay2 * 2, 3e3);
       }
       if (!_connected) return null;
     }
@@ -1943,11 +1905,11 @@ async function embedViaClient(text, priority = "high") {
 `);
     killAndRespawnDaemon();
     const start = Date.now();
-    let delay = 200;
+    let delay2 = 200;
     while (Date.now() - start < CONNECT_TIMEOUT_MS) {
-      await new Promise((r) => setTimeout(r, delay));
+      await new Promise((r) => setTimeout(r, delay2));
       if (await connectToSocket()) break;
-      delay = Math.min(delay * 2, 3e3);
+      delay2 = Math.min(delay2 * 2, 3e3);
     }
     if (!_connected) return null;
     const retry = await sendRequest([text], priority);
@@ -1973,9 +1935,11 @@ function isMainModule(importMetaUrl) {
 }
 
 // src/bin/backfill-conversations.ts
-process.env.EXE_EMBED_PRIORITY = "low";
-async function findJsonlFiles(cutoffMs) {
-  const projectsDir = path6.join(homedir(), ".claude", "projects");
+var TOOL_NAME = "backfill-conversation";
+var MIN_MESSAGES = 3;
+var MAX_SUMMARY_LENGTH = 4e3;
+async function findJsonlFiles(sinceDate, projectFilter) {
+  const projectsDir = path5.join(homedir(), ".claude", "projects");
   const files = [];
   async function walk(dir) {
     let entries;
@@ -1985,61 +1949,67 @@ async function findJsonlFiles(cutoffMs) {
       return;
     }
     for (const entry of entries) {
-      const full = path6.join(dir, entry.name);
+      const full = path5.join(dir, entry.name);
       if (entry.isDirectory()) {
+        if (entry.name === "subagents" || entry.name === "tool-results") continue;
         await walk(full);
       } else if (entry.name.endsWith(".jsonl")) {
         try {
           const s = await stat(full);
-          if (s.mtimeMs >= cutoffMs) files.push(full);
+          if (sinceDate && s.mtimeMs < sinceDate.getTime()) continue;
+          files.push(full);
         } catch {
         }
       }
     }
   }
-  await walk(projectsDir);
+  if (projectFilter) {
+    let projectDirs;
+    try {
+      projectDirs = await readdir(projectsDir, { withFileTypes: true });
+    } catch {
+      return files;
+    }
+    for (const entry of projectDirs) {
+      if (!entry.isDirectory()) continue;
+      const decoded = decodeProjectDir(entry.name);
+      if (decoded.toLowerCase().includes(projectFilter.toLowerCase())) {
+        await walk(path5.join(projectsDir, entry.name));
+      }
+    }
+  } else {
+    await walk(projectsDir);
+  }
   return files;
 }
-function projectNameFromPath(filePath) {
-  const projectsDir = path6.join(homedir(), ".claude", "projects");
-  const relative = path6.relative(projectsDir, filePath);
-  const projectDir = relative.split(path6.sep)[0] ?? relative;
+function decodeProjectDir(dirName) {
   const homeEncoded = homedir().replaceAll("/", "-");
-  if (projectDir.startsWith(homeEncoded + "-")) {
-    return projectDir.slice(homeEncoded.length + 1);
+  if (dirName.startsWith(homeEncoded + "-")) {
+    return dirName.slice(homeEncoded.length + 1);
   }
-  if (projectDir === homeEncoded) return "home";
-  return projectDir;
+  if (dirName === homeEncoded) return "home";
+  return dirName;
 }
-function extractAssistantText(content) {
-  if (typeof content === "string") return content;
-  const texts = [];
-  for (const block of content) {
-    if (block.type === "text" && block.text) {
-      texts.push(block.text);
-    }
-  }
-  return texts.join("\n");
-}
-function extractUserText(content) {
-  if (typeof content === "string") return content;
-  const texts = [];
-  for (const block of content) {
-    if (block.type === "text" && block.text) {
-      texts.push(block.text);
-    }
-  }
-  return texts.join("\n");
+function projectNameFromPath(filePath) {
+  const projectsDir = path5.join(homedir(), ".claude", "projects");
+  const relative = path5.relative(projectsDir, filePath);
+  const projectDir = relative.split(path5.sep)[0] ?? "unknown";
+  return decodeProjectDir(projectDir);
 }
-async function extractConversationPairs(filePath, projectFilter) {
-  const fallbackProject = projectNameFromPath(filePath);
-  if (projectFilter && !fallbackProject.toLowerCase().includes(projectFilter.toLowerCase())) {
-    return [];
-  }
-  const pairs = [];
-  let fileCwd = "";
-  let fileSessionId = "";
-  let pendingUser = null;
+async function parseConversation(filePath) {
+  const conv = {
+    sessionId: path5.basename(filePath, ".jsonl"),
+    projectName: projectNameFromPath(filePath),
+    cwd: void 0,
+    startTime: void 0,
+    endTime: void 0,
+    userMessages: [],
+    toolCounts: {},
+    filesTouched: /* @__PURE__ */ new Set(),
+    errorCount: 0,
+    totalMessages: 0,
+    agentId: "default"
+  };
   const rl = createInterface({
     input: createReadStream(filePath, { encoding: "utf8" }),
     crlfDelay: Infinity
@@ -2052,251 +2022,265 @@ async function extractConversationPairs(filePath, projectFilter) {
     } catch {
       continue;
     }
-    if (entry.cwd) fileCwd = entry.cwd;
-    if (entry.sessionId) fileSessionId = entry.sessionId;
-    if (entry.type === "user" && entry.message?.content) {
-      const text = extractUserText(entry.message.content);
-      if (text.trim()) {
-        pendingUser = {
-          text,
-          timestamp: entry.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
-          uuid: entry.uuid ?? ""
-        };
+    if (entry.cwd && typeof entry.cwd === "string") {
+      conv.cwd = entry.cwd;
+    }
+    const ts = entry.timestamp;
+    if (ts) {
+      if (!conv.startTime || ts < conv.startTime) conv.startTime = ts;
+      if (!conv.endTime || ts > conv.endTime) conv.endTime = ts;
+    }
+    const entryType = entry.type;
+    if (entryType === "user") {
+      conv.totalMessages++;
+      const message = entry.message;
+      if (message?.content) {
+        const text = extractUserText(message.content);
+        if (text && text.length > 10) {
+          conv.userMessages.push(text);
+        }
+      }
+    } else if (entryType === "assistant") {
+      conv.totalMessages++;
+      const message = entry.message;
+      if (message?.content && Array.isArray(message.content)) {
+        for (const block of message.content) {
+          if (typeof block !== "object" || block === null) continue;
+          const b = block;
+          if (b.type === "tool_use") {
+            const toolName = b.name;
+            conv.toolCounts[toolName] = (conv.toolCounts[toolName] || 0) + 1;
+            const input = b.input;
+            if (input?.file_path && typeof input.file_path === "string") {
+              if (toolName === "Write" || toolName === "Edit") {
+                conv.filesTouched.add(input.file_path);
+              }
+            }
+          }
+        }
       }
-    } else if (entry.type === "assistant" && entry.message?.content) {
-      const assistantText = extractAssistantText(entry.message.content);
-      if (!assistantText.trim()) continue;
-      const resolvedProject = fileCwd ? path6.basename(fileCwd) : fallbackProject;
-      const userText = pendingUser?.text ?? "";
-      const timestamp = entry.timestamp ?? pendingUser?.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
-      pairs.push({
-        userText,
-        assistantText,
-        timestamp,
-        sessionId: fileSessionId || path6.basename(filePath, ".jsonl"),
-        project: resolvedProject,
-        cwd: fileCwd || fallbackProject
-      });
-      pendingUser = null;
     }
   }
-  return pairs;
+  if (conv.cwd) {
+    conv.projectName = path5.basename(conv.cwd);
+    const worktreeMatch = conv.cwd.match(/\.worktrees\/([^/]+)/);
+    if (worktreeMatch?.[1]) {
+      conv.agentId = worktreeMatch[1];
+    }
+  }
+  return conv;
 }
-function hashPair(userText, assistantText) {
-  return crypto2.createHash("sha256").update(userText.slice(0, 500) + "||" + assistantText.slice(0, 500)).digest("hex");
+function extractUserText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    const parts = [];
+    for (const block of content) {
+      if (typeof block === "string") {
+        parts.push(block);
+      } else if (typeof block === "object" && block !== null) {
+        const b = block;
+        if (b.type === "text" && typeof b.text === "string") {
+          parts.push(b.text);
+        }
+      }
+    }
+    return parts.join("\n");
+  }
+  return "";
 }
-async function loadExistingHashes(cutoffIso) {
+function buildSummary(conv) {
+  const parts = [];
+  parts.push(`Session: ${conv.sessionId}`);
+  parts.push(`Project: ${conv.projectName}`);
+  if (conv.startTime) {
+    parts.push(`Time: ${conv.startTime}${conv.endTime ? ` \u2192 ${conv.endTime}` : ""}`);
+  }
+  parts.push(`Messages: ${conv.totalMessages}`);
+  if (conv.agentId !== "default") {
+    parts.push(`Agent: ${conv.agentId}`);
+  }
+  parts.push("");
+  if (conv.userMessages.length > 0) {
+    parts.push("## What was asked");
+    const prompts = conv.userMessages.slice(0, 5);
+    for (const prompt of prompts) {
+      const truncated = prompt.length > 300 ? prompt.slice(0, 300) + "..." : prompt;
+      const cleaned = truncated.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "").trim();
+      if (cleaned) parts.push(`- ${cleaned}`);
+    }
+    if (conv.userMessages.length > 5) {
+      parts.push(`- ... and ${conv.userMessages.length - 5} more prompts`);
+    }
+    parts.push("");
+  }
+  const toolEntries = Object.entries(conv.toolCounts).sort((a, b) => b[1] - a[1]);
+  if (toolEntries.length > 0) {
+    parts.push("## Tools used");
+    for (const [tool, count] of toolEntries) {
+      parts.push(`- ${tool}: ${count}`);
+    }
+    parts.push("");
+  }
+  if (conv.filesTouched.size > 0) {
+    parts.push("## Files modified");
+    const fileList = [...conv.filesTouched].sort();
+    const shown = fileList.slice(0, 20);
+    for (const f of shown) {
+      parts.push(`- ${f}`);
+    }
+    if (fileList.length > 20) {
+      parts.push(`- ... and ${fileList.length - 20} more files`);
+    }
+    parts.push("");
+  }
+  if (conv.errorCount > 0) {
+    parts.push(`Errors: ${conv.errorCount}`);
+  }
+  let summary = parts.join("\n");
+  if (summary.length > MAX_SUMMARY_LENGTH) {
+    summary = summary.slice(0, MAX_SUMMARY_LENGTH);
+  }
+  return summary;
+}
+async function loadExistingSourcePaths() {
   const client = getClient();
-  const hashes = /* @__PURE__ */ new Set();
+  const paths = /* @__PURE__ */ new Set();
   let offset = 0;
   const batchSize = 500;
   while (true) {
     const result = await client.execute({
-      sql: `SELECT content_text, agent_response FROM conversations
-            WHERE platform = 'claude-code' AND timestamp > ?
+      sql: `SELECT source_path FROM memories
+            WHERE tool_name = ? AND source_path IS NOT NULL
             ORDER BY id LIMIT ? OFFSET ?`,
-      args: [cutoffIso, batchSize, offset]
+      args: [TOOL_NAME, batchSize, offset]
     });
     if (result.rows.length === 0) break;
     for (const row of result.rows) {
-      hashes.add(
-        hashPair(
-          row.content_text ?? "",
-          row.agent_response ?? ""
-        )
-      );
+      paths.add(row.source_path);
     }
     offset += batchSize;
   }
-  return hashes;
-}
-var MAX_CONTENT_LENGTH = 8e3;
-var MIN_ASSISTANT_LENGTH = 50;
-async function storePair(pair, daemonConnected, stats, agentId) {
-  const client = getClient();
-  const id = crypto2.randomUUID();
-  const userTrunc = pair.userText.length > MAX_CONTENT_LENGTH ? pair.userText.slice(0, MAX_CONTENT_LENGTH) : pair.userText;
-  const assistTrunc = pair.assistantText.length > MAX_CONTENT_LENGTH ? pair.assistantText.slice(0, MAX_CONTENT_LENGTH) : pair.assistantText;
-  await client.execute({
-    sql: `INSERT INTO conversations
-          (id, platform, external_id, sender_id, sender_name, sender_phone, sender_email,
-           recipient_id, channel_id, thread_id, reply_to_id,
-           content_text, content_media, agent_response, agent_name,
-           timestamp, ingested_at)
-          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-    args: [
-      id,
-      "claude-code",
-      null,
-      "user",
-      "user",
-      null,
-      null,
-      null,
-      pair.project,
-      pair.sessionId,
-      null,
-      userTrunc,
-      null,
-      assistTrunc,
-      "claude",
-      pair.timestamp,
-      (/* @__PURE__ */ new Date()).toISOString()
-    ]
-  });
-  stats.conversationsStored++;
-  const rawText = [
-    `[claude-code] Conversation in ${pair.project}`,
-    userTrunc ? `User: ${userTrunc}` : null,
-    `Assistant: ${assistTrunc}`
-  ].filter(Boolean).join("\n");
-  let vector = null;
-  if (daemonConnected) {
-    try {
-      vector = await embedViaClient(rawText, "low");
-      if (!vector) stats.embedFailed++;
-    } catch {
-      stats.embedFailed++;
-    }
-  }
-  await writeMemory({
-    id: crypto2.randomUUID(),
-    agent_id: agentId,
-    agent_role: "coo",
-    session_id: pair.sessionId,
-    timestamp: pair.timestamp,
-    tool_name: "ConversationBackfill",
-    project_name: pair.project,
-    has_error: false,
-    raw_text: rawText,
-    vector,
-    importance: 3
-  });
-  stats.memoriesStored++;
+  return paths;
 }
 async function backfillConversations(options) {
   const stats = {
     filesScanned: 0,
     conversationsStored: 0,
-    memoriesStored: 0,
     skippedDedup: 0,
-    skippedShort: 0,
+    skippedTooShort: 0,
     embedFailed: 0
   };
-  const cutoffMs = Date.now() - options.days * 24 * 60 * 60 * 1e3;
-  const cutoffIso = new Date(cutoffMs).toISOString();
-  let cooAgentId = "exe";
-  try {
-    const { loadEmployees: loadEmployees2 } = await Promise.resolve().then(() => (init_employees(), employees_exports));
-    const employees = await loadEmployees2();
-    const coo = employees.find((e) => e.role === "COO");
-    if (coo) cooAgentId = coo.name.toLowerCase();
-  } catch {
+  const sinceDate = options.since ? new Date(options.since) : void 0;
+  if (sinceDate && isNaN(sinceDate.getTime())) {
+    throw new Error(`Invalid --since date: ${options.since}`);
   }
-  process.stderr.write(`[backfill-conversations] Scanning last ${options.days} days (agent: ${cooAgentId})...
-`);
+  process.stderr.write("[backfill-conversations] Initializing store...\n");
+  await initStore();
+  let daemonConnected = false;
   if (!options.dryRun) {
-    process.stderr.write("[backfill-conversations] Initializing store...\n");
-    await initStore();
-    try {
-      const client = getClient();
-      const old = await client.execute({
-        sql: "SELECT COUNT(*) as cnt FROM memories WHERE agent_id = 'backfill' OR (tool_name = 'ConversationBackfill' AND agent_id != ?)",
-        args: [cooAgentId]
-      });
-      const count = Number(old.rows[0]?.cnt ?? 0);
-      if (count > 0) {
-        await client.execute({
-          sql: "UPDATE memories SET agent_id = ?, agent_role = 'coo' WHERE agent_id = 'backfill' OR (tool_name = 'ConversationBackfill' AND agent_id != ?)",
-          args: [cooAgentId, cooAgentId]
-        });
-        process.stderr.write(`[backfill-conversations] Migrated ${count} records \u2192 agent_id='${cooAgentId}'
-`);
-      }
-    } catch {
+    daemonConnected = await connectEmbedDaemon();
+    if (!daemonConnected) {
+      process.stderr.write(
+        "[backfill-conversations] WARNING: Daemon unavailable \u2014 vectors will be NULL (backfill-vectors can fix later)\n"
+      );
     }
   }
-  const daemonConnected = options.dryRun ? false : await connectEmbedDaemon();
-  if (!daemonConnected && !options.dryRun) {
-    process.stderr.write(
-      "[backfill-conversations] WARNING: Daemon unavailable \u2014 vectors will be NULL (backfill-vectors can fix later)\n"
-    );
-  }
-  let seenHashes = /* @__PURE__ */ new Set();
-  if (!options.dryRun) {
-    process.stderr.write("[backfill-conversations] Loading existing hashes for dedup...\n");
-    seenHashes = await loadExistingHashes(cutoffIso);
-    process.stderr.write(`[backfill-conversations] ${seenHashes.size} existing conversations loaded
+  process.stderr.write("[backfill-conversations] Loading already-ingested conversations...\n");
+  const existingPaths = options.dryRun ? /* @__PURE__ */ new Set() : await loadExistingSourcePaths();
+  process.stderr.write(`[backfill-conversations] ${existingPaths.size} conversations already ingested
 `);
-  }
-  const files = await findJsonlFiles(cutoffMs);
-  process.stderr.write(`[backfill-conversations] Found ${files.length} JSONL files
+  const files = await findJsonlFiles(sinceDate, options.project);
+  process.stderr.write(`[backfill-conversations] Found ${files.length} JSONL files to process
 `);
+  process.env.EXE_EMBED_PRIORITY = "low";
   for (const file of files) {
-    const pairs = await extractConversationPairs(file, options.projectFilter);
     stats.filesScanned++;
-    for (const pair of pairs) {
-      if (pair.assistantText.length < MIN_ASSISTANT_LENGTH) {
-        stats.skippedShort++;
-        continue;
-      }
-      const hash = hashPair(pair.userText, pair.assistantText);
-      if (seenHashes.has(hash)) {
-        stats.skippedDedup++;
-        continue;
+    if (existingPaths.has(file)) {
+      stats.skippedDedup++;
+      continue;
+    }
+    const conv = await parseConversation(file);
+    if (conv.totalMessages < MIN_MESSAGES) {
+      stats.skippedTooShort++;
+      continue;
+    }
+    const summary = buildSummary(conv);
+    if (options.dryRun) {
+      process.stdout.write(`
+\u2500\u2500\u2500 ${file} \u2500\u2500\u2500
+`);
+      process.stdout.write(`Project: ${conv.projectName} | Messages: ${conv.totalMessages}`);
+      process.stdout.write(` | Tools: ${Object.keys(conv.toolCounts).length}`);
+      process.stdout.write(` | Files: ${conv.filesTouched.size}
+`);
+      const firstPrompt = conv.userMessages[0];
+      if (firstPrompt) {
+        process.stdout.write(`First prompt: ${firstPrompt.slice(0, 120)}
+`);
       }
-      seenHashes.add(hash);
-      if (!options.dryRun) {
-        await storePair(pair, daemonConnected, stats, cooAgentId);
-      } else {
-        stats.conversationsStored++;
-        stats.memoriesStored++;
+      stats.conversationsStored++;
+      continue;
+    }
+    let vector = null;
+    if (daemonConnected) {
+      try {
+        vector = await embedViaClient(summary, "low");
+        if (!vector) stats.embedFailed++;
+      } catch {
+        stats.embedFailed++;
       }
     }
-    if (stats.filesScanned % 20 === 0) {
+    await writeMemory({
+      id: crypto2.randomUUID(),
+      agent_id: conv.agentId,
+      agent_role: conv.agentId === "exe" ? "COO" : "specialist",
+      session_id: conv.sessionId,
+      timestamp: conv.startTime ?? (/* @__PURE__ */ new Date()).toISOString(),
+      tool_name: TOOL_NAME,
+      project_name: conv.projectName,
+      has_error: conv.errorCount > 0,
+      raw_text: summary,
+      vector,
+      source_path: file,
+      source_type: "conversation"
+    });
+    existingPaths.add(file);
+    stats.conversationsStored++;
+    if (stats.filesScanned % 50 === 0) {
       process.stderr.write(
         `[backfill-conversations] Progress: ${stats.filesScanned}/${files.length} files, ${stats.conversationsStored} stored
 `
       );
-      if (!options.dryRun) await flushBatch();
+      await flushBatch();
     }
   }
-  if (!options.dryRun) await flushBatch();
+  if (!options.dryRun) {
+    await flushBatch();
+  }
   process.stderr.write(
-    `[backfill-conversations] Done. Files: ${stats.filesScanned}, Conversations: ${stats.conversationsStored}, Memories: ${stats.memoriesStored}, Dedup: ${stats.skippedDedup}, Short: ${stats.skippedShort}, EmbedFail: ${stats.embedFailed}
+    `[backfill-conversations] Done. Scanned: ${stats.filesScanned}, Stored: ${stats.conversationsStored}, Dedup: ${stats.skippedDedup}, TooShort: ${stats.skippedTooShort}, EmbedFail: ${stats.embedFailed}
 `
   );
   return stats;
 }
-function parseArgs(argv) {
-  let days = 30;
-  let projectFilter;
-  let dryRun = false;
-  for (let i = 0; i < argv.length; i++) {
-    switch (argv[i]) {
-      case "--days":
-        days = parseInt(argv[++i] ?? "30", 10) || 30;
-        break;
-      case "--project":
-        projectFilter = argv[++i] ?? void 0;
-        break;
-      case "--dry-run":
-        dryRun = true;
-        break;
-    }
-  }
-  return { days, projectFilter, dryRun };
-}
 if (isMainModule(import.meta.url)) {
-  const options = parseArgs(process.argv.slice(2));
-  backfillConversations(options).then((result) => {
+  const { values } = parseArgs({
+    options: {
+      since: { type: "string" },
+      project: { type: "string" },
+      "dry-run": { type: "boolean", default: false }
+    },
+    strict: true
+  });
+  backfillConversations({
+    since: values.since,
+    project: values.project,
+    dryRun: values["dry-run"]
+  }).then((result) => {
     console.log(JSON.stringify(result, null, 2));
     process.exit(0);
   }).catch((err) => {
-    console.error(
-      "Backfill failed:",
-      err instanceof Error ? err.message : String(err)
-    );
+    console.error("Backfill failed:", err instanceof Error ? err.message : String(err));
     process.exit(1);
   });
 }