@goondocks/myco 0.3.0 → 0.3.1

package/dist/{main-JY6O6ZVH.js → main-D4X6XWRT.js}

@@ -1,18 +1,24 @@
 import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+import {
+  BufferProcessor,
+  TranscriptMiner,
+  buildSimilarityPrompt,
+  extractNumber,
+  extractTurnsFromBuffer,
+  writeObservationNotes
+} from "./chunk-JIQISBPI.js";
 import {
   VaultWriter,
   bareSessionId,
-  formatMemoryBody,
   formatSessionBody,
   sessionNoteId,
   sessionRelativePath,
   sessionWikilink
 } from "./chunk-P2Q77C5F.js";
 import {
-  ARTIFACT_TYPES,
   indexNote,
   rebuildIndex
-} from "./chunk-QQWUV3TC.js";
+} from "./chunk-72OAG4SF.js";
 import {
   generateEmbedding
 } from "./chunk-RGVBGTD6.js";
@@ -44,33 +50,24 @@ import {
   EventBuffer
 } from "./chunk-I7PMGO6S.js";
 import {
-  AgentRegistry,
   claudeCodeAdapter,
   createPerProjectAdapter,
   extensionForMimeType
 } from "./chunk-2QEJKG7R.js";
 import {
-  AI_RESPONSE_PREVIEW_CHARS,
   CANDIDATE_CONTENT_PREVIEW,
-  CHARS_PER_TOKEN,
-  CLASSIFICATION_MAX_TOKENS,
-  COMMAND_PREVIEW_CHARS,
   CONTENT_SNIPPET_CHARS,
   CONTEXT_SESSION_PREVIEW_CHARS,
   EMBEDDING_INPUT_LIMIT,
-  EXTRACTION_MAX_TOKENS,
   FILE_WATCH_STABILITY_MS,
   LINEAGE_RECENT_SESSIONS_LIMIT,
   MAX_SLUG_LENGTH,
   PROMPT_CONTEXT_MAX_MEMORIES,
   PROMPT_CONTEXT_MIN_LENGTH,
   PROMPT_CONTEXT_MIN_SIMILARITY,
-  PROMPT_PREVIEW_CHARS,
   RELATED_MEMORIES_LIMIT,
   SESSION_CONTEXT_MAX_PLANS,
-  STALE_BUFFER_MAX_AGE_MS,
-  SUMMARY_MAX_TOKENS,
-  TITLE_MAX_TOKENS
+  STALE_BUFFER_MAX_AGE_MS
 } from "./chunk-Q7BEFSOV.js";
 import {
   __toESM
@@ -280,244 +277,9 @@ var BatchManager = class {
   }
 };
 
-// src/prompts/index.ts
+// src/daemon/lineage.ts
 import fs2 from "fs";
 import path2 from "path";
