@goondocks/myco 0.3.7 → 0.4.1

package/dist/{main-S3WSUF5T.js → main-3JSO25IZ.js}

@@ -5,8 +5,16 @@ import {
   buildSimilarityPrompt,
   extractNumber,
   extractTurnsFromBuffer,
+  loadPrompt,
+  stripReasoningTokens,
   writeObservationNotes
-} from "./chunk-FFQNE6CT.js";
+} from "./chunk-V2OWD2VV.js";
+import {
+  handleMycoContext
+} from "./chunk-WBT5DWGC.js";
+import {
+  DaemonLogger
+} from "./chunk-5EZ7QF6J.js";
 import {
   VaultWriter,
   bareSessionId,
@@ -14,64 +22,69 @@ import {
   sessionNoteId,
   sessionRelativePath,
   sessionWikilink
-} from "./chunk-QWU7QLZI.js";
+} from "./chunk-I7PNZEBO.js";
 import {
   indexNote,
   rebuildIndex
-} from "./chunk-AWF3M57N.js";
+} from "./chunk-FPEDTLQ6.js";
 import {
   generateEmbedding
 } from "./chunk-RGVBGTD6.js";
+import {
+  createEmbeddingProvider,
+  createLlmProvider
+} from "./chunk-IVS5MYBL.js";
 import {
   VectorIndex
 } from "./chunk-XQXXF6MU.js";
 import {
-  DaemonLogger
-} from "./chunk-5EZ7QF6J.js";
+  stripFrontmatter
+} from "./chunk-MIU3DKLN.js";
 import {
   initFts
 } from "./chunk-6FQISQNA.js";
 import {
   MycoIndex
-} from "./chunk-PA3VMINE.js";
+} from "./chunk-AK6GNLPV.js";
+import "./chunk-P7RNAYU7.js";
 import {
-  createEmbeddingProvider,
-  createLlmProvider
-} from "./chunk-7WNE22W7.js";
-import "./chunk-BA23DROX.js";
-import {
-  external_exports,
   loadConfig
-} from "./chunk-ISCT2SI6.js";
+} from "./chunk-TBRZAJ7W.js";
 import {
+  external_exports,
   require_dist
-} from "./chunk-EF4JVH24.js";
+} from "./chunk-6UJWI4IW.js";
 import {
   EventBuffer
 } from "./chunk-HIN3UVOG.js";
 import {
   getPluginVersion
-} from "./chunk-YFG2O5HR.js";
+} from "./chunk-2GJFTIWX.js";
 import {
   claudeCodeAdapter,
   createPerProjectAdapter,
   extensionForMimeType
-} from "./chunk-JKOALBZC.js";
+} from "./chunk-BNIYWCST.js";
 import {
   CANDIDATE_CONTENT_PREVIEW,
+  CHARS_PER_TOKEN,
   CONTENT_SNIPPET_CHARS,
   CONTEXT_SESSION_PREVIEW_CHARS,
+  DIGEST_LLM_REQUEST_TIMEOUT_MS,
+  DIGEST_SUBSTRATE_TYPE_WEIGHTS,
+  DIGEST_TIER_MIN_CONTEXT,
   EMBEDDING_INPUT_LIMIT,
   FILE_WATCH_STABILITY_MS,
   LINEAGE_RECENT_SESSIONS_LIMIT,
   MAX_SLUG_LENGTH,
-  PROMPT_CONTEXT_MAX_MEMORIES,
+  PROMPT_CONTEXT_MAX_SPORES,
   PROMPT_CONTEXT_MIN_LENGTH,
   PROMPT_CONTEXT_MIN_SIMILARITY,
-  RELATED_MEMORIES_LIMIT,
+  RELATED_SPORES_LIMIT,
   SESSION_CONTEXT_MAX_PLANS,
-  STALE_BUFFER_MAX_AGE_MS
-} from "./chunk-7VPJK56U.js";
+  STALE_BUFFER_MAX_AGE_MS,
+  estimateTokens
+} from "./chunk-JBD5KP5G.js";
 import {
   __toESM
 } from "./chunk-PZUWP5VK.js";
