@goondocks/myco 0.6.2 → 0.6.4

package/dist/{main-3JZDUJLU.js → main-6AGPIMH2.js}

@@ -1,26 +1,26 @@
 import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
 import {
   gatherStats
-} from "./chunk-HRGHDMYI.js";
+} from "./chunk-NL6WQO56.js";
 import {
   BufferProcessor,
   DigestEngine,
   Metabolism,
   SUMMARIZATION_FAILED_MARKER,
-  TranscriptMiner,
   appendTraceRecord,
-  extractTurnsFromBuffer,
+  readLastRecord,
   readLastTimestamp,
   runCuration,
   runDigest,
   runRebuild,
   runReprocess,
+  updateTitleAndSummary,
   writeObservationNotes
-} from "./chunk-PQWQC3RF.js";
+} from "./chunk-4XVKZ3WA.js";
 import {
   consolidateSpores,
   handleMycoContext
-} from "./chunk-LDKXXKF6.js";
+} from "./chunk-2ZIBCEYO.js";
 import {
   DaemonLogger
 } from "./chunk-QLUE3BUL.js";
@@ -31,10 +31,9 @@ import {
   CONVERSATION_HEADING,
   VaultWriter,
   bareSessionId,
-  buildSimilarityPrompt,
   checkSupersession,
   extractJson,
-  extractNumber,
+  extractSection,
   formatNotesForPrompt,
   formatSessionBody,
   indexNote,
@@ -44,51 +43,54 @@ import {
   sessionNoteId,
   sessionRelativePath,
   sessionWikilink,
-  stripReasoningTokens
-} from "./chunk-ALBVNGCF.js";
+  stripReasoningTokens,
+  walkMarkdownFiles
+} from "./chunk-UP4P4OAA.js";
 import {
   generateEmbedding
 } from "./chunk-RGVBGTD6.js";
 import {
   createEmbeddingProvider,
   createLlmProvider
-} from "./chunk-V5R6O6RP.js";
-import "./chunk-RY76WEN3.js";
+} from "./chunk-NLUE6CYG.js";
+import {
+  stripFrontmatter
+} from "./chunk-GENQ5QGP.js";
 import {
   initFts
 } from "./chunk-6FQISQNA.js";
 import {
   MycoIndex
 } from "./chunk-TWSTAVLO.js";
-import "./chunk-25DJSF2K.js";
+import "./chunk-YTFXA4RX.js";
 import "./chunk-SAKJMNSR.js";
 import {
   LmStudioBackend,
   OllamaBackend
-} from "./chunk-MWW62YZP.js";
+} from "./chunk-7WHF2OIZ.js";
 import {
   CONFIG_FILENAME,
   loadConfig,
   saveConfig
-} from "./chunk-YG6MLLGL.js";
+} from "./chunk-HYVT345Y.js";
 import {
   MycoConfigSchema,
   external_exports,
   require_dist
-} from "./chunk-JSK7L46L.js";
+} from "./chunk-ERG2IEWX.js";
 import {
   EventBuffer
 } from "./chunk-HIN3UVOG.js";
 import {
   getPluginVersion
-} from "./chunk-CK24O5YQ.js";
+} from "./chunk-QN4W3JUA.js";
 import {
+  AgentRegistry,
   claudeCodeAdapter,
   createPerProjectAdapter,
   extensionForMimeType
-} from "./chunk-RNWALAFP.js";
+} from "./chunk-Z74SDEKE.js";
 import {
-  CANDIDATE_CONTENT_PREVIEW,
   CONSOLIDATION_MAX_TOKENS,
   CONSOLIDATION_MIN_CLUSTER_SIZE,
   CONSOLIDATION_VECTOR_FETCH_LIMIT,
@@ -98,16 +100,27 @@ import {
   DAEMON_EVICT_TIMEOUT_MS,
   EMBEDDING_INPUT_LIMIT,
   FILE_WATCH_STABILITY_MS,
+  ITEM_STAGE_MAP,
   LINEAGE_RECENT_SESSIONS_LIMIT,
   LLM_REASONING_MODE,
   MAX_SLUG_LENGTH,
+  MS_PER_DAY,
+  PIPELINE_BACKOFF_MULTIPLIER,
+  PIPELINE_ITEMS_DEFAULT_LIMIT,
+  PIPELINE_PARSE_MAX_RETRIES,
+  PIPELINE_PROVIDER_ROLES,
+  PIPELINE_STAGES,
+  PIPELINE_TICK_STAGES,
   PROMPT_CONTEXT_MAX_SPORES,
   PROMPT_CONTEXT_MIN_LENGTH,
   PROMPT_CONTEXT_MIN_SIMILARITY,
+  PROMPT_PREVIEW_CHARS,
   RELATED_SPORES_LIMIT,
   SESSION_CONTEXT_MAX_PLANS,
-  STALE_BUFFER_MAX_AGE_MS
-} from "./chunk-WBLTISAK.js";
+  STAGE_PROVIDER_MAP,
+  STALE_BUFFER_MAX_AGE_MS,
+  estimateTokens
+} from "./chunk-J4D4CROB.js";
 import {
   __toESM
 } from "./chunk-PZUWP5VK.js";
@@ -502,10 +515,6 @@ 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;
-var LINEAGE_SIMILARITY_HIGH_CONFIDENCE = 0.9;
-var LINEAGE_SIMILARITY_CANDIDATES = 3;
-var LINEAGE_SIMILARITY_MAX_TOKENS = 8;
 var MS_PER_SECOND = 1e3;
 var MS_PER_HOUR = 36e5;
 var LineageGraph = class {
@@ -697,7 +706,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path10) => statMethod(path10, { bigint: true });
+      this._stat = (path12) => statMethod(path12, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -722,8 +731,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path10, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path10));
+          const { path: path12, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path12));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -763,20 +772,20 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path10, depth) {
+  async _exploreDir(path12, depth) {
     let files;
     try {
-      files = await readdir(path10, this._rdOptions);
+      files = await readdir(path12, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path10 };
+    return { files, depth, path: path12 };
   }
-  async _formatEntry(dirent, path10) {
+  async _formatEntry(dirent, path12) {
     let entry;
     const basename3 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path10, basename3));
+      const fullPath = presolve(pjoin(path12, basename3));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename3 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -1176,16 +1185,16 @@ var delFromSet = (main2, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path10, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path12, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path10);
-    emitRaw(rawEvent, evPath, { watchedPath: path10 });
-    if (evPath && path10 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path10, evPath), KEY_LISTENERS, sp.join(path10, evPath));
+    listener(path12);
+    emitRaw(rawEvent, evPath, { watchedPath: path12 });
+    if (evPath && path12 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path12, evPath), KEY_LISTENERS, sp.join(path12, evPath));
     }
   };
   try {
-    return fs_watch(path10, {
+    return fs_watch(path12, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -1201,12 +1210,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path10, fullPath, options, handlers) => {
+var setFsWatchListener = (path12, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path10, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path12, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -1217,7 +1226,7 @@ var setFsWatchListener = (path10, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path10,
+      path12,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -1232,7 +1241,7 @@ var setFsWatchListener = (path10, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path10, "r");
+          const fd = await open(path12, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -1263,7 +1272,7 @@ var setFsWatchListener = (path10, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path10, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path12, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -1285,7 +1294,7 @@ var setFsWatchFileListener = (path10, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path10, curr));
+          foreach(cont.listeners, (listener2) => listener2(path12, curr));
         }
       })
     };
@@ -1315,13 +1324,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path10, listener) {
+  _watchWithNodeFs(path12, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path10);
-    const basename3 = sp.basename(path10);
+    const directory = sp.dirname(path12);
+    const basename3 = sp.basename(path12);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename3);
-    const absolutePath = sp.resolve(path10);
+    const absolutePath = sp.resolve(path12);
     const options = {
       persistent: opts.persistent
     };
@@ -1331,12 +1340,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename3) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path10, absolutePath, options, {
+      closer = setFsWatchFileListener(path12, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path10, absolutePath, options, {
+      closer = setFsWatchListener(path12, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -1358,7 +1367,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename3))
       return;
-    const listener = async (path10, newStats) => {
+    const listener = async (path12, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -1372,11 +1381,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path10);
+            this.fsw._closeFile(path12);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path10, closer2);
+              this.fsw._addPathCloser(path12, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -1408,7 +1417,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, path10, item) {
+  async _handleSymlink(entry, directory, path12, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -1418,7 +1427,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path10);
+        linkPath = await fsrealpath(path12);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -1428,12 +1437,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, path10, entry.stats);
+          this.fsw._emit(EV.CHANGE, path12, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path10, entry.stats);
+        this.fsw._emit(EV.ADD, path12, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -1463,9 +1472,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path10 = sp.join(directory, item);
+      let path12 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path10, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path12, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -1474,8 +1483,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path10 = sp.join(dir, sp.relative(dir, path10));
-        this._addToNodeFs(path10, initialAdd, wh, depth + 1);
+        path12 = sp.join(dir, sp.relative(dir, path12));
+        this._addToNodeFs(path12, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve3, reject) => {
@@ -1544,13 +1553,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path10, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path12, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path10) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path12) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path10);
+    const wh = this.fsw._getWatchHelpers(path12);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -1566,8 +1575,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path10);
-        const targetPath = follow ? await fsrealpath(path10) : path10;
+        const absPath = sp.resolve(path12);
+        const targetPath = follow ? await fsrealpath(path12) : path12;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -1577,29 +1586,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path10) : path10;
+        const targetPath = follow ? await fsrealpath(path12) : path12;
         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, path10, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path12, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path10), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path12), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path10, closer);
+        this.fsw._addPathCloser(path12, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path10;
+        return path12;
       }
     }
   }
@@ -1642,24 +1651,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path10) {
-  if (typeof path10 !== "string")
+function normalizePath(path12) {
+  if (typeof path12 !== "string")
     throw new Error("string expected");
-  path10 = sp2.normalize(path10);
-  path10 = path10.replace(/\\/g, "/");
+  path12 = sp2.normalize(path12);
+  path12 = path12.replace(/\\/g, "/");
   let prepend = false;
-  if (path10.startsWith("//"))
+  if (path12.startsWith("//"))
     prepend = true;
-  path10 = path10.replace(DOUBLE_SLASH_RE, "/");
+  path12 = path12.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path10 = "/" + path10;
-  return path10;
+    path12 = "/" + path12;
+  return path12;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path10 = normalizePath(testString);
+  const path12 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path10, stats)) {
+    if (pattern(path12, stats)) {
       return true;
     }
   }
@@ -1697,19 +1706,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-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));
+var normalizePathToUnix = (path12) => toUnix(sp2.normalize(toUnix(path12)));
+var normalizeIgnored = (cwd = "") => (path12) => {
+  if (typeof path12 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path12) ? path12 : sp2.join(cwd, path12));
   } else {
-    return path10;
+    return path12;
   }
 };
