@goondocks/myco 0.5.1 → 0.6.1

package/dist/{main-NFQ4II75.js → main-JEUQS3BY.js}

@@ -4,14 +4,24 @@ import {
   TranscriptMiner,
   extractTurnsFromBuffer,
   writeObservationNotes
-} from "./chunk-R6LQT3U7.js";
+} from "./chunk-B5UZSHQV.js";
+import {
+  gatherStats
+} from "./chunk-ZMYNRTTD.js";
 import {
   DigestEngine,
-  Metabolism
-} from "./chunk-HL2S5QZG.js";
+  Metabolism,
+  appendTraceRecord,
+  readLastTimestamp,
+  runCuration,
+  runDigest,
+  runRebuild
+} from "./chunk-2ZBB3MQT.js";
+import "./chunk-3JCXYLHD.js";
 import {
+  consolidateSpores,
   handleMycoContext
-} from "./chunk-IURC35BF.js";
+} from "./chunk-KUMVJIJW.js";
 import {
   VaultWriter,
   bareSessionId,
@@ -19,60 +29,72 @@ import {
   sessionNoteId,
   sessionRelativePath,
   sessionWikilink
-} from "./chunk-6LTNFMXO.js";
+} from "./chunk-KC7ENQTN.js";
 import {
   DaemonLogger
-} from "./chunk-5EZ7QF6J.js";
+} from "./chunk-QLUE3BUL.js";
+import {
+  VectorIndex
+} from "./chunk-4RMSHZE4.js";
 import {
-  checkSupersession
-} from "./chunk-FIA5NTRH.js";
+  checkSupersession,
+  isActiveSpore
+} from "./chunk-UVGAVYWZ.js";
 import {
+  buildSimilarityPrompt,
+  extractNumber,
+  formatNotesForPrompt,
   indexNote,
-  rebuildIndex
-} from "./chunk-JJL6AMDA.js";
+  loadPrompt,
+  rebuildIndex,
+  stripReasoningTokens
+} from "./chunk-24DOZEUJ.js";
 import {
   generateEmbedding
 } from "./chunk-RGVBGTD6.js";
-import {
-  VectorIndex
-} from "./chunk-XQXXF6MU.js";
-import {
-  buildSimilarityPrompt,
-  extractNumber
-} from "./chunk-KYL67SKZ.js";
-import "./chunk-2AMAOSRF.js";
 import {
   createEmbeddingProvider,
   createLlmProvider
-} from "./chunk-RCV2I4AI.js";
-import "./chunk-MIU3DKLN.js";
+} from "./chunk-GDYYJTTT.js";
+import "./chunk-GNR3QAER.js";
 import {
   initFts
 } from "./chunk-6FQISQNA.js";
 import {
   MycoIndex
-} from "./chunk-AK6GNLPV.js";
-import "./chunk-JI6M2L2W.js";
+} from "./chunk-TWSTAVLO.js";
+import "./chunk-2YBUL3IL.js";
+import "./chunk-SAKJMNSR.js";
 import {
-  loadConfig
-} from "./chunk-TBRZAJ7W.js";
+  LmStudioBackend,
+  OllamaBackend
+} from "./chunk-QGJ2ZIUZ.js";
 import {
+  CONFIG_FILENAME,
+  loadConfig,
+  saveConfig
+} from "./chunk-P3WO3N3I.js";
+import {
+  MycoConfigSchema,
   external_exports,
   require_dist
-} from "./chunk-6UJWI4IW.js";
+} from "./chunk-MQSYSQ6T.js";
 import {
   EventBuffer
 } from "./chunk-HIN3UVOG.js";
 import {
   getPluginVersion
-} from "./chunk-7KQB22DP.js";
+} from "./chunk-E7OBRBCQ.js";
 import {
   claudeCodeAdapter,
   createPerProjectAdapter,
   extensionForMimeType
-} from "./chunk-X6TKHO22.js";
+} from "./chunk-5QWZT4AB.js";
 import {
   CANDIDATE_CONTENT_PREVIEW,
+  CONSOLIDATION_MAX_TOKENS,
+  CONSOLIDATION_MIN_CLUSTER_SIZE,
+  CONSOLIDATION_VECTOR_FETCH_LIMIT,
   CONTENT_SNIPPET_CHARS,
   CONTEXT_SESSION_PREVIEW_CHARS,
   EMBEDDING_INPUT_LIMIT,
@@ -86,40 +108,138 @@ import {
   RELATED_SPORES_LIMIT,
   SESSION_CONTEXT_MAX_PLANS,
   STALE_BUFFER_MAX_AGE_MS
-} from "./chunk-B6WVNDA5.js";
+} from "./chunk-6BSDCZ5Q.js";
 import {
   __toESM
 } from "./chunk-PZUWP5VK.js";
 
 // src/daemon/server.ts
 import http from "http";
+import fs2 from "fs";
+import path2 from "path";
+
+// src/daemon/router.ts
+var Router = class {
+  routes = [];
+  add(method, pattern, handler) {
+    const type = pattern.includes(":") ? "param" : pattern.endsWith("/*") ? "prefix" : "exact";
+    const segments = type === "param" ? pattern.split("/") : void 0;
+    this.routes.push({ method, pattern, handler, type, segments });
+  }
+  /**
+   * Match a request against registered routes.
+   * Priority: exact > parameterized > prefix. Within parameterized routes,
+   * first-registered wins if multiple patterns match at the same depth.
+   */
+  match(method, rawUrl) {
+    const url = new URL(rawUrl, "http://localhost");
+    const pathname = url.pathname;
+    const query = {};
+    url.searchParams.forEach((v, k) => {
+      query[k] = v;
+    });
+    let paramMatch;
+    let prefixMatch;
+    for (const route of this.routes) {
+      if (route.method !== method) continue;
+      if (route.type === "exact" && route.pattern === pathname) {
+        return { handler: route.handler, params: {}, query, pathname };
+      }
+      if (route.type === "param" && !paramMatch && route.segments) {
+        const parts = pathname.split("/");
+        if (parts.length === route.segments.length) {
+          const params = {};
+          let matched = true;
+          for (let i = 0; i < route.segments.length; i++) {
+            if (route.segments[i].startsWith(":")) {
+              params[route.segments[i].slice(1)] = parts[i];
+            } else if (route.segments[i] !== parts[i]) {
+              matched = false;
+              break;
+            }
+          }
+          if (matched) {
+            paramMatch = { handler: route.handler, params, query, pathname };
+          }
+        }
+      }
+      if (route.type === "prefix" && !prefixMatch) {
+        const prefix = route.pattern.slice(0, -1);
+        if (pathname.startsWith(prefix)) {
+          prefixMatch = { handler: route.handler, params: {}, query, pathname };
+        }
+      }
+    }
+    return paramMatch ?? prefixMatch;
+  }
+};
+
+// src/daemon/static.ts
 import fs from "fs";
 import path from "path";
+var HASHED_ASSET_PREFIX = "/assets/";
+var IMMUTABLE_CACHE = "public, max-age=31536000, immutable";
+var NO_CACHE = "no-cache";
+var MIME_TYPES = {
+  ".html": "text/html",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf"
+};
+function resolveStaticFile(uiDir, pathname) {
+  const relative3 = pathname.startsWith("/") ? pathname.slice(1) : pathname;
+  const resolved = path.resolve(uiDir, relative3 || "index.html");
+  if (!resolved.startsWith(path.resolve(uiDir))) {
+    return void 0;
+  }
+  if (fs.existsSync(resolved) && fs.statSync(resolved).isFile()) {
+    const ext = path.extname(resolved);
+    const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
+    const cacheControl = pathname.startsWith(HASHED_ASSET_PREFIX) ? IMMUTABLE_CACHE : NO_CACHE;
+    return { filePath: resolved, contentType, cacheControl };
+  }
+  const indexPath = path.join(uiDir, "index.html");
+  if (fs.existsSync(indexPath)) {
+    return { filePath: indexPath, contentType: "text/html", cacheControl: NO_CACHE };
+  }
+  return void 0;
+}
+
+// src/daemon/server.ts
+var DEFAULT_STATUS = 200;
 var DaemonServer = class {
   port = 0;
   version;
+  uiDir;
   server = null;
   vaultDir;
   logger;
-  routes = /* @__PURE__ */ new Map();
+  router = new Router();
   constructor(config) {
     this.vaultDir = config.vaultDir;
     this.logger = config.logger;
+    this.uiDir = config.uiDir ?? null;
     this.version = getPluginVersion();
     this.registerDefaultRoutes();
   }
   registerRoute(method, routePath, handler) {
-    this.routes.set(`${method} ${routePath}`, { method, handler });
+    this.router.add(method, routePath, handler);
   }
-  async start() {
+  async start(port = 0) {
     return new Promise((resolve3, reject) => {
       this.server = http.createServer((req, res) => this.handleRequest(req, res));
       this.server.on("error", reject);
-      this.server.listen(0, "127.0.0.1", () => {
+      this.server.listen(port, "127.0.0.1", () => {
         const addr = this.server.address();
         this.port = addr.port;
         this.writeDaemonJson();
-        this.logger.info("daemon", "Server started", { port: this.port });
+        this.logger.info("daemon", "Server started", { port: this.port, dashboard: `http://localhost:${this.port}/` });
         resolve3();
       });
     });
@@ -139,40 +259,66 @@ var DaemonServer = class {
   }
   registerDefaultRoutes() {
     this.registerRoute("GET", "/health", async () => ({
-      myco: true,
-      version: this.version,
-      pid: process.pid,
-      uptime: process.uptime()
+      body: {
+        myco: true,
+        version: this.version,
+        pid: process.pid,
+        uptime: process.uptime()
+      }
     }));
   }
   async handleRequest(req, res) {
-    const key = `${req.method} ${req.url}`;
-    const route = this.routes.get(key);
-    if (!route) {
-      res.writeHead(404, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ error: "not found" }));
+    const match = this.router.match(req.method, req.url);
+    if (match) {
+      try {
+        const body = req.method === "POST" || req.method === "PUT" ? await readBody(req) : void 0;
+        const result = await match.handler({
+          body,
+          query: match.query,
+          params: match.params,
+          pathname: match.pathname
+        });
+        const status = result.status ?? DEFAULT_STATUS;
+        const headers = { "Content-Type": "application/json", ...result.headers };
+        res.writeHead(status, headers);
+        res.end(JSON.stringify(result.body));
+      } catch (error) {
+        this.logger.error("daemon", "Request handler error", {
+          path: req.url,
+          error: error.message
+        });
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: error.message }));
+      }
       return;
     }
-    try {
-      const body = req.method === "POST" ? await readBody(req) : void 0;
-      const result = await route.handler(body);
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify(result));
-    } catch (error) {
-      this.logger.error("daemon", "Request handler error", {
-        path: req.url,
-        error: error.message
-      });
-      res.writeHead(500, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ error: error.message }));
+    if (this.uiDir && req.method === "GET") {
+      const pathname = new URL(req.url, "http://localhost").pathname;
+      const result = resolveStaticFile(this.uiDir, pathname);
+      if (result) {
+        try {
+          const content = await fs2.promises.readFile(result.filePath);
+          res.writeHead(200, {
+            "Content-Type": result.contentType,
+            "Cache-Control": result.cacheControl
+          });
+          res.end(content);
+        } catch {
+          res.writeHead(404, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "not found" }));
+        }
+        return;
+      }
     }
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "not found" }));
   }
   updateDaemonJsonSessions(sessions) {
-    const jsonPath = path.join(this.vaultDir, "daemon.json");
+    const jsonPath = path2.join(this.vaultDir, "daemon.json");
     try {
-      const info = JSON.parse(fs.readFileSync(jsonPath, "utf-8"));
+      const info = JSON.parse(fs2.readFileSync(jsonPath, "utf-8"));
       info.sessions = sessions;
-      fs.writeFileSync(jsonPath, JSON.stringify(info, null, 2));
+      fs2.writeFileSync(jsonPath, JSON.stringify(info, null, 2));
     } catch {
     }
   }
