@riconext/hermes-repo 1.1.0 → 1.2.0

package/dist/cli.js

@@ -102,14 +102,26 @@ function parseLlmConfig(raw) {
   const llm = raw.llm;
   return {
     enabled: typeof llm?.enabled === "boolean" ? llm.enabled : false,
+    provider: typeof llm?.provider === "string" ? llm.provider : "openai",
     baseUrl: typeof llm?.baseUrl === "string" ? llm.baseUrl : "https://api.openai.com/v1",
-    model: typeof llm?.model === "string" ? llm.model : "gpt-4o"
+    model: typeof llm?.model === "string" ? llm.model : "gpt-4o",
+    apiKey: typeof llm?.apiKey === "string" ? llm.apiKey : "",
+    timeoutMs: typeof llm?.timeoutMs === "number" && llm.timeoutMs > 0 ? llm.timeoutMs : 6e4,
+    maxInputChars: typeof llm?.maxInputChars === "number" && llm.maxInputChars > 0 ? llm.maxInputChars : 24e3,
+    mode: llm?.mode === "sync" ? "sync" : "async"
   };
 }
 function parseConsolidateConfig(raw) {
   const c = raw.consolidate;
+  const autoFlush = c?.autoFlush && typeof c.autoFlush === "object" && !Array.isArray(c.autoFlush) ? c.autoFlush : {};
   return {
-    autoArchiveDays: typeof c?.autoArchiveDays === "number" ? c.autoArchiveDays : 30
+    autoArchiveDays: typeof c?.autoArchiveDays === "number" ? c.autoArchiveDays : 30,
+    autoFlush: {
+      enabled: autoFlush.enabled === true,
+      minPendingSessions: typeof autoFlush.minPendingSessions === "number" && autoFlush.minPendingSessions > 0 ? autoFlush.minPendingSessions : 3,
+      minIntervalMinutes: typeof autoFlush.minIntervalMinutes === "number" && autoFlush.minIntervalMinutes > 0 ? autoFlush.minIntervalMinutes : 30,
+      maxPendingChars: typeof autoFlush.maxPendingChars === "number" && autoFlush.maxPendingChars > 0 ? autoFlush.maxPendingChars : 2e4
+    }
   };
 }
 function readConfigAtRepo(repoRoot) {
@@ -136,8 +148,25 @@ function readConfigAtRepo(repoRoot) {
         storage: { backend: "file" },
         assistants,
         debug: raw.debug === true,
-        llm: { enabled: false, baseUrl: "https://api.openai.com/v1", model: "gpt-4o" },
-        consolidate: { autoArchiveDays: 30 }
+        llm: {
+          enabled: false,
+          provider: "openai",
+          baseUrl: "https://api.openai.com/v1",
+          model: "gpt-4o",
+          apiKey: "",
+          timeoutMs: 6e4,
+          maxInputChars: 24e3,
+          mode: "async"
+        },
+        consolidate: {
+          autoArchiveDays: 30,
+          autoFlush: {
+            enabled: false,
+            minPendingSessions: 3,
+            minIntervalMinutes: 30,
+            maxPendingChars: 2e4
+          }
+        }
       };
     }
     return null;
@@ -158,12 +187,10 @@ function loadRepoContext(cwd) {
 }
 
 // src/capture/runLlmJob.ts
-import { existsSync as existsSync5, readFileSync as readFileSync6, renameSync, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync5, renameSync, writeFileSync as writeFileSync3 } from "fs";
 import { join as join6 } from "path";
 
 // src/config/llmConfig.ts
