@hanhnd/agent-kit 1.0.32 → 1.0.33

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

@@ -35883,7 +35883,7 @@ var StdioServerTransport = class {
   }
 };
 
-// src/tools/core.ts
+// src/mcp/core.ts
 import * as fs3 from "fs";
 import * as path4 from "path";
 
@@ -35898,18 +35898,18 @@ function mcpJson(obj) {
   return mcpText(JSON.stringify(obj, null, 2));
 }
 
-// src/tools/config.ts
+// src/core/config/index.ts
 import * as fs2 from "fs";
 import * as path2 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;
@@ -35982,7 +35982,7 @@ function tryAcquireProcessLock(lockPath) {
   return tryWriteFileExclusive(lockPath, lockContent);
 }
 
-// src/tools/config.ts
+// src/core/config/index.ts
 function resolveMemoryConfig(settings2, workspaceRoot2) {
   const override = settings2.memory ?? {};
   return {
@@ -36053,7 +36053,7 @@ var FORBIDDEN_PATTERNS = [
 ];
 var FORBIDDEN_DIRS = [".git", ".ssh", ".aws", ".kube", ".gnupg", ".docker"];
 
-// src/tools/handoffs.ts
+// src/core/handoffs/index.ts
 import * as path3 from "path";
 var HANDOFF_TYPES = [
   "brainstorm",
@@ -36106,7 +36106,7 @@ function resolveHandoffPath(input) {
   };
 }
 
-// src/tools/core.ts
+// src/mcp/core.ts
 function registerCoreTools(server2) {
   server2.tool(
     "kit_save_handoff",
@@ -36139,13 +36139,13 @@ function registerCoreTools(server2) {
   );
 }
 
-// src/tools/agent.ts
+// src/mcp/agent.ts
 import { spawn } from "child_process";
 import { randomUUID } from "crypto";
 import * as fs4 from "fs";
 import * as path6 from "path";
 
-// src/tools/security.ts
+// src/core/security/index.ts
 import { execFileSync } from "child_process";
 import * as path5 from "path";
 function sanitize(input) {
@@ -36171,7 +36171,6 @@ function validatePath(filePath, baseDir = process.cwd()) {
   }
   return resolved;
 }
-var GIT_TIMEOUT = parseInt(process.env.GEMINI_KIT_GIT_TIMEOUT || "30000", 10);
 function commandExists(cmd) {
   try {
     const checkCmd = process.platform === "win32" ? "where" : "which";
@@ -36196,7 +36195,7 @@ function sanitizeOutput(text) {
     // AWS access keys
     /xox[baprs]-[A-Za-z0-9-]{10,}/g,
     // Slack tokens
-    /[Aa]tlassian[_\-]?[Aa][Pp][Ii][_\-]?[Tt]oken[^\s]*\s*[:=]\s*\S+/g
+    /[Aa]tlassian[_-]?[Aa][Pp][Ii][_-]?[Tt]oken[^\s]*\s*[:=]\s*\S+/g
     // Atlassian token patterns
   ];
   let sanitized = text;
@@ -36206,7 +36205,7 @@ function sanitizeOutput(text) {
   return sanitized;
 }
 
-// src/tools/agent.ts
+// src/mcp/agent.ts
 var AGENT_TIMEOUT = parseInt(process.env.KIT_AGENT_TIMEOUT || "300000", 10);
 var jobRegistry = /* @__PURE__ */ new Map();
 var INSTALL_HINTS = {
@@ -36356,10 +36355,10 @@ function registerAgentTools(server2) {
   );
 }
 
-// src/tools/integration.ts
+// src/mcp/integration.ts
 import { writeFileSync as writeFileSync4 } from "fs";
 
-// src/utils/credentials.ts
+// src/services/integration/credentials.ts
 import * as fs5 from "fs";
 
 // src/utils/paths.ts
@@ -36370,7 +36369,7 @@ 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
+// src/services/integration/credentials.ts
 var cachedCredentials = null;
 function parseIni(content) {
   const result = {};
@@ -36429,7 +36428,7 @@ function getCredential(key) {
   return loadCredentials()[key];
 }
 
-// src/utils/parser.ts
+// src/services/integration/parser/adf.ts
 function adfToMarkdown(adf) {
   if (!adf || typeof adf !== "object") return "No description";
   const content = adf.content;
@@ -36551,7 +36550,7 @@ ${renderNodes(node.content, listDepth, node.type).trim()}
   return renderNodes(content).trim() || "No description";
 }
 
-// src/tools/integration.ts
+// src/mcp/integration.ts
 var BitbucketPrSchema = external_exports.object({
   id: external_exports.number(),
   title: external_exports.string(),
@@ -36737,10 +36736,10 @@ ${ticket.fields.labels?.join(", ") || "None"}`;
   );
 }
 
-// src/tools/memory.ts
+// src/mcp/memory.ts
 import * as path14 from "path";
 
-// src/memory/embedder.ts
+// src/services/memory/embedder.ts
 var EmbedderError = class extends Error {
   constructor(message, cause) {
     super(message);
@@ -36786,9 +36785,9 @@ var Embedder = class {
     try {
       const { EmbeddingModel, FlagEmbedding } = await import("fastembed");
       const modelMap = {
-        "Xenova/bge-small-en-v1.5": EmbeddingModel.BGESmallENV15,
-        "Xenova/bge-base-en-v1.5": EmbeddingModel.BGEBaseENV15,
-        "Xenova/all-MiniLM-L6-v2": EmbeddingModel.AllMiniLML6V2
+        ["tiny" /* TINY */]: EmbeddingModel.AllMiniLML6V2,
+        ["small" /* SMALL */]: EmbeddingModel.BGESmallENV15,
+        ["large" /* LARGE */]: EmbeddingModel.BGEBaseENV15
       };
       const model = modelMap[this.modelName] ?? EmbeddingModel.BGESmallENV15;
       const embedder = await FlagEmbedding.init({
@@ -36811,7 +36810,7 @@ var Embedder = class {
   }
 };
 
-// src/memory/indexer.ts
+// src/services/memory/indexer.ts
 import * as fs6 from "fs";
 import * as path8 from "path";
 
@@ -36821,7 +36820,7 @@ function sha256Hex(content) {
   return createHash("sha256").update(content).digest("hex");
 }
 
-// src/memory/chunker.ts
+// src/services/memory/chunker.ts
 function computeChunkId(content) {
   return sha256Hex(content).slice(0, 16);
 }
@@ -36952,7 +36951,7 @@ ${sectionText}` : sectionText;
   return chunks;
 }
 
-// src/memory/indexer.ts
+// src/services/memory/indexer.ts
 var MemoryIndexer = class {
   constructor(store, embedder, config2) {
     this.store = store;
@@ -37135,7 +37134,7 @@ ${content}
   }
 };
 
-// src/memory/store.ts
+// src/services/memory/store.ts
 var import_stopword = __toESM(require_stopword_cjs(), 1);
 import Database from "better-sqlite3";
 import * as fs7 from "fs";
@@ -37381,25 +37380,28 @@ var MemoryStore = class {
   }
 };
 
-// src/memory/digest/processor.ts
+// src/services/digest/processor.ts
 import * as fs10 from "node:fs";
 import * as path13 from "node:path";
 
-// src/memory/digest/constants.ts
+// src/services/digest/constants.ts
 import * as path10 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 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 DIGEST_WORKER_DIR = path10.join(WIKI_DIR, "digest");
+var DIGEST_LOCKFILE_REL_PATH = path10.join(DIGEST_WORKER_DIR, "digest-worker.lock");
+var DIGEST_WORKER_STATUS_REL_PATH = path10.join(DIGEST_WORKER_DIR, "digest-worker.status.json");
+var DIGEST_WORKER_LOG_REL_PATH = path10.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 fs8 from "node:fs";
 import * as path11 from "node:path";
 function defaultProvisionalDigestDir(workspaceRoot2) {
@@ -37439,7 +37441,7 @@ function writeConversationDigestSettings(workspaceRoot2, digest) {
   });
 }
 
-// src/memory/digest/model-registry.ts
+// src/services/digest/model-registry.ts
 var DigestModelRegistryError = class extends Error {
   constructor(message) {
     super(message);
@@ -37447,24 +37449,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",
@@ -37489,7 +37491,7 @@ function getDigestModelSpec(modelId) {
   return spec;
 }
 
-// src/memory/digest/providers/llama-local.ts
+// src/services/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";
@@ -37509,7 +37511,7 @@ async function withTimeout(promise, timeoutMs, createError) {
   }
 }
 
-// src/memory/digest/providers/llama-local.ts
+// src/services/digest/providers/llama-local.ts
 var LlamaLocalDigestProviderError = class extends Error {
   constructor(message) {
     super(message);
@@ -37529,7 +37531,6 @@ function trimConversationExport(content, maxInputChars) {
 }
 function buildPrompt(input, maxInputChars) {
   const conversationExport = trimConversationExport(input.content, maxInputChars);
-  const sourceName = path12.basename(input.sourcePath);
   return [
     {
       role: "system",
@@ -37637,10 +37638,32 @@ async function createLlamaLocalDigestProvider(modelId) {
   };
 }
 
-// src/memory/digest/processor.ts
+// src/services/digest/processor.ts
 function digestLockPath(workspaceRoot2) {
   return path13.join(workspaceRoot2, DIGEST_LOCKFILE_REL_PATH);
 }
+function discoverPendingConversationFiles(workspaceRoot2) {
+  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);
+  return files.filter((f) => {
+    try {
+      const input = readConversationDigestInput(workspaceRoot2, f);
+      return !findExistingProvisionalDigest(outDir, input);
+    } catch {
+      return false;
+    }
+  });
+}
 async function indexProvisionalDigestFile(workspaceRoot2, markdownPath) {
   try {
     const settings2 = loadProjectSettings(workspaceRoot2);
@@ -37692,7 +37715,8 @@ async function digestConversationFile(options) {
 }
 async function digestPendingConversations({
   workspaceRoot: workspaceRoot2,
-  digestFn = digestConversationFile
+  digestFn = digestConversationFile,
+  onProgress
 }) {
   const digestConfig = resolveConversationDigestConfig(loadProjectSettings(workspaceRoot2));
   if (!digestConfig || digestConfig.enabled === false) {
@@ -37703,26 +37727,7 @@ async function digestPendingConversations({
     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;
-      }
-    });
+    const candidates = discoverPendingConversationFiles(workspaceRoot2);
     if (candidates.length === 0) {
       return { ok: true, initialized: true, action: "noop", reason: "no-pending" };
     }
@@ -37744,6 +37749,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) {
@@ -37788,7 +37796,7 @@ async function initializeConversationDigestModel(input) {
   }
 }
 
-// src/tools/memory.ts
+// src/mcp/memory.ts
 function registerMemoryToolHandlers(server2, indexer, store, config2, workspaceRoot2 = process.cwd()) {
   server2.tool(
     "kit_memory_search",
@@ -37868,17 +37876,19 @@ ${content}`;
     }
   );
 }
-function registerMemoryTools(server2, settings2, workspaceRoot2) {
+function registerMemoryTools(server2, settings2, workspaceRoot2, overrides) {
   if (settings2.memory?.enabled !== true) return null;
-  const config2 = resolveMemoryConfig(settings2, workspaceRoot2);
-  const store = new MemoryStore(path14.join(config2.wikiDir, "index.db"), config2);
-  const embedder = new Embedder(config2.embeddingModel);
-  const indexer = new MemoryIndexer(store, embedder, config2);
+  const config2 = overrides?.config ?? resolveMemoryConfig(settings2, workspaceRoot2);
+  const store = overrides?.store ?? new MemoryStore(path14.join(config2.wikiDir, "index.db"), config2);
+  const indexer = overrides?.indexer ?? (() => {
+    const embedder = new Embedder(config2.embeddingModel);
+    return new MemoryIndexer(store, embedder, config2);
+  })();
   registerMemoryToolHandlers(server2, indexer, store, config2, workspaceRoot2);
   return indexer;
 }
 
-// src/kit-server.ts
+// src/entrypoints/server.ts
 var server = new McpServer({
   name: "kit-agents",
   version: "1.0.0"

package/dist/services/digest/background.d.ts

@@ -0,0 +1,11 @@
+import type { DigestPendingLauncherResult, DigestWorkerStatus, DigestFileOptions, ProvisionalDigestResult } from './types.js';
+export declare function runDigestPendingWorker(input: {
+    workspaceRoot: string;
+    pendingAtStart?: number;
+    digestFn?: (opts: DigestFileOptions) => Promise<ProvisionalDigestResult>;
+}): Promise<DigestWorkerStatus>;
+export declare function launchDigestPendingWorker(input: {
+    workspaceRoot: string;
+    args: string[];
+    entrypoint: string | undefined;
+}): DigestPendingLauncherResult;

package/dist/services/digest/background.js

@@ -0,0 +1,258 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { spawn } from 'node:child_process';
+import { DIGEST_LOCKFILE_REL_PATH, DIGEST_WORKER_FLAG, DIGEST_WORKER_LOG_REL_PATH, DIGEST_WORKER_STATUS_REL_PATH, } from './constants.js';
+import { digestPendingConversations, summarizePendingConversations } from './processor.js';
+import { atomicWriteJsonFile } from '../../utils/files.js';
+import { isRecord } from '../../utils/json.js';
+function digestWorkerStatusPath(workspaceRoot) {
+    return path.join(workspaceRoot, DIGEST_WORKER_STATUS_REL_PATH);
+}
+function digestWorkerLogPath(workspaceRoot) {
+    return path.join(workspaceRoot, DIGEST_WORKER_LOG_REL_PATH);
+}
+function digestWorkerLockPath(workspaceRoot) {
+    return path.join(workspaceRoot, DIGEST_LOCKFILE_REL_PATH);
+}
+function isoNow() {
+    return 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,
+    };
+}
+const WORKER_STATES = 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 === undefined || typeof value.lastError === 'string'));
+}
+function readDigestWorkerStatus(workspaceRoot) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(digestWorkerStatusPath(workspaceRoot), 'utf8'));
+        return isDigestWorkerStatus(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeDigestWorkerStatus(workspaceRoot, status) {
+    atomicWriteJsonFile(digestWorkerStatusPath(workspaceRoot), status);
+}
+function appendDigestWorkerLog(workspaceRoot, message) {
+    try {
+        const logPath = digestWorkerLogPath(workspaceRoot);
+        fs.mkdirSync(path.dirname(logPath), { recursive: true });
+        fs.appendFileSync(logPath, `[${isoNow()}] ${message}\n`, 'utf8');
+    }
+    catch {
+        // Diagnostics must never block hook startup or worker completion.
+    }
+}
+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 (!fs.existsSync(lockPath))
+        return undefined;
+    try {
+        const parsed = JSON.parse(fs.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,
+    };
+}
+export async function runDigestPendingWorker(input) {
+    const startedAt = isoNow();
+    let pendingAtStart = input.pendingAtStart ?? 0;
+    try {
+        const summary = summarizePendingConversations(input.workspaceRoot);
+        if (input.pendingAtStart === undefined) {
+            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;
+    }
+}
+export function launchDigestPendingWorker(input) {
+    const startedAt = isoNow();
+    let pendingAtStart = 0;
+    try {
+        const previousStatus = readDigestWorkerStatus(input.workspaceRoot);
+        if (previousStatus?.state === 'running' && isLivePid(previousStatus.pid)) {
+            const status = {
+                ...previousStatus,
+                state: 'locked',
+                updatedAt: isoNow(),
+                lastError: undefined,
+            };
+            writeDigestWorkerStatus(input.workspaceRoot, status);
+            return { ok: true, mode: 'background-launcher', status, spawned: false, reason: 'locked' };
+        }
+        const lockPid = readLockPid(input.workspaceRoot);
+        if (lockPid !== undefined && isLivePid(lockPid)) {
+            const status = emptyStatus('locked', 0, startedAt);
+            writeDigestWorkerStatus(input.workspaceRoot, status);
+            return { ok: true, mode: 'background-launcher', status, spawned: false, reason: 'locked' };
+        }
+        const summary = summarizePendingConversations(input.workspaceRoot);
+        if (!summary.initialized) {
+            const status = emptyStatus('not-initialized', 0, startedAt);
+            writeDigestWorkerStatus(input.workspaceRoot, status);
+            return { ok: true, mode: 'background-launcher', status, spawned: false, reason: 'not-initialized' };
+        }
+        if (summary.pending === 0) {
+            const status = emptyStatus('no-pending', 0, startedAt);
+            writeDigestWorkerStatus(input.workspaceRoot, status);
+            return { ok: true, mode: 'background-launcher', status, spawned: false, reason: 'no-pending' };
+        }
+        pendingAtStart = summary.pending;
+        if (!input.entrypoint) {
+            const status = {
+                ...emptyStatus('failed', pendingAtStart, startedAt),
+                errors: 1,
+                lastError: 'CLI entrypoint is unavailable',
+            };
+            writeDigestWorkerStatus(input.workspaceRoot, status);
+            return {
+                ok: false,
+                mode: 'background-launcher',
+                status,
+                spawned: false,
+                reason: 'spawn-failed',
+                error: status.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,
+        };
+    }
+}