@@ -183,13 +329,13 @@ var DaemonServer = class {
       started: (/* @__PURE__ */ new Date()).toISOString(),
       sessions: []
     };
-    const jsonPath = path.join(this.vaultDir, "daemon.json");
-    fs.writeFileSync(jsonPath, JSON.stringify(info, null, 2));
+    const jsonPath = path2.join(this.vaultDir, "daemon.json");
+    fs2.writeFileSync(jsonPath, JSON.stringify(info, null, 2));
   }
   removeDaemonJson() {
-    const jsonPath = path.join(this.vaultDir, "daemon.json");
+    const jsonPath = path2.join(this.vaultDir, "daemon.json");
     try {
-      fs.unlinkSync(jsonPath);
+      fs2.unlinkSync(jsonPath);
     } catch {
     }
   }
@@ -299,8 +445,8 @@ var BatchManager = class {
 };
 
 // src/daemon/lineage.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import path3 from "path";
 var LINEAGE_IMMEDIATE_GAP_SECONDS = 5;
 var LINEAGE_FALLBACK_MAX_HOURS = 24;
 var LINEAGE_SIMILARITY_THRESHOLD = 0.7;
@@ -313,8 +459,8 @@ var LineageGraph = class {
   state;
   filePath;
   constructor(vaultDir) {
-    this.filePath = path2.join(vaultDir, "lineage.json");
-    fs2.mkdirSync(path2.dirname(this.filePath), { recursive: true });
+    this.filePath = path3.join(vaultDir, "lineage.json");
+    fs3.mkdirSync(path3.dirname(this.filePath), { recursive: true });
     this.state = this.load();
   }
   addLink(link) {
@@ -394,7 +540,7 @@ var LineageGraph = class {
   }
   load() {
     try {
-      const raw = JSON.parse(fs2.readFileSync(this.filePath, "utf-8"));
+      const raw = JSON.parse(fs3.readFileSync(this.filePath, "utf-8"));
       const sessionArtifacts = raw.sessionArtifacts ?? raw.sessionPlans ?? {};
       return { links: raw.links ?? [], sessionArtifacts };
     } catch {
@@ -403,8 +549,8 @@ var LineageGraph = class {
   }
   persist() {
     const tmp = this.filePath + ".tmp";
-    fs2.writeFileSync(tmp, JSON.stringify(this.state, null, 2));
-    fs2.renameSync(tmp, this.filePath);
+    fs3.writeFileSync(tmp, JSON.stringify(this.state, null, 2));
+    fs3.renameSync(tmp, this.filePath);
   }
 };
 
@@ -498,7 +644,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path7) => statMethod(path7, { bigint: true });
+      this._stat = (path10) => statMethod(path10, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -523,8 +669,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path7, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path7));
+          const { path: path10, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path10));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -564,20 +710,20 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path7, depth) {
+  async _exploreDir(path10, depth) {
     let files;
     try {
-      files = await readdir(path7, this._rdOptions);
+      files = await readdir(path10, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path7 };
+    return { files, depth, path: path10 };
   }
-  async _formatEntry(dirent, path7) {
+  async _formatEntry(dirent, path10) {
     let entry;
     const basename3 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path7, basename3));
+      const fullPath = presolve(pjoin(path10, basename3));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename3 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -977,16 +1123,16 @@ var delFromSet = (main2, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path7, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path10, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path7);
-    emitRaw(rawEvent, evPath, { watchedPath: path7 });
-    if (evPath && path7 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path7, evPath), KEY_LISTENERS, sp.join(path7, evPath));
+    listener(path10);
+    emitRaw(rawEvent, evPath, { watchedPath: path10 });
+    if (evPath && path10 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path10, evPath), KEY_LISTENERS, sp.join(path10, evPath));
     }
   };
   try {
-    return fs_watch(path7, {
+    return fs_watch(path10, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -1002,12 +1148,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path7, fullPath, options, handlers) => {
+var setFsWatchListener = (path10, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path7, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path10, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -1018,7 +1164,7 @@ var setFsWatchListener = (path7, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path7,
+      path10,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -1033,7 +1179,7 @@ var setFsWatchListener = (path7, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path7, "r");
+          const fd = await open(path10, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -1064,7 +1210,7 @@ var setFsWatchListener = (path7, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path7, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path10, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -1086,7 +1232,7 @@ var setFsWatchFileListener = (path7, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path7, curr));
+          foreach(cont.listeners, (listener2) => listener2(path10, curr));
         }
       })
     };
@@ -1116,13 +1262,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path7, listener) {
+  _watchWithNodeFs(path10, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path7);
-    const basename3 = sp.basename(path7);
+    const directory = sp.dirname(path10);
+    const basename3 = sp.basename(path10);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename3);
-    const absolutePath = sp.resolve(path7);
+    const absolutePath = sp.resolve(path10);
     const options = {
       persistent: opts.persistent
     };
@@ -1132,12 +1278,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename3) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path7, absolutePath, options, {
+      closer = setFsWatchFileListener(path10, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path7, absolutePath, options, {
+      closer = setFsWatchListener(path10, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -1159,7 +1305,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename3))
       return;
-    const listener = async (path7, newStats) => {
+    const listener = async (path10, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -1173,11 +1319,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path7);
+            this.fsw._closeFile(path10);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path7, closer2);
+              this.fsw._addPathCloser(path10, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -1209,7 +1355,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path7, item) {
+  async _handleSymlink(entry, directory, path10, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -1219,7 +1365,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path7);
+        linkPath = await fsrealpath(path10);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -1229,12 +1375,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path7, entry.stats);
+          this.fsw._emit(EV.CHANGE, path10, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path7, entry.stats);
+        this.fsw._emit(EV.ADD, path10, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -1264,9 +1410,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path7 = sp.join(directory, item);
+      let path10 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path7, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path10, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -1275,8 +1421,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path7 = sp.join(dir, sp.relative(dir, path7));
-        this._addToNodeFs(path7, initialAdd, wh, depth + 1);
+        path10 = sp.join(dir, sp.relative(dir, path10));
+        this._addToNodeFs(path10, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve3, reject) => {
@@ -1345,13 +1491,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path7, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path10, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path7) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path10) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path7);
+    const wh = this.fsw._getWatchHelpers(path10);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -1367,8 +1513,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path7);
-        const targetPath = follow ? await fsrealpath(path7) : path7;
+        const absPath = sp.resolve(path10);
+        const targetPath = follow ? await fsrealpath(path10) : path10;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -1378,29 +1524,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path7) : path7;
+        const targetPath = follow ? await fsrealpath(path10) : path10;
         if (this.fsw.closed)
           return;
         const parent = sp.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path7, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path10, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path7), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path10), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path7, closer);
+        this.fsw._addPathCloser(path10, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path7;
+        return path10;
       }
     }
   }
@@ -1443,24 +1589,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path7) {
-  if (typeof path7 !== "string")
+function normalizePath(path10) {
+  if (typeof path10 !== "string")
     throw new Error("string expected");
-  path7 = sp2.normalize(path7);
-  path7 = path7.replace(/\\/g, "/");
+  path10 = sp2.normalize(path10);
+  path10 = path10.replace(/\\/g, "/");
   let prepend = false;
-  if (path7.startsWith("//"))
+  if (path10.startsWith("//"))
     prepend = true;
-  path7 = path7.replace(DOUBLE_SLASH_RE, "/");
+  path10 = path10.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path7 = "/" + path7;
-  return path7;
+    path10 = "/" + path10;
+  return path10;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path7 = normalizePath(testString);
+  const path10 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path7, stats)) {
+    if (pattern(path10, stats)) {
       return true;
     }
   }
