@hanhnd/agent-kit 1.0.32 → 1.0.34

package/dist/{kit-cli.js → cli.js}

@@ -14920,13 +14920,13 @@ var require_stopword_cjs = __commonJS({
   }
 });
 
-// src/memory/digest/processor.ts
+// src/services/digest/processor.ts
 import * as fs7 from "node:fs";
 import * as path9 from "node:path";
 
-// src/memory/digest/constants.ts
+// src/services/digest/constants.ts
 import * as path from "node:path";
-var DEFAULT_DIGEST_MODEL_ID = "qwen2.5-1.5b-instruct-q4";
+var DEFAULT_DIGEST_MODEL_ID = "default" /* DEFAULT */;
 var DEFAULT_DIGEST_MAX_INPUT_CHARS = 3e3;
 var DEFAULT_DIGEST_TIMEOUT_MS = 12e4;
 var DIGEST_TIMEOUT_GRACE_MS = 5e3;
@@ -14936,12 +14936,15 @@ var KIT_DIR = ".agent-kit";
 var WIKI_DIR = path.join(KIT_DIR, "wiki");
 var WIKI_RAW_DIR = path.join(WIKI_DIR, "raw");
 var PROVISIONAL_DIGEST_DIR = path.join(WIKI_DIR, "compiled", "provisional", "conversation-digests");
-var DIGEST_LOCKFILE_REL_PATH = path.join(KIT_DIR, "digest-worker.lock");
+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_MAX_GENERATED_TOKENS = 512;
 var LLAMA_TEMPERATURE = 0.1;
 
-// src/memory/digest/files.ts
+// src/services/digest/files.ts
 import * as fs3 from "node:fs";
 import * as path4 from "node:path";
 
@@ -15017,25 +15020,25 @@ function sha256Hex(content) {
   return createHash("sha256").update(content).digest("hex");
 }
 
-// src/tools/config.ts
+// src/core/config/index.ts
 import * as fs2 from "fs";
 import * as path3 from "path";
 
-// src/memory/constants.ts
+// src/services/memory/constants.ts
 var DEFAULT_MEMORY_CONFIG = {
   enabled: false,
   wikiDir: "",
   topK: 5,
   chunkSize: 1500,
   overlapLines: 2,
-  embeddingModel: "Xenova/bge-small-en-v1.5",
+  embeddingModel: "small" /* SMALL */,
   vectorDimension: 384
 };
 var LOCK_RETRY_MS = 50;
 var LOCK_TIMEOUT_MS = 500;
 var RRF_K = 60;
 
-// src/tools/config.ts
+// src/core/config/index.ts
 function resolveMemoryConfig(settings, workspaceRoot) {
   const override = settings.memory ?? {};
   return {
@@ -15074,7 +15077,7 @@ function resolveConversationDigestConfig(settings) {
   };
 }
 
-// src/memory/digest/files.ts
+// src/services/digest/files.ts
 function defaultProvisionalDigestDir(workspaceRoot) {
   return path4.join(workspaceRoot, PROVISIONAL_DIGEST_DIR);
 }
@@ -15112,7 +15115,7 @@ function writeConversationDigestSettings(workspaceRoot, digest) {
   });
 }
 