@@ -483,7 +496,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 = (path8) => statMethod(path8, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -508,8 +521,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: path8, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path8));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -549,20 +562,20 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path7, depth) {
+  async _exploreDir(path8, depth) {
     let files;
     try {
-      files = await readdir(path7, this._rdOptions);
+      files = await readdir(path8, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path7 };
+    return { files, depth, path: path8 };
   }
-  async _formatEntry(dirent, path7) {
+  async _formatEntry(dirent, path8) {
     let entry;
     const basename3 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path7, basename3));
+      const fullPath = presolve(pjoin(path8, basename3));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename3 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -962,16 +975,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(path8, 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(path8);
+    emitRaw(rawEvent, evPath, { watchedPath: path8 });
+    if (evPath && path8 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path8, evPath), KEY_LISTENERS, sp.join(path8, evPath));
     }
   };
   try {
-    return fs_watch(path7, {
+    return fs_watch(path8, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -987,12 +1000,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path7, fullPath, options, handlers) => {
+var setFsWatchListener = (path8, 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(path8, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -1003,7 +1016,7 @@ var setFsWatchListener = (path7, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path7,
+      path8,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -1018,7 +1031,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(path8, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -1049,7 +1062,7 @@ var setFsWatchListener = (path7, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path7, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path8, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -1071,7 +1084,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(path8, curr));
         }
       })
     };
@@ -1101,13 +1114,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path7, listener) {
+  _watchWithNodeFs(path8, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path7);
-    const basename3 = sp.basename(path7);
+    const directory = sp.dirname(path8);
+    const basename3 = sp.basename(path8);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename3);
-    const absolutePath = sp.resolve(path7);
+    const absolutePath = sp.resolve(path8);
     const options = {
       persistent: opts.persistent
     };
@@ -1117,12 +1130,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(path8, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path7, absolutePath, options, {
+      closer = setFsWatchListener(path8, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -1144,7 +1157,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename3))
       return;
-    const listener = async (path7, newStats) => {
+    const listener = async (path8, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -1158,11 +1171,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(path8);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path7, closer2);
+              this.fsw._addPathCloser(path8, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -1194,7 +1207,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, path8, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -1204,7 +1217,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path7);
+        linkPath = await fsrealpath(path8);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -1214,12 +1227,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, path8, 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, path8, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -1249,9 +1262,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path7 = sp.join(directory, item);
+      let path8 = 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, path8, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -1260,8 +1273,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);
+        path8 = sp.join(dir, sp.relative(dir, path8));
+        this._addToNodeFs(path8, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve3, reject) => {
@@ -1330,13 +1343,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(path8, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path7) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path8) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path7);
+    const wh = this.fsw._getWatchHelpers(path8);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -1352,8 +1365,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(path8);
+        const targetPath = follow ? await fsrealpath(path8) : path8;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -1363,29 +1376,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(path8) : path8;
         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, path8, 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(path8), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path7, closer);
+        this.fsw._addPathCloser(path8, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path7;
+        return path8;
       }
     }
   }
@@ -1428,24 +1441,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path7) {
-  if (typeof path7 !== "string")
+function normalizePath(path8) {
+  if (typeof path8 !== "string")
     throw new Error("string expected");
-  path7 = sp2.normalize(path7);
-  path7 = path7.replace(/\\/g, "/");
+  path8 = sp2.normalize(path8);
+  path8 = path8.replace(/\\/g, "/");
   let prepend = false;
-  if (path7.startsWith("//"))
+  if (path8.startsWith("//"))
     prepend = true;
-  path7 = path7.replace(DOUBLE_SLASH_RE, "/");
+  path8 = path8.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path7 = "/" + path7;
-  return path7;
+    path8 = "/" + path8;
+  return path8;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path7 = normalizePath(testString);
+  const path8 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path7, stats)) {
+    if (pattern(path8, stats)) {
       return true;
     }
   }
@@ -1483,19 +1496,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 = (path8) => toUnix(sp2.normalize(toUnix(path8)));
+var normalizeIgnored = (cwd = "") => (path8) => {
+  if (typeof path8 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path8) ? path8 : sp2.join(cwd, path8));
   } else {
-    return path7;
+    return path8;
   }
 };