-var getAbsolutePath = (path10, cwd) => {
-  if (sp2.isAbsolute(path10)) {
-    return path10;
+var getAbsolutePath = (path12, cwd) => {
+  if (sp2.isAbsolute(path12)) {
+    return path12;
   }
-  return sp2.join(cwd, path10);
+  return sp2.join(cwd, path12);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -1774,10 +1783,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path10, follow, fsw) {
+  constructor(path12, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path10;
-    this.path = path10 = path10.replace(REPLACER_RE, "");
+    const watchPath = path12;
+    this.path = path12 = path12.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -1917,20 +1926,20 @@ var FSWatcher = class extends EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path10) => {
-        const absPath = getAbsolutePath(path10, cwd);
+      paths = paths.map((path12) => {
+        const absPath = getAbsolutePath(path12, cwd);
         return absPath;
       });
     }
-    paths.forEach((path10) => {
-      this._removeIgnoredPath(path10);
+    paths.forEach((path12) => {
+      this._removeIgnoredPath(path12);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path10) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path10, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path12) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path12, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -1952,17 +1961,17 @@ var FSWatcher = class extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path10) => {
-      if (!sp2.isAbsolute(path10) && !this._closers.has(path10)) {
+    paths.forEach((path12) => {
+      if (!sp2.isAbsolute(path12) && !this._closers.has(path12)) {
         if (cwd)
-          path10 = sp2.join(cwd, path10);
-        path10 = sp2.resolve(path10);
+          path12 = sp2.join(cwd, path12);
+        path12 = sp2.resolve(path12);
       }
-      this._closePath(path10);
-      this._addIgnoredPath(path10);
-      if (this._watched.has(path10)) {
+      this._closePath(path12);
+      this._addIgnoredPath(path12);
+      if (this._watched.has(path12)) {
         this._addIgnoredPath({
-          path: path10,
+          path: path12,
           recursive: true
         });
       }
@@ -2026,38 +2035,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, path10, stats) {
+  async _emit(event, path12, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path10 = sp2.normalize(path10);
+      path12 = sp2.normalize(path12);
     if (opts.cwd)
-      path10 = sp2.relative(opts.cwd, path10);
-    const args = [path10];
+      path12 = sp2.relative(opts.cwd, path12);
+    const args = [path12];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path10))) {
+    if (awf && (pw = this._pendingWrites.get(path12))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path10, [event, ...args]);
+        this._pendingUnlinks.set(path12, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path11) => {
+          this._pendingUnlinks.forEach((entry, path13) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path11);
+            this._pendingUnlinks.delete(path13);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path10)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path12)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path10);
+        this._pendingUnlinks.delete(path12);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -2075,16 +2084,16 @@ var FSWatcher = class extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path10, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path12, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path10, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path12, 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, path10) : path10;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path12) : path12;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -2115,23 +2124,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, path10, timeout) {
+  _throttle(actionType, path12, 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(path10);
+    const actionPath = action.get(path12);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path10);
+      const item = action.get(path12);
       const count = item ? item.count : 0;
-      action.delete(path10);
+      action.delete(path12);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -2139,7 +2148,7 @@ var FSWatcher = class extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path10, thr);
+    action.set(path12, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -2153,44 +2162,44 @@ var FSWatcher = class extends EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path10, threshold, event, awfEmit) {
+  _awaitWriteFinish(path12, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path10;
-    if (this.options.cwd && !sp2.isAbsolute(path10)) {
-      fullPath = sp2.join(this.options.cwd, path10);
+    let fullPath = path12;
+    if (this.options.cwd && !sp2.isAbsolute(path12)) {
+      fullPath = sp2.join(this.options.cwd, path12);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path10)) {
+        if (err || !writes.has(path12)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path10).lastChange = now2;
+          writes.get(path12).lastChange = now2;
         }
-        const pw = writes.get(path10);
+        const pw = writes.get(path12);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path10);
+          writes.delete(path12);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path10)) {
-      writes.set(path10, {
+    if (!writes.has(path12)) {
+      writes.set(path12, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path10);
+          writes.delete(path12);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -2201,8 +2210,8 @@ var FSWatcher = class extends EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path10, stats) {
-    if (this.options.atomic && DOT_RE.test(path10))
+  _isIgnored(path12, stats) {
+    if (this.options.atomic && DOT_RE.test(path12))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -2212,17 +2221,17 @@ var FSWatcher = class extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path10, stats);
+    return this._userIgnored(path12, stats);
   }
-  _isntIgnored(path10, stat4) {
-    return !this._isIgnored(path10, stat4);
+  _isntIgnored(path12, stat4) {
+    return !this._isIgnored(path12, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path10) {
-    return new WatchHelper(path10, this.options.followSymlinks, this);
+  _getWatchHelpers(path12) {
+    return new WatchHelper(path12, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -2254,63 +2263,63 @@ var FSWatcher = class extends EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    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))
+    const path12 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path12);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path12) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path12, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path10);
+    const wp = this._getWatchedDir(path12);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path10, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path12, 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 = path10;
+    let relPath = path12;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path10);
+      relPath = sp2.relative(this.options.cwd, path12);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path10);
+    this._watched.delete(path12);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path10))
-      this._emit(eventName, path10);
-    this._closePath(path10);
+    if (wasTracked && !this._isIgnored(path12))
+      this._emit(eventName, path12);
+    this._closePath(path12);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path10) {
-    this._closeFile(path10);
-    const dir = sp2.dirname(path10);
-    this._getWatchedDir(dir).remove(sp2.basename(path10));
+  _closePath(path12) {
+    this._closeFile(path12);
+    const dir = sp2.dirname(path12);
+    this._getWatchedDir(dir).remove(sp2.basename(path12));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path10) {
-    const closers = this._closers.get(path10);
+  _closeFile(path12) {
+    const closers = this._closers.get(path12);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path10);
+    this._closers.delete(path12);
   }
-  _addPathCloser(path10, closer) {
+  _addPathCloser(path12, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path10);
+    let list = this._closers.get(path12);
     if (!list) {
       list = [];
-      this._closers.set(path10, list);
+      this._closers.set(path12, list);
     }
     list.push(closer);
   }
@@ -2690,6 +2699,53 @@ function isPortAvailable(port) {
   });
 }
 
+// src/capture/transcript-miner.ts
+var TranscriptMiner = class {
+  registry;
+  constructor(config) {
+    this.registry = new AgentRegistry(config?.additionalAdapters);
+  }
+  /**
+   * Extract all conversation turns for a session.
+   * Convenience wrapper — delegates to getAllTurnsWithSource.
+   */
+  getAllTurns(sessionId) {
+    return this.getAllTurnsWithSource(sessionId).turns;
+  }
+  /**
+   * Extract turns using the hook-provided transcript path first (fast, no scanning),
+   * then fall back to adapter registry scanning if the path isn't provided.
+   */
+  getAllTurnsWithSource(sessionId, transcriptPath) {
+    if (transcriptPath) {
+      const result2 = this.registry.parseTurnsFromPath(transcriptPath);
+      if (result2) return result2;
+    }
+    const result = this.registry.getTranscriptTurns(sessionId);
+    if (result) return result;
+    return { turns: [], source: "none" };
+  }
+};
+function extractTurnsFromBuffer(events) {
+  const turns = [];
+  let current = null;
+  for (const event of events) {
+    const type = event.type;
+    if (type === "user_prompt") {
+      if (current) turns.push(current);
+      current = {
+        prompt: String(event.prompt ?? "").slice(0, PROMPT_PREVIEW_CHARS),
+        toolCount: 0,
+        timestamp: String(event.timestamp ?? (/* @__PURE__ */ new Date()).toISOString())
+      };
+    } else if (type === "tool_use") {
+      if (current) current.toolCount++;
+    }
+  }
+  if (current) turns.push(current);
+  return turns;
+}
+
 // src/artifacts/candidates.ts
 import { execFileSync } from "child_process";
 import fs4 from "fs";
@@ -2997,6 +3053,7 @@ async function handleRebuild(deps) {
       config: deps.config,
       index: deps.index,
       vectorIndex: deps.vectorIndex ?? void 0,
+      pipeline: deps.pipeline,
       log: deps.log
     },
     deps.embeddingProvider,
@@ -3046,9 +3103,10 @@ async function handleDigest(deps, body) {
       config: deps.config,
       index: deps.index,
       vectorIndex: deps.vectorIndex ?? void 0,
+      pipeline: deps.pipeline,
       log: deps.log
     },
