@goondocks/myco 0.19.4 → 0.19.6

package/dist/{main-EVS3FXDJ.js → main-RPJSS7PT.js}

@@ -15,7 +15,7 @@ import {
   getEmbeddingQueueDepth,
   getUnembedded,
   markEmbedded
-} from "./chunk-YDCGI3CS.js";
+} from "./chunk-VLGBWOBY.js";
 import {
   getTeamPackageVersion,
   loadSecrets,
@@ -23,7 +23,7 @@ import {
   readSecrets,
   resolveVaultConfigPath,
   writeSecret
-} from "./chunk-PLYWR5D7.js";
+} from "./chunk-FKBPXCH3.js";
 import {
   buildTaskInstruction,
   closeOpenBatches,
@@ -71,7 +71,7 @@ import {
   setResponseSummary,
   updateCandidate,
   updateNotificationStatus
-} from "./chunk-RTNLDAIC.js";
+} from "./chunk-P5VNHGVZ.js";
 import {
   fullTextSearch,
   hydrateSearchResults
@@ -91,7 +91,7 @@ import {
 } from "./chunk-Q4QD6LJT.js";
 import {
   listTurnsByRun
-} from "./chunk-QLCD77AN.js";
+} from "./chunk-6RFZWV4R.js";
 import {
   cleanupStagedSkill,
   listStaleStagingDirs
@@ -109,9 +109,11 @@ import {
   listBufferSessionIds
 } from "./chunk-V7XG6V6C.js";
 import "./chunk-POEPHBQK.js";
-import "./chunk-5B2ORGTF.js";
+import "./chunk-NCBLB2C6.js";
 import "./chunk-SAKJMNSR.js";
-import "./chunk-WYOE4IAX.js";
+import {
+  SymbiontInstaller
+} from "./chunk-TMNFCUAD.js";
 import {
   checkLocalProvider
 } from "./chunk-6ZDJXSEO.js";
@@ -168,7 +170,7 @@ import {
   updateBackupConfig,
   updateConfig,
   updateTeamConfig
-} from "./chunk-3C4LT4BW.js";
+} from "./chunk-NKQZ73LL.js";
 import {
   closeDatabase,
   getDatabase,
@@ -177,12 +179,13 @@ import {
 } from "./chunk-MYX5NCRH.js";
 import {
   resolveCliEntryPath
-} from "./chunk-W3P6MHLQ.js";
+} from "./chunk-QH5HS54N.js";
 import {
   getPluginVersion
-} from "./chunk-NTWJR6KH.js";
+} from "./chunk-ST2D3SGM.js";
 import {
-  loadManifests
+  loadManifests,
+  resolvePackageRoot
 } from "./chunk-UVKQ62II.js";
 import {
   findPackageRoot
@@ -1406,10 +1409,12 @@ async function handlePutConfig(vaultDir, body) {
 function createPlanDirHandlers(deps) {
   const { vaultDir, symbiontPlanDirsByAgent, symbiontPlanDirs } = deps;
   async function handleGetPlanDirs(_req) {
+    const config = loadConfig(vaultDir);
     return {
       body: {
         symbiont: symbiontPlanDirsByAgent,
-        custom: deps.planWatchConfig.watchDirs.filter((d) => !symbiontPlanDirs.includes(d))
+        custom: deps.planWatchConfig.watchDirs.filter((d) => !symbiontPlanDirs.includes(d)),
+        ignore_plan_dirs_in_git: config.capture.ignore_plan_dirs_in_git
       }
     };
   }
@@ -1418,15 +1423,28 @@ function createPlanDirHandlers(deps) {
     if (!Array.isArray(body.plan_dirs)) {
       return { status: 400, body: { error: "plan_dirs must be an array" } };
     }
+    if (body.ignore_plan_dirs_in_git !== void 0 && typeof body.ignore_plan_dirs_in_git !== "boolean") {
+      return { status: 400, body: { error: "ignore_plan_dirs_in_git must be a boolean" } };
+    }
     const updated = updateConfig(vaultDir, (cfg) => ({
       ...cfg,
-      capture: { ...cfg.capture, plan_dirs: body.plan_dirs }
+      capture: {
+        ...cfg.capture,
+        plan_dirs: body.plan_dirs,
+        ignore_plan_dirs_in_git: body.ignore_plan_dirs_in_git ?? cfg.capture.ignore_plan_dirs_in_git
+      }
     }));
     deps.setPlanWatchConfig({
       ...deps.planWatchConfig,
       watchDirs: [.../* @__PURE__ */ new Set([...symbiontPlanDirs, ...body.plan_dirs])]
     });
-    return { body: { custom: updated.capture.plan_dirs } };
+    deps.reconcileProjectFiles?.();
+    return {
+      body: {
+        custom: updated.capture.plan_dirs,
+        ignore_plan_dirs_in_git: updated.capture.ignore_plan_dirs_in_git
+      }
+    };
   }
   return { handleGetPlanDirs, handleUpdatePlanDirs };
 }
@@ -2200,9 +2218,33 @@ function createUpdateHandlers(deps) {
   };
 }
 
-// src/daemon/backup.ts
+// src/symbionts/reconcile.ts
 import fs12 from "fs";
 import path12 from "path";
+function getConfiguredManifests(projectRoot, config) {
+  const allManifests = loadManifests();
+  const enabledNames = getEnabledSymbiontNames(config);
+  if (enabledNames) {
+    return allManifests.filter((manifest) => enabledNames.has(manifest.name));
+  }
+  return allManifests.filter((manifest) => fs12.existsSync(path12.join(projectRoot, manifest.configDir)));
+}
+function reconcileConfiguredSymbionts(projectRoot, vaultDir = path12.join(projectRoot, ".myco")) {
+  const config = loadConfig(vaultDir);
+  const manifests = getConfiguredManifests(projectRoot, config);
+  const packageRoot = resolvePackageRoot();
+  let updatedCount = 0;
+  for (const manifest of manifests) {
+    const installer = new SymbiontInstaller(manifest, projectRoot, packageRoot);
+    installer.install();
+    updatedCount++;
+  }
+  return updatedCount;
+}
+
+// src/daemon/backup.ts
+import fs13 from "fs";
+import path13 from "path";
 var BACKUP_TABLES = [
   "sessions",
   "prompt_batches",
@@ -2229,7 +2271,7 @@ function toSqlLiteral(value) {
   return `'${escapeSql(String(value))}'`;
 }
 function createBackup(db, backupDir, machineId) {
-  fs12.mkdirSync(backupDir, { recursive: true });
+  fs13.mkdirSync(backupDir, { recursive: true });
   const lines = [];
   const timestamp = epochSeconds();
   lines.push(`${BACKUP_HEADER_TEMPLATE}: machine_id=${machineId}, created_at=${timestamp}`);
@@ -2247,22 +2289,22 @@ function createBackup(db, backupDir, machineId) {
     }
     lines.push("");
   }
-  const filePath = path12.join(backupDir, `${machineId}${BACKUP_EXTENSION}`);
-  fs12.writeFileSync(filePath, lines.join("\n"), "utf-8");
+  const filePath = path13.join(backupDir, `${machineId}${BACKUP_EXTENSION}`);
+  fs13.writeFileSync(filePath, lines.join("\n"), "utf-8");
   return filePath;
 }
 function listBackups(backupDir) {
   let entries;
   try {
-    entries = fs12.readdirSync(backupDir);
+    entries = fs13.readdirSync(backupDir);
   } catch {
     return [];
   }
   const backups = [];
   for (const entry of entries) {
     if (!BACKUP_FILENAME_PATTERN.test(entry)) continue;
-    const filePath = path12.join(backupDir, entry);
-    const stat = fs12.statSync(filePath);
+    const filePath = path13.join(backupDir, entry);
+    const stat = fs13.statSync(filePath);
     backups.push({
       machine_id: entry.slice(0, -BACKUP_EXTENSION.length),
       file_name: entry,
@@ -2274,7 +2316,7 @@ function listBackups(backupDir) {
 }
 var INSERT_REGEX = /^INSERT OR IGNORE INTO (\w+)\s+\(([^)]+)\)\s+VALUES\s+\((.+)\);$/;
 function parseBackupFile(backupPath) {
-  const content = fs12.readFileSync(backupPath, "utf-8");
+  const content = fs13.readFileSync(backupPath, "utf-8");
   const inserts = [];
   for (const line of content.split("\n")) {
     const match = INSERT_REGEX.exec(line);
@@ -2358,7 +2400,7 @@ function restoreBackup(db, backupPath) {
 }
 
 // src/daemon/api/backup.ts
-import path13 from "path";
+import path14 from "path";
 function createBackupHandlers(deps) {
   async function handleCreateBackup(_req) {
     const filePath = createBackup(deps.db, deps.backupDir, deps.machineId);
@@ -2417,7 +2459,7 @@ function createBackupConfigHandlers(deps) {
   const { vaultDir } = deps;
   async function handleGetBackupConfig() {
     const cfg = loadConfig(vaultDir);
-    return { body: { dir: cfg.backup.dir ?? null, default_dir: path13.resolve(vaultDir, "backups") } };
+    return { body: { dir: cfg.backup.dir ?? null, default_dir: path14.resolve(vaultDir, "backups") } };
   }
   async function handlePutBackupConfig(req) {
     const { dir } = req.body;
@@ -2587,15 +2629,15 @@ var TeamSyncClient = class _TeamSyncClient {
       "Content-Type": "application/json"
     };
   }
-  async request(method, path22, body) {
-    const res = await this.fetchFn(`${this.workerUrl}${path22}`, {
+  async request(method, path23, body) {
+    const res = await this.fetchFn(`${this.workerUrl}${path23}`, {
       method,
       headers: this.headers(),
       body: body !== void 0 ? JSON.stringify(body) : void 0
     });
     if (!res.ok) {
       const text = await res.text().catch(() => "");
-      throw new Error(`Team sync request ${method} ${path22} failed: ${res.status} ${text}`);
+      throw new Error(`Team sync request ${method} ${path23} failed: ${res.status} ${text}`);
     }
     return res.json();
   }
@@ -2730,7 +2772,7 @@ function createTeamHandlers(deps) {
     return { body: { retried: count } };
   }
   async function handleUpgradeWorker(_req) {
-    const { upgradeWorker } = await import("./team-M6TC4TFC.js");
+    const { upgradeWorker } = await import("./team-SNLC6FZM.js");
     logger.info("team-sync.upgrade.start", "Starting worker upgrade");
     const result = upgradeWorker(vaultDir);
     if (!result.success) {
@@ -2946,8 +2988,8 @@ function createSessionLifecycleHandlers(deps) {
 }
 
 // src/daemon/api/skills.ts
-import fs13 from "fs";
-import path14 from "path";
+import fs14 from "fs";
+import path15 from "path";
 
 // src/db/queries/skill-usage.ts
 var USAGE_COLUMNS = [
@@ -3114,15 +3156,15 @@ function createSkillRecordDeleteHandler(deps) {
     if (result.body?.deleted) {
       const record = result.body;
       if (record.name) {
-        const projectRoot = path14.resolve(vaultDir, "..");
-        const skillDir = path14.resolve(projectRoot, ".agents", "skills", record.name);
+        const projectRoot = path15.resolve(vaultDir, "..");
+        const skillDir = path15.resolve(projectRoot, ".agents", "skills", record.name);
         try {
-          fs13.rmSync(skillDir, { recursive: true, force: true });
+          fs14.rmSync(skillDir, { recursive: true, force: true });
         } catch (err) {
           logger.warn(LOG_KINDS.PROCESSOR_BATCH, "Failed to remove skill directory", { name: record.name, error: String(err) });
         }
         try {
-          const { syncSkillSymlinks } = await import("./installer-BWJED3ED.js");
+          const { syncSkillSymlinks } = await import("./installer-WMTB4NCX.js");
           syncSkillSymlinks(projectRoot, record.name, { remove: true });
         } catch (err) {
           logger.warn(LOG_KINDS.PROCESSOR_BATCH, "Failed to remove skill symlinks", { name: record.name, error: String(err) });
@@ -3375,12 +3417,12 @@ async function handleGetModels(req) {
 
 // src/daemon/api/stats.ts
 import { createHash as createHash2 } from "crypto";
-import fs14 from "fs";
-import path15 from "path";
+import fs15 from "fs";
+import path16 from "path";
 function computeConfigHash(vaultDir) {
   try {
-    const configPath = path15.join(vaultDir, CONFIG_FILENAME);
-    const raw = fs14.readFileSync(configPath, "utf-8");
+    const configPath = path16.join(vaultDir, CONFIG_FILENAME);
+    const raw = fs15.readFileSync(configPath, "utf-8");
     return createHash2("md5").update(raw).digest("hex");
   } catch {
     return "";
@@ -3746,7 +3788,7 @@ async function triggerTitleSummary(sessionId, deps) {
   if (config.agent.summary_batch_interval <= 0) return;
   if (config.agent.event_tasks_enabled === false) return;
   try {
-    const { runAgent } = await import("./executor-4TJOZN32.js");
+    const { runAgent } = await import("./executor-NXNSUEMQ.js");
     runAgent(vaultDir, {
       task: "title-summary",
       instruction: `Process session ${sessionId} only`,
@@ -3858,6 +3900,9 @@ var DEFAULT_LIST_OFFSET3 = 0;
 var DEFAULT_GRAPH_DEPTH = 1;
 var MAX_GRAPH_DEPTH = 3;
 var SPORE_NAME_PREVIEW_CHARS = 60;
+var GRAPH_SEED_ENTITY_LIMIT = 4;
+var GRAPH_SEED_SPORE_LIMIT = 4;
+var GRAPH_SEED_SESSION_LIMIT = 4;
 var EXCLUDED_GRAPH_EDGE_TYPES = /* @__PURE__ */ new Set(["HAS_BATCH", "EXTRACTED_FROM"]);
 async function handleListSpores(req) {
   const agentId = req.query.agent_id;
@@ -3898,11 +3943,93 @@ async function handleListEntities(req) {
   });
   return { body: { entities } };
 }
+async function handleGetGraphSeeds(_req) {
+  const db = getDatabase();
+  const sporeRows = db.prepare(
+    `SELECT id, observation_type, status, content, created_at
+     FROM spores
+     WHERE agent_id = ? AND status = 'active'
+     ORDER BY created_at DESC
+     LIMIT ?`
+  ).all(DEFAULT_AGENT_ID, GRAPH_SEED_SPORE_LIMIT);
+  const sessionRows = db.prepare(
+    `SELECT id, title, summary, status, started_at as created_at
+     FROM sessions
+     WHERE status != 'active'
+     ORDER BY started_at DESC
+     LIMIT ?`
+  ).all(GRAPH_SEED_SESSION_LIMIT);
+  const entityRows = db.prepare(
+    `SELECT e.id, e.type, e.name, e.status, e.first_seen as created_at, COUNT(em.entity_id) as mention_count
+     FROM entities e
+     LEFT JOIN entity_mentions em ON em.entity_id = e.id
+     WHERE e.agent_id = ? AND e.status = 'active'
+     GROUP BY e.id
+     ORDER BY mention_count DESC, e.last_seen DESC
+     LIMIT ?`
+  ).all(DEFAULT_AGENT_ID, GRAPH_SEED_ENTITY_LIMIT);
+  const sporeSeeds = sporeRows.map((row) => ({
+    id: row.id,
+    name: (row.content ?? "").slice(0, SPORE_NAME_PREVIEW_CHARS),
+    type: "spore",
+    status: row.status ?? void 0,
+    created_at: row.created_at,
+    content: row.content,
+    observation_type: row.observation_type
+  }));
+  const sessionSeeds = sessionRows.map((row) => ({
+    id: row.id,
+    name: row.title ?? `Session ${row.id.slice(-6)}`,
+    type: "session",
+    status: row.status ?? void 0,
+    created_at: row.created_at,
+    content: row.summary ?? void 0
+  }));
+  const entitySeeds = entityRows.map((row) => ({
+    id: row.id,
+    name: row.name,
+    type: row.type,
+    status: row.status ?? void 0,
+    created_at: row.created_at,
+    mention_count: Number(row.mention_count) || 0
+  }));
+  const seeds = [
+    ...entitySeeds,
+    ...sessionSeeds,
+    ...sporeSeeds
+  ];
+  const recommendedId = entitySeeds[0]?.id ?? sessionSeeds[0]?.id ?? sporeSeeds[0]?.id ?? null;
+  return {
+    body: {
+      seeds,
+      recommended_id: recommendedId
+    }
+  };
+}
 async function handleGetGraph(req) {
   const depth = Math.min(Number(req.query.depth) || DEFAULT_GRAPH_DEPTH, MAX_GRAPH_DEPTH);
-  const center = getEntity(req.params.id);
-  if (!center) return { status: 404, body: { error: "not_found" } };
-  const graph = getGraphForNode(req.params.id, "entity", { depth });
+  const id = req.params.id;
+  let centerNode = null;
+  let centerType = "entity";
+  const entity = getEntity(id);
+  if (entity) {
+    centerNode = entity;
+    centerType = "entity";
+  } else {
+    const spore = getSpore(id);
+    if (spore) {
+      centerNode = spore;
+      centerType = "spore";
+    } else {
+      const session = getSession(id);
+      if (session) {
+        centerNode = session;
+        centerType = "session";
+      }
+    }
+  }
+  if (!centerNode) return { status: 404, body: { error: "not_found" } };
+  const graph = getGraphForNode(id, centerType, { depth });
   const filteredEdges = graph.edges.filter(
     (e) => !EXCLUDED_GRAPH_EDGE_TYPES.has(e.type)
   );
@@ -3911,24 +4038,26 @@ async function handleGetGraph(req) {
   const sporeIds = /* @__PURE__ */ new Set();
   const sessionIds = /* @__PURE__ */ new Set();
   for (const edge of filteredEdges) {
-    for (const [id, type] of [
+    for (const [nodeId, type] of [
       [edge.source_id, edge.source_type],
       [edge.target_id, edge.target_type]
     ]) {
       switch (type) {
         case "entity":
-          entityIds.add(id);
+          entityIds.add(nodeId);
           break;
         case "spore":
-          sporeIds.add(id);
+          sporeIds.add(nodeId);
           break;
         case "session":
-          sessionIds.add(id);
+          sessionIds.add(nodeId);
           break;
       }
     }
   }
-  entityIds.add(center.id);
+  if (centerType === "entity") entityIds.add(id);
+  if (centerType === "spore") sporeIds.add(id);
+  if (centerType === "session") sessionIds.add(id);
   const entityIdArray = Array.from(entityIds);
   let entityNodes = [];
   if (entityIdArray.length > 0) {
@@ -3996,17 +4125,17 @@ async function handleGetGraph(req) {
       content: n.summary ?? void 0
     }))
   ];
-  const centerNode = allNodes.find((n) => n.id === center.id);
   const uiEdges = filteredEdges.map((e) => ({
     source_id: e.source_id,
     target_id: e.target_id,
     label: e.type,
     weight: e.confidence
   }));
+  const centerResponseNode = allNodes.find((n) => n.id === id);
   return {
     body: {
-      center: centerNode ?? { ...center, mention_count: mentionCounts.get(center.id) ?? 0 },
-      nodes: allNodes.filter((n) => n.id !== center.id),
+      center: centerResponseNode,
+      nodes: allNodes.filter((n) => n.id !== id),
       edges: uiEdges,
       depth
     }
@@ -5433,17 +5562,17 @@ var SqliteRecordSource = class {
 };
 
 // src/daemon/database/manager.ts
-import fs16 from "fs";
+import fs17 from "fs";
 
 // src/db/queries/database.ts
-import fs15 from "fs";
+import fs16 from "fs";
 function pragmaScalar(name) {
   const db = getDatabase();
   return db.pragma(name, { simple: true });
 }
 function safeFileSize(filePath) {
   try {
-    return fs15.statSync(filePath).size;
+    return fs16.statSync(filePath).size;
   } catch (err) {
     if (err.code === "ENOENT") return 0;
     throw err;
@@ -5715,7 +5844,7 @@ var DatabaseMaintenanceManager = class {
   }
   async vacuum() {
     const size_before = this.fileSize();
-    const stats = await fs16.promises.statfs(this.vaultDir);
+    const stats = await fs17.promises.statfs(this.vaultDir);
     const free_bytes = Number(stats.bavail) * Number(stats.bsize);
     const required_bytes = size_before * VACUUM_FREE_SPACE_MULTIPLIER;
     if (free_bytes < required_bytes) {
@@ -5763,7 +5892,7 @@ var DatabaseMaintenanceManager = class {
   }
   fileSize() {
     try {
-      return fs16.statSync(this.dbPath).size;
+      return fs17.statSync(this.dbPath).size;
     } catch {
       return 0;
     }
@@ -5776,8 +5905,8 @@ function registerBuiltinDomains() {
     domain: "agents",
     label: "Agent Tasks",
     types: [
-      { id: "agent.task.success", label: "Task completed", defaultMode: "banner", defaultLevel: "success" },
-      { id: "agent.task.failure", label: "Task failed", defaultMode: "banner", defaultLevel: "error" }
+      { id: "agent.task.success", label: "Task completed", defaultMode: "summary", defaultLevel: "success" },
+      { id: "agent.task.failure", label: "Task failed", defaultMode: "summary", defaultLevel: "error" }
     ]
   });
   register({
@@ -5793,8 +5922,8 @@ function registerBuiltinDomains() {
     label: "Skills",
     types: [
       { id: "skill.surveyed", label: "Skill candidate surveyed", defaultMode: "summary", defaultLevel: "info" },
-      { id: "skill.created", label: "Skill created", defaultMode: "banner", defaultLevel: "success" },
-      { id: "skill.evolved", label: "Skill evolved", defaultMode: "banner", defaultLevel: "info" }
+      { id: "skill.created", label: "Skill created", defaultMode: "summary", defaultLevel: "success" },
+      { id: "skill.evolved", label: "Skill evolved", defaultMode: "summary", defaultLevel: "info" }
     ]
   });
   register({
@@ -5809,7 +5938,7 @@ function registerBuiltinDomains() {
     domain: "daemon",
     label: "Daemon",
     types: [
-      { id: "daemon.version_sync", label: "Version sync restart", defaultMode: "banner", defaultLevel: "info" }
+      { id: "daemon.version_sync", label: "Version sync restart", defaultMode: "summary", defaultLevel: "info" }
     ]
   });
 }
@@ -6242,7 +6371,7 @@ async function registerScheduledTasks(powerManager, deps) {
       else runningTasks.delete(name);
     },
     runTask: async (taskName) => {
-      const { runAgent } = await import("./executor-4TJOZN32.js");
+      const { runAgent } = await import("./executor-NXNSUEMQ.js");
       const taskConfig = config.agent.tasks?.[taskName];
       const projectRoot = resolve(vaultDir, "..");
       const built = buildTaskInstruction(taskName, taskConfig?.params, taskAgentMap.get(taskName), projectRoot, embeddingManager);
@@ -6281,7 +6410,7 @@ async function registerScheduledTasks(powerManager, deps) {
           link: `/agent?run=${result.runId}`,
           metadata: { taskName, runId: result.runId }
         }, config);
-        const { countToolCallsByRun } = await import("./turns-3ZQAF6HF.js");
+        const { countToolCallsByRun } = await import("./turns-YFNI5CQC.js");
         const counts = countToolCallsByRun(result.runId, ["vault_create_spore", "vault_write_digest"]);
         const sporeCount = counts["vault_create_spore"] ?? 0;
         const digestCount = counts["vault_write_digest"] ?? 0;
@@ -6546,7 +6675,7 @@ function createAgentRunHandlers(deps) {
         };
       }
     }
-    const { runAgent } = await import("./executor-4TJOZN32.js");
+    const { runAgent } = await import("./executor-NXNSUEMQ.js");
     const resultPromise = runAgent(vaultDir, {
       task,
       instruction,
@@ -6557,13 +6686,29 @@ function createAgentRunHandlers(deps) {
     const effectiveAgentId = agentId ?? "myco-agent";
     const runId = getLatestRunId(effectiveAgentId, task);
     resultPromise.then((result) => {
+      const taskName = task ?? "agent run";
       if (result.status === "failed") {
+        notify(vaultDir, {
+          domain: "agents",
+          type: "agent.task.failure",
+          title: `Task failed: ${taskName}`,
+          message: result.error ?? "Unknown error",
+          link: `/agent?run=${result.runId}`,
+          metadata: { taskName: task ?? null, runId: result.runId }
+        }, mycoConfig);
         logger.error(LOG_KINDS.AGENT_ERROR, "Agent run failed", {
           runId: result.runId,
           error: result.error ?? "No error message",
           phases: result.phases?.map((p) => `${p.name}:${p.status}`) ?? []
         });
       } else {
+        notify(vaultDir, {
+          domain: "agents",
+          type: "agent.task.success",
+          title: `Task completed: ${taskName}`,
+          link: `/agent?run=${result.runId}`,
+          metadata: { taskName: task ?? null, runId: result.runId }
+        }, mycoConfig);
         logger.info(LOG_KINDS.AGENT_RUN, "Agent run completed", {
           runId: result.runId,
           status: result.status,
@@ -6615,8 +6760,8 @@ function createAgentRunHandlers(deps) {
 }
 
 // src/daemon/api/attachments.ts
-import fs17 from "fs";
-import path16 from "path";
+import fs18 from "fs";
+import path17 from "path";
 var ATTACHMENT_MEDIA_TYPES = {
   png: "image/png",
   jpg: "image/jpeg",
@@ -6636,14 +6781,14 @@ function createAttachmentHandler(deps) {
       const contentType2 = att.media_type ?? "application/octet-stream";
       return { status: 200, headers: { "Content-Type": contentType2 }, body: att.data };
     }
-    const filePath = path16.join(vaultDir, "attachments", filename);
+    const filePath = path17.join(vaultDir, "attachments", filename);
     let diskData;
     try {
-      diskData = fs17.readFileSync(filePath);
+      diskData = fs18.readFileSync(filePath);
     } catch {
       return { status: 404, body: { error: "not_found" } };
     }
-    const ext = path16.extname(filename).slice(1).toLowerCase();
+    const ext = path17.extname(filename).slice(1).toLowerCase();
     const contentType = ATTACHMENT_MEDIA_TYPES[ext] ?? "application/octet-stream";
     return { status: 200, headers: { "Content-Type": contentType }, body: diskData };
   }
@@ -6651,19 +6796,19 @@ function createAttachmentHandler(deps) {
 }
 
 // src/daemon/log-reconcile.ts
-import fs18 from "fs";
-import path17 from "path";
+import fs19 from "fs";
+import path18 from "path";
 function reconcileLogBuffer(logDir, sinceTimestamp) {
   let replayed = 0;
   const files = [];
   for (let i = 3; i >= 1; i--) {
-    const rotated = path17.join(logDir, `daemon.${i}.log`);
-    if (fs18.existsSync(rotated)) files.push(rotated);
+    const rotated = path18.join(logDir, `daemon.${i}.log`);
+    if (fs19.existsSync(rotated)) files.push(rotated);
   }
-  const current = path17.join(logDir, "daemon.log");
-  if (fs18.existsSync(current)) files.push(current);
+  const current = path18.join(logDir, "daemon.log");
+  if (fs19.existsSync(current)) files.push(current);
   for (const file of files) {
-    const content = fs18.readFileSync(file, "utf-8");
+    const content = fs19.readFileSync(file, "utf-8");
     for (const line of content.split("\n")) {
       if (!line.trim()) continue;
       try {
@@ -6940,8 +7085,8 @@ function registerPowerJobs(powerManager, deps) {
 }
 
 // src/daemon/reconciliation.ts
-import fs19 from "fs";
-import path18 from "path";
+import fs20 from "fs";
+import path19 from "path";
 
 // src/daemon/event-handlers.ts
 var TOOL_INPUT_STORE_LIMIT = 4e3;
@@ -7110,10 +7255,10 @@ function createReconciler({ bufferDir, logger }) {
   function reconcileSession(sessionId) {
     if (reconciledSessions.has(sessionId)) return;
     reconciledSessions.add(sessionId);
-    const bufferPath = path18.join(bufferDir, `${sessionId}.jsonl`);
+    const bufferPath = path19.join(bufferDir, `${sessionId}.jsonl`);
     let content;
     try {
-      content = fs19.readFileSync(bufferPath, "utf-8").trim();
+      content = fs20.readFileSync(bufferPath, "utf-8").trim();
     } catch {
       return;
     }
@@ -7182,7 +7327,7 @@ function createReconciler({ bufferDir, logger }) {
 }
 
 // src/daemon/stop-processing.ts
-import fs20 from "fs";
+import fs21 from "fs";
 
 // src/daemon/capture-images.ts
 var SESSION_SHORT_LEN = 6;
@@ -7222,7 +7367,7 @@ function captureBatchImages(input) {
 // src/daemon/plan-capture.ts
 import { createHash as createHash4 } from "crypto";
 import os7 from "os";
-import path19 from "path";
+import path20 from "path";
 function extractTaggedPlans(text, tags) {
   const results = [];
   for (const tag of tags) {
@@ -7248,11 +7393,11 @@ var FILE_WRITE_TOOLS = /* @__PURE__ */ new Set([
 var HEADING_REGEX = /^#\s+(.+)$/m;
 var PLAN_ID_HASH_LENGTH = 16;
 function isInPlanDirectory(filePath, watchDirs, projectRoot) {
-  const abs = path19.isAbsolute(filePath) ? filePath : path19.resolve(projectRoot, filePath);
+  const abs = path20.isAbsolute(filePath) ? filePath : path20.resolve(projectRoot, filePath);
   return watchDirs.some((dir) => {
-    const expanded = dir.startsWith("~/") ? path19.join(os7.homedir(), dir.slice(2)) : dir;
-    const absDir = path19.isAbsolute(expanded) ? expanded : path19.resolve(projectRoot, expanded);
-    const prefix = absDir.endsWith(path19.sep) ? absDir : absDir + path19.sep;
+    const expanded = dir.startsWith("~/") ? path20.join(os7.homedir(), dir.slice(2)) : dir;
+    const absDir = path20.isAbsolute(expanded) ? expanded : path20.resolve(projectRoot, expanded);
+    const prefix = absDir.endsWith(path20.sep) ? absDir : absDir + path20.sep;
     return abs === absDir || abs.startsWith(prefix);
   });
 }
@@ -7262,7 +7407,7 @@ function isPlanWriteEvent(toolName, toolInput, config) {
   if (typeof filePath !== "string") return null;
   if (!isInPlanDirectory(filePath, config.watchDirs, config.projectRoot)) return null;
   if (config.extensions?.length) {
-    const ext = path19.extname(filePath).toLowerCase();
+    const ext = path20.extname(filePath).toLowerCase();
     if (!config.extensions.includes(ext)) return null;
   }
   return filePath;
@@ -7276,7 +7421,7 @@ function capturePlan(input) {
   const now = Math.floor(Date.now() / 1e3);
   const contentHash = createHash4(CONTENT_HASH_ALGORITHM).update(input.content).digest("hex");
   const id = createHash4("md5").update(input.sourcePath).digest("hex").slice(0, PLAN_ID_HASH_LENGTH);
-  const title = parsePlanTitle(input.content, path19.basename(input.sourcePath));
+  const title = parsePlanTitle(input.content, path20.basename(input.sourcePath));
   return upsertPlan({
     id,
     title,
@@ -7445,7 +7590,7 @@ function createStopProcessor(deps) {
         let transcriptText = null;
         if (hookTranscriptPath) {
           try {
-            transcriptText = fs20.readFileSync(hookTranscriptPath, "utf-8");
+            transcriptText = fs21.readFileSync(hookTranscriptPath, "utf-8");
           } catch {
           }
         }
@@ -7581,8 +7726,8 @@ function createStopProcessor(deps) {
 }
 
 // src/daemon/event-dispatch.ts
-import fs21 from "fs";
-import path20 from "path";
+import fs22 from "fs";
+import path21 from "path";
 var EventBody = external_exports.object({ type: external_exports.string(), session_id: external_exports.string() }).passthrough();
 function createEventDispatcher(deps) {
   const {
@@ -7621,7 +7766,7 @@ function createEventDispatcher(deps) {
       reconcileSession(event.session_id);
     }
     if (!sessionBuffers.has(event.session_id)) {
-      const bufferDir = path20.join(vaultDir, "buffer");
+      const bufferDir = path21.join(vaultDir, "buffer");
       sessionBuffers.set(event.session_id, new EventBuffer(bufferDir, event.session_id));
     }
     sessionBuffers.get(event.session_id).append(event);
@@ -7680,10 +7825,10 @@ function createEventDispatcher(deps) {
       );
       if (planFilePath) {
         const captureSessionId = event.session_id;
-        fs21.promises.readFile(planFilePath, "utf-8").then((planContent) => {
+        fs22.promises.readFile(planFilePath, "utf-8").then((planContent) => {
           const latestBatch = getLatestBatch(captureSessionId);
           capturePlan({
-            sourcePath: path20.relative(projectRoot, planFilePath),
+            sourcePath: path21.relative(projectRoot, planFilePath),
             content: planContent,
             sessionId: captureSessionId,
             promptBatchId: latestBatch?.id ?? null
@@ -7825,14 +7970,14 @@ function createEventDispatcher(deps) {
 }
 
 // src/daemon/main.ts
-import fs22 from "fs";
+import fs23 from "fs";
 import os8 from "os";
-import path21 from "path";
+import path22 from "path";
 function killStaleDaemon(vaultDir, logger) {
-  const daemonJsonPath = path21.join(vaultDir, "daemon.json");
+  const daemonJsonPath = path22.join(vaultDir, "daemon.json");
   try {
-    if (!fs22.existsSync(daemonJsonPath)) return;
-    const info = JSON.parse(fs22.readFileSync(daemonJsonPath, "utf-8"));
+    if (!fs23.existsSync(daemonJsonPath)) return;
+    const info = JSON.parse(fs23.readFileSync(daemonJsonPath, "utf-8"));
     if (!info.pid) return;
     if (info.pid === process.pid) return;
     try {
@@ -7841,7 +7986,7 @@ function killStaleDaemon(vaultDir, logger) {
       logger.info(LOG_KINDS.DAEMON_START, "Killed stale daemon", { pid: info.pid });
     } catch {
     }
-    fs22.unlinkSync(daemonJsonPath);
+    fs23.unlinkSync(daemonJsonPath);
   } catch {
   }
 }
@@ -7851,7 +7996,7 @@ async function main() {
     process.stderr.write("Usage: mycod --vault <path>\n");
     process.exit(1);
   }
-  const vaultDir = path21.resolve(vaultArg);
+  const vaultDir = path22.resolve(vaultArg);
   loadSecrets(vaultDir);
   const config = loadConfig(vaultDir);
   const manifests = loadManifests();
@@ -7863,7 +8008,7 @@ async function main() {
     projectRoot,
     extensions: config.capture.artifact_extensions
   };
-  const logger = new DaemonLogger(path21.join(vaultDir, "logs"), {
+  const logger = new DaemonLogger(path22.join(vaultDir, "logs"), {
     level: config.daemon.log_level
   });
   if (config.daemon.log_level === "debug") {
@@ -7892,7 +8037,7 @@ async function main() {
   const devCliEntry = detectDevBuild(
     globalPrefix,
     process.argv[1],
-    fs22.realpathSync
+    fs23.realpathSync
   );
   if (devCliEntry) {
     setDevBuildCliEntry(devCliEntry);
@@ -7906,11 +8051,11 @@ async function main() {
   registerBuiltinDomains();
   logger.info(LOG_KINDS.DAEMON_START, "SQLite initialized", { vault: vaultDir });
   {
-    const reasonPath = path21.join(vaultDir, RESTART_REASON_FILENAME);
+    const reasonPath = path22.join(vaultDir, RESTART_REASON_FILENAME);
     try {
-      if (fs22.existsSync(reasonPath)) {
-        const raw = JSON.parse(fs22.readFileSync(reasonPath, "utf-8"));
-        fs22.unlinkSync(reasonPath);
+      if (fs23.existsSync(reasonPath)) {
+        const raw = JSON.parse(fs23.readFileSync(reasonPath, "utf-8"));
+        fs23.unlinkSync(reasonPath);
         if (raw.reason === "version_sync" && raw.to_version) {
           const message = raw.local_update_ran ? "Restarted and updated local project hooks." : "Restarted to pick up the latest version.";
           notify(vaultDir, {
@@ -7952,13 +8097,13 @@ async function main() {
   });
   const lastLogTimestamp = getMaxTimestamp();
   if (lastLogTimestamp) {
-    const logDir = path21.join(vaultDir, "logs");
+    const logDir = path22.join(vaultDir, "logs");
     const replayedCount = reconcileLogBuffer(logDir, lastLogTimestamp);
     if (replayedCount > 0) {
       logger.info(LOG_KINDS.DAEMON_RECONCILE, `Replayed ${replayedCount} log entries from buffer`, { replayed: replayedCount });
     }
   }
-  const vectorsDbPath = path21.join(vaultDir, "vectors.db");
+  const vectorsDbPath = path22.join(vaultDir, "vectors.db");
   const vectorStore = new SqliteVecVectorStore(vectorsDbPath);
   const llmProvider = createEmbeddingProvider(config.embedding);
   const embeddingProvider = new EmbeddingProviderAdapter(llmProvider, config.embedding);
@@ -7978,12 +8123,23 @@ async function main() {
   try {
     const staleDb = getDatabase();
     const staleRows = staleDb.prepare(
-      `SELECT id FROM agent_runs WHERE status = 'running'`
+      `SELECT id, task FROM agent_runs WHERE status = 'running'`
     ).all();
     if (staleRows.length > 0) {
+      const completedAt = epochSeconds();
       staleDb.prepare(
         `UPDATE agent_runs SET status = 'failed', completed_at = ?, error = 'Daemon restarted while run was in progress' WHERE status = 'running'`
-      ).run(epochSeconds());
+      ).run(completedAt);
+      for (const row of staleRows) {
+        notify(vaultDir, {
+          domain: "agents",
+          type: "agent.task.failure",
+          title: `Task failed: ${row.task ?? "agent run"}`,
+          message: "Daemon restarted while run was in progress",
+          link: `/agent?run=${row.id}`,
+          metadata: { taskName: row.task, runId: row.id, reason: "daemon_restart" }
+        }, config);
+      }
       logger.info(LOG_KINDS.AGENT_RUN, "Cleaned stale running agent runs", {
         count: staleRows.length,
         ids: staleRows.map((r) => r.id)
@@ -7994,10 +8150,10 @@ async function main() {
   }
   let uiDir = null;
   {
-    const root = findPackageRoot(path21.dirname(new URL(import.meta.url).pathname));
+    const root = findPackageRoot(path22.dirname(new URL(import.meta.url).pathname));
     if (root) {
-      const candidate = path21.join(root, "dist", "ui");
-      if (fs22.existsSync(candidate)) uiDir = candidate;
+      const candidate = path22.join(root, "dist", "ui");
+      if (fs23.existsSync(candidate)) uiDir = candidate;
     }
   }
   if (uiDir) {
@@ -8030,7 +8186,7 @@ async function main() {
       (p) => createPerProjectAdapter(p, claudeCodeAdapter.parseTurns)
     )
   });
-  const bufferDir = path21.join(vaultDir, "buffer");
+  const bufferDir = path22.join(vaultDir, "buffer");
   const sessionBuffers = /* @__PURE__ */ new Map();
   const reconciler = createReconciler({ bufferDir, logger });
   reconciler.runStartupReconciliation();
@@ -8083,6 +8239,7 @@ async function main() {
   server.registerRoute("PUT", "/api/config", async (req) => {
     const result = await handlePutConfig(vaultDir, req.body);
     if (!result.status || result.status < 400) {
+      reconcileConfiguredSymbionts(path22.dirname(vaultDir), vaultDir);
       configHash = computeConfigHash(vaultDir);
     }
     return result;
@@ -8099,10 +8256,19 @@ async function main() {
     planWatchConfig,
     setPlanWatchConfig: (cfg) => {
       planWatchConfig = cfg;
+    },
+    reconcileProjectFiles: () => {
+      reconcileConfiguredSymbionts(path22.dirname(vaultDir), vaultDir);
     }
   });
   server.registerRoute("GET", "/api/config/plan-dirs", planDirHandlers.handleGetPlanDirs);
-  server.registerRoute("POST", "/api/config/plan-dirs", planDirHandlers.handleUpdatePlanDirs);
+  server.registerRoute("POST", "/api/config/plan-dirs", async (req) => {
+    const result = await planDirHandlers.handleUpdatePlanDirs(req);
+    if (!result.status || result.status < 400) {
+      configHash = computeConfigHash(vaultDir);
+    }
+    return result;
+  });
   const configHashRef = { get: () => configHash };
   server.registerRoute("GET", "/api/stats", createLiveStatsHandler({
     vaultDir,
@@ -8117,7 +8283,7 @@ async function main() {
   server.registerRoute("POST", "/api/log", createLogIngestionHandler(logger));
   server.registerRoute("GET", "/api/models", async (req) => handleGetModels(req));
   server.registerRoute("POST", "/api/restart", async (req) => handleRestart({ vaultDir, progressTracker }, req.body));
-  const updateProjectRoot = path21.dirname(vaultDir);
+  const updateProjectRoot = path22.dirname(vaultDir);
   const updateHandlers = createUpdateHandlers({
     vaultDir,
     projectRoot: updateProjectRoot,
@@ -8154,6 +8320,7 @@ async function main() {
   server.registerRoute("GET", "/api/spores", handleListSpores);
   server.registerRoute("GET", "/api/spores/:id", handleGetSpore);
   server.registerRoute("GET", "/api/entities", handleListEntities);
+  server.registerRoute("GET", "/api/graph/seeds", handleGetGraphSeeds);
   server.registerRoute("GET", "/api/graph", handleGetFullGraph);
   server.registerRoute("GET", "/api/graph/:id", handleGetGraph);
   server.registerRoute("GET", "/api/digest", handleGetDigest);
@@ -8183,7 +8350,7 @@ async function main() {
   server.registerRoute("GET", "/api/mcp/sessions", mcpProxy.handleSessions);
   server.registerRoute("GET", "/api/mcp/team", mcpProxy.handleTeam);
   const rawBackupDir = config.backup.dir;
-  const backupDir = rawBackupDir ? path21.resolve(rawBackupDir.startsWith("~/") ? path21.join(os8.homedir(), rawBackupDir.slice(2)) : rawBackupDir) : path21.resolve(vaultDir, "backups");
+  const backupDir = rawBackupDir ? path22.resolve(rawBackupDir.startsWith("~/") ? path22.join(os8.homedir(), rawBackupDir.slice(2)) : rawBackupDir) : path22.resolve(vaultDir, "backups");
   const backupHandlers = createBackupHandlers({ db, backupDir, machineId });
   server.registerRoute("POST", "/api/backup", backupHandlers.handleCreateBackup);
   server.registerRoute("GET", "/api/backups", backupHandlers.handleListBackups);
@@ -8287,4 +8454,4 @@ export {
   handleUserPrompt,
   main
 };
-//# sourceMappingURL=main-EVS3FXDJ.js.map
+//# sourceMappingURL=main-RPJSS7PT.js.map