@qxbyte/muse 0.1.0 → 0.1.2

package/dist/cli.js

@@ -5,17 +5,147 @@ import { Command } from "commander";
 import { render } from "ink";
 
 // src/app.tsx
-import { useCallback, useEffect, useMemo as useMemo2, useReducer, useRef, useState as useState2 } from "react";
-import { Box as Box9, Text as Text9, useApp, useInput as useInput3, useStdout } from "ink";
-import TextInput from "ink-text-input";
-import { mkdir as mkdir2, readFile as readFile4, writeFile } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
-import { homedir as homedir7 } from "os";
-import { dirname as dirname3, join as join5 } from "path";
+import { useCallback, useEffect as useEffect5, useMemo as useMemo2, useReducer, useRef, useState as useState7 } from "react";
+import { Box as Box12, Text as Text14, useApp, useInput as useInput4, useStdout } from "ink";
 
-// src/components/StartupBanner.tsx
-import { Box, Text } from "ink";
+// src/components/BgTextInput.tsx
+import { useState, useEffect } from "react";
+import { Text, useInput } from "ink";
 import { jsx, jsxs } from "react/jsx-runtime";
+var BLINK_MS = 530;
+function BgTextInput({
+  value,
+  onChange,
+  onSubmit,
+  width,
+  backgroundColor,
+  color,
+  isActive = true
+}) {
+  const [cursor, setCursor] = useState(value.length);
+  const [blinkOn, setBlinkOn] = useState(true);
+  useEffect(() => {
+    setCursor((c) => Math.min(c, value.length));
+  }, [value]);
+  useEffect(() => {
+    if (!isActive) return;
+    setBlinkOn(true);
+    const id = setInterval(() => setBlinkOn((b) => !b), BLINK_MS);
+    return () => clearInterval(id);
+  }, [isActive, cursor, value]);
+  useInput(
+    (input, key) => {
+      if (key.return) {
+        onSubmit?.(value);
+        return;
+      }
+      if (key.backspace || key.delete) {
+        if (cursor === 0) return;
+        const next = value.slice(0, cursor - 1) + value.slice(cursor);
+        onChange(next);
+        setCursor((c) => Math.max(0, c - 1));
+        return;
+      }
+      if (key.leftArrow) {
+        setCursor((c) => Math.max(0, c - 1));
+        return;
+      }
+      if (key.rightArrow) {
+        setCursor((c) => Math.min(value.length, c + 1));
+        return;
+      }
+      if (key.ctrl && input === "a") {
+        setCursor(0);
+        return;
+      }
+      if (key.ctrl && input === "e") {
+        setCursor(value.length);
+        return;
+      }
+      if (key.ctrl || key.shift || key.tab || key.escape || key.upArrow || key.downArrow || key.meta) {
+        return;
+      }
+      if (input && !key.return) {
+        const next = value.slice(0, cursor) + input + value.slice(cursor);
+        onChange(next);
+        setCursor((c) => c + input.length);
+      }
+    },
+    { isActive }
+  );
+  const view = computeViewport(value, cursor, width);
+  const at = view.atChar;
+  const padLen = Math.max(0, width - view.consumedWidth);
+  const showCursor = isActive && blinkOn;
+  return /* @__PURE__ */ jsxs(Text, { backgroundColor, color, children: [
+    view.before,
+    showCursor ? /* @__PURE__ */ jsx(Text, { backgroundColor: "blue", color, dimColor: true, children: at }) : /* @__PURE__ */ jsx(Text, { backgroundColor, color, children: at }),
+    view.after,
+    " ".repeat(padLen)
+  ] });
+}
+function charWidth(ch) {
+  const cp = ch.codePointAt(0);
+  if (cp === void 0) return 0;
+  if (cp < 32 || cp === 127) return 0;
+  if (cp >= 4352 && cp <= 4447 || // Hangul Jamo
+  cp >= 11904 && cp <= 12350 || // CJK Radicals
+  cp >= 12353 && cp <= 13311 || // Hiragana / Katakana / CJK Symbols
+  cp >= 13312 && cp <= 19903 || // CJK Ext A
+  cp >= 19968 && cp <= 40959 || // CJK Unified
+  cp >= 40960 && cp <= 42191 || // Yi
+  cp >= 44032 && cp <= 55203 || // Hangul Syllables
+  cp >= 63744 && cp <= 64255 || // CJK Compat
+  cp >= 65072 && cp <= 65103 || // CJK Compat Forms
+  cp >= 65280 && cp <= 65376 || // Fullwidth ASCII / Punctuation
+  cp >= 65504 && cp <= 65510 || // Fullwidth Sign
+  cp >= 131072 && cp <= 196605) {
+    return 2;
+  }
+  return 1;
+}
+function stringWidth(s) {
+  let w = 0;
+  for (const ch of s) w += charWidth(ch);
+  return w;
+}
+function computeViewport(value, cursor, width) {
+  const cursorAtEnd = cursor >= value.length;
+  const atChar = cursorAtEnd ? " " : value[cursor] ?? " ";
+  const cursorCellW = charWidth(atChar);
+  let beforeStart = 0;
+  while (true) {
+    const before = value.slice(beforeStart, cursor);
+    const after = cursorAtEnd ? "" : value.slice(cursor + 1);
+    const total = stringWidth(before) + cursorCellW + stringWidth(after);
+    if (total <= width) {
+      return { before, atChar, after, consumedWidth: total };
+    }
+    if (beforeStart >= cursor) {
+      let after2 = cursorAtEnd ? "" : value.slice(cursor + 1);
+      while (after2.length > 0 && stringWidth("") + cursorCellW + stringWidth(after2) > width) {
+        after2 = after2.slice(0, -1);
+      }
+      return {
+        before: "",
+        atChar,
+        after: after2,
+        consumedWidth: cursorCellW + stringWidth(after2)
+      };
+    }
+    beforeStart++;
+  }
+}
+
+// src/app.tsx
+import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import { homedir as homedir8 } from "os";
+import { basename, dirname as dirname3, join as join6 } from "path";
+
+// src/components/StartupBanner.tsx
+import { Box, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 var LETTERS = {
   M: ["\u2588   \u2588", "\u2588\u2588 \u2588\u2588", "\u2588 \u2588 \u2588", "\u2588   \u2588", "\u2588   \u2588"],
   U: ["\u2588   \u2588", "\u2588   \u2588", "\u2588   \u2588", "\u2588   \u2588", " \u2588\u2588\u2588 "],
@@ -35,87 +165,87 @@ var LETTER_GAP = 3;
 var LOGO_WIDTH = 5 * 4 + LETTER_GAP * 3;
 var GAP_WIDTH = 6;
 function LogoLine({ row }) {
-  return /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
-    /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { color: COLORS.M, children: LETTERS.M[row] }) }),
-    /* @__PURE__ */ jsx(Box, { marginLeft: LETTER_GAP, children: /* @__PURE__ */ jsx(Text, { color: COLORS.U, children: LETTERS.U[row] }) }),
-    /* @__PURE__ */ jsx(Box, { marginLeft: LETTER_GAP, children: /* @__PURE__ */ jsx(Text, { color: COLORS.S, children: LETTERS.S[row] }) }),
-    /* @__PURE__ */ jsx(Box, { marginLeft: LETTER_GAP, children: /* @__PURE__ */ jsx(Text, { color: COLORS.E, children: LETTERS.E[row] }) })
+  return /* @__PURE__ */ jsxs2(Box, { flexDirection: "row", children: [
+    /* @__PURE__ */ jsx2(Box, { children: /* @__PURE__ */ jsx2(Text2, { color: COLORS.M, children: LETTERS.M[row] }) }),
+    /* @__PURE__ */ jsx2(Box, { marginLeft: LETTER_GAP, children: /* @__PURE__ */ jsx2(Text2, { color: COLORS.U, children: LETTERS.U[row] }) }),
+    /* @__PURE__ */ jsx2(Box, { marginLeft: LETTER_GAP, children: /* @__PURE__ */ jsx2(Text2, { color: COLORS.S, children: LETTERS.S[row] }) }),
+    /* @__PURE__ */ jsx2(Box, { marginLeft: LETTER_GAP, children: /* @__PURE__ */ jsx2(Text2, { color: COLORS.E, children: LETTERS.E[row] }) })
   ] });
 }
 function BannerLine({ row, children }) {
-  return /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
-    /* @__PURE__ */ jsx(Box, { minWidth: LOGO_WIDTH, children: /* @__PURE__ */ jsx(LogoLine, { row }) }),
-    /* @__PURE__ */ jsx(Box, { width: GAP_WIDTH }),
+  return /* @__PURE__ */ jsxs2(Box, { flexDirection: "row", children: [
+    /* @__PURE__ */ jsx2(Box, { minWidth: LOGO_WIDTH, children: /* @__PURE__ */ jsx2(LogoLine, { row }) }),
+    /* @__PURE__ */ jsx2(Box, { width: GAP_WIDTH }),
     children ?? null
   ] });
 }
 function StartupBanner({ version, model, cwd }) {
-  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingY: 0, children: [
-    /* @__PURE__ */ jsx(BannerLine, { row: 0 }),
-    /* @__PURE__ */ jsx(BannerLine, { row: 1, children: /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
-      /* @__PURE__ */ jsx(Text, { color: COLORS.asterisk, children: "\u273B" }),
-      /* @__PURE__ */ jsx(Text, { color: COLORS.text, children: " Welcome to Muse " }),
-      /* @__PURE__ */ jsxs(Text, { color: COLORS.versionAccent, children: [
+  return /* @__PURE__ */ jsxs2(Box, { flexDirection: "column", paddingY: 0, children: [
+    /* @__PURE__ */ jsx2(BannerLine, { row: 0 }),
+    /* @__PURE__ */ jsx2(BannerLine, { row: 1, children: /* @__PURE__ */ jsxs2(Box, { flexDirection: "row", children: [
+      /* @__PURE__ */ jsx2(Text2, { color: COLORS.asterisk, children: "\u273B" }),
+      /* @__PURE__ */ jsx2(Text2, { color: COLORS.text, children: " Welcome to Muse " }),
+      /* @__PURE__ */ jsxs2(Text2, { color: COLORS.versionAccent, children: [
         "v",
         version
       ] })
     ] }) }),
-    /* @__PURE__ */ jsx(BannerLine, { row: 2, children: /* @__PURE__ */ jsxs(Text, { color: COLORS.text, children: [
+    /* @__PURE__ */ jsx2(BannerLine, { row: 2, children: /* @__PURE__ */ jsxs2(Text2, { color: COLORS.text, children: [
       "model: ",
       model
     ] }) }),
-    /* @__PURE__ */ jsx(BannerLine, { row: 3, children: /* @__PURE__ */ jsxs(Text, { color: COLORS.text, children: [
+    /* @__PURE__ */ jsx2(BannerLine, { row: 3, children: /* @__PURE__ */ jsxs2(Text2, { color: COLORS.text, children: [
       "cwd:   ",
       cwd
     ] }) }),
-    /* @__PURE__ */ jsx(BannerLine, { row: 4 })
+    /* @__PURE__ */ jsx2(BannerLine, { row: 4 })
   ] });
 }
 function CompactBanner({ version, model, cwd }) {
-  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingY: 0, children: [
-    /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
-      /* @__PURE__ */ jsx(Text, { color: COLORS.asterisk, children: "\u273B" }),
-      /* @__PURE__ */ jsx(Text, { color: COLORS.text, children: " Welcome to Muse " }),
-      /* @__PURE__ */ jsxs(Text, { color: COLORS.versionAccent, children: [
+  return /* @__PURE__ */ jsxs2(Box, { flexDirection: "column", paddingY: 0, children: [
+    /* @__PURE__ */ jsxs2(Box, { flexDirection: "row", children: [
+      /* @__PURE__ */ jsx2(Text2, { color: COLORS.asterisk, children: "\u273B" }),
+      /* @__PURE__ */ jsx2(Text2, { color: COLORS.text, children: " Welcome to Muse " }),
+      /* @__PURE__ */ jsxs2(Text2, { color: COLORS.versionAccent, children: [
         "v",
         version
       ] })
     ] }),
-    /* @__PURE__ */ jsxs(Text, { color: COLORS.text, children: [
+    /* @__PURE__ */ jsxs2(Text2, { color: COLORS.text, children: [
       "model: ",
       model
     ] }),
-    /* @__PURE__ */ jsxs(Text, { color: COLORS.text, children: [
+    /* @__PURE__ */ jsxs2(Text2, { color: COLORS.text, children: [
       "cwd:   ",
       cwd
     ] })
   ] });
 }
 function SingleLineBanner({ version, model }) {
-  return /* @__PURE__ */ jsxs(Text, { children: [
-    /* @__PURE__ */ jsx(Text, { color: COLORS.text, children: "Muse " }),
-    /* @__PURE__ */ jsxs(Text, { color: COLORS.versionAccent, children: [
+  return /* @__PURE__ */ jsxs2(Text2, { children: [
+    /* @__PURE__ */ jsx2(Text2, { color: COLORS.text, children: "Muse " }),
+    /* @__PURE__ */ jsxs2(Text2, { color: COLORS.versionAccent, children: [
       "v",
       version
     ] }),
-    /* @__PURE__ */ jsxs(Text, { color: COLORS.text, children: [
+    /* @__PURE__ */ jsxs2(Text2, { color: COLORS.text, children: [
       " \xB7 ",
       model
     ] })
   ] });
 }
 function pickBanner(width, props) {
-  if (width >= 60) return /* @__PURE__ */ jsx(StartupBanner, { ...props });
-  if (width >= 40) return /* @__PURE__ */ jsx(CompactBanner, { ...props });
-  return /* @__PURE__ */ jsx(SingleLineBanner, { version: props.version, model: props.model });
+  if (width >= 60) return /* @__PURE__ */ jsx2(StartupBanner, { ...props });
+  if (width >= 40) return /* @__PURE__ */ jsx2(CompactBanner, { ...props });
+  return /* @__PURE__ */ jsx2(SingleLineBanner, { version: props.version, model: props.model });
 }
 
 // src/components/MessageView.tsx
 import { useMemo } from "react";
-import { Box as Box2, Text as Text2 } from "ink";
+import { Box as Box2, Text as Text3 } from "ink";
 import { marked } from "marked";
 import { markedTerminal } from "marked-terminal";
-import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
 marked.use(markedTerminal());
 function renderMarkdown(text) {
   try {
@@ -128,11 +258,21 @@ function renderMarkdown(text) {
 function MessageView({ message }) {
   switch (message.role) {
     case "user":
-      return /* @__PURE__ */ jsx2(UserMessage, { content: typeof message.content === "string" ? message.content : flattenText(message.content) });
+      return /* @__PURE__ */ jsx3(UserMessage, { content: typeof message.content === "string" ? message.content : flattenText(message.content) });
     case "assistant":
-      return /* @__PURE__ */ jsx2(AssistantMessage, { content: message.content });
+      return /* @__PURE__ */ jsx3(AssistantMessage, { content: message.content });
     case "tool":
-      return /* @__PURE__ */ jsx2(ToolResultLine, { isError: message.isError ?? false, content: message.content });
+      if (message.toolName === "TodoWrite") return null;
+      return /* @__PURE__ */ jsx3(
+        ToolResultLine,
+        {
+          isError: message.isError ?? false,
+          content: message.content,
+          diff: message.diff,
+          summary: message.summary,
+          kind: message.kind
+        }
+      );
     case "system":
       return null;
   }
@@ -140,47 +280,134 @@ function MessageView({ message }) {
 function flattenText(parts) {
   return parts.filter((p) => p.type === "text").map((p) => p.text).join("\n");
 }
+var DOT = "\u23FA";
 function UserMessage({ content }) {
-  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "row", marginTop: 1, children: [
-    /* @__PURE__ */ jsx2(Text2, { color: "cyan", bold: true, children: "> " }),
-    /* @__PURE__ */ jsx2(Text2, { children: content })
+  return /* @__PURE__ */ jsxs3(Box2, { flexDirection: "row", marginTop: 1, children: [
+    /* @__PURE__ */ jsx3(Text3, { color: "cyan", bold: true, children: "> " }),
+    /* @__PURE__ */ jsx3(Text3, { children: content })
   ] });
 }
 function AssistantMessage({ content }) {
-  return /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", marginTop: 1, children: content.map((part, i) => {
+  return /* @__PURE__ */ jsx3(Box2, { flexDirection: "column", marginTop: 1, children: content.map((part, i) => {
     if (part.type === "text") {
-      return /* @__PURE__ */ jsx2(AssistantTextPart, { text: part.text }, i);
+      return /* @__PURE__ */ jsx3(AssistantTextPart, { text: part.text }, i);
     }
     if (part.type === "tool_use") {
-      return /* @__PURE__ */ jsx2(ToolCallLine, { name: part.name, args: part.args }, i);
+      if (part.name === "TodoWrite") {
+        return /* @__PURE__ */ jsx3(TodoList, { todos: extractTodos(part.args) }, i);
+      }
+      return /* @__PURE__ */ jsx3(ToolCallLine, { name: part.name, args: part.args }, i);
     }
     return null;
   }) });
 }
 function AssistantTextPart({ text }) {
   const rendered = useMemo(() => renderMarkdown(text), [text]);
-  return /* @__PURE__ */ jsx2(Text2, { children: rendered });
+  return /* @__PURE__ */ jsxs3(Box2, { flexDirection: "row", children: [
+    /* @__PURE__ */ jsxs3(Text3, { color: "cyan", children: [
+      DOT,
+      " "
+    ] }),
+    /* @__PURE__ */ jsx3(Box2, { flexDirection: "column", flexGrow: 1, children: /* @__PURE__ */ jsx3(Text3, { children: rendered }) })
+  ] });
 }
 function ToolCallLine({ name, args }) {
   const argSummary = formatArgs(args);
-  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "row", marginTop: 1, children: [
-    /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: "\u2192 " }),
-    /* @__PURE__ */ jsx2(Text2, { color: "yellow", bold: true, children: name }),
-    /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+  return /* @__PURE__ */ jsxs3(Box2, { flexDirection: "row", children: [
+    /* @__PURE__ */ jsxs3(Text3, { color: "yellow", children: [
+      DOT,
+      " "
+    ] }),
+    /* @__PURE__ */ jsx3(Text3, { color: "yellow", bold: true, children: name }),
+    /* @__PURE__ */ jsx3(Box2, { flexGrow: 1, minWidth: 0, children: /* @__PURE__ */ jsxs3(Text3, { dimColor: true, wrap: "truncate-end", children: [
       "(",
       argSummary,
       ")"
-    ] })
+    ] }) })
   ] });
 }
-function ToolResultLine({ isError, content }) {
-  const preview = content.length > 200 ? content.slice(0, 200) + "..." : content;
-  const oneLine = preview.split("\n")[0];
-  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "row", marginLeft: 2, children: [
-    /* @__PURE__ */ jsx2(Text2, { color: isError ? "red" : "green", children: isError ? "\u2717 " : "\u2713 " }),
-    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: oneLine })
+function extractTodos(args) {
+  if (typeof args !== "object" || args === null) return [];
+  const todos = args.todos;
+  return Array.isArray(todos) ? todos : [];
+}
+function TodoList({ todos }) {
+  return /* @__PURE__ */ jsxs3(Box2, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsxs3(Box2, { flexDirection: "row", children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "yellow", children: "\u2192 " }),
+      /* @__PURE__ */ jsx3(Text3, { color: "yellow", bold: true, children: "Todos" })
+    ] }),
+    todos.map((todo, i) => /* @__PURE__ */ jsx3(TodoRow, { todo }, i))
   ] });
 }
+function TodoRow({ todo }) {
+  const label = todo.status === "in_progress" && todo.activeForm ? todo.activeForm : todo.content;
+  switch (todo.status) {
+    case "completed":
+      return /* @__PURE__ */ jsxs3(Box2, { flexDirection: "row", marginLeft: 2, children: [
+        /* @__PURE__ */ jsx3(Text3, { color: "green", children: "\u2612 " }),
+        /* @__PURE__ */ jsx3(Text3, { dimColor: true, strikethrough: true, children: label })
+      ] });
+    case "in_progress":
+      return /* @__PURE__ */ jsxs3(Box2, { flexDirection: "row", marginLeft: 2, children: [
+        /* @__PURE__ */ jsx3(Text3, { color: "cyan", bold: true, children: "\u2610 " }),
+        /* @__PURE__ */ jsx3(Text3, { color: "cyan", bold: true, children: label })
+      ] });
+    default:
+      return /* @__PURE__ */ jsxs3(Box2, { flexDirection: "row", marginLeft: 2, children: [
+        /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "\u2610 " }),
+        /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: label })
+      ] });
+  }
+}
+function ToolResultLine({
+  isError,
+  content,
+  diff,
+  summary,
+  kind
+}) {
+  const fallback = (() => {
+    const preview = content.length > 200 ? content.slice(0, 200) + "\u2026" : content;
+    return preview.split("\n")[0];
+  })();
+  const headLine = summary ?? fallback;
+  const totalLines = content.split("\n").length;
+  const extra = totalLines > 1 ? ` (+${totalLines - 1} lines)` : "";
+  const effective = kind ?? (isError ? "error" : "success");
+  const dotColor = effective === "error" ? "red" : effective === "warn" ? "yellowBright" : "green";
+  return /* @__PURE__ */ jsxs3(Box2, { flexDirection: "column", marginLeft: 2, children: [
+    /* @__PURE__ */ jsxs3(Box2, { flexDirection: "row", children: [
+      /* @__PURE__ */ jsxs3(Text3, { color: dotColor, children: [
+        DOT,
+        " "
+      ] }),
+      /* @__PURE__ */ jsx3(Box2, { flexGrow: 1, minWidth: 0, children: /* @__PURE__ */ jsxs3(Text3, { dimColor: true, wrap: "truncate-end", children: [
+        headLine,
+        extra
+      ] }) })
+    ] }),
+    diff && /* @__PURE__ */ jsx3(DiffBlock, { diff })
+  ] });
+}
+function DiffBlock({ diff }) {
+  const lines = diff.split("\n");
+  const start = lines.findIndex((l) => l.startsWith("@@"));
+  const rendered = start >= 0 ? lines.slice(start) : lines;
+  return /* @__PURE__ */ jsx3(Box2, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: rendered.map((line, i) => {
+    let color;
+    let dim = false;
+    if (line.startsWith("+")) color = "green";
+    else if (line.startsWith("-")) color = "red";
+    else if (line.startsWith("@@")) {
+      color = "cyan";
+      dim = true;
+    } else {
+      dim = true;
+    }
+    return /* @__PURE__ */ jsx3(Text3, { color, dimColor: dim, children: line || " " }, i);
+  }) });
+}
 function formatArgs(args) {
   if (typeof args !== "object" || args === null) return String(args);
   const entries = Object.entries(args);
@@ -198,34 +425,86 @@ function formatArgs(args) {
 }
 
 // src/components/PermissionPrompt.tsx
-import { Box as Box3, Text as Text3, useInput } from "ink";
-import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+import { useState as useState2 } from "react";
+import { Box as Box3, Text as Text4, useInput as useInput2 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var OPTIONS = [
+  { decision: "yes", labelKey: "yes", shortcut: "y" },
+  { decision: "session_allow", labelKey: "session", shortcut: "s" },
+  { decision: "no", labelKey: "no", shortcut: "n" }
+];
 function PermissionPrompt({ request }) {
-  useInput((input, key) => {
-    if (input === "y" || key.return) {
-      request.resolve(true);
-    } else if (input === "n" || key.escape) {
-      request.resolve(false);
+  const [index, setIndex] = useState2(0);
+  useInput2((input, key) => {
+    if (key.upArrow) {
+      setIndex((i) => (i - 1 + OPTIONS.length) % OPTIONS.length);
+      return;
+    }
+    if (key.downArrow) {
+      setIndex((i) => (i + 1) % OPTIONS.length);
+      return;
+    }
+    if (key.return) {
+      request.resolve(OPTIONS[index].decision);
+      return;
+    }
+    if (key.escape) {
+      request.resolve("no");
+      return;
+    }
+    const lower = input?.toLowerCase?.();
+    for (let i = 0; i < OPTIONS.length; i++) {
+      const o = OPTIONS[i];
+      if (lower === o.shortcut || input === String(i + 1)) {
+        request.resolve(o.decision);
+        return;
+      }
     }
   });
-  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginY: 1, borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
-    /* @__PURE__ */ jsxs3(Text3, { color: "yellow", bold: true, children: [
+  return /* @__PURE__ */ jsxs4(Box3, { flexDirection: "column", marginY: 1, borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs4(Text4, { color: "yellow", bold: true, children: [
       "\u23F5 Approve ",
       request.toolName,
       "?"
     ] }),
-    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: request.summary }),
-    /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx3(Text3, { children: "(y)es / (n)o / Enter=allow / Esc=reject" }) })
+    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: request.summary }),
+    /* @__PURE__ */ jsx4(Box3, { flexDirection: "column", marginTop: 1, children: OPTIONS.map((o, i) => {
+      const focused = i === index;
+      const label = labelFor(o.labelKey, request.toolName);
+      return /* @__PURE__ */ jsxs4(Text4, { color: focused ? "cyan" : void 0, bold: focused, children: [
+        focused ? "\u203A " : "  ",
+        i + 1,
+        ". ",
+        label,
+        "  ",
+        /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+          "(",
+          o.shortcut,
+          ")"
+        ] })
+      ] }, o.decision);
+    }) }),
+    /* @__PURE__ */ jsx4(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "\u2191\u2193 select \xB7 Enter confirm \xB7 y/s/n shortcut \xB7 Esc=no" }) })
   ] });
 }
+function labelFor(key, toolName) {
+  switch (key) {
+    case "yes":
+      return "Yes";
+    case "session":
+      return `Yes, allow ${toolName} for the rest of this session`;
+    case "no":
+      return "No";
+  }
+}
 
 // src/components/ModelSelector.tsx
-import { Box as Box5, Text as Text5 } from "ink";
+import { Box as Box5, Text as Text6 } from "ink";
 
 // src/components/Selector.tsx
-import { useState } from "react";
-import { Box as Box4, Text as Text4, useInput as useInput2 } from "ink";
-import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+import { useState as useState3 } from "react";
+import { Box as Box4, Text as Text5, useInput as useInput3 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
 var POINTER_COLOR = "#A855F7";
 function Selector({
   items,
@@ -238,8 +517,8 @@ function Selector({
   onCancel
 }) {
   const safeInitial = Math.max(0, Math.min(initialIndex, items.length - 1));
-  const [index, setIndex] = useState(safeInitial);
-  useInput2((_, key) => {
+  const [index, setIndex] = useState3(safeInitial);
+  useInput3((_, key) => {
     if (key.upArrow) {
       setIndex((i) => Math.max(0, i - 1));
     } else if (key.downArrow) {
@@ -255,7 +534,7 @@ function Selector({
   const start = Math.max(0, Math.min(index - Math.floor(window / 2), len - window));
   const end = Math.min(len, start + window);
   const visible = items.slice(start, end);
-  return /* @__PURE__ */ jsxs4(
+  return /* @__PURE__ */ jsxs5(
     Box4,
     {
       flexDirection: "column",
@@ -264,20 +543,20 @@ function Selector({
       borderStyle: "round",
       borderColor: "cyan",
       children: [
-        (title || hint) && /* @__PURE__ */ jsxs4(Box4, { marginBottom: 1, children: [
-          title && /* @__PURE__ */ jsx4(Text4, { bold: true, children: title }),
-          title && hint && /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "  " }),
-          hint && /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: hint })
+        (title || hint) && /* @__PURE__ */ jsxs5(Box4, { marginBottom: 1, children: [
+          title && /* @__PURE__ */ jsx5(Text5, { bold: true, children: title }),
+          title && hint && /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "  " }),
+          hint && /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: hint })
         ] }),
         visible.map((item, i) => {
           const realIndex = start + i;
           const focused = realIndex === index;
-          return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "row", children: [
-            /* @__PURE__ */ jsx4(Text4, { color: POINTER_COLOR, bold: true, children: focused ? "\u203A " : "  " }),
+          return /* @__PURE__ */ jsxs5(Box4, { flexDirection: "row", children: [
+            /* @__PURE__ */ jsx5(Text5, { color: POINTER_COLOR, bold: true, children: focused ? "\u203A " : "  " }),
             renderRow(item, focused)
           ] }, realIndex);
         }),
-        window < len && /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+        window < len && /* @__PURE__ */ jsx5(Box4, { marginTop: 1, children: /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
           "(",
           start + 1,
           "-",
@@ -292,24 +571,24 @@ function Selector({
 }
 
 // src/components/ModelSelector.tsx
-import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
 function ModelSelector({ request }) {
-  const { items, currentId, resolve: resolve5 } = request;
+  const { items, currentId, resolve: resolve6 } = request;
   const initialIndex = Math.max(
     0,
     items.findIndex((m) => m.id === currentId)
   );
   const labelWidth = Math.max(...items.map((m) => (m.name ?? m.id).length));
-  return /* @__PURE__ */ jsx5(
+  return /* @__PURE__ */ jsx6(
     Selector,
     {
       items,
       initialIndex,
       title: "Select model",
       hint: "\u2191\u2193 navigate \xB7 Enter confirm \xB7 Esc cancel",
-      onSubmit: (m) => resolve5(m),
-      onCancel: () => resolve5(null),
-      renderRow: (m, _focused) => /* @__PURE__ */ jsx5(ModelRow, { model: m, active: m.id === currentId, labelWidth })
+      onSubmit: (m) => resolve6(m),
+      onCancel: () => resolve6(null),
+      renderRow: (m, _focused) => /* @__PURE__ */ jsx6(ModelRow, { model: m, active: m.id === currentId, labelWidth })
     }
   );
 }
@@ -322,17 +601,17 @@ function ModelRow({
   const label = (model.name ?? model.id).padEnd(labelWidth);
   const vendor = model.vendor ? `[${model.vendor}]` : "";
   const caps = formatCaps(model);
-  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "row", children: [
-    /* @__PURE__ */ jsxs5(Text5, { color: active ? "green" : void 0, children: [
+  return /* @__PURE__ */ jsxs6(Box5, { flexDirection: "row", children: [
+    /* @__PURE__ */ jsxs6(Text6, { color: active ? "green" : void 0, children: [
       dot,
       " "
     ] }),
-    /* @__PURE__ */ jsx5(Text5, { children: label }),
-    /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+    /* @__PURE__ */ jsx6(Text6, { children: label }),
+    /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
       "  ",
       vendor
     ] }),
-    caps && /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+    caps && /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
       "  ",
       caps
     ] })
@@ -346,15 +625,15 @@ function formatCaps(m) {
 }
 
 // src/components/SessionSelector.tsx
-import { Box as Box6, Text as Text6 } from "ink";
-import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+import { Box as Box6, Text as Text7 } from "ink";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
 function SessionSelector({ request }) {
-  const { items, currentId, resolve: resolve5 } = request;
+  const { items, currentId, resolve: resolve6 } = request;
   const initialIndex = Math.max(
     0,
     items.findIndex((s) => s.id === currentId)
   );
-  return /* @__PURE__ */ jsx6(
+  return /* @__PURE__ */ jsx7(
     Selector,
     {
       items,
@@ -362,9 +641,9 @@ function SessionSelector({ request }) {
       maxVisible: 12,
       title: "Resume session",
       hint: "\u2191\u2193 navigate \xB7 Enter load \xB7 Esc cancel",
-      onSubmit: (s) => resolve5(s),
-      onCancel: () => resolve5(null),
-      renderRow: (s) => /* @__PURE__ */ jsx6(SessionRow, { session: s, active: s.id === currentId })
+      onSubmit: (s) => resolve6(s),
+      onCancel: () => resolve6(null),
+      renderRow: (s) => /* @__PURE__ */ jsx7(SessionRow, { session: s, active: s.id === currentId })
     }
   );
 }
@@ -373,18 +652,18 @@ function SessionRow({ session, active }) {
   const time = formatTime(session.createdAt);
   const count = `[${String(session.messageCount).padStart(2)} msgs]`;
   const preview = session.preview ?? "(empty)";
-  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "row", children: [
-    /* @__PURE__ */ jsx6(Text6, { color: active ? "green" : void 0, children: active ? "\u25CF " : "  " }),
-    /* @__PURE__ */ jsx6(Text6, { children: id8 }),
-    /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+  return /* @__PURE__ */ jsxs7(Box6, { flexDirection: "row", children: [
+    /* @__PURE__ */ jsx7(Text7, { color: active ? "green" : void 0, children: active ? "\u25CF " : "  " }),
+    /* @__PURE__ */ jsx7(Text7, { children: id8 }),
+    /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
       "  ",
       time
     ] }),
-    /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+    /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
       "  ",
       count
     ] }),
-    /* @__PURE__ */ jsxs6(Text6, { children: [
+    /* @__PURE__ */ jsxs7(Text7, { children: [
       "  ",
       preview
     ] })
@@ -398,8 +677,8 @@ function formatTime(iso) {
 }
 
 // src/components/SlashAutocomplete.tsx
-import { Box as Box7, Text as Text7 } from "ink";
-import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+import { Box as Box7, Text as Text8 } from "ink";
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
 var DEFAULT_MAX = 10;
 var SLASH_COLOR = "#A855F7";
 function SlashAutocomplete({ matches, index, maxVisible = DEFAULT_MAX }) {
@@ -407,35 +686,34 @@ function SlashAutocomplete({ matches, index, maxVisible = DEFAULT_MAX }) {
   const start = Math.max(0, Math.min(index - Math.floor(maxVisible / 2), matches.length - maxVisible));
   const end = Math.min(matches.length, start + maxVisible);
   const visible = matches.slice(start, end);
-  const nameWidth = Math.max(...matches.map((c) => c.name.length + (c.argsHint ? c.argsHint.length + 1 : 0)));
-  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", marginTop: 1, children: [
+  const nameWidth = Math.max(...matches.map((c) => c.name.length));
+  return /* @__PURE__ */ jsxs8(Box7, { flexDirection: "column", marginTop: 1, children: [
     visible.map((cmd, i) => {
       const realIndex = start + i;
-      return /* @__PURE__ */ jsx7(Row, { cmd, focused: realIndex === index, nameWidth }, cmd.name);
+      return /* @__PURE__ */ jsx8(Row, { cmd, focused: realIndex === index, nameWidth }, cmd.name);
     }),
-    matches.length > visible.length && /* @__PURE__ */ jsx7(Box7, { marginLeft: 2, children: /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+    matches.length > visible.length && /* @__PURE__ */ jsx8(Box7, { marginLeft: 2, children: /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
       "\u2191\u2193 select \xB7 Tab/Enter accept \xB7 Esc cancel  (",
       matches.length - visible.length,
       " more)"
     ] }) }),
-    matches.length <= visible.length && /* @__PURE__ */ jsx7(Box7, { marginLeft: 2, children: /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "\u2191\u2193 select \xB7 Tab/Enter accept \xB7 Esc cancel" }) })
+    matches.length <= visible.length && /* @__PURE__ */ jsx8(Box7, { marginLeft: 2, children: /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "\u2191\u2193 select \xB7 Tab/Enter accept \xB7 Esc cancel" }) })
   ] });
 }
 function Row({ cmd, focused, nameWidth }) {
-  const head = cmd.argsHint ? `${cmd.name} ${cmd.argsHint}` : cmd.name;
-  const padded = head.padEnd(nameWidth);
-  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "row", children: [
-    /* @__PURE__ */ jsxs7(Text7, { color: focused ? SLASH_COLOR : void 0, bold: focused, children: [
+  const padded = cmd.name.padEnd(nameWidth);
+  return /* @__PURE__ */ jsxs8(Box7, { flexDirection: "row", children: [
+    /* @__PURE__ */ jsxs8(Text8, { color: focused ? SLASH_COLOR : void 0, bold: focused, children: [
       "/",
       padded
     ] }),
-    /* @__PURE__ */ jsx7(Text7, { children: "   " }),
-    /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: cmd.description })
+    /* @__PURE__ */ jsx8(Text8, { children: "   " }),
+    /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: cmd.description })
   ] });
 }
 
 // src/components/PermissionModeBar.tsx
-import { Box as Box8, Text as Text8 } from "ink";
+import { Box as Box8, Text as Text9 } from "ink";
 
 // src/permission/index.ts
 var MODE_CYCLE = [
@@ -459,6 +737,8 @@ var MODE_COLOR = {
 var PermissionGate = class {
   rules;
   mode = "default";
+  /** Session 级 allow：用户在 PermissionPrompt 选 "yes, for session" 后填充。 */
+  sessionAllow = /* @__PURE__ */ new Set();
   constructor(rules = {}) {
     this.rules = {
       allow: rules.allow ?? [],
@@ -478,8 +758,16 @@ var PermissionGate = class {
     this.mode = MODE_CYCLE[(i + 1) % MODE_CYCLE.length];
     return this.mode;
   }
+  /** 用户在 PermissionPrompt 选 "yes, allow for session" 时记下。 */
+  allowForSession(toolName) {
+    this.sessionAllow.add(toolName);
+  }
+  isSessionAllowed(toolName) {
+    return this.sessionAllow.has(toolName);
+  }
   decide(input) {
     if (this.matches(this.rules.deny, input)) return "deny";
+    if (this.sessionAllow.has(input.toolName)) return "allow";
     switch (this.mode) {
       case "bypassPermissions":
         return "allow";
@@ -533,7 +821,7 @@ var PermissionGate = class {
 };
 
 // src/components/PermissionModeBar.tsx
-import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+import { jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
 function PermissionModeBar({ mode, compact }) {
   const color = MODE_COLOR[mode];
   const label = MODE_LABEL[mode];
@@ -545,19 +833,234 @@ function PermissionModeBar({ mode, compact }) {
       plan: "[plan]",
       bypassPermissions: "[bypass]"
     };
-    return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "row", children: [
-      /* @__PURE__ */ jsx8(Text8, { color, bold: isBypass, children: short[mode] }),
-      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: " shift+tab" })
+    return /* @__PURE__ */ jsxs9(Box8, { flexDirection: "row", children: [
+      /* @__PURE__ */ jsx9(Text9, { color, bold: isBypass, children: short[mode] }),
+      /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: " shift+tab" })
     ] });
   }
-  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "row", children: [
-    /* @__PURE__ */ jsxs8(Text8, { color, bold: isBypass, children: [
-      "\u25B6\u25B6 ",
+  return /* @__PURE__ */ jsxs9(Box8, { flexDirection: "row", children: [
+    /* @__PURE__ */ jsxs9(Text9, { color, bold: isBypass, children: [
+      "\u25B8\u25B8 ",
       label
     ] }),
-    /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: " (shift+tab to cycle)" })
+    /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: " (shift+tab to cycle)" })
+  ] });
+}
+
+// src/components/FooterStatus.tsx
+import { Box as Box9, Text as Text10 } from "ink";
+import { Fragment, jsx as jsx10, jsxs as jsxs10 } from "react/jsx-runtime";
+var BAR_TOTAL_WIDE = 10;
+var BAR_TOTAL_COMPACT = 6;
+function FooterStatus({
+  sessionId,
+  model,
+  contextWindow,
+  lastInputTokens,
+  sessionInputTokens,
+  sessionOutputTokens,
+  termWidth
+}) {
+  const sid = sessionId.slice(0, 8);
+  const hasCtx = contextWindow > 0;
+  const pct = hasCtx ? Math.min(100, Math.round(lastInputTokens / contextWindow * 100)) : 0;
+  const ctxColor = pct >= 90 ? "red" : pct >= 70 ? "yellow" : "green";
+  const SEP = /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: " \u2502 " });
+  const SEP_DOT = /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: " \xB7 " });
+  const renderBar = (barW) => {
+    const filled = Math.round(pct / 100 * barW);
+    const empty = barW - filled;
+    return /* @__PURE__ */ jsxs10(Fragment, { children: [
+      filled > 0 && /* @__PURE__ */ jsx10(Text10, { color: ctxColor, children: "\u2588".repeat(filled) }),
+      empty > 0 && /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: "\u2591".repeat(empty) })
+    ] });
+  };
+  if (termWidth < 60) {
+    return /* @__PURE__ */ jsxs10(Box9, { flexDirection: "row", children: [
+      /* @__PURE__ */ jsx10(Text10, { color: "cyan", bold: true, children: sid }),
+      SEP_DOT,
+      /* @__PURE__ */ jsx10(Text10, { color: "magenta", children: model }),
+      hasCtx && /* @__PURE__ */ jsxs10(Fragment, { children: [
+        SEP_DOT,
+        renderBar(BAR_TOTAL_COMPACT),
+        /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: ` ${pct}%` })
+      ] })
+    ] });
+  }
+  if (termWidth < 100) {
+    return /* @__PURE__ */ jsxs10(Box9, { flexDirection: "row", children: [
+      /* @__PURE__ */ jsx10(Text10, { color: "cyan", bold: true, children: `@${sid}` }),
+      SEP,
+      /* @__PURE__ */ jsx10(Text10, { color: "magenta", children: model }),
+      hasCtx && /* @__PURE__ */ jsxs10(Fragment, { children: [
+        SEP,
+        /* @__PURE__ */ jsx10(Text10, { children: "ctx: " }),
+        renderBar(BAR_TOTAL_COMPACT),
+        /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: ` ${pct}%` })
+      ] })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs10(Box9, { flexDirection: "row", children: [
+    /* @__PURE__ */ jsx10(Text10, { color: "cyan", bold: true, children: `@${sid}` }),
+    SEP,
+    /* @__PURE__ */ jsx10(Text10, { color: "magenta", children: model }),
+    hasCtx && /* @__PURE__ */ jsxs10(Fragment, { children: [
+      SEP,
+      /* @__PURE__ */ jsx10(Text10, { children: "ctx: " }),
+      renderBar(BAR_TOTAL_WIDE),
+      /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: ` ${pct}%` }),
+      /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: `  ${formatTokens(lastInputTokens)}/${formatTokens(contextWindow)}` })
+    ] }),
+    SEP,
+    /* @__PURE__ */ jsx10(Text10, { children: "tok: " }),
+    /* @__PURE__ */ jsx10(Text10, { color: "green", children: `\u2191${formatTokens(sessionInputTokens)}` }),
+    /* @__PURE__ */ jsx10(Text10, { children: " " }),
+    /* @__PURE__ */ jsx10(Text10, { color: "blueBright", children: `\u2193${formatTokens(sessionOutputTokens)}` })
   ] });
 }
+function formatTokens(n) {
+  if (n < 1e3) return String(n);
+  if (n < 1e4) return (n / 1e3).toFixed(1).replace(/\.0$/, "") + "k";
+  if (n < 1e6) return Math.round(n / 1e3) + "k";
+  return (n / 1e6).toFixed(1).replace(/\.0$/, "") + "M";
+}
+
+// src/components/ProgressBanner.tsx
+import { useEffect as useEffect2, useState as useState4 } from "react";
+import { Box as Box10, Text as Text11 } from "ink";
+import { jsx as jsx11, jsxs as jsxs11 } from "react/jsx-runtime";
+var BAR_WIDTH = 42;
+var TICK_MS = 400;
+var TIP_ROTATE_SEC = 5;
+function ProgressBanner({ state }) {
+  const [now, setNow] = useState4(Date.now());
+  useEffect2(() => {
+    const t = setInterval(() => setNow(Date.now()), TICK_MS);
+    return () => clearInterval(t);
+  }, []);
+  const elapsedSec = Math.max(0, Math.floor((now - state.startTime) / 1e3));
+  const percent = Math.max(0, Math.min(99, Math.floor(state.getPercent())));
+  const filled = Math.floor(percent / 100 * BAR_WIDTH);
+  const empty = BAR_WIDTH - filled;
+  const bar = "\u25B0".repeat(filled) + "\u25B1".repeat(empty);
+  const tip = state.tips.length ? state.tips[Math.floor(elapsedSec / TIP_ROTATE_SEC) % state.tips.length] : "";
+  return /* @__PURE__ */ jsxs11(Box10, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsxs11(Box10, { children: [
+      /* @__PURE__ */ jsx11(Text11, { color: "cyan", bold: true, children: "\u2726 " }),
+      /* @__PURE__ */ jsxs11(Text11, { color: "cyan", children: [
+        state.title,
+        "..."
+      ] }),
+      /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: ` (${elapsedSec}s)` })
+    ] }),
+    /* @__PURE__ */ jsxs11(Box10, { marginLeft: 2, children: [
+      /* @__PURE__ */ jsx11(Text11, { color: "cyan", children: bar }),
+      /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: ` ${percent}%` })
+    ] }),
+    tip && /* @__PURE__ */ jsx11(Box10, { marginLeft: 2, children: /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: `\u2514 Tip: ${tip}` }) })
+  ] });
+}
+
+// src/components/StatusLine.tsx
+import { useEffect as useEffect4, useState as useState6 } from "react";
+import { Box as Box11, Text as Text13 } from "ink";
+
+// src/components/Shimmer.tsx
+import { useEffect as useEffect3, useState as useState5 } from "react";
+import { Text as Text12 } from "ink";
+import { jsx as jsx12 } from "react/jsx-runtime";
+var FRAME_MS = 100;
+var TRAIL = 4;
+function Shimmer({ text, bold = true }) {
+  const chars = Array.from(text);
+  const cycle = chars.length + TRAIL;
+  const [phase, setPhase] = useState5(0);
+  useEffect3(() => {
+    const id = setInterval(() => {
+      setPhase((p) => (p + 1) % cycle);
+    }, FRAME_MS);
+    return () => clearInterval(id);
+  }, [cycle]);
+  return /* @__PURE__ */ jsx12(Text12, { children: chars.map((ch, i) => {
+    const d = Math.abs(i - phase);
+    if (d === 0) {
+      return /* @__PURE__ */ jsx12(Text12, { color: "white", bold, children: ch }, i);
+    }
+    if (d === 1) {
+      return /* @__PURE__ */ jsx12(Text12, { color: "white", children: ch }, i);
+    }
+    return /* @__PURE__ */ jsx12(Text12, { color: "gray", dimColor: true, children: ch }, i);
+  }) });
+}
+
+// src/components/StatusLine.tsx
+import { jsx as jsx13, jsxs as jsxs12 } from "react/jsx-runtime";
+var TICK_MS2 = 400;
+function StatusLine({ startTime, firstTextTime, inputTokens, runningTool, lang }) {
+  const [now, setNow] = useState6(Date.now());
+  useEffect4(() => {
+    const t = setInterval(() => setNow(Date.now()), TICK_MS2);
+    return () => clearInterval(t);
+  }, []);
+  const elapsedSec = Math.max(0, Math.floor((now - startTime) / 1e3));
+  const mainLabel = lang === "zh-CN" ? "\u5DE5\u4F5C\u4E2D" : "Working";
+  const parts = [formatDuration(elapsedSec)];
+  if (inputTokens > 0) {
+    parts.push(`\u2191 ${formatTokens2(inputTokens)} tokens`);
+  }
+  if (firstTextTime !== null) {
+    const thinkSec = Math.max(0, Math.floor((firstTextTime - startTime) / 1e3));
+    parts.push(
+      lang === "zh-CN" ? `\u601D\u8003 ${formatDuration(thinkSec)}` : `thought for ${formatDuration(thinkSec)}`
+    );
+  }
+  return /* @__PURE__ */ jsxs12(Box11, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsxs12(Box11, { flexDirection: "row", children: [
+      /* @__PURE__ */ jsx13(Text13, { color: "gray", children: "\u25CF " }),
+      /* @__PURE__ */ jsx13(Shimmer, { text: mainLabel }),
+      /* @__PURE__ */ jsx13(Text13, { dimColor: true, children: `  (${parts.join(" \xB7 ")})` })
+    ] }),
+    runningTool && /* @__PURE__ */ jsxs12(Box11, { flexDirection: "row", marginLeft: 2, marginTop: 0, children: [
+      /* @__PURE__ */ jsx13(Text13, { dimColor: true, children: "\u21B3 " }),
+      /* @__PURE__ */ jsx13(Text13, { color: "cyan", children: runningTool })
+    ] })
+  ] });
+}
+function formatTokens2(n) {
+  if (n < 1e3) return String(n);
+  if (n < 1e4) return (n / 1e3).toFixed(1).replace(/\.0$/, "") + "k";
+  if (n < 1e6) return Math.round(n / 1e3) + "k";
+  return (n / 1e6).toFixed(1).replace(/\.0$/, "") + "M";
+}
+function formatDuration(sec) {
+  if (sec < 60) return `${sec}s`;
+  const m = Math.floor(sec / 60);
+  const s = sec % 60;
+  return s === 0 ? `${m}m` : `${m}m${s}s`;
+}
+
+// src/ui/termTitle.ts
+var ENABLED = (() => {
+  if (!process.stdout.isTTY) return false;
+  if (process.env.MUSE_NO_TITLE === "1") return false;
+  return true;
+})();
+var lastTitle = "";
+function sanitize(s) {
+  return s.replace(/[\x00-\x1f\x7f]/g, "");
+}
+function setTerminalTitle(title) {
+  if (!ENABLED) return;
+  const clean = sanitize(title);
+  if (clean === lastTitle) return;
+  lastTitle = clean;
+  process.stdout.write(`\x1B]0;${clean}\x07`);
+}
+function resetTerminalTitle() {
+  if (!ENABLED) return;
+  lastTitle = "";
+  process.stdout.write(`\x1B]0;\x07`);
+}
 
 // src/llm/providers/openai-compatible.ts
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
@@ -668,17 +1171,45 @@ var OpenAICompatibleClient = class {
     const { messages, tools, systemPrompt, temperature, maxTokens, abortSignal } = opts;
     const aiMessages = convertMessages(messages, systemPrompt);
     const aiTools = tools ? convertTools(tools) : void 0;
+    let attempt = 0;
+    const maxAttempts = 3;
+    let result;
+    while (true) {
+      try {
+        result = streamText({
+          model: this.modelProvider,
+          messages: aiMessages,
+          tools: aiTools,
+          temperature,
+          maxTokens,
+          abortSignal
+        });
+        break;
+      } catch (err) {
+        if (abortSignal?.aborted) {
+          yield { type: "error", error: err instanceof Error ? err : new Error(String(err)) };
+          return;
+        }
+        if (!isRetryable(err) || attempt >= maxAttempts - 1) {
+          yield { type: "error", error: err instanceof Error ? err : new Error(String(err)) };
+          return;
+        }
+        const delay = 1e3 * Math.pow(2, attempt);
+        log.warn(`LLM connect failed (attempt ${attempt + 1}/${maxAttempts}); retrying in ${delay}ms`, {
+          msg: err instanceof Error ? err.message : String(err)
+        });
+        await sleep(delay, abortSignal);
+        attempt += 1;
+      }
+    }
+    if (!result) {
+      yield { type: "error", error: new Error("Internal: stream result is undefined after retry loop.") };
+      return;
+    }
+    const stream = result.fullStream;
     try {
-      const result = streamText({
-        model: this.modelProvider,
-        messages: aiMessages,
-        tools: aiTools,
-        temperature,
-        maxTokens,
-        abortSignal
-      });
       const seenToolCalls = /* @__PURE__ */ new Set();
-      for await (const part of result.fullStream) {
+      for await (const part of stream) {
         switch (part.type) {
           case "text-delta":
             yield { type: "text", delta: part.textDelta };
@@ -784,6 +1315,33 @@ function convertTools(tools) {
   }
   return result;
 }
+function isRetryable(err) {
+  if (!(err instanceof Error)) return false;
+  const msg = err.message.toLowerCase();
+  const code = err.code ?? "";
+  if (code === "ECONNRESET" || code === "ETIMEDOUT" || code === "ENOTFOUND" || code === "ECONNREFUSED" || code === "EAI_AGAIN") {
+    return true;
+  }
+  if (msg.includes("fetch failed") || msg.includes("network") || msg.includes("socket hang up") || msg.includes("under maintenance") || msg.includes("rate limit") || msg.includes("429") || msg.includes("502") || msg.includes("503") || msg.includes("504")) {
+    return true;
+  }
+  return false;
+}
+async function sleep(ms, abortSignal) {
+  await new Promise((resolve6, reject) => {
+    if (abortSignal?.aborted) return reject(new Error("aborted"));
+    const t = setTimeout(() => {
+      abortSignal?.removeEventListener("abort", onAbort);
+      resolve6();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(t);
+      abortSignal?.removeEventListener("abort", onAbort);
+      reject(new Error("aborted"));
+    };
+    abortSignal?.addEventListener("abort", onAbort);
+  });
+}
 function mapFinishReason(reason) {
   switch (reason) {
     case "stop":
@@ -884,10 +1442,7 @@ function setActiveModelEnv(entry) {
 function createLLMClientFromModelEntry(entry) {
   const apiKey = process.env[ACTIVE_API_KEY_ENV] ?? "";
   if (!apiKey && !entry.baseUrl.includes("localhost")) {
-    throw new MuseError(
-      `Model "${entry.id}" has no apiKey in env ${ACTIVE_API_KEY_ENV}. Check models.json (or models.local.json) and ensure setActiveModelEnv() was called.`,
-      "MISSING_API_KEY"
-    );
+    throw new MuseError(buildMissingKeyMessage(entry), "MISSING_API_KEY");
   }
   const capabilities = {};
   if (entry.supportsToolCall !== void 0) capabilities.toolCalling = entry.supportsToolCall;
@@ -901,6 +1456,34 @@ function createLLMClientFromModelEntry(entry) {
     capabilities
   });
 }
+function buildMissingKeyMessage(entry) {
+  const envVars = (entry._apiKeyEnvVars ?? []).filter(
+    (v) => !process.env[v]
+  );
+  const head = `Model "${entry.id}" needs an API key but none was found.`;
+  if (envVars.length > 0) {
+    const list = envVars.map((v) => `$${v}`).join(", ");
+    const fixVar = envVars[0];
+    return [
+      head,
+      ``,
+      `Cause: ~/.muse/models.local.json sets apiKey to a placeholder referencing ${list},`,
+      `       but the shell environment does not have ${envVars.length > 1 ? "those variables" : "that variable"} set.`,
+      ``,
+      `Fix (pick one):`,
+      `  1. Replace the \${${fixVar}} placeholder in ~/.muse/models.local.json with the literal key`,
+      `     (recommended \u2014 the file is local-only and never enters git).`,
+      `  2. Export the variable in your shell:`,
+      `       export ${fixVar}=<your-key>`
+    ].join("\n");
+  }
+  return [
+    head,
+    ``,
+    `Edit ~/.muse/models.local.json and set "apiKey" on the "${entry.id}" entry`,
+    `(plain text is fine \u2014 the file stays local-only).`
+  ].join("\n");
+}
 function createLLMClient(opts) {
   const { provider, model, providers } = opts;
   const config = providers[provider];
@@ -933,6 +1516,32 @@ function createLLMClient(opts) {
   );
 }
 
+// src/loop/todos.ts
+var TodoStore = class {
+  items = [];
+  list() {
+    return this.items.slice();
+  }
+  set(items) {
+    this.items = items.slice();
+  }
+  clear() {
+    this.items = [];
+  }
+  /** 把当前清单格式化为 system prompt 段落；无任务时返回空串。 */
+  toPromptSection() {
+    if (this.items.length === 0) return "";
+    const lines = this.items.map((t, i) => {
+      const marker = t.status === "completed" ? "[x]" : t.status === "in_progress" ? "[~]" : "[ ]";
+      return `  ${i + 1}. ${marker} ${t.content}`;
+    });
+    return `# Current todos
+${lines.join("\n")}
+
+Update via TodoWrite as you make progress. Keep exactly one item in_progress at a time.`;
+  }
+};
+
 // src/loop/agent.ts
 var Agent = class {
   constructor(ctx) {
@@ -940,6 +1549,7 @@ var Agent = class {
   }
   ctx;
   messages = [];
+  todos = new TodoStore();
   getMessages() {
     return this.messages;
   }
@@ -956,10 +1566,14 @@ var Agent = class {
       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: this.ctx.systemPrompt,
+        systemPrompt,
         abortSignal: this.ctx.abortSignal
       });
       const assistantParts = [];
@@ -1048,27 +1662,36 @@ var Agent = class {
       return;
     }
     if (decision === "ask") {
-      approved = await this.ctx.events?.onPermissionRequest?.(call.name, call.args, summary) ?? false;
-      if (!approved) {
+      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
+      askPermission: async () => true,
       // 已在外层处理
+      todos: this.todos
     };
     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);
+    this.recordToolResult(call.id, call.name, result.content, result.isError ?? false, result.summary, result.diff, result.kind);
   }
-  recordToolResult(id, name, content, isError, summary) {
+  recordToolResult(id, name, content, isError, summary, diff, kind) {
     const toolMsg = {
       role: "tool",
       toolUseId: id,
       content,
-      isError
+      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 });
@@ -1079,7 +1702,7 @@ var Agent = class {
 // src/loop/system-prompt.ts
 import { homedir as homedir2 } from "os";
 function buildSystemPrompt(opts) {
-  const { cwd, model, provider, lang, toolNames } = opts;
+  const { cwd, model, provider, lang, toolNames, memoryIndex } = opts;
   const home = homedir2();
   const displayCwd = cwd.startsWith(home) ? cwd.replace(home, "~") : cwd;
   const sections = [];
@@ -1104,18 +1727,113 @@ Prefer the dedicated tool over Bash when one fits (Read for file reading, Edit f
 - If a command may be destructive (rm -rf, force push, drop table, etc.), warn first and let the user run it manually.
 - When the user asks a question that does not need tools, just answer.`
   );
+  if (toolNames.includes("TodoWrite")) {
+    sections.push(
+      `# Task management
+- For non-trivial, multi-step work, use TodoWrite to plan and track progress.
+- Keep exactly one task in_progress; mark a task completed immediately when done.
+- Skip it for trivial single-step requests.`
+    );
+  }
   if (lang === "zh-CN") {
     sections.push(`# Output language
 Reply in Chinese (\u7B80\u4F53\u4E2D\u6587) unless the user writes in English.`);
   }
+  if (memoryIndex && memoryIndex.trim()) {
+    sections.push(
+      `# Memory (long-term)
+Below is MEMORY.md \u2014 your index of persistent facts about the user, project, and prior feedback. Each line points at a file you can MemoryRead. Use MemoryWrite to record new durable knowledge (user role/preferences, validated decisions, project facts, external references). Do NOT save things derivable from the repo or git history.
+
+` + memoryIndex
+    );
+  }
   return sections.join("\n\n");
 }
 
-// src/config/loader.ts
-import { readFile } from "fs/promises";
+// src/loop/memory.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
 import { existsSync } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join2, resolve } from "path";
+import { join as join2 } from "path";
+import { createHash } from "crypto";
+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 memoryFilePath(cwd, name) {
+  return join2(memoryDir(cwd), `${name}.md`);
+}
+async function loadMemoryIndex(cwd, maxLines = 200) {
+  const path = memoryIndexPath(cwd);
+  if (!existsSync(path)) return "";
+  try {
+    const raw = await readFile(path, "utf-8");
+    const lines = raw.split("\n");
+    if (lines.length <= maxLines) return raw.trim();
+    return lines.slice(0, maxLines).join("\n").trim() + `
+... [truncated; ${lines.length - maxLines} more lines]`;
+  } catch {
+    return "";
+  }
+}
+async function readMemoryFile(cwd, name) {
+  const path = memoryFilePath(cwd, name);
+  if (!existsSync(path)) {
+    throw new Error(`Memory "${name}" does not exist at ${path}.`);
+  }
+  return readFile(path, "utf-8");
+}
+async function writeMemory(cwd, opts) {
+  const dir = memoryDir(cwd);
+  await mkdir(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()}
+`;
+  await writeFile(filePath, content, "utf-8");
+  const indexPath = memoryIndexPath(cwd);
+  let index = "";
+  if (existsSync(indexPath)) index = await readFile(indexPath, "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;
+    }
+  } else {
+    lines.push(newLine);
+    indexUpdated = true;
+  }
+  if (indexUpdated) {
+    const out = lines.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+    await writeFile(indexPath, out, "utf-8");
+  }
+  return { filePath, indexUpdated };
+}
+
+// src/config/loader.ts
+import { readFile as readFile2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join3, resolve } from "path";
 
 // src/config/types.ts
 import { z } from "zod";
@@ -1125,8 +1843,8 @@ var ProviderConfigSchema = z.object({
   extraHeaders: z.record(z.string()).optional()
 }).passthrough();
 var LLMConfigSchema = z.object({
-  provider: z.string().optional().describe("Fallback provider preset (only used when no models.json entry matches)."),
-  model: z.string().optional().describe("Active model id; should match an id in models.json."),
+  provider: z.string().optional().describe("Fallback provider preset (only used when no models.local.json entry matches)."),
+  model: z.string().optional().describe("Active model id; should match an id in models.local.json."),
   temperature: z.number().min(0).max(2).optional(),
   maxTokens: z.number().int().positive().optional()
 });
@@ -1191,7 +1909,7 @@ var DEFAULTS = {
     ollama: { baseUrl: "http://localhost:11434/v1" }
   },
   permissions: {
-    allow: ["Read", "Grep", "Glob"],
+    allow: ["Read", "Grep", "Glob", "TodoWrite"],
     ask: ["Write", "Edit", "Bash"],
     deny: [],
     defaultMode: "ask"
@@ -1202,9 +1920,9 @@ var DEFAULTS = {
   }
 };
 async function readJsonIfExists(path) {
-  if (!existsSync(path)) return void 0;
+  if (!existsSync2(path)) return void 0;
   try {
-    const raw = await readFile(path, "utf-8");
+    const raw = await readFile2(path, "utf-8");
     return JSON.parse(raw);
   } catch (err) {
     log.warn(`Failed to parse settings at ${path}: ${err instanceof Error ? err.message : String(err)}`);
@@ -1232,9 +1950,9 @@ async function loadSettings(cwd = process.cwd()) {
   const sources = ["<defaults>"];
   let merged = DEFAULTS;
   const candidates = [
-    join2(homedir3(), ".muse", "settings.json"),
-    join2(cwd, ".muse", "settings.json"),
-    join2(cwd, ".muse", "settings.local.json")
+    join3(homedir4(), ".muse", "settings.json"),
+    join3(cwd, ".muse", "settings.json"),
+    join3(cwd, ".muse", "settings.local.json")
   ];
   for (const path of candidates) {
     const raw = await readJsonIfExists(path);
@@ -1261,10 +1979,10 @@ async function loadSettings(cwd = process.cwd()) {
 }
 
 // src/config/models.ts
-import { readFile as readFile2 } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join3 } from "path";
+import { readFile as readFile3 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join4 } from "path";
 import { z as z2 } from "zod";
 var ModelEntryInputSchema = z2.object({
   id: z2.string().min(1),
@@ -1285,65 +2003,61 @@ var ModelsRegistryInputSchema = z2.object({
   /** 不填 = 全部 models 都进 selector；填了就是 selector 子集（按顺序）。 */
   availableModels: z2.array(z2.string()).optional()
 }).passthrough();
-var CANDIDATES = () => [
-  join3(homedir4(), ".muse", "models.json"),
-  join3(homedir4(), ".muse", "models.local.json")
-];
+var MODELS_PATH = () => join4(homedir5(), ".muse", "models.local.json");
 async function loadModelsRegistry() {
   const sources = [];
   const errors = [];
-  let merged;
-  for (const path of CANDIDATES()) {
-    if (!existsSync2(path)) continue;
-    let raw;
-    try {
-      raw = JSON.parse(await readFile2(path, "utf-8"));
-    } catch (err) {
-      const msg = `JSON parse error: ${err instanceof Error ? err.message : String(err)}`;
-      log.warn(`Failed to parse ${path}: ${msg}`);
-      errors.push({ path, message: msg });
-      continue;
-    }
-    const parsed = ModelsRegistryInputSchema.safeParse(raw);
-    if (!parsed.success) {
-      const msg = formatZodIssues2(parsed.error.issues);
-      log.warn(`Invalid models registry at ${path}: ${msg}`);
-      errors.push({ path, message: msg });
-      continue;
-    }
-    const normalized = {
-      ...parsed.data,
-      models: parsed.data.models.map(normalizeModelEntry)
-    };
-    merged = mergeRegistries(merged, normalized);
-    sources.push(path);
+  const path = MODELS_PATH();
+  if (!existsSync3(path)) {
+    return { registry: void 0, sources, errors };
+  }
+  let raw;
+  try {
+    raw = JSON.parse(await readFile3(path, "utf-8"));
+  } catch (err) {
+    const msg = `JSON parse error: ${err instanceof Error ? err.message : String(err)}`;
+    log.warn(`Failed to parse ${path}: ${msg}`);
+    errors.push({ path, message: msg });
+    return { registry: void 0, sources, errors };
+  }
+  const parsed = ModelsRegistryInputSchema.safeParse(raw);
+  if (!parsed.success) {
+    const msg = formatZodIssues2(parsed.error.issues);
+    log.warn(`Invalid models registry at ${path}: ${msg}`);
+    errors.push({ path, message: msg });
+    return { registry: void 0, sources, errors };
   }
-  if (!merged) return { registry: void 0, sources, errors };
-  const expanded = expandEnvVars(merged);
+  const normalized = {
+    ...parsed.data,
+    models: parsed.data.models.map(normalizeModelEntry)
+  };
+  sources.push(path);
+  const expanded = expandEnvVars(normalized);
   return { registry: expanded, sources, errors };
 }
 function formatZodIssues2(issues) {
   return issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; ");
 }
-function mergeRegistries(low, high) {
-  if (!low) return high;
-  const byId = /* @__PURE__ */ new Map();
-  for (const m of low.models) byId.set(m.id, m);
-  for (const m of high.models) byId.set(m.id, m);
-  return {
-    ...low,
-    ...high,
-    models: [...byId.values()],
-    availableModels: high.availableModels ?? low.availableModels
-  };
-}
 function normalizeModelEntry(entry) {
   let baseUrl = (entry.baseUrl ?? entry.url ?? "").replace(/\/+$/, "");
   if (baseUrl.endsWith("/chat/completions")) {
     baseUrl = baseUrl.slice(0, -"/chat/completions".length);
   }
   const { url: _url, ...rest } = entry;
-  return { ...rest, baseUrl };
+  const apiKeyEnvVars = entry.apiKey ? extractEnvVars(entry.apiKey) : [];
+  return {
+    ...rest,
+    baseUrl,
+    ...apiKeyEnvVars.length > 0 ? { _apiKeyEnvVars: apiKeyEnvVars } : {}
+  };
+}
+var ENV_PLACEHOLDER = /\$\{([A-Z_][A-Z0-9_]*)\}/g;
+function extractEnvVars(s) {
+  const out = [];
+  let m;
+  ENV_PLACEHOLDER.lastIndex = 0;
+  while ((m = ENV_PLACEHOLDER.exec(s)) !== null) out.push(m[1]);
+  return out;
 }
 function findEntry(registry, modelId) {
   return registry.models.find((m) => m.id === modelId);
@@ -1452,7 +2166,7 @@ async function compactMessages(messages, opts) {
   }
   const older = messages.slice(0, cutoff);
   const recent = messages.slice(cutoff);
-  const summary = await summarizeConversation(older, opts.llm, opts.abortSignal);
+  const summary = await summarizeConversation(older, opts.llm, opts.abortSignal, opts.onProgress);
   const summaryMessage = {
     role: "user",
     content: `[Previous conversation summary]
@@ -1497,7 +2211,7 @@ function hasUnresolvedToolUse(older) {
   }
   return false;
 }
-async function summarizeConversation(older, llm, abortSignal) {
+async function summarizeConversation(older, llm, abortSignal, onProgress) {
   const transcript = renderTranscript(older);
   const prompt = [
     {
@@ -1517,8 +2231,10 @@ ${transcript}
   ];
   let text = "";
   for await (const ev of llm.stream({ messages: prompt, abortSignal })) {
-    if (ev.type === "text") text += ev.delta;
-    else if (ev.type === "error") throw ev.error;
+    if (ev.type === "text") {
+      text += ev.delta;
+      onProgress?.(text.length);
+    } else if (ev.type === "error") throw ev.error;
   }
   return text.trim() || "(empty summary)";
 }
@@ -1579,16 +2295,16 @@ function getMCPStatus(settings) {
 }
 
 // src/session/jsonl.ts
-import { appendFile, mkdir, readdir, readFile as readFile3, stat } from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
-import { homedir as homedir5 } from "os";
-import { dirname as dirname2, join as join4 } from "path";
-import { createHash, randomUUID } from "crypto";
-function projectHash(cwd) {
-  return createHash("sha256").update(cwd).digest("hex").slice(0, 16);
+import { appendFile, mkdir as mkdir2, readdir, readFile as readFile4, stat } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { homedir as homedir6 } from "os";
+import { dirname as dirname2, join as join5 } from "path";
+import { createHash as createHash2, randomUUID } from "crypto";
+function projectHash2(cwd) {
+  return createHash2("sha256").update(cwd).digest("hex").slice(0, 16);
 }
 function sessionsDir(cwd) {
-  return join4(homedir5(), ".muse", "projects", projectHash(cwd), "sessions");
+  return join5(homedir6(), ".muse", "projects", projectHash2(cwd), "sessions");
 }
 var Session = class _Session {
   meta;
@@ -1599,8 +2315,8 @@ var Session = class _Session {
   static async create(cwd) {
     const id = randomUUID();
     const dir = sessionsDir(cwd);
-    await mkdir(dir, { recursive: true });
-    const path = join4(dir, `${id}.jsonl`);
+    await mkdir2(dir, { recursive: true });
+    const path = join5(dir, `${id}.jsonl`);
     const meta = {
       id,
       cwd,
@@ -1616,7 +2332,7 @@ var Session = class _Session {
   }
   static async resolve(cwd, idOrPrefix) {
     const dir = sessionsDir(cwd);
-    if (!existsSync3(dir)) return void 0;
+    if (!existsSync4(dir)) return void 0;
     const entries = await readdir(dir);
     const matches = entries.filter((e) => e.endsWith(".jsonl") && e.startsWith(idOrPrefix));
     if (matches.length === 0) return void 0;
@@ -1624,12 +2340,12 @@ var Session = class _Session {
       throw new Error(`Ambiguous session id "${idOrPrefix}" matches ${matches.length} sessions; use more characters.`);
     }
     const top = matches[0];
-    const st = await stat(join4(dir, top));
+    const st = await stat(join5(dir, top));
     return {
       id: top.replace(/\.jsonl$/, ""),
       cwd,
       createdAt: st.mtime.toISOString(),
-      path: join4(dir, top)
+      path: join5(dir, top)
     };
   }
   /**
@@ -1638,13 +2354,13 @@ var Session = class _Session {
    */
   static async listAll(cwd, limit) {
     const dir = sessionsDir(cwd);
-    if (!existsSync3(dir)) return [];
+    if (!existsSync4(dir)) return [];
     const entries = await readdir(dir);
     const files = entries.filter((e) => e.endsWith(".jsonl"));
     if (files.length === 0) return [];
     const stats = await Promise.all(
       files.map(async (f) => {
-        const path = join4(dir, f);
+        const path = join5(dir, f);
         const st = await stat(path);
         return { file: f, path, mtime: st.mtime };
       })
@@ -1681,7 +2397,7 @@ var Session = class _Session {
     const line = JSON.stringify(event) + "\n";
     this.writeQueue = this.writeQueue.then(async () => {
       try {
-        await mkdir(dirname2(this.meta.path), { recursive: true });
+        await mkdir2(dirname2(this.meta.path), { recursive: true });
         await appendFile(this.meta.path, line, "utf-8");
       } catch (err) {
         log.warn(`session append failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -1690,8 +2406,8 @@ var Session = class _Session {
     return this.writeQueue;
   }
   async readAll() {
-    if (!existsSync3(this.meta.path)) return [];
-    const raw = await readFile3(this.meta.path, "utf-8");
+    if (!existsSync4(this.meta.path)) return [];
+    const raw = await readFile4(this.meta.path, "utf-8");
     const events = [];
     for (const line of raw.split("\n")) {
       if (!line.trim()) continue;
@@ -1706,7 +2422,7 @@ var Session = class _Session {
 async function readSummary(meta) {
   let events = [];
   try {
-    const raw = await readFile3(meta.path, "utf-8");
+    const raw = await readFile4(meta.path, "utf-8");
     for (const line of raw.split("\n")) {
       if (!line.trim()) continue;
       try {
@@ -1728,9 +2444,9 @@ async function readSummary(meta) {
 }
 
 // src/slash/_format.ts
-import { homedir as homedir6 } from "os";
+import { homedir as homedir7 } from "os";
 function shortPath(p) {
-  const home = homedir6();
+  const home = homedir7();
   if (p === home) return "~";
   if (p.startsWith(home + "/")) return "~" + p.slice(home.length);
   return p;
@@ -1828,6 +2544,18 @@ var COST = {
     return { display: lines.join("\n") };
   }
 };
+var COMPACT_TIPS = [
+  "Shift+Tab cycles permission modes (default / acceptEdits / plan / bypass)",
+  "/mode plan drafts changes without executing them",
+  "/cost shows token usage and estimated spend",
+  "/resume picks up a previous session in this directory",
+  "muse --continue resumes the last session on startup",
+  "MemoryWrite saves persistent knowledge across sessions",
+  "TodoWrite keeps the model honest on multi-step tasks",
+  'Pipe to muse: cat bug.log | muse "explain this"',
+  "Ctrl+C exits immediately; Esc rejects a pending tool"
+];
+var COMPACT_ESTIMATED_CHARS = 1800;
 var COMPACT = {
   name: "compact",
   description: "summarize older messages to free up context space",
@@ -1837,23 +2565,39 @@ var COMPACT = {
     const { flags } = parseArgs(ctx.args);
     const keepRecent = typeof flags.keep === "string" ? Math.max(1, parseInt(flags.keep, 10)) : 4;
     if (Number.isNaN(keepRecent)) return { display: `Invalid --keep value: ${flags.keep}` };
-    const result = await compactMessages(ctx.history, { llm: ctx.llm, keepRecent });
-    if (result.noop) {
-      return { display: `(history has ${result.originalCount} messages; not enough to compact with --keep ${keepRecent})` };
-    }
-    ctx.actions.setMessages(result.newMessages);
-    const preview = result.summary.length > 240 ? result.summary.slice(0, 240) + "\u2026" : result.summary;
-    return {
-      display: `Compacted ${result.originalCount} \u2192 ${result.newCount} messages (kept last ${keepRecent}).
+    const progressRef = { chars: 0 };
+    ctx.actions.showProgress({
+      title: "Compacting conversation",
+      tips: COMPACT_TIPS,
+      getPercent: () => progressRef.chars / COMPACT_ESTIMATED_CHARS * 100
+    });
+    try {
+      const result = await compactMessages(ctx.history, {
+        llm: ctx.llm,
+        keepRecent,
+        onProgress: (chars) => {
+          progressRef.chars = chars;
+        }
+      });
+      if (result.noop) {
+        return { display: `(history has ${result.originalCount} messages; not enough to compact with --keep ${keepRecent})` };
+      }
+      ctx.actions.setMessages(result.newMessages);
+      const preview = result.summary.length > 240 ? result.summary.slice(0, 240) + "\u2026" : result.summary;
+      return {
+        display: `Compacted ${result.originalCount} \u2192 ${result.newCount} messages (kept last ${keepRecent}).
 
 Summary:
 ${preview}`
-    };
+      };
+    } finally {
+      ctx.actions.hideProgress();
+    }
   }
 };
 var MODELS = {
   name: "models",
-  description: "pick a model from ~/.muse/models.json (\u2191\u2193 to navigate)",
+  description: "pick a model from ~/.muse/models.local.json (\u2191\u2193 to navigate)",
   async execute(ctx) {
     let registry = ctx.modelsRegistry;
     let errors = [];
@@ -1871,7 +2615,7 @@ var MODELS = {
     const visible = visibleEntries(registry);
     if (visible.length === 0) {
       return {
-        display: `models.json has no available models.
+        display: `models.local.json has no available models.
 Check that "availableModels" lists at least one id present in "models".`
       };
     }
@@ -1889,7 +2633,7 @@ Check that "availableModels" lists at least one id present in "models".`
 };
 function renderLoadErrors(errors) {
   return [
-    `models.json was found but failed to load:`,
+    `models.local.json was found but failed to load:`,
     ``,
     ...errors.flatMap((e) => [`  ${shortPath(e.path)}`, `    ${e.message}`]),
     ``,
@@ -1900,7 +2644,7 @@ function renderLoadErrors(errors) {
 function renderEmptyRegistryHint() {
   return [
     `No models registry found.`,
-    `Create ~/.muse/models.json with a "models" array. Example:`,
+    `Create ~/.muse/models.local.json with a "models" array. Example:`,
     ``,
     `{`,
     `  "models": [`,
@@ -2038,6 +2782,44 @@ async function loadAndReport(meta, ctx) {
     display: `Resumed session ${meta.id.slice(0, 8)} (${messages.length} messages from ${formatTime2(meta.createdAt)}).`
   };
 }
+var MODE_ALIASES = {
+  default: "default",
+  normal: "default",
+  acceptedits: "acceptEdits",
+  "accept-edits": "acceptEdits",
+  accept: "acceptEdits",
+  edits: "acceptEdits",
+  plan: "plan",
+  bypass: "bypassPermissions",
+  bypasspermissions: "bypassPermissions"
+};
+var MODE_CMD = {
+  name: "mode",
+  description: "show or switch the permission mode (alternative to Shift+Tab)",
+  argsHint: "[default|acceptEdits|plan|bypassPermissions]",
+  execute(ctx) {
+    const arg = ctx.args.trim().toLowerCase();
+    if (!arg) {
+      const cur = ctx.actions.getMode();
+      const lines = [`Current permission mode: ${cur} \u2014 ${MODE_LABEL[cur]}`, ``, `Available modes:`];
+      for (const m of MODE_CYCLE) {
+        const marker = m === cur ? "\u25CF" : " ";
+        lines.push(`  ${marker} ${m.padEnd(20)} ${MODE_LABEL[m]}`);
+      }
+      lines.push(``, `Switch: /mode <name>   or   Shift+Tab to cycle`);
+      return { display: lines.join("\n") };
+    }
+    const target = MODE_ALIASES[arg];
+    if (!target) {
+      return {
+        display: `Unknown mode "${ctx.args.trim()}". Valid: ${MODE_CYCLE.join(" | ")}`
+      };
+    }
+    if (target === ctx.actions.getMode()) return { display: `Already in ${target} mode.` };
+    ctx.actions.setMode(target);
+    return { display: `Switched to ${target} \u2014 ${MODE_LABEL[target]}` };
+  }
+};
 var BUILTIN_SLASH_COMMANDS = [
   HELP,
   CLEAR,
@@ -2045,31 +2827,53 @@ var BUILTIN_SLASH_COMMANDS = [
   MODELS,
   CONFIG,
   MCP,
+  MODE_CMD,
   COST,
   RESUME,
   QUIT
 ];
 
 // src/app.tsx
-import { jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
+import { jsx as jsx14, jsxs as jsxs13 } from "react/jsx-runtime";
 function reducer(state, action) {
   switch (action.type) {
     case "user_submit":
-      return { ...state, streamingText: "", status: "streaming" };
+      return {
+        ...state,
+        streamingText: "",
+        status: "streaming",
+        runningTool: null,
+        turnStartTime: Date.now(),
+        turnFirstTextTime: null,
+        turnInputTokens: 0
+      };
     case "history_set":
       return { ...state, history: action.messages };
     case "stream_delta":
-      return { ...state, streamingText: state.streamingText + action.delta };
+      return {
+        ...state,
+        streamingText: state.streamingText + action.delta,
+        status: state.status === "tool" ? "streaming" : state.status,
+        runningTool: null,
+        turnFirstTextTime: state.turnFirstTextTime ?? Date.now()
+      };
     case "stream_reset":
       return { ...state, streamingText: "" };
     case "set_status":
-      return { ...state, status: action.status };
+      return {
+        ...state,
+        status: action.status,
+        runningTool: action.status === "tool" ? state.runningTool : null
+      };
+    case "tool_start":
+      return { ...state, status: "tool", runningTool: action.name };
     case "add_usage":
       return {
         ...state,
         inputTokens: state.inputTokens + action.usage.inputTokens,
         outputTokens: state.outputTokens + action.usage.outputTokens,
-        totalTokens: state.totalTokens + action.usage.totalTokens
+        totalTokens: state.totalTokens + action.usage.totalTokens,
+        turnInputTokens: state.turnInputTokens + action.usage.inputTokens
       };
   }
 }
@@ -2089,32 +2893,52 @@ function App({
   const { exit } = useApp();
   const { stdout } = useStdout();
   const termWidth = stdout?.columns ?? 80;
-  const [llm, setLLM] = useState2(initialLLM);
-  const [permissions, setPermissions] = useState2(initialPermissions);
-  const [settings, setSettings] = useState2(initialSettings);
-  const [settingsSources, setSettingsSources] = useState2(initialSources);
-  const [modelsRegistry, setModelsRegistry] = useState2(initialModelsRegistry);
-  const [mode, setMode] = useState2(initialPermissions.getMode());
+  const [llm, setLLM] = useState7(initialLLM);
+  const [permissions, setPermissions] = useState7(initialPermissions);
+  const [settings, setSettings] = useState7(initialSettings);
+  const [settingsSources, setSettingsSources] = useState7(initialSources);
+  const [modelsRegistry, setModelsRegistry] = useState7(initialModelsRegistry);
+  const [mode, setMode] = useState7(initialPermissions.getMode());
   const [state, dispatch] = useReducer(reducer, {
     history: initialMessages ?? [],
     streamingText: "",
     status: "idle",
+    runningTool: null,
     inputTokens: 0,
     outputTokens: 0,
-    totalTokens: 0
+    totalTokens: 0,
+    turnStartTime: 0,
+    turnFirstTextTime: null,
+    turnInputTokens: 0
   });
   const messagesRef = useRef(initialMessages ?? []);
-  const [input, setInput] = useState2("");
-  const [inputRemountKey, setInputRemountKey] = useState2(0);
+  const [input, setInput] = useState7("");
+  const [inputRemountKey, setInputRemountKey] = useState7(0);
   const commitInput = (value) => {
     setInput(value);
     setInputRemountKey((k) => k + 1);
   };
-  const [pending, setPending] = useState2(null);
-  const [picker, setPicker] = useState2(null);
-  const [sessionPicker, setSessionPicker] = useState2(null);
-  const [autocompleteIndex, setAutocompleteIndex] = useState2(0);
+  const [pending, setPending] = useState7(null);
+  const [picker, setPicker] = useState7(null);
+  const [sessionPicker, setSessionPicker] = useState7(null);
+  const [autocompleteIndex, setAutocompleteIndex] = useState7(0);
+  const [progress, setProgress] = useState7(null);
   const agentRef = useRef(null);
+  const queuedInputsRef = useRef([]);
+  const [queuedInputs, setQueuedInputs] = useState7([]);
+  const enqueueInput = (text) => {
+    queuedInputsRef.current.push(text);
+    setQueuedInputs([...queuedInputsRef.current]);
+  };
+  const dequeueInput = () => {
+    if (queuedInputsRef.current.length === 0) return null;
+    const front = queuedInputsRef.current.shift();
+    setQueuedInputs([...queuedInputsRef.current]);
+    return front;
+  };
+  const inputHistoryRef = useRef(extractUserInputs(initialMessages ?? []));
+  const historyIndexRef = useRef(-1);
+  const savedDraftRef = useRef("");
   const slash = useMemo2(() => {
     const r = new SlashRegistry();
     r.registerAll(BUILTIN_SLASH_COMMANDS);
@@ -2131,17 +2955,48 @@ function App({
     ) : all;
     return { matches, query };
   }, [input, slash]);
-  useEffect(() => {
+  useEffect5(() => {
     const len = autocomplete?.matches.length ?? 0;
     if (autocompleteIndex >= len) setAutocompleteIndex(0);
   }, [autocomplete, autocompleteIndex]);
-  useEffect(() => {
+  useEffect5(() => {
+    const project = basename(cwd) || "muse";
+    const baseIdle = `muse \xB7 ${project}`;
+    if (state.status === "idle") {
+      setTerminalTitle(baseIdle);
+      return;
+    }
+    const FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+    let i = 0;
+    const id = setInterval(() => {
+      const frame = FRAMES[i % FRAMES.length];
+      const tail = state.runningTool ? ` \xB7 ${state.runningTool}` : "";
+      setTerminalTitle(`${frame} muse \xB7 ${project}${tail}`);
+      i++;
+    }, 100);
+    return () => clearInterval(id);
+  }, [state.status, state.runningTool, cwd]);
+  useEffect5(() => {
+    return () => resetTerminalTitle();
+  }, []);
+  const [memoryIndex, setMemoryIndex] = useState7("");
+  useEffect5(() => {
+    let cancelled = false;
+    loadMemoryIndex(cwd).then((idx) => {
+      if (!cancelled) setMemoryIndex(idx);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [cwd]);
+  useEffect5(() => {
     const systemPrompt = buildSystemPrompt({
       cwd,
       model: llm.model,
       provider: llm.providerName,
       lang,
-      toolNames: tools.list().map((t) => t.name)
+      toolNames: tools.list().map((t) => t.name),
+      memoryIndex
     });
     const agent = new Agent({
       llm,
@@ -2152,7 +3007,8 @@ function App({
       systemPrompt,
       events: {
         onText: (delta) => dispatch({ type: "stream_delta", delta }),
-        onToolCallStart: () => dispatch({ type: "set_status", status: "tool" }),
+        onToolCallStart: (_id, name) => dispatch({ type: "tool_start", name }),
+        onToolResult: () => dispatch({ type: "set_status", status: "streaming" }),
         onUsage: (usage) => dispatch({ type: "add_usage", usage }),
         onTurnEnd: () => {
           const msgs = [...agent.getMessages()];
@@ -2160,6 +3016,19 @@ function App({
           dispatch({ type: "history_set", messages: msgs });
           dispatch({ type: "stream_reset" });
           dispatch({ type: "set_status", status: "idle" });
+          const next = dequeueInput();
+          if (next) {
+            setTimeout(() => {
+              dispatch({ type: "user_submit" });
+              agent.runTurn(next).catch((err) => {
+                const m = err instanceof Error ? err.message : String(err);
+                dispatch({ type: "stream_delta", delta: `
+[error] ${m}
+` });
+                dispatch({ type: "set_status", status: "idle" });
+              });
+            }, 0);
+          }
         },
         onError: (err) => {
           dispatch({ type: "stream_delta", delta: `
@@ -2167,15 +3036,15 @@ function App({
 ` });
           dispatch({ type: "set_status", status: "idle" });
         },
-        onPermissionRequest: (toolName, args, summary) => new Promise((resolve5) => {
-          setPending({ toolName, args, summary, resolve: resolve5 });
+        onPermissionRequest: (toolName, args, summary) => new Promise((resolve6) => {
+          setPending({ toolName, args, summary, resolve: resolve6 });
         })
       }
     });
     agent.setMessages(messagesRef.current);
     agentRef.current = agent;
-  }, [llm, tools, permissions, session, cwd, lang]);
-  useInput3(
+  }, [llm, tools, permissions, session, cwd, lang, memoryIndex]);
+  useInput4(
     (inputKey, key) => {
       if (key.ctrl && inputKey === "c") {
         exit();
@@ -2186,22 +3055,41 @@ function App({
         setMode(next);
         return;
       }
-      if (!autocomplete || autocomplete.matches.length === 0) return;
-      const len = autocomplete.matches.length;
-      if (key.upArrow) {
-        setAutocompleteIndex((i) => (i - 1 + len) % len);
+      if (autocomplete && autocomplete.matches.length > 0) {
+        const len = autocomplete.matches.length;
+        if (key.upArrow) {
+          setAutocompleteIndex((i) => (i - 1 + len) % len);
+        } else if (key.downArrow) {
+          setAutocompleteIndex((i) => (i + 1) % len);
+        } else if (key.tab) {
+          const picked = autocomplete.matches[autocompleteIndex];
+          if (picked) commitInput(`/${picked.name}`);
+        } else if (key.escape) {
+          commitInput("");
+        }
+        return;
+      }
+      const hist = inputHistoryRef.current;
+      if (key.upArrow && hist.length > 0) {
+        const cur = historyIndexRef.current;
+        if (cur === -1) savedDraftRef.current = input;
+        const next = Math.min(cur + 1, hist.length - 1);
+        historyIndexRef.current = next;
+        commitInput(hist[hist.length - 1 - next] ?? "");
       } else if (key.downArrow) {
-        setAutocompleteIndex((i) => (i + 1) % len);
-      } else if (key.tab) {
-        const picked = autocomplete.matches[autocompleteIndex];
-        if (picked) commitInput(`/${picked.name}`);
-      } else if (key.escape) {
-        commitInput("");
+        const cur = historyIndexRef.current;
+        if (cur === -1) return;
+        const next = cur - 1;
+        historyIndexRef.current = next;
+        if (next === -1) commitInput(savedDraftRef.current);
+        else commitInput(hist[hist.length - 1 - next] ?? "");
       }
     },
-    { isActive: state.status === "idle" && !pending && !picker && !sessionPicker }
+    // 模型在跑时也要响应键盘（让用户能 Ctrl+C / Shift+Tab / autocomplete 导航）；
+    // 仅模态弹起时让出键盘所有权
+    { isActive: !pending && !picker && !sessionPicker }
   );
-  const acceptingInput = state.status === "idle" && pending === null && picker === null && sessionPicker === null;
+  const acceptingInput = pending === null && picker === null && sessionPicker === null;
   const actions = useMemo2(
     () => ({
       setMessages: (msgs) => {
@@ -2209,11 +3097,11 @@ function App({
         agentRef.current?.setMessages(msgs);
         dispatch({ type: "history_set", messages: msgs });
       },
-      pickModel: (items, currentId) => new Promise((resolve5) => {
-        setPicker({ items, currentId, resolve: resolve5 });
+      pickModel: (items, currentId) => new Promise((resolve6) => {
+        setPicker({ items, currentId, resolve: resolve6 });
       }),
-      pickSession: (items, currentId) => new Promise((resolve5) => {
-        setSessionPicker({ items, currentId, resolve: resolve5 });
+      pickSession: (items, currentId) => new Promise((resolve6) => {
+        setSessionPicker({ items, currentId, resolve: resolve6 });
       }),
       switchModel: async (modelId) => {
         if (!modelsRegistry) throw new Error("No models registry loaded.");
@@ -2224,6 +3112,20 @@ function App({
         setLLM(next);
         await persistActiveModel(modelId);
       },
+      getMode: () => permissions.getMode(),
+      setMode: (m) => {
+        permissions.setMode(m);
+        setMode(m);
+      },
+      showProgress: (opts) => {
+        setProgress({
+          title: opts.title,
+          tips: opts.tips ?? [],
+          getPercent: opts.getPercent ?? (() => 0),
+          startTime: Date.now()
+        });
+      },
+      hideProgress: () => setProgress(null),
       reloadSettings: async () => {
         const { settings: nextSettings, sources } = await loadSettings(cwd);
         const { registry: nextModels } = await loadModelsRegistry();
@@ -2253,7 +3155,7 @@ function App({
         return { settings: nextSettings, sources };
       }
     }),
-    [cwd, modelsRegistry, llm.model]
+    [cwd, modelsRegistry, llm.model, permissions]
   );
   const handleSubmit = useCallback(
     async (value) => {
@@ -2271,6 +3173,10 @@ function App({
       }
       const parsed = parseSlash(trimmed);
       if (parsed) {
+        if (state.status !== "idle") {
+          commitInput("");
+          return;
+        }
         const cmd = slash.get(parsed.name);
         commitInput("");
         if (!cmd) {
@@ -2305,6 +3211,15 @@ function App({
         return;
       }
       commitInput("");
+      const hist = inputHistoryRef.current;
+      if (hist[hist.length - 1] !== trimmed) hist.push(trimmed);
+      if (hist.length > 200) hist.shift();
+      historyIndexRef.current = -1;
+      savedDraftRef.current = "";
+      if (state.status !== "idle") {
+        enqueueInput(trimmed);
+        return;
+      }
       dispatch({ type: "user_submit" });
       try {
         await agentRef.current?.runTurn(trimmed);
@@ -2316,7 +3231,7 @@ function App({
         dispatch({ type: "set_status", status: "idle" });
       }
     },
-    [slash, cwd, llm, session, settings, settingsSources, modelsRegistry, state.inputTokens, state.outputTokens, state.totalTokens, actions, autocomplete, autocompleteIndex]
+    [slash, cwd, llm, session, settings, settingsSources, modelsRegistry, state.inputTokens, state.outputTokens, state.totalTokens, state.status, actions, autocomplete, autocompleteIndex]
   );
   function appendAssistantText(text) {
     const msg = { role: "assistant", content: [{ type: "text", text }] };
@@ -2334,25 +3249,31 @@ function App({
     }
   }
   const banner = !showBanner ? null : pickBanner(termWidth, { version: "0.1.0", model: llm.model, cwd: shortCwd(cwd) });
-  return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", children: [
+  return /* @__PURE__ */ jsxs13(Box12, { flexDirection: "column", children: [
     banner,
-    /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", marginTop: 1, children: [
-      state.history.map((msg, i) => /* @__PURE__ */ jsx9(MessageView, { message: msg }, i)),
-      state.streamingText && /* @__PURE__ */ jsx9(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx9(Text9, { children: state.streamingText }) })
+    /* @__PURE__ */ jsxs13(Box12, { flexDirection: "column", marginTop: 1, children: [
+      state.history.map((msg, i) => /* @__PURE__ */ jsx14(MessageView, { message: msg }, i)),
+      state.streamingText && /* @__PURE__ */ jsxs13(Box12, { flexDirection: "row", marginTop: 1, children: [
+        /* @__PURE__ */ jsxs13(Text14, { color: "cyan", children: [
+          DOT,
+          " "
+        ] }),
+        /* @__PURE__ */ jsx14(Box12, { flexDirection: "column", flexGrow: 1, children: /* @__PURE__ */ jsx14(Text14, { children: state.streamingText }) })
+      ] })
     ] }),
-    pending && /* @__PURE__ */ jsx9(
+    pending && /* @__PURE__ */ jsx14(
       PermissionPrompt,
       {
         request: {
           ...pending,
-          resolve: (ok) => {
-            pending.resolve(ok);
+          resolve: (decision) => {
+            pending.resolve(decision);
             setPending(null);
           }
         }
       }
     ),
-    picker && /* @__PURE__ */ jsx9(
+    picker && /* @__PURE__ */ jsx14(
       ModelSelector,
       {
         request: {
@@ -2364,7 +3285,7 @@ function App({
         }
       }
     ),
-    sessionPicker && /* @__PURE__ */ jsx9(
+    sessionPicker && /* @__PURE__ */ jsx14(
       SessionSelector,
       {
         request: {
@@ -2376,38 +3297,90 @@ function App({
         }
       }
     ),
-    acceptingInput && /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsxs9(Box9, { marginTop: 1, children: [
-        /* @__PURE__ */ jsx9(Text9, { color: "cyan", children: "> " }),
-        /* @__PURE__ */ jsx9(TextInput, { value: input, onChange: setInput, onSubmit: handleSubmit }, inputRemountKey)
+    state.status !== "idle" && /* @__PURE__ */ jsx14(
+      StatusLine,
+      {
+        startTime: state.turnStartTime,
+        firstTextTime: state.turnFirstTextTime,
+        inputTokens: state.turnInputTokens,
+        runningTool: state.runningTool,
+        lang
+      }
+    ),
+    progress && /* @__PURE__ */ jsx14(ProgressBanner, { state: progress }),
+    acceptingInput && /* @__PURE__ */ jsxs13(Box12, { flexDirection: "column", children: [
+      queuedInputs.length > 0 && /* @__PURE__ */ jsxs13(Box12, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: [
+        queuedInputs.map((q, i) => /* @__PURE__ */ jsx14(Text14, { color: "yellow", dimColor: true, children: `\u21B3 queued: ${q.length > 60 ? q.slice(0, 60) + "\u2026" : q}` }, i)),
+        /* @__PURE__ */ jsx14(Text14, { dimColor: true, children: `  (will send after current turn \xB7 ${queuedInputs.length} pending)` })
       ] }),
-      autocomplete && autocomplete.matches.length > 0 && /* @__PURE__ */ jsx9(SlashAutocomplete, { matches: autocomplete.matches, index: autocompleteIndex })
+      /* @__PURE__ */ jsxs13(Box12, { marginTop: 1, flexDirection: "column", children: [
+        /* @__PURE__ */ jsx14(Text14, { backgroundColor: "#1c1c1c", children: " ".repeat(Math.max(1, termWidth - 1)) }),
+        /* @__PURE__ */ jsxs13(Box12, { flexDirection: "row", children: [
+          /* @__PURE__ */ jsx14(Text14, { backgroundColor: "#1c1c1c", color: "gray", bold: true, children: " \u276F " }),
+          /* @__PURE__ */ jsx14(
+            BgTextInput,
+            {
+              value: input,
+              onChange: setInput,
+              onSubmit: handleSubmit,
+              width: Math.max(10, termWidth - 4),
+              backgroundColor: "#1c1c1c",
+              isActive: acceptingInput
+            },
+            inputRemountKey
+          )
+        ] }),
+        /* @__PURE__ */ jsx14(Text14, { backgroundColor: "#1c1c1c", children: " ".repeat(Math.max(1, termWidth - 1)) })
+      ] }),
+      autocomplete && autocomplete.matches.length > 0 && /* @__PURE__ */ jsx14(SlashAutocomplete, { matches: autocomplete.matches, index: autocompleteIndex })
     ] }),
-    state.status === "streaming" && /* @__PURE__ */ jsx9(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "... (streaming)" }) }),
-    state.status === "tool" && /* @__PURE__ */ jsx9(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "... (running tool)" }) }),
-    /* @__PURE__ */ jsx9(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx9(PermissionModeBar, { mode, compact: termWidth < 60 }) })
+    /* @__PURE__ */ jsxs13(Box12, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx14(
+        FooterStatus,
+        {
+          sessionId: session.meta.id,
+          model: llm.model,
+          contextWindow: llm.capabilities.maxContextWindow,
+          lastInputTokens: state.turnInputTokens,
+          sessionInputTokens: state.inputTokens,
+          sessionOutputTokens: state.outputTokens,
+          termWidth
+        }
+      ),
+      /* @__PURE__ */ jsx14(PermissionModeBar, { mode, compact: termWidth < 60 })
+    ] })
   ] });
 }
+function extractUserInputs(messages) {
+  const out = [];
+  for (const m of messages) {
+    if (m.role !== "user") continue;
+    const text = typeof m.content === "string" ? m.content : m.content.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+    if (text.startsWith("[Previous conversation summary]")) continue;
+    if (text.trim()) out.push(text);
+  }
+  return out;
+}
 function shortCwd(cwd) {
-  const home = homedir7();
+  const home = homedir8();
   if (cwd === home) return "~";
   if (cwd.startsWith(home + "/")) return "~" + cwd.slice(home.length);
   return cwd;
 }
 async function persistActiveModel(modelId) {
-  const path = join5(homedir7(), ".muse", "settings.json");
+  const path = join6(homedir8(), ".muse", "settings.json");
   let current = {};
-  if (existsSync4(path)) {
+  if (existsSync5(path)) {
     try {
-      current = JSON.parse(await readFile4(path, "utf-8"));
+      current = JSON.parse(await readFile5(path, "utf-8"));
     } catch {
       current = {};
     }
   }
   const llm = current.llm ?? {};
   const next = { ...current, llm: { ...llm, model: modelId } };
-  await mkdir2(dirname3(path), { recursive: true });
-  await writeFile(path, JSON.stringify(next, null, 2) + "\n", "utf-8");
+  await mkdir3(dirname3(path), { recursive: true });
+  await writeFile2(path, JSON.stringify(next, null, 2) + "\n", "utf-8");
 }
 
 // src/tools/registry.ts
@@ -2521,8 +3494,8 @@ var ToolRegistry = class {
 };
 
 // src/tools/builtin/read.ts
-import { readFile as readFile5, stat as stat2 } from "fs/promises";
-import { resolve as resolve2, isAbsolute } from "path";
+import { readFile as readFile6, stat as stat2 } from "fs/promises";
+import { resolve as resolve3, isAbsolute } from "path";
 import { z as z3 } from "zod";
 
 // src/tools/types.ts
@@ -2537,6 +3510,48 @@ function defineTool(def) {
   };
 }
 
+// src/tools/_sensitive.ts
+import { homedir as homedir9 } from "os";
+import { basename as basename2, resolve as resolve2 } from "path";
+var HOME = homedir9();
+var SENSITIVE_DIRS = [
+  resolve2(HOME, ".ssh"),
+  resolve2(HOME, ".aws"),
+  resolve2(HOME, ".gnupg"),
+  resolve2(HOME, ".config", "gh")
+];
+var SENSITIVE_FILES = [
+  resolve2(HOME, ".kube", "config"),
+  resolve2(HOME, ".netrc"),
+  resolve2(HOME, ".pypirc")
+];
+var SENSITIVE_BASENAMES = /* @__PURE__ */ new Set([
+  "id_rsa",
+  "id_ed25519",
+  "id_ecdsa",
+  "id_dsa"
+]);
+var ENV_PATTERN2 = /(?:^|\/)\.env(\..+)?$/;
+function checkSensitivePath(path) {
+  const abs = resolve2(path);
+  for (const dir of SENSITIVE_DIRS) {
+    if (abs === dir || abs.startsWith(dir + "/")) {
+      return { blocked: true, reason: `sensitive directory ${dir.replace(HOME, "~")}` };
+    }
+  }
+  for (const f of SENSITIVE_FILES) {
+    if (abs === f) return { blocked: true, reason: `sensitive file ${f.replace(HOME, "~")}` };
+  }
+  const base = basename2(abs);
+  if (SENSITIVE_BASENAMES.has(base)) {
+    return { blocked: true, reason: `private key filename ${base}` };
+  }
+  if (ENV_PATTERN2.test(abs)) {
+    return { blocked: true, reason: `.env file (may contain secrets)` };
+  }
+  return { blocked: false };
+}
+
 // src/tools/builtin/read.ts
 var ReadArgs = z3.object({
   file_path: z3.string().describe("Absolute or cwd-relative path to the file."),
@@ -2552,7 +3567,11 @@ var ReadTool = defineTool({
   permission: "read",
   summarize: (args) => `Read(${args.file_path}${args.offset != null ? `, offset=${args.offset}` : ""}${args.limit != null ? `, limit=${args.limit}` : ""})`,
   async execute(args, ctx) {
-    const path = isAbsolute(args.file_path) ? args.file_path : resolve2(ctx.cwd, args.file_path);
+    const path = isAbsolute(args.file_path) ? args.file_path : resolve3(ctx.cwd, args.file_path);
+    const sensitive = checkSensitivePath(path);
+    if (sensitive.blocked) {
+      return { content: `Refused: ${path} matches sensitive path policy (${sensitive.reason}).`, isError: true };
+    }
     let info;
     try {
       info = await stat2(path);
@@ -2562,7 +3581,7 @@ var ReadTool = defineTool({
     if (!info.isFile()) {
       throw new ToolError(`Not a regular file: ${path}`, "Read");
     }
-    const content = await readFile5(path, "utf-8");
+    const content = await readFile6(path, "utf-8");
     const lines = content.split(/\r?\n/);
     const offset = args.offset ?? 0;
     const limit = args.limit ?? DEFAULT_LIMIT;
@@ -2585,9 +3604,26 @@ var ReadTool = defineTool({
 });
 
 // src/tools/builtin/write.ts
-import { writeFile as writeFile2, mkdir as mkdir3, stat as stat3 } from "fs/promises";
-import { resolve as resolve3, isAbsolute as isAbsolute2, dirname as dirname4 } from "path";
+import { readFile as readFile7, writeFile as writeFile3, mkdir as mkdir4, stat as stat3 } from "fs/promises";
+import { resolve as resolve4, isAbsolute as isAbsolute2, dirname as dirname4 } from "path";
 import { z as z4 } from "zod";
+
+// src/tools/_diff.ts
+import { createPatch } from "diff";
+var MAX_DIFF_LINES = 200;
+function makeUnifiedDiff(filePath, oldContent, newContent) {
+  if (oldContent === newContent) return "";
+  const patch = createPatch(filePath, oldContent, newContent, "before", "after", { context: 3 });
+  return truncate(patch);
+}
+function truncate(diff) {
+  const lines = diff.split("\n");
+  if (lines.length <= MAX_DIFF_LINES) return diff;
+  return lines.slice(0, MAX_DIFF_LINES).join("\n") + `
+... [${lines.length - MAX_DIFF_LINES} more diff lines truncated]`;
+}
+
+// src/tools/builtin/write.ts
 var WriteArgs = z4.object({
   file_path: z4.string().describe("Absolute or cwd-relative path to the file."),
   content: z4.string().describe("Full content of the file.")
@@ -2599,25 +3635,33 @@ var WriteTool = defineTool({
   permission: "write",
   summarize: (args) => `Write(${args.file_path}, ${args.content.length} chars)`,
   async execute(args, ctx) {
-    const path = isAbsolute2(args.file_path) ? args.file_path : resolve3(ctx.cwd, args.file_path);
+    const path = isAbsolute2(args.file_path) ? args.file_path : resolve4(ctx.cwd, args.file_path);
+    const sensitive = checkSensitivePath(path);
+    if (sensitive.blocked) {
+      return { content: `Refused: ${path} matches sensitive path policy (${sensitive.reason}).`, isError: true };
+    }
     let existed = false;
+    let oldContent = "";
     try {
       const info = await stat3(path);
       existed = info.isFile();
+      if (existed) oldContent = await readFile7(path, "utf-8");
     } catch {
     }
-    await mkdir3(dirname4(path), { recursive: true });
-    await writeFile2(path, args.content, "utf-8");
+    await mkdir4(dirname4(path), { recursive: true });
+    await writeFile3(path, args.content, "utf-8");
+    const diff = makeUnifiedDiff(args.file_path, oldContent, args.content);
     return {
       content: existed ? `Overwrote ${path} (${args.content.length} bytes).` : `Created ${path} (${args.content.length} bytes).`,
-      summary: `${existed ? "Overwrote" : "Created"} ${args.file_path}`
+      summary: `${existed ? "Overwrote" : "Created"} ${args.file_path}`,
+      diff: diff || void 0
     };
   }
 });
 
 // src/tools/builtin/edit.ts
-import { readFile as readFile6, writeFile as writeFile3 } from "fs/promises";
-import { resolve as resolve4, isAbsolute as isAbsolute3 } from "path";
+import { readFile as readFile8, writeFile as writeFile4 } from "fs/promises";
+import { resolve as resolve5, isAbsolute as isAbsolute3 } from "path";
 import { z as z5 } from "zod";
 var EditArgs = z5.object({
   file_path: z5.string().describe("Absolute or cwd-relative path to the file."),
@@ -2632,10 +3676,14 @@ var EditTool = defineTool({
   permission: "write",
   summarize: (args) => `Edit(${args.file_path})`,
   async execute(args, ctx) {
-    const path = isAbsolute3(args.file_path) ? args.file_path : resolve4(ctx.cwd, args.file_path);
+    const path = isAbsolute3(args.file_path) ? args.file_path : resolve5(ctx.cwd, args.file_path);
+    const sensitive = checkSensitivePath(path);
+    if (sensitive.blocked) {
+      return { content: `Refused: ${path} matches sensitive path policy (${sensitive.reason}).`, isError: true };
+    }
     let content;
     try {
-      content = await readFile6(path, "utf-8");
+      content = await readFile8(path, "utf-8");
     } catch (err) {
       throw new ToolError(`Cannot read ${path}: ${err instanceof Error ? err.message : String(err)}`, "Edit", err);
     }
@@ -2656,10 +3704,12 @@ var EditTool = defineTool({
       };
     }
     const newContent = args.replace_all ? content.split(args.old_string).join(args.new_string) : content.replace(args.old_string, args.new_string);
-    await writeFile3(path, newContent, "utf-8");
+    await writeFile4(path, newContent, "utf-8");
+    const diff = makeUnifiedDiff(args.file_path, content, newContent);
     return {
       content: `Edited ${path}: replaced ${args.replace_all ? occurrences : 1} occurrence(s).`,
-      summary: `Edited ${args.file_path}`
+      summary: `Edited ${args.file_path}`,
+      diff: diff || void 0
     };
   }
 });
@@ -2738,8 +3788,8 @@ var BashTool = defineTool({
         maxBuffer: MAX_OUTPUT_BYTES * 2,
         cancelSignal: ctx.abortSignal
       });
-      const stdout = truncate(result.stdout ?? "", MAX_OUTPUT_BYTES, "stdout");
-      const stderr = truncate(result.stderr ?? "", MAX_OUTPUT_BYTES, "stderr");
+      const stdout = truncate2(result.stdout ?? "", MAX_OUTPUT_BYTES, "stdout");
+      const stderr = truncate2(result.stderr ?? "", MAX_OUTPUT_BYTES, "stderr");
       const parts = [];
       if (stdout) parts.push(`<stdout>
 ${stdout}
@@ -2763,7 +3813,7 @@ ${stderr}
     }
   }
 });
-function truncate(text, max, label) {
+function truncate2(text, max, label) {
   if (text.length <= max) return text;
   return text.slice(0, max) + `
 ... [${label} truncated, original ${text.length} bytes]`;
@@ -2872,6 +3922,243 @@ var GlobTool = defineTool({
   }
 });
 
+// src/tools/builtin/todo.ts
+import { z as z9 } from "zod";
+var TodoSchema = z9.object({
+  content: z9.string().describe("Imperative one-line task description (e.g. 'Run the test suite')."),
+  status: z9.enum(["pending", "in_progress", "completed"]).describe("Current status."),
+  activeForm: z9.string().optional().describe("Present-continuous form for the spinner (e.g. 'Running the test suite').")
+});
+var TodoWriteArgs = z9.object({
+  todos: z9.array(TodoSchema).describe("Full list. Replaces the current store.")
+});
+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.",
+  parameters: TodoWriteArgs,
+  permission: "read",
+  summarize: (args) => `TodoWrite(${args.todos.length} items)`,
+  async execute(args, ctx) {
+    if (!ctx.todos) {
+      return {
+        content: "TodoWrite is unavailable: this agent run has no todo store. (Internal bug; tell the user.)",
+        isError: true
+      };
+    }
+    ctx.todos.set(args.todos);
+    const summary = args.todos.map((t, i) => `${i + 1}. ${t.status === "completed" ? "[x]" : t.status === "in_progress" ? "[~]" : "[ ]"} ${t.content}`).join("\n");
+    return {
+      content: `Updated todos (${args.todos.length} items):
+${summary}`,
+      summary: `Todos: ${args.todos.filter((t) => t.status === "completed").length}/${args.todos.length} done`
+    };
+  }
+});
+
+// src/tools/builtin/webfetch.ts
+import { z as z10 } from "zod";
+var WebFetchArgs = z10.object({
+  url: z10.string().describe("Fully-qualified URL. http will be upgraded to https."),
+  prompt: z10.string().optional().describe(
+    "What information to look for. The host returns the page content; the LLM should then read it to answer the prompt."
+  )
+});
+var MAX_RESPONSE_BYTES = 1e6;
+var FETCH_TIMEOUT_MS = 3e4;
+var PRIVATE_HOST_PATTERNS = [
+  /^localhost$/i,
+  /^127\./,
+  /^0\.0\.0\.0$/,
+  /^169\.254\./,
+  /^10\./,
+  /^192\.168\./,
+  /^172\.(1[6-9]|2[0-9]|3[0-1])\./,
+  /^::1$/,
+  /^fc[0-9a-f]{2}:/i,
+  /^fe80:/i
+];
+function isPrivateHost(hostname) {
+  return PRIVATE_HOST_PATTERNS.some((p) => p.test(hostname));
+}
+var WebFetchTool = defineTool({
+  name: "WebFetch",
+  description: "Fetch a URL and return its textual content (HTML stripped to a markdown-ish form). Use for reading documentation, blog posts, or API specs. Private/loopback hosts are blocked. If the URL redirects to a different host, the redirect target is returned for you to re-fetch.",
+  parameters: WebFetchArgs,
+  permission: "network",
+  summarize: (args) => `WebFetch(${args.url})`,
+  async execute(args, ctx) {
+    let target;
+    try {
+      target = new URL(args.url);
+    } catch {
+      return { content: `Invalid URL: ${args.url}`, isError: true };
+    }
+    if (target.protocol === "http:") {
+      target.protocol = "https:";
+    }
+    if (target.protocol !== "https:") {
+      return { content: `Refused: only http(s) URLs are allowed.`, isError: true };
+    }
+    if (isPrivateHost(target.hostname)) {
+      return { content: `Refused: ${target.hostname} is a private/loopback host (SSRF guard).`, isError: true };
+    }
+    const controller = new AbortController();
+    const onAbort = () => controller.abort();
+    ctx.abortSignal?.addEventListener("abort", onAbort);
+    const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    try {
+      const resp = await fetch(target.toString(), {
+        redirect: "manual",
+        signal: controller.signal,
+        headers: { "user-agent": "muse-cli/0.1" }
+      });
+      if (resp.status >= 300 && resp.status < 400) {
+        const loc = resp.headers.get("location");
+        if (loc) {
+          try {
+            const redirectURL = new URL(loc, target);
+            if (redirectURL.hostname !== target.hostname) {
+              return {
+                content: `Redirect to a different host: ${redirectURL.toString()}
+Re-fetch the new URL explicitly if you trust it.`,
+                summary: `Redirect to a different host: ${redirectURL.toString()}`,
+                kind: "warn"
+              };
+            }
+            return {
+              content: `Redirect (same host): ${redirectURL.toString()}
+Re-fetch the new URL to continue.`,
+              summary: `Redirect \u2192 ${redirectURL.pathname}`,
+              kind: "warn"
+            };
+          } catch {
+            return { content: `Redirect with unparseable location: ${loc}`, isError: true };
+          }
+        }
+      }
+      if (!resp.ok) {
+        return { content: `HTTP ${resp.status} ${resp.statusText} for ${target.toString()}`, isError: true };
+      }
+      const contentType = resp.headers.get("content-type") ?? "";
+      const reader = resp.body?.getReader();
+      if (!reader) return { content: `Empty response body.`, isError: true };
+      const chunks = [];
+      let total = 0;
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        if (value) {
+          total += value.byteLength;
+          if (total > MAX_RESPONSE_BYTES) {
+            await reader.cancel();
+            chunks.push(value.slice(0, value.byteLength - (total - MAX_RESPONSE_BYTES)));
+            break;
+          }
+          chunks.push(value);
+        }
+      }
+      const body = new TextDecoder("utf-8", { fatal: false }).decode(Buffer.concat(chunks.map((c) => Buffer.from(c))));
+      let processed = body;
+      if (/^text\/html|application\/xhtml/i.test(contentType)) {
+        processed = htmlToText(body);
+      }
+      const summary = args.prompt ? `# WebFetch result for: ${args.prompt}` : `Fetched ${target.hostname} (${total} bytes${total >= MAX_RESPONSE_BYTES ? ", truncated" : ""})`;
+      const truncated = processed.length > 2e5 ? processed.slice(0, 2e5) + "\n\n... [truncated]" : processed;
+      const preface = args.prompt ? `# WebFetch result for: ${args.prompt}
+
+Source: ${target.toString()}
+
+` : `Source: ${target.toString()}
+
+`;
+      return { content: preface + truncated, summary };
+    } catch (err) {
+      if (err.name === "AbortError") {
+        return { content: `WebFetch aborted (timeout or user cancel).`, isError: true };
+      }
+      return { content: `WebFetch failed: ${err instanceof Error ? err.message : String(err)}`, isError: true };
+    } finally {
+      clearTimeout(timer);
+      ctx.abortSignal?.removeEventListener("abort", onAbort);
+    }
+  }
+});
+function htmlToText(html) {
+  let s = html;
+  s = s.replace(/<(script|style|svg|noscript)\b[^>]*>[\s\S]*?<\/\1>/gi, "");
+  s = s.replace(/<!--[\s\S]*?-->/g, "");
+  s = s.replace(/<h([1-6])\b[^>]*>([\s\S]*?)<\/h\1>/gi, (_m, lvl, txt) => {
+    return `
+
+${"#".repeat(parseInt(lvl, 10))} ${stripTags(txt).trim()}
+
+`;
+  });
+  s = s.replace(/<a\b[^>]*href=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/gi, (_m, href, txt) => {
+    const label = stripTags(txt).trim();
+    return label ? `[${label}](${href})` : href;
+  });
+  s = s.replace(/<li\b[^>]*>([\s\S]*?)<\/li>/gi, (_m, txt) => `
+- ${stripTags(txt).trim()}`);
+  s = s.replace(/<(p|div|section|article|header|footer|main|aside|nav|pre|blockquote|br|hr)\b[^>]*>/gi, "\n");
+  s = s.replace(/<\/(p|div|section|article|header|footer|main|aside|nav|pre|blockquote)>/gi, "\n");
+  s = s.replace(/<code\b[^>]*>([\s\S]*?)<\/code>/gi, (_m, txt) => `\`${stripTags(txt)}\``);
+  s = stripTags(s);
+  s = s.replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+  s = s.replace(/\n{3,}/g, "\n\n").trim();
+  return s;
+}
+function stripTags(s) {
+  return s.replace(/<[^>]+>/g, "");
+}
+
+// src/tools/builtin/memory.ts
+import { z as z11 } from "zod";
+var TYPES = ["user", "feedback", "project", "reference"];
+var MemoryWriteArgs = z11.object({
+  name: z11.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: z11.string().describe("One-line summary used in MEMORY.md index (decides future relevance)."),
+  type: z11.enum(TYPES).describe("user | feedback | project | reference"),
+  body: z11.string().describe("Memory content (markdown). For feedback/project, lead with the rule/fact then **Why:** and **How to apply:** lines.")
+});
+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.",
+  parameters: MemoryWriteArgs,
+  permission: "write",
+  summarize: (args) => `MemoryWrite(${args.name}, type=${args.type})`,
+  async execute(args, ctx) {
+    const { filePath, indexUpdated } = await writeMemory(ctx.cwd, {
+      name: args.name,
+      description: args.description,
+      type: args.type,
+      body: args.body
+    });
+    return {
+      content: `Saved memory "${args.name}" (${args.type}) \u2192 ${filePath}${indexUpdated ? "\nMEMORY.md updated." : ""}`,
+      summary: `MemoryWrite ${args.name}`
+    };
+  }
+});
+var MemoryReadArgs = z11.object({
+  name: z11.string().describe("Memory slug to read (no .md extension).")
+});
+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).",
+  parameters: MemoryReadArgs,
+  permission: "read",
+  summarize: (args) => `MemoryRead(${args.name})`,
+  async execute(args, ctx) {
+    try {
+      const content = await readMemoryFile(ctx.cwd, args.name);
+      return { content, summary: `MemoryRead ${args.name}` };
+    } catch (err) {
+      return { content: err instanceof Error ? err.message : String(err), isError: true };
+    }
+  }
+});
+
 // src/tools/builtin/index.ts
 var BUILTIN_TOOLS = [
   ReadTool,
@@ -2879,16 +4166,20 @@ var BUILTIN_TOOLS = [
   EditTool,
   BashTool,
   GrepTool,
-  GlobTool
+  GlobTool,
+  TodoWriteTool,
+  WebFetchTool,
+  MemoryReadTool,
+  MemoryWriteTool
 ];
 
 // src/cli.tsx
-import { jsx as jsx10 } from "react/jsx-runtime";
+import { jsx as jsx15 } from "react/jsx-runtime";
 var VERSION = "0.1.0";
 async function main() {
   const program = new Command();
-  program.name("muse").description("A Claude Code-style agent CLI. Provider-agnostic. First-class support for Chinese / self-hostable LLMs.").version(VERSION, "-v, --version", "print version");
-  program.argument("[prompt...]", "one-shot prompt (omit for interactive mode)").option("-m, --model <model>", "override model").option("-p, --provider <provider>", "override provider").option("--no-banner", "skip startup banner").option("--quiet", "minimal output (implies --no-banner)").option("--continue", "resume last session in this directory").option("--debug", "verbose logging").action(async (promptArgs, opts) => {
+  program.name("muse").description("A TypeScript agent CLI built around OpenAI-compatible APIs. First-class support for self-hostable and Chinese LLMs.").version(VERSION, "-v, --version", "print version");
+  program.argument("[prompt...]", "one-shot prompt (omit for interactive mode)").option("-m, --model <model>", "override model").option("-p, --provider <provider>", "override provider").option("--no-banner", "skip startup banner").option("--quiet", "minimal output (implies --no-banner)").option("--continue", "resume last session in this directory").option("--mode <mode>", "initial permission mode (default|acceptEdits|plan|bypassPermissions)").option("--debug", "verbose logging").action(async (promptArgs, opts) => {
     if (opts.debug) log.setLevel("debug");
     const cwd = process.cwd();
     const { settings, sources } = await loadSettings(cwd);
@@ -2908,7 +4199,7 @@ async function main() {
         llmModelName = llm.model;
       } else {
         if (!provider || !model) {
-          die("No model configured. Either define one in ~/.muse/models.json or set llm.provider+llm.model in settings.json.");
+          die("No model configured. Either define one in ~/.muse/models.local.json or set llm.provider+llm.model in settings.json.");
         }
         llm = createLLMClient({ provider, model, providers: settings.providers ?? {} });
         llmProviderName = provider;
@@ -2921,24 +4212,62 @@ async function main() {
     const tools = new ToolRegistry();
     tools.registerAll(BUILTIN_TOOLS);
     const permissions = new PermissionGate(settings.permissions);
-    const session = await Session.create(cwd);
-    await session.append({
-      type: "session_start",
-      time: (/* @__PURE__ */ new Date()).toISOString(),
-      cwd,
-      provider: llmProviderName,
-      model: llmModelName
-    });
+    if (opts.mode) {
+      const valid = ["default", "acceptEdits", "plan", "bypassPermissions"];
+      if (!valid.includes(opts.mode)) {
+        die(`Invalid --mode "${opts.mode}". Valid: ${valid.join(", ")}`);
+      }
+      permissions.setMode(opts.mode);
+    }
+    let session;
+    let initialMessages;
+    if (opts.continue) {
+      const latest = await Session.findLatest(cwd);
+      if (latest) {
+        const opened = await Session.open(latest);
+        session = opened.session;
+        initialMessages = Session.messagesFromEvents(opened.events);
+        log.debug("resumed session", { id: latest.id, messages: initialMessages.length });
+      } else {
+        session = await Session.create(cwd);
+        await session.append({
+          type: "session_start",
+          time: (/* @__PURE__ */ new Date()).toISOString(),
+          cwd,
+          provider: llmProviderName,
+          model: llmModelName
+        });
+      }
+    } else {
+      session = await Session.create(cwd);
+      await session.append({
+        type: "session_start",
+        time: (/* @__PURE__ */ new Date()).toISOString(),
+        cwd,
+        provider: llmProviderName,
+        model: llmModelName
+      });
+    }
     const showBanner = !opts.quiet && opts.banner !== false;
     const lang = settings.ui?.lang ?? "en";
     const pipedInput = await readStdinIfPiped();
     const oneShotPrompt = [...promptArgs ?? [], pipedInput].filter(Boolean).join("\n").trim();
     if (oneShotPrompt) {
-      await runOneShot({ llm, tools, permissions, session, cwd, lang, prompt: oneShotPrompt, quiet: opts.quiet ?? false });
+      await runOneShot({
+        llm,
+        tools,
+        permissions,
+        session,
+        cwd,
+        lang,
+        prompt: oneShotPrompt,
+        quiet: opts.quiet ?? false,
+        initialMessages
+      });
       return;
     }
     const { waitUntilExit } = render(
-      /* @__PURE__ */ jsx10(
+      /* @__PURE__ */ jsx15(
         App,
         {
           llm,
@@ -2951,7 +4280,8 @@ async function main() {
           modelsSources,
           cwd,
           lang,
-          showBanner
+          showBanner,
+          initialMessages
         }
       )
     );
@@ -2966,12 +4296,14 @@ async function readStdinIfPiped() {
   return Buffer.concat(chunks).toString("utf-8").trim();
 }
 async function runOneShot(opts) {
+  const memoryIndex = await loadMemoryIndex(opts.cwd);
   const systemPrompt = buildSystemPrompt({
     cwd: opts.cwd,
     model: opts.llm.model,
     provider: opts.llm.providerName,
     lang: opts.lang,
-    toolNames: opts.tools.list().map((t) => t.name)
+    toolNames: opts.tools.list().map((t) => t.name),
+    memoryIndex
   });
   const agent = new Agent({
     llm: opts.llm,
@@ -2994,10 +4326,11 @@ async function runOneShot(opts) {
         if (!opts.quiet) process.stderr.write(`
 [denied: ${toolName} \u2014 ${summary}; run in interactive mode to approve]
 `);
-        return false;
+        return "no";
       }
     }
   });
+  if (opts.initialMessages?.length) agent.setMessages(opts.initialMessages);
   await agent.runTurn(opts.prompt);
   process.stdout.write("\n");
 }