@askexenow/exe-os 0.9.227 → 0.9.228

package/dist/mcp/tools/create-reminder.js

@@ -0,0 +1,13 @@
+import {
+  registerCreateReminder
+} from "../../chunk-NC56276G.js";
+import "../../chunk-X2ZDES26.js";
+import "../../chunk-NGJ5FIQV.js";
+import "../../chunk-M43RSLT4.js";
+import "../../chunk-FXU7JOXK.js";
+import "../../chunk-TNTFEWU5.js";
+import "../../chunk-LYH5HE24.js";
+import "../../chunk-R5U7XKVJ.js";
+export {
+  registerCreateReminder
+};

package/dist/mcp/tools/create-task.js

@@ -0,0 +1,34 @@
+import {
+  registerCreateTask
+} from "../../chunk-N2SIOC5S.js";
+import "../../chunk-MLXJ5EZG.js";
+import "../../chunk-IUHWJRDM.js";
+import "../../chunk-UBRE5MK7.js";
+import "../../chunk-TWR6EV57.js";
+import "../../chunk-GMIXDGAT.js";
+import "../../chunk-QI4IXJN7.js";
+import "../../chunk-4JERP7NT.js";
+import "../../chunk-K2YWCFZ3.js";
+import "../../chunk-MVW62NIZ.js";
+import "../../chunk-OYNKIAVW.js";
+import "../../chunk-CX6GL3ZJ.js";
+import "../../chunk-7OM54FQY.js";
+import "../../chunk-GVP5U4WL.js";
+import "../../chunk-NGP6LSV2.js";
+import "../../chunk-7GDCFV36.js";
+import "../../chunk-CVYC6DUW.js";
+import "../../chunk-OPU3NYOO.js";
+import "../../chunk-GJV3WDWM.js";
+import "../../chunk-MP2AFCGL.js";
+import "../../chunk-CEGFVFT3.js";
+import "../../chunk-HYZV25LY.js";
+import "../../chunk-NGJ5FIQV.js";
+import "../../chunk-M43RSLT4.js";
+import "../../chunk-FXU7JOXK.js";
+import "../../chunk-D4IVTUNN.js";
+import "../../chunk-TNTFEWU5.js";
+import "../../chunk-LYH5HE24.js";
+import "../../chunk-R5U7XKVJ.js";
+export {
+  registerCreateTask
+};

package/dist/mcp/tools/deactivate-behavior.js

@@ -0,0 +1,16 @@
+import {
+  registerDeactivateBehavior
+} from "../../chunk-U7XLP37W.js";
+import "../../chunk-P7E37KXE.js";
+import "../../chunk-UBRE5MK7.js";
+import "../../chunk-CVYC6DUW.js";
+import "../../chunk-GJV3WDWM.js";
+import "../../chunk-NGJ5FIQV.js";
+import "../../chunk-M43RSLT4.js";
+import "../../chunk-FXU7JOXK.js";
+import "../../chunk-TNTFEWU5.js";
+import "../../chunk-LYH5HE24.js";
+import "../../chunk-R5U7XKVJ.js";
+export {
+  registerDeactivateBehavior
+};

package/dist/mcp/tools/list-reminders.js

@@ -0,0 +1,13 @@
+import {
+  registerListReminders
+} from "../../chunk-B3IPZ7DJ.js";
+import "../../chunk-X2ZDES26.js";
+import "../../chunk-NGJ5FIQV.js";
+import "../../chunk-M43RSLT4.js";
+import "../../chunk-FXU7JOXK.js";
+import "../../chunk-TNTFEWU5.js";
+import "../../chunk-LYH5HE24.js";
+import "../../chunk-R5U7XKVJ.js";
+export {
+  registerListReminders
+};

package/dist/mcp/tools/list-tasks.js

