agenr 0.6.0 → 0.6.2

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [0.6.2] - 2026-02-19
+
+### Added
+- feat(extractor): elaborative encoding pre-fetch now runs before each chunk extraction, retrieves top-related memories from the vector index, and injects up to 3 references into the extractor prompt
+- feat(cli): `--no-pre-fetch` flag added to `agenr extract`, `agenr ingest`, and `agenr watch` to opt out of prompt memory pre-fetch
+- feat(cli): `--db` flag added to `agenr extract`, `agenr ingest`, and `agenr watch` for database path overrides
+- feat(recall): exported `fetchRelatedEntries()` thin wrapper for direct ANN vector candidate queries
+
+### Changed
+- tuning(extractor): pre-fetch similarity threshold set to `0.78` for `text-embedding-3-small` (1024 dimensions)
+- tuning(extractor): fresh-install pre-fetch skip threshold set to 20 non-superseded entries
+- tuning(extractor): pre-fetch timeout set to 5000ms to avoid chunk extraction stalls on hanging embedding calls
+
+### Security
+- prompt: injected related memories are explicitly reference-only and do not lower the SKIP threshold
+- runtime: pre-fetch is always best-effort and silently degrades to empty related-memory context on any error
+
+## [0.6.1] - 2026-02-19
+
+### Fixed
+- fix(watch): context file generation failed with CLIENT_CLOSED when context path is configured
+- fix(mcp): remove agenr_done tool (was not removed in v0.6.0 as intended)
+
 ## [0.6.0] - 2026-02-18
 
 ### Added
@@ -22,7 +45,7 @@
 - fix(watch): use real recall score breakdown in generated context variants
 
 ### Removed
-- agenr_done MCP tool removed (breaking change) -- use agenr_retire instead. agenr_retire accepts an entry ID from agenr_recall output and works on all entry types, not just todos.
+- `agenr_done` MCP tool removed; use `agenr_retire` instead (supports all entry types, not just todos)
 
 ## [0.5.3] - 2026-02-18
 

package/dist/cli-main.d.ts

@@ -1,5 +1,6 @@
 import { Command } from 'commander';
 import { Model, Api, Context, SimpleStreamOptions, AssistantMessageEvent, AssistantMessage } from '@mariozechner/pi-ai';
+import { Client } from '@libsql/client';
 
 declare const KNOWLEDGE_TYPES: readonly ["fact", "decision", "preference", "todo", "relationship", "event", "lesson"];
 declare const EXPIRY_LEVELS: readonly ["core", "permanent", "temporary"];
@@ -130,8 +131,16 @@ interface LlmClient {
     credentials: ResolvedCredentials;
 }
 
+declare function readConfig(env?: NodeJS.ProcessEnv): AgenrConfig | null;
+
 declare function deduplicateEntries(entries: KnowledgeEntry[]): KnowledgeEntry[];
 
+declare function getDb(dbPath?: string): Client;
+declare function initDb(client: Client): Promise<void>;
+declare function closeDb(client: Client): void;
+
+declare function resolveEmbeddingApiKey(config: AgenrConfig | null | undefined, env?: NodeJS.ProcessEnv): string;
+
 type SimpleAssistantStream = AsyncIterable<AssistantMessageEvent> & {
     result: () => Promise<AssistantMessage>;
 };
@@ -165,6 +174,10 @@ declare function extractKnowledgeFromChunks(params: {
     streamSimpleImpl?: StreamSimpleFn;
     sleepImpl?: (ms: number) => Promise<void>;
     retryDelayMs?: (attempt: number) => number;
+    db?: Client;
+    embeddingApiKey?: string;
+    noPreFetch?: boolean;
+    embedFn?: (texts: string[], apiKey: string) => Promise<number[][]>;
 }): Promise<ExtractChunksResult>;
 
 interface ResolveLlmClientInput {
@@ -204,8 +217,10 @@ interface ExtractCommandOptions {
     split?: boolean;
     model?: string;
     provider?: string;
+    db?: string;
     verbose?: boolean;
     noDedup?: boolean;
+    noPreFetch?: boolean;
 }
 interface CliDeps {
     expandInputFilesFn: typeof expandInputFiles;
@@ -215,6 +230,11 @@ interface CliDeps {
     extractKnowledgeFromChunksFn: typeof extractKnowledgeFromChunks;
     deduplicateEntriesFn: typeof deduplicateEntries;
     writeOutputFn: typeof writeOutput;
+    readConfigFn: typeof readConfig;
+    resolveEmbeddingApiKeyFn: typeof resolveEmbeddingApiKey;
+    getDbFn: typeof getDb;
+    initDbFn: typeof initDb;
+    closeDbFn: typeof closeDb;
 }
 declare function runExtractCommand(files: string[], options: ExtractCommandOptions, deps?: Partial<CliDeps>): Promise<{
     exitCode: number;

package/dist/cli-main.js

@@ -3867,6 +3867,9 @@ async function fetchVectorCandidates(db, queryEmbedding, limit, platform, projec
     };
   });
 }