-import { fileURLToPath } from "url";
-var __dirname = path2.dirname(fileURLToPath(import.meta.url));
-var promptCache = /* @__PURE__ */ new Map();
-function loadPrompt(name) {
-  let cached = promptCache.get(name);
-  if (!cached) {
-    cached = fs2.readFileSync(path2.join(__dirname, `${name}.md`), "utf-8").trim();
-    promptCache.set(name, cached);
-  }
-  return cached;
-}
-function interpolate(template, vars) {
-  let result = template;
-  for (const [key, value] of Object.entries(vars)) {
-    result = result.replaceAll(`{{${key}}}`, value);
-  }
-  return result;
-}
-function buildExtractionPrompt(sessionId, eventCount, toolSummary) {
-  return interpolate(loadPrompt("extraction"), {
-    sessionId,
-    eventCount: String(eventCount),
-    toolSummary
-  });
-}
-function buildSummaryPrompt(sessionId, user, content) {
-  return interpolate(loadPrompt("summary"), {
-    sessionId,
-    user,
-    content
-  });
-}
-function buildTitlePrompt(summary, sessionId) {
-  return interpolate(loadPrompt("title"), {
-    summary,
-    sessionId
-  });
-}
-var ARTIFACT_TYPE_DESCRIPTIONS = [
-  '"spec" \u2014 Design specifications, architecture documents',
-  '"plan" \u2014 Implementation plans, roadmaps',
-  '"rfc" \u2014 Requests for comment, proposals',
-  '"doc" \u2014 Documentation, guides, READMEs',
-  '"other" \u2014 Other substantive documents'
-];
-function buildSimilarityPrompt(currentSummary, candidateSummary) {
-  return interpolate(loadPrompt("session-similarity"), {
-    currentSummary,
-    candidateSummary
-  });
-}
-function buildClassificationPrompt(sessionId, candidates) {
-  const fileList = candidates.map((c) => {
-    const truncated = c.content.slice(0, CANDIDATE_CONTENT_PREVIEW);
-    return `### ${c.path}
-\`\`\`
-${truncated}
-\`\`\``;
-  }).join("\n\n");
-  return interpolate(loadPrompt("classification"), {
-    sessionId,
-    fileList,
-    artifactTypes: ARTIFACT_TYPE_DESCRIPTIONS.map((d) => `- ${d}`).join("\n"),
-    validTypes: ARTIFACT_TYPES.join("|")
-  });
-}
-
-// src/intelligence/response.ts
-var REASONING_PATTERNS = [
-  // <think>...</think>answer  (DeepSeek, Qwen, GLM, many others)
-  /<think>[\s\S]*?<\/think>\s*/gi,
-  // Implicit opening: reasoning...</think>answer  (GLM-4.7 observed)
-  /^[\s\S]*?<\/think>\s*/i,
-  // <reasoning>...</reasoning>answer
-  /<reasoning>[\s\S]*?<\/reasoning>\s*/gi,
-  // <|thinking|>...<|/thinking|>answer
-  /<\|thinking\|>[\s\S]*?<\|\/thinking\|>\s*/gi
-];
-function stripReasoningTokens(text) {
-  if (!text) return text;
-  for (const pattern of REASONING_PATTERNS) {
-    const stripped = text.replace(pattern, "").trim();
-    if (stripped && stripped !== text.trim()) {
-      return stripped;
-    }
-  }
-  return text;
-}
-function extractJson(text) {
-  const cleaned = stripReasoningTokens(text);
-  const fenceMatch = cleaned.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
-  if (fenceMatch) {
-    return JSON.parse(fenceMatch[1].trim());
-  }
-  const objectMatch = cleaned.match(/\{[\s\S]*\}/);
-  if (objectMatch) {
-    return JSON.parse(objectMatch[0]);
-  }
-  return JSON.parse(cleaned);
-}
-function extractNumber(text) {
-  const cleaned = stripReasoningTokens(text).trim();
-  const match = cleaned.match(/(\d+\.?\d*)/);
-  if (match) return parseFloat(match[1]);
-  return parseFloat(cleaned);
-}
-
-// src/daemon/processor.ts
-var ClassificationResponseSchema = external_exports.object({
-  artifacts: external_exports.array(external_exports.object({
-    source_path: external_exports.string(),
-    artifact_type: external_exports.enum(ARTIFACT_TYPES),
-    title: external_exports.string(),
-    tags: external_exports.array(external_exports.string()).default([])
-  })).default([])
-});
-var BufferProcessor = class {
-  constructor(backend, contextWindow = 8192) {
-    this.backend = backend;
-    this.contextWindow = contextWindow;
-  }
-  truncateForContext(data, maxTokens) {
-    const available = this.contextWindow - maxTokens;
-    const dataTokens = Math.ceil(data.length / CHARS_PER_TOKEN);
-    if (dataTokens <= available) return data;
-    const charBudget = available * CHARS_PER_TOKEN;
-    return data.slice(0, charBudget);
-  }
-  async process(events, sessionId) {
-    const rawPrompt = this.buildPromptForExtraction(events, sessionId);
-    const prompt = this.truncateForContext(rawPrompt, EXTRACTION_MAX_TOKENS);
-    try {
-      const response = await this.backend.summarize(prompt, { maxTokens: EXTRACTION_MAX_TOKENS });
-      const parsed = extractJson(response.text);
-      return {
-        summary: parsed.summary,
-        observations: parsed.observations ?? [],
-        degraded: false
-      };
-    } catch (error) {
-      return {
-        summary: `LLM processing failed for session ${sessionId}. ${events.length} events captured. Error: ${error.message}`,
-        observations: [],
-        degraded: true
-      };
-    }
-  }
-  buildPromptForExtraction(events, sessionId) {
-    const toolSummary = this.summarizeEvents(events);
-    return buildExtractionPrompt(sessionId, events.length, toolSummary);
-  }
-  async summarizeSession(conversationMarkdown, sessionId, user) {
-    const truncatedContent = this.truncateForContext(conversationMarkdown, SUMMARY_MAX_TOKENS);
-    const summaryPrompt = buildSummaryPrompt(sessionId, user ?? "unknown", truncatedContent);
-    let summaryText;
-    try {
-      const response = await this.backend.summarize(summaryPrompt, { maxTokens: SUMMARY_MAX_TOKENS });
-      summaryText = stripReasoningTokens(response.text);
-    } catch (error) {
-      summaryText = `Session ${sessionId} \u2014 summarization failed: ${error.message}`;
-    }
-    const titlePrompt = buildTitlePrompt(summaryText, sessionId);
-    let title;
-    try {
-      const response = await this.backend.summarize(titlePrompt, { maxTokens: TITLE_MAX_TOKENS });
-      title = stripReasoningTokens(response.text).trim();
-    } catch {
-      title = `Session ${sessionId}`;
-    }
-    return { summary: summaryText, title };
-  }
-  async classifyArtifacts(candidates, sessionId) {
-    if (candidates.length === 0) return [];
-    const prompt = this.buildPromptForClassification(candidates, sessionId);
-    const response = await this.backend.summarize(prompt, { maxTokens: CLASSIFICATION_MAX_TOKENS });
-    const raw = extractJson(response.text);
-    const parsed = ClassificationResponseSchema.parse(raw);
-    return parsed.artifacts;
-  }
-  buildPromptForClassification(candidates, sessionId) {
-    return buildClassificationPrompt(sessionId, candidates);
-  }
-  summarizeEvents(events) {
-    const toolCounts = /* @__PURE__ */ new Map();
-    const filesAccessed = /* @__PURE__ */ new Set();
-    const prompts = [];
-    const aiResponses = [];
-    for (const event of events) {
-      if (event.type === "user_prompt") {
-        const prompt = String(event.prompt ?? "");
-        if (prompt) prompts.push(prompt.slice(0, PROMPT_PREVIEW_CHARS));
-        continue;
-      }
-      if (event.type === "ai_response") {
-        const content = String(event.content ?? "");
-        if (content) aiResponses.push(content.slice(0, AI_RESPONSE_PREVIEW_CHARS));
-        continue;
-      }
-      const tool = String(event.tool_name ?? event.tool ?? "unknown");
-      toolCounts.set(tool, (toolCounts.get(tool) ?? 0) + 1);
-      const input = event.tool_input ?? event.input;
-      if (input?.path) filesAccessed.add(String(input.path));
-      if (input?.file_path) filesAccessed.add(String(input.file_path));
-      if (input?.command) filesAccessed.add(`[cmd] ${String(input.command).slice(0, COMMAND_PREVIEW_CHARS)}`);
-    }
-    const lines = [];
-    if (prompts.length > 0) {
-      lines.push("### User Prompts");
-      for (const p of prompts) {
-        lines.push(`- "${p}"`);
-      }
-    }
-    lines.push("\n### Tool Usage");
-    for (const [tool, count] of toolCounts) {
-      lines.push(`- ${tool}: ${count} calls`);
-    }
-    if (filesAccessed.size > 0) {
-      lines.push("\n### Files Accessed");
-      for (const file of filesAccessed) {
-        lines.push(`- ${file}`);
-      }
-    }
-    if (aiResponses.length > 0) {
-      lines.push("\n### AI Responses");
-      for (const r of aiResponses) {
-        lines.push(`- "${r}"`);
-      }
-    }
-    return lines.join("\n");
-  }
-};
-
-// src/daemon/lineage.ts
-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;
@@ -530,8 +292,8 @@ var LineageGraph = class {
   state;
   filePath;
   constructor(vaultDir) {
-    this.filePath = path3.join(vaultDir, "lineage.json");
-    fs3.mkdirSync(path3.dirname(this.filePath), { recursive: true });
+    this.filePath = path2.join(vaultDir, "lineage.json");
+    fs2.mkdirSync(path2.dirname(this.filePath), { recursive: true });
     this.state = this.load();
   }
   addLink(link) {
@@ -611,7 +373,7 @@ var LineageGraph = class {
   }
   load() {
     try {
-      const raw = JSON.parse(fs3.readFileSync(this.filePath, "utf-8"));
+      const raw = JSON.parse(fs2.readFileSync(this.filePath, "utf-8"));
       const sessionArtifacts = raw.sessionArtifacts ?? raw.sessionPlans ?? {};
       return { links: raw.links ?? [], sessionArtifacts };
     } catch {
@@ -620,8 +382,8 @@ var LineageGraph = class {
   }
   persist() {
     const tmp = this.filePath + ".tmp";
-    fs3.writeFileSync(tmp, JSON.stringify(this.state, null, 2));
-    fs3.renameSync(tmp, this.filePath);
+    fs2.writeFileSync(tmp, JSON.stringify(this.state, null, 2));
+    fs2.renameSync(tmp, this.filePath);
   }
 };
 
@@ -715,7 +477,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path8) => statMethod(path8, { bigint: true });
+      this._stat = (path7) => statMethod(path7, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -740,8 +502,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path8, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path8));
+          const { path: path7, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path7));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -781,20 +543,20 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path8, depth) {
+  async _exploreDir(path7, depth) {
     let files;
     try {
-      files = await readdir(path8, this._rdOptions);
+      files = await readdir(path7, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path8 };
+    return { files, depth, path: path7 };
   }
-  async _formatEntry(dirent, path8) {
+  async _formatEntry(dirent, path7) {
     let entry;
     const basename3 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path8, basename3));
+      const fullPath = presolve(pjoin(path7, basename3));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename3 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -1194,16 +956,16 @@ var delFromSet = (main2, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path8, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path7, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path8);
-    emitRaw(rawEvent, evPath, { watchedPath: path8 });
-    if (evPath && path8 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path8, evPath), KEY_LISTENERS, sp.join(path8, evPath));
+    listener(path7);
+    emitRaw(rawEvent, evPath, { watchedPath: path7 });
+    if (evPath && path7 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path7, evPath), KEY_LISTENERS, sp.join(path7, evPath));
     }
   };
   try {
-    return fs_watch(path8, {
+    return fs_watch(path7, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -1219,12 +981,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path8, fullPath, options, handlers) => {
+var setFsWatchListener = (path7, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path8, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path7, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -1235,7 +997,7 @@ var setFsWatchListener = (path8, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path8,
+      path7,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -1250,7 +1012,7 @@ var setFsWatchListener = (path8, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path8, "r");
+          const fd = await open(path7, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -1281,7 +1043,7 @@ var setFsWatchListener = (path8, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path8, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path7, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -1303,7 +1065,7 @@ var setFsWatchFileListener = (path8, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path8, curr));
+          foreach(cont.listeners, (listener2) => listener2(path7, curr));
         }
       })
     };
@@ -1333,13 +1095,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path8, listener) {
+  _watchWithNodeFs(path7, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path8);
-    const basename3 = sp.basename(path8);
+    const directory = sp.dirname(path7);
+    const basename3 = sp.basename(path7);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename3);
-    const absolutePath = sp.resolve(path8);
+    const absolutePath = sp.resolve(path7);
     const options = {
       persistent: opts.persistent
     };
@@ -1349,12 +1111,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename3) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path8, absolutePath, options, {
+      closer = setFsWatchFileListener(path7, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path8, absolutePath, options, {
+      closer = setFsWatchListener(path7, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -1376,7 +1138,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename3))
       return;
-    const listener = async (path8, newStats) => {
+    const listener = async (path7, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -1390,11 +1152,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path8);
+            this.fsw._closeFile(path7);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path8, closer2);
+              this.fsw._addPathCloser(path7, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -1426,7 +1188,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, path8, item) {
+  async _handleSymlink(entry, directory, path7, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -1436,7 +1198,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path8);
+        linkPath = await fsrealpath(path7);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -1446,12 +1208,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, path8, entry.stats);
+          this.fsw._emit(EV.CHANGE, path7, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path8, entry.stats);
+        this.fsw._emit(EV.ADD, path7, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -1481,9 +1243,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path8 = sp.join(directory, item);
+      let path7 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path8, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path7, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -1492,8 +1254,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path8 = sp.join(dir, sp.relative(dir, path8));
-        this._addToNodeFs(path8, initialAdd, wh, depth + 1);
+        path7 = sp.join(dir, sp.relative(dir, path7));
+        this._addToNodeFs(path7, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve3, reject) => {
@@ -1562,13 +1324,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path8, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path7, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path8) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path7) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path8);
+    const wh = this.fsw._getWatchHelpers(path7);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -1584,8 +1346,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path8);
-        const targetPath = follow ? await fsrealpath(path8) : path8;
+        const absPath = sp.resolve(path7);
+        const targetPath = follow ? await fsrealpath(path7) : path7;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -1595,29 +1357,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path8) : path8;
+        const targetPath = follow ? await fsrealpath(path7) : path7;
         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, path8, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path7, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path8), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path7), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path8, closer);
