engrm 0.4.9 → 0.4.11

package/dist/cli.js

@@ -607,9 +607,59 @@ function isVecExtensionLoaded(db) {
     return false;
   }
 }
+function tableExists(db, name) {
+  const row = db.query(`SELECT name FROM sqlite_master WHERE type IN ('table', 'view') AND name = ?`).get(name);
+  return Boolean(row?.name);
+}
+function columnExists(db, table, column) {
+  if (!tableExists(db, table))
+    return false;
+  const rows = db.query(`PRAGMA table_info(${table})`).all();
+  return rows.some((row) => row.name === column);
+}
+function ensureLegacyBaseTables(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS sync_state (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `);
+}
+function inferLegacySchemaVersion(db) {
+  const hasProjects = tableExists(db, "projects");
+  const hasObservations = tableExists(db, "observations");
+  const hasSessions = tableExists(db, "sessions");
+  if (!(hasProjects && hasObservations && hasSessions))
+    return 0;
+  ensureLegacyBaseTables(db);
+  let version = 1;
+  if (columnExists(db, "observations", "superseded_by"))
+    version = Math.max(version, 2);
+  if (columnExists(db, "observations", "remote_source_id"))
+    version = Math.max(version, 3);
+  if (tableExists(db, "vec_observations"))
+    version = Math.max(version, 4);
+  const hasSessionMetrics = columnExists(db, "sessions", "files_touched_count") && columnExists(db, "sessions", "searches_performed") && columnExists(db, "sessions", "tool_calls_count");
+  if (hasSessionMetrics || tableExists(db, "security_findings"))
+    version = Math.max(version, 5);
+  if (columnExists(db, "sessions", "risk_score"))
+    version = Math.max(version, 6);
+  if (tableExists(db, "packs_installed"))
+    version = Math.max(version, 7);
+  if (tableExists(db, "user_prompts"))
+    version = Math.max(version, 9);
+  if (tableExists(db, "tool_events"))
+    version = Math.max(version, 10);
+  return version;
+}
 function runMigrations(db) {
   const currentVersion = db.query("PRAGMA user_version").get();
   let version = currentVersion.user_version;
+  const inferred = inferLegacySchemaVersion(db);
+  if (inferred > version) {
+    db.exec(`PRAGMA user_version = ${inferred}`);
+    version = inferred;
+  }
   for (const migration of MIGRATIONS) {
     if (migration.version <= version)
       continue;
@@ -689,6 +739,11 @@ import { createHash as createHash2 } from "node:crypto";
 var IS_BUN = typeof globalThis.Bun !== "undefined";
 function openDatabase(dbPath) {
   if (IS_BUN) {
+    if (process.platform === "darwin") {
+      try {
+        return openNodeDatabase(dbPath);
+      } catch {}
+    }
     return openBunDatabase(dbPath);
   }
   return openNodeDatabase(dbPath);

package/dist/hooks/elicitation-result.js

@@ -1437,9 +1437,59 @@ function isVecExtensionLoaded(db) {
     return false;
   }
 }
+function tableExists(db, name) {
+  const row = db.query(`SELECT name FROM sqlite_master WHERE type IN ('table', 'view') AND name = ?`).get(name);
+  return Boolean(row?.name);
+}
+function columnExists(db, table, column) {
+  if (!tableExists(db, table))
+    return false;
+  const rows = db.query(`PRAGMA table_info(${table})`).all();
+  return rows.some((row) => row.name === column);
+}
+function ensureLegacyBaseTables(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS sync_state (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `);
+}
+function inferLegacySchemaVersion(db) {
+  const hasProjects = tableExists(db, "projects");
+  const hasObservations = tableExists(db, "observations");
+  const hasSessions = tableExists(db, "sessions");
+  if (!(hasProjects && hasObservations && hasSessions))
+    return 0;
+  ensureLegacyBaseTables(db);
+  let version = 1;
+  if (columnExists(db, "observations", "superseded_by"))
+    version = Math.max(version, 2);
+  if (columnExists(db, "observations", "remote_source_id"))
+    version = Math.max(version, 3);
+  if (tableExists(db, "vec_observations"))
+    version = Math.max(version, 4);
+  const hasSessionMetrics = columnExists(db, "sessions", "files_touched_count") && columnExists(db, "sessions", "searches_performed") && columnExists(db, "sessions", "tool_calls_count");
+  if (hasSessionMetrics || tableExists(db, "security_findings"))
+    version = Math.max(version, 5);
+  if (columnExists(db, "sessions", "risk_score"))
+    version = Math.max(version, 6);
+  if (tableExists(db, "packs_installed"))
+    version = Math.max(version, 7);
+  if (tableExists(db, "user_prompts"))
+    version = Math.max(version, 9);
+  if (tableExists(db, "tool_events"))
+    version = Math.max(version, 10);
+  return version;
+}
 function runMigrations(db) {
   const currentVersion = db.query("PRAGMA user_version").get();
   let version = currentVersion.user_version;
+  const inferred = inferLegacySchemaVersion(db);
+  if (inferred > version) {
+    db.exec(`PRAGMA user_version = ${inferred}`);
+    version = inferred;
+  }
   for (const migration of MIGRATIONS) {
     if (migration.version <= version)
       continue;
@@ -1515,6 +1565,11 @@ import { createHash as createHash2 } from "node:crypto";
 var IS_BUN = typeof globalThis.Bun !== "undefined";
 function openDatabase(dbPath) {
   if (IS_BUN) {
+    if (process.platform === "darwin") {
+      try {
+        return openNodeDatabase(dbPath);
+      } catch {}
+    }
     return openBunDatabase(dbPath);
   }
   return openNodeDatabase(dbPath);

package/dist/hooks/post-tool-use.js

@@ -785,9 +785,59 @@ function isVecExtensionLoaded(db) {
     return false;
   }
 }
+function tableExists(db, name) {
+  const row = db.query(`SELECT name FROM sqlite_master WHERE type IN ('table', 'view') AND name = ?`).get(name);
+  return Boolean(row?.name);
+}
+function columnExists(db, table, column) {
+  if (!tableExists(db, table))
+    return false;
+  const rows = db.query(`PRAGMA table_info(${table})`).all();
+  return rows.some((row) => row.name === column);
+}
+function ensureLegacyBaseTables(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS sync_state (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `);
+}
+function inferLegacySchemaVersion(db) {
+  const hasProjects = tableExists(db, "projects");
+  const hasObservations = tableExists(db, "observations");
+  const hasSessions = tableExists(db, "sessions");
+  if (!(hasProjects && hasObservations && hasSessions))
+    return 0;
+  ensureLegacyBaseTables(db);
+  let version = 1;
+  if (columnExists(db, "observations", "superseded_by"))
+    version = Math.max(version, 2);
+  if (columnExists(db, "observations", "remote_source_id"))
+    version = Math.max(version, 3);
+  if (tableExists(db, "vec_observations"))
+    version = Math.max(version, 4);
+  const hasSessionMetrics = columnExists(db, "sessions", "files_touched_count") && columnExists(db, "sessions", "searches_performed") && columnExists(db, "sessions", "tool_calls_count");
+  if (hasSessionMetrics || tableExists(db, "security_findings"))
+    version = Math.max(version, 5);
+  if (columnExists(db, "sessions", "risk_score"))
+    version = Math.max(version, 6);
+  if (tableExists(db, "packs_installed"))
+    version = Math.max(version, 7);
+  if (tableExists(db, "user_prompts"))
+    version = Math.max(version, 9);
+  if (tableExists(db, "tool_events"))
+    version = Math.max(version, 10);
+  return version;
+}
 function runMigrations(db) {
   const currentVersion = db.query("PRAGMA user_version").get();
   let version = currentVersion.user_version;
+  const inferred = inferLegacySchemaVersion(db);
+  if (inferred > version) {
+    db.exec(`PRAGMA user_version = ${inferred}`);
+    version = inferred;
+  }
   for (const migration of MIGRATIONS) {
     if (migration.version <= version)
       continue;
@@ -863,6 +913,11 @@ import { createHash as createHash2 } from "node:crypto";
 var IS_BUN = typeof globalThis.Bun !== "undefined";
 function openDatabase(dbPath) {
   if (IS_BUN) {
+    if (process.platform === "darwin") {
+      try {
+        return openNodeDatabase(dbPath);
+      } catch {}
+    }
     return openBunDatabase(dbPath);
   }
   return openNodeDatabase(dbPath);

package/dist/hooks/pre-compact.js

@@ -579,9 +579,59 @@ function isVecExtensionLoaded(db) {
     return false;
   }
 }
+function tableExists(db, name) {
+  const row = db.query(`SELECT name FROM sqlite_master WHERE type IN ('table', 'view') AND name = ?`).get(name);
+  return Boolean(row?.name);
+}
+function columnExists(db, table, column) {
+  if (!tableExists(db, table))
+    return false;
+  const rows = db.query(`PRAGMA table_info(${table})`).all();
+  return rows.some((row) => row.name === column);
+}
+function ensureLegacyBaseTables(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS sync_state (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `);
+}
+function inferLegacySchemaVersion(db) {
+  const hasProjects = tableExists(db, "projects");
+  const hasObservations = tableExists(db, "observations");
+  const hasSessions = tableExists(db, "sessions");
+  if (!(hasProjects && hasObservations && hasSessions))
+    return 0;
+  ensureLegacyBaseTables(db);
+  let version = 1;
+  if (columnExists(db, "observations", "superseded_by"))
+    version = Math.max(version, 2);
+  if (columnExists(db, "observations", "remote_source_id"))
+    version = Math.max(version, 3);
+  if (tableExists(db, "vec_observations"))
+    version = Math.max(version, 4);
+  const hasSessionMetrics = columnExists(db, "sessions", "files_touched_count") && columnExists(db, "sessions", "searches_performed") && columnExists(db, "sessions", "tool_calls_count");
+  if (hasSessionMetrics || tableExists(db, "security_findings"))
+    version = Math.max(version, 5);
+  if (columnExists(db, "sessions", "risk_score"))
+    version = Math.max(version, 6);
+  if (tableExists(db, "packs_installed"))
+    version = Math.max(version, 7);
+  if (tableExists(db, "user_prompts"))
+    version = Math.max(version, 9);
+  if (tableExists(db, "tool_events"))
+    version = Math.max(version, 10);
+  return version;
+}
 function runMigrations(db) {
   const currentVersion = db.query("PRAGMA user_version").get();
   let version = currentVersion.user_version;
+  const inferred = inferLegacySchemaVersion(db);
+  if (inferred > version) {
+    db.exec(`PRAGMA user_version = ${inferred}`);
+    version = inferred;
+  }
   for (const migration of MIGRATIONS) {
     if (migration.version <= version)
       continue;
@@ -657,6 +707,11 @@ import { createHash as createHash2 } from "node:crypto";
 var IS_BUN = typeof globalThis.Bun !== "undefined";
 function openDatabase(dbPath) {
   if (IS_BUN) {
+    if (process.platform === "darwin") {
+      try {
+        return openNodeDatabase(dbPath);
+      } catch {}
+    }
     return openBunDatabase(dbPath);
   }
   return openNodeDatabase(dbPath);

package/dist/hooks/sentinel.js

@@ -655,9 +655,59 @@ function isVecExtensionLoaded(db) {
     return false;
   }
 }
+function tableExists(db, name) {
+  const row = db.query(`SELECT name FROM sqlite_master WHERE type IN ('table', 'view') AND name = ?`).get(name);
+  return Boolean(row?.name);
+}
+function columnExists(db, table, column) {
+  if (!tableExists(db, table))
+    return false;
+  const rows = db.query(`PRAGMA table_info(${table})`).all();
+  return rows.some((row) => row.name === column);
+}
+function ensureLegacyBaseTables(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS sync_state (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `);
+}
+function inferLegacySchemaVersion(db) {
+  const hasProjects = tableExists(db, "projects");
+  const hasObservations = tableExists(db, "observations");
+  const hasSessions = tableExists(db, "sessions");
+  if (!(hasProjects && hasObservations && hasSessions))
+    return 0;
+  ensureLegacyBaseTables(db);
+  let version = 1;
+  if (columnExists(db, "observations", "superseded_by"))
+    version = Math.max(version, 2);
+  if (columnExists(db, "observations", "remote_source_id"))
+    version = Math.max(version, 3);
+  if (tableExists(db, "vec_observations"))
+    version = Math.max(version, 4);
+  const hasSessionMetrics = columnExists(db, "sessions", "files_touched_count") && columnExists(db, "sessions", "searches_performed") && columnExists(db, "sessions", "tool_calls_count");
+  if (hasSessionMetrics || tableExists(db, "security_findings"))
+    version = Math.max(version, 5);
+  if (columnExists(db, "sessions", "risk_score"))
+    version = Math.max(version, 6);
+  if (tableExists(db, "packs_installed"))
+    version = Math.max(version, 7);
+  if (tableExists(db, "user_prompts"))
+    version = Math.max(version, 9);
+  if (tableExists(db, "tool_events"))
+    version = Math.max(version, 10);
+  return version;
+}
 function runMigrations(db) {
   const currentVersion = db.query("PRAGMA user_version").get();
   let version = currentVersion.user_version;
+  const inferred = inferLegacySchemaVersion(db);
+  if (inferred > version) {
+    db.exec(`PRAGMA user_version = ${inferred}`);
+    version = inferred;
+  }
   for (const migration of MIGRATIONS) {
     if (migration.version <= version)
       continue;
@@ -733,6 +783,11 @@ import { createHash as createHash2 } from "node:crypto";
 var IS_BUN = typeof globalThis.Bun !== "undefined";
 function openDatabase(dbPath) {
   if (IS_BUN) {
+    if (process.platform === "darwin") {
+      try {
+        return openNodeDatabase(dbPath);
+      } catch {}
+    }
     return openBunDatabase(dbPath);
   }
   return openNodeDatabase(dbPath);

package/dist/hooks/session-start.js

@@ -2166,9 +2166,59 @@ function isVecExtensionLoaded(db) {
     return false;
   }
 }
+function tableExists(db, name) {
+  const row = db.query(`SELECT name FROM sqlite_master WHERE type IN ('table', 'view') AND name = ?`).get(name);
+  return Boolean(row?.name);
+}
+function columnExists(db, table, column) {
+  if (!tableExists(db, table))
+    return false;
+  const rows = db.query(`PRAGMA table_info(${table})`).all();
+  return rows.some((row) => row.name === column);
+}
+function ensureLegacyBaseTables(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS sync_state (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `);
+}
+function inferLegacySchemaVersion(db) {
+  const hasProjects = tableExists(db, "projects");
+  const hasObservations = tableExists(db, "observations");
+  const hasSessions = tableExists(db, "sessions");
+  if (!(hasProjects && hasObservations && hasSessions))
+    return 0;
+  ensureLegacyBaseTables(db);
+  let version = 1;
+  if (columnExists(db, "observations", "superseded_by"))
+    version = Math.max(version, 2);
+  if (columnExists(db, "observations", "remote_source_id"))
+    version = Math.max(version, 3);
+  if (tableExists(db, "vec_observations"))
+    version = Math.max(version, 4);
+  const hasSessionMetrics = columnExists(db, "sessions", "files_touched_count") && columnExists(db, "sessions", "searches_performed") && columnExists(db, "sessions", "tool_calls_count");
+  if (hasSessionMetrics || tableExists(db, "security_findings"))
+    version = Math.max(version, 5);
+  if (columnExists(db, "sessions", "risk_score"))
+    version = Math.max(version, 6);
+  if (tableExists(db, "packs_installed"))
+    version = Math.max(version, 7);
+  if (tableExists(db, "user_prompts"))
+    version = Math.max(version, 9);
+  if (tableExists(db, "tool_events"))
+    version = Math.max(version, 10);
+  return version;
+}
 function runMigrations(db) {
   const currentVersion = db.query("PRAGMA user_version").get();
   let version = currentVersion.user_version;
+  const inferred = inferLegacySchemaVersion(db);
+  if (inferred > version) {
+    db.exec(`PRAGMA user_version = ${inferred}`);
+    version = inferred;
+  }
   for (const migration of MIGRATIONS) {
     if (migration.version <= version)
       continue;
@@ -2244,6 +2294,11 @@ import { createHash as createHash3 } from "node:crypto";
 var IS_BUN = typeof globalThis.Bun !== "undefined";
 function openDatabase(dbPath) {
   if (IS_BUN) {
+    if (process.platform === "darwin") {
+      try {
+        return openNodeDatabase(dbPath);
+      } catch {}
+    }
     return openBunDatabase(dbPath);
   }
   return openNodeDatabase(dbPath);
@@ -3009,19 +3064,28 @@ function formatVisibleStartupBrief(context) {
   const sessionFallbacks = sessionFallbacksFromContext(context);
   const recentOutcomeLines = buildRecentOutcomeLines(context, latest);
   const projectSignals = buildProjectSignalLine(context);
+  const shownItems = new Set;
   if (promptLines.length > 0) {
     lines.push(`${c2.cyan}Recent Requests:${c2.reset}`);
     for (const item of promptLines) {
       lines.push(`  - ${truncateInline(item, 160)}`);
+      rememberShownItem(shownItems, item);
     }
   }
   if (latest) {
+    const sanitizedNextSteps = sanitizeNextSteps(latest.next_steps, {
+      request: currentRequest,
+      investigated: chooseSection(latest.investigated, observationFallbacks.investigated, "Investigated"),
+      learned: latest.learned,
+      completed: chooseSection(latest.completed, observationFallbacks.completed, "Completed"),
+      recentOutcomes: recentOutcomeLines
+    });
     const sections = [
       ["Request", currentRequest, 1],
       ["Investigated", chooseSection(latest.investigated, observationFallbacks.investigated, "Investigated"), 2],
       ["Learned", latest.learned, 2],
       ["Completed", chooseSection(latest.completed, observationFallbacks.completed, "Completed"), 2],
-      ["Next Steps", latest.next_steps, 2]
+      ["Next Steps", sanitizedNextSteps, 2]
     ];
     for (const [label, value, maxItems] of sections) {
       const formatted = toSplashLines(value, maxItems ?? 2);
@@ -3029,33 +3093,45 @@ function formatVisibleStartupBrief(context) {
         lines.push(`${c2.cyan}${label}:${c2.reset}`);
         for (const item of formatted) {
           lines.push(`  ${item}`);
+          rememberShownItem(shownItems, item);
         }
       }
     }
   } else if (currentRequest && !duplicatesPromptLine(currentRequest, latestPromptLine)) {
     lines.push(`${c2.cyan}Current Request:${c2.reset}`);
     lines.push(`  - ${truncateInline(currentRequest, 160)}`);
+    rememberShownItem(shownItems, currentRequest);
     if (toolFallbacks.length > 0) {
-      lines.push(`${c2.cyan}Recent Tools:${c2.reset}`);
-      for (const item of toolFallbacks) {
-        lines.push(`  - ${truncateInline(item, 160)}`);
+      const additiveTools = filterAdditiveToolFallbacks(toolFallbacks, shownItems);
+      if (additiveTools.length > 0) {
+        lines.push(`${c2.cyan}Recent Tools:${c2.reset}`);
+        for (const item of additiveTools) {
+          lines.push(`  - ${truncateInline(item, 160)}`);
+          rememberShownItem(shownItems, item);
+        }
       }
     }
   }
   if (latest && currentRequest && !hasRequestSection(lines) && !duplicatesPromptLine(currentRequest, latestPromptLine)) {
     lines.push(`${c2.cyan}Current Request:${c2.reset}`);
     lines.push(`  - ${truncateInline(currentRequest, 160)}`);
+    rememberShownItem(shownItems, currentRequest);
   }
   if (recentOutcomeLines.length > 0) {
     lines.push(`${c2.cyan}Recent Work:${c2.reset}`);
     for (const item of recentOutcomeLines) {
       lines.push(`  - ${truncateInline(item, 160)}`);
+      rememberShownItem(shownItems, item);
     }
   }
   if (toolFallbacks.length > 0 && latest) {
-    lines.push(`${c2.cyan}Recent Tools:${c2.reset}`);
-    for (const item of toolFallbacks) {
-      lines.push(`  - ${truncateInline(item, 160)}`);
+    const additiveTools = filterAdditiveToolFallbacks(toolFallbacks, shownItems);
+    if (additiveTools.length > 0) {
+      lines.push(`${c2.cyan}Recent Tools:${c2.reset}`);
+      for (const item of additiveTools) {
+        lines.push(`  - ${truncateInline(item, 160)}`);
+        rememberShownItem(shownItems, item);
+      }
     }
   }
   if (sessionFallbacks.length > 0) {
@@ -3080,6 +3156,46 @@ function formatVisibleStartupBrief(context) {
   }
   return lines.slice(0, 14);
 }
+function rememberShownItem(shown, value) {
+  if (!value)
+    return;
+  for (const item of value.split(`
+`)) {
+    const normalized = normalizeStartupItem(item);
+    if (normalized)
+      shown.add(normalized);
+  }
+}
+function extractNormalizedSplashItems(value) {
+  if (!value)
+    return [];
+  return value.split(`
+`).map((line) => normalizeStartupItem(line)).filter(Boolean);
+}
+function sanitizeNextSteps(nextSteps, context) {
+  if (!nextSteps)
+    return null;
+  const covered = new Set([
+    normalizeStartupItem(context.request ?? ""),
+    ...extractNormalizedSplashItems(context.investigated),
+    ...extractNormalizedSplashItems(context.learned),
+    ...extractNormalizedSplashItems(context.completed),
+    ...context.recentOutcomes.map((item) => normalizeStartupItem(item))
+  ].filter(Boolean));
+  const kept = nextSteps.split(`
+`).map((line) => line.trim()).filter(Boolean).map((line) => line.replace(/^[-*]\s*/, "")).filter((line) => {
+    const normalized = normalizeStartupItem(line.replace(/^(investigate|follow through):\s*/i, ""));
+    return normalized && !covered.has(normalized);
+  });
+  return kept.length > 0 ? kept.map((line) => `- ${line}`).join(`
+`) : null;
+}
+function filterAdditiveToolFallbacks(toolFallbacks, shownItems) {
+  return toolFallbacks.filter((item) => {
+    const normalized = normalizeStartupItem(item);
+    return normalized && !shownItems.has(normalized);
+  });
+}
 function buildPromptFallback(context) {
   const latest = (context.recentPrompts ?? []).find((prompt) => isMeaningfulPrompt2(prompt.prompt));
   if (!latest?.prompt)

package/dist/hooks/stop.js

@@ -43,7 +43,10 @@ function extractRetrospective(observations, sessionId, projectId, userId) {
   const investigated = extractInvestigated(observations);
   const learned = extractLearned(observations);
   const completed = extractCompleted(observations);
-  const nextSteps = extractNextSteps(observations);
+  const nextSteps = extractNextSteps(observations, {
+    request,
+    completed
+  });
   if (!request && !investigated && !learned && !completed && !nextSteps) {
     return null;
   }
@@ -101,13 +104,17 @@ ${facts}` : `- ${title}`;
   return dedupeBulletLines(lines).join(`
 `);
 }
-function extractNextSteps(observations) {
+function extractNextSteps(observations, existing) {
   if (observations.length < 2)
     return null;
   const lastQuarterStart = Math.max(0, Math.min(observations.length - 1, observations.length - 3, Math.floor(observations.length * 0.75)));
   const lastQuarter = observations.slice(lastQuarterStart);
-  const unresolved = lastQuarter.filter((o) => o.type === "bugfix" && o.narrative && /error|fail|exception/i.test(o.narrative));
-  const explicitDecisions = lastQuarter.filter((o) => o.type === "decision").sort((a, b) => scoreNarrativeObservation(b) - scoreNarrativeObservation(a)).slice(0, 2).map((o) => `- Follow through: ${o.title}`);
+  const alreadyCovered = new Set([
+    normalizeObservationKey(existing.request ?? ""),
+    ...extractNormalizedSummaryItems(existing.completed)
+  ].filter(Boolean));
+  const unresolved = lastQuarter.filter((o) => o.type === "bugfix" && o.narrative && /error|fail|exception/i.test(o.narrative) && !alreadyCovered.has(normalizeObservationKey(o.title)));
+  const explicitDecisions = lastQuarter.filter((o) => o.type === "decision").sort((a, b) => scoreNarrativeObservation(b) - scoreNarrativeObservation(a)).slice(0, 2).filter((o) => !alreadyCovered.has(normalizeObservationKey(o.title))).map((o) => `- Follow through: ${o.title}`);
   if (unresolved.length === 0 && explicitDecisions.length === 0)
     return null;
   const lines = unresolved.map((o) => `- Investigate: ${o.title}`).slice(0, 3).concat(explicitDecisions);
@@ -148,6 +155,12 @@ function dedupeObservationsByTitle(observations) {
   }
   return deduped;
 }
+function extractNormalizedSummaryItems(value) {
+  if (!value)
+    return [];
+  return value.split(`
+`).map((line) => line.trim()).filter(Boolean).map((line) => line.replace(/^[-*]\s*/, "")).map((line) => line.replace(/^(investigate|follow through):\s*/i, "")).map((line) => normalizeObservationKey(line)).filter(Boolean);
+}
 function scoreCompletedObservation(obs) {
   let score = scoreNarrativeObservation(obs);
   if (obs.type === "feature")
@@ -801,9 +814,59 @@ function isVecExtensionLoaded(db) {
     return false;
   }
 }
+function tableExists(db, name) {
+  const row = db.query(`SELECT name FROM sqlite_master WHERE type IN ('table', 'view') AND name = ?`).get(name);
+  return Boolean(row?.name);
+}
+function columnExists(db, table, column) {
+  if (!tableExists(db, table))
+    return false;
+  const rows = db.query(`PRAGMA table_info(${table})`).all();
+  return rows.some((row) => row.name === column);
+}
+function ensureLegacyBaseTables(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS sync_state (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `);
+}
+function inferLegacySchemaVersion(db) {
+  const hasProjects = tableExists(db, "projects");
+  const hasObservations = tableExists(db, "observations");
+  const hasSessions = tableExists(db, "sessions");
+  if (!(hasProjects && hasObservations && hasSessions))
+    return 0;
+  ensureLegacyBaseTables(db);
+  let version = 1;
+  if (columnExists(db, "observations", "superseded_by"))
+    version = Math.max(version, 2);
+  if (columnExists(db, "observations", "remote_source_id"))
+    version = Math.max(version, 3);
+  if (tableExists(db, "vec_observations"))
+    version = Math.max(version, 4);
+  const hasSessionMetrics = columnExists(db, "sessions", "files_touched_count") && columnExists(db, "sessions", "searches_performed") && columnExists(db, "sessions", "tool_calls_count");
+  if (hasSessionMetrics || tableExists(db, "security_findings"))
+    version = Math.max(version, 5);
+  if (columnExists(db, "sessions", "risk_score"))
+    version = Math.max(version, 6);
+  if (tableExists(db, "packs_installed"))
+    version = Math.max(version, 7);
+  if (tableExists(db, "user_prompts"))
+    version = Math.max(version, 9);
+  if (tableExists(db, "tool_events"))
+    version = Math.max(version, 10);
+  return version;
+}
 function runMigrations(db) {
   const currentVersion = db.query("PRAGMA user_version").get();
   let version = currentVersion.user_version;
+  const inferred = inferLegacySchemaVersion(db);
+  if (inferred > version) {
+    db.exec(`PRAGMA user_version = ${inferred}`);
+    version = inferred;
+  }
   for (const migration of MIGRATIONS) {
     if (migration.version <= version)
       continue;
@@ -879,6 +942,11 @@ import { createHash as createHash2 } from "node:crypto";
 var IS_BUN = typeof globalThis.Bun !== "undefined";
 function openDatabase(dbPath) {
   if (IS_BUN) {
+    if (process.platform === "darwin") {
+      try {
+        return openNodeDatabase(dbPath);
+      } catch {}
+    }
     return openBunDatabase(dbPath);
   }
   return openNodeDatabase(dbPath);
@@ -1857,8 +1925,13 @@ function buildSummaryVectorDocument(summary, config, project, observations = [],
       next_step_items: extractSectionItems(summary.next_steps),
       prompt_count: captureContext?.prompt_count ?? 0,
       tool_event_count: captureContext?.tool_event_count ?? 0,
+      capture_state: captureContext?.capture_state ?? "summary-only",
+      recent_request_prompts: captureContext?.recent_request_prompts ?? [],
       latest_request: captureContext?.latest_request ?? null,
       recent_tool_names: captureContext?.recent_tool_names ?? [],
+      recent_tool_commands: captureContext?.recent_tool_commands ?? [],
+      hot_files: captureContext?.hot_files ?? [],
+      recent_outcomes: captureContext?.recent_outcomes ?? [],
       decisions_count: valueSignals.decisions_count,
       lessons_count: valueSignals.lessons_count,
       discoveries_count: valueSignals.discoveries_count,
@@ -1902,7 +1975,7 @@ async function pushOutbox(db, client, config, batchSize = 50) {
       const doc2 = buildSummaryVectorDocument(summary, config, {
         canonical_id: project2.canonical_id,
         name: project2.name
-      }, summaryObservations, buildSummaryCaptureContext(sessionPrompts, sessionToolEvents));
+      }, summaryObservations, buildSummaryCaptureContext(sessionPrompts, sessionToolEvents, summaryObservations));
       batch.push({ entryId: entry.id, doc: doc2 });
       continue;
     }
@@ -1976,16 +2049,39 @@ function extractSectionItems(section) {
   return section.split(`
 `).map((line) => line.trim()).filter(Boolean).map((line) => line.replace(/^[-*]\s*/, "").trim()).filter(Boolean).slice(0, 4);
 }
-function buildSummaryCaptureContext(prompts, toolEvents) {
+function buildSummaryCaptureContext(prompts, toolEvents, observations) {
   const latestRequest = prompts.length > 0 ? prompts[prompts.length - 1]?.prompt ?? null : null;
+  const recentRequestPrompts = prompts.slice(-3).map((prompt) => prompt.prompt.trim()).filter(Boolean);
   const recentToolNames = [...new Set(toolEvents.slice(-8).map((tool) => tool.tool_name).filter(Boolean))];
+  const recentToolCommands = [...new Set(toolEvents.slice(-5).map((tool) => (tool.command ?? tool.file_path ?? "").trim()).filter(Boolean))];
+  const hotFiles = [...new Set(observations.flatMap((obs) => [
+    ...parseJsonArray2(obs.files_modified),
+    ...parseJsonArray2(obs.files_read)
+  ]).filter(Boolean))].slice(0, 6);
+  const recentOutcomes = observations.filter((obs) => ["bugfix", "feature", "refactor", "change", "decision"].includes(obs.type)).map((obs) => obs.title.trim()).filter((title) => title.length > 0).slice(0, 6);
+  const captureState = prompts.length > 0 && toolEvents.length > 0 ? "rich" : prompts.length > 0 || toolEvents.length > 0 ? "partial" : "summary-only";
   return {
     prompt_count: prompts.length,
     tool_event_count: toolEvents.length,
+    recent_request_prompts: recentRequestPrompts,
     latest_request: latestRequest,
-    recent_tool_names: recentToolNames
+    recent_tool_names: recentToolNames,
+    recent_tool_commands: recentToolCommands,
+    capture_state: captureState,
+    hot_files: hotFiles,
+    recent_outcomes: recentOutcomes
   };
 }
+function parseJsonArray2(value) {
+  if (!value)
+    return [];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
+  } catch {
+    return [];
+  }
+}
 
 // src/embeddings/embedder.ts
 var _available = null;

package/dist/hooks/user-prompt-submit.js

@@ -723,9 +723,59 @@ function isVecExtensionLoaded(db) {
     return false;
   }
 }
+function tableExists(db, name) {
+  const row = db.query(`SELECT name FROM sqlite_master WHERE type IN ('table', 'view') AND name = ?`).get(name);
+  return Boolean(row?.name);
+}
+function columnExists(db, table, column) {
+  if (!tableExists(db, table))
+    return false;
+  const rows = db.query(`PRAGMA table_info(${table})`).all();
+  return rows.some((row) => row.name === column);
+}
+function ensureLegacyBaseTables(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS sync_state (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `);
+}
+function inferLegacySchemaVersion(db) {
+  const hasProjects = tableExists(db, "projects");
+  const hasObservations = tableExists(db, "observations");
+  const hasSessions = tableExists(db, "sessions");
+  if (!(hasProjects && hasObservations && hasSessions))
+    return 0;
+  ensureLegacyBaseTables(db);
+  let version = 1;
+  if (columnExists(db, "observations", "superseded_by"))
+    version = Math.max(version, 2);
+  if (columnExists(db, "observations", "remote_source_id"))
+    version = Math.max(version, 3);
+  if (tableExists(db, "vec_observations"))
+    version = Math.max(version, 4);
+  const hasSessionMetrics = columnExists(db, "sessions", "files_touched_count") && columnExists(db, "sessions", "searches_performed") && columnExists(db, "sessions", "tool_calls_count");
+  if (hasSessionMetrics || tableExists(db, "security_findings"))
+    version = Math.max(version, 5);
+  if (columnExists(db, "sessions", "risk_score"))
+    version = Math.max(version, 6);
+  if (tableExists(db, "packs_installed"))
+    version = Math.max(version, 7);
+  if (tableExists(db, "user_prompts"))
+    version = Math.max(version, 9);
+  if (tableExists(db, "tool_events"))
+    version = Math.max(version, 10);
+  return version;
+}
 function runMigrations(db) {
   const currentVersion = db.query("PRAGMA user_version").get();
   let version = currentVersion.user_version;
+  const inferred = inferLegacySchemaVersion(db);
+  if (inferred > version) {
+    db.exec(`PRAGMA user_version = ${inferred}`);
+    version = inferred;
+  }
   for (const migration of MIGRATIONS) {
     if (migration.version <= version)
       continue;
@@ -801,6 +851,11 @@ import { createHash as createHash2 } from "node:crypto";
 var IS_BUN = typeof globalThis.Bun !== "undefined";
 function openDatabase(dbPath) {
   if (IS_BUN) {
+    if (process.platform === "darwin") {
+      try {
+        return openNodeDatabase(dbPath);
+      } catch {}
+    }
     return openBunDatabase(dbPath);
   }
   return openNodeDatabase(dbPath);

package/dist/server.js

@@ -14129,9 +14129,59 @@ function isVecExtensionLoaded(db) {
     return false;
   }
 }
+function tableExists(db, name) {
+  const row = db.query(`SELECT name FROM sqlite_master WHERE type IN ('table', 'view') AND name = ?`).get(name);
+  return Boolean(row?.name);
+}
+function columnExists(db, table, column) {
+  if (!tableExists(db, table))
+    return false;
+  const rows = db.query(`PRAGMA table_info(${table})`).all();
+  return rows.some((row) => row.name === column);
+}
+function ensureLegacyBaseTables(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS sync_state (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `);
+}
+function inferLegacySchemaVersion(db) {
+  const hasProjects = tableExists(db, "projects");
+  const hasObservations = tableExists(db, "observations");
+  const hasSessions = tableExists(db, "sessions");
+  if (!(hasProjects && hasObservations && hasSessions))
+    return 0;
+  ensureLegacyBaseTables(db);
+  let version2 = 1;
+  if (columnExists(db, "observations", "superseded_by"))
+    version2 = Math.max(version2, 2);
+  if (columnExists(db, "observations", "remote_source_id"))
+    version2 = Math.max(version2, 3);
+  if (tableExists(db, "vec_observations"))
+    version2 = Math.max(version2, 4);
+  const hasSessionMetrics = columnExists(db, "sessions", "files_touched_count") && columnExists(db, "sessions", "searches_performed") && columnExists(db, "sessions", "tool_calls_count");
+  if (hasSessionMetrics || tableExists(db, "security_findings"))
+    version2 = Math.max(version2, 5);
+  if (columnExists(db, "sessions", "risk_score"))
+    version2 = Math.max(version2, 6);
+  if (tableExists(db, "packs_installed"))
+    version2 = Math.max(version2, 7);
+  if (tableExists(db, "user_prompts"))
+    version2 = Math.max(version2, 9);
+  if (tableExists(db, "tool_events"))
+    version2 = Math.max(version2, 10);
+  return version2;
+}
 function runMigrations(db) {
   const currentVersion = db.query("PRAGMA user_version").get();
   let version2 = currentVersion.user_version;
+  const inferred = inferLegacySchemaVersion(db);
+  if (inferred > version2) {
+    db.exec(`PRAGMA user_version = ${inferred}`);
+    version2 = inferred;
+  }
   for (const migration of MIGRATIONS) {
     if (migration.version <= version2)
       continue;
@@ -14211,6 +14261,11 @@ import { createHash as createHash2 } from "node:crypto";
 var IS_BUN = typeof globalThis.Bun !== "undefined";
 function openDatabase(dbPath) {
   if (IS_BUN) {
+    if (process.platform === "darwin") {
+      try {
+        return openNodeDatabase(dbPath);
+      } catch {}
+    }
     return openBunDatabase(dbPath);
   }
   return openNodeDatabase(dbPath);
@@ -17331,18 +17386,44 @@ function getSessionContext(db, input) {
   });
   if (!context)
     return null;
+  const recentRequests = context.recentPrompts?.length ?? 0;
+  const recentTools = context.recentToolEvents?.length ?? 0;
+  const captureState = recentRequests > 0 && recentTools > 0 ? "rich" : recentRequests > 0 || recentTools > 0 ? "partial" : "summary-only";
+  const hotFiles = buildHotFiles(context);
   return {
     project_name: context.project_name,
     canonical_id: context.canonical_id,
     session_count: context.session_count,
     total_active: context.total_active,
-    recent_requests: context.recentPrompts?.length ?? 0,
-    recent_tools: context.recentToolEvents?.length ?? 0,
+    recent_requests: recentRequests,
+    recent_tools: recentTools,
     recent_sessions: context.recentSessions?.length ?? 0,
-    raw_capture_active: (context.recentPrompts?.length ?? 0) > 0 || (context.recentToolEvents?.length ?? 0) > 0,
+    recent_outcomes: context.recentOutcomes ?? [],
+    hot_files: hotFiles,
+    capture_state: captureState,
+    raw_capture_active: recentRequests > 0 || recentTools > 0,
     preview: formatContextForInjection(context)
   };
 }
+function buildHotFiles(context) {
+  const counts = new Map;
+  for (const obs of context.observations) {
+    for (const path of [...parseJsonArray(obs.files_read), ...parseJsonArray(obs.files_modified)]) {
+      counts.set(path, (counts.get(path) ?? 0) + 1);
+    }
+  }
+  return Array.from(counts.entries()).map(([path, count]) => ({ path, count })).sort((a, b) => b.count - a.count || a.path.localeCompare(b.path)).slice(0, 6);
+}
+function parseJsonArray(value) {
+  if (!value)
+    return [];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
+  } catch {
+    return [];
+  }
+}
 
 // src/tools/send-message.ts
 async function sendMessage(db, config2, input) {
@@ -17959,8 +18040,13 @@ function buildSummaryVectorDocument(summary, config2, project, observations = []
       next_step_items: extractSectionItems2(summary.next_steps),
       prompt_count: captureContext?.prompt_count ?? 0,
       tool_event_count: captureContext?.tool_event_count ?? 0,
+      capture_state: captureContext?.capture_state ?? "summary-only",
+      recent_request_prompts: captureContext?.recent_request_prompts ?? [],
       latest_request: captureContext?.latest_request ?? null,
       recent_tool_names: captureContext?.recent_tool_names ?? [],
+      recent_tool_commands: captureContext?.recent_tool_commands ?? [],
+      hot_files: captureContext?.hot_files ?? [],
+      recent_outcomes: captureContext?.recent_outcomes ?? [],
       decisions_count: valueSignals.decisions_count,
       lessons_count: valueSignals.lessons_count,
       discoveries_count: valueSignals.discoveries_count,
@@ -18004,7 +18090,7 @@ async function pushOutbox(db, client, config2, batchSize = 50) {
       const doc3 = buildSummaryVectorDocument(summary, config2, {
         canonical_id: project2.canonical_id,
         name: project2.name
-      }, summaryObservations, buildSummaryCaptureContext(sessionPrompts, sessionToolEvents));
+      }, summaryObservations, buildSummaryCaptureContext(sessionPrompts, sessionToolEvents, summaryObservations));
       batch.push({ entryId: entry.id, doc: doc3 });
       continue;
     }
@@ -18078,16 +18164,39 @@ function extractSectionItems2(section) {
   return section.split(`
 `).map((line) => line.trim()).filter(Boolean).map((line) => line.replace(/^[-*]\s*/, "").trim()).filter(Boolean).slice(0, 4);
 }
-function buildSummaryCaptureContext(prompts, toolEvents) {
+function buildSummaryCaptureContext(prompts, toolEvents, observations) {
   const latestRequest = prompts.length > 0 ? prompts[prompts.length - 1]?.prompt ?? null : null;
+  const recentRequestPrompts = prompts.slice(-3).map((prompt) => prompt.prompt.trim()).filter(Boolean);
   const recentToolNames = [...new Set(toolEvents.slice(-8).map((tool) => tool.tool_name).filter(Boolean))];
+  const recentToolCommands = [...new Set(toolEvents.slice(-5).map((tool) => (tool.command ?? tool.file_path ?? "").trim()).filter(Boolean))];
+  const hotFiles = [...new Set(observations.flatMap((obs) => [
+    ...parseJsonArray2(obs.files_modified),
+    ...parseJsonArray2(obs.files_read)
+  ]).filter(Boolean))].slice(0, 6);
+  const recentOutcomes = observations.filter((obs) => ["bugfix", "feature", "refactor", "change", "decision"].includes(obs.type)).map((obs) => obs.title.trim()).filter((title) => title.length > 0).slice(0, 6);
+  const captureState = prompts.length > 0 && toolEvents.length > 0 ? "rich" : prompts.length > 0 || toolEvents.length > 0 ? "partial" : "summary-only";
   return {
     prompt_count: prompts.length,
     tool_event_count: toolEvents.length,
+    recent_request_prompts: recentRequestPrompts,
     latest_request: latestRequest,
-    recent_tool_names: recentToolNames
+    recent_tool_names: recentToolNames,
+    recent_tool_commands: recentToolCommands,
+    capture_state: captureState,
+    hot_files: hotFiles,
+    recent_outcomes: recentOutcomes
   };
 }
+function parseJsonArray2(value) {
+  if (!value)
+    return [];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
+  } catch {
+    return [];
+  }
+}
 
 // src/sync/pull.ts
 var PULL_CURSOR_KEY = "pull_cursor";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engrm",
-  "version": "0.4.9",
+  "version": "0.4.11",
   "description": "Shared memory across devices, sessions, and coding agents",
   "mcpName": "io.github.dr12hes/engrm",
   "type": "module",