@cleocode/cleo 2026.4.38 → 2026.4.40

package/dist/cli/index.js

@@ -45821,6 +45821,390 @@ var init_brain_consolidator = __esm({
   }
 });
 
+// packages/core/src/memory/graph-memory-bridge.ts
+var graph_memory_bridge_exports = {};
+__export(graph_memory_bridge_exports, {
+  autoLinkMemories: () => autoLinkMemories,
+  linkMemoryToCode: () => linkMemoryToCode,
+  listCodeLinks: () => listCodeLinks,
+  queryCodeForMemory: () => queryCodeForMemory,
+  queryMemoriesForCode: () => queryMemoriesForCode
+});
+function extractFilePaths(text3) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const m2 of text3.matchAll(FILE_PATH_PATTERN)) {
+    const p2 = m2[1];
+    if (p2) paths.add(p2);
+  }
+  return Array.from(paths);
+}
+function extractSymbolCandidates(text3) {
+  const syms = /* @__PURE__ */ new Set();
+  for (const m2 of text3.matchAll(SYMBOL_PATTERN)) {
+    const s3 = m2[1];
+    if (s3 && s3.length >= 4 && !SYMBOL_STOP_WORDS.has(s3.toLowerCase())) {
+      syms.add(s3);
+    }
+  }
+  return Array.from(syms);
+}
+function metadataText(metaJson) {
+  if (!metaJson) return "";
+  try {
+    const obj = JSON.parse(metaJson);
+    return Object.values(obj).filter((v2) => typeof v2 === "string").join(" ");
+  } catch {
+    return "";
+  }
+}
+async function linkMemoryToCode(projectRoot, memoryId, codeSymbol) {
+  try {
+    const brainDb = await getBrainDb(projectRoot);
+    await getNexusDb();
+    const nexusNative = getNexusNativeDb();
+    if (!nexusNative) return false;
+    const nexusNode = nexusNative.prepare("SELECT id, label, file_path, kind FROM nexus_nodes WHERE id = ? LIMIT 1").get(codeSymbol);
+    if (!nexusNode) return false;
+    const now2 = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
+    const idParts = memoryId.split(":");
+    const nodeType = idParts[0] ?? "observation";
+    await brainDb.insert(brainPageNodes).values({
+      id: memoryId,
+      nodeType,
+      label: memoryId,
+      qualityScore: 0.5,
+      contentHash: null,
+      lastActivityAt: now2,
+      createdAt: now2,
+      updatedAt: now2
+    }).onConflictDoUpdate({
+      target: brainPageNodes.id,
+      set: { lastActivityAt: now2, updatedAt: now2 }
+    });
+    await brainDb.insert(brainPageEdges).values({
+      fromId: memoryId,
+      toId: codeSymbol,
+      edgeType: "code_reference",
+      weight: 1,
+      provenance: "manual",
+      createdAt: now2
+    }).onConflictDoNothing();
+    return true;
+  } catch (err) {
+    console.warn("[graph-memory-bridge] linkMemoryToCode failed:", err);
+    return false;
+  }
+}
+async function autoLinkMemories(projectRoot) {
+  const result = { scanned: 0, linked: 0, alreadyLinked: 0, links: [] };
+  try {
+    await getBrainDb(projectRoot);
+    const brainNative = getBrainNativeDb();
+    await getNexusDb();
+    const nexusNative = getNexusNativeDb();
+    if (!brainNative || !nexusNative) return result;
+    const brainNodes = typedAll(
+      brainNative.prepare(`
+        SELECT id, node_type, label, quality_score, metadata_json
+        FROM brain_page_nodes
+        WHERE node_type IN ('observation', 'decision', 'pattern', 'learning')
+          AND quality_score >= 0.3
+        ORDER BY quality_score DESC
+        LIMIT 500
+      `)
+    );
+    result.scanned = brainNodes.length;
+    if (brainNodes.length === 0) return result;
+    const nexusNodes2 = typedAll(
+      nexusNative.prepare(`
+        SELECT id, label, name, file_path, kind
+        FROM nexus_nodes
+        WHERE kind NOT IN ('community', 'process', 'folder')
+        LIMIT 20000
+      `)
+    );
+    if (nexusNodes2.length === 0) return result;
+    const byFilePath = /* @__PURE__ */ new Map();
+    const byNameExact = /* @__PURE__ */ new Map();
+    const byNameLower = /* @__PURE__ */ new Map();
+    for (const node of nexusNodes2) {
+      if (node.file_path) {
+        const fp = node.file_path.toLowerCase();
+        const existing = byFilePath.get(fp) ?? [];
+        existing.push(node);
+        byFilePath.set(fp, existing);
+      }
+      if (node.name) {
+        const exact = byNameExact.get(node.name) ?? [];
+        exact.push(node);
+        byNameExact.set(node.name, exact);
+        const lower = node.name.toLowerCase();
+        const fuzzy = byNameLower.get(lower) ?? [];
+        fuzzy.push(node);
+        byNameLower.set(lower, fuzzy);
+      }
+    }
+    const now2 = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
+    const existingEdges = /* @__PURE__ */ new Set();
+    const rawEdges = typedAll(
+      brainNative.prepare(`
+        SELECT from_id, to_id FROM brain_page_edges WHERE edge_type = 'code_reference'
+      `)
+    );
+    for (const e of rawEdges) {
+      existingEdges.add(`${e.from_id}|${e.to_id}`);
+    }
+    for (const brainNode of brainNodes) {
+      const corpus = `${brainNode.label} ${metadataText(brainNode.metadata_json)}`;
+      const filePaths = extractFilePaths(corpus);
+      const symbolCandidates = extractSymbolCandidates(corpus);
+      const candidates = [];
+      for (const fp of filePaths) {
+        const matches = byFilePath.get(fp.toLowerCase());
+        if (matches) {
+          for (const n of matches) {
+            candidates.push({ nexusNode: n, strategy: "exact-file", weight: 1 });
+          }
+        }
+      }
+      for (const sym of symbolCandidates) {
+        const exactMatches = byNameExact.get(sym);
+        if (exactMatches) {
+          for (const n of exactMatches) {
+            candidates.push({ nexusNode: n, strategy: "exact-symbol", weight: 1 });
+          }
+        }
+      }
+      const exactSymSet = new Set(
+        symbolCandidates.flatMap((s3) => byNameExact.get(s3) ?? []).map((n) => n.id)
+      );
+      for (const sym of symbolCandidates) {
+        if (sym.length < 5) continue;
+        const lower = sym.toLowerCase();
+        const fuzzyMatches = byNameLower.get(lower);
+        if (fuzzyMatches) {
+          for (const n of fuzzyMatches) {
+            if (!exactSymSet.has(n.id)) {
+              candidates.push({ nexusNode: n, strategy: "fuzzy-symbol", weight: 0.6 });
+            }
+          }
+        }
+      }
+      const bestByNexusId = /* @__PURE__ */ new Map();
+      for (const c of candidates) {
+        const existing = bestByNexusId.get(c.nexusNode.id);
+        if (!existing || c.weight > existing.weight) {
+          bestByNexusId.set(c.nexusNode.id, c);
+        }
+      }
+      const sortedCandidates = Array.from(bestByNexusId.values()).sort((a, b2) => b2.weight - a.weight).slice(0, 10);
+      for (const { nexusNode, strategy, weight } of sortedCandidates) {
+        const edgeKey = `${brainNode.id}|${nexusNode.id}`;
+        if (existingEdges.has(edgeKey)) {
+          result.alreadyLinked++;
+          continue;
+        }
+        brainNative.prepare(`
+            INSERT OR IGNORE INTO brain_page_nodes
+              (id, node_type, label, quality_score, content_hash, metadata_json, last_activity_at, created_at, updated_at)
+            VALUES (?, ?, ?, ?, NULL, NULL, ?, ?, ?)
+          `).run(
+          brainNode.id,
+          brainNode.node_type,
+          brainNode.label,
+          brainNode.quality_score,
+          now2,
+          now2,
+          now2
+        );
+        try {
+          brainNative.prepare(`
+              INSERT OR IGNORE INTO brain_page_edges
+                (from_id, to_id, edge_type, weight, provenance, created_at)
+              VALUES (?, ?, 'code_reference', ?, ?, ?)
+            `).run(brainNode.id, nexusNode.id, weight, `auto:${strategy}`, now2);
+          existingEdges.add(edgeKey);
+          result.linked++;
+          result.links.push({
+            brainNodeId: brainNode.id,
+            nexusNodeId: nexusNode.id,
+            nexusLabel: nexusNode.label,
+            matchStrategy: strategy,
+            weight
+          });
+        } catch (edgeErr) {
+          console.warn("[graph-memory-bridge] edge insert failed:", edgeErr);
+        }
+      }
+    }
+  } catch (err) {
+    console.warn("[graph-memory-bridge] autoLinkMemories failed:", err);
+  }
+  return result;
+}
+async function queryMemoriesForCode(projectRoot, symbol2) {
+  const result = { nexusNodeId: symbol2, memories: [] };
+  try {
+    await getBrainDb(projectRoot);
+    const brainNative = getBrainNativeDb();
+    if (!brainNative) return result;
+    const rows = typedAll(
+      brainNative.prepare(`
+        SELECT n.id, n.node_type, n.label, n.quality_score,
+               e.weight, e.provenance
+        FROM brain_page_edges e
+        JOIN brain_page_nodes n ON n.id = e.from_id
+        WHERE e.to_id = ?
+          AND e.edge_type = 'code_reference'
+        ORDER BY e.weight DESC, n.quality_score DESC
+        LIMIT 50
+      `),
+      symbol2
+    );
+    result.memories = rows.map((r) => ({
+      nodeId: r.id,
+      nodeType: r.node_type,
+      label: r.label,
+      qualityScore: r.quality_score,
+      edgeWeight: r.weight,
+      matchStrategy: r.provenance?.replace("auto:", "") ?? "manual"
+    }));
+  } catch (err) {
+    console.warn("[graph-memory-bridge] queryMemoriesForCode failed:", err);
+  }
+  return result;
+}
+async function queryCodeForMemory(projectRoot, memoryId) {
+  const result = { brainNodeId: memoryId, codeNodes: [] };
+  try {
+    await getBrainDb(projectRoot);
+    const brainNative = getBrainNativeDb();
+    await getNexusDb();
+    const nexusNative = getNexusNativeDb();
+    if (!brainNative || !nexusNative) return result;
+    const brainEdges = typedAll(
+      brainNative.prepare(`
+        SELECT to_id, weight, provenance
+        FROM brain_page_edges
+        WHERE from_id = ?
+          AND edge_type = 'code_reference'
+        ORDER BY weight DESC
+        LIMIT 50
+      `),
+      memoryId
+    );
+    if (brainEdges.length === 0) return result;
+    for (const edge of brainEdges) {
+      const nexusNode = nexusNative.prepare("SELECT id, label, file_path, kind FROM nexus_nodes WHERE id = ? LIMIT 1").get(edge.to_id);
+      if (nexusNode) {
+        result.codeNodes.push({
+          nexusNodeId: nexusNode.id,
+          label: nexusNode.label,
+          filePath: nexusNode.file_path,
+          kind: nexusNode.kind,
+          edgeWeight: edge.weight,
+          matchStrategy: edge.provenance?.replace("auto:", "") ?? "manual"
+        });
+      }
+    }
+  } catch (err) {
+    console.warn("[graph-memory-bridge] queryCodeForMemory failed:", err);
+  }
+  return result;
+}
+async function listCodeLinks(projectRoot, limit = 100) {
+  const entries = [];
+  try {
+    await getBrainDb(projectRoot);
+    const brainNative = getBrainNativeDb();
+    await getNexusDb();
+    const nexusNative = getNexusNativeDb();
+    if (!brainNative || !nexusNative) return entries;
+    const rows = typedAll(
+      brainNative.prepare(`
+        SELECT e.from_id, e.to_id, e.weight, e.created_at,
+               n.node_type, n.label
+        FROM brain_page_edges e
+        JOIN brain_page_nodes n ON n.id = e.from_id
+        WHERE e.edge_type = 'code_reference'
+        ORDER BY e.weight DESC, e.created_at DESC
+        LIMIT ?
+      `),
+      limit
+    );
+    for (const row of rows) {
+      const nexusNode = nexusNative.prepare("SELECT id, label, file_path, kind FROM nexus_nodes WHERE id = ? LIMIT 1").get(row.to_id);
+      entries.push({
+        brainNodeId: row.from_id,
+        brainNodeType: row.node_type,
+        brainNodeLabel: row.label,
+        nexusNodeId: row.to_id,
+        nexusNodeLabel: nexusNode?.label ?? row.to_id,
+        filePath: nexusNode?.file_path ?? null,
+        kind: nexusNode?.kind ?? "unknown",
+        weight: row.weight,
+        createdAt: row.created_at
+      });
+    }
+  } catch (err) {
+    console.warn("[graph-memory-bridge] listCodeLinks failed:", err);
+  }
+  return entries;
+}
+var FILE_PATH_PATTERN, SYMBOL_PATTERN, SYMBOL_STOP_WORDS;
+var init_graph_memory_bridge = __esm({
+  "packages/core/src/memory/graph-memory-bridge.ts"() {
+    "use strict";
+    init_brain_schema();
+    init_brain_sqlite();
+    init_nexus_sqlite();
+    init_typed_query();
+    FILE_PATH_PATTERN = /(?:^|\s|['"`(])([a-zA-Z0-9_\-./]+\.(?:ts|tsx|js|jsx|rs|go|py|mjs|cjs))(?:$|\s|['"`)])/g;
+    SYMBOL_PATTERN = /\b([a-zA-Z_][a-zA-Z0-9_]*(?:[A-Z][a-zA-Z0-9_]*)+|[a-zA-Z_]{4,}[a-zA-Z0-9_]*)\b/g;
+    SYMBOL_STOP_WORDS = /* @__PURE__ */ new Set([
+      "true",
+      "false",
+      "null",
+      "undefined",
+      "const",
+      "async",
+      "await",
+      "return",
+      "export",
+      "import",
+      "from",
+      "type",
+      "interface",
+      "function",
+      "class",
+      "this",
+      "super",
+      "extends",
+      "implements",
+      "with",
+      "that",
+      "then",
+      "when",
+      "have",
+      "been",
+      "will",
+      "should",
+      "could",
+      "would",
+      "error",
+      "result",
+      "value",
+      "data",
+      "info",
+      "note",
+      "todo",
+      "done",
+      "fail",
+      "pass"
+    ]);
+  }
+});
+
 // packages/core/src/memory/brain-lifecycle.ts
 var brain_lifecycle_exports = {};
 __export(brain_lifecycle_exports, {
@@ -46120,6 +46504,13 @@ async function runConsolidation(projectRoot) {
   } catch (err) {
     console.warn("[consolidation] Step 7 summary generation failed:", err);
   }
+  try {
+    const { autoLinkMemories: autoLinkMemories2 } = await Promise.resolve().then(() => (init_graph_memory_bridge(), graph_memory_bridge_exports));
+    const bridgeResult = await autoLinkMemories2(projectRoot);
+    result.graphLinksCreated = bridgeResult.linked;
+  } catch (err) {
+    console.warn("[consolidation] Step 8 graph memory bridge failed:", err);
+  }
   return result;
 }
 async function deduplicateByEmbedding(projectRoot) {
@@ -65809,6 +66200,19 @@ async function completeTask(options, cwd, accessor) {
     })()
   ).catch(() => {
   });
+  try {
+    const { hooks: hooks2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
+    await hooks2.dispatch("PostToolUse", cwd ?? process.cwd(), {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      taskId: options.taskId,
+      taskTitle: task.title,
+      previousStatus: before.status,
+      newStatus: "done",
+      unblockedCount: unblockedTasks.length
+    }).catch(() => {
+    });
+  } catch {
+  }
   return {
     task,
     ...autoCompleted.length > 0 && { autoCompleted },
@@ -85212,6 +85616,7 @@ var init_error_registry = __esm({
 // packages/core/src/init.ts
 var init_exports = {};
 __export(init_exports, {
+  deployStarterBundle: () => deployStarterBundle,
   ensureInitialized: () => ensureInitialized,
   getVersion: () => getVersion2,
   initAgentDefinition: () => initAgentDefinition,
@@ -85697,53 +86102,7 @@ async function initProject(opts = {}) {
     );
   }
   try {
-    const cantDir = join106(cleoDir, "cant");
-    const cantAgentsDir = join106(cantDir, "agents");
-    const hasCantFiles = existsSync107(cantDir) && readdirSync36(cantDir, { recursive: true }).some(
-      (f2) => typeof f2 === "string" && f2.endsWith(".cant")
-    );
-    if (!hasCantFiles) {
-      let starterBundleSrc = null;
-      try {
-        const { createRequire: createRequire19 } = await import("node:module");
-        const req = createRequire19(import.meta.url);
-        const cleoOsPkgMain = req.resolve("@cleocode/cleo-os/package.json");
-        const cleoOsPkgRoot = dirname22(cleoOsPkgMain);
-        const candidate = join106(cleoOsPkgRoot, "starter-bundle");
-        if (existsSync107(candidate)) {
-          starterBundleSrc = candidate;
-        }
-      } catch {
-      }
-      if (!starterBundleSrc) {
-        const packageRoot = getPackageRoot();
-        const fallbacks = [
-          join106(packageRoot, "..", "cleo-os", "starter-bundle"),
-          join106(packageRoot, "..", "..", "packages", "cleo-os", "starter-bundle")
-        ];
-        starterBundleSrc = fallbacks.find((p2) => existsSync107(p2)) ?? null;
-      }
-      if (starterBundleSrc) {
-        await mkdir16(cantDir, { recursive: true });
-        await mkdir16(cantAgentsDir, { recursive: true });
-        const teamSrc = join106(starterBundleSrc, "team.cant");
-        const teamDst = join106(cantDir, "team.cant");
-        if (existsSync107(teamSrc) && !existsSync107(teamDst)) {
-          await copyFile4(teamSrc, teamDst);
-        }
-        const agentsSrc = join106(starterBundleSrc, "agents");
-        if (existsSync107(agentsSrc)) {
-          const agentFiles = readdirSync36(agentsSrc).filter((f2) => f2.endsWith(".cant"));
-          for (const agentFile of agentFiles) {
-            const dst = join106(cantAgentsDir, agentFile);
-            if (!existsSync107(dst)) {
-              await copyFile4(join106(agentsSrc, agentFile), dst);
-            }
-          }
-        }
-        created.push("starter-bundle: team + agent .cant files deployed to .cleo/cant/");
-      }
-    }
+    await deployStarterBundle(cleoDir, created, warnings);
   } catch (err) {
     warnings.push(`Starter bundle deploy: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -85871,6 +86230,58 @@ async function getVersion2(projectRoot) {
   }
   return { version: "0.0.0" };
 }
+async function deployStarterBundle(cleoDir, created, warnings) {
+  const cantDir = join106(cleoDir, "cant");
+  const cantAgentsDir = join106(cantDir, "agents");
+  const hasCantFiles = existsSync107(cantDir) && readdirSync36(cantDir, { recursive: true }).some(
+    (f2) => typeof f2 === "string" && f2.endsWith(".cant")
+  );
+  if (hasCantFiles) return;
+  let starterBundleSrc = null;
+  try {
+    const { createRequire: createRequire19 } = await import("node:module");
+    const req = createRequire19(import.meta.url);
+    const cleoOsPkgMain = req.resolve("@cleocode/cleo-os/package.json");
+    const cleoOsPkgRoot = dirname22(cleoOsPkgMain);
+    const candidate = join106(cleoOsPkgRoot, "starter-bundle");
+    if (existsSync107(candidate)) {
+      starterBundleSrc = candidate;
+    }
+  } catch {
+  }
+  if (!starterBundleSrc) {
+    const packageRoot = getPackageRoot();
+    const fallbacks = [
+      join106(packageRoot, "..", "cleo-os", "starter-bundle"),
+      join106(packageRoot, "..", "..", "packages", "cleo-os", "starter-bundle")
+    ];
+    starterBundleSrc = fallbacks.find((p2) => existsSync107(p2)) ?? null;
+  }
+  if (!starterBundleSrc) {
+    warnings.push(
+      "Starter bundle not found \u2014 .cleo/cant/ will remain empty. Run cleo init in a project with @cleocode/cleo-os installed."
+    );
+    return;
+  }
+  await mkdir16(cantDir, { recursive: true });
+  await mkdir16(cantAgentsDir, { recursive: true });
+  const teamSrc = join106(starterBundleSrc, "team.cant");
+  const teamDst = join106(cantDir, "team.cant");
+  if (existsSync107(teamSrc) && !existsSync107(teamDst)) {
+    await copyFile4(teamSrc, teamDst);
+  }
+  const agentsSrc = join106(starterBundleSrc, "agents");
+  if (existsSync107(agentsSrc)) {
+    const agentFiles = readdirSync36(agentsSrc).filter((f2) => f2.endsWith(".cant"));
+    for (const agentFile of agentFiles) {
+      const dst = join106(cantAgentsDir, agentFile);
+      if (!existsSync107(dst)) {
+        await copyFile4(join106(agentsSrc, agentFile), dst);
+      }
+    }
+  }
+  created.push("starter-bundle: team + agent .cant files deployed to .cleo/cant/");
+}
 var DIR_SYMLINK_TYPE2;
 var init_init = __esm({
   "packages/core/src/init.ts"() {
@@ -99759,6 +100170,27 @@ async function runUpgrade(options = {}) {
       }
     } catch {
     }
+    try {
+      const { deployStarterBundle: deployStarterBundle2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+      const cantCreated = [];
+      const cantWarnings = [];
+      await deployStarterBundle2(cleoDir, cantCreated, cantWarnings);
+      if (cantCreated.length > 0) {
+        actions.push({
+          action: "cant_starter_bundle",
+          status: "applied",
+          details: cantCreated.join(", ")
+        });
+      }
+      for (const w2 of cantWarnings) {
+        actions.push({
+          action: "cant_starter_bundle",
+          status: "skipped",
+          details: w2
+        });
+      }
+    } catch {
+    }
     try {
       const skillsCreated = [];
       const skillsWarnings = [];
@@ -111714,6 +112146,7 @@ __export(internal_exports, {
   attachAgentToProject: () => attachAgentToProject2,
   auditData: () => auditData,
   auditLog: () => auditLog,
+  autoLinkMemories: () => autoLinkMemories,
   autoRecordDispatchTokenUsage: () => autoRecordDispatchTokenUsage,
   backfillBrainGraph: () => backfillBrainGraph,
   backfillTasks: () => backfillTasks,
@@ -112127,12 +112560,14 @@ __export(internal_exports, {
   lifecycleStageNameSchema: () => lifecycleStageNameSchema,
   lifecycleStageStatusSchema: () => lifecycleStageStatusSchema,
   lifecycleTransitionTypeSchema: () => lifecycleTransitionTypeSchema,
+  linkMemoryToCode: () => linkMemoryToCode,
   listAdrs: () => listAdrs,
   listAgentInstances: () => listAgentInstances,
   listAgentsForProject: () => listAgentsForProject,
   listBackups: () => listBackups,
   listBrainBackups: () => listBrainBackups,
   listChains: () => listChains,
+  listCodeLinks: () => listCodeLinks,
   listEpicsWithLifecycle: () => listEpicsWithLifecycle,
   listGlobalSaltBackups: () => listGlobalSaltBackups,
   listGlobalSqliteBackups: () => listGlobalSqliteBackups,
@@ -112256,6 +112691,8 @@ __export(internal_exports, {
   pushRelease: () => pushRelease,
   pushWarning: () => pushWarning,
   queryAudit: () => queryAudit,
+  queryCodeForMemory: () => queryCodeForMemory,
+  queryMemoriesForCode: () => queryMemoriesForCode,
   readGrades: () => readGrades,
   readJson: () => readJson,
   readManifestEntries: () => readManifestEntries2,
@@ -112613,6 +113050,7 @@ var init_internal = __esm({
     init_init();
     init_auto_extract();
     init_brain_embedding();
+    init_graph_memory_bridge();
     init_llm_extraction();
     init_memory_bridge();
     init_session_memory();
@@ -118731,7 +119169,31 @@ async function orchestrateSpawnExecute(taskId, adapterId, protocolType, projectR
       }
     } catch {
     }
+    try {
+      const { hooks: hooks2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
+      await hooks2.dispatch("SubagentStart", cwd, {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        taskId,
+        agentId: cleoSpawnContext.options?.preferredAgent ?? `worker-${taskId}`,
+        role: protocolType || "worker",
+        providerId: adapter.providerId
+      }).catch(() => {
+      });
+    } catch {
+    }
     const result = await adapter.spawn(cleoSpawnContext);
+    try {
+      const { hooks: hooks2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
+      await hooks2.dispatch("SubagentStop", cwd, {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        taskId,
+        agentId: cleoSpawnContext.options?.preferredAgent ?? `worker-${taskId}`,
+        status: result.status,
+        instanceId: result.instanceId
+      }).catch(() => {
+      });
+    } catch {
+    }
     void sendConduitEvent(cwd, "cleo-core", {
       event: "agent.spawned",
       taskId,
@@ -124218,27 +124680,59 @@ var init_memory2 = __esm({
               return wrapResult(result, "query", "memory", operation, startTime);
             }
             case "code.links": {
-              const { listCodeLinks } = await Promise.resolve().then(() => (init_internal(), internal_exports));
-              const result = await listCodeLinks(projectRoot);
-              return wrapResult(result, "query", "memory", operation, startTime);
+              const { listCodeLinks: listCodeLinks2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
+              const links = await listCodeLinks2(projectRoot);
+              return wrapResult(
+                { success: true, data: links },
+                "query",
+                "memory",
+                operation,
+                startTime
+              );
             }
             case "code.memories-for-code": {
               const symbol2 = params?.symbol;
               if (!symbol2) {
-                return errorResult("query", "memory", operation, "E_INVALID_INPUT", "symbol is required", startTime);
+                return errorResult(
+                  "query",
+                  "memory",
+                  operation,
+                  "E_INVALID_INPUT",
+                  "symbol is required",
+                  startTime
+                );
               }
-              const { queryMemoriesForCode } = await Promise.resolve().then(() => (init_internal(), internal_exports));
-              const result = await queryMemoriesForCode(projectRoot, symbol2);
-              return wrapResult({ success: true, data: result }, "query", "memory", operation, startTime);
+              const { queryMemoriesForCode: queryMemoriesForCode2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
+              const result = await queryMemoriesForCode2(projectRoot, symbol2);
+              return wrapResult(
+                { success: true, data: result },
+                "query",
+                "memory",
+                operation,
+                startTime
+              );
             }
             case "code.for-memory": {
               const memoryId = params?.memoryId;
               if (!memoryId) {
-                return errorResult("query", "memory", operation, "E_INVALID_INPUT", "memoryId is required", startTime);
+                return errorResult(
+                  "query",
+                  "memory",
+                  operation,
+                  "E_INVALID_INPUT",
+                  "memoryId is required",
+                  startTime
+                );
               }
-              const { queryCodeForMemory } = await Promise.resolve().then(() => (init_internal(), internal_exports));
-              const result = await queryCodeForMemory(projectRoot, memoryId);
-              return wrapResult({ success: true, data: result }, "query", "memory", operation, startTime);
+              const { queryCodeForMemory: queryCodeForMemory2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
+              const result = await queryCodeForMemory2(projectRoot, memoryId);
+              return wrapResult(
+                { success: true, data: result },
+                "query",
+                "memory",
+                operation,
+                startTime
+              );
             }
             default:
               return unsupportedOp("query", "memory", operation, startTime);
@@ -124414,16 +124908,35 @@ var init_memory2 = __esm({
               const memoryId = params?.memoryId;
               const codeSymbol = params?.codeSymbol;
               if (!memoryId || !codeSymbol) {
-                return errorResult("mutate", "memory", operation, "E_INVALID_INPUT", "memoryId and codeSymbol are required", startTime);
+                return errorResult(
+                  "mutate",
+                  "memory",
+                  operation,
+                  "E_INVALID_INPUT",
+                  "memoryId and codeSymbol are required",
+                  startTime
+                );
               }
-              const { linkMemoryToCode } = await Promise.resolve().then(() => (init_internal(), internal_exports));
-              const linked = await linkMemoryToCode(projectRoot, memoryId, codeSymbol);
-              return wrapResult({ success: true, data: { linked } }, "mutate", "memory", operation, startTime);
+              const { linkMemoryToCode: linkMemoryToCode2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
+              const linked = await linkMemoryToCode2(projectRoot, memoryId, codeSymbol);
+              return wrapResult(
+                { success: true, data: { linked } },
+                "mutate",
+                "memory",
+                operation,
+                startTime
+              );
             }
             case "code.auto-link": {
-              const { autoLinkMemories } = await Promise.resolve().then(() => (init_internal(), internal_exports));
-              const result = await autoLinkMemories(projectRoot);
-              return wrapResult({ success: true, data: result }, "mutate", "memory", operation, startTime);
+              const { autoLinkMemories: autoLinkMemories2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
+              const result = await autoLinkMemories2(projectRoot);
+              return wrapResult(
+                { success: true, data: result },
+                "mutate",
+                "memory",
+                operation,
+                startTime
+              );
             }
             default:
               return unsupportedOp("mutate", "memory", operation, startTime);