@askexenow/exe-os 0.9.127 → 0.9.129

package/dist/chunk-2WGSIVI4.js

@@ -0,0 +1,149 @@
+import {
+  init_mcp_prefix,
+  isExeMcpTool
+} from "./chunk-6BFIFI5F.js";
+
+// src/lib/error-detector.ts
+init_mcp_prefix();
+import crypto from "crypto";
+var ERROR_PATTERNS = [
+  /\bError\b/i,
+  /\bERR!\b/,
+  /\bFAIL(ED|URE)?\b/i,
+  /\bException\b/i,
+  /\bTraceback\b/,
+  /\bpanic\b/,
+  /\bSIGSEGV\b/,
+  /\bSIGABRT\b/,
+  /exit code [1-9]/i,
+  /non-zero (exit|status)/i,
+  /command not found/i,
+  /permission denied/i,
+  /ENOENT/,
+  /EACCES/,
+  /ENOMEM/
+];
+var FILE_CONTENT_TOOLS = /* @__PURE__ */ new Set([
+  "Read",
+  "Write",
+  "Edit",
+  "Glob",
+  "Grep",
+  "NotebookEdit"
+]);
+var STDERR_IGNORE_PATTERNS = [
+  /^warning\b/i,
+  /\bDeprecationWarning\b/,
+  /^hint:/i,
+  /^npm warn\b/i,
+  /^npm notice\b/i,
+  /^\(node:\d+\) \w*Warning:/,
+  /^Cloning into/,
+  /^Already on/,
+  /^Switched to/,
+  /^Your branch is/,
+  /^Auto-merging/,
+  /^\s*$/
+];
+function isRealStderr(stderr) {
+  const lines = stderr.trim().split("\n");
+  const meaningful = lines.filter(
+    (line) => line.trim().length > 0 && !STDERR_IGNORE_PATTERNS.some((p) => p.test(line))
+  );
+  return meaningful.length > 0;
+}
+function logSuppression(exitCode, stderr, stdout) {
+  process.stderr.write(
+    `[error-detector] suppressed bash non-zero exit: code=${exitCode} stderr_len=${stderr.length} stdout_len=${stdout.length}
+`
+  );
+}
+function detectError(data) {
+  const response = data.tool_response;
+  if (!response) return false;
+  const toolName = data.tool_name ?? "";
+  if (FILE_CONTENT_TOOLS.has(toolName)) {
+    return response.type === "error" || response.error != null;
+  }
+  if (toolName === "Bash") {
+    const exitCode = typeof response.exitCode === "number" ? response.exitCode : 0;
+    const stderr = typeof response.stderr === "string" ? response.stderr : "";
+    const stdout = typeof response.stdout === "string" ? response.stdout : "";
+    if (exitCode === 141) {
+      logSuppression(exitCode, stderr, stdout);
+      return false;
+    }
+    if (stderr.trim().length > 0 && isRealStderr(stderr)) return true;
+    if (exitCode !== 0 && !isRealStderr(stderr) && stdout.trim().length > 0) {
+      logSuppression(exitCode, stderr, stdout);
+      return false;
+    }
+    if (exitCode !== 0) return true;
+    return false;
+  }
+  if (response.type === "error" || response.error != null || response.isError === true) {
+    return true;
+  }
+  if (typeof response.stderr === "string" && response.stderr.trim().length > 0) {
+    if (isRealStderr(response.stderr)) return true;
+  }
+  const textParts = [];
+  if (typeof response.stdout === "string") textParts.push(response.stdout);
+  if (typeof response.output === "string") textParts.push(response.output);
+  if (typeof response.text === "string") textParts.push(response.text);
+  if (typeof response.message === "string") textParts.push(response.message);
+  if (textParts.length === 0) return false;
+  const text = textParts.join("\n");
+  return ERROR_PATTERNS.some((pattern) => pattern.test(text));
+}
+function isExeOsError(data) {
+  const toolName = data.tool_name ?? "";
+  if (isExeMcpTool(toolName)) return true;
+  if (toolName === "Bash") {
+    const cmd = String(data.tool_input?.command ?? "");
+    if (/\bexe-os\b|exe-boot|exe-healthcheck|scan-tasks|exe-call/.test(cmd)) return true;
+    if (/node.*dist\/(bin|hooks|lib)\//.test(cmd)) return true;
+  }
+  return false;
+}
+var USER_ERROR_PATTERNS = [
+  /not found:?\s/i,
+  /expected \d+ words/i,
+  /provide either/i,
+  /invalid.*parameter/i,
+  /already exists/i,
+  /Multiple tasks match/i,
+  /Use a more specific identifier/i
+];
+var SYSTEM_BUG_PATTERNS = [
+  /SQLITE_ERROR/,
+  /Cannot find module/,
+  /ERR_MODULE_NOT_FOUND/,
+  /TypeError:/,
+  /ReferenceError:/,
+  /Cannot read propert/,
+  /is not a function/,
+  /ENOENT.*dist\//,
+  /dimension mismatch/i,
+  /unhealthy.*model/i,
+  /constraint.*violat/i
+];
+function classifyError(errorText) {
+  if (USER_ERROR_PATTERNS.some((p) => p.test(errorText))) return "user";
+  if (SYSTEM_BUG_PATTERNS.some((p) => p.test(errorText))) return "system";
+  if (/at\s+\S+\s+\(.*exe-os.*\)/m.test(errorText)) return "system";
+  if (/at\s+\S+\s+\(.*dist\/(lib|bin|hooks|mcp)\//m.test(errorText)) return "system";
+  return "unknown";
+}
+function errorFingerprint(toolName, errorText) {
+  const normalized = errorText.replace(/\d{4}-\d{2}-\d{2}T[\d:.]+Z/g, "TIMESTAMP").replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, "UUID").replace(/\/Users\/[^\s]+/g, "PATH").replace(/:\d+:\d+/g, ":LINE:COL").slice(0, 200);
+  return crypto.createHash("sha256").update(`${toolName}:${normalized}`).digest("hex").slice(0, 16);
+}
+
+export {
+  ERROR_PATTERNS,
+  detectError,
+  isExeOsError,
+  classifyError,
+  errorFingerprint
+};

package/dist/chunk-35TVNLJI.js

@@ -0,0 +1,57 @@
+import {
+  enqueueMemory
+} from "./chunk-RWO327FJ.js";
+import {
+  init_exe_daemon_client,
+  isClientConnected,
+  sendDaemonRequest
+} from "./chunk-NMQKGFEP.js";
+
+// src/lib/memory-queue-client.ts
+init_exe_daemon_client();
+async function writeMemoryViaDaemon(entry) {
+  if (process.env.EXE_IS_DAEMON === "1") {
+    enqueueMemory(entry);
+    return false;
+  }
+  if (!isClientConnected()) {
+    enqueueMemory(entry);
+    return false;
+  }
+  try {
+    const response = await sendDaemonRequest({
+      type: "write-memory",
+      entry
+    });
+    if (response.ok) return true;
+    enqueueMemory(entry);
+    return false;
+  } catch {
+    enqueueMemory(entry);
+    return false;
+  }
+}
+async function batchWriteMemoryViaDaemon(entries) {
+  if (entries.length === 0) return 0;
+  if (process.env.EXE_IS_DAEMON === "1" || !isClientConnected()) {
+    for (const entry of entries) enqueueMemory(entry);
+    return 0;
+  }
+  try {
+    const response = await sendDaemonRequest({
+      type: "batch-write-memory",
+      entries
+    });
+    if (response.ok) return response.count ?? entries.length;
+    for (const entry of entries) enqueueMemory(entry);
+    return 0;
+  } catch {
+    for (const entry of entries) enqueueMemory(entry);
+    return 0;
+  }
+}
+
+export {
+  writeMemoryViaDaemon,
+  batchWriteMemoryViaDaemon
+};

package/dist/chunk-3SYV36U5.js

@@ -0,0 +1,47 @@
+import {
+  extractSemanticText
+} from "./chunk-R23EMFJV.js";
+import {
+  getProjectName,
+  init_project_name
+} from "./chunk-LPGBKR4H.js";
+import {
+  detectError
+} from "./chunk-2WGSIVI4.js";
+
+// src/lib/post-tool-memory.ts
+init_project_name();
+function buildPostToolMemoryEntry(data, agent) {
+  let rawText = extractSemanticText(data.tool_name, data.tool_input, data.tool_response);
+  if (rawText.trim().length < 10) {
+    const inputPreview = JSON.stringify(data.tool_input ?? "").slice(0, 500);
+    const outputPreview = JSON.stringify(data.tool_response ?? "").slice(0, 500);
+    rawText = `Tool call: ${data.tool_name}
+Input: ${inputPreview}
+Output: ${outputPreview}`;
+  }
+  if (rawText.trim().length < 10) return null;
+  const hasError = detectError(data);
+  const toolInputStr = JSON.stringify(data.tool_input ?? "").slice(0, 200);
+  const toolOutputStr = JSON.stringify(data.tool_response ?? "").slice(0, 200);
+  return {
+    raw_text: rawText,
+    agent_id: agent.agentId,
+    agent_role: agent.agentRole,
+    tool_name: data.tool_name,
+    project_name: getProjectName(data.cwd ?? process.cwd()),
+    session_id: data.session_id,
+    has_error: hasError,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    trajectory: JSON.stringify({
+      input: toolInputStr,
+      tool: data.tool_name,
+      output: toolOutputStr,
+      result_type: hasError ? "error" : "success"
+    })
+  };
+}
+
+export {
+  buildPostToolMemoryEntry
+};

package/dist/chunk-46SQTBQW.js

@@ -0,0 +1,207 @@
+// src/lib/graph-export.ts
+async function loadGraphData(client) {
+  const entityResult = await client.execute(`
+    SELECT e.id, e.name, e.type,
+      (SELECT COUNT(*) FROM relationships r WHERE r.source_entity_id = e.id OR r.target_entity_id = e.id) as degree
+    FROM entities e
+    ORDER BY degree DESC
+  `);
+  const nodes = entityResult.rows.map((row) => ({
+    id: String(row.id),
+    label: String(row.name),
+    type: String(row.type),
+    degree: Number(row.degree ?? 0)
+  }));
+  const relResult = await client.execute(`
+    SELECT source_entity_id, target_entity_id, type, weight,
+           COALESCE(confidence, 1.0) as confidence,
+           COALESCE(confidence_label, 'extracted') as confidence_label
+    FROM relationships
+  `);
+  const edges = relResult.rows.map((row) => ({
+    from: String(row.source_entity_id),
+    to: String(row.target_entity_id),
+    label: String(row.type),
+    weight: Number(row.weight),
+    confidence: Number(row.confidence),
+    confidenceLabel: String(row.confidence_label)
+  }));
+  return { nodes, edges };
+}
+function detectCommunities(nodes, edges) {
+  const communities = /* @__PURE__ */ new Map();
+  nodes.forEach((n, i) => communities.set(n.id, i));
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    if (!adjacency.has(e.from)) adjacency.set(e.from, []);
+    if (!adjacency.has(e.to)) adjacency.set(e.to, []);
+    adjacency.get(e.from).push(e.to);
+    adjacency.get(e.to).push(e.from);
+  }
+  for (let iter = 0; iter < 5; iter++) {
+    for (const node of nodes) {
+      const neighbors = adjacency.get(node.id) ?? [];
+      if (neighbors.length === 0) continue;
+      const counts = /* @__PURE__ */ new Map();
+      for (const n of neighbors) {
+        const c = communities.get(n) ?? 0;
+        counts.set(c, (counts.get(c) ?? 0) + 1);
+      }
+      let maxCount = 0;
+      let maxCommunity = communities.get(node.id) ?? 0;
+      for (const [c, count] of counts) {
+        if (count > maxCount) {
+          maxCount = count;
+          maxCommunity = c;
+        }
+      }
+      communities.set(node.id, maxCommunity);
+    }
+  }
+  return communities;
+}
+var TYPE_COLORS = {
+  person: "#F5D76E",
+  project: "#6B4C9A",
+  tool: "#22C55E",
+  decision: "#EF4444",
+  concept: "#3B82F6",
+  file: "#6B7280",
+  rationale: "#F97316"
+};
+async function exportGraphHTML(client, projectName) {
+  const { nodes, edges } = await loadGraphData(client);
+  if (nodes.length === 0) return "<html><body>No graph data.</body></html>";
+  const communities = detectCommunities(nodes, edges);
+  for (const node of nodes) {
+    node.community = communities.get(node.id) ?? 0;
+  }
+  const visNodes = nodes.map((n) => ({
+    id: n.id,
+    label: n.label,
+    size: Math.max(10, Math.min(50, n.degree * 5)),
+    color: TYPE_COLORS[n.type] ?? "#999",
+    title: `${n.label} (${n.type})
+Degree: ${n.degree}
+Community: ${n.community}`,
+    group: n.type
+  }));
+  const visEdges = edges.map((e, i) => ({
+    id: `e${i}`,
+    from: e.from,
+    to: e.to,
+    label: e.label,
+    width: Math.max(1, e.weight),
+    color: e.confidenceLabel === "ambiguous" ? "#EF4444" : e.confidenceLabel === "inferred" ? "#F59E0B" : "#6B7280",
+    title: `${e.label} (confidence: ${e.confidence.toFixed(1)}, ${e.confidenceLabel})`
+  }));
+  const title = projectName ? `${projectName} Knowledge Graph` : "exe-os Knowledge Graph";
+  return `<!DOCTYPE html>
+<html>
+<head>
+<title>${title}</title>
+<style>
+  body { margin: 0; background: #0F0E1A; color: #F0EDE8; font-family: 'Manrope', sans-serif; }
+  #graph { width: 100%; height: 80vh; border: 1px solid #3D3660; }
+  #sidebar { padding: 16px; background: #1A1830; }
+  #search { width: 300px; padding: 8px; background: #2A2840; color: #F0EDE8; border: 1px solid #3D3660; border-radius: 4px; margin: 8px; }
+  .stat { color: #6B4C9A; margin: 4px 8px; }
+  h1 { color: #F5D76E; margin: 8px; font-size: 1.5em; }
+  .legend { display: flex; gap: 12px; margin: 8px; flex-wrap: wrap; }
+  .legend-item { display: flex; align-items: center; gap: 4px; font-size: 0.85em; }
+  .legend-dot { width: 10px; height: 10px; border-radius: 50%; }
+</style>
+<script src="https://unpkg.com/vis-network@9.1.9/standalone/umd/vis-network.min.js"></script>
+</head>
+<body>
+<div id="sidebar">
+  <h1>${title}</h1>
+  <input id="search" placeholder="Search entities..." oninput="filterGraph(this.value)">
+  <div class="legend">
+    ${Object.entries(TYPE_COLORS).map(
+    ([type, color]) => `<span class="legend-item"><span class="legend-dot" style="background:${color}"></span>${type}</span>`
+  ).join("")}
+  </div>
+  <span class="stat">${nodes.length} nodes</span>
+  <span class="stat">${edges.length} edges</span>
+</div>
+<div id="graph"></div>
+<script>
+var nodes = new vis.DataSet(${JSON.stringify(visNodes)});
+var edges = new vis.DataSet(${JSON.stringify(visEdges)});
+var container = document.getElementById('graph');
+var network = new vis.Network(container, {nodes: nodes, edges: edges}, {
+  physics: { solver: 'forceAtlas2Based', forceAtlas2Based: { gravitationalConstant: -50 } },
+  edges: { arrows: 'to', font: { size: 9, color: '#6B4C9A' } },
+  nodes: { font: { color: '#F0EDE8' }, shape: 'dot' },
+  interaction: { hover: true, tooltipDelay: 100 }
+});
+function filterGraph(query) {
+  if (!query) { nodes.forEach(function(n) { nodes.update({id: n.id, hidden: false}); }); return; }
+  var q = query.toLowerCase();
+  nodes.forEach(function(n) { nodes.update({id: n.id, hidden: !n.label.toLowerCase().includes(q)}); });
+}
+</script>
+</body>
+</html>`;
+}
+async function generateGraphReport(client, projectName) {
+  const { nodes, edges } = await loadGraphData(client);
+  if (nodes.length === 0) return "# Graph Report\n\nNo graph data yet. Run graph extraction first.";
+  const communities = detectCommunities(nodes, edges);
+  for (const node of nodes) {
+    node.community = communities.get(node.id) ?? 0;
+  }
+  const godNodes = [...nodes].sort((a, b) => b.degree - a.degree).slice(0, 10);
+  const communityMap = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const c = node.community ?? 0;
+    if (!communityMap.has(c)) communityMap.set(c, []);
+    communityMap.get(c).push(node);
+  }
+  const topCommunities = [...communityMap.entries()].sort((a, b) => b[1].length - a[1].length).slice(0, 10);
+  const ambiguous = edges.filter((e) => e.confidenceLabel === "ambiguous");
+  const crossCommunity = edges.filter((e) => {
+    const fromC = communities.get(e.from);
+    const toC = communities.get(e.to);
+    return fromC !== void 0 && toC !== void 0 && fromC !== toC;
+  }).slice(0, 10);
+  let hyperedgeCount = 0;
+  try {
+    const result = await client.execute("SELECT COUNT(*) as cnt FROM hyperedges");
+    hyperedgeCount = Number(result.rows[0]?.cnt ?? 0);
+  } catch {
+  }
+  const nodeLabels = new Map(nodes.map((n) => [n.id, n.label]));
+  const lines = [
+    `# Knowledge Graph Report${projectName ? ` \u2014 ${projectName}` : ""}`,
+    "",
+    `Generated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`,
+    "",
+    "## Stats",
+    `- **Nodes:** ${nodes.length}`,
+    `- **Edges:** ${edges.length}`,
+    `- **Hyperedges:** ${hyperedgeCount}`,
+    `- **Communities:** ${communityMap.size}`,
+    "",
+    "## God Nodes (highest connectivity)",
+    ...godNodes.map((n) => `- **${n.label}** (${n.type}) \u2014 ${n.degree} connections`),
+    "",
+    "## Communities",
+    ...topCommunities.map(
+      ([id, members]) => `- **Community ${id}** (${members.length} nodes): ${members.slice(0, 8).map((m) => m.label).join(", ")}${members.length > 8 ? "\u2026" : ""}`
+    ),
+    "",
+    "## Cross-Community Connections",
+    crossCommunity.length > 0 ? crossCommunity.map((e) => `- ${nodeLabels.get(e.from) ?? e.from} \u2192[${e.label}]\u2192 ${nodeLabels.get(e.to) ?? e.to}`).join("\n") : "None detected",
+    "",
+    "## Open Questions (ambiguous edges)",
+    ambiguous.length > 0 ? ambiguous.map((e) => `- [${e.confidence.toFixed(1)}] ${nodeLabels.get(e.from) ?? e.from} \u2192[${e.label}]\u2192 ${nodeLabels.get(e.to) ?? e.to}`).join("\n") : "No ambiguous edges"
+  ];
+  return lines.join("\n");
+}
+
+export {
+  exportGraphHTML,
+  generateGraphReport
+};