+        this.fsw._addPathCloser(path7, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path8;
+        return path7;
       }
     }
   }
@@ -1660,24 +1422,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path8) {
-  if (typeof path8 !== "string")
+function normalizePath(path7) {
+  if (typeof path7 !== "string")
     throw new Error("string expected");
-  path8 = sp2.normalize(path8);
-  path8 = path8.replace(/\\/g, "/");
+  path7 = sp2.normalize(path7);
+  path7 = path7.replace(/\\/g, "/");
   let prepend = false;
-  if (path8.startsWith("//"))
+  if (path7.startsWith("//"))
     prepend = true;
-  path8 = path8.replace(DOUBLE_SLASH_RE, "/");
+  path7 = path7.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path8 = "/" + path8;
-  return path8;
+    path7 = "/" + path7;
+  return path7;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path8 = normalizePath(testString);
+  const path7 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path8, stats)) {
+    if (pattern(path7, stats)) {
       return true;
     }
   }
@@ -1715,19 +1477,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path8) => toUnix(sp2.normalize(toUnix(path8)));
-var normalizeIgnored = (cwd = "") => (path8) => {
-  if (typeof path8 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path8) ? path8 : sp2.join(cwd, path8));
+var normalizePathToUnix = (path7) => toUnix(sp2.normalize(toUnix(path7)));
+var normalizeIgnored = (cwd = "") => (path7) => {
+  if (typeof path7 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path7) ? path7 : sp2.join(cwd, path7));
   } else {
-    return path8;
+    return path7;
   }
 };
