@askexenow/exe-os 0.9.63 → 0.9.64

package/dist/mcp/server.js

@@ -1893,15 +1893,6 @@ 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);
@@ -1926,32 +1917,6 @@ 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(
@@ -12888,78 +12853,6 @@ 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, {
@@ -18792,6 +18685,8 @@ 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
@@ -19075,140 +18970,6 @@ 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 };
@@ -19407,121 +19168,6 @@ 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));
@@ -19566,8 +19212,7 @@ async function runAudit(client, flags) {
   }
   const duplicateCount = duplicates.reduce((sum, d) => sum + d.delete_ids.length, 0);
   const hookHealth = auditHookHealth();
-  const hookOwnership = auditHookOwnership();
-  return { stats, nullVectors, duplicates, duplicateCount, bloated, fts, orphanedProjects, conflicts, hookHealth, hookOwnership, shards };
+  return { stats, nullVectors, duplicates, duplicateCount, bloated, fts, orphanedProjects, conflicts, hookHealth, shards };
 }
 function indicator(value, warn) {
   if (value === 0) return "\u{1F7E2}";
@@ -19646,15 +19291,6 @@ 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) {
@@ -19724,9 +19360,6 @@ 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) {
@@ -19860,8 +19493,8 @@ function splitAtSentences(text3, maxChunkSize) {
 }
 async function main(argv = process.argv.slice(2)) {
   const flags = parseFlags(argv);
-  const { fastDbInit: fastDbInit2 } = await Promise.resolve().then(() => (init_fast_db_init(), fast_db_init_exports));
-  const client = await fastDbInit2();
+  await initStore();
+  const client = getClient();
   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.63",
+  "version": "0.9.64",
   "description": "AI employee operating system — persistent memory, task management, and multi-agent coordination for Claude Code.",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",