@qxbyte/muse 0.1.3 → 0.2.0

package/dist/index.js

@@ -20,6 +20,15 @@ var Logger = class {
   level = "info";
   logPath;
   fileEnabled = true;
+  /**
+   * 是否把 warn/error 同时打到 stderr。**默认 false**,因为 Ink TUI 会捕获 stderr
+   * 渲染区,造成 "[error] xxx" 拼接到 PermissionModeBar / footer 等正常 UI 后面的
+   * 视觉污染(B-19 修复)。需要 stderr 输出的场景(cli.tsx die / runOneShot)
+   * 都已经在用 process.stderr.write 显式打,不依赖 logger。
+   *
+   * 单元测试 / 后台脚本可显式 setStderrEnabled(true) 开启。
+   */
+  stderrEnabled = false;
   constructor() {
     const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
     this.logPath = join(homedir(), ".muse", "logs", `${date}.jsonl`);
@@ -32,6 +41,9 @@ var Logger = class {
   setLevel(level) {
     this.level = level;
   }
+  setStderrEnabled(enabled) {
+    this.stderrEnabled = enabled;
+  }
   write(level, msg, extra) {
     if (LEVELS[level] < LEVELS[this.level]) return;
     const entry = {
@@ -46,7 +58,7 @@ var Logger = class {
       } catch {
       }
     }
-    if (level === "warn" || level === "error") {
+    if (this.stderrEnabled && (level === "warn" || level === "error")) {
       const prefix = level === "error" ? "[error]" : "[warn]";
       process.stderr.write(`${prefix} ${msg}
 `);
@@ -81,7 +93,11 @@ var DEFAULT_CAPABILITIES = {
   parallelToolCalls: true,
   vision: false,
   jsonMode: true,
-  maxContextWindow: 32e3
+  // 没在 models.local.json 显式声明 contextWindow 时的兜底值。
+  // 200k 是 2026 年主流 LLM(GPT-4.1 / Claude / DeepSeek-v3 / Qwen-Plus / GLM-4 等)的
+  // 常见容量,比 32k 兜底更接近真实,避免 ctx% 大幅虚高 / auto-compact 过早触发。
+  // 仍建议在每条 entry 显式写 contextWindow,避免依赖默认值。
+  maxContextWindow: 2e5
 };
 var OpenAICompatibleClient = class {
   providerName;
@@ -201,8 +217,7 @@ function convertMessages(messages, systemPrompt) {
         if (typeof msg.content === "string") {
           result.push({ role: "user", content: msg.content });
         } else {
-          const text = msg.content.filter((p) => p.type === "text").map((p) => p.text).join("\n");
-          result.push({ role: "user", content: text });
+          result.push({ role: "user", content: convertUserParts(msg.content) });
         }
         break;
       case "assistant":
@@ -226,6 +241,33 @@ function convertMessages(messages, systemPrompt) {
   }
   return result;
 }
+function convertUserParts(parts) {
+  const out = [];
+  for (const part of parts) {
+    if (part.type === "text") {
+      out.push({ type: "text", text: part.text });
+    } else if (part.type === "image") {
+      out.push({
+        type: "image",
+        // SDK 接受 base64 字符串作为 DataContent
+        image: part.data,
+        mimeType: part.mediaType
+      });
+    } else if (part.type === "file") {
+      out.push({
+        type: "text",
+        text: `<file path="${part.path}"${part.mimeType ? ` mimeType="${part.mimeType}"` : ""}>
+${part.text}
+</file>`
+      });
+    }
+  }
+  if (out.length === 0) return "";
+  if (out.every((p) => p.type === "text")) {
+    return out.map((p) => p.text).join("\n\n");
+  }
+  return out;
+}
 function convertAssistantContent(msg) {
   const parts = [];
   for (const part of msg.content) {
@@ -266,11 +308,11 @@ function isRetryable(err) {
   return false;
 }
 async function sleep(ms, abortSignal) {
-  await new Promise((resolve6, reject) => {
+  await new Promise((resolve8, reject) => {
     if (abortSignal?.aborted) return reject(new Error("aborted"));
     const t = setTimeout(() => {
       abortSignal?.removeEventListener("abort", onAbort);
-      resolve6();
+      resolve8();
     }, ms);
     const onAbort = () => {
       clearTimeout(t);
@@ -958,11 +1000,14 @@ var TodoSchema = z7.object({
   activeForm: z7.string().optional().describe("Present-continuous form for the spinner (e.g. 'Running the test suite').")
 });
 var TodoWriteArgs = z7.object({
-  todos: z7.array(TodoSchema).describe("Full list. Replaces the current store.")
+  todos: z7.array(TodoSchema).describe("Full list. Replaces the current store."),
+  listTitle: z7.string().optional().describe(
+    "Short (2-6 word) imperative title describing the OVERALL goal of this todo list, e.g. 'Refactor auth flow' / '\u5206\u6790 Muse \u67B6\u6784' / 'Migrate to ESM'. Shown as the list header in UI. Keep it stable across calls within the same task; only change it if the goal genuinely shifts."
+  )
 });
 var TodoWriteTool = defineTool({
   name: "TodoWrite",
-  description: "Maintain a structured task list for the current session. Pass the FULL list every call (it replaces the store). Mark exactly one task in_progress at a time; mark completed immediately when done; do not batch completions. Use when the task has 3+ distinct steps or is non-trivial. Skip for single trivial actions.",
+  description: "Maintain a structured task list for the current session. Pass the FULL list every call (it replaces the store). Mark exactly one task in_progress at a time; mark completed immediately when done; do not batch completions. Use when the task has 3+ distinct steps or is non-trivial. Skip for single trivial actions. Always include `listTitle` summarizing the overall goal so the UI can label this batch meaningfully.",
   parameters: TodoWriteArgs,
   permission: "read",
   summarize: (args) => `TodoWrite(${args.todos.length} items)`,
@@ -1144,110 +1189,299 @@ function stripTags(s) {
 import { z as z9 } from "zod";
 
 // src/loop/memory.ts
-import { mkdir as mkdir2, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
-import { existsSync } from "fs";
+import { mkdir as mkdir2, readFile as readFile4, writeFile as writeFile3, unlink, readdir } from "fs/promises";
+import { existsSync, statSync } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join2 } from "path";
 import { createHash } from "crypto";
+function trustRank(t) {
+  switch (t) {
+    case "trusted":
+      return 2;
+    case "verified":
+      return 1;
+    case "auto":
+      return 0;
+  }
+}
 function projectHash(cwd) {
   return createHash("sha256").update(cwd).digest("hex").slice(0, 16);
 }
 function memoryDir(cwd) {
   return join2(homedir3(), ".muse", "projects", projectHash(cwd), "memory");
 }
-function memoryIndexPath(cwd) {
-  return join2(memoryDir(cwd), "MEMORY.md");
+function globalMemoryDir() {
+  return join2(homedir3(), ".muse", "memory");
 }
-function memoryFilePath(cwd, name) {
-  return join2(memoryDir(cwd), `${name}.md`);
+function scopeDir(cwd, scope) {
+  return scope === "user" ? globalMemoryDir() : memoryDir(cwd);
 }
-async function readMemoryFile(cwd, name) {
-  const path = memoryFilePath(cwd, name);
-  if (!existsSync(path)) {
-    throw new Error(`Memory "${name}" does not exist at ${path}.`);
-  }
-  return readFile4(path, "utf-8");
+function memoryIndexPath(cwd, scope = "project") {
+  return join2(scopeDir(cwd, scope), "MEMORY.md");
+}
+function memoryFilePath(cwd, name, scope = "project") {
+  return join2(scopeDir(cwd, scope), `${name}.md`);
+}
+async function readMemory(cwd, name, scope) {
+  const candidates = scope ? [scope] : ["project", "user"];
+  for (const s of candidates) {
+    const filePath = memoryFilePath(cwd, name, s);
+    if (!existsSync(filePath)) continue;
+    const raw = await readFile4(filePath, "utf-8");
+    const { frontmatter, body } = parseMemoryFile(raw, name, filePath);
+    return { frontmatter, body, filePath, scope: s };
+  }
+  const where = scope ? `${scope} scope` : `project or user scope`;
+  throw new Error(`Memory "${name}" does not exist in ${where}.`);
+}
+async function readMemoryFile(cwd, name, scope) {
+  const file = await readMemory(cwd, name, scope);
+  return readFile4(file.filePath, "utf-8");
 }
 async function writeMemory(cwd, opts) {
-  const dir = memoryDir(cwd);
+  const scope = opts.scope ?? "project";
+  const dir = scopeDir(cwd, scope);
   await mkdir2(dir, { recursive: true });
-  const filePath = memoryFilePath(cwd, opts.name);
-  const frontmatter = [
-    "---",
-    `name: ${opts.name}`,
-    `description: ${opts.description.replace(/\n/g, " ").trim()}`,
-    `metadata:`,
-    `  type: ${opts.type}`,
-    "---"
-  ].join("\n");
-  const content = `${frontmatter}
-
-${opts.body.trim()}
-`;
+  const filePath = memoryFilePath(cwd, opts.name, scope);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const reqTrust = opts.trust ?? "auto";
+  const reqSource = opts.source ?? "manual-write";
+  let createdAt = now;
+  let finalTrust = reqTrust;
+  let finalSource = reqSource;
+  const isCreating = !existsSync(filePath);
+  if (!isCreating) {
+    try {
+      const raw = await readFile4(filePath, "utf-8");
+      const existing = parseMemoryFile(raw, opts.name, filePath).frontmatter;
+      createdAt = existing.created_at;
+      if (trustRank(existing.trust) > trustRank(reqTrust)) {
+        finalTrust = existing.trust;
+        finalSource = existing.source;
+      }
+    } catch {
+      createdAt = now;
+    }
+  }
+  const fm = {
+    name: opts.name,
+    description: opts.description.replace(/\n/g, " ").trim(),
+    type: opts.type,
+    trust: finalTrust,
+    source: finalSource,
+    created_at: createdAt,
+    updated_at: now
+  };
+  const content = serializeMemoryFile(fm, opts.body);
   await writeFile3(filePath, content, "utf-8");
-  const indexPath = memoryIndexPath(cwd);
-  let index = "";
-  if (existsSync(indexPath)) index = await readFile4(indexPath, "utf-8");
+  const indexUpdated = await upsertIndexLine(cwd, scope, fm);
+  return { filePath, indexUpdated, created: isCreating, scope };
+}
+var FRONTMATTER_RE = /^---\n([\s\S]*?)\n---\n?/;
+function parseMemoryFile(raw, fallbackName, filePath) {
+  const m = raw.match(FRONTMATTER_RE);
+  if (!m) {
+    return {
+      frontmatter: lazyDefaults(fallbackName, "", filePath),
+      body: raw.trim()
+    };
+  }
+  const fmText = m[1];
+  const body = raw.slice(m[0].length).trim();
+  const lines = fmText.split("\n");
+  let name = fallbackName;
+  let description = "";
+  let type = "user";
+  let trust = "auto";
+  let source = "manual-write";
+  let createdAt = "";
+  let updatedAt = "";
+  let inMetadata = false;
+  for (const line of lines) {
+    if (line.match(/^metadata:\s*$/)) {
+      inMetadata = true;
+      continue;
+    }
+    if (!inMetadata) {
+      const kv = parseKV(line);
+      if (!kv) continue;
+      if (kv.key === "name") name = kv.value;
+      else if (kv.key === "description") description = kv.value;
+    } else {
+      if (!line.match(/^\s+\S/)) {
+        inMetadata = false;
+        continue;
+      }
+      const kv = parseKV(line);
+      if (!kv) continue;
+      switch (kv.key) {
+        case "type":
+          if (isMemoryType(kv.value)) type = kv.value;
+          break;
+        case "trust":
+          if (isTrustLevel(kv.value)) trust = kv.value;
+          break;
+        case "source":
+          source = kv.value;
+          break;
+        case "created_at":
+          createdAt = kv.value;
+          break;
+        case "updated_at":
+          updatedAt = kv.value;
+          break;
+      }
+    }
+  }
+  if (!createdAt || !updatedAt) {
+    const mtimeIso = safeFileMtime(filePath);
+    if (!createdAt) createdAt = mtimeIso;
+    if (!updatedAt) updatedAt = createdAt;
+  }
+  return {
+    frontmatter: { name, description, type, trust, source, created_at: createdAt, updated_at: updatedAt },
+    body
+  };
+}
+function parseKV(line) {
+  const m = line.match(/^\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.*?)\s*$/);
+  if (!m) return null;
+  const key = m[1];
+  let value = m[2];
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    value = value.slice(1, -1);
+  }
+  return { key, value };
+}
+function isMemoryType(v) {
+  return v === "user" || v === "feedback" || v === "project" || v === "reference";
+}
+function isTrustLevel(v) {
+  return v === "trusted" || v === "verified" || v === "auto";
+}
+function safeFileMtime(filePath) {
+  try {
+    return statSync(filePath).mtime.toISOString();
+  } catch {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+}
+function lazyDefaults(name, description, filePath) {
+  const mtimeIso = safeFileMtime(filePath);
+  return {
+    name,
+    description,
+    type: "user",
+    trust: "auto",
+    source: "manual-write",
+    created_at: mtimeIso,
+    updated_at: mtimeIso
+  };
+}
+function serializeMemoryFile(fm, body) {
+  const lines = [
+    "---",
+    `name: ${fm.name}`,
+    `description: ${escapeYamlValue(fm.description)}`,
+    "metadata:",
+    `  type: ${fm.type}`,
+    `  trust: ${fm.trust}`,
+    `  source: ${fm.source}`,
+    `  created_at: ${fm.created_at}`,
+    `  updated_at: ${fm.updated_at}`,
+    "---",
+    "",
+    body.trim(),
+    ""
+  ];
+  return lines.join("\n");
+}
+function escapeYamlValue(v) {
+  if (/[:#&*?{}[\]|>!%@`]/.test(v) || v.startsWith(" ") || v.endsWith(" ")) {
+    return `"${v.replace(/"/g, '\\"')}"`;
+  }
+  return v;
+}
+var INDEX_LINE_RE = /^\[(trusted|verified|auto)\]\s+-\s+\[([a-zA-Z0-9-_]+)\]\(([^)]+)\)\s+—\s+(.*)$/;
+function formatIndexLine(fm) {
+  return `[${fm.trust}] - [${fm.name}](${fm.name}.md) \u2014 ${fm.description}`;
+}
+async function upsertIndexLine(cwd, scope, fm) {
+  const indexPath2 = memoryIndexPath(cwd, scope);
+  let index = existsSync(indexPath2) ? await readFile4(indexPath2, "utf-8") : "";
   const lines = index ? index.split("\n") : [];
-  const linePrefix = `- [${opts.name}](${opts.name}.md)`;
-  const newLine = `${linePrefix} \u2014 ${opts.description.replace(/\n/g, " ").trim()}`;
-  const existing = lines.findIndex((l) => l.startsWith(linePrefix));
-  let indexUpdated = false;
-  if (existing >= 0) {
-    if (lines[existing] !== newLine) {
-      lines[existing] = newLine;
-      indexUpdated = true;
+  const newLine = formatIndexLine(fm);
+  const existingIdx = lines.findIndex((l) => {
+    const m = l.match(INDEX_LINE_RE);
+    if (m) return m[2] === fm.name;
+    return l.startsWith(`- [${fm.name}](${fm.name}.md)`);
+  });
+  let changed = false;
+  if (existingIdx >= 0) {
+    if (lines[existingIdx] !== newLine) {
+      lines[existingIdx] = newLine;
+      changed = true;
     }
   } else {
     lines.push(newLine);
-    indexUpdated = true;
+    changed = true;
   }
-  if (indexUpdated) {
+  if (changed) {
     const out = lines.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
-    await writeFile3(indexPath, out, "utf-8");
+    await mkdir2(scopeDir(cwd, scope), { recursive: true });
+    await writeFile3(indexPath2, out, "utf-8");
   }
-  return { filePath, indexUpdated };
+  return changed;
 }
 
 // src/tools/builtin/memory.ts
 var TYPES = ["user", "feedback", "project", "reference"];
+var SCOPE_VALUES = ["project", "user"];
 var MemoryWriteArgs = z9.object({
   name: z9.string().regex(/^[a-z0-9][a-z0-9-_]*$/i, "must be a kebab- or snake-style slug").describe("Short kebab/snake slug; used as filename (<name>.md) and index key."),
   description: z9.string().describe("One-line summary used in MEMORY.md index (decides future relevance)."),
   type: z9.enum(TYPES).describe("user | feedback | project | reference"),
-  body: z9.string().describe("Memory content (markdown). For feedback/project, lead with the rule/fact then **Why:** and **How to apply:** lines.")
+  body: z9.string().describe("Memory content (markdown). For feedback/project, lead with the rule/fact then **Why:** and **How to apply:** lines."),
+  scope: z9.enum(SCOPE_VALUES).optional().describe(
+    'Storage scope. "project"(default \u2014 safe bias) = saved under current project, not visible to other projects. "user"(global) = saved under ~/.muse/memory/, visible across ALL projects. Choose carefully:\n  scope=project \u2014 project architecture / file conventions / team agreements (pnpm vs npm) / project-specific bugs+fixes / API contracts.\n    When unsure, choose project (safer; user can /memory promote-scope later).\n  scope=user \u2014 user role / working language / timezone / cross-project editor preferences (tabs/spaces, naming style, comment language) / tool preferences that apply EVERYWHERE / recurring feedback that reveals user personality.\n  HARD RULE: personal preference items (tabs/spaces, comment language, editor) MUST be scope=user \u2014 do NOT save them as project memory just because cwd is in a project. If you cannot tell whether a fact is personal or project-specific, ask the user or default to project.'
+  )
 });
 var MemoryWriteTool = defineTool({
   name: "MemoryWrite",
-  description: "Save a long-term memory file under ~/.muse/projects/<hash>/memory/<name>.md and update MEMORY.md index. Use for: user role/preferences, validated approach decisions (feedback), project facts (auto-convert relative dates), external system references. Do NOT save: code patterns derivable from the repo, git history, fix recipes, ephemeral task state.",
+  description: "Save a long-term memory file under ~/.muse/[projects/<hash>/]memory/<name>.md and update MEMORY.md index. Choose scope carefully (see scope arg). Use for: user role/preferences (scope=user), validated approach decisions (feedback), project facts (auto-convert relative dates), external system references. Do NOT save: code patterns derivable from the repo, git history, fix recipes, ephemeral task state.",
   parameters: MemoryWriteArgs,
   permission: "write",
-  summarize: (args) => `MemoryWrite(${args.name}, type=${args.type})`,
+  summarize: (args) => `MemoryWrite(${args.name}, ${args.scope ?? "project"}, type=${args.type})`,
   async execute(args, ctx) {
-    const { filePath, indexUpdated } = await writeMemory(ctx.cwd, {
+    const result = await writeMemory(ctx.cwd, {
       name: args.name,
       description: args.description,
       type: args.type,
-      body: args.body
+      body: args.body,
+      trust: "auto",
+      source: "manual-write",
+      scope: args.scope
+      // defaults to "project" inside writeMemory
     });
     return {
-      content: `Saved memory "${args.name}" (${args.type}) \u2192 ${filePath}${indexUpdated ? "\nMEMORY.md updated." : ""}`,
-      summary: `MemoryWrite ${args.name}`
+      content: `Saved memory "${args.name}" (${args.type}, scope=${result.scope}, trust=auto) \u2192 ${result.filePath}${result.indexUpdated ? "\nMEMORY.md updated." : ""}`,
+      summary: `MemoryWrite ${args.name} (${result.scope})`
     };
   }
 });
 var MemoryReadArgs = z9.object({
-  name: z9.string().describe("Memory slug to read (no .md extension).")
+  name: z9.string().describe("Memory slug to read (no .md extension)."),
+  scope: z9.enum(SCOPE_VALUES).optional().describe("Optional scope to read from. Default: project first, fallback user. Specify when name exists in both scopes.")
 });
 var MemoryReadTool = defineTool({
   name: "MemoryRead",
-  description: "Read a specific long-term memory file by name. Use after seeing it referenced in MEMORY.md (which is auto-injected into the system prompt).",
+  description: "Read a specific long-term memory file by name. Default lookup: project scope first, then user scope. Use after seeing it referenced in MEMORY.md (which is auto-injected into the system prompt). Pass scope='project' or 'user' to disambiguate when the same name exists in both.",
   parameters: MemoryReadArgs,
   permission: "read",
-  summarize: (args) => `MemoryRead(${args.name})`,
+  summarize: (args) => `MemoryRead(${args.name}${args.scope ? `, ${args.scope}` : ""})`,
   async execute(args, ctx) {
     try {
-      const content = await readMemoryFile(ctx.cwd, args.name);
+      const content = await readMemoryFile(ctx.cwd, args.name, args.scope);
       return { content, summary: `MemoryRead ${args.name}` };
     } catch (err) {
       return { content: err instanceof Error ? err.message : String(err), isError: true };
@@ -1419,7 +1653,7 @@ var PermissionGate = class {
 };
 
 // src/session/jsonl.ts
-import { appendFile, mkdir as mkdir3, readdir, readFile as readFile5, stat as stat3 } from "fs/promises";
+import { appendFile, mkdir as mkdir3, readdir as readdir2, readFile as readFile5, stat as stat3 } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
 import { homedir as homedir4 } from "os";
 import { dirname as dirname3, join as join3 } from "path";
@@ -1457,7 +1691,7 @@ var Session = class _Session {
   static async resolve(cwd, idOrPrefix) {
     const dir = sessionsDir(cwd);
     if (!existsSync2(dir)) return void 0;
-    const entries = await readdir(dir);
+    const entries = await readdir2(dir);
     const matches = entries.filter((e) => e.endsWith(".jsonl") && e.startsWith(idOrPrefix));
     if (matches.length === 0) return void 0;
     if (matches.length > 1) {
@@ -1479,7 +1713,7 @@ var Session = class _Session {
   static async listAll(cwd, limit) {
     const dir = sessionsDir(cwd);
     if (!existsSync2(dir)) return [];
-    const entries = await readdir(dir);
+    const entries = await readdir2(dir);
     const files = entries.filter((e) => e.endsWith(".jsonl"));
     if (files.length === 0) return [];
     const stats = await Promise.all(
@@ -1561,7 +1795,12 @@ async function readSummary(meta) {
   let preview;
   if (firstUser) {
     const c = firstUser.message.content;
-    const text = typeof c === "string" ? c : c.map((p) => p.type === "text" ? p.text : "").join(" ").trim();
+    const text = typeof c === "string" ? c : c.map((p) => {
+      if (p.type === "text") return p.text;
+      if (p.type === "file") return `\u{1F4CE}`;
+      if (p.type === "image") return `\u{1F5BC}`;
+      return "";
+    }).join(" ").trim();
     preview = text.slice(0, 60).replace(/\s+/g, " ");
   }
   return { ...meta, preview, messageCount: messages.length };
@@ -1593,163 +1832,24 @@ Update via TodoWrite as you make progress. Keep exactly one item in_progress at
   }
 };
 
-// src/loop/agent.ts
-var Agent = class {
-  constructor(ctx) {
-    this.ctx = ctx;
-  }
-  ctx;
-  messages = [];
-  todos = new TodoStore();
-  getMessages() {
-    return this.messages;
-  }
-  setMessages(msgs) {
-    this.messages = msgs;
+// src/preprocess/types.ts
+var NOOP_LOGGER = {
+  stage() {
+  },
+  warn() {
   }
-  /** 执行一次完整的"用户输入 → 助手响应（含工具循环） → 等待下一轮输入"。 */
-  async runTurn(userInput) {
-    const userMessage = { role: "user", content: userInput };
-    this.messages.push(userMessage);
-    await this.ctx.session.append({ type: "message", time: (/* @__PURE__ */ new Date()).toISOString(), message: userMessage });
-    while (true) {
-      const mode = this.ctx.permissions.getMode();
-      const tools = this.ctx.tools.toLLMDefinitions(
-        mode === "plan" ? (t) => t.permission === "read" : void 0
-      );
-      const todoSection = this.todos.toPromptSection();
-      const systemPrompt = todoSection ? `${this.ctx.systemPrompt}
+};
 
-${todoSection}` : this.ctx.systemPrompt;
-      const stream = this.ctx.llm.stream({
-        messages: this.messages,
-        tools,
-        systemPrompt,
-        abortSignal: this.ctx.abortSignal
-      });
-      const assistantParts = [];
-      const toolCallsToRun = [];
-      let lastError;
-      for await (const ev of stream) {
-        this.handleEvent(ev, assistantParts, toolCallsToRun, (e) => {
-          lastError = e;
-        });
-        if (lastError) break;
-      }
-      if (lastError) {
-        this.ctx.events?.onError?.(lastError);
-        log.error("agent stream error", { msg: lastError.message });
-        return;
-      }
-      const assistantMessage = { role: "assistant", content: assistantParts };
-      this.messages.push(assistantMessage);
-      await this.ctx.session.append({ type: "message", time: (/* @__PURE__ */ new Date()).toISOString(), message: assistantMessage });
-      if (toolCallsToRun.length === 0) {
-        this.ctx.events?.onTurnEnd?.();
-        return;
-      }
-      this.ctx.events?.onAssistantTurn?.();
-      for (const call of toolCallsToRun) {
-        await this.runToolCall(call);
-      }
-    }
-  }
-  handleEvent(ev, assistantParts, toolCallsToRun, onError) {
-    switch (ev.type) {
-      case "text":
-        {
-          const last = assistantParts[assistantParts.length - 1];
-          if (last && last.type === "text") {
-            last.text += ev.delta;
-          } else {
-            assistantParts.push({ type: "text", text: ev.delta });
-          }
-        }
-        this.ctx.events?.onText?.(ev.delta);
-        break;
-      case "tool_call_start":
-        this.ctx.events?.onToolCallStart?.(ev.id, ev.name);
-        break;
-      case "tool_call_complete": {
-        const callPart = { type: "tool_use", id: ev.id, name: ev.name, args: ev.args };
-        assistantParts.push(callPart);
-        toolCallsToRun.push(callPart);
-        this.ctx.events?.onToolCallArgs?.(ev.id, ev.args);
-        break;
-      }
-      case "finish":
-        if (ev.usage) {
-          this.ctx.events?.onUsage?.(ev.usage);
-          this.ctx.session.append({
-            type: "usage",
-            time: (/* @__PURE__ */ new Date()).toISOString(),
-            usage: ev.usage,
-            provider: this.ctx.llm.providerName,
-            model: this.ctx.llm.model
-          });
-        }
-        break;
-      case "error":
-        onError(ev.error);
-        break;
-    }
-  }
-  async runToolCall(call) {
-    const tool2 = this.ctx.tools.get(call.name);
-    if (!tool2) {
-      const result2 = `Tool "${call.name}" is not available.`;
-      this.recordToolResult(call.id, call.name, result2, true);
-      return;
-    }
-    const summary = tool2.summarize?.(call.args) ?? `${call.name}(...)`;
-    const decision = this.ctx.permissions.decide({
-      toolName: call.name,
-      args: call.args,
-      permission: tool2.permission
-    });
-    let approved = decision === "allow";
-    if (decision === "deny") {
-      const reason = this.ctx.permissions.getMode() === "plan" ? `Denied: you are in plan mode. Only read-only tools are available. Propose changes instead of executing.` : `Denied by policy: ${call.name}.`;
-      this.recordToolResult(call.id, call.name, reason, true);
-      return;
-    }
-    if (decision === "ask") {
-      const userDecision = await this.ctx.events?.onPermissionRequest?.(call.name, call.args, summary) ?? "no";
-      if (userDecision === "no") {
-        this.recordToolResult(call.id, call.name, `User rejected ${call.name}.`, true);
-        return;
-      }
-      if (userDecision === "session_allow") {
-        this.ctx.permissions.allowForSession(call.name);
-      }
-      approved = true;
-    }
-    const toolCtx = {
-      cwd: this.ctx.cwd,
-      abortSignal: this.ctx.abortSignal,
-      askPermission: async () => true,
-      // 已在外层处理
-      todos: this.todos,
-      askQuestions: this.ctx.events?.onAskQuestions ? (qs) => this.ctx.events.onAskQuestions(qs) : void 0
-    };
-    const result = await this.ctx.tools.execute(call.name, call.args, toolCtx);
-    this.recordToolResult(call.id, call.name, result.content, result.isError ?? false, result.summary, result.diff, result.kind);
-  }
-  recordToolResult(id, name, content, isError, summary, diff, kind) {
-    const toolMsg = {
-      role: "tool",
-      toolUseId: id,
-      content,
-      isError,
-      toolName: name,
-      ...diff ? { diff } : {},
-      ...summary ? { summary } : {},
-      ...kind ? { kind } : {}
-    };
-    this.messages.push(toolMsg);
-    this.ctx.session.append({ type: "message", time: (/* @__PURE__ */ new Date()).toISOString(), message: toolMsg });
-    this.ctx.events?.onToolResult?.(id, name, content, isError, summary);
+// src/preprocess/pipeline.ts
+var PipelineBlockedError = class extends Error {
+  constructor(point, reason) {
+    super(`blocked at ${point}: ${reason}`);
+    this.point = point;
+    this.reason = reason;
+    this.name = "PipelineBlockedError";
   }
+  point;
+  reason;
 };
 
 // src/loop/system-prompt.ts
@@ -1803,72 +1903,1917 @@ Below is MEMORY.md \u2014 your index of persistent facts about the user, project
   return sections.join("\n\n");
 }
 
-// src/config/loader.ts
+// src/loop/hierarchy.ts
 import { readFile as readFile6 } from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync3, statSync as statSync2 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join4, resolve as resolve5 } from "path";
-
-// src/config/types.ts
-import { z as z11 } from "zod";
-var ProviderConfigSchema = z11.object({
-  apiKey: z11.string().optional(),
-  baseUrl: z11.string().optional(),
-  extraHeaders: z11.record(z11.string()).optional()
-}).passthrough();
-var LLMConfigSchema = z11.object({
-  provider: z11.string().optional().describe("Fallback provider preset (only used when no models.local.json entry matches)."),
-  model: z11.string().optional().describe("Active model id; should match an id in models.local.json."),
-  temperature: z11.number().min(0).max(2).optional(),
-  maxTokens: z11.number().int().positive().optional()
-});
-var PermissionsSchema = z11.object({
-  allow: z11.array(z11.string()).optional(),
-  ask: z11.array(z11.string()).optional(),
-  deny: z11.array(z11.string()).optional(),
-  defaultMode: z11.enum(["strict", "relaxed", "ask"]).optional()
-});
-var UISchema = z11.object({
-  theme: z11.enum(["dark", "light"]).optional(),
-  lang: z11.enum(["en", "zh-CN"]).optional(),
-  showBanner: z11.boolean().optional()
-});
-var SettingsSchema = z11.object({
-  llm: LLMConfigSchema.optional(),
-  providers: z11.record(ProviderConfigSchema).optional(),
-  permissions: PermissionsSchema.optional(),
-  ui: UISchema.optional(),
-  mcpServers: z11.record(z11.unknown()).optional(),
-  skills: z11.object({
-    enabled: z11.boolean().optional(),
-    disabled: z11.array(z11.string()).optional()
-  }).optional()
-}).passthrough();
-
-// src/config/_env.ts
-var ENV_PATTERN2 = /\$\{([A-Z_][A-Z0-9_]*)\}/g;
-function expandEnvVars(value) {
-  if (typeof value === "string") {
-    return value.replace(ENV_PATTERN2, (_match, name) => process.env[name] ?? "");
+import { dirname as dirname4, join as join4, resolve as resolve5 } from "path";
+function findProjectRoot(cwd) {
+  let cur = resolve5(cwd);
+  while (true) {
+    if (existsSync3(join4(cur, ".git")) || existsSync3(join4(cur, ".muse"))) {
+      return cur;
+    }
+    const parent = dirname4(cur);
+    if (parent === cur) return resolve5(cwd);
+    cur = parent;
   }
-  if (Array.isArray(value)) {
-    return value.map(expandEnvVars);
+}
+async function loadSubdirMemory(absSubdir, opts = {}) {
+  const sizeCap = opts.sizeCapBytes ?? 5120;
+  const candidates = [
+    { path: join4(absSubdir, "MUSE.md"), source: "MUSE.md" }
+  ];
+  if (opts.ignoreAgentsMd !== true) {
+    candidates.push({ path: join4(absSubdir, "AGENTS.md"), source: "AGENTS.md" });
   }
-  if (value && typeof value === "object") {
-    const result = {};
-    for (const [k, v] of Object.entries(value)) {
-      result[k] = expandEnvVars(v);
+  for (const { path, source } of candidates) {
+    if (!existsSync3(path)) continue;
+    try {
+      let raw = (await readFile6(path, "utf-8")).trim();
+      if (!raw) continue;
+      const truncated = raw.length > sizeCap;
+      if (truncated) {
+        raw = raw.slice(0, sizeCap) + `
+
+[... truncated (over ${sizeCap}B; use Read tool to view full file)]`;
+      }
+      return { content: raw, source, truncated };
+    } catch {
     }
-    return result;
   }
-  return value;
+  return null;
 }
 
-// src/config/loader.ts
-function formatZodIssues(issues) {
-  return issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; ");
+// src/loop/memory-index.ts
+import { readFile as readFile7, writeFile as writeFile4, mkdir as mkdir4, unlink as unlink2 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { join as join5 } from "path";
+function indexPath(cwd, scope) {
+  return join5(scopeDir(cwd, scope), ".index.json");
 }
-var DEFAULTS = {
+async function readPersistent(cwd, scope) {
+  const path = indexPath(cwd, scope);
+  if (!existsSync4(path)) return null;
+  try {
+    const raw = await readFile7(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    if (parsed.schemaVersion !== 1) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writePersistent(cwd, scope, persistent) {
+  const dir = scopeDir(cwd, scope);
+  await mkdir4(dir, { recursive: true });
+  await writeFile4(indexPath(cwd, scope), JSON.stringify(persistent), "utf-8");
+}
+function snippet(body) {
+  return body.length > 400 ? body.slice(0, 400) + "\n... [truncated]" : body;
+}
+function embedInputText(f) {
+  return `${f.frontmatter.name}: ${f.frontmatter.description}`;
+}
+async function embedMemoryFile(provider, f) {
+  const fm = f.frontmatter;
+  const vector = await provider.embed(embedInputText(f));
+  return {
+    mtime: fm.updated_at,
+    type: fm.type,
+    trust: fm.trust,
+    description: fm.description,
+    bodySnippet: snippet(f.body),
+    fullBody: f.body,
+    vector
+  };
+}
+function makeEntry(name, scope, p) {
+  return {
+    name,
+    type: p.type,
+    trust: p.trust,
+    scope,
+    description: p.description,
+    rawIndexLine: `[${p.trust}] - [${name}](${name}.md) \u2014 ${p.description}`,
+    bodySnippet: p.bodySnippet,
+    fullBody: p.fullBody,
+    vector: p.vector
+  };
+}
+async function upsertMemoryEntry(index, name, scope) {
+  let f;
+  try {
+    f = await readMemory(index.cwd, name, scope);
+  } catch {
+    return;
+  }
+  const p = await embedMemoryFile(index.provider, f);
+  const idx = index.entries.findIndex((e) => e.name === name && e.scope === f.scope);
+  const newEntry = makeEntry(name, f.scope, p);
+  if (idx >= 0) index.entries[idx] = newEntry;
+  else index.entries.push(newEntry);
+  const persistent = await readPersistent(index.cwd, f.scope) ?? {
+    providerId: index.provider.id,
+    dim: index.provider.dim,
+    schemaVersion: 1,
+    entries: {}
+  };
+  persistent.entries[name] = p;
+  await writePersistent(index.cwd, f.scope, persistent);
+}
+
+// src/preprocess/tokenize.ts
+import { getEncoding } from "js-tiktoken";
+var _enc;
+function enc() {
+  if (!_enc) _enc = getEncoding("cl100k_base");
+  return _enc;
+}
+function countText(text) {
+  if (!text) return 0;
+  return enc().encode(text).length;
+}
+function countMessages(messages, systemPrompt, tools) {
+  let total = 0;
+  if (systemPrompt) total += countText(systemPrompt);
+  for (const m of messages) {
+    if (m.role === "tool") {
+      total += countText(m.content);
+      continue;
+    }
+    const content = m.content;
+    if (typeof content === "string") {
+      total += countText(content);
+    } else if (Array.isArray(content)) {
+      for (const p of content) {
+        if (p.type === "text") total += countText(p.text ?? "");
+        else if (p.type === "tool_use") {
+          total += countText(p.name) + countText(JSON.stringify(p.args ?? {}));
+        } else if (p.type === "file") {
+          total += countText(p.path) + countText(p.text);
+        } else if (p.type === "image") {
+          total += countText(`[image: ${p.path ?? p.mediaType}]`);
+        }
+      }
+    }
+  }
+  if (tools && tools.length > 0) {
+    for (const t of tools) total += countText(JSON.stringify(t));
+  }
+  return total;
+}
+
+// src/preprocess/hooks.ts
+import { execa as execa3 } from "execa";
+var DEFAULT_TIMEOUT = 3e4;
+var MAX_TIMEOUT = 6e4;
+var SHELL_META = /[;|&><`$()]/;
+async function runHooks(point, input, hooks, logger = NOOP_LOGGER) {
+  const specs = hooks?.[point];
+  if (!specs || specs.length === 0) return {};
+  let merged = {};
+  let payload = { ...input };
+  const matcherKey = pickMatcherKey(input);
+  for (const spec of specs) {
+    if (!matchesMatcher(spec.matcher, payload, matcherKey)) continue;
+    if (SHELL_META.test(spec.command)) {
+      logger.warn(`hook:${point}`, `command rejected: contains shell metachar`, { command: spec.command });
+      continue;
+    }
+    const timeout = Math.min(spec.timeout ?? DEFAULT_TIMEOUT, MAX_TIMEOUT);
+    try {
+      const result = await execa3(spec.command, [], {
+        input: JSON.stringify(payload),
+        timeout,
+        reject: false,
+        env: hookEnv()
+      });
+      if (result.failed) {
+        const reason = `exit ${result.exitCode ?? "?"} / signal ${result.signal ?? ""}`;
+        handleHookError(point, spec, reason, logger);
+        continue;
+      }
+      const text = (result.stdout ?? "").trim();
+      if (!text) continue;
+      let out;
+      try {
+        out = JSON.parse(text);
+      } catch (err) {
+        handleHookError(point, spec, `stdout not JSON: ${err.message}`, logger);
+        continue;
+      }
+      if (out?.block && typeof out.block === "object" && typeof out.block.reason === "string") {
+        throw new PipelineBlockedError(point, out.block.reason);
+      }
+      merged = { ...merged, ...out };
+      payload = { ...payload, ...out };
+    } catch (err) {
+      if (err instanceof PipelineBlockedError) throw err;
+      handleHookError(point, spec, err.message, logger);
+    }
+  }
+  return merged;
+}
+function handleHookError(point, spec, reason, logger) {
+  const onError = spec.onError ?? "skip";
+  logger.warn(`hook:${point}`, reason, { command: spec.command, onError });
+  if (onError === "throw") {
+    throw new Error(`hook ${point} failed: ${reason}`);
+  }
+}
+function pickMatcherKey(input) {
+  if (typeof input.toolName === "string") return "toolName";
+  if (typeof input.path === "string") return "path";
+  return void 0;
+}
+function matchesMatcher(matcher, payload, key) {
+  if (!matcher || matcher === ".*") return true;
+  if (!key) return true;
+  const value = payload[key];
+  if (typeof value !== "string") return true;
+  try {
+    return new RegExp(matcher).test(value);
+  } catch {
+    return false;
+  }
+}
+function hookEnv() {
+  const allow = ["PATH", "HOME", "LANG", "LC_ALL", "TERM", "USER", "SHELL"];
+  const out = {};
+  for (const key of allow) {
+    const v = process.env[key];
+    if (v) out[key] = v;
+  }
+  return out;
+}
+
+// src/loop/prompts/summarize.ts
+var FACTS_BLOCK = `
+
+---
+
+# Extracted Facts for Long-term Memory (optional)
+
+If \u2014 and only if \u2014 the conversation revealed durable facts worth keeping across future sessions,
+output one JSON code block in this format:
+
+\`\`\`json
+{
+  "facts": [
+    {
+      "name": "kebab-case-slug",
+      "type": "user" | "feedback" | "project" | "reference",
+      "description": "one-line summary used as memory index hook",
+      "body": "markdown content of the fact"
+    }
+  ]
+}
+\`\`\`
+
+Strict constraints (read carefully \u2014 over-eager extraction breaks user trust):
+- Only include facts with **cross-session value**: user role / preference, project hard rule, validated approach
+- Do NOT include: code visible in the repo, git history facts, transient task state, errors already fixed
+- Do NOT save chitchat, model-internal reasoning, or speculation
+- If nothing meets the bar, output \`{"facts": []}\` \u2014 empty is better than noise
+- Each fact \`name\` must be a unique slug (kebab- or snake-case alphanumeric)
+- For \`feedback\` / \`project\` types, body should lead with the rule, then "Why:" and "How to apply:" lines`;
+function buildSummaryPrompt(transcript, schema) {
+  if (schema === "9-section") {
+    return SECTION_9_TEMPLATE.replace("{TRANSCRIPT}", transcript) + FACTS_BLOCK;
+  }
+  return SECTION_6_TEMPLATE.replace("{TRANSCRIPT}", transcript) + FACTS_BLOCK;
+}
+var SECTION_9_TEMPLATE = `Summarize the following conversation. Use **exactly these 9 sections in this order**. If a section has no content, write "(none)" \u2014 do not skip section numbers.
+
+# Conversation Summary
+
+1. **Primary Request and Intent**
+   \u2014 Quote the user's original request verbatim (use > markdown quotes). Do not paraphrase.
+
+2. **Key Technical Concepts**
+   \u2014 Bullet list of frameworks, languages, libraries, patterns relevant to the conversation.
+
+3. **Files and Code Sections**
+   \u2014 File path + function / class name + what was read or changed. Be concrete.
+
+4. **Errors and fixes**
+   \u2014 Each error message (or class of error) + the specific fix taken. Future you will repeat these mistakes if this section is sloppy.
+
+5. **Problem Solving**
+   \u2014 Key reasoning steps and trade-offs considered. "I chose A over B because X."
+
+6. **All user messages**
+   \u2014 **List every user message verbatim**, separated by \`---\`. Sacred section: NEVER omit, paraphrase, or merge user messages.
+
+7. **Pending Tasks**
+   \u2014 TODOs the user explicitly stated and items the assistant identified as not-yet-done.
+
+8. **Current Work**
+   \u2014 What was actively being done at the moment of summarization. One paragraph.
+
+9. **Optional Next Step**
+   \u2014 Recommended next action, anchored in quote(s) from the user's recent messages. If unclear, write "(awaiting user direction)".
+
+--- BEGIN CONVERSATION ---
+{TRANSCRIPT}
+--- END CONVERSATION ---`;
+var SECTION_6_TEMPLATE = `Summarize the following conversation. Use these 6 sections in order. Do not skip section numbers; write "(none)" for empty sections.
+
+# Conversation Summary
+
+1. **Primary Request and Intent** \u2014 Quote the user's original request verbatim.
+
+2. **Concepts, Decisions, and Reasoning** \u2014 Frameworks involved + key trade-offs.
+
+3. **Files and Changes** \u2014 File paths + what was modified.
+
+4. **Errors and fixes** \u2014 Error messages + specific fixes.
+
+5. **All user messages** \u2014 List every user message verbatim, separated by \`---\`. Sacred: never omit.
+
+6. **Current Work + Next Step** \u2014 What was being done + recommended next action (anchored in user quotes).
+
+--- BEGIN CONVERSATION ---
+{TRANSCRIPT}
+--- END CONVERSATION ---`;
+function extractFacts(summaryText) {
+  const jsonBlock = summaryText.match(/```(?:json)?\s*\n([\s\S]*?)\n```/);
+  if (!jsonBlock) return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonBlock[1].trim());
+  } catch {
+    return [];
+  }
+  if (typeof parsed !== "object" || parsed === null) return [];
+  const facts = parsed.facts;
+  if (!Array.isArray(facts)) return [];
+  const out = /* @__PURE__ */ new Map();
+  for (const raw of facts) {
+    if (typeof raw !== "object" || raw === null) continue;
+    const r = raw;
+    const name = typeof r.name === "string" ? r.name : "";
+    const type = r.type;
+    const description = typeof r.description === "string" ? r.description : "";
+    const body = typeof r.body === "string" ? r.body : "";
+    if (!name || !description || !body) continue;
+    if (!/^[a-z0-9][a-z0-9-_]*$/i.test(name)) continue;
+    if (type !== "user" && type !== "feedback" && type !== "project" && type !== "reference") continue;
+    out.set(name, { name, type, description, body });
+  }
+  return [...out.values()];
+}
+function stripFactsBlock(summaryText) {
+  return summaryText.replace(/---\s*\n\s*#?\s*Extracted Facts[\s\S]*?```(?:json)?[\s\S]*?```/i, "").replace(/```(?:json)?\s*\n[\s\S]*?\n```/g, (match) => {
+    if (/"facts"\s*:/.test(match)) return "";
+    return match;
+  }).trim();
+}
+
+// src/loop/context.ts
+var CompactBlockedError = class extends Error {
+  constructor(reason) {
+    super(`compact blocked by PreCompact hook: ${reason}`);
+    this.reason = reason;
+    this.name = "CompactBlockedError";
+  }
+  reason;
+};
+async function compactMessages(messages, opts) {
+  const keepRecent = opts.keepRecent ?? 4;
+  const cutoff = findSafeCutoff(messages, keepRecent);
+  if (cutoff <= 0) {
+    return {
+      newMessages: messages,
+      summary: "",
+      originalCount: messages.length,
+      newCount: messages.length,
+      noop: true
+    };
+  }
+  try {
+    await runHooks(
+      "PreCompact",
+      { messageCount: messages.length, cutoff, keepRecent },
+      opts.hooks
+    );
+  } catch (err) {
+    if (err instanceof PipelineBlockedError) {
+      throw new CompactBlockedError(err.reason);
+    }
+    throw err;
+  }
+  const older = messages.slice(0, cutoff);
+  const recent = messages.slice(cutoff);
+  const schema = opts.schema ?? "9-section";
+  const rawSummary = await summarizeConversation(
+    older,
+    opts.llm,
+    schema,
+    opts.abortSignal,
+    opts.onProgress
+  );
+  const summary = stripFactsBlock(rawSummary);
+  const facts = opts.cwd ? extractFacts(rawSummary) : [];
+  const summaryMessage = {
+    role: "user",
+    content: `[Previous conversation summary]
+
+${summary}
+
+[End of summary. The conversation continues below.]`
+  };
+  const newMessages = [summaryMessage, ...recent];
+  try {
+    await runHooks(
+      "PostCompact",
+      { before: messages.length, after: newMessages.length, summary, factCount: facts.length },
+      opts.hooks
+    );
+  } catch (err) {
+    if (err instanceof PipelineBlockedError) {
+    } else {
+      throw err;
+    }
+  }
+  let promotedFacts;
+  const shouldPromote = opts.promoteFactsToMemory !== false && opts.cwd && facts.length > 0;
+  if (shouldPromote) {
+    promotedFacts = await promoteFactsToMemory(facts, opts.cwd, opts.hooks);
+  }
+  return {
+    newMessages,
+    summary,
+    originalCount: messages.length,
+    newCount: newMessages.length,
+    noop: false,
+    promotedFacts
+  };
+}
+async function promoteFactsToMemory(facts, cwd, hooks) {
+  const results = [];
+  for (const fact of facts) {
+    try {
+      await runHooks(
+        "MemoryPromote",
+        { name: fact.name, type: fact.type, description: fact.description, body: fact.body, source: "compact-promote" },
+        hooks
+      );
+    } catch (err) {
+      if (err instanceof PipelineBlockedError) {
+        results.push({
+          name: fact.name,
+          type: fact.type,
+          description: fact.description,
+          status: "blocked",
+          reason: err.reason
+        });
+        continue;
+      }
+      results.push({
+        name: fact.name,
+        type: fact.type,
+        description: fact.description,
+        status: "failed",
+        reason: err instanceof Error ? err.message : String(err)
+      });
+      continue;
+    }
+    try {
+      await writeMemory(cwd, {
+        name: fact.name,
+        description: fact.description,
+        type: fact.type,
+        body: fact.body,
+        trust: "auto",
+        source: "compact-promote"
+      });
+      results.push({ name: fact.name, type: fact.type, description: fact.description, status: "saved" });
+    } catch (err) {
+      results.push({
+        name: fact.name,
+        type: fact.type,
+        description: fact.description,
+        status: "failed",
+        reason: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return results;
+}
+function findSafeCutoff(messages, keepRecent) {
+  if (messages.length <= keepRecent) return 0;
+  const ideal = Math.max(0, messages.length - keepRecent);
+  for (let i = ideal; i > 0; i--) {
+    if (messages[i].role !== "user") continue;
+    if (hasUnresolvedToolUse(messages.slice(0, i))) continue;
+    return i;
+  }
+  return 0;
+}
+function hasUnresolvedToolUse(older) {
+  const seenToolUseIds = /* @__PURE__ */ new Set();
+  const seenToolResultIds = /* @__PURE__ */ new Set();
+  for (const msg of older) {
+    if (msg.role === "assistant") {
+      for (const part of msg.content) {
+        if (part.type === "tool_use") seenToolUseIds.add(part.id);
+      }
+    } else if (msg.role === "tool") {
+      seenToolResultIds.add(msg.toolUseId);
+    }
+  }
+  for (const id of seenToolUseIds) {
+    if (!seenToolResultIds.has(id)) return true;
+  }
+  return false;
+}
+async function summarizeConversation(older, llm, schema, abortSignal, onProgress) {
+  const transcript = renderTranscript(older);
+  const prompt = [
+    {
+      role: "user",
+      content: buildSummaryPrompt(transcript, schema)
+    }
+  ];
+  let text = "";
+  for await (const ev of llm.stream({ messages: prompt, abortSignal })) {
+    if (ev.type === "text") {
+      text += ev.delta;
+      onProgress?.(text.length);
+    } else if (ev.type === "error") throw ev.error;
+  }
+  return text.trim() || "(empty summary)";
+}
+function renderTranscript(messages) {
+  const lines = [];
+  for (const msg of messages) {
+    switch (msg.role) {
+      case "system":
+        lines.push(`[system]
+${msg.content}
+`);
+        break;
+      case "user":
+        lines.push(`[user]
+${typeof msg.content === "string" ? msg.content : flattenContent(msg.content)}
+`);
+        break;
+      case "assistant":
+        lines.push(`[assistant]
+${renderAssistant(msg)}
+`);
+        break;
+      case "tool":
+        lines.push(`[tool result${msg.isError ? " ERROR" : ""}]
+${msg.content}
+`);
+        break;
+    }
+  }
+  return lines.join("\n");
+}
+function renderAssistant(msg) {
+  const parts = [];
+  for (const part of msg.content) {
+    if (part.type === "text") parts.push(part.text);
+    else if (part.type === "tool_use") {
+      parts.push(`<tool_call name="${part.name}" args=${JSON.stringify(part.args)} />`);
+    }
+  }
+  return parts.join("\n");
+}
+function flattenContent(parts) {
+  const out = [];
+  for (const p of parts) {
+    if (p.type === "text") out.push(p.text);
+    else if (p.type === "file") out.push(`[file: ${p.path}]`);
+    else if (p.type === "image") out.push(`[image: ${p.path ?? p.mediaType}]`);
+  }
+  return out.join("\n");
+}
+
+// src/preprocess/request/budget-guard.ts
+var BudgetExceededError = class extends Error {
+  constructor(estimated, budget, reason) {
+    super(`context budget exceeded: estimated ${estimated} > budget ${budget} (${reason})`);
+    this.estimated = estimated;
+    this.budget = budget;
+    this.reason = reason;
+    this.name = "BudgetExceededError";
+  }
+  estimated;
+  budget;
+  reason;
+};
+
+// src/preprocess/request/ctx.ts
+function createRequestCtx(init) {
+  return {
+    messages: init.messages,
+    systemPrompt: "",
+    tools: [],
+    modelId: init.modelId,
+    mode: init.mode,
+    cwd: init.cwd,
+    services: init.services,
+    settings: init.settings ?? {}
+  };
+}
+
+// src/loop/agent.ts
+import { existsSync as existsSync5 } from "fs";
+import { dirname as dirname5, isAbsolute as isAbsolute4, join as join6, relative, resolve as resolve6 } from "path";
+
+// src/preprocess/truncate.ts
+var DEFAULT_BUDGET = 64 * 1024;
+
+// node_modules/chalk/source/vendor/ansi-styles/index.js
+var ANSI_BACKGROUND_OFFSET = 10;
+var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+var styles = {
+  modifier: {
+    reset: [0, 0],
+    // 21 isn't widely supported and 22 does the same thing
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    // Bright color
+    blackBright: [90, 39],
+    gray: [90, 39],
+    // Alias of `blackBright`
+    grey: [90, 39],
+    // Alias of `blackBright`
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    // Bright color
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    // Alias of `bgBlackBright`
+    bgGrey: [100, 49],
+    // Alias of `bgBlackBright`
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
+  }
+};
+var modifierNames = Object.keys(styles.modifier);
+var foregroundColorNames = Object.keys(styles.color);
+var backgroundColorNames = Object.keys(styles.bgColor);
+var colorNames = [...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+  const codes = /* @__PURE__ */ new Map();
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          /* eslint-disable no-bitwise */
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+          /* eslint-enable no-bitwise */
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+var ansiStyles = assembleStyles();
+var ansi_styles_default = ansiStyles;
+
+// node_modules/chalk/source/vendor/supports-color/index.js
+import process2 from "process";
+import os from "os";
+import tty from "tty";
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+var { env } = process2;
+var flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+  flagForceColor = 0;
+} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+  flagForceColor = 1;
+}
+function envForceColor() {
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      return 1;
+    }
+    if (env.FORCE_COLOR === "false") {
+      return 0;
+    }
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  }
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== void 0) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === void 0) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (process2.platform === "win32") {
+    const osRelease = os.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)) {
+      return 3;
+    }
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var supportsColor = {
+  stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+  stderr: createSupportsColor({ isTTY: tty.isatty(2) })
+};
+var supports_color_default = supportsColor;
+
+// node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, replacer) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
+    return string;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string[index - 1] === "\r";
+    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+    endIndex = index + 1;
+    index = string.indexOf("\n", endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+
+// node_modules/chalk/source/index.js
+var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
+var GENERATOR = /* @__PURE__ */ Symbol("GENERATOR");
+var STYLER = /* @__PURE__ */ Symbol("STYLER");
+var IS_EMPTY = /* @__PURE__ */ Symbol("IS_EMPTY");
+var levelMapping = [
+  "ansi",
+  "ansi",
+  "ansi256",
+  "ansi16m"
+];
+var styles2 = /* @__PURE__ */ Object.create(null);
+var applyOptions = (object, options = {}) => {
+  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+    throw new Error("The `level` option should be an integer from 0 to 3");
+  }
+  const colorLevel = stdoutColor ? stdoutColor.level : 0;
+  object.level = options.level === void 0 ? colorLevel : options.level;
+};
+var chalkFactory = (options) => {
+  const chalk2 = (...strings) => strings.join(" ");
+  applyOptions(chalk2, options);
+  Object.setPrototypeOf(chalk2, createChalk.prototype);
+  return chalk2;
+};
+function createChalk(options) {
+  return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+  styles2[styleName] = {
+    get() {
+      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+      Object.defineProperty(this, styleName, { value: builder });
+      return builder;
+    }
+  };
+}
+styles2.visible = {
+  get() {
+    const builder = createBuilder(this, this[STYLER], true);
+    Object.defineProperty(this, "visible", { value: builder });
+    return builder;
+  }
+};
+var getModelAnsi = (model, level, type, ...arguments_) => {
+  if (model === "rgb") {
+    if (level === "ansi16m") {
+      return ansi_styles_default[type].ansi16m(...arguments_);
+    }
+    if (level === "ansi256") {
+      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+    }
+    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+  }
+  if (model === "hex") {
+    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+  }
+  return ansi_styles_default[type][model](...arguments_);
+};
+var usedModels = ["rgb", "hex", "ansi256"];
+for (const model of usedModels) {
+  styles2[model] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+  styles2[bgModel] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+}
+var proto = Object.defineProperties(() => {
+}, {
+  ...styles2,
+  level: {
+    enumerable: true,
+    get() {
+      return this[GENERATOR].level;
+    },
+    set(level) {
+      this[GENERATOR].level = level;
+    }
+  }
+});
+var createStyler = (open, close, parent) => {
+  let openAll;
+  let closeAll;
+  if (parent === void 0) {
+    openAll = open;
+    closeAll = close;
+  } else {
+    openAll = parent.openAll + open;
+    closeAll = close + parent.closeAll;
+  }
+  return {
+    open,
+    close,
+    openAll,
+    closeAll,
+    parent
+  };
+};
+var createBuilder = (self, _styler, _isEmpty) => {
+  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+  Object.setPrototypeOf(builder, proto);
+  builder[GENERATOR] = self;
+  builder[STYLER] = _styler;
+  builder[IS_EMPTY] = _isEmpty;
+  return builder;
+};
+var applyStyle = (self, string) => {
+  if (self.level <= 0 || !string) {
+    return self[IS_EMPTY] ? "" : string;
+  }
+  let styler = self[STYLER];
+  if (styler === void 0) {
+    return string;
+  }
+  const { openAll, closeAll } = styler;
+  if (string.includes("\x1B")) {
+    while (styler !== void 0) {
+      string = stringReplaceAll(string, styler.close, styler.open);
+      styler = styler.parent;
+    }
+  }
+  const lfIndex = string.indexOf("\n");
+  if (lfIndex !== -1) {
+    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+  }
+  return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles2);
+var chalk = createChalk();
+var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
+var source_default = chalk;
+
+// src/preprocess/render/markdown.ts
+import { marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+if (source_default.level === 0) source_default.level = 3;
+
+// src/preprocess/result/ctx.ts
+function createResultCtx(init) {
+  return {
+    toolName: init.toolName,
+    toolUseId: init.toolUseId,
+    args: init.args,
+    raw: init.raw,
+    content: init.raw.content,
+    summary: init.raw.summary,
+    diff: init.raw.diff,
+    warnings: [],
+    settings: init.settings ?? {}
+  };
+}
+
+// src/loop/agent.ts
+function combineSignals(...signals) {
+  const live = signals.filter((s) => !!s);
+  if (live.length === 0) return void 0;
+  if (live.length === 1) return live[0];
+  const combined = new AbortController();
+  for (const s of live) {
+    if (s.aborted) {
+      combined.abort(s.reason);
+      break;
+    }
+    s.addEventListener("abort", () => combined.abort(s.reason), { once: true });
+  }
+  return combined.signal;
+}
+function isAbortError(err) {
+  if (!err) return false;
+  if (err instanceof Error) {
+    if (err.name === "AbortError") return true;
+    const code = err.code;
+    if (code === "ABORT_ERR" || code === "ECANCELED") return true;
+    const msg = err.message.toLowerCase();
+    if (msg.includes("aborted") || msg.includes("cancelled") || msg.includes("canceled")) return true;
+  }
+  return false;
+}
+var Agent = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.todos = ctx.todos ?? new TodoStore();
+    this.projectRoot = findProjectRoot(ctx.cwd);
+  }
+  ctx;
+  messages = [];
+  todos;
+  /** 本轮 stream 发出时的 input tokens 估算值;finish 真实 usage 回来时减去,补差量给 UI。
+   *  为什么:OpenAI 兼容 stream 的 usage 只在 finish 下发,期间 StatusLine 拿不到 token 数;
+   *  先用 chars/4 估算并即刻推一次 onUsage,流式中就能显示 "↑ N tokens",真实值到达时无缝覆盖。 */
+  lastEstimateInputTokens = 0;
+  /** 当前轮次的 abort signal(runTurn 开始时设,结束清);runToolCall 读它给 execa 等用。 */
+  turnAbortSignal;
+  /**
+   * "引导(guidance)"队列:模型还在跑时用户继续输入的内容暂存这里。
+   * 主循环每轮 stream 启动前 check + flush;合并成一条 role:user 注入 messages,
+   * 让 LLM 在下一轮看到"已跑完的 tool result + 用户新输入"一起决策。
+   *
+   * 注入点:工具批跑完、下一轮 LLM stream 之前。**不打断**正在跑的工具,避免模型
+   * 因丢失中间结果而重跑(用户原话:"不应该直接终止某一个小的命令或者工具执行")。
+   *
+   * Esc 单击时若队列非空,优先清队列(轻撤销),还有空也不 abort turn。
+   */
+  pendingGuidance = [];
+  /**
+   * II-1.3 子目录惰性加载状态:已注入过子目录 MUSE.md / AGENTS.md 的绝对路径集合。
+   *
+   * tool 操作触及未加载过的子目录(包含 MUSE.md 或 AGENTS.md)时,把内容附加到 tool result
+   * prefix,让 LLM 看到该子目录的 guidance。同一子目录只注入一次(去重)。
+   *
+   * /clear 调 clearLoadedSubdirs() 重置;/resume 不重置(假设旧 session 已加载过)。
+   */
+  loadedSubdirs = /* @__PURE__ */ new Set();
+  projectRoot;
+  /** 给 /clear 等场景重置子目录加载状态。 */
+  clearLoadedSubdirs() {
+    this.loadedSubdirs.clear();
+  }
+  /** 估算 input tokens:走 src/preprocess/tokenize.ts(js-tiktoken cl100k_base)。
+   *  比旧 chars/4 精度高,trim-history / budget-guard 也共享同一个估算口径。 */
+  estimateInputTokens(messages, systemPrompt, tools) {
+    return countMessages(messages, systemPrompt, tools);
+  }
+  getMessages() {
+    return this.messages;
+  }
+  setMessages(msgs) {
+    this.messages = msgs;
+  }
+  /**
+   * 把一段"引导"内容塞进队列。下一轮 stream 启动前会被合并成一条 role:user 注入 messages。
+   * 调用方:App 的 handleSubmit 在 state.status !== "idle" 时走这条路径。
+   */
+  enqueueGuidance(content) {
+    const parts = typeof content === "string" ? [{ type: "text", text: content }] : content;
+    this.pendingGuidance.push(parts);
+  }
+  /** 用户单击 Esc 时若队列非空,清掉(轻撤销;不 abort 当前 turn)。 */
+  clearGuidance() {
+    this.pendingGuidance.length = 0;
+  }
+  getPendingGuidanceCount() {
+    return this.pendingGuidance.length;
+  }
+  /**
+   * 把当前 pendingGuidance 合并成一条 role:user message push 进 messages,清空队列。
+   * 多条 guidance 之间用空行分隔(模型把它们读成"一次性补充的几点")。
+   * 返回 true 表示真的注入了内容;false 表示队列本就空。
+   */
+  flushGuidance() {
+    if (this.pendingGuidance.length === 0) return false;
+    const queued = this.pendingGuidance;
+    this.pendingGuidance = [];
+    const merged = [];
+    const SEP = "\n\n---\n\n";
+    for (let i = 0; i < queued.length; i++) {
+      const parts = queued[i];
+      if (i > 0) {
+        const tail = merged[merged.length - 1];
+        if (tail && tail.type === "text") tail.text += SEP;
+        else merged.push({ type: "text", text: SEP });
+      }
+      for (const p of parts) {
+        const tail = merged[merged.length - 1];
+        if (p.type === "text" && tail && tail.type === "text") {
+          tail.text += p.text;
+        } else {
+          merged.push({ ...p });
+        }
+      }
+    }
+    const guidanceMsg = { role: "user", content: merged };
+    this.messages.push(guidanceMsg);
+    this.ctx.session.append({ type: "message", time: (/* @__PURE__ */ new Date()).toISOString(), message: guidanceMsg });
+    this.ctx.events?.onGuidanceInjected?.(merged);
+    return true;
+  }
+  /**
+   * 执行一次完整的"用户输入 → 助手响应(含工具循环) → 等待下一轮输入"。
+   *
+   * userInput 可以是:
+   *   - string:纯文本(向后兼容,无附件场景)
+   *   - ContentPart[]:多 part 内容(text + file/image 附件)
+   *
+   * abortSignal:本轮专属信号(每轮新建,App.handleSubmit 传入);Esc 触发 abort
+   * 时立刻打断 LLM stream + execa 工具 + 等待循环。优先级高于 ctx.abortSignal
+   * (后者是进程级 / 启动时签名,用于全局退出)。
+   */
+  async runTurn(userInput, abortSignal) {
+    const turnSignal = combineSignals(abortSignal, this.ctx.abortSignal);
+    this.turnAbortSignal = turnSignal;
+    const userMessage = { role: "user", content: userInput };
+    this.messages.push(userMessage);
+    await this.ctx.session.append({ type: "message", time: (/* @__PURE__ */ new Date()).toISOString(), message: userMessage });
+    while (true) {
+      this.flushGuidance();
+      let systemPrompt;
+      let tools;
+      let messagesForStream;
+      try {
+        const built = await this.buildRequest();
+        systemPrompt = built.systemPrompt;
+        tools = built.tools;
+        messagesForStream = built.messages;
+      } catch (err) {
+        if (err instanceof BudgetExceededError) {
+          this.ctx.events?.onError?.(err);
+          log.error("budget exceeded", { msg: err.message });
+          this.turnAbortSignal = void 0;
+          return;
+        }
+        throw err;
+      }
+      try {
+        const hookOut = await runHooks(
+          "PreLLMRequest",
+          { messages: this.messages, systemPrompt, tools, modelId: this.ctx.llm.model },
+          this.ctx.hooks,
+          this.ctx.hookLogger
+        );
+        if (typeof hookOut.systemPrompt === "string") systemPrompt = hookOut.systemPrompt;
+        if (Array.isArray(hookOut.messages)) messagesForStream = hookOut.messages;
+        if (Array.isArray(hookOut.tools)) tools = hookOut.tools;
+      } catch (err) {
+        if (err instanceof PipelineBlockedError) {
+          this.ctx.events?.onBlocked?.(err.reason);
+          this.ctx.events?.onError?.(new Error(`PreLLMRequest blocked: ${err.reason}`));
+          return;
+        }
+        throw err;
+      }
+      const estimate = this.estimateInputTokens(messagesForStream, systemPrompt, tools);
+      this.lastEstimateInputTokens = estimate;
+      this.ctx.events?.onEstimate?.(estimate);
+      const stream = this.ctx.llm.stream({
+        messages: messagesForStream,
+        tools,
+        systemPrompt,
+        abortSignal: turnSignal
+      });
+      const assistantParts = [];
+      const toolCallsToRun = [];
+      let lastError;
+      try {
+        for await (const ev of stream) {
+          this.handleEvent(ev, assistantParts, toolCallsToRun, (e) => {
+            lastError = e;
+          });
+          if (lastError) break;
+          if (turnSignal?.aborted) break;
+        }
+      } catch (err) {
+        if (isAbortError(err) || turnSignal?.aborted) {
+          this.persistInterruptedAssistant(assistantParts);
+          this.ctx.events?.onTurnEnd?.();
+          this.turnAbortSignal = void 0;
+          return;
+        }
+        throw err;
+      }
+      if (lastError) {
+        this.ctx.events?.onError?.(lastError);
+        log.error("agent stream error", { msg: lastError.message });
+        this.turnAbortSignal = void 0;
+        return;
+      }
+      if (turnSignal?.aborted) {
+        this.persistInterruptedAssistant(assistantParts);
+        this.ctx.events?.onTurnEnd?.();
+        this.turnAbortSignal = void 0;
+        return;
+      }
+      const assistantMessage = { role: "assistant", content: assistantParts };
+      this.messages.push(assistantMessage);
+      await this.ctx.session.append({ type: "message", time: (/* @__PURE__ */ new Date()).toISOString(), message: assistantMessage });
+      const assistantText = assistantParts.filter((p) => p.type === "text").map((p) => p.text).join("");
+      const toolCalls = toolCallsToRun.map((t) => ({ id: t.id, name: t.name, args: t.args }));
+      try {
+        await runHooks(
+          "PostLLMResponse",
+          { assistantText, toolCalls },
+          this.ctx.hooks,
+          this.ctx.hookLogger
+        );
+      } catch (err) {
+        if (err instanceof PipelineBlockedError) {
+          log.warn("PostLLMResponse tried to block, ignored", { reason: err.reason });
+        } else {
+          throw err;
+        }
+      }
+      if (toolCallsToRun.length === 0) {
+        if (this.pendingGuidance.length > 0) continue;
+        this.ctx.events?.onTurnEnd?.();
+        this.turnAbortSignal = void 0;
+        return;
+      }
+      this.ctx.events?.onAssistantTurn?.();
+      for (const call of toolCallsToRun) {
+        if (turnSignal?.aborted) {
+          this.recordToolResult(call.id, call.name, `Interrupted by user (Esc).`, true);
+        } else {
+          await this.runToolCall(call);
+          await new Promise((resolve8) => setImmediate(resolve8));
+        }
+      }
+      if (turnSignal?.aborted) {
+        this.ctx.events?.onTurnEnd?.();
+        this.turnAbortSignal = void 0;
+        return;
+      }
+    }
+  }
+  /** 拼装本轮 system prompt + tools(+ 可能 trim 后的 messages)。
+   *  优先走 RequestPipeline,无 pipeline 时回退到 legacy 路径。
+   *
+   *  注意:trim-history 可能替换 ctx.messages,这里把它回流出去给主循环作为
+   *  messagesForStream。**不污染** this.messages — 因为 trim 是临时为本次请求
+   *  做的窗口缩减,真正的历史不动(budget-guard 触发的 compact 例外:那是
+   *  通过 services.compact 真实写回 this.messages 的)。 */
+  async buildRequest() {
+    if (this.ctx.requestPipeline && this.ctx.requestServices) {
+      const ctx = createRequestCtx({
+        messages: this.messages,
+        modelId: this.ctx.llm.model,
+        mode: this.ctx.permissions.getMode(),
+        cwd: this.ctx.cwd,
+        services: {
+          ...this.ctx.requestServices,
+          todos: this.todos,
+          contextWindow: this.ctx.llm.capabilities.maxContextWindow,
+          abortSignal: this.turnAbortSignal,
+          // compact 闭包:budget-guard 触发时调用。真实改写 this.messages
+          // (compact 是历史压缩,不可逆,要落到 agent state)。
+          compact: async (signal) => {
+            const result = await compactMessages(this.messages, {
+              llm: this.ctx.llm,
+              abortSignal: signal,
+              hooks: this.ctx.hooks,
+              cwd: this.ctx.cwd
+            });
+            this.messages = result.newMessages;
+            if (result.promotedFacts && this.ctx.requestServices?.memoryEmbeddingIndex) {
+              for (const f of result.promotedFacts) {
+                if (f.status !== "saved") continue;
+                try {
+                  await upsertMemoryEntry(this.ctx.requestServices.memoryEmbeddingIndex, f.name, "project");
+                } catch (err) {
+                  log.warn("memory index upsert (compact-promote) failed", { name: f.name, msg: err.message });
+                }
+              }
+            }
+            return this.messages;
+          }
+        }
+      });
+      await this.ctx.requestPipeline.run(ctx);
+      return { systemPrompt: ctx.systemPrompt, tools: ctx.tools, messages: ctx.messages };
+    }
+    const mode = this.ctx.permissions.getMode();
+    const tools = this.ctx.tools.toLLMDefinitions(
+      mode === "plan" ? (t) => t.permission === "read" : void 0
+    );
+    const todoSection = this.todos.toPromptSection();
+    const base = this.ctx.systemPrompt ?? "";
+    const systemPrompt = todoSection ? `${base}
+
+${todoSection}` : base;
+    return { systemPrompt, tools, messages: this.messages };
+  }
+  handleEvent(ev, assistantParts, toolCallsToRun, onError) {
+    switch (ev.type) {
+      case "text":
+        {
+          const last = assistantParts[assistantParts.length - 1];
+          if (last && last.type === "text") {
+            last.text += ev.delta;
+          } else {
+            assistantParts.push({ type: "text", text: ev.delta });
+          }
+        }
+        this.ctx.events?.onText?.(ev.delta);
+        break;
+      case "tool_call_start":
+        this.ctx.events?.onToolCallStart?.(ev.id, ev.name);
+        break;
+      case "tool_call_complete": {
+        const callPart = { type: "tool_use", id: ev.id, name: ev.name, args: ev.args };
+        assistantParts.push(callPart);
+        toolCallsToRun.push(callPart);
+        this.ctx.events?.onToolCallArgs?.(ev.id, ev.args);
+        break;
+      }
+      case "finish":
+        if (ev.usage) {
+          const adjusted = {
+            inputTokens: ev.usage.inputTokens - this.lastEstimateInputTokens,
+            outputTokens: ev.usage.outputTokens,
+            totalTokens: ev.usage.totalTokens - this.lastEstimateInputTokens
+          };
+          this.ctx.events?.onUsage?.(adjusted);
+          this.ctx.session.append({
+            type: "usage",
+            time: (/* @__PURE__ */ new Date()).toISOString(),
+            usage: ev.usage,
+            // session 写真实值,不写 estimate
+            provider: this.ctx.llm.providerName,
+            model: this.ctx.llm.model
+          });
+        }
+        this.lastEstimateInputTokens = 0;
+        break;
+      case "error":
+        onError(ev.error);
+        break;
+    }
+  }
+  /** Esc 中断时:把"已经流出来"的 assistant 内容存进 history,标 [interrupted] 后缀。 */
+  persistInterruptedAssistant(parts) {
+    const cleanedParts = parts.filter((p) => p.type !== "tool_use");
+    const lastIdx = cleanedParts.length - 1;
+    if (lastIdx >= 0 && cleanedParts[lastIdx].type === "text") {
+      const t = cleanedParts[lastIdx];
+      cleanedParts[lastIdx] = { type: "text", text: `${t.text}
+
+[interrupted]` };
+    } else {
+      cleanedParts.push({ type: "text", text: "[interrupted]" });
+    }
+    const assistantMessage = { role: "assistant", content: cleanedParts };
+    this.messages.push(assistantMessage);
+    this.ctx.session.append({ type: "message", time: (/* @__PURE__ */ new Date()).toISOString(), message: assistantMessage });
+  }
+  async runToolCall(call) {
+    const tool2 = this.ctx.tools.get(call.name);
+    if (!tool2) {
+      const result = `Tool "${call.name}" is not available.`;
+      this.recordToolResult(call.id, call.name, result, true);
+      return;
+    }
+    const summary = tool2.summarize?.(call.args) ?? `${call.name}(...)`;
+    const decision = this.ctx.permissions.decide({
+      toolName: call.name,
+      args: call.args,
+      permission: tool2.permission
+    });
+    if (decision === "deny") {
+      const reason = this.ctx.permissions.getMode() === "plan" ? `Denied: you are in plan mode. Only read-only tools are available. Propose changes instead of executing.` : `Denied by policy: ${call.name}.`;
+      this.recordToolResult(call.id, call.name, reason, true);
+      return;
+    }
+    if (decision === "ask") {
+      const userDecision = await this.ctx.events?.onPermissionRequest?.(call.name, call.args, summary) ?? "no";
+      if (userDecision === "no") {
+        this.recordToolResult(call.id, call.name, `User rejected ${call.name}.`, true);
+        return;
+      }
+      if (userDecision === "session_allow") {
+        this.ctx.permissions.allowForSession(call.name);
+      }
+    }
+    let effectiveArgs = call.args;
+    try {
+      const hookOut = await runHooks(
+        "PreToolUse",
+        { toolName: call.name, args: effectiveArgs },
+        this.ctx.hooks,
+        this.ctx.hookLogger
+      );
+      if (hookOut.args !== void 0) effectiveArgs = hookOut.args;
+    } catch (err) {
+      if (err instanceof PipelineBlockedError) {
+        this.ctx.events?.onBlocked?.(err.reason);
+        this.recordToolResult(call.id, call.name, `Blocked by PreToolUse hook: ${err.reason}`, true);
+        return;
+      }
+      throw err;
+    }
+    const toolCtx = {
+      cwd: this.ctx.cwd,
+      abortSignal: this.turnAbortSignal ?? this.ctx.abortSignal,
+      askPermission: async () => true,
+      // 已在外层处理
+      todos: this.todos,
+      askQuestions: this.ctx.events?.onAskQuestions ? (qs) => this.ctx.events.onAskQuestions(qs) : void 0
+    };
+    const raw = await this.ctx.tools.execute(call.name, effectiveArgs, toolCtx);
+    const processed = await this.postProcessResult({
+      toolName: call.name,
+      toolUseId: call.id,
+      args: effectiveArgs,
+      raw
+    });
+    this.recordToolResult(
+      call.id,
+      call.name,
+      processed.content,
+      processed.isError,
+      processed.summary,
+      processed.diff,
+      processed.kind
+    );
+  }
+  async postProcessResult(input) {
+    let content = input.raw.content;
+    let summary = input.raw.summary;
+    let diff = input.raw.diff;
+    const isError = input.raw.isError ?? false;
+    let kind = input.raw.kind;
+    if (this.ctx.resultPipeline) {
+      const rctx = createResultCtx({
+        toolName: input.toolName,
+        toolUseId: input.toolUseId,
+        args: input.args,
+        raw: input.raw,
+        settings: this.ctx.resultSettings
+      });
+      try {
+        await this.ctx.resultPipeline.run(rctx);
+        content = rctx.content;
+        summary = rctx.summary;
+        diff = rctx.diff;
+      } catch (err) {
+        log.warn("result pipeline error", { msg: err.message });
+      }
+    }
+    try {
+      const hookOut = await runHooks(
+        "PostToolUse",
+        { toolName: input.toolName, args: input.args, content, summary, isError },
+        this.ctx.hooks,
+        this.ctx.hookLogger
+      );
+      if (typeof hookOut.content === "string") content = hookOut.content;
+      if (typeof hookOut.summary === "string") summary = hookOut.summary;
+    } catch (err) {
+      if (err instanceof PipelineBlockedError) {
+        log.warn("PostToolUse hook tried to block, ignored", { reason: err.reason });
+      } else {
+        throw err;
+      }
+    }
+    if (input.toolName === "MemoryWrite" && !isError) {
+      const index = this.ctx.requestServices?.memoryEmbeddingIndex;
+      if (index) {
+        try {
+          const args = input.args;
+          const name = typeof args?.name === "string" ? args.name : void 0;
+          const scope = args?.scope === "user" ? "user" : "project";
+          if (name) {
+            await upsertMemoryEntry(index, name, scope);
+          }
+        } catch (err) {
+          log.warn("memory index upsert failed", { msg: err.message });
+        }
+      }
+    }
+    try {
+      const subdirInjection = await this.maybeInjectSubdirHierarchy(input.toolName, input.args);
+      if (subdirInjection) {
+        content = `${subdirInjection}
+
+---
+
+[Original tool result]
+${content}`;
+      }
+    } catch (err) {
+      log.warn("subdir hierarchy inject failed", { msg: err.message });
+    }
+    return { content, isError, summary, diff, kind };
+  }
+  /**
+   * 检查工具操作的路径是否落入未加载过的子目录;子目录(向上找最近的)若含 MUSE.md / AGENTS.md
+   * 就把内容封装成 system 注释返回(由 caller 前置到 tool result)。
+   */
+  async maybeInjectSubdirHierarchy(toolName, args) {
+    const path = extractToolPath(toolName, args);
+    if (!path) return null;
+    const absPath = isAbsolute4(path) ? path : resolve6(this.ctx.cwd, path);
+    const subdir = findContainingSubdirWithHierarchy(absPath, this.projectRoot);
+    if (!subdir) return null;
+    if (this.loadedSubdirs.has(subdir)) return null;
+    this.loadedSubdirs.add(subdir);
+    const loaded = await loadSubdirMemory(subdir);
+    if (!loaded) return null;
+    const relPath = relative(this.projectRoot, subdir) || ".";
+    const truncatedNote = loaded.truncated ? " (content truncated; use Read to view full file)" : "";
+    return `[System: loaded ${loaded.source} from ${relPath}/${truncatedNote}]
+${loaded.content}`;
+  }
+  recordToolResult(id, name, content, isError, summary, diff, kind) {
+    const toolMsg = {
+      role: "tool",
+      toolUseId: id,
+      content,
+      isError,
+      toolName: name,
+      ...diff ? { diff } : {},
+      ...summary ? { summary } : {},
+      ...kind ? { kind } : {}
+    };
+    this.messages.push(toolMsg);
+    this.ctx.session.append({ type: "message", time: (/* @__PURE__ */ new Date()).toISOString(), message: toolMsg });
+    this.ctx.events?.onToolResult?.(id, name, content, isError, summary);
+  }
+};
+function extractToolPath(toolName, args) {
+  if (typeof args !== "object" || args === null) return null;
+  if (toolName === "Read" || toolName === "Edit" || toolName === "Write") {
+    const fp = args.file_path;
+    if (typeof fp === "string") return fp;
+  }
+  if (toolName === "Grep" || toolName === "Glob") {
+    const p = args.path;
+    if (typeof p === "string") return p;
+  }
+  return null;
+}
+function findContainingSubdirWithHierarchy(absPath, projectRoot) {
+  const rel = relative(projectRoot, absPath);
+  if (!rel || rel.startsWith("..") || isAbsolute4(rel)) return null;
+  let cur = dirname5(absPath);
+  while (cur !== projectRoot && cur.startsWith(projectRoot)) {
+    if (existsSync5(join6(cur, "MUSE.md")) || existsSync5(join6(cur, "AGENTS.md"))) {
+      return cur;
+    }
+    const parent = dirname5(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+  return null;
+}
+
+// src/config/loader.ts
+import { readFile as readFile8 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join7, resolve as resolve7 } from "path";
+
+// src/config/types.ts
+import { z as z11 } from "zod";
+var ProviderConfigSchema = z11.object({
+  apiKey: z11.string().optional(),
+  baseUrl: z11.string().optional(),
+  extraHeaders: z11.record(z11.string()).optional()
+}).passthrough();
+var LLMConfigSchema = z11.object({
+  provider: z11.string().optional().describe("Fallback provider preset (only used when no models.local.json entry matches)."),
+  model: z11.string().optional().describe("Active model id; should match an id in models.local.json."),
+  temperature: z11.number().min(0).max(2).optional(),
+  maxTokens: z11.number().int().positive().optional()
+});
+var PermissionsSchema = z11.object({
+  allow: z11.array(z11.string()).optional(),
+  ask: z11.array(z11.string()).optional(),
+  deny: z11.array(z11.string()).optional(),
+  defaultMode: z11.enum(["strict", "relaxed", "ask"]).optional()
+});
+var UISchema = z11.object({
+  theme: z11.enum(["dark", "light"]).optional(),
+  lang: z11.enum(["en", "zh-CN"]).optional(),
+  showBanner: z11.boolean().optional()
+});
+var HookSpecSchema = z11.object({
+  matcher: z11.string().optional(),
+  command: z11.string(),
+  timeout: z11.number().int().positive().optional(),
+  onError: z11.enum(["skip", "throw"]).optional()
+});
+var HooksConfigSchema = z11.object({
+  SessionStart: z11.array(HookSpecSchema).optional(),
+  SessionEnd: z11.array(HookSpecSchema).optional(),
+  UserPromptSubmit: z11.array(HookSpecSchema).optional(),
+  PreLLMRequest: z11.array(HookSpecSchema).optional(),
+  PostLLMResponse: z11.array(HookSpecSchema).optional(),
+  PreToolUse: z11.array(HookSpecSchema).optional(),
+  PostToolUse: z11.array(HookSpecSchema).optional(),
+  PreCompact: z11.array(HookSpecSchema).optional(),
+  PostCompact: z11.array(HookSpecSchema).optional(),
+  MemoryPromote: z11.array(HookSpecSchema).optional()
+}).passthrough();
+var InputPreprocessSettingsSchema = z11.object({
+  atFileExpand: z11.object({
+    enabled: z11.boolean().optional(),
+    maxBytes: z11.number().int().positive().optional()
+  }).optional(),
+  templateExpand: z11.object({
+    enabled: z11.boolean().optional()
+  }).optional(),
+  maxChars: z11.number().int().positive().optional(),
+  redactPreScan: z11.object({
+    enabled: z11.boolean().optional()
+  }).optional()
+}).passthrough();
+var RequestPreprocessSettingsSchema = z11.object({
+  trimHistory: z11.object({
+    enabled: z11.boolean().optional(),
+    budgetRatio: z11.number().min(0).max(1).optional()
+  }).optional(),
+  budgetGuard: z11.object({
+    enabled: z11.boolean().optional(),
+    budgetRatio: z11.number().min(0).max(1).optional()
+  }).optional(),
+  redact: z11.object({
+    enabled: z11.boolean().optional()
+  }).optional()
+}).passthrough();
+var ResultPreprocessSettingsSchema = z11.object({
+  truncate: z11.object({
+    budgetBytes: z11.number().int().positive().optional()
+  }).optional(),
+  detectBinary: z11.object({
+    enabled: z11.boolean().optional()
+  }).optional(),
+  summarize: z11.object({
+    enabled: z11.boolean().optional()
+  }).optional(),
+  normalizeError: z11.object({
+    enabled: z11.boolean().optional()
+  }).optional(),
+  redact: z11.object({
+    enabled: z11.boolean().optional()
+  }).optional(),
+  injectDiff: z11.boolean().optional()
+}).passthrough();
+var RenderPreprocessSettingsSchema = z11.object({
+  streamMarkdown: z11.object({
+    enabled: z11.boolean().optional()
+  }).optional(),
+  collapseLong: z11.object({
+    enabled: z11.boolean().optional(),
+    threshold: z11.number().int().positive().optional()
+  }).optional()
+}).passthrough();
+var PreprocessSettingsSchema = z11.object({
+  input: InputPreprocessSettingsSchema.optional(),
+  request: RequestPreprocessSettingsSchema.optional(),
+  result: ResultPreprocessSettingsSchema.optional(),
+  render: RenderPreprocessSettingsSchema.optional(),
+  /** 全局禁用的 stage name 列表(kebab-case)。 */
+  disable: z11.array(z11.string()).optional()
+}).passthrough();
+var SettingsSchema = z11.object({
+  llm: LLMConfigSchema.optional(),
+  providers: z11.record(ProviderConfigSchema).optional(),
+  permissions: PermissionsSchema.optional(),
+  ui: UISchema.optional(),
+  mcpServers: z11.record(z11.unknown()).optional(),
+  skills: z11.object({
+    enabled: z11.boolean().optional(),
+    disabled: z11.array(z11.string()).optional()
+  }).optional(),
+  hooks: HooksConfigSchema.optional(),
+  preprocess: PreprocessSettingsSchema.optional(),
+  /**
+   * 启动时注入到 process.env 的额外环境变量(对齐业界 CLI Agent 的 settings.env 模式)。
+   * 值必须是字符串(JSON 无 number→env 的隐式转换;约束传 "1" / "0" 这种字面值)。
+   *
+   * 当前支持的 muse 自识别变量:
+   *   MUSE_DISABLE_CURSOR_BLINK=1   关闭输入框光标闪烁(默认闪烁)
+   *   其他 muse 模块可自行约定 MUSE_* 名字读取。
+   *
+   * 注意:这里写入的变量会进入 process.env,**但 Hook 子进程仍走环境变量白名单**
+   * (见 src/preprocess/hooks.ts),不会自动透传给 hook 命令,避免泄露密钥。
+   */
+  env: z11.record(z11.string()).optional(),
+  /** Memory 模块设置(II-5 向量索引)。 */
+  memory: z11.object({
+    embedding: z11.object({
+      /** 启用 embedding 召回(默认 false;关闭时 inject-memory 走传统全文)。 */
+      enabled: z11.boolean().optional(),
+      /** 后端 provider。默认 hash-bag(零依赖);设了 preset 自动走 openai-compatible。 */
+      provider: z11.enum(["hash-bag", "openai-compatible", "openai", "local-minilm"]).optional(),
+      /** Preset 名(dashscope-v3 / openai-3-small / openai-3-large / zhipu-3 / ollama-nomic / ollama-bge-m3)。 */
+      preset: z11.string().optional(),
+      /** Base URL(覆盖 preset 默认或自定义 provider 时填)。 */
+      baseUrl: z11.string().optional(),
+      /** 模型名(覆盖 preset 默认或自定义 provider 时填)。 */
+      model: z11.string().optional(),
+      /** 向量维度(用户根据模型官方说明调整;preset 给推荐默认,可覆盖)。
+       *  设了此字段 → HTTP 请求带 dimensions 参数(MRL truncation);
+       *  没设 → 走模型默认。
+       *  启动期 muse 会 probe 一次校验实际维度,不匹配则降级 hash-bag + 提示修正。 */
+      dim: z11.number().int().positive().optional(),
+      /** API key(${ENV_VAR} 或明文;Ollama 等本地端点可省)。 */
+      apiKey: z11.string().optional(),
+      /** 检索 top-K(默认 5)。 */
+      topK: z11.number().int().positive().optional(),
+      /** memory 数量低于此值时退化到全注入(默认 3,2026-06-07 R5 修订)。 */
+      minMemoryCount: z11.number().int().nonnegative().optional(),
+      /** 注入 token 预算上限,超出按 trust 优先保留(默认 1500)。 */
+      maxInjectTokens: z11.number().int().positive().optional()
+    }).optional()
+  }).optional()
+}).passthrough();
+
+// src/config/_env.ts
+var ENV_PATTERN2 = /\$\{([A-Z_][A-Z0-9_]*)\}/g;
+function expandEnvVars(value) {
+  if (typeof value === "string") {
+    return value.replace(ENV_PATTERN2, (_match, name) => process.env[name] ?? "");
+  }
+  if (Array.isArray(value)) {
+    return value.map(expandEnvVars);
+  }
+  if (value && typeof value === "object") {
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = expandEnvVars(v);
+    }
+    return result;
+  }
+  return value;
+}
+
+// src/config/loader.ts
+function formatZodIssues(issues) {
+  return issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; ");
+}
+var DEFAULTS = {
   llm: {
     provider: "deepseek",
     model: "deepseek-chat"
@@ -1894,9 +3839,9 @@ var DEFAULTS = {
   }
 };
 async function readJsonIfExists(path) {
-  if (!existsSync3(path)) return void 0;
+  if (!existsSync6(path)) return void 0;
   try {
-    const raw = await readFile6(path, "utf-8");
+    const raw = await readFile8(path, "utf-8");
     return JSON.parse(raw);
   } catch (err) {
     log.warn(`Failed to parse settings at ${path}: ${err instanceof Error ? err.message : String(err)}`);
@@ -1924,9 +3869,9 @@ async function loadSettings(cwd = process.cwd()) {
   const sources = ["<defaults>"];
   let merged = DEFAULTS;
   const candidates = [
-    join4(homedir6(), ".muse", "settings.json"),
-    join4(cwd, ".muse", "settings.json"),
-    join4(cwd, ".muse", "settings.local.json")
+    join7(homedir7(), ".muse", "settings.json"),
+    join7(cwd, ".muse", "settings.json"),
+    join7(cwd, ".muse", "settings.local.json")
   ];
   for (const path of candidates) {
     const raw = await readJsonIfExists(path);
@@ -1949,6 +3894,13 @@ async function loadSettings(cwd = process.cwd()) {
     sources.push("env:MUSE_MODEL");
   }
   merged = expandEnvVars(merged);
+  if (merged.env) {
+    for (const [key, value] of Object.entries(merged.env)) {
+      if (process.env[key] === void 0) {
+        process.env[key] = value;
+      }
+    }
+  }
   return { settings: merged, sources };
 }
 export {