@riconext/hermes-repo 0.13.0 → 0.14.0

package/dist/cli.js

@@ -201,10 +201,36 @@ function serializeLlmConfig(cfg) {
 import { readFileSync as readFileSync3 } from "fs";
 import { basename } from "path";
 var FILE_CHANGE_TOOLS = /^(Write|Edit|MultiEdit|NotebookEdit|write|edit)$/i;
+var SKIP_LINE_TYPES = /* @__PURE__ */ new Set([
+  "file-history-snapshot",
+  "summary",
+  "function_call_result"
+]);
+function textFromContentParts(content) {
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content.map((part) => {
+    if (!part || typeof part !== "object") {
+      return "";
+    }
+    const p = part;
+    if (typeof p.text === "string") {
+      return p.text;
+    }
+    return "";
+  }).filter(Boolean).join("\n");
+}
 function extractText(record) {
   if (typeof record.content === "string") {
     return record.content;
   }
+  if (Array.isArray(record.content)) {
+    const top = textFromContentParts(record.content);
+    if (top) {
+      return top;
+    }
+  }
   const message = record.message;
   if (message && typeof message === "object") {
     const msg = message;
@@ -212,12 +238,7 @@ function extractText(record) {
       return msg.content;
     }
     if (Array.isArray(msg.content)) {
-      return msg.content.map((part) => {
-        if (part && typeof part === "object" && "text" in part) {
-          return String(part.text);
-        }
-        return "";
-      }).join("\n");
+      return textFromContentParts(msg.content);
     }
   }
   return "";
@@ -233,9 +254,13 @@ function inferRole(record) {
   }
   return "unknown";
 }
+function isSkippedLine(record) {
+  const t = String(record.type ?? "").toLowerCase();
+  return SKIP_LINE_TYPES.has(t);
+}
 function isToolUse(record) {
   const t = String(record.type ?? "").toLowerCase();
-  return t === "tool_use" || t === "tool";
+  return t === "tool_use" || t === "tool" || t === "function_call";
 }
 function toolName(record) {
   if (typeof record.name === "string") return record.name;
@@ -284,6 +309,9 @@ function parseJsonlFile(jsonlPath) {
     if (!trimmed) continue;
     try {
       const record = JSON.parse(trimmed);
+      if (isSkippedLine(record)) {
+        continue;
+      }
       if (isToolUse(record)) {
         toolCalls += 1;
         const name = toolName(record);
@@ -907,6 +935,7 @@ function parseHookInputJson(raw) {
     const transcriptPath = transcriptRaw && existsSync6(transcriptRaw) ? resolve2(transcriptRaw) : void 0;
     return {
       transcriptPath,
+      transcriptPathRaw: transcriptRaw,
       hookEventName: pickString(parsed, "hook_event_name", "hookEventName"),
       sessionId: pickString(parsed, "session_id", "sessionId"),
       conversationId: pickString(parsed, "conversation_id", "conversationId"),
@@ -932,7 +961,7 @@ function isCodebuddyCaptureHook(hook) {
   if (!hook) {
     return false;
   }
-  return isTranscriptUnderAssistant(hook.transcriptPath, ".codebuddy");
+  return isTranscriptUnderAssistant(hook.transcriptPath, ".codebuddy") || isTranscriptUnderAssistant(hook.transcriptPathRaw, ".codebuddy");
 }
 function isClaudeCaptureHook(hook) {
   if (!hook) {
@@ -3498,6 +3527,14 @@ function runCaptureCommand(opts) {
   const debug = ctx?.config.debug === true;
   configureDebugLogging(ctx?.repoRoot ?? null, debug);
   const hookInput = readHookInputSync();
+  if (hookInput && isCodebuddyCaptureHook(hookInput)) {
+    const stdinPath = hookInput.transcriptPathRaw ?? hookInput.transcriptPath ?? "(missing)";
+    debugLog(
+      debug,
+      "capture",
+      `codebuddy stop stdin transcript_path=${stdinPath}`
+    );
+  }
   finalizeHookCommand(async () => {
     await runCapture({
       cwd: opts.cwd,
@@ -3698,27 +3735,101 @@ var claudeCodeAdapter = {
   }
 };
 
-// src/init/assistants/codebuddy.ts
+// src/init/assistants/codex.ts
 import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync14 } from "fs";
 import { join as join27 } from "path";
 
-// src/init/mergeCodebuddySettings.ts
+// src/init/mergeCodexConfig.ts
 import { existsSync as existsSync24, readFileSync as readFileSync24 } from "fs";
 import { join as join26 } 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";
+function buildCodexHermesBlock() {
+  return [
+    CODEX_HERMES_START_MARKER,
+    "# Hermes uses AGENTS.md as the shared Codex project guidance entry.",
+    "# Run `npx @riconext/hermes-repo search <keyword>` to inspect project memory.",
+    '# Run `npx @riconext/hermes-repo ref --capture <path> --reason "..."` after using memory.',
+    CODEX_HERMES_END_MARKER
+  ].join("\n");
+}
+function codexConfigPath(repoRoot) {
+  return join26(repoRoot, ".codex", "config.toml");
+}
+function spliceHermesBlock(existing, block) {
+  const startIdx = existing.indexOf(CODEX_HERMES_START_MARKER);
+  const endIdx = existing.indexOf(CODEX_HERMES_END_MARKER);
+  if (startIdx >= 0 && endIdx >= startIdx) {
+    const before = existing.slice(0, startIdx).trimEnd();
+    const after = existing.slice(endIdx + CODEX_HERMES_END_MARKER.length).trimStart();
+    return `${before ? `${before}
+
+` : ""}${block}${after ? `
+
+${after}` : ""}
+`;
+  }
+  const trimmed = existing.trimEnd();
+  return `${trimmed ? `${trimmed}
+
+` : ""}${block}
+`;
+}
+function mergeCodexConfig(repoRoot) {
+  const configPath = codexConfigPath(repoRoot);
+  const existed = existsSync24(configPath);
+  const block = buildCodexHermesBlock();
+  if (!existed) {
+    return {
+      content: `${block}
+`,
+      action: "created"
+    };
+  }
+  const existing = readFileSync24(configPath, "utf8");
+  const hasBlock = existing.includes(CODEX_HERMES_START_MARKER) && existing.includes(CODEX_HERMES_END_MARKER);
+  return {
+    content: spliceHermesBlock(existing, block),
+    action: hasBlock ? "replaced" : "appended"
+  };
+}
+
+// src/init/assistants/codex.ts
+var codexAdapter = {
+  id: "codex",
+  label: "OpenAI Codex\uFF08AGENTS.md + .codex/config.toml\uFF09",
+  available: true,
+  scaffoldPaths: [CODEX_CONFIG_REL],
+  write(ctx) {
+    mkdirSync9(join27(ctx.repoRoot, ".codex"), { recursive: true });
+    const { content, action } = mergeCodexConfig(ctx.repoRoot);
+    writeFileSync14(codexConfigPath(ctx.repoRoot), content, "utf8");
+    ctx.report.files.push({ path: CODEX_CONFIG_REL, action });
+  }
+};
+
+// src/init/assistants/codebuddy.ts
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync15 } from "fs";
+import { join as join29 } from "path";
+
+// src/init/mergeCodebuddySettings.ts
+import { existsSync as existsSync25, readFileSync as readFileSync25 } from "fs";
+import { join as join28 } from "path";
 var CODEBUDDY_SETTINGS_LOCAL_REL = ".codebuddy/settings.local.json";
 function codebuddySettingsLocalPath(repoRoot) {
-  return join26(repoRoot, ".codebuddy", "settings.local.json");
+  return join28(repoRoot, ".codebuddy", "settings.local.json");
 }
 function mergeCodebuddyLocalSettings(repoRoot) {
   const settingsPath = codebuddySettingsLocalPath(repoRoot);
-  const existed = existsSync24(settingsPath);
+  const existed = existsSync25(settingsPath);
   const templateParsed = JSON.parse(
     renderTemplate("hooks.codebuddy.json.tpl")
   );
   let existing = {};
   if (existed) {
     try {
-      existing = JSON.parse(readFileSync24(settingsPath, "utf8"));
+      existing = JSON.parse(readFileSync25(settingsPath, "utf8"));
     } catch {
       existing = {};
     }
@@ -3746,32 +3857,32 @@ var codebuddyAdapter = {
   available: true,
   scaffoldPaths: [CODEBUDDY_SETTINGS_LOCAL_REL],
   write(ctx) {
-    mkdirSync9(join27(ctx.repoRoot, ".codebuddy"), { recursive: true });
+    mkdirSync10(join29(ctx.repoRoot, ".codebuddy"), { recursive: true });
     const { content, action } = mergeCodebuddyLocalSettings(ctx.repoRoot);
-    writeFileSync14(codebuddySettingsLocalPath(ctx.repoRoot), content, "utf8");
+    writeFileSync15(codebuddySettingsLocalPath(ctx.repoRoot), content, "utf8");
     ctx.report.files.push({ path: CODEBUDDY_SETTINGS_LOCAL_REL, action });
   }
 };
 
 // src/init/assistants/cursor.ts
-import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync15 } from "fs";
-import { join as join29 } from "path";
+import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync16 } from "fs";
+import { join as join31 } from "path";
 
 // src/init/mergeCursorHooks.ts
-import { existsSync as existsSync25, readFileSync as readFileSync25 } from "fs";
-import { join as join28 } from "path";
+import { existsSync as existsSync26, readFileSync as readFileSync26 } from "fs";
+import { join as join30 } from "path";
 var CURSOR_HOOKS_REL = ".cursor/hooks.json";
 function cursorHooksPath(repoRoot) {
-  return join28(repoRoot, ".cursor", "hooks.json");
+  return join30(repoRoot, ".cursor", "hooks.json");
 }
 function mergeCursorHooks(repoRoot) {
   const hooksPath = cursorHooksPath(repoRoot);
-  const existed = existsSync25(hooksPath);
+  const existed = existsSync26(hooksPath);
   const templateParsed = JSON.parse(renderTemplate("hooks.cursor.json.tpl"));
   let existing = {};
   if (existed) {
     try {
-      existing = JSON.parse(readFileSync25(hooksPath, "utf8"));
+      existing = JSON.parse(readFileSync26(hooksPath, "utf8"));
     } catch {
       existing = {};
     }
@@ -3800,9 +3911,9 @@ var cursorAdapter = {
   available: true,
   scaffoldPaths: [CURSOR_HOOKS_REL],
   write(ctx) {
-    mkdirSync10(join29(ctx.repoRoot, ".cursor"), { recursive: true });
+    mkdirSync11(join31(ctx.repoRoot, ".cursor"), { recursive: true });
     const { content, action } = mergeCursorHooks(ctx.repoRoot);
-    writeFileSync15(cursorHooksPath(ctx.repoRoot), content, "utf8");
+    writeFileSync16(cursorHooksPath(ctx.repoRoot), content, "utf8");
     ctx.report.files.push({ path: CURSOR_HOOKS_REL, action });
   }
 };
@@ -3812,7 +3923,8 @@ var DEFAULT_ASSISTANT_IDS = ["claude-code"];
 var ALL_ADAPTERS = [
   claudeCodeAdapter,
   cursorAdapter,
-  codebuddyAdapter
+  codebuddyAdapter,
+  codexAdapter
 ];
 var ADAPTER_BY_ID = new Map(
   ALL_ADAPTERS.map((a) => [a.id, a])
@@ -3861,30 +3973,30 @@ function validateAssistantSelection(ids) {
 }
 
 // src/init/ensureDirs.ts
-import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync16 } from "fs";
-import { join as join30 } from "path";
+import { mkdirSync as mkdirSync12, writeFileSync as writeFileSync17 } from "fs";
+import { join as join32 } from "path";
 function ensureMemoryTree(repoRoot) {
-  const memoryRoot = join30(repoRoot, MEMORY_DIR);
-  mkdirSync11(memoryRoot, { recursive: true });
+  const memoryRoot = join32(repoRoot, MEMORY_DIR);
+  mkdirSync12(memoryRoot, { recursive: true });
   for (const sub of MEMORY_SUBDIRS) {
-    mkdirSync11(join30(memoryRoot, sub), { recursive: true });
+    mkdirSync12(join32(memoryRoot, sub), { recursive: true });
   }
-  mkdirSync11(join30(repoRoot, ".claude"), { recursive: true });
+  mkdirSync12(join32(repoRoot, ".claude"), { recursive: true });
   for (const sub of GITKEEP_DIRS) {
-    const keepPath = join30(memoryRoot, sub, ".gitkeep");
-    writeFileSync16(keepPath, "", { flag: "a" });
+    const keepPath = join32(memoryRoot, sub, ".gitkeep");
+    writeFileSync17(keepPath, "", { flag: "a" });
   }
 }
 
 // src/init/mergeAssistants.ts
-import { existsSync as existsSync26, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync27 } from "fs";
 function readExistingAssistants(repoRoot) {
   const configPath = memoryPath(repoRoot, "config.json");
-  if (!existsSync26(configPath)) {
+  if (!existsSync27(configPath)) {
     return [];
   }
   try {
-    const config = JSON.parse(readFileSync26(configPath, "utf8"));
+    const config = JSON.parse(readFileSync27(configPath, "utf8"));
     if (!Array.isArray(config.assistants)) {
       return [];
     }
@@ -3899,17 +4011,17 @@ function mergeAssistants(repoRoot, selected) {
 }
 
 // src/init/mergeGitignore.ts
-import { existsSync as existsSync27, readFileSync as readFileSync27, writeFileSync as writeFileSync17 } from "fs";
-import { join as join31 } from "path";
+import { existsSync as existsSync28, readFileSync as readFileSync28, writeFileSync as writeFileSync18 } from "fs";
+import { join as join33 } 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 = join31(repoRoot, ".gitignore");
-  const contentBefore = existsSync27(gitignorePath) ? readFileSync27(gitignorePath, "utf8") : "";
+  const gitignorePath = join33(repoRoot, ".gitignore");
+  const contentBefore = existsSync28(gitignorePath) ? readFileSync28(gitignorePath, "utf8") : "";
   const warnBroadMemoryIgnore = contentBefore.length > 0 && !contentBefore.includes(START_MARKER) && /(^|\n)\.memory\/\s*$/m.test(contentBefore);
-  if (!existsSync27(gitignorePath)) {
-    writeFileSync17(gitignorePath, `${block}
+  if (!existsSync28(gitignorePath)) {
+    writeFileSync18(gitignorePath, `${block}
 `, "utf8");
     return { action: "created", warnBroadMemoryIgnore: false };
   }
@@ -3919,7 +4031,7 @@ function mergeHermesGitignore(repoRoot) {
     const before = contentBefore.slice(0, startIdx);
     const after = contentBefore.slice(endIdx + END_MARKER.length);
     const next = `${before}${block}${after}`.replace(/\n{3,}/g, "\n\n");
-    writeFileSync17(gitignorePath, next.endsWith("\n") ? next : `${next}
+    writeFileSync18(gitignorePath, next.endsWith("\n") ? next : `${next}
 `, "utf8");
     return { action: "replaced", warnBroadMemoryIgnore };
   }
@@ -3927,11 +4039,11 @@ function mergeHermesGitignore(repoRoot) {
     const before = contentBefore.slice(0, startIdx);
     const next = `${before}${block}
 `;
-    writeFileSync17(gitignorePath, next, "utf8");
+    writeFileSync18(gitignorePath, next, "utf8");
     return { action: "updated", warnBroadMemoryIgnore };
   }
   const separator = contentBefore.endsWith("\n") || contentBefore.length === 0 ? "\n" : "\n\n";
-  writeFileSync17(gitignorePath, `${contentBefore}${separator}${block}
+  writeFileSync18(gitignorePath, `${contentBefore}${separator}${block}
 `, "utf8");
   return { action: "appended", warnBroadMemoryIgnore };
 }
@@ -4002,8 +4114,8 @@ async function withSpinnerProgress(label, fn, formatDone, stream = process.stder
 }
 
 // src/coldstart/collectors/existingRules.ts
-import { existsSync as existsSync28, readFileSync as readFileSync28, readdirSync as readdirSync9 } from "fs";
-import { join as join32 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync29, readdirSync as readdirSync9 } from "fs";
+import { join as join34 } from "path";
 var MAX_EXCERPT = 3500;
 var RULE_CANDIDATES = [
   "AGENTS.md",
@@ -4011,12 +4123,12 @@ var RULE_CANDIDATES = [
   ".cursorrules"
 ];
 function readExcerpt(repoRoot, rel) {
-  const full = join32(repoRoot, rel);
-  if (!existsSync28(full)) {
+  const full = join34(repoRoot, rel);
+  if (!existsSync29(full)) {
     return null;
   }
   try {
-    const raw = readFileSync28(full, "utf8");
+    const raw = readFileSync29(full, "utf8");
     return raw.length > MAX_EXCERPT ? `${raw.slice(0, MAX_EXCERPT)}
 ...(truncated)` : raw;
   } catch {
@@ -4024,8 +4136,8 @@ function readExcerpt(repoRoot, rel) {
   }
 }
 function collectCursorRules(repoRoot) {
-  const dir = join32(repoRoot, ".cursor", "rules");
-  if (!existsSync28(dir)) {
+  const dir = join34(repoRoot, ".cursor", "rules");
+  if (!existsSync29(dir)) {
     return [];
   }
   const out = [];
@@ -4076,8 +4188,8 @@ function collectGitLog(repoRoot, limit = 50) {
 }
 
 // src/coldstart/collectors/packageJson.ts
-import { existsSync as existsSync29, readFileSync as readFileSync29 } from "fs";
-import { join as join33 } from "path";
+import { existsSync as existsSync30, readFileSync as readFileSync30 } from "fs";
+import { join as join35 } from "path";
 var STACK_HINTS = {
   react: "react",
   vue: "vue",
@@ -4110,12 +4222,12 @@ function inferStackTags(deps) {
   return [...tags];
 }
 function collectPackageJson(repoRoot) {
-  const path = join33(repoRoot, "package.json");
-  if (!existsSync29(path)) {
+  const path = join35(repoRoot, "package.json");
+  if (!existsSync30(path)) {
     return null;
   }
   try {
-    const raw = JSON.parse(readFileSync29(path, "utf8"));
+    const raw = JSON.parse(readFileSync30(path, "utf8"));
     return {
       name: raw.name,
       dependencies: depKeys(raw.dependencies),
@@ -4127,8 +4239,8 @@ function collectPackageJson(repoRoot) {
 }
 
 // src/coldstart/collectors/repoSignals.ts
-import { existsSync as existsSync30, readdirSync as readdirSync10 } from "fs";
-import { join as join34 } from "path";
+import { existsSync as existsSync31, readdirSync as readdirSync10 } from "fs";
+import { join as join36 } from "path";
 var SIGNAL_FILES = [
   "Dockerfile",
   "Makefile",
@@ -4140,12 +4252,12 @@ var SIGNAL_FILES = [
 function collectRepoSignals(repoRoot) {
   const signals = [];
   for (const rel of SIGNAL_FILES) {
-    const full = join34(repoRoot, rel);
-    if (existsSync30(full)) {
+    const full = join36(repoRoot, rel);
+    if (existsSync31(full)) {
       signals.push(rel);
     }
   }
-  if (existsSync30(join34(repoRoot, ".gitignore"))) {
+  if (existsSync31(join36(repoRoot, ".gitignore"))) {
     signals.push(".gitignore");
   }
   try {
@@ -4290,7 +4402,7 @@ function runProjectScan(repoRoot) {
 
 // src/init/prompts.ts
 import { checkbox, confirm, input, password } from "@inquirer/prompts";
-import { existsSync as existsSync31, readFileSync as readFileSync30 } from "fs";
+import { existsSync as existsSync32, readFileSync as readFileSync31 } from "fs";
 import { resolve as resolve6 } from "path";
 
 // src/coldstart/countCaptures.ts
@@ -4301,11 +4413,11 @@ function countExistingCaptures(repoRoot) {
 // src/init/prompts.ts
 function isInitialized(targetDir) {
   const configPath = memoryPath(targetDir, "config.json");
-  if (!existsSync31(configPath)) {
+  if (!existsSync32(configPath)) {
     return false;
   }
   try {
-    const config = JSON.parse(readFileSync30(configPath, "utf8"));
+    const config = JSON.parse(readFileSync31(configPath, "utf8"));
     return config.version === 1;
   } catch {
     return false;
@@ -4404,7 +4516,7 @@ async function promptLlmFields(defaults = {}, options = {}) {
 }
 async function gatherLlmInitInput(targetDir) {
   const llmPath = memoryPath(targetDir, "llm.json");
-  if (existsSync31(llmPath)) {
+  if (existsSync32(llmPath)) {
     const overwrite = await confirm({
       message: "\u68C0\u6D4B\u5230\u5DF2\u6709 .memory/llm.json\uFF0C\u662F\u5426\u8986\u76D6\u5E76\u91CD\u65B0\u914D\u7F6E\uFF1F",
       default: false
@@ -4435,17 +4547,17 @@ async function gatherLlmInitInput(targetDir) {
 }
 
 // src/init/writeScaffoldFile.ts
-import { copyFileSync, writeFileSync as writeFileSync21 } from "fs";
+import { copyFileSync, writeFileSync as writeFileSync22 } from "fs";
 
 // src/init/mergeConfig.ts
-import { existsSync as existsSync32, readFileSync as readFileSync31 } from "fs";
+import { existsSync as existsSync33, readFileSync as readFileSync32 } from "fs";
 function mergeConfigForInit(repoRoot, assistants) {
   const configPath = memoryPath(repoRoot, "config.json");
-  const existed = existsSync32(configPath);
+  const existed = existsSync33(configPath);
   let existing = {};
   if (existed) {
     try {
-      existing = JSON.parse(readFileSync31(configPath, "utf8"));
+      existing = JSON.parse(readFileSync32(configPath, "utf8"));
     } catch {
       existing = {};
     }
@@ -4469,8 +4581,8 @@ function mergeConfigForInit(repoRoot, assistants) {
 }
 
 // src/init/mergeAgentsMd.ts
-import { existsSync as existsSync33, readFileSync as readFileSync32, writeFileSync as writeFileSync18 } from "fs";
-import { join as join35 } from "path";
+import { existsSync as existsSync34, readFileSync as readFileSync33, writeFileSync as writeFileSync19 } from "fs";
+import { join as join37 } 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() {
@@ -4507,7 +4619,7 @@ function withGapBeforeHermesBlock(prefix) {
   }
   return `${trimmed}${GAP_BEFORE_HERMES_BLOCK}`;
 }
-function spliceHermesBlock(existing, block) {
+function spliceHermesBlock2(existing, block) {
   const startIdx = existing.indexOf(HERMES_AGENTS_START_MARKER);
   const endIdx = existing.indexOf(HERMES_AGENTS_END_MARKER);
   if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
@@ -4526,32 +4638,32 @@ function spliceHermesBlock(existing, block) {
 `;
 }
 function mergeAgentsMd(repoRoot, force) {
-  const agentsPath = join35(repoRoot, "AGENTS.md");
+  const agentsPath = join37(repoRoot, "AGENTS.md");
   const block = buildHermesAgentsMarkedBlock();
-  if (!existsSync33(agentsPath)) {
-    writeFileSync18(agentsPath, buildNewAgentsMd(), "utf8");
+  if (!existsSync34(agentsPath)) {
+    writeFileSync19(agentsPath, buildNewAgentsMd(), "utf8");
     return "created";
   }
-  const content = readFileSync32(agentsPath, "utf8");
+  const content = readFileSync33(agentsPath, "utf8");
   if (agentsMdHasHermesBlock(content)) {
     if (!force) {
       return "skipped";
     }
-    writeFileSync18(agentsPath, spliceHermesBlock(content, block), "utf8");
+    writeFileSync19(agentsPath, spliceHermesBlock2(content, block), "utf8");
     return "replaced";
   }
   if (agentsMdHasLegacyHermesContent(content)) {
     return "skipped";
   }
-  writeFileSync18(agentsPath, spliceHermesBlock(content, block), "utf8");
+  writeFileSync19(agentsPath, spliceHermesBlock2(content, block), "utf8");
   return "appended";
 }
 
 // src/init/mergeLlmConfig.ts
-import { existsSync as existsSync34, writeFileSync as writeFileSync19 } from "fs";
+import { existsSync as existsSync35, writeFileSync as writeFileSync20 } from "fs";
 function mergeLlmConfigForInit(repoRoot, input2) {
   const llmPath = memoryPath(repoRoot, "llm.json");
-  const existed = existsSync34(llmPath);
+  const existed = existsSync35(llmPath);
   let existing = {};
   if (existed) {
     try {
@@ -4580,14 +4692,14 @@ function mergeLlmConfigForInit(repoRoot, input2) {
 }
 function writeLlmJson(repoRoot, input2) {
   const { content, action } = mergeLlmConfigForInit(repoRoot, input2);
-  writeFileSync19(memoryPath(repoRoot, "llm.json"), content, "utf8");
+  writeFileSync20(memoryPath(repoRoot, "llm.json"), content, "utf8");
   return action;
 }
 
 // src/init/scaffoldWrite.ts
-import { existsSync as existsSync35, writeFileSync as writeFileSync20 } from "fs";
+import { existsSync as existsSync36, writeFileSync as writeFileSync21 } from "fs";
 function shouldWriteFile(absolutePath, force) {
-  if (!existsSync35(absolutePath)) {
+  if (!existsSync36(absolutePath)) {
     return { write: true, action: "created" };
   }
   if (force) {
@@ -4601,7 +4713,7 @@ function writeIfAllowed(report, absolutePath, relativePath, content, force) {
     report.files.push({ path: relativePath, action });
     return;
   }
-  writeFileSync20(absolutePath, content, "utf8");
+  writeFileSync21(absolutePath, content, "utf8");
   report.files.push({ path: relativePath, action });
 }
 
@@ -4609,7 +4721,7 @@ function writeIfAllowed(report, absolutePath, relativePath, content, force) {
 function writeConfigJson(report, repoRoot, assistants) {
   const { content, action } = mergeConfigForInit(repoRoot, assistants);
   const absolutePath = memoryPath(repoRoot, "config.json");
-  writeFileSync21(absolutePath, content, "utf8");
+  writeFileSync22(absolutePath, content, "utf8");
   report.files.push({ path: ".memory/config.json", action });
 }
 function copyTemplateIfAllowed(report, templateName, destAbsolute, relativePath, force) {
@@ -4896,10 +5008,10 @@ async function runInitCommand(opts) {
 }
 
 // src/feedback/writeRef.ts
-import { existsSync as existsSync36, mkdirSync as mkdirSync12, writeFileSync as writeFileSync22 } from "fs";
-import { join as join36 } from "path";
+import { existsSync as existsSync37, mkdirSync as mkdirSync13, writeFileSync as writeFileSync23 } from "fs";
+import { join as join38 } from "path";
 function targetExists(repoRoot, target) {
-  return existsSync36(join36(repoRoot, ".memory", target));
+  return existsSync37(join38(repoRoot, ".memory", target));
 }
 function writeRef(opts) {
   const { repoRoot, reason, session } = opts;
@@ -4921,16 +5033,16 @@ function writeRef(opts) {
     date,
     ...session ? { session } : {}
   };
-  mkdirSync12(refsDir(repoRoot), { recursive: true });
+  mkdirSync13(refsDir(repoRoot), { recursive: true });
   const filePath = refFilePath(repoRoot, target, date);
   const base = filePath.replace(/\.json$/, "");
   let finalPath = `${filePath}`;
   let n = 0;
-  while (existsSync36(finalPath)) {
+  while (existsSync37(finalPath)) {
     n++;
     finalPath = `${base}-${n}.json`;
   }
-  writeFileSync22(finalPath, `${JSON.stringify(record, null, 2)}
+  writeFileSync23(finalPath, `${JSON.stringify(record, null, 2)}
 `, "utf8");
   const file = finalPath.split("/refs/").pop() ?? finalPath;
   return { target, file: `refs/${file}` };
@@ -4970,15 +5082,15 @@ function runRefCommand(opts) {
 }
 
 // src/search/runSearch.ts
-import { existsSync as existsSync37, readdirSync as readdirSync11, readFileSync as readFileSync34 } from "fs";
-import { join as join37 } from "path";
+import { existsSync as existsSync38, readdirSync as readdirSync11, readFileSync as readFileSync35 } from "fs";
+import { join as join39 } from "path";
 function walkMdFiles(dir) {
-  if (!existsSync37(dir)) {
+  if (!existsSync38(dir)) {
     return [];
   }
   const out = [];
   for (const name of readdirSync11(dir)) {
-    const full = join37(dir, name);
+    const full = join39(dir, name);
     if (name.endsWith(".md")) {
       out.push(full);
     } else if (!name.startsWith(".")) {
@@ -4987,7 +5099,7 @@ function walkMdFiles(dir) {
         if (Array.isArray(st)) {
           for (const child of readdirSync11(full)) {
             if (child.endsWith(".md")) {
-              out.push(join37(full, child));
+              out.push(join39(full, child));
             }
           }
         }
@@ -4999,13 +5111,13 @@ function walkMdFiles(dir) {
 }
 function listSkillMd(repoRoot) {
   const skillsDir = memoryPath(repoRoot, "skills");
-  if (!existsSync37(skillsDir)) {
+  if (!existsSync38(skillsDir)) {
     return [];
   }
   const out = [];
   for (const slug of readdirSync11(skillsDir)) {
-    const f = join37(skillsDir, slug, "SKILL.md");
-    if (existsSync37(f)) {
+    const f = join39(skillsDir, slug, "SKILL.md");
+    if (existsSync38(f)) {
       out.push(f);
     }
   }
@@ -5013,7 +5125,7 @@ function listSkillMd(repoRoot) {
 }
 function summaryFromFile(absPath, relFromMemory) {
   try {
-    const content = readFileSync34(absPath, "utf8");
+    const content = readFileSync35(absPath, "utf8");
     if (relFromMemory.startsWith("captures/")) {
       const parsed = parseCaptureMarkdown(content, relFromMemory, absPath);
       if (parsed) {
@@ -5036,10 +5148,10 @@ function runSearch(opts) {
   const memRoot = memoryPath(opts.repoRoot);
   const captureTypes = opts.type ? [opts.type] : ["semantic", "episodic", "procedural"];
   for (const t of captureTypes) {
-    const dir = join37(memRoot, "captures", t);
+    const dir = join39(memRoot, "captures", t);
     for (const abs of walkMdFiles(dir)) {
       const rel = abs.replace(memRoot + "/", "").replace(/\\/g, "/");
-      const content = readFileSync34(abs, "utf8").toLowerCase();
+      const content = readFileSync35(abs, "utf8").toLowerCase();
       if (content.includes(kw)) {
         hits.push({
           path: rel,
@@ -5051,10 +5163,10 @@ function runSearch(opts) {
       }
     }
   }
-  const topicsDir = join37(memRoot, "topics");
+  const topicsDir = join39(memRoot, "topics");
   for (const abs of walkMdFiles(topicsDir)) {
     const rel = abs.replace(memRoot + "/", "").replace(/\\/g, "/");
-    if (readFileSync34(abs, "utf8").toLowerCase().includes(kw)) {
+    if (readFileSync35(abs, "utf8").toLowerCase().includes(kw)) {
       hits.push({ path: rel, summary: summaryFromFile(abs, rel) });
     }
     if (hits.length >= limit) {
@@ -5063,7 +5175,7 @@ function runSearch(opts) {
   }
   for (const abs of listSkillMd(opts.repoRoot)) {
     const rel = abs.replace(memRoot + "/", "").replace(/\\/g, "/");
-    if (readFileSync34(abs, "utf8").toLowerCase().includes(kw)) {
+    if (readFileSync35(abs, "utf8").toLowerCase().includes(kw)) {
       hits.push({ path: rel, summary: summaryFromFile(abs, rel) });
     }
     if (hits.length >= limit) {
@@ -5116,7 +5228,7 @@ function runSearchCommand(opts) {
 }
 
 // src/stats/runStats.ts
-import { existsSync as existsSync38, statSync as statSync6 } from "fs";
+import { existsSync as existsSync39, statSync as statSync6 } from "fs";
 function collectStats(repoRoot, nowMs = Date.now()) {
   const all = listAllCaptures(repoRoot);
   const active = filterActiveCaptures(all);
@@ -5146,7 +5258,7 @@ function collectStats(repoRoot, nowMs = Date.now()) {
     }
   }
   const memoryFile = memoryPath(repoRoot, "MEMORY.md");
-  const memoryBytes = existsSync38(memoryFile) ? statSync6(memoryFile).size : 0;
+  const memoryBytes = existsSync39(memoryFile) ? statSync6(memoryFile).size : 0;
   const allSkills = listSkillIndex(repoRoot);
   const skillUsage = readSkillUsage(repoRoot);
   const inMemory = filterSkillIndexForMemory(allSkills, skillUsage, repoRoot, nowMs);
@@ -5213,11 +5325,11 @@ function runStatsCommand(opts) {
 }
 
 // src/promote/runPromote.ts
-import { existsSync as existsSync44, mkdirSync as mkdirSync14, writeFileSync as writeFileSync24 } from "fs";
+import { existsSync as existsSync45, mkdirSync as mkdirSync15, writeFileSync as writeFileSync25 } from "fs";
 import { resolve as resolve8 } from "path";
 
 // src/promote/buildTopicDraft.ts
-import { existsSync as existsSync39, readFileSync as readFileSync35 } from "fs";
+import { existsSync as existsSync40, readFileSync as readFileSync36 } from "fs";
 function ruleTopicDraftBody(tag, captures, existing) {
   const lines = captures.map(
     (c) => `- [${c.date}] [${c.type}] ${c.summary.slice(0, 120)} (${c.path}) [\u664B\u5347\u5019\u9009]`
@@ -5244,9 +5356,9 @@ async function buildTopicDraftBody(repoRoot, captures, llm) {
   const slug = tagToSlug(tag);
   const abs = memoryPath(repoRoot, "topics", `${slug}.md`);
   let existing = "";
-  if (existsSync39(abs)) {
+  if (existsSync40(abs)) {
     try {
-      existing = readFileSync35(abs, "utf8");
+      existing = readFileSync36(abs, "utf8");
     } catch {
       existing = "";
     }
@@ -5271,7 +5383,7 @@ ${c.findings.slice(0, 300)}`
 }
 
 // src/promote/detectTopicConflict.ts
-import { existsSync as existsSync40, readFileSync as readFileSync36 } from "fs";
+import { existsSync as existsSync41, readFileSync as readFileSync37 } from "fs";
 var MUTEX_PAIRS2 = [
   ["localstorage", "httponly"],
   ["local storage", "httponly"],
@@ -5301,12 +5413,12 @@ function detectTopicConflict(repoRoot, capture) {
   const slug = tagToSlug(tag);
   const topicPath = memoryPath(repoRoot, "topics", `${slug}.md`);
   const relTopic = `topics/${slug}.md`;
-  if (!existsSync40(topicPath)) {
+  if (!existsSync41(topicPath)) {
     return { hasConflict: false, reason: "none" };
   }
   let existing = "";
   try {
-    existing = readFileSync36(topicPath, "utf8");
+    existing = readFileSync37(topicPath, "utf8");
   } catch {
     return { hasConflict: false, reason: "none" };
   }
@@ -5472,17 +5584,17 @@ async function buildMergedStagingDrafts(repoRoot, analyses, llm) {
 
 // src/promote/applyDecisions.ts
 import {
-  existsSync as existsSync41,
-  mkdirSync as mkdirSync13,
+  existsSync as existsSync42,
+  mkdirSync as mkdirSync14,
   readdirSync as readdirSync12,
-  readFileSync as readFileSync37,
+  readFileSync as readFileSync38,
   unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync23
+  writeFileSync as writeFileSync24
 } from "fs";
-import { join as join39 } from "path";
+import { join as join41 } from "path";
 
 // src/promote/paths.ts
-import { join as join38 } from "path";
+import { join as join40 } from "path";
 function promoteDir(repoRoot) {
   return memoryPath(repoRoot, "promote");
 }
@@ -5500,7 +5612,7 @@ function resolvePromoteTemplatePath(repoRoot) {
   return inMemory;
 }
 function stagingTopicPath(repoRoot, slug) {
-  return join38(promoteStagingTopicsDir(repoRoot), `${slug}.md`);
+  return join40(promoteStagingTopicsDir(repoRoot), `${slug}.md`);
 }
 
 // src/promote/applyDecisions.ts
@@ -5536,17 +5648,17 @@ function buildManifestTemplate(capturePaths, dateIso) {
 }
 function removePromoteMarker(repoRoot, capturePath) {
   const marker = promoteMarkerPath(repoRoot, capturePath);
-  if (existsSync41(marker)) {
+  if (existsSync42(marker)) {
     unlinkSync3(marker);
   }
 }
 function annotateReject(repoRoot, capturePath, note) {
-  const abs = join39(repoRoot, ".memory", capturePath);
-  if (!existsSync41(abs)) {
+  const abs = join41(repoRoot, ".memory", capturePath);
+  if (!existsSync42(abs)) {
     return;
   }
   try {
-    let content = readFileSync37(abs, "utf8");
+    let content = readFileSync38(abs, "utf8");
     const fields = {
       promote_rejected_at: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)
     };
@@ -5554,22 +5666,22 @@ function annotateReject(repoRoot, capturePath, note) {
       fields.promote_note = note.trim().slice(0, 200);
     }
     content = setFrontmatterScalars(content, fields);
-    writeFileSync23(abs, content, "utf8");
+    writeFileSync24(abs, content, "utf8");
   } catch {
   }
 }
 function mergeTopicFromStaging(repoRoot, slug, dryRun) {
   const staging = stagingTopicPath(repoRoot, slug);
-  if (!existsSync41(staging)) {
+  if (!existsSync42(staging)) {
     return null;
   }
-  const draft = readFileSync37(staging, "utf8");
+  const draft = readFileSync38(staging, "utf8");
   const dest = memoryPath(repoRoot, "topics", `${slug}.md`);
   if (dryRun) {
     return `topics/${slug}.md`;
   }
-  mkdirSync13(memoryPath(repoRoot, "topics"), { recursive: true });
-  writeFileSync23(dest, draft.endsWith("\n") ? draft : `${draft}
+  mkdirSync14(memoryPath(repoRoot, "topics"), { recursive: true });
+  writeFileSync24(dest, draft.endsWith("\n") ? draft : `${draft}
 `, "utf8");
   return `topics/${slug}.md`;
 }
@@ -5605,7 +5717,7 @@ function applyDecisions(repoRoot, manifest, opts) {
   }
   if (slugsToMerge.size === 0 && result.approved.length > 0) {
     const stagingDir = promoteStagingTopicsDir(repoRoot);
-    if (existsSync41(stagingDir)) {
+    if (existsSync42(stagingDir)) {
       for (const name of readdirSync12(stagingDir)) {
         if (name.endsWith(".md")) {
           slugsToMerge.add(name.replace(/\.md$/, ""));
@@ -5622,21 +5734,21 @@ function applyDecisions(repoRoot, manifest, opts) {
   return result;
 }
 function readManifestFile(manifestPath) {
-  const raw = readFileSync37(manifestPath, "utf8");
+  const raw = readFileSync38(manifestPath, "utf8");
   return parseManifestJson(raw);
 }
 function writeManifestTemplate(repoRoot, capturePaths) {
   const dateIso = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const manifest = buildManifestTemplate(capturePaths, dateIso);
   const path = decisionsTemplatePath(repoRoot);
-  mkdirSync13(memoryPath(repoRoot, "promote"), { recursive: true });
-  writeFileSync23(path, `${JSON.stringify(manifest, null, 2)}
+  mkdirSync14(memoryPath(repoRoot, "promote"), { recursive: true });
+  writeFileSync24(path, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
   return path;
 }
 
 // src/promote/buildPrBody.ts
-import { existsSync as existsSync42, readFileSync as readFileSync38 } from "fs";
+import { existsSync as existsSync43, readFileSync as readFileSync39 } from "fs";
 function actionLabel(action) {
   if (action === "approve") {
     return "\u6279\u51C6\u664B\u5347";
@@ -5676,9 +5788,9 @@ ${conflictLine}
 }
 function loadTemplate(repoRoot) {
   const path = resolvePromoteTemplatePath(repoRoot);
-  if (existsSync42(path)) {
+  if (existsSync43(path)) {
     try {
-      return readFileSync38(path, "utf8");
+      return readFileSync39(path, "utf8");
     } catch {
     }
   }
@@ -5726,7 +5838,7 @@ ${items}
 }
 
 // src/promote/listPromoteCandidates.ts
-import { existsSync as existsSync43, readdirSync as readdirSync13 } from "fs";
+import { existsSync as existsSync44, readdirSync as readdirSync13 } from "fs";
 var TYPES2 = ["semantic", "episodic", "procedural"];
 function normalizeCapturePath(input2) {
   let p = input2.replace(/\\/g, "/").trim();
@@ -5743,7 +5855,7 @@ function listPromoteCandidates(repoRoot, filterPaths) {
   const results = [];
   for (const type of TYPES2) {
     const dir = memoryPath(repoRoot, "captures", type);
-    if (!existsSync43(dir)) {
+    if (!existsSync44(dir)) {
       continue;
     }
     for (const name of readdirSync13(dir)) {
@@ -5770,8 +5882,8 @@ function listPromoteCandidates(repoRoot, filterPaths) {
 
 // src/promote/runPromote.ts
 function ensurePromoteDirs(repoRoot) {
-  mkdirSync14(promoteDir(repoRoot), { recursive: true });
-  mkdirSync14(promoteStagingTopicsDir(repoRoot), { recursive: true });
+  mkdirSync15(promoteDir(repoRoot), { recursive: true });
+  mkdirSync15(promoteStagingTopicsDir(repoRoot), { recursive: true });
 }
 function formatPreviewTable(analyses) {
   const lines = [
@@ -5815,15 +5927,15 @@ async function runPromote(opts) {
   const stagingTopicPaths = [];
   for (const [slug, body] of mergedDrafts) {
     const path = stagingTopicPath(repoRoot, slug);
-    writeFileSync24(path, body, "utf8");
+    writeFileSync25(path, body, "utf8");
     stagingTopicPaths.push(
       `.memory/promote/staging/topics/${slug}.md`
     );
   }
   const prBody = buildPrBody(repoRoot, analyses);
   const prBodyPath = opts.outPath ? resolve8(opts.outPath) : defaultPrBodyPath(repoRoot, dateIso);
-  mkdirSync14(memoryPath(repoRoot, "promote"), { recursive: true });
-  writeFileSync24(prBodyPath, prBody, "utf8");
+  mkdirSync15(memoryPath(repoRoot, "promote"), { recursive: true });
+  writeFileSync25(prBodyPath, prBody, "utf8");
   const manifestTemplatePath = writeManifestTemplate(
     repoRoot,
     candidates.map((c) => c.path)