@askexenow/exe-os 0.9.271 → 0.9.273

package/dist/chunk-X2WBH2IO.js

@@ -0,0 +1,297 @@
+import {
+  getClient
+} from "./chunk-CHBHR5W6.js";
+
+// src/lib/memory-graph-extractor.ts
+function entityId(type, name) {
+  return `mem:${type}:${name.toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "")}`;
+}
+function relationshipId(sourceId, targetId, relType) {
+  return `rel:${sourceId}:${relType}:${targetId}`;
+}
+var FILE_EXT_PATTERN = /(?:^|\s|['"`(])([a-zA-Z0-9_./-]+\.(?:ts|js|tsx|jsx|json|md|py|rs|go|toml|yaml|yml|css|html|sql|sh|bash|zsh|env|conf|cfg|xml|csv|lock))\b/g;
+var PATH_PATTERN = /(?:^|\s|['"`(])((?:src|lib|bin|dist|tests?|__tests__|node_modules|\.?\w+)\/[a-zA-Z0-9_./-]+)/g;
+function extractFilePaths(text) {
+  const paths = /* @__PURE__ */ new Set();
+  let match;
+  FILE_EXT_PATTERN.lastIndex = 0;
+  while ((match = FILE_EXT_PATTERN.exec(text)) !== null) {
+    const p = match[1].trim();
+    if (p.length >= 3 && p.length <= 200 && !p.startsWith("http")) {
+      paths.add(p);
+    }
+  }
+  PATH_PATTERN.lastIndex = 0;
+  while ((match = PATH_PATTERN.exec(text)) !== null) {
+    const p = match[1].trim();
+    if (p.length >= 5 && p.length <= 200 && !p.startsWith("http") && p.includes("/")) {
+      paths.add(p);
+    }
+  }
+  return Array.from(paths).slice(0, 20);
+}
+var ERROR_PATTERNS = [
+  /\b(Error|TypeError|ReferenceError|SyntaxError|RangeError):\s*(.{10,80})/g,
+  /\b(ERR_[A-Z_]+)/g,
+  /\b(ENOENT|EACCES|EPERM|ECONNREFUSED|ETIMEDOUT|SQLITE_BUSY)\b/g,
+  /\bfailed\s+(?:to\s+)?(\w+(?:\s+\w+){0,3})/gi
+];
+function extractErrors(text) {
+  const errors = /* @__PURE__ */ new Set();
+  for (const pattern of ERROR_PATTERNS) {
+    pattern.lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+      const err = (match[1] ?? match[0]).trim();
+      if (err.length >= 3 && err.length <= 100) {
+        errors.add(err);
+      }
+    }
+    if (errors.size >= 5) break;
+  }
+  return Array.from(errors).slice(0, 5);
+}
+var CONCEPT_PATTERNS = [
+  // Exe OS architecture
+  [/\b(?:GraphRAG|graph[\s-]?rag)\b/gi, "GraphRAG"],
+  [/\b(?:cloud[\s-]?sync|cloud backup)\b/gi, "cloud-sync"],
+  [/\b(?:three[\s-]?layer cognition|3[\s-]?layer cognition|cognition layers?)\b/gi, "three-layer-cognition"],
+  [/\b(?:working[\s-]?memory|runtime[\s-]?scratchpad)\b/gi, "working-memory"],
+  [/\b(?:checkpoint[\s/]?resume|crash[\s-]?recovery)\b/gi, "checkpoint-resume"],
+  [/\b(?:fan[\s-]?out[\s/]?fan[\s-]?in|barrier[\s-]?primitive)\b/gi, "fan-out-fan-in"],
+  [/\b(?:entity[\s-]?extraction|entity[\s-]?resolution)\b/gi, "entity-extraction"],
+  [/\b(?:alias[\s-]?resolution|entity[\s-]?aliases?)\b/gi, "alias-resolution"],
+  [/\b(?:daemon[\s-]?orchestration|daemon[\s-]?tick)\b/gi, "daemon-orchestration"],
+  [/\b(?:capacity[\s-]?monitor|context[\s-]?capacity)\b/gi, "capacity-monitor"],
+  [/\b(?:idle[\s-]?nudge|idle[\s-]?detection)\b/gi, "idle-nudge"],
+  [/\b(?:session[\s-]?scoping|session[\s-]?isolation)\b/gi, "session-scoping"],
+  [/\b(?:task[\s-]?enforcement|task[\s-]?lifecycle)\b/gi, "task-lifecycle"],
+  [/\b(?:intercom|tmux[\s-]?send[\s-]?keys)\b/gi, "intercom"],
+  [/\b(?:memory[\s-]?sovereignty|E2EE|local[\s-]?first)\b/gi, "memory-sovereignty"],
+  [/\b(?:MCP[\s-]?server|MCP[\s-]?tool|model[\s-]?context[\s-]?protocol)\b/gi, "MCP"],
+  [/\b(?:domain[\s-]?shard|shard[\s-]?manager)\b/gi, "domain-sharding"],
+  [/\b(?:co[\s-]?occurrence[\s-]?edge|co[\s-]?occurrence)\b/gi, "co-occurrence"],
+  [/\b(?:stack[\s-]?update|stack[\s-]?manifest)\b/gi, "stack-update"],
+  [/\b(?:license[\s-]?validation|license[\s-]?check)\b/gi, "licensing"],
+  // Infrastructure
+  [/\b(?:white[\s-]?label|agency[\s-]?mode)\b/gi, "white-label"],
+  [/\b(?:AGPL|AGPL[\s-]?3)\b/g, "AGPL-license"],
+  [/\b(?:SQLCipher)\b/g, "SQLCipher"],
+  [/\b(?:pgvector)\b/g, "pgvector"],
+  [/\b(?:Cloudflare[\s-]?Workers?)\b/gi, "cloudflare-workers"]
+];
+function extractConcepts(text) {
+  const concepts = /* @__PURE__ */ new Set();
+  for (const [pattern, canonical] of CONCEPT_PATTERNS) {
+    pattern.lastIndex = 0;
+    if (pattern.test(text)) {
+      concepts.add(canonical);
+    }
+    if (concepts.size >= 10) break;
+  }
+  return Array.from(concepts);
+}
+var IDENTIFIER_PATTERN = /\b([a-z][a-zA-Z0-9]{3,30}[A-Z][a-zA-Z0-9]{0,30}|[A-Z][a-zA-Z0-9]{2,30})\b/g;
+var COMMON_WORDS = /* @__PURE__ */ new Set([
+  "Error",
+  "String",
+  "Number",
+  "Boolean",
+  "Object",
+  "Array",
+  "Promise",
+  "Buffer",
+  "Event",
+  "Date",
+  "Math",
+  "JSON",
+  "RegExp",
+  "Symbol",
+  "NULL",
+  "TRUE",
+  "FALSE",
+  "undefined",
+  "NaN",
+  "This",
+  "That",
+  "Each",
+  "Some",
+  "Every",
+  "Many"
+]);
+function extractIdentifiers(text) {
+  const counts = /* @__PURE__ */ new Map();
+  IDENTIFIER_PATTERN.lastIndex = 0;
+  let match;
+  while ((match = IDENTIFIER_PATTERN.exec(text)) !== null) {
+    const id = match[1];
+    if (!COMMON_WORDS.has(id) && id.length >= 4) {
+      counts.set(id, (counts.get(id) ?? 0) + 1);
+    }
+  }
+  return Array.from(counts.entries()).filter(([, count]) => count >= 2).map(([name]) => name).slice(0, 10);
+}
+function extractMemoryGraph(memoryText, agentId, projectName, toolName) {
+  const entities = [];
+  const relationships = [];
+  entities.push({ name: agentId, type: "agent" });
+  if (projectName && projectName !== "unknown") {
+    entities.push({ name: projectName, type: "project" });
+    relationships.push({
+      source: agentId,
+      sourceType: "agent",
+      target: projectName,
+      targetType: "project",
+      type: "works_on"
+    });
+  }
+  if (toolName && toolName !== "manual" && toolName !== "unknown") {
+    entities.push({ name: toolName, type: "tool" });
+    relationships.push({
+      source: agentId,
+      sourceType: "agent",
+      target: toolName,
+      targetType: "tool",
+      type: "used_tool"
+    });
+  }
+  const filePaths = extractFilePaths(memoryText);
+  for (const fp of filePaths) {
+    entities.push({ name: fp, type: "file" });
+    relationships.push({
+      source: agentId,
+      sourceType: "agent",
+      target: fp,
+      targetType: "file",
+      type: "modified"
+    });
+    if (projectName && projectName !== "unknown") {
+      relationships.push({
+        source: fp,
+        sourceType: "file",
+        target: projectName,
+        targetType: "project",
+        type: "belongs_to"
+      });
+    }
+  }
+  const errors = extractErrors(memoryText);
+  for (const err of errors) {
+    entities.push({ name: err, type: "error" });
+    relationships.push({
+      source: agentId,
+      sourceType: "agent",
+      target: err,
+      targetType: "error",
+      type: "encountered"
+    });
+  }
+  const identifiers = extractIdentifiers(memoryText);
+  for (const id of identifiers) {
+    entities.push({ name: id, type: "function" });
+    if (filePaths.length > 0) {
+      relationships.push({
+        source: filePaths[0],
+        sourceType: "file",
+        target: id,
+        targetType: "function",
+        type: "contains"
+      });
+    }
+  }
+  const concepts = extractConcepts(memoryText);
+  for (const concept of concepts) {
+    entities.push({ name: concept, type: "concept" });
+    if (projectName && projectName !== "unknown") {
+      relationships.push({
+        source: concept,
+        sourceType: "concept",
+        target: projectName,
+        targetType: "project",
+        type: "related_to"
+      });
+    }
+  }
+  return { entities, relationships };
+}
+async function resolveEntityAlias(client, name, originalId) {
+  try {
+    const normalized = name.toLowerCase().trim();
+    const result = await client.execute({
+      sql: "SELECT canonical_entity_id FROM entity_aliases WHERE alias = ?",
+      args: [normalized]
+    });
+    if (result.rows.length > 0) {
+      return String(result.rows[0].canonical_entity_id);
+    }
+  } catch {
+  }
+  return originalId;
+}
+async function upsertMemoryGraph(result, memoryId) {
+  const client = getClient();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const e of result.entities) {
+    const rawId = entityId(e.type, e.name);
+    const id = await resolveEntityAlias(client, e.name, rawId);
+    await client.execute({
+      sql: `INSERT INTO entities (id, name, type, first_seen, last_seen, properties)
+            VALUES (?, ?, ?, ?, ?, '{}')
+            ON CONFLICT(name, type) DO UPDATE SET last_seen = ?`,
+      args: [id, e.name, e.type, now, now, now]
+    });
+    await client.execute({
+      sql: `INSERT OR IGNORE INTO entity_memories (entity_id, memory_id)
+            VALUES (?, ?)`,
+      args: [id, memoryId]
+    });
+  }
+  try {
+    const { createCoOccurrenceEdges } = await import("./co-occurrence-AVYXRV4L.js");
+    await createCoOccurrenceEdges(result.entities, memoryId);
+  } catch {
+  }
+  for (const r of result.relationships) {
+    const sourceId = entityId(r.sourceType, r.source);
+    const targetId = entityId(r.targetType, r.target);
+    const relId = relationshipId(sourceId, targetId, r.type);
+    await client.execute({
+      sql: `INSERT INTO relationships (id, source_entity_id, target_entity_id, type, weight, timestamp, properties)
+            VALUES (?, ?, ?, ?, 1.0, ?, '{}')
+            ON CONFLICT(source_entity_id, target_entity_id, type) DO UPDATE SET
+              weight = MIN(weight + 0.1, 10.0),
+              timestamp = ?`,
+      args: [relId, sourceId, targetId, r.type, now, now]
+    });
+  }
+}
+async function extractGraphForBatch(batch) {
+  for (const row of batch) {
+    try {
+      const graphResult = extractMemoryGraph(
+        row.raw_text,
+        row.agent_id,
+        row.project_name,
+        row.tool_name
+      );
+      if (graphResult.entities.length > 0) {
+        await upsertMemoryGraph(graphResult, row.id);
+      }
+      try {
+        const client = getClient();
+        await client.execute({
+          sql: `UPDATE memories SET graph_extracted = 1 WHERE id = ?`,
+          args: [row.id]
+        });
+      } catch {
+      }
+    } catch {
+    }
+  }
+}
+
+export {
+  extractMemoryGraph,
+  upsertMemoryGraph,
+  extractGraphForBatch
+};

package/dist/chunk-X33TSJNO.js

@@ -0,0 +1,394 @@
+import {
+  readMcpHttpEvents,
+  summarizeMcpTransport
+} from "./chunk-LBRIPVY3.js";
+import {
+  mcpHttpPort
+} from "./chunk-ILFJMEY5.js";
+import {
+  EXE_AI_DIR
+} from "./chunk-VXIMSRTO.js";
+import {
+  isMainModule
+} from "./chunk-6Y4B3QF6.js";
+
+// src/bin/exe-healthcheck.ts
+import { existsSync, readFileSync, readdirSync } from "fs";
+import path from "path";
+import { execSync } from "child_process";
+import { fileURLToPath } from "url";
+function findPackageRoot() {
+  let dir = path.dirname(fileURLToPath(import.meta.url));
+  const { root } = path.parse(dir);
+  while (dir !== root) {
+    if (existsSync(path.join(dir, "package.json"))) return dir;
+    dir = path.dirname(dir);
+  }
+  throw new Error("Cannot find package root");
+}
+function checkBuildIntegrity(pkgRoot) {
+  const results = [];
+  const tsupConfig = path.join(pkgRoot, "tsup.config.ts");
+  if (!existsSync(tsupConfig)) {
+    return [{ name: "build/tsup-config", pass: false, detail: "tsup.config.ts not found" }];
+  }
+  const configContent = readFileSync(tsupConfig, "utf-8");
+  const entryMatches = configContent.matchAll(/"([^"]+)":\s*"src\//g);
+  const missing = [];
+  let total = 0;
+  for (const match of entryMatches) {
+    const outputKey = match[1];
+    const expectedPath = path.join(pkgRoot, "dist", `${outputKey}.js`);
+    total++;
+    if (!existsSync(expectedPath)) {
+      missing.push(`dist/${outputKey}.js`);
+    }
+  }
+  if (missing.length > 0) {
+    results.push({
+      name: "build/entry-points",
+      pass: false,
+      detail: `${missing.length}/${total} entry points missing:
+    ${missing.join("\n    ")}`
+    });
+  } else {
+    results.push({
+      name: "build/entry-points",
+      pass: true,
+      detail: `${total} entry points verified`
+    });
+  }
+  return results;
+}
+function checkEmbedPipeline(pkgRoot) {
+  const results = [];
+  const daemonPath = path.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+  if (!existsSync(daemonPath)) {
+    results.push({
+      name: "exed/daemon-exists",
+      pass: false,
+      detail: `exe-daemon.js not found at ${daemonPath}`
+    });
+    return results;
+  }
+  results.push({ name: "exed/daemon-exists", pass: true, detail: "dist/lib/exe-daemon.js exists" });
+  const entryDirs = ["dist/hooks", "dist/bin", "dist/mcp"];
+  for (const dir of entryDirs) {
+    const fullDir = path.join(pkgRoot, dir);
+    if (!existsSync(fullDir)) continue;
+    let walkDir = fullDir;
+    const { root } = path.parse(walkDir);
+    let foundRoot = null;
+    while (walkDir !== root) {
+      if (existsSync(path.join(walkDir, "package.json"))) {
+        foundRoot = walkDir;
+        break;
+      }
+      walkDir = path.dirname(walkDir);
+    }
+    if (!foundRoot) {
+      results.push({
+        name: `exed/reachable-from-${dir}`,
+        pass: false,
+        detail: `Cannot find package root from ${dir}`
+      });
+      continue;
+    }
+    const resolvedDaemon = path.join(foundRoot, "dist", "lib", "exe-daemon.js");
+    const reachable = existsSync(resolvedDaemon);
+    results.push({
+      name: `exed/reachable-from-${dir}`,
+      pass: reachable,
+      detail: reachable ? `Resolves to ${resolvedDaemon}` : `NOT FOUND: ${resolvedDaemon}`
+    });
+  }
+  return results;
+}
+function checkTaskSystem(pkgRoot) {
+  const results = [];
+  const scannerPath = path.join(pkgRoot, "dist", "bin", "scan-tasks.js");
+  if (!existsSync(scannerPath)) {
+    results.push({ name: "tasks/scanner", pass: false, detail: "scan-tasks.js not found" });
+    return results;
+  }
+  try {
+    execSync(`node "${scannerPath}" /tmp/nonexistent-healthcheck-test --format=json 2>/dev/null`, {
+      timeout: 1e4,
+      encoding: "utf-8"
+    });
+    results.push({ name: "tasks/scanner", pass: true, detail: "scan-tasks.js runs without import errors" });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("Cannot find module") || msg.includes("ERR_MODULE_NOT_FOUND") || msg.includes("SyntaxError")) {
+      results.push({ name: "tasks/scanner", pass: false, detail: `Import error: ${msg.slice(0, 200)}` });
+    } else {
+      results.push({ name: "tasks/scanner", pass: true, detail: "scan-tasks.js runs (no import errors)" });
+    }
+  }
+  return results;
+}
+function checkWorkerSpawning(pkgRoot) {
+  const results = [];
+  const workerPath = path.join(pkgRoot, "dist", "hooks", "ingest-worker.js");
+  if (!existsSync(workerPath)) {
+    results.push({ name: "workers/ingest-worker", pass: false, detail: "ingest-worker.js not found" });
+    return results;
+  }
+  try {
+    execSync(`node --check "${workerPath}" 2>&1`, { timeout: 1e4, encoding: "utf-8" });
+    results.push({ name: "workers/ingest-worker", pass: true, detail: "ingest-worker.js parses OK" });
+  } catch (err) {
+    results.push({
+      name: "workers/ingest-worker",
+      pass: false,
+      detail: `Parse error: ${err instanceof Error ? err.message.slice(0, 200) : String(err)}`
+    });
+  }
+  const hooksDir = path.join(pkgRoot, "dist", "hooks");
+  if (existsSync(hooksDir)) {
+    const hookFiles = readdirSync(hooksDir).filter((f) => f.endsWith(".js") && !f.endsWith(".js.map"));
+    let hooksPassed = 0;
+    const hooksFailed = [];
+    for (const hook of hookFiles) {
+      try {
+        execSync(`node --check "${path.join(hooksDir, hook)}" 2>&1`, { timeout: 1e4, encoding: "utf-8" });
+        hooksPassed++;
+      } catch {
+        hooksFailed.push(hook);
+      }
+    }
+    if (hooksFailed.length > 0) {
+      results.push({
+        name: "workers/hooks-parse",
+        pass: false,
+        detail: `${hooksFailed.length}/${hookFiles.length} hooks fail to parse: ${hooksFailed.join(", ")}`
+      });
+    } else {
+      results.push({
+        name: "workers/hooks-parse",
+        pass: true,
+        detail: `${hooksPassed} hook entry points parse OK`
+      });
+    }
+  }
+  return results;
+}
+function checkMcpTransport() {
+  const results = [];
+  const pidPath = path.join(EXE_AI_DIR, "exed.pid");
+  const tokenPath = path.join(EXE_AI_DIR, "exed.token");
+  let daemonAlive = false;
+  if (existsSync(pidPath)) {
+    try {
+      const pid = parseInt(readFileSync(pidPath, "utf8").trim(), 10);
+      process.kill(pid, 0);
+      daemonAlive = true;
+      results.push({ name: "mcp/daemon-process", pass: true, detail: `exed process alive (pid ${pid})` });
+    } catch {
+      results.push({ name: "mcp/daemon-process", pass: false, detail: "exed.pid exists but process is not alive; restart exe-os/exed" });
+    }
+  } else {
+    results.push({ name: "mcp/daemon-process", pass: false, detail: "No exed.pid found; daemon is not running" });
+  }
+  if (daemonAlive && existsSync(tokenPath)) {
+    try {
+      const token = readFileSync(tokenPath, "utf8").trim();
+      const port = mcpHttpPort();
+      const response = execSync(
+        `curl -sS -i -m 1 -H "Authorization: Bearer ${token}" -H 'Accept: application/json, text/event-stream' http://127.0.0.1:${port}/mcp`,
+        { encoding: "utf8", timeout: 1500 }
+      );
+      const jsonRpcError = response.includes("Content-Type: application/json") && response.includes("missing MCP session");
+      results.push({
+        name: "mcp/http-endpoint",
+        pass: jsonRpcError,
+        detail: jsonRpcError ? "MCP HTTP endpoint reachable; missing-session probe returns JSON-RPC (expected)" : "MCP HTTP endpoint reachable but did not return expected JSON-RPC missing-session response"
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message.slice(0, 180) : String(err);
+      const timedOut = msg.includes("ETIMEDOUT") || msg.includes("timed out") || msg.includes("killed");
+      results.push({
+        name: "mcp/http-endpoint",
+        pass: false,
+        detail: timedOut ? "Daemon alive but MCP unresponsive (timed out after 1.5s)" : `MCP HTTP endpoint not reachable: ${msg}`
+      });
+    }
+  } else if (daemonAlive) {
+    results.push({ name: "mcp/http-endpoint", pass: false, detail: "Daemon is alive but exed.token is missing; cannot probe MCP HTTP" });
+  }
+  const events = readMcpHttpEvents(200);
+  const summary = summarizeMcpTransport(events);
+  results.push({
+    name: "mcp/local-event-log",
+    pass: true,
+    detail: `${events.length} recent event(s); activeSessions=${summary.activeSessions ?? "unknown"}; lastHandshake=${summary.lastSuccessfulHandshake ?? "none"}; lastTool=${summary.lastSuccessfulToolCall ?? "none"}`
+  });
+  results.push({
+    name: "mcp/monitor-summary",
+    pass: true,
+    detail: `Privacy-safe local monitor summary: ${path.join(EXE_AI_DIR, "monitor", "mcp-transport-summary.json")}`
+  });
+  return results;
+}
+function checkClaudeCodeInstall() {
+  const results = [];
+  const execPath = process.env.CLAUDE_CODE_EXECPATH ?? "";
+  if (execPath.length > 0 && (execPath.includes("claude/versions/") || execPath.includes("claude.exe") || execPath.includes("claude-native"))) {
+    results.push({
+      name: "cc/execpath-clean",
+      pass: false,
+      detail: `CLAUDE_CODE_EXECPATH points to native binary: "${execPath}" \u2014 20K phantom billing risk. Unset it: unset CLAUDE_CODE_EXECPATH`
+    });
+  } else {
+    results.push({
+      name: "cc/execpath-clean",
+      pass: true,
+      detail: execPath ? `CLAUDE_CODE_EXECPATH=${execPath} (node runtime, OK)` : "CLAUDE_CODE_EXECPATH is unset"
+    });
+  }
+  try {
+    const claudePath = execSync("which claude 2>/dev/null || true", { encoding: "utf8", timeout: 5e3 }).trim();
+    if (!claudePath) {
+      results.push({
+        name: "cc/cli-binary",
+        pass: false,
+        detail: "claude not found in PATH"
+      });
+    } else {
+      let resolved = claudePath;
+      try {
+        resolved = execSync(`readlink -f "${claudePath}" 2>/dev/null || readlink "${claudePath}" 2>/dev/null || echo "${claudePath}"`, {
+          encoding: "utf8",
+          timeout: 5e3
+        }).trim();
+      } catch {
+      }
+      if (resolved.includes("bin/claude.exe") || resolved.includes("bin/claude-native")) {
+        results.push({
+          name: "cc/cli-binary",
+          pass: false,
+          detail: `claude resolves to native binary: ${resolved}. Should be cli.js. Run: npm install -g @anthropic-ai/claude-code@2.1.98`
+        });
+      } else {
+        results.push({
+          name: "cc/cli-binary",
+          pass: true,
+          detail: `claude resolves to: ${resolved}`
+        });
+      }
+    }
+  } catch {
+    results.push({
+      name: "cc/cli-binary",
+      pass: false,
+      detail: "Failed to check claude binary path"
+    });
+  }
+  const versionsDir = path.join(
+    process.env.HOME ?? process.env.USERPROFILE ?? "",
+    ".local",
+    "share",
+    "claude",
+    "versions"
+  );
+  if (existsSync(versionsDir)) {
+    try {
+      const entries = readdirSync(versionsDir);
+      if (entries.length > 0) {
+        results.push({
+          name: "cc/native-cache-clean",
+          pass: false,
+          detail: `${entries.length} cached native version(s) found in ${versionsDir}: ${entries.slice(0, 3).join(", ")}${entries.length > 3 ? "..." : ""}. Remove: rm -rf "${versionsDir}"`
+        });
+      } else {
+        results.push({
+          name: "cc/native-cache-clean",
+          pass: true,
+          detail: `${versionsDir} is empty`
+        });
+      }
+    } catch {
+      results.push({
+        name: "cc/native-cache-clean",
+        pass: true,
+        detail: `${versionsDir} not readable (OK)`
+      });
+    }
+  } else {
+    results.push({
+      name: "cc/native-cache-clean",
+      pass: true,
+      detail: `${versionsDir} does not exist`
+    });
+  }
+  const disableOld = process.env.DISABLE_AUTOUPDATER === "1";
+  const disableNew = process.env.CLAUDE_CODE_AUTOUPDATER_DISABLED === "1";
+  if (!disableOld && !disableNew) {
+    results.push({
+      name: "cc/autoupdater-disabled",
+      pass: false,
+      detail: "Neither DISABLE_AUTOUPDATER=1 nor CLAUDE_CODE_AUTOUPDATER_DISABLED=1 is set. Auto-updater may install infected native binary. Export both in your shell profile."
+    });
+  } else {
+    const which = [
+      disableOld ? "DISABLE_AUTOUPDATER=1" : null,
+      disableNew ? "CLAUDE_CODE_AUTOUPDATER_DISABLED=1" : null
+    ].filter(Boolean).join(" + ");
+    results.push({
+      name: "cc/autoupdater-disabled",
+      pass: true,
+      detail: `Auto-updater disabled via ${which}`
+    });
+  }
+  try {
+    const ccVersion = execSync("claude --version 2>/dev/null || echo unknown", {
+      encoding: "utf8",
+      timeout: 5e3
+    }).trim();
+    const versionMatch = ccVersion.match(/(\d+\.\d+\.\d+)/);
+    if (versionMatch) {
+      const ver = versionMatch[1];
+      const [, minor] = ver.split(".").map(Number);
+      const isRisky = minor !== void 0 && minor >= 1 && parseInt(ver.split(".")[2] ?? "0") >= 119;
+      results.push({
+        name: "cc/version",
+        pass: !isRisky,
+        detail: isRisky ? `CC version ${ver} \u2014 \u22652.1.119 ships native binary only. Pin: npm install -g @anthropic-ai/claude-code@2.1.98` : `CC version ${ver}`
+      });
+    }
+  } catch {
+  }
+  return results;
+}
+function runHealthCheck() {
+  const pkgRoot = findPackageRoot();
+  const results = [
+    ...checkBuildIntegrity(pkgRoot),
+    ...checkEmbedPipeline(pkgRoot),
+    ...checkTaskSystem(pkgRoot),
+    ...checkWorkerSpawning(pkgRoot),
+    ...checkMcpTransport(),
+    ...checkClaudeCodeInstall()
+  ];
+  const passed = results.filter((r) => r.pass).length;
+  const failed = results.filter((r) => !r.pass).length;
+  return { results, passed, failed };
+}
+if (isMainModule(import.meta.url) && (process.argv[1] ?? "").includes("exe-healthcheck")) {
+  const { results, passed, failed } = runHealthCheck();
+  console.log("\n  exe-os Health Check\n");
+  for (const r of results) {
+    const icon = r.pass ? "\x1B[32m\u2713\x1B[0m" : "\x1B[31m\u2717\x1B[0m";
+    console.log(`  ${icon} ${r.name}`);
+    console.log(`    ${r.detail}`);
+  }
+  console.log(`
+  ${passed} passed, ${failed} failed
+`);
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+export {
+  checkClaudeCodeInstall,
+  runHealthCheck
+};