-var getAbsolutePath = (path8, cwd) => {
-  if (sp2.isAbsolute(path8)) {
-    return path8;
+var getAbsolutePath = (path7, cwd) => {
+  if (sp2.isAbsolute(path7)) {
+    return path7;
   }
-  return sp2.join(cwd, path8);
+  return sp2.join(cwd, path7);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -1792,10 +1554,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path8, follow, fsw) {
+  constructor(path7, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path8;
-    this.path = path8 = path8.replace(REPLACER_RE, "");
+    const watchPath = path7;
+    this.path = path7 = path7.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -1935,20 +1697,20 @@ var FSWatcher = class extends EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path8) => {
-        const absPath = getAbsolutePath(path8, cwd);
+      paths = paths.map((path7) => {
+        const absPath = getAbsolutePath(path7, cwd);
         return absPath;
       });
     }
-    paths.forEach((path8) => {
-      this._removeIgnoredPath(path8);
+    paths.forEach((path7) => {
+      this._removeIgnoredPath(path7);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path8) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path8, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path7) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path7, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -1970,17 +1732,17 @@ var FSWatcher = class extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path8) => {
-      if (!sp2.isAbsolute(path8) && !this._closers.has(path8)) {
+    paths.forEach((path7) => {
+      if (!sp2.isAbsolute(path7) && !this._closers.has(path7)) {
         if (cwd)
-          path8 = sp2.join(cwd, path8);
-        path8 = sp2.resolve(path8);
+          path7 = sp2.join(cwd, path7);
+        path7 = sp2.resolve(path7);
       }
-      this._closePath(path8);
-      this._addIgnoredPath(path8);
-      if (this._watched.has(path8)) {
+      this._closePath(path7);
+      this._addIgnoredPath(path7);
+      if (this._watched.has(path7)) {
         this._addIgnoredPath({
-          path: path8,
+          path: path7,
           recursive: true
         });
       }
@@ -2044,38 +1806,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, path8, stats) {
+  async _emit(event, path7, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path8 = sp2.normalize(path8);
+      path7 = sp2.normalize(path7);
     if (opts.cwd)
-      path8 = sp2.relative(opts.cwd, path8);
-    const args = [path8];
+      path7 = sp2.relative(opts.cwd, path7);
+    const args = [path7];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path8))) {
+    if (awf && (pw = this._pendingWrites.get(path7))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path8, [event, ...args]);
+        this._pendingUnlinks.set(path7, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path9) => {
+          this._pendingUnlinks.forEach((entry, path8) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path9);
+            this._pendingUnlinks.delete(path8);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path8)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path7)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path8);
+        this._pendingUnlinks.delete(path7);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -2093,16 +1855,16 @@ var FSWatcher = class extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path8, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path7, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path8, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path7, 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, path8) : path8;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path7) : path7;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -2133,23 +1895,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, path8, timeout) {
+  _throttle(actionType, path7, 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(path8);
+    const actionPath = action.get(path7);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path8);
+      const item = action.get(path7);
       const count = item ? item.count : 0;
-      action.delete(path8);
+      action.delete(path7);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -2157,7 +1919,7 @@ var FSWatcher = class extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path8, thr);
+    action.set(path7, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -2171,44 +1933,44 @@ var FSWatcher = class extends EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path8, threshold, event, awfEmit) {
+  _awaitWriteFinish(path7, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path8;
-    if (this.options.cwd && !sp2.isAbsolute(path8)) {
-      fullPath = sp2.join(this.options.cwd, path8);
+    let fullPath = path7;
+    if (this.options.cwd && !sp2.isAbsolute(path7)) {
+      fullPath = sp2.join(this.options.cwd, path7);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path8)) {
+        if (err || !writes.has(path7)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path8).lastChange = now2;
+          writes.get(path7).lastChange = now2;
         }
-        const pw = writes.get(path8);
+        const pw = writes.get(path7);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path8);
+          writes.delete(path7);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path8)) {
-      writes.set(path8, {
+    if (!writes.has(path7)) {
+      writes.set(path7, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path8);
+          writes.delete(path7);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -2219,8 +1981,8 @@ var FSWatcher = class extends EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path8, stats) {
-    if (this.options.atomic && DOT_RE.test(path8))
+  _isIgnored(path7, stats) {
+    if (this.options.atomic && DOT_RE.test(path7))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -2230,17 +1992,17 @@ var FSWatcher = class extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path8, stats);
+    return this._userIgnored(path7, stats);
   }
-  _isntIgnored(path8, stat4) {
-    return !this._isIgnored(path8, stat4);
+  _isntIgnored(path7, stat4) {
+    return !this._isIgnored(path7, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path8) {
-    return new WatchHelper(path8, this.options.followSymlinks, this);
+  _getWatchHelpers(path7) {
+    return new WatchHelper(path7, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -2272,63 +2034,63 @@ var FSWatcher = class extends EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path8 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path8);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path8) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path8, 100))
+    const path7 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path7);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path7) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path7, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path8);
+    const wp = this._getWatchedDir(path7);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path8, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path7, 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 = path8;
+    let relPath = path7;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path8);
+      relPath = sp2.relative(this.options.cwd, path7);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path8);
+    this._watched.delete(path7);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path8))
-      this._emit(eventName, path8);
-    this._closePath(path8);
+    if (wasTracked && !this._isIgnored(path7))
+      this._emit(eventName, path7);
+    this._closePath(path7);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path8) {
-    this._closeFile(path8);
-    const dir = sp2.dirname(path8);
-    this._getWatchedDir(dir).remove(sp2.basename(path8));
+  _closePath(path7) {
+    this._closeFile(path7);
+    const dir = sp2.dirname(path7);
+    this._getWatchedDir(dir).remove(sp2.basename(path7));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path8) {
-    const closers = this._closers.get(path8);
+  _closeFile(path7) {
+    const closers = this._closers.get(path7);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path8);
+    this._closers.delete(path7);
   }
-  _addPathCloser(path8, closer) {
+  _addPathCloser(path7, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path8);
+    let list = this._closers.get(path7);
     if (!list) {
       list = [];
-      this._closers.set(path8, list);
+      this._closers.set(path7, list);
     }
     list.push(closer);
   }
@@ -2357,7 +2119,7 @@ function watch(paths, options = {}) {
 }
 
 // src/daemon/watcher.ts
-import path4 from "path";
+import path3 from "path";
 var PlanWatcher = class {
   config;
   fsWatcher = null;
@@ -2383,7 +2145,7 @@ var PlanWatcher = class {
           source: "tool",
           filePath,
           sessionId: event.session_id,
-          detail: `${event.tool_name} on plan file: ${path4.basename(filePath)}`,
+          detail: `${event.tool_name} on plan file: ${path3.basename(filePath)}`,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
       }
@@ -2391,7 +2153,7 @@ var PlanWatcher = class {
   }
   startFileWatcher() {
     const absPaths = this.config.watchPaths.map(
-      (p) => path4.resolve(this.config.projectRoot, p)
+      (p) => path3.resolve(this.config.projectRoot, p)
     );
     this.fsWatcher = watch(absPaths, {
       ignoreInitial: true,
@@ -2407,7 +2169,7 @@ var PlanWatcher = class {
     this.fsWatcher = null;
   }
   onFileChange(absolutePath, action) {
-    const rel = path4.relative(this.config.projectRoot, absolutePath);
+    const rel = path3.relative(this.config.projectRoot, absolutePath);
     this.knownPlans.add(absolutePath);
     this.config.onPlan({
       source: "filesystem",
@@ -2417,95 +2179,17 @@ var PlanWatcher = class {
     });
   }
   isInPlanDirectory(filePath) {
-    const abs = path4.isAbsolute(filePath) ? filePath : path4.resolve(this.config.projectRoot, filePath);
+    const abs = path3.isAbsolute(filePath) ? filePath : path3.resolve(this.config.projectRoot, filePath);
     return this.config.watchPaths.some(
-      (wp) => abs.startsWith(path4.resolve(this.config.projectRoot, wp))
+      (wp) => abs.startsWith(path3.resolve(this.config.projectRoot, wp))
     );
   }
 };
 
-// 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/vault/observations.ts
-function writeObservationNotes(observations, sessionId, writer, index, vaultDir) {
-  const results = [];
-  for (const obs of observations) {
-    const obsId = `${obs.type}-${sessionId.slice(-6)}-${Date.now()}`;
-    const body = formatMemoryBody({
-      title: obs.title,
-      observationType: obs.type,
-      content: obs.content,
-      sessionId,
-      root_cause: obs.root_cause,
-      fix: obs.fix,
-      rationale: obs.rationale,
-      alternatives_rejected: obs.alternatives_rejected,
-      gained: obs.gained,
-      sacrificed: obs.sacrificed,
-      tags: obs.tags
-    });
-    const relativePath = writer.writeMemory({
-      id: obsId,
-      observation_type: obs.type,
-      session: sessionNoteId(sessionId),
-      tags: obs.tags,
-      content: body
-    });
-    indexNote(index, vaultDir, relativePath);
-    results.push({ id: obsId, path: relativePath, observation: obs });
-  }
-  return results;
-}
-
 // src/artifacts/candidates.ts
 import { execFileSync } from "child_process";
-import fs4 from "fs";
-import path5 from "path";
+import fs3 from "fs";
+import path4 from "path";
 var EXCLUDED_FILENAMES = /* @__PURE__ */ new Set([
   "claude.md",
   "agents.md",
@@ -2526,7 +2210,7 @@ var EXCLUDED_PREFIXES = [
   ".github/"
 ];
 function isExcludedPath(relativePath) {
-  const basename3 = path5.basename(relativePath).toLowerCase();
+  const basename3 = path4.basename(relativePath).toLowerCase();
   if (EXCLUDED_FILENAMES.has(basename3)) return true;
   const normalized = relativePath.replace(/\\/g, "/");
   return EXCLUDED_PREFIXES.some((prefix) => normalized.startsWith(prefix));
@@ -2534,7 +2218,7 @@ function isExcludedPath(relativePath) {
 function collectArtifactCandidates(filePaths, config, projectRoot) {
   if (filePaths.size === 0) return [];
   const extFiltered = [...filePaths].filter(
-    (absPath) => config.artifact_extensions.includes(path5.extname(absPath))
+    (absPath) => config.artifact_extensions.includes(path4.extname(absPath))
   );
   if (extFiltered.length === 0) return [];
   const ignoredSet = getGitIgnored(extFiltered, projectRoot);
@@ -2542,8 +2226,8 @@ function collectArtifactCandidates(filePaths, config, projectRoot) {
   for (const absPath of extFiltered) {
     if (ignoredSet.has(absPath)) continue;
     try {
-      const content = fs4.readFileSync(absPath, "utf-8");
-      const relativePath = path5.relative(projectRoot, absPath);
+      const content = fs3.readFileSync(absPath, "utf-8");
+      const relativePath = path4.relative(projectRoot, absPath);
       if (isExcludedPath(relativePath)) continue;
       candidates.push({ path: relativePath, content });
     } catch {
@@ -2566,9 +2250,9 @@ function getGitIgnored(filePaths, cwd) {
 
 // src/artifacts/slugify.ts
 import crypto from "crypto";
-import path6 from "path";
+import path5 from "path";
 function slugifyPath(relativePath) {
-  const ext = path6.extname(relativePath);
+  const ext = path5.extname(relativePath);
   const withoutExt = ext ? relativePath.slice(0, -ext.length) : relativePath;
   let slug = withoutExt.replace(/[/\\]/g, "-").toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
   if (slug.length > MAX_SLUG_LENGTH) {
@@ -2580,8 +2264,8 @@ function slugifyPath(relativePath) {
 
 // src/daemon/main.ts
 var import_yaml = __toESM(require_dist(), 1);
-import fs5 from "fs";
-import path7 from "path";
+import fs4 from "fs";
+import path6 from "path";
 function indexAndEmbed(relativePath, noteId, embeddingText, metadata, deps) {
   indexNote(deps.index, deps.vaultDir, relativePath);
   if (deps.vectorIndex && embeddingText) {
@@ -2634,28 +2318,28 @@ ${candidate.content}`,
   }
 }
 function migrateMemoryFiles(vaultDir) {
-  const memoriesDir = path7.join(vaultDir, "memories");
-  if (!fs5.existsSync(memoriesDir)) return 0;
+  const memoriesDir = path6.join(vaultDir, "memories");
+  if (!fs4.existsSync(memoriesDir)) return 0;
   let moved = 0;
-  const entries = fs5.readdirSync(memoriesDir);
+  const entries = fs4.readdirSync(memoriesDir);
   for (const entry of entries) {
-    const fullPath = path7.join(memoriesDir, entry);
+    const fullPath = path6.join(memoriesDir, entry);
     if (!entry.endsWith(".md")) continue;
-    if (fs5.statSync(fullPath).isDirectory()) continue;
+    if (fs4.statSync(fullPath).isDirectory()) continue;
     try {
-      const content = fs5.readFileSync(fullPath, "utf-8");
+      const content = fs4.readFileSync(fullPath, "utf-8");
       const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
       if (!fmMatch) continue;
       const parsed = import_yaml.default.parse(fmMatch[1]);
       const obsType = parsed.observation_type;
       if (!obsType) continue;
       const normalizedType = obsType.replace(/_/g, "-");
-      const targetDir = path7.join(memoriesDir, normalizedType);
-      fs5.mkdirSync(targetDir, { recursive: true });
-      const targetPath = path7.join(targetDir, entry);
-      fs5.renameSync(fullPath, targetPath);
+      const targetDir = path6.join(memoriesDir, normalizedType);
+      fs4.mkdirSync(targetDir, { recursive: true });
+      const targetPath = path6.join(targetDir, entry);
+      fs4.renameSync(fullPath, targetPath);
       const now = /* @__PURE__ */ new Date();
-      fs5.utimesSync(targetPath, now, now);
+      fs4.utimesSync(targetPath, now, now);
       moved++;
     } catch {
     }
@@ -2668,9 +2352,9 @@ async function main() {
     process.stderr.write("Usage: mycod --vault <path>\n");
     process.exit(1);
   }
-  const vaultDir = path7.resolve(vaultArg);
+  const vaultDir = path6.resolve(vaultArg);
   const config = loadConfig(vaultDir);
-  const logger = new DaemonLogger(path7.join(vaultDir, "logs"), {
+  const logger = new DaemonLogger(path6.join(vaultDir, "logs"), {
     level: config.daemon.log_level,
     maxSize: config.daemon.max_log_size
   });
@@ -2692,14 +2376,14 @@ async function main() {
   let vectorIndex = null;
   try {
     const testEmbed = await embeddingProvider.embed("test");
-    vectorIndex = new VectorIndex(path7.join(vaultDir, "vectors.db"), testEmbed.dimensions);
+    vectorIndex = new VectorIndex(path6.join(vaultDir, "vectors.db"), testEmbed.dimensions);
     logger.info("embeddings", "Vector index initialized", { dimensions: testEmbed.dimensions });
   } catch (error) {
     logger.warn("embeddings", "Vector index unavailable", { error: error.message });
   }
   const processor = new BufferProcessor(llmProvider, config.intelligence.llm.context_window);
   const vault = new VaultWriter(vaultDir);
-  const index = new MycoIndex(path7.join(vaultDir, "index.db"));
+  const index = new MycoIndex(path6.join(vaultDir, "index.db"));
   const lineageGraph = new LineageGraph(vaultDir);
   const transcriptMiner = new TranscriptMiner({
     additionalAdapters: config.capture.transcript_paths.map(
@@ -2708,17 +2392,17 @@ async function main() {
   });
   let activeStopProcessing = null;
   const indexDeps = { index, vaultDir, vectorIndex, embeddingProvider, logger };
-  const bufferDir = path7.join(vaultDir, "buffer");
+  const bufferDir = path6.join(vaultDir, "buffer");
   const sessionBuffers = /* @__PURE__ */ new Map();
   const sessionFilePaths = /* @__PURE__ */ new Map();
   const capturedArtifactPaths = /* @__PURE__ */ new Map();
-  if (fs5.existsSync(bufferDir)) {
+  if (fs4.existsSync(bufferDir)) {
     const cutoff = Date.now() - STALE_BUFFER_MAX_AGE_MS;
-    for (const file of fs5.readdirSync(bufferDir)) {
-      const filePath = path7.join(bufferDir, file);
-      const stat4 = fs5.statSync(filePath);
+    for (const file of fs4.readdirSync(bufferDir)) {
+      const filePath = path6.join(bufferDir, file);
+      const stat4 = fs4.statSync(filePath);
       if (stat4.mtimeMs < cutoff) {
-        fs5.unlinkSync(filePath);
+        fs4.unlinkSync(filePath);
         logger.debug("daemon", "Cleaned stale buffer", { file });
       }
     }
@@ -2754,10 +2438,10 @@ async function main() {
       logger.info("watcher", "Plan detected", { source: event.source, file: event.filePath });
       if (event.filePath) {
         try {
-          const content = fs5.readFileSync(event.filePath, "utf-8");
-          const relativePath = path7.relative(vaultDir, event.filePath);
-          const title = content.match(/^#\s+(.+)$/m)?.[1] ?? path7.basename(event.filePath);
-          const planId = `plan-${path7.basename(event.filePath, ".md")}`;
+          const content = fs4.readFileSync(event.filePath, "utf-8");
+          const relativePath = path6.relative(vaultDir, event.filePath);
+          const title = content.match(/^#\s+(.+)$/m)?.[1] ?? path6.basename(event.filePath);
+          const planId = `plan-${path6.basename(event.filePath, ".md")}`;
           indexAndEmbed(
             relativePath,
             planId,
@@ -2808,7 +2492,7 @@ ${content}`,
           }
           const captured = capturedArtifactPaths.get(sessionId);
           for (const c of candidates) {
-            const absPath = path7.resolve(process.cwd(), c.path);
+            const absPath = path6.resolve(process.cwd(), c.path);
             captured.add(absPath);
           }
         }).catch((err) => logger.warn("processor", "Incremental artifact capture failed", {
@@ -2847,14 +2531,14 @@ ${content}`,
     registry.unregister(session_id);
     try {
       const cutoff = Date.now() - STALE_BUFFER_MAX_AGE_MS;
-      for (const file of fs5.readdirSync(bufferDir)) {
+      for (const file of fs4.readdirSync(bufferDir)) {
         if (!file.endsWith(".jsonl")) continue;
         const bufferSessionId = file.replace(".jsonl", "");
         if (bufferSessionId === session_id) continue;
-        const filePath = path7.join(bufferDir, file);
-        const stat4 = fs5.statSync(filePath);
+        const filePath = path6.join(bufferDir, file);
+        const stat4 = fs4.statSync(filePath);
         if (stat4.mtimeMs < cutoff) {
-          fs5.unlinkSync(filePath);
+          fs4.unlinkSync(filePath);
           logger.debug("daemon", "Cleaned stale buffer", { file });
         }
       }
@@ -2949,15 +2633,15 @@ ${content}`,
     }
     const ended = (/* @__PURE__ */ new Date()).toISOString();
     let started = allTurns.length > 0 && allTurns[0].timestamp ? allTurns[0].timestamp : ended;
-    const sessionsDir = path7.join(vaultDir, "sessions");
+    const sessionsDir = path6.join(vaultDir, "sessions");
     const sessionFileName = `${sessionNoteId(sessionId)}.md`;
     let existingContent;
     const duplicatePaths = [];
     try {
-      for (const dateDir of fs5.readdirSync(sessionsDir)) {
-        const candidate = path7.join(sessionsDir, dateDir, sessionFileName);
+      for (const dateDir of fs4.readdirSync(sessionsDir)) {
+        const candidate = path6.join(sessionsDir, dateDir, sessionFileName);
         try {
-          const content = fs5.readFileSync(candidate, "utf-8");
+          const content = fs4.readFileSync(candidate, "utf-8");
           if (!existingContent || content.length > existingContent.length) {
             existingContent = content;
           }
@@ -3017,20 +2701,20 @@ ${conversationText}`;
     }
     const date = started.slice(0, 10);
     const relativePath = sessionRelativePath(sessionId, date);
-    const targetFullPath = path7.join(vaultDir, relativePath);
+    const targetFullPath = path6.join(vaultDir, relativePath);
     for (const dup of duplicatePaths) {
       if (dup !== targetFullPath) {
         try {
-          fs5.unlinkSync(dup);
+          fs4.unlinkSync(dup);
           logger.debug("lifecycle", "Removed duplicate session file", { path: dup });
         } catch {
         }
       }
     }
-    const attachmentsDir = path7.join(vaultDir, "attachments");
+    const attachmentsDir = path6.join(vaultDir, "attachments");
     const hasImages = allTurns.some((t) => t.images?.length);
     if (hasImages) {
-      fs5.mkdirSync(attachmentsDir, { recursive: true });
+      fs4.mkdirSync(attachmentsDir, { recursive: true });
     }
     const turnImageNames = /* @__PURE__ */ new Map();
     for (let i = 0; i < allTurns.length; i++) {
@@ -3041,9 +2725,9 @@ ${conversationText}`;
         const img = turn.images[j];
         const ext = extensionForMimeType(img.mediaType);
         const filename = `${bareSessionId(sessionId)}-t${i + 1}-${j + 1}.${ext}`;
-        const filePath = path7.join(attachmentsDir, filename);
-        if (!fs5.existsSync(filePath)) {
-          fs5.writeFileSync(filePath, Buffer.from(img.data, "base64"));
+        const filePath = path6.join(attachmentsDir, filename);
+        if (!fs4.existsSync(filePath)) {
+          fs4.writeFileSync(filePath, Buffer.from(img.data, "base64"));
           logger.debug("processor", "Image saved", { filename, turn: i + 1 });
         }
         names.push(filename);
@@ -3256,4 +2940,4 @@ export {
 chokidar/index.js:
   (*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) *)
 */
-//# sourceMappingURL=main-JY6O6ZVH.js.map
+//# sourceMappingURL=main-D4X6XWRT.js.map