@askexenow/exe-os 0.9.62 → 0.9.63

package/dist/mcp/server.js

@@ -1893,6 +1893,15 @@ var init_database_adapter = __esm({
 });
 
 // src/lib/daemon-protocol.ts
+var daemon_protocol_exports = {};
+__export(daemon_protocol_exports, {
+  deserializeArgs: () => deserializeArgs,
+  deserializeResultSet: () => deserializeResultSet,
+  deserializeValue: () => deserializeValue,
+  serializeArgs: () => serializeArgs,
+  serializeResultSet: () => serializeResultSet,
+  serializeValue: () => serializeValue
+});
 function serializeValue(v) {
   if (v === null || v === void 0) return null;
   if (typeof v === "bigint") return Number(v);
@@ -1917,6 +1926,32 @@ function deserializeValue(v) {
   }
   return v;
 }
+function serializeArgs(args) {
+  return args.map(serializeValue);
+}
+function deserializeArgs(args) {
+  return args.map(deserializeValue);
+}
+function serializeResultSet(rs) {
+  const rows = [];
+  for (const row of rs.rows) {
+    const obj = {};
+    for (let i = 0; i < rs.columns.length; i++) {
+      const col = rs.columns[i];
+      if (col !== void 0) {
+        obj[col] = serializeValue(row[i]);
+      }
+    }
+    rows.push(obj);
+  }
+  return {
+    columns: [...rs.columns],
+    columnTypes: [...rs.columnTypes ?? []],
+    rows,
+    rowsAffected: typeof rs.rowsAffected === "bigint" ? Number(rs.rowsAffected) : rs.rowsAffected ?? 0,
+    lastInsertRowid: rs.lastInsertRowid != null ? typeof rs.lastInsertRowid === "bigint" ? Number(rs.lastInsertRowid) : rs.lastInsertRowid : null
+  };
+}
 function deserializeResultSet(srs) {
   const rows = srs.rows.map((obj) => {
     const values = srs.columns.map(
@@ -12853,6 +12888,78 @@ var init_worker_gate = __esm({
   }
 });
 
+// src/bin/fast-db-init.ts
+var fast_db_init_exports = {};
+__export(fast_db_init_exports, {
+  fastDbInit: () => fastDbInit
+});
+async function fastDbInit() {
+  const { isInitialized: isInitialized2, getClient: getClient2, setExternalClient: setExternalClient2 } = await Promise.resolve().then(() => (init_database(), database_exports));
+  if (isInitialized2()) {
+    return getClient2();
+  }
+  try {
+    const { connectEmbedDaemon: connectEmbedDaemon2, sendDaemonRequest: sendDaemonRequest2, isClientConnected: isClientConnected2 } = await Promise.resolve().then(() => (init_exe_daemon_client(), exe_daemon_client_exports));
+    const { deserializeResultSet: deserializeResultSet2 } = await Promise.resolve().then(() => (init_daemon_protocol(), daemon_protocol_exports));
+    await connectEmbedDaemon2();
+    if (isClientConnected2()) {
+      const daemonClient = {
+        async execute(stmt) {
+          const sql = typeof stmt === "string" ? stmt : stmt.sql;
+          const args = typeof stmt === "string" ? [] : Array.isArray(stmt.args) ? stmt.args : [];
+          const resp = await sendDaemonRequest2({ type: "db-execute", sql, args });
+          if (resp.error) throw new Error(String(resp.error));
+          if (resp.db) return deserializeResultSet2(resp.db);
+          throw new Error("Unexpected daemon response");
+        },
+        async batch(stmts, mode) {
+          const statements = stmts.map((s) => {
+            const sql = typeof s === "string" ? s : s.sql;
+            const args = typeof s === "string" ? [] : Array.isArray(s.args) ? s.args : [];
+            return { sql, args };
+          });
+          const resp = await sendDaemonRequest2({ type: "db-batch", statements, mode: mode ?? "deferred" });
+          if (resp.error) throw new Error(String(resp.error));
+          const batchResults = resp["db-batch"];
+          if (batchResults) return batchResults.map(deserializeResultSet2);
+          throw new Error("Unexpected daemon batch response");
+        },
+        async transaction(_mode) {
+          throw new Error("Transactions not supported via daemon socket");
+        },
+        async executeMultiple(_sql) {
+          throw new Error("executeMultiple not supported via daemon socket");
+        },
+        async migrate(_stmts) {
+          throw new Error("migrate not supported via daemon socket");
+        },
+        sync() {
+          return Promise.resolve(void 0);
+        },
+        close() {
+        },
+        get closed() {
+          return false;
+        },
+        get protocol() {
+          return "file";
+        }
+      };
+      setExternalClient2(daemonClient);
+      return daemonClient;
+    }
+  } catch {
+  }
+  const { initStore: initStore2 } = await Promise.resolve().then(() => (init_store(), store_exports));
+  await initStore2({ lightweight: true });
+  return getClient2();
+}
+var init_fast_db_init = __esm({
+  "src/bin/fast-db-init.ts"() {
+    "use strict";
+  }
+});
+
 // src/lib/db-backup.ts
 var db_backup_exports = {};
 __export(db_backup_exports, {
@@ -18685,8 +18792,6 @@ init_database();
 import { z as z56 } from "zod";
 
 // src/bin/exe-doctor.ts
-init_store();
-init_database();
 import os14 from "os";
 
 // src/lib/is-main.ts
@@ -18970,6 +19075,140 @@ async function detectConflicts(client, projectFilter, agentFilter2) {
   };
 }
 
+// src/adapters/runtime-hook-manifest.ts
+var EXE_HOOKS = {
+  postToolCombined: "dist/hooks/post-tool-combined.js",
+  sessionStart: "dist/hooks/session-start.js",
+  promptSubmit: "dist/hooks/prompt-submit.js",
+  heartbeat: "dist/hooks/exe-heartbeat-hook.js",
+  stop: "dist/hooks/stop.js",
+  preToolUse: "dist/hooks/pre-tool-use.js",
+  subagentStop: "dist/hooks/subagent-stop.js",
+  preCompact: "dist/hooks/pre-compact.js",
+  postCompact: "dist/hooks/post-compact.js",
+  sessionEnd: "dist/hooks/session-end.js",
+  notification: "dist/hooks/notification.js",
+  instructionsLoaded: "dist/hooks/instructions-loaded.js"
+};
+var EXE_HOOK_MANIFEST = [
+  {
+    key: "postToolCombined",
+    event: "PostToolUse",
+    commandMarker: EXE_HOOKS.postToolCombined,
+    owner: "exe-os",
+    purpose: "Single PostToolUse entrypoint for ingestion, error recall, summaries, and bug detection.",
+    runtimes: ["claude", "codex", "opencode"],
+    checkpointRole: "none"
+  },
+  {
+    key: "sessionStart",
+    event: "SessionStart",
+    commandMarker: EXE_HOOKS.sessionStart,
+    owner: "exe-os",
+    purpose: "Loads agent identity, procedures, and boot context.",
+    runtimes: ["claude", "codex", "opencode"],
+    checkpointRole: "none"
+  },
+  {
+    key: "promptSubmit",
+    event: "UserPromptSubmit",
+    commandMarker: EXE_HOOKS.promptSubmit,
+    owner: "exe-os",
+    purpose: "Injects current tasks, pending reviews, and local context before each prompt.",
+    runtimes: ["claude", "codex", "opencode"],
+    checkpointRole: "none"
+  },
+  {
+    key: "heartbeat",
+    event: "UserPromptSubmit",
+    commandMarker: EXE_HOOKS.heartbeat,
+    owner: "exe-os",
+    purpose: "Lightweight heartbeat/status sidecar for Claude Code sessions.",
+    runtimes: ["claude"],
+    checkpointRole: "none"
+  },
+  {
+    key: "stop",
+    event: "Stop",
+    commandMarker: EXE_HOOKS.stop,
+    owner: "exe-os",
+    purpose: "Finalizes task state, capacity signals, and emergency checkpointing.",
+    runtimes: ["claude", "codex", "opencode"],
+    checkpointRole: "capacity_checkpoint"
+  },
+  {
+    key: "preToolUse",
+    event: "PreToolUse",
+    commandMarker: EXE_HOOKS.preToolUse,
+    owner: "exe-os",
+    purpose: "Preflight guardrails before shell/tool execution.",
+    runtimes: ["claude", "codex", "opencode"],
+    checkpointRole: "none"
+  },
+  {
+    key: "subagentStop",
+    event: "SubagentStop",
+    commandMarker: EXE_HOOKS.subagentStop,
+    owner: "exe-os",
+    purpose: "Captures subagent completion context.",
+    runtimes: ["claude"],
+    checkpointRole: "none"
+  },
+  {
+    key: "preCompact",
+    event: "PreCompact",
+    commandMarker: EXE_HOOKS.preCompact,
+    owner: "exe-os",
+    purpose: "Writes active-task snapshot and compaction recovery context.",
+    runtimes: ["claude"],
+    checkpointRole: "recovery_context"
+  },
+  {
+    key: "postCompact",
+    event: "PostCompact",
+    commandMarker: EXE_HOOKS.postCompact,
+    owner: "exe-os",
+    purpose: "Rehydrates recovery context after compaction.",
+    runtimes: ["claude"],
+    checkpointRole: "recovery_context"
+  },
+  {
+    key: "sessionEnd",
+    event: "SessionEnd",
+    commandMarker: EXE_HOOKS.sessionEnd,
+    owner: "exe-os",
+    purpose: "Stores session-end checkpoint and triages orphaned in-progress tasks.",
+    runtimes: ["claude"],
+    checkpointRole: "session_summary"
+  },
+  {
+    key: "notification",
+    event: "Notification",
+    commandMarker: EXE_HOOKS.notification,
+    owner: "exe-os",
+    purpose: "Captures runtime notifications and nudges.",
+    runtimes: ["claude"],
+    checkpointRole: "none"
+  },
+  {
+    key: "instructionsLoaded",
+    event: "InstructionsLoaded",
+    commandMarker: EXE_HOOKS.instructionsLoaded,
+    owner: "exe-os",
+    purpose: "Applies runtime instruction post-processing.",
+    runtimes: ["claude"],
+    checkpointRole: "none"
+  }
+];
+var LEGACY_SPLIT_POST_TOOL_HOOK_MARKERS = [
+  "dist/hooks/ingest.js",
+  "dist/hooks/error-recall.js",
+  "dist/hooks/ingest-worker.js"
+];
+function manifestEntryForCommand(command) {
+  return EXE_HOOK_MANIFEST.find((entry) => command.includes(entry.commandMarker));
+}
+
 // src/bin/exe-doctor.ts
 function parseFlags(argv) {
   const flags = { fix: false, dryRun: false, verbose: false, conflicts: false };
@@ -19168,6 +19407,121 @@ function auditHookHealth() {
   const topPatterns = [...patternCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([pattern, count]) => ({ pattern, count }));
   return { logExists: true, totalLines, errorsLastHour, topPatterns };
 }
+function safeReadJson(filePath) {
+  if (!existsSync27(filePath)) return null;
+  try {
+    return JSON.parse(readFileSync20(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function collectHookCommandsFromClaudeSettings(settings) {
+  const hooks = settings?.hooks;
+  if (!hooks || typeof hooks !== "object") return [];
+  const commands = [];
+  for (const [event, groups] of Object.entries(hooks)) {
+    if (!Array.isArray(groups)) continue;
+    for (const group of groups) {
+      const hooksForGroup = group?.hooks;
+      if (!Array.isArray(hooksForGroup)) continue;
+      for (const hook of hooksForGroup) {
+        const command = hook?.command;
+        if (typeof command === "string") commands.push({ event, command });
+      }
+    }
+  }
+  return commands;
+}
+function collectHookCommandsFromCodexHooks(config2) {
+  const commands = [];
+  if (!config2 || typeof config2 !== "object") return commands;
+  const root = config2;
+  for (const [event, value] of Object.entries(root)) {
+    const entries = Array.isArray(value) ? value : value && typeof value === "object" ? Object.values(value) : [];
+    for (const entry of entries) {
+      if (typeof entry === "string") commands.push({ event, command: entry });
+      const command = entry?.command;
+      if (typeof command === "string") commands.push({ event, command });
+    }
+  }
+  return commands;
+}
+function buildHookOwnershipIssues(runtime, commands) {
+  const issues = [];
+  for (const marker of LEGACY_SPLIT_POST_TOOL_HOOK_MARKERS) {
+    const count = commands.filter((cmd) => cmd.command.includes(marker)).length;
+    if (count > 0) {
+      issues.push({
+        runtime,
+        event: "PostToolUse",
+        marker,
+        count,
+        message: `Legacy split PostToolUse hook still installed: ${marker}`
+      });
+    }
+  }
+  for (const entry of EXE_HOOK_MANIFEST.filter((hook) => hook.runtimes.includes(runtime))) {
+    const matching = commands.filter((cmd) => cmd.command.includes(entry.commandMarker));
+    if (matching.length > 1) {
+      issues.push({
+        runtime,
+        event: entry.event,
+        marker: entry.commandMarker,
+        count: matching.length,
+        message: `Duplicate exe-os hook owner for ${entry.event}: ${entry.commandMarker}`
+      });
+    }
+    for (const cmd of matching) {
+      if (cmd.event !== entry.event) {
+        issues.push({
+          runtime,
+          event: cmd.event,
+          marker: entry.commandMarker,
+          count: 1,
+          message: `exe-os hook ${entry.commandMarker} is registered under ${cmd.event}, expected ${entry.event}`
+        });
+      }
+    }
+  }
+  for (const cmd of commands) {
+    if (!cmd.command.includes("dist/hooks/")) continue;
+    if (!cmd.command.includes("exe-os")) continue;
+    const entry = manifestEntryForCommand(cmd.command);
+    const isLegacy = LEGACY_SPLIT_POST_TOOL_HOOK_MARKERS.some((marker) => cmd.command.includes(marker));
+    if (!entry && !isLegacy) {
+      issues.push({
+        runtime,
+        event: cmd.event,
+        marker: "dist/hooks/",
+        count: 1,
+        message: `Unknown exe-os hook command not present in ownership manifest: ${cmd.command.slice(0, 160)}`
+      });
+    }
+  }
+  return issues;
+}
+function auditHookOwnership() {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+  const checkedFiles = [];
+  const issues = [];
+  const claudeSettingsPath = path32.join(home, ".claude", "settings.json");
+  const claudeSettings = safeReadJson(claudeSettingsPath);
+  if (claudeSettings) {
+    checkedFiles.push(claudeSettingsPath);
+    issues.push(...buildHookOwnershipIssues("claude", collectHookCommandsFromClaudeSettings(claudeSettings)));
+  }
+  const codexHooksPath = path32.join(home, ".codex", "hooks.json");
+  const codexHooks = safeReadJson(codexHooksPath);
+  if (codexHooks) {
+    checkedFiles.push(codexHooksPath);
+    issues.push(...buildHookOwnershipIssues("codex", collectHookCommandsFromCodexHooks(codexHooks)));
+  }
+  return {
+    checkedFiles,
+    issues,
+    staleLegacyHooks: issues.filter((issue) => issue.message.includes("Legacy split"))
+  };
+}
 async function auditShards() {
   try {
     const { auditShardHealth: auditShardHealth2 } = await Promise.resolve().then(() => (init_shard_manager(), shard_manager_exports));
@@ -19212,7 +19566,8 @@ async function runAudit(client, flags) {
   }
   const duplicateCount = duplicates.reduce((sum, d) => sum + d.delete_ids.length, 0);
   const hookHealth = auditHookHealth();
-  return { stats, nullVectors, duplicates, duplicateCount, bloated, fts, orphanedProjects, conflicts, hookHealth, shards };
+  const hookOwnership = auditHookOwnership();
+  return { stats, nullVectors, duplicates, duplicateCount, bloated, fts, orphanedProjects, conflicts, hookHealth, hookOwnership, shards };
 }
 function indicator(value, warn) {
   if (value === 0) return "\u{1F7E2}";
@@ -19291,6 +19646,15 @@ function formatReport(report, flags) {
       lines.push(`                     ${p.count}x: ${p.pattern}`);
     }
   }
+  const ho = report.hookOwnership;
+  if (ho.issues.length === 0) {
+    lines.push(`\u{1F7E2} Hook ownership:  ${ho.checkedFiles.length > 0 ? "manifest clean" : "no local hook config found"}`);
+  } else {
+    lines.push(`\u{1F534} Hook ownership:  ${fmtNum(ho.issues.length)} issue(s)`);
+    for (const issue of ho.issues.slice(0, 5)) {
+      lines.push(`                     [${issue.runtime}/${issue.event}] ${issue.message}`);
+    }
+  }
   const sh = report.shards;
   if (sh.total > 0) {
     if (sh.unreadable === 0) {
@@ -19360,6 +19724,9 @@ function formatReport(report, flags) {
   if (report.conflicts.superseded > 0) {
     recs.push(`${fmtNum(report.conflicts.superseded)} superseded memories can be deactivated`);
   }
+  if (report.hookOwnership.issues.length > 0) {
+    recs.push(`Run exe-os install to refresh hook config; remove stale exe-os hook commands if they remain`);
+  }
   if (recs.length > 0) {
     lines.push("Recommendations:");
     for (const r of recs) {
@@ -19493,8 +19860,8 @@ function splitAtSentences(text3, maxChunkSize) {
 }
 async function main(argv = process.argv.slice(2)) {
   const flags = parseFlags(argv);
-  await initStore();
-  const client = getClient();
+  const { fastDbInit: fastDbInit2 } = await Promise.resolve().then(() => (init_fast_db_init(), fast_db_init_exports));
+  const client = await fastDbInit2();
   const report = await runAudit(client, flags);
   console.log(formatReport(report, flags));
   if (flags.fix || flags.dryRun) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askexenow/exe-os",
-  "version": "0.9.62",
+  "version": "0.9.63",
   "description": "AI employee operating system — persistent memory, task management, and multi-agent coordination for Claude Code.",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",