@@ -1498,19 +1644,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path7) => toUnix(sp2.normalize(toUnix(path7)));
-var normalizeIgnored = (cwd = "") => (path7) => {
-  if (typeof path7 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path7) ? path7 : sp2.join(cwd, path7));
+var normalizePathToUnix = (path10) => toUnix(sp2.normalize(toUnix(path10)));
+var normalizeIgnored = (cwd = "") => (path10) => {
+  if (typeof path10 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path10) ? path10 : sp2.join(cwd, path10));
   } else {
-    return path7;
+    return path10;
   }
 };
-var getAbsolutePath = (path7, cwd) => {
-  if (sp2.isAbsolute(path7)) {
-    return path7;
+var getAbsolutePath = (path10, cwd) => {
+  if (sp2.isAbsolute(path10)) {
+    return path10;
   }
-  return sp2.join(cwd, path7);
+  return sp2.join(cwd, path10);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -1575,10 +1721,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path7, follow, fsw) {
+  constructor(path10, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path7;
-    this.path = path7 = path7.replace(REPLACER_RE, "");
+    const watchPath = path10;
+    this.path = path10 = path10.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -1718,20 +1864,20 @@ var FSWatcher = class extends EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path7) => {
-        const absPath = getAbsolutePath(path7, cwd);
+      paths = paths.map((path10) => {
+        const absPath = getAbsolutePath(path10, cwd);
         return absPath;
       });
     }
-    paths.forEach((path7) => {
-      this._removeIgnoredPath(path7);
+    paths.forEach((path10) => {
+      this._removeIgnoredPath(path10);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path7) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path7, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path10) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path10, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -1753,17 +1899,17 @@ var FSWatcher = class extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path7) => {
-      if (!sp2.isAbsolute(path7) && !this._closers.has(path7)) {
+    paths.forEach((path10) => {
+      if (!sp2.isAbsolute(path10) && !this._closers.has(path10)) {
         if (cwd)
-          path7 = sp2.join(cwd, path7);
-        path7 = sp2.resolve(path7);
+          path10 = sp2.join(cwd, path10);
+        path10 = sp2.resolve(path10);
       }
-      this._closePath(path7);
-      this._addIgnoredPath(path7);
-      if (this._watched.has(path7)) {
+      this._closePath(path10);
+      this._addIgnoredPath(path10);
+      if (this._watched.has(path10)) {
         this._addIgnoredPath({
-          path: path7,
+          path: path10,
           recursive: true
         });
       }
@@ -1827,38 +1973,38 @@ var FSWatcher = class extends EventEmitter {
    * @param stats arguments to be passed with event
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
-  async _emit(event, path7, stats) {
+  async _emit(event, path10, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path7 = sp2.normalize(path7);
+      path10 = sp2.normalize(path10);
     if (opts.cwd)
-      path7 = sp2.relative(opts.cwd, path7);
-    const args = [path7];
+      path10 = sp2.relative(opts.cwd, path10);
+    const args = [path10];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path7))) {
+    if (awf && (pw = this._pendingWrites.get(path10))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path7, [event, ...args]);
+        this._pendingUnlinks.set(path10, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path8) => {
+          this._pendingUnlinks.forEach((entry, path11) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path8);
+            this._pendingUnlinks.delete(path11);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path7)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path10)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path7);
+        this._pendingUnlinks.delete(path10);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -1876,16 +2022,16 @@ var FSWatcher = class extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path7, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path10, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path7, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path10, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sp2.join(opts.cwd, path7) : path7;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path10) : path10;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -1916,23 +2062,23 @@ var FSWatcher = class extends EventEmitter {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path7, timeout) {
+  _throttle(actionType, path10, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, /* @__PURE__ */ new Map());
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path7);
+    const actionPath = action.get(path10);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path7);
+      const item = action.get(path10);
       const count = item ? item.count : 0;
-      action.delete(path7);
+      action.delete(path10);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -1940,7 +2086,7 @@ var FSWatcher = class extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path7, thr);
+    action.set(path10, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -1954,44 +2100,44 @@ var FSWatcher = class extends EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path7, threshold, event, awfEmit) {
+  _awaitWriteFinish(path10, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path7;
-    if (this.options.cwd && !sp2.isAbsolute(path7)) {
-      fullPath = sp2.join(this.options.cwd, path7);
+    let fullPath = path10;
+    if (this.options.cwd && !sp2.isAbsolute(path10)) {
+      fullPath = sp2.join(this.options.cwd, path10);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path7)) {
+        if (err || !writes.has(path10)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path7).lastChange = now2;
+          writes.get(path10).lastChange = now2;
         }
-        const pw = writes.get(path7);
+        const pw = writes.get(path10);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path7);
+          writes.delete(path10);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path7)) {
-      writes.set(path7, {
+    if (!writes.has(path10)) {
+      writes.set(path10, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path7);
+          writes.delete(path10);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -2002,8 +2148,8 @@ var FSWatcher = class extends EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path7, stats) {
-    if (this.options.atomic && DOT_RE.test(path7))
+  _isIgnored(path10, stats) {
+    if (this.options.atomic && DOT_RE.test(path10))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -2013,17 +2159,17 @@ var FSWatcher = class extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path7, stats);
+    return this._userIgnored(path10, stats);
   }
-  _isntIgnored(path7, stat4) {
-    return !this._isIgnored(path7, stat4);
+  _isntIgnored(path10, stat4) {
+    return !this._isIgnored(path10, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path7) {
-    return new WatchHelper(path7, this.options.followSymlinks, this);
+  _getWatchHelpers(path10) {
+    return new WatchHelper(path10, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -2055,63 +2201,63 @@ var FSWatcher = class extends EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path7 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path7);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path7) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path7, 100))
+    const path10 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path10);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path10) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path10, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path7);
+    const wp = this._getWatchedDir(path10);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path7, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path10, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path7;
+    let relPath = path10;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path7);
+      relPath = sp2.relative(this.options.cwd, path10);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path7);
+    this._watched.delete(path10);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path7))
-      this._emit(eventName, path7);
-    this._closePath(path7);
+    if (wasTracked && !this._isIgnored(path10))
+      this._emit(eventName, path10);
+    this._closePath(path10);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path7) {
-    this._closeFile(path7);
-    const dir = sp2.dirname(path7);
-    this._getWatchedDir(dir).remove(sp2.basename(path7));
+  _closePath(path10) {
+    this._closeFile(path10);
+    const dir = sp2.dirname(path10);
+    this._getWatchedDir(dir).remove(sp2.basename(path10));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path7) {
-    const closers = this._closers.get(path7);
+  _closeFile(path10) {
+    const closers = this._closers.get(path10);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path7);
+    this._closers.delete(path10);
   }
-  _addPathCloser(path7, closer) {
+  _addPathCloser(path10, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path7);
+    let list = this._closers.get(path10);
     if (!list) {
       list = [];
-      this._closers.set(path7, list);
+      this._closers.set(path10, list);
     }
     list.push(closer);
   }
@@ -2140,7 +2286,7 @@ function watch(paths, options = {}) {
 }
 
 // src/daemon/watcher.ts
-import path3 from "path";
+import path4 from "path";
 var PlanWatcher = class {
   config;
   fsWatcher = null;
@@ -2166,7 +2312,7 @@ var PlanWatcher = class {
           source: "tool",
           filePath,
           sessionId: event.session_id,
-          detail: `${event.tool_name} on plan file: ${path3.basename(filePath)}`,
+          detail: `${event.tool_name} on plan file: ${path4.basename(filePath)}`,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
       }
@@ -2174,7 +2320,7 @@ var PlanWatcher = class {
   }
   startFileWatcher() {
     const absPaths = this.config.watchPaths.map(
-      (p) => path3.resolve(this.config.projectRoot, p)
+      (p) => path4.resolve(this.config.projectRoot, p)
     );
     this.fsWatcher = watch(absPaths, {
       ignoreInitial: true,
@@ -2190,7 +2336,7 @@ var PlanWatcher = class {
     this.fsWatcher = null;
   }
   onFileChange(absolutePath, action) {
-    const rel = path3.relative(this.config.projectRoot, absolutePath);
+    const rel = path4.relative(this.config.projectRoot, absolutePath);
     this.knownPlans.add(absolutePath);
     this.config.onPlan({
       source: "filesystem",
@@ -2200,17 +2346,299 @@ var PlanWatcher = class {
     });
   }
   isInPlanDirectory(filePath) {
-    const abs = path3.isAbsolute(filePath) ? filePath : path3.resolve(this.config.projectRoot, filePath);
+    const abs = path4.isAbsolute(filePath) ? filePath : path4.resolve(this.config.projectRoot, filePath);
     return this.config.watchPaths.some(
-      (wp) => abs.startsWith(path3.resolve(this.config.projectRoot, wp))
+      (wp) => abs.startsWith(path4.resolve(this.config.projectRoot, wp))
     );
   }
 };
 
+// src/daemon/consolidation.ts
+import path5 from "path";
+var consolidationResponseSchema = external_exports.discriminatedUnion("consolidate", [
+  external_exports.object({ consolidate: external_exports.literal(false), reason: external_exports.string().optional() }),
+  external_exports.object({
+    consolidate: external_exports.literal(true),
+    title: external_exports.string(),
+    content: external_exports.string(),
+    source_ids: external_exports.array(external_exports.string()),
+    tags: external_exports.array(external_exports.string()).optional()
+  })
+]);
+var CONSOLIDATION_TRACE_FILENAME = "consolidation-trace.jsonl";
+var ConsolidationEngine = class {
+  deps;
+  log;
+  lastTimestampCache = void 0;
+  constructor(config) {
+    this.deps = {
+      vaultDir: config.vaultDir,
+      index: config.index,
+      vectorIndex: config.vectorIndex,
+      llmProvider: config.llmProvider,
+      embeddingProvider: config.embeddingProvider
+    };
+    this.log = config.log ?? (() => {
+    });
+  }
+  /**
+   * Read the timestamp of the last consolidation pass from the trace file.
+   * Cached in memory after first read — subsequent calls are O(1).
+   */
+  getLastTimestamp() {
+    if (this.lastTimestampCache !== void 0) return this.lastTimestampCache;
+    const tracePath = path5.join(this.deps.vaultDir, "digest", CONSOLIDATION_TRACE_FILENAME);
+    this.lastTimestampCache = readLastTimestamp(tracePath);
+    return this.lastTimestampCache;
+  }
+  /**
+   * Append a consolidation pass result as a JSON line to the trace file.
+   * Updates the in-memory timestamp cache.
+   */
+  appendTrace(record) {
+    const tracePath = path5.join(this.deps.vaultDir, "digest", CONSOLIDATION_TRACE_FILENAME);
+    appendTraceRecord(tracePath, record);
+    this.lastTimestampCache = record.timestamp;
+  }
+  /**
+   * Run one consolidation pass.
+   *
+   * Algorithm:
+   * 1. Early-exit if vectorIndex or llmProvider is absent.
+   * 2. Query index for spores created since lastTimestamp.
+   * 3. Filter for active spores.
+   * 4. For each new spore (skip if already processed):
+   *    a. Embed it.
+   *    b. Vector-search for similar spores.
+   *    c. Fetch candidate notes; filter same-type + active + not-processed.
+   *    d. Include trigger spore in cluster if not already present.
+   *    e. Skip if cluster < CONSOLIDATION_MIN_CLUSTER_SIZE.
+   *    f. Ask LLM whether to consolidate.
+   *    g. If approved, call consolidateSpores(); track counts.
+   *    h. Mark cluster members as processed regardless of outcome.
+   * 5. Append trace record, return result.
+   *
+   * Returns null if no new spores were found or dependencies are absent.
+   */
+  async runPass() {
+    const { vaultDir, index, vectorIndex, llmProvider, embeddingProvider } = this.deps;
+    if (!vectorIndex || !llmProvider || !embeddingProvider) {
+      this.log("debug", "ConsolidationEngine: skipped \u2014 vectorIndex, llmProvider, or embeddingProvider unavailable");
+      return null;
+    }
+    const startTime = Date.now();
+    const lastTimestamp = this.getLastTimestamp();
+    const allSpores = index.query({ type: "spore", since: lastTimestamp ?? void 0 });
+    const newSpores = allSpores.filter((n) => isActiveSpore(n.frontmatter));
+    this.log("debug", "ConsolidationEngine: spores to check", {
+      count: newSpores.length,
+      lastTimestamp: lastTimestamp ?? "never"
+    });
+    if (newSpores.length === 0) {
+      return null;
+    }
+    const processedIds = /* @__PURE__ */ new Set();
+    let clustersFound = 0;
+    let consolidated = 0;
+    let sporesSuperseded = 0;
+    const template = loadPrompt("consolidation");
+    for (const triggerSpore of newSpores) {
+      if (processedIds.has(triggerSpore.id)) continue;
+      const observationType = triggerSpore.frontmatter["observation_type"];
+      let embedding;
+      const storedEmbedding = vectorIndex.getEmbedding(triggerSpore.id);
+      if (storedEmbedding) {
+        embedding = storedEmbedding;
+      } else {
+        try {
+          const embeddingText = triggerSpore.content.slice(0, EMBEDDING_INPUT_LIMIT);
+          const result = await generateEmbedding(embeddingProvider, embeddingText);
+          embedding = result.embedding;
+        } catch (err) {
+          this.log("warn", "ConsolidationEngine: embedding failed", { id: triggerSpore.id, error: String(err) });
+          processedIds.add(triggerSpore.id);
+          continue;
+        }
+      }
+      const vectorResults = vectorIndex.search(embedding, {
+        type: "spore",
+        limit: CONSOLIDATION_VECTOR_FETCH_LIMIT
+      });
+      if (vectorResults.length === 0) {
+        processedIds.add(triggerSpore.id);
+        continue;
+      }
+      const candidateIds = vectorResults.map((r) => r.id);
+      const candidateNotes = index.queryByIds(candidateIds);
+      const filtered = candidateNotes.filter((note) => {
+        if (processedIds.has(note.id)) return false;
+        if (!isActiveSpore(note.frontmatter)) return false;
+        if (observationType && note.frontmatter["observation_type"] !== observationType) return false;
+        return true;
+      });
+      const clusterMap = new Map(filtered.map((n) => [n.id, n]));
+      if (!clusterMap.has(triggerSpore.id)) {
+        clusterMap.set(triggerSpore.id, triggerSpore);
+      }
+      const cluster = Array.from(clusterMap.values());
+      if (cluster.length < CONSOLIDATION_MIN_CLUSTER_SIZE) {
+        this.log("debug", "ConsolidationEngine: cluster too small \u2014 skipping", {
+          triggerId: triggerSpore.id,
+          clusterSize: cluster.length,
+          minRequired: CONSOLIDATION_MIN_CLUSTER_SIZE
+        });
+        cluster.forEach((n) => processedIds.add(n.id));
+        continue;
+      }
+      clustersFound++;
+      const candidatesText = formatNotesForPrompt(cluster);
+      const prompt = template.replace("{{count}}", String(cluster.length)).replace("{{observation_type}}", observationType ?? "unknown").replace("{{candidates}}", candidatesText);
+      let responseText;
+      try {
+        const response = await llmProvider.summarize(prompt, {
+          maxTokens: CONSOLIDATION_MAX_TOKENS,
+          reasoning: LLM_REASONING_MODE
+        });
+        responseText = stripReasoningTokens(response.text);
+      } catch (err) {
+        this.log("warn", "ConsolidationEngine: LLM call failed", {
+          triggerId: triggerSpore.id,
+          error: String(err)
+        });
+        cluster.forEach((n) => processedIds.add(n.id));
+        continue;
+      }
+      let parsed;
+      try {
+        const raw = JSON.parse(responseText);
+        const result = consolidationResponseSchema.safeParse(raw);
+        if (!result.success) {
+          this.log("warn", "ConsolidationEngine: LLM response failed schema validation", {
+            triggerId: triggerSpore.id,
+            responseText
+          });
+          cluster.forEach((n) => processedIds.add(n.id));
+          continue;
+        }
+        parsed = result.data;
+      } catch {
+        this.log("warn", "ConsolidationEngine: failed to parse LLM response", {
+          triggerId: triggerSpore.id,
+          responseText
+        });
+        cluster.forEach((n) => processedIds.add(n.id));
+        continue;
+      }
+      if (!parsed.consolidate) {
+        this.log("debug", "ConsolidationEngine: LLM declined to consolidate", {
+          triggerId: triggerSpore.id,
+          reason: parsed.reason
+        });
+        cluster.forEach((n) => processedIds.add(n.id));
+        continue;
+      }
+      const clusterIdSet = new Set(cluster.map((n) => n.id));
+      const validSourceIds = parsed.source_ids.filter((id) => clusterIdSet.has(id));
+      if (validSourceIds.length < CONSOLIDATION_MIN_CLUSTER_SIZE) {
+        this.log("warn", "ConsolidationEngine: insufficient valid source_ids after validation", {
+          triggerId: triggerSpore.id,
+          sourceIds: parsed.source_ids,
+          validCount: validSourceIds.length
+        });
+        cluster.forEach((n) => processedIds.add(n.id));
+        continue;
+      }
+      try {
+        const consolidateResult = await consolidateSpores(
+          {
+            sourceSporeIds: validSourceIds,
+            consolidatedContent: parsed.content,
+            observationType: observationType ?? "gotcha",
+            tags: parsed.tags
+          },
+          {
+            vaultDir,
+            index,
+            vectorIndex,
+            embeddingProvider: embeddingProvider ?? null
+          }
+        );
+        consolidated++;
+        sporesSuperseded += consolidateResult.sources_archived;
+        this.log("info", "ConsolidationEngine: consolidated cluster", {
+          wisdomId: consolidateResult.wisdom_id,
+          sourcesArchived: consolidateResult.sources_archived,
+          clusterSize: cluster.length
+        });
+      } catch (err) {
+        this.log("warn", "ConsolidationEngine: consolidateSpores failed", {
+          triggerId: triggerSpore.id,
+          error: String(err)
+        });
+      }
+      cluster.forEach((n) => processedIds.add(n.id));
+    }
+    const passTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const durationMs = Date.now() - startTime;
+    const passResult = {
+      timestamp: passTimestamp,
+      sporesChecked: newSpores.length,
+      clustersFound,
+      consolidated,
+      sporesSuperseded,
+      durationMs
+    };
+    if (consolidated > 0) {
+      this.appendTrace(passResult);
+    } else {
+      this.lastTimestampCache = passTimestamp;
+    }
+    this.log("info", "ConsolidationEngine: pass complete", {
+      sporesChecked: newSpores.length,
+      clustersFound,
+      consolidated,
+      sporesSuperseded,
+      durationMs
+    });
+    return passResult;
+  }
+};
+
+// src/daemon/port.ts
+import { createHash } from "crypto";
+import net from "net";
+var PORT_RANGE_START = 19200;
+var PORT_RANGE_SIZE = 1e4;
+var PORT_RETRY_COUNT = 10;
+function derivePort(vaultPath) {
+  const hash = createHash("md5").update(vaultPath).digest();
+  const num = hash.readUInt16LE(0);
+  return PORT_RANGE_START + num % PORT_RANGE_SIZE;
+}
+async function resolvePort(configPort, vaultPath) {
+  const basePort = configPort ?? derivePort(vaultPath);
+  for (let offset = 0; offset < PORT_RETRY_COUNT; offset++) {
+    const candidate = basePort + offset;
+    if (candidate > 65535) break;
+    if (await isPortAvailable(candidate)) return candidate;
+  }
+  return 0;
+}
+function isPortAvailable(port) {
+  return new Promise((resolve3) => {
+    const server = net.createServer();
+    server.once("error", () => resolve3(false));
+    server.once("listening", () => {
+      server.close(() => resolve3(true));
+    });
+    server.listen(port, "127.0.0.1");
+  });
+}
+
 // src/artifacts/candidates.ts
 import { execFileSync } from "child_process";
-import fs3 from "fs";
-import path4 from "path";
+import fs4 from "fs";
+import path6 from "path";
 var EXCLUDED_FILENAMES = /* @__PURE__ */ new Set([
   "claude.md",
   "agents.md",
@@ -2231,7 +2659,7 @@ var EXCLUDED_PREFIXES = [
   ".github/"
 ];
 function isExcludedPath(relativePath) {
-  const basename3 = path4.basename(relativePath).toLowerCase();
+  const basename3 = path6.basename(relativePath).toLowerCase();
   if (EXCLUDED_FILENAMES.has(basename3)) return true;
   const normalized = relativePath.replace(/\\/g, "/");
   return EXCLUDED_PREFIXES.some((prefix) => normalized.startsWith(prefix));
@@ -2239,7 +2667,7 @@ function isExcludedPath(relativePath) {
 function collectArtifactCandidates(filePaths, config, projectRoot) {
   if (filePaths.size === 0) return [];
   const extFiltered = [...filePaths].filter(
-    (absPath) => config.artifact_extensions.includes(path4.extname(absPath))
+    (absPath) => config.artifact_extensions.includes(path6.extname(absPath))
   );
   if (extFiltered.length === 0) return [];
   const ignoredSet = getGitIgnored(extFiltered, projectRoot);
@@ -2247,8 +2675,8 @@ function collectArtifactCandidates(filePaths, config, projectRoot) {
   for (const absPath of extFiltered) {
     if (ignoredSet.has(absPath)) continue;
     try {
-      const content = fs3.readFileSync(absPath, "utf-8");
-      const relativePath = path4.relative(projectRoot, absPath);
+      const content = fs4.readFileSync(absPath, "utf-8");
+      const relativePath = path6.relative(projectRoot, absPath);
       if (isExcludedPath(relativePath)) continue;
       candidates.push({ path: relativePath, content });
     } catch {
@@ -2271,9 +2699,9 @@ function getGitIgnored(filePaths, cwd) {
 
 // src/artifacts/slugify.ts
 import crypto from "crypto";
-import path5 from "path";
+import path7 from "path";
 function slugifyPath(relativePath) {
-  const ext = path5.extname(relativePath);
+  const ext = path7.extname(relativePath);
   const withoutExt = ext ? relativePath.slice(0, -ext.length) : relativePath;
   let slug = withoutExt.replace(/[/\\]/g, "-").toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
   if (slug.length > MAX_SLUG_LENGTH) {
@@ -2283,10 +2711,416 @@ function slugifyPath(relativePath) {
   return slug;
 }
 
+// src/daemon/api/config.ts
+async function handleGetConfig(vaultDir) {
+  const config = loadConfig(vaultDir);
+  return { body: config };
+}
+async function handlePutConfig(vaultDir, body) {
+  const result = MycoConfigSchema.safeParse(body);
+  if (!result.success) {
+    return {
+      status: 400,
+      body: { error: "validation_failed", issues: result.error.issues }
+    };
+  }
+  saveConfig(vaultDir, result.data);
+  return { body: result.data };
+}
+
+// src/daemon/api/stats.ts
+import { createHash as createHash2 } from "crypto";
+import fs5 from "fs";
+import path8 from "path";
+async function handleGetStats(deps) {
+  const baseStats = gatherStats(deps.vaultDir, deps.index, deps.vectorIndex ?? void 0);
+  const digestConfig = deps.config.digest;
+  const digest = {
+    enabled: digestConfig.enabled,
+    consolidation_enabled: digestConfig.consolidation,
+    metabolism_state: deps.metabolism?.state ?? null,
+    last_cycle: null,
+    substrate_queue: 0
+  };
+  return {
+    body: {
+      daemon: {
+        ...baseStats.daemon,
+        pid: baseStats.daemon?.pid ?? process.pid,
+        port: baseStats.daemon?.port ?? 0,
+        version: deps.version,
+        uptime_seconds: process.uptime(),
+        active_sessions: baseStats.daemon?.active_sessions ?? [],
+        config_hash: deps.configHash
+      },
+      vault: baseStats.vault,
+      index: baseStats.index,
+      digest,
+      intelligence: {
+        processor: {
+          provider: deps.config.intelligence.llm.provider,
+          model: deps.config.intelligence.llm.model
+        },
+        digest: digestConfig.intelligence.provider ? {
+          provider: digestConfig.intelligence.provider,
+          model: digestConfig.intelligence.model ?? deps.config.intelligence.llm.model
+        } : null,
+        embedding: {
+          provider: deps.config.intelligence.embedding.provider,
+          model: deps.config.intelligence.embedding.model
+        }
+      }
+    }
+  };
+}
+function computeConfigHash(vaultDir) {
+  try {
+    const configPath = path8.join(vaultDir, CONFIG_FILENAME);
+    const raw = fs5.readFileSync(configPath, "utf-8");
+    return createHash2("md5").update(raw).digest("hex");
+  } catch {
+    return "";
+  }
+}
+
+// src/daemon/api/logs.ts
+async function handleGetLogs(ringBuffer, query) {
+  const since = query.since || null;
+  const level = query.level;
+  const limit = query.limit ? parseInt(query.limit, 10) : void 0;
+  const result = ringBuffer.since(since, { level, limit: isNaN(limit) ? void 0 : limit });
+  const entries = result.entries.map((entry) => {
+    const { component, ...rest } = entry;
+    return { ...rest, category: component };
+  });
+  return {
+    body: {
+      entries,
+      cursor: result.cursor,
+      ...result.cursor_reset ? { cursor_reset: true } : {}
+    }
+  };
+}
+
+// src/daemon/api/restart.ts
+import { spawn } from "child_process";
+var RestartBodySchema = external_exports.object({
+  force: external_exports.boolean().optional()
+}).optional();
+var RESTART_RESPONSE_FLUSH_MS = 500;
+var RESTART_CHILD_DELAY_SECONDS = 3;
+async function handleRestart(deps, body) {
+  const parsed = RestartBodySchema.safeParse(body);
+  const force = parsed.success ? parsed.data?.force : false;
+  if (!force && deps.progressTracker.hasActiveOperations()) {
+    return {
+      status: 409,
+      body: { status: "busy", message: "Active operations in progress. Use force=true to override." }
+    };
+  }
+  const daemonScript = process.argv[1];
+  const shellCmd = `sleep ${RESTART_CHILD_DELAY_SECONDS} && ${process.execPath} ${daemonScript} --vault ${deps.vaultDir}`;
+  const child = spawn("/bin/sh", ["-c", shellCmd], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  setTimeout(() => {
+    process.kill(process.pid, "SIGTERM");
+  }, RESTART_RESPONSE_FLUSH_MS);
+  return { body: { status: "restarting" } };
+}
+
+// src/daemon/api/progress.ts
+import { randomUUID } from "crypto";
+var MAX_CONCURRENT_OPERATIONS = 10;
+var PROGRESS_TTL_MS = 5 * 60 * 1e3;
+var ProgressTracker = class {
+  entries = /* @__PURE__ */ new Map();
+  /**
+   * Create a new tracked operation. Returns the existing token if an
+   * operation of the same type is already running (duplicate prevention).
+   * Throws if the maximum concurrent operations limit is reached.
+   */
+  /**
+   * Create a new tracked operation or return existing one.
+   * Returns `{ token, isNew }` — if `isNew` is false, the operation
+   * was already running and the caller should NOT launch it again.
+   * Throws if the maximum concurrent operations limit is reached.
+   */
+  create(type) {
+    this.cleanup();
+    for (const entry of this.entries.values()) {
+      if (entry.type === type && entry.status === "running") {
+        return { token: entry.token, isNew: false };
+      }
+    }
+    const runningCount = [...this.entries.values()].filter((e) => e.status === "running").length;
+    if (runningCount >= MAX_CONCURRENT_OPERATIONS) {
+      throw new Error(`Maximum concurrent operations reached (${MAX_CONCURRENT_OPERATIONS})`);
+    }
+    const token = randomUUID();
+    const now = Date.now();
+    this.entries.set(token, {
+      token,
+      type,
+      status: "running",
+      created: now,
+      updated: now
+    });
+    return { token, isNew: true };
+  }
+  /**
+   * Update progress for a tracked operation.
+   */
+  update(token, data) {
+    const entry = this.entries.get(token);
+    if (!entry) return;
+    if (data.percent !== void 0) entry.percent = data.percent;
+    if (data.message !== void 0) entry.message = data.message;
+    if (data.status !== void 0) entry.status = data.status;
+    entry.updated = Date.now();
+  }
+  /**
+   * Get the current state of a tracked operation.
+   */
+  get(token) {
+    return this.entries.get(token);
+  }
+  /**
+   * Check whether any operations are currently running.
+   */
+  hasActiveOperations() {
+    for (const entry of this.entries.values()) {
+      if (entry.status === "running") return true;
+    }
+    return false;
+  }
+  /**
+   * Remove completed/failed entries older than PROGRESS_TTL_MS.
+   */
+  cleanup() {
+    const cutoff = Date.now() - PROGRESS_TTL_MS;
+    for (const [token, entry] of this.entries) {
+      if (entry.status !== "running" && entry.updated < cutoff) {
+        this.entries.delete(token);
+      }
+    }
+  }
+};
+async function handleGetProgress(tracker, token) {
+  const entry = tracker.get(token);
+  if (!entry) {
+    return { status: 404, body: { error: "not_found", message: "Progress token not found" } };
+  }
+  return { body: entry };
+}
+
+// src/daemon/api/operations.ts
+var PROGRESS_COMPLETE = 100;
+var CurateBody = external_exports.object({
+  dry_run: external_exports.boolean().optional()
+}).optional();
+var DigestBody = external_exports.object({
+  tier: external_exports.number().int().positive().optional(),
+  full: external_exports.boolean().optional()
+}).optional();
+async function handleRebuild(deps) {
+  const { token, isNew } = deps.progressTracker.create("rebuild");
+  if (!isNew) {
+    return { body: { token, status: "already_running" } };
+  }
+  runRebuild(
+    {
+      vaultDir: deps.vaultDir,
+      config: deps.config,
+      index: deps.index,
+      vectorIndex: deps.vectorIndex ?? void 0,
+      log: deps.log
+    },
+    deps.embeddingProvider,
+    (done, total) => {
+      const percent = total > 0 ? Math.round(done / total * PROGRESS_COMPLETE) : 0;
+      deps.progressTracker.update(token, {
+        percent,
+        message: `Embedded ${done}/${total} notes`
+      });
+    }
+  ).then((result) => {
+    deps.progressTracker.update(token, {
+      status: "completed",
+      percent: PROGRESS_COMPLETE,
+      message: `FTS: ${result.ftsCount}, embedded: ${result.embeddedCount}, failed: ${result.failedCount}, skipped: ${result.skippedCount}`
+    });
+    deps.log("info", "Rebuild completed via API", {
+      fts: result.ftsCount,
+      embedded: result.embeddedCount,
+      failed: result.failedCount
+    });
+  }).catch((err) => {
+    deps.progressTracker.update(token, {
+      status: "failed",
+      message: err.message
+    });
+    deps.log("warn", "Rebuild failed via API", { error: err.message });
+  });
+  return { body: { token } };
+}
+async function handleDigest(deps, body) {
+  const parsed = DigestBody.safeParse(body);
+  if (!parsed.success) {
+    return { status: 400, body: { error: "validation_failed", issues: parsed.error.issues } };
+  }
+  if (!deps.config.digest.enabled) {
+    return { status: 400, body: { error: "digest_disabled", message: "Digest is not enabled in myco.yaml" } };
+  }
+  const options = parsed.data;
+  const { token, isNew } = deps.progressTracker.create("digest");
+  if (!isNew) {
+    return { body: { token, status: "already_running" } };
+  }
+  runDigest(
+    {
+      vaultDir: deps.vaultDir,
+      config: deps.config,
+      index: deps.index,
+      vectorIndex: deps.vectorIndex ?? void 0,
+      log: deps.log
+    },
+    deps.llmProvider,
+    options ?? void 0
+  ).then((result) => {
+    if (result) {
+      deps.progressTracker.update(token, {
+        status: "completed",
+        percent: PROGRESS_COMPLETE,
+        message: `Tiers: [${result.tiersGenerated.join(", ")}], substrate: ${Object.values(result.substrate).flat().length} notes, ${(result.durationMs / 1e3).toFixed(1)}s`
+      });
+      deps.log("info", "Digest completed via API", {
+        tiers: result.tiersGenerated,
+        duration: result.durationMs
+      });
+    } else {
+      deps.progressTracker.update(token, {
+        status: "completed",
+        percent: PROGRESS_COMPLETE,
+        message: "No substrate found \u2014 nothing to digest"
+      });
+    }
+  }).catch((err) => {
+    deps.progressTracker.update(token, {
+      status: "failed",
+      message: err.message
+    });
+    deps.log("warn", "Digest failed via API", { error: err.message });
+  });
+  return { body: { token } };
+}
+async function handleCurate(deps, body, runCuration2) {
+  const parsed = CurateBody.safeParse(body);
+  if (!parsed.success) {
+    return { status: 400, body: { error: "validation_failed", issues: parsed.error.issues } };
+  }
+  const isDryRun = parsed.data?.dry_run ?? false;
+  if (!deps.vectorIndex) {
+    return { status: 400, body: { error: "vector_index_unavailable", message: "Curate requires a working embedding provider" } };
+  }
+  const curationDeps = {
+    vaultDir: deps.vaultDir,
+    config: deps.config,
+    index: deps.index,
+    vectorIndex: deps.vectorIndex,
+    llmProvider: deps.llmProvider,
+    embeddingProvider: deps.embeddingProvider,
+    log: deps.log
+  };
+  if (isDryRun) {
+    try {
+      const result = await runCuration2(curationDeps, true);
+      return { body: { dry_run: true, ...result } };
+    } catch (err) {
+      return { status: 500, body: { error: "curation_failed", message: err.message } };
+    }
+  }
+  const { token, isNew } = deps.progressTracker.create("curate");
+  if (!isNew) {
+    return { body: { token, status: "already_running" } };
+  }
+  runCuration2(curationDeps, false).then((result) => {
+    deps.progressTracker.update(token, {
+      status: "completed",
+      percent: PROGRESS_COMPLETE,
+      message: `Scanned: ${result.scanned}, clusters: ${result.clustersEvaluated}, superseded: ${result.superseded}`
+    });
+    deps.log("info", "Curation completed via API", { ...result });
+  }).catch((err) => {
+    deps.progressTracker.update(token, {
+      status: "failed",
+      message: err.message
+    });
+    deps.log("warn", "Curation failed via API", { error: err.message });
+  });
+  return { body: { token } };
+}
+
+// src/daemon/api/models.ts
+var MODEL_LIST_TIMEOUT_MS = 5e3;
+var ANTHROPIC_MODELS = [
+  "claude-opus-4-6",
+  "claude-sonnet-4-6",
+  "claude-haiku-4-5-20251001"
+];
+var EMBEDDING_PATTERNS = [
+  "embed",
+  "bge-",
+  "nomic-embed",
+  "e5-",
+  "gte-",
+  "granite-embedding"
+];
+function filterEmbeddingModels(models) {
+  return models.filter((m) => {
+    const name = m.toLowerCase();
+    return EMBEDDING_PATTERNS.some((p) => name.includes(p));
+  });
+}
+function filterLlmModels(models) {
+  return models.filter((m) => {
+    const name = m.toLowerCase();
+    return !EMBEDDING_PATTERNS.some((p) => name.includes(p));
+  });
+}
+async function handleGetModels(req) {
+  const provider = req.query.provider;
+  const type = req.query.type;
+  if (!provider) {
+    return { status: 400, body: { error: "provider query parameter required" } };
+  }
+  let models = [];
+  try {
+    if (provider === "ollama") {
+      const backend = new OllamaBackend({ base_url: req.query.base_url });
+      models = await backend.listModels(MODEL_LIST_TIMEOUT_MS);
+    } else if (provider === "lm-studio" || provider === "openai-compatible") {
+      const backend = new LmStudioBackend({ base_url: req.query.base_url });
+      models = await backend.listModels(MODEL_LIST_TIMEOUT_MS);
+    } else if (provider === "anthropic") {
+      models = ANTHROPIC_MODELS;
+    }
+  } catch {
+  }
+  if (type === "embedding") {
+    models = filterEmbeddingModels(models);
+  } else if (type === "llm") {
+    models = filterLlmModels(models);
+  }
+  return { body: { provider, models } };
+}
+
 // src/daemon/main.ts
 var import_yaml = __toESM(require_dist(), 1);
-import fs4 from "fs";
-import path6 from "path";
+import fs6 from "fs";
+import path9 from "path";
 function indexAndEmbed(relativePath, noteId, embeddingText, metadata, deps) {
   indexNote(deps.index, deps.vaultDir, relativePath);
   if (deps.vectorIndex && embeddingText) {
@@ -2358,28 +3192,28 @@ ${candidate.content}`,
   }
 }
 function migrateSporeFiles(vaultDir) {
-  const sporesDir = path6.join(vaultDir, "spores");
-  if (!fs4.existsSync(sporesDir)) return 0;
+  const sporesDir = path9.join(vaultDir, "spores");
+  if (!fs6.existsSync(sporesDir)) return 0;
   let moved = 0;
-  const entries = fs4.readdirSync(sporesDir);
+  const entries = fs6.readdirSync(sporesDir);
   for (const entry of entries) {
-    const fullPath = path6.join(sporesDir, entry);
+    const fullPath = path9.join(sporesDir, entry);
     if (!entry.endsWith(".md")) continue;
-    if (fs4.statSync(fullPath).isDirectory()) continue;
+    if (fs6.statSync(fullPath).isDirectory()) continue;
     try {
-      const content = fs4.readFileSync(fullPath, "utf-8");
+      const content = fs6.readFileSync(fullPath, "utf-8");
       const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
       if (!fmMatch) continue;
       const parsed = import_yaml.default.parse(fmMatch[1]);
       const obsType = parsed.observation_type;
       if (!obsType) continue;
       const normalizedType = obsType.replace(/_/g, "-");
-      const targetDir = path6.join(sporesDir, normalizedType);
-      fs4.mkdirSync(targetDir, { recursive: true });
-      const targetPath = path6.join(targetDir, entry);
-      fs4.renameSync(fullPath, targetPath);
+      const targetDir = path9.join(sporesDir, normalizedType);
+      fs6.mkdirSync(targetDir, { recursive: true });
+      const targetPath = path9.join(targetDir, entry);
+      fs6.renameSync(fullPath, targetPath);
       const now = /* @__PURE__ */ new Date();
-      fs4.utimesSync(targetPath, now, now);
+      fs6.utimesSync(targetPath, now, now);
       moved++;
     } catch {
     }
@@ -2392,13 +3226,28 @@ async function main() {
     process.stderr.write("Usage: mycod --vault <path>\n");
     process.exit(1);
   }
-  const vaultDir = path6.resolve(vaultArg);
+  const vaultDir = path9.resolve(vaultArg);
   const config = loadConfig(vaultDir);
-  const logger = new DaemonLogger(path6.join(vaultDir, "logs"), {
+  const logger = new DaemonLogger(path9.join(vaultDir, "logs"), {
     level: config.daemon.log_level,
     maxSize: config.daemon.max_log_size
   });
-  const server = new DaemonServer({ vaultDir, logger });
+  let uiDir = null;
+  {
+    let dir = path9.dirname(new URL(import.meta.url).pathname);
+    for (let i = 0; i < 5; i++) {
+      const candidate = path9.join(dir, "dist", "ui");
+      if (fs6.existsSync(path9.join(dir, "package.json")) && fs6.existsSync(candidate)) {
+        uiDir = candidate;
+        break;
+      }
+      dir = path9.dirname(dir);
+    }
+  }
+  if (uiDir) {
+    logger.debug("daemon", "Static UI directory found", { path: uiDir });
+  }
+  const server = new DaemonServer({ vaultDir, logger, uiDir: uiDir ?? void 0 });
   const registry = new SessionRegistry({
     gracePeriod: config.daemon.grace_period,
     onEmpty: async () => {
@@ -2417,14 +3266,14 @@ async function main() {
   let vectorIndex = null;
   try {
     const testEmbed = await embeddingProvider.embed("test");
-    vectorIndex = new VectorIndex(path6.join(vaultDir, "vectors.db"), testEmbed.dimensions);
+    vectorIndex = new VectorIndex(path9.join(vaultDir, "vectors.db"), testEmbed.dimensions);
     logger.info("embeddings", "Vector index initialized", { dimensions: testEmbed.dimensions });
   } catch (error) {
     logger.warn("embeddings", "Vector index unavailable", { error: error.message });
   }
   const processor = new BufferProcessor(llmProvider, config.intelligence.llm.context_window, config.capture);
   const vault = new VaultWriter(vaultDir);
-  const index = new MycoIndex(path6.join(vaultDir, "index.db"));
+  const index = new MycoIndex(path9.join(vaultDir, "index.db"));
   const lineageGraph = new LineageGraph(vaultDir);
   const transcriptMiner = new TranscriptMiner({
     additionalAdapters: config.capture.transcript_paths.map(
@@ -2433,17 +3282,17 @@ async function main() {
   });
   let activeStopProcessing = null;
   const indexDeps = { index, vaultDir, vectorIndex, embeddingProvider, llmProvider, logger };
-  const bufferDir = path6.join(vaultDir, "buffer");
+  const bufferDir = path9.join(vaultDir, "buffer");
   const sessionBuffers = /* @__PURE__ */ new Map();
   const sessionFilePaths = /* @__PURE__ */ new Map();
   const capturedArtifactPaths = /* @__PURE__ */ new Map();
-  if (fs4.existsSync(bufferDir)) {
+  if (fs6.existsSync(bufferDir)) {
     const cutoff = Date.now() - STALE_BUFFER_MAX_AGE_MS;
-    for (const file of fs4.readdirSync(bufferDir)) {
-      const filePath = path6.join(bufferDir, file);
-      const stat4 = fs4.statSync(filePath);
+    for (const file of fs6.readdirSync(bufferDir)) {
+      const filePath = path9.join(bufferDir, file);
+      const stat4 = fs6.statSync(filePath);
       if (stat4.mtimeMs < cutoff) {
-        fs4.unlinkSync(filePath);
+        fs6.unlinkSync(filePath);
         logger.debug("daemon", "Cleaned stale buffer", { file });
       }
     }
@@ -2480,10 +3329,10 @@ async function main() {
       logger.info("watcher", "Plan detected", { source: event.source, file: event.filePath });
       if (event.filePath) {
         try {
-          const content = fs4.readFileSync(event.filePath, "utf-8");
-          const relativePath = path6.relative(vaultDir, event.filePath);
-          const title = content.match(/^#\s+(.+)$/m)?.[1] ?? path6.basename(event.filePath);
-          const planId = `plan-${path6.basename(event.filePath, ".md")}`;
+          const content = fs6.readFileSync(event.filePath, "utf-8");
+          const relativePath = path9.relative(vaultDir, event.filePath);
+          const title = content.match(/^#\s+(.+)$/m)?.[1] ?? path9.basename(event.filePath);
+          const planId = `plan-${path9.basename(event.filePath, ".md")}`;
           indexAndEmbed(
             relativePath,
             planId,
@@ -2522,6 +3371,23 @@ ${content}`,
       config,
       log: (level, message, data) => logger[level]("digest", message, data)
     });
+    if (config.digest.consolidation) {
+      const consolidationEngine = new ConsolidationEngine({
+        vaultDir,
+        index,
+        vectorIndex,
+        embeddingProvider,
+        llmProvider: digestLlm,
+        log: (level, message, data) => logger[level]("consolidation", message, data)
+      });
+      digestEngine.registerPrePass("consolidation", async () => {
+        const result = await consolidationEngine.runPass();
+        if (result && result.consolidated > 0) {
+          logger.info("consolidation", `Consolidation pass: ${result.consolidated} wisdom notes, ${result.sporesSuperseded} spores superseded`);
+        }
+      });
+      logger.info("consolidation", "Auto-consolidation enabled as digest pre-pass");
+    }
     metabolism = new Metabolism(config.digest.metabolism);
     logger.debug("digest", "Firing initial digest cycle (background)");
     digestEngine.runCycle().then((result) => {
@@ -2580,7 +3446,7 @@ ${content}`,
           }
           const captured = capturedArtifactPaths.get(sessionId);
           for (const c of candidates) {
-            const absPath = path6.resolve(process.cwd(), c.path);
+            const absPath = path9.resolve(process.cwd(), c.path);
             captured.add(absPath);
           }
         }).catch((err) => logger.warn("processor", "Incremental artifact capture failed", {
@@ -2590,8 +3456,8 @@ ${content}`,
       }
     }
   });
-  server.registerRoute("POST", "/sessions/register", async (body) => {
-    const { session_id, branch, started_at } = RegisterBody.parse(body);
+  server.registerRoute("POST", "/sessions/register", async (req) => {
+    const { session_id, branch, started_at } = RegisterBody.parse(req.body);
     const resolvedStartedAt = started_at ?? (/* @__PURE__ */ new Date()).toISOString();
     registry.register(session_id, { started_at: resolvedStartedAt, branch });
     server.updateDaemonJsonSessions(registry.sessions);
@@ -2613,21 +3479,21 @@ ${content}`,
     }
     metabolism?.activate();
     logger.info("lifecycle", "Session registered", { session_id, branch });
-    return { ok: true, sessions: registry.sessions };
+    return { body: { ok: true, sessions: registry.sessions } };
   });
-  server.registerRoute("POST", "/sessions/unregister", async (body) => {
-    const { session_id } = UnregisterBody.parse(body);
+  server.registerRoute("POST", "/sessions/unregister", async (req) => {
+    const { session_id } = UnregisterBody.parse(req.body);
     registry.unregister(session_id);
     try {
       const cutoff = Date.now() - STALE_BUFFER_MAX_AGE_MS;
-      for (const file of fs4.readdirSync(bufferDir)) {
+      for (const file of fs6.readdirSync(bufferDir)) {
         if (!file.endsWith(".jsonl")) continue;
         const bufferSessionId = file.replace(".jsonl", "");
         if (bufferSessionId === session_id) continue;
-        const filePath = path6.join(bufferDir, file);
-        const stat4 = fs4.statSync(filePath);
+        const filePath = path9.join(bufferDir, file);
+        const stat4 = fs6.statSync(filePath);
         if (stat4.mtimeMs < cutoff) {
-          fs4.unlinkSync(filePath);
+          fs6.unlinkSync(filePath);
           logger.debug("daemon", "Cleaned stale buffer", { file });
         }
       }
@@ -2638,10 +3504,10 @@ ${content}`,
     capturedArtifactPaths.delete(session_id);
     server.updateDaemonJsonSessions(registry.sessions);
     logger.info("lifecycle", "Session unregistered", { session_id });
-    return { ok: true, sessions: registry.sessions };
+    return { body: { ok: true, sessions: registry.sessions } };
   });
-  server.registerRoute("POST", "/events", async (body) => {
-    const validated = EventBody.parse(body);
+  server.registerRoute("POST", "/events", async (req) => {
+    const validated = EventBody.parse(req.body);
     const event = { ...validated, timestamp: validated.timestamp ?? (/* @__PURE__ */ new Date()).toISOString() };
     logger.debug("hooks", "Event received", { type: event.type, session_id: event.session_id });
     if (!registry.getSession(event.session_id)) {
@@ -2668,10 +3534,10 @@ ${content}`,
         }
       }
     }
-    return { ok: true };
+    return { body: { ok: true } };
   });
-  server.registerRoute("POST", "/events/stop", async (body) => {
-    const { session_id: sessionId, user, transcript_path: hookTranscriptPath, last_assistant_message: lastAssistantMessage } = StopBody.parse(body);
+  server.registerRoute("POST", "/events/stop", async (req) => {
+    const { session_id: sessionId, user, transcript_path: hookTranscriptPath, last_assistant_message: lastAssistantMessage } = StopBody.parse(req.body);
     if (!registry.getSession(sessionId)) {
       registry.register(sessionId, { started_at: (/* @__PURE__ */ new Date()).toISOString() });
       logger.debug("lifecycle", "Auto-registered session from stop event", { session_id: sessionId });
@@ -2685,7 +3551,7 @@ ${content}`,
     activeStopProcessing = prev.then(run).finally(() => {
       activeStopProcessing = null;
     });
-    return { ok: true };
+    return { body: { ok: true } };
   });
   async function processStopEvent(sessionId, user, sessionMeta, hookTranscriptPath, lastAssistantMessage) {
     const lastBatch = batchManager.finalize(sessionId);
@@ -2722,15 +3588,15 @@ ${content}`,
     }
     const ended = (/* @__PURE__ */ new Date()).toISOString();
     let started = allTurns.length > 0 && allTurns[0].timestamp ? allTurns[0].timestamp : ended;
-    const sessionsDir = path6.join(vaultDir, "sessions");
+    const sessionsDir = path9.join(vaultDir, "sessions");
     const sessionFileName = `${sessionNoteId(sessionId)}.md`;
     let existingContent;
     const duplicatePaths = [];
     try {
-      for (const dateDir of fs4.readdirSync(sessionsDir)) {
-        const candidate = path6.join(sessionsDir, dateDir, sessionFileName);
+      for (const dateDir of fs6.readdirSync(sessionsDir)) {
+        const candidate = path9.join(sessionsDir, dateDir, sessionFileName);
         try {
-          const content = fs4.readFileSync(candidate, "utf-8");
+          const content = fs6.readFileSync(candidate, "utf-8");
           if (!existingContent || content.length > existingContent.length) {
             existingContent = content;
           }
@@ -2793,20 +3659,20 @@ ${conversationText}`;
     }
     const date = started.slice(0, 10);
     const relativePath = sessionRelativePath(sessionId, date);
-    const targetFullPath = path6.join(vaultDir, relativePath);
+    const targetFullPath = path9.join(vaultDir, relativePath);
     for (const dup of duplicatePaths) {
       if (dup !== targetFullPath) {
         try {
-          fs4.unlinkSync(dup);
+          fs6.unlinkSync(dup);
           logger.debug("lifecycle", "Removed duplicate session file", { path: dup });
         } catch {
         }
       }
     }
-    const attachmentsDir = path6.join(vaultDir, "attachments");
+    const attachmentsDir = path9.join(vaultDir, "attachments");
     const hasImages = allTurns.some((t) => t.images?.length);
     if (hasImages) {
-      fs4.mkdirSync(attachmentsDir, { recursive: true });
+      fs6.mkdirSync(attachmentsDir, { recursive: true });
     }
     const turnImageNames = /* @__PURE__ */ new Map();
     for (let i = 0; i < allTurns.length; i++) {
@@ -2817,9 +3683,9 @@ ${conversationText}`;
         const img = turn.images[j];
         const ext = extensionForMimeType(img.mediaType);
         const filename = `${bareSessionId(sessionId)}-t${i + 1}-${j + 1}.${ext}`;
-        const filePath = path6.join(attachmentsDir, filename);
-        if (!fs4.existsSync(filePath)) {
-          fs4.writeFileSync(filePath, Buffer.from(img.data, "base64"));
+        const filePath = path9.join(attachmentsDir, filename);
+        if (!fs6.existsSync(filePath)) {
+          fs6.writeFileSync(filePath, Buffer.from(img.data, "base64"));
           logger.debug("processor", "Image saved", { filename, turn: i + 1 });
         }
         names.push(filename);
@@ -2920,8 +3786,8 @@ ${conversationText}`;
     }
     logger.info("processor", "Session note written", { session_id: sessionId, path: relativePath });
   }
-  server.registerRoute("POST", "/context", async (body) => {
-    const { session_id, branch } = ContextBody.parse(body);
+  server.registerRoute("POST", "/context", async (req) => {
+    const { session_id, branch } = ContextBody.parse(req.body);
     logger.debug("hooks", "Session context query", { session_id });
     try {
       if (config.digest.enabled && config.digest.inject_tier) {
@@ -2932,7 +3798,7 @@ ${conversationText}`;
 Branch:: \`${branch}\``);
           meta.push(`Session:: \`${session_id}\``);
           logger.debug("context", `Injecting digest extract (tier ${result.tier})`, { session_id, fallback: result.fallback });
-          return { text: meta.join("\n\n"), source: "digest", tier: result.tier };
+          return { body: { text: meta.join("\n\n"), source: "digest", tier: result.tier } };
         }
       }
       const parts = [];
@@ -2965,22 +3831,22 @@ ${planLines.join("\n")}`);
       }
       parts.push(`Session:: \`${session_id}\``);
       if (parts.length > 0) {
-        return { text: parts.join("\n\n") };
+        return { body: { text: parts.join("\n\n") } };
       }
-      return { text: "" };
+      return { body: { text: "" } };
     } catch (error) {
       logger.error("daemon", "Session context failed", { error: error.message });
-      return { text: "" };
+      return { body: { text: "" } };
     }
   });
   const PromptContextBody = external_exports.object({
     prompt: external_exports.string(),
     session_id: external_exports.string().optional()
   });
-  server.registerRoute("POST", "/context/prompt", async (body) => {
-    const { prompt, session_id } = PromptContextBody.parse(body);
+  server.registerRoute("POST", "/context/prompt", async (req) => {
+    const { prompt, session_id } = PromptContextBody.parse(req.body);
     if (!prompt || prompt.length < PROMPT_CONTEXT_MIN_LENGTH || !vectorIndex) {
-      return { text: "" };
+      return { body: { text: "" } };
     }
     try {
       const emb = await generateEmbedding(embeddingProvider, prompt.slice(0, EMBEDDING_INPUT_LIMIT));
@@ -2989,7 +3855,7 @@ ${planLines.join("\n")}`);
         type: "spore",
         relativeThreshold: PROMPT_CONTEXT_MIN_SIMILARITY
       });
-      if (results.length === 0) return { text: "" };
+      if (results.length === 0) return { body: { text: "" } };
       const noteMap = new Map(
         index.queryByIds(results.map((r) => r.id)).map((n) => [n.id, n])
       );
@@ -3002,7 +3868,7 @@ ${planLines.join("\n")}`);
         const obsType = fm.observation_type ?? "note";
         lines.push(`- [${obsType}] ${note.title}: ${note.content.slice(0, CONTENT_SNIPPET_CHARS)} \`[${note.id}]\``);
       }
-      if (lines.length === 0) return { text: "" };
+      if (lines.length === 0) return { body: { text: "" } };
       const injected = `**Relevant spores for this task:**
 ${lines.join("\n")}`;
       logger.debug("context", "Prompt context injected", {
@@ -3010,14 +3876,72 @@ ${lines.join("\n")}`;
         spores: lines.length,
         prompt_preview: prompt.slice(0, 50)
       });
-      return { text: injected };
+      return { body: { text: injected } };
     } catch (err) {
       logger.debug("context", "Prompt context failed", { error: err.message });
-      return { text: "" };
+      return { body: { text: "" } };
     }
   });
-  await server.start();
+  const progressTracker = new ProgressTracker();
+  let configHash = computeConfigHash(vaultDir);
+  server.registerRoute("GET", "/api/config", async () => handleGetConfig(vaultDir));
+  server.registerRoute("PUT", "/api/config", async (req) => {
+    const result = await handlePutConfig(vaultDir, req.body);
+    if (!result.status || result.status < 400) {
+      configHash = computeConfigHash(vaultDir);
+    }
+    return result;
+  });
+  server.registerRoute("GET", "/api/stats", async () => handleGetStats({
+    vaultDir,
+    index,
+    vectorIndex,
+    version: server.version,
+    config,
+    configHash,
+    metabolism
+  }));
+  server.registerRoute("GET", "/api/logs", async (req) => handleGetLogs(logger.getRingBuffer(), req.query));
+  server.registerRoute("GET", "/api/models", async (req) => handleGetModels(req));
+  server.registerRoute("POST", "/api/restart", async (req) => handleRestart({ vaultDir, progressTracker }, req.body));
+  server.registerRoute("GET", "/api/progress/:token", async (req) => handleGetProgress(progressTracker, req.params.token));
+  const operationDeps = {
+    vaultDir,
+    config,
+    index,
+    vectorIndex,
+    llmProvider,
+    embeddingProvider,
+    progressTracker,
+    log: (level, message, data) => {
+      const fn = logger[level];
+      if (typeof fn === "function") fn.call(logger, "operations", message, data);
+    }
+  };
+  server.registerRoute("POST", "/api/rebuild", async () => handleRebuild(operationDeps));
+  server.registerRoute("POST", "/api/digest", async (req) => handleDigest(operationDeps, req.body));
+  server.registerRoute("POST", "/api/curate", async (req) => handleCurate(operationDeps, req.body, runCuration));
+  const resolvedPort = await resolvePort(config.daemon.port, vaultDir);
+  if (resolvedPort === 0) {
+    logger.warn("daemon", "All preferred ports occupied, using ephemeral port");
+  }
+  await server.start(resolvedPort);
   logger.info("daemon", "Daemon ready", { vault: vaultDir, port: server.port });
+  if (config.daemon.port === null && resolvedPort !== 0) {
+    try {
+      config.daemon.port = resolvedPort;
+      saveConfig(vaultDir, config);
+      logger.info("daemon", "Persisted auto-derived port to myco.yaml", { port: resolvedPort });
+    } catch (err) {
+      logger.warn("daemon", "Failed to persist auto-derived port", { error: err.message });
+    }
+  }
+  try {
+    const { loadTemplate } = await import("./templates-XPRBOWCE.js");
+    const portalContent = loadTemplate("portal", { port: String(server.port) });
+    fs6.writeFileSync(path9.join(vaultDir, "_portal.md"), portalContent, "utf-8");
+  } catch {
+  }
   if (needsMigrationReindex) {
     setImmediate(() => {
       logger.info("daemon", "Rebuilding index after memories\u2192spores migration (background)");
@@ -3053,4 +3977,4 @@ export {
 chokidar/index.js:
   (*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) *)
 */
-//# sourceMappingURL=main-NFQ4II75.js.map
+//# sourceMappingURL=main-JEUQS3BY.js.map