@hanhnd/agent-kit 1.0.30 → 1.0.32

package/dist/kit-server.js

@@ -2987,7 +2987,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve3.call(this, root, ref);
+      let _sch = resolve5.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
         const { schemaId } = this.opts;
@@ -3014,7 +3014,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve3(root, ref) {
+    function resolve5(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3229,8 +3229,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path11) {
-      let input = path11;
+    function removeDotSegments(path15) {
+      let input = path15;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3429,8 +3429,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path11, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path11 && path11 !== "/" ? path11 : void 0;
+        const [path15, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path15 && path15 !== "/" ? path15 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -3589,55 +3589,55 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve3(baseURI, relativeURI, options) {
+    function resolve5(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
-    function resolveComponent(base, relative3, options, skipNormalization) {
+    function resolveComponent(base, relative4, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
         base = parse3(serialize(base, options), options);
-        relative3 = parse3(serialize(relative3, options), options);
+        relative4 = parse3(serialize(relative4, options), options);
       }
       options = options || {};
-      if (!options.tolerant && relative3.scheme) {
-        target.scheme = relative3.scheme;
-        target.userinfo = relative3.userinfo;
-        target.host = relative3.host;
-        target.port = relative3.port;
-        target.path = removeDotSegments(relative3.path || "");
-        target.query = relative3.query;
+      if (!options.tolerant && relative4.scheme) {
+        target.scheme = relative4.scheme;
+        target.userinfo = relative4.userinfo;
+        target.host = relative4.host;
+        target.port = relative4.port;
+        target.path = removeDotSegments(relative4.path || "");
+        target.query = relative4.query;
       } else {
-        if (relative3.userinfo !== void 0 || relative3.host !== void 0 || relative3.port !== void 0) {
-          target.userinfo = relative3.userinfo;
-          target.host = relative3.host;
-          target.port = relative3.port;
-          target.path = removeDotSegments(relative3.path || "");
-          target.query = relative3.query;
+        if (relative4.userinfo !== void 0 || relative4.host !== void 0 || relative4.port !== void 0) {
+          target.userinfo = relative4.userinfo;
+          target.host = relative4.host;
+          target.port = relative4.port;
+          target.path = removeDotSegments(relative4.path || "");
+          target.query = relative4.query;
         } else {
-          if (!relative3.path) {
+          if (!relative4.path) {
             target.path = base.path;
-            if (relative3.query !== void 0) {
-              target.query = relative3.query;
+            if (relative4.query !== void 0) {
+              target.query = relative4.query;
             } else {
               target.query = base.query;
             }
           } else {
-            if (relative3.path[0] === "/") {
-              target.path = removeDotSegments(relative3.path);
+            if (relative4.path[0] === "/") {
+              target.path = removeDotSegments(relative4.path);
             } else {
               if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) {
-                target.path = "/" + relative3.path;
+                target.path = "/" + relative4.path;
               } else if (!base.path) {
-                target.path = relative3.path;
+                target.path = relative4.path;
               } else {
-                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative3.path;
+                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative4.path;
               }
               target.path = removeDotSegments(target.path);
             }
-            target.query = relative3.query;
+            target.query = relative4.query;
           }
           target.userinfo = base.userinfo;
           target.host = base.host;
@@ -3645,7 +3645,7 @@ var require_fast_uri = __commonJS({
         }
         target.scheme = base.scheme;
       }
-      target.fragment = relative3.fragment;
+      target.fragment = relative4.fragment;
       return target;
     }
     function equal(uriA, uriB, options) {
@@ -3816,7 +3816,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve: resolve3,
+      resolve: resolve5,
       resolveComponent,
       equal,
       serialize,
@@ -6792,12 +6792,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs7, exportName) {
+    function addFormats(ajv, list, fs11, exportName) {
       var _a;
       var _b;
       (_a = (_b = ajv.opts.code).formats) !== null && _a !== void 0 ? _a : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs7[f]);
+        ajv.addFormat(f, fs11[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -22171,8 +22171,8 @@ function getErrorMap() {
 
 // ../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path11, errorMaps, issueData } = params;
-  const fullPath = [...path11, ...issueData.path || []];
+  const { data, path: path15, errorMaps, issueData } = params;
+  const fullPath = [...path15, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -22288,11 +22288,11 @@ var errorUtil;
 
 // ../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path11, key) {
+  constructor(parent, value, path15, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path11;
+    this._path = path15;
     this._key = key;
   }
   get path() {
@@ -25930,10 +25930,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path11) {
-  if (!path11)
+function getElementAtPath(obj, path15) {
+  if (!path15)
     return obj;
-  return path11.reduce((acc, key) => acc?.[key], obj);
+  return path15.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -26253,11 +26253,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path11, issues) {
+function prefixIssues(path15, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path11);
+    iss.path.unshift(path15);
     return iss;
   });
 }
@@ -33768,7 +33768,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve3) => setTimeout(resolve3, pollInterval));
+        await new Promise((resolve5) => setTimeout(resolve5, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error2) {
@@ -33785,7 +33785,7 @@ var Protocol = class {
    */
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve5, reject) => {
       const earlyReject = (error2) => {
         reject(error2);
       };
@@ -33863,7 +33863,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve3(parseResult.data);
+            resolve5(parseResult.data);
           }
         } catch (error2) {
           reject(error2);
@@ -34124,12 +34124,12 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve5, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve3, interval);
+      const timeoutId = setTimeout(resolve5, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -35229,7 +35229,7 @@ var McpServer = class {
     let task = createTaskResult.task;
     const pollInterval = task.pollInterval ?? 5e3;
     while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-      await new Promise((resolve3) => setTimeout(resolve3, pollInterval));
+      await new Promise((resolve5) => setTimeout(resolve5, pollInterval));
       const updatedTask = await extra.taskStore.getTask(taskId);
       if (!updatedTask) {
         throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
@@ -35872,20 +35872,20 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve3) => {
+    return new Promise((resolve5) => {
       const json = serializeMessage(message);
       if (this._stdout.write(json)) {
-        resolve3();
+        resolve5();
       } else {
-        this._stdout.once("drain", resolve3);
+        this._stdout.once("drain", resolve5);
       }
     });
   }
 };
 
 // src/tools/core.ts
-import * as fs2 from "fs";
-import * as path3 from "path";
+import * as fs3 from "fs";
+import * as path4 from "path";
 
 // src/utils/utils.ts
 function getWorkspaceRoot() {
@@ -35899,10 +35899,10 @@ function mcpJson(obj) {
 }
 
 // src/tools/config.ts
-import * as fs from "fs";
-import * as path from "path";
+import * as fs2 from "fs";
+import * as path2 from "path";
 
-// src/memory/types.ts
+// src/memory/constants.ts
 var DEFAULT_MEMORY_CONFIG = {
   enabled: false,
   wikiDir: "",
@@ -35912,6 +35912,75 @@ var DEFAULT_MEMORY_CONFIG = {
   embeddingModel: "Xenova/bge-small-en-v1.5",
   vectorDimension: 384
 };
+var LOCK_RETRY_MS = 50;
+var LOCK_TIMEOUT_MS = 500;
+var RRF_K = 60;
+
+// src/utils/files.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+function atomicWriteTextFile(filePath, content) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(tempPath, content, "utf8");
+  fs.renameSync(tempPath, filePath);
+}
+function atomicWriteJsonFile(filePath, value) {
+  atomicWriteTextFile(filePath, `${JSON.stringify(value, null, 2)}
+`);
+}
+function tryWriteFileExclusive(filePath, content) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  try {
+    fs.writeFileSync(filePath, content, { flag: "wx" });
+    return true;
+  } catch (err) {
+    if (err.code === "EEXIST") return false;
+    throw err;
+  }
+}
+async function acquireLock(lockPath, timeoutMs, retryMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      if (tryWriteFileExclusive(lockPath, String(process.pid))) return true;
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, retryMs));
+  }
+  return false;
+}
+function releaseLock(lockPath, opts = {}) {
+  try {
+    fs.unlinkSync(lockPath);
+  } catch (err) {
+    if (opts.ignoreErrors || err.code === "ENOENT") return;
+    throw err;
+  }
+}
+function tryAcquireProcessLock(lockPath) {
+  const lockContent = JSON.stringify({ pid: process.pid });
+  if (tryWriteFileExclusive(lockPath, lockContent)) return true;
+  let pid;
+  try {
+    const raw = fs.readFileSync(lockPath, "utf8");
+    pid = JSON.parse(raw).pid;
+  } catch {
+  }
+  if (pid !== void 0) {
+    try {
+      process.kill(pid, 0);
+      return false;
+    } catch (err) {
+      if (err.code !== "ESRCH") return false;
+    }
+  }
+  try {
+    fs.unlinkSync(lockPath);
+  } catch {
+  }
+  return tryWriteFileExclusive(lockPath, lockContent);
+}
 
 // src/tools/config.ts
 function resolveMemoryConfig(settings2, workspaceRoot2) {
@@ -35920,20 +35989,37 @@ function resolveMemoryConfig(settings2, workspaceRoot2) {
     ...DEFAULT_MEMORY_CONFIG,
     ...override,
     enabled: override.enabled ?? DEFAULT_MEMORY_CONFIG.enabled,
-    wikiDir: typeof override.wikiDir === "string" && override.wikiDir.length > 0 ? override.wikiDir : path.join(workspaceRoot2, ".agent-kit", "wiki")
+    wikiDir: typeof override.wikiDir === "string" && override.wikiDir.length > 0 ? override.wikiDir : path2.join(workspaceRoot2, ".agent-kit", "wiki")
   };
 }
 function loadProjectSettings(projectDir) {
-  const settingsPath = path.join(projectDir, ".agent-kit", "settings.json");
-  if (fs.existsSync(settingsPath)) {
+  const settingsPath = path2.join(projectDir, ".agent-kit", "settings.json");
+  if (fs2.existsSync(settingsPath)) {
     try {
-      return JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+      return JSON.parse(fs2.readFileSync(settingsPath, "utf-8"));
     } catch (error2) {
       console.error(`[agent-kit] Warning: Failed to parse ${settingsPath}:`, error2);
     }
   }
   return {};
 }
+function writeProjectSettings(workspaceRoot2, patch) {
+  const settingsPath = path2.join(workspaceRoot2, ".agent-kit", "settings.json");
+  const current = loadProjectSettings(workspaceRoot2);
+  atomicWriteJsonFile(settingsPath, { ...current, ...patch });
+}
+function resolveConversationDigestConfig(settings2) {
+  const digest = settings2.memory?.conversationDigest;
+  if (!digest?.initialized || typeof digest.modelId !== "string" || typeof digest.initializedAt !== "string") {
+    return void 0;
+  }
+  return {
+    enabled: digest.enabled !== false,
+    initialized: true,
+    modelId: digest.modelId,
+    initializedAt: digest.initializedAt
+  };
+}
 var FORBIDDEN_FILES = [
   ".env",
   ".bashrc",
@@ -35948,7 +36034,7 @@ var FORBIDDEN_FILES = [
   ".netrc",
   ".gitconfig",
   "credentials"
-  // ~/.claude/credentials file
+  // ~/.agent-kit/credentials file
 ];
 var FORBIDDEN_PATTERNS = [
   /^\.env$/i,
@@ -35965,17 +36051,10 @@ var FORBIDDEN_PATTERNS = [
   /secrets\.json$/i,
   /secret\.json$/i
 ];
-var FORBIDDEN_DIRS = [
-  ".git",
-  ".ssh",
-  ".aws",
-  ".kube",
-  ".gnupg",
-  ".docker"
-];
+var FORBIDDEN_DIRS = [".git", ".ssh", ".aws", ".kube", ".gnupg", ".docker"];
 
 // src/tools/handoffs.ts
-import * as path2 from "path";
+import * as path3 from "path";
 var HANDOFF_TYPES = [
   "brainstorm",
   "clarification",
@@ -36018,11 +36097,11 @@ function resolveHandoffPath(input) {
     content: input.content,
     type: canonicalType
   });
-  const relativePath = path2.join(".agent-kit", "handoffs", featureSlug, `${canonicalType}.md`);
+  const relativePath = path3.join(".agent-kit", "handoffs", featureSlug, `${canonicalType}.md`);
   return {
     featureSlug,
     canonicalType,
-    filePath: path2.join(input.workspaceRoot, relativePath),
+    filePath: path3.join(input.workspaceRoot, relativePath),
     relativePath
   };
 }
@@ -36047,11 +36126,11 @@ function registerCoreTools(server2) {
           slug,
           content
         });
-        const handoffDir = path3.dirname(location.filePath);
-        if (!fs2.existsSync(handoffDir)) {
-          fs2.mkdirSync(handoffDir, { recursive: true });
+        const handoffDir = path4.dirname(location.filePath);
+        if (!fs3.existsSync(handoffDir)) {
+          fs3.mkdirSync(handoffDir, { recursive: true });
         }
-        fs2.writeFileSync(location.filePath, content, "utf8");
+        fs3.writeFileSync(location.filePath, content, "utf8");
         return mcpText(`\u2705 Saved to: ${location.filePath}`);
       } catch (error2) {
         return mcpText(`Error saving handoff: ${error2}`);
@@ -36063,28 +36142,28 @@ function registerCoreTools(server2) {
 // src/tools/agent.ts
 import { spawn } from "child_process";
 import { randomUUID } from "crypto";
-import * as fs3 from "fs";
-import * as path5 from "path";
+import * as fs4 from "fs";
+import * as path6 from "path";
 
 // src/tools/security.ts
 import { execFileSync } from "child_process";
-import * as path4 from "path";
+import * as path5 from "path";
 function sanitize(input) {
   return String(input).replace(/[;&|`$<>\\]/g, "").trim().slice(0, 500);
 }
 function validatePath(filePath, baseDir = process.cwd()) {
-  const resolved = path4.resolve(baseDir, filePath);
-  const root = path4.resolve(baseDir);
-  if (resolved !== root && !resolved.startsWith(root + path4.sep)) {
+  const resolved = path5.resolve(baseDir, filePath);
+  const root = path5.resolve(baseDir);
+  if (resolved !== root && !resolved.startsWith(root + path5.sep)) {
     throw new Error(`Path traversal detected: ${filePath}`);
   }
-  const segments = resolved.split(path4.sep);
+  const segments = resolved.split(path5.sep);
   for (const segment of segments) {
     if (FORBIDDEN_DIRS.some((d) => segment.toLowerCase() === d.toLowerCase())) {
       throw new Error(`Access to sensitive directory is FORBIDDEN: ${segment}`);
     }
   }
-  const fileName = path4.basename(resolved);
+  const fileName = path5.basename(resolved);
   const isExactForbidden = FORBIDDEN_FILES.some((f) => fileName.toLowerCase() === f.toLowerCase());
   const isPatternForbidden = FORBIDDEN_PATTERNS.some((re) => re.test(fileName));
   if (isExactForbidden || isPatternForbidden) {
@@ -36142,36 +36221,27 @@ function agentArgs(agent, prompt, workspaceRoot2) {
     case "claude":
       return ["--dangerously-skip-permissions", "-p", prompt];
     case "codex":
-      return [
-        "--ask-for-approval",
-        "never",
-        "--sandbox",
-        "workspace-write",
-        "--cd",
-        workspaceRoot2,
-        "exec",
-        prompt
-      ];
+      return ["--ask-for-approval", "never", "--sandbox", "workspace-write", "--cd", workspaceRoot2, "exec", prompt];
   }
 }
 function taskSlug(task) {
   return task.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim().split(/\s+/).slice(0, 6).join("-").slice(0, 48);
 }
 function initAgentLog(workspaceRoot2, slug, agent) {
-  const logsDir = path5.join(workspaceRoot2, ".agent-kit", "logs", "agents");
-  fs3.mkdirSync(logsDir, { recursive: true });
+  const logsDir = path6.join(workspaceRoot2, ".agent-kit", "logs", "agents");
+  fs4.mkdirSync(logsDir, { recursive: true });
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const logFile = path5.join(logsDir, `delegate-${now}-${slug}.log`);
+  const logFile = path6.join(logsDir, `delegate-${now}-${slug}.log`);
   const header = `Agent: ${agent}
 Date: ${now}
 ${"\u2500".repeat(60)}
 
 `;
-  fs3.writeFileSync(logFile, header, "utf-8");
-  const logStream = fs3.createWriteStream(logFile, { flags: "a" });
+  fs4.writeFileSync(logFile, header, "utf-8");
+  const logStream = fs4.createWriteStream(logFile, { flags: "a" });
   logStream.on("error", () => {
   });
-  return { logPath: path5.relative(workspaceRoot2, logFile), logStream };
+  return { logPath: path6.relative(workspaceRoot2, logFile), logStream };
 }
 function registerAgentTools(server2) {
   server2.tool(
@@ -36179,9 +36249,7 @@ function registerAgentTools(server2) {
     "!Important: Trigger only when user explicitly asks to delegate a task to an external agent CLI (gemini, claude, or codex). The task can be a direct message or a path to a handoff file (.agent-kit/handoffs/feature-slug/plan.md).",
     {
       agent: external_exports.enum(["gemini", "claude", "codex"]).describe('The agent CLI to invoke: "gemini", "claude", or "codex"'),
-      task: external_exports.string().describe(
-        'Task message or path to a handoff file (e.g., ".agent-kit/handoffs/feature-slug/plan.md")'
-      )
+      task: external_exports.string().describe('Task message or path to a handoff file (e.g., ".agent-kit/handoffs/feature-slug/plan.md")')
     },
     async ({ agent, task }, extra) => {
       const workspaceRoot2 = getWorkspaceRoot();
@@ -36190,11 +36258,11 @@ function registerAgentTools(server2) {
       let killChild;
       try {
         let prompt = task;
-        const resolvedTask = path5.resolve(workspaceRoot2, task);
-        if (fs3.existsSync(resolvedTask) && fs3.statSync(resolvedTask).isFile()) {
+        const resolvedTask = path6.resolve(workspaceRoot2, task);
+        if (fs4.existsSync(resolvedTask) && fs4.statSync(resolvedTask).isFile()) {
           try {
             validatePath(task, workspaceRoot2);
-            prompt = fs3.readFileSync(resolvedTask, "utf-8");
+            prompt = fs4.readFileSync(resolvedTask, "utf-8");
           } catch (err) {
             return mcpText(`Error reading task file: ${err}`);
           }
@@ -36247,7 +36315,7 @@ function registerAgentTools(server2) {
         };
         if (extra.signal.aborted) killChild();
         else extra.signal.addEventListener("abort", killChild);
-        await new Promise((resolve3, reject) => {
+        await new Promise((resolve5, reject) => {
           child.stdout?.on("data", (data) => {
             job.chunks.push(data.toString());
             job.logStream.write(data);
@@ -36257,11 +36325,8 @@ function registerAgentTools(server2) {
             job.logStream.write(data);
           });
           child.on("close", (code, signal) => {
-            if (code === 0) resolve3();
-            else
-              reject(
-                new Error(`Process exited with code ${code}${signal ? ` (signal: ${signal})` : ""}`)
-              );
+            if (code === 0) resolve5();
+            else reject(new Error(`Process exited with code ${code}${signal ? ` (signal: ${signal})` : ""}`));
           });
           child.on("error", reject);
         });
@@ -36292,13 +36357,20 @@ function registerAgentTools(server2) {
 }
 
 // src/tools/integration.ts
-import { writeFileSync as writeFileSync3 } from "fs";
+import { writeFileSync as writeFileSync4 } from "fs";
 
 // src/utils/credentials.ts
-import * as fs4 from "fs";
+import * as fs5 from "fs";
+
+// src/utils/paths.ts
 import * as os from "os";
-import * as path6 from "path";
-var CREDENTIALS_FILE = path6.join(os.homedir(), ".claude", "credentials");
+import * as path7 from "path";
+var AGENT_KIT_HOME = path7.join(os.homedir(), ".agent-kit");
+var CREDENTIALS_FILE = path7.join(AGENT_KIT_HOME, "credentials");
+var MODEL_CACHE_DIR = path7.join(AGENT_KIT_HOME, "cache", "models");
+var FASTEMBED_CACHE_DIR = path7.join(MODEL_CACHE_DIR, "fastembed");
+
+// src/utils/credentials.ts
 var cachedCredentials = null;
 function parseIni(content) {
   const result = {};
@@ -36323,12 +36395,12 @@ function parseIni(content) {
 }
 function loadCredentials() {
   if (cachedCredentials !== null) return cachedCredentials;
-  if (!fs4.existsSync(CREDENTIALS_FILE)) {
+  if (!fs5.existsSync(CREDENTIALS_FILE)) {
     cachedCredentials = {};
     return cachedCredentials;
   }
   try {
-    const stat = fs4.statSync(CREDENTIALS_FILE);
+    const stat = fs5.statSync(CREDENTIALS_FILE);
     const mode = stat.mode & 511;
     if (mode !== 384) {
       process.stderr.write(
@@ -36338,7 +36410,7 @@ function loadCredentials() {
     }
   } catch {
   }
-  const content = fs4.readFileSync(CREDENTIALS_FILE, "utf-8");
+  const content = fs5.readFileSync(CREDENTIALS_FILE, "utf-8");
   const ini = parseIni(content);
   const profile = process.env.KIT_PROFILE ?? "default";
   cachedCredentials = ini[profile] ?? {};
@@ -36467,9 +36539,7 @@ ${renderNodes(node.content, listDepth, node.type).trim()}
     for (const row of rows) {
       if (row.type !== "tableRow") continue;
       const cells = row.content || [];
-      const rendered = cells.map(
-        (c) => renderNodes(c.content).trim().replace(/\n+/g, " ").replace(/\|/g, "\\|")
-      );
+      const rendered = cells.map((c) => renderNodes(c.content).trim().replace(/\n+/g, " ").replace(/\|/g, "\\|"));
       result += "| " + rendered.join(" | ") + " |\n";
       if (isFirstRow) {
         result += "| " + cells.map(() => "---").join(" | ") + " |\n";
@@ -36538,9 +36608,7 @@ function registerIntegrationTools(server2) {
     "Get Bitbucket PR details and optionally the diff. Accepts a full PR URL or a numeric PR ID with workspace + repoSlug.",
     {
       input: external_exports.string().describe("Bitbucket PR URL or numeric PR ID"),
-      workspace: external_exports.string().optional().describe(
-        "Bitbucket workspace slug (required for numeric ID if BITBUCKET_DEFAULT_WORKSPACE not set)"
-      ),
+      workspace: external_exports.string().optional().describe("Bitbucket workspace slug (required for numeric ID if BITBUCKET_DEFAULT_WORKSPACE not set)"),
       repoSlug: external_exports.string().optional().describe("Bitbucket repo slug (required for numeric ID)"),
       includeDiff: external_exports.boolean().optional().default(true).describe("Include unified diff in response")
     },
@@ -36565,9 +36633,7 @@ function registerIntegrationTools(server2) {
           );
         }
         if (!repo || !prId) {
-          return mcpText(
-            `\u274C Could not parse PR URL. Expected: bitbucket.org/{ws}/{repo}/pull-requests/{id}`
-          );
+          return mcpText(`\u274C Could not parse PR URL. Expected: bitbucket.org/{ws}/{repo}/pull-requests/{id}`);
         }
         const safeWs = sanitize(ws);
         const safeRepo = sanitize(repo);
@@ -36599,7 +36665,7 @@ ${diff}
           } else {
             const filePath = `/tmp/kit-pr-${prId}-${Date.now()}.diff`;
             try {
-              writeFileSync3(filePath, diff, "utf8");
+              writeFileSync4(filePath, diff, "utf8");
               output += `
 
 ### Diff
@@ -36672,12 +36738,9 @@ ${ticket.fields.labels?.join(", ") || "None"}`;
 }
 
 // src/tools/memory.ts
-import * as path10 from "path";
+import * as path14 from "path";
 
 // src/memory/embedder.ts
-import * as os2 from "os";
-import * as path7 from "path";
-var DEFAULT_CACHE_DIR = path7.join(os2.homedir(), ".cache", "fastembed");
 var EmbedderError = class extends Error {
   constructor(message, cause) {
     super(message);
@@ -36714,6 +36777,11 @@ var Embedder = class {
   isReady() {
     return this.pipeline !== null;
   }
+  async initialize() {
+    if (!this.pipeline) {
+      await this.loadModel();
+    }
+  }
   async loadModel() {
     try {
       const { EmbeddingModel, FlagEmbedding } = await import("fastembed");
@@ -36723,7 +36791,11 @@ var Embedder = class {
         "Xenova/all-MiniLM-L6-v2": EmbeddingModel.AllMiniLML6V2
       };
       const model = modelMap[this.modelName] ?? EmbeddingModel.BGESmallENV15;
-      const embedder = await FlagEmbedding.init({ model, cacheDir: DEFAULT_CACHE_DIR, showDownloadProgress: false });
+      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)) {
@@ -36740,13 +36812,18 @@ var Embedder = class {
 };
 
 // src/memory/indexer.ts
-import * as fs5 from "fs";
+import * as fs6 from "fs";
 import * as path8 from "path";
 
+// src/utils/hash.ts
+import { createHash } from "node:crypto";
+function sha256Hex(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+
 // src/memory/chunker.ts
-import { createHash } from "crypto";
 function computeChunkId(content) {
-  return createHash("sha256").update(content).digest("hex").slice(0, 16);
+  return sha256Hex(content).slice(0, 16);
 }
 function cleanContentForEmbedding(text) {
   return text.replace(/<!--[\s\S]*?-->/g, "");
@@ -36876,26 +36953,6 @@ ${sectionText}` : sectionText;
 }
 
 // src/memory/indexer.ts
-var LOCK_RETRY_MS = 50;
-var LOCK_TIMEOUT_MS = 500;
-async function acquireLock(lockPath) {
-  const deadline = Date.now() + LOCK_TIMEOUT_MS;
-  while (Date.now() < deadline) {
-    try {
-      fs5.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
-      return true;
-    } catch {
-      await new Promise((r) => setTimeout(r, LOCK_RETRY_MS));
-    }
-  }
-  return false;
-}
-function releaseLock(lockPath) {
-  try {
-    fs5.unlinkSync(lockPath);
-  } catch {
-  }
-}
 var MemoryIndexer = class {
   constructor(store, embedder, config2) {
     this.store = store;
@@ -36908,25 +36965,25 @@ var MemoryIndexer = class {
   }
   async indexFileRelativeTo(absolutePath, sourceRoot) {
     const source = path8.relative(sourceRoot, absolutePath);
-    const existingHashes = this.store.hashesBySource(source);
+    const existingChunkIds = this.store.hashesBySource(source);
     let text;
     try {
-      text = fs5.readFileSync(absolutePath, "utf8");
+      text = fs6.readFileSync(absolutePath, "utf8");
     } catch (err) {
       console.warn(`[memory-indexer] Cannot read file ${absolutePath}:`, err);
-      return { indexed: 0, deleted: 0, skipped: existingHashes.size };
+      return { indexed: 0, deleted: 0, skipped: existingChunkIds.size };
     }
     const allChunks = chunkMarkdown(text, source, this.config);
-    const newHashes = new Set(allChunks.map((c) => c.id));
-    const toIndex = allChunks.filter((c) => !existingHashes.has(c.id));
-    const toDelete = [...existingHashes].filter((h) => !newHashes.has(h));
+    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));
     let embeddings = [];
     if (toIndex.length > 0) {
       try {
         embeddings = await this.embedder.embed(toIndex.map((c) => c.content));
       } catch (err) {
         console.warn(`[memory-indexer] Embedding failed for ${absolutePath}:`, err);
-        return { indexed: 0, deleted: 0, skipped: existingHashes.size };
+        return { indexed: 0, deleted: 0, skipped: existingChunkIds.size };
       }
     }
     if (toIndex.length > 0) {
@@ -36943,14 +37000,14 @@ var MemoryIndexer = class {
   }
   async indexDirectory(rootDir, opts = {}) {
     const totals = { indexed: 0, deleted: 0, skipped: 0 };
-    if (!fs5.existsSync(rootDir)) return totals;
+    if (!fs6.existsSync(rootDir)) return totals;
     const relativeBase = opts.relativeBase ?? this.config.wikiDir;
     const excludeFiles = new Set(opts.excludeFiles ?? []);
     const files = [];
     const walk = (dirPath) => {
       let entries;
       try {
-        entries = fs5.readdirSync(dirPath, { withFileTypes: true });
+        entries = fs6.readdirSync(dirPath, { withFileTypes: true });
       } catch (err) {
         console.warn(`[memory-indexer] Cannot scan directory ${dirPath}:`, err);
         return;
@@ -36967,9 +37024,7 @@ var MemoryIndexer = class {
       }
     };
     walk(rootDir);
-    const currentSources = new Set(
-      files.map((file) => path8.relative(relativeBase, file))
-    );
+    const currentSources = new Set(files.map((file) => path8.relative(relativeBase, file)));
     for (const stale of this.store.indexedSources()) {
       if (!currentSources.has(stale)) {
         this.store.deleteBySource(stale);
@@ -37000,22 +37055,21 @@ var MemoryIndexer = class {
     if (bm25Ids.size > 0) {
       denseResults = denseResults.filter((result) => bm25Ids.has(result.id));
     }
-    const k = 60;
     const scoreMap = /* @__PURE__ */ new Map();
     denseResults.forEach((r, rank) => {
-      scoreMap.set(r.id, { dense: 1 / (k + rank + 1), bm25: 0 });
+      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 / (k + rank + 1);
+        existing.bm25 = 1 / (RRF_K + rank + 1);
       } else {
-        scoreMap.set(r.id, { dense: 0, bm25: 1 / (k + rank + 1) });
+        scoreMap.set(r.id, { dense: 0, bm25: 1 / (RRF_K + rank + 1) });
       }
     });
     const hasDense = this.store.vecAvailable && denseResults.length > 0;
     const numRetrievers = hasDense ? 2 : 1;
-    const maxScore = numRetrievers / 61;
+    const maxScore = numRetrievers / (RRF_K + 1);
     const ranked = [...scoreMap.entries()].map(([id, scores]) => ({
       id,
       totalScore: scores.dense + scores.bm25,
@@ -37036,7 +37090,7 @@ var MemoryIndexer = class {
       const retriever = r.hasDense && r.hasBm25 ? "both" : r.hasDense ? "dense" : "bm25";
       let contentSource = "file";
       try {
-        chunk.content = fs5.readFileSync(path8.join(this.config.wikiDir, chunk.source), "utf8");
+        chunk.content = fs6.readFileSync(path8.join(this.config.wikiDir, chunk.source), "utf8");
       } catch {
         contentSource = "fallback";
       }
@@ -37049,22 +37103,23 @@ var MemoryIndexer = class {
     const rawDir = path8.join(this.config.wikiDir, "raw");
     const savePath = path8.join(rawDir, `conv_save_${datePart}.md`);
     const lockPath = `${savePath}.lock`;
-    fs5.mkdirSync(rawDir, { recursive: true });
-    const acquired = await acquireLock(lockPath);
+    fs6.mkdirSync(rawDir, { recursive: true });
+    const acquired = await acquireLock(lockPath, LOCK_TIMEOUT_MS, LOCK_RETRY_MS);
     if (!acquired) {
       console.warn("[memory-indexer] Could not acquire write lock, writing anyway (fail-open)");
     }
     try {
-      fs5.appendFileSync(savePath, `
+      fs6.appendFileSync(savePath, `
 ${content}
 `, "utf8");
     } finally {
-      if (acquired) releaseLock(lockPath);
+      if (acquired) releaseLock(lockPath, { ignoreErrors: true });
     }
     return { indexed: 0, deleted: 0, skipped: 0 };
   }
   async startupIndex() {
     try {
+      await this.embedder.initialize();
       await this.indexDirectory(path8.join(this.config.wikiDir, "compiled"), {
         relativeBase: this.config.wikiDir,
         excludeFiles: ["index.md", "log.md"]
@@ -37083,7 +37138,7 @@ ${content}
 // src/memory/store.ts
 var import_stopword = __toESM(require_stopword_cjs(), 1);
 import Database from "better-sqlite3";
-import * as fs6 from "fs";
+import * as fs7 from "fs";
 import * as path9 from "path";
 var StoreError = class extends Error {
   constructor(message, cause) {
@@ -37095,7 +37150,7 @@ var StoreError = class extends Error {
 var MemoryStore = class {
   constructor(dbPath, config2) {
     this.config = config2;
-    fs6.mkdirSync(path9.dirname(dbPath), { recursive: true });
+    fs7.mkdirSync(path9.dirname(dbPath), { recursive: true });
     this.db = this.openDatabase(dbPath);
   }
   db;
@@ -37111,7 +37166,7 @@ var MemoryStore = class {
     } catch (err) {
       console.error("[memory-store] DB open failed, recreating:", err);
       try {
-        fs6.unlinkSync(dbPath);
+        fs7.unlinkSync(dbPath);
       } catch {
       }
       const db = new Database(dbPath);
@@ -37326,8 +37381,415 @@ var MemoryStore = class {
   }
 };
 
+// src/memory/digest/processor.ts
+import * as fs10 from "node:fs";
+import * as path13 from "node:path";
+
+// src/memory/digest/constants.ts
+import * as path10 from "node:path";
+var DEFAULT_DIGEST_MODEL_ID = "qwen2.5-1.5b-instruct-q4";
+var DEFAULT_DIGEST_MAX_INPUT_CHARS = 3e3;
+var DEFAULT_DIGEST_TIMEOUT_MS = 12e4;
+var KIT_DIR = ".agent-kit";
+var WIKI_DIR = path10.join(KIT_DIR, "wiki");
+var WIKI_RAW_DIR = path10.join(WIKI_DIR, "raw");
+var PROVISIONAL_DIGEST_DIR = path10.join(WIKI_DIR, "compiled", "provisional", "conversation-digests");
+var DIGEST_LOCKFILE_REL_PATH = path10.join(KIT_DIR, "digest-worker.lock");
+var LLAMA_CONTEXT_SIZE = 4096;
+var LLAMA_MAX_GENERATED_TOKENS = 512;
+var LLAMA_TEMPERATURE = 0.1;
+
+// src/memory/digest/files.ts
+import * as fs8 from "node:fs";
+import * as path11 from "node:path";
+function defaultProvisionalDigestDir(workspaceRoot2) {
+  return path11.join(workspaceRoot2, PROVISIONAL_DIGEST_DIR);
+}
+function readConversationDigestInput(workspaceRoot2, inputPath) {
+  const absoluteInput = path11.isAbsolute(inputPath) ? inputPath : path11.resolve(workspaceRoot2, inputPath);
+  const content = fs8.readFileSync(absoluteInput, "utf8");
+  return {
+    sourcePath: path11.relative(workspaceRoot2, absoluteInput),
+    content,
+    contentHash: sha256Hex(content)
+  };
+}
+function provisionalDigestPath(outDir, input) {
+  const safeName = path11.basename(input.sourcePath).replace(/\.[^.]+$/, "").replace(/[^a-z0-9._-]+/gi, "-");
+  return path11.join(outDir, `${input.contentHash.slice(0, 16)}-${safeName}.md`);
+}
+function findExistingProvisionalDigest(outDir, input) {
+  const markdownPath = provisionalDigestPath(outDir, input);
+  return fs8.existsSync(markdownPath) ? markdownPath : void 0;
+}
+function writeProvisionalDigestFile(outDir, input, markdown) {
+  const markdownPath = provisionalDigestPath(outDir, input);
+  atomicWriteTextFile(markdownPath, markdown);
+  return markdownPath;
+}
+function writeConversationDigestSettings(workspaceRoot2, digest) {
+  const current = loadProjectSettings(workspaceRoot2);
+  const memory = current.memory ?? {};
+  writeProjectSettings(workspaceRoot2, {
+    memory: {
+      ...memory,
+      enabled: memory.enabled ?? true,
+      conversationDigest: digest
+    }
+  });
+}
+
+// src/memory/digest/model-registry.ts
+var DigestModelRegistryError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DigestModelRegistryError";
+  }
+};
+var DIGEST_MODEL_REGISTRY = {
+  "qwen2.5-0.5b-instruct-q4": {
+    id: "qwen2.5-0.5b-instruct-q4",
+    ggufUri: "hf:bartowski/Qwen2.5-0.5B-Instruct-GGUF/Qwen2.5-0.5B-Instruct-Q4_K_M.gguf",
+    approxSizeBytes: 4e8,
+    license: "Apache-2.0",
+    sourceUrl: "https://huggingface.co/bartowski/Qwen2.5-0.5B-Instruct-GGUF",
+    enabled: true
+  },
+  "qwen2.5-1.5b-instruct-q4": {
+    id: "qwen2.5-1.5b-instruct-q4",
+    ggufUri: "hf:bartowski/Qwen2.5-1.5B-Instruct-GGUF/Qwen2.5-1.5B-Instruct-Q4_K_M.gguf",
+    approxSizeBytes: 1e9,
+    license: "Apache-2.0",
+    sourceUrl: "https://huggingface.co/bartowski/Qwen2.5-1.5B-Instruct-GGUF",
+    enabled: true
+  },
+  "qwen2.5-3b-instruct-q4": {
+    id: "qwen2.5-3b-instruct-q4",
+    ggufUri: "hf:bartowski/Qwen2.5-3B-Instruct-GGUF/Qwen2.5-3B-Instruct-Q4_K_M.gguf",
+    approxSizeBytes: 19e8,
+    license: "Apache-2.0",
+    sourceUrl: "https://huggingface.co/bartowski/Qwen2.5-3B-Instruct-GGUF",
+    enabled: true
+  }
+};
+function getDigestModelSpec(modelId) {
+  if (!modelId.trim()) {
+    throw new DigestModelRegistryError("Digest model id is required");
+  }
+  const spec = DIGEST_MODEL_REGISTRY[modelId];
+  if (!spec) {
+    throw new DigestModelRegistryError(`Unknown digest model: ${modelId}`);
+  }
+  if (spec.enabled !== true) {
+    throw new DigestModelRegistryError(`Digest model is disabled: ${modelId}`);
+  }
+  if (!spec.ggufUri || !spec.sourceUrl) {
+    throw new DigestModelRegistryError(`Digest model spec is incomplete: ${modelId}`);
+  }
+  return spec;
+}
+
+// src/memory/digest/providers/llama-local.ts
+import * as fs9 from "node:fs";
+import * as path12 from "node:path";
+import { getLlama, LlamaChatSession, createModelDownloader } from "node-llama-cpp";
+
+// src/utils/async.ts
+async function withTimeout(promise, timeoutMs, createError) {
+  let timer;
+  const timeout = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => {
+      reject(createError());
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([promise, timeout]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+// src/memory/digest/providers/llama-local.ts
+var LlamaLocalDigestProviderError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LlamaLocalDigestProviderError";
+  }
+};
+function titleFromSource(sourcePath) {
+  return path12.basename(sourcePath).replace(/\.[^.]+$/, "").replace(/[_-]+/g, " ");
+}
+function trimConversationExport(content, maxInputChars) {
+  const trimmed = content.trim();
+  if (trimmed.length <= maxInputChars) return trimmed;
+  return [
+    "[Earlier conversation content omitted to fit the local digest context window.]",
+    trimmed.slice(-maxInputChars)
+  ].join("\n\n");
+}
+function buildPrompt(input, maxInputChars) {
+  const conversationExport = trimConversationExport(input.content, maxInputChars);
+  const sourceName = path12.basename(input.sourcePath);
+  return [
+    {
+      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 ... ```)."
+      ].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">',
+        conversationExport,
+        "</conversation_export>"
+      ].join("\n")
+    }
+  ];
+}
+function stripCodeFence(text) {
+  const trimmed = text.trim();
+  const match = trimmed.match(/^```(?:markdown|md)?\s*\n([\s\S]*?)\n```$/i);
+  return match ? match[1].trim() : trimmed;
+}
+function sanitizeConversationDigestMarkdown(generatedText) {
+  return stripCodeFence(generatedText).trim() + "\n";
+}
+async function createLlamaLocalDigestProvider(modelId) {
+  const spec = getDigestModelSpec(modelId);
+  const modelCacheDir = path12.join(MODEL_CACHE_DIR, "llama");
+  fs9.mkdirSync(modelCacheDir, { recursive: true });
+  let modelFilePath;
+  try {
+    const downloader = await createModelDownloader({
+      modelUri: spec.ggufUri,
+      dirPath: modelCacheDir
+    });
+    modelFilePath = downloader.entrypointFilePath;
+    if (!fs9.existsSync(modelFilePath)) {
+      await downloader.download();
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new LlamaLocalDigestProviderError(`Failed to download model: ${message}`);
+  }
+  let llama;
+  let model;
+  try {
+    llama = await getLlama();
+    model = await llama.loadModel({ modelPath: modelFilePath });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new LlamaLocalDigestProviderError(`Failed to load model: ${message}`);
+  }
+  return {
+    id: "llama-local",
+    async dispose() {
+      await model.dispose();
+    },
+    async generateDigestMarkdown(input, options) {
+      const messages = buildPrompt(input, options.maxInputChars);
+      const systemContent = messages[0].content;
+      const userContent = messages[1].content;
+      const context = await model.createContext({ contextSize: LLAMA_CONTEXT_SIZE });
+      try {
+        const session = new LlamaChatSession({
+          contextSequence: context.getSequence(),
+          systemPrompt: systemContent
+        });
+        const response = await withTimeout(
+          session.prompt(userContent, {
+            maxTokens: LLAMA_MAX_GENERATED_TOKENS,
+            temperature: LLAMA_TEMPERATURE
+          }),
+          options.timeoutMs,
+          () => new LlamaLocalDigestProviderError(`Llama provider timed out after ${options.timeoutMs}ms`)
+        );
+        return sanitizeConversationDigestMarkdown(response);
+      } finally {
+        await context.dispose();
+      }
+    }
+  };
+}
+
+// src/memory/digest/processor.ts
+function digestLockPath(workspaceRoot2) {
+  return path13.join(workspaceRoot2, DIGEST_LOCKFILE_REL_PATH);
+}
+async function indexProvisionalDigestFile(workspaceRoot2, markdownPath) {
+  try {
+    const settings2 = loadProjectSettings(workspaceRoot2);
+    const config2 = resolveMemoryConfig(settings2, workspaceRoot2);
+    const store = new MemoryStore(path13.join(config2.wikiDir, "index.db"), config2);
+    const embedder = { embed: async (_texts) => [], initialize: async () => {
+    } };
+    const indexer = new MemoryIndexer(store, embedder, config2);
+    await indexer.indexFile(markdownPath);
+    return { indexed: true };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { indexed: false, error: message };
+  }
+}
+async function digestConversationFile(options) {
+  const outDir = options.outDir ? path13.resolve(options.workspaceRoot, options.outDir) : defaultProvisionalDigestDir(options.workspaceRoot);
+  const input = readConversationDigestInput(options.workspaceRoot, options.inputPath);
+  const existingPath = findExistingProvisionalDigest(outDir, input);
+  if (existingPath) {
+    const indexResult = await indexProvisionalDigestFile(options.workspaceRoot, existingPath);
+    return {
+      markdown: existingPath,
+      status: "provisional",
+      contentHash: input.contentHash,
+      skipped: true,
+      ...indexResult
+    };
+  }
+  const provider = await createLlamaLocalDigestProvider(options.modelId);
+  try {
+    const markdown = await provider.generateDigestMarkdown(input, {
+      modelId: options.modelId,
+      maxInputChars: options.maxInputChars ?? DEFAULT_DIGEST_MAX_INPUT_CHARS,
+      timeoutMs: options.timeoutMs ?? DEFAULT_DIGEST_TIMEOUT_MS
+    });
+    const markdownPath = writeProvisionalDigestFile(outDir, input, markdown);
+    const indexResult = await indexProvisionalDigestFile(options.workspaceRoot, markdownPath);
+    return {
+      markdown: markdownPath,
+      status: "provisional",
+      contentHash: input.contentHash,
+      skipped: false,
+      ...indexResult
+    };
+  } finally {
+    await provider.dispose?.();
+  }
+}
+async function digestPendingConversations({
+  workspaceRoot: workspaceRoot2,
+  digestFn = digestConversationFile
+}) {
+  const digestConfig = resolveConversationDigestConfig(loadProjectSettings(workspaceRoot2));
+  if (!digestConfig || digestConfig.enabled === false) {
+    return { ok: true, initialized: false, action: "noop", reason: "not-initialized" };
+  }
+  const lockPath = digestLockPath(workspaceRoot2);
+  if (!tryAcquireProcessLock(lockPath)) {
+    return { ok: true, initialized: true, action: "noop", reason: "locked" };
+  }
+  try {
+    const rawDir = path13.join(workspaceRoot2, WIKI_RAW_DIR);
+    let files;
+    try {
+      files = fs10.readdirSync(rawDir).filter((f) => f.startsWith("conv_") && f.endsWith(".md")).map((f) => path13.join(rawDir, f)).sort((a, b) => fs10.statSync(a).mtimeMs - fs10.statSync(b).mtimeMs);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        files = [];
+      } else {
+        throw err;
+      }
+    }
+    const outDir = defaultProvisionalDigestDir(workspaceRoot2);
+    const candidates = files.filter((f) => {
+      try {
+        const input = readConversationDigestInput(workspaceRoot2, f);
+        return !findExistingProvisionalDigest(outDir, input);
+      } catch {
+        return false;
+      }
+    });
+    if (candidates.length === 0) {
+      return { ok: true, initialized: true, action: "noop", reason: "no-pending" };
+    }
+    let count = 0;
+    let skipped = 0;
+    let errors = 0;
+    for (const filePath of candidates) {
+      try {
+        const result = await digestFn({
+          workspaceRoot: workspaceRoot2,
+          inputPath: filePath,
+          modelId: digestConfig.modelId
+        });
+        if (result.skipped) {
+          skipped++;
+        } else {
+          count++;
+        }
+      } catch {
+        errors++;
+      }
+    }
+    return { ok: true, initialized: true, action: "digested", count, skipped, errors };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, initialized: true, action: "error", error: message };
+  } finally {
+    releaseLock(lockPath);
+  }
+}
+async function initializeConversationDigestModel(input) {
+  try {
+    getDigestModelSpec(input.modelId);
+    if (input.allowDownload !== true) {
+      return {
+        initialized: false,
+        modelId: input.modelId,
+        error: "Digest model initialization requires explicit download permission"
+      };
+    }
+    const loadedProvider = await createLlamaLocalDigestProvider(input.modelId);
+    await loadedProvider?.dispose?.();
+    const initializedAt = (/* @__PURE__ */ new Date()).toISOString();
+    writeConversationDigestSettings(input.workspaceRoot, {
+      enabled: input.enabled ?? true,
+      initialized: true,
+      modelId: input.modelId,
+      initializedAt
+    });
+    await digestPendingConversations({ workspaceRoot: input.workspaceRoot });
+    return {
+      initialized: true,
+      modelId: input.modelId,
+      initializedAt
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      initialized: false,
+      modelId: input.modelId,
+      error: message
+    };
+  }
+}
+
 // src/tools/memory.ts
-function registerMemoryToolHandlers(server2, indexer, store, config2) {
+function registerMemoryToolHandlers(server2, indexer, store, config2, workspaceRoot2 = process.cwd()) {
   server2.tool(
     "kit_memory_search",
     "Search persistent memory for context relevant to the current question. Returns semantically relevant results using hybrid dense+BM25+RRF search.",
@@ -37377,14 +37839,42 @@ ${content}`;
       }
     }
   );
+  server2.tool(
+    "kit_memory_digest_init",
+    "Initialize or toggle local conversation digesting. Downloads/cache-loads the pinned local model only when explicitly invoked.",
+    {
+      model_id: external_exports.string().optional().describe("Digest model id"),
+      enabled: external_exports.boolean().optional().describe("Enable or disable conversation digesting")
+    },
+    async ({ model_id, enabled }) => {
+      try {
+        const existingConfig = resolveConversationDigestConfig(loadProjectSettings(workspaceRoot2));
+        const result = await initializeConversationDigestModel({
+          workspaceRoot: workspaceRoot2,
+          modelId: model_id ?? existingConfig?.modelId ?? DEFAULT_DIGEST_MODEL_ID,
+          allowDownload: true,
+          enabled
+        });
+        return mcpJson({
+          initialized: result.initialized,
+          model_id: result.modelId,
+          initialized_at: result.initializedAt,
+          error: result.error
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return mcpJson({ initialized: false, error: message });
+      }
+    }
+  );
 }
 function registerMemoryTools(server2, settings2, workspaceRoot2) {
   if (settings2.memory?.enabled !== true) return null;
   const config2 = resolveMemoryConfig(settings2, workspaceRoot2);
-  const store = new MemoryStore(path10.join(config2.wikiDir, "index.db"), config2);
+  const store = new MemoryStore(path14.join(config2.wikiDir, "index.db"), config2);
   const embedder = new Embedder(config2.embeddingModel);
   const indexer = new MemoryIndexer(store, embedder, config2);
-  registerMemoryToolHandlers(server2, indexer, store, config2);
+  registerMemoryToolHandlers(server2, indexer, store, config2, workspaceRoot2);
   return indexer;
 }