+async function fetchRelatedEntries(db, queryEmbedding, limit) {
+  return fetchVectorCandidates(db, queryEmbedding, limit);
+}
 async function fetchSessionCandidates(db, limit, context, platform, project, excludeProject, projectStrict) {
   const normalizedProject = parseProjectList(project);
   const normalizedExclude = parseProjectList(excludeProject);
@@ -9176,11 +9179,18 @@ WHY: Routine execution. No durable knowledge, decisions, or lessons.
 - canonical_key: optional lowercase hyphenated 3-5 word identifier when clear (example: "preferred-package-manager")
 - content: clear declarative statement, not a quote. Min 20 chars.
 - source_context: one sentence, max 20 words.
-- tags: 1-4 lowercase descriptive tags.`;
+- tags: 1-4 lowercase descriptive tags.
+When related memories are injected before a chunk, they are reference material only. They do not lower the emission threshold.`;
 var MAX_ATTEMPTS = 5;
 var DEFAULT_INTER_CHUNK_DELAY_MS = 150;
 var DEDUP_BATCH_SIZE = 50;
 var DEDUP_BATCH_TRIGGER = 100;
+var PREFETCH_SIMILARITY_THRESHOLD = 0.78;
+var PREFETCH_SIMILARITY_EPSILON = 1e-6;
+var PREFETCH_CANDIDATE_LIMIT = 10;
+var MAX_PREFETCH_RESULTS = 3;
+var PREFETCH_MIN_DB_ENTRIES = 20;
+var PREFETCH_TIMEOUT_MS = 5e3;
 var DEDUP_SYSTEM_PROMPT = `You are deduplicating a list of extracted knowledge entries.
 
 Rules:
@@ -9244,8 +9254,77 @@ var ParseResponseError = class extends Error {
 function normalize3(value) {
   return value.trim().toLowerCase();
 }
-function buildUserPrompt(chunk) {
+async function preFetchRelated(chunkText2, db, embeddingApiKey, embedFn = embed, onVerbose) {
+  const run = async () => {
+    try {
+      if (!chunkText2.trim()) {
+        onVerbose?.("[pre-fetch] skipped (empty chunk text)");
+        return [];
+      }
+      const countResult = await db.execute({
+        sql: "SELECT COUNT(*) AS count FROM entries WHERE superseded_by IS NULL",
+        args: []
+      });
+      const count = Number(countResult.rows[0]?.count ?? 0);
+      if (count < PREFETCH_MIN_DB_ENTRIES) {
+        onVerbose?.(`[pre-fetch] skipped (db count ${count} < ${PREFETCH_MIN_DB_ENTRIES})`);
+        return [];
+      }
+      const vectors = await embedFn([chunkText2], embeddingApiKey);
+      const queryVec = vectors[0];
+      if (!queryVec || !Array.isArray(queryVec)) {
+        onVerbose?.("[pre-fetch] skipped: embedding provider returned no query vector");
+        return [];
+      }
+      onVerbose?.(`[pre-fetch] embedded chunk (${queryVec.length} dims)`);
+      const candidates = await fetchRelatedEntries(db, queryVec, PREFETCH_CANDIDATE_LIMIT);
+      onVerbose?.(`[pre-fetch] ${candidates.length} candidates returned`);
+      const above = candidates.filter(
+        (candidate) => candidate.vectorSim + PREFETCH_SIMILARITY_EPSILON >= PREFETCH_SIMILARITY_THRESHOLD
+      );
+      onVerbose?.(`[pre-fetch] ${above.length} above threshold ${PREFETCH_SIMILARITY_THRESHOLD}`);
+      return above.slice(0, MAX_PREFETCH_RESULTS).map((candidate) => candidate.entry);
+    } catch (error) {
+      onVerbose?.(`[pre-fetch] skipped: ${error instanceof Error ? error.message : String(error)}`);
+      return [];
+    }
+  };
+  let timeoutId;
+  const timeout = new Promise((resolve) => {
+    timeoutId = setTimeout(() => {
+      onVerbose?.(`[pre-fetch] skipped: timeout after ${PREFETCH_TIMEOUT_MS}ms`);
+      resolve([]);
+    }, PREFETCH_TIMEOUT_MS);
+  });
+  const result = await Promise.race([run(), timeout]);
+  if (timeoutId) {
+    clearTimeout(timeoutId);
+  }
+  return result;
+}
+function buildUserPrompt(chunk, related) {
+  if (related === void 0) {
+    return [
+      "Selectively extract durable knowledge from this conversation transcript.",
+      "",
+      "Transcript:",
+      "---",
+      chunk.text,
+      "---",
+      "",
+      'Call submit_knowledge once with {"entries": [...]} and use an empty array if nothing qualifies.'
+    ].join("\n");
+  }
+  const memoryBlock = related.length === 0 ? "[none found]" : related.map((entry) => `- [${entry.type}] ${entry.subject}: ${entry.content}`).join("\n");
   return [
+    "Existing related memories (reference only -- your SKIP/emit threshold is unchanged):",
+    memoryBlock,
+    "",
+    "Do not emit entries that express the same fact as any memory listed above, even in different words.",
+    "If this chunk clearly contradicts a memory listed above, emit a fact entry stating the contradiction directly in the content field. Do not use inline citation markers like [1] or [2] in any field -- these become dead references.",
+    "Only emit a cross-reference entry when this chunk extends, contradicts, or updates a specific fact. Do not cross-reference just because entries share the same project or general domain.",
+    "Your SKIP/emit threshold is unchanged. The memories above are reference only.",
+    "",
     "Selectively extract durable knowledge from this conversation transcript.",
     "",
     "Transcript:",
@@ -9826,12 +9905,13 @@ async function sleepMs2(ms) {
   await new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function extractChunkOnce(params) {
+  const prompt = buildUserPrompt(params.chunk, params.related);
   const context = {
     systemPrompt: SYSTEM_PROMPT,
     messages: [
       {
         role: "user",
-        content: buildUserPrompt(params.chunk),
+        content: prompt,
         timestamp: Date.now()
       }
     ],
@@ -9902,6 +9982,13 @@ async function extractKnowledgeFromChunks(params) {
         let lastError = null;
         let chunkResult = null;
         let streamBuffer = [];
+        const related = params.noPreFetch === true ? void 0 : params.db && params.embeddingApiKey ? await preFetchRelated(
+          chunk.text,
+          params.db,
+          params.embeddingApiKey,
+          params.embedFn,
+          params.verbose ? params.onVerbose : void 0
+        ) : void 0;
         for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt += 1) {
           if (params.verbose) {
             params.onVerbose?.(
@@ -9922,7 +10009,8 @@ async function extractKnowledgeFromChunks(params) {
               onStreamDelta: bufferStreamDeltas ? (delta, kind) => {
                 streamBuffer.push({ delta, kind });
               } : params.onStreamDelta,
-              streamSimpleImpl: params.streamSimpleImpl
+              streamSimpleImpl: params.streamSimpleImpl,
+              related
             });
             warnings.push(...chunkResult.warnings);
             successfulChunks += 1;
@@ -12430,6 +12518,21 @@ async function runIngestCommand(inputPaths, options, deps) {
   let forceDeletedEntrySourceRows = 0;
   let completed = 0;
   let embeddingApiKey = null;
+  if (!options.noPreFetch) {
+    try {
+      embeddingApiKey = resolvedDeps.resolveEmbeddingApiKeyFn(config, process.env);
+    } catch (error) {
+      embeddingApiKey = null;
+      if (verbose) {
+        clack4.log.warn(
+          formatWarn(
+            `Pre-fetch disabled - embedding API key not available: ${error instanceof Error ? error.message : String(error)}`
+          ),
+          clackOutput
+        );
+      }
+    }
+  }
   let watchStateLoaded = false;
   let watchState = createEmptyWatchState();
   let cursor = 0;
@@ -12604,6 +12707,9 @@ async function runIngestCommand(inputPaths, options, deps) {
         client,
         verbose: false,
         llmConcurrency,
+        db: options.noPreFetch ? void 0 : db,
+        embeddingApiKey: options.noPreFetch ? void 0 : embeddingApiKey ?? void 0,
+        noPreFetch: options.noPreFetch === true,
         onVerbose: verbose ? (line) => {
           clack4.log.info(line, clackOutput);
         } : void 0,
@@ -13202,26 +13308,6 @@ var TOOL_DEFINITIONS = [
       }
     }
   },
-  {
-    name: "agenr_done",
-    description: "Mark a todo as completed and remove it from active recall. Use when you have resolved a task or confirmed something is no longer needed. Fuzzy-matches by subject.",
-    inputSchema: {
-      type: "object",
-      additionalProperties: false,
-      required: ["subject"],
-      properties: {
-        subject: {
-          type: "string",
-          description: "The subject of the todo to mark as done. Partial/fuzzy match is supported."
-        },
-        confirm: {
-          type: "boolean",
-          description: "If true, skip confirmation prompt and mark done immediately. Default false.",
-          default: false
-        }
-      }
-    }
-  },
   {
     name: "agenr_extract",
     description: "Extract knowledge entries from raw text.",
@@ -13562,30 +13648,6 @@ function formatExtractedText(entries, stored) {
   }
   return lines.join("\n");
 }
-function toActiveTodoRows(rows) {
-  return rows.map((row) => ({
-    id: typeof row.id === "string" ? row.id : String(row.id ?? ""),
-    subject: typeof row.subject === "string" ? row.subject : String(row.subject ?? ""),
-    content: typeof row.content === "string" ? row.content : String(row.content ?? "")
-  }));
-}
-function findTodoMatches(rows, subject) {
-  const normalizedSubject = subject.trim().toLowerCase();
-  return rows.filter((row) => {
-    const normalizedRow = row.subject.toLowerCase();
-    return normalizedRow.includes(normalizedSubject) || normalizedSubject.includes(normalizedRow);
-  });
-}
-function formatDoneCandidates(subject, candidates) {
-  const lines = [`Multiple active todos match "${subject}":`, ""];
-  for (let i = 0; i < candidates.length; i += 1) {
-    const candidate = candidates[i];
-    lines.push(`${i + 1}. ${candidate.subject}`);
-  }
-  lines.push("");
-  lines.push("Re-run with confirm=true to mark the top match.");
-  return lines.join("\n");
-}
 function extractIdForError(raw) {
   if (!isRecord(raw) || !hasOwn(raw, "id")) {
     return null;
@@ -13782,47 +13844,6 @@ function createMcpServer(options = {}, deps = {}) {
     });
     return formatStoreSummary(result);
   }
-  async function callDoneTool(args) {
-    const subject = typeof args.subject === "string" ? args.subject.trim() : "";
-    if (!subject) {
-      throw new RpcError(JSON_RPC_INVALID_PARAMS, "subject is required");
-    }
-    if (args.confirm !== void 0 && typeof args.confirm !== "boolean") {
-      throw new RpcError(JSON_RPC_INVALID_PARAMS, "confirm must be a boolean");
-    }
-    const confirm5 = args.confirm === true;
-    const db = await ensureDb();
-    const result = await db.execute({
-      sql: `
-        SELECT id, subject, content
-        FROM entries
-        WHERE type = 'todo' AND superseded_by IS NULL
-        ORDER BY importance DESC, created_at DESC, subject ASC
-      `,
-      args: []
-    });
-    const todos = toActiveTodoRows(result.rows);
-    const matches = findTodoMatches(todos, subject);
-    if (matches.length === 0) {
-      return {
-        content: [{ type: "text", text: `No active todo matching: ${subject}` }],
-        isError: true
-      };
-    }
-    if (matches.length > 1 && !confirm5) {
-      return {
-        content: [{ type: "text", text: formatDoneCandidates(subject, matches.slice(0, 5)) }]
-      };
-    }
-    const selected = matches[0];
-    await db.execute({
-      sql: "UPDATE entries SET superseded_by = id, updated_at = datetime('now') WHERE id = ?",
-      args: [selected.id]
-    });
-    return {
-      content: [{ type: "text", text: `Marked done: ${selected.subject}` }]
-    };
-  }
   async function callExtractTool(args) {
     const text2 = typeof args.text === "string" ? args.text : "";
     if (!text2.trim()) {
@@ -13930,9 +13951,6 @@ function createMcpServer(options = {}, deps = {}) {
           content: [{ type: "text", text: await callStoreTool(params.args) }]
         };
       }
-      if (params.name === "agenr_done") {
-        return callDoneTool(params.args);
-      }
       if (params.name === "agenr_extract") {
         return {
           content: [{ type: "text", text: await callExtractTool(params.args) }]
@@ -15149,6 +15167,16 @@ async function runWatcher(options, deps) {
   if (db) {
     await resolvedDeps.initDbFn(db);
   }
+  if (!options.noPreFetch) {
+    try {
+      embeddingApiKey = resolvedDeps.resolveEmbeddingApiKeyFn(config, process.env);
+    } catch (error) {
+      embeddingApiKey = null;
+      options.onWarn?.(
+        `Pre-fetch disabled - embedding API key not available: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
   let dbChain = Promise.resolve();
   const withDbLock = async (fn) => {
     const previous = dbChain;
@@ -15378,6 +15406,9 @@ async function runWatcher(options, deps) {
           chunks: parsed.chunks,
           client,
           verbose: options.verbose,
+          db: options.noPreFetch ? void 0 : db ?? void 0,
+          embeddingApiKey: options.noPreFetch ? void 0 : embeddingApiKey ?? void 0,
+          noPreFetch: options.noPreFetch === true,
           onChunkComplete: async (chunkResult) => {
             await processChunkEntries(chunkResult.entries);
           }
@@ -15836,6 +15867,7 @@ async function runWatchCommand(file, options, deps) {
   const once2 = options.once === true;
   const json = options.json === true;
   const raw = options.raw === true;
+  const contextEnabled = Boolean(options.context);
   const modeConfig = await resolveWatchMode(file, options, resolvedDeps.statFileFn);
   const clackOutput = { output: process.stderr };
   clack10.intro(banner(), clackOutput);
@@ -15876,8 +15908,16 @@ async function runWatchCommand(file, options, deps) {
   );
   clack10.log.info("", clackOutput);
   clack10.log.info("Waiting for changes...", clackOutput);
+  const emitWatchWarning = (message) => {
+    if (message.startsWith("Filtered:")) {
+      clack10.log.info(message, clackOutput);
+      return;
+    }
+    clack10.log.warn(formatWarn(message), clackOutput);
+  };
   let cycleCount = 0;
   let contextChain = Promise.resolve();
+  let contextDb = null;
   const summary = await runWatcher(
     {
       filePath: modeConfig.filePath ?? void 0,
@@ -15892,17 +15932,12 @@ async function runWatchCommand(file, options, deps) {
       raw,
       once: once2,
       onlineDedup: options.onlineDedup !== false,
+      noPreFetch: options.noPreFetch === true,
       model: options.model,
       provider: options.provider,
       dbPath: options.db,
       initialState: state,
-      onWarn: (message) => {
-        if (message.startsWith("Filtered:")) {
-          clack10.log.info(message, clackOutput);
-          return;
-        }
-        clack10.log.warn(formatWarn(message), clackOutput);
-      },
+      onWarn: emitWatchWarning,
       onSwitch: (from, to, platform) => {
         const fromLabel = from ? formatSwitchLabel(from) : "(none)";
         const platformLabel = platform ? ` [${platform}]` : "";
@@ -15944,6 +15979,7 @@ async function runWatchCommand(file, options, deps) {
           clackOutput
         );
         if (!dryRun && options.context && result.entriesStored > 0 && ctx.db) {
+          contextDb = ctx.db;
           const contextPath = path29.resolve(options.context.replace(/^~(?=$|\/)/, os19.homedir()));
           contextChain = contextChain.then(async () => {
             await resolvedDeps.generateContextFileFn(
@@ -15954,12 +15990,8 @@ async function runWatchCommand(file, options, deps) {
             );
             await writeContextVariants(ctx.db, contextPath, resolvedDeps.nowFn());
           }).catch((err) => {
-            if (verbose) {
-              clack10.log.warn(
-                `Context refresh failed: ${err instanceof Error ? err.message : String(err)}`,
-                clackOutput
-              );
-            }
+            const msg = `Context refresh failed: ${err instanceof Error ? err.message : String(err)}`;
+            emitWatchWarning(msg);
           });
         }
       }
@@ -15973,7 +16005,8 @@ async function runWatchCommand(file, options, deps) {
       deduplicateEntriesFn: resolvedDeps.deduplicateEntriesFn,
       getDbFn: resolvedDeps.getDbFn,
       initDbFn: resolvedDeps.initDbFn,
-      closeDbFn: resolvedDeps.closeDbFn,
+      closeDbFn: contextEnabled ? () => {
+      } : resolvedDeps.closeDbFn,
       storeEntriesFn: resolvedDeps.storeEntriesFn,
       loadWatchStateFn: resolvedDeps.loadWatchStateFn,
       saveWatchStateFn: resolvedDeps.saveWatchStateFn,
@@ -15984,6 +16017,12 @@ async function runWatchCommand(file, options, deps) {
     }
   );
   await contextChain.catch(() => void 0);
+  if (contextEnabled && contextDb) {
+    try {
+      resolvedDeps.closeDbFn(contextDb);
+    } catch {
+    }
+  }
   clack10.log.info(
     `Summary: ${summary.cycles} cycles | ${summary.entriesStored} entries stored | watched for ${formatDuration(summary.durationMs)}`,
     clackOutput
@@ -16334,6 +16373,10 @@ async function runSetup(env = process.env) {
 }
 
 // src/cli-main.ts
+function stderrLine2(message) {
+  process.stderr.write(`${message}
+`);
+}
 async function assertReadableFile(filePath) {
   const stat = await fs32.stat(filePath);
   if (!stat.isFile()) {
@@ -16376,7 +16419,12 @@ async function runExtractCommand(files, options, deps) {
     createLlmClientFn: deps?.createLlmClientFn ?? createLlmClient,
     extractKnowledgeFromChunksFn: deps?.extractKnowledgeFromChunksFn ?? extractKnowledgeFromChunks,
     deduplicateEntriesFn: deps?.deduplicateEntriesFn ?? deduplicateEntries,
-    writeOutputFn: deps?.writeOutputFn ?? writeOutput
+    writeOutputFn: deps?.writeOutputFn ?? writeOutput,
+    readConfigFn: deps?.readConfigFn ?? readConfig,
+    resolveEmbeddingApiKeyFn: deps?.resolveEmbeddingApiKeyFn ?? resolveEmbeddingApiKey,
+    getDbFn: deps?.getDbFn ?? getDb,
+    initDbFn: deps?.initDbFn ?? initDb,
+    closeDbFn: deps?.closeDbFn ?? closeDb
   };
   const expanded = await resolvedDeps.expandInputFilesFn(files);
   if (expanded.length === 0) {
@@ -16390,6 +16438,30 @@ async function runExtractCommand(files, options, deps) {
     model: options.model,
     env: process.env
   });
+  let db;
+  let embeddingApiKey;
+  if (!options.noPreFetch) {
+    const config = resolvedDeps.readConfigFn(process.env);
+    const dbPath = options.db?.trim() || config?.db?.path?.trim();
+    if (dbPath) {
+      let preFetchDb;
+      try {
+        embeddingApiKey = resolvedDeps.resolveEmbeddingApiKeyFn(config, process.env);
+        preFetchDb = resolvedDeps.getDbFn(dbPath);
+        await resolvedDeps.initDbFn(preFetchDb);
+        db = preFetchDb;
+      } catch (error) {
+        if (preFetchDb) {
+          resolvedDeps.closeDbFn(preFetchDb);
+        }
+        db = void 0;
+        embeddingApiKey = void 0;
+        if (verbose) {
+          stderrLine2(`[pre-fetch] init skipped: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+    }
+  }
   const clackOutput = { output: process.stderr };
   clack12.intro(banner(), clackOutput);
   clack12.log.info(
@@ -16436,114 +16508,129 @@ async function runExtractCommand(files, options, deps) {
     summaryWarnings += 1;
     return warning;
   };
-  if (verbose) {
-    for (const [index, file] of expanded.entries()) {
-      const key = toReportKey(file, keySet);
-      clack12.log.info(`${ui.dim(`[${index + 1}/${expanded.length}]`)} ${path31.basename(file)}`, clackOutput);
-      try {
-        const parsed = await resolvedDeps.parseTranscriptFileFn(file);
-        clack12.log.info(
-          `[parse] ${key}: messages=${parsed.messages.length}, chunks=${parsed.chunks.length}`,
-          clackOutput
-        );
-        const extracted = await resolvedDeps.extractKnowledgeFromChunksFn({
-          file: key,
-          chunks: parsed.chunks,
-          client,
-          verbose: true,
-          noDedup: options.noDedup === true,
-          onVerbose: (line) => clack12.log.info(line, clackOutput),
-          onStreamDelta: (delta) => process.stderr.write(delta)
-        });
-        process.stderr.write("\n");
-        const stats = recordSuccess({
-          key,
-          chunks: parsed.chunks.length,
-          extracted,
-          parseWarnings: parsed.warnings
-        });
-        clack12.log.info(ui.success(`${stats.deduped_entries} entries (${stats.chunks} chunks)`), clackOutput);
-      } catch (error) {
-        const warning = recordFailure(key, error);
-        clack12.log.error(warning, clackOutput);
+  try {
+    if (verbose) {
+      for (const [index, file] of expanded.entries()) {
+        const key = toReportKey(file, keySet);
+        clack12.log.info(`${ui.dim(`[${index + 1}/${expanded.length}]`)} ${path31.basename(file)}`, clackOutput);
+        try {
+          const parsed = await resolvedDeps.parseTranscriptFileFn(file);
+          clack12.log.info(
+            `[parse] ${key}: messages=${parsed.messages.length}, chunks=${parsed.chunks.length}`,
+            clackOutput
+          );
+          const extracted = await resolvedDeps.extractKnowledgeFromChunksFn({
+            file: key,
+            chunks: parsed.chunks,
+            client,
+            verbose: true,
+            noDedup: options.noDedup === true,
+            db,
+            embeddingApiKey,
+            noPreFetch: options.noPreFetch === true,
+            onVerbose: (line) => clack12.log.info(line, clackOutput),
+            onStreamDelta: (delta) => process.stderr.write(delta)
+          });
+          process.stderr.write("\n");
+          const stats = recordSuccess({
+            key,
+            chunks: parsed.chunks.length,
+            extracted,
+            parseWarnings: parsed.warnings
+          });
+          clack12.log.info(ui.success(`${stats.deduped_entries} entries (${stats.chunks} chunks)`), clackOutput);
+        } catch (error) {
+          const warning = recordFailure(key, error);
+          clack12.log.error(warning, clackOutput);
+        }
       }
-    }
-  } else {
-    await clack12.tasks(
-      expanded.map((file, index) => ({
-        title: `${ui.dim(`[${index + 1}/${expanded.length}]`)} ${path31.basename(file)}`,
-        task: async () => {
-          const key = toReportKey(file, keySet);
-          try {
-            const parsed = await resolvedDeps.parseTranscriptFileFn(file);
-            const extracted = await resolvedDeps.extractKnowledgeFromChunksFn({
-              file: key,
-              chunks: parsed.chunks,
-              client,
-              verbose: false,
-              noDedup: options.noDedup === true
-            });
-            const stats = recordSuccess({
-              key,
-              chunks: parsed.chunks.length,
-              extracted,
-              parseWarnings: parsed.warnings
-            });
-            return `${stats.deduped_entries} entries (${stats.chunks} chunks)`;
-          } catch (error) {
-            recordFailure(key, error);
-            return formatError("processing failed");
+    } else {
+      await clack12.tasks(
+        expanded.map((file, index) => ({
+          title: `${ui.dim(`[${index + 1}/${expanded.length}]`)} ${path31.basename(file)}`,
+          task: async () => {
+            const key = toReportKey(file, keySet);
+            try {
+              const parsed = await resolvedDeps.parseTranscriptFileFn(file);
+              const extracted = await resolvedDeps.extractKnowledgeFromChunksFn({
+                file: key,
+                chunks: parsed.chunks,
+                client,
+                verbose: false,
+                noDedup: options.noDedup === true,
+                db,
+                embeddingApiKey,
+                noPreFetch: options.noPreFetch === true
+              });
+              const stats = recordSuccess({
+                key,
+                chunks: parsed.chunks.length,
+                extracted,
+                parseWarnings: parsed.warnings
+              });
+              return `${stats.deduped_entries} entries (${stats.chunks} chunks)`;
+            } catch (error) {
+              recordFailure(key, error);
+              return formatError("processing failed");
+            }
           }
-        }
-      })),
+        })),
+        clackOutput
+      );
+    }
+    const report = {
+      version: APP_VERSION,
+      extracted_at: (/* @__PURE__ */ new Date()).toISOString(),
+      provider: client.resolvedModel.provider,
+      model: client.resolvedModel.modelId,
+      files: fileMap,
+      summary: {
+        files: Object.keys(fileMap).length,
+        chunks: summaryChunks,
+        successful_chunks: summarySuccessChunks,
+        failed_chunks: summaryFailedChunks,
+        raw_entries: summaryRawEntries,
+        deduped_entries: summaryDedupedEntries,
+        warnings: summaryWarnings
+      }
+    };
+    const writtenPaths = await resolvedDeps.writeOutputFn({
+      report,
+      format: options.format,
+      output: options.output,
+      split: options.split === true
+    });
+    clack12.note(
+      [
+        formatLabel("Files", String(report.summary.files)),
+        formatLabel("Chunks", `${report.summary.successful_chunks}/${report.summary.chunks} successful`),
+        formatLabel(
+          "Entries",
+          `${report.summary.deduped_entries} entries (${report.summary.raw_entries - report.summary.deduped_entries} duplicates removed)`
+        ),
+        report.summary.failed_chunks > 0 ? formatWarn(`${report.summary.failed_chunks} chunks failed`) : null,
+        report.summary.warnings > 0 ? formatWarn(`${report.summary.warnings} warning(s)`) : null
+      ].filter((line) => Boolean(line)).join("\n"),
+      "Extraction Complete",
       clackOutput
     );
-  }
-  const report = {
-    version: APP_VERSION,
-    extracted_at: (/* @__PURE__ */ new Date()).toISOString(),
-    provider: client.resolvedModel.provider,
-    model: client.resolvedModel.modelId,
-    files: fileMap,
-    summary: {
-      files: Object.keys(fileMap).length,
-      chunks: summaryChunks,
-      successful_chunks: summarySuccessChunks,
-      failed_chunks: summaryFailedChunks,
-      raw_entries: summaryRawEntries,
-      deduped_entries: summaryDedupedEntries,
-      warnings: summaryWarnings
+    for (const outPath of writtenPaths) {
+      clack12.log.success("Wrote " + ui.bold(outPath), clackOutput);
+    }
+    clack12.outro(void 0, clackOutput);
+    return {
+      exitCode: report.summary.successful_chunks > 0 ? 0 : 1,
+      report,
+      writtenPaths
+    };
+  } finally {
+    if (db) {
+      try {
+        resolvedDeps.closeDbFn(db);
+      } catch {
+      }
     }
-  };
-  const writtenPaths = await resolvedDeps.writeOutputFn({
-    report,
-    format: options.format,
-    output: options.output,
-    split: options.split === true
-  });
-  clack12.note(
-    [
-      formatLabel("Files", String(report.summary.files)),
-      formatLabel("Chunks", `${report.summary.successful_chunks}/${report.summary.chunks} successful`),
-      formatLabel(
-        "Entries",
-        `${report.summary.deduped_entries} entries (${report.summary.raw_entries - report.summary.deduped_entries} duplicates removed)`
-      ),
-      report.summary.failed_chunks > 0 ? formatWarn(`${report.summary.failed_chunks} chunks failed`) : null,
-      report.summary.warnings > 0 ? formatWarn(`${report.summary.warnings} warning(s)`) : null
-    ].filter((line) => Boolean(line)).join("\n"),
-    "Extraction Complete",
-    clackOutput
-  );
-  for (const outPath of writtenPaths) {
-    clack12.log.success("Wrote " + ui.bold(outPath), clackOutput);
   }
-  clack12.outro(void 0, clackOutput);
-  return {
-    exitCode: report.summary.successful_chunks > 0 ? 0 : 1,
-    report,
-    writtenPaths
-  };
 }
 function createProgram() {
   const program = new Command();
@@ -16575,15 +16662,17 @@ function createProgram() {
     program.outputHelp();
     clack12.outro(ui.dim("https://agenr.ai"));
   });
-  program.command("extract").description("Extract structured knowledge from conversation transcripts").argument("<files...>", "One or more transcript files (.jsonl, .md, .txt)").option("--json", "Output raw KnowledgeEntry[] JSON", false).option("--format <type>", "Output format: json, markdown", "markdown").option("--output <file>", "Write output to file (or directory with --split)").option("--split", "Write one output file per input transcript", false).option("--model <model>", "LLM model to use").option("--provider <name>", "LLM provider: anthropic, openai, openai-codex").option("--no-dedup", "Skip post-extraction LLM dedup pass", false).option("--verbose", "Show extraction progress and debug info", false).action(async (files, opts) => {
+  program.command("extract").description("Extract structured knowledge from conversation transcripts").argument("<files...>", "One or more transcript files (.jsonl, .md, .txt)").option("--json", "Output raw KnowledgeEntry[] JSON", false).option("--format <type>", "Output format: json, markdown", "markdown").option("--output <file>", "Write output to file (or directory with --split)").option("--split", "Write one output file per input transcript", false).option("--db <path>", "Database path override").option("--model <model>", "LLM model to use").option("--provider <name>", "LLM provider: anthropic, openai, openai-codex").option("--no-dedup", "Skip post-extraction LLM dedup pass", false).option("--no-pre-fetch", "Disable elaborative encoding pre-fetch").option("--verbose", "Show extraction progress and debug info", false).action(async (files, opts) => {
     const selectedFormat = opts.json ? "json" : opts.format;
     const format = selectedFormat === "json" ? "json" : selectedFormat === "markdown" ? "markdown" : null;
     if (!format) {
       throw new Error("--format must be one of: json, markdown");
     }
+    const noPreFetch = opts.noPreFetch === true;
     const result = await runExtractCommand(files, {
       ...opts,
-      format
+      format,
+      noPreFetch
     });
     process.exitCode = result.exitCode;
   });
@@ -16655,16 +16744,22 @@ function createProgram() {
       process.exitCode = result.exitCode;
     }
   );
-  program.command("watch").description("Watch a transcript file and auto-extract knowledge as it grows").argument("[file]", "Transcript file to watch (.jsonl, .md, .txt)").option("--dir <path>", "Sessions directory to watch (resolver picks active file)").option("--platform <name>", "Session platform: openclaw, claude-code, codex, mtime").option("--auto", "Deprecated: use --platform <name> instead", false).option("--interval <seconds>", "Polling interval in seconds", parseIntOption, 300).option("--min-chunk <chars>", "Minimum new chars before extraction", parseIntOption, 2e3).option("--context <path>", "Regenerate context file after each cycle").option("--db <path>", "Database path override").option("--model <model>", "LLM model to use").option("--provider <name>", "LLM provider: anthropic, openai, openai-codex").option("--raw", "Bypass adapter filtering (pass transcripts through unmodified)", false).option("--verbose", "Show extraction progress", false).option("--dry-run", "Extract without storing", false).option("--once", "Run one cycle and exit", false).option("--json", "Output JSON results", false).action(async (file, opts) => {
-    const result = await runWatchCommand(file, opts);
+  program.command("watch").description("Watch a transcript file and auto-extract knowledge as it grows").argument("[file]", "Transcript file to watch (.jsonl, .md, .txt)").option("--dir <path>", "Sessions directory to watch (resolver picks active file)").option("--platform <name>", "Session platform: openclaw, claude-code, codex, mtime").option("--auto", "Deprecated: use --platform <name> instead", false).option("--interval <seconds>", "Polling interval in seconds", parseIntOption, 300).option("--min-chunk <chars>", "Minimum new chars before extraction", parseIntOption, 2e3).option("--context <path>", "Regenerate context file after each cycle").option("--db <path>", "Database path override").option("--model <model>", "LLM model to use").option("--provider <name>", "LLM provider: anthropic, openai, openai-codex").option("--raw", "Bypass adapter filtering (pass transcripts through unmodified)", false).option("--no-pre-fetch", "Disable elaborative encoding pre-fetch").option("--verbose", "Show extraction progress", false).option("--dry-run", "Extract without storing", false).option("--once", "Run one cycle and exit", false).option("--json", "Output JSON results", false).action(async (file, opts) => {
+    const result = await runWatchCommand(file, {
+      ...opts,
+      noPreFetch: opts.noPreFetch === true
+    });
     process.exitCode = result.exitCode;
   });
   program.command("todo <subcommand> <subject>").description("Manage todos in the knowledge base").option("--db <path>", "Database path override").action(async (subcommand, subject, opts) => {
     const result = await runTodoCommand(subcommand, subject, { db: opts.db });
     process.exitCode = result.exitCode;
   });
-  program.command("ingest").description("Bulk-ingest knowledge from files and directories").argument("<paths...>", "Files or directories to process").option("--glob <pattern>", "File filter glob", "**/*.{jsonl,md,txt}").option("--db <path>", "Database path override").option("--model <model>", "LLM model to use").option("--provider <name>", "LLM provider: anthropic, openai, openai-codex").option("--platform <name>", "Platform tag: openclaw, claude-code, codex").option("--project <name>", "Project tag (lowercase).", (val, prev) => [...prev, val], []).option("--verbose", "Show per-file details", false).option("--raw", "Bypass adapter filtering (pass transcripts through unmodified)", false).option("--dry-run", "Extract without storing", false).option("--json", "Output JSON results", false).option("--concurrency <n>", "Parallel chunk extractions", parseIntOption, 5).option("--skip-ingested", "Skip already-ingested files", true).option("--no-retry", "Disable auto-retry for failed files").option("--max-retries <n>", "Maximum auto-retry attempts", parseIntOption, 3).option("--force", "Clean re-ingest: delete previous rows for each file before processing", false).action(async (paths, opts) => {
-    const result = await runIngestCommand(paths, opts);
+  program.command("ingest").description("Bulk-ingest knowledge from files and directories").argument("<paths...>", "Files or directories to process").option("--glob <pattern>", "File filter glob", "**/*.{jsonl,md,txt}").option("--db <path>", "Database path override").option("--model <model>", "LLM model to use").option("--provider <name>", "LLM provider: anthropic, openai, openai-codex").option("--platform <name>", "Platform tag: openclaw, claude-code, codex").option("--project <name>", "Project tag (lowercase).", (val, prev) => [...prev, val], []).option("--verbose", "Show per-file details", false).option("--raw", "Bypass adapter filtering (pass transcripts through unmodified)", false).option("--dry-run", "Extract without storing", false).option("--json", "Output JSON results", false).option("--concurrency <n>", "Parallel chunk extractions", parseIntOption, 5).option("--skip-ingested", "Skip already-ingested files", true).option("--no-retry", "Disable auto-retry for failed files").option("--no-pre-fetch", "Disable elaborative encoding pre-fetch").option("--max-retries <n>", "Maximum auto-retry attempts", parseIntOption, 3).option("--force", "Clean re-ingest: delete previous rows for each file before processing", false).action(async (paths, opts) => {
+    const result = await runIngestCommand(paths, {
+      ...opts,
+      noPreFetch: opts.noPreFetch === true
+    });
     process.exitCode = result.exitCode;
   });
   program.command("consolidate").description("Consolidate and clean up the knowledge database").option("--rules-only", "Only run rule-based cleanup (no LLM)", false).option("--dry-run", "Show what would happen without making changes", false).option("--forget", "Delete forgetting candidates after consolidation", false).option("--report", "Print pre-run stats report (with --dry-run: report only)", false).option("--platform <name>", "Scope consolidation to platform: openclaw, claude-code, codex").option("--project <name>", "Scope consolidation to project (repeatable)", (val, prev) => [...prev, val], []).option("--exclude-project <name>", "Exclude entries from project (repeatable)", (val, prev) => [...prev, val], []).option(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agenr",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "AGENt memoRy -- Memory infrastructure for AI agents",
   "type": "module",
   "bin": {