package/dist/chunk-4CMVLKEI.js

@@ -0,0 +1,171 @@
+import {
+  writeMemoryViaDaemon
+} from "./chunk-35TVNLJI.js";
+
+// src/lib/auto-checkpoint.ts
+var FILE_RE = /(?:^|\s)([\w./-]+\.(?:ts|tsx|js|jsx|json|md|yml|yaml|sql|go|py|css|scss|html|sh))(?:\b|$)/g;
+var DECISION_RE = /\b(decision:|decided:|we decided|founder directive|captured in .*architecture|source of truth)\b/i;
+function asString(value, fallback = "") {
+  if (value == null) return fallback;
+  return String(value);
+}
+function compactLine(text, max = 220) {
+  return text.replace(/\s+/g, " ").trim().slice(0, max);
+}
+function topEntries(counts, limit) {
+  return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, limit).map(([name, count]) => `${name}(${count})`);
+}
+function buildAutoCheckpoint(input) {
+  const maxSamples = input.maxSamples ?? 8;
+  const projectCounts = /* @__PURE__ */ new Map();
+  const toolCounts = /* @__PURE__ */ new Map();
+  const files = /* @__PURE__ */ new Set();
+  const errors = [];
+  const samples = [];
+  const decisionTexts = [];
+  for (const row of input.memories) {
+    const tool = asString(row.tool_name, "unknown");
+    const project = asString(row.project_name, input.projectName || "unknown");
+    const raw = asString(row.raw_text);
+    const hasError = row.has_error === 1 || row.has_error === true;
+    toolCounts.set(tool, (toolCounts.get(tool) ?? 0) + 1);
+    projectCounts.set(project, (projectCounts.get(project) ?? 0) + 1);
+    if (hasError && errors.length < 5) errors.push(compactLine(raw, 180));
+    if (samples.length < maxSamples && raw.length > 30) {
+      samples.push(`[${tool}] ${compactLine(raw)}`);
+    }
+    if (DECISION_RE.test(raw) && decisionTexts.length < 5) {
+      decisionTexts.push(`AUTO DECISION CANDIDATE [${input.agentId}]: ${compactLine(raw, 500)}`);
+    }
+    for (const match of raw.matchAll(FILE_RE)) {
+      if (match[1]) files.add(match[1]);
+      if (files.size >= 20) break;
+    }
+  }
+  const taskLines = (input.tasks ?? []).slice(0, 10).map((task) => {
+    const status = asString(task.status, "unknown");
+    const priority = asString(task.priority, "?").toUpperCase();
+    const title = asString(task.title, "untitled");
+    const taskFile = asString(task.task_file);
+    return `- [${status}/${priority}] ${title}${taskFile ? ` (${taskFile})` : ""}`;
+  });
+  const parts = [
+    `CONTEXT CHECKPOINT [auto:${input.reason}]`,
+    `Agent: ${input.agentId} (${input.agentRole})`,
+    `Session: ${input.sessionId}`,
+    `Project: ${input.projectName}`,
+    `Time: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "",
+    "## Recent Activity",
+    `- Memories scanned: ${input.memories.length}`,
+    `- Projects: ${topEntries(projectCounts, 5).join(", ") || input.projectName}`,
+    `- Tools: ${topEntries(toolCounts, 8).join(", ") || "none"}`
+  ];
+  if (taskLines.length > 0) {
+    parts.push("", "## Open / Active Tasks", ...taskLines);
+  }
+  if (files.size > 0) {
+    parts.push("", "## Files Mentioned", ...[...files].slice(0, 20).map((f) => `- ${f}`));
+  }
+  if (samples.length > 0) {
+    parts.push("", "## Important Recent Traces", ...samples.map((s) => `- ${s}`));
+  }
+  if (errors.length > 0) {
+    parts.push("", "## Errors / Risks", ...errors.map((e) => `- ${e}`));
+  }
+  if (decisionTexts.length > 0) {
+    parts.push("", "## Decision Candidates", ...decisionTexts.map((d) => `- ${d.replace(/^AUTO DECISION CANDIDATE \\[[^\\]]+\\]: /, "")}`));
+  }
+  return {
+    checkpointText: parts.join("\n"),
+    decisionTexts
+  };
+}
+
+// src/lib/checkpoint-orchestrator.ts
+function toolNameForReason(reason) {
+  switch (reason) {
+    case "periodic":
+      return "auto-summary";
+    case "session-end":
+      return "SessionEnd";
+    case "pre-compact":
+      return "pre-compact-hook";
+    case "capacity-signal":
+      return "auto-checkpoint";
+  }
+}
+function importanceForReason(reason, override) {
+  if (override !== void 0) return override;
+  switch (reason) {
+    case "periodic":
+      return 7;
+    case "session-end":
+    case "pre-compact":
+    case "capacity-signal":
+      return 8;
+  }
+}
+function buildContinuityCheckpoint(input) {
+  const { checkpointText, decisionTexts } = buildAutoCheckpoint({
+    agentId: input.agentId,
+    agentRole: input.agentRole,
+    sessionId: input.sessionId,
+    projectName: input.projectName,
+    reason: input.reason,
+    memories: input.memories ?? [],
+    tasks: input.tasks ?? [],
+    maxSamples: input.maxSamples
+  });
+  const extra = input.extraSections?.filter((section) => section.trim().length > 0) ?? [];
+  return {
+    checkpointText: extra.length > 0 ? `${checkpointText}
+
+${extra.join("\n\n")}` : checkpointText,
+    decisionTexts
+  };
+}
+async function writeContinuityCheckpoint(input) {
+  const result = buildContinuityCheckpoint(input);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await writeMemoryViaDaemon({
+    raw_text: result.checkpointText,
+    agent_id: input.agentId,
+    agent_role: input.agentRole,
+    session_id: input.sessionId,
+    tool_name: toolNameForReason(input.reason),
+    project_name: input.projectName,
+    timestamp: now,
+    importance: importanceForReason(input.reason, input.importance),
+    task_id: input.taskId,
+    memory_type: "checkpoint"
+  });
+  const decisionLimit = input.reason === "periodic" ? 3 : 5;
+  for (const decisionText of result.decisionTexts.slice(0, decisionLimit)) {
+    await writeMemoryViaDaemon({
+      raw_text: decisionText,
+      agent_id: input.agentId,
+      agent_role: input.agentRole,
+      session_id: input.sessionId,
+      tool_name: "auto-decision",
+      project_name: input.projectName,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      importance: 8,
+      memory_type: "decision"
+    });
+  }
+  return result;
+}
+async function checkpointActiveTask(input) {
+  const { writeCheckpoint } = await import("./lib/tasks.js");
+  await writeCheckpoint({
+    taskId: input.taskId,
+    step: input.step ?? "pre-compaction-checkpoint",
+    contextSummary: `Auto-checkpoint before context compaction. Task: ${input.taskTitle}. Session: ${input.sessionId}. Project: ${input.projectName}.`
+  });
+}
+
+export {
+  writeContinuityCheckpoint,
+  checkpointActiveTask
+};