-// src/memory/digest/model-registry.ts
+// src/services/digest/model-registry.ts
 var DigestModelRegistryError = class extends Error {
   constructor(message) {
     super(message);
@@ -15120,24 +15123,24 @@ var DigestModelRegistryError = class extends Error {
   }
 };
 var DIGEST_MODEL_REGISTRY = {
-  "qwen2.5-0.5b-instruct-q4": {
-    id: "qwen2.5-0.5b-instruct-q4",
+  ["tiny" /* TINY */]: {
+    id: "tiny" /* TINY */,
     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",
+  ["default" /* DEFAULT */]: {
+    id: "default" /* DEFAULT */,
     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",
+  ["large" /* LARGE */]: {
+    id: "large" /* LARGE */,
     ggufUri: "hf:bartowski/Qwen2.5-3B-Instruct-GGUF/Qwen2.5-3B-Instruct-Q4_K_M.gguf",
     approxSizeBytes: 19e8,
     license: "Apache-2.0",
@@ -15162,7 +15165,7 @@ function getDigestModelSpec(modelId) {
   return spec;
 }
 
-// src/memory/digest/providers/llama-local.ts
+// src/services/digest/providers/llama-local.ts
 import * as fs4 from "node:fs";
 import * as path6 from "node:path";
 import { getLlama, LlamaChatSession, createModelDownloader } from "node-llama-cpp";
@@ -15190,7 +15193,7 @@ var CREDENTIALS_FILE = path5.join(AGENT_KIT_HOME, "credentials");
 var MODEL_CACHE_DIR = path5.join(AGENT_KIT_HOME, "cache", "models");
 var FASTEMBED_CACHE_DIR = path5.join(MODEL_CACHE_DIR, "fastembed");
 
-// src/memory/digest/providers/llama-local.ts
+// src/services/digest/providers/llama-local.ts
 var LlamaLocalDigestProviderError = class extends Error {
   constructor(message) {
     super(message);
@@ -15210,7 +15213,6 @@ function trimConversationExport(content, maxInputChars) {
 }
 function buildPrompt(input, maxInputChars) {
   const conversationExport = trimConversationExport(input.content, maxInputChars);
-  const sourceName = path6.basename(input.sourcePath);
   return [
     {
       role: "system",
@@ -15318,7 +15320,7 @@ async function createLlamaLocalDigestProvider(modelId) {
   };
 }
 
-// src/memory/store.ts
+// src/services/memory/store.ts
 var import_stopword = __toESM(require_stopword_cjs(), 1);
 import Database from "better-sqlite3";
 import * as fs5 from "fs";
@@ -15564,11 +15566,11 @@ var MemoryStore = class {
   }
 };
 
-// src/memory/indexer.ts
+// src/services/memory/indexer.ts
 import * as fs6 from "fs";
 import * as path8 from "path";
 
-// src/memory/chunker.ts
+// src/services/memory/chunker.ts
 function computeChunkId(content) {
   return sha256Hex(content).slice(0, 16);
 }
@@ -15699,7 +15701,7 @@ ${sectionText}` : sectionText;
   return chunks;
 }
 
-// src/memory/indexer.ts
+// src/services/memory/indexer.ts
 var MemoryIndexer = class {
   constructor(store, embedder, config) {
     this.store = store;
@@ -15882,10 +15884,32 @@ ${content}
   }
 };
 
-// src/memory/digest/processor.ts
+// src/services/digest/processor.ts
 function digestLockPath(workspaceRoot) {
   return path9.join(workspaceRoot, DIGEST_LOCKFILE_REL_PATH);
 }
+function discoverPendingConversationFiles(workspaceRoot) {
+  const rawDir = path9.join(workspaceRoot, WIKI_RAW_DIR);
+  let files;
+  try {
+    files = fs7.readdirSync(rawDir).filter((f) => f.startsWith("conv_") && f.endsWith(".md")).map((f) => path9.join(rawDir, f)).sort((a, b) => fs7.statSync(a).mtimeMs - fs7.statSync(b).mtimeMs);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      files = [];
+    } else {
+      throw err;
+    }
+  }
+  const outDir = defaultProvisionalDigestDir(workspaceRoot);
+  return files.filter((f) => {
+    try {
+      const input = readConversationDigestInput(workspaceRoot, f);
+      return !findExistingProvisionalDigest(outDir, input);
+    } catch {
+      return false;
+    }
+  });
+}
 async function indexProvisionalDigestFile(workspaceRoot, markdownPath) {
   try {
     const settings = loadProjectSettings(workspaceRoot);
@@ -15935,9 +15959,21 @@ async function digestConversationFile(options) {
     await provider.dispose?.();
   }
 }
+function summarizePendingConversations(workspaceRoot) {
+  const digestConfig = resolveConversationDigestConfig(loadProjectSettings(workspaceRoot));
+  if (!digestConfig || digestConfig.enabled === false) {
+    return { initialized: false, pending: 0, reason: "not-initialized" };
+  }
+  const candidates = discoverPendingConversationFiles(workspaceRoot);
+  if (candidates.length === 0) {
+    return { initialized: true, pending: 0, reason: "no-pending" };
+  }
+  return { initialized: true, pending: candidates.length };
+}
 async function digestPendingConversations({
   workspaceRoot,
-  digestFn = digestConversationFile
+  digestFn = digestConversationFile,
+  onProgress
 }) {
   const digestConfig = resolveConversationDigestConfig(loadProjectSettings(workspaceRoot));
   if (!digestConfig || digestConfig.enabled === false) {
@@ -15948,26 +15984,7 @@ async function digestPendingConversations({
     return { ok: true, initialized: true, action: "noop", reason: "locked" };
   }
   try {
-    const rawDir = path9.join(workspaceRoot, WIKI_RAW_DIR);
-    let files;
-    try {
-      files = fs7.readdirSync(rawDir).filter((f) => f.startsWith("conv_") && f.endsWith(".md")).map((f) => path9.join(rawDir, f)).sort((a, b) => fs7.statSync(a).mtimeMs - fs7.statSync(b).mtimeMs);
-    } catch (err) {
-      if (err.code === "ENOENT") {
-        files = [];
-      } else {
-        throw err;
-      }
-    }
-    const outDir = defaultProvisionalDigestDir(workspaceRoot);
-    const candidates = files.filter((f) => {
-      try {
-        const input = readConversationDigestInput(workspaceRoot, f);
-        return !findExistingProvisionalDigest(outDir, input);
-      } catch {
-        return false;
-      }
-    });
+    const candidates = discoverPendingConversationFiles(workspaceRoot);
     if (candidates.length === 0) {
       return { ok: true, initialized: true, action: "noop", reason: "no-pending" };
     }
@@ -15989,6 +16006,9 @@ async function digestPendingConversations({
       } catch {
         errors++;
       }
+      if (onProgress) {
+        await onProgress({ processed: count, skipped, errors });
+      }
     }
     return { ok: true, initialized: true, action: "digested", count, skipped, errors };
   } catch (err) {
@@ -16033,10 +16053,262 @@ async function initializeConversationDigestModel(input) {
   }
 }
 
-// src/memory/digest/worker.ts
+// src/services/digest/background.ts
+import * as fs8 from "node:fs";
+import * as path10 from "node:path";
+import { spawn } from "node:child_process";
+
+// src/utils/json.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/services/digest/background.ts
+function digestWorkerStatusPath(workspaceRoot) {
+  return path10.join(workspaceRoot, DIGEST_WORKER_STATUS_REL_PATH);
+}
+function digestWorkerLogPath(workspaceRoot) {
+  return path10.join(workspaceRoot, DIGEST_WORKER_LOG_REL_PATH);
+}
+function digestWorkerLockPath(workspaceRoot) {
+  return path10.join(workspaceRoot, DIGEST_LOCKFILE_REL_PATH);
+}
+function isoNow() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function emptyStatus(state, pendingAtStart, startedAt = isoNow()) {
+  return {
+    state,
+    pid: null,
+    startedAt,
+    updatedAt: startedAt,
+    pendingAtStart,
+    processed: 0,
+    skipped: 0,
+    errors: 0
+  };
+}
+var WORKER_STATES = /* @__PURE__ */ new Set([
+  "running",
+  "complete",
+  "failed",
+  "not-initialized",
+  "no-pending",
+  "locked",
+  "stale"
+]);
+function isDigestWorkerStatus(value) {
+  if (!isRecord(value)) return false;
+  return typeof value.state === "string" && WORKER_STATES.has(value.state) && (typeof value.pid === "number" || value.pid === null) && typeof value.startedAt === "string" && typeof value.updatedAt === "string" && typeof value.pendingAtStart === "number" && typeof value.processed === "number" && typeof value.skipped === "number" && typeof value.errors === "number" && (value.lastError === void 0 || typeof value.lastError === "string");
+}
+function readDigestWorkerStatus(workspaceRoot) {
+  try {
+    const parsed = JSON.parse(fs8.readFileSync(digestWorkerStatusPath(workspaceRoot), "utf8"));
+    return isDigestWorkerStatus(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function writeDigestWorkerStatus(workspaceRoot, status) {
+  atomicWriteJsonFile(digestWorkerStatusPath(workspaceRoot), status);
+}
+function appendDigestWorkerLog(workspaceRoot, message) {
+  try {
+    const logPath = digestWorkerLogPath(workspaceRoot);
+    fs8.mkdirSync(path10.dirname(logPath), { recursive: true });
+    fs8.appendFileSync(logPath, `[${isoNow()}] ${message}
+`, "utf8");
+  } catch {
+  }
+}
+function isLivePid(pid) {
+  if (pid === null || !Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code !== "ESRCH";
+  }
+}
+function readLockPid(workspaceRoot) {
+  const lockPath = digestWorkerLockPath(workspaceRoot);
+  if (!fs8.existsSync(lockPath)) return void 0;
+  try {
+    const parsed = JSON.parse(fs8.readFileSync(lockPath, "utf8"));
+    return isRecord(parsed) && typeof parsed.pid === "number" ? parsed.pid : null;
+  } catch {
+    return null;
+  }
+}
+function statusFromPendingResult(result, startedAt, pendingAtStart) {
+  const updatedAt = isoNow();
+  if (!result.ok) {
+    return {
+      ...emptyStatus("failed", pendingAtStart, startedAt),
+      updatedAt,
+      errors: 1,
+      lastError: result.error
+    };
+  }
+  if (result.action === "digested") {
+    return {
+      state: "complete",
+      pid: null,
+      startedAt,
+      updatedAt,
+      pendingAtStart,
+      processed: result.count,
+      skipped: result.skipped,
+      errors: result.errors
+    };
+  }
+  return {
+    ...emptyStatus(result.reason, pendingAtStart, startedAt),
+    updatedAt
+  };
+}
+async function runDigestPendingWorker(input) {
+  const startedAt = isoNow();
+  let pendingAtStart = input.pendingAtStart ?? 0;
+  try {
+    const summary = summarizePendingConversations(input.workspaceRoot);
+    if (input.pendingAtStart === void 0) {
+      pendingAtStart = summary.initialized ? summary.pending : 0;
+    }
+    const runningStatus = {
+      ...emptyStatus("running", pendingAtStart, startedAt),
+      pid: process.pid
+    };
+    writeDigestWorkerStatus(input.workspaceRoot, runningStatus);
+    appendDigestWorkerLog(input.workspaceRoot, `worker started pid=${process.pid} pending=${pendingAtStart}`);
+    const result = await digestPendingConversations({
+      workspaceRoot: input.workspaceRoot,
+      digestFn: input.digestFn,
+      onProgress: (progress) => {
+        const currentStatus = {
+          ...runningStatus,
+          updatedAt: isoNow(),
+          processed: progress.processed,
+          skipped: progress.skipped,
+          errors: progress.errors
+        };
+        writeDigestWorkerStatus(input.workspaceRoot, currentStatus);
+      }
+    });
+    const status = statusFromPendingResult(result, startedAt, pendingAtStart);
+    writeDigestWorkerStatus(input.workspaceRoot, status);
+    appendDigestWorkerLog(
+      input.workspaceRoot,
+      `worker finished state=${status.state} processed=${status.processed} skipped=${status.skipped} errors=${status.errors}`
+    );
+    return status;
+  } catch (err) {
+    const status = {
+      ...emptyStatus("failed", pendingAtStart, startedAt),
+      updatedAt: isoNow(),
+      errors: 1,
+      lastError: errorMessage(err)
+    };
+    writeDigestWorkerStatus(input.workspaceRoot, status);
+    appendDigestWorkerLog(input.workspaceRoot, `worker failed error=${status.lastError}`);
+    return status;
+  }
+}
+function launchDigestPendingWorker(input) {
+  const startedAt = isoNow();
+  let pendingAtStart = 0;
+  try {
+    const previousStatus = readDigestWorkerStatus(input.workspaceRoot);
+    if (previousStatus?.state === "running" && isLivePid(previousStatus.pid)) {
+      const status2 = {
+        ...previousStatus,
+        state: "locked",
+        updatedAt: isoNow(),
+        lastError: void 0
+      };
+      writeDigestWorkerStatus(input.workspaceRoot, status2);
+      return { ok: true, mode: "background-launcher", status: status2, spawned: false, reason: "locked" };
+    }
+    const lockPid = readLockPid(input.workspaceRoot);
+    if (lockPid !== void 0 && isLivePid(lockPid)) {
+      const status2 = emptyStatus("locked", 0, startedAt);
+      writeDigestWorkerStatus(input.workspaceRoot, status2);
+      return { ok: true, mode: "background-launcher", status: status2, spawned: false, reason: "locked" };
+    }
+    const summary = summarizePendingConversations(input.workspaceRoot);
+    if (!summary.initialized) {
+      const status2 = emptyStatus("not-initialized", 0, startedAt);
+      writeDigestWorkerStatus(input.workspaceRoot, status2);
+      return { ok: true, mode: "background-launcher", status: status2, spawned: false, reason: "not-initialized" };
+    }
+    if (summary.pending === 0) {
+      const status2 = emptyStatus("no-pending", 0, startedAt);
+      writeDigestWorkerStatus(input.workspaceRoot, status2);
+      return { ok: true, mode: "background-launcher", status: status2, spawned: false, reason: "no-pending" };
+    }
+    pendingAtStart = summary.pending;
+    if (!input.entrypoint) {
+      const status2 = {
+        ...emptyStatus("failed", pendingAtStart, startedAt),
+        errors: 1,
+        lastError: "CLI entrypoint is unavailable"
+      };
+      writeDigestWorkerStatus(input.workspaceRoot, status2);
+      return {
+        ok: false,
+        mode: "background-launcher",
+        status: status2,
+        spawned: false,
+        reason: "spawn-failed",
+        error: status2.lastError
+      };
+    }
+    const child = spawn(
+      process.execPath,
+      [input.entrypoint, "memory", "digest-pending", ...input.args, `--${DIGEST_WORKER_FLAG}`],
+      {
+        cwd: input.workspaceRoot,
+        detached: true,
+        stdio: "ignore"
+      }
+    );
+    child.unref();
+    if (!child.pid) {
+      throw new Error("worker process did not expose a pid");
+    }
+    const status = {
+      ...emptyStatus("running", pendingAtStart, startedAt),
+      pid: child.pid
+    };
+    writeDigestWorkerStatus(input.workspaceRoot, status);
+    appendDigestWorkerLog(input.workspaceRoot, `launcher spawned pid=${child.pid} pending=${pendingAtStart}`);
+    return { ok: true, mode: "background-launcher", status, spawned: true, pid: child.pid };
+  } catch (err) {
+    const status = {
+      ...emptyStatus("failed", pendingAtStart, startedAt),
+      errors: 1,
+      lastError: errorMessage(err)
+    };
+    writeDigestWorkerStatus(input.workspaceRoot, status);
+    appendDigestWorkerLog(input.workspaceRoot, `launcher failed error=${status.lastError}`);
+    return {
+      ok: false,
+      mode: "background-launcher",
+      status,
+      spawned: false,
+      reason: "spawn-failed",
+      error: status.lastError
+    };
+  }
+}
+
+// src/services/digest/worker.ts
 import { spawnSync } from "node:child_process";
 
-// src/utils/args.ts
+// src/cli/utils/args.ts
 function parseArgs(args) {
   const flags = /* @__PURE__ */ new Map();
   const positionals = [];
@@ -16069,7 +16341,7 @@ function numberFlag(flags, key, defaultValue) {
   return value;
 }
 
-// src/memory/digest/worker.ts
+// src/services/digest/worker.ts
 function isDigestWorkerResult(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
   const record = value;
@@ -16116,7 +16388,7 @@ 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();
 }
 
-// src/cli/memory.ts
+// src/cli/commands/memory.ts
 function writeDigestFileResult(result, workerMode) {
   if (workerMode) {
     process.stdout.write(DIGEST_WORKER_RESULT_PREFIX + JSON.stringify(result) + "\n");
@@ -16145,7 +16417,7 @@ async function cmdDigestFile(args) {
   const modelId = stringFlag(parsed.flags, "model") ?? digestConfig?.modelId ?? DEFAULT_DIGEST_MODEL_ID;
   const inputPath = stringFlag(parsed.flags, "input");
   if (!inputPath) {
-    process.stderr.write("Usage: agent-kit-cli memory digest-file --input <path> --model <id>\n");
+    process.stderr.write("Usage: cli memory digest-file --input <path> --model <id>\n");
     return 1;
   }
   const result = await digestConversationFile({
@@ -16161,11 +16433,23 @@ async function cmdDigestFile(args) {
 }
 async function cmdDigestPending(args) {
   const parsed = parseArgs(args);
-  if (parsed.flags.get("hook") !== true) {
-    process.stderr.write("Usage: agent-kit-cli memory digest-pending --hook\n");
-    return 1;
+  const workspaceRoot = getWorkspaceRoot();
+  const isBackground = parsed.flags.get("background") === true;
+  if (isBackground && parsed.flags.get(DIGEST_WORKER_FLAG) === true) {
+    const result2 = await runDigestPendingWorker({ workspaceRoot });
+    process.stdout.write(JSON.stringify(result2) + "\n");
+    return 0;
+  }
+  if (isBackground) {
+    const result2 = launchDigestPendingWorker({
+      workspaceRoot,
+      args,
+      entrypoint: process.argv[1]
+    });
+    process.stdout.write(JSON.stringify(result2) + "\n");
+    return 0;
   }
-  const result = await digestPendingConversations({ workspaceRoot: getWorkspaceRoot() });
+  const result = await digestPendingConversations({ workspaceRoot });
   process.stdout.write(JSON.stringify(result) + "\n");
   return 0;
 }
@@ -16180,7 +16464,7 @@ async function runMemoryCli(args, _env) {
     process.stderr.write("[agent-kit] memory " + (command ?? "") + " failed: " + message + "\n");
     return 1;
   }
-  process.stderr.write("Usage: agent-kit-cli memory <digest-file|digest-init|digest-pending>\n");
+  process.stderr.write("Usage: cli memory <digest-file|digest-init|digest-pending>\n");
   return 1;
 }
 
@@ -16190,11 +16474,11 @@ async function runAgentKitCli(argv, env) {
   if (command === "memory") {
     return runMemoryCli(rest, env);
   }
-  process.stderr.write("Usage: agent-kit-cli memory <digest-file|digest-init|digest-pending>\n");
+  process.stderr.write("Usage: cli memory <digest-file|digest-init|digest-pending>\n");
   return 1;
 }
 
-// src/kit-cli.ts
+// src/entrypoints/cli.ts
 try {
   const exitCode = await runAgentKitCli(process.argv.slice(2), process.env);
   process.exit(exitCode);

package/dist/{tools/config.d.ts → core/config/index.d.ts}

@@ -2,8 +2,8 @@
  * Configuration utilities
  * Shared configuration constants and loaders
  */
-import type { MemoryConfig } from '../memory/types.js';
-import type { ConversationDigestSettings } from '../memory/digest/types.js';
+import type { MemoryConfig } from '../../services/memory/types.js';
+import type { ConversationDigestSettings } from '../../services/digest/types.js';
 /**
  * Default file extensions - expanded to support more languages
  * Used by kit_get_project_context and other tools
@@ -22,11 +22,6 @@ export { MemoryConfig };
  * Merge DEFAULT_MEMORY_CONFIG with settings.memory; resolve wikiDir when not explicitly set.
  */
 export declare function resolveMemoryConfig(settings: ProjectSettings, workspaceRoot: string): MemoryConfig;
-/**
- * Get file extensions - from settings.json or defaults
- * Allows project-specific customization
- */
-export declare function getFileExtensions(projectDir: string): string[];
 export declare function loadProjectSettings(projectDir: string): ProjectSettings;
 export declare function writeProjectSettings(workspaceRoot: string, patch: Partial<ProjectSettings>): void;
 export declare function resolveConversationDigestConfig(settings: ProjectSettings): ConversationDigestSettings | undefined;

package/dist/{tools/config.js → core/config/index.js}

@@ -4,8 +4,8 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
-import { DEFAULT_MEMORY_CONFIG } from '../memory/constants.js';
-import { atomicWriteJsonFile } from '../utils/files.js';
+import { DEFAULT_MEMORY_CONFIG } from '../../services/memory/constants.js';
+import { atomicWriteJsonFile } from '../../utils/files.js';
 /**
  * Default file extensions - expanded to support more languages
  * Used by kit_get_project_context and other tools
@@ -48,17 +48,6 @@ export function resolveMemoryConfig(settings, workspaceRoot) {
             : path.join(workspaceRoot, '.agent-kit', 'wiki'),
     };
 }
-/**
- * Get file extensions - from settings.json or defaults
- * Allows project-specific customization
- */
-export function getFileExtensions(projectDir) {
-    const settings = loadProjectSettings(projectDir);
-    if (settings.fileExtensions && Array.isArray(settings.fileExtensions)) {
-        return settings.fileExtensions;
-    }
-    return DEFAULT_EXTENSIONS;
-}
 export function loadProjectSettings(projectDir) {
     const settingsPath = path.join(projectDir, '.agent-kit', 'settings.json');
     if (fs.existsSync(settingsPath)) {

package/dist/core/handoffs/index.d.ts

@@ -0,0 +1,17 @@
+export declare const HANDOFF_TYPES: readonly ["brainstorm", "clarification", "plan", "ticket", "research", "scenario", "investigation", "code"];
+type HandoffType = (typeof HANDOFF_TYPES)[number];
+type CanonicalHandoffType = 'brainstorm' | 'clarification' | 'plan' | 'ticket' | 'research' | 'scenario' | 'investigation' | 'code';
+export interface SavedHandoffFolderLocation {
+    featureSlug: string;
+    canonicalType: CanonicalHandoffType;
+    folderPath: string;
+    relativePath: string;
+}
+export declare function resolveHandoffFolder(input: {
+    workspaceRoot: string;
+    type: HandoffType;
+    slug: string;
+    primaryContent: string;
+}): SavedHandoffFolderLocation;
+export declare function validateHandoffFilename(name: string): string;
+export {};