@askexenow/exe-os 0.8.82 → 0.8.85

package/dist/bin/exe-doctor.js

@@ -311,6 +311,12 @@ function getClient() {
   if (!_resilientClient) {
     throw new Error("Database client not initialized. Call initDatabase() first.");
   }
+  if (process.env.EXE_IS_DAEMON === "1") {
+    return _resilientClient;
+  }
+  if (_daemonClient && _daemonClient._isDaemonActive()) {
+    return _daemonClient;
+  }
   return _resilientClient;
 }
 function getRawClient() {
@@ -799,6 +805,12 @@ async function ensureSchema() {
     } catch {
     }
   }
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_content_hash ON memories(content_hash, agent_id)`
+    );
+  } catch {
+  }
   await client.executeMultiple(`
     CREATE TABLE IF NOT EXISTS entities (
       id TEXT PRIMARY KEY,
@@ -851,7 +863,30 @@ async function ensureSchema() {
       entity_id TEXT NOT NULL,
       PRIMARY KEY (hyperedge_id, entity_id)
     );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS entities_fts USING fts5(
+      name,
+      content=entities,
+      content_rowid=rowid
+    );
+
+    CREATE TRIGGER IF NOT EXISTS entities_fts_ai AFTER INSERT ON entities BEGIN
+      INSERT INTO entities_fts(rowid, name) VALUES (new.rowid, new.name);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS entities_fts_ad AFTER DELETE ON entities BEGIN
+      INSERT INTO entities_fts(entities_fts, rowid, name) VALUES('delete', old.rowid, old.name);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS entities_fts_au AFTER UPDATE ON entities BEGIN
+      INSERT INTO entities_fts(entities_fts, rowid, name) VALUES('delete', old.rowid, old.name);
+      INSERT INTO entities_fts(rowid, name) VALUES (new.rowid, new.name);
+    END;
   `);
+  try {
+    await client.execute("INSERT INTO entities_fts(entities_fts) VALUES('rebuild')");
+  } catch {
+  }
   await client.executeMultiple(`
     CREATE TABLE IF NOT EXISTS entity_aliases (
       alias TEXT NOT NULL PRIMARY KEY,
@@ -1032,6 +1067,33 @@ async function ensureSchema() {
     CREATE INDEX IF NOT EXISTS idx_conversations_channel
       ON conversations(channel_id);
   `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS session_agent_map (
+      session_uuid TEXT PRIMARY KEY,
+      agent_id TEXT NOT NULL,
+      session_name TEXT,
+      task_id TEXT,
+      project_name TEXT,
+      started_at TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_session_agent_map_agent
+      ON session_agent_map(agent_id);
+  `);
+  try {
+    const mapCount = await client.execute({ sql: `SELECT COUNT(*) as cnt FROM session_agent_map`, args: [] });
+    if (Number(mapCount.rows[0]?.cnt ?? 0) === 0) {
+      await client.execute({
+        sql: `INSERT OR IGNORE INTO session_agent_map (session_uuid, agent_id, session_name, started_at)
+              SELECT session_id, agent_id, '', MIN(timestamp)
+              FROM memories
+              WHERE session_id IS NOT NULL AND session_id != '' AND agent_id IS NOT NULL AND agent_id != ''
+              GROUP BY session_id, agent_id`,
+        args: []
+      });
+    }
+  } catch {
+  }
   try {
     await client.execute({
       sql: `ALTER TABLE tasks ADD COLUMN budget_tokens INTEGER`,
@@ -1165,8 +1227,30 @@ async function ensureSchema() {
     });
   } catch {
   }
+  for (const col of [
+    "ALTER TABLE memories ADD COLUMN intent TEXT",
+    "ALTER TABLE memories ADD COLUMN outcome TEXT",
+    "ALTER TABLE memories ADD COLUMN domain TEXT",
+    "ALTER TABLE memories ADD COLUMN referenced_entities TEXT",
+    "ALTER TABLE memories ADD COLUMN retrieval_count INTEGER DEFAULT 0",
+    "ALTER TABLE memories ADD COLUMN chain_position TEXT",
+    "ALTER TABLE memories ADD COLUMN review_status TEXT",
+    "ALTER TABLE memories ADD COLUMN context_window_pct INTEGER",
+    "ALTER TABLE memories ADD COLUMN file_paths TEXT",
+    "ALTER TABLE memories ADD COLUMN commit_hash TEXT",
+    "ALTER TABLE memories ADD COLUMN duration_ms INTEGER",
+    "ALTER TABLE memories ADD COLUMN token_cost REAL",
+    "ALTER TABLE memories ADD COLUMN audience TEXT",
+    "ALTER TABLE memories ADD COLUMN language_type TEXT",
+    "ALTER TABLE memories ADD COLUMN parent_memory_id TEXT"
+  ]) {
+    try {
+      await client.execute(col);
+    } catch {
+    }
+  }
 }
-var _client, _resilientClient, initTurso;
+var _client, _resilientClient, _daemonClient, initTurso;
 var init_database = __esm({
   "src/lib/database.ts"() {
     "use strict";
@@ -1174,6 +1258,7 @@ var init_database = __esm({
     init_employees();
     _client = null;
     _resilientClient = null;
+    _daemonClient = null;
     initTurso = initDatabase;
   }
 });
@@ -1715,6 +1800,7 @@ var init_worker_gate = __esm({
 });
 
 // src/lib/store.ts
+import { createHash } from "crypto";
 init_database();
 
 // src/lib/keychain.ts
@@ -1750,12 +1836,20 @@ async function getMasterKey() {
   }
   const keyPath = getKeyPath();
   if (!existsSync3(keyPath)) {
+    process.stderr.write(
+      `[keychain] Key not found at ${keyPath} (HOME=${os3.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
+`
+    );
     return null;
   }
   try {
     const content = await readFile3(keyPath, "utf-8");
     return Buffer.from(content.trim(), "base64");
-  } catch {
+  } catch (err) {
+    process.stderr.write(
+      `[keychain] Key read failed at ${keyPath}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
     return null;
   }
 }
@@ -1898,6 +1992,7 @@ import { realpathSync } from "fs";
 import { fileURLToPath } from "url";
 function isMainModule(importMetaUrl) {
   if (process.argv[1] == null) return false;
+  if (process.argv[1].includes("mcp/server")) return false;
   try {
     const scriptPath = realpathSync(process.argv[1]);
     const modulePath = realpathSync(fileURLToPath(importMetaUrl));
@@ -1912,6 +2007,268 @@ import { existsSync as existsSync6 } from "fs";
 import { spawn } from "child_process";
 import path6 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
+
+// src/lib/conflict-detector.ts
+var DEFAULT_MAX_PAIRS = 100;
+var SIM_LOW = 0.85;
+var SIM_HIGH = 0.95;
+var LLM_BATCH_SIZE = 15;
+function cosineSimilarity(a, b) {
+  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];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+async function fetchMemoriesWithVectors(client, projectFilter, agentFilter2) {
+  let hasStatusCol = false;
+  try {
+    const info = await client.execute("PRAGMA table_info(memories)");
+    hasStatusCol = info.rows.some((r) => r.name === "status");
+  } catch {
+  }
+  const clauses = ["vector IS NOT NULL"];
+  if (hasStatusCol) clauses.push("status = 'active'");
+  const args = [];
+  if (projectFilter) {
+    clauses.push("project_name = ?");
+    args.push(projectFilter);
+  }
+  if (agentFilter2) {
+    clauses.push("agent_id = ?");
+    args.push(agentFilter2);
+  }
+  const where = " WHERE " + clauses.join(" AND ");
+  const result = await client.execute({
+    sql: `SELECT id, agent_id, raw_text, timestamp, project_name, vector
+          FROM memories${where}
+          ORDER BY project_name, timestamp DESC`,
+    args
+  });
+  const byProject = /* @__PURE__ */ new Map();
+  for (const row of result.rows) {
+    const project = row.project_name;
+    const vec = row.vector == null ? null : Array.isArray(row.vector) ? row.vector : Array.from(row.vector);
+    if (!vec || vec.length === 0) continue;
+    const mem = {
+      id: row.id,
+      agent_id: row.agent_id,
+      raw_text: row.raw_text,
+      timestamp: row.timestamp,
+      vector: vec
+    };
+    const list = byProject.get(project);
+    if (list) list.push(mem);
+    else byProject.set(project, [mem]);
+  }
+  return byProject;
+}
+function findCandidatePairs(memories, maxPairs) {
+  const pairs = [];
+  for (let i = 0; i < memories.length && pairs.length < maxPairs; i++) {
+    for (let j = i + 1; j < memories.length && pairs.length < maxPairs; j++) {
+      const sim = cosineSimilarity(memories[i].vector, memories[j].vector);
+      if (sim >= SIM_LOW && sim <= SIM_HIGH) {
+        pairs.push({ a: memories[i], b: memories[j], similarity: sim });
+      }
+    }
+  }
+  pairs.sort((x, y) => y.similarity - x.similarity);
+  return pairs;
+}
+async function classifyPairsBatch(pairs) {
+  const Anthropic = (await import("@anthropic-ai/sdk")).default;
+  const client = new Anthropic();
+  const pairDescriptions = pairs.map(
+    (p, i) => `Pair ${i + 1}:
+Memory A (${p.a.agent_id}, ${p.a.timestamp}): "${p.a.raw_text.slice(0, 300)}"
+Memory B (${p.b.agent_id}, ${p.b.timestamp}): "${p.b.raw_text.slice(0, 300)}"`
+  ).join("\n\n");
+  const prompt = `You are classifying pairs of memory records for contradictions.
+
+For each pair, classify as:
+- AGREE: Both memories say the same thing (no action needed).
+- CONFLICT: The memories contradict each other (one must be wrong).
+- SUPERSEDED: One memory replaces/updates the other (the older one is outdated).
+
+Respond with a JSON array. Each element: {"pair": <1-indexed>, "classification": "AGREE"|"CONFLICT"|"SUPERSEDED", "explanation": "<brief reason>"}
+
+${pairDescriptions}
+
+Respond ONLY with the JSON array, no markdown fences.`;
+  const response = await client.messages.create({
+    model: "claude-haiku-4-5-20251001",
+    max_tokens: 1024,
+    messages: [{ role: "user", content: prompt }]
+  });
+  const text = response.content[0]?.type === "text" ? response.content[0].text : "";
+  try {
+    const parsed = JSON.parse(text);
+    return parsed.map((r) => ({
+      classification: ["AGREE", "CONFLICT", "SUPERSEDED"].includes(
+        r.classification
+      ) ? r.classification : "AGREE",
+      explanation: r.explanation ?? ""
+    }));
+  } catch {
+    return pairs.map(() => ({
+      classification: "AGREE",
+      explanation: "LLM response parse error"
+    }));
+  }
+}
+function recommend(classification) {
+  switch (classification) {
+    case "CONFLICT":
+      return "manual_review";
+    case "SUPERSEDED":
+      return "deactivate_older";
+    case "AGREE":
+      return "merge";
+    case "UNCLASSIFIED":
+      return "none";
+  }
+}
+async function detectConflicts(client, projectFilter, agentFilter2) {
+  const maxPairs = parseInt(
+    process.env.CONFLICT_MAX_PAIRS ?? String(DEFAULT_MAX_PAIRS),
+    10
+  );
+  const byProject = await fetchMemoriesWithVectors(
+    client,
+    projectFilter,
+    agentFilter2
+  );
+  const allCandidates = [];
+  for (const [, memories] of byProject) {
+    if (memories.length < 2) continue;
+    const candidates2 = findCandidatePairs(
+      memories,
+      maxPairs - allCandidates.length
+    );
+    allCandidates.push(...candidates2);
+    if (allCandidates.length >= maxPairs) break;
+  }
+  if (allCandidates.length === 0) {
+    return {
+      candidateCount: 0,
+      classified: 0,
+      conflicts: 0,
+      superseded: 0,
+      agree: 0,
+      unclassified: 0,
+      pairs: [],
+      skipped: false
+    };
+  }
+  const truncated = allCandidates.length > maxPairs;
+  const candidates = allCandidates.slice(0, maxPairs);
+  const hasApiKey = !!process.env.ANTHROPIC_API_KEY;
+  const pairs = [];
+  if (hasApiKey) {
+    for (let i = 0; i < candidates.length; i += LLM_BATCH_SIZE) {
+      const batch = candidates.slice(i, i + LLM_BATCH_SIZE);
+      try {
+        const results = await classifyPairsBatch(batch);
+        for (let j = 0; j < batch.length; j++) {
+          const c = batch[j];
+          const r = results[j] ?? {
+            classification: "AGREE",
+            explanation: "No result"
+          };
+          pairs.push({
+            memoryA: {
+              id: c.a.id,
+              agentId: c.a.agent_id,
+              text: c.a.raw_text,
+              timestamp: c.a.timestamp
+            },
+            memoryB: {
+              id: c.b.id,
+              agentId: c.b.agent_id,
+              text: c.b.raw_text,
+              timestamp: c.b.timestamp
+            },
+            similarity: c.similarity,
+            classification: r.classification,
+            explanation: r.explanation,
+            recommendation: recommend(r.classification)
+          });
+        }
+      } catch (err) {
+        for (const c of batch) {
+          pairs.push({
+            memoryA: {
+              id: c.a.id,
+              agentId: c.a.agent_id,
+              text: c.a.raw_text,
+              timestamp: c.a.timestamp
+            },
+            memoryB: {
+              id: c.b.id,
+              agentId: c.b.agent_id,
+              text: c.b.raw_text,
+              timestamp: c.b.timestamp
+            },
+            similarity: c.similarity,
+            classification: "UNCLASSIFIED",
+            explanation: `LLM error: ${err instanceof Error ? err.message : String(err)}`,
+            recommendation: "none"
+          });
+        }
+      }
+    }
+  } else {
+    for (const c of candidates) {
+      pairs.push({
+        memoryA: {
+          id: c.a.id,
+          agentId: c.a.agent_id,
+          text: c.a.raw_text,
+          timestamp: c.a.timestamp
+        },
+        memoryB: {
+          id: c.b.id,
+          agentId: c.b.agent_id,
+          text: c.b.raw_text,
+          timestamp: c.b.timestamp
+        },
+        similarity: c.similarity,
+        classification: "UNCLASSIFIED",
+        explanation: "ANTHROPIC_API_KEY not set \u2014 skipped LLM classification",
+        recommendation: "none"
+      });
+    }
+  }
+  const severityOrder = { CONFLICT: 0, SUPERSEDED: 1, UNCLASSIFIED: 2, AGREE: 3 };
+  pairs.sort(
+    (a, b) => severityOrder[a.classification] - severityOrder[b.classification]
+  );
+  const conflicts = pairs.filter((p) => p.classification === "CONFLICT").length;
+  const superseded = pairs.filter(
+    (p) => p.classification === "SUPERSEDED"
+  ).length;
+  const agree = pairs.filter((p) => p.classification === "AGREE").length;
+  const unclassified = pairs.filter(
+    (p) => p.classification === "UNCLASSIFIED"
+  ).length;
+  return {
+    candidateCount: candidates.length,
+    classified: conflicts + superseded + agree,
+    conflicts,
+    superseded,
+    agree,
+    unclassified,
+    pairs,
+    skipped: truncated,
+    skipReason: truncated ? `Exceeded max ${maxPairs} pairs \u2014 increase CONFLICT_MAX_PAIRS to analyze more` : void 0
+  };
+}
+
+// src/bin/exe-doctor.ts
 function parseFlags(argv) {
   const flags = { fix: false, dryRun: false, verbose: false };
   for (let i = 0; i < argv.length; i++) {
@@ -2059,16 +2416,17 @@ async function auditOrphanedProjects(client) {
   return orphans;
 }
 async function runAudit(client, flags) {
-  const [stats, nullVectors, duplicates, bloated, fts, orphanedProjects] = await Promise.all([
+  const [stats, nullVectors, duplicates, bloated, fts, orphanedProjects, conflicts] = await Promise.all([
     auditStats(client, flags),
     auditNullVectors(client, flags),
     auditDuplicates(client, flags),
     auditBloated(client, flags),
     auditFts(client),
-    auditOrphanedProjects(client)
+    auditOrphanedProjects(client),
+    detectConflicts(client, flags.project, flags.agent)
   ]);
   const duplicateCount = duplicates.reduce((sum, d) => sum + d.delete_ids.length, 0);
-  return { stats, nullVectors, duplicates, duplicateCount, bloated, fts, orphanedProjects };
+  return { stats, nullVectors, duplicates, duplicateCount, bloated, fts, orphanedProjects, conflicts };
 }
 function indicator(value, warn) {
   if (value === 0) return "\u{1F7E2}";
@@ -2114,6 +2472,22 @@ function formatReport(report, flags) {
     const orphanList = report.orphanedProjects.map((o) => `${o.project_name} \u2014 ${o.count} memories`).join(", ");
     lines.push(`\u2139\uFE0F  Orphaned projects: ${report.orphanedProjects.length} (${orphanList})`);
   }
+  const cr = report.conflicts;
+  if (cr.candidateCount > 0) {
+    const conflictIndicator = cr.conflicts > 0 ? "\u{1F534}" : cr.superseded > 0 ? "\u{1F7E0}" : "\u{1F7E2}";
+    lines.push(`${conflictIndicator} Conflicts:        ${fmtNum(cr.candidateCount)} candidate pairs`);
+    if (cr.classified > 0) {
+      lines.push(`                     CONFLICT: ${cr.conflicts}, SUPERSEDED: ${cr.superseded}, AGREE: ${cr.agree}`);
+    }
+    if (cr.unclassified > 0) {
+      lines.push(`                     Unclassified: ${cr.unclassified}`);
+    }
+    if (cr.skipped) {
+      lines.push(`  \u26A0\uFE0F  ${cr.skipReason}`);
+    }
+  } else {
+    lines.push("\u{1F7E2} Conflicts:        none detected");
+  }
   lines.push("");
   if (flags.verbose) {
     if (report.duplicates.length > 0) {
@@ -2130,6 +2504,23 @@ function formatReport(report, flags) {
       }
       lines.push("");
     }
+    const actionable = report.conflicts.pairs.filter(
+      (p) => p.classification === "CONFLICT" || p.classification === "SUPERSEDED"
+    );
+    if (actionable.length > 0) {
+      lines.push("Conflict Detection");
+      lines.push("==================");
+      for (const p of actionable.slice(0, 10)) {
+        const aShort = p.memoryA.text.length > 60 ? p.memoryA.text.slice(0, 60) + "..." : p.memoryA.text;
+        const bShort = p.memoryB.text.length > 60 ? p.memoryB.text.slice(0, 60) + "..." : p.memoryB.text;
+        lines.push(
+          `  [${p.classification}] ${p.memoryA.id.slice(0, 8)} (${p.memoryA.agentId}, ${p.memoryA.timestamp.slice(0, 10)}) vs ${p.memoryB.id.slice(0, 8)} (${p.memoryB.agentId}, ${p.memoryB.timestamp.slice(0, 10)})`
+        );
+        lines.push(`    "${aShort}" vs "${bShort}"`);
+        lines.push(`    ${p.explanation} \u2192 Recommendation: ${p.recommendation}`);
+      }
+      lines.push("");
+    }
   }
   const recs = [];
   if (report.nullVectors > 0) {
@@ -2148,6 +2539,12 @@ function formatReport(report, flags) {
     const names = report.orphanedProjects.map((o) => `"${o.project_name}"`).join(", ");
     recs.push(`Consider /exe-forget for orphaned project${report.orphanedProjects.length > 1 ? "s" : ""} ${names}`);
   }
+  if (report.conflicts.conflicts > 0) {
+    recs.push(`${fmtNum(report.conflicts.conflicts)} conflicting memory pairs need manual review`);
+  }
+  if (report.conflicts.superseded > 0) {
+    recs.push(`${fmtNum(report.conflicts.superseded)} superseded memories can be deactivated`);
+  }
   if (recs.length > 0) {
     lines.push("Recommendations:");
     for (const r of recs) {
@@ -2314,7 +2711,7 @@ ${mode} Complete.`);
   }
   return report;
 }
-if (isMainModule(import.meta.url)) {
+if (isMainModule(import.meta.url) && (process.argv[1] ?? "").includes("exe-doctor")) {
   main().catch((err) => {
     console.error(err instanceof Error ? err.message : String(err));
     process.exit(1);