@hanhnd/agent-kit 1.0.34 → 1.0.36

package/dist/cli.js

@@ -1,18 +1,11 @@
 #!/usr/bin/env node
-import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __commonJS = (cb, mod) => function __require2() {
+var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __copyProps = (to, from, except, desc) => {
@@ -14926,8 +14919,8 @@ import * as path9 from "node:path";
 
 // src/services/digest/constants.ts
 import * as path from "node:path";
-var DEFAULT_DIGEST_MODEL_ID = "default" /* DEFAULT */;
-var DEFAULT_DIGEST_MAX_INPUT_CHARS = 3e3;
+var DEFAULT_DIGEST_MODEL_ID = "base" /* BASE */;
+var DEFAULT_DIGEST_MAX_INPUT_CHARS = 1e4;
 var DEFAULT_DIGEST_TIMEOUT_MS = 12e4;
 var DIGEST_TIMEOUT_GRACE_MS = 5e3;
 var DIGEST_WORKER_FLAG = "__agent-kit-digest-worker";
@@ -14940,7 +14933,7 @@ var DIGEST_WORKER_DIR = path.join(WIKI_DIR, "digest");
 var DIGEST_LOCKFILE_REL_PATH = path.join(DIGEST_WORKER_DIR, "digest-worker.lock");
 var DIGEST_WORKER_STATUS_REL_PATH = path.join(DIGEST_WORKER_DIR, "digest-worker.status.json");
 var DIGEST_WORKER_LOG_REL_PATH = path.join(DIGEST_WORKER_DIR, "digest-worker.log");
-var LLAMA_CONTEXT_SIZE = 4096;
+var LLAMA_CONTEXT_SIZE = 8192;
 var LLAMA_MAX_GENERATED_TOKENS = 512;
 var LLAMA_TEMPERATURE = 0.1;
 
@@ -15022,6 +15015,7 @@ function sha256Hex(content) {
 
 // src/core/config/index.ts
 import * as fs2 from "fs";
+import * as os from "os";
 import * as path3 from "path";
 
 // src/services/memory/constants.ts
@@ -15031,7 +15025,7 @@ var DEFAULT_MEMORY_CONFIG = {
   topK: 5,
   chunkSize: 1500,
   overlapLines: 2,
-  embeddingModel: "small" /* SMALL */,
+  embeddingModel: "base" /* BASE */,
   vectorDimension: 384
 };
 var LOCK_RETRY_MS = 50;
@@ -15048,21 +15042,23 @@ function resolveMemoryConfig(settings, workspaceRoot) {
     wikiDir: typeof override.wikiDir === "string" && override.wikiDir.length > 0 ? override.wikiDir : path3.join(workspaceRoot, ".agent-kit", "wiki")
   };
 }
-function loadProjectSettings(projectDir) {
-  const settingsPath = path3.join(projectDir, ".agent-kit", "settings.json");
-  if (fs2.existsSync(settingsPath)) {
+function getGlobalSettingsFile() {
+  return path3.join(os.homedir(), ".agent-kit", "settings.json");
+}
+function loadGlobalSettings() {
+  const file = getGlobalSettingsFile();
+  if (fs2.existsSync(file)) {
     try {
-      return JSON.parse(fs2.readFileSync(settingsPath, "utf-8"));
+      return JSON.parse(fs2.readFileSync(file, "utf-8"));
     } catch (error) {
-      console.error(`[agent-kit] Warning: Failed to parse ${settingsPath}:`, error);
+      console.error(`[agent-kit] Warning: Failed to parse ${file}:`, error);
     }
   }
   return {};
 }
-function writeProjectSettings(workspaceRoot, patch) {
-  const settingsPath = path3.join(workspaceRoot, ".agent-kit", "settings.json");
-  const current = loadProjectSettings(workspaceRoot);
-  atomicWriteJsonFile(settingsPath, { ...current, ...patch });
+function writeGlobalSettings(patch) {
+  const current = loadGlobalSettings();
+  atomicWriteJsonFile(getGlobalSettingsFile(), { ...current, ...patch });
 }
 function resolveConversationDigestConfig(settings) {
   const digest = settings.memory?.conversationDigest;
@@ -15104,9 +15100,9 @@ function writeProvisionalDigestFile(outDir, input, markdown) {
   return markdownPath;
 }
 function writeConversationDigestSettings(workspaceRoot, digest) {
-  const current = loadProjectSettings(workspaceRoot);
+  const current = loadGlobalSettings();
   const memory = current.memory ?? {};
-  writeProjectSettings(workspaceRoot, {
+  writeGlobalSettings({
     memory: {
       ...memory,
       enabled: memory.enabled ?? true,
@@ -15131,8 +15127,8 @@ var DIGEST_MODEL_REGISTRY = {
     sourceUrl: "https://huggingface.co/bartowski/Qwen2.5-0.5B-Instruct-GGUF",
     enabled: true
   },
-  ["default" /* DEFAULT */]: {
-    id: "default" /* DEFAULT */,
+  ["base" /* BASE */]: {
+    id: "base" /* BASE */,
     ggufUri: "hf:bartowski/Qwen2.5-1.5B-Instruct-GGUF/Qwen2.5-1.5B-Instruct-Q4_K_M.gguf",
     approxSizeBytes: 1e9,
     license: "Apache-2.0",
@@ -15186,10 +15182,11 @@ async function withTimeout(promise, timeoutMs, createError) {
 }
 
 // src/utils/paths.ts
-import * as os from "os";
+import * as os2 from "os";
 import * as path5 from "path";
-var AGENT_KIT_HOME = path5.join(os.homedir(), ".agent-kit");
+var AGENT_KIT_HOME = path5.join(os2.homedir(), ".agent-kit");
 var CREDENTIALS_FILE = path5.join(AGENT_KIT_HOME, "credentials");
+var GLOBAL_SETTINGS_FILE = path5.join(AGENT_KIT_HOME, "settings.json");
 var MODEL_CACHE_DIR = path5.join(AGENT_KIT_HOME, "cache", "models");
 var FASTEMBED_CACHE_DIR = path5.join(MODEL_CACHE_DIR, "fastembed");
 
@@ -15217,39 +15214,19 @@ function buildPrompt(input, maxInputChars) {
     {
       role: "system",
       content: [
-        "# ROLE",
-        "You write short project-memory wiki pages from developer transcripts.",
-        "Your output is temporary recall to prevent blind steps.",
-        "",
-        "# RULES",
-        "1. Read the end of the export FIRST to discover the ultimate resolution.",
-        "2. What the user says LAST ALWAYS overrides earlier agreements.",
-        "3. Capture absolute engineering conclusions, never conversational pleasantries.",
-        "4. Return Markdown only. Do not wrap output in code blocks (```markdown ... ```)."
+        "You are a technical summarizer.",
+        "Focus ONLY on the final decisions made at the end of the transcript.",
+        "Never invent or guess details.",
+        "Keep the output concise and strictly factual."
       ].join("\n")
     },
     {
       role: "user",
       content: [
-        "Generate a high-level project memory page. STRICTLY adhere to this architectural layout:",
-        "",
-        "<layout>",
-        "# Digest: " + titleFromSource(input.sourcePath),
-        "- **Ultimate Core Resolution**: [Describe the final working state of the feature and what problem it solves in 1-2 sentences. No conversational filler.]",
-        "- **Architectural Changes**: [List 3-4 high-level engineering decisions made (e.g., shifts in hook timing, data isolation, atomic locks). Focus on systemic changes, NOT individual files.]",
-        "- **Component State**: [Briefly state how the Plugin side and the MCP/CLI side now interact based on the final decision.]",
-        "- **Considered & Rejected**: [List concepts proposed but discarded (e.g., initial hooks location, mocking strategies). Omit if empty.]",
-        "</layout>",
-        "",
-        "# CRITICAL RULES:",
-        "- DO NOT list individual file paths, line numbers, or specific test cases (EXCLUDE lists of files).",
-        "- Focus entirely on the SYSTEM DESIGN and ARCHITECTURE that the next engineer needs to know.",
-        "- Keep output under 300 tokens. Stop immediately after the last valid section.",
-        "",
-        "Source path: " + input.sourcePath,
-        '<conversation_export format="memory-kit">',
+        "Transcript:",
         conversationExport,
-        "</conversation_export>"
+        "",
+        "Task: Write a brief summary paragraph of the final agreed-upon decisions in the transcript above. Then, provide a simple bulleted list of the specific technical changes or outcomes."
       ].join("\n")
     }
   ];
@@ -15312,7 +15289,18 @@ async function createLlamaLocalDigestProvider(modelId) {
           options.timeoutMs,
           () => new LlamaLocalDigestProviderError(`Llama provider timed out after ${options.timeoutMs}ms`)
         );
-        return sanitizeConversationDigestMarkdown(response);
+        const metadata = `## Digest: ${titleFromSource(input.sourcePath)}
+
+| Key | Value |
+| ------ | ----- |
+| **Source** | ${input.sourcePath} |
+| **Generated** | ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]} |
+| **Model** | ${modelId} |
+`;
+        const sanitized = sanitizeConversationDigestMarkdown(response);
+        return `${metadata}
+
+${sanitized}`;
       } finally {
         await context.dispose();
       }
@@ -15322,9 +15310,11 @@ async function createLlamaLocalDigestProvider(modelId) {
 
 // src/services/memory/store.ts
 var import_stopword = __toESM(require_stopword_cjs(), 1);
-import Database from "better-sqlite3";
+import Database from "libsql";
 import * as fs5 from "fs";
 import * as path7 from "path";
+var SCHEMA_VERSION = 3;
+var LibsqlDatabase = Database;
 var StoreError = class extends Error {
   constructor(message, cause) {
     super(message);
@@ -15339,13 +15329,11 @@ var MemoryStore = class {
     this.db = this.openDatabase(dbPath);
   }
   db;
-  _vecAvailable = false;
   openDatabase(dbPath) {
     try {
-      const db = new Database(dbPath);
+      const db = new LibsqlDatabase(dbPath);
       db.pragma("journal_mode = WAL");
       db.pragma("busy_timeout = 5000");
-      this.loadVecExtension(db);
       this.createSchema(db);
       return db;
     } catch (err) {
@@ -15354,102 +15342,115 @@ var MemoryStore = class {
         fs5.unlinkSync(dbPath);
       } catch {
       }
-      const db = new Database(dbPath);
-      db.pragma("journal_mode = WAL");
-      db.pragma("busy_timeout = 5000");
-      this.loadVecExtension(db);
-      this.createSchema(db);
-      return db;
-    }
-  }
-  loadVecExtension(db) {
-    try {
-      const sqliteVec = __require("sqlite-vec");
-      sqliteVec.load(db);
-      this._vecAvailable = true;
-    } catch (err) {
-      console.warn("[memory-store] sqlite-vec unavailable, degrading to FTS5-only:", err);
-      this._vecAvailable = false;
+      try {
+        const db = new LibsqlDatabase(dbPath);
+        db.pragma("journal_mode = WAL");
+        db.pragma("busy_timeout = 5000");
+        this.createSchema(db);
+        return db;
+      } catch (retryErr) {
+        throw new StoreError("database open failed", retryErr);
+      }
     }
   }
   createSchema(db) {
-    db.exec(`
-      CREATE TABLE IF NOT EXISTS memory_chunks (
-        rowid         INTEGER PRIMARY KEY AUTOINCREMENT,
-        id            TEXT NOT NULL UNIQUE,
-        source        TEXT NOT NULL,
-        heading       TEXT NOT NULL DEFAULT '',
-        heading_level INTEGER NOT NULL DEFAULT 0,
-        content       TEXT NOT NULL,
-        line_start    INTEGER NOT NULL,
-        line_end      INTEGER NOT NULL,
-        indexed_at    INTEGER NOT NULL
-      );
-
-      CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts USING fts5(
-        source,
-        heading,
-        content,
-        content='memory_chunks',
-        content_rowid='rowid'
-      );
-
-      CREATE TRIGGER IF NOT EXISTS memory_chunks_ai
-        AFTER INSERT ON memory_chunks BEGIN
-          INSERT INTO memory_fts(rowid, source, heading, content)
-            VALUES (new.rowid, new.source, new.heading, new.content);
-        END;
-
-      CREATE TRIGGER IF NOT EXISTS memory_chunks_ad
-        AFTER DELETE ON memory_chunks BEGIN
-          INSERT INTO memory_fts(memory_fts, rowid, source, heading, content)
-            VALUES ('delete', old.rowid, old.source, old.heading, old.content);
-        END;
-    `);
-    if (this._vecAvailable) {
-      try {
+    try {
+      const current = this.readUserVersion(db);
+      if (current < SCHEMA_VERSION) {
         db.exec(`
-          CREATE VIRTUAL TABLE IF NOT EXISTS memory_vec USING vec0(
-            embedding FLOAT[${this.config.vectorDimension}]
-          );
+          DROP TRIGGER IF EXISTS memory_chunks_ai;
+          DROP TRIGGER IF EXISTS memory_chunks_ad;
+          DROP TABLE IF EXISTS memory_fts;
+          DROP TABLE IF EXISTS memory_vec;
+          DROP INDEX IF EXISTS idx_memory_chunks_embedding;
+          DROP TABLE IF EXISTS memory_chunks;
         `);
-      } catch (err) {
-        console.warn("[memory-store] Failed to create memory_vec, disabling vector search:", err);
-        this._vecAvailable = false;
+        db.pragma(`user_version = ${SCHEMA_VERSION}`);
       }
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS memory_chunks (
+          rowid         INTEGER PRIMARY KEY AUTOINCREMENT,
+          id            TEXT NOT NULL UNIQUE,
+          source        TEXT NOT NULL,
+          source_type   TEXT NOT NULL DEFAULT 'wiki',
+          heading       TEXT NOT NULL DEFAULT '',
+          heading_level INTEGER NOT NULL DEFAULT 0,
+          content       TEXT NOT NULL,
+          line_start    INTEGER NOT NULL,
+          line_end      INTEGER NOT NULL,
+          indexed_at    INTEGER NOT NULL,
+          file_mtime_at INTEGER NOT NULL DEFAULT 0,
+          embedding     F32_BLOB(${this.config.vectorDimension}) NOT NULL
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_memory_chunks_type_mtime
+          ON memory_chunks (source_type, file_mtime_at DESC);
+
+        CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts USING fts5(
+          source,
+          heading,
+          content,
+          content='memory_chunks',
+          content_rowid='rowid'
+        );
+
+        CREATE TRIGGER IF NOT EXISTS memory_chunks_ai
+          AFTER INSERT ON memory_chunks BEGIN
+            INSERT INTO memory_fts(rowid, source, heading, content)
+              VALUES (new.rowid, new.source, new.heading, new.content);
+          END;
+
+        CREATE TRIGGER IF NOT EXISTS memory_chunks_ad
+          AFTER DELETE ON memory_chunks BEGIN
+            INSERT INTO memory_fts(memory_fts, rowid, source, heading, content)
+              VALUES ('delete', old.rowid, old.source, old.heading, old.content);
+          END;
+
+        CREATE INDEX IF NOT EXISTS idx_memory_chunks_embedding
+          ON memory_chunks (libsql_vector_idx(embedding));
+      `);
+    } catch (err) {
+      throw new StoreError("schema migration failed", err);
     }
   }
+  readUserVersion(db) {
+    const value = db.pragma("user_version", { simple: true });
+    if (typeof value === "number") return value;
+    if (Array.isArray(value)) {
+      const [row] = value;
+      return typeof row?.user_version === "number" ? row.user_version : 0;
+    }
+    if (value && typeof value === "object" && "user_version" in value) {
+      const row = value;
+      return typeof row.user_version === "number" ? row.user_version : 0;
+    }
+    return 0;
+  }
   upsert(chunks, embeddings) {
     const insertChunk = this.db.prepare(`
       INSERT OR REPLACE INTO memory_chunks
-        (id, source, heading, heading_level, content, line_start, line_end, indexed_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        (id, source, source_type, heading, heading_level, content, line_start, line_end, indexed_at, file_mtime_at, embedding)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, vector32(?))
     `);
-    let insertVec = null;
-    if (this._vecAvailable) {
-      insertVec = this.db.prepare(`INSERT OR REPLACE INTO memory_vec (rowid, embedding) VALUES (?, ?)`);
-    }
     const upsertAll = this.db.transaction(() => {
       for (let i = 0; i < chunks.length; i++) {
         const chunk = chunks[i];
         try {
+          const vectorBinding = this.toVectorBinding(embeddings[i]);
           this.db.prepare(`DELETE FROM memory_chunks WHERE id = ?`).run(chunk.id);
-          const info = insertChunk.run(
+          insertChunk.run(
             chunk.id,
             chunk.source,
+            chunk.sourceType,
             chunk.heading,
             chunk.headingLevel,
             chunk.content,
             chunk.lineStart,
             chunk.lineEnd,
-            Date.now()
+            Date.now(),
+            chunk.fileMtimeAt,
+            vectorBinding
           );
-          if (insertVec && embeddings[i] && info.lastInsertRowid) {
-            const rowid = Number(info.lastInsertRowid);
-            const emb = embeddings[i];
-            const buf = Buffer.from(emb.buffer, emb.byteOffset, emb.byteLength);
-            insertVec.run(rowid, buf);
-          }
         } catch (err) {
           console.warn(`[memory-store] Failed to upsert chunk ${chunk.id}:`, err);
         }
@@ -15461,6 +15462,20 @@ var MemoryStore = class {
       throw new StoreError("Full batch upsert failed", err);
     }
   }
+  toVectorBinding(embedding) {
+    if (!embedding) throw new Error("missing embedding");
+    if (!(embedding instanceof Float32Array)) throw new Error("missing embedding");
+    if (embedding.length !== this.config.vectorDimension) throw new Error("embedding dimension mismatch");
+    const values = Array.from(embedding, (value) => {
+      if (!Number.isFinite(value)) throw new Error("embedding contains non-finite value");
+      return value;
+    });
+    return JSON.stringify(values);
+  }
+  normalizeVectorDistance(distance) {
+    if (distance <= 0) return 1;
+    return Math.max(0, Math.min(1, 1 - distance));
+  }
   hashesBySource(source) {
     const rows = this.db.prepare(`SELECT id FROM memory_chunks WHERE source = ?`).all(source);
     return new Set(rows.map((r) => r.id));
@@ -15469,13 +15484,22 @@ var MemoryStore = class {
     const rows = this.db.prepare(`SELECT DISTINCT source FROM memory_chunks`).all();
     return rows.map((r) => r.source);
   }
+  getRecentSources(options) {
+    const limit = Math.min(Math.max(1, options.limit || 5), 50);
+    const whereClause = options.sourceType ? " WHERE source_type = ?" : "";
+    const params = options.sourceType ? [options.sourceType, limit] : [limit];
+    try {
+      const rows = this.db.prepare(
+        `SELECT source, MAX(file_mtime_at) AS t FROM memory_chunks${whereClause} GROUP BY source ORDER BY t DESC LIMIT ?`
+      ).all(...params);
+      return rows.map((row) => ({ source: row.source, fileMtimeAt: row.t }));
+    } catch (err) {
+      console.warn("[memory-store] Recent source lookup failed:", err);
+      return [];
+    }
+  }
   deleteBySource(source) {
-    const rows = this.db.prepare(`SELECT rowid FROM memory_chunks WHERE source = ?`).all(source);
     const deleteAll = this.db.transaction(() => {
-      if (this._vecAvailable && rows.length > 0) {
-        const placeholders = rows.map(() => "?").join(", ");
-        this.db.prepare(`DELETE FROM memory_vec WHERE rowid IN (${placeholders})`).run(...rows.map((r) => r.rowid));
-      }
       this.db.prepare(`DELETE FROM memory_chunks WHERE source = ?`).run(source);
     });
     deleteAll();
@@ -15483,30 +15507,24 @@ var MemoryStore = class {
   deleteByIds(ids) {
     if (ids.length === 0) return;
     const placeholders = ids.map(() => "?").join(", ");
-    const rows = this.db.prepare(`SELECT rowid FROM memory_chunks WHERE id IN (${placeholders})`).all(...ids);
     const deleteAll = this.db.transaction(() => {
-      if (this._vecAvailable && rows.length > 0) {
-        const rPlaceholders = rows.map(() => "?").join(", ");
-        this.db.prepare(`DELETE FROM memory_vec WHERE rowid IN (${rPlaceholders})`).run(...rows.map((r) => r.rowid));
-      }
       this.db.prepare(`DELETE FROM memory_chunks WHERE id IN (${placeholders})`).run(...ids);
     });
     deleteAll();
   }
   searchDense(embedding, limit) {
-    if (!this._vecAvailable) return [];
     try {
-      const buf = Buffer.from(embedding.buffer);
+      const queryVector = this.toVectorBinding(embedding);
       const rows = this.db.prepare(
-        `SELECT mc.id, mv.distance
-           FROM memory_vec mv
-           JOIN memory_chunks mc ON mc.rowid = mv.rowid
-           WHERE mv.embedding MATCH ? AND k = ?
-           ORDER BY mv.distance`
-      ).all(buf, limit);
+        `SELECT mc.id, vector_distance_cos(mc.embedding, vector32(?)) AS distance
+           FROM vector_top_k('idx_memory_chunks_embedding', vector32(?), ?) AS vector_matches
+           JOIN memory_chunks mc ON mc.rowid = vector_matches.id
+           ORDER BY distance
+           LIMIT ?`
+      ).all(queryVector, queryVector, limit, limit);
       return rows.map((r) => ({
         id: r.id,
-        score: Math.max(0, 1 - r.distance)
+        score: this.normalizeVectorDistance(r.distance)
       }));
     } catch (err) {
       console.warn("[memory-store] Dense search failed:", err);
@@ -15545,21 +15563,23 @@ var MemoryStore = class {
     if (ids.length === 0) return [];
     const placeholders = ids.map(() => "?").join(", ");
     const rows = this.db.prepare(
-      `SELECT id, source, heading, heading_level, content, line_start, line_end
+      `SELECT id, source, source_type, heading, heading_level, content, line_start, line_end, file_mtime_at
          FROM memory_chunks WHERE id IN (${placeholders})`
     ).all(...ids);
     return rows.map((r) => ({
       id: r.id,
       source: r.source,
+      sourceType: r.source_type,
       heading: r.heading,
       headingLevel: r.heading_level,
       content: r.content,
       lineStart: r.line_start,
-      lineEnd: r.line_end
+      lineEnd: r.line_end,
+      fileMtimeAt: r.file_mtime_at
     }));
   }
   get vecAvailable() {
-    return this._vecAvailable;
+    return true;
   }
   close() {
     this.db.close();
@@ -15648,7 +15668,7 @@ function splitSection(text, maxLen) {
   if (byPara.every((p) => p.length <= maxLen)) return byPara;
   return byPara.flatMap((p) => p.length <= maxLen ? [p] : splitAtLine(p, maxLen));
 }
-function chunkMarkdown(text, source, config) {
+function chunkMarkdown(text, source, config, meta) {
   if (!text || !text.trim()) return [];
   const { chunkSize, overlapLines } = config;
   const lines = text.split("\n");
@@ -15687,11 +15707,13 @@ ${sectionText}` : sectionText;
       chunks.push({
         id: computeChunkId(content),
         source,
+        sourceType: meta.sourceType,
         heading: section.heading,
         headingLevel: section.headingLevel,
         content,
         lineStart: firstLine,
-        lineEnd: lastLine
+        lineEnd: lastLine,
+        fileMtimeAt: meta.fileMtimeAt
       });
       if (pi === parts.length - 1) {
         prevOverlapLines = partLines.slice(-overlapLines);
@@ -15702,6 +15724,13 @@ ${sectionText}` : sectionText;
 }
 
 // src/services/memory/indexer.ts
+function deriveSourceType(source) {
+  if (source.startsWith("compiled/provisional/conversation-digests/")) return "digest";
+  if (source.startsWith("compiled/concepts/")) return "concept";
+  if (source.startsWith("compiled/entities/")) return "entity";
+  if (source === "compiled/preferences.md") return "preference";
+  return "wiki";
+}
 var MemoryIndexer = class {
   constructor(store, embedder, config) {
     this.store = store;
@@ -15722,7 +15751,15 @@ var MemoryIndexer = class {
       console.warn(`[memory-indexer] Cannot read file ${absolutePath}:`, err);
       return { indexed: 0, deleted: 0, skipped: existingChunkIds.size };
     }
-    const allChunks = chunkMarkdown(text, source, this.config);
+    let fileMtimeAt;
+    try {
+      fileMtimeAt = fs6.statSync(absolutePath).mtimeMs;
+    } catch (err) {
+      console.warn(`[memory-indexer] Cannot stat file ${absolutePath}:`, err);
+      fileMtimeAt = Date.now();
+    }
+    const sourceType = deriveSourceType(source);
+    const allChunks = chunkMarkdown(text, source, this.config, { sourceType, fileMtimeAt });
     const currentChunkIds = new Set(allChunks.map((chunk) => chunk.id));
     const toIndex = allChunks.filter((chunk) => !existingChunkIds.has(chunk.id));
     const toDelete = [...existingChunkIds].filter((id) => !currentChunkIds.has(id));
@@ -15809,12 +15846,9 @@ var MemoryIndexer = class {
       scoreMap.set(r.id, { dense: 1 / (RRF_K + rank + 1), bm25: 0 });
     });
     bm25Results.forEach((r, rank) => {
-      const existing = scoreMap.get(r.id);
-      if (existing) {
-        existing.bm25 = 1 / (RRF_K + rank + 1);
-      } else {
-        scoreMap.set(r.id, { dense: 0, bm25: 1 / (RRF_K + rank + 1) });
-      }
+      const entry = scoreMap.get(r.id) ?? { dense: 0, bm25: 0 };
+      entry.bm25 = 1 / (RRF_K + rank + 1);
+      scoreMap.set(r.id, entry);
     });
     const hasDense = this.store.vecAvailable && denseResults.length > 0;
     const numRetrievers = hasDense ? 2 : 1;
@@ -15884,6 +15918,77 @@ ${content}
   }
 };
 
+// src/services/memory/embedder.ts
+var EmbedderError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.name = "EmbedderError";
+    if (cause instanceof Error) this.cause = cause;
+  }
+};
+var Embedder = class {
+  modelName;
+  pipeline = null;
+  _dimension;
+  constructor(modelName) {
+    this.modelName = modelName;
+  }
+  async embed(texts) {
+    if (texts.length === 0) return [];
+    if (!this.pipeline) {
+      await this.loadModel();
+    }
+    try {
+      const results = await this.pipeline(texts);
+      return results.map((vec) => {
+        const arr = new Float32Array(vec);
+        if (!this._dimension) this._dimension = arr.length;
+        return arr;
+      });
+    } catch (cause) {
+      throw new EmbedderError(`Embedding failed for batch of ${texts.length} texts`, cause);
+    }
+  }
+  get dimension() {
+    return this._dimension;
+  }
+  isReady() {
+    return this.pipeline !== null;
+  }
+  async initialize() {
+    if (!this.pipeline) {
+      await this.loadModel();
+    }
+  }
+  async loadModel() {
+    try {
+      const { EmbeddingModel, FlagEmbedding } = await import("fastembed");
+      const modelMap = {
+        ["tiny" /* TINY */]: EmbeddingModel.AllMiniLML6V2,
+        ["base" /* BASE */]: EmbeddingModel.BGESmallENV15,
+        ["large" /* LARGE */]: EmbeddingModel.BGEBaseENV15
+      };
+      const model = modelMap[this.modelName] ?? EmbeddingModel.BGESmallENV15;
+      const embedder = await FlagEmbedding.init({
+        model,
+        cacheDir: FASTEMBED_CACHE_DIR,
+        showDownloadProgress: false
+      });
+      this.pipeline = async (texts) => {
+        const result = [];
+        for await (const batch of embedder.embed(texts, texts.length)) {
+          for (const vec of batch) {
+            result.push(Array.from(vec));
+          }
+        }
+        return result;
+      };
+    } catch (cause) {
+      throw new EmbedderError(`Failed to load embedding model: ${this.modelName}`, cause);
+    }
+  }
+};
+
 // src/services/digest/processor.ts
 function digestLockPath(workspaceRoot) {
   return path9.join(workspaceRoot, DIGEST_LOCKFILE_REL_PATH);
@@ -15910,19 +16015,25 @@ function discoverPendingConversationFiles(workspaceRoot) {
     }
   });
 }
-async function indexProvisionalDigestFile(workspaceRoot, markdownPath) {
+async function indexProvisionalDigestFile(workspaceRoot, markdownPath, indexer) {
+  let store;
   try {
-    const settings = loadProjectSettings(workspaceRoot);
+    if (indexer) {
+      await indexer.indexFile(markdownPath);
+      return { indexed: true };
+    }
+    const settings = loadGlobalSettings();
     const config = resolveMemoryConfig(settings, workspaceRoot);
-    const store = new MemoryStore(path9.join(config.wikiDir, "index.db"), config);
-    const embedder = { embed: async (_texts) => [], initialize: async () => {
-    } };
-    const indexer = new MemoryIndexer(store, embedder, config);
-    await indexer.indexFile(markdownPath);
+    if (config.enabled !== true) return { indexed: false };
+    store = new MemoryStore(path9.join(config.wikiDir, "index.db"), config);
+    const embedder = new Embedder(config.embeddingModel);
+    await embedder.initialize();
+    await new MemoryIndexer(store, embedder, config).indexFile(markdownPath);
     return { indexed: true };
   } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return { indexed: false, error: message };
+    return { indexed: false, error: err instanceof Error ? err.message : String(err) };
+  } finally {
+    store?.close();
   }
 }
 async function digestConversationFile(options) {
@@ -15930,7 +16041,7 @@ async function digestConversationFile(options) {
   const input = readConversationDigestInput(options.workspaceRoot, options.inputPath);
   const existingPath = findExistingProvisionalDigest(outDir, input);
   if (existingPath) {
-    const indexResult = await indexProvisionalDigestFile(options.workspaceRoot, existingPath);
+    const indexResult = await indexProvisionalDigestFile(options.workspaceRoot, existingPath, options.indexer);
     return {
       markdown: existingPath,
       status: "provisional",
@@ -15947,7 +16058,7 @@ async function digestConversationFile(options) {
       timeoutMs: options.timeoutMs ?? DEFAULT_DIGEST_TIMEOUT_MS
     });
     const markdownPath = writeProvisionalDigestFile(outDir, input, markdown);
-    const indexResult = await indexProvisionalDigestFile(options.workspaceRoot, markdownPath);
+    const indexResult = await indexProvisionalDigestFile(options.workspaceRoot, markdownPath, options.indexer);
     return {
       markdown: markdownPath,
       status: "provisional",
@@ -15960,7 +16071,7 @@ async function digestConversationFile(options) {
   }
 }
 function summarizePendingConversations(workspaceRoot) {
-  const digestConfig = resolveConversationDigestConfig(loadProjectSettings(workspaceRoot));
+  const digestConfig = resolveConversationDigestConfig(loadGlobalSettings());
   if (!digestConfig || digestConfig.enabled === false) {
     return { initialized: false, pending: 0, reason: "not-initialized" };
   }
@@ -15975,7 +16086,7 @@ async function digestPendingConversations({
   digestFn = digestConversationFile,
   onProgress
 }) {
-  const digestConfig = resolveConversationDigestConfig(loadProjectSettings(workspaceRoot));
+  const digestConfig = resolveConversationDigestConfig(loadGlobalSettings());
   if (!digestConfig || digestConfig.enabled === false) {
     return { ok: true, initialized: false, action: "noop", reason: "not-initialized" };
   }
@@ -15983,11 +16094,21 @@ async function digestPendingConversations({
   if (!tryAcquireProcessLock(lockPath)) {
     return { ok: true, initialized: true, action: "noop", reason: "locked" };
   }
+  let closeIndexer;
   try {
     const candidates = discoverPendingConversationFiles(workspaceRoot);
     if (candidates.length === 0) {
       return { ok: true, initialized: true, action: "noop", reason: "no-pending" };
     }
+    let indexer;
+    const memoryConfig = resolveMemoryConfig(loadGlobalSettings(), workspaceRoot);
+    if (memoryConfig.enabled === true) {
+      const store = new MemoryStore(path9.join(memoryConfig.wikiDir, "index.db"), memoryConfig);
+      const embedder = new Embedder(memoryConfig.embeddingModel);
+      indexer = new MemoryIndexer(store, embedder, memoryConfig);
+      closeIndexer = () => store.close();
+      await embedder.initialize();
+    }
     let count = 0;
     let skipped = 0;
     let errors = 0;
@@ -15996,7 +16117,8 @@ async function digestPendingConversations({
         const result = await digestFn({
           workspaceRoot,
           inputPath: filePath,
-          modelId: digestConfig.modelId
+          modelId: digestConfig.modelId,
+          indexer
         });
         if (result.skipped) {
           skipped++;
@@ -16013,9 +16135,17 @@ async function digestPendingConversations({
     return { ok: true, initialized: true, action: "digested", count, skipped, errors };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
+    console.warn("[digest] Pending conversation digest failed:", err);
     return { ok: false, initialized: true, action: "error", error: message };
   } finally {
     releaseLock(lockPath);
+    if (closeIndexer) {
+      try {
+        closeIndexer();
+      } catch (err) {
+        console.warn("[digest] Failed to close memory indexer store:", err);
+      }
+    }
   }
 }
 async function initializeConversationDigestModel(input) {
@@ -16385,7 +16515,7 @@ function runDigestFileInWorker(args) {
 
 // src/utils/utils.ts
 function getWorkspaceRoot() {
-  return process.env.WORKSPACE_DIR || process.env.CLAUDE_PROJECT_DIR || process.env.CODEX_PROJECT_DIR || process.env.GEMINI_PROJECT_DIR || process.env.CLAUDE_WORKSPACE || process.env.CODEX_WORKSPACE || process.env.GEMINI_WORKSPACE || process.env.INIT_CWD || process.env.PWD || process.cwd();
+  return process.env.WORKSPACE_DIR || process.env.CLAUDE_PROJECT_DIR || process.env.CODEX_PROJECT_DIR || process.env.GEMINI_PROJECT_DIR || process.env.INIT_CWD || process.env.PWD || process.cwd();
 }
 
 // src/cli/commands/memory.ts
@@ -16396,6 +16526,37 @@ function writeDigestFileResult(result, workerMode) {
   }
   process.stdout.write(JSON.stringify(result, null, 2) + "\n");
 }
+function formatLauncherResult(result) {
+  if (!result.ok) return `Digest failed: ${result.error ?? "unknown error"}`;
+  if (result.spawned) return "Background digest started";
+  switch (result.status.state) {
+    case "locked":
+      return "Digest already running";
+    case "no-pending":
+      return "No conversations to digest";
+    case "not-initialized":
+      return "Digest not initialized";
+    default:
+      return `Digest skipped (${result.status.state})`;
+  }
+}
+function formatPendingResult(result) {
+  if (!result.ok) return `Digest failed: ${result.error ?? "unknown error"}`;
+  if (result.action === "noop") {
+    switch (result.reason) {
+      case "locked":
+        return "Digest already running";
+      case "no-pending":
+        return "No conversations to digest";
+      case "not-initialized":
+        return "Digest not initialized";
+    }
+  }
+  const parts = [`${result.count} conversation${result.count !== 1 ? "s" : ""} digested`];
+  if (result.skipped > 0) parts.push(`${result.skipped} skipped`);
+  if (result.errors > 0) parts.push(`${result.errors} errors`);
+  return parts.join(", ");
+}
 async function cmdDigestInit(args) {
   const parsed = parseArgs(args);
   const modelId = stringFlag(parsed.flags, "model") ?? DEFAULT_DIGEST_MODEL_ID;
@@ -16413,7 +16574,7 @@ async function cmdDigestFile(args) {
   if (workerResult !== void 0) return workerResult;
   const parsed = parseArgs(args);
   const workspaceRoot = getWorkspaceRoot();
-  const digestConfig = resolveConversationDigestConfig(loadProjectSettings(workspaceRoot));
+  const digestConfig = resolveConversationDigestConfig(loadGlobalSettings());
   const modelId = stringFlag(parsed.flags, "model") ?? digestConfig?.modelId ?? DEFAULT_DIGEST_MODEL_ID;
   const inputPath = stringFlag(parsed.flags, "input");
   if (!inputPath) {
@@ -16446,11 +16607,19 @@ async function cmdDigestPending(args) {
       args,
       entrypoint: process.argv[1]
     });
-    process.stdout.write(JSON.stringify(result2) + "\n");
+    process.stdout.write(
+      JSON.stringify({
+        systemMessage: `[memory-kit] ${formatLauncherResult(result2)}`
+      }) + "\n"
+    );
     return 0;
   }
   const result = await digestPendingConversations({ workspaceRoot });
-  process.stdout.write(JSON.stringify(result) + "\n");
+  process.stdout.write(
+    JSON.stringify({
+      systemMessage: `[memory-kit] ${formatPendingResult(result)}`
+    }) + "\n"
+  );
   return 0;
 }
 async function runMemoryCli(args, _env) {