@@ -0,0 +1,33 @@
+import {
+  registerListTasks
+} from "../../chunk-6ES7UEXD.js";
+import "../../chunk-IUHWJRDM.js";
+import "../../chunk-UBRE5MK7.js";
+import "../../chunk-TWR6EV57.js";
+import "../../chunk-GMIXDGAT.js";
+import "../../chunk-QI4IXJN7.js";
+import "../../chunk-4JERP7NT.js";
+import "../../chunk-K2YWCFZ3.js";
+import "../../chunk-MVW62NIZ.js";
+import "../../chunk-OYNKIAVW.js";
+import "../../chunk-CX6GL3ZJ.js";
+import "../../chunk-7OM54FQY.js";
+import "../../chunk-GVP5U4WL.js";
+import "../../chunk-NGP6LSV2.js";
+import "../../chunk-7GDCFV36.js";
+import "../../chunk-CVYC6DUW.js";
+import "../../chunk-OPU3NYOO.js";
+import "../../chunk-GJV3WDWM.js";
+import "../../chunk-MP2AFCGL.js";
+import "../../chunk-CEGFVFT3.js";
+import "../../chunk-HYZV25LY.js";
+import "../../chunk-NGJ5FIQV.js";
+import "../../chunk-M43RSLT4.js";
+import "../../chunk-FXU7JOXK.js";
+import "../../chunk-D4IVTUNN.js";
+import "../../chunk-TNTFEWU5.js";
+import "../../chunk-LYH5HE24.js";
+import "../../chunk-R5U7XKVJ.js";
+export {
+  registerListTasks
+};

package/dist/mcp/tools/send-message.js

@@ -0,0 +1,33 @@
+import {
+  registerSendMessage
+} from "../../chunk-HFRT4QZS.js";
+import "../../chunk-CDN4PWHZ.js";
+import "../../chunk-UBRE5MK7.js";
+import "../../chunk-TWR6EV57.js";
+import "../../chunk-GMIXDGAT.js";
+import "../../chunk-QI4IXJN7.js";
+import "../../chunk-4JERP7NT.js";
+import "../../chunk-K2YWCFZ3.js";
+import "../../chunk-MVW62NIZ.js";
+import "../../chunk-OYNKIAVW.js";
+import "../../chunk-CX6GL3ZJ.js";
+import "../../chunk-7OM54FQY.js";
+import "../../chunk-GVP5U4WL.js";
+import "../../chunk-NGP6LSV2.js";
+import "../../chunk-7GDCFV36.js";
+import "../../chunk-CVYC6DUW.js";
+import "../../chunk-OPU3NYOO.js";
+import "../../chunk-GJV3WDWM.js";
+import "../../chunk-MP2AFCGL.js";
+import "../../chunk-CEGFVFT3.js";
+import "../../chunk-HYZV25LY.js";
+import "../../chunk-NGJ5FIQV.js";
+import "../../chunk-M43RSLT4.js";
+import "../../chunk-FXU7JOXK.js";
+import "../../chunk-D4IVTUNN.js";
+import "../../chunk-TNTFEWU5.js";
+import "../../chunk-LYH5HE24.js";
+import "../../chunk-R5U7XKVJ.js";
+export {
+  registerSendMessage
+};

package/dist/mcp/tools/update-task.js

@@ -0,0 +1,32 @@
+import {
+  registerUpdateTask
+} from "../../chunk-FV5FDWL3.js";
+import "../../chunk-IUHWJRDM.js";
+import "../../chunk-TWR6EV57.js";
+import "../../chunk-GMIXDGAT.js";
+import "../../chunk-QI4IXJN7.js";
+import "../../chunk-4JERP7NT.js";
+import "../../chunk-K2YWCFZ3.js";
+import "../../chunk-MVW62NIZ.js";
+import "../../chunk-OYNKIAVW.js";
+import "../../chunk-CX6GL3ZJ.js";
+import "../../chunk-7OM54FQY.js";
+import "../../chunk-GVP5U4WL.js";
+import "../../chunk-NGP6LSV2.js";
+import "../../chunk-7GDCFV36.js";
+import "../../chunk-CVYC6DUW.js";
+import "../../chunk-OPU3NYOO.js";
+import "../../chunk-GJV3WDWM.js";
+import "../../chunk-MP2AFCGL.js";
+import "../../chunk-CEGFVFT3.js";
+import "../../chunk-HYZV25LY.js";
+import "../../chunk-NGJ5FIQV.js";
+import "../../chunk-M43RSLT4.js";
+import "../../chunk-FXU7JOXK.js";
+import "../../chunk-D4IVTUNN.js";
+import "../../chunk-TNTFEWU5.js";
+import "../../chunk-LYH5HE24.js";
+import "../../chunk-R5U7XKVJ.js";
+export {
+  registerUpdateTask
+};