-    deps.llmProvider,
+    deps.digestLlmProvider,
     options ?? void 0
   ).then((result) => {
     if (result) {
@@ -3093,6 +3151,7 @@ async function handleCurate(deps, body, runCuration2) {
     vectorIndex: deps.vectorIndex,
     llmProvider: deps.llmProvider,
     embeddingProvider: deps.embeddingProvider,
+    pipeline: deps.pipeline,
     log: deps.log
   };
   if (isDryRun) {
@@ -3144,6 +3203,7 @@ async function handleReprocess(deps, body) {
       config: deps.config,
       index: deps.index,
       vectorIndex: deps.vectorIndex ?? void 0,
+      pipeline: deps.pipeline,
       log: deps.log
     },
     deps.llmProvider,
@@ -3250,47 +3310,1412 @@ function handleGetSessions(index) {
   return { body: { sessions, dates } };
 }
 
-// src/daemon/main.ts
+// src/daemon/api/pipeline.ts
+var RetryItemBody = external_exports.object({
+  type: external_exports.string(),
+  stage: external_exports.string()
+});
+function handlePipelineHealth(pipeline) {
+  return async () => {
+    const health = pipeline.health();
+    return { body: health };
+  };
+}
+function handlePipelineItems(pipeline) {
+  return async (req) => {
+    const { stage, status, type, limit, offset } = req.query;
+    const parsedLimit = limit ? parseInt(limit, 10) : void 0;
+    const parsedOffset = offset ? parseInt(offset, 10) : void 0;
+    if (limit && (isNaN(parsedLimit) || parsedLimit < 0)) {
+      return { status: 400, body: { error: "invalid_limit", message: "limit must be a non-negative integer" } };
+    }
+    if (offset && (isNaN(parsedOffset) || parsedOffset < 0)) {
+      return { status: 400, body: { error: "invalid_offset", message: "offset must be a non-negative integer" } };
+    }
+    const result = pipeline.listItems({
+      stage,
+      status,
+      type,
+      limit: parsedLimit,
+      offset: parsedOffset
+    });
+    return { body: result };
+  };
+}
+function handlePipelineItemDetail(pipeline) {
+  return async (req) => {
+    const { id } = req.params;
+    const { type } = req.query;
+    if (!type) {
+      return { status: 400, body: { error: "missing_type", message: 'query param "type" is required' } };
+    }
+    const stages = pipeline.getItemStatus(id, type);
+    if (stages.length === 0) {
+      return { status: 404, body: { error: "not_found", message: `No work item found: ${id} (${type})` } };
+    }
+    const history = pipeline.getTransitionHistory(id, type);
+    return { body: { id, type, stages, history } };
+  };
+}
+function handlePipelineCircuits(pipeline) {
+  return async () => {
+    const circuits = pipeline.listCircuits();
+    return { body: circuits };
+  };
+}
+function handlePipelineRetry(pipeline) {
+  return async (req) => {
+    const { id } = req.params;
+    const parsed = RetryItemBody.safeParse(req.body);
+    if (!parsed.success) {
+      return { status: 400, body: { error: "validation_failed", issues: parsed.error.issues } };
+    }
+    const { type, stage } = parsed.data;
+    const retried = pipeline.retryItem(id, type, stage);
+    if (!retried) {
+      return { status: 404, body: { error: "not_poisoned", message: `Item ${id} is not poisoned at stage ${stage}` } };
+    }
+    return { body: { retried: true, id, type, stage } };
+  };
+}
+function handlePipelineSkip(pipeline) {
+  return async (req) => {
+    const { id } = req.params;
+    const parsed = RetryItemBody.safeParse(req.body);
+    if (!parsed.success) {
+      return { status: 400, body: { error: "validation_failed", issues: parsed.error.issues } };
+    }
+    const { type, stage } = parsed.data;
+    const skipped = pipeline.skipItem(id, type, stage);
+    if (!skipped) {
+      return { status: 404, body: { error: "not_skippable", message: `Item ${id} is not failed or poisoned at stage ${stage}` } };
+    }
+    return { body: { skipped: true, id, type, stage } };
+  };
+}
+function handlePipelineRetryAll(pipeline) {
+  return async () => {
+    const count = pipeline.retryAllPoisoned();
+    return { body: { retried: count } };
+  };
+}
+function handlePipelineCircuitReset(pipeline) {
+  return async (req) => {
+    const { provider } = req.params;
+    if (!PIPELINE_PROVIDER_ROLES.includes(provider)) {
+      return {
+        status: 400,
+        body: {
+          error: "unknown_provider",
+          message: `Unknown provider role '${provider}'. Valid roles: ${PIPELINE_PROVIDER_ROLES.join(", ")}`
+        }
+      };
+    }
+    pipeline.resetCircuit(provider);
+    const unblocked = pipeline.unblockItemsForCircuit(provider);
+    return { body: { reset: true, provider, unblocked } };
+  };
+}
+
+// src/daemon/api/digest.ts
 var import_yaml = __toESM(require_dist(), 1);
 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) {
-    generateEmbedding(deps.embeddingProvider, embeddingText.slice(0, EMBEDDING_INPUT_LIMIT)).then((emb) => deps.vectorIndex.upsert(noteId, emb.embedding, metadata)).catch((err) => deps.logger.debug("embeddings", "Embedding failed", { id: noteId, error: err.message }));
+function handleForceDigest(setForceDigest) {
+  return async () => {
+    setForceDigest();
+    return {
+      body: {
+        status: "queued",
+        message: "Digest will run on next pipeline tick (upstream must be clear)"
+      }
+    };
+  };
+}
+function readExtractTimestamp(extractPath) {
+  try {
+    const content = fs6.readFileSync(extractPath, "utf-8");
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!fmMatch) return null;
+    const fm = import_yaml.default.parse(fmMatch[1]);
+    return typeof fm.generated === "string" ? fm.generated : null;
+  } catch {
+    return null;
   }
 }
-function writeObservations(observations, sessionId, deps) {
-  const written = writeObservationNotes(observations, sessionId, deps.vault, deps.index, deps.vaultDir);
-  for (const note of written) {
-    indexAndEmbed(
-      note.path,
-      note.id,
-      `${note.observation.title}
-${note.observation.content}`,
-      { type: "spore", importance: "high", session_id: sessionId },
-      deps
+function handleDigestHealth(deps) {
+  return async () => {
+    const tracePath = path9.join(deps.vaultDir, "digest", "trace.jsonl");
+    const lastCycle = readLastRecord(tracePath);
+    let lastCycleTimestamp = lastCycle?.timestamp ?? null;
+    const digestDir = path9.join(deps.vaultDir, "digest");
+    try {
+      for (const file of fs6.readdirSync(digestDir)) {
+        if (!file.startsWith("extract-") || !file.endsWith(".md")) continue;
+        const extractTs = readExtractTimestamp(path9.join(digestDir, file));
+        if (extractTs && (!lastCycleTimestamp || extractTs > lastCycleTimestamp)) {
+          lastCycleTimestamp = extractTs;
+        }
+      }
+    } catch {
+    }
+    const substrateReady = deps.pipeline.newSubstrateSinceLastDigest();
+    return {
+      body: {
+        last_cycle: lastCycleTimestamp ? {
+          cycle_id: lastCycle?.cycleId ?? null,
+          timestamp: lastCycleTimestamp,
+          substrate_count: lastCycle ? Object.values(lastCycle.substrate).flat().length : null,
+          tiers_generated: lastCycle?.tiersGenerated ?? null,
+          duration_ms: lastCycle?.durationMs ?? null,
+          model: lastCycle?.model ?? null
+        } : null,
+        substrate_ready: substrateReady,
+        substrate_threshold: deps.minNotesForCycle,
+        metabolism_state: deps.metabolismState(),
+        digest_ready: deps.digestReady(),
+        cycle_in_progress: deps.cycleInProgress()
+      }
+    };
+  };
+}
+
+// src/daemon/pipeline.ts
+import Database from "better-sqlite3";
+import fs7 from "fs";
+import path10 from "path";
+
+// src/daemon/pipeline-classify.ts
+var WELL_KNOWN_API_HOSTS = ["api.anthropic.com", "api.openai.com"];
+var TRANSIENT_STATUS_PATTERNS = [" 429 ", " 500 ", " 503 "];
+var MODEL_NOT_FOUND_PATTERNS = [
+  "model not found",
+  "model not loaded",
+  "no model loaded"
+];
+var RESOURCE_FAILURE_PATTERNS = [
+  "model_load_failed",
+  "insufficient system resources",
+  "unsupported",
+  "not compatible"
+];
+var TRANSIENT_MESSAGE_PATTERNS = [
+  "socket hang up"
+];
+var CONFIG_ERROR_CODES = /* @__PURE__ */ new Set(["ECONNREFUSED"]);
+var TRANSIENT_ERROR_CODES = /* @__PURE__ */ new Set(["ETIMEDOUT", "ECONNRESET"]);
+function hasCode(err, code) {
+  return err.code === code;
+}
+function hasAnyCode(err, codes) {
+  const code = err.code;
+  return code !== void 0 && codes.has(code);
+}
+function messageContains(err, patterns) {
+  const msg = err.message.toLowerCase();
+  return patterns.some((p) => msg.includes(p.toLowerCase()));
+}
+function statusMatch(err, patterns) {
+  const msg = " " + err.message + " ";
+  return patterns.some((p) => msg.includes(p));
+}
+function connectionRefusedAction(ctx) {
+  const provider = ctx.providerName ?? "the provider";
+  const url = ctx.baseUrl ? ` at ${ctx.baseUrl}` : "";
+  return `${provider} is not reachable${url}. Check that ${provider} is running and the baseUrl is correct.`;
+}
+function modelNotFoundAction(ctx) {
+  const model = ctx.modelName ? `'${ctx.modelName}'` : "the configured model";
+  const provider = ctx.providerName ?? "the provider";
+  return `Model ${model} was not found in ${provider}. Ensure the model is downloaded and loaded.`;
+}
+function resourceExhaustionAction(ctx) {
+  const provider = ctx.providerName ?? "the provider";
+  return `${provider} could not load the model due to insufficient resources. Try a smaller model or free up memory.`;
+}
+function authFailureAction(status, ctx) {
+  const provider = ctx.providerName ?? "the provider";
+  if (status === "401") {
+    return `Authentication failed for ${provider}. Check that the API key is set and valid.`;
+  }
+  return `Access denied (403) for ${provider}. Check API key permissions and account status.`;
+}
+function dnsFailureAction(ctx) {
+  const provider = ctx.providerName ?? "the provider";
+  const host = ctx.configuredHost ?? "the configured host";
+  return `Cannot resolve host '${host}' for ${provider}. Check the baseUrl hostname.`;
+}
+function classifyError(error, context) {
+  const ctx = context ?? {};
+  if (error instanceof SyntaxError) {
+    return { type: "parse", suggestedAction: "LLM returned unparseable JSON. The response may be malformed or truncated." };
+  }
+  if (error.name === "ParseError") {
+    return { type: "parse", suggestedAction: "LLM returned an empty or invalid response. Check model health and prompt." };
+  }
+  const msgLower = error.message.toLowerCase();
+  if (msgLower.includes("empty content") || msgLower.includes("schema validation")) {
+    return { type: "parse", suggestedAction: "LLM returned an empty or schema-invalid response. Check model health and prompt." };
+  }
+  if (msgLower.includes("only reasoning") || msgLower.includes("empty after strip") || msgLower.includes("observation extraction failed")) {
+    return { type: "parse", suggestedAction: "LLM returned only reasoning tokens with no usable content. Check model reasoning settings." };
+  }
+  if (msgLower.includes("missing output") || msgLower.includes("no content in response") || msgLower.includes("summarization failed")) {
+    return { type: "parse", suggestedAction: "LLM response is missing expected fields. Check provider health and model compatibility." };
+  }
+  if (hasCode(error, "ECONNREFUSED") || hasAnyCode(error, CONFIG_ERROR_CODES)) {
+    return { type: "config", suggestedAction: connectionRefusedAction(ctx) };
+  }
+  if (messageContains(error, MODEL_NOT_FOUND_PATTERNS)) {
+    return { type: "config", suggestedAction: modelNotFoundAction(ctx) };
+  }
+  if (messageContains(error, RESOURCE_FAILURE_PATTERNS)) {
+    return { type: "config", suggestedAction: resourceExhaustionAction(ctx) };
+  }
+  if (statusMatch(error, [" 401 "])) {
+    return { type: "config", suggestedAction: authFailureAction("401", ctx) };
+  }
+  if (statusMatch(error, [" 403 "])) {
+    return { type: "config", suggestedAction: authFailureAction("403", ctx) };
+  }
+  if (/ 401$/.test(error.message) || error.message.endsWith(" 401")) {
+    return { type: "config", suggestedAction: authFailureAction("401", ctx) };
+  }
+  if (/ 403$/.test(error.message) || error.message.endsWith(" 403")) {
+    return { type: "config", suggestedAction: authFailureAction("403", ctx) };
+  }
+  if (hasCode(error, "ENOTFOUND")) {
+    if (ctx.configuredHost && error.message.includes(ctx.configuredHost)) {
+      return { type: "config", suggestedAction: dnsFailureAction(ctx) };
+    }
+    if (WELL_KNOWN_API_HOSTS.some((host) => error.message.includes(host))) {
+      return { type: "transient" };
+    }
+    return { type: "config", suggestedAction: dnsFailureAction(ctx) };
+  }
+  if (error.name === "AbortError") {
+    return { type: "transient" };
+  }
+  if (hasAnyCode(error, TRANSIENT_ERROR_CODES)) {
+    return { type: "transient" };
+  }
+  if (statusMatch(error, TRANSIENT_STATUS_PATTERNS)) {
+    return { type: "transient" };
+  }
+  if (messageContains(error, TRANSIENT_MESSAGE_PATTERNS)) {
+    return { type: "transient" };
+  }
+  return { type: "transient" };
+}
+
+// src/daemon/pipeline.ts
+var PIPELINE_DB_FILENAME = "pipeline.db";
+var SCHEMA_SQL = `
+  -- work_items: every piece of content in the pipeline
+  CREATE TABLE IF NOT EXISTS work_items (
+    id TEXT NOT NULL,
+    item_type TEXT NOT NULL,
+    source_path TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    PRIMARY KEY (id, item_type)
+  );
+
+  -- stage_transitions: append-only audit trail
+  CREATE TABLE IF NOT EXISTS stage_transitions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    work_item_id TEXT NOT NULL,
+    item_type TEXT NOT NULL,
+    stage TEXT NOT NULL,
+    status TEXT NOT NULL,
+    attempt INTEGER DEFAULT 1,
+    error_type TEXT,
+    error_message TEXT,
+    started_at TEXT,
+    completed_at TEXT,
+    output TEXT,
+    created_at TEXT NOT NULL,
+    FOREIGN KEY (work_item_id, item_type) REFERENCES work_items(id, item_type)
+  );
+
+  -- stage_history: compacted transitions older than retention window
+  CREATE TABLE IF NOT EXISTS stage_history (
+    work_item_id TEXT NOT NULL,
+    item_type TEXT NOT NULL,
+    stage TEXT NOT NULL,
+    total_attempts INTEGER,
+    final_status TEXT NOT NULL,
+    first_attempt TEXT NOT NULL,
+    last_attempt TEXT NOT NULL,
+    last_error TEXT,
+    error_types TEXT,
+    last_output TEXT,
+    PRIMARY KEY (work_item_id, item_type, stage)
+  );
+
+  -- circuit_breakers: per-provider-role state
+  CREATE TABLE IF NOT EXISTS circuit_breakers (
+    provider_role TEXT PRIMARY KEY,
+    state TEXT NOT NULL DEFAULT 'closed',
+    failure_count INTEGER DEFAULT 0,
+    last_failure TEXT,
+    last_error TEXT,
+    opens_at TEXT,
+    updated_at TEXT NOT NULL
+  );
+`;
+var INDEXES_SQL = `
+  CREATE INDEX IF NOT EXISTS idx_transitions_item_stage
+    ON stage_transitions(work_item_id, item_type, stage);
+  CREATE INDEX IF NOT EXISTS idx_transitions_status
+    ON stage_transitions(status);
+  CREATE INDEX IF NOT EXISTS idx_items_type
+    ON work_items(item_type);
+`;
+var VIEW_SQL = `
+  CREATE VIEW IF NOT EXISTS pipeline_status AS
+  WITH ranked AS (
+    SELECT st.*,
+      ROW_NUMBER() OVER (
+        PARTITION BY st.work_item_id, st.item_type, st.stage
+        ORDER BY st.id DESC
+      ) AS rn
+    FROM stage_transitions st
+  )
+  SELECT
+    wi.id, wi.item_type, wi.source_path,
+    r.stage, r.status, r.attempt,
+    r.error_type, r.error_message,
+    r.started_at, r.completed_at,
+    r.output
+  FROM work_items wi
+  JOIN ranked r ON r.work_item_id = wi.id AND r.item_type = wi.item_type
+  WHERE r.rn = 1;
+`;
+var HEALTH_STAGE_STATUS_SQL = `
+  SELECT stage, status, COUNT(*) as count
+  FROM pipeline_status
+  GROUP BY stage, status
+`;
+var HEALTH_CIRCUITS_SQL = `
+  SELECT provider_role, state, failure_count, last_error
+  FROM circuit_breakers
+`;
+var PipelineManager = class {
+  db;
+  config;
+  constructor(vaultDir, config) {
+    const dbPath = path10.join(vaultDir, PIPELINE_DB_FILENAME);
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    this.config = config;
+    this.init();
+  }
+  init() {
+    this.db.exec("DROP VIEW IF EXISTS pipeline_status");
+    this.db.exec(SCHEMA_SQL);
+    try {
+      this.db.exec("ALTER TABLE stage_transitions ADD COLUMN output TEXT");
+    } catch {
+    }
+    try {
+      this.db.exec("ALTER TABLE stage_history ADD COLUMN last_output TEXT");
+    } catch {
+    }
+    this.db.exec(INDEXES_SQL);
+    this.db.exec(VIEW_SQL);
+  }
+  /** Expose the underlying database for direct queries (used in tests and by higher-level methods). */
+  getDb() {
+    return this.db;
+  }
+  /** Read a PRAGMA value (used in tests to verify WAL mode and foreign keys). */
+  getPragma(name) {
+    return this.db.pragma(name, { simple: true });
+  }
+  /** Quick check whether the pipeline has any registered work items. */
+  isEmpty() {
+    const row = this.db.prepare("SELECT 1 FROM work_items LIMIT 1").get();
+    return !row;
+  }
+  /** Aggregate pipeline health: stage/status counts, circuit states, totals. */
+  health() {
+    const stageRows = this.db.prepare(HEALTH_STAGE_STATUS_SQL).all();
+    const stages = {};
+    const totals = {
+      pending: 0,
+      processing: 0,
+      failed: 0,
+      blocked: 0,
+      poisoned: 0,
+      succeeded: 0
+    };
+    for (const row of stageRows) {
+      if (!stages[row.stage]) {
+        stages[row.stage] = {};
+      }
+      stages[row.stage][row.status] = row.count;
+      if (row.status in totals) {
+        totals[row.status] += row.count;
+      }
+    }
+    const circuitRows = this.db.prepare(HEALTH_CIRCUITS_SQL).all();
+    const circuits = circuitRows.map((r) => ({
+      provider_role: r.provider_role,
+      state: r.state,
+      failure_count: r.failure_count,
+      last_error: r.last_error
+    }));
+    return { stages, circuits, totals };
+  }
+  // -------------------------------------------------------------------------
+  // Work item registration
+  // -------------------------------------------------------------------------
+  /**
+   * Register a work item in the pipeline. Creates the work_items row and
+   * initial stage_transitions for all applicable stages.
+   *
+   * Uses INSERT OR IGNORE for work_items (idempotency — re-registering is a no-op).
+   * Checks if transitions already exist before inserting.
+   */
+  register(itemId, itemType, sourcePath) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.prepare(
+      "INSERT OR IGNORE INTO work_items (id, item_type, source_path, created_at, updated_at) VALUES (?, ?, ?, ?, ?)"
+    ).run(itemId, itemType, sourcePath ?? null, now, now);
+    const existingCount = this.db.prepare(
+      "SELECT COUNT(*) as cnt FROM stage_transitions WHERE work_item_id = ? AND item_type = ?"
+    ).get(itemId, itemType);
+    if (existingCount.cnt > 0) {
+      return;
+    }
+    const applicableStages = ITEM_STAGE_MAP[itemType] ?? [];
+    const insertStmt = this.db.prepare(
+      "INSERT INTO stage_transitions (work_item_id, item_type, stage, status, attempt, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+    );
+    const insertAll = this.db.transaction(() => {
+      for (const stage of PIPELINE_STAGES) {
+        const status = applicableStages.includes(stage) ? "pending" : "skipped";
+        insertStmt.run(itemId, itemType, stage, status, 1, now);
+      }
+    });
+    insertAll();
+  }
+  // -------------------------------------------------------------------------
+  // Stage transitions
+  // -------------------------------------------------------------------------
+  /**
+   * Record a stage transition. Append-only — never updates existing rows.
+   *
+   * When status is 'failed': checks retry limits and may auto-poison.
+   * When error_type is 'config': blocks all downstream stages.
+   */
+  advance(itemId, itemType, stage, status, error, output) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const priorCount = this.db.prepare(
+      `SELECT COUNT(*) as cnt FROM stage_transitions
+         WHERE work_item_id = ? AND item_type = ? AND stage = ?
+         AND status IN ('failed', 'processing')`
+    ).get(itemId, itemType, stage);
+    const attempt = status === "failed" || status === "processing" ? Math.ceil((priorCount.cnt + 1) / 2) || 1 : priorCount.cnt > 0 ? Math.ceil(priorCount.cnt / 2) || 1 : 1;
+    let resolvedStatus = status;
+    if (status === "failed" && error?.errorType) {
+      const maxRetries = error.errorType === "transient" ? this.config.retry.transient_max : PIPELINE_PARSE_MAX_RETRIES;
+      const failedCount = this.db.prepare(
+        `SELECT COUNT(*) as cnt FROM stage_transitions
+           WHERE work_item_id = ? AND item_type = ? AND stage = ? AND status = 'failed'`
+      ).get(itemId, itemType, stage);
+      if (failedCount.cnt >= maxRetries) {
+        resolvedStatus = "poisoned";
+      }
+    }
+    const startedAt = status === "processing" ? now : null;
+    const completedAt = ["succeeded", "failed", "poisoned", "blocked", "skipped"].includes(resolvedStatus) ? now : null;
+    const outputJson = status === "succeeded" && output ? JSON.stringify(output) : null;
+    this.db.prepare(
+      `INSERT INTO stage_transitions
+         (work_item_id, item_type, stage, status, attempt, error_type, error_message, started_at, completed_at, output, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      itemId,
+      itemType,
+      stage,
+      resolvedStatus,
+      attempt,
+      error?.errorType ?? null,
+      error?.errorMessage ?? null,
+      startedAt,
+      completedAt,
+      outputJson,
+      now
     );
-    deps.logger.info("processor", "Observation written", { type: note.observation.type, title: note.observation.title, session_id: sessionId });
+    this.db.prepare("UPDATE work_items SET updated_at = ? WHERE id = ? AND item_type = ?").run(now, itemId, itemType);
+    if (status === "failed" && error?.errorType === "config") {
+      const stageIdx = PIPELINE_STAGES.indexOf(stage);
+      if (stageIdx >= 0) {
+        const downstreamStages = PIPELINE_STAGES.slice(stageIdx + 1);
+        for (const downstream of downstreamStages) {
+          const currentStatus = this.db.prepare(
+            `SELECT status FROM stage_transitions
+               WHERE work_item_id = ? AND item_type = ? AND stage = ?
+               ORDER BY id DESC LIMIT 1`
+          ).get(itemId, itemType, downstream);
+          if (currentStatus && currentStatus.status === "pending") {
+            this.db.prepare(
+              `INSERT INTO stage_transitions
+                 (work_item_id, item_type, stage, status, attempt, error_type, error_message, started_at, completed_at, created_at)
+                 VALUES (?, ?, ?, 'blocked', 1, 'config', ?, NULL, ?, ?)`
+            ).run(
+              itemId,
+              itemType,
+              downstream,
+              `blocked by ${stage} config failure`,
+              now,
+              now
+            );
+          }
+        }
+      }
+    }
   }
-  if (written.length > 0) {
-    const curationDeps = {
-      index: deps.index,
-      vectorIndex: deps.vectorIndex,
-      embeddingProvider: deps.embeddingProvider,
-      llmProvider: deps.llmProvider,
-      vaultDir: deps.vaultDir,
-      log: ((level, msg, data) => deps.logger[level]("curation", msg, data))
+  // -------------------------------------------------------------------------
+  // Status queries
+  // -------------------------------------------------------------------------
+  /**
+   * Get current status for all stages of a work item.
+   * Queries the pipeline_status view filtered by work_item_id and item_type.
+   */
+  getItemStatus(itemId, itemType) {
+    return this.db.prepare(
+      `SELECT stage, status, attempt, error_type, error_message, started_at, completed_at, output
+         FROM pipeline_status
+         WHERE id = ? AND item_type = ?`
+    ).all(itemId, itemType);
+  }
+  // -------------------------------------------------------------------------
+  // Batch queries
+  // -------------------------------------------------------------------------
+  /**
+   * Get pending work items ready for processing at a given stage.
+   *
+   * Requirements:
+   * - Only items where the requested stage is 'pending'
+   * - Only items whose PREVIOUS stage (in PIPELINE_STAGES order) is 'succeeded' or 'skipped'
+   * - Exclude items in backoff window
+   * - Ordered by work_items.created_at ASC (oldest first)
+   */
+  nextBatch(stage, limit) {
+    const stageIdx = PIPELINE_STAGES.indexOf(stage);
+    const prevStage = stageIdx > 0 ? PIPELINE_STAGES[stageIdx - 1] : null;
+    const upstreamCheck = prevStage ? `AND EXISTS (
+           SELECT 1 FROM pipeline_status ps2
+           WHERE ps2.id = ps.id AND ps2.item_type = ps.item_type
+           AND ps2.stage = ? AND ps2.status IN ('succeeded', 'skipped')
+         )` : "";
+    const sql = `
+      SELECT ps.id, ps.item_type, ps.source_path, wi.created_at
+      FROM pipeline_status ps
+      JOIN work_items wi ON wi.id = ps.id AND wi.item_type = ps.item_type
+      WHERE ps.stage = ? AND ps.status IN ('pending', 'failed')
+      ${upstreamCheck}
+      AND NOT EXISTS (
+        SELECT 1 FROM stage_transitions st2
+        WHERE st2.work_item_id = ps.id AND st2.item_type = ps.item_type
+        AND st2.stage = ? AND st2.status = 'failed'
+        AND st2.completed_at IS NOT NULL
+        AND (julianday('now') - julianday(st2.completed_at)) * 86400000 <
+          ? * POWER(?, (
+            SELECT COUNT(*) FROM stage_transitions st3
+            WHERE st3.work_item_id = ps.id AND st3.item_type = ps.item_type
+            AND st3.stage = ? AND st3.status = 'failed'
+          ) - 1)
+      )
+      ORDER BY wi.created_at ASC
+      LIMIT ?`;
+    const params = [stage];
+    if (prevStage) {
+      params.push(prevStage);
+    }
+    params.push(stage, this.config.retry.backoff_base_seconds * 1e3, PIPELINE_BACKOFF_MULTIPLIER, stage, limit);
+    return this.db.prepare(sql).all(...params);
+  }
+  // -------------------------------------------------------------------------
+  // Circuit breakers
+  // -------------------------------------------------------------------------
+  /**
+   * Get current state of a circuit breaker for the given provider role.
+   * Returns the persisted row, or a synthetic default (closed, 0 failures)
+   * if no row exists yet.
+   */
+  circuitState(providerRole) {
+    const row = this.db.prepare("SELECT * FROM circuit_breakers WHERE provider_role = ?").get(providerRole);
+    if (row) {
+      return row;
+    }
+    return {
+      provider_role: providerRole,
+      state: "closed",
+      failure_count: 0,
+      last_failure: null,
+      last_error: null,
+      opens_at: null,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
     };
-    (async () => {
-      for (const note of written) {
-        try {
-          await checkSupersession(note.id, curationDeps);
-        } catch (err) {
-          deps.logger.debug("curation", "Supersession check failed", { id: note.id, error: err.message });
+  }
+  /**
+   * Record a failure against a circuit breaker. Increments failure_count and
+   * updates last_error / last_failure. If failure_count reaches the configured
+   * failure_threshold, sets state to 'open' and calculates
+   * opens_at = now + configured cooldown_seconds.
+   */
+  tripCircuit(providerRole, errorMessage) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const current = this.circuitState(providerRole);
+    const newFailureCount = current.failure_count + 1;
+    const shouldOpen = newFailureCount >= this.config.circuit_breaker.failure_threshold;
+    const newState = shouldOpen ? "open" : "closed";
+    const opensAt = shouldOpen ? new Date(Date.now() + this.config.circuit_breaker.cooldown_seconds * 1e3).toISOString() : null;
+    this.db.prepare(
+      `INSERT INTO circuit_breakers
+           (provider_role, state, failure_count, last_failure, last_error, opens_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(provider_role) DO UPDATE SET
+           state        = excluded.state,
+           failure_count = excluded.failure_count,
+           last_failure  = excluded.last_failure,
+           last_error    = excluded.last_error,
+           opens_at      = excluded.opens_at,
+           updated_at    = excluded.updated_at`
+    ).run(providerRole, newState, newFailureCount, now, errorMessage, opensAt, now);
+  }
+  /**
+   * Re-open a circuit after a failed half-open probe with doubled cooldown.
+   *
+   * When a half-open probe fails, the circuit should re-open with a cooldown
+   * of `previousCooldown * 2`, capped at the configured max_cooldown_seconds.
+   * This implements exponential backoff for repeated probe failures.
+   */
+  reopenCircuit(providerRole, errorMessage) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const current = this.circuitState(providerRole);
+    let previousCooldown = this.config.circuit_breaker.cooldown_seconds * 1e3;
+    if (current.last_failure && current.opens_at) {
+      const lastFailureMs = new Date(current.last_failure).getTime();
+      const opensAtMs = new Date(current.opens_at).getTime();
+      const storedCooldown = opensAtMs - lastFailureMs;
+      if (storedCooldown > 0) {
+        previousCooldown = storedCooldown;
+      }
+    }
+    const doubledCooldown = Math.min(
+      previousCooldown * 2,
+      this.config.circuit_breaker.max_cooldown_seconds * 1e3
+    );
+    const opensAt = new Date(Date.now() + doubledCooldown).toISOString();
+    this.db.prepare(
+      `INSERT INTO circuit_breakers
+           (provider_role, state, failure_count, last_failure, last_error, opens_at, updated_at)
+         VALUES (?, 'open', ?, ?, ?, ?, ?)
+         ON CONFLICT(provider_role) DO UPDATE SET
+           state         = 'open',
+           failure_count = excluded.failure_count,
+           last_failure  = excluded.last_failure,
+           last_error    = excluded.last_error,
+           opens_at      = excluded.opens_at,
+           updated_at    = excluded.updated_at`
+    ).run(providerRole, current.failure_count + 1, now, errorMessage, opensAt, now);
+  }
+  /**
+   * Manually reset a circuit breaker to closed state.
+   * Sets state='closed', failure_count=0, clears opens_at.
+   */
+  resetCircuit(providerRole) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.prepare(
+      `INSERT INTO circuit_breakers
+           (provider_role, state, failure_count, last_failure, last_error, opens_at, updated_at)
+         VALUES (?, 'closed', 0, NULL, NULL, NULL, ?)
+         ON CONFLICT(provider_role) DO UPDATE SET
+           state         = 'closed',
+           failure_count = 0,
+           opens_at      = NULL,
+           updated_at    = excluded.updated_at`
+    ).run(providerRole, now);
+  }
+  /**
+   * Check if an open circuit's cooldown has expired and is ready for a
+   * half-open probe. If state is 'open' and current time >= opens_at,
+   * transitions state to 'half-open' and returns true. Otherwise returns false.
+   */
+  probeCircuit(providerRole) {
+    const current = this.circuitState(providerRole);
+    if (current.state !== "open") {
+      return false;
+    }
+    if (!current.opens_at) {
+      return false;
+    }
+    const now = Date.now();
+    const opensAt = new Date(current.opens_at).getTime();
+    if (now < opensAt) {
+      return false;
+    }
+    this.db.prepare(
+      `UPDATE circuit_breakers
+         SET state = 'half-open', updated_at = ?
+         WHERE provider_role = ?`
+    ).run((/* @__PURE__ */ new Date()).toISOString(), providerRole);
+    return true;
+  }
+  /**
+   * When a circuit opens, find all stages that use this provider role and
+   * insert new 'blocked' transitions for all items that currently have
+   * 'pending' status at those stages.
+   *
+   * Returns the count of blocked items.
+   */
+  blockItemsForCircuit(providerRole) {
+    return this._transitionItemsForCircuit(providerRole, "pending", "blocked");
+  }
+  /**
+   * When a circuit closes, find all stages that use this provider role and
+   * insert new 'pending' transitions for all items that currently have
+   * 'blocked' status at those stages.
+   *
+   * Returns the count of unblocked items.
+   */
+  unblockItemsForCircuit(providerRole) {
+    return this._transitionItemsForCircuit(providerRole, "blocked", "pending");
+  }
+  /**
+   * Shared implementation for blockItemsForCircuit / unblockItemsForCircuit.
+   * Finds all stages mapped to providerRole, selects items at fromStatus,
+   * and inserts a new transition at toStatus.
+   */
+  _transitionItemsForCircuit(providerRole, fromStatus, toStatus) {
+    const affectedStages = Object.keys(STAGE_PROVIDER_MAP).filter((stage) => STAGE_PROVIDER_MAP[stage] === providerRole);
+    if (affectedStages.length === 0) {
+      return 0;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    let transitionedCount = 0;
+    const isBlocking = toStatus === "blocked";
+    const doTransition = this.db.transaction(() => {
+      for (const stage of affectedStages) {
+        const items = this.db.prepare(
+          `SELECT id, item_type FROM pipeline_status
+             WHERE stage = ? AND status = ?`
+        ).all(stage, fromStatus);
+        for (const item of items) {
+          if (isBlocking) {
+            this.db.prepare(
+              `INSERT INTO stage_transitions
+                 (work_item_id, item_type, stage, status, attempt, error_type, error_message, started_at, completed_at, created_at)
+                 VALUES (?, ?, ?, 'blocked', 1, 'config', ?, NULL, ?, ?)`
+            ).run(item.id, item.item_type, stage, `circuit open: ${providerRole}`, now, now);
+          } else {
+            this.db.prepare(
+              `INSERT INTO stage_transitions
+                 (work_item_id, item_type, stage, status, attempt, error_type, error_message, started_at, completed_at, created_at)
+                 VALUES (?, ?, ?, 'pending', 1, NULL, NULL, NULL, NULL, ?)`
+            ).run(item.id, item.item_type, stage, now);
+          }
+          transitionedCount++;
+        }
+      }
+    });
+    doTransition();
+    return transitionedCount;
+  }
+  // -------------------------------------------------------------------------
+  // Compaction
+  // -------------------------------------------------------------------------
+  /**
+   * Compact stage_transitions older than retentionDays into stage_history rows.
+   *
+   * For each (work_item_id, item_type, stage) group whose transitions are older
+   * than the cutoff, inserts or replaces a stage_history row aggregating those
+   * transitions, then deletes the original rows.
+   *
+   * Returns `{ compacted, deleted }`: compacted = number of groups written to
+   * stage_history; deleted = number of transition rows removed.
+   */
+  compact(retentionDays = this.config.retention_days) {
+    const cutoff = new Date(Date.now() - retentionDays * MS_PER_DAY).toISOString();
+    const oldRows = this.db.prepare(
+      `SELECT id, work_item_id, item_type, stage, status, attempt, error_type, output, created_at
+         FROM stage_transitions
+         WHERE created_at < ?
+         ORDER BY id ASC`
+    ).all(cutoff);
+    if (oldRows.length === 0) {
+      return { compacted: 0, deleted: 0 };
+    }
+    const groups = /* @__PURE__ */ new Map();
+    for (const row of oldRows) {
+      const key = `${row.work_item_id}\0${row.item_type}\0${row.stage}`;
+      const existing = groups.get(key);
+      if (existing) {
+        existing.rows.push(row);
+      } else {
+        groups.set(key, { work_item_id: row.work_item_id, item_type: row.item_type, stage: row.stage, rows: [row] });
+      }
+    }
+    const upsertHistory = this.db.prepare(
+      `INSERT OR REPLACE INTO stage_history
+         (work_item_id, item_type, stage, total_attempts, final_status, first_attempt, last_attempt, last_error, error_types, last_output)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    );
+    const deleteTransitions = this.db.prepare(
+      "DELETE FROM stage_transitions WHERE work_item_id = ? AND item_type = ? AND stage = ? AND created_at < ?"
+    );
+    let compacted = 0;
+    let deleted = 0;
+    const doCompact = this.db.transaction(() => {
+      for (const group of groups.values()) {
+        const latestRow = group.rows[group.rows.length - 1];
+        const earliestRow = group.rows[0];
+        const errorTypeCounts = {};
+        for (const row of group.rows) {
+          if (row.error_type) {
+            errorTypeCounts[row.error_type] = (errorTypeCounts[row.error_type] ?? 0) + 1;
+          }
+        }
+        const lastErrorRow = this.db.prepare(
+          `SELECT error_message FROM stage_transitions
+             WHERE work_item_id = ? AND item_type = ? AND stage = ?
+             ORDER BY id DESC LIMIT 1`
+        ).get(group.work_item_id, group.item_type, group.stage);
+        const lastSucceeded = group.rows.filter((r) => r.status === "succeeded").pop();
+        const lastOutput = lastSucceeded?.output ?? null;
+        upsertHistory.run(
+          group.work_item_id,
+          group.item_type,
+          group.stage,
+          group.rows.length,
+          latestRow.status,
+          earliestRow.created_at,
+          latestRow.created_at,
+          lastErrorRow?.error_message ?? null,
+          JSON.stringify(errorTypeCounts),
+          lastOutput
+        );
+        const deleteResult = deleteTransitions.run(
+          group.work_item_id,
+          group.item_type,
+          group.stage,
+          cutoff
+        );
+        compacted++;
+        deleted += deleteResult.changes;
+      }
+    });
+    doCompact();
+    return { compacted, deleted };
+  }
+  // -------------------------------------------------------------------------
+  // Recovery
+  // -------------------------------------------------------------------------
+  /**
+   * Recover stuck items on daemon startup.
+   *
+   * Finds all items currently in 'processing' status (via the pipeline_status view)
+   * and inserts a new 'pending' transition for each, effectively resetting them
+   * for reprocessing.
+   *
+   * Returns the count of recovered items.
+   */
+  recoverStuck() {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const stuckItems = this.db.prepare(
+      `SELECT id, item_type, stage FROM pipeline_status WHERE status = 'processing'`
+    ).all();
+    if (stuckItems.length === 0) {
+      return 0;
+    }
+    const insertPending = this.db.prepare(
+      `INSERT INTO stage_transitions
+         (work_item_id, item_type, stage, status, attempt, error_type, error_message, started_at, completed_at, created_at)
+       VALUES (?, ?, ?, 'pending', 1, NULL, NULL, NULL, NULL, ?)`
+    );
+    const doRecover = this.db.transaction(() => {
+      for (const item of stuckItems) {
+        insertPending.run(item.id, item.item_type, item.stage, now);
+      }
+    });
+    doRecover();
+    return stuckItems.length;
+  }
+  // -------------------------------------------------------------------------
+  // API query helpers
+  // -------------------------------------------------------------------------
+  /**
+   * List work items from the pipeline_status view with optional filters and pagination.
+   *
+   * Filters: stage, status, item_type. All optional.
+   * Returns rows ordered by work_items.created_at DESC (newest first).
+   */
+  listItems(filters) {
+    const conditions = [];
+    const params = [];
+    if (filters.stage) {
+      conditions.push("ps.stage = ?");
+      params.push(filters.stage);
+    }
+    if (filters.status) {
+      conditions.push("ps.status = ?");
+      params.push(filters.status);
+    }
+    if (filters.type) {
+      conditions.push("ps.item_type = ?");
+      params.push(filters.type);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const countSql = `SELECT COUNT(*) as total FROM pipeline_status ps ${where}`;
+    const countRow = this.db.prepare(countSql).get(...params);
+    const limit = filters.limit ?? PIPELINE_ITEMS_DEFAULT_LIMIT;
+    const offset = filters.offset ?? 0;
+    const querySql = `
+      SELECT ps.id, ps.item_type, ps.source_path, ps.stage, ps.status,
+             ps.attempt, ps.error_type, ps.error_message, ps.started_at, ps.completed_at
+      FROM pipeline_status ps
+      JOIN work_items wi ON wi.id = ps.id AND wi.item_type = ps.item_type
+      ${where}
+      ORDER BY wi.created_at DESC
+      LIMIT ? OFFSET ?
+    `;
+    const items = this.db.prepare(querySql).all(...params, limit, offset);
+    return { items, total: countRow.total };
+  }
+  /**
+   * Get the full transition history for a single work item.
+   * Returns all stage_transitions rows ordered by id ASC (oldest first).
+   */
+  getTransitionHistory(itemId, itemType) {
+    return this.db.prepare(
+      `SELECT id, work_item_id, item_type, stage, status, attempt,
+                error_type, error_message, started_at, completed_at, output, created_at
+         FROM stage_transitions
+         WHERE work_item_id = ? AND item_type = ?
+         ORDER BY id ASC`
+    ).all(itemId, itemType);
+  }
+  /**
+   * Retry a single poisoned work item by inserting a new 'pending' transition
+   * at the specified stage. Returns true if the item was poisoned and retried,
+   * false if the item was not found or not poisoned at that stage.
+   */
+  retryItem(itemId, itemType, stage) {
+    const current = this.db.prepare(
+      `SELECT status FROM pipeline_status
+         WHERE id = ? AND item_type = ? AND stage = ?`
+    ).get(itemId, itemType, stage);
+    if (!current || current.status !== "poisoned") {
+      return false;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.prepare(
+      `INSERT INTO stage_transitions
+           (work_item_id, item_type, stage, status, attempt, error_type, error_message, started_at, completed_at, created_at)
+         VALUES (?, ?, ?, 'pending', 1, NULL, NULL, NULL, NULL, ?)`
+    ).run(itemId, itemType, stage, now);
+    return true;
+  }
+  /**
+   * Skip a poisoned or failed work item at the specified stage.
+   * Inserts a 'skipped' transition so the item no longer counts as an error.
+   * Returns true if the item was in an error state and was skipped.
+   */
+  skipItem(itemId, itemType, stage) {
+    const current = this.db.prepare(
+      `SELECT status FROM pipeline_status
+         WHERE id = ? AND item_type = ? AND stage = ?`
+    ).get(itemId, itemType, stage);
+    if (!current || current.status !== "poisoned" && current.status !== "failed") {
+      return false;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.prepare(
+      `INSERT INTO stage_transitions
+           (work_item_id, item_type, stage, status, attempt, error_type, error_message, started_at, completed_at, created_at)
+         VALUES (?, ?, ?, 'skipped', 1, NULL, NULL, NULL, ?, ?)`
+    ).run(itemId, itemType, stage, now, now);
+    return true;
+  }
+  /**
+   * Retry all poisoned items by inserting new 'pending' transitions.
+   * Returns the count of items retried.
+   */
+  retryAllPoisoned() {
+    const poisonedItems = this.db.prepare(
+      `SELECT id, item_type, stage FROM pipeline_status WHERE status = 'poisoned'`
+    ).all();
+    if (poisonedItems.length === 0) {
+      return 0;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const insertPending = this.db.prepare(
+      `INSERT INTO stage_transitions
+         (work_item_id, item_type, stage, status, attempt, error_type, error_message, started_at, completed_at, created_at)
+       VALUES (?, ?, ?, 'pending', 1, NULL, NULL, NULL, NULL, ?)`
+    );
+    const doRetry = this.db.transaction(() => {
+      for (const item of poisonedItems) {
+        insertPending.run(item.id, item.item_type, item.stage, now);
+      }
+    });
+    doRetry();
+    return poisonedItems.length;
+  }
+  /**
+   * List all circuit breaker rows from the database.
+   */
+  listCircuits() {
+    return this.db.prepare("SELECT * FROM circuit_breakers ORDER BY provider_role ASC").all();
+  }
+  // -------------------------------------------------------------------------
+  // Tick processing
+  // -------------------------------------------------------------------------
+  handlers = null;
+  tickInProgress = false;
+  tickLogger = null;
+  /** Register stage handlers called by tick(). Must be set before tick() is useful. */
+  setHandlers(handlers) {
+    this.handlers = handlers;
+  }
+  /** Set a logger for tick diagnostics. */
+  setLogger(logger) {
+    this.tickLogger = logger;
+  }
+  /**
+   * Process one tick of the pipeline: for each tick-processable stage
+   * (extraction, embedding, consolidation), fetch a batch of pending items
+   * and run the corresponding handler.
+   *
+   * Stages are processed sequentially; items within a batch run concurrently.
+   *
+   * Guarded by tickInProgress — if a tick is already running, returns immediately.
+   */
+  async tick(batchSize) {
+    if (this.tickInProgress) {
+      return;
+    }
+    if (!this.handlers) {
+      return;
+    }
+    this.tickInProgress = true;
+    try {
+      for (const stage of PIPELINE_TICK_STAGES) {
+        const providerRole = STAGE_PROVIDER_MAP[stage];
+        if (providerRole) {
+          const circuit = this.circuitState(providerRole);
+          if (circuit.state === "open") {
+            const canProbe = this.probeCircuit(providerRole);
+            if (!canProbe) {
+              const blocked = this.blockItemsForCircuit(providerRole);
+              if (blocked > 0) {
+                this.tickLogger?.("debug", "pipeline", `Circuit open for ${providerRole}, blocked ${blocked} items`, { stage, providerRole });
+              }
+              continue;
+            }
+            this.tickLogger?.("debug", "pipeline", `Circuit half-open probe for ${providerRole}`, { stage, providerRole });
+          }
+        }
+        const batch = this.nextBatch(stage, batchSize);
+        if (batch.length === 0) {
+          continue;
+        }
+        const handler = this.handlers[stage];
+        if (!handler) {
+          continue;
+        }
+        await Promise.all(
+          batch.map(async (item) => {
+            this.advance(item.id, item.item_type, stage, "processing");
+            try {
+              const output = await handler(item.id, item.item_type, item.source_path);
+              this.advance(item.id, item.item_type, stage, "succeeded", void 0, output ?? void 0);
+              if (providerRole) {
+                const circuitAfter = this.circuitState(providerRole);
+                if (circuitAfter.state === "half-open") {
+                  this.resetCircuit(providerRole);
+                  const unblocked = this.unblockItemsForCircuit(providerRole);
+                  this.tickLogger?.("info", "pipeline", `Circuit closed after successful probe, unblocked ${unblocked} items`, { stage, providerRole });
+                }
+              }
+            } catch (err) {
+              const error = err instanceof Error ? err : new Error(String(err));
+              const classified = classifyError(error);
+              this.advance(item.id, item.item_type, stage, "failed", {
+                errorType: classified.type,
+                errorMessage: error.message
+              });
+              this.tickLogger?.("warn", "pipeline", `Stage handler failed: ${stage}`, {
+                itemId: item.id,
+                itemType: item.item_type,
+                errorType: classified.type,
+                error: error.message
+              });
+              if (classified.type === "config" && providerRole) {
+                const circuitBefore = this.circuitState(providerRole);
+                if (circuitBefore.state === "half-open") {
+                  this.reopenCircuit(providerRole, error.message);
+                  const blocked = this.blockItemsForCircuit(providerRole);
+                  this.tickLogger?.("warn", "pipeline", `Half-open probe failed for ${providerRole}, re-opened with doubled cooldown, blocked ${blocked} items`, { stage, providerRole });
+                } else {
+                  this.tripCircuit(providerRole, error.message);
+                  const circuitAfter = this.circuitState(providerRole);
+                  if (circuitAfter.state === "open") {
+                    const blocked = this.blockItemsForCircuit(providerRole);
+                    this.tickLogger?.("warn", "pipeline", `Circuit opened for ${providerRole}, blocked ${blocked} items`, { stage, providerRole });
+                  }
+                }
+              }
+            }
+          })
+        );
+      }
+    } finally {
+      this.tickInProgress = false;
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Digest gating helpers
+  // -------------------------------------------------------------------------
+  /**
+   * Check if any upstream stages (extraction, embedding, consolidation) have
+   * active work items (pending, processing, or blocked — but not failed/poisoned).
+   *
+   * Used to gate the digest engine: digest should not run while upstream
+   * stages still have work in flight.
+   */
+  hasUpstreamWork() {
+    const active = this.db.prepare(
+      `SELECT COUNT(*) as cnt FROM pipeline_status
+         WHERE stage IN ('extraction', 'embedding', 'consolidation')
+         AND status IN ('pending', 'processing', 'blocked')`
+    ).get();
+    if (active.cnt > 0) return true;
+    const midPipeline = this.db.prepare(
+      `SELECT COUNT(*) as cnt FROM pipeline_status ps1
+         WHERE ps1.stage = 'digest' AND ps1.status = 'pending'
+         AND EXISTS (
+           SELECT 1 FROM pipeline_status ps2
+           WHERE ps2.id = ps1.id AND ps2.item_type = ps1.item_type
+           AND ps2.stage != 'digest'
+           AND ps2.status NOT IN ('succeeded', 'skipped', 'failed', 'poisoned')
+         )`
+    ).get();
+    return midPipeline.cnt > 0;
+  }
+  /**
+   * Count items at digest:pending where ALL other stages for that item
+   * are in a terminal state (succeeded, skipped, failed, or poisoned).
+   *
+   * Used to gate digest: only run when enough processed substrate has accumulated.
+   */
+  newSubstrateSinceLastDigest() {
+    const result = this.db.prepare(
+      `SELECT COUNT(*) as cnt FROM pipeline_status ps1
+         WHERE ps1.stage = 'digest' AND ps1.status = 'pending'
+         AND NOT EXISTS (
+           SELECT 1 FROM pipeline_status ps2
+           WHERE ps2.id = ps1.id AND ps2.item_type = ps1.item_type
+           AND ps2.stage != 'digest'
+           AND ps2.status NOT IN ('succeeded', 'skipped', 'failed', 'poisoned')
+         )`
+    ).get();
+    return result.cnt;
+  }
+  /**
+   * Mark all digest:pending items as digest:succeeded after a successful cycle.
+   * Returns the number of items advanced.
+   */
+  advanceDigestItems(output) {
+    const items = this.db.prepare(
+      `SELECT id, item_type FROM pipeline_status
+         WHERE stage = 'digest' AND status = 'pending'`
+    ).all();
+    const advanceAll = this.db.transaction(() => {
+      for (const item of items) {
+        this.advance(item.id, item.item_type, "digest", "succeeded", void 0, output);
+      }
+    });
+    advanceAll();
+    return items.length;
+  }
+  // -------------------------------------------------------------------------
+  // Rebuild from vault
+  // -------------------------------------------------------------------------
+  /**
+   * Walk the vault and infer pipeline stage completion from existing data.
+   *
+   * Used for first-run migration: when pipeline.db is empty but the vault
+   * already has session, spore, and artifact files from prior processing.
+   *
+   * Algorithm:
+   * 1. Walk sessions/, spores/, artifacts/ directories for .md files
+   * 2. Register each as a work item with inferred stage statuses
+   * 3. Check vector index for embedding status
+   * 4. Check digest trace for digest status
+   * 5. Infer extraction status for sessions (check if spores reference them)
+   * 6. Mark spore consolidation as pending (cannot reliably infer)
+   */
+  rebuild(vaultDir, vectorIndex, digestTracePath) {
+    const digestedIds = this.loadDigestedIds(digestTracePath);
+    const sporeSessionIds = this.collectSporeSessionIds(vaultDir);
+    const stages = {};
+    let registered = 0;
+    const bumpStage = (key) => {
+      stages[key] = (stages[key] ?? 0) + 1;
+    };
+    const runRebuild2 = this.db.transaction(() => {
+      const sessionsDir = path10.join(vaultDir, "sessions");
+      for (const filePath of walkMarkdownFiles(sessionsDir)) {
+        const filename = path10.basename(filePath, ".md");
+        const itemId = filename.startsWith("session-") ? filename.slice("session-".length) : filename;
+        const relativePath = path10.relative(vaultDir, filePath);
+        this.register(itemId, "session", relativePath);
+        registered++;
+        this.advance(itemId, "session", "capture", "succeeded");
+        bumpStage("capture:succeeded");
+        if (sporeSessionIds.has(itemId) || sporeSessionIds.has(`session-${itemId}`)) {
+          this.advance(itemId, "session", "extraction", "succeeded");
+          bumpStage("extraction:succeeded");
+        } else {
+          bumpStage("extraction:pending");
+        }
+        if (vectorIndex?.has(itemId) || vectorIndex?.has(`session-${itemId}`)) {
+          this.advance(itemId, "session", "embedding", "succeeded");
+          bumpStage("embedding:succeeded");
+        } else {
+          bumpStage("embedding:pending");
+        }
+        if (digestedIds.has(itemId) || digestedIds.has(`session-${itemId}`)) {
+          this.advance(itemId, "session", "digest", "succeeded");
+          bumpStage("digest:succeeded");
+        } else {
+          bumpStage("digest:pending");
+        }
+      }
+      const sporesDir = path10.join(vaultDir, "spores");
+      for (const filePath of walkMarkdownFiles(sporesDir)) {
+        const itemId = path10.basename(filePath, ".md");
+        const relativePath = path10.relative(vaultDir, filePath);
+        this.register(itemId, "spore", relativePath);
+        registered++;
+        this.advance(itemId, "spore", "capture", "succeeded");
+        bumpStage("capture:succeeded");
+        if (vectorIndex?.has(itemId)) {
+          this.advance(itemId, "spore", "embedding", "succeeded");
+          bumpStage("embedding:succeeded");
+        } else {
+          bumpStage("embedding:pending");
+        }
+        bumpStage("consolidation:pending");
+        if (digestedIds.has(itemId)) {
+          this.advance(itemId, "spore", "digest", "succeeded");
+          bumpStage("digest:succeeded");
+        } else {
+          bumpStage("digest:pending");
+        }
+      }
+      const artifactsDir = path10.join(vaultDir, "artifacts");
+      for (const filePath of walkMarkdownFiles(artifactsDir)) {
+        const itemId = path10.basename(filePath, ".md");
+        const relativePath = path10.relative(vaultDir, filePath);
+        this.register(itemId, "artifact", relativePath);
+        registered++;
+        this.advance(itemId, "artifact", "capture", "succeeded");
+        bumpStage("capture:succeeded");
+        if (vectorIndex?.has(itemId)) {
+          this.advance(itemId, "artifact", "embedding", "succeeded");
+          bumpStage("embedding:succeeded");
+        } else {
+          bumpStage("embedding:pending");
+        }
+        if (digestedIds.has(itemId)) {
+          this.advance(itemId, "artifact", "digest", "succeeded");
+          bumpStage("digest:succeeded");
+        } else {
+          bumpStage("digest:pending");
+        }
+      }
+    });
+    runRebuild2();
+    return { registered, stages };
+  }
+  /**
+   * Read digest trace JSONL and collect all note IDs that appear in any
+   * substrate array. Returns an empty Set if the trace file doesn't exist.
+   */
+  loadDigestedIds(tracePath) {
+    const ids = /* @__PURE__ */ new Set();
+    if (!tracePath) return ids;
+    let content;
+    try {
+      content = fs7.readFileSync(tracePath, "utf-8").trim();
+    } catch {
+      return ids;
+    }
+    if (!content) return ids;
+    for (const line of content.split("\n")) {
+      try {
+        const record = JSON.parse(line);
+        if (record.substrate) {
+          for (const arr of Object.values(record.substrate)) {
+            if (Array.isArray(arr)) {
+              for (const id of arr) {
+                ids.add(id);
+              }
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    return ids;
+  }
+  /**
+   * Walk spore files and collect session IDs they reference.
+   * Used to infer whether extraction has been completed for a session.
+   */
+  collectSporeSessionIds(vaultDir) {
+    const sessionIds = /* @__PURE__ */ new Set();
+    const sporesDir = path10.join(vaultDir, "spores");
+    for (const filePath of walkMarkdownFiles(sporesDir)) {
+      try {
+        const content = fs7.readFileSync(filePath, "utf-8");
+        const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+        if (!fmMatch) continue;
+        const sessionMatch = fmMatch[1].match(/^session:\s*(?:"\[\[)?([^"\]]+)/m);
+        if (sessionMatch) {
+          const rawSession = sessionMatch[1].trim();
+          sessionIds.add(rawSession);
+          if (rawSession.startsWith("session-")) {
+            sessionIds.add(rawSession.slice("session-".length));
+          }
         }
+      } catch {
       }
-    })();
+    }
+    return sessionIds;
+  }
+  /** Close the database connection. */
+  close() {
+    this.db.close();
+  }
+};
+
+// src/daemon/main.ts
+var import_yaml2 = __toESM(require_dist(), 1);
+import fs8 from "fs";
+import path11 from "path";
+function indexAndEmbed(relativePath, noteId, embeddingText, metadata, deps) {
+  indexNote(deps.index, deps.vaultDir, relativePath);
+  if (deps.vectorIndex && embeddingText) {
+    generateEmbedding(deps.embeddingProvider, embeddingText.slice(0, EMBEDDING_INPUT_LIMIT)).then((emb) => deps.vectorIndex.upsert(noteId, emb.embedding, metadata)).catch((err) => deps.logger.debug("embeddings", "Embedding failed", { id: noteId, error: err.message }));
   }
 }
 async function captureArtifacts(candidates, classified, sessionId, deps, lineage) {
@@ -3325,28 +4750,28 @@ ${candidate.content}`,
   }
 }
 function migrateSporeFiles(vaultDir) {
-  const sporesDir = path9.join(vaultDir, "spores");
-  if (!fs6.existsSync(sporesDir)) return 0;
+  const sporesDir = path11.join(vaultDir, "spores");
+  if (!fs8.existsSync(sporesDir)) return 0;
   let moved = 0;
-  const entries = fs6.readdirSync(sporesDir);
+  const entries = fs8.readdirSync(sporesDir);
   for (const entry of entries) {
-    const fullPath = path9.join(sporesDir, entry);
+    const fullPath = path11.join(sporesDir, entry);
     if (!entry.endsWith(".md")) continue;
-    if (fs6.statSync(fullPath).isDirectory()) continue;
+    if (fs8.statSync(fullPath).isDirectory()) continue;
     try {
-      const content = fs6.readFileSync(fullPath, "utf-8");
+      const content = fs8.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 = path9.join(sporesDir, normalizedType);
-      fs6.mkdirSync(targetDir, { recursive: true });
-      const targetPath = path9.join(targetDir, entry);
-      fs6.renameSync(fullPath, targetPath);
+      const targetDir = path11.join(sporesDir, normalizedType);
+      fs8.mkdirSync(targetDir, { recursive: true });
+      const targetPath = path11.join(targetDir, entry);
+      fs8.renameSync(fullPath, targetPath);
       const now = /* @__PURE__ */ new Date();
-      fs6.utimesSync(targetPath, now, now);
+      fs8.utimesSync(targetPath, now, now);
       moved++;
     } catch {
     }
@@ -3359,22 +4784,22 @@ async function main() {
     process.stderr.write("Usage: mycod --vault <path>\n");
     process.exit(1);
   }
-  const vaultDir = path9.resolve(vaultArg);
+  const vaultDir = path11.resolve(vaultArg);
   const config = loadConfig(vaultDir);
-  const logger = new DaemonLogger(path9.join(vaultDir, "logs"), {
+  const logger = new DaemonLogger(path11.join(vaultDir, "logs"), {
     level: config.daemon.log_level,
     maxSize: config.daemon.max_log_size
   });
   let uiDir = null;
   {
-    let dir = path9.dirname(new URL(import.meta.url).pathname);
+    let dir = path11.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)) {
+      const candidate = path11.join(dir, "dist", "ui");
+      if (fs8.existsSync(path11.join(dir, "package.json")) && fs8.existsSync(candidate)) {
         uiDir = candidate;
         break;
       }
-      dir = path9.dirname(dir);
+      dir = path11.dirname(dir);
     }
   }
   if (uiDir) {
@@ -3382,16 +4807,8 @@ async function main() {
   }
   const server = new DaemonServer({ vaultDir, logger, uiDir: uiDir ?? void 0 });
   const registry = new SessionRegistry({
-    gracePeriod: config.daemon.grace_period,
-    onEmpty: async () => {
-      logger.info("daemon", "Grace period expired, shutting down");
-      metabolism?.stop();
-      planWatcher.stopFileWatcher();
-      await server.stop();
-      vectorIndex?.close();
-      index.close();
-      logger.close();
-      process.exit(0);
+    gracePeriod: 0,
+    onEmpty: () => {
     }
   });
   const llmProvider = createLlmProvider(config.intelligence.llm);
@@ -3399,15 +4816,192 @@ async function main() {
   let vectorIndex = null;
   try {
     const testEmbed = await embeddingProvider.embed("test");
-    vectorIndex = new VectorIndex(path9.join(vaultDir, "vectors.db"), testEmbed.dimensions);
+    vectorIndex = new VectorIndex(path11.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(path9.join(vaultDir, "index.db"));
+  const index = new MycoIndex(path11.join(vaultDir, "index.db"));
   const lineageGraph = new LineageGraph(vaultDir);
+  const pipeline = new PipelineManager(vaultDir, config.pipeline);
+  const recoveredCount = pipeline.recoverStuck();
+  if (recoveredCount > 0) {
+    logger.info("pipeline", "Recovered stuck pipeline items", { count: recoveredCount });
+  }
+  if (pipeline.isEmpty()) {
+    logger.info("pipeline", "First-run migration: rebuilding pipeline from vault");
+    const result = pipeline.rebuild(vaultDir, vectorIndex, path11.join(vaultDir, "digest", "trace.jsonl"));
+    logger.info("pipeline", "Pipeline rebuild complete", { registered: result.registered, stages: result.stages });
+  }
+  let consolidationEngine = null;
+  let consolidationPassRanThisTick = false;
+  pipeline.setHandlers({
+    extraction: async (itemId, itemType, sourcePath) => {
+      if (itemType !== "session") return;
+      logger.info("pipeline", "Extraction started", { session_id: itemId });
+      const fullPath = sourcePath ? path11.join(vaultDir, sourcePath) : null;
+      if (!fullPath || !fs8.existsSync(fullPath)) {
+        throw new Error(`Session note not found: ${sourcePath}`);
+      }
+      const fileContent = fs8.readFileSync(fullPath, "utf-8");
+      const { body, frontmatter } = stripFrontmatter(fileContent);
+      const conversationMarkdown = extractSection(body, CONVERSATION_HEADING);
+      const user = typeof frontmatter.user === "string" && frontmatter.user ? frontmatter.user : void 0;
+      if (!conversationMarkdown.trim()) {
+        throw new Error(`No conversation content in session note: ${sourcePath}`);
+      }
+      const extractionResult = await processor.process(conversationMarkdown, itemId);
+      if (extractionResult.degraded) {
+        throw new Error(`Observation extraction failed for session ${itemId}`);
+      }
+      const { summary: narrative, title } = await processor.summarizeSession(
+        conversationMarkdown,
+        itemId,
+        user
+      );
+      if (narrative.includes(SUMMARIZATION_FAILED_MARKER)) {
+        throw new Error(`Summarization failed for session ${itemId}: ${narrative}`);
+      }
+      const written = writeObservationNotes(
+        extractionResult.observations,
+        itemId,
+        vault,
+        index,
+        vaultDir
+      );
+      for (const note of written) {
+        indexAndEmbed(
+          note.path,
+          note.id,
+          `${note.observation.title}
+${note.observation.content}`,
+          { type: "spore", importance: "high", session_id: itemId },
+          indexDeps
+        );
+        logger.info("pipeline", "Spore written", { type: note.observation.type, title: note.observation.title, session_id: itemId });
+      }
+      const fmEnd = fileContent.indexOf("---", 4);
+      const parsedFm = import_yaml2.default.parse(fileContent.slice(4, fmEnd));
+      parsedFm.observations_count = written.length;
+      parsedFm.summary_tokens = estimateTokens(narrative);
+      parsedFm.extraction_model = config.intelligence.llm.model;
+      const fmYaml = import_yaml2.default.stringify(parsedFm, { defaultStringType: "QUOTE_DOUBLE", defaultKeyType: "PLAIN" }).trim();
+      const updatedBody = updateTitleAndSummary(body, title, narrative);
+      fs8.writeFileSync(fullPath, `---
+${fmYaml}
+---
+
+${updatedBody}`, "utf-8");
+      indexNote(index, vaultDir, sourcePath);
+      for (const note of written) {
+        pipeline.register(note.id, "spore", note.path);
+        pipeline.advance(note.id, "spore", "capture", "succeeded");
+      }
+      logger.info("pipeline", "Extraction completed", {
+        session_id: itemId,
+        observations: written.length,
+        title
+      });
+      return {
+        observations: written.length,
+        observation_ids: written.map((n) => n.id),
+        summary_tokens: estimateTokens(narrative),
+        title,
+        model: config.intelligence.llm.model
+      };
+    },
+    embedding: async (itemId, itemType, sourcePath) => {
+      if (!vectorIndex || !embeddingProvider) {
+        throw new Error("Embedding provider or vector index not available");
+      }
+      if (!sourcePath) {
+        throw new Error(`No source path for ${itemType}/${itemId}`);
+      }
+      const fullPath = path11.join(vaultDir, sourcePath);
+      if (!fs8.existsSync(fullPath)) {
+        throw new Error(`Vault note not found: ${sourcePath}`);
+      }
+      const fileContent = fs8.readFileSync(fullPath, "utf-8");
+      const { body, frontmatter } = stripFrontmatter(fileContent);
+      let embeddableText;
+      if (itemType === "session") {
+        const title = typeof frontmatter.title === "string" ? frontmatter.title : "";
+        const summary = typeof frontmatter.summary === "string" ? frontmatter.summary : "";
+        const calloutMatch = body.match(/> \[!abstract\] Summary\n((?:> .*\n?)*)/);
+        const narrative = calloutMatch ? calloutMatch[1].replace(/^> /gm, "").trim() : "";
+        embeddableText = `${title}
+${narrative || summary}`.trim();
+      } else {
+        const titleMatch = body.match(/^#\s+(.+)$/m);
+        const title = titleMatch ? titleMatch[1] : "";
+        embeddableText = `${title}
+${body}`.trim();
+      }
+      if (!embeddableText) {
+        logger.debug("pipeline", "No embeddable content, skipping", { id: itemId, type: itemType });
+        return;
+      }
+      const result = await generateEmbedding(
+        embeddingProvider,
+        embeddableText.slice(0, EMBEDDING_INPUT_LIMIT)
+      );
+      const metadata = {
+        type: itemType,
+        file_path: sourcePath,
+        session_id: typeof frontmatter.session === "string" ? frontmatter.session : typeof frontmatter.id === "string" && itemType === "session" ? frontmatter.id : "",
+        branch: typeof frontmatter.branch === "string" ? frontmatter.branch : ""
+      };
+      vectorIndex.upsert(itemId, result.embedding, metadata);
+      if (itemType === "session" && sourcePath) {
+        vault.updateNoteFrontmatter(sourcePath, {
+          embedding_model: config.intelligence.embedding.model
+        }, true);
+      }
+      logger.info("pipeline", "Embedding stored", {
+        id: itemId,
+        type: itemType,
+        dimensions: result.dimensions
+      });
+      return {
+        model: result.model,
+        dimensions: result.dimensions
+      };
+    },
+    consolidation: async (itemId, itemType) => {
+      if (itemType !== "spore") return;
+      const supersededIds = await checkSupersession(itemId, {
+        index,
+        vectorIndex,
+        embeddingProvider,
+        llmProvider,
+        vaultDir,
+        log: ((level, msg, data) => logger[level]("curation", msg, data))
+      });
+      if (consolidationEngine && !consolidationPassRanThisTick) {
+        consolidationPassRanThisTick = true;
+        await consolidationEngine.runPass();
+      }
+      return {
+        superseded: supersededIds ?? [],
+        wisdom_created: null,
+        candidates_evaluated: 0
+      };
+    }
+  });
+  pipeline.setLogger((level, domain, message, data) => {
+    const fn = logger[level];
+    if (typeof fn === "function") fn.call(logger, domain, message, data);
+  });
+  const pipelineTickTimer = setInterval(async () => {
+    try {
+      consolidationPassRanThisTick = false;
+      await pipeline.tick(config.pipeline.batch_size);
+    } catch (err) {
+      logger.error("pipeline", "Pipeline tick failed", { error: err.message });
+    }
+  }, config.pipeline.tick_interval_seconds * 1e3);
   const transcriptMiner = new TranscriptMiner({
     additionalAdapters: config.capture.transcript_paths.map(
       (p) => createPerProjectAdapter(p, claudeCodeAdapter.parseTurns)
@@ -3415,17 +5009,17 @@ async function main() {
   });
   let activeStopProcessing = null;
   const indexDeps = { index, vaultDir, vectorIndex, embeddingProvider, llmProvider, logger };
-  const bufferDir = path9.join(vaultDir, "buffer");
+  const bufferDir = path11.join(vaultDir, "buffer");
   const sessionBuffers = /* @__PURE__ */ new Map();
   const sessionFilePaths = /* @__PURE__ */ new Map();
   const capturedArtifactPaths = /* @__PURE__ */ new Map();
-  if (fs6.existsSync(bufferDir)) {
+  if (fs8.existsSync(bufferDir)) {
     const cutoff = Date.now() - STALE_BUFFER_MAX_AGE_MS;
-    for (const file of fs6.readdirSync(bufferDir)) {
-      const filePath = path9.join(bufferDir, file);
-      const stat4 = fs6.statSync(filePath);
+    for (const file of fs8.readdirSync(bufferDir)) {
+      const filePath = path11.join(bufferDir, file);
+      const stat4 = fs8.statSync(filePath);
       if (stat4.mtimeMs < cutoff) {
-        fs6.unlinkSync(filePath);
+        fs8.unlinkSync(filePath);
         logger.debug("daemon", "Cleaned stale buffer", { file });
       }
     }
@@ -3462,10 +5056,10 @@ async function main() {
       logger.info("watcher", "Plan detected", { source: event.source, file: event.filePath });
       if (event.filePath) {
         try {
-          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")}`;
+          const content = fs8.readFileSync(event.filePath, "utf-8");
+          const relativePath = path11.relative(vaultDir, event.filePath);
+          const title = content.match(/^#\s+(.+)$/m)?.[1] ?? path11.basename(event.filePath);
+          const planId = `plan-${path11.basename(event.filePath, ".md")}`;
           indexAndEmbed(
             relativePath,
             planId,
@@ -3486,16 +5080,16 @@ ${content}`,
     }
   });
   planWatcher.startFileWatcher();
+  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
+  };
+  const digestLlm = config.digest.intelligence.model || config.digest.intelligence.provider ? createLlmProvider(digestLlmConfig) : llmProvider;
   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,
@@ -3505,7 +5099,7 @@ ${content}`,
       log: (level, message, data) => logger[level]("digest", message, data)
     });
     if (config.digest.consolidation.enabled) {
-      const consolidationEngine = new ConsolidationEngine({
+      consolidationEngine = new ConsolidationEngine({
         vaultDir,
         index,
         vectorIndex,
@@ -3514,55 +5108,74 @@ ${content}`,
         maxTokens: config.digest.consolidation.max_tokens,
         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");
+      logger.info("consolidation", "Auto-consolidation enabled as pipeline stage");
     }
     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.onEmptyCycle();
-    });
+    let digestReady = true;
+    let forceDigest = false;
     metabolism.start(async () => {
+      digestReady = true;
+    });
+    const originalTick = pipeline.tick.bind(pipeline);
+    pipeline.tick = async (batchSize) => {
+      await originalTick(batchSize);
+      if (!digestReady) return;
+      if (pipeline.hasUpstreamWork()) {
+        logger.debug("digest", "Digest deferred \u2014 upstream stages pending");
+        return;
+      }
+      if (!forceDigest) {
+        const ready = pipeline.newSubstrateSinceLastDigest();
+        if (ready < config.digest.substrate.min_notes_for_cycle) {
+          logger.debug("digest", "Digest deferred \u2014 insufficient substrate", {
+            ready,
+            threshold: config.digest.substrate.min_notes_for_cycle
+          });
+          return;
+        }
+      }
+      digestReady = false;
+      forceDigest = false;
       try {
         const cycleResult = await digestEngine.runCycle();
         if (cycleResult) {
           metabolism.onSubstrateFound();
+          const digestOutput = {
+            included_in_cycle: cycleResult.cycleId,
+            tiers_generated: cycleResult.tiersGenerated
+          };
+          const advanced = pipeline.advanceDigestItems(digestOutput);
+          if (advanced > 0) {
+            logger.debug("digest", `Advanced ${advanced} pipeline items to digest:succeeded`);
+          }
           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");
+    };
+    server.registerRoute("POST", "/api/pipeline/digest/force", handleForceDigest(() => {
+      forceDigest = true;
+    }));
+    server.registerRoute("GET", "/api/pipeline/digest-health", handleDigestHealth({
+      vaultDir,
+      pipeline,
+      minNotesForCycle: config.digest.substrate.min_notes_for_cycle,
+      metabolismState: () => metabolism?.state ?? "disabled",
+      digestReady: () => digestReady,
+      cycleInProgress: () => digestEngine.isCycleInProgress
+    }));
+    logger.info("digest", "Digest enabled \u2014 controlled by pipeline tick");
   }
   const batchManager = new BatchManager(async (closedBatch) => {
     if (closedBatch.length === 0) return;
     const sessionId = closedBatch[0].session_id;
-    const asRecords = closedBatch;
-    const result = await processor.process(asRecords, sessionId);
-    if (!result.degraded) {
-      writeObservations(result.observations, sessionId, { vault, ...indexDeps });
-    }
-    logger.debug("processor", "Batch processed", {
+    logger.debug("processor", "Batch closed (extraction deferred to pipeline)", {
       session_id: sessionId,
-      events: closedBatch.length,
-      observations: result.observations.length,
-      degraded: result.degraded
+      events: closedBatch.length
     });
     const allPaths = sessionFilePaths.get(sessionId);
     const alreadyCaptured = capturedArtifactPaths.get(sessionId) ?? /* @__PURE__ */ new Set();
@@ -3580,7 +5193,7 @@ ${content}`,
           }
           const captured = capturedArtifactPaths.get(sessionId);
           for (const c of candidates) {
-            const absPath = path9.resolve(process.cwd(), c.path);
+            const absPath = path11.resolve(process.cwd(), c.path);
             captured.add(absPath);
           }
         }).catch((err) => logger.warn("processor", "Incremental artifact capture failed", {
@@ -3620,14 +5233,14 @@ ${content}`,
     registry.unregister(session_id);
     try {
       const cutoff = Date.now() - STALE_BUFFER_MAX_AGE_MS;
-      for (const file of fs6.readdirSync(bufferDir)) {
+      for (const file of fs8.readdirSync(bufferDir)) {
         if (!file.endsWith(".jsonl")) continue;
         const bufferSessionId = file.replace(".jsonl", "");
         if (bufferSessionId === session_id) continue;
-        const filePath = path9.join(bufferDir, file);
-        const stat4 = fs6.statSync(filePath);
+        const filePath = path11.join(bufferDir, file);
+        const stat4 = fs8.statSync(filePath);
         if (stat4.mtimeMs < cutoff) {
-          fs6.unlinkSync(filePath);
+          fs8.unlinkSync(filePath);
           logger.debug("daemon", "Cleaned stale buffer", { file });
         }
       }
@@ -3687,6 +5300,32 @@ ${content}`,
     });
     return { body: { ok: true } };
   });
+  function enrichTurnsWithToolMetadata(turns, events) {
+    if (events.length === 0 || turns.length === 0) return;
+    const toolEvents = events.filter((e) => e.type === "tool_use");
+    if (toolEvents.length === 0) return;
+    let cursor = 0;
+    for (let i = 0; i < turns.length; i++) {
+      const turnEnd = i + 1 < turns.length ? turns[i + 1].timestamp : null;
+      const breakdown = {};
+      const files = /* @__PURE__ */ new Set();
+      while (cursor < toolEvents.length) {
+        const ts = String(toolEvents[cursor].timestamp ?? "");
+        if (turnEnd !== null && ts >= turnEnd) break;
+        const evt = toolEvents[cursor];
+        const toolName = String(evt.tool_name ?? evt.tool ?? "unknown");
+        breakdown[toolName] = (breakdown[toolName] ?? 0) + 1;
+        const input = evt.tool_input;
+        const filePath = input?.file_path ?? input?.path;
+        if (typeof filePath === "string") files.add(filePath);
+        cursor++;
+      }
+      if (Object.keys(breakdown).length > 0) {
+        turns[i].toolBreakdown = breakdown;
+        if (files.size > 0) turns[i].files = [...files];
+      }
+    }
+  }
   async function processStopEvent(sessionId, user, sessionMeta, hookTranscriptPath, lastAssistantMessage) {
     const lastBatch = batchManager.finalize(sessionId);
     const transcriptResult = transcriptMiner.getAllTurnsWithSource(sessionId, hookTranscriptPath);
@@ -3720,17 +5359,18 @@ ${content}`,
         lastTurn.aiResponse = lastAssistantMessage;
       }
     }
+    enrichTurnsWithToolMetadata(allTurns, bufferEvents);
     const ended = (/* @__PURE__ */ new Date()).toISOString();
     let started = allTurns.length > 0 && allTurns[0].timestamp ? allTurns[0].timestamp : ended;
-    const sessionsDir = path9.join(vaultDir, "sessions");
+    const sessionsDir = path11.join(vaultDir, "sessions");
     const sessionFileName = `${sessionNoteId(sessionId)}.md`;
     let existingContent;
     const duplicatePaths = [];
     try {
-      for (const dateDir of fs6.readdirSync(sessionsDir)) {
-        const candidate = path9.join(sessionsDir, dateDir, sessionFileName);
+      for (const dateDir of fs8.readdirSync(sessionsDir)) {
+        const candidate = path11.join(sessionsDir, dateDir, sessionFileName);
         try {
-          const content = fs6.readFileSync(candidate, "utf-8");
+          const content = fs8.readFileSync(candidate, "utf-8");
           if (!existingContent || content.length > existingContent.length) {
             existingContent = content;
           }
@@ -3741,11 +5381,18 @@ ${content}`,
     } catch {
     }
     let existingTurnCount = 0;
+    let existingExtractionFields = null;
     if (existingContent) {
       const fmMatch = existingContent.match(/^---\n([\s\S]*?)\n---/);
       if (fmMatch) {
-        const parsed = import_yaml.default.parse(fmMatch[1]);
+        const parsed = import_yaml2.default.parse(fmMatch[1]);
         if (typeof parsed.started === "string") started = parsed.started;
+        const extractionKeys = ["observations_count", "summary_tokens", "extraction_model", "embedding_model"];
+        const preserved = {};
+        for (const key of extractionKeys) {
+          if (parsed[key] !== void 0) preserved[key] = parsed[key];
+        }
+        if (Object.keys(preserved).length > 0) existingExtractionFields = preserved;
       }
       const turnMatches = existingContent.match(/^### Turn \d+/gm);
       existingTurnCount = turnMatches?.length ?? 0;
@@ -3766,47 +5413,22 @@ ${content}`,
       logger.debug("processor", "No new turns, skipping session rewrite", { session_id: sessionId, turns: allTurns.length });
       return;
     }
-    const conversationText = allTurns.map((t, i) => {
-      const parts = [`### Turn ${i + 1}`];
-      if (t.prompt) parts.push(`Prompt: ${t.prompt}`);
-      if (t.toolCount > 0) parts.push(`Tools: ${t.toolCount} calls`);
-      if (t.aiResponse) parts.push(`Response: ${t.aiResponse}`);
-      return parts.join("\n");
-    }).join("\n\n");
-    const conversationSection = `${CONVERSATION_HEADING}
-
-${conversationText}`;
-    const observationPromise = lastBatch.length > 0 ? processor.process(lastBatch, sessionId).catch((err) => {
-      logger.warn("processor", "Observation extraction failed", { session_id: sessionId, error: err.message });
-      return null;
-    }) : Promise.resolve(null);
-    const artifactPromise = artifactCandidates.length > 0 ? processor.classifyArtifacts(artifactCandidates, sessionId).then((classified) => captureArtifacts(artifactCandidates, classified, sessionId, { vault, ...indexDeps }, lineageGraph)).catch((err) => {
-      logger.warn("processor", "Artifact capture failed", { session_id: sessionId, error: err.message });
-    }) : Promise.resolve();
-    const summaryPromise = processor.summarizeSession(conversationSection, sessionId, user).catch((err) => {
-      logger.warn("processor", "Session summarization failed", { session_id: sessionId, error: err.message });
-      return null;
-    });
-    const [observationResult, , summaryResult] = await Promise.all([observationPromise, artifactPromise, summaryPromise]);
-    if (observationResult && !observationResult.degraded) {
-      writeObservations(observationResult.observations, sessionId, { vault, ...indexDeps });
-    }
     const date = started.slice(0, 10);
     const relativePath = sessionRelativePath(sessionId, date);
-    const targetFullPath = path9.join(vaultDir, relativePath);
+    const targetFullPath = path11.join(vaultDir, relativePath);
     for (const dup of duplicatePaths) {
       if (dup !== targetFullPath) {
         try {
-          fs6.unlinkSync(dup);
+          fs8.unlinkSync(dup);
           logger.debug("lifecycle", "Removed duplicate session file", { path: dup });
         } catch {
         }
       }
     }
-    const attachmentsDir = path9.join(vaultDir, "attachments");
+    const attachmentsDir = path11.join(vaultDir, "attachments");
     const hasImages = allTurns.some((t) => t.images?.length);
     if (hasImages) {
-      fs6.mkdirSync(attachmentsDir, { recursive: true });
+      fs8.mkdirSync(attachmentsDir, { recursive: true });
     }
     const turnImageNames = /* @__PURE__ */ new Map();
     for (let i = 0; i < allTurns.length; i++) {
@@ -3817,9 +5439,9 @@ ${conversationText}`;
         const img = turn.images[j];
         const ext = extensionForMimeType(img.mediaType);
         const filename = `${bareSessionId(sessionId)}-t${i + 1}-${j + 1}.${ext}`;
-        const filePath = path9.join(attachmentsDir, filename);
-        if (!fs6.existsSync(filePath)) {
-          fs6.writeFileSync(filePath, Buffer.from(img.data, "base64"));
+        const filePath = path11.join(attachmentsDir, filename);
+        if (!fs8.existsSync(filePath)) {
+          fs8.writeFileSync(filePath, Buffer.from(img.data, "base64"));
           logger.debug("processor", "Image saved", { filename, turn: i + 1 });
         }
         names.push(filename);
@@ -3828,9 +5450,15 @@ ${conversationText}`;
     }
     let title = `Session ${sessionId}`;
     let narrative = "";
-    if (summaryResult) {
-      title = summaryResult.title;
-      narrative = summaryResult.summary;
+    if (existingContent) {
+      const existingTitle = existingContent.match(/^# (.+)$/m)?.[1];
+      if (existingTitle && existingTitle !== `Session ${sessionId}`) {
+        title = existingTitle;
+      }
+      const calloutMatch = existingContent.match(/> \[!abstract\] Summary\n((?:> .*\n?)*)/);
+      if (calloutMatch) {
+        narrative = calloutMatch[1].replace(/^> /gm, "").trim();
+      }
     }
     const relatedMemories = index.query({ type: "spore", limit: RELATED_SPORES_LIMIT }).filter((n) => {
       const fm = n.frontmatter;
@@ -3848,6 +5476,8 @@ ${conversationText}`;
       turns: allTurns.map((t, i) => ({
         prompt: t.prompt,
         toolCount: t.toolCount,
+        toolBreakdown: t.toolBreakdown,
+        files: t.files,
         aiResponse: t.aiResponse,
         images: turnImageNames.get(i)
       }))
@@ -3863,62 +5493,18 @@ ${conversationText}`;
       parent: parentId ? sessionWikilink(parentId) : void 0,
       parent_reason: parentLink?.signal,
       tools_used: allTurns.reduce((sum, t) => sum + t.toolCount, 0),
+      transcript_source: turnSource,
+      transcript_path: hookTranscriptPath,
       summary
     });
-    indexAndEmbed(
-      relativePath,
-      sessionNoteId(sessionId),
-      narrative,
-      { type: "session", session_id: sessionId },
-      indexDeps
-    );
-    logger.debug("processor", "Session turns", { source: turnSource, total: allTurns.length });
-    await artifactPromise;
-    if (!parentId && vectorIndex && narrative) {
-      generateEmbedding(embeddingProvider, narrative).then(async (emb) => {
-        const candidates = vectorIndex.search(emb.embedding, { limit: LINEAGE_SIMILARITY_CANDIDATES }).filter((r) => r.metadata.type === "session" && r.id !== sessionNoteId(sessionId));
-        if (candidates.length === 0) return;
-        const candidateNotes = index.queryByIds(candidates.map((c) => c.id));
-        const noteMap = new Map(candidateNotes.map((n) => [n.id, n]));
-        const scores = await Promise.all(candidates.map(async (candidate) => {
-          const note = noteMap.get(candidate.id);
-          if (!note) return { id: candidate.id, score: 0 };
-          try {
-            const prompt = buildSimilarityPrompt(narrative, note.content.slice(0, CANDIDATE_CONTENT_PREVIEW));
-            const response = await llmProvider.summarize(prompt, { maxTokens: LINEAGE_SIMILARITY_MAX_TOKENS, reasoning: LLM_REASONING_MODE });
-            const score = extractNumber(response.text);
-            return { id: candidate.id, score: isNaN(score) ? 0 : score };
-          } catch {
-            return { id: candidate.id, score: 0 };
-          }
-        }));
-        const best = scores.reduce((a, b) => b.score > a.score ? b : a);
-        if (best.score >= LINEAGE_SIMILARITY_THRESHOLD) {
-          const bestParentId = bareSessionId(best.id);
-          const confidence = best.score >= LINEAGE_SIMILARITY_HIGH_CONFIDENCE ? "high" : "medium";
-          lineageGraph.addLink({
-            parent: bestParentId,
-            child: sessionId,
-            signal: "semantic_similarity",
-            confidence
-          });
-          try {
-            vault.updateNoteFrontmatter(relativePath, {
-              parent: sessionWikilink(bestParentId),
-              parent_reason: "semantic_similarity"
-            });
-            indexNote(index, vaultDir, relativePath);
-          } catch {
-          }
-          logger.info("lineage", "LLM similarity parent detected", {
-            child: sessionId,
-            parent: bestParentId,
-            score: best.score
-          });
-        }
-      }).catch((err) => logger.debug("lineage", "Similarity detection failed", { error: err.message }));
+    if (existingExtractionFields) {
+      vault.updateNoteFrontmatter(relativePath, existingExtractionFields);
     }
-    logger.info("processor", "Session note written", { session_id: sessionId, path: relativePath });
+    indexNote(index, vaultDir, relativePath);
+    logger.debug("processor", "Session turns", { source: turnSource, total: allTurns.length });
+    pipeline.register(sessionId, "session", relativePath);
+    pipeline.advance(sessionId, "session", "capture", "succeeded");
+    logger.info("processor", "Session captured and registered in pipeline", { session_id: sessionId, path: relativePath });
   }
   server.registerRoute("POST", "/context", async (req) => {
     const { session_id, branch } = ContextBody.parse(req.body);
@@ -4045,8 +5631,10 @@ ${lines.join("\n")}`;
     index,
     vectorIndex,
     llmProvider,
+    digestLlmProvider: digestLlm,
     embeddingProvider,
     progressTracker,
+    pipeline,
     log: (level, message, data) => {
       const fn = logger[level];
       if (typeof fn === "function") fn.call(logger, "operations", message, data);
@@ -4057,6 +5645,14 @@ ${lines.join("\n")}`;
   server.registerRoute("POST", "/api/curate", async (req) => handleCurate(operationDeps, req.body, runCuration));
   server.registerRoute("POST", "/api/reprocess", async (req) => handleReprocess(operationDeps, req.body));
   server.registerRoute("GET", "/api/sessions", async () => handleGetSessions(index));
+  server.registerRoute("GET", "/api/pipeline/health", handlePipelineHealth(pipeline));
+  server.registerRoute("GET", "/api/pipeline/items", handlePipelineItems(pipeline));
+  server.registerRoute("GET", "/api/pipeline/items/:id", handlePipelineItemDetail(pipeline));
+  server.registerRoute("GET", "/api/pipeline/circuits", handlePipelineCircuits(pipeline));
+  server.registerRoute("POST", "/api/pipeline/retry/:id", handlePipelineRetry(pipeline));
+  server.registerRoute("POST", "/api/pipeline/skip/:id", handlePipelineSkip(pipeline));
+  server.registerRoute("POST", "/api/pipeline/retry-all", handlePipelineRetryAll(pipeline));
+  server.registerRoute("POST", "/api/pipeline/circuit/:provider/reset", handlePipelineCircuitReset(pipeline));
   await server.evictExistingDaemon();
   const resolvedPort = await resolvePort(config.daemon.port, vaultDir);
   if (resolvedPort === 0) {
@@ -4076,7 +5672,7 @@ ${lines.join("\n")}`;
   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");
+    fs8.writeFileSync(path11.join(vaultDir, "_portal.md"), portalContent, "utf-8");
   } catch {
   }
   if (needsMigrationReindex) {
@@ -4094,6 +5690,8 @@ ${lines.join("\n")}`;
       await activeStopProcessing;
     }
     metabolism?.stop();
+    clearInterval(pipelineTickTimer);
+    pipeline.close();
     planWatcher.stopFileWatcher();
     registry.destroy();
     await server.stop();
@@ -4114,4 +5712,4 @@ export {
 chokidar/index.js:
   (*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) *)
 */
-//# sourceMappingURL=main-3JZDUJLU.js.map
+//# sourceMappingURL=main-6AGPIMH2.js.map