-var getAbsolutePath = (path7, cwd) => {
-  if (sp2.isAbsolute(path7)) {
-    return path7;
+var getAbsolutePath = (path8, cwd) => {
+  if (sp2.isAbsolute(path8)) {
+    return path8;
   }
-  return sp2.join(cwd, path7);
+  return sp2.join(cwd, path8);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -1560,10 +1573,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path7, follow, fsw) {
+  constructor(path8, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path7;
-    this.path = path7 = path7.replace(REPLACER_RE, "");
+    const watchPath = path8;
+    this.path = path8 = path8.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -1703,20 +1716,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((path8) => {
+        const absPath = getAbsolutePath(path8, cwd);
         return absPath;
       });
     }
-    paths.forEach((path7) => {
-      this._removeIgnoredPath(path7);
+    paths.forEach((path8) => {
+      this._removeIgnoredPath(path8);
     });
     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 (path8) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path8, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -1738,17 +1751,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((path8) => {
+      if (!sp2.isAbsolute(path8) && !this._closers.has(path8)) {
         if (cwd)
-          path7 = sp2.join(cwd, path7);
-        path7 = sp2.resolve(path7);
+          path8 = sp2.join(cwd, path8);
+        path8 = sp2.resolve(path8);
       }
-      this._closePath(path7);
-      this._addIgnoredPath(path7);
-      if (this._watched.has(path7)) {
+      this._closePath(path8);
+      this._addIgnoredPath(path8);
+      if (this._watched.has(path8)) {
         this._addIgnoredPath({
-          path: path7,
+          path: path8,
           recursive: true
         });
       }
@@ -1812,38 +1825,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, path8, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path7 = sp2.normalize(path7);
+      path8 = sp2.normalize(path8);
     if (opts.cwd)
-      path7 = sp2.relative(opts.cwd, path7);
-    const args = [path7];
+      path8 = sp2.relative(opts.cwd, path8);
+    const args = [path8];
     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(path8))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path7, [event, ...args]);
+        this._pendingUnlinks.set(path8, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path8) => {
+          this._pendingUnlinks.forEach((entry, path9) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path8);
+            this._pendingUnlinks.delete(path9);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path7)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path8)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path7);
+        this._pendingUnlinks.delete(path8);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -1861,16 +1874,16 @@ var FSWatcher = class extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path7, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path8, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path7, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path8, 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, path8) : path8;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -1901,23 +1914,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, path8, 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(path8);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path7);
+      const item = action.get(path8);
       const count = item ? item.count : 0;
-      action.delete(path7);
+      action.delete(path8);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -1925,7 +1938,7 @@ var FSWatcher = class extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path7, thr);
+    action.set(path8, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -1939,44 +1952,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(path8, 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 = path8;
+    if (this.options.cwd && !sp2.isAbsolute(path8)) {
+      fullPath = sp2.join(this.options.cwd, path8);
     }
     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(path8)) {
           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(path8).lastChange = now2;
         }
-        const pw = writes.get(path7);
+        const pw = writes.get(path8);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path7);
+          writes.delete(path8);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path7)) {
-      writes.set(path7, {
+    if (!writes.has(path8)) {
+      writes.set(path8, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path7);
+          writes.delete(path8);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -1987,8 +2000,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(path8, stats) {
+    if (this.options.atomic && DOT_RE.test(path8))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -1998,17 +2011,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(path8, stats);
   }
-  _isntIgnored(path7, stat4) {
-    return !this._isIgnored(path7, stat4);
+  _isntIgnored(path8, stat4) {
+    return !this._isIgnored(path8, 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(path8) {
+    return new WatchHelper(path8, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -2040,63 +2053,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 path8 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path8);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path8) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path8, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path7);
+    const wp = this._getWatchedDir(path8);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path7, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path8, 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 = path8;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path7);
+      relPath = sp2.relative(this.options.cwd, path8);
     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(path8);
     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(path8))
+      this._emit(eventName, path8);
+    this._closePath(path8);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path7) {
-    this._closeFile(path7);
-    const dir = sp2.dirname(path7);
-    this._getWatchedDir(dir).remove(sp2.basename(path7));
+  _closePath(path8) {
+    this._closeFile(path8);
+    const dir = sp2.dirname(path8);
+    this._getWatchedDir(dir).remove(sp2.basename(path8));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path7) {
-    const closers = this._closers.get(path7);
+  _closeFile(path8) {
+    const closers = this._closers.get(path8);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path7);
+    this._closers.delete(path8);
   }
-  _addPathCloser(path7, closer) {
+  _addPathCloser(path8, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path7);
+    let list = this._closers.get(path8);
     if (!list) {
       list = [];
-      this._closers.set(path7, list);
+      this._closers.set(path8, list);
     }
     list.push(closer);
   }
@@ -2192,10 +2205,358 @@ var PlanWatcher = class {
   }
 };
 
-// src/artifacts/candidates.ts
-import { execFileSync } from "child_process";
+// src/daemon/digest.ts
+var import_yaml = __toESM(require_dist(), 1);
 import fs3 from "fs";
 import path4 from "path";
+import crypto from "crypto";
+var PREVIOUS_EXTRACT_OVERHEAD_TOKENS = 50;
+var CONTEXT_SAFETY_MARGIN = 0.7;
+var EXTRACT_TYPE = "extract";
+var DigestEngine = class {
+  vaultDir;
+  index;
+  llm;
+  config;
+  log;
+  lastCycleTimestampCache = void 0;
+  cycleInProgress = false;
+  modelReady = false;
+  constructor(engineConfig) {
+    this.vaultDir = engineConfig.vaultDir;
+    this.index = engineConfig.index;
+    this.llm = engineConfig.llmProvider;
+    this.config = engineConfig.config;
+    this.log = engineConfig.log ?? (() => {
+    });
+  }
+  /**
+   * Query index for recent vault notes to feed into the digest.
+   * Filters out extract notes (our own output) and caps at max_notes_per_cycle.
+   */
+  discoverSubstrate(lastCycleTimestamp) {
+    const maxNotes = this.config.digest.substrate.max_notes_per_cycle;
+    const notes = lastCycleTimestamp ? this.index.query({ updatedSince: lastCycleTimestamp, limit: maxNotes }) : this.index.query({ limit: maxNotes });
+    const filtered = notes.filter((n) => n.type !== EXTRACT_TYPE);
+    filtered.sort((a, b) => {
+      const weightA = DIGEST_SUBSTRATE_TYPE_WEIGHTS[a.type] ?? 0;
+      const weightB = DIGEST_SUBSTRATE_TYPE_WEIGHTS[b.type] ?? 0;
+      if (weightB !== weightA) return weightB - weightA;
+      return b.created.localeCompare(a.created);
+    });
+    return filtered.slice(0, maxNotes);
+  }
+  /**
+   * Filter configured tiers by the context window available.
+   * Only tiers whose minimum context requirement is met are eligible.
+   */
+  getEligibleTiers() {
+    const contextWindow = this.config.digest.intelligence.context_window;
+    return this.config.digest.tiers.filter((tier) => {
+      const minContext = DIGEST_TIER_MIN_CONTEXT[tier];
+      return minContext !== void 0 && minContext <= contextWindow;
+    });
+  }
+  /**
+   * Format notes compactly for inclusion in the digest prompt.
+   * Stops adding notes once the token budget is exceeded.
+   */
+  formatSubstrate(notes, tokenBudget) {
+    const charBudget = tokenBudget * CHARS_PER_TOKEN;
+    const parts = [];
+    let usedChars = 0;
+    for (const note of notes) {
+      const entry = `### [${note.type}] ${note.id} \u2014 "${note.title}"
+${note.content}`;
+      if (usedChars + entry.length > charBudget && parts.length > 0) break;
+      parts.push(entry);
+      usedChars += entry.length;
+    }
+    return parts.join("\n\n");
+  }
+  /**
+   * Read a previously generated extract for a given tier.
+   * Returns the body (stripped of YAML frontmatter), or null if not found.
+   */
+  readPreviousExtract(tier) {
+    const extractPath = path4.join(this.vaultDir, "digest", `extract-${tier}.md`);
+    let content;
+    try {
+      content = fs3.readFileSync(extractPath, "utf-8");
+    } catch {
+      return null;
+    }
+    return stripFrontmatter(content).body;
+  }
+  /**
+   * Write a digest extract to the vault with YAML frontmatter.
+   * Uses atomic write pattern (temp file + rename).
+   */
+  writeExtract(tier, body, cycleId, model, substrateCount) {
+    const digestDir = path4.join(this.vaultDir, "digest");
+    fs3.mkdirSync(digestDir, { recursive: true });
+    const frontmatter = {
+      type: EXTRACT_TYPE,
+      tier,
+      generated: (/* @__PURE__ */ new Date()).toISOString(),
+      cycle_id: cycleId,
+      substrate_count: substrateCount,
+      model
+    };
+    const fmYaml = import_yaml.default.stringify(frontmatter, {
+      defaultStringType: "QUOTE_DOUBLE",
+      defaultKeyType: "PLAIN"
+    }).trim();
+    const file = `---
+${fmYaml}
+---
+
+${body}
+`;
+    const fullPath = path4.join(digestDir, `extract-${tier}.md`);
+    const tmpPath = `${fullPath}.tmp`;
+    fs3.writeFileSync(tmpPath, file, "utf-8");
+    fs3.renameSync(tmpPath, fullPath);
+  }
+  /**
+   * Append a digest cycle result as a JSON line to trace.jsonl.
+   */
+  appendTrace(record) {
+    const digestDir = path4.join(this.vaultDir, "digest");
+    fs3.mkdirSync(digestDir, { recursive: true });
+    const tracePath = path4.join(digestDir, "trace.jsonl");
+    fs3.appendFileSync(tracePath, JSON.stringify(record) + "\n", "utf-8");
+    this.lastCycleTimestampCache = record.timestamp;
+  }
+  /**
+   * Read the last cycle timestamp from trace.jsonl.
+   * Cached in memory after first read — subsequent calls are O(1).
+   */
+  getLastCycleTimestamp() {
+    if (this.lastCycleTimestampCache !== void 0) return this.lastCycleTimestampCache;
+    const tracePath = path4.join(this.vaultDir, "digest", "trace.jsonl");
+    let content;
+    try {
+      content = fs3.readFileSync(tracePath, "utf-8").trim();
+    } catch {
+      this.lastCycleTimestampCache = null;
+      return null;
+    }
+    if (!content) {
+      this.lastCycleTimestampCache = null;
+      return null;
+    }
+    const lines = content.split("\n");
+    const lastLine = lines[lines.length - 1];
+    try {
+      const record = JSON.parse(lastLine);
+      this.lastCycleTimestampCache = record.timestamp;
+      return record.timestamp;
+    } catch {
+      this.lastCycleTimestampCache = null;
+      return null;
+    }
+  }
+  /**
+   * Run a full digest cycle: discover substrate, generate extracts for each tier.
+   * Returns the cycle result, or null if no substrate was found.
+   */
+  async runCycle() {
+    if (this.cycleInProgress) {
+      this.log("debug", "Cycle already in progress \u2014 skipping");
+      return null;
+    }
+    this.cycleInProgress = true;
+    try {
+      return await this.runCycleInternal();
+    } finally {
+      this.cycleInProgress = false;
+    }
+  }
+  async runCycleInternal() {
+    if (!this.modelReady && this.llm.ensureLoaded) {
+      const { context_window: contextWindow, gpu_kv_cache: gpuKvCache } = this.config.digest.intelligence;
+      this.log("info", "Loading digest model", { contextWindow, gpuKvCache });
+      await this.llm.ensureLoaded(contextWindow, gpuKvCache);
+      this.modelReady = true;
+    }
+    const startTime = Date.now();
+    const lastTimestamp = this.getLastCycleTimestamp();
+    const substrate = this.discoverSubstrate(lastTimestamp);
+    this.log("debug", "Discovering substrate", { lastTimestamp: lastTimestamp ?? "cold start", substrateCount: substrate.length });
+    if (substrate.length === 0) {
+      this.log("debug", "No substrate found \u2014 skipping cycle");
+      return null;
+    }
+    this.log("info", `Starting digest cycle`, { substrateCount: substrate.length });
+    const cycleId = crypto.randomUUID();
+    const eligibleTiers = this.getEligibleTiers();
+    this.log("debug", `Eligible tiers: [${eligibleTiers.join(", ")}]`);
+    const tiersGenerated = [];
+    let totalTokensUsed = 0;
+    let model = "";
+    const typeToKey = {
+      session: "sessions",
+      spore: "spores",
+      plan: "plans",
+      artifact: "artifacts",
+      "team-member": "team"
+    };
+    const substrateIndex = {
+      sessions: [],
+      spores: [],
+      plans: [],
+      artifacts: [],
+      team: []
+    };
+    for (const note of substrate) {
+      const key = typeToKey[note.type];
+      if (key) {
+        substrateIndex[key].push(note.id);
+      }
+    }
+    const systemPrompt = loadPrompt("digest-system");
+    for (const tier of eligibleTiers) {
+      const tierPrompt = loadPrompt(`digest-${tier}`);
+      const previousExtract = this.readPreviousExtract(tier);
+      const contextWindow = this.config.digest.intelligence.context_window;
+      const systemPromptTokens = estimateTokens(systemPrompt);
+      const tierPromptTokens = estimateTokens(tierPrompt);
+      const previousExtractTokens = previousExtract ? estimateTokens(previousExtract) + PREVIOUS_EXTRACT_OVERHEAD_TOKENS : 0;
+      const availableTokens = Math.floor(contextWindow * CONTEXT_SAFETY_MARGIN);
+      const substrateBudget = availableTokens - tier - systemPromptTokens - tierPromptTokens - previousExtractTokens;
+      if (substrateBudget <= 0) continue;
+      const formattedSubstrate = this.formatSubstrate(substrate, substrateBudget);
+      const promptParts = [tierPrompt];
+      if (previousExtract) {
+        promptParts.push("", "## Previous Synthesis", "", previousExtract);
+      }
+      promptParts.push("", "## New Substrate", "", formattedSubstrate);
+      promptParts.push(
+        "",
+        "---",
+        "Produce your updated synthesis now. Stay within the token budget specified above."
+      );
+      const userPrompt = promptParts.join("\n");
+      const promptTokens = estimateTokens(systemPrompt + userPrompt);
+      this.log("debug", `Tier ${tier}: sending LLM request`, { promptTokens, maxTokens: tier, substrateBudget });
+      const tierStart = Date.now();
+      const digestConfig = this.config.digest.intelligence;
+      const opts = {
+        maxTokens: tier,
+        timeoutMs: DIGEST_LLM_REQUEST_TIMEOUT_MS,
+        contextLength: contextWindow,
+        reasoning: "off",
+        systemPrompt,
+        keepAlive: digestConfig.keep_alive ?? void 0
+      };
+      const response = await this.llm.summarize(userPrompt, opts);
+      const tierDuration = Date.now() - tierStart;
+      const extractText = stripReasoningTokens(response.text);
+      model = response.model;
+      const responseTokens = estimateTokens(extractText);
+      totalTokensUsed += promptTokens + responseTokens;
+      this.log("info", `Tier ${tier}: completed`, { durationMs: tierDuration, responseTokens, model: response.model });
+      this.writeExtract(tier, extractText, cycleId, response.model, substrate.length);
+      tiersGenerated.push(tier);
+    }
+    const result = {
+      cycleId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      substrate: substrateIndex,
+      tiersGenerated,
+      model,
+      durationMs: Date.now() - startTime,
+      tokensUsed: totalTokensUsed
+    };
+    this.appendTrace(result);
+    return result;
+  }
+};
+var MS_PER_SECOND2 = 1e3;
+var Metabolism = class {
+  state = "active";
+  currentIntervalMs;
+  cooldownStep = 0;
+  lastSubstrateTime;
+  timer = null;
+  activeIntervalMs;
+  cooldownIntervalsMs;
+  dormancyThresholdMs;
+  constructor(config) {
+    this.activeIntervalMs = config.active_interval * MS_PER_SECOND2;
+    this.cooldownIntervalsMs = config.cooldown_intervals.map((s) => s * MS_PER_SECOND2);
+    this.dormancyThresholdMs = config.dormancy_threshold * MS_PER_SECOND2;
+    this.currentIntervalMs = this.activeIntervalMs;
+    this.lastSubstrateTime = Date.now();
+  }
+  /** Reset to active state when new substrate is found. */
+  onSubstrateFound() {
+    this.state = "active";
+    this.cooldownStep = 0;
+    this.currentIntervalMs = this.activeIntervalMs;
+    this.lastSubstrateTime = Date.now();
+  }
+  /** Advance cooldown when a cycle finds no new substrate. */
+  onEmptyCycle() {
+    if (this.state === "dormant") return;
+    this.state = "cooling";
+    if (this.cooldownStep < this.cooldownIntervalsMs.length) {
+      this.currentIntervalMs = this.cooldownIntervalsMs[this.cooldownStep];
+      this.cooldownStep++;
+    }
+    this.checkDormancy();
+  }
+  /** Enter dormant state if enough time has elapsed since last substrate. */
+  checkDormancy() {
+    const elapsed = Date.now() - this.lastSubstrateTime;
+    if (elapsed >= this.dormancyThresholdMs) {
+      this.state = "dormant";
+    }
+  }
+  /** Return to active from any state, resetting timers and rescheduling immediately. */
+  activate() {
+    this.onSubstrateFound();
+    if (this.callback) {
+      this.reschedule();
+    }
+  }
+  /** Set lastSubstrateTime explicitly (for testing). */
+  markLastSubstrate(time) {
+    this.lastSubstrateTime = time;
+  }
+  /** Begin scheduling digest cycles with adaptive intervals. */
+  start(callback) {
+    this.callback = callback;
+    this.reschedule();
+  }
+  /** Stop the timer. */
+  stop() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+  callback = null;
+  reschedule() {
+    this.stop();
+    if (!this.callback) return;
+    const cb = this.callback;
+    const schedule = () => {
+      this.timer = setTimeout(async () => {
+        await cb();
+        schedule();
+      }, this.currentIntervalMs);
+      this.timer.unref();
+    };
+    schedule();
+  }
+};
+
+// src/artifacts/candidates.ts
+import { execFileSync } from "child_process";
+import fs4 from "fs";
+import path5 from "path";
 var EXCLUDED_FILENAMES = /* @__PURE__ */ new Set([
   "claude.md",
   "agents.md",
@@ -2216,7 +2577,7 @@ var EXCLUDED_PREFIXES = [
   ".github/"
 ];
 function isExcludedPath(relativePath) {
-  const basename3 = path4.basename(relativePath).toLowerCase();
+  const basename3 = path5.basename(relativePath).toLowerCase();
   if (EXCLUDED_FILENAMES.has(basename3)) return true;
   const normalized = relativePath.replace(/\\/g, "/");
   return EXCLUDED_PREFIXES.some((prefix) => normalized.startsWith(prefix));
@@ -2224,7 +2585,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(path5.extname(absPath))
   );
   if (extFiltered.length === 0) return [];
   const ignoredSet = getGitIgnored(extFiltered, projectRoot);
@@ -2232,8 +2593,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 = path5.relative(projectRoot, absPath);
       if (isExcludedPath(relativePath)) continue;
       candidates.push({ path: relativePath, content });
     } catch {
@@ -2255,23 +2616,23 @@ function getGitIgnored(filePaths, cwd) {
 }
 
 // src/artifacts/slugify.ts
-import crypto from "crypto";
-import path5 from "path";
+import crypto2 from "crypto";
+import path6 from "path";
 function slugifyPath(relativePath) {
-  const ext = path5.extname(relativePath);
+  const ext = path6.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) {
-    const hash = crypto.createHash("sha256").update(relativePath).digest("hex").slice(0, 6);
+    const hash = crypto2.createHash("sha256").update(relativePath).digest("hex").slice(0, 6);
     slug = slug.slice(0, MAX_SLUG_LENGTH) + "-" + hash;
   }
   return slug;
 }
 
 // src/daemon/main.ts
-var import_yaml = __toESM(require_dist(), 1);
-import fs4 from "fs";
-import path6 from "path";
+var import_yaml2 = __toESM(require_dist(), 1);
+import fs5 from "fs";
+import path7 from "path";
 function indexAndEmbed(relativePath, noteId, embeddingText, metadata, deps) {
   indexNote(deps.index, deps.vaultDir, relativePath);
   if (deps.vectorIndex && embeddingText) {
@@ -2286,7 +2647,7 @@ function writeObservations(observations, sessionId, deps) {
       note.id,
       `${note.observation.title}
 ${note.observation.content}`,
-      { type: "memory", importance: "high", session_id: sessionId },
+      { type: "spore", importance: "high", session_id: sessionId },
       deps
     );
     deps.logger.info("processor", "Observation written", { type: note.observation.type, title: note.observation.title, session_id: sessionId });
@@ -2323,29 +2684,29 @@ ${candidate.content}`,
     lineage?.registerArtifactForSession(sessionId, artifactId);
   }
 }
-function migrateMemoryFiles(vaultDir) {
-  const memoriesDir = path6.join(vaultDir, "memories");
-  if (!fs4.existsSync(memoriesDir)) return 0;
+function migrateSporeFiles(vaultDir) {
+  const sporesDir = path7.join(vaultDir, "spores");
+  if (!fs5.existsSync(sporesDir)) return 0;
   let moved = 0;
-  const entries = fs4.readdirSync(memoriesDir);
+  const entries = fs5.readdirSync(sporesDir);
   for (const entry of entries) {
-    const fullPath = path6.join(memoriesDir, entry);
+    const fullPath = path7.join(sporesDir, entry);
     if (!entry.endsWith(".md")) continue;
-    if (fs4.statSync(fullPath).isDirectory()) continue;
+    if (fs5.statSync(fullPath).isDirectory()) continue;
     try {
-      const content = fs4.readFileSync(fullPath, "utf-8");
+      const content = fs5.readFileSync(fullPath, "utf-8");
       const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
       if (!fmMatch) continue;
-      const parsed = import_yaml.default.parse(fmMatch[1]);
+      const parsed = import_yaml2.default.parse(fmMatch[1]);
       const obsType = parsed.observation_type;
       if (!obsType) continue;
       const normalizedType = obsType.replace(/_/g, "-");
-      const targetDir = path6.join(memoriesDir, normalizedType);
-      fs4.mkdirSync(targetDir, { recursive: true });
-      const targetPath = path6.join(targetDir, entry);
-      fs4.renameSync(fullPath, targetPath);
+      const targetDir = path7.join(sporesDir, normalizedType);
+      fs5.mkdirSync(targetDir, { recursive: true });
+      const targetPath = path7.join(targetDir, entry);
+      fs5.renameSync(fullPath, targetPath);
       const now = /* @__PURE__ */ new Date();
-      fs4.utimesSync(targetPath, now, now);
+      fs5.utimesSync(targetPath, now, now);
       moved++;
     } catch {
     }
@@ -2358,9 +2719,9 @@ async function main() {
     process.stderr.write("Usage: mycod --vault <path>\n");
     process.exit(1);
   }
-  const vaultDir = path6.resolve(vaultArg);
+  const vaultDir = path7.resolve(vaultArg);
   const config = loadConfig(vaultDir);
-  const logger = new DaemonLogger(path6.join(vaultDir, "logs"), {
+  const logger = new DaemonLogger(path7.join(vaultDir, "logs"), {
     level: config.daemon.log_level,
     maxSize: config.daemon.max_log_size
   });
@@ -2369,6 +2730,7 @@ async function main() {
     gracePeriod: config.daemon.grace_period,
     onEmpty: async () => {
       logger.info("daemon", "Grace period expired, shutting down");
+      metabolism?.stop();
       planWatcher.stopFileWatcher();
       await server.stop();
       vectorIndex?.close();
@@ -2382,14 +2744,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(path7.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);
+  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(path7.join(vaultDir, "index.db"));
   const lineageGraph = new LineageGraph(vaultDir);
   const transcriptMiner = new TranscriptMiner({
     additionalAdapters: config.capture.transcript_paths.map(
@@ -2398,24 +2760,25 @@ async function main() {
   });
   let activeStopProcessing = null;
   const indexDeps = { index, vaultDir, vectorIndex, embeddingProvider, logger };
-  const bufferDir = path6.join(vaultDir, "buffer");
+  const bufferDir = path7.join(vaultDir, "buffer");
   const sessionBuffers = /* @__PURE__ */ new Map();
   const sessionFilePaths = /* @__PURE__ */ new Map();
   const capturedArtifactPaths = /* @__PURE__ */ new Map();
-  if (fs4.existsSync(bufferDir)) {
+  if (fs5.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 fs5.readdirSync(bufferDir)) {
+      const filePath = path7.join(bufferDir, file);
+      const stat4 = fs5.statSync(filePath);
       if (stat4.mtimeMs < cutoff) {
-        fs4.unlinkSync(filePath);
+        fs5.unlinkSync(filePath);
         logger.debug("daemon", "Cleaned stale buffer", { file });
       }
     }
   }
-  const migrated = migrateMemoryFiles(vaultDir);
+  const needsMigrationReindex = index.query({ type: "memory" }).length > 0;
+  const migrated = migrateSporeFiles(vaultDir);
   if (migrated > 0) {
-    logger.info("daemon", "Migrated memory files to type subdirectories", { count: migrated });
+    logger.info("daemon", "Migrated spore files to type subdirectories", { count: migrated });
     initFts(index);
     rebuildIndex(index, vaultDir);
   }
@@ -2444,10 +2807,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 = fs5.readFileSync(event.filePath, "utf-8");
+          const relativePath = path7.relative(vaultDir, event.filePath);
+          const title = content.match(/^#\s+(.+)$/m)?.[1] ?? path7.basename(event.filePath);
+          const planId = `plan-${path7.basename(event.filePath, ".md")}`;
           indexAndEmbed(
             relativePath,
             planId,
@@ -2468,6 +2831,51 @@ ${content}`,
     }
   });
   planWatcher.startFileWatcher();
+  let metabolism = null;
+  if (config.digest.enabled) {
+    const digestLlmConfig = {
+      provider: config.digest.intelligence.provider ?? config.intelligence.llm.provider,
+      model: config.digest.intelligence.model ?? config.intelligence.llm.model,
+      base_url: config.digest.intelligence.base_url ?? config.intelligence.llm.base_url,
+      context_window: config.digest.intelligence.context_window
+    };
+    logger.debug("digest", "Digest LLM config", digestLlmConfig);
+    const digestLlm = config.digest.intelligence.model || config.digest.intelligence.provider ? createLlmProvider(digestLlmConfig) : llmProvider;
+    logger.debug("digest", `Using ${digestLlm.name} provider for digest`);
+    const digestEngine = new DigestEngine({
+      vaultDir,
+      index,
+      llmProvider: digestLlm,
+      config,
+      log: (level, message, data) => logger[level]("digest", message, data)
+    });
+    metabolism = new Metabolism(config.digest.metabolism);
+    logger.debug("digest", "Firing initial digest cycle (background)");
+    digestEngine.runCycle().then((result) => {
+      if (result) {
+        metabolism.onSubstrateFound();
+        logger.info("digest", `Initial digest cycle: ${result.tiersGenerated.length} tiers, ${result.durationMs}ms`);
+      }
+    }).catch((err) => {
+      logger.warn("digest", "Initial digest cycle failed", { error: err.message });
+    });
+    metabolism.start(async () => {
+      try {
+        const cycleResult = await digestEngine.runCycle();
+        if (cycleResult) {
+          metabolism.onSubstrateFound();
+          logger.info("digest", `Digest cycle ${cycleResult.cycleId}: ${cycleResult.tiersGenerated.length} tiers`);
+        } else {
+          metabolism.onEmptyCycle();
+          logger.debug("digest", "No substrate, backing off");
+        }
+      } catch (err) {
+        logger.warn("digest", "Digest cycle failed", { error: err.message });
+        metabolism.onEmptyCycle();
+      }
+    });
+    logger.info("digest", "Digest enabled \u2014 starting metabolism");
+  }
   const batchManager = new BatchManager(async (closedBatch) => {
     if (closedBatch.length === 0) return;
     const sessionId = closedBatch[0].session_id;
@@ -2498,7 +2906,7 @@ ${content}`,
           }
           const captured = capturedArtifactPaths.get(sessionId);
           for (const c of candidates) {
-            const absPath = path6.resolve(process.cwd(), c.path);
+            const absPath = path7.resolve(process.cwd(), c.path);
             captured.add(absPath);
           }
         }).catch((err) => logger.warn("processor", "Incremental artifact capture failed", {
@@ -2529,6 +2937,7 @@ ${content}`,
     } catch (err) {
       logger.debug("lineage", "Heuristic detection failed", { error: err.message });
     }
+    metabolism?.activate();
     logger.info("lifecycle", "Session registered", { session_id, branch });
     return { ok: true, sessions: registry.sessions };
   });
@@ -2537,14 +2946,14 @@ ${content}`,
     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 fs5.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 = path7.join(bufferDir, file);
+        const stat4 = fs5.statSync(filePath);
         if (stat4.mtimeMs < cutoff) {
-          fs4.unlinkSync(filePath);
+          fs5.unlinkSync(filePath);
           logger.debug("daemon", "Cleaned stale buffer", { file });
         }
       }
@@ -2639,15 +3048,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 = path7.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 fs5.readdirSync(sessionsDir)) {
+        const candidate = path7.join(sessionsDir, dateDir, sessionFileName);
         try {
-          const content = fs4.readFileSync(candidate, "utf-8");
+          const content = fs5.readFileSync(candidate, "utf-8");
           if (!existingContent || content.length > existingContent.length) {
             existingContent = content;
           }
@@ -2707,20 +3116,20 @@ ${conversationText}`;
     }
     const date = started.slice(0, 10);
     const relativePath = sessionRelativePath(sessionId, date);
-    const targetFullPath = path6.join(vaultDir, relativePath);
+    const targetFullPath = path7.join(vaultDir, relativePath);
     for (const dup of duplicatePaths) {
       if (dup !== targetFullPath) {
         try {
-          fs4.unlinkSync(dup);
+          fs5.unlinkSync(dup);
           logger.debug("lifecycle", "Removed duplicate session file", { path: dup });
         } catch {
         }
       }
     }
-    const attachmentsDir = path6.join(vaultDir, "attachments");
+    const attachmentsDir = path7.join(vaultDir, "attachments");
     const hasImages = allTurns.some((t) => t.images?.length);
     if (hasImages) {
-      fs4.mkdirSync(attachmentsDir, { recursive: true });
+      fs5.mkdirSync(attachmentsDir, { recursive: true });
     }
     const turnImageNames = /* @__PURE__ */ new Map();
     for (let i = 0; i < allTurns.length; i++) {
@@ -2731,9 +3140,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 = path7.join(attachmentsDir, filename);
+        if (!fs5.existsSync(filePath)) {
+          fs5.writeFileSync(filePath, Buffer.from(img.data, "base64"));
           logger.debug("processor", "Image saved", { filename, turn: i + 1 });
         }
         names.push(filename);
@@ -2746,7 +3155,7 @@ ${conversationText}`;
       title = summaryResult.title;
       narrative = summaryResult.summary;
     }
-    const relatedMemories = index.query({ type: "memory", limit: RELATED_MEMORIES_LIMIT }).filter((n) => {
+    const relatedMemories = index.query({ type: "spore", limit: RELATED_SPORES_LIMIT }).filter((n) => {
       const fm = n.frontmatter;
       return fm.session === sessionNoteId(sessionId) || fm.session === sessionId;
     }).map((n) => ({ id: n.id, title: n.title }));
@@ -2838,6 +3247,17 @@ ${conversationText}`;
     const { session_id, branch } = ContextBody.parse(body);
     logger.debug("hooks", "Session context query", { session_id });
     try {
+      if (config.digest.enabled && config.digest.inject_tier) {
+        const result = handleMycoContext(vaultDir, { tier: config.digest.inject_tier });
+        if (result.generated !== void 0) {
+          const meta = [result.content];
+          if (branch) meta.push(`
+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 };
+        }
+      }
       const parts = [];
       const plans = index.query({ type: "plan" });
       const activePlans = plans.filter((p) => {
@@ -2888,8 +3308,8 @@ ${planLines.join("\n")}`);
     try {
       const emb = await generateEmbedding(embeddingProvider, prompt.slice(0, EMBEDDING_INPUT_LIMIT));
       const results = vectorIndex.search(emb.embedding, {
-        limit: PROMPT_CONTEXT_MAX_MEMORIES,
-        type: "memory",
+        limit: PROMPT_CONTEXT_MAX_SPORES,
+        type: "spore",
         relativeThreshold: PROMPT_CONTEXT_MIN_SIMILARITY
       });
       if (results.length === 0) return { text: "" };
@@ -2906,11 +3326,11 @@ ${planLines.join("\n")}`);
         lines.push(`- [${obsType}] ${note.title}: ${note.content.slice(0, CONTENT_SNIPPET_CHARS)} \`[${note.id}]\``);
       }
       if (lines.length === 0) return { text: "" };
-      const injected = `**Relevant memories for this task:**
+      const injected = `**Relevant spores for this task:**
 ${lines.join("\n")}`;
       logger.debug("context", "Prompt context injected", {
         session_id,
-        memories: lines.length,
+        spores: lines.length,
         prompt_preview: prompt.slice(0, 50)
       });
       return { text: injected };
@@ -2921,12 +3341,21 @@ ${lines.join("\n")}`;
   });
   await server.start();
   logger.info("daemon", "Daemon ready", { vault: vaultDir, port: server.port });
+  if (needsMigrationReindex) {
+    setImmediate(() => {
+      logger.info("daemon", "Rebuilding index after memories\u2192spores migration (background)");
+      initFts(index);
+      rebuildIndex(index, vaultDir);
+      logger.info("daemon", "Migration reindex complete");
+    });
+  }
   const shutdown = async (signal) => {
     logger.info("daemon", `${signal} received`);
     if (activeStopProcessing) {
       logger.info("daemon", "Waiting for active stop processing to complete...");
       await activeStopProcessing;
     }
+    metabolism?.stop();
     planWatcher.stopFileWatcher();
     registry.destroy();
     await server.stop();
@@ -2940,11 +3369,11 @@ ${lines.join("\n")}`;
 }
 export {
   main,
-  migrateMemoryFiles
+  migrateSporeFiles
 };
 /*! Bundled license information:
 
 chokidar/index.js:
   (*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) *)
 */
-//# sourceMappingURL=main-S3WSUF5T.js.map
+//# sourceMappingURL=main-3JSO25IZ.js.map