package/dist/mcp-diagnostics-5T5OZ52S.js

@@ -0,0 +1,200 @@
+import "./chunk-R5U7XKVJ.js";
+
+// src/adapters/claude/mcp-diagnostics.ts
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+import os from "os";
+function readJson(filePath) {
+  if (!existsSync(filePath)) return null;
+  try {
+    return JSON.parse(readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function pathApplies(projectPath, cwd) {
+  const project = path.resolve(projectPath);
+  const current = path.resolve(cwd);
+  return current === project || current.startsWith(project + path.sep);
+}
+function findAncestorMcpJsons(cwd, homeDir) {
+  const files = [];
+  let dir = path.resolve(cwd);
+  const root = path.parse(dir).root;
+  const stop = path.resolve(homeDir);
+  while (dir !== root) {
+    const candidate = path.join(dir, ".mcp.json");
+    if (existsSync(candidate)) files.push(candidate);
+    if (dir === stop) break;
+    dir = path.dirname(dir);
+  }
+  return files;
+}
+function extractPermissionPrefixes(settings) {
+  const allow = settings?.permissions?.allow ?? [];
+  const prefixes = /* @__PURE__ */ new Set();
+  for (const entry of allow) {
+    const match = entry.match(/^mcp__(.+?)__/);
+    if (match?.[1]) prefixes.add(match[1]);
+  }
+  return [...prefixes].sort();
+}
+function serverAllowedByPermissions(serverName, prefixes) {
+  return prefixes.has(serverName) || prefixes.has(serverName.replace(/-/g, "_"));
+}
+function diagnoseClaudeMcpConfig(homeDir = os.homedir(), cwd = process.cwd(), env = process.env) {
+  const claudeJsonPath = path.join(homeDir, ".claude.json");
+  const settingsPath = path.join(homeDir, ".claude", "settings.json");
+  const claudeJson = readJson(claudeJsonPath);
+  const settings = readJson(settingsPath);
+  const issues = [];
+  if (!claudeJson) {
+    issues.push({
+      severity: "error",
+      code: "claude-json-missing-or-invalid",
+      message: "~/.claude.json is missing or invalid, so Claude MCP server config cannot be audited.",
+      fix: "Run exe-os claude install, then re-open Claude Code."
+    });
+  }
+  if (!settings) {
+    issues.push({
+      severity: "warn",
+      code: "settings-json-missing-or-invalid",
+      message: "~/.claude/settings.json is missing or invalid; MCP permissions cannot be audited.",
+      fix: "Run exe-os claude install, then re-open Claude Code."
+    });
+  }
+  const globalServers = Object.keys(claudeJson?.mcpServers ?? {}).sort();
+  const projectServers = [];
+  const applicableProjects = [];
+  for (const [projectPath, projectConfig] of Object.entries(claudeJson?.projects ?? {})) {
+    if (!pathApplies(projectPath, cwd)) continue;
+    applicableProjects.push([projectPath, projectConfig]);
+    for (const name of Object.keys(projectConfig.mcpServers ?? {})) {
+      projectServers.push({ name, source: "project", path: projectPath });
+    }
+    if (Array.isArray(projectConfig.enabledMcpServers)) {
+      issues.push({
+        severity: projectConfig.enabledMcpServers.length === 0 ? "warn" : "info",
+        code: "enabled-mcp-servers-present",
+        message: `Project ${projectPath} contains enabledMcpServers=${JSON.stringify(projectConfig.enabledMcpServers)}. This key is not the same as enabledMcpjsonServers and has caused confusing /mcp debugging reports.`,
+        fix: "If MCP tools are hidden, back up ~/.claude.json, remove only this key, restart Claude Code, and compare /mcp + ToolSearch."
+      });
+    }
+  }
+  const mcpJsonServers = [];
+  for (const mcpJsonPath of findAncestorMcpJsons(cwd, homeDir)) {
+    const mcpJson = readJson(mcpJsonPath);
+    for (const name of Object.keys(mcpJson?.mcpServers ?? {})) {
+      mcpJsonServers.push({ name, source: "mcp.json", path: mcpJsonPath });
+    }
+  }
+  const permissionPrefixes = extractPermissionPrefixes(settings);
+  const permissionPrefixSet = new Set(permissionPrefixes);
+  const allConfiguredServerNames = [...globalServers, ...projectServers.map((s) => s.name), ...mcpJsonServers.map((s) => s.name)];
+  const configuredServers = [...new Set(allConfiguredServerNames)].sort();
+  const nonExeServers = configuredServers.filter((s) => s !== "exe-os" && s !== "exe-mem");
+  const nonExeWithoutPermissions = nonExeServers.filter((s) => !serverAllowedByPermissions(s, permissionPrefixSet));
+  if (nonExeWithoutPermissions.length > 0 && permissionPrefixes.some((p) => p === "exe-os" || p === "exe-mem")) {
+    issues.push({
+      severity: "warn",
+      code: "non-exe-mcp-not-permission-allowlisted",
+      message: `Interactive Claude Code may only surface/auto-run permission-allowed MCP tools. exe-os is allowlisted, but these configured servers are not: ${nonExeWithoutPermissions.join(", ")}.`,
+      fix: "In Claude Code, run /permissions and allow the needed MCP server tools (for example mcp__figma__*), then restart. As a diagnostic only, test ENABLE_TOOL_SEARCH=false claude to compare tool injection."
+    });
+  }
+  const duplicateNames = allConfiguredServerNames.filter((name, index, arr) => arr.indexOf(name) !== index);
+  if (duplicateNames.length > 0) {
+    issues.push({
+      severity: "warn",
+      code: "duplicate-mcp-server-names",
+      message: `Duplicate MCP server names exist across global/project/.mcp.json scopes: ${[...new Set(duplicateNames)].join(", ")}. Claude Code can show Connected while dropping tools when scopes collide.`,
+      fix: "Use one source of truth per MCP server name; remove or rename duplicates."
+    });
+  }
+  const alwaysLoadServers = [];
+  for (const [name, config] of Object.entries(claudeJson?.mcpServers ?? {})) {
+    if (config && typeof config === "object" && config.alwaysLoad === true) {
+      alwaysLoadServers.push(`${name} (global)`);
+    }
+  }
+  for (const [projectPath, projectConfig] of applicableProjects) {
+    for (const [name, config] of Object.entries(projectConfig.mcpServers ?? {})) {
+      if (config && typeof config === "object" && config.alwaysLoad === true) {
+        alwaysLoadServers.push(`${name} (${projectPath})`);
+      }
+    }
+  }
+  if (alwaysLoadServers.length > 0) {
+    issues.push({
+      severity: "warn",
+      code: "always-load-mcp-present",
+      message: `alwaysLoad:true is set on MCP server(s): ${alwaysLoadServers.join(", ")}. Field reports from Claude Code 2.1.x show this can make servers appear Connected while tools do not inject in interactive sessions.`,
+      fix: "Back up ~/.claude.json, remove alwaysLoad:true from affected MCP entries, restart Claude Code, and compare ToolSearch + /mcp. exe-os will not remove this automatically because it is customer-owned config."
+    });
+  }
+  for (const server of mcpJsonServers) {
+    for (const [projectPath, projectConfig] of applicableProjects) {
+      if (!projectConfig.mcpServers?.[server.name]) continue;
+      const enabled = new Set(projectConfig.enabledMcpjsonServers ?? []);
+      if (!enabled.has(server.name)) {
+        issues.push({
+          severity: "error",
+          code: "disabled-mcp-json-shadows-project-server",
+          message: `${server.name} appears in ${server.path} and project ${projectPath}, but is not enabled in enabledMcpjsonServers. This can shadow the project server and yield Connected/0 tools.`,
+          fix: "Remove/rename the duplicate .mcp.json entry or enable that .mcp.json server explicitly."
+        });
+      }
+    }
+  }
+  if (env.ENABLE_TOOL_SEARCH && env.ENABLE_TOOL_SEARCH !== "auto") {
+    issues.push({
+      severity: "info",
+      code: "enable-tool-search-env-set",
+      message: `ENABLE_TOOL_SEARCH is set to ${env.ENABLE_TOOL_SEARCH}. This changes Claude Code's deferred tool injection path.`,
+      fix: "For debugging, compare interactive launches with ENABLE_TOOL_SEARCH=false, ENABLE_TOOL_SEARCH=auto, and unset."
+    });
+  }
+  if (configuredServers.length > 8) {
+    issues.push({
+      severity: "info",
+      code: "large-mcp-surface",
+      message: `${configuredServers.length} MCP servers are configured for this project. If pipe mode sees tools but interactive mode does not, reduce scope temporarily or enable only needed servers while debugging Claude Code tool injection.`,
+      fix: "Keep exe-os global, move project/design tools into the active project only, and use /permissions for the servers needed in that session."
+    });
+  }
+  return {
+    cwd: path.resolve(cwd),
+    globalServers,
+    projectServers: projectServers.sort((a, b) => a.name.localeCompare(b.name)),
+    mcpJsonServers: mcpJsonServers.sort((a, b) => a.name.localeCompare(b.name)),
+    permissionPrefixes,
+    issues
+  };
+}
+function formatMcpDiagnosticReport(report) {
+  const lines = [];
+  lines.push("Claude MCP Diagnostic");
+  lines.push(`cwd: ${report.cwd}`);
+  lines.push("");
+  lines.push(`global servers: ${report.globalServers.length ? report.globalServers.join(", ") : "none"}`);
+  lines.push(`project servers: ${report.projectServers.length ? report.projectServers.map((s) => `${s.name} (${s.path})`).join(", ") : "none"}`);
+  lines.push(`.mcp.json servers: ${report.mcpJsonServers.length ? report.mcpJsonServers.map((s) => `${s.name} (${s.path})`).join(", ") : "none"}`);
+  lines.push(`permission MCP prefixes: ${report.permissionPrefixes.length ? report.permissionPrefixes.join(", ") : "none"}`);
+  lines.push("");
+  if (report.issues.length === 0) {
+    lines.push("\u2713 No obvious MCP config hazards detected.");
+    return lines.join("\n");
+  }
+  lines.push("Issues / clues:");
+  for (const issue of report.issues) {
+    const icon = issue.severity === "error" ? "\u2717" : issue.severity === "warn" ? "!" : "i";
+    lines.push(`${icon} [${issue.code}] ${issue.message}`);
+    if (issue.fix) lines.push(`  Fix/test: ${issue.fix}`);
+  }
+  return lines.join("\n");
+}
+export {
+  diagnoseClaudeMcpConfig,
+  formatMcpDiagnosticReport
+};

package/dist/mcp-disconnect-tracker-VINUVEZJ.js

@@ -0,0 +1,79 @@
+import "./chunk-R5U7XKVJ.js";
+
+// src/lib/mcp-disconnect-tracker.ts
+import { appendFileSync, mkdirSync, existsSync, readFileSync } from "fs";
+import path from "path";
+import os from "os";
+var LOG_DIR = path.join(os.homedir(), ".exe-os", "logs");
+var DISCONNECT_LOG = path.join(LOG_DIR, "mcp-disconnects.log");
+var RECONNECT_WARN_THRESHOLD = 3;
+function logDisconnect(event) {
+  try {
+    if (!existsSync(LOG_DIR)) mkdirSync(LOG_DIR, { recursive: true });
+    const line = JSON.stringify(event) + "\n";
+    appendFileSync(DISCONNECT_LOG, line);
+  } catch {
+  }
+}
+function countRecentDisconnects(hours = 24) {
+  try {
+    if (!existsSync(DISCONNECT_LOG)) return 0;
+    const content = readFileSync(DISCONNECT_LOG, "utf-8");
+    const cutoff = new Date(Date.now() - hours * 36e5).toISOString();
+    let count = 0;
+    for (const line of content.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const event = JSON.parse(line);
+        if (event.timestamp >= cutoff) count++;
+      } catch {
+      }
+    }
+    return count;
+  } catch {
+    return 0;
+  }
+}
+function isReconnectionRateHigh() {
+  const countLastHour = countRecentDisconnects(1);
+  const countLast24h = countRecentDisconnects(24);
+  return {
+    high: countLastHour > RECONNECT_WARN_THRESHOLD,
+    countLastHour,
+    countLast24h
+  };
+}
+function getDaemonHealthSummary() {
+  const disconnects = isReconnectionRateHigh();
+  const lines = [];
+  if (disconnects.countLast24h > 0) {
+    lines.push(
+      `MCP disconnects: ${disconnects.countLastHour}/hr, ${disconnects.countLast24h}/24h` + (disconnects.high ? " \u26A0\uFE0F HIGH \u2014 investigate stability" : "")
+    );
+  }
+  try {
+    const pidPath = path.join(os.homedir(), ".exe-os", "exed.pid");
+    if (existsSync(pidPath)) {
+      const pid = parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
+      try {
+        process.kill(pid, 0);
+        lines.push(`Daemon PID ${pid}: running`);
+      } catch {
+        lines.push(`Daemon PID ${pid}: dead (stale PID file)`);
+      }
+    }
+  } catch {
+  }
+  try {
+    const rss = process.memoryUsage().rss;
+    lines.push(`RSS: ${(rss / 1024 / 1024).toFixed(0)}MB`);
+  } catch {
+  }
+  return lines.length > 0 ? lines.join("\n") : "No health data available";
+}
+export {
+  countRecentDisconnects,
+  getDaemonHealthSummary,
+  isReconnectionRateHigh,
+  logDisconnect
+};

package/dist/mcp-http-config-HMQWKLON.js

@@ -0,0 +1,26 @@
+import {
+  DEFAULT_MCP_HTTP_AGENT_ID,
+  DEFAULT_MCP_HTTP_AGENT_ROLE,
+  DEFAULT_MCP_HTTP_PORT,
+  buildClaudeHttpMcpEntry,
+  buildMcpHttpHeaders,
+  mcpHttpPort,
+  mcpHttpUrl,
+  readOrCreateDaemonToken
+} from "./chunk-CHUGUZV3.js";
+import "./chunk-NGJ5FIQV.js";
+import "./chunk-M43RSLT4.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-TNTFEWU5.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-R5U7XKVJ.js";
+export {
+  DEFAULT_MCP_HTTP_AGENT_ID,
+  DEFAULT_MCP_HTTP_AGENT_ROLE,
+  DEFAULT_MCP_HTTP_PORT,
+  buildClaudeHttpMcpEntry,
+  buildMcpHttpHeaders,
+  mcpHttpPort,
+  mcpHttpUrl,
+  readOrCreateDaemonToken
+};

package/dist/memory-cards-N7LZUKHF.js

@@ -0,0 +1,173 @@
+import {
+  getClient
+} from "./chunk-NGJ5FIQV.js";
+import "./chunk-M43RSLT4.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-TNTFEWU5.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-R5U7XKVJ.js";
+
+// src/lib/memory-cards.ts
+import { createHash } from "crypto";
+var MAX_CARDS_PER_MEMORY = 8;
+var MAX_SEGMENT_CHARS = 500;
+var MIN_SEGMENT_CHARS = 20;
+function stableId(memoryId, type, content) {
+  return createHash("sha256").update(`${memoryId}:${type}:${content}`).digest("hex").slice(0, 32);
+}
+function cleanText(text) {
+  let cleaned = text.replace(
+    /```(\w*)\n(.*?)(?:\n[\s\S]*?)```/g,
+    (_m, lang, firstLine) => `[code${lang ? `:${lang}` : ""}] ${firstLine.trim()}`
+  );
+  cleaned = cleaned.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+  return cleaned;
+}
+function splitSegments(text) {
+  const cleaned = cleanText(text);
+  const segments = cleaned.split(/(?<=[.!?:;])\s+|\n{2,}|(?<=\))\s+(?=[A-Z])|\s*[|│]\s*/).map((s) => s.trim()).filter((s) => s.length >= MIN_SEGMENT_CHARS && s.length <= MAX_SEGMENT_CHARS);
+  if (segments.length === 0 && cleaned.length >= MIN_SEGMENT_CHARS) {
+    const lines = cleaned.split(/\n+/).map((l) => l.trim()).filter((l) => l.length >= MIN_SEGMENT_CHARS && l.length <= MAX_SEGMENT_CHARS);
+    if (lines.length > 0) return lines;
+    if (cleaned.length >= MIN_SEGMENT_CHARS) {
+      return [cleaned.slice(0, MAX_SEGMENT_CHARS)];
+    }
+  }
+  return segments;
+}
+function inferCardType(sentence, toolName) {
+  const lower = sentence.toLowerCase();
+  if (toolName === "store_decision" || /\b(decided|decision|adr|approved|rejected)\b/.test(lower)) return "decision";
+  if (/\b(prefers|preference|likes|dislikes|wants|doesn't want|does not want)\b/.test(lower)) return "preference";
+  if (/\b(changed|updated|replaced|now|no longer|instead|supersedes)\b/.test(lower)) return "belief_update";
+  if (toolName && ["Read", "Write", "Edit", "Bash"].includes(toolName)) return "code";
+  if (/\b(meeting|deadline|shipped|launched|completed|failed|blocked|assigned|created)\b/.test(lower)) return "event";
+  return "fact";
+}
+function extractSubject(sentence, agentId) {
+  const explicit = sentence.match(/\b([A-Z][a-zA-Z0-9_-]{2,}(?:\s+[A-Z][a-zA-Z0-9_-]{2,})?)\b/);
+  return explicit?.[1] ?? agentId;
+}
+function predicateFor(type) {
+  switch (type) {
+    case "preference":
+      return "prefers";
+    case "belief_update":
+      return "updated";
+    case "decision":
+      return "decided";
+    case "event":
+      return "happened";
+    case "code":
+      return "implemented";
+    default:
+      return "states";
+  }
+}
+function extractMemoryCards(row) {
+  const segments = splitSegments(row.raw_text);
+  const cards = [];
+  for (const sentence of segments) {
+    const type = inferCardType(sentence, row.tool_name);
+    const subject = extractSubject(sentence, row.agent_id);
+    const content = sentence.length > MAX_SEGMENT_CHARS ? `${sentence.slice(0, MAX_SEGMENT_CHARS - 1)}\u2026` : sentence;
+    cards.push({
+      id: stableId(row.id, type, content),
+      memory_id: row.id,
+      agent_id: row.agent_id,
+      session_id: row.session_id,
+      project_name: row.project_name ?? null,
+      timestamp: row.timestamp,
+      card_type: type,
+      subject,
+      predicate: predicateFor(type),
+      object: content,
+      content,
+      source_ref: row.id,
+      confidence: type === "fact" ? 0.55 : 0.65
+    });
+    if (cards.length >= MAX_CARDS_PER_MEMORY) break;
+  }
+  return cards;
+}
+async function insertMemoryCardsForBatch(rows) {
+  const cards = rows.flatMap(extractMemoryCards);
+  if (cards.length === 0) return 0;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const client = getClient();
+  const stmts = cards.map((card) => ({
+    sql: `INSERT OR IGNORE INTO memory_cards
+          (id, memory_id, agent_id, session_id, project_name, timestamp, card_type,
+           subject, predicate, object, content, source_ref, confidence, active, created_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?)`,
+    args: [
+      card.id,
+      card.memory_id,
+      card.agent_id,
+      card.session_id,
+      card.project_name,
+      card.timestamp,
+      card.card_type,
+      card.subject,
+      card.predicate,
+      card.object,
+      card.content,
+      card.source_ref,
+      card.confidence,
+      now
+    ]
+  }));
+  await client.batch(stmts, "write");
+  return cards.length;
+}
+function buildMatchExpr(queryText) {
+  const terms = queryText.toLowerCase().split(/\s+/).filter((t) => t.length >= 3).map((t) => t.replace(/[^a-z0-9_]/g, "")).filter((t) => t.length >= 3).slice(0, 12);
+  if (terms.length === 0) return null;
+  return terms.map((t) => `${t}*`).join(terms.length >= 3 ? " AND " : " OR ");
+}
+async function searchMemoryCards(queryText, agentId, options) {
+  const limit = options?.limit ?? 10;
+  const matchExpr = buildMatchExpr(queryText);
+  if (!matchExpr) return [];
+  let sql = `SELECT c.id, c.memory_id, c.agent_id, c.session_id, c.project_name,
+                    c.timestamp, c.card_type, c.content, c.source_ref, c.confidence
+             FROM memory_cards c
+             JOIN memory_cards_fts fts ON c.rowid = fts.rowid
+             WHERE memory_cards_fts MATCH ?
+               AND c.agent_id = ?
+               AND COALESCE(c.active, 1) = 1`;
+  const args = [matchExpr, agentId];
+  if (options?.projectName) {
+    sql += ` AND c.project_name = ?`;
+    args.push(options.projectName);
+  }
+  if (options?.since) {
+    sql += ` AND c.timestamp >= ?`;
+    args.push(options.since);
+  }
+  sql += ` ORDER BY rank LIMIT ?`;
+  args.push(limit);
+  const result = await getClient().execute({ sql, args });
+  return result.rows.map((row) => ({
+    id: `card:${String(row.id)}`,
+    agent_id: String(row.agent_id),
+    agent_role: "memory_card",
+    session_id: String(row.session_id),
+    timestamp: String(row.timestamp),
+    tool_name: `memory_card:${String(row.card_type)}`,
+    project_name: row.project_name == null ? "" : String(row.project_name),
+    has_error: false,
+    raw_text: `[${String(row.card_type)}] ${String(row.content)}
+Source memory: ${String(row.source_ref ?? row.memory_id)}`,
+    vector: [],
+    importance: 6,
+    status: "active",
+    confidence: Number(row.confidence ?? 0.6),
+    last_accessed: String(row.timestamp)
+  }));
+}
+export {
+  extractMemoryCards,
+  insertMemoryCardsForBatch,
+  searchMemoryCards
+};

package/dist/memory-graph-extractor-GADBVHRC.js

@@ -0,0 +1,16 @@
+import {
+  extractGraphForBatch,
+  extractMemoryGraph,
+  upsertMemoryGraph
+} from "./chunk-IONVLDMB.js";
+import "./chunk-NGJ5FIQV.js";
+import "./chunk-M43RSLT4.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-TNTFEWU5.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-R5U7XKVJ.js";
+export {
+  extractGraphForBatch,
+  extractMemoryGraph,
+  upsertMemoryGraph
+};