-var DEFAULT_LLM_TIMEOUT_MS = 6e4;
-var DEFAULT_LLM_MAX_INPUT_CHARS = 24e3;
 function isLlmAvailable(cfg) {
   if (!cfg?.enabled) {
     return false;
@@ -171,52 +198,11 @@ function isLlmAvailable(cfg) {
   return Boolean(cfg.apiKey?.trim()) && Boolean(cfg.baseUrl?.trim()) && Boolean(cfg.model?.trim());
 }
 function effectiveLlmMode(cfg) {
-  const forceSync = process.env.HERMES_LLM_SYNC;
-  if (forceSync === "1" || forceSync === "true") {
-    return "sync";
-  }
   return cfg.mode === "sync" ? "sync" : "async";
 }
-function parseLlmConfigRaw(raw) {
-  if (raw.enabled !== true && raw.enabled !== false) {
-    return null;
-  }
-  const baseUrl = typeof raw.baseUrl === "string" ? raw.baseUrl : "";
-  const model = typeof raw.model === "string" ? raw.model : "";
-  const apiKey = typeof raw.apiKey === "string" ? raw.apiKey : "";
-  const timeoutMs = typeof raw.timeoutMs === "number" && raw.timeoutMs > 0 ? raw.timeoutMs : DEFAULT_LLM_TIMEOUT_MS;
-  const maxInputChars = typeof raw.maxInputChars === "number" && raw.maxInputChars > 0 ? raw.maxInputChars : DEFAULT_LLM_MAX_INPUT_CHARS;
-  const mode = raw.mode === "sync" ? "sync" : "async";
-  const provider = typeof raw.provider === "string" ? raw.provider : "openai";
-  return {
-    enabled: raw.enabled,
-    provider,
-    baseUrl,
-    model,
-    apiKey,
-    timeoutMs,
-    maxInputChars,
-    mode
-  };
-}
-
-// src/config/readLlmConfig.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-function readLlmConfigAtRepo(repoRoot) {
-  const llmPath = memoryPath(repoRoot, "llm.json");
-  if (!existsSync2(llmPath)) {
-    return null;
-  }
-  try {
-    const raw = JSON.parse(readFileSync2(llmPath, "utf8"));
-    return parseLlmConfigRaw(raw);
-  } catch {
-    return null;
-  }
-}
 
 // src/capture/claude-code/parseJsonl.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 import { basename } from "path";
 var FILE_CHANGE_TOOLS = /^(Write|Edit|MultiEdit|NotebookEdit|write|edit)$/i;
 var SKIP_LINE_TYPES = /* @__PURE__ */ new Set([
@@ -318,7 +304,7 @@ function countNestedTools(record) {
 }
 function parseJsonlFile(jsonlPath) {
   const sessionId = basename(jsonlPath, ".jsonl");
-  const raw = readFileSync3(jsonlPath, "utf8");
+  const raw = readFileSync2(jsonlPath, "utf8");
   const messages = [];
   let fileChanges = 0;
   let toolCalls = 0;
@@ -362,10 +348,10 @@ function parseJsonlFile(jsonlPath) {
 // src/capture/enqueueLlmJob.ts
 import { spawn } from "child_process";
 import {
-  existsSync as existsSync3,
+  existsSync as existsSync2,
   mkdirSync as mkdirSync2,
   readdirSync,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync3,
   rmSync,
   writeFileSync
 } from "fs";
@@ -383,7 +369,7 @@ function makeJobId(sessionId) {
 }
 function removeStaleJobsForSession(repoRoot, sessionId) {
   const dir = pendingDir(repoRoot);
-  if (!existsSync3(dir)) {
+  if (!existsSync2(dir)) {
     return;
   }
   for (const name of readdirSync(dir)) {
@@ -392,7 +378,7 @@ function removeStaleJobsForSession(repoRoot, sessionId) {
     }
     try {
       const raw = JSON.parse(
-        readFileSync4(join4(dir, name), "utf8")
+        readFileSync3(join4(dir, name), "utf8")
       );
       if (raw.sessionId === sessionId) {
         rmSync(join4(dir, name), { force: true });
@@ -436,24 +422,24 @@ function enqueueLlmJob(opts) {
 }
 function readLlmJob(repoRoot, jobId) {
   const path = join4(pendingDir(repoRoot), `${jobId}.json`);
-  if (!existsSync3(path)) {
+  if (!existsSync2(path)) {
     return null;
   }
   try {
-    return JSON.parse(readFileSync4(path, "utf8"));
+    return JSON.parse(readFileSync3(path, "utf8"));
   } catch {
     return null;
   }
 }
 function deleteLlmJob(repoRoot, jobId) {
   const path = join4(pendingDir(repoRoot), `${jobId}.json`);
-  if (existsSync3(path)) {
+  if (existsSync2(path)) {
     rmSync(path, { force: true });
   }
 }
 function listPendingJobs(repoRoot) {
   const dir = pendingDir(repoRoot);
-  if (!existsSync3(dir)) {
+  if (!existsSync2(dir)) {
     return [];
   }
   const jobs = [];
@@ -463,7 +449,7 @@ function listPendingJobs(repoRoot) {
     }
     try {
       jobs.push(
-        JSON.parse(readFileSync4(join4(dir, name), "utf8"))
+        JSON.parse(readFileSync3(join4(dir, name), "utf8"))
       );
     } catch {
     }
@@ -693,7 +679,7 @@ async function llmFormat(session, assistant, llm) {
 }
 
 // src/capture/writeCapture.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
 import { join as join5 } from "path";
 function isoNow() {
   return (/* @__PURE__ */ new Date()).toISOString();
@@ -746,7 +732,7 @@ function resolveSessionFile(repoRoot, sessionId) {
   const filename = `session-${sessionId}.md`;
   const absolutePath = memoryPath(repoRoot, "captures", "raw", filename);
   const relativePath = join5(".memory", "captures", "raw", filename);
-  return { absolutePath, relativePath, exists: existsSync4(absolutePath) };
+  return { absolutePath, relativePath, exists: existsSync3(absolutePath) };
 }
 function renderCaptureMarkdown(formatted, date) {
   const tagsStr = formatted.tags.map((t) => JSON.stringify(t)).join(", ");
@@ -793,7 +779,7 @@ function appendCaptureToSession(repoRoot, formatted) {
       previousStatus: null
     };
   }
-  const existingContent = readFileSync5(absolutePath, "utf8");
+  const existingContent = readFileSync4(absolutePath, "utf8");
   const existingFm = parseSessionFileFrontmatter(existingContent);
   if (!existingFm) {
     const fm = {
@@ -847,7 +833,7 @@ function appendCaptureToSession(repoRoot, formatted) {
 function markSessionConsolidated(repoRoot, sessionId) {
   const { absolutePath, exists } = resolveSessionFile(repoRoot, sessionId);
   if (!exists) return;
-  const content = readFileSync5(absolutePath, "utf8");
+  const content = readFileSync4(absolutePath, "utf8");
   const fm = parseSessionFileFrontmatter(content);
   if (!fm) return;
   const updatedFm = {
@@ -867,10 +853,10 @@ function markSessionConsolidated(repoRoot, sessionId) {
 // src/capture/runLlmJob.ts
 function captureAlreadyUpgraded(repoRoot, captureFile) {
   const path = join6(repoRoot, captureFile);
-  if (!existsSync5(path)) {
+  if (!existsSync4(path)) {
     return false;
   }
-  const text = readFileSync6(path, "utf8");
+  const text = readFileSync5(path, "utf8");
   return /llmUpgradedAt:/.test(text);
 }
 async function runLlmJob(repoRoot, job, debug) {
@@ -878,11 +864,11 @@ async function runLlmJob(repoRoot, job, debug) {
     deleteLlmJob(repoRoot, job.jobId);
     return { ok: true, reason: "already-upgraded" };
   }
-  const llm = readLlmConfigAtRepo(repoRoot);
+  const llm = readConfigAtRepo(repoRoot)?.llm ?? null;
   if (!isLlmAvailable(llm)) {
     return { ok: false, reason: "llm not available" };
   }
-  if (!existsSync5(job.jsonlPath)) {
+  if (!existsSync4(job.jsonlPath)) {
     return { ok: false, reason: "jsonl missing" };
   }
   const session = parseJsonlFile(job.jsonlPath);
@@ -965,7 +951,7 @@ function runCaptureLlmCommand(opts) {
 }
 
 // src/capture/hookInput.ts
-import { existsSync as existsSync6, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
 import { resolve as resolve2 } from "path";
 function pickString(obj, ...keys) {
   for (const key of keys) {
@@ -1003,7 +989,7 @@ function parseHookInputJson(raw) {
   try {
     const parsed = JSON.parse(trimmed);
     const transcriptRaw = pickString(parsed, "transcript_path", "transcriptPath");
-    const transcriptPath = transcriptRaw && existsSync6(transcriptRaw) ? resolve2(transcriptRaw) : void 0;
+    const transcriptPath = transcriptRaw && existsSync5(transcriptRaw) ? resolve2(transcriptRaw) : void 0;
     return {
       transcriptPath,
       transcriptPathRaw: transcriptRaw,
@@ -1022,7 +1008,7 @@ function readHookInputSync() {
     return null;
   }
   try {
-    const raw = readFileSync7(0, "utf8");
+    const raw = readFileSync6(0, "utf8");
     return parseHookInputJson(raw);
   } catch {
     return null;
@@ -1135,11 +1121,16 @@ function needsLlm(session) {
   return false;
 }
 
+// src/consolidate/scheduleConsolidate.ts
+import { spawn as spawn2 } from "child_process";
+import { dirname as dirname5, join as join11 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
 // src/consolidate/state.ts
 import {
-  existsSync as existsSync7,
+  existsSync as existsSync6,
   mkdirSync as mkdirSync4,
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync7,
   rmSync as rmSync2,
   writeFileSync as writeFileSync4
 } from "fs";
@@ -1161,11 +1152,11 @@ function consolidateLockPath(repoRoot) {
 }
 function readConsolidateState(repoRoot) {
   const path = consolidateStatePath(repoRoot);
-  if (!existsSync7(path)) {
+  if (!existsSync6(path)) {
     return { ...EMPTY_STATE, processedSessions: {} };
   }
   try {
-    const raw = JSON.parse(readFileSync8(path, "utf8"));
+    const raw = JSON.parse(readFileSync7(path, "utf8"));
     if (typeof raw === "object" && raw !== null) {
       const obj = raw;
       if (obj.version === 2 && typeof obj.processedSessions === "object") {
@@ -1189,11 +1180,11 @@ function writeConsolidateState(repoRoot, state) {
 }
 function readConsolidateLock(repoRoot) {
   const path = consolidateLockPath(repoRoot);
-  if (!existsSync7(path)) {
+  if (!existsSync6(path)) {
     return null;
   }
   try {
-    return JSON.parse(readFileSync8(path, "utf8"));
+    return JSON.parse(readFileSync7(path, "utf8"));
   } catch {
     return null;
   }
@@ -1213,7 +1204,7 @@ function writeConsolidateLock(repoRoot) {
 }
 function releaseConsolidateLock(repoRoot) {
   const path = consolidateLockPath(repoRoot);
-  if (existsSync7(path)) {
+  if (existsSync6(path)) {
     rmSync2(path, { force: true });
   }
 }
@@ -1226,7 +1217,7 @@ function isLockStale(lock, ttlMs) {
 }
 
 // src/consolidate/sessionScanner.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync9 } from "fs";
+import { readdirSync as readdirSync2, readFileSync as readFileSync8 } from "fs";
 import { join as join7 } from "path";
 function parseSessionFrontmatter(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
@@ -1257,7 +1248,7 @@ function scanAllSessions(repoRoot) {
   for (const file of files) {
     const absolutePath = join7(rawDir, file);
     try {
-      const content = readFileSync9(absolutePath, "utf8");
+      const content = readFileSync8(absolutePath, "utf8");
       const fm = parseSessionFrontmatter(content);
       if (!fm || !fm.sessionId) continue;
       const fmEndIndex = content.indexOf("---", 4);
@@ -1286,7 +1277,7 @@ function filterPendingSessions(sessions) {
 }
 
 // src/consolidate/llmConsolidateV2.ts
-import { readFileSync as readFileSync10, readdirSync as readdirSync3 } from "fs";
+import { readFileSync as readFileSync9, readdirSync as readdirSync3 } from "fs";
 import { join as join8 } from "path";
 var CONSOLIDATE_SYSTEM_PROMPT = `\u4F60\u662F\u4E00\u4E2A\u9879\u76EE\u77E5\u8BC6\u6574\u7406\u4E13\u5BB6\u3002\u4F60\u7684\u4EFB\u52A1\u662F\u4ECE AI \u7F16\u7A0B\u52A9\u624B\u7684\u5BF9\u8BDD\u8BB0\u5F55\u4E2D\u63D0\u70BC\u51FA\u7ED3\u6784\u5316\u7684\u77E5\u8BC6\u5E93\u3002
 
@@ -1395,7 +1386,7 @@ function scanMarkdownDirectory(absoluteDir, relativePrefix, type, domain, result
   }
   for (const file of files) {
     try {
-      const content = readFileSync10(join8(absoluteDir, file), "utf8");
+      const content = readFileSync9(join8(absoluteDir, file), "utf8");
       const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
       let title = file.replace(/\.md$/, "");
       if (fmMatch) {
@@ -1421,7 +1412,7 @@ function buildLlmConsolidateInput(repoRoot, sessions) {
   const pendingSessions = sessions.map((s) => ({
     sessionId: s.sessionId,
     status: s.frontmatter.status,
-    content: readFileSync10(s.absolutePath, "utf8"),
+    content: readFileSync9(s.absolutePath, "utf8"),
     captureCount: s.frontmatter.captureCount,
     createdAt: s.frontmatter.createdAt
   }));
@@ -1429,7 +1420,7 @@ function buildLlmConsolidateInput(repoRoot, sessions) {
   const memoryPathAbs = memoryPath(repoRoot, "MEMORY.md");
   let currentMemoryMd = null;
   try {
-    currentMemoryMd = readFileSync10(memoryPathAbs, "utf8");
+    currentMemoryMd = readFileSync9(memoryPathAbs, "utf8");
   } catch {
   }
   return {
@@ -1439,15 +1430,14 @@ function buildLlmConsolidateInput(repoRoot, sessions) {
   };
 }
 async function callLlmConsolidate(input2, llmConfig) {
-  const apiKey = process.env.HERMES_LLM_API_KEY;
-  if (!apiKey) {
+  if (!llmConfig.enabled) {
     throw new Error(
-      "LLM \u672A\u914D\u7F6E\uFF1A\u8BF7\u8BBE\u7F6E HERMES_LLM_API_KEY \u73AF\u5883\u53D8\u91CF"
+      "LLM \u672A\u542F\u7528\uFF1A\u8BF7\u5728 config.json \u4E2D\u8BBE\u7F6E llm.enabled = true"
     );
   }
-  if (!llmConfig.enabled) {
+  if (!llmConfig.apiKey.trim() || !llmConfig.baseUrl.trim() || !llmConfig.model.trim()) {
     throw new Error(
-      "LLM \u672A\u542F\u7528\uFF1A\u8BF7\u5728 config.json \u4E2D\u8BBE\u7F6E llm.enabled = true"
+      "LLM \u672A\u914D\u7F6E\uFF1A\u8BF7\u5728 config.json \u4E2D\u8BBE\u7F6E llm.apiKey\u3001llm.baseUrl \u548C llm.model"
     );
   }
   const url = `${llmConfig.baseUrl.replace(/\/$/, "")}/chat/completions`;
@@ -1459,7 +1449,7 @@ async function callLlmConsolidate(input2, llmConfig) {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
+        Authorization: `Bearer ${llmConfig.apiKey}`
       },
       body: JSON.stringify({
         model: llmConfig.model,
@@ -1551,7 +1541,7 @@ function isSkippedEntry(raw) {
 }
 
 // src/consolidate/writeKnowledge.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
 import { dirname as dirname4 } from "path";
 function writeKnowledgeFiles(repoRoot, files) {
   const result = {
@@ -1565,7 +1555,7 @@ function writeKnowledgeFiles(repoRoot, files) {
       const dir = dirname4(absolutePath);
       mkdirSync5(dir, { recursive: true });
       const content = serializeKnowledgeFile(kf.frontmatter, kf.body);
-      const alreadyExists = existsSync8(absolutePath);
+      const alreadyExists = existsSync7(absolutePath);
       if (kf.action === "create" && alreadyExists) {
         result.updated.push(kf.targetPath);
       } else if (kf.action === "create") {
@@ -1585,7 +1575,7 @@ function writeKnowledgeFiles(repoRoot, files) {
 }
 function writeMemoryMd(repoRoot, memoryMd) {
   const memoryPathAbs = memoryPath(repoRoot, "MEMORY.md");
-  if (existsSync8(memoryPathAbs)) {
+  if (existsSync7(memoryPathAbs)) {
     const existing = __require("fs").readFileSync(memoryPathAbs, "utf8");
     const preserved = extractUserEditedSections(existing);
     if (preserved.length > 0) {
@@ -1802,6 +1792,9 @@ function extractDomainsFromResults(files) {
 var CONSOLIDATE_LOCK_TTL_MS = 30 * 60 * 1e3;
 
 // src/consolidate/scheduleConsolidate.ts
+function cliPath2() {
+  return join11(dirname5(fileURLToPath2(import.meta.url)), "..", "cli.js");
+}
 async function runFlushCommand(opts) {
   const ctx = loadRepoContext(opts.cwd);
   if (!ctx) {
@@ -1836,11 +1829,83 @@ async function runFlushCommand(opts) {
     debug: opts.debug ?? ctx.config.debug
   });
 }
+function shouldAutoFlush(sessions, consolidate, lastConsolidatedAt) {
+  const autoFlush = consolidate.autoFlush;
+  if (!autoFlush.enabled || sessions.length === 0) {
+    return false;
+  }
+  if (sessions.length >= autoFlush.minPendingSessions) {
+    return true;
+  }
+  const pendingChars = sessions.reduce(
+    (sum, session) => sum + session.bodyContent.length,
+    0
+  );
+  if (pendingChars >= autoFlush.maxPendingChars) {
+    return true;
+  }
+  const last = Date.parse(lastConsolidatedAt);
+  if (Number.isNaN(last)) {
+    return true;
+  }
+  const minIntervalMs = autoFlush.minIntervalMinutes * 60 * 1e3;
+  return Date.now() - last >= minIntervalMs;
+}
 function maybeScheduleConsolidate(opts) {
+  const ctx = loadRepoContext(opts.repoRoot);
+  if (!ctx) {
+    return;
+  }
+  const autoFlush = ctx.config.consolidate.autoFlush;
+  if (!autoFlush.enabled) {
+    return;
+  }
+  if (!isLlmAvailable(ctx.config.llm)) {
+    debugLog(opts.debug === true, "consolidate", "auto flush skipped: llm not available");
+    return;
+  }
   const lock = readConsolidateLock(opts.repoRoot);
   if (lock && !isLockStale(lock, CONSOLIDATE_LOCK_TTL_MS)) {
+    debugLog(opts.debug === true, "consolidate", "auto flush skipped: lock held");
+    return;
+  }
+  const pendingSessions = filterPendingSessions(scanAllSessions(opts.repoRoot));
+  const state = readConsolidateState(opts.repoRoot);
+  if (!shouldAutoFlush(
+    pendingSessions,
+    ctx.config.consolidate,
+    state.lastConsolidatedAt
+  )) {
+    debugLog(
+      opts.debug === true,
+      "consolidate",
+      `auto flush skipped: ${pendingSessions.length} pending session(s) below thresholds`
+    );
     return;
   }
+  try {
+    const child = spawn2(
+      process.execPath,
+      [cliPath2(), "flush", "-C", opts.repoRoot],
+      {
+        detached: true,
+        stdio: "ignore",
+        cwd: opts.repoRoot
+      }
+    );
+    child.unref();
+    debugLog(
+      opts.debug === true,
+      "consolidate",
+      `auto flush scheduled: ${pendingSessions.length} pending session(s)`
+    );
+  } catch (err) {
+    debugLog(
+      opts.debug === true,
+      "consolidate",
+      `auto flush spawn failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
 }
 
 // src/capture/commitCapture.ts
@@ -1863,7 +1928,7 @@ async function commitCapture(opts) {
   }
   const result = appendCaptureToSession(repoRoot, formatted);
   const captureFile = result.relativePath;
-  const llm = readLlmConfigAtRepo(repoRoot);
+  const llm = readConfigAtRepo(repoRoot)?.llm ?? null;
   if (!isLlmAvailable(llm) || !needsLlm(session)) {
     debugLog(debug === true, "capture", `ok: ${captureFile} (format=simple)`);
     return finishCapture(repoRoot, debug, {
@@ -1911,37 +1976,37 @@ async function commitCapture(opts) {
 }
 
 // src/capture/claude-code/resolveSession.ts
-import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync12, statSync } from "fs";
+import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync11, statSync } from "fs";
 import { homedir } from "os";
-import { basename as basename2, join as join11, resolve as resolve3 } from "path";
+import { basename as basename2, join as join12, resolve as resolve3 } from "path";
 function encodeClaudeProjectDir(absPath) {
   return resolve3(absPath).replace(/\//g, "-");
 }
 function resolveSessionJsonlPath(repoRoot, options = {}) {
   const override = process.env.HERMES_SESSION_JSONL;
-  if (override && existsSync10(override)) {
+  if (override && existsSync9(override)) {
     return resolve3(override);
   }
   const fromHook = options.transcriptPath;
-  if (fromHook && existsSync10(fromHook)) {
+  if (fromHook && existsSync9(fromHook)) {
     return resolve3(fromHook);
   }
   const sessionId = process.env.CLAUDE_SESSION_ID ?? process.env.CLAUDE_CODE_SESSION_ID ?? process.env.SESSION_ID;
-  const claudeHome = process.env.CLAUDE_CONFIG_DIR ? resolve3(process.env.CLAUDE_CONFIG_DIR) : join11(homedir(), ".claude");
-  const projectsRoot = join11(claudeHome, "projects");
-  if (!existsSync10(projectsRoot)) {
+  const claudeHome = process.env.CLAUDE_CONFIG_DIR ? resolve3(process.env.CLAUDE_CONFIG_DIR) : join12(homedir(), ".claude");
+  const projectsRoot = join12(claudeHome, "projects");
+  if (!existsSync9(projectsRoot)) {
     return null;
   }
   const cwd = resolve3(options.cwd ?? repoRoot);
   const preferredProjectDir = encodeClaudeProjectDir(cwd);
-  const preferredPath = join11(projectsRoot, preferredProjectDir);
-  if (existsSync10(preferredPath)) {
+  const preferredPath = join12(projectsRoot, preferredProjectDir);
+  if (existsSync9(preferredPath)) {
     const hit = pickNewestJsonl(preferredPath, sessionId);
     if (hit) {
       return hit;
     }
-    const legacySessions = join11(preferredPath, "sessions");
-    if (existsSync10(legacySessions)) {
+    const legacySessions = join12(preferredPath, "sessions");
+    if (existsSync9(legacySessions)) {
       const legacyHit = pickNewestJsonl(legacySessions, sessionId);
       if (legacyHit) {
         return legacyHit;
@@ -1951,10 +2016,10 @@ function resolveSessionJsonlPath(repoRoot, options = {}) {
   const candidates = [];
   for (const projectDir of readdirSync4(projectsRoot, { withFileTypes: true })) {
     if (!projectDir.isDirectory()) continue;
-    const projectPath = join11(projectsRoot, projectDir.name);
+    const projectPath = join12(projectsRoot, projectDir.name);
     collectJsonlCandidates(projectPath, sessionId, candidates);
-    const legacySessions = join11(projectPath, "sessions");
-    if (existsSync10(legacySessions)) {
+    const legacySessions = join12(projectPath, "sessions");
+    if (existsSync9(legacySessions)) {
       collectJsonlCandidates(legacySessions, sessionId, candidates);
     }
   }
@@ -1974,14 +2039,14 @@ function pickNewestJsonl(dir, sessionId) {
   return candidates[0]?.path ?? null;
 }
 function collectJsonlCandidates(dir, sessionId, out) {
-  if (!existsSync10(dir)) {
+  if (!existsSync9(dir)) {
     return;
   }
   for (const entry of readdirSync4(dir, { withFileTypes: true })) {
     if (!entry.isFile() || !entry.name.endsWith(".jsonl")) {
       continue;
     }
-    const fullPath = join11(dir, entry.name);
+    const fullPath = join12(dir, entry.name);
     if (sessionId && !entry.name.includes(sessionId) && basename2(entry.name, ".jsonl") !== sessionId) {
       continue;
     }
@@ -2014,31 +2079,31 @@ async function runClaudeCodeCapture(repoRoot, cwd, dryRun, options) {
 }
 
 // src/capture/codebuddy/resolveSession.ts
-import { existsSync as existsSync11, readdirSync as readdirSync5, statSync as statSync2 } from "fs";
+import { existsSync as existsSync10, readdirSync as readdirSync5, statSync as statSync2 } from "fs";
 import { homedir as homedir2 } from "os";
-import { basename as basename3, join as join12, resolve as resolve4 } from "path";
+import { basename as basename3, join as join13, resolve as resolve4 } from "path";
 function encodeCodebuddyProjectDir(absPath) {
   return resolve4(absPath).replace(/^\//, "").replace(/\//g, "-");
 }
 function resolveCodebuddySessionJsonl(options) {
   const override = process.env.HERMES_CODEBUDDY_SESSION;
-  if (override && existsSync11(override)) {
+  if (override && existsSync10(override)) {
     return resolve4(override);
   }
   const fromHook = options.transcriptPath;
-  if (fromHook && existsSync11(fromHook)) {
+  if (fromHook && existsSync10(fromHook)) {
     return resolve4(fromHook);
   }
   const sessionId = process.env.CODEBUDDY_SESSION_ID ?? process.env.SESSION_ID;
-  const codebuddyHome = process.env.CODEBUDDY_CONFIG_DIR ? resolve4(process.env.CODEBUDDY_CONFIG_DIR) : join12(homedir2(), ".codebuddy");
-  const projectsRoot = join12(codebuddyHome, "projects");
-  if (!existsSync11(projectsRoot)) {
+  const codebuddyHome = process.env.CODEBUDDY_CONFIG_DIR ? resolve4(process.env.CODEBUDDY_CONFIG_DIR) : join13(homedir2(), ".codebuddy");
+  const projectsRoot = join13(codebuddyHome, "projects");
+  if (!existsSync10(projectsRoot)) {
     return null;
   }
   const cwd = resolve4(options.cwd ?? options.repoRoot);
   const preferredProjectDir = encodeCodebuddyProjectDir(cwd);
-  const preferredPath = join12(projectsRoot, preferredProjectDir);
-  if (existsSync11(preferredPath)) {
+  const preferredPath = join13(projectsRoot, preferredProjectDir);
+  if (existsSync10(preferredPath)) {
     const hit = pickNewestJsonlRecursive(preferredPath, sessionId);
     if (hit) {
       return hit;
@@ -2049,7 +2114,7 @@ function resolveCodebuddySessionJsonl(options) {
     if (!projectDir.isDirectory()) {
       continue;
     }
-    collectJsonlRecursive(join12(projectsRoot, projectDir.name), sessionId, candidates);
+    collectJsonlRecursive(join13(projectsRoot, projectDir.name), sessionId, candidates);
   }
   if (candidates.length === 0) {
     return null;
@@ -2067,11 +2132,11 @@ function pickNewestJsonlRecursive(dir, sessionId) {
   return candidates[0]?.path ?? null;
 }
 function collectJsonlRecursive(dir, sessionId, out) {
-  if (!existsSync11(dir)) {
+  if (!existsSync10(dir)) {
     return;
   }
   for (const entry of readdirSync5(dir, { withFileTypes: true })) {
-    const full = join12(dir, entry.name);
+    const full = join13(dir, entry.name);
     if (entry.isDirectory()) {
       collectJsonlRecursive(full, sessionId, out);
       continue;
@@ -2119,36 +2184,36 @@ async function runCodebuddyCapture(repoRoot, cwd, dryRun, options) {
 }
 
 // src/capture/cursor/resolveSession.ts
-import { existsSync as existsSync12, readdirSync as readdirSync6, statSync as statSync3 } from "fs";
+import { existsSync as existsSync11, readdirSync as readdirSync6, statSync as statSync3 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join13, resolve as resolve5 } from "path";
+import { join as join14, resolve as resolve5 } from "path";
 function encodeCursorProjectDir(absPath) {
   return resolve5(absPath).replace(/^\//, "").replace(/\//g, "-");
 }
 function resolveCursorSessionJsonl(options) {
   const override = process.env.HERMES_CURSOR_SESSION;
-  if (override && existsSync12(override)) {
+  if (override && existsSync11(override)) {
     return resolve5(override);
   }
-  const cursorHome = process.env.CURSOR_CONFIG_DIR ? resolve5(process.env.CURSOR_CONFIG_DIR) : join13(homedir3(), ".cursor");
-  const projectsRoot = join13(cursorHome, "projects");
-  if (!existsSync12(projectsRoot)) {
+  const cursorHome = process.env.CURSOR_CONFIG_DIR ? resolve5(process.env.CURSOR_CONFIG_DIR) : join14(homedir3(), ".cursor");
+  const projectsRoot = join14(cursorHome, "projects");
+  if (!existsSync11(projectsRoot)) {
     return null;
   }
   const sessionId = options.hookInput?.sessionId ?? options.hookInput?.conversationId ?? process.env.CURSOR_SESSION_ID ?? process.env.CURSOR_AGENT_SESSION_ID;
   const workspace = options.hookInput?.workspaceRoots?.[0] ?? (options.cwd ? resolve5(options.cwd) : resolve5(options.repoRoot));
   const encoded = encodeCursorProjectDir(workspace);
-  const projectDir = join13(projectsRoot, encoded);
-  const transcriptsRoot = join13(projectDir, "agent-transcripts");
-  if (!existsSync12(transcriptsRoot)) {
+  const projectDir = join14(projectsRoot, encoded);
+  const transcriptsRoot = join14(projectDir, "agent-transcripts");
+  if (!existsSync11(transcriptsRoot)) {
     return pickNewestCursorJsonl(projectsRoot);
   }
   if (sessionId) {
-    const direct = join13(transcriptsRoot, sessionId, `${sessionId}.jsonl`);
-    if (existsSync12(direct)) {
+    const direct = join14(transcriptsRoot, sessionId, `${sessionId}.jsonl`);
+    if (existsSync11(direct)) {
       return direct;
     }
-    const nested = findJsonlUnderDir(join13(transcriptsRoot, sessionId), sessionId);
+    const nested = findJsonlUnderDir(join14(transcriptsRoot, sessionId), sessionId);
     if (nested) {
       return nested;
     }
@@ -2156,19 +2221,19 @@ function resolveCursorSessionJsonl(options) {
   return pickNewestCursorJsonl(transcriptsRoot);
 }
 function findJsonlUnderDir(dir, sessionId) {
-  if (!existsSync12(dir)) {
+  if (!existsSync11(dir)) {
     return null;
   }
-  const direct = join13(dir, `${sessionId}.jsonl`);
-  if (existsSync12(direct)) {
+  const direct = join14(dir, `${sessionId}.jsonl`);
+  if (existsSync11(direct)) {
     return direct;
   }
   for (const entry of readdirSync6(dir, { withFileTypes: true })) {
     if (entry.isFile() && entry.name.endsWith(".jsonl")) {
-      return join13(dir, entry.name);
+      return join14(dir, entry.name);
     }
     if (entry.isDirectory()) {
-      const found = findJsonlUnderDir(join13(dir, entry.name), sessionId);
+      const found = findJsonlUnderDir(join14(dir, entry.name), sessionId);
       if (found) {
         return found;
       }
@@ -2186,11 +2251,11 @@ function pickNewestCursorJsonl(root) {
   return candidates[0]?.path ?? null;
 }
 function collectJsonlRecursive2(dir, out) {
-  if (!existsSync12(dir)) {
+  if (!existsSync11(dir)) {
     return;
   }
   for (const entry of readdirSync6(dir, { withFileTypes: true })) {
-    const full = join13(dir, entry.name);
+    const full = join14(dir, entry.name);
     if (entry.isDirectory()) {
       collectJsonlRecursive2(full, out);
       continue;
@@ -2415,8 +2480,8 @@ async function runFlushCommandCli(opts) {
 }
 
 // src/inject/runInject.ts
-import { existsSync as existsSync13, readdirSync as readdirSync7, readFileSync as readFileSync13 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync12, readdirSync as readdirSync7, readFileSync as readFileSync12 } from "fs";
+import { join as join15 } from "path";
 
 // src/inject/constants.ts
 var INJECT_MAX_CHARS = 8e3;
@@ -2476,9 +2541,9 @@ function rulesPathOnDisk(repoRoot) {
 }
 function readMemoryMd(repoRoot) {
   const path = memoryPathOnDisk(repoRoot);
-  if (!existsSync13(path)) return null;
+  if (!existsSync12(path)) return null;
   try {
-    const content = readFileSync13(path, "utf8");
+    const content = readFileSync12(path, "utf8");
     return content.trim() || null;
   } catch {
     return null;
@@ -2496,8 +2561,8 @@ function readAllRules(repoRoot) {
   const parts = [];
   for (const file of files) {
     try {
-      const filePath = join14(rulesDir, file);
-      const content = readFileSync13(filePath, "utf8").trim();
+      const filePath = join15(rulesDir, file);
+      const content = readFileSync12(filePath, "utf8").trim();
       if (!content) continue;
       parts.push(`### ${file}`, "", content, "");
     } catch {
@@ -2524,49 +2589,49 @@ import { resolve as resolve7 } from "path";
 
 // src/init/assistants/claude-code.ts
 import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync6 } from "fs";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 
 // src/init/mergeClaudeSettings.ts
-import { existsSync as existsSync15, readFileSync as readFileSync16 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync15 } from "fs";
+import { join as join18 } from "path";
 
 // src/init/templateDir.ts
-import { existsSync as existsSync14, readFileSync as readFileSync15 } from "fs";
-import { dirname as dirname6, join as join16 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { existsSync as existsSync13, readFileSync as readFileSync14 } from "fs";
+import { dirname as dirname7, join as join17 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
 
 // src/index.ts
-import { readFileSync as readFileSync14 } from "fs";
-import { dirname as dirname5, join as join15 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { readFileSync as readFileSync13 } from "fs";
+import { dirname as dirname6, join as join16 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 var PACKAGE_NAME = "@riconext/hermes-repo";
-var __dirname = dirname5(fileURLToPath2(import.meta.url));
+var __dirname = dirname6(fileURLToPath3(import.meta.url));
 function readPkgVersion() {
-  const pkgPath = join15(__dirname, "..", "package.json");
-  const pkg = JSON.parse(readFileSync14(pkgPath, "utf8"));
+  const pkgPath = join16(__dirname, "..", "package.json");
+  const pkg = JSON.parse(readFileSync13(pkgPath, "utf8"));
   return pkg.version;
 }
 
 // src/init/templateDir.ts
 function resolveTemplateDir() {
-  const here = dirname6(fileURLToPath3(import.meta.url));
+  const here = dirname7(fileURLToPath4(import.meta.url));
   const candidates = [
-    join16(here, "templates"),
-    join16(here, "..", "..", "templates")
+    join17(here, "templates"),
+    join17(here, "..", "..", "templates")
   ];
   for (const dir of candidates) {
-    if (existsSync14(dir)) {
+    if (existsSync13(dir)) {
       return dir;
     }
   }
-  return join16(here, "templates");
+  return join17(here, "templates");
 }
 var templateDir = resolveTemplateDir();
 function resolveTemplatePath(name) {
-  return join16(templateDir, name);
+  return join17(templateDir, name);
 }
 function readTemplate(name) {
-  return readFileSync15(resolveTemplatePath(name), "utf8");
+  return readFileSync14(resolveTemplatePath(name), "utf8");
 }
 function renderTemplate(name) {
   const raw = readTemplate(name);
@@ -2576,16 +2641,16 @@ function renderTemplate(name) {
 // src/init/mergeClaudeSettings.ts
 var CLAUDE_SETTINGS_LOCAL_REL = ".claude/settings.local.json";
 function claudeSettingsLocalPath(repoRoot) {
-  return join17(repoRoot, ".claude", "settings.local.json");
+  return join18(repoRoot, ".claude", "settings.local.json");
 }
 function mergeClaudeLocalSettings(repoRoot) {
   const settingsPath = claudeSettingsLocalPath(repoRoot);
-  const existed = existsSync15(settingsPath);
+  const existed = existsSync14(settingsPath);
   const templateParsed = JSON.parse(renderTemplate("hooks.json.tpl"));
   let existing = {};
   if (existed) {
     try {
-      existing = JSON.parse(readFileSync16(settingsPath, "utf8"));
+      existing = JSON.parse(readFileSync15(settingsPath, "utf8"));
     } catch {
       existing = {};
     }
@@ -2613,7 +2678,7 @@ var claudeCodeAdapter = {
   available: true,
   scaffoldPaths: [CLAUDE_SETTINGS_LOCAL_REL],
   write(ctx) {
-    mkdirSync7(join18(ctx.repoRoot, ".claude"), { recursive: true });
+    mkdirSync7(join19(ctx.repoRoot, ".claude"), { recursive: true });
     const { content, action } = mergeClaudeLocalSettings(ctx.repoRoot);
     writeFileSync6(claudeSettingsLocalPath(ctx.repoRoot), content, "utf8");
     ctx.report.files.push({ path: CLAUDE_SETTINGS_LOCAL_REL, action });
@@ -2622,11 +2687,11 @@ var claudeCodeAdapter = {
 
 // src/init/assistants/codex.ts
 import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync7 } from "fs";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 
 // src/init/mergeCodexConfig.ts
-import { existsSync as existsSync16, readFileSync as readFileSync17 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync16 } from "fs";
+import { join as join20 } from "path";
 var CODEX_CONFIG_REL = ".codex/config.toml";
 var CODEX_HERMES_START_MARKER = "# >>> hermes-repo codex (do not edit this block manually)";
 var CODEX_HERMES_END_MARKER = "# <<< hermes-repo codex";
@@ -2640,7 +2705,7 @@ function buildCodexHermesBlock() {
   ].join("\n");
 }
 function codexConfigPath(repoRoot) {
-  return join19(repoRoot, ".codex", "config.toml");
+  return join20(repoRoot, ".codex", "config.toml");
 }
 function spliceHermesBlock(existing, block) {
   const startIdx = existing.indexOf(CODEX_HERMES_START_MARKER);
@@ -2663,7 +2728,7 @@ ${after}` : ""}
 }
 function mergeCodexConfig(repoRoot) {
   const configPath = codexConfigPath(repoRoot);
-  const existed = existsSync16(configPath);
+  const existed = existsSync15(configPath);
   const block = buildCodexHermesBlock();
   if (!existed) {
     return {
@@ -2672,7 +2737,7 @@ function mergeCodexConfig(repoRoot) {
       action: "created"
     };
   }
-  const existing = readFileSync17(configPath, "utf8");
+  const existing = readFileSync16(configPath, "utf8");
   const hasBlock = existing.includes(CODEX_HERMES_START_MARKER) && existing.includes(CODEX_HERMES_END_MARKER);
   return {
     content: spliceHermesBlock(existing, block),
@@ -2687,7 +2752,7 @@ var codexAdapter = {
   available: true,
   scaffoldPaths: [CODEX_CONFIG_REL],
   write(ctx) {
-    mkdirSync8(join20(ctx.repoRoot, ".codex"), { recursive: true });
+    mkdirSync8(join21(ctx.repoRoot, ".codex"), { recursive: true });
     const { content, action } = mergeCodexConfig(ctx.repoRoot);
     writeFileSync7(codexConfigPath(ctx.repoRoot), content, "utf8");
     ctx.report.files.push({ path: CODEX_CONFIG_REL, action });
@@ -2696,25 +2761,25 @@ var codexAdapter = {
 
 // src/init/assistants/codebuddy.ts
 import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync8 } from "fs";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 
 // src/init/mergeCodebuddySettings.ts
-import { existsSync as existsSync17, readFileSync as readFileSync18 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync17 } from "fs";
+import { join as join22 } from "path";
 var CODEBUDDY_SETTINGS_LOCAL_REL = ".codebuddy/settings.local.json";
 function codebuddySettingsLocalPath(repoRoot) {
-  return join21(repoRoot, ".codebuddy", "settings.local.json");
+  return join22(repoRoot, ".codebuddy", "settings.local.json");
 }
 function mergeCodebuddyLocalSettings(repoRoot) {
   const settingsPath = codebuddySettingsLocalPath(repoRoot);
-  const existed = existsSync17(settingsPath);
+  const existed = existsSync16(settingsPath);
   const templateParsed = JSON.parse(
     renderTemplate("hooks.codebuddy.json.tpl")
   );
   let existing = {};
   if (existed) {
     try {
-      existing = JSON.parse(readFileSync18(settingsPath, "utf8"));
+      existing = JSON.parse(readFileSync17(settingsPath, "utf8"));
     } catch {
       existing = {};
     }
@@ -2742,7 +2807,7 @@ var codebuddyAdapter = {
   available: true,
   scaffoldPaths: [CODEBUDDY_SETTINGS_LOCAL_REL],
   write(ctx) {
-    mkdirSync9(join22(ctx.repoRoot, ".codebuddy"), { recursive: true });
+    mkdirSync9(join23(ctx.repoRoot, ".codebuddy"), { recursive: true });
     const { content, action } = mergeCodebuddyLocalSettings(ctx.repoRoot);
     writeFileSync8(codebuddySettingsLocalPath(ctx.repoRoot), content, "utf8");
     ctx.report.files.push({ path: CODEBUDDY_SETTINGS_LOCAL_REL, action });
@@ -2751,23 +2816,23 @@ var codebuddyAdapter = {
 
 // src/init/assistants/cursor.ts
 import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync9 } from "fs";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 
 // src/init/mergeCursorHooks.ts
-import { existsSync as existsSync18, readFileSync as readFileSync19 } from "fs";
-import { join as join23 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync18 } from "fs";
+import { join as join24 } from "path";
 var CURSOR_HOOKS_REL = ".cursor/hooks.json";
 function cursorHooksPath(repoRoot) {
-  return join23(repoRoot, ".cursor", "hooks.json");
+  return join24(repoRoot, ".cursor", "hooks.json");
 }
 function mergeCursorHooks(repoRoot) {
   const hooksPath = cursorHooksPath(repoRoot);
-  const existed = existsSync18(hooksPath);
+  const existed = existsSync17(hooksPath);
   const templateParsed = JSON.parse(renderTemplate("hooks.cursor.json.tpl"));
   let existing = {};
   if (existed) {
     try {
-      existing = JSON.parse(readFileSync19(hooksPath, "utf8"));
+      existing = JSON.parse(readFileSync18(hooksPath, "utf8"));
     } catch {
       existing = {};
     }
@@ -2796,7 +2861,7 @@ var cursorAdapter = {
   available: true,
   scaffoldPaths: [CURSOR_HOOKS_REL],
   write(ctx) {
-    mkdirSync10(join24(ctx.repoRoot, ".cursor"), { recursive: true });
+    mkdirSync10(join25(ctx.repoRoot, ".cursor"), { recursive: true });
     const { content, action } = mergeCursorHooks(ctx.repoRoot);
     writeFileSync9(cursorHooksPath(ctx.repoRoot), content, "utf8");
     ctx.report.files.push({ path: CURSOR_HOOKS_REL, action });
@@ -2859,29 +2924,29 @@ function validateAssistantSelection(ids) {
 
 // src/init/ensureDirs.ts
 import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync10 } from "fs";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 function ensureMemoryTree(repoRoot) {
-  const memoryRoot = join25(repoRoot, MEMORY_DIR);
+  const memoryRoot = join26(repoRoot, MEMORY_DIR);
   mkdirSync11(memoryRoot, { recursive: true });
   for (const sub of MEMORY_SUBDIRS) {
-    mkdirSync11(join25(memoryRoot, sub), { recursive: true });
+    mkdirSync11(join26(memoryRoot, sub), { recursive: true });
   }
-  mkdirSync11(join25(repoRoot, ".claude"), { recursive: true });
+  mkdirSync11(join26(repoRoot, ".claude"), { recursive: true });
   for (const sub of GITKEEP_DIRS) {
-    const keepPath = join25(memoryRoot, sub, ".gitkeep");
+    const keepPath = join26(memoryRoot, sub, ".gitkeep");
     writeFileSync10(keepPath, "", { flag: "a" });
   }
 }
 
 // src/init/mergeAssistants.ts
-import { existsSync as existsSync19, readFileSync as readFileSync20 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync19 } from "fs";
 function readExistingAssistants(repoRoot) {
   const configPath = memoryPath(repoRoot, "config.json");
-  if (!existsSync19(configPath)) {
+  if (!existsSync18(configPath)) {
     return [];
   }
   try {
-    const config = JSON.parse(readFileSync20(configPath, "utf8"));
+    const config = JSON.parse(readFileSync19(configPath, "utf8"));
     if (!Array.isArray(config.assistants)) {
       return [];
     }
@@ -2896,16 +2961,16 @@ function mergeAssistants(repoRoot, selected) {
 }
 
 // src/init/mergeGitignore.ts
-import { existsSync as existsSync20, readFileSync as readFileSync21, writeFileSync as writeFileSync11 } from "fs";
-import { join as join26 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync20, writeFileSync as writeFileSync11 } from "fs";
+import { join as join27 } from "path";
 var START_MARKER = "# >>> hermes-repo memory (do not edit this block manually)";
 var END_MARKER = "# <<< hermes-repo memory";
 function mergeHermesGitignore(repoRoot) {
   const block = readTemplate("gitignore-block.txt").trimEnd() + "\n";
-  const gitignorePath = join26(repoRoot, ".gitignore");
-  const contentBefore = existsSync20(gitignorePath) ? readFileSync21(gitignorePath, "utf8") : "";
+  const gitignorePath = join27(repoRoot, ".gitignore");
+  const contentBefore = existsSync19(gitignorePath) ? readFileSync20(gitignorePath, "utf8") : "";
   const warnBroadMemoryIgnore = contentBefore.length > 0 && !contentBefore.includes(START_MARKER) && /(^|\n)\.memory\/\s*$/m.test(contentBefore);
-  if (!existsSync20(gitignorePath)) {
+  if (!existsSync19(gitignorePath)) {
     writeFileSync11(gitignorePath, `${block}
 `, "utf8");
     return { action: "created", warnBroadMemoryIgnore: false };
@@ -2937,22 +3002,33 @@ function mergeHermesGitignore(repoRoot) {
 import { copyFileSync, mkdirSync as mkdirSync12, writeFileSync as writeFileSync14 } from "fs";
 
 // src/init/mergeConfig.ts
-import { existsSync as existsSync21, readFileSync as readFileSync22 } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync21 } from "fs";
 var DEFAULT_LLM = {
   enabled: false,
+  provider: "openai",
   baseUrl: "https://api.openai.com/v1",
-  model: "gpt-4o"
+  model: "gpt-4o",
+  apiKey: "",
+  timeoutMs: 6e4,
+  maxInputChars: 24e3,
+  mode: "async"
 };
 var DEFAULT_CONSOLIDATE = {
-  autoArchiveDays: 30
+  autoArchiveDays: 30,
+  autoFlush: {
+    enabled: false,
+    minPendingSessions: 3,
+    minIntervalMinutes: 30,
+    maxPendingChars: 2e4
+  }
 };
 function mergeConfigForInit(repoRoot, assistants) {
   const configPath = memoryPath(repoRoot, "config.json");
-  const existed = existsSync21(configPath);
+  const existed = existsSync20(configPath);
   let existing = {};
   if (existed) {
     try {
-      existing = JSON.parse(readFileSync22(configPath, "utf8"));
+      existing = JSON.parse(readFileSync21(configPath, "utf8"));
     } catch {
       existing = {};
     }
@@ -2960,6 +3036,7 @@ function mergeConfigForInit(repoRoot, assistants) {
   const prevStorage = existing.storage && typeof existing.storage === "object" && !Array.isArray(existing.storage) ? existing.storage : {};
   const prevLlm = existing.llm && typeof existing.llm === "object" && !Array.isArray(existing.llm) ? existing.llm : {};
   const prevConsolidate = existing.consolidate && typeof existing.consolidate === "object" && !Array.isArray(existing.consolidate) ? existing.consolidate : {};
+  const prevAutoFlush = prevConsolidate.autoFlush && typeof prevConsolidate.autoFlush === "object" && !Array.isArray(prevConsolidate.autoFlush) ? prevConsolidate.autoFlush : {};
   const merged = {
     ...existing,
     version: 2,
@@ -2970,7 +3047,14 @@ function mergeConfigForInit(repoRoot, assistants) {
     assistants,
     debug: existing.debug === true,
     llm: { ...DEFAULT_LLM, ...prevLlm },
-    consolidate: { ...DEFAULT_CONSOLIDATE, ...prevConsolidate }
+    consolidate: {
+      ...DEFAULT_CONSOLIDATE,
+      ...prevConsolidate,
+      autoFlush: {
+        ...DEFAULT_CONSOLIDATE.autoFlush,
+        ...prevAutoFlush
+      }
+    }
   };
   return {
     content: `${JSON.stringify(merged, null, 2)}
@@ -2980,8 +3064,8 @@ function mergeConfigForInit(repoRoot, assistants) {
 }
 
 // src/init/mergeAgentsMd.ts
-import { existsSync as existsSync22, readFileSync as readFileSync23, writeFileSync as writeFileSync12 } from "fs";
-import { join as join27 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync22, writeFileSync as writeFileSync12 } from "fs";
+import { join as join28 } from "path";
 var HERMES_AGENTS_START_MARKER = "<!-- >>> hermes-repo agents (do not edit this block manually) -->";
 var HERMES_AGENTS_END_MARKER = "<!-- <<< hermes-repo agents -->";
 function buildHermesAgentsBlockBody() {
@@ -3037,13 +3121,13 @@ function spliceHermesBlock2(existing, block) {
 `;
 }
 function mergeAgentsMd(repoRoot, force) {
-  const agentsPath = join27(repoRoot, "AGENTS.md");
+  const agentsPath = join28(repoRoot, "AGENTS.md");
   const block = buildHermesAgentsMarkedBlock();
-  if (!existsSync22(agentsPath)) {
+  if (!existsSync21(agentsPath)) {
     writeFileSync12(agentsPath, buildNewAgentsMd(), "utf8");
     return "created";
   }
-  const content = readFileSync23(agentsPath, "utf8");
+  const content = readFileSync22(agentsPath, "utf8");
   if (agentsMdHasHermesBlock(content)) {
     if (!force) {
       return "skipped";
@@ -3059,9 +3143,9 @@ function mergeAgentsMd(repoRoot, force) {
 }
 
 // src/init/scaffoldWrite.ts
-import { existsSync as existsSync23, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync22, writeFileSync as writeFileSync13 } from "fs";
 function shouldWriteFile(absolutePath, force) {
-  if (!existsSync23(absolutePath)) {
+  if (!existsSync22(absolutePath)) {
     return { write: true, action: "created" };
   }
   if (force) {
@@ -3151,15 +3235,15 @@ function writeScaffoldFiles(repoRoot, opts, report) {
 
 // src/init/prompts.ts
 import { checkbox, confirm, input } from "@inquirer/prompts";
-import { existsSync as existsSync24, readFileSync as readFileSync24 } from "fs";
+import { existsSync as existsSync23, readFileSync as readFileSync23 } from "fs";
 import { resolve as resolve6 } from "path";
 function isInitialized(targetDir) {
   const configPath = memoryPath(targetDir, "config.json");
-  if (!existsSync24(configPath)) {
+  if (!existsSync23(configPath)) {
     return false;
   }
   try {
-    const config = JSON.parse(readFileSync24(configPath, "utf8"));
+    const config = JSON.parse(readFileSync23(configPath, "utf8"));
     return typeof config.version === "number" && config.version >= 1;
   } catch {
     return false;