reasonix 0.30.5 → 0.32.0

package/dist/index.js

@@ -294,165 +294,6 @@ var DeepSeekClient = class {
   }
 };
 
-// src/harvest.ts
-function emptyPlanState() {
-  return { subgoals: [], hypotheses: [], uncertainties: [], rejectedPaths: [] };
-}
-function isPlanStateEmpty(s) {
-  if (!s) return true;
-  return s.subgoals.length === 0 && s.hypotheses.length === 0 && s.uncertainties.length === 0 && s.rejectedPaths.length === 0;
-}
-var SYSTEM_PROMPT = `You extract a typed plan state from a reasoning trace produced by another LLM.
-Output ONLY a JSON object. No markdown, no prose, no backticks.
-
-Schema:
-{
-  "subgoals":       string[],   // concrete intermediate objectives the trace identifies
-  "hypotheses":     string[],   // candidate approaches or assumptions being weighed
-  "uncertainties":  string[],   // facts the trace flags as unclear / to verify
-  "rejectedPaths":  string[]    // approaches the trace considered and then abandoned
-}
-
-Constraints:
-- Every field must be present. Use [] if not applicable.
-- Each array has at most {maxItems} items.
-- Each item is plain text, at most {maxItemLen} characters, no markdown.
-- Write in the same language as the trace (Chinese in \u2192 Chinese out, etc.).
-- Do not quote back the trace; write short, specific phrases.`;
-async function harvest(reasoningContent, client, options = {}, signal) {
-  if (!client || !reasoningContent) return emptyPlanState();
-  if (signal?.aborted) return emptyPlanState();
-  const minLen = options.minReasoningLen ?? 40;
-  const trimmed = reasoningContent.trim();
-  if (trimmed.length < minLen) return emptyPlanState();
-  const model = options.model ?? "deepseek-v4-flash";
-  const maxItems = options.maxItems ?? 5;
-  const maxItemLen = options.maxItemLen ?? 80;
-  const system = SYSTEM_PROMPT.replace("{maxItems}", String(maxItems)).replace(
-    "{maxItemLen}",
-    String(maxItemLen)
-  );
-  try {
-    const resp = await client.chat({
-      model,
-      messages: [
-        { role: "system", content: system },
-        { role: "user", content: trimmed }
-      ],
-      responseFormat: { type: "json_object" },
-      temperature: 0,
-      maxTokens: 600,
-      // Pin mode + effort so a future default-model swap (e.g. someone
-      // sets `options.model = "deepseek-v4-pro"`) can't accidentally
-      // turn this micro-extraction into a multi-thousand-reasoning-
-      // token call. DeepSeek ignores these on non-thinking models, so
-      // the request stays valid regardless of the chosen model.
-      thinking: "disabled",
-      reasoningEffort: "high",
-      signal
-    });
-    return parsePlanState(resp.content, maxItems, maxItemLen);
-  } catch {
-    return emptyPlanState();
-  }
-}
-function parsePlanState(raw, maxItems, maxItemLen) {
-  const text = (raw ?? "").trim();
-  if (!text) return emptyPlanState();
-  let parsed;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-    const match = text.match(/\{[\s\S]*\}/);
-    if (!match) return emptyPlanState();
-    try {
-      parsed = JSON.parse(match[0]);
-    } catch {
-      return emptyPlanState();
-    }
-  }
-  if (!parsed || typeof parsed !== "object") return emptyPlanState();
-  const obj = parsed;
-  return {
-    subgoals: sanitizeArray(obj.subgoals, maxItems, maxItemLen),
-    hypotheses: sanitizeArray(obj.hypotheses, maxItems, maxItemLen),
-    uncertainties: sanitizeArray(obj.uncertainties, maxItems, maxItemLen),
-    rejectedPaths: sanitizeArray(obj.rejectedPaths ?? obj.rejected_paths, maxItems, maxItemLen)
-  };
-}
-function sanitizeArray(raw, maxItems, maxItemLen) {
-  if (!Array.isArray(raw)) return [];
-  const out = [];
-  for (const item of raw) {
-    if (out.length >= maxItems) break;
-    if (typeof item !== "string") continue;
-    const cleaned = item.trim().replace(/\s+/g, " ");
-    if (!cleaned) continue;
-    out.push(cleaned.length <= maxItemLen ? cleaned : `${cleaned.slice(0, maxItemLen - 1)}\u2026`);
-  }
-  return out;
-}
-
-// src/consistency.ts
-var defaultSelector = (samples) => {
-  if (samples.length === 0) throw new Error("defaultSelector: samples is empty");
-  return samples.slice().sort((a, b) => {
-    const uDiff = a.planState.uncertainties.length - b.planState.uncertainties.length;
-    if (uDiff !== 0) return uDiff;
-    const aLen = a.response.content?.length ?? 0;
-    const bLen = b.response.content?.length ?? 0;
-    return aLen - bLen;
-  })[0];
-};
-async function runBranches(client, request, opts = {}) {
-  const budget = Math.max(1, opts.budget ?? 1);
-  const temperatures = resolveTemperatures(budget, opts.temperatures);
-  const selector = opts.selector ?? defaultSelector;
-  const samples = await Promise.all(
-    temperatures.map(async (temperature, index) => {
-      const response = await client.chat({ ...request, temperature });
-      const planState = await harvest(response.reasoningContent, client, opts.harvestOptions);
-      const sample = { index, temperature, response, planState };
-      try {
-        opts.onSampleDone?.(sample);
-      } catch {
-      }
-      return sample;
-    })
-  );
-  return { chosen: selector(samples), samples };
-}
-function aggregateBranchUsage(samples) {
-  let promptTokens = 0;
-  let completionTokens = 0;
-  let totalTokens = 0;
-  let promptCacheHitTokens = 0;
-  let promptCacheMissTokens = 0;
-  for (const s of samples) {
-    promptTokens += s.response.usage.promptTokens;
-    completionTokens += s.response.usage.completionTokens;
-    totalTokens += s.response.usage.totalTokens;
-    promptCacheHitTokens += s.response.usage.promptCacheHitTokens;
-    promptCacheMissTokens += s.response.usage.promptCacheMissTokens;
-  }
-  return {
-    promptTokens,
-    completionTokens,
-    totalTokens,
-    promptCacheHitTokens,
-    promptCacheMissTokens
-  };
-}
-function resolveTemperatures(budget, custom) {
-  if (custom && custom.length >= budget) return [...custom.slice(0, budget)];
-  if (budget === 1) return [0];
-  const out = [];
-  for (let i = 0; i < budget; i++) {
-    out.push(Number((i / (budget - 1)).toFixed(2)));
-  }
-  return out;
-}
-
 // src/core/pause-gate.ts
 var PauseGate = class {
   _nextId = 0;
@@ -540,14 +381,1604 @@ var PauseGate = class {
     } catch {
     }
   }
-};
-var pauseGate = new PauseGate();
+};
+var pauseGate = new PauseGate();
+
+// src/hooks.ts
+import { spawn } from "child_process";
+import { existsSync, readFileSync as readFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+
+// src/config.ts
+import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+
+// src/index/config.ts
+import picomatch from "picomatch";
+var DEFAULT_INDEX_EXCLUDES = {
+  dirs: [
+    "node_modules",
+    ".git",
+    ".hg",
+    ".svn",
+    "dist",
+    "build",
+    "out",
+    ".next",
+    ".nuxt",
+    "target",
+    ".venv",
+    "venv",
+    "__pycache__",
+    ".pytest_cache",
+    ".mypy_cache",
+    ".cache",
+    "coverage",
+    ".turbo",
+    ".vercel",
+    ".reasonix"
+  ],
+  files: [
+    "package-lock.json",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "Cargo.lock",
+    "poetry.lock",
+    "Pipfile.lock",
+    "go.sum",
+    ".DS_Store"
+  ],
+  exts: [
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".webp",
+    ".bmp",
+    ".ico",
+    ".tiff",
+    ".woff",
+    ".woff2",
+    ".ttf",
+    ".otf",
+    ".eot",
+    ".zip",
+    ".tar",
+    ".gz",
+    ".bz2",
+    ".xz",
+    ".rar",
+    ".7z",
+    ".exe",
+    ".dll",
+    ".so",
+    ".dylib",
+    ".bin",
+    ".class",
+    ".jar",
+    ".war",
+    ".wasm",
+    ".o",
+    ".obj",
+    ".lib",
+    ".a",
+    ".pyc",
+    ".pyo",
+    ".mp3",
+    ".mp4",
+    ".wav",
+    ".ogg",
+    ".webm",
+    ".mov",
+    ".avi",
+    ".pdf",
+    ".sqlite",
+    ".db"
+  ]
+};
+var DEFAULT_MAX_FILE_BYTES = 256 * 1024;
+
+// src/config.ts
+function defaultConfigPath() {
+  return join(homedir(), ".reasonix", "config.json");
+}
+function readConfig(path2 = defaultConfigPath()) {
+  try {
+    const raw = readFileSync(path2, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object") return parsed;
+  } catch {
+  }
+  return {};
+}
+function writeConfig(cfg, path2 = defaultConfigPath()) {
+  mkdirSync(dirname(path2), { recursive: true });
+  writeFileSync(path2, JSON.stringify(cfg, null, 2), "utf8");
+  try {
+    chmodSync(path2, 384);
+  } catch {
+  }
+}
+function loadLanguage(path2 = defaultConfigPath()) {
+  return readConfig(path2).lang;
+}
+function loadApiKey(path2 = defaultConfigPath()) {
+  if (process.env.DEEPSEEK_API_KEY) return process.env.DEEPSEEK_API_KEY;
+  return readConfig(path2).apiKey;
+}
+function webSearchEngine(path2 = defaultConfigPath()) {
+  const cfg = readConfig(path2).webSearchEngine;
+  if (cfg === "searxng") return "searxng";
+  return "mojeek";
+}
+function webSearchEndpoint(path2 = defaultConfigPath()) {
+  const cfg = readConfig(path2).webSearchEndpoint;
+  if (cfg && typeof cfg === "string") return cfg;
+  return "http://localhost:8080";
+}
+function saveApiKey(key, path2 = defaultConfigPath()) {
+  const cfg = readConfig(path2);
+  cfg.apiKey = key.trim();
+  writeConfig(cfg, path2);
+}
+function findProjectKey(cfg, rootDir) {
+  const projects = cfg.projects;
+  if (!projects) return void 0;
+  if (Object.hasOwn(projects, rootDir)) return rootDir;
+  if (process.platform !== "win32") return void 0;
+  const lower = rootDir.toLowerCase();
+  for (const k of Object.keys(projects)) {
+    if (k.toLowerCase() === lower) return k;
+  }
+  return void 0;
+}
+function addProjectShellAllowed(rootDir, prefix, path2 = defaultConfigPath()) {
+  const trimmed = prefix.trim();
+  if (!trimmed) return;
+  const cfg = readConfig(path2);
+  if (!cfg.projects) cfg.projects = {};
+  const key = findProjectKey(cfg, rootDir) ?? rootDir;
+  if (!cfg.projects[key]) cfg.projects[key] = {};
+  const existing = cfg.projects[key].shellAllowed ?? [];
+  if (existing.includes(trimmed)) return;
+  cfg.projects[key].shellAllowed = [...existing, trimmed];
+  writeConfig(cfg, path2);
+}
+function isPlausibleKey(key) {
+  const trimmed = key.trim();
+  return /^sk-[A-Za-z0-9_-]{16,}$/.test(trimmed);
+}
+function redactKey(key) {
+  if (!key) return "";
+  if (key.length <= 12) return "****";
+  return `${key.slice(0, 6)}\u2026${key.slice(-4)}`;
+}
+
+// src/i18n/EN.ts
+var EN = {
+  common: {
+    error: "Error",
+    warning: "Warning",
+    loading: "Loading...",
+    done: "Done",
+    cancel: "Cancel",
+    confirm: "Confirm",
+    back: "Back",
+    next: "Next"
+  },
+  cli: {
+    description: "DeepSeek-native agent framework \u2014 built for cache hits and cheap tokens.",
+    continue: "Resume the most recently used chat session without showing the picker.",
+    setup: "Interactive wizard \u2014 API key, preset, MCP servers. Re-run any time to reconfigure.",
+    code: "Code-editing chat \u2014 filesystem tools rooted at <dir> (default: cwd), coding system prompt, v4-flash baseline.",
+    chat: "Interactive Ink TUI with live cache/cost panel.",
+    run: "Run a single task non-interactively, streaming output.",
+    stats: "Show usage dashboard.",
+    doctor: "One-command health check.",
+    commit: "Draft a commit message from the staged diff.",
+    sessions: "List saved chat sessions, or inspect one by name.",
+    pruneSessions: "Delete saved sessions idle \u2265N days (default 90). Use --dry-run to preview.",
+    events: "Pretty-print the kernel event-log sidecar.",
+    replay: "Interactive Ink TUI to scrub through a transcript.",
+    diff: "Compare two transcripts in a split-pane Ink TUI.",
+    mcp: "Model Context Protocol helpers \u2014 discover servers, test your setup.",
+    version: "Print Reasonix version.",
+    update: "Check for a newer Reasonix and install it.",
+    index: "Build (or incrementally refresh) a local semantic search index."
+  },
+  ui: {
+    welcome: "Run `reasonix` any time to start chatting \u2014 your settings are remembered.",
+    taglineChat: "DeepSeek-native agent",
+    taglineCode: "DeepSeek-native coding agent",
+    taglineSub: "cache-first \xB7 flash-first",
+    startSessionHint: "type a message to start your session",
+    inputPlaceholder: "Ask anything... (type / for commands, @ for files)",
+    busy: "Thinking...",
+    thinking: "\u25B8 thinking...",
+    undo: "Undo",
+    undoHint: "press u within 5s to undo",
+    applied: "applied",
+    rejected: "rejected",
+    noDashboard: "Suppress the auto-launched embedded web dashboard.",
+    dashboardAutoStartFailed: "\u25B2 dashboard auto-start failed ({reason}) \u2014 try /dashboard, or pass --no-dashboard to silence",
+    systemAppendHint: "Append instructions to the code system prompt. Does NOT replace the default prompt \u2014 adds after it.",
+    systemAppendFileHint: "Append file contents to the code system prompt. Does NOT replace the default prompt. UTF-8, relative to cwd or absolute.",
+    resumedSession: '\u25B8 resumed session "{name}" with {count} prior messages \xB7 /forget to start over \xB7 /sessions to list',
+    newSession: '\u25B8 session "{name}" (new) \u2014 auto-saved as you chat \xB7 /forget to delete \xB7 /sessions to list',
+    ephemeralSession: "\u25B8 ephemeral chat (no session persistence) \u2014 drop --no-session to enable",
+    restoredEdits: "\u25B8 restored {count} pending edit block(s) from an interrupted prior run \u2014 /apply to commit or /discard to drop.",
+    resumedPlan: "Resumed plan \xB7 {when}{summary}",
+    tipEditBindings: "\u25B8 TIP: edit-gate keybindings\n    y / n       accept or drop pending edits\n    Shift+Tab   switch review \u2194 AUTO (persisted; AUTO applies instantly)\n    u           undo the last auto-applied batch (within the 5s banner)\n  Current mode is shown in the bottom status bar. Run /keys anytime for the full list.\n  (This tip shows once \u2014 suppressed after.)",
+    modelOverride: "override the default model",
+    noSession: "disable session persistence for this run",
+    resumeHint: "force-resume the named session (even if idle)",
+    newHint: "force a fresh session (ignore --session / --continue)",
+    transcriptHint: "path to write the JSONL transcript",
+    budgetHint: "session USD cap \u2014 warns at 80%, refuses next turn at 100%",
+    modelIdHint: "DeepSeek model id (e.g. deepseek-v4-flash)",
+    systemPromptHint: "override the default system prompt",
+    presetHint: "model bundle \u2014 auto|flash|pro",
+    sessionNameHint: "session name (default: 'default')",
+    ephemeralHint: "disable session persistence for this run",
+    mcpSpecHint: "MCP server spec (repeatable)",
+    mcpPrefixHint: "prefix MCP tool names with this string",
+    noConfigHint: "ignore ~/.reasonix/config.json for this run",
+    presetHintShort: "model bundle \u2014 auto|flash|pro",
+    budgetHintShort: "session USD cap",
+    transcriptHintShort: "JSONL transcript path",
+    mcpSpecHintShort: "MCP server spec (repeatable)",
+    mcpPrefixHintShort: "MCP tool name prefix",
+    dryRunHint: "show what would be installed without actually installing",
+    rebuildHint: "rebuild the index from scratch",
+    embedModelHint: "embedding model name",
+    projectDirHint: "project root directory",
+    ollamaUrlHint: "Ollama server URL",
+    skipPromptsHint: "skip confirmation prompts",
+    verboseHint: "show full session metadata",
+    pruneDaysHint: "delete sessions idle this many days or more (default 90)",
+    pruneDryRunHint: "list what would be deleted without removing anything",
+    eventTypeHint: "filter by event type",
+    eventSinceHint: "start from this event id",
+    eventTailHint: "show only the last N events",
+    jsonHint: "output as JSON",
+    projectionHint: "show projected state at each event",
+    printHint: "print to stdout instead of TUI",
+    headHint: "show only the first N events",
+    tailHint: "show only the last N events",
+    mdReportHint: "write a markdown diff report to this path",
+    printHintTable: "print a table to stdout",
+    tuiHint: "open the interactive TUI",
+    labelAHint: "label for the left pane",
+    labelBHint: "label for the right pane",
+    mcpListDescription: "browse the MCP registry (official \u2192 smithery \u2192 local fallback)",
+    mcpInspectDescription: "inspect an MCP server spec (tools, resources, prompts)",
+    mcpSearchDescription: "search the MCP registry for servers matching a query",
+    mcpInstallDescription: "install an MCP server by name (writes its spec to your config)",
+    mcpBrowseDescription: "interactive marketplace browser \u2014 type to filter, enter to install",
+    mcpLocalHint: "show only the bundled offline catalog",
+    mcpRefreshHint: "bypass the 24h cache and refetch",
+    mcpLimitHint: "max entries to show",
+    mcpPagesHint: "eagerly load this many pages (default 1)",
+    mcpAllHint: "load every page (slow on first run)",
+    mcpMaxPagesHint: "cap how many pages to walk while searching (default 20)",
+    jsonHintCatalog: "output as JSON",
+    jsonHintReport: "output the inspection report as JSON",
+    modelOverrideFlash: "override the model (default: deepseek-v4-flash)",
+    skipConfirmHint: "skip the confirmation prompt"
+  },
+  slash: {
+    help: { description: "show the full command reference" },
+    status: { description: "current model, flags, context, session" },
+    preset: {
+      description: "model bundle \u2014 auto escalates flash \u2192 pro, flash/pro lock",
+      argsHint: "<auto|flash|pro>"
+    },
+    model: { description: "switch DeepSeek model id", argsHint: "<id>" },
+    models: { description: "list available models fetched from DeepSeek /models" },
+    language: {
+      description: "switch the runtime language",
+      argsHint: "<EN|zh-CN>",
+      success: "Language switched to English.",
+      unsupported: "Unsupported language code: {code}. Supported: {supported}."
+    },
+    pro: {
+      description: "arm v4-pro for the NEXT turn only (one-shot \xB7 auto-disarms after turn)",
+      argsHint: "[off]"
+    },
+    budget: {
+      description: "session USD cap \u2014 warns at 80%, refuses next turn at 100%. Off by default. /budget alone shows status",
+      argsHint: "[usd|off]"
+    },
+    mcp: { description: "list MCP servers + tools attached to this session" },
+    resource: {
+      description: "browse + read MCP resources (no arg \u2192 list URIs; <uri> \u2192 fetch contents)",
+      argsHint: "[uri]"
+    },
+    prompt: {
+      description: "browse + fetch MCP prompts (no arg \u2192 list names; <name> \u2192 render prompt)",
+      argsHint: "[name]"
+    },
+    memory: {
+      description: "show / manage pinned memory (REASONIX.md + ~/.reasonix/memory)",
+      argsHint: "[list|show <name>|forget <name>|clear <scope> confirm]"
+    },
+    skill: {
+      description: "list / run user skills (<project>/.reasonix/skills + ~/.reasonix/skills)",
+      argsHint: "[list|show <name>|<name> [args]]"
+    },
+    hooks: {
+      description: "list active hooks (settings.json under .reasonix/) \xB7 reload re-reads from disk",
+      argsHint: "[reload]"
+    },
+    permissions: {
+      description: "show / edit shell allowlist (builtin read-only \xB7 per-project: ~/.reasonix/config.json)",
+      argsHint: "[list|add <prefix>|remove <prefix|N>|clear confirm]"
+    },
+    dashboard: {
+      description: "launch the embedded web dashboard (127.0.0.1, token-gated)",
+      argsHint: "[stop]"
+    },
+    update: { description: "show current vs latest version + the shell command to upgrade" },
+    stats: {
+      description: "cross-session cost dashboard (today / week / month / all-time \xB7 cache hit \xB7 vs Claude)"
+    },
+    cost: {
+      description: "bare \u2192 last turn's spend (Usage card); with text \u2192 estimate cost of sending it next (worst-case + likely-cache)",
+      argsHint: "[text]"
+    },
+    doctor: { description: "health check (api / config / api-reach / index / hooks / project)" },
+    context: { description: "show context-window breakdown (system / tools / log / input)" },
+    retry: { description: "truncate & resend your last message (fresh sample)" },
+    compact: {
+      description: "shrink oversized tool results AND tool-call args (edit_file search/replace) in the log; cap in tokens, default 4000",
+      argsHint: "[tokens]"
+    },
+    keys: { description: "show all keyboard shortcuts and prompt prefixes" },
+    plans: { description: "list this session's active + archived plans, newest first" },
+    replay: {
+      description: "load an archived plan as a read-only Time Travel snapshot (default: newest)",
+      argsHint: "[N]"
+    },
+    sessions: { description: "list saved sessions (current marked with \u25B8)" },
+    setup: { description: "reminds you to exit and run `reasonix setup`" },
+    semantic: {
+      description: "show semantic_search status \u2014 built? Ollama installed? how to enable"
+    },
+    clear: { description: "clear visible scrollback only (log/context kept)" },
+    new: { description: "start a fresh conversation (clear context + scrollback)" },
+    loop: {
+      description: "auto-resubmit <prompt> every <interval> until you type something / Esc / /loop stop",
+      argsHint: "<5s..6h> <prompt>  \xB7  stop  \xB7  (no args = status)"
+    },
+    exit: { description: "quit the TUI" },
+    init: {
+      description: "scan the project and synthesize a baseline REASONIX.md (model writes; review with /apply). `force` overwrites an existing file.",
+      argsHint: "[force]"
+    },
+    apply: {
+      description: "commit pending edit blocks to disk (no arg \u2192 all; `1`, `1,3`, or `1-4` \u2192 that subset, rest stay pending)",
+      argsHint: "[N|N,M|N-M]"
+    },
+    discard: {
+      description: "drop pending edit blocks without writing (no arg \u2192 all; indices \u2192 that subset)",
+      argsHint: "[N|N,M|N-M]"
+    },
+    walk: {
+      description: "step through pending edits one block at a time (git-add-p style: y/n per block, a apply rest, A flip AUTO)"
+    },
+    undo: { description: "roll back the last applied edit batch" },
+    history: { description: "list every edit batch this session (ids for /show, undone markers)" },
+    show: {
+      description: "dump a stored edit diff (omit id for newest non-undone)",
+      argsHint: "[id]"
+    },
+    commit: { description: "git add -A && git commit -m ...", argsHint: '"msg"' },
+    checkpoint: {
+      description: "snapshot every file the session has touched (Cursor-style internal store, not git). /checkpoint alone lists.",
+      argsHint: "[name|list|forget <id>]"
+    },
+    restore: {
+      description: "roll back files to a named checkpoint (see /checkpoint list)",
+      argsHint: "<name|id>"
+    },
+    plan: {
+      description: "toggle read-only plan mode (writes bounced until submit_plan + approval)",
+      argsHint: "[on|off]"
+    },
+    mode: {
+      description: "edit-gate: review (queue) \xB7 auto (apply+undo) \xB7 yolo (apply+auto-shell). Shift+Tab cycles.",
+      argsHint: "[review|auto|yolo]"
+    },
+    jobs: { description: "list background jobs started by run_background" },
+    kill: {
+      description: "stop a background job by id (SIGTERM \u2192 SIGKILL after grace)",
+      argsHint: "<id>"
+    },
+    logs: {
+      description: "tail a background job's output (default last 80 lines)",
+      argsHint: "<id> [lines]"
+    }
+  },
+  wizard: {
+    languageTitle: "Choose your language",
+    languageSubtitle: "Detected from your system locale. Switch later via /language.",
+    welcomeTitle: "Welcome to Reasonix.",
+    apiKeyPrompt: "Paste your DeepSeek API key to get started.",
+    apiKeyGetOne: "Get one at: https://platform.deepseek.com/api_keys",
+    apiKeySavedLocally: "Saved locally to {path}",
+    apiKeyInputLabel: "key \u203A ",
+    apiKeyInvalid: "Doesn't look like a DeepSeek key. They start with 'sk-' and are 30+ chars.",
+    apiKeyPreview: "preview: {redacted}",
+    presetTitle: "Pick a preset",
+    mcpTitle: "Which MCP servers should Reasonix wire up for you?",
+    mcpUserArgsHint: "(you'll provide {arg})",
+    mcpFooterMulti: "[\u2191\u2193] navigate  \xB7  [Space] toggle  \xB7  [Enter] confirm  \xB7  [Esc] cancel  \xB7  empty = skip",
+    mcpArgsTitle: "Configure {name}",
+    mcpArgsDirMissing: "Directory {path} doesn't exist.",
+    mcpArgsDirCreateHint: "[Y/Enter] create it (mkdir -p) \xB7 [N/Esc] enter a different path",
+    mcpArgsDirCreateFailed: "Couldn't create {path}: {message}",
+    mcpArgsRequiredParam: "Required parameter: ",
+    mcpArgsEmpty: "{name} needs a value \u2014 got an empty string.",
+    mcpArgsNotADir: "{path} exists but is not a directory.",
+    reviewTitle: "Ready to save",
+    reviewLabelApiKey: "API key",
+    reviewLabelLanguage: "Language",
+    reviewLabelPreset: "Preset",
+    reviewLabelMcp: "MCP",
+    reviewMcpNone: "(none)",
+    reviewMcpServers: "{count} server(s)",
+    reviewSavesTo: "Saves to {path}",
+    reviewSaveError: "Could not save config: {message}",
+    reviewFooter: "[Enter] save \xB7 [Esc] cancel",
+    savedTitle: "\u25B8 Saved.",
+    savedFooter: "[Enter] to exit",
+    selectFooter: "[\u2191\u2193] navigate \xB7 [Enter] confirm \xB7 [Esc] cancel",
+    stepCounter: "Step {step}/{total} \xB7 "
+  },
+  app: {
+    walkCancelledRemaining: "\u25B8 walk cancelled \u2014 {count} block(s) still pending.",
+    walkCancelled: "\u25B8 walk cancelled.",
+    editModeYolo: "\u25B8 edit mode: YOLO \u2014 edits AND shell commands auto-run. /undo still rolls back edits. Use carefully.",
+    editModeAuto: "\u25B8 edit mode: AUTO \u2014 edits apply immediately; press u within 5s to undo (space pauses the timer). Shell commands still ask.",
+    editModeReview: "\u25B8 edit mode: review \u2014 edits queue for /apply (or y) / /discard (or n)",
+    rejectedEdit: "\u25B8 rejected edit to {path}{context}",
+    autoApprovingRest: "\u25B8 auto-approving remaining edits for this turn",
+    flippedAutoSession: "\u25B8 flipped to AUTO mode for the rest of the session (persisted)",
+    flippedAutoWalk: "\u25B8 flipped to AUTO mode \u2014 future edits will apply immediately. Walk exited.",
+    dashboardStopped: "\u25B8 dashboard stopped.",
+    notedMemory: "\u25B8 noted ({scope}) \u2014 {verb} {path}",
+    notedScopeProject: "project",
+    notedScopeGlobal: "global",
+    notedVerbCreated: "created",
+    notedVerbAppended: "appended to",
+    memoryWriteFailed: "# memory write failed",
+    commandFailed: "! command failed",
+    restoreCodeOnly: "\u25B8 /restore is code-mode only",
+    hookUserPromptSubmit: "UserPromptSubmit hook",
+    hookStop: "Stop hook",
+    atMentions: "\u25B8 @mentions: {parts}",
+    atUrl: "\u25B8 @url: {parts}",
+    atUrlFailed: "@url expansion failed",
+    denied: "\u25B8 denied: {cmd}{context}",
+    alwaysAllowed: '\u25B8 always allowed "{prefix}" for {dir}',
+    runningCommand: "\u25B8 running: {cmd}",
+    startingBackground: "\u25B8 starting (background): {cmd}",
+    checkpointSaved: "\u26C1 checkpoint saved \xB7 {id} \xB7 {count} file{s} \xB7 /restore {id} to roll back this step",
+    continuingAfter: "\u25B8 continuing after {label}{counter}",
+    planStoppedAt: "\u25B8 plan stopped at {label}{counter}",
+    revisingAfter: "\u25B8 revising after {label} \u2014 {feedback}"
+  },
+  hooks: {
+    head: "hook {tag} `{cmd}` {decision}{truncTag}",
+    headWithDetail: "hook {tag} `{cmd}` {decision}{truncTag}: {detail}",
+    truncated: " (output truncated at 256KB)",
+    decisionBlock: "block",
+    decisionWarn: "warn",
+    decisionTimeout: "timeout",
+    decisionError: "error"
+  },
+  summary: {
+    status: "summarizing what was gathered\u2026",
+    hallucinatedFallback: "(model emitted fake tool-call markup instead of a prose summary \u2014 try /retry with a narrower question, or /think to inspect R1's reasoning)",
+    failedAfterReason: "{label} and the fallback summary call failed: {message}. Run /clear and retry with a narrower question, or raise --max-tool-iters."
+  },
+  loop: {
+    budgetExhausted: "session budget exhausted \u2014 spent ${spent} \u2265 cap ${cap}. Bump the cap with /budget <usd>, clear it with /budget off, or end the session.",
+    budget80Pct: "\u25B2 budget 80% used \u2014 ${spent} of ${cap}. Next turn or two likely trips the cap.",
+    proArmed: "\u21E7 /pro armed \u2014 this turn runs on deepseek-v4-pro (one-shot \xB7 disarms after turn)",
+    abortedAtIter: "aborted at iter {iter}/{cap} \u2014 stopped without producing a summary (press \u2191 + Enter or /retry to resume)",
+    toolUploadStatus: "tool result uploaded \xB7 model thinking before next response\u2026",
+    toolBudgetWarning: "{iter}/{cap} tool calls used \u2014 approaching budget. Press Esc to force a summary now.",
+    preflightFoldStatus: "preflight: context near full, attempting fold\u2026",
+    preflightFolded: "preflight: request ~{estimate}/{ctxMax} tokens ({pct}%) \u2014 folded {beforeMessages} messages \u2192 {afterMessages} (summary {summaryChars} chars). Sending.",
+    preflightNoFold: "preflight: request ~{estimate}/{ctxMax} tokens ({pct}%) and nothing left to fold \u2014 DeepSeek will likely 400. Run /clear or /new to start fresh.",
+    flashEscalation: "\u21E7 flash requested escalation \u2014 retrying this turn on {model}{reasonSuffix}",
+    harvestStatus: "extracting plan state from reasoning\u2026",
+    autoEscalation: "\u21E7 auto-escalating to {model} for the rest of this turn \u2014 flash hit {breakdown}. Next turn falls back to {fallback} unless /pro is armed.",
+    repeatToolCallWarning: "Caught a repeated tool call \u2014 let the model see the issue and retry with a different approach.",
+    stormStuck: "Stopped a stuck retry loop \u2014 the model kept calling the same tool with identical args after a self-correction nudge. Try /retry, rephrase, or rule out the underlying blocker.",
+    stormSuppressed: "Suppressed {count} repeated tool call(s) \u2014 same name + args fired 3+ times.",
+    compactingHistoryStatus: "compacting history{aggressiveTag}\u2026",
+    aggressiveTag: " (aggressive)",
+    foldedHistory: "context {before}/{ctxMax} ({pct}%) \u2014 folded {beforeMessages} messages \u2192 {afterMessages} (summary {summaryChars} chars). Continuing.",
+    aggressivelyFoldedHistory: "context {before}/{ctxMax} ({pct}%) \u2014 aggressively folded {beforeMessages} messages \u2192 {afterMessages} (summary {summaryChars} chars). Continuing.",
+    forcingSummary: "context {before}/{ctxMax} ({pct}%) \u2014 forcing summary from what was gathered. Run /compact, /clear, or /new to reset."
+  },
+  errors: {
+    contextOverflow: "Context overflow (DeepSeek 400): session history is {requested}, past the model's prompt limit (V4: 1M tokens; legacy chat/reasoner: 131k). Usually a single tool result grew too big. Reasonix caps new tool results at 8k tokens and auto-heals oversized history on session load \u2014 a restart often clears it. If it still overflows, run /forget (delete the session) or /clear (drop the displayed history) to start fresh.",
+    contextOverflowTooMany: "too many tokens",
+    auth401: "Authentication failed (DeepSeek 401): {inner}. Your API key is rejected. Fix with `reasonix setup` or `export DEEPSEEK_API_KEY=sk-...`. Get one at https://platform.deepseek.com/api_keys.",
+    balance402: "Out of balance (DeepSeek 402): {inner}. Top up at https://platform.deepseek.com/top_up \u2014 the panel header shows your balance once it's non-zero.",
+    badparam422: "Invalid parameter (DeepSeek 422): {inner}",
+    badrequest400: "Bad request (DeepSeek 400): {inner}",
+    deepseek5xxHead: "DeepSeek service unavailable ({status}) \u2014 this is a DeepSeek-side problem, not Reasonix. Already retried 4\xD7 with backoff.",
+    deepseek5xxReachable: " DeepSeek's main API answered our health check, but /chat/completions is failing \u2014 partial outage on their side.",
+    deepseek5xxUnreachable: " DeepSeek API is unreachable from your network \u2014 could be a wider DS outage or a local network issue.",
+    deepseek5xxActionNetwork: " Try: (1) check your network, (2) wait 30s and retry, (3) status page: https://status.deepseek.com.",
+    deepseek5xxActionRetry: " Try: (1) wait 30s and retry, (2) /preset to switch model, (3) status page: https://status.deepseek.com.",
+    innerNoMessage: "(no message)",
+    reasonAborted: "[aborted by user (Esc) \u2014 summarizing what I found so far]",
+    reasonContextGuard: "[context budget running low \u2014 summarizing before the next call would overflow]",
+    reasonStuck: "[stuck on a repeated tool call \u2014 explaining what was tried and what's blocking progress]",
+    reasonBudget: "[tool-call budget ({iterCap}) reached \u2014 forcing summary from what I found]",
+    labelAborted: "aborted by user",
+    labelContextGuard: "context-guard triggered (prompt > 80% of window)",
+    labelStuck: "stuck (repeated tool call suppressed by storm-breaker)",
+    labelBudget: "tool-call budget ({iterCap}) reached"
+  },
+  handlers: {
+    basic: {
+      newInfo: "\u25B8 new conversation \u2014 dropped {count} message(s) from context. Same session, fresh slate.",
+      helpTitle: "Commands:",
+      helpShellTitle: "Shell shortcut:",
+      helpShell: "  !<cmd>                   run <cmd> in the sandbox root; output goes into",
+      helpShellDetail: "                             the conversation so the model sees it next turn.",
+      helpShellConsent: "                             No allowlist gate \u2014 user-typed = explicit consent.",
+      helpShellExample: "                             Example: !git status   !ls src/   !npm test",
+      helpMemoryTitle: "Quick memory:",
+      helpMemoryPin: "  #<note>                  append <note> to <project>/REASONIX.md (committable).",
+      helpMemoryPinEx: "                             Example: #findByEmail must be case-insensitive",
+      helpMemoryGlobal: "  #g <note>                append <note> to ~/.reasonix/REASONIX.md (global, never committed).",
+      helpMemoryGlobalEx: "                             Example: #g always run pnpm not npm",
+      helpMemoryPinBoth: "                             Both pin into every future session's prefix. Faster than /memory.",
+      helpMemoryEscape: "                             Use `\\#text` to send a literal `#text` to the model.",
+      helpFileTitle: "File references (code mode):",
+      helpFile: "  @path/to/file            inline file content under [Referenced files] on send.",
+      helpFilePicker: "                             Type `@` to open the picker (\u2191\u2193 navigate, Tab/Enter pick).",
+      helpUrlTitle: "URL references:",
+      helpUrl: "  @https://example.com     fetch the URL, strip HTML, inline under [Referenced URLs].",
+      helpUrlCache: "                             Same URL twice in one session fetches once (in-mem cache).",
+      helpUrlPunct: "                             Trailing sentence punctuation (./,/)) is stripped automatically.",
+      helpPresetsTitle: "Presets (branch + harvest are NEVER auto-enabled \u2014 opt-in only):",
+      helpPresetAuto: "  auto   v4-flash \u2192 v4-pro on hard turns  \u2190 default \xB7 cheap when easy, smart when hard",
+      helpPresetFlash: "  flash  v4-flash always                  cheapest \xB7 predictable per-turn cost",
+      helpPresetPro: "  pro    v4-pro   always                  ~3\xD7 flash (5/31) \xB7 hard multi-turn work",
+      helpSessionsTitle: "Sessions (auto-enabled by default, named 'default'):",
+      helpSessionCustom: "  reasonix chat --session <name>   use a different named session",
+      helpSessionNone: "  reasonix chat --no-session       disable persistence for this run",
+      retryNone: "nothing to retry \u2014 no prior user message in this session's log.",
+      retryInfo: '\u25B8 retrying: "{preview}"',
+      loopTuiOnly: "/loop is only available in the interactive TUI (not in run/replay).",
+      loopStopped: "\u25B8 loop stopped.",
+      loopNoActive: "no active loop to stop.",
+      loopNoActiveHint: "no active loop. Start one with `/loop <interval> <prompt>` (e.g. /loop 30s npm test).\nCancels on: /loop stop \xB7 Esc \xB7 /clear /new \xB7 any user-typed prompt.",
+      loopStarted: '\u25B8 loop started \u2014 re-submitting "{prompt}" every {duration}. Type anything (or /loop stop) to cancel.'
+    },
+    admin: {
+      doctorNeedsTui: "/doctor needs a TUI context (postDoctor wired).",
+      doctorRunning: "\u2695 Doctor \u2014 running health checks\u2026",
+      hooksReloadUnavailable: "/hooks reload is not available in this context (no reload callback wired).",
+      hooksReloaded: "\u25B8 reloaded hooks \xB7 {count} active",
+      hooksUsage: "usage: /hooks            list active hooks\n       /hooks reload     re-read settings.json files",
+      hooksNone: "no hooks configured.",
+      hooksDropHint: "drop a settings.json with a `hooks` key into either of:",
+      hooksProject: "  \xB7 {path} (project)",
+      hooksProjectFallback: "  \xB7 <project>/.reasonix/settings.json (project)",
+      hooksGlobal: "  \xB7 {path} (global)",
+      hooksEvents: "events: PreToolUse, PostToolUse, UserPromptSubmit, Stop",
+      hooksExitCodes: "exit 0 = pass \xB7 exit 2 = block (Pre*) \xB7 other = warn",
+      hooksLoaded: "\u25B8 {count} hook(s) loaded",
+      hooksSources: "sources: project={project} \xB7 global={global}",
+      updateCurrent: "current: reasonix {version}",
+      updateLatestPending: "latest:  (not yet resolved \u2014 background check in flight or offline)",
+      updateRetryHint: "triggered a fresh registry fetch \u2014 retry `/update` in a few seconds,",
+      updateRetryHint2: "or run `reasonix update` in another terminal to force it synchronously.",
+      updateLatest: "latest:  reasonix {version}",
+      updateUpToDate: "you're on the latest. nothing to do.",
+      updateNpxHint: "you're running via npx \u2014 the next `npx reasonix ...` launch will auto-fetch.",
+      updateNpxForce: "to force a refresh sooner: `npm cache clean --force`.",
+      updateUpgradeHint: "to upgrade, exit this session and run:",
+      updateUpgradeCmd1: "  reasonix update           (interactive, dry-run supported via --dry-run)",
+      updateUpgradeCmd2: "  npm install -g reasonix@latest   (direct)",
+      updateInSessionDisabled: "in-session install is deliberately disabled \u2014 the npm spawn would",
+      updateInSessionDisabled2: "corrupt this TUI's rendering and Windows can lock the running binary.",
+      statsNoData: "no usage data yet.",
+      statsEveryTurn: "every turn you run here appends one record \u2014 this session's turns",
+      statsWillAppear: "will show up in the dashboard once you send a message."
+    },
+    edits: {
+      undoCodeOnly: "/undo is only available inside `reasonix code` \u2014 chat mode doesn't apply edits.",
+      historyCodeOnly: "/history is only available inside `reasonix code`.",
+      showCodeOnly: "/show is only available inside `reasonix code`.",
+      applyCodeOnly: "/apply is only available inside `reasonix code` (nothing to apply here).",
+      discardCodeOnly: "/discard is only available inside `reasonix code`.",
+      planCodeOnly: "/plan is only available inside `reasonix code` \u2014 chat mode doesn't gate tool writes.",
+      planOn: "\u25B8 plan mode ON \u2014 write tools are gated; the model MUST call `submit_plan` before anything executes. (The model can also call submit_plan on its own for big tasks even when plan mode is off \u2014 this toggle is the stronger, explicit constraint.) Type /plan off to leave.",
+      planOff: "\u25B8 plan mode OFF \u2014 write tools are live again. Model can still propose plans autonomously for large tasks.",
+      modeCodeOnly: "/mode is only available inside `reasonix code`.",
+      modeUsage: "usage: /mode <review|auto|yolo>   (Shift+Tab also cycles)",
+      modeYolo: "\u25B8 edit mode: YOLO \u2014 edits AND shell commands auto-run with no prompt. /undo still rolls back edits. Use carefully.",
+      modeAuto: "\u25B8 edit mode: AUTO \u2014 edits apply immediately; press u within 5s to undo, or /undo later. Shell commands still ask.",
+      modeReview: "\u25B8 edit mode: review \u2014 edits queue for /apply (or y) / /discard (or n)",
+      commitCodeOnly: "/commit is only available inside `reasonix code` (needs a rooted git repo).",
+      commitUsage: 'usage: /commit "your commit message"  \u2014 runs `git add -A && git commit -m "\u2026"` in {root}',
+      walkCodeOnly: "/walk is only available inside `reasonix code`.",
+      checkpointCodeOnly: "/checkpoint is only available inside `reasonix code` \u2014 chat mode doesn't apply edits.",
+      checkpointNone: "no checkpoints yet \u2014 `/checkpoint <name>` snapshots every file the session has touched. Restore later with `/restore <name>`.",
+      checkpointHeader: "\u25C8 checkpoints \xB7 {count} stored",
+      checkpointRestoreHint: "  /restore <name|id> \xB7 /checkpoint forget <id> \xB7 /checkpoint <name> to add",
+      checkpointForgetUsage: "usage: /checkpoint forget <id|name>",
+      checkpointNoMatch: '\u25B8 no checkpoint matching "{name}" \u2014 see /checkpoint list',
+      checkpointDeleted: "\u25B8 deleted checkpoint {id} ({name})",
+      checkpointDeleteFailed: "\u25B8 failed to delete {id} (already gone?)",
+      checkpointSaveUsage: "usage: /checkpoint <name>   (or /checkpoint list to see existing)",
+      checkpointSavedEmpty: `\u25B8 checkpoint "{name}" saved ({id}) \u2014 but no files have been touched yet, so it's an empty baseline. Edits made after this point will be revertable.`,
+      checkpointSaved: '\u25B8 checkpoint "{name}" saved ({id}) \u2014 {files} file{s}, {size} KB. Restore: /restore {name}',
+      restoreCodeOnly: "/restore is only available inside `reasonix code`.",
+      restoreUsage: "usage: /restore <name|id>   (see /checkpoint list for ids)",
+      restoreNoMatch: '\u25B8 no checkpoint matching "{target}" \u2014 try /checkpoint list',
+      restoreInfo: '\u25B8 restored "{name}" ({id}) from {when}',
+      restoreWrote: "  \xB7 wrote back {count} file{s}",
+      restoreRemoved: "  \xB7 removed {count} file{s} (didn't exist at checkpoint time)",
+      restoreSkipped: "  \u2717 {count} file{s} skipped:"
+    },
+    model: {
+      modelHint: "try deepseek-v4-flash or deepseek-v4-pro \u2014 run /models to fetch the live list",
+      modelUsage: "usage: /model <id>   ({hint})",
+      modelNotInCatalog: "model \u2192 {id}   (\u26A0 not in the fetched catalog: {list}. If this is wrong the next call will 400 \u2014 run /models to refresh.)",
+      modelSet: "model \u2192 {id}",
+      presetAuto: "preset \u2192 auto  (v4-flash \u2192 v4-pro on hard turns \xB7 default)",
+      presetFlash: "preset \u2192 flash  (v4-flash always \xB7 cheapest \xB7 /pro still bumps one turn)",
+      presetPro: "preset \u2192 pro  (v4-pro always \xB7 ~3\xD7 flash \xB7 for hard multi-turn work)",
+      presetUsage: "usage: /preset <auto|flash|pro>",
+      proNothingArmed: "nothing armed \u2014 /pro with no args will arm pro for your next turn",
+      proDisarmed: "\u25B8 /pro disarmed \u2014 next turn falls back to the current preset",
+      proUsage: "usage: /pro       arm pro for the next turn (one-shot, auto-disarms after)\n       /pro off  cancel armed state before the next turn",
+      proArmed: "\u25B8 /pro armed \u2014 your NEXT message runs on {model} regardless of preset. Auto-disarms after one turn. Use /preset max for a persistent switch.",
+      budgetNoCap: "no session budget set \u2014 Reasonix will keep going until you stop it. Set one with: /budget <usd>   (e.g. /budget 5)",
+      budgetStatus: "budget: ${spent} of ${cap} ({pct}%) \xB7 /budget off to clear, /budget <usd> to change",
+      budgetOff: "budget \u2192 off (no cap)",
+      budgetUsage: 'usage: /budget <usd>   (got "{arg}" \u2014 must be a positive number, e.g. /budget 5 or /budget 12.50)',
+      budgetExhausted: "\u25B2 budget \u2192 ${cap} but already spent ${spent}. Next turn will be refused \u2014 bump the cap higher to keep going, or end the session.",
+      budgetSet: "budget \u2192 ${cap}  (so far: ${spent} \xB7 warns at 80%, refuses next turn at 100% \xB7 /budget off to clear)"
+    },
+    permissions: {
+      mutateCodeOnly: "/permissions add / remove / clear are only available inside `reasonix code` \u2014 they edit the project-scoped allowlist (`~/.reasonix/config.json` projects[<root>].shellAllowed).",
+      addUsage: 'usage: /permissions add <prefix>   (multi-token OK: /permissions add "git push origin")',
+      addAlready: "\u25B8 already allowed: {prefix}",
+      addBuiltin: "\u25B8 `{prefix}` is already in the builtin allowlist \u2014 no per-project entry needed. (Builtin entries are always on.)",
+      addInfo: "\u25B8 added: {prefix}\n  \u2192 next `{prefix}` invocation runs without prompting in this project.",
+      removeUsage: "usage: /permissions remove <prefix-or-index>   (e.g. /permissions remove 3, or /permissions remove npm)",
+      removeEmpty: "\u25B8 no project allowlist entries to remove.",
+      removeIndexOob: "\u25B8 index out of range: {idx} (project list has {count} entries)",
+      removeNothing: "\u25B8 nothing to remove.",
+      removeBuiltin: "\u25B8 `{prefix}` is in the builtin allowlist (read-only). Builtin entries can't be removed at runtime \u2014 they're baked into the binary.",
+      removeInfo: "\u25B8 removed: {prefix}",
+      removeNotFound: "\u25B8 no such project entry: {prefix}   (try /permissions list to see what's stored)",
+      clearAlready: "\u25B8 project allowlist is already empty.",
+      clearConfirm: "about to drop {count} project allowlist entr{plural} for {root}. Re-run with the word 'confirm' to proceed: /permissions clear confirm",
+      clearedNone: "\u25B8 project allowlist was already empty \u2014 nothing changed.",
+      cleared: "\u25B8 cleared {count} project allowlist entr{plural}.",
+      usage: 'usage: /permissions [list]                   show current state\n       /permissions add <prefix>            persist (e.g. "npm run build")\n       /permissions remove <prefix-or-N>    drop one entry\n       /permissions clear confirm           wipe every project entry',
+      modeYolo: "\u25B8 edit mode: YOLO  \u2014 every shell command auto-runs, allowlist is bypassed. /mode review to re-enable prompts.",
+      modeAuto: "\u25B8 edit mode: auto  \u2014 edits auto-apply, shell still gated by allowlist (or ShellConfirm prompt for non-allowlisted).",
+      modeReview: "\u25B8 edit mode: review \u2014 both edits and non-allowlisted shell commands ask before running.",
+      projectHeader: "Project allowlist ({count}) \u2014 {root}",
+      projectNone1: '  (none \u2014 pick "always allow" on a ShellConfirm prompt to add one,',
+      projectNone2: "   or `/permissions add <prefix>` directly.)",
+      projectNoRoot: "Project allowlist \u2014 (no project root; chat mode shows builtin entries only)",
+      builtinHeader: "Builtin allowlist ({count}) \u2014 read-only, baked in",
+      subcommands: "Subcommands: /permissions add <prefix> \xB7 /permissions remove <prefix-or-N> \xB7 /permissions clear confirm"
+    },
+    dashboard: {
+      notAvailable: "/dashboard is not available in this context (no startDashboard callback wired).",
+      stopNoCallback: "/dashboard stop: no stop callback wired.",
+      notRunning: "\u25B8 dashboard is not running.",
+      stopping: "\u25B8 dashboard stopping\u2026",
+      alreadyRunning: "\u25B8 dashboard is already running:",
+      alreadyRunningHint: "Open it in any browser. Type `/dashboard stop` to tear it down.",
+      ready: "\u25B8 dashboard ready:",
+      readyHint: "127.0.0.1 only \xB7 token-gated. Type `/dashboard stop` to shut down.",
+      failed: "\u25B8 dashboard failed to start: {reason}",
+      starting: "\u25B8 starting dashboard server\u2026"
+    },
+    observability: {
+      contextInfo: "context: ~{total} of {max} ({pct}%) \xB7 system {sys} \xB7 tools {tools} \xB7 log {log}",
+      compactStarting: "\u25B8 folding older turns into a summary\u2026",
+      compactNoop: "\u25B8 nothing to fold \u2014 log already small or recent turns alone exceed the budget.",
+      compactDone: "\u25B8 folded {before} messages \u2192 {after} (summary {chars} chars). Continuing.",
+      compactFailed: "\u25B8 fold failed: {reason}",
+      costNoTurn: "no turn yet \u2014 `/cost` shows the most recent turn's token + spend breakdown.",
+      costNeedsTui: "/cost needs a TUI context (postUsage wired).",
+      costNoPricing: '\u25B8 /cost: no pricing table for model "{model}". Add one to telemetry/stats.ts.',
+      costEstimate: "\u25B8 /cost estimate \xB7 {model} \xB7 {prompt} prompt tokens (sys {sys} + tools {tools} + log {log} + msg {msg})",
+      costWorstCase: "  worst case (full miss): {input} input + ~{output} output ({avg} avg) \u2248 {total}",
+      costLikely: "  likely ({pct}% session cache hit): {input} input + ~{output} output \u2248 {total}",
+      costLikelyCold: "  likely: matches worst case until cache fills (no completed turns yet)",
+      statusModel: "  model   {model}",
+      statusFlags: "  flags   stream={stream} \xB7 effort={effort}",
+      statusCtx: "  ctx     {bar} {used}/{max} ({pct}%)",
+      statusCtxNone: "  ctx     no turns yet",
+      statusCost: "  cost    ${cost} \xB7 cache {bar} {pct}% \xB7 turns {turns}",
+      statusCostCold: "  cost    ${cost} \xB7 turns {turns} (cache warming up)",
+      statusBudget: "  budget  ${spent} / ${cap} ({pct}%){tag}",
+      statusSession: '  session "{name}" \xB7 {count} messages in log (resumed {resumed})',
+      statusSessionEphemeral: "  session (ephemeral \u2014 no persistence)",
+      statusWorkspace: "  workspace {path} \xB7 pinned at launch (relaunch with --dir <path> to switch)",
+      statusMcp: "  mcp     {servers} server(s), {tools} tool(s) in registry",
+      statusEdits: "  edits   {count} pending (/apply to commit, /discard to drop)",
+      statusPlan: "  plan    ON \u2014 writes gated (submit_plan + approval)",
+      statusModeYolo: "  mode    YOLO \u2014 edits + shell auto-run with no prompt (/undo still rolls back \xB7 Shift+Tab to flip)",
+      statusModeAuto: "  mode    AUTO \u2014 edits apply immediately (u to undo within 5s \xB7 Shift+Tab to flip)",
+      statusModeReview: "  mode    review \u2014 edits queue for /apply or y  (Shift+Tab to flip)",
+      statusDash: "  dash    {url} (open in browser \xB7 /dashboard stop)"
+    },
+    plans: {
+      noSession: "no session attached \u2014 `/plans` is per-session. Run `reasonix code` in a project to get a session.",
+      activePlan: "\u25B8 active plan{label} \u2014 {done}/{total} step{s} done \xB7 last touched {when}",
+      activeNone: "\u25B8 active plan: (none)",
+      noArchives: "no archived plans yet for this session \u2014 they auto-archive when every step is done",
+      archivedHeader: "Archived ({count}):",
+      replayNoSession: "no session attached \u2014 `/replay` is per-session. Run `reasonix code` in a project to get a session.",
+      replayNoArchives: "no archived plans yet for this session \u2014 `/replay` lights up once a plan completes (auto-archives when every step is done).",
+      replayInvalidIndex: "invalid index \u2014 `/replay` takes 1..{max} (newest = 1). Use `/plans` to see the list.",
+      archivedRow: "  \u2713 {when}  {total} step{s} \xB7 {completion}  {label}",
+      completionComplete: "complete",
+      stopAborted: "\u25B8 plan stopped \u2014 model aborted; type a follow-up to continue or start a new task."
+    },
+    jobs: {
+      codeOnly: "/jobs is only available inside `reasonix code`.",
+      killCodeOnly: "/kill is only available inside `reasonix code`.",
+      logsCodeOnly: "/logs is only available inside `reasonix code`.",
+      empty: "\u25C8 jobs \xB7 0 running \xB7 0 total\n  (run_background spawns one \u2014 dev servers, watchers, long-running scripts)",
+      header: "\u25C8 jobs \xB7 {running} running \xB7 {total} total",
+      footer: "  /logs <id> tail \xB7 /kill <id> SIGTERM \u2192 SIGKILL",
+      killUsage: "usage: /kill <id>   (see /jobs for ids)",
+      killNotFound: "job {id}: not found",
+      killAlreadyExited: "job {id} already exited ({code})",
+      killStopping: "\u25B8 stopping job {id} (tree kill: SIGTERM \u2192 SIGKILL after 2s grace; Windows: taskkill /T /F)",
+      killStatus: "\u25B8 job {id} {status}",
+      killStillAlive: "still alive after SIGKILL (!) \u2014 report this as a bug",
+      logsUsage: "usage: /logs <id> [lines]   (default last 80 lines)",
+      logsNotFound: "job {id}: not found",
+      logsStatus: "[job {id} \xB7 {status}]\n$ {command}",
+      logsRunning: "running \xB7 pid {pid}",
+      logsExited: "exited {code}",
+      logsFailed: "failed ({reason})",
+      logsStopped: "stopped"
+    },
+    memory: {
+      disabled: "memory is disabled (REASONIX_MEMORY=off in env). Unset the var to re-enable \u2014 no REASONIX.md or ~/.reasonix/memory content will be pinned in the meantime.",
+      noRoot: "no working directory on this session \u2014 `/memory` needs a root to resolve REASONIX.md from. (Running in a test harness?)",
+      listEmpty: "no user memories yet. The model can call `remember` to save one, or you can create files by hand in ~/.reasonix/memory/global/ or the per-project subdir.",
+      listHeader: "User memories ({count}):",
+      listFooter: "View body: /memory show <name>   Delete: /memory forget <name>",
+      showUsage: "usage: /memory show <name>  or  /memory show <scope>/<name>",
+      showNotFound: "no memory found: {target}",
+      showFailed: "show failed: {reason}",
+      forgetUsage: "usage: /memory forget <name>  or  /memory forget <scope>/<name>",
+      forgetNotFound: "no memory found: {target}",
+      forgetInfo: "\u25B8 forgot {scope}/{name}. Next /new or launch won't see it.",
+      forgetFailed: "could not forget {scope}/{name} (already gone?)",
+      forgetError: "forget failed: {reason}",
+      clearUsage: "usage: /memory clear <global|project> confirm",
+      clearConfirm: "about to delete every memory in scope={scope}. Re-run with the word 'confirm' to proceed: /memory clear {scope} confirm",
+      cleared: "\u25B8 cleared scope={scope} \u2014 deleted {count} memory file(s).",
+      noMemory: "no memory pinned in {root}.",
+      layers: "Three layers are available:",
+      layerProject: "  1. {file} \u2014 committable team memory (in the repo).",
+      layerGlobal: "  2. ~/.reasonix/memory/global/ \u2014 your cross-project private memory.",
+      layerProjectHash: "  3. ~/.reasonix/memory/<project-hash>/ \u2014 this project's private memory.",
+      askModel: "Ask the model to `remember` something, or hand-edit files directly.",
+      changesNote: "Changes take effect on next /new or launch \u2014 the system prompt is hashed once per session to keep the prefix cache warm.",
+      subcommands: "Subcommands: /memory list | /memory show <name> | /memory forget <name> | /memory clear <scope> confirm",
+      changesNoteShort: "Changes take effect on next /new or launch. Subcommands: /memory list | show | forget | clear"
+    },
+    mcp: {
+      noServers: 'no MCP servers attached. Run `reasonix setup` to pick some, or launch with --mcp "<spec>". `reasonix mcp list` shows the catalog.',
+      toolsLabel: "  tools     {count}",
+      resourcesHint: "`/resource` to browse+read",
+      promptsHint: "`/prompt` to browse+fetch",
+      awarenessOnly: "Chat mode consumes tools today; resources+prompts are surfaced here for awareness.",
+      catalogHint: "Full catalog: `reasonix mcp list` \xB7 deeper diagnosis: `reasonix mcp inspect <spec>`.",
+      fallbackServers: "MCP servers ({count}):",
+      fallbackTools: "Tools in registry ({count}):",
+      fallbackChange: "To change this set, exit and run `reasonix setup`.",
+      usageDisableEnable: "usage: /mcp {action} <name>  \xB7  pick a name shown in /mcp (anonymous servers can't be named-toggled).",
+      usageReconnect: "usage: /mcp reconnect <name>  \xB7  pick a name shown in /mcp.",
+      unknownServer: 'unknown MCP server "{name}". Known: {list}.',
+      noneList: "(none)",
+      reconnectNoTui: "/mcp reconnect requires the interactive TUI (postInfo not wired)."
+    },
+    init: {
+      codeOnly: "/init only works in code mode (it needs filesystem tools).\nRun `reasonix code [path]` to start a session rooted at the\nproject you want to initialize, then run /init.",
+      exists: "\u25B8 REASONIX.md already exists at {path}",
+      existsForce: "  /init force   regenerate from scratch (overwrites)",
+      existsEdit: "  Or edit it by hand \u2014 it's just markdown. The current file is",
+      existsPinned: "  pinned into the system prompt every launch as-is.",
+      info: "\u25B8 /init \u2014 model will scan the project and synthesize REASONIX.md.\n  The result lands as a pending edit; review with /apply or /walk."
+    },
+    webSearchEngine: {
+      currentEngine: "Current web search engine: {engine}",
+      endpoint: "SearXNG endpoint: {url}",
+      usageHeader: "Usage:",
+      usageMojeek: "  /search-engine mojeek            use Mojeek (default, no external deps)",
+      usageSearxng: "  /search-engine searxng            use SearXNG at default endpoint",
+      usageSearxngUrl: "  /search-engine searxng <url>      use SearXNG at custom endpoint",
+      alias: "Alias: /se",
+      searxngInfo: "SearXNG is a self-hosted metasearch engine (https://github.com/searxng/searxng).",
+      searxngInstall: "Install it with:  docker run -d -p 8080:8080 searxng/searxng",
+      switched: 'Switched web search engine to "{engine}".{note}',
+      switchedSearxngNote: " Make sure SearXNG is running at {endpoint}.",
+      confirmed: '\u2713 Web search engine set to "{engine}"{detail}. Next assistant turn will pick up the change.',
+      confirmedDetail: " ({endpoint})"
+    },
+    skill: {
+      listEmpty: "no skills found. Reasonix reads skills from:",
+      listProjectScope: "  \xB7 <project>/.reasonix/skills/<name>/SKILL.md  (or <name>.md)  \u2014 project scope",
+      listGlobalScope: "  \xB7 ~/.reasonix/skills/<name>/SKILL.md  (or <name>.md)  \u2014 global scope",
+      listProjectOnly: "  (project scope is only active in `reasonix code`)",
+      listFrontmatter: "Each file's frontmatter needs at least `name` and `description`.",
+      listInvoke: "Invoke a skill with `/skill <name> [args]` or by asking the model to call `run_skill`.",
+      listHeader: "User skills ({count}):",
+      listFooter: "View: /skill show <name>   Run: /skill <name> [args]   New: /skill new <name>",
+      listEmptyNewHint: "Scaffold one with: /skill new <name>  (project scope) \u2014 there's no remote registry yet; you author skills directly.",
+      showUsage: "usage: /skill show <name>",
+      showNotFound: "no skill found: {name}",
+      runNotFound: "no skill found: {name}  (try /skill list)",
+      runInfo: "\u25B8 running skill: {name}{args}",
+      newUsage: "usage: /skill new <name> [--global]",
+      newCreated: "\u25B8 created skill: {name}\n  {path}\n  edit it, then `/skill {name}` to invoke",
+      newError: "\u25B2 /skill new failed: {reason}"
+    }
+  }
+};
+
+// src/i18n/zh-CN.ts
+var zhCN = {
+  common: {
+    error: "\u9519\u8BEF",
+    warning: "\u8B66\u544A",
+    loading: "\u52A0\u8F7D\u4E2D...",
+    done: "\u5B8C\u6210",
+    cancel: "\u53D6\u6D88",
+    confirm: "\u786E\u8BA4",
+    back: "\u8FD4\u56DE",
+    next: "\u4E0B\u4E00\u6B65"
+  },
+  cli: {
+    description: "DeepSeek \u539F\u751F\u667A\u80FD\u4F53\u6846\u67B6 \u2014 \u4E13\u4E3A\u7F13\u5B58\u547D\u4E2D\u548C\u4F4E\u6210\u672C\u4EE4\u724C\u6784\u5EFA\u3002",
+    continue: "\u6062\u590D\u6700\u8FD1\u4F7F\u7528\u7684\u804A\u5929\u4F1A\u8BDD\uFF0C\u4E0D\u663E\u793A\u9009\u62E9\u5668\u3002",
+    setup: "\u4EA4\u4E92\u5F0F\u5411\u5BFC \u2014 API \u5BC6\u94A5\u3001\u9884\u8BBE\u3001MCP \u670D\u52A1\u5668\u3002\u968F\u65F6\u91CD\u65B0\u8FD0\u884C\u4EE5\u91CD\u65B0\u914D\u7F6E\u3002",
+    code: "\u4EE3\u7801\u7F16\u8F91\u804A\u5929 \u2014 \u4EE5 <dir>\uFF08\u9ED8\u8BA4\uFF1Acwd\uFF09\u4E3A\u6839\u7684\u6587\u4EF6\u7CFB\u7EDF\u5DE5\u5177\uFF0C\u7F16\u7801\u7CFB\u7EDF\u63D0\u793A\u8BCD\uFF0Cv4-flash \u57FA\u7EBF\u3002",
+    chat: "\u5177\u6709\u5B9E\u65F6\u7F13\u5B58/\u6210\u672C\u9762\u677F\u7684\u4EA4\u4E92\u5F0F Ink TUI\u3002",
+    run: "\u4EE5\u975E\u4EA4\u4E92\u65B9\u5F0F\u8FD0\u884C\u5355\u4E2A\u4EFB\u52A1\uFF0C\u6D41\u5F0F\u8F93\u51FA\u3002",
+    stats: "\u663E\u793A\u4F7F\u7528\u60C5\u51B5\u4EEA\u8868\u677F\u3002",
+    doctor: "\u4E00\u952E\u5065\u5EB7\u68C0\u67E5\u3002",
+    commit: "\u4ECE\u6682\u5B58\u7684\u5DEE\u5F02\u4E2D\u8D77\u8349\u63D0\u4EA4\u6D88\u606F\u3002",
+    sessions: "\u5217\u51FA\u4FDD\u5B58\u7684\u804A\u5929\u4F1A\u8BDD\uFF0C\u6216\u6309\u540D\u79F0\u68C0\u67E5\u3002",
+    pruneSessions: "\u5220\u9664\u7A7A\u95F2 \u2265N \u5929\u7684\u5DF2\u4FDD\u5B58\u4F1A\u8BDD\uFF08\u9ED8\u8BA4 90\uFF09\u3002\u4F7F\u7528 --dry-run \u9884\u89C8\u3002",
+    events: "\u7F8E\u5316\u6253\u5370\u5185\u6838\u4E8B\u4EF6\u65E5\u5FD7\u4FA7\u8FB9\u6587\u4EF6\u3002",
+    replay: "\u4EA4\u4E92\u5F0F Ink TUI\uFF0C\u7528\u4E8E\u6D4F\u89C8\u8F6C\u5F55\u7A3F\u3002",
+    diff: "\u5728\u5206\u680F Ink TUI \u4E2D\u6BD4\u8F83\u4E24\u4E2A\u8F6C\u5F55\u7A3F\u3002",
+    mcp: "\u6A21\u578B\u4E0A\u4E0B\u6587\u534F\u8BAE (MCP) \u52A9\u624B \u2014 \u53D1\u73B0\u670D\u52A1\u5668\uFF0C\u6D4B\u8BD5\u60A8\u7684\u8BBE\u7F6E\u3002",
+    version: "\u6253\u5370 Reasonix \u7248\u672C\u3002",
+    update: "\u68C0\u67E5\u8F83\u65B0\u7248\u672C\u7684 Reasonix \u5E76\u5B89\u88C5\u3002",
+    index: "\u6784\u5EFA\uFF08\u6216\u589E\u91CF\u5237\u65B0\uFF09\u672C\u5730\u8BED\u4E49\u641C\u7D22\u7D22\u5F15\u3002"
+  },
+  ui: {
+    welcome: "\u968F\u65F6\u8FD0\u884C `reasonix` \u5F00\u59CB\u804A\u5929 \u2014 \u60A8\u7684\u8BBE\u7F6E\u5C06\u88AB\u8BB0\u4F4F\u3002",
+    taglineChat: "DeepSeek \u539F\u751F\u667A\u80FD\u4F53",
+    taglineCode: "DeepSeek \u539F\u751F\u4EE3\u7801\u667A\u80FD\u4F53",
+    taglineSub: "\u7F13\u5B58\u4F18\u5148 \xB7 Flash \u4F18\u5148",
+    startSessionHint: "\u8F93\u5165\u6D88\u606F\u4EE5\u5F00\u59CB\u60A8\u7684\u4F1A\u8BDD",
+    inputPlaceholder: "\u8F93\u5165\u4EFB\u4F55\u5185\u5BB9... (\u8F93\u5165 / \u4F7F\u7528\u547D\u4EE4, @ \u5F15\u7528\u6587\u4EF6)",
+    busy: "\u601D\u8003\u4E2D...",
+    thinking: "\u25B8 \u601D\u8003\u4E2D...",
+    undo: "\u64A4\u6D88",
+    undoHint: "\u5728 5 \u79D2\u5185\u6309 u \u64A4\u6D88",
+    applied: "\u5DF2\u5E94\u7528",
+    rejected: "\u5DF2\u62D2\u7EDD",
+    noDashboard: "\u7981\u6B62\u81EA\u52A8\u542F\u52A8\u5D4C\u5165\u5F0F Web \u4EEA\u8868\u677F\u3002",
+    dashboardAutoStartFailed: "\u25B2 \u4EEA\u8868\u677F\u81EA\u52A8\u542F\u52A8\u5931\u8D25 ({reason}) \u2014 \u5C1D\u8BD5 /dashboard\uFF0C\u6216\u4F20\u9012 --no-dashboard \u4EE5\u9759\u9ED8",
+    systemAppendHint: "\u8FFD\u52A0\u6307\u4EE4\u5230\u4EE3\u7801\u7CFB\u7EDF\u63D0\u793A\u8BCD\u3002\u4E0D\u66FF\u6362\u9ED8\u8BA4\u63D0\u793A\u8BCD \u2014 \u5728\u5176\u540E\u6DFB\u52A0\u3002",
+    systemAppendFileHint: "\u8FFD\u52A0\u6587\u4EF6\u5185\u5BB9\u5230\u4EE3\u7801\u7CFB\u7EDF\u63D0\u793A\u8BCD\u3002\u4E0D\u66FF\u6362\u9ED8\u8BA4\u63D0\u793A\u8BCD\u3002UTF-8\uFF0C\u76F8\u5BF9\u4E8E cwd \u6216\u7EDD\u5BF9\u8DEF\u5F84\u3002",
+    resumedSession: '\u25B8 \u5DF2\u6062\u590D\u4F1A\u8BDD "{name}"\uFF0C\u5305\u542B {count} \u6761\u5386\u53F2\u6D88\u606F \xB7 /forget \u91CD\u65B0\u5F00\u59CB \xB7 /sessions \u5217\u51FA',
+    newSession: '\u25B8 \u4F1A\u8BDD "{name}" (\u65B0) \u2014 \u968F\u804A\u968F\u5B58 \xB7 /forget \u5220\u9664 \xB7 /sessions \u5217\u51FA',
+    ephemeralSession: "\u25B8 \u4E34\u65F6\u804A\u5929 (\u4E0D\u4FDD\u5B58\u4F1A\u8BDD) \u2014 \u53BB\u6389 --no-session \u4EE5\u542F\u7528\u4FDD\u5B58",
+    restoredEdits: "\u25B8 \u4ECE\u4E2D\u65AD\u7684\u8FD0\u884C\u4E2D\u6062\u590D\u4E86 {count} \u4E2A\u5F85\u5904\u7406\u7684\u7F16\u8F91\u5757 \u2014 /apply \u63D0\u4EA4\u6216 /discard \u653E\u5F03\u3002",
+    resumedPlan: "\u5DF2\u6062\u590D\u8BA1\u5212 \xB7 {when}{summary}",
+    tipEditBindings: "\u25B8 \u63D0\u793A\uFF1A\u7F16\u8F91\u95E8\u63A7\u5FEB\u6377\u952E\n    y / n       \u63A5\u53D7\u6216\u653E\u5F03\u5F85\u5904\u7406\u7684\u7F16\u8F91\n    Shift+Tab   \u5207\u6362 \u9884\u89C8 \u2194 \u81EA\u52A8 (\u6301\u4E45\u5316\uFF1B\u81EA\u52A8\u6A21\u5F0F\u7ACB\u5373\u5E94\u7528)\n    u           \u64A4\u6D88\u4E0A\u6B21\u81EA\u52A8\u5E94\u7528\u7684\u6279\u5904\u7406 (\u5728 5 \u79D2\u6A2A\u5E45\u5185)\n  \u5F53\u524D\u6A21\u5F0F\u663E\u793A\u5728\u5E95\u90E8\u72B6\u6001\u680F\u3002\u968F\u65F6\u8FD0\u884C /keys \u67E5\u770B\u5B8C\u6574\u5217\u8868\u3002\n  (\u6B64\u63D0\u793A\u4EC5\u663E\u793A\u4E00\u6B21 \u2014 \u4E4B\u540E\u5C06\u9690\u85CF\u3002)",
+    modelOverride: "\u8986\u76D6\u9ED8\u8BA4\u6A21\u578B",
+    noSession: "\u7981\u7528\u672C\u6B21\u8FD0\u884C\u7684\u4F1A\u8BDD\u6301\u4E45\u5316",
+    resumeHint: "\u5F3A\u5236\u6062\u590D\u6307\u5B9A\u4F1A\u8BDD\uFF08\u5373\u4F7F\u7A7A\u95F2\uFF09",
+    newHint: "\u5F3A\u5236\u521B\u5EFA\u65B0\u4F1A\u8BDD\uFF08\u5FFD\u7565 --session / --continue\uFF09",
+    transcriptHint: "JSONL \u8F6C\u5F55\u7A3F\u7684\u5199\u5165\u8DEF\u5F84",
+    budgetHint: "\u4F1A\u8BDD\u7F8E\u5143\u4E0A\u9650 \u2014 80% \u65F6\u8B66\u544A\uFF0C100% \u65F6\u62D2\u7EDD\u4E0B\u4E00\u8F6E",
+    modelIdHint: "DeepSeek \u6A21\u578B ID\uFF08\u4F8B\u5982 deepseek-v4-flash\uFF09",
+    systemPromptHint: "\u8986\u76D6\u9ED8\u8BA4\u7CFB\u7EDF\u63D0\u793A\u8BCD",
+    presetHint: "\u6A21\u578B\u7EC4\u5408 \u2014 auto|flash|pro",
+    sessionNameHint: "\u4F1A\u8BDD\u540D\u79F0\uFF08\u9ED8\u8BA4\uFF1A'default'\uFF09",
+    ephemeralHint: "\u7981\u7528\u672C\u6B21\u8FD0\u884C\u7684\u4F1A\u8BDD\u6301\u4E45\u5316",
+    mcpSpecHint: "MCP \u670D\u52A1\u5668\u89C4\u683C\uFF08\u53EF\u91CD\u590D\uFF09",
+    mcpPrefixHint: "\u7528\u6B64\u5B57\u7B26\u4E32\u4E3A MCP \u5DE5\u5177\u540D\u6DFB\u52A0\u524D\u7F00",
+    noConfigHint: "\u672C\u6B21\u8FD0\u884C\u5FFD\u7565 ~/.reasonix/config.json",
+    presetHintShort: "\u6A21\u578B\u7EC4\u5408 \u2014 auto|flash|pro",
+    budgetHintShort: "\u4F1A\u8BDD\u7F8E\u5143\u4E0A\u9650",
+    transcriptHintShort: "JSONL \u8F6C\u5F55\u7A3F\u8DEF\u5F84",
+    mcpSpecHintShort: "MCP \u670D\u52A1\u5668\u89C4\u683C\uFF08\u53EF\u91CD\u590D\uFF09",
+    mcpPrefixHintShort: "MCP \u5DE5\u5177\u540D\u524D\u7F00",
+    dryRunHint: "\u663E\u793A\u5C06\u8981\u5B89\u88C5\u7684\u5185\u5BB9\u4F46\u4E0D\u5B9E\u9645\u5B89\u88C5",
+    rebuildHint: "\u4ECE\u5934\u91CD\u5EFA\u7D22\u5F15",
+    embedModelHint: "\u5D4C\u5165\u6A21\u578B\u540D\u79F0",
+    projectDirHint: "\u9879\u76EE\u6839\u76EE\u5F55",
+    ollamaUrlHint: "Ollama \u670D\u52A1\u5668 URL",
+    skipPromptsHint: "\u8DF3\u8FC7\u786E\u8BA4\u63D0\u793A",
+    verboseHint: "\u663E\u793A\u5B8C\u6574\u7684\u4F1A\u8BDD\u5143\u6570\u636E",
+    pruneDaysHint: "\u5220\u9664\u7A7A\u95F2\u6B64\u5929\u6570\u6216\u66F4\u591A\u7684\u4F1A\u8BDD\uFF08\u9ED8\u8BA4 90\uFF09",
+    pruneDryRunHint: "\u5217\u51FA\u5C06\u8981\u5220\u9664\u7684\u5185\u5BB9\u4F46\u4E0D\u5B9E\u9645\u5220\u9664",
+    eventTypeHint: "\u6309\u4E8B\u4EF6\u7C7B\u578B\u8FC7\u6EE4",
+    eventSinceHint: "\u4ECE\u6B64\u4E8B\u4EF6 ID \u5F00\u59CB",
+    eventTailHint: "\u4EC5\u663E\u793A\u6700\u540E N \u4E2A\u4E8B\u4EF6",
+    jsonHint: "\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA",
+    projectionHint: "\u663E\u793A\u6BCF\u4E2A\u4E8B\u4EF6\u7684\u6295\u5F71\u72B6\u6001",
+    printHint: "\u6253\u5370\u5230\u6807\u51C6\u8F93\u51FA\u800C\u975E TUI",
+    headHint: "\u4EC5\u663E\u793A\u524D N \u4E2A\u4E8B\u4EF6",
+    tailHint: "\u4EC5\u663E\u793A\u6700\u540E N \u4E2A\u4E8B\u4EF6",
+    mdReportHint: "\u5C06 markdown \u5DEE\u5F02\u62A5\u544A\u5199\u5165\u6B64\u8DEF\u5F84",
+    printHintTable: "\u6253\u5370\u8868\u683C\u5230\u6807\u51C6\u8F93\u51FA",
+    tuiHint: "\u6253\u5F00\u4EA4\u4E92\u5F0F TUI",
+    labelAHint: "\u5DE6\u4FA7\u9762\u677F\u7684\u6807\u7B7E",
+    labelBHint: "\u53F3\u4FA7\u9762\u677F\u7684\u6807\u7B7E",
+    mcpListDescription: "\u6D4F\u89C8 MCP \u6CE8\u518C\u8868\uFF08\u5B98\u65B9 \u2192 smithery \u2192 \u672C\u5730 fallback\uFF09",
+    mcpInspectDescription: "\u68C0\u67E5 MCP \u670D\u52A1\u5668\u89C4\u683C\uFF08\u5DE5\u5177\u3001\u8D44\u6E90\u3001\u63D0\u793A\uFF09",
+    mcpSearchDescription: "\u5728 MCP \u6CE8\u518C\u8868\u4E2D\u641C\u7D22\u5339\u914D\u7684\u670D\u52A1\u5668",
+    mcpInstallDescription: "\u6309\u540D\u79F0\u5B89\u88C5 MCP \u670D\u52A1\u5668\uFF08\u5C06\u5176\u89C4\u683C\u5199\u5165\u914D\u7F6E\uFF09",
+    mcpBrowseDescription: "\u4EA4\u4E92\u5F0F\u5E02\u573A\u6D4F\u89C8\u5668 \u2014 \u8F93\u5165\u8FC7\u6EE4\u3001\u56DE\u8F66\u5B89\u88C5",
+    mcpLocalHint: "\u53EA\u663E\u793A\u5185\u7F6E\u7684\u79BB\u7EBF\u76EE\u5F55",
+    mcpRefreshHint: "\u5FFD\u7565 24 \u5C0F\u65F6\u7F13\u5B58\uFF0C\u5F3A\u5236\u5237\u65B0",
+    mcpLimitHint: "\u6700\u591A\u663E\u793A\u591A\u5C11\u6761",
+    mcpPagesHint: "\u4E00\u6B21\u6027\u9884\u52A0\u8F7D\u591A\u5C11\u9875\uFF08\u9ED8\u8BA4 1\uFF09",
+    mcpAllHint: "\u52A0\u8F7D\u5168\u90E8\u9875\uFF08\u9996\u6B21\u8F83\u6162\uFF09",
+    mcpMaxPagesHint: "\u641C\u7D22\u65F6\u6700\u591A\u8D70\u591A\u5C11\u9875\uFF08\u9ED8\u8BA4 20\uFF09",
+    jsonHintCatalog: "\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA",
+    jsonHintReport: "\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA\u68C0\u67E5\u62A5\u544A",
+    modelOverrideFlash: "\u8986\u76D6\u6A21\u578B\uFF08\u9ED8\u8BA4\uFF1Adeepseek-v4-flash\uFF09",
+    skipConfirmHint: "\u8DF3\u8FC7\u786E\u8BA4\u63D0\u793A"
+  },
+  slash: {
+    help: { description: "\u663E\u793A\u5B8C\u6574\u547D\u4EE4\u53C2\u8003" },
+    status: { description: "\u5F53\u524D\u6A21\u578B\u3001\u6807\u5FD7\u3001\u4E0A\u4E0B\u6587\u3001\u4F1A\u8BDD" },
+    preset: {
+      description: "\u6A21\u578B\u7EC4\u5408 \u2014 \u81EA\u52A8\u5728 flash \u2192 pro \u4E4B\u95F4\u5207\u6362\uFF0C\u6216\u9501\u5B9A flash/pro",
+      argsHint: "<auto|flash|pro>"
+    },
+    model: { description: "\u5207\u6362 DeepSeek \u6A21\u578B ID", argsHint: "<id>" },
+    models: { description: "\u5217\u51FA\u4ECE DeepSeek /models \u83B7\u53D6\u7684\u53EF\u7528\u6A21\u578B" },
+    language: {
+      description: "\u5207\u6362\u8FD0\u884C\u65F6\u8BED\u8A00",
+      argsHint: "<en|zh-CN>",
+      success: "\u8BED\u8A00\u5DF2\u5207\u6362\u4E3A\u7B80\u4F53\u4E2D\u6587\u3002",
+      unsupported: "\u4E0D\u652F\u6301\u7684\u8BED\u8A00\u4EE3\u7801\uFF1A{code}\u3002\u652F\u6301\u7684\u8BED\u8A00\uFF1A{supported}\u3002"
+    },
+    pro: {
+      description: "\u4EC5\u4E3A\u4E0B\u4E00\u8F6E\u542F\u7528 v4-pro\uFF08\u4E00\u6B21\u6027 \xB7 \u81EA\u52A8\u89E3\u9664\uFF09",
+      argsHint: "[off]"
+    },
+    budget: {
+      description: "\u4F1A\u8BDD\u7F8E\u5143\u4E0A\u9650 \u2014 80% \u65F6\u8B66\u544A\uFF0C100% \u65F6\u62D2\u7EDD\u4E0B\u4E00\u8F6E\u3002\u9ED8\u8BA4\u5173\u95ED\u3002\u5355\u72EC /budget \u663E\u793A\u72B6\u6001",
+      argsHint: "[usd|off]"
+    },
+    mcp: { description: "\u5217\u51FA\u9644\u52A0\u5230\u6B64\u4F1A\u8BDD\u7684 MCP \u670D\u52A1\u5668 + \u5DE5\u5177" },
+    resource: {
+      description: "\u6D4F\u89C8 + \u8BFB\u53D6 MCP \u8D44\u6E90\uFF08\u65E0\u53C2\u6570 \u2192 \u5217\u51FA URI\uFF1B<uri> \u2192 \u83B7\u53D6\u5185\u5BB9\uFF09",
+      argsHint: "[uri]"
+    },
+    prompt: {
+      description: "\u6D4F\u89C8 + \u83B7\u53D6 MCP \u63D0\u793A\uFF08\u65E0\u53C2\u6570 \u2192 \u5217\u51FA\u540D\u79F0\uFF1B<name> \u2192 \u6E32\u67D3\u63D0\u793A\uFF09",
+      argsHint: "[name]"
+    },
+    memory: {
+      description: "\u663E\u793A / \u7BA1\u7406\u56FA\u5B9A\u8BB0\u5FC6\uFF08REASONIX.md + ~/.reasonix/memory\uFF09",
+      argsHint: "[list|show <name>|forget <name>|clear <scope> confirm]"
+    },
+    skill: {
+      description: "\u5217\u51FA / \u8FD0\u884C\u7528\u6237\u6280\u80FD\uFF08<project>/.reasonix/skills + ~/.reasonix/skills\uFF09",
+      argsHint: "[list|show <name>|<name> [args]]"
+    },
+    hooks: {
+      description: "\u5217\u51FA\u6D3B\u8DC3\u7684 hooks\uFF08.reasonix/ \u4E0B\u7684 settings.json\uFF09\xB7 reload \u4ECE\u78C1\u76D8\u91CD\u65B0\u8BFB\u53D6",
+      argsHint: "[reload]"
+    },
+    permissions: {
+      description: "\u663E\u793A / \u7F16\u8F91 shell \u5141\u8BB8\u5217\u8868\uFF08\u5185\u7F6E\u53EA\u8BFB \xB7 \u9879\u76EE\u7EA7\uFF1A~/.reasonix/config.json\uFF09",
+      argsHint: "[list|add <prefix>|remove <prefix|N>|clear confirm]"
+    },
+    dashboard: {
+      description: "\u542F\u52A8\u5D4C\u5165\u5F0F Web \u4EEA\u8868\u677F\uFF08127.0.0.1\uFF0Ctoken \u4FDD\u62A4\uFF09",
+      argsHint: "[stop]"
+    },
+    update: { description: "\u663E\u793A\u5F53\u524D\u7248\u672C\u4E0E\u6700\u65B0\u7248\u672C\u53CA\u5347\u7EA7\u547D\u4EE4" },
+    stats: {
+      description: "\u8DE8\u4F1A\u8BDD\u6210\u672C\u4EEA\u8868\u677F\uFF08\u4ECA\u65E5 / \u672C\u5468 / \u672C\u6708 / \u5168\u90E8 \xB7 \u7F13\u5B58\u547D\u4E2D \xB7 \u4E0E Claude \u5BF9\u6BD4\uFF09"
+    },
+    cost: {
+      description: "\u7A7A \u2192 \u4E0A\u4E00\u8F6E\u82B1\u8D39\uFF08\u4F7F\u7528\u5361\u7247\uFF09\uFF1B\u5E26\u6587\u672C \u2192 \u4F30\u7B97\u53D1\u9001\u6210\u672C\uFF08\u6700\u574F\u60C5\u51B5 + \u53EF\u80FD\u7F13\u5B58\u547D\u4E2D\uFF09",
+      argsHint: "[text]"
+    },
+    doctor: {
+      description: "\u5065\u5EB7\u68C0\u67E5\uFF08api / config / api-reach / index / hooks / project\uFF09"
+    },
+    context: { description: "\u663E\u793A\u4E0A\u4E0B\u6587\u7A97\u53E3\u5206\u89E3\uFF08\u7CFB\u7EDF / \u5DE5\u5177 / \u65E5\u5FD7 / \u8F93\u5165\uFF09" },
+    retry: { description: "\u622A\u65AD\u5E76\u91CD\u53D1\u60A8\u7684\u6700\u540E\u4E00\u6761\u6D88\u606F\uFF08\u91CD\u65B0\u91C7\u6837\uFF09" },
+    compact: {
+      description: "\u7F29\u5C0F\u65E5\u5FD7\u4E2D\u8FC7\u5927\u7684\u5DE5\u5177\u7ED3\u679C\u548C\u5DE5\u5177\u8C03\u7528\u53C2\u6570\uFF1B\u4E0A\u9650\u4E3A tokens\uFF0C\u9ED8\u8BA4 4000",
+      argsHint: "[tokens]"
+    },
+    keys: { description: "\u663E\u793A\u6240\u6709\u952E\u76D8\u5FEB\u6377\u952E\u548C\u63D0\u793A\u524D\u7F00" },
+    plans: { description: "\u5217\u51FA\u6B64\u4F1A\u8BDD\u7684\u6D3B\u8DC3 + \u5F52\u6863\u8BA1\u5212\uFF08\u6700\u65B0\u5728\u524D\uFF09" },
+    replay: {
+      description: "\u52A0\u8F7D\u5F52\u6863\u8BA1\u5212\u4E3A\u53EA\u8BFB\u7684\u65F6\u95F4\u65C5\u884C\u5FEB\u7167\uFF08\u9ED8\u8BA4\uFF1A\u6700\u65B0\uFF09",
+      argsHint: "[N]"
+    },
+    sessions: { description: "\u5217\u51FA\u5DF2\u4FDD\u5B58\u7684\u4F1A\u8BDD\uFF08\u5F53\u524D\u6807\u8BB0\u4E3A \u25B8\uFF09" },
+    setup: { description: "\u63D0\u9192\u60A8\u9000\u51FA\u5E76\u8FD0\u884C `reasonix setup`" },
+    semantic: {
+      description: "\u663E\u793A semantic_search \u72B6\u6001 \u2014 \u5DF2\u6784\u5EFA\uFF1FOllama \u5DF2\u5B89\u88C5\uFF1F\u5982\u4F55\u542F\u7528"
+    },
+    clear: { description: "\u4EC5\u6E05\u9664\u53EF\u89C1\u7684\u6EDA\u52A8\u56DE\u653E\uFF08\u65E5\u5FD7/\u4E0A\u4E0B\u6587\u4FDD\u7559\uFF09" },
+    new: { description: "\u5F00\u59CB\u5168\u65B0\u5BF9\u8BDD\uFF08\u6E05\u9664\u4E0A\u4E0B\u6587 + \u6EDA\u52A8\u56DE\u653E\uFF09" },
+    loop: {
+      description: "\u6BCF <interval> \u81EA\u52A8\u91CD\u65B0\u63D0\u4EA4 <prompt>\uFF0C\u76F4\u5230\u60A8\u8F93\u5165 / Esc / /loop stop",
+      argsHint: "<5s..6h> <prompt>  \xB7  stop  \xB7  \uFF08\u65E0\u53C2\u6570 = \u72B6\u6001\uFF09"
+    },
+    exit: { description: "\u9000\u51FA TUI" },
+    init: {
+      description: "\u626B\u63CF\u9879\u76EE\u5E76\u5408\u6210\u57FA\u7EBF REASONIX.md\uFF08\u6A21\u578B\u5199\u5165\uFF1B\u4F7F\u7528 /apply \u5BA1\u67E5\uFF09\u3002`force` \u8986\u76D6\u5DF2\u6709\u6587\u4EF6\u3002",
+      argsHint: "[force]"
+    },
+    apply: {
+      description: "\u5C06\u5F85\u5904\u7406\u7684\u7F16\u8F91\u5757\u63D0\u4EA4\u5230\u78C1\u76D8\uFF08\u65E0\u53C2\u6570 \u2192 \u5168\u90E8\uFF1B`1`\u3001`1,3` \u6216 `1-4` \u2192 \u8BE5\u5B50\u96C6\uFF0C\u5176\u4F59\u4FDD\u6301\u5F85\u5904\u7406\uFF09",
+      argsHint: "[N|N,M|N-M]"
+    },
+    discard: {
+      description: "\u4E22\u5F03\u5F85\u5904\u7406\u7684\u7F16\u8F91\u5757\u800C\u4E0D\u5199\u5165\uFF08\u65E0\u53C2\u6570 \u2192 \u5168\u90E8\uFF1B\u7D22\u5F15 \u2192 \u8BE5\u5B50\u96C6\uFF09",
+      argsHint: "[N|N,M|N-M]"
+    },
+    walk: {
+      description: "\u9010\u5757\u9010\u6B65\u5904\u7406\u5F85\u5904\u7406\u7684\u7F16\u8F91\uFF08git-add-p \u98CE\u683C\uFF1A\u6BCF\u5757 y/n\uFF0Ca \u5E94\u7528\u5269\u4F59\uFF0CA \u5207\u6362 AUTO\uFF09"
+    },
+    undo: { description: "\u56DE\u6EDA\u6700\u540E\u5E94\u7528\u7684\u7F16\u8F91\u6279\u5904\u7406" },
+    history: {
+      description: "\u5217\u51FA\u6B64\u4F1A\u8BDD\u7684\u6BCF\u4E2A\u7F16\u8F91\u6279\u5904\u7406\uFF08\u7528\u4E8E /show \u7684 ID\uFF0C\u64A4\u6D88\u6807\u8BB0\uFF09"
+    },
+    show: {
+      description: "\u8F6C\u50A8\u5B58\u50A8\u7684\u7F16\u8F91\u5DEE\u5F02\uFF08\u7701\u7565 id \u65F6\u4E3A\u6700\u65B0\u672A\u64A4\u6D88\u7684\uFF09",
+      argsHint: "[id]"
+    },
+    commit: { description: "git add -A && git commit -m ...", argsHint: '"msg"' },
+    checkpoint: {
+      description: "\u5FEB\u7167\u4F1A\u8BDD\u6D89\u53CA\u7684\u6BCF\u4E2A\u6587\u4EF6\uFF08Cursor \u98CE\u683C\u5185\u90E8\u5B58\u50A8\uFF0C\u975E git\uFF09\u3002\u5355\u72EC /checkpoint \u5217\u51FA\u3002",
+      argsHint: "[name|list|forget <id>]"
+    },
+    restore: {
+      description: "\u5C06\u6587\u4EF6\u56DE\u6EDA\u5230\u547D\u540D\u7684\u68C0\u67E5\u70B9\uFF08\u89C1 /checkpoint list\uFF09",
+      argsHint: "<name|id>"
+    },
+    plan: {
+      description: "\u5207\u6362\u53EA\u8BFB\u8BA1\u5212\u6A21\u5F0F\uFF08\u5199\u5165\u88AB\u5F39\u56DE\u76F4\u5230 submit_plan + \u5BA1\u6279\uFF09",
+      argsHint: "[on|off]"
+    },
+    mode: {
+      description: "\u7F16\u8F91\u95E8\u63A7\uFF1Areview\uFF08\u6392\u961F\uFF09\xB7 auto\uFF08\u5E94\u7528+\u64A4\u6D88\uFF09\xB7 yolo\uFF08\u5E94\u7528+\u81EA\u52A8 shell\uFF09\u3002Shift+Tab \u5FAA\u73AF\u3002",
+      argsHint: "[review|auto|yolo]"
+    },
+    jobs: { description: "\u5217\u51FA run_background \u542F\u52A8\u7684\u540E\u53F0\u4F5C\u4E1A" },
+    kill: {
+      description: "\u6309 ID \u505C\u6B62\u540E\u53F0\u4F5C\u4E1A\uFF08SIGTERM \u2192 \u5BBD\u9650\u671F\u540E SIGKILL\uFF09",
+      argsHint: "<id>"
+    },
+    logs: {
+      description: "\u8DDF\u8E2A\u540E\u53F0\u4F5C\u4E1A\u7684\u8F93\u51FA\uFF08\u9ED8\u8BA4\u6700\u540E 80 \u884C\uFF09",
+      argsHint: "<id> [lines]"
+    }
+  },
+  wizard: {
+    languageTitle: "\u9009\u62E9\u8BED\u8A00",
+    languageSubtitle: "\u5DF2\u6839\u636E\u7CFB\u7EDF\u8BED\u8A00\u81EA\u52A8\u9009\u4E2D\u3002\u4E4B\u540E\u53EF\u7528 /language \u5207\u6362\u3002",
+    welcomeTitle: "\u6B22\u8FCE\u4F7F\u7528 Reasonix\u3002",
+    apiKeyPrompt: "\u7C98\u8D34\u4F60\u7684 DeepSeek API key \u5F00\u59CB\u4F7F\u7528\u3002",
+    apiKeyGetOne: "\u5728\u6B64\u83B7\u53D6\uFF1Ahttps://platform.deepseek.com/api_keys",
+    apiKeySavedLocally: "\u4FDD\u5B58\u5728\u672C\u5730\uFF1A{path}",
+    apiKeyInputLabel: "key \u203A ",
+    apiKeyInvalid: "\u8FD9\u770B\u8D77\u6765\u4E0D\u50CF DeepSeek \u7684 key\u3002\u5B83\u4EEC\u4EE5 'sk-' \u5F00\u5934\uFF0C30 \u5B57\u7B26\u4EE5\u4E0A\u3002",
+    apiKeyPreview: "\u9884\u89C8\uFF1A{redacted}",
+    presetTitle: "\u9009\u62E9\u9884\u8BBE",
+    mcpTitle: "Reasonix \u8981\u4E3A\u4F60\u63A5\u5165\u54EA\u4E9B MCP \u670D\u52A1\u5668\uFF1F",
+    mcpUserArgsHint: "\uFF08\u9700\u8981\u4F60\u63D0\u4F9B {arg}\uFF09",
+    mcpFooterMulti: "[\u2191\u2193] \u79FB\u52A8  \xB7  [\u7A7A\u683C] \u9009\u62E9  \xB7  [Enter] \u786E\u8BA4  \xB7  [Esc] \u53D6\u6D88  \xB7  \u5168\u4E0D\u9009 = \u8DF3\u8FC7",
+    mcpArgsTitle: "\u914D\u7F6E {name}",
+    mcpArgsDirMissing: "\u76EE\u5F55 {path} \u4E0D\u5B58\u5728\u3002",
+    mcpArgsDirCreateHint: "[Y/Enter] \u521B\u5EFA\uFF08mkdir -p\uFF09\xB7 [N/Esc] \u8F93\u5165\u5176\u4ED6\u8DEF\u5F84",
+    mcpArgsDirCreateFailed: "\u65E0\u6CD5\u521B\u5EFA {path}\uFF1A{message}",
+    mcpArgsRequiredParam: "\u5FC5\u586B\u53C2\u6570\uFF1A",
+    mcpArgsEmpty: "{name} \u9700\u8981\u4E00\u4E2A\u503C \u2014 \u4E0D\u80FD\u4E3A\u7A7A\u3002",
+    mcpArgsNotADir: "{path} \u5B58\u5728\u4F46\u4E0D\u662F\u76EE\u5F55\u3002",
+    reviewTitle: "\u786E\u8BA4\u4FDD\u5B58",
+    reviewLabelApiKey: "API key",
+    reviewLabelLanguage: "\u8BED\u8A00",
+    reviewLabelPreset: "\u9884\u8BBE",
+    reviewLabelMcp: "MCP",
+    reviewMcpNone: "\uFF08\u65E0\uFF09",
+    reviewMcpServers: "{count} \u4E2A\u670D\u52A1\u5668",
+    reviewSavesTo: "\u4FDD\u5B58\u5230 {path}",
+    reviewSaveError: "\u4FDD\u5B58\u914D\u7F6E\u5931\u8D25\uFF1A{message}",
+    reviewFooter: "[Enter] \u4FDD\u5B58 \xB7 [Esc] \u53D6\u6D88",
+    savedTitle: "\u25B8 \u5DF2\u4FDD\u5B58\u3002",
+    savedFooter: "[Enter] \u9000\u51FA",
+    selectFooter: "[\u2191\u2193] \u79FB\u52A8 \xB7 [Enter] \u786E\u8BA4 \xB7 [Esc] \u53D6\u6D88",
+    stepCounter: "\u6B65\u9AA4 {step}/{total} \xB7 "
+  },
+  app: {
+    walkCancelledRemaining: "\u25B8 \u6D4F\u89C8\u5DF2\u53D6\u6D88 \u2014 \u8FD8\u6709 {count} \u4E2A\u5F85\u5904\u7406\u7F16\u8F91\u5757\u3002",
+    walkCancelled: "\u25B8 \u6D4F\u89C8\u5DF2\u53D6\u6D88\u3002",
+    editModeYolo: "\u25B8 \u7F16\u8F91\u6A21\u5F0F\uFF1AYOLO \u2014 \u7F16\u8F91\u548C shell \u547D\u4EE4\u90FD\u81EA\u52A8\u6267\u884C\u3002/undo \u4ECD\u53EF\u64A4\u9500\u7F16\u8F91\u3002\u8BF7\u8C28\u614E\u4F7F\u7528\u3002",
+    editModeAuto: "\u25B8 \u7F16\u8F91\u6A21\u5F0F\uFF1AAUTO \u2014 \u7F16\u8F91\u7ACB\u5373\u5E94\u7528\uFF1B5 \u79D2\u5185\u6309 u \u64A4\u9500\uFF08\u7A7A\u683C\u6682\u505C\u8BA1\u65F6\uFF09\u3002shell \u547D\u4EE4\u4ECD\u4F1A\u8BE2\u95EE\u3002",
+    editModeReview: "\u25B8 \u7F16\u8F91\u6A21\u5F0F\uFF1Areview \u2014 \u7F16\u8F91\u5165\u961F\u5F85 /apply\uFF08\u6216 y\uFF09/ /discard\uFF08\u6216 n\uFF09",
+    rejectedEdit: "\u25B8 \u62D2\u7EDD\u4E86\u5BF9 {path} \u7684\u7F16\u8F91{context}",
+    autoApprovingRest: "\u25B8 \u672C\u8F6E\u5269\u4F59\u7F16\u8F91\u81EA\u52A8\u6279\u51C6",
+    flippedAutoSession: "\u25B8 \u5DF2\u5207\u6362\u5230 AUTO \u6A21\u5F0F\uFF08\u672C\u4F1A\u8BDD\u5269\u4F59\u751F\u6548\uFF0C\u5DF2\u6301\u4E45\u5316\uFF09",
+    flippedAutoWalk: "\u25B8 \u5DF2\u5207\u6362\u5230 AUTO \u6A21\u5F0F \u2014 \u540E\u7EED\u7F16\u8F91\u7ACB\u5373\u5E94\u7528\u3002\u6D4F\u89C8\u6A21\u5F0F\u9000\u51FA\u3002",
+    dashboardStopped: "\u25B8 \u4EEA\u8868\u677F\u5DF2\u505C\u6B62\u3002",
+    notedMemory: "\u25B8 \u5DF2\u8BB0\u5F55\uFF08{scope}\uFF09\u2014 {verb} {path}",
+    notedScopeProject: "\u9879\u76EE",
+    notedScopeGlobal: "\u5168\u5C40",
+    notedVerbCreated: "\u521B\u5EFA",
+    notedVerbAppended: "\u8FFD\u52A0\u5230",
+    memoryWriteFailed: "# \u8BB0\u5FC6\u5199\u5165\u5931\u8D25",
+    commandFailed: "! \u547D\u4EE4\u5931\u8D25",
+    restoreCodeOnly: "\u25B8 /restore \u4EC5\u5728\u4EE3\u7801\u6A21\u5F0F\u53EF\u7528",
+    hookUserPromptSubmit: "UserPromptSubmit \u94A9\u5B50",
+    hookStop: "Stop \u94A9\u5B50",
+    atMentions: "\u25B8 @mentions\uFF1A{parts}",
+    atUrl: "\u25B8 @url\uFF1A{parts}",
+    atUrlFailed: "@url \u5C55\u5F00\u5931\u8D25",
+    denied: "\u25B8 \u5DF2\u62D2\u7EDD\uFF1A{cmd}{context}",
+    alwaysAllowed: '\u25B8 \u5DF2\u5BF9 {dir} \u6C38\u4E45\u5141\u8BB8 "{prefix}"',
+    runningCommand: "\u25B8 \u6B63\u5728\u6267\u884C\uFF1A{cmd}",
+    startingBackground: "\u25B8 \u540E\u53F0\u542F\u52A8\uFF1A{cmd}",
+    checkpointSaved: "\u26C1 \u5DF2\u4FDD\u5B58\u68C0\u67E5\u70B9 \xB7 {id} \xB7 {count} \u4E2A\u6587\u4EF6 \xB7 /restore {id} \u53EF\u56DE\u6EDA\u6B64\u6B65",
+    continuingAfter: "\u25B8 \u5728 {label}{counter} \u4E4B\u540E\u7EE7\u7EED",
+    planStoppedAt: "\u25B8 \u8BA1\u5212\u5728 {label}{counter} \u5904\u505C\u6B62",
+    revisingAfter: "\u25B8 \u5728 {label} \u4E4B\u540E\u4FEE\u8BA2 \u2014 {feedback}"
+  },
+  hooks: {
+    head: "\u94A9\u5B50 {tag} `{cmd}` {decision}{truncTag}",
+    headWithDetail: "\u94A9\u5B50 {tag} `{cmd}` {decision}{truncTag}\uFF1A{detail}",
+    truncated: "\uFF08\u8F93\u51FA\u5728 256KB \u5904\u622A\u65AD\uFF09",
+    decisionBlock: "\u62E6\u622A",
+    decisionWarn: "\u544A\u8B66",
+    decisionTimeout: "\u8D85\u65F6",
+    decisionError: "\u9519\u8BEF"
+  },
+  summary: {
+    status: "\u6B63\u5728\u603B\u7ED3\u5DF2\u6536\u96C6\u7684\u5185\u5BB9\u2026",
+    hallucinatedFallback: "\uFF08\u6A21\u578B\u751F\u6210\u4E86\u4F2A\u9020\u7684\u5DE5\u5177\u8C03\u7528\u6807\u8BB0\u800C\u975E\u7EAF\u6587\u672C\u603B\u7ED3 \u2014 \u8BD5\u8BD5 /retry \u6362\u4E2A\u66F4\u7A84\u7684\u95EE\u9898\uFF0C\u6216 /think \u67E5\u770B R1 \u7684\u63A8\u7406\uFF09",
+    failedAfterReason: "{label}\uFF0C\u4E14\u56DE\u9000\u7684\u603B\u7ED3\u8C03\u7528\u4E5F\u5931\u8D25\uFF1A{message}\u3002\u8BF7\u8FD0\u884C /clear \u540E\u7528\u66F4\u7A84\u7684\u95EE\u9898\u91CD\u8BD5\uFF0C\u6216\u63D0\u9AD8 --max-tool-iters\u3002"
+  },
+  loop: {
+    budgetExhausted: "\u4F1A\u8BDD\u9884\u7B97\u5DF2\u7528\u5B8C \u2014 \u5DF2\u82B1\u8D39 ${spent} \u2265 \u4E0A\u9650 ${cap}\u3002\u7528 /budget <usd> \u63D0\u9AD8\u4E0A\u9650\uFF0C/budget off \u6E05\u9664\u4E0A\u9650\uFF0C\u6216\u7ED3\u675F\u4F1A\u8BDD\u3002",
+    budget80Pct: "\u25B2 \u9884\u7B97\u5DF2\u7528 80% \u2014 ${spent} / ${cap}\u3002\u4E0B\u4E00\u4E24\u8F6E\u53EF\u80FD\u5C31\u89E6\u9876\u3002",
+    proArmed: "\u21E7 /pro \u5DF2\u88C5\u5907 \u2014 \u672C\u8F6E\u4F7F\u7528 deepseek-v4-pro\uFF08\u4E00\u6B21\u6027 \xB7 \u672C\u8F6E\u540E\u81EA\u52A8\u89E3\u9664\uFF09",
+    abortedAtIter: "\u5728\u7B2C {iter}/{cap} \u6B21\u5DE5\u5177\u8C03\u7528\u5904\u4E2D\u65AD \u2014 \u672A\u751F\u6210\u603B\u7ED3\u5373\u505C\u6B62\uFF08\u6309 \u2191 + Enter \u6216 /retry \u6062\u590D\uFF09",
+    toolUploadStatus: "\u5DE5\u5177\u7ED3\u679C\u5DF2\u4E0A\u4F20 \xB7 \u6A21\u578B\u5728\u751F\u6210\u4E0B\u4E00\u6761\u54CD\u5E94\u524D\u601D\u8003\u4E2D\u2026",
+    toolBudgetWarning: "\u5DF2\u7528 {iter}/{cap} \u6B21\u5DE5\u5177\u8C03\u7528 \u2014 \u63A5\u8FD1\u4E0A\u9650\u3002\u6309 Esc \u7ACB\u5373\u5F3A\u5236\u603B\u7ED3\u3002",
+    preflightFoldStatus: "\u9884\u68C0\uFF1A\u4E0A\u4E0B\u6587\u63A5\u8FD1\u4E0A\u9650\uFF0C\u5C1D\u8BD5\u6298\u53E0\u2026",
+    preflightFolded: "\u9884\u68C0\uFF1A\u8BF7\u6C42\u7EA6 {estimate}/{ctxMax} tokens\uFF08{pct}%\uFF09\u2014 \u5DF2\u6298\u53E0 {beforeMessages} \u6761\u6D88\u606F \u2192 {afterMessages}\uFF08\u603B\u7ED3 {summaryChars} \u5B57\uFF09\u3002\u53D1\u9001\u4E2D\u3002",
+    preflightNoFold: "\u9884\u68C0\uFF1A\u8BF7\u6C42\u7EA6 {estimate}/{ctxMax} tokens\uFF08{pct}%\uFF09\u4E14\u6CA1\u6709\u53EF\u6298\u53E0\u7684\u5185\u5BB9 \u2014 DeepSeek \u5927\u6982\u7387\u4F1A\u8FD4\u56DE 400\u3002\u8BF7\u8FD0\u884C /clear \u6216 /new \u91CD\u65B0\u5F00\u59CB\u3002",
+    flashEscalation: "\u21E7 flash \u8BF7\u6C42\u5347\u7EA7 \u2014 \u672C\u8F6E\u6539\u7528 {model}{reasonSuffix}",
+    harvestStatus: "\u6B63\u5728\u4ECE\u63A8\u7406\u8FC7\u7A0B\u63D0\u53D6\u8BA1\u5212\u72B6\u6001\u2026",
+    autoEscalation: "\u21E7 \u672C\u8F6E\u5269\u4F59\u8C03\u7528\u81EA\u52A8\u5347\u7EA7\u5230 {model} \u2014 flash \u547D\u4E2D {breakdown}\u3002\u4E0B\u4E00\u8F6E\u56DE\u9000\u5230 {fallback}\uFF0C\u9664\u975E\u5DF2\u88C5\u5907 /pro\u3002",
+    repeatToolCallWarning: "\u62E6\u622A\u5230\u91CD\u590D\u5DE5\u5177\u8C03\u7528 \u2014 \u8BA9\u6A21\u578B\u5BDF\u89C9\u95EE\u9898\u5E76\u6362\u79CD\u65B9\u5F0F\u91CD\u8BD5\u3002",
+    stormStuck: "\u5DF2\u505C\u6B62\u5361\u6B7B\u7684\u91CD\u8BD5\u5FAA\u73AF \u2014 \u6A21\u578B\u5728\u81EA\u7EA0\u63D0\u793A\u540E\u4ECD\u4EE5\u76F8\u540C\u53C2\u6570\u91CD\u590D\u8C03\u7528\u540C\u4E00\u5DE5\u5177\u3002\u8BF7\u5C1D\u8BD5 /retry\u3001\u6362\u79CD\u8BF4\u6CD5\uFF0C\u6216\u6392\u67E5\u5E95\u5C42\u963B\u585E\u3002",
+    stormSuppressed: "\u5DF2\u6291\u5236 {count} \u6B21\u91CD\u590D\u5DE5\u5177\u8C03\u7528 \u2014 \u540C\u4E00\u540D\u79F0 + \u53C2\u6570\u89E6\u53D1 3 \u6B21\u4EE5\u4E0A\u3002",
+    compactingHistoryStatus: "\u6B63\u5728\u538B\u7F29\u5386\u53F2{aggressiveTag}\u2026",
+    aggressiveTag: "\uFF08\u6FC0\u8FDB\uFF09",
+    foldedHistory: "\u4E0A\u4E0B\u6587 {before}/{ctxMax}\uFF08{pct}%\uFF09\u2014 \u5DF2\u6298\u53E0 {beforeMessages} \u6761\u6D88\u606F \u2192 {afterMessages}\uFF08\u603B\u7ED3 {summaryChars} \u5B57\uFF09\u3002\u7EE7\u7EED\u3002",
+    aggressivelyFoldedHistory: "\u4E0A\u4E0B\u6587 {before}/{ctxMax}\uFF08{pct}%\uFF09\u2014 \u5DF2\u6FC0\u8FDB\u6298\u53E0 {beforeMessages} \u6761\u6D88\u606F \u2192 {afterMessages}\uFF08\u603B\u7ED3 {summaryChars} \u5B57\uFF09\u3002\u7EE7\u7EED\u3002",
+    forcingSummary: "\u4E0A\u4E0B\u6587 {before}/{ctxMax}\uFF08{pct}%\uFF09\u2014 \u57FA\u4E8E\u5DF2\u6536\u96C6\u5230\u7684\u5185\u5BB9\u5F3A\u5236\u603B\u7ED3\u3002\u8BF7\u8FD0\u884C /compact\u3001/clear \u6216 /new \u91CD\u7F6E\u3002"
+  },
+  errors: {
+    contextOverflow: "\u4E0A\u4E0B\u6587\u6EA2\u51FA\uFF08DeepSeek 400\uFF09\uFF1A\u4F1A\u8BDD\u5386\u53F2\u5DF2\u8FBE {requested}\uFF0C\u8D85\u51FA\u6A21\u578B prompt \u4E0A\u9650\uFF08V4\uFF1A1M tokens\uFF1B\u65E7\u7248 chat/reasoner\uFF1A131k\uFF09\u3002\u901A\u5E38\u662F\u5355\u4E2A\u5DE5\u5177\u7ED3\u679C\u592A\u5927\u3002Reasonix \u9ED8\u8BA4\u5C06\u65B0\u5DE5\u5177\u7ED3\u679C\u9650\u5236\u5728 8k tokens\uFF0C\u5E76\u5728\u4F1A\u8BDD\u52A0\u8F7D\u65F6\u81EA\u52A8\u4FEE\u590D\u8D85\u5927\u5386\u53F2 \u2014 \u91CD\u542F\u5E38\u80FD\u6E05\u6389\u3002\u5982\u679C\u4ECD\u7136\u6EA2\u51FA\uFF0C\u8FD0\u884C /forget\uFF08\u5220\u9664\u4F1A\u8BDD\uFF09\u6216 /clear\uFF08\u4E22\u5F03\u663E\u793A\u4E2D\u7684\u5386\u53F2\uFF09\u4ECE\u5934\u5F00\u59CB\u3002",
+    contextOverflowTooMany: "tokens \u6570\u91CF\u8FC7\u591A",
+    auth401: "\u8BA4\u8BC1\u5931\u8D25\uFF08DeepSeek 401\uFF09\uFF1A{inner}\u3002\u4F60\u7684 API key \u88AB\u62D2\u7EDD\u3002\u8FD0\u884C `reasonix setup` \u6216 `export DEEPSEEK_API_KEY=sk-...` \u4FEE\u590D\u3002\u5728 https://platform.deepseek.com/api_keys \u83B7\u53D6 key\u3002",
+    balance402: "\u4F59\u989D\u4E0D\u8DB3\uFF08DeepSeek 402\uFF09\uFF1A{inner}\u3002\u5728 https://platform.deepseek.com/top_up \u5145\u503C \u2014 \u4F59\u989D\u975E\u96F6\u65F6\u9762\u677F\u9876\u680F\u4F1A\u663E\u793A\u3002",
+    badparam422: "\u53C2\u6570\u9519\u8BEF\uFF08DeepSeek 422\uFF09\uFF1A{inner}",
+    badrequest400: "\u8BF7\u6C42\u9519\u8BEF\uFF08DeepSeek 400\uFF09\uFF1A{inner}",
+    deepseek5xxHead: "DeepSeek \u670D\u52A1\u4E0D\u53EF\u7528\uFF08{status}\uFF09 \u2014 \u8FD9\u662F DeepSeek \u670D\u52A1\u7AEF\u95EE\u9898\uFF0C\u4E0D\u662F Reasonix \u6545\u969C\u3002\u5DF2\u6309\u6307\u6570\u9000\u907F\u91CD\u8BD5 4 \u6B21\u3002",
+    deepseek5xxReachable: " DeepSeek \u4E3B API \u5065\u5EB7\u68C0\u67E5\u901A\u8FC7\uFF0C\u4F46 /chat/completions \u5728\u6302 \u2014 \u4ED6\u4EEC\u90A3\u8FB9\u90E8\u5206\u670D\u52A1\u5F02\u5E38\u3002",
+    deepseek5xxUnreachable: " \u65E0\u6CD5\u4ECE\u4F60\u7684\u7F51\u7EDC\u8BBF\u95EE DeepSeek API \u2014 \u53EF\u80FD\u662F DS \u6574\u4F53\u6545\u969C\uFF0C\u4E5F\u53EF\u80FD\u662F\u672C\u5730\u7F51\u7EDC\u95EE\u9898\u3002",
+    deepseek5xxActionNetwork: " \u5EFA\u8BAE\uFF1A(1) \u68C0\u67E5\u7F51\u7EDC\uFF0C(2) \u7B49 30 \u79D2\u540E\u91CD\u8BD5\uFF0C(3) \u67E5\u770B\u72B6\u6001\u9875 https://status.deepseek.com\u3002",
+    deepseek5xxActionRetry: " \u5EFA\u8BAE\uFF1A(1) \u7B49 30 \u79D2\u540E\u91CD\u8BD5\uFF0C(2) \u7528 /preset \u5207\u6362\u6A21\u578B\uFF0C(3) \u67E5\u770B\u72B6\u6001\u9875 https://status.deepseek.com\u3002",
+    innerNoMessage: "\uFF08\u65E0\u9519\u8BEF\u4FE1\u606F\uFF09",
+    reasonAborted: "[\u7528\u6237\u5DF2\u4E2D\u65AD\uFF08Esc\uFF09 \u2014 \u6B63\u5728\u603B\u7ED3\u5230\u76EE\u524D\u4E3A\u6B62\u7684\u53D1\u73B0]",
+    reasonContextGuard: "[\u4E0A\u4E0B\u6587\u989D\u5EA6\u5373\u5C06\u8017\u5C3D \u2014 \u5728\u4E0B\u4E00\u6B21\u8C03\u7528\u6EA2\u51FA\u4E4B\u524D\u5148\u603B\u7ED3]",
+    reasonStuck: "[\u5361\u5728\u91CD\u590D\u7684\u5DE5\u5177\u8C03\u7528\u4E0A \u2014 \u8BF4\u660E\u5DF2\u5C1D\u8BD5\u7684\u65B9\u6CD5\u4EE5\u53CA\u963B\u585E\u70B9]",
+    reasonBudget: "[\u5DE5\u5177\u8C03\u7528\u914D\u989D\uFF08{iterCap}\uFF09\u5DF2\u7528\u5C3D \u2014 \u57FA\u4E8E\u5DF2\u53D1\u73B0\u7684\u5185\u5BB9\u5F3A\u5236\u603B\u7ED3]",
+    labelAborted: "\u7528\u6237\u4E2D\u65AD",
+    labelContextGuard: "\u89E6\u53D1\u4E0A\u4E0B\u6587\u4FDD\u62A4\uFF08prompt > 80% \u7A97\u53E3\uFF09",
+    labelStuck: "\u5361\u6B7B\uFF08\u91CD\u590D\u5DE5\u5177\u8C03\u7528\u88AB\u53CD\u98CE\u66B4\u673A\u5236\u6291\u5236\uFF09",
+    labelBudget: "\u5DE5\u5177\u8C03\u7528\u914D\u989D\uFF08{iterCap}\uFF09\u5DF2\u7528\u5C3D"
+  },
+  handlers: {
+    basic: {
+      newInfo: "\u25B8 \u65B0\u5BF9\u8BDD \u2014 \u5DF2\u4ECE\u4E0A\u4E0B\u6587\u4E2D\u4E22\u5F03 {count} \u6761\u6D88\u606F\u3002\u540C\u4E00\u4F1A\u8BDD\uFF0C\u5168\u65B0\u5F00\u59CB\u3002",
+      helpTitle: "\u547D\u4EE4\uFF1A",
+      helpShellTitle: "Shell \u5FEB\u6377\u65B9\u5F0F\uFF1A",
+      helpShell: "  !<cmd>                   \u5728\u6C99\u7BB1\u6839\u76EE\u5F55\u8FD0\u884C <cmd>\uFF1B\u8F93\u51FA\u8FDB\u5165\u5BF9\u8BDD",
+      helpShellDetail: "                             \u4EE5\u4FBF\u6A21\u578B\u5728\u4E0B\u4E00\u8F6E\u770B\u5230\u3002\u65E0\u5141\u8BB8\u5217\u8868\u9650\u5236\u3002",
+      helpShellConsent: "                             \u7528\u6237\u8F93\u5165 = \u660E\u786E\u540C\u610F\u3002",
+      helpShellExample: "                             \u793A\u4F8B\uFF1A!git status   !ls src/   !npm test",
+      helpMemoryTitle: "\u5FEB\u901F\u8BB0\u5FC6\uFF1A",
+      helpMemoryPin: "  #<note>                  \u5C06 <note> \u8FFD\u52A0\u5230 <project>/REASONIX.md\uFF08\u53EF\u63D0\u4EA4\uFF09\u3002",
+      helpMemoryPinEx: "                             \u793A\u4F8B\uFF1A#findByEmail \u5FC5\u987B\u533A\u5206\u5927\u5C0F\u5199",
+      helpMemoryGlobal: "  #g <note>                \u5C06 <note> \u8FFD\u52A0\u5230 ~/.reasonix/REASONIX.md\uFF08\u5168\u5C40\uFF0C\u4E0D\u63D0\u4EA4\uFF09\u3002",
+      helpMemoryGlobalEx: "                             \u793A\u4F8B\uFF1A#g \u59CB\u7EC8\u4F7F\u7528 pnpm \u800C\u975E npm",
+      helpMemoryPinBoth: "                             \u4E24\u8005\u90FD\u56FA\u5B9A\u5230\u6BCF\u4E2A\u672A\u6765\u4F1A\u8BDD\u7684\u524D\u7F00\u4E2D\u3002\u6BD4 /memory \u66F4\u5FEB\u3002",
+      helpMemoryEscape: "                             \u4F7F\u7528 `\\#text` \u53D1\u9001\u5B57\u9762\u91CF `#text` \u7ED9\u6A21\u578B\u3002",
+      helpFileTitle: "\u6587\u4EF6\u5F15\u7528\uFF08\u4EE3\u7801\u6A21\u5F0F\uFF09\uFF1A",
+      helpFile: "  @path/to/file            \u53D1\u9001\u65F6\u5C06\u6587\u4EF6\u5185\u5BB9\u5185\u8054\u5230 [Referenced files] \u4E0B\u3002",
+      helpFilePicker: "                             \u8F93\u5165 `@` \u6253\u5F00\u9009\u62E9\u5668\uFF08\u2191\u2193 \u5BFC\u822A\uFF0CTab/Enter \u9009\u62E9\uFF09\u3002",
+      helpUrlTitle: "URL \u5F15\u7528\uFF1A",
+      helpUrl: "  @https://example.com     \u83B7\u53D6 URL\uFF0C\u5265\u79BB HTML\uFF0C\u5185\u8054\u5230 [Referenced URLs] \u4E0B\u3002",
+      helpUrlCache: "                             \u540C\u4E00\u4F1A\u8BDD\u4E2D\u76F8\u540C URL \u53EA\u83B7\u53D6\u4E00\u6B21\uFF08\u5185\u5B58\u7F13\u5B58\uFF09\u3002",
+      helpUrlPunct: "                             \u81EA\u52A8\u5265\u79BB\u5C3E\u90E8\u6807\u70B9\u7B26\u53F7\uFF08./,/\uFF09\uFF09\u3002",
+      helpPresetsTitle: "\u9884\u8BBE\uFF08branch + harvest \u6C38\u8FDC\u4E0D\u4F1A\u81EA\u52A8\u542F\u7528 \u2014 \u4EC5\u624B\u52A8\u9009\u62E9\uFF09\uFF1A",
+      helpPresetAuto: "  auto   v4-flash \u2192 v4-pro \u5728\u56F0\u96BE\u8F6E\u6B21\u5207\u6362  \u2190 \u9ED8\u8BA4 \xB7 \u7B80\u5355\u65F6\u4FBF\u5B9C\uFF0C\u56F0\u96BE\u65F6\u667A\u80FD",
+      helpPresetFlash: "  flash  \u59CB\u7EC8\u4F7F\u7528 v4-flash                  \u6700\u4FBF\u5B9C \xB7 \u6BCF\u8F6E\u6210\u672C\u53EF\u9884\u6D4B",
+      helpPresetPro: "  pro    \u59CB\u7EC8\u4F7F\u7528 v4-pro                     \u7EA6 3 \u500D flash \xB7 \u7528\u4E8E\u56F0\u96BE\u7684\u591A\u8F6E\u5DE5\u4F5C",
+      helpSessionsTitle: "\u4F1A\u8BDD\uFF08\u9ED8\u8BA4\u81EA\u52A8\u542F\u7528\uFF0C\u547D\u540D\u4E3A 'default'\uFF09\uFF1A",
+      helpSessionCustom: "  reasonix chat --session <name>   \u4F7F\u7528\u4E0D\u540C\u7684\u547D\u540D\u4F1A\u8BDD",
+      helpSessionNone: "  reasonix chat --no-session       \u7981\u7528\u672C\u6B21\u8FD0\u884C\u7684\u6301\u4E45\u5316",
+      retryNone: "\u6CA1\u6709\u53EF\u91CD\u8BD5\u7684\u5185\u5BB9 \u2014 \u6B64\u4F1A\u8BDD\u65E5\u5FD7\u4E2D\u6CA1\u6709\u5148\u524D\u7684\u7528\u6237\u6D88\u606F\u3002",
+      retryInfo: '\u25B8 \u91CD\u8BD5\u4E2D\uFF1A"{preview}"',
+      loopTuiOnly: "/loop \u4EC5\u5728\u4EA4\u4E92\u5F0F TUI \u4E2D\u53EF\u7528\uFF08\u4E0D\u5728 run/replay \u4E2D\uFF09\u3002",
+      loopStopped: "\u25B8 \u5FAA\u73AF\u5DF2\u505C\u6B62\u3002",
+      loopNoActive: "\u6CA1\u6709\u6D3B\u52A8\u7684\u5FAA\u73AF\u53EF\u505C\u6B62\u3002",
+      loopNoActiveHint: "\u6CA1\u6709\u6D3B\u52A8\u7684\u5FAA\u73AF\u3002\u4F7F\u7528 `/loop <interval> <prompt>` \u542F\u52A8\u4E00\u4E2A\uFF08\u4F8B\u5982 /loop 30s npm test\uFF09\u3002\n\u53D6\u6D88\u65B9\u5F0F\uFF1A/loop stop \xB7 Esc \xB7 /clear /new \xB7 \u4EFB\u4F55\u7528\u6237\u8F93\u5165\u7684\u63D0\u793A\u3002",
+      loopStarted: '\u25B8 \u5FAA\u73AF\u5DF2\u542F\u52A8 \u2014 \u6BCF {duration} \u91CD\u65B0\u63D0\u4EA4 "{prompt}"\u3002\u8F93\u5165\u4EFB\u4F55\u5185\u5BB9\uFF08\u6216 /loop stop\uFF09\u53D6\u6D88\u3002'
+    },
+    admin: {
+      doctorNeedsTui: "/doctor \u9700\u8981 TUI \u4E0A\u4E0B\u6587\uFF08postDoctor \u5DF2\u8FDE\u63A5\uFF09\u3002",
+      doctorRunning: "\u2695 \u5065\u5EB7\u68C0\u67E5 \u2014 \u6B63\u5728\u8FD0\u884C\u2026",
+      hooksReloadUnavailable: "/hooks reload \u5728\u6B64\u4E0A\u4E0B\u6587\u4E2D\u4E0D\u53EF\u7528\uFF08\u65E0\u91CD\u8F7D\u56DE\u8C03\uFF09\u3002",
+      hooksReloaded: "\u25B8 \u5DF2\u91CD\u8F7D hooks \xB7 {count} \u4E2A\u6D3B\u8DC3",
+      hooksUsage: "\u7528\u6CD5\uFF1A/hooks            \u5217\u51FA\u6D3B\u8DC3\u7684 hooks\n       /hooks reload     \u91CD\u65B0\u8BFB\u53D6 settings.json \u6587\u4EF6",
+      hooksNone: "\u672A\u914D\u7F6E hooks\u3002",
+      hooksDropHint: "\u5C06\u5305\u542B `hooks` \u952E\u7684 settings.json \u653E\u5165\u4EE5\u4E0B\u4EFB\u4E00\u4F4D\u7F6E\uFF1A",
+      hooksProject: "  \xB7 {path}\uFF08\u9879\u76EE\uFF09",
+      hooksProjectFallback: "  \xB7 <project>/.reasonix/settings.json\uFF08\u9879\u76EE\uFF09",
+      hooksGlobal: "  \xB7 {path}\uFF08\u5168\u5C40\uFF09",
+      hooksEvents: "\u4E8B\u4EF6\uFF1APreToolUse, PostToolUse, UserPromptSubmit, Stop",
+      hooksExitCodes: "exit 0 = \u901A\u8FC7 \xB7 exit 2 = \u963B\u6B62\uFF08Pre*\uFF09\xB7 \u5176\u4ED6 = \u8B66\u544A",
+      hooksLoaded: "\u25B8 \u5DF2\u52A0\u8F7D {count} \u4E2A hook",
+      hooksSources: "\u6765\u6E90\uFF1Aproject={project} \xB7 global={global}",
+      updateCurrent: "\u5F53\u524D\uFF1Areasonix {version}",
+      updateLatestPending: "\u6700\u65B0\uFF1A\uFF08\u5C1A\u672A\u89E3\u6790 \u2014 \u540E\u53F0\u68C0\u67E5\u8FDB\u884C\u4E2D\u6216\u79BB\u7EBF\uFF09",
+      updateRetryHint: "\u5DF2\u89E6\u53D1\u65B0\u7684\u6CE8\u518C\u8868\u83B7\u53D6 \u2014 \u51E0\u79D2\u540E\u91CD\u8BD5 `/update`\uFF0C",
+      updateRetryHint2: "\u6216\u5728\u53E6\u4E00\u4E2A\u7EC8\u7AEF\u8FD0\u884C `reasonix update` \u5F3A\u5236\u540C\u6B65\u6267\u884C\u3002",
+      updateLatest: "\u6700\u65B0\uFF1Areasonix {version}",
+      updateUpToDate: "\u60A8\u5DF2\u662F\u6700\u65B0\u7248\u672C\u3002\u65E0\u9700\u64CD\u4F5C\u3002",
+      updateNpxHint: "\u60A8\u6B63\u5728\u901A\u8FC7 npx \u8FD0\u884C \u2014 \u4E0B\u6B21 `npx reasonix ...` \u542F\u52A8\u65F6\u5C06\u81EA\u52A8\u83B7\u53D6\u3002",
+      updateNpxForce: "\u8981\u5F3A\u5236\u5237\u65B0\uFF1A`npm cache clean --force`\u3002",
+      updateUpgradeHint: "\u8981\u5347\u7EA7\uFF0C\u8BF7\u9000\u51FA\u6B64\u4F1A\u8BDD\u5E76\u8FD0\u884C\uFF1A",
+      updateUpgradeCmd1: "  reasonix update           \uFF08\u4EA4\u4E92\u5F0F\uFF0C\u652F\u6301 --dry-run \u9884\u89C8\uFF09",
+      updateUpgradeCmd2: "  npm install -g reasonix@latest   \uFF08\u76F4\u63A5\u5B89\u88C5\uFF09",
+      updateInSessionDisabled: "\u4F1A\u8BDD\u5185\u5B89\u88C5\u88AB\u523B\u610F\u7981\u7528 \u2014 npm spawn \u4F1A",
+      updateInSessionDisabled2: "\u7834\u574F\u6B64 TUI \u7684\u6E32\u67D3\uFF0C\u4E14 Windows \u53EF\u80FD\u9501\u5B9A\u8FD0\u884C\u4E2D\u7684\u4E8C\u8FDB\u5236\u6587\u4EF6\u3002",
+      statsNoData: "\u5C1A\u65E0\u4F7F\u7528\u6570\u636E\u3002",
+      statsEveryTurn: "\u60A8\u5728\u6B64\u8FD0\u884C\u7684\u6BCF\u4E00\u8F6E\u90FD\u4F1A\u8FFD\u52A0\u4E00\u6761\u8BB0\u5F55 \u2014 \u6B64\u4F1A\u8BDD\u7684\u8F6E\u6B21",
+      statsWillAppear: "\u5C06\u5728\u60A8\u53D1\u9001\u6D88\u606F\u540E\u663E\u793A\u5728\u4EEA\u8868\u677F\u4E2D\u3002"
+    },
+    edits: {
+      undoCodeOnly: "/undo \u4EC5\u5728 `reasonix code` \u4E2D\u53EF\u7528 \u2014 \u804A\u5929\u6A21\u5F0F\u4E0D\u5E94\u7528\u7F16\u8F91\u3002",
+      historyCodeOnly: "/history \u4EC5\u5728 `reasonix code` \u4E2D\u53EF\u7528\u3002",
+      showCodeOnly: "/show \u4EC5\u5728 `reasonix code` \u4E2D\u53EF\u7528\u3002",
+      applyCodeOnly: "/apply \u4EC5\u5728 `reasonix code` \u4E2D\u53EF\u7528\uFF08\u6B64\u5904\u65E0\u5185\u5BB9\u53EF\u5E94\u7528\uFF09\u3002",
+      discardCodeOnly: "/discard \u4EC5\u5728 `reasonix code` \u4E2D\u53EF\u7528\u3002",
+      planCodeOnly: "/plan \u4EC5\u5728 `reasonix code` \u4E2D\u53EF\u7528 \u2014 \u804A\u5929\u6A21\u5F0F\u4E0D\u9650\u5236\u5DE5\u5177\u5199\u5165\u3002",
+      planOn: "\u25B8 \u8BA1\u5212\u6A21\u5F0F\u5F00\u542F \u2014 \u5199\u5165\u5DE5\u5177\u88AB\u9650\u5236\uFF1B\u6A21\u578B\u5FC5\u987B\u5148\u8C03\u7528 `submit_plan` \u624D\u80FD\u6267\u884C\u4EFB\u4F55\u64CD\u4F5C\u3002\uFF08\u6A21\u578B\u4E5F\u53EF\u4EE5\u5728\u8BA1\u5212\u6A21\u5F0F\u5173\u95ED\u65F6\u81EA\u4E3B\u8C03\u7528 submit_plan \u5904\u7406\u5927\u578B\u4EFB\u52A1 \u2014 \u6B64\u5F00\u5173\u662F\u66F4\u5F3A\u7684\u663E\u5F0F\u7EA6\u675F\u3002\uFF09\u8F93\u5165 /plan off \u9000\u51FA\u3002",
+      planOff: "\u25B8 \u8BA1\u5212\u6A21\u5F0F\u5173\u95ED \u2014 \u5199\u5165\u5DE5\u5177\u518D\u6B21\u53EF\u7528\u3002\u6A21\u578B\u4ECD\u53EF\u4E3A\u5927\u578B\u4EFB\u52A1\u81EA\u4E3B\u63D0\u51FA\u8BA1\u5212\u3002",
+      modeCodeOnly: "/mode \u4EC5\u5728 `reasonix code` \u4E2D\u53EF\u7528\u3002",
+      modeUsage: "\u7528\u6CD5\uFF1A/mode <review|auto|yolo>   \uFF08Shift+Tab \u4E5F\u53EF\u5FAA\u73AF\uFF09",
+      modeYolo: "\u25B8 \u7F16\u8F91\u6A21\u5F0F\uFF1AYOLO \u2014 \u7F16\u8F91\u548C Shell \u547D\u4EE4\u81EA\u52A8\u8FD0\u884C\uFF0C\u65E0\u63D0\u793A\u3002/undo \u4ECD\u53EF\u56DE\u6EDA\u7F16\u8F91\u3002\u8BF7\u8C28\u614E\u4F7F\u7528\u3002",
+      modeAuto: "\u25B8 \u7F16\u8F91\u6A21\u5F0F\uFF1AAUTO \u2014 \u7F16\u8F91\u7ACB\u5373\u5E94\u7528\uFF1B\u5728 5 \u79D2\u5185\u6309 u \u64A4\u6D88\uFF0C\u6216\u7A0D\u540E\u4F7F\u7528 /undo\u3002Shell \u547D\u4EE4\u4ECD\u4F1A\u8BE2\u95EE\u3002",
+      modeReview: "\u25B8 \u7F16\u8F91\u6A21\u5F0F\uFF1Areview \u2014 \u7F16\u8F91\u6392\u961F\u7B49\u5F85 /apply\uFF08\u6216 y\uFF09/ /discard\uFF08\u6216 n\uFF09",
+      commitCodeOnly: "/commit \u4EC5\u5728 `reasonix code` \u4E2D\u53EF\u7528\uFF08\u9700\u8981\u6709\u6839\u7684 git \u4ED3\u5E93\uFF09\u3002",
+      commitUsage: '\u7528\u6CD5\uFF1A/commit "\u63D0\u4EA4\u6D88\u606F"  \u2014 \u5728 {root} \u4E2D\u8FD0\u884C `git add -A && git commit -m "\u2026"`',
+      walkCodeOnly: "/walk \u4EC5\u5728 `reasonix code` \u4E2D\u53EF\u7528\u3002",
+      checkpointCodeOnly: "/checkpoint \u4EC5\u5728 `reasonix code` \u4E2D\u53EF\u7528 \u2014 \u804A\u5929\u6A21\u5F0F\u4E0D\u5E94\u7528\u7F16\u8F91\u3002",
+      checkpointNone: "\u5C1A\u65E0\u68C0\u67E5\u70B9 \u2014 `/checkpoint <name>` \u5FEB\u7167\u4F1A\u8BDD\u6D89\u53CA\u7684\u6BCF\u4E2A\u6587\u4EF6\u3002\u7A0D\u540E\u4F7F\u7528 `/restore <name>` \u6062\u590D\u3002",
+      checkpointHeader: "\u25C8 \u68C0\u67E5\u70B9 \xB7 \u5DF2\u5B58\u50A8 {count} \u4E2A",
+      checkpointRestoreHint: "  /restore <name|id> \xB7 /checkpoint forget <id> \xB7 /checkpoint <name> \u6DFB\u52A0",
+      checkpointForgetUsage: "\u7528\u6CD5\uFF1A/checkpoint forget <id|name>",
+      checkpointNoMatch: '\u25B8 \u672A\u627E\u5230\u5339\u914D "{name}" \u7684\u68C0\u67E5\u70B9 \u2014 \u89C1 /checkpoint list',
+      checkpointDeleted: "\u25B8 \u5DF2\u5220\u9664\u68C0\u67E5\u70B9 {id}\uFF08{name}\uFF09",
+      checkpointDeleteFailed: "\u25B8 \u5220\u9664 {id} \u5931\u8D25\uFF08\u5DF2\u6D88\u5931\uFF1F\uFF09",
+      checkpointSaveUsage: "\u7528\u6CD5\uFF1A/checkpoint <name>   \uFF08\u6216 /checkpoint list \u67E5\u770B\u73B0\u6709\uFF09",
+      checkpointSavedEmpty: '\u25B8 \u68C0\u67E5\u70B9 "{name}" \u5DF2\u4FDD\u5B58\uFF08{id}\uFF09\u2014 \u4F46\u5C1A\u672A\u6D89\u53CA\u4EFB\u4F55\u6587\u4EF6\uFF0C\u56E0\u6B64\u662F\u7A7A\u57FA\u7EBF\u3002\u6B64\u540E\u7684\u7F16\u8F91\u5C06\u53EF\u64A4\u6D88\u3002',
+      checkpointSaved: '\u25B8 \u68C0\u67E5\u70B9 "{name}" \u5DF2\u4FDD\u5B58\uFF08{id}\uFF09\u2014 {files} \u4E2A\u6587\u4EF6\uFF0C{size} KB\u3002\u6062\u590D\uFF1A/restore {name}',
+      restoreCodeOnly: "/restore \u4EC5\u5728 `reasonix code` \u4E2D\u53EF\u7528\u3002",
+      restoreUsage: "\u7528\u6CD5\uFF1A/restore <name|id>   \uFF08\u89C1 /checkpoint list \u83B7\u53D6 ID\uFF09",
+      restoreNoMatch: '\u25B8 \u672A\u627E\u5230\u5339\u914D "{target}" \u7684\u68C0\u67E5\u70B9 \u2014 \u5C1D\u8BD5 /checkpoint list',
+      restoreInfo: '\u25B8 \u5DF2\u6062\u590D "{name}"\uFF08{id}\uFF09\uFF0C\u6765\u81EA {when}',
+      restoreWrote: "  \xB7 \u5199\u56DE\u4E86 {count} \u4E2A\u6587\u4EF6",
+      restoreRemoved: "  \xB7 \u79FB\u9664\u4E86 {count} \u4E2A\u6587\u4EF6\uFF08\u68C0\u67E5\u70B9\u65F6\u4E0D\u5B58\u5728\uFF09",
+      restoreSkipped: "  \u2717 \u8DF3\u8FC7\u4E86 {count} \u4E2A\u6587\u4EF6\uFF1A"
+    },
+    model: {
+      modelHint: "\u5C1D\u8BD5 deepseek-v4-flash \u6216 deepseek-v4-pro \u2014 \u8FD0\u884C /models \u83B7\u53D6\u5B9E\u65F6\u5217\u8868",
+      modelUsage: "\u7528\u6CD5\uFF1A/model <id>   \uFF08{hint}\uFF09",
+      modelNotInCatalog: "model \u2192 {id}   \uFF08\u26A0 \u4E0D\u5728\u83B7\u53D6\u7684\u76EE\u5F55\u4E2D\uFF1A{list}\u3002\u5982\u679C\u8FD9\u662F\u9519\u8BEF\u7684\uFF0C\u4E0B\u6B21\u8C03\u7528\u5C06\u8FD4\u56DE 400 \u2014 \u8FD0\u884C /models \u5237\u65B0\u3002\uFF09",
+      modelSet: "model \u2192 {id}",
+      presetAuto: "preset \u2192 auto  \uFF08v4-flash \u2192 v4-pro \u5728\u56F0\u96BE\u8F6E\u6B21\u5207\u6362 \xB7 \u9ED8\u8BA4\uFF09",
+      presetFlash: "preset \u2192 flash  \uFF08\u59CB\u7EC8\u4F7F\u7528 v4-flash \xB7 \u6700\u4FBF\u5B9C \xB7 /pro \u4ECD\u53EF\u4E34\u65F6\u63D0\u5347\u4E00\u8F6E\uFF09",
+      presetPro: "preset \u2192 pro  \uFF08\u59CB\u7EC8\u4F7F\u7528 v4-pro \xB7 \u7EA6 3 \u500D flash \xB7 \u7528\u4E8E\u56F0\u96BE\u7684\u591A\u8F6E\u5DE5\u4F5C\uFF09",
+      presetUsage: "\u7528\u6CD5\uFF1A/preset <auto|flash|pro>",
+      proNothingArmed: "\u672A\u542F\u7528 \u2014 /pro \u4E0D\u5E26\u53C2\u6570\u5C06\u4E3A\u4E0B\u4E00\u8F6E\u542F\u7528 pro",
+      proDisarmed: "\u25B8 /pro \u5DF2\u89E3\u9664 \u2014 \u4E0B\u4E00\u8F6E\u56DE\u9000\u5230\u5F53\u524D\u9884\u8BBE",
+      proUsage: "\u7528\u6CD5\uFF1A/pro       \u4E3A\u4E0B\u4E00\u8F6E\u542F\u7528 pro\uFF08\u4E00\u6B21\u6027\uFF0C\u81EA\u52A8\u89E3\u9664\uFF09\n       /pro off  \u5728\u4E0B\u4E00\u8F6E\u524D\u53D6\u6D88\u542F\u7528\u72B6\u6001",
+      proArmed: "\u25B8 /pro \u5DF2\u542F\u7528 \u2014 \u60A8\u7684\u4E0B\u4E00\u6761\u6D88\u606F\u5C06\u5728 {model} \u4E0A\u8FD0\u884C\uFF0C\u65E0\u8BBA\u9884\u8BBE\u5982\u4F55\u3002\u4E00\u8F6E\u540E\u81EA\u52A8\u89E3\u9664\u3002\u4F7F\u7528 /preset max \u8FDB\u884C\u6301\u4E45\u5207\u6362\u3002",
+      budgetNoCap: "\u672A\u8BBE\u7F6E\u4F1A\u8BDD\u9884\u7B97 \u2014 Reasonix \u5C06\u6301\u7EED\u8FD0\u884C\u76F4\u5230\u60A8\u505C\u6B62\u3002\u4F7F\u7528\u4EE5\u4E0B\u65B9\u5F0F\u8BBE\u7F6E\uFF1A/budget <usd>   \uFF08\u4F8B\u5982 /budget 5\uFF09",
+      budgetStatus: "\u9884\u7B97\uFF1A${spent} / ${cap}\uFF08{pct}%\uFF09\xB7 /budget off \u6E05\u9664\uFF0C/budget <usd> \u66F4\u6539",
+      budgetOff: "budget \u2192 \u5173\u95ED\uFF08\u65E0\u4E0A\u9650\uFF09",
+      budgetUsage: '\u7528\u6CD5\uFF1A/budget <usd>   \uFF08\u6536\u5230 "{arg}" \u2014 \u5FC5\u987B\u662F\u6B63\u6570\uFF0C\u4F8B\u5982 /budget 5 \u6216 /budget 12.50\uFF09',
+      budgetExhausted: "\u25B2 budget \u2192 ${cap} \u4F46\u5DF2\u82B1\u8D39 ${spent}\u3002\u4E0B\u4E00\u8F6E\u5C06\u88AB\u62D2\u7EDD \u2014 \u63D0\u9AD8\u4E0A\u9650\u4EE5\u7EE7\u7EED\uFF0C\u6216\u7ED3\u675F\u4F1A\u8BDD\u3002",
+      budgetSet: "budget \u2192 ${cap}  \uFF08\u8FC4\u4ECA\uFF1A${spent} \xB7 80% \u65F6\u8B66\u544A\uFF0C100% \u65F6\u62D2\u7EDD\u4E0B\u4E00\u8F6E \xB7 /budget off \u6E05\u9664\uFF09"
+    },
+    permissions: {
+      mutateCodeOnly: "/permissions add / remove / clear \u4EC5\u5728 `reasonix code` \u4E2D\u53EF\u7528 \u2014 \u5B83\u4EEC\u7F16\u8F91\u9879\u76EE\u8303\u56F4\u7684\u5141\u8BB8\u5217\u8868\uFF08`~/.reasonix/config.json` projects[<root>].shellAllowed\uFF09\u3002",
+      addUsage: '\u7528\u6CD5\uFF1A/permissions add <prefix>   \uFF08\u591A token \u53EF\u7528\uFF1A/permissions add "git push origin"\uFF09',
+      addAlready: "\u25B8 \u5DF2\u5141\u8BB8\uFF1A{prefix}",
+      addBuiltin: "\u25B8 `{prefix}` \u5DF2\u5728\u5185\u7F6E\u5141\u8BB8\u5217\u8868\u4E2D \u2014 \u65E0\u9700\u9879\u76EE\u6761\u76EE\u3002\uFF08\u5185\u7F6E\u6761\u76EE\u59CB\u7EC8\u5F00\u542F\u3002\uFF09",
+      addInfo: "\u25B8 \u5DF2\u6DFB\u52A0\uFF1A{prefix}\n  \u2192 \u5728\u6B64\u9879\u76EE\u4E2D\uFF0C\u4E0B\u6B21 `{prefix}` \u8C03\u7528\u5C06\u65E0\u9700\u63D0\u793A\u3002",
+      removeUsage: "\u7528\u6CD5\uFF1A/permissions remove <prefix-or-index>   \uFF08\u4F8B\u5982 /permissions remove 3\uFF0C\u6216 /permissions remove npm\uFF09",
+      removeEmpty: "\u25B8 \u6CA1\u6709\u9879\u76EE\u5141\u8BB8\u5217\u8868\u6761\u76EE\u53EF\u79FB\u9664\u3002",
+      removeIndexOob: "\u25B8 \u7D22\u5F15\u8D85\u51FA\u8303\u56F4\uFF1A{idx}\uFF08\u9879\u76EE\u5217\u8868\u6709 {count} \u4E2A\u6761\u76EE\uFF09",
+      removeNothing: "\u25B8 \u65E0\u5185\u5BB9\u53EF\u79FB\u9664\u3002",
+      removeBuiltin: "\u25B8 `{prefix}` \u5728\u5185\u7F6E\u5141\u8BB8\u5217\u8868\u4E2D\uFF08\u53EA\u8BFB\uFF09\u3002\u5185\u7F6E\u6761\u76EE\u65E0\u6CD5\u5728\u8FD0\u884C\u65F6\u79FB\u9664 \u2014 \u5B83\u4EEC\u5DF2\u7F16\u8BD1\u5230\u4E8C\u8FDB\u5236\u6587\u4EF6\u4E2D\u3002",
+      removeInfo: "\u25B8 \u5DF2\u79FB\u9664\uFF1A{prefix}",
+      removeNotFound: "\u25B8 \u65E0\u6B64\u9879\u76EE\u6761\u76EE\uFF1A{prefix}   \uFF08\u5C1D\u8BD5 /permissions list \u67E5\u770B\u5DF2\u5B58\u50A8\u7684\u5185\u5BB9\uFF09",
+      clearAlready: "\u25B8 \u9879\u76EE\u5141\u8BB8\u5217\u8868\u5DF2\u4E3A\u7A7A\u3002",
+      clearConfirm: "\u5373\u5C06\u4E22\u5F03 {root} \u7684 {count} \u4E2A\u9879\u76EE\u5141\u8BB8\u5217\u8868\u6761\u76EE\u3002\u91CD\u65B0\u8FD0\u884C\u5E76\u9644\u5E26 'confirm' \u4E00\u8BCD\u4EE5\u7EE7\u7EED\uFF1A/permissions clear confirm",
+      clearedNone: "\u25B8 \u9879\u76EE\u5141\u8BB8\u5217\u8868\u5DF2\u4E3A\u7A7A \u2014 \u65E0\u53D8\u5316\u3002",
+      cleared: "\u25B8 \u5DF2\u6E05\u9664 {count} \u4E2A\u9879\u76EE\u5141\u8BB8\u5217\u8868\u6761\u76EE\u3002",
+      usage: '\u7528\u6CD5\uFF1A/permissions [list]                   \u663E\u793A\u5F53\u524D\u72B6\u6001\n       /permissions add <prefix>            \u6301\u4E45\u5316\uFF08\u4F8B\u5982 "npm run build"\uFF09\n       /permissions remove <prefix-or-N>    \u5220\u9664\u4E00\u4E2A\u6761\u76EE\n       /permissions clear confirm           \u6E05\u9664\u6240\u6709\u9879\u76EE\u6761\u76EE',
+      modeYolo: "\u25B8 \u7F16\u8F91\u6A21\u5F0F\uFF1AYOLO  \u2014 \u6BCF\u4E2A shell \u547D\u4EE4\u81EA\u52A8\u8FD0\u884C\uFF0C\u5141\u8BB8\u5217\u8868\u88AB\u7ED5\u8FC7\u3002/mode review \u91CD\u65B0\u542F\u7528\u63D0\u793A\u3002",
+      modeAuto: "\u25B8 \u7F16\u8F91\u6A21\u5F0F\uFF1Aauto  \u2014 \u7F16\u8F91\u81EA\u52A8\u5E94\u7528\uFF0Cshell \u4ECD\u53D7\u5141\u8BB8\u5217\u8868\u9650\u5236\uFF08\u6216\u975E\u5141\u8BB8\u5217\u8868\u7684 ShellConfirm \u63D0\u793A\uFF09\u3002",
+      modeReview: "\u25B8 \u7F16\u8F91\u6A21\u5F0F\uFF1Areview \u2014 \u7F16\u8F91\u548C\u975E\u5141\u8BB8\u5217\u8868\u7684 shell \u547D\u4EE4\u5728\u8FD0\u884C\u524D\u90FD\u4F1A\u8BE2\u95EE\u3002",
+      projectHeader: "\u9879\u76EE\u5141\u8BB8\u5217\u8868\uFF08{count}\uFF09\u2014 {root}",
+      projectNone1: '  \uFF08\u65E0 \u2014 \u5728 ShellConfirm \u63D0\u793A\u4E2D\u9009\u62E9 "always allow" \u6DFB\u52A0\u4E00\u4E2A\uFF0C',
+      projectNone2: "   \u6216\u76F4\u63A5 `/permissions add <prefix>`\u3002\uFF09",
+      projectNoRoot: "\u9879\u76EE\u5141\u8BB8\u5217\u8868 \u2014 \uFF08\u65E0\u9879\u76EE\u6839\u76EE\u5F55\uFF1B\u804A\u5929\u6A21\u5F0F\u4EC5\u663E\u793A\u5185\u7F6E\u6761\u76EE\uFF09",
+      builtinHeader: "\u5185\u7F6E\u5141\u8BB8\u5217\u8868\uFF08{count}\uFF09\u2014 \u53EA\u8BFB\uFF0C\u5DF2\u7F16\u8BD1",
+      subcommands: "\u5B50\u547D\u4EE4\uFF1A/permissions add <prefix> \xB7 /permissions remove <prefix-or-N> \xB7 /permissions clear confirm"
+    },
+    dashboard: {
+      notAvailable: "/dashboard \u5728\u6B64\u4E0A\u4E0B\u6587\u4E2D\u4E0D\u53EF\u7528\uFF08\u65E0 startDashboard \u56DE\u8C03\uFF09\u3002",
+      stopNoCallback: "/dashboard stop\uFF1A\u65E0\u505C\u6B62\u56DE\u8C03\u3002",
+      notRunning: "\u25B8 \u4EEA\u8868\u677F\u672A\u8FD0\u884C\u3002",
+      stopping: "\u25B8 \u4EEA\u8868\u677F\u6B63\u5728\u505C\u6B62\u2026",
+      alreadyRunning: "\u25B8 \u4EEA\u8868\u677F\u5DF2\u5728\u8FD0\u884C\uFF1A",
+      alreadyRunningHint: "\u5728\u4EFB\u4F55\u6D4F\u89C8\u5668\u4E2D\u6253\u5F00\u5B83\u3002\u8F93\u5165 `/dashboard stop` \u5173\u95ED\u3002",
+      ready: "\u25B8 \u4EEA\u8868\u677F\u5C31\u7EEA\uFF1A",
+      readyHint: "\u4EC5 127.0.0.1 \xB7 token \u4FDD\u62A4\u3002\u8F93\u5165 `/dashboard stop` \u5173\u95ED\u3002",
+      failed: "\u25B8 \u4EEA\u8868\u677F\u542F\u52A8\u5931\u8D25\uFF1A{reason}",
+      starting: "\u25B8 \u6B63\u5728\u542F\u52A8\u4EEA\u8868\u677F\u670D\u52A1\u5668\u2026"
+    },
+    observability: {
+      contextInfo: "\u4E0A\u4E0B\u6587\uFF1A~{total} / {max}\uFF08{pct}%\uFF09\xB7 \u7CFB\u7EDF {sys} \xB7 \u5DE5\u5177 {tools} \xB7 \u65E5\u5FD7 {log}",
+      compactStarting: "\u25B8 \u6B63\u5728\u6298\u53E0\u65E7\u8F6E\u6B21\u4E3A\u6458\u8981\u2026",
+      compactNoop: "\u25B8 \u65E0\u9700\u6298\u53E0 \u2014 \u65E5\u5FD7\u5DF2\u8DB3\u591F\u5C0F\uFF0C\u6216\u6700\u8FD1\u8F6E\u6B21\u672C\u8EAB\u5DF2\u8D85\u8FC7\u9884\u7B97\u3002",
+      compactDone: "\u25B8 \u5DF2\u6298\u53E0 {before} \u6761\u6D88\u606F \u2192 {after}\uFF08\u6458\u8981 {chars} \u5B57\u7B26\uFF09\u3002\u7EE7\u7EED\u3002",
+      compactFailed: "\u25B8 \u6298\u53E0\u5931\u8D25\uFF1A{reason}",
+      costNoTurn: "\u5C1A\u65E0\u8F6E\u6B21 \u2014 `/cost` \u663E\u793A\u6700\u8FD1\u4E00\u8F6E\u7684 token + \u82B1\u8D39\u660E\u7EC6\u3002",
+      costNeedsTui: "/cost \u9700\u8981 TUI \u4E0A\u4E0B\u6587\uFF08postUsage \u5DF2\u8FDE\u63A5\uFF09\u3002",
+      costNoPricing: '\u25B8 /cost\uFF1A\u6A21\u578B "{model}" \u65E0\u5B9A\u4EF7\u8868\u3002\u8BF7\u5728 telemetry/stats.ts \u4E2D\u6DFB\u52A0\u3002',
+      costEstimate: "\u25B8 /cost \u4F30\u7B97 \xB7 {model} \xB7 {prompt} prompt tokens\uFF08\u7CFB\u7EDF {sys} + \u5DE5\u5177 {tools} + \u65E5\u5FD7 {log} + \u6D88\u606F {msg}\uFF09",
+      costWorstCase: "  \u6700\u574F\u60C5\u51B5\uFF08\u5B8C\u5168\u672A\u547D\u4E2D\uFF09\uFF1A{input} \u8F93\u5165 + ~{output} \u8F93\u51FA\uFF08{avg} \u5E73\u5747\uFF09\u2248 {total}",
+      costLikely: "  \u53EF\u80FD\uFF08{pct}% \u4F1A\u8BDD\u7F13\u5B58\u547D\u4E2D\uFF09\uFF1A{input} \u8F93\u5165 + ~{output} \u8F93\u51FA \u2248 {total}",
+      costLikelyCold: "  \u53EF\u80FD\uFF1A\u5728\u7F13\u5B58\u586B\u5145\u524D\u4E0E\u6700\u574F\u60C5\u51B5\u76F8\u540C\uFF08\u65E0\u5DF2\u5B8C\u6210\u7684\u8F6E\u6B21\uFF09",
+      statusModel: "  \u6A21\u578B    {model}",
+      statusFlags: "  \u6807\u5FD7    stream={stream} \xB7 effort={effort}",
+      statusCtx: "  \u4E0A\u4E0B\u6587  {bar} {used}/{max}\uFF08{pct}%\uFF09",
+      statusCtxNone: "  \u4E0A\u4E0B\u6587  \u5C1A\u65E0\u8F6E\u6B21",
+      statusCost: "  \u6210\u672C    ${cost} \xB7 \u7F13\u5B58 {bar} {pct}% \xB7 \u8F6E\u6B21 {turns}",
+      statusCostCold: "  \u6210\u672C    ${cost} \xB7 \u8F6E\u6B21 {turns}\uFF08\u7F13\u5B58\u9884\u70ED\u4E2D\uFF09",
+      statusBudget: "  \u9884\u7B97    ${spent} / ${cap}\uFF08{pct}%\uFF09{tag}",
+      statusSession: '  \u4F1A\u8BDD    "{name}" \xB7 \u65E5\u5FD7\u4E2D {count} \u6761\u6D88\u606F\uFF08\u6062\u590D\u4E86 {resumed} \u6761\uFF09',
+      statusSessionEphemeral: "  \u4F1A\u8BDD    \uFF08\u4E34\u65F6 \u2014 \u65E0\u6301\u4E45\u5316\uFF09",
+      statusWorkspace: "  \u5DE5\u4F5C\u533A  {path} \xB7 \u542F\u52A8\u65F6\u9501\u5B9A\uFF08\u7528 --dir <path> \u91CD\u65B0\u542F\u52A8\u4EE5\u5207\u6362\uFF09",
+      statusMcp: "  MCP     {servers} \u4E2A\u670D\u52A1\u5668\uFF0C\u6CE8\u518C\u8868\u4E2D {tools} \u4E2A\u5DE5\u5177",
+      statusEdits: "  \u7F16\u8F91    {count} \u4E2A\u5F85\u5904\u7406\uFF08/apply \u63D0\u4EA4\uFF0C/discard \u4E22\u5F03\uFF09",
+      statusPlan: "  \u8BA1\u5212    \u5F00\u542F \u2014 \u5199\u5165\u53D7\u9650\uFF08submit_plan + \u5BA1\u6279\uFF09",
+      statusModeYolo: "  \u6A21\u5F0F    YOLO \u2014 \u7F16\u8F91 + shell \u81EA\u52A8\u8FD0\u884C\uFF0C\u65E0\u63D0\u793A\uFF08/undo \u4ECD\u53EF\u56DE\u6EDA \xB7 Shift+Tab \u5207\u6362\uFF09",
+      statusModeAuto: "  \u6A21\u5F0F    AUTO \u2014 \u7F16\u8F91\u7ACB\u5373\u5E94\u7528\uFF085 \u79D2\u5185\u6309 u \u64A4\u6D88 \xB7 Shift+Tab \u5207\u6362\uFF09",
+      statusModeReview: "  \u6A21\u5F0F    review \u2014 \u7F16\u8F91\u6392\u961F\u7B49\u5F85 /apply \u6216 y\uFF08Shift+Tab \u5207\u6362\uFF09",
+      statusDash: "  \u4EEA\u8868\u677F  {url}\uFF08\u5728\u6D4F\u89C8\u5668\u4E2D\u6253\u5F00 \xB7 /dashboard stop\uFF09"
+    },
+    plans: {
+      noSession: "\u672A\u9644\u52A0\u4F1A\u8BDD \u2014 `/plans` \u662F\u6309\u4F1A\u8BDD\u7684\u3002\u5728\u9879\u76EE\u4E2D\u8FD0\u884C `reasonix code` \u4EE5\u83B7\u53D6\u4F1A\u8BDD\u3002",
+      activePlan: "\u25B8 \u6D3B\u8DC3\u8BA1\u5212{label} \u2014 {done}/{total} \u6B65\u9AA4\u5DF2\u5B8C\u6210 \xB7 \u6700\u540E\u89E6\u53CA {when}",
+      activeNone: "\u25B8 \u6D3B\u8DC3\u8BA1\u5212\uFF1A\uFF08\u65E0\uFF09",
+      noArchives: "\u6B64\u4F1A\u8BDD\u5C1A\u65E0\u5F52\u6863\u8BA1\u5212 \u2014 \u5F53\u6BCF\u4E2A\u6B65\u9AA4\u5B8C\u6210\u65F6\u81EA\u52A8\u5F52\u6863",
+      archivedHeader: "\u5DF2\u5F52\u6863\uFF08{count}\uFF09\uFF1A",
+      replayNoSession: "\u672A\u9644\u52A0\u4F1A\u8BDD \u2014 `/replay` \u662F\u6309\u4F1A\u8BDD\u7684\u3002\u5728\u9879\u76EE\u4E2D\u8FD0\u884C `reasonix code` \u4EE5\u83B7\u53D6\u4F1A\u8BDD\u3002",
+      replayNoArchives: "\u6B64\u4F1A\u8BDD\u5C1A\u65E0\u5F52\u6863\u8BA1\u5212 \u2014 `/replay` \u5728\u8BA1\u5212\u5B8C\u6210\u540E\u542F\u7528\uFF08\u6BCF\u4E2A\u6B65\u9AA4\u5B8C\u6210\u65F6\u81EA\u52A8\u5F52\u6863\uFF09\u3002",
+      replayInvalidIndex: "\u65E0\u6548\u7D22\u5F15 \u2014 `/replay` \u63A5\u53D7 1..{max}\uFF08\u6700\u65B0 = 1\uFF09\u3002\u4F7F\u7528 `/plans` \u67E5\u770B\u5217\u8868\u3002",
+      archivedRow: "  \u2713 {when}  {total}\u6B65 \xB7 {completion}  {label}",
+      completionComplete: "\u5DF2\u5B8C\u6210",
+      stopAborted: "\u25B8 \u8BA1\u5212\u5DF2\u505C\u6B62 \u2014 \u6A21\u578B\u5DF2\u4E2D\u6B62\uFF1B\u8F93\u5165\u540E\u7EED\u5185\u5BB9\u7EE7\u7EED\uFF0C\u6216\u5F00\u59CB\u65B0\u4EFB\u52A1\u3002"
+    },
+    jobs: {
+      codeOnly: "/jobs \u4EC5\u5728 `reasonix code` \u4E2D\u53EF\u7528\u3002",
+      killCodeOnly: "/kill \u4EC5\u5728 `reasonix code` \u4E2D\u53EF\u7528\u3002",
+      logsCodeOnly: "/logs \u4EC5\u5728 `reasonix code` \u4E2D\u53EF\u7528\u3002",
+      empty: "\u25C8 \u4F5C\u4E1A \xB7 0 \u8FD0\u884C\u4E2D \xB7 \u5171 0 \u4E2A\n  \uFF08run_background \u751F\u6210\u4E00\u4E2A \u2014 \u5F00\u53D1\u670D\u52A1\u5668\u3001\u76D1\u89C6\u5668\u3001\u957F\u65F6\u95F4\u8FD0\u884C\u7684\u811A\u672C\uFF09",
+      header: "\u25C8 \u4F5C\u4E1A \xB7 {running} \u8FD0\u884C\u4E2D \xB7 \u5171 {total} \u4E2A",
+      footer: "  /logs <id> \u8DDF\u8E2A \xB7 /kill <id> SIGTERM \u2192 SIGKILL",
+      killUsage: "\u7528\u6CD5\uFF1A/kill <id>   \uFF08\u89C1 /jobs \u83B7\u53D6 ID\uFF09",
+      killNotFound: "\u4F5C\u4E1A {id}\uFF1A\u672A\u627E\u5230",
+      killAlreadyExited: "\u4F5C\u4E1A {id} \u5DF2\u9000\u51FA\uFF08{code}\uFF09",
+      killStopping: "\u25B8 \u6B63\u5728\u505C\u6B62\u4F5C\u4E1A {id}\uFF08\u6811\u7EC8\u6B62\uFF1ASIGTERM \u2192 2 \u79D2\u5BBD\u9650\u671F\u540E SIGKILL\uFF1BWindows\uFF1Ataskkill /T /F\uFF09",
+      killStatus: "\u25B8 \u4F5C\u4E1A {id} {status}",
+      killStillAlive: "SIGKILL \u540E\u4ECD\u5B58\u6D3B (!) \u2014 \u8BF7\u5C06\u6B64\u4F5C\u4E3A bug \u62A5\u544A",
+      logsUsage: "\u7528\u6CD5\uFF1A/logs <id> [lines]   \uFF08\u9ED8\u8BA4\u6700\u540E 80 \u884C\uFF09",
+      logsNotFound: "\u4F5C\u4E1A {id}\uFF1A\u672A\u627E\u5230",
+      logsStatus: "[\u4F5C\u4E1A {id} \xB7 {status}]\n$ {command}",
+      logsRunning: "\u8FD0\u884C\u4E2D \xB7 pid {pid}",
+      logsExited: "\u5DF2\u9000\u51FA {code}",
+      logsFailed: "\u5931\u8D25\uFF08{reason}\uFF09",
+      logsStopped: "\u5DF2\u505C\u6B62"
+    },
+    memory: {
+      disabled: "\u8BB0\u5FC6\u5DF2\u7981\u7528\uFF08\u73AF\u5883\u53D8\u91CF REASONIX_MEMORY=off\uFF09\u3002\u53D6\u6D88\u8BBE\u7F6E\u8BE5\u53D8\u91CF\u4EE5\u91CD\u65B0\u542F\u7528 \u2014 \u6B64\u671F\u95F4\u4E0D\u4F1A\u56FA\u5B9A\u4EFB\u4F55 REASONIX.md \u6216 ~/.reasonix/memory \u5185\u5BB9\u3002",
+      noRoot: "\u6B64\u4F1A\u8BDD\u65E0\u5DE5\u4F5C\u76EE\u5F55 \u2014 `/memory` \u9700\u8981\u4E00\u4E2A\u6839\u76EE\u5F55\u6765\u89E3\u6790 REASONIX.md\u3002\uFF08\u5728\u6D4B\u8BD5\u73AF\u5883\u4E2D\u8FD0\u884C\uFF1F\uFF09",
+      listEmpty: "\u5C1A\u65E0\u7528\u6237\u8BB0\u5FC6\u3002\u6A21\u578B\u53EF\u4EE5\u8C03\u7528 `remember` \u4FDD\u5B58\u4E00\u4E2A\uFF0C\u6216\u60A8\u53EF\u4EE5\u5728 ~/.reasonix/memory/global/ \u6216\u9879\u76EE\u5B50\u76EE\u5F55\u4E2D\u624B\u52A8\u521B\u5EFA\u6587\u4EF6\u3002",
+      listHeader: "\u7528\u6237\u8BB0\u5FC6\uFF08{count}\uFF09\uFF1A",
+      listFooter: "\u67E5\u770B\u6B63\u6587\uFF1A/memory show <name>   \u5220\u9664\uFF1A/memory forget <name>",
+      showUsage: "\u7528\u6CD5\uFF1A/memory show <name>  \u6216  /memory show <scope>/<name>",
+      showNotFound: "\u672A\u627E\u5230\u8BB0\u5FC6\uFF1A{target}",
+      showFailed: "\u663E\u793A\u5931\u8D25\uFF1A{reason}",
+      forgetUsage: "\u7528\u6CD5\uFF1A/memory forget <name>  \u6216  /memory forget <scope>/<name>",
+      forgetNotFound: "\u672A\u627E\u5230\u8BB0\u5FC6\uFF1A{target}",
+      forgetInfo: "\u25B8 \u5DF2\u9057\u5FD8 {scope}/{name}\u3002\u4E0B\u6B21 /new \u6216\u542F\u52A8\u65F6\u5C06\u4E0D\u53EF\u89C1\u3002",
+      forgetFailed: "\u65E0\u6CD5\u9057\u5FD8 {scope}/{name}\uFF08\u5DF2\u6D88\u5931\uFF1F\uFF09",
+      forgetError: "\u9057\u5FD8\u5931\u8D25\uFF1A{reason}",
+      clearUsage: "\u7528\u6CD5\uFF1A/memory clear <global|project> confirm",
+      clearConfirm: "\u5373\u5C06\u5220\u9664 scope={scope} \u4E2D\u7684\u6BCF\u4E2A\u8BB0\u5FC6\u3002\u91CD\u65B0\u8FD0\u884C\u5E76\u9644\u5E26 'confirm' \u4E00\u8BCD\u4EE5\u7EE7\u7EED\uFF1A/memory clear {scope} confirm",
+      cleared: "\u25B8 \u5DF2\u6E05\u9664 scope={scope} \u2014 \u5220\u9664\u4E86 {count} \u4E2A\u8BB0\u5FC6\u6587\u4EF6\u3002",
+      noMemory: "\u5728 {root} \u4E2D\u672A\u56FA\u5B9A\u8BB0\u5FC6\u3002",
+      layers: "\u53EF\u7528\u7684\u4E09\u4E2A\u5C42\u7EA7\uFF1A",
+      layerProject: "  1. {file} \u2014 \u53EF\u63D0\u4EA4\u7684\u56E2\u961F\u8BB0\u5FC6\uFF08\u5728\u4ED3\u5E93\u4E2D\uFF09\u3002",
+      layerGlobal: "  2. ~/.reasonix/memory/global/ \u2014 \u60A8\u7684\u8DE8\u9879\u76EE\u79C1\u6709\u8BB0\u5FC6\u3002",
+      layerProjectHash: "  3. ~/.reasonix/memory/<project-hash>/ \u2014 \u6B64\u9879\u76EE\u7684\u79C1\u6709\u8BB0\u5FC6\u3002",
+      askModel: "\u8BA9\u6A21\u578B `remember` \u67D0\u4E9B\u5185\u5BB9\uFF0C\u6216\u76F4\u63A5\u624B\u7F16\u8F91\u6587\u4EF6\u3002",
+      changesNote: "\u66F4\u6539\u5728\u4E0B\u6B21 /new \u6216\u542F\u52A8\u65F6\u751F\u6548 \u2014 \u7CFB\u7EDF\u63D0\u793A\u8BCD\u6BCF\u4F1A\u8BDD\u54C8\u5E0C\u4E00\u6B21\u4EE5\u4FDD\u6301\u524D\u7F00\u7F13\u5B58\u70ED\u5EA6\u3002",
+      subcommands: "\u5B50\u547D\u4EE4\uFF1A/memory list | /memory show <name> | /memory forget <name> | /memory clear <scope> confirm",
+      changesNoteShort: "\u66F4\u6539\u5728\u4E0B\u6B21 /new \u6216\u542F\u52A8\u65F6\u751F\u6548\u3002\u5B50\u547D\u4EE4\uFF1A/memory list | show | forget | clear"
+    },
+    mcp: {
+      noServers: '\u672A\u9644\u52A0 MCP \u670D\u52A1\u5668\u3002\u8FD0\u884C `reasonix setup` \u9009\u62E9\u4E00\u4E9B\uFF0C\u6216\u4F7F\u7528 --mcp "<spec>" \u542F\u52A8\u3002`reasonix mcp list` \u663E\u793A\u76EE\u5F55\u3002',
+      toolsLabel: "  \u5DE5\u5177     {count}",
+      resourcesHint: "`/resource` \u6D4F\u89C8+\u8BFB\u53D6",
+      promptsHint: "`/prompt` \u6D4F\u89C8+\u83B7\u53D6",
+      awarenessOnly: "\u804A\u5929\u6A21\u5F0F\u76EE\u524D\u6D88\u8017\u5DE5\u5177\uFF1B\u8D44\u6E90+\u63D0\u793A\u5728\u6B64\u5C55\u793A\u4F9B\u4E86\u89E3\u3002",
+      catalogHint: "\u5B8C\u6574\u76EE\u5F55\uFF1A`reasonix mcp list` \xB7 \u6DF1\u5EA6\u8BCA\u65AD\uFF1A`reasonix mcp inspect <spec>`\u3002",
+      fallbackServers: "MCP \u670D\u52A1\u5668\uFF08{count}\uFF09\uFF1A",
+      fallbackTools: "\u6CE8\u518C\u8868\u4E2D\u7684\u5DE5\u5177\uFF08{count}\uFF09\uFF1A",
+      fallbackChange: "\u8981\u66F4\u6539\u6B64\u8BBE\u7F6E\uFF0C\u8BF7\u9000\u51FA\u5E76\u8FD0\u884C `reasonix setup`\u3002",
+      usageDisableEnable: "\u7528\u6CD5\uFF1A/mcp {action} <name>  \xB7  \u4ECE /mcp \u5217\u8868\u4E2D\u6311\u4E00\u4E2A\u540D\u5B57\uFF08\u533F\u540D\u670D\u52A1\u5668\u65E0\u6CD5\u6309\u540D\u5207\u6362\uFF09\u3002",
+      usageReconnect: "\u7528\u6CD5\uFF1A/mcp reconnect <name>  \xB7  \u4ECE /mcp \u5217\u8868\u4E2D\u6311\u4E00\u4E2A\u540D\u5B57\u3002",
+      unknownServer: '\u672A\u77E5 MCP \u670D\u52A1\u5668 "{name}"\u3002\u5DF2\u77E5\uFF1A{list}\u3002',
+      noneList: "\uFF08\u65E0\uFF09",
+      reconnectNoTui: "/mcp reconnect \u9700\u8981\u4EA4\u4E92\u5F0F TUI\uFF08postInfo \u672A\u8FDE\u63A5\uFF09\u3002"
+    },
+    init: {
+      codeOnly: "/init \u4EC5\u5728\u4EE3\u7801\u6A21\u5F0F\u4E0B\u5DE5\u4F5C\uFF08\u9700\u8981\u6587\u4EF6\u7CFB\u7EDF\u5DE5\u5177\uFF09\u3002\n\u8FD0\u884C `reasonix code [path]` \u542F\u52A8\u4E00\u4E2A\u4EE5\u60A8\u8981\u521D\u59CB\u5316\u7684\u9879\u76EE\u4E3A\u6839\u7684\u4F1A\u8BDD\uFF0C\n\u7136\u540E\u8FD0\u884C /init\u3002",
+      exists: "\u25B8 REASONIX.md \u5DF2\u5B58\u5728\u4E8E {path}",
+      existsForce: "  /init force   \u4ECE\u5934\u91CD\u65B0\u751F\u6210\uFF08\u8986\u76D6\uFF09",
+      existsEdit: "  \u6216\u624B\u52A8\u7F16\u8F91 \u2014 \u5B83\u53EA\u662F markdown\u3002\u5F53\u524D\u6587\u4EF6\u5DF2",
+      existsPinned: "  \u56FA\u5B9A\u5230\u6BCF\u6B21\u542F\u52A8\u7684\u7CFB\u7EDF\u63D0\u793A\u8BCD\u4E2D\u3002",
+      info: "\u25B8 /init \u2014 \u6A21\u578B\u5C06\u626B\u63CF\u9879\u76EE\u5E76\u5408\u6210 REASONIX.md\u3002\n  \u7ED3\u679C\u5C06\u4F5C\u4E3A\u5F85\u5904\u7406\u7684\u7F16\u8F91\uFF1B\u4F7F\u7528 /apply \u6216 /walk \u5BA1\u67E5\u3002"
+    },
+    webSearchEngine: {
+      currentEngine: "\u5F53\u524D\u7F51\u9875\u641C\u7D22\u5F15\u64CE\uFF1A{engine}",
+      endpoint: "SearXNG \u7AEF\u70B9\uFF1A{url}",
+      usageHeader: "\u7528\u6CD5\uFF1A",
+      usageMojeek: "  /search-engine mojeek            \u4F7F\u7528 Mojeek\uFF08\u9ED8\u8BA4\uFF0C\u65E0\u5916\u90E8\u4F9D\u8D56\uFF09",
+      usageSearxng: "  /search-engine searxng            \u4F7F\u7528 SearXNG \u9ED8\u8BA4\u7AEF\u70B9",
+      usageSearxngUrl: "  /search-engine searxng <url>      \u4F7F\u7528 SearXNG \u81EA\u5B9A\u4E49\u7AEF\u70B9",
+      alias: "\u522B\u540D\uFF1A/se",
+      searxngInfo: "SearXNG \u662F\u4E00\u4E2A\u81EA\u6258\u7BA1\u7684\u5143\u641C\u7D22\u5F15\u64CE\uFF08https://github.com/searxng/searxng\uFF09\u3002",
+      searxngInstall: "\u5B89\u88C5\u547D\u4EE4\uFF1A  docker run -d -p 8080:8080 searxng/searxng",
+      switched: '\u5DF2\u5207\u6362\u7F51\u9875\u641C\u7D22\u5F15\u64CE\u4E3A "{engine}"\u3002{note}',
+      switchedSearxngNote: " \u8BF7\u786E\u4FDD SearXNG \u5728 {endpoint} \u8FD0\u884C\u3002",
+      confirmed: '\u2713 \u7F51\u9875\u641C\u7D22\u5F15\u64CE\u5DF2\u8BBE\u4E3A "{engine}"{detail}\u3002\u4E0B\u4E00\u8F6E\u6A21\u578B\u8C03\u7528\u5C06\u751F\u6548\u3002',
+      confirmedDetail: "\uFF08{endpoint}\uFF09"
+    },
+    skill: {
+      listEmpty: "\u672A\u627E\u5230\u6280\u80FD\u3002Reasonix \u4ECE\u4EE5\u4E0B\u4F4D\u7F6E\u8BFB\u53D6\u6280\u80FD\uFF1A",
+      listProjectScope: "  \xB7 <project>/.reasonix/skills/<name>/SKILL.md  \uFF08\u6216 <name>.md\uFF09 \u2014 \u9879\u76EE\u8303\u56F4",
+      listGlobalScope: "  \xB7 ~/.reasonix/skills/<name>/SKILL.md  \uFF08\u6216 <name>.md\uFF09 \u2014 \u5168\u5C40\u8303\u56F4",
+      listProjectOnly: "  \uFF08\u9879\u76EE\u8303\u56F4\u4EC5\u5728 `reasonix code` \u4E2D\u6D3B\u8DC3\uFF09",
+      listFrontmatter: "\u6BCF\u4E2A\u6587\u4EF6\u7684 frontmatter \u81F3\u5C11\u9700\u8981 `name` \u548C `description`\u3002",
+      listInvoke: "\u4F7F\u7528 `/skill <name> [args]` \u8C03\u7528\u6280\u80FD\uFF0C\u6216\u8BA9\u6A21\u578B\u8C03\u7528 `run_skill`\u3002",
+      listHeader: "\u7528\u6237\u6280\u80FD\uFF08{count}\uFF09\uFF1A",
+      listFooter: "\u67E5\u770B\uFF1A/skill show <name>   \u8FD0\u884C\uFF1A/skill <name> [args]   \u65B0\u5EFA\uFF1A/skill new <name>",
+      listEmptyNewHint: "\u7528 `/skill new <name>` \u5728\u9879\u76EE\u8303\u56F4\u4E0B\u751F\u6210\u4E00\u4E2A\u7A7A\u767D\u6A21\u677F \u2014 \u6682\u65E0\u5728\u7EBF\u5E02\u573A\uFF0C\u6280\u80FD\u9700\u8981\u81EA\u5DF1\u5199\u3002",
+      showUsage: "\u7528\u6CD5\uFF1A/skill show <name>",
+      showNotFound: "\u672A\u627E\u5230\u6280\u80FD\uFF1A{name}",
+      runNotFound: "\u672A\u627E\u5230\u6280\u80FD\uFF1A{name}  \uFF08\u5C1D\u8BD5 /skill list\uFF09",
+      runInfo: "\u25B8 \u6B63\u5728\u8FD0\u884C\u6280\u80FD\uFF1A{name}{args}",
+      newUsage: "\u7528\u6CD5\uFF1A/skill new <name> [--global]",
+      newCreated: "\u25B8 \u5DF2\u521B\u5EFA\u6280\u80FD\uFF1A{name}\n  {path}\n  \u7F16\u8F91\u540E\u7528 `/skill {name}` \u8C03\u7528",
+      newError: "\u25B2 /skill new \u5931\u8D25\uFF1A{reason}"
+    }
+  }
+};
+
+// src/i18n/index.ts
+var translations = {
+  EN,
+  "zh-CN": zhCN
+};
+function detectSystemLanguage(locale = Intl.DateTimeFormat().resolvedOptions().locale) {
+  if (locale.startsWith("zh")) return "zh-CN";
+  if (locale.startsWith("en")) return "EN";
+  return null;
+}
+var currentLang = loadLanguage() ?? detectSystemLanguage() ?? "EN";
+function t(path2, params) {
+  const parts = path2.split(".");
+  let val = translations[currentLang] || translations.EN;
+  for (const part of parts) {
+    val = val?.[part];
+    if (val === void 0) break;
+  }
+  if (val === void 0 && currentLang !== "EN") {
+    val = translations.EN;
+    for (const part of parts) {
+      val = val?.[part];
+      if (val === void 0) break;
+    }
+  }
+  if (typeof val !== "string") {
+    return path2;
+  }
+  if (params) {
+    let result = val;
+    for (const [k, v] of Object.entries(params)) {
+      result = result.replace(new RegExp(`\\{${k}\\}`, "g"), String(v));
+    }
+    return result;
+  }
+  return val;
+}
 
 // src/hooks.ts
-import { spawn } from "child_process";
-import { existsSync, readFileSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
 var HOOK_EVENTS = [
   "PreToolUse",
   "PostToolUse",
@@ -564,15 +1995,15 @@ var DEFAULT_TIMEOUTS_MS = {
 var HOOK_SETTINGS_FILENAME = "settings.json";
 var HOOK_SETTINGS_DIRNAME = ".reasonix";
 function globalSettingsPath(homeDirOverride) {
-  return join(homeDirOverride ?? homedir(), HOOK_SETTINGS_DIRNAME, HOOK_SETTINGS_FILENAME);
+  return join2(homeDirOverride ?? homedir2(), HOOK_SETTINGS_DIRNAME, HOOK_SETTINGS_FILENAME);
 }
 function projectSettingsPath(projectRoot) {
-  return join(projectRoot, HOOK_SETTINGS_DIRNAME, HOOK_SETTINGS_FILENAME);
+  return join2(projectRoot, HOOK_SETTINGS_DIRNAME, HOOK_SETTINGS_FILENAME);
 }
 function readSettingsFile(path2) {
   if (!existsSync(path2)) return null;
   try {
-    const raw = readFileSync(path2, "utf8");
+    const raw = readFileSync2(path2, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object") return parsed;
   } catch {
@@ -691,9 +2122,12 @@ function formatHookOutcomeMessage(outcome) {
   const detail = (outcome.stderr || outcome.stdout || "").trim();
   const tag = `${outcome.hook.scope}/${outcome.hook.event}`;
   const cmd = outcome.hook.command.length > 60 ? `${outcome.hook.command.slice(0, 60)}\u2026` : outcome.hook.command;
-  const truncTag = outcome.truncated ? " (output truncated at 256KB)" : "";
-  const head = `hook ${tag} \`${cmd}\` ${outcome.decision}${truncTag}`;
-  return detail ? `${head}: ${detail}` : head;
+  const truncTag = outcome.truncated ? t("hooks.truncated") : "";
+  const decision = t(`hooks.decision${capitalize(outcome.decision)}`);
+  return detail ? t("hooks.headWithDetail", { tag, cmd, decision, truncTag, detail }) : t("hooks.head", { tag, cmd, decision, truncTag });
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
 }
 function decideOutcome(event, raw) {
   if (raw.spawnError) return "error";
@@ -735,9 +2169,9 @@ async function runHooks(opts) {
 }
 
 // src/tokenizer.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
 import { createRequire } from "module";
-import { dirname, join as join2 } from "path";
+import { dirname as dirname2, join as join3 } from "path";
 import { fileURLToPath } from "url";
 import { gunzipSync } from "zlib";
 function buildByteToChar() {
@@ -765,26 +2199,26 @@ function resolveDataPath() {
   if (process.env.REASONIX_TOKENIZER_PATH) return process.env.REASONIX_TOKENIZER_PATH;
   const candidates = [];
   try {
-    const here = dirname(fileURLToPath(import.meta.url));
-    candidates.push(join2(here, "..", "data", "deepseek-tokenizer.json.gz"));
-    candidates.push(join2(here, "..", "..", "data", "deepseek-tokenizer.json.gz"));
+    const here = dirname2(fileURLToPath(import.meta.url));
+    candidates.push(join3(here, "..", "data", "deepseek-tokenizer.json.gz"));
+    candidates.push(join3(here, "..", "..", "data", "deepseek-tokenizer.json.gz"));
   } catch {
   }
   try {
     const req = createRequire(import.meta.url);
     candidates.push(
-      join2(dirname(req.resolve("reasonix/package.json")), "data", "deepseek-tokenizer.json.gz")
+      join3(dirname2(req.resolve("reasonix/package.json")), "data", "deepseek-tokenizer.json.gz")
     );
   } catch {
   }
   for (const p of candidates) {
     if (existsSync2(p)) return p;
   }
-  return candidates[0] ?? join2(process.cwd(), "data", "deepseek-tokenizer.json.gz");
+  return candidates[0] ?? join3(process.cwd(), "data", "deepseek-tokenizer.json.gz");
 }
 function loadTokenizer() {
   if (cached) return cached;
-  const buf = readFileSync2(resolveDataPath());
+  const buf = readFileSync3(resolveDataPath());
   const json = gunzipSync(buf).toString("utf8");
   const data = JSON.parse(json);
   const mergeRank = /* @__PURE__ */ new Map();
@@ -799,10 +2233,10 @@ function loadTokenizer() {
   }
   const addedMap = /* @__PURE__ */ new Map();
   const addedContents = [];
-  for (const t of data.added_tokens) {
-    if (!t.special) {
-      addedMap.set(t.content, t.id);
-      addedContents.push(t.content);
+  for (const t2 of data.added_tokens) {
+    if (!t2.special) {
+      addedMap.set(t2.content, t2.id);
+      addedContents.push(t2.content);
     }
   }
   addedContents.sort((a, b) => b.length - a.length);
@@ -869,29 +2303,29 @@ function bpeEncode(piece, mergeRank) {
 }
 function encode(text) {
   if (!text) return [];
-  const t = loadTokenizer();
+  const t2 = loadTokenizer();
   const ids = [];
   const process2 = (segment) => {
     if (!segment) return;
     let chunks = [segment];
-    for (const re of t.splitRegexes) chunks = applySplit(chunks, re);
+    for (const re of t2.splitRegexes) chunks = applySplit(chunks, re);
     for (const chunk of chunks) {
       if (!chunk) continue;
-      const byteLevel = byteLevelEncode(chunk, t.byteToChar);
-      const pieces = bpeEncode(byteLevel, t.mergeRank);
+      const byteLevel = byteLevelEncode(chunk, t2.byteToChar);
+      const pieces = bpeEncode(byteLevel, t2.mergeRank);
       for (const p of pieces) {
-        const id = t.vocab[p];
+        const id = t2.vocab[p];
         if (id !== void 0) ids.push(id);
       }
     }
   };
-  if (t.addedPattern) {
-    t.addedPattern.lastIndex = 0;
+  if (t2.addedPattern) {
+    t2.addedPattern.lastIndex = 0;
     let last = 0;
-    for (const m of text.matchAll(t.addedPattern)) {
+    for (const m of text.matchAll(t2.addedPattern)) {
       const idx = m.index ?? 0;
       if (idx > last) process2(text.slice(last, idx));
-      const id = t.addedMap.get(m[0]);
+      const id = t2.addedMap.get(m[0]);
       if (id !== void 0) ids.push(id);
       last = idx + m[0].length;
     }
@@ -1051,12 +2485,12 @@ var ToolRegistry = class {
     return this._tools.get(name)?.parallelSafe === true;
   }
   specs() {
-    return [...this._tools.values()].map((t) => ({
+    return [...this._tools.values()].map((t2) => ({
       type: "function",
       function: {
-        name: t.name,
-        description: t.description ?? "",
-        parameters: t.flatSchema ?? t.parameters ?? { type: "object", properties: {} }
+        name: t2.name,
+        description: t2.description ?? "",
+        parameters: t2.flatSchema ?? t2.parameters ?? { type: "object", properties: {} }
       }
     }));
   }
@@ -1308,23 +2742,23 @@ function blockToString(block) {
 import { execFileSync } from "child_process";
 import {
   appendFileSync,
-  chmodSync,
+  chmodSync as chmodSync2,
   existsSync as existsSync3,
-  mkdirSync,
-  readFileSync as readFileSync3,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync4,
   readdirSync,
   renameSync,
   statSync,
   unlinkSync,
-  writeFileSync
+  writeFileSync as writeFileSync2
 } from "fs";
-import { homedir as homedir2 } from "os";
-import { dirname as dirname2, join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname3, join as join4 } from "path";
 function sessionsDir() {
-  return join3(homedir2(), ".reasonix", "sessions");
+  return join4(homedir3(), ".reasonix", "sessions");
 }
 function sessionPath(name) {
-  return join3(sessionsDir(), `${sanitizeName(name)}.jsonl`);
+  return join4(sessionsDir(), `${sanitizeName(name)}.jsonl`);
 }
 function sanitizeName(name) {
   const cleaned = name.replace(/[^\w\-\u4e00-\u9fa5]/g, "_").slice(0, 64);
@@ -1334,7 +2768,7 @@ function loadSessionMessages(name) {
   const path2 = sessionPath(name);
   if (!existsSync3(path2)) return [];
   try {
-    const raw = readFileSync3(path2, "utf8");
+    const raw = readFileSync4(path2, "utf8");
     const out = [];
     for (const line of raw.split(/\r?\n/)) {
       const trimmed = line.trim();
@@ -1352,11 +2786,11 @@ function loadSessionMessages(name) {
 }
 function appendSessionMessage(name, message) {
   const path2 = sessionPath(name);
-  mkdirSync(dirname2(path2), { recursive: true });
+  mkdirSync2(dirname3(path2), { recursive: true });
   appendFileSync(path2, `${JSON.stringify(message)}
 `, "utf8");
   try {
-    chmodSync(path2, 384);
+    chmodSync2(path2, 384);
   } catch {
   }
 }
@@ -1368,7 +2802,7 @@ function listSessions() {
       (f) => f.endsWith(".jsonl") && !f.endsWith(".events.jsonl")
     );
     return files.map((file) => {
-      const path2 = join3(dir, file);
+      const path2 = join4(dir, file);
       const stat2 = statSync(path2);
       const name = file.replace(/\.jsonl$/, "");
       const messageCount = countLines(path2);
@@ -1386,13 +2820,13 @@ function listSessions() {
   }
 }
 function metaPath(name) {
-  return join3(sessionsDir(), `${sanitizeName(name)}.meta.json`);
+  return join4(sessionsDir(), `${sanitizeName(name)}.meta.json`);
 }
 function loadSessionMeta(name) {
   const p = metaPath(name);
   if (!existsSync3(p)) return {};
   try {
-    const raw = JSON.parse(readFileSync3(p, "utf8"));
+    const raw = JSON.parse(readFileSync4(p, "utf8"));
     return raw && typeof raw === "object" ? raw : {};
   } catch {
     return {};
@@ -1416,18 +2850,18 @@ function deleteSession(name) {
 }
 function rewriteSession(name, messages) {
   const path2 = sessionPath(name);
-  mkdirSync(dirname2(path2), { recursive: true });
+  mkdirSync2(dirname3(path2), { recursive: true });
   const body = messages.map((m) => JSON.stringify(m)).join("\n");
-  writeFileSync(path2, body ? `${body}
+  writeFileSync2(path2, body ? `${body}
 ` : "", "utf8");
   try {
-    chmodSync(path2, 384);
+    chmodSync2(path2, 384);
   } catch {
   }
 }
 function countLines(path2) {
   try {
-    const raw = readFileSync3(path2, "utf8");
+    const raw = readFileSync4(path2, "utf8");
     return raw.split(/\r?\n/).filter((l) => l.trim()).length;
   } catch {
     return 0;
@@ -1515,27 +2949,27 @@ var SessionStats = class {
     return stats;
   }
   get totalCost() {
-    return this._carryoverCost + this.turns.reduce((sum, t) => sum + t.cost, 0);
+    return this._carryoverCost + this.turns.reduce((sum, t2) => sum + t2.cost, 0);
   }
   get totalClaudeEquivalent() {
-    return this.turns.reduce((sum, t) => sum + claudeEquivalentCost(t.usage), 0);
+    return this.turns.reduce((sum, t2) => sum + claudeEquivalentCost(t2.usage), 0);
   }
   get savingsVsClaude() {
     const c = this.totalClaudeEquivalent;
     return c > 0 ? 1 - this.totalCost / c : 0;
   }
   get totalInputCost() {
-    return this.turns.reduce((sum, t) => sum + inputCostUsd(t.model, t.usage), 0);
+    return this.turns.reduce((sum, t2) => sum + inputCostUsd(t2.model, t2.usage), 0);
   }
   get totalOutputCost() {
-    return this.turns.reduce((sum, t) => sum + outputCostUsd(t.model, t.usage), 0);
+    return this.turns.reduce((sum, t2) => sum + outputCostUsd(t2.model, t2.usage), 0);
   }
   get aggregateCacheHitRatio() {
     let hit = this._carryoverCacheHit;
     let miss = this._carryoverCacheMiss;
-    for (const t of this.turns) {
-      hit += t.usage.promptCacheHitTokens;
-      miss += t.usage.promptCacheMissTokens;
+    for (const t2 of this.turns) {
+      hit += t2.usage.promptCacheHitTokens;
+      miss += t2.usage.promptCacheMissTokens;
     }
     const denom = hit + miss;
     return denom > 0 ? hit / denom : 0;
@@ -1700,62 +3134,59 @@ var ContextManager = class {
   }
 };
 
-// src/loop/branch.ts
-function summarizeBranch(chosen, samples) {
-  return {
-    budget: samples.length,
-    chosenIndex: chosen.index,
-    uncertainties: samples.map((s) => s.planState.uncertainties.length),
-    temperatures: samples.map((s) => s.temperature)
-  };
-}
-
 // src/loop/errors.ts
-function formatLoopError(err) {
+function formatLoopError(err, probe) {
   const msg = err.message ?? "";
   if (msg.includes("maximum context length")) {
     const reqMatch = msg.match(/requested\s+(\d+)\s+tokens/);
-    const requested = reqMatch ? `${Number(reqMatch[1]).toLocaleString()} tokens` : "too many tokens";
-    return `Context overflow (DeepSeek 400): session history is ${requested}, past the model's prompt limit (V4: 1M tokens; legacy chat/reasoner: 131k). Usually a single tool result grew too big. Reasonix caps new tool results at 8k tokens and auto-heals oversized history on session load \u2014 a restart often clears it. If it still overflows, run /forget (delete the session) or /clear (drop the displayed history) to start fresh.`;
+    const requested = reqMatch ? `${Number(reqMatch[1]).toLocaleString()} tokens` : t("errors.contextOverflowTooMany");
+    return t("errors.contextOverflow", { requested });
   }
   const m = /^DeepSeek (\d{3}):\s*([\s\S]*)$/.exec(msg);
   if (!m) return msg;
   const status = m[1] ?? "";
   const body = m[2] ?? "";
   const inner = extractDeepSeekErrorMessage(body);
-  if (status === "401") {
-    return `Authentication failed (DeepSeek 401): ${inner}. Your API key is rejected. Fix with \`reasonix setup\` or \`export DEEPSEEK_API_KEY=sk-...\`. Get one at https://platform.deepseek.com/api_keys.`;
-  }
-  if (status === "402") {
-    return `Out of balance (DeepSeek 402): ${inner}. Top up at https://platform.deepseek.com/top_up \u2014 the panel header shows your balance once it's non-zero.`;
-  }
-  if (status === "422") {
-    return `Invalid parameter (DeepSeek 422): ${inner}`;
-  }
-  if (status === "400") {
-    return `Bad request (DeepSeek 400): ${inner}`;
-  }
+  if (status === "401") return t("errors.auth401", { inner });
+  if (status === "402") return t("errors.balance402", { inner });
+  if (status === "422") return t("errors.badparam422", { inner });
+  if (status === "400") return t("errors.badrequest400", { inner });
+  if (is5xxStatus(status)) return formatDeepSeek5xx(status, probe);
   return msg;
 }
+function is5xxError(err) {
+  if (!(err instanceof Error)) return false;
+  const m = /^DeepSeek (5\d{2}):/.exec(err.message ?? "");
+  return m !== null;
+}
+async function probeDeepSeekReachable(client, timeoutMs = 1500) {
+  const balance = await client.getBalance({ signal: AbortSignal.timeout(timeoutMs) });
+  return { reachable: balance !== null };
+}
+function is5xxStatus(status) {
+  return status === "500" || status === "502" || status === "503" || status === "504";
+}
+function formatDeepSeek5xx(status, probe) {
+  const head = t("errors.deepseek5xxHead", { status });
+  const probeNote = probe === void 0 ? "" : probe.reachable ? t("errors.deepseek5xxReachable") : t("errors.deepseek5xxUnreachable");
+  const action = probe?.reachable === false ? t("errors.deepseek5xxActionNetwork") : t("errors.deepseek5xxActionRetry");
+  return `${head}${probeNote}${action}`;
+}
 function reasonPrefixFor(reason, iterCap) {
-  if (reason === "aborted") return "[aborted by user (Esc) \u2014 summarizing what I found so far]";
-  if (reason === "context-guard") {
-    return "[context budget running low \u2014 summarizing before the next call would overflow]";
-  }
-  if (reason === "stuck") {
-    return "[stuck on a repeated tool call \u2014 explaining what was tried and what's blocking progress]";
-  }
-  return `[tool-call budget (${iterCap}) reached \u2014 forcing summary from what I found]`;
+  if (reason === "aborted") return t("errors.reasonAborted");
+  if (reason === "context-guard") return t("errors.reasonContextGuard");
+  if (reason === "stuck") return t("errors.reasonStuck");
+  return t("errors.reasonBudget", { iterCap });
 }
 function errorLabelFor(reason, iterCap) {
-  if (reason === "aborted") return "aborted by user";
-  if (reason === "context-guard") return "context-guard triggered (prompt > 80% of window)";
-  if (reason === "stuck") return "stuck (repeated tool call suppressed by storm-breaker)";
-  return `tool-call budget (${iterCap}) reached`;
+  if (reason === "aborted") return t("errors.labelAborted");
+  if (reason === "context-guard") return t("errors.labelContextGuard");
+  if (reason === "stuck") return t("errors.labelStuck");
+  return t("errors.labelBudget", { iterCap });
 }
 function extractDeepSeekErrorMessage(body) {
   const trimmed = body.trim();
-  if (!trimmed) return "(no message)";
+  if (!trimmed) return t("errors.innerNoMessage");
   try {
     const parsed = JSON.parse(trimmed);
     if (parsed && typeof parsed === "object") {
@@ -1782,13 +3213,13 @@ function isEscalationRequest(content) {
   return parseEscalationMarker(content).matched;
 }
 function looksLikePartialEscalationMarker(buf) {
-  const t = buf.trimStart();
-  if (t.length === 0) return true;
-  if (t.length <= NEEDS_PRO_MARKER_PREFIX.length) {
-    return NEEDS_PRO_MARKER_PREFIX.startsWith(t);
+  const t2 = buf.trimStart();
+  if (t2.length === 0) return true;
+  if (t2.length <= NEEDS_PRO_MARKER_PREFIX.length) {
+    return NEEDS_PRO_MARKER_PREFIX.startsWith(t2);
   }
-  if (!t.startsWith(NEEDS_PRO_MARKER_PREFIX)) return false;
-  const rest = t.slice(NEEDS_PRO_MARKER_PREFIX.length);
+  if (!t2.startsWith(NEEDS_PRO_MARKER_PREFIX)) return false;
+  const rest = t2.slice(NEEDS_PRO_MARKER_PREFIX.length);
   if (rest[0] !== ">" && rest[0] !== ":") return false;
   return true;
 }
@@ -1830,7 +3261,7 @@ function buildSyntheticAssistantMessage(content, fallbackModel) {
 // src/loop/force-summary.ts
 async function* forceSummaryAfterIterLimit(ctx, opts = { reason: "budget" }) {
   try {
-    yield { turn: ctx.turn, role: "status", content: "summarizing what was gathered\u2026" };
+    yield { turn: ctx.turn, role: "status", content: t("summary.status") };
     const messages = ctx.buildMessages();
     messages.push({
       role: "user",
@@ -1847,7 +3278,7 @@ async function* forceSummaryAfterIterLimit(ctx, opts = { reason: "budget" }) {
     });
     const rawContent = resp.content?.trim() ?? "";
     const cleaned = stripHallucinatedToolMarkup(rawContent);
-    const summary = cleaned || "(model emitted fake tool-call markup instead of a prose summary \u2014 try /retry with a narrower question, or /think to inspect R1's reasoning)";
+    const summary = cleaned || t("summary.hallucinatedFallback");
     const reasonPrefix = reasonPrefixFor(opts.reason, ctx.maxToolIters);
     const annotated = `${reasonPrefix}
 
@@ -1868,7 +3299,7 @@ ${summary}`;
       turn: ctx.turn,
       role: "error",
       content: "",
-      error: `${label} and the fallback summary call failed: ${err.message}. Run /clear and retry with a narrower question, or raise --max-tool-iters.`
+      error: t("summary.failedAfterReason", { label, message: err.message })
     };
     yield { turn: ctx.turn, role: "done", content: "" };
   }
@@ -2058,19 +3489,19 @@ var ImmutablePrefix = class {
     return [{ role: "system", content: this.system }, ...this.fewShots.map((m) => ({ ...m }))];
   }
   tools() {
-    return this._toolSpecs.map((t) => structuredClone(t));
+    return this._toolSpecs.map((t2) => structuredClone(t2));
   }
   addTool(spec) {
     const name = spec.function?.name;
     if (!name) return false;
-    if (this._toolSpecs.some((t) => t.function?.name === name)) return false;
+    if (this._toolSpecs.some((t2) => t2.function?.name === name)) return false;
     this._toolSpecs.push(spec);
     this._fingerprintCache = null;
     return true;
   }
   /** Mirror of addTool for MCP hot-unbridge. Same cache-miss cost — prefix changes shape. */
   removeTool(name) {
-    const idx = this._toolSpecs.findIndex((t) => t.function?.name === name);
+    const idx = this._toolSpecs.findIndex((t2) => t2.function?.name === name);
     if (idx < 0) return false;
     this._toolSpecs.splice(idx, 1);
     this._fingerprintCache = null;
@@ -2465,13 +3896,9 @@ var CacheFirstLoop = class {
   stats = new SessionStats();
   repair;
   // Mutable via configure() — slash commands in the TUI / library callers tweak
-  // these mid-session so users don't have to restart to try harvest or branch.
+  // these mid-session so users don't have to restart.
   model;
   stream;
-  harvestEnabled;
-  harvestOptions;
-  branchEnabled;
-  branchOptions;
   reasoningEffort;
   autoEscalate = true;
   budgetUsd;
@@ -2509,19 +3936,8 @@ var CacheFirstLoop = class {
     this.hooks = opts.hooks ?? [];
     this.hookCwd = opts.hookCwd ?? process.cwd();
     this.confirmationGate = opts.confirmationGate ?? pauseGate;
-    if (typeof opts.branch === "number") {
-      this.branchOptions = { budget: opts.branch };
-    } else if (opts.branch && typeof opts.branch === "object") {
-      this.branchOptions = opts.branch;
-    } else {
-      this.branchOptions = {};
-    }
-    this.branchEnabled = (this.branchOptions.budget ?? 1) > 1;
-    const harvestForced = this.branchEnabled;
-    this.harvestEnabled = harvestForced || opts.harvest === true || typeof opts.harvest === "object" && opts.harvest !== null;
-    this.harvestOptions = typeof opts.harvest === "object" && opts.harvest !== null ? opts.harvest : this.branchOptions.harvestOptions ?? {};
     this._streamPreference = opts.stream ?? true;
-    this.stream = this.branchEnabled ? false : this._streamPreference;
+    this.stream = this._streamPreference;
     const allowedNames = /* @__PURE__ */ new Set([...this.prefix.toolSpecs.map((s) => s.function.name)]);
     const registry = this.tools;
     const isMutating = (call) => {
@@ -2639,29 +4055,12 @@ var CacheFirstLoop = class {
   }
   configure(opts) {
     if (opts.model !== void 0) this.model = opts.model;
-    if (opts.stream !== void 0) this._streamPreference = opts.stream;
+    if (opts.stream !== void 0) {
+      this._streamPreference = opts.stream;
+      this.stream = opts.stream;
+    }
     if (opts.reasoningEffort !== void 0) this.reasoningEffort = opts.reasoningEffort;
     if (opts.autoEscalate !== void 0) this.autoEscalate = opts.autoEscalate;
-    if (opts.branch !== void 0) {
-      if (typeof opts.branch === "number") {
-        this.branchOptions = { budget: opts.branch };
-      } else if (opts.branch && typeof opts.branch === "object") {
-        this.branchOptions = opts.branch;
-      } else {
-        this.branchOptions = {};
-      }
-      this.branchEnabled = (this.branchOptions.budget ?? 1) > 1;
-    }
-    if (opts.harvest !== void 0) {
-      const want = opts.harvest === true || typeof opts.harvest === "object" && opts.harvest !== null;
-      this.harvestEnabled = want || this.branchEnabled;
-      if (typeof opts.harvest === "object" && opts.harvest !== null) {
-        this.harvestOptions = opts.harvest;
-      }
-    } else if (this.branchEnabled) {
-      this.harvestEnabled = true;
-    }
-    this.stream = this.branchEnabled ? false : this._streamPreference;
   }
   /** `null` disables the cap; any change re-arms the 80% warning. */
   setBudget(usd) {
@@ -2684,6 +4083,10 @@ var CacheFirstLoop = class {
   get escalatedThisTurn() {
     return this._escalateThisTurn;
   }
+  /** UI surface — model id of the call about to run (or running) right now, including escalation. */
+  get currentCallModel() {
+    return this.modelForCurrentCall();
+  }
   modelForCurrentCall() {
     return this._escalateThisTurn ? ESCALATION_MODEL : this.model;
   }
@@ -2776,7 +4179,10 @@ ${reason}`
           turn: this._turn,
           role: "error",
           content: "",
-          error: `session budget exhausted \u2014 spent $${spent.toFixed(4)} \u2265 cap $${this.budgetUsd.toFixed(2)}. Bump the cap with /budget <usd>, clear it with /budget off, or end the session.`
+          error: t("loop.budgetExhausted", {
+            spent: spent.toFixed(4),
+            cap: this.budgetUsd.toFixed(2)
+          })
         };
         return;
       }
@@ -2785,7 +4191,10 @@ ${reason}`
         yield {
           turn: this._turn,
           role: "warning",
-          content: `\u25B2 budget 80% used \u2014 $${spent.toFixed(4)} of $${this.budgetUsd.toFixed(2)}. Next turn or two likely trips the cap.`
+          content: t("loop.budget80Pct", {
+            spent: spent.toFixed(4),
+            cap: this.budgetUsd.toFixed(2)
+          })
         };
       }
     }
@@ -2810,7 +4219,7 @@ ${reason}`
       yield {
         turn: this._turn,
         role: "warning",
-        content: "\u21E7 /pro armed \u2014 this turn runs on deepseek-v4-pro (one-shot \xB7 disarms after turn)"
+        content: t("loop.proArmed")
       };
     }
     let pendingUser = userInput;
@@ -2822,7 +4231,7 @@ ${reason}`
         yield {
           turn: this._turn,
           role: "warning",
-          content: `aborted at iter ${iter}/${this.maxToolIters} \u2014 stopped without producing a summary (press \u2191 + Enter or /retry to resume)`
+          content: t("loop.abortedAtIter", { iter, cap: this.maxToolIters })
         };
         const stoppedMsg = "[aborted by user (Esc) \u2014 no summary produced. Ask again or /retry when ready; prior tool output is still in the log.]";
         this.appendAndPersist(buildSyntheticAssistantMessage(stoppedMsg, this.model));
@@ -2840,7 +4249,7 @@ ${reason}`
         yield {
           turn: this._turn,
           role: "status",
-          content: "tool result uploaded \xB7 model thinking before next response\u2026"
+          content: t("loop.toolUploadStatus")
         };
       }
       if (!warnedForIterBudget && iter >= warnAt) {
@@ -2848,7 +4257,7 @@ ${reason}`
         yield {
           turn: this._turn,
           role: "warning",
-          content: `${iter}/${this.maxToolIters} tool calls used \u2014 approaching budget. Press Esc to force a summary now.`
+          content: t("loop.toolBudgetWarning", { iter, cap: this.maxToolIters })
         };
       }
       let messages = this.buildMessages(pendingUser);
@@ -2859,25 +4268,32 @@ ${reason}`
           yield {
             turn: this._turn,
             role: "status",
-            content: "preflight: context near full, attempting fold\u2026"
+            content: t("loop.preflightFoldStatus")
           };
           const result = await this.context.fold(this.model);
           if (result.folded) {
             yield {
               turn: this._turn,
               role: "warning",
-              content: `preflight: request ~${estimate.toLocaleString()}/${ctxMax.toLocaleString()} tokens (${Math.round(
-                estimate / ctxMax * 100
-              )}%) \u2014 folded ${result.beforeMessages} messages \u2192 ${result.afterMessages} (summary ${result.summaryChars} chars). Sending.`
+              content: t("loop.preflightFolded", {
+                estimate: estimate.toLocaleString(),
+                ctxMax: ctxMax.toLocaleString(),
+                pct: Math.round(estimate / ctxMax * 100),
+                beforeMessages: result.beforeMessages,
+                afterMessages: result.afterMessages,
+                summaryChars: result.summaryChars
+              })
             };
             messages = this.buildMessages(pendingUser);
           } else {
             yield {
               turn: this._turn,
               role: "warning",
-              content: `preflight: request ~${estimate.toLocaleString()}/${ctxMax.toLocaleString()} tokens (${Math.round(
-                estimate / ctxMax * 100
-              )}%) and nothing left to fold \u2014 DeepSeek will likely 400. Run /clear or /new to start fresh.`
+              content: t("loop.preflightNoFold", {
+                estimate: estimate.toLocaleString(),
+                ctxMax: ctxMax.toLocaleString(),
+                pct: Math.round(estimate / ctxMax * 100)
+              })
             };
           }
         }
@@ -2886,89 +4302,8 @@ ${reason}`
       let reasoningContent = "";
       let toolCalls = [];
       let usage = null;
-      let branchSummary;
-      let preHarvestedPlanState;
       try {
-        if (this.branchEnabled) {
-          const budget = this.branchOptions.budget ?? 1;
-          yield {
-            turn: this._turn,
-            role: "branch_start",
-            content: "",
-            branchProgress: {
-              completed: 0,
-              total: budget,
-              latestIndex: -1,
-              latestTemperature: -1,
-              latestUncertainties: -1
-            }
-          };
-          const queue = [];
-          let waiter = null;
-          const onSampleDone = (sample) => {
-            if (waiter) {
-              const w = waiter;
-              waiter = null;
-              w(sample);
-            } else {
-              queue.push(sample);
-            }
-          };
-          const callModel = this.modelForCurrentCall();
-          const branchPromise = runBranches(
-            this.client,
-            {
-              model: callModel,
-              messages,
-              tools: toolSpecs.length ? toolSpecs : void 0,
-              signal,
-              thinking: thinkingModeForModel(callModel),
-              reasoningEffort: this.reasoningEffort
-            },
-            {
-              ...this.branchOptions,
-              harvestOptions: this.harvestOptions,
-              onSampleDone
-            }
-          );
-          for (let k = 0; k < budget; k++) {
-            const sample = queue.shift() ?? await new Promise((resolve10) => {
-              waiter = resolve10;
-            });
-            yield {
-              turn: this._turn,
-              role: "branch_progress",
-              content: "",
-              branchProgress: {
-                completed: k + 1,
-                total: budget,
-                latestIndex: sample.index,
-                latestTemperature: sample.temperature,
-                latestUncertainties: sample.planState.uncertainties.length
-              }
-            };
-          }
-          const result = await branchPromise;
-          assistantContent = result.chosen.response.content;
-          reasoningContent = result.chosen.response.reasoningContent ?? "";
-          toolCalls = result.chosen.response.toolCalls;
-          const agg = aggregateBranchUsage(result.samples);
-          usage = new Usage(
-            agg.promptTokens,
-            agg.completionTokens,
-            agg.totalTokens,
-            agg.promptCacheHitTokens,
-            agg.promptCacheMissTokens
-          );
-          preHarvestedPlanState = result.chosen.planState;
-          branchSummary = summarizeBranch(result.chosen, result.samples);
-          yield {
-            turn: this._turn,
-            role: "branch_done",
-            content: "",
-            branch: branchSummary
-          };
-        } else if (this.stream) {
+        if (this.stream) {
           const callBuf = /* @__PURE__ */ new Map();
           const readyIndices = /* @__PURE__ */ new Set();
           const callModel = this.modelForCurrentCall();
@@ -3076,11 +4411,12 @@ ${reason}`
           this._turnAbort = new AbortController();
           return;
         }
+        const probe = is5xxError(err) ? await probeDeepSeekReachable(this.client) : void 0;
         yield {
           turn: this._turn,
           role: "error",
           content: "",
-          error: formatLoopError(err)
+          error: formatLoopError(err, probe)
         };
         return;
       }
@@ -3091,14 +4427,12 @@ ${reason}`
         yield {
           turn: this._turn,
           role: "warning",
-          content: `\u21E7 flash requested escalation \u2014 retrying this turn on ${ESCALATION_MODEL}${reasonSuffix}`
+          content: t("loop.flashEscalation", { model: ESCALATION_MODEL, reasonSuffix })
         };
         assistantContent = "";
         reasoningContent = "";
         toolCalls = [];
         usage = null;
-        branchSummary = void 0;
-        preHarvestedPlanState = void 0;
         iter--;
         continue;
       }
@@ -3112,14 +4446,6 @@ ${reason}`
         pendingUser = null;
       }
       this.scratch.reasoning = reasoningContent || null;
-      if (!preHarvestedPlanState && this.harvestEnabled && (reasoningContent?.trim().length ?? 0) >= 40) {
-        yield {
-          turn: this._turn,
-          role: "status",
-          content: "extracting plan state from reasoning\u2026"
-        };
-      }
-      const planState = preHarvestedPlanState ? preHarvestedPlanState : this.harvestEnabled ? await harvest(reasoningContent || null, this.client, this.harvestOptions, signal) : emptyPlanState();
       const { calls: repairedCalls, report } = this.repair.process(
         toolCalls,
         reasoningContent || null,
@@ -3138,15 +4464,17 @@ ${reason}`
         role: "assistant_final",
         content: assistantContent,
         stats: turnStats,
-        planState,
-        repair: report,
-        branch: branchSummary
+        repair: report
       };
       if (this.noteToolFailureSignal("", report)) {
         yield {
           turn: this._turn,
           role: "warning",
-          content: `\u21E7 auto-escalating to ${ESCALATION_MODEL} for the rest of this turn \u2014 flash hit ${this._turnFailures.formatBreakdown()}. Next turn falls back to ${this.model} unless /pro is armed.`
+          content: t("loop.autoEscalation", {
+            model: ESCALATION_MODEL,
+            breakdown: this._turnFailures.formatBreakdown(),
+            fallback: this.model
+          })
         };
       }
       const allSuppressed = report.stormsBroken > 0 && repairedCalls.length === 0 && toolCalls.length > 0;
@@ -3171,13 +4499,13 @@ ${reason}`
         yield {
           turn: this._turn,
           role: "warning",
-          content: "Caught a repeated tool call \u2014 let the model see the issue and retry with a different approach."
+          content: t("loop.repeatToolCallWarning")
         };
         continue;
       }
       if (report.stormsBroken > 0) {
         const noteTail = report.notes.length ? ` \u2014 ${report.notes[report.notes.length - 1]}` : "";
-        const phrase = allSuppressed ? "Stopped a stuck retry loop \u2014 the model kept calling the same tool with identical args after a self-correction nudge. Try /retry, rephrase, or rule out the underlying blocker." : `Suppressed ${report.stormsBroken} repeated tool call(s) \u2014 same name + args fired 3+ times.`;
+        const phrase = allSuppressed ? t("loop.stormStuck") : t("loop.stormSuppressed", { count: report.stormsBroken });
         yield {
           turn: this._turn,
           role: "warning",
@@ -3197,20 +4525,28 @@ ${reason}`
         this._foldedThisTurn = true;
         const before = decision.promptTokens;
         const ctxMax = decision.ctxMax;
-        const aggressiveTag = decision.aggressive ? " (aggressive)" : "";
+        const aggressiveTag = decision.aggressive ? t("loop.aggressiveTag") : "";
         yield {
           turn: this._turn,
           role: "status",
-          content: `compacting history${aggressiveTag}\u2026`
+          content: t("loop.compactingHistoryStatus", { aggressiveTag })
         };
         const result = await this.compactHistory({ keepRecentTokens: decision.tailBudget });
         if (result.folded) {
           yield {
             turn: this._turn,
             role: "warning",
-            content: `context ${before.toLocaleString()}/${ctxMax.toLocaleString()} (${Math.round(
-              before / ctxMax * 100
-            )}%) \u2014 ${decision.aggressive ? "aggressively folded" : "folded"} ${result.beforeMessages} messages \u2192 ${result.afterMessages} (summary ${result.summaryChars} chars). Continuing.`
+            content: t(
+              decision.aggressive ? "loop.aggressivelyFoldedHistory" : "loop.foldedHistory",
+              {
+                before: before.toLocaleString(),
+                ctxMax: ctxMax.toLocaleString(),
+                pct: Math.round(before / ctxMax * 100),
+                beforeMessages: result.beforeMessages,
+                afterMessages: result.afterMessages,
+                summaryChars: result.summaryChars
+              }
+            )
           };
         }
       } else if (decision.kind === "exit-with-summary") {
@@ -3219,9 +4555,11 @@ ${reason}`
         yield {
           turn: this._turn,
           role: "warning",
-          content: `context ${before.toLocaleString()}/${ctxMax.toLocaleString()} (${Math.round(
-            before / ctxMax * 100
-          )}%) \u2014 forcing summary from what was gathered. Run /compact, /clear, or /new to reset.`
+          content: t("loop.forcingSummary", {
+            before: before.toLocaleString(),
+            ctxMax: ctxMax.toLocaleString(),
+            pct: Math.round(before / ctxMax * 100)
+          })
         };
         this.context.trimTrailingToolCalls();
         yield* forceSummaryAfterIterLimit(this.summaryContext(), { reason: "context-guard" });
@@ -3279,7 +4617,11 @@ ${reason}`
             yield {
               turn: this._turn,
               role: "warning",
-              content: `\u21E7 auto-escalating to ${ESCALATION_MODEL} for the rest of this turn \u2014 flash hit ${this._turnFailures.formatBreakdown()}. Next turn falls back to ${this.model} unless /pro is armed.`
+              content: t("loop.autoEscalation", {
+                model: ESCALATION_MODEL,
+                breakdown: this._turnFailures.formatBreakdown(),
+                fallback: this.model
+              })
             };
           }
           yield {
@@ -3322,12 +4664,12 @@ function parsePositiveIntEnv(raw) {
 }
 
 // src/at-mentions.ts
-import { existsSync as existsSync4, readFileSync as readFileSync5, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync6, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
 import { readdir, stat } from "fs/promises";
-import { isAbsolute, join as join4, relative, resolve } from "path";
+import { isAbsolute, join as join5, relative, resolve } from "path";
 
 // src/gitignore.ts
-import { readFileSync as readFileSync4 } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
 import { readFile } from "fs/promises";
 import path from "path";
 import ignore from "ignore";
@@ -3340,7 +4682,7 @@ async function loadGitignoreAt(dirAbs) {
 }
 function loadGitignoreAtSync(dirAbs) {
   try {
-    return ignore().add(readFileSync4(path.join(dirAbs, ".gitignore"), "utf8"));
+    return ignore().add(readFileSync5(path.join(dirAbs, ".gitignore"), "utf8"));
   } catch {
     return null;
   }
@@ -3356,6 +4698,7 @@ function ignoredByLayers(layers, abs, isDir) {
 
 // src/at-mentions.ts
 var DEFAULT_AT_MENTION_MAX_BYTES = 64 * 1024;
+var DEFAULT_AT_DIR_MAX_ENTRIES = 200;
 var DEFAULT_PICKER_IGNORE_DIRS = [
   "node_modules",
   ".git",
@@ -3398,7 +4741,7 @@ function listFilesWithStatsSync(root, opts = {}) {
     for (const ent of entries) {
       if (out.length >= maxResults) return;
       const relPath = dirRel ? `${dirRel}/${ent.name}` : ent.name;
-      const absPath = join4(dirAbs, ent.name);
+      const absPath = join5(dirAbs, ent.name);
       if (ent.isDirectory()) {
         if (ent.name.startsWith(".") || ignoreDirs.has(ent.name)) continue;
         if (ignoredByLayers(effectiveLayers, absPath, true)) continue;
@@ -3411,6 +4754,16 @@ function listFilesWithStatsSync(root, opts = {}) {
         } catch {
         }
         out.push({ path: relPath, mtimeMs });
+      } else if (ent.isSymbolicLink()) {
+        let target = null;
+        try {
+          target = statSync2(absPath);
+        } catch {
+          continue;
+        }
+        if (!target.isFile()) continue;
+        if (ignoredByLayers(effectiveLayers, absPath, false)) continue;
+        out.push({ path: relPath, mtimeMs: target.mtimeMs });
       }
     }
   };
@@ -3441,7 +4794,7 @@ async function listFilesWithStatsAsync(root, opts = {}) {
     for (const ent of entries) {
       if (out.length >= maxResults) break;
       const relPath = dirRel ? `${dirRel}/${ent.name}` : ent.name;
-      const absPath = join4(dirAbs, ent.name);
+      const absPath = join5(dirAbs, ent.name);
       if (ent.isDirectory()) {
         if (ent.name.startsWith(".") || ignoreDirs.has(ent.name)) continue;
         if (ignoredByLayers(effectiveLayers, absPath, true)) continue;
@@ -3451,7 +4804,7 @@ async function listFilesWithStatsAsync(root, opts = {}) {
           if (out.length >= maxResults) return;
         }
         await walk2(absPath, relPath, effectiveLayers);
-      } else if (ent.isFile()) {
+      } else if (ent.isFile() || ent.isSymbolicLink()) {
         fileEnts.push(ent);
       }
     }
@@ -3466,19 +4819,23 @@ async function statBatch(ents, dirAbs, dirRel, out, maxResults, layers) {
   const accepted = [];
   for (const e of ents) {
     if (out.length + accepted.length >= maxResults) break;
-    if (ignoredByLayers(layers, join4(dirAbs, e.name), false)) continue;
+    if (ignoredByLayers(layers, join5(dirAbs, e.name), false)) continue;
     accepted.push(e);
   }
   const stats = await Promise.all(
     accepted.map(
-      (e) => stat(join4(dirAbs, e.name)).then((s) => s.mtimeMs).catch(() => 0)
+      (e) => stat(join5(dirAbs, e.name)).then((s) => ({ mtimeMs: s.mtimeMs, isFile: s.isFile() })).catch(() => null)
     )
   );
   for (let i = 0; i < accepted.length; i++) {
     const ent = accepted[i];
+    const s = stats[i];
+    if (ent.isSymbolicLink()) {
+      if (!s || !s.isFile) continue;
+    }
     out.push({
       path: dirRel ? `${dirRel}/${ent.name}` : ent.name,
-      mtimeMs: stats[i] ?? 0
+      mtimeMs: s?.mtimeMs ?? 0
     });
   }
 }
@@ -3539,25 +4896,37 @@ function rankPickerCandidates(files, query, limitOrOpts) {
 var AT_MENTION_PATTERN = /(?<=^|\s)@([a-zA-Z0-9_./\\-]+)/g;
 function expandAtMentions(text, rootDir, opts = {}) {
   const maxBytes = opts.maxBytes ?? DEFAULT_AT_MENTION_MAX_BYTES;
+  const maxDirEntries = Math.max(1, opts.maxDirEntries ?? DEFAULT_AT_DIR_MAX_ENTRIES);
   const fs4 = opts.fs ?? defaultFs;
   const root = resolve(rootDir);
   const seen = /* @__PURE__ */ new Map();
   const expansions = [];
+  const dirListings = /* @__PURE__ */ new Map();
   for (const match of text.matchAll(AT_MENTION_PATTERN)) {
     const rawPath = match[1] ?? "";
     let cleaned = rawPath;
     while (cleaned.endsWith(".")) cleaned = cleaned.slice(0, -1);
+    if (cleaned.endsWith("/") || cleaned.endsWith("\\")) cleaned = cleaned.slice(0, -1);
     if (!cleaned) continue;
     const token = `@${cleaned}`;
     if (seen.has(token)) continue;
-    const expansion = resolveMention(cleaned, root, maxBytes, fs4);
+    const expansion = resolveMention(cleaned, root, maxBytes, maxDirEntries, fs4, dirListings);
     seen.set(token, expansion);
     expansions.push(expansion);
   }
   if (expansions.length === 0) return { text, expansions };
   const blocks = [];
   for (const ex of expansions) {
-    if (ex.ok) {
+    if (ex.ok && ex.isDirectory) {
+      const files = dirListings.get(ex.path) ?? [];
+      const truncAttr = ex.truncated ? ' truncated="true"' : "";
+      const body = files.length > 0 ? `
+${files.join("\n")}
+` : "\n";
+      blocks.push(
+        `<directory path="${ex.path}" entries="${ex.entries ?? files.length}"${truncAttr}>${body}</directory>`
+      );
+    } else if (ex.ok) {
       const content = readSafe(root, ex.path, fs4);
       blocks.push(`<file path="${ex.path}">
 ${content}
@@ -3572,7 +4941,7 @@ ${content}
 ${blocks.join("\n\n")}`;
   return { text: augmented, expansions };
 }
-function resolveMention(rawPath, root, maxBytes, fs4) {
+function resolveMention(rawPath, root, maxBytes, maxDirEntries, fs4, dirListings) {
   if (isAbsolute(rawPath)) {
     return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "escape" };
   }
@@ -3584,14 +4953,26 @@ function resolveMention(rawPath, root, maxBytes, fs4) {
   if (!fs4.exists(resolved)) {
     return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "missing" };
   }
-  if (!fs4.isFile(resolved)) {
-    return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "not-file" };
+  if (fs4.isFile(resolved)) {
+    const size = fs4.size(resolved);
+    if (size > maxBytes) {
+      return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "too-large", bytes: size };
+    }
+    return { token: `@${rawPath}`, path: rawPath, ok: true, bytes: size };
   }
-  const size = fs4.size(resolved);
-  if (size > maxBytes) {
-    return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "too-large", bytes: size };
+  if (fs4.isDir?.(resolved) && fs4.listDir) {
+    const { files, truncated } = fs4.listDir(resolved, root, maxDirEntries);
+    dirListings.set(rawPath, files);
+    return {
+      token: `@${rawPath}`,
+      path: rawPath,
+      ok: true,
+      isDirectory: true,
+      entries: files.length,
+      truncated
+    };
   }
-  return { token: `@${rawPath}`, path: rawPath, ok: true, bytes: size };
+  return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "not-file" };
 }
 function readSafe(root, rawPath, fs4) {
   const resolved = resolve(root, rawPath);
@@ -3610,6 +4991,24 @@ var defaultFs = {
       return false;
     }
   },
+  isDir: (p) => {
+    try {
+      return statSync2(p).isDirectory();
+    } catch {
+      return false;
+    }
+  },
+  listDir: (dirAbs, root, max) => {
+    const dirRel = relative(root, dirAbs).split(/[\\/]/).join("/");
+    const walkCap = Math.max(max * 4, 5e3);
+    const all = listFilesSync(root, { maxResults: walkCap });
+    const prefix = dirRel ? `${dirRel}/` : "";
+    const filtered = dirRel ? all.filter((f) => f === dirRel || f.startsWith(prefix)) : all;
+    return {
+      files: filtered.slice(0, max),
+      truncated: filtered.length > max
+    };
+  },
   size: (p) => {
     try {
       return statSync2(p).size;
@@ -3617,20 +5016,20 @@ var defaultFs = {
       return 0;
     }
   },
-  read: (p) => readFileSync5(p, "utf8")
+  read: (p) => readFileSync6(p, "utf8")
 };
 
 // src/memory/project.ts
-import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync7 } from "fs";
+import { join as join6 } from "path";
 var PROJECT_MEMORY_FILE = "REASONIX.md";
 var PROJECT_MEMORY_MAX_CHARS = 8e3;
 function readProjectMemory(rootDir) {
-  const path2 = join5(rootDir, PROJECT_MEMORY_FILE);
+  const path2 = join6(rootDir, PROJECT_MEMORY_FILE);
   if (!existsSync5(path2)) return null;
   let raw;
   try {
-    raw = readFileSync6(path2, "utf8");
+    raw = readFileSync7(path2, "utf8");
   } catch {
     return null;
   }
@@ -3667,19 +5066,19 @@ ${mem.content}
 import { createHash as createHash2 } from "crypto";
 import {
   existsSync as existsSync7,
-  mkdirSync as mkdirSync3,
-  readFileSync as readFileSync8,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync9,
   readdirSync as readdirSync4,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync4
 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join7, resolve as resolve3 } from "path";
+import { homedir as homedir5 } from "os";
+import { join as join8, resolve as resolve3 } from "path";
 
 // src/skills.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync7, readdirSync as readdirSync3, statSync as statSync3, writeFileSync as writeFileSync2 } from "fs";
-import { homedir as homedir3 } from "os";
-import { dirname as dirname3, join as join6, resolve as resolve2 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync8, readdirSync as readdirSync3, statSync as statSync3, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname4, join as join7, resolve as resolve2 } from "path";
 
 // src/prompt-fragments.ts
 var TUI_FORMATTING_RULES = `Formatting (rendered in a TUI with a real markdown renderer):
@@ -3740,7 +5139,7 @@ var SkillStore = class {
   projectRoot;
   disableBuiltins;
   constructor(opts = {}) {
-    this.homeDir = opts.homeDir ?? homedir3();
+    this.homeDir = opts.homeDir ?? homedir4();
     this.projectRoot = opts.projectRoot ? resolve2(opts.projectRoot) : void 0;
     this.disableBuiltins = opts.disableBuiltins === true;
   }
@@ -3753,11 +5152,11 @@ var SkillStore = class {
     const out = [];
     if (this.projectRoot) {
       out.push({
-        dir: join6(this.projectRoot, ".reasonix", SKILLS_DIRNAME),
+        dir: join7(this.projectRoot, ".reasonix", SKILLS_DIRNAME),
         scope: "project"
       });
     }
-    out.push({ dir: join6(this.homeDir, ".reasonix", SKILLS_DIRNAME), scope: "global" });
+    out.push({ dir: join7(this.homeDir, ".reasonix", SKILLS_DIRNAME), scope: "global" });
     return out;
   }
   /** Higher-priority root wins on collision (project > global > builtin); sorted for stable prefix hash. */
@@ -3792,15 +5191,15 @@ var SkillStore = class {
     if (scope === "project" && !this.projectRoot) {
       return { error: "project scope requires a workspace \u2014 run from `reasonix code`" };
     }
-    const root = scope === "project" ? join6(this.projectRoot ?? "", ".reasonix", SKILLS_DIRNAME) : join6(this.homeDir, ".reasonix", SKILLS_DIRNAME);
-    const flat = join6(root, `${name}.md`);
-    const folder = join6(root, name, SKILL_FILE);
+    const root = scope === "project" ? join7(this.projectRoot ?? "", ".reasonix", SKILLS_DIRNAME) : join7(this.homeDir, ".reasonix", SKILLS_DIRNAME);
+    const flat = join7(root, `${name}.md`);
+    const folder = join7(root, name, SKILL_FILE);
     if (existsSync6(folder)) {
       return { error: `skill "${name}" already exists at ${folder}` };
     }
-    mkdirSync2(dirname3(flat), { recursive: true });
+    mkdirSync3(dirname4(flat), { recursive: true });
     try {
-      writeFileSync2(flat, skillStubBody(name), { encoding: "utf8", flag: "wx" });
+      writeFileSync3(flat, skillStubBody(name), { encoding: "utf8", flag: "wx" });
     } catch (err) {
       if (err.code === "EEXIST") {
         return { error: `skill "${name}" already exists at ${flat}` };
@@ -3814,11 +5213,11 @@ var SkillStore = class {
     if (!isValidSkillName(name)) return null;
     for (const { dir, scope } of this.roots()) {
       if (!existsSync6(dir)) continue;
-      const dirCandidate = join6(dir, name, SKILL_FILE);
+      const dirCandidate = join7(dir, name, SKILL_FILE);
       if (existsSync6(dirCandidate) && statSync3(dirCandidate).isFile()) {
         return this.parse(dirCandidate, name, scope);
       }
-      const flatCandidate = join6(dir, `${name}.md`);
+      const flatCandidate = join7(dir, `${name}.md`);
       if (existsSync6(flatCandidate) && statSync3(flatCandidate).isFile()) {
         return this.parse(flatCandidate, name, scope);
       }
@@ -3833,21 +5232,21 @@ var SkillStore = class {
   readEntry(dir, scope, entry) {
     if (entry.isDirectory()) {
       if (!isValidSkillName(entry.name)) return null;
-      const file = join6(dir, entry.name, SKILL_FILE);
+      const file = join7(dir, entry.name, SKILL_FILE);
       if (!existsSync6(file)) return null;
       return this.parse(file, entry.name, scope);
     }
     if (entry.isFile() && entry.name.endsWith(".md")) {
       const stem = entry.name.slice(0, -3);
       if (!isValidSkillName(stem)) return null;
-      return this.parse(join6(dir, entry.name), stem, scope);
+      return this.parse(join7(dir, entry.name), stem, scope);
     }
     return null;
   }
   parse(path2, stem, scope) {
     let raw;
     try {
-      raw = readFileSync7(path2, "utf8");
+      raw = readFileSync8(path2, "utf8");
     } catch {
       return null;
     }
@@ -4118,15 +5517,15 @@ function projectHash(rootDir) {
 }
 function scopeDir(opts) {
   if (opts.scope === "global") {
-    return join7(opts.homeDir, USER_MEMORY_DIR, "global");
+    return join8(opts.homeDir, USER_MEMORY_DIR, "global");
   }
   if (!opts.projectRoot) {
     throw new Error("scope=project requires a projectRoot on MemoryStore");
   }
-  return join7(opts.homeDir, USER_MEMORY_DIR, projectHash(opts.projectRoot));
+  return join8(opts.homeDir, USER_MEMORY_DIR, projectHash(opts.projectRoot));
 }
 function ensureDir(p) {
-  if (!existsSync7(p)) mkdirSync3(p, { recursive: true });
+  if (!existsSync7(p)) mkdirSync4(p, { recursive: true });
 }
 function parseFrontmatter2(raw) {
   const lines = raw.split(/\r?\n/);
@@ -4171,7 +5570,7 @@ var MemoryStore = class {
   homeDir;
   projectRoot;
   constructor(opts = {}) {
-    this.homeDir = opts.homeDir ?? join7(homedir4(), ".reasonix");
+    this.homeDir = opts.homeDir ?? join8(homedir5(), ".reasonix");
     this.projectRoot = opts.projectRoot ? resolve3(opts.projectRoot) : void 0;
   }
   /** Directory this store writes `scope` files into, creating it if needed. */
@@ -4182,7 +5581,7 @@ var MemoryStore = class {
   }
   /** Absolute path to a memory file (no existence check). */
   pathFor(scope, name) {
-    return join7(this.dir(scope), `${sanitizeMemoryName(name)}.md`);
+    return join8(this.dir(scope), `${sanitizeMemoryName(name)}.md`);
   }
   /** True iff this store is configured with a project scope available. */
   hasProjectScope() {
@@ -4190,14 +5589,14 @@ var MemoryStore = class {
   }
   loadIndex(scope) {
     if (scope === "project" && !this.projectRoot) return null;
-    const file = join7(
+    const file = join8(
       scopeDir({ homeDir: this.homeDir, scope, projectRoot: this.projectRoot }),
       MEMORY_INDEX_FILE
     );
     if (!existsSync7(file)) return null;
     let raw;
     try {
-      raw = readFileSync8(file, "utf8");
+      raw = readFileSync9(file, "utf8");
     } catch {
       return null;
     }
@@ -4215,7 +5614,7 @@ var MemoryStore = class {
     if (!existsSync7(file)) {
       throw new Error(`memory not found: scope=${scope} name=${name}`);
     }
-    const raw = readFileSync8(file, "utf8");
+    const raw = readFileSync9(file, "utf8");
     const { data, body } = parseFrontmatter2(raw);
     return {
       name: data.name ?? name,
@@ -4268,10 +5667,10 @@ var MemoryStore = class {
       createdAt: todayIso()
     };
     const dir = this.dir(input.scope);
-    const file = join7(dir, `${name}.md`);
+    const file = join8(dir, `${name}.md`);
     const content = `${formatFrontmatter(entry)}${body}
 `;
-    writeFileSync3(file, content, "utf8");
+    writeFileSync4(file, content, "utf8");
     this.regenerateIndex(input.scope);
     return file;
   }
@@ -4297,7 +5696,7 @@ var MemoryStore = class {
       return;
     }
     const mdFiles = files.filter((f) => f !== MEMORY_INDEX_FILE && f.endsWith(".md")).sort((a, b) => a.localeCompare(b));
-    const indexPath = join7(dir, MEMORY_INDEX_FILE);
+    const indexPath = join8(dir, MEMORY_INDEX_FILE);
     if (mdFiles.length === 0) {
       if (existsSync7(indexPath)) unlinkSync2(indexPath);
       return;
@@ -4312,16 +5711,16 @@ var MemoryStore = class {
         lines.push(`- [${name}](${name}.md) \u2014 (malformed, check frontmatter)`);
       }
     }
-    writeFileSync3(indexPath, `${lines.join("\n")}
+    writeFileSync4(indexPath, `${lines.join("\n")}
 `, "utf8");
   }
 };
-function readGlobalReasonixMemory(homeDir = join7(homedir4(), ".reasonix")) {
-  const path2 = join7(homeDir, "REASONIX.md");
+function readGlobalReasonixMemory(homeDir = join8(homedir5(), ".reasonix")) {
+  const path2 = join8(homeDir, "REASONIX.md");
   if (!existsSync7(path2)) return null;
   let raw;
   try {
-    raw = readFileSync8(path2, "utf8");
+    raw = readFileSync9(path2, "utf8");
   } catch {
     return null;
   }
@@ -4335,7 +5734,7 @@ function readGlobalReasonixMemory(homeDir = join7(homedir4(), ".reasonix")) {
 }
 function applyGlobalReasonixMemory(basePrompt, homeDir) {
   if (!memoryEnabled()) return basePrompt;
-  const dir = homeDir ?? join7(homedir4(), ".reasonix");
+  const dir = homeDir ?? join8(homedir5(), ".reasonix");
   const mem = readGlobalReasonixMemory(dir);
   if (!mem) return basePrompt;
   return [
@@ -4395,91 +5794,6 @@ import { promises as fs3 } from "fs";
 import * as pathMod3 from "path";
 import picomatch2 from "picomatch";
 
-// src/index/config.ts
-import picomatch from "picomatch";
-var DEFAULT_INDEX_EXCLUDES = {
-  dirs: [
-    "node_modules",
-    ".git",
-    ".hg",
-    ".svn",
-    "dist",
-    "build",
-    "out",
-    ".next",
-    ".nuxt",
-    "target",
-    ".venv",
-    "venv",
-    "__pycache__",
-    ".pytest_cache",
-    ".mypy_cache",
-    ".cache",
-    "coverage",
-    ".turbo",
-    ".vercel",
-    ".reasonix"
-  ],
-  files: [
-    "package-lock.json",
-    "yarn.lock",
-    "pnpm-lock.yaml",
-    "Cargo.lock",
-    "poetry.lock",
-    "Pipfile.lock",
-    "go.sum",
-    ".DS_Store"
-  ],
-  exts: [
-    ".png",
-    ".jpg",
-    ".jpeg",
-    ".gif",
-    ".webp",
-    ".bmp",
-    ".ico",
-    ".tiff",
-    ".woff",
-    ".woff2",
-    ".ttf",
-    ".otf",
-    ".eot",
-    ".zip",
-    ".tar",
-    ".gz",
-    ".bz2",
-    ".xz",
-    ".rar",
-    ".7z",
-    ".exe",
-    ".dll",
-    ".so",
-    ".dylib",
-    ".bin",
-    ".class",
-    ".jar",
-    ".war",
-    ".wasm",
-    ".o",
-    ".obj",
-    ".lib",
-    ".a",
-    ".pyc",
-    ".pyo",
-    ".mp3",
-    ".mp4",
-    ".wav",
-    ".ogg",
-    ".webm",
-    ".mov",
-    ".avi",
-    ".pdf",
-    ".sqlite",
-    ".db"
-  ]
-};
-var DEFAULT_MAX_FILE_BYTES = 256 * 1024;
-
 // src/tools/fs/edit.ts
 import { promises as fs } from "fs";
 import * as pathMod from "path";
@@ -4562,10 +5876,15 @@ function lineDiff(a, b) {
 // src/tools/fs/search.ts
 import { promises as fs2 } from "fs";
 import * as pathMod2 from "path";
+function throwIfAborted(signal) {
+  if (!signal?.aborted) return;
+  throw new DOMException("search aborted by user", "AbortError");
+}
 function displayRel2(rootDir, full) {
   return pathMod2.relative(rootDir, full).replaceAll("\\", "/");
 }
 async function searchFiles(ctx, startAbs, args) {
+  throwIfAborted(args.signal);
   const needle = args.pattern.toLowerCase();
   const includeDeps = args.include_deps === true;
   let re = null;
@@ -4577,6 +5896,7 @@ async function searchFiles(ctx, startAbs, args) {
   const matches = [];
   let totalBytes = 0;
   const walk2 = async (dir) => {
+    throwIfAborted(args.signal);
     let entries;
     try {
       entries = await fs2.readdir(dir, { withFileTypes: true });
@@ -4584,6 +5904,7 @@ async function searchFiles(ctx, startAbs, args) {
       return;
     }
     for (const e of entries) {
+      throwIfAborted(args.signal);
       const full = pathMod2.join(dir, e.name);
       const lower = e.name.toLowerCase();
       const hit = re ? re.test(e.name) : lower.includes(needle);
@@ -4606,6 +5927,7 @@ async function searchFiles(ctx, startAbs, args) {
   return matches.length === 0 ? "(no matches)" : matches.join("\n");
 }
 async function searchContent(ctx, startAbs, args) {
+  throwIfAborted(args.signal);
   const caseSensitive = args.case_sensitive === true;
   const includeDeps = args.include_deps === true;
   let re = null;
@@ -4621,6 +5943,7 @@ async function searchContent(ctx, startAbs, args) {
   let truncated = false;
   const walk2 = async (dir) => {
     if (truncated) return;
+    throwIfAborted(args.signal);
     let entries;
     try {
       entries = await fs2.readdir(dir, { withFileTypes: true });
@@ -4629,6 +5952,7 @@ async function searchContent(ctx, startAbs, args) {
     }
     for (const e of entries) {
       if (truncated) return;
+      throwIfAborted(args.signal);
       if (e.isDirectory()) {
         if (!includeDeps && ctx.skipDirNames.has(e.name)) continue;
         await walk2(pathMod2.join(dir, e.name));
@@ -4646,6 +5970,7 @@ async function searchContent(ctx, startAbs, args) {
       }
       let raw;
       try {
+        throwIfAborted(args.signal);
         const st = await fh.stat();
         if (st.size > 2 * 1024 * 1024) {
           await fh.close();
@@ -4658,12 +5983,14 @@ async function searchContent(ctx, startAbs, args) {
         continue;
       }
       await fh.close();
+      throwIfAborted(args.signal);
       const firstNul = raw.indexOf(0);
       if (firstNul !== -1 && firstNul < 8 * 1024) continue;
       const text = raw.toString("utf8");
       const rel = displayRel2(ctx.rootDir, full);
       const lines = text.split(/\r?\n/);
       for (let li = 0; li < lines.length; li++) {
+        throwIfAborted(args.signal);
         const line = lines[li];
         const lineForCheck = caseSensitive ? line : line.toLowerCase();
         const hit = re ? re.test(line) : lineForCheck.includes(needle);
@@ -4945,10 +6272,10 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
       },
       required: ["pattern"]
     },
-    fn: async (args) => searchFiles(
+    fn: async (args, toolCtx) => searchFiles(
       { rootDir, maxListBytes, skipDirNames: SKIP_DIR_NAMES },
       safePath(args.path ?? "."),
-      args
+      { ...args, signal: toolCtx?.signal }
     )
   });
   registry.register({
@@ -4982,7 +6309,7 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
       },
       required: ["pattern"]
     },
-    fn: async (args) => searchContent(
+    fn: async (args, toolCtx) => searchContent(
       {
         rootDir,
         maxListBytes,
@@ -4991,7 +6318,7 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
         nameMatch: compileNameFilter(typeof args.glob === "string" ? args.glob : null)
       },
       safePath(args.path ?? "."),
-      args
+      { ...args, signal: toolCtx?.signal }
     )
   });
   registry.register({
@@ -5798,12 +7125,12 @@ async function spawnSubagent(opts) {
 }
 function aggregateChildUsage(loop) {
   const agg = new Usage();
-  for (const t of loop.stats.turns) {
-    agg.promptTokens += t.usage.promptTokens;
-    agg.completionTokens += t.usage.completionTokens;
-    agg.totalTokens += t.usage.totalTokens;
-    agg.promptCacheHitTokens += t.usage.promptCacheHitTokens;
-    agg.promptCacheMissTokens += t.usage.promptCacheMissTokens;
+  for (const t2 of loop.stats.turns) {
+    agg.promptTokens += t2.usage.promptTokens;
+    agg.completionTokens += t2.usage.completionTokens;
+    agg.totalTokens += t2.usage.totalTokens;
+    agg.promptCacheHitTokens += t2.usage.promptCacheHitTokens;
+    agg.promptCacheMissTokens += t2.usage.promptCacheMissTokens;
   }
   return agg;
 }
@@ -5930,70 +7257,6 @@ function forkRegistryWithAllowList(parent, allow, alsoExclude) {
 // src/tools/shell.ts
 import * as pathMod7 from "path";
 
-// src/config.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "fs";
-import { homedir as homedir5 } from "os";
-import { dirname as dirname5, join as join10 } from "path";
-function defaultConfigPath() {
-  return join10(homedir5(), ".reasonix", "config.json");
-}
-function readConfig(path2 = defaultConfigPath()) {
-  try {
-    const raw = readFileSync9(path2, "utf8");
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed === "object") return parsed;
-  } catch {
-  }
-  return {};
-}
-function writeConfig(cfg, path2 = defaultConfigPath()) {
-  mkdirSync4(dirname5(path2), { recursive: true });
-  writeFileSync4(path2, JSON.stringify(cfg, null, 2), "utf8");
-  try {
-    chmodSync2(path2, 384);
-  } catch {
-  }
-}
-function loadApiKey(path2 = defaultConfigPath()) {
-  if (process.env.DEEPSEEK_API_KEY) return process.env.DEEPSEEK_API_KEY;
-  return readConfig(path2).apiKey;
-}
-function webSearchEngine(path2 = defaultConfigPath()) {
-  const cfg = readConfig(path2).webSearchEngine;
-  if (cfg === "searxng") return "searxng";
-  return "mojeek";
-}
-function webSearchEndpoint(path2 = defaultConfigPath()) {
-  const cfg = readConfig(path2).webSearchEndpoint;
-  if (cfg && typeof cfg === "string") return cfg;
-  return "http://localhost:8080";
-}
-function saveApiKey(key, path2 = defaultConfigPath()) {
-  const cfg = readConfig(path2);
-  cfg.apiKey = key.trim();
-  writeConfig(cfg, path2);
-}
-function addProjectShellAllowed(rootDir, prefix, path2 = defaultConfigPath()) {
-  const trimmed = prefix.trim();
-  if (!trimmed) return;
-  const cfg = readConfig(path2);
-  if (!cfg.projects) cfg.projects = {};
-  if (!cfg.projects[rootDir]) cfg.projects[rootDir] = {};
-  const existing = cfg.projects[rootDir].shellAllowed ?? [];
-  if (existing.includes(trimmed)) return;
-  cfg.projects[rootDir].shellAllowed = [...existing, trimmed];
-  writeConfig(cfg, path2);
-}
-function isPlausibleKey(key) {
-  const trimmed = key.trim();
-  return /^sk-[A-Za-z0-9_-]{16,}$/.test(trimmed);
-}
-function redactKey(key) {
-  if (!key) return "";
-  if (key.length <= 12) return "****";
-  return `${key.slice(0, 6)}\u2026${key.slice(-4)}`;
-}
-
 // src/tools/jobs.ts
 import { spawn as spawn2 } from "child_process";
 import * as pathMod4 from "path";
@@ -7835,14 +9098,6 @@ function recordFromLoopEvent(ev, extra) {
   if (ev.toolName !== void 0) rec.tool = ev.toolName;
   if (ev.toolArgs !== void 0) rec.args = ev.toolArgs;
   if (ev.error !== void 0) rec.error = ev.error;
-  if (ev.planState && !isPlanStateEmptyShape(ev.planState)) {
-    rec.planState = {
-      subgoals: [...ev.planState.subgoals],
-      hypotheses: [...ev.planState.hypotheses],
-      uncertainties: [...ev.planState.uncertainties],
-      rejectedPaths: [...ev.planState.rejectedPaths]
-    };
-  }
   if (ev.stats) {
     rec.usage = {
       prompt_tokens: ev.stats.usage.promptTokens,
@@ -7878,9 +9133,6 @@ function readTranscript(path2) {
   const raw = readFileSync11(path2, "utf8");
   return parseTranscript(raw);
 }
-function isPlanStateEmptyShape(s) {
-  return s.subgoals.length === 0 && s.hypotheses.length === 0 && s.uncertainties.length === 0 && s.rejectedPaths.length === 0;
-}
 function parseTranscript(raw) {
   const out = { meta: null, records: [] };
   for (const line of raw.split(/\r?\n/)) {
@@ -7916,20 +9168,12 @@ function computeReplayStats(records) {
   const prefixHashes = /* @__PURE__ */ new Set();
   let userTurns = 0;
   let toolCalls = 0;
-  let harvestedTurns = 0;
-  let totalUncertainties = 0;
-  let totalSubgoals = 0;
   for (const rec of records) {
     if (rec.role === "user") userTurns++;
     else if (rec.role === "tool") toolCalls++;
     else if (rec.role === "assistant_final") {
       if (rec.model) models.add(rec.model);
       if (rec.prefixHash) prefixHashes.add(rec.prefixHash);
-      if (rec.planState) {
-        harvestedTurns++;
-        totalUncertainties += rec.planState.uncertainties.length;
-        totalSubgoals += rec.planState.subgoals.length;
-      }
       if (rec.usage && rec.model) {
         const u = new Usage(
           rec.usage.prompt_tokens ?? 0,
@@ -7957,22 +9201,19 @@ function computeReplayStats(records) {
     prefixHashes: [...prefixHashes],
     userTurns,
     toolCalls,
-    harvestedTurns,
-    totalUncertainties,
-    totalSubgoals,
     ...summarizeTurns(turns)
   };
 }
 function summarizeTurns(turns) {
-  const totalCost = turns.reduce((s, t) => s + t.cost, 0);
-  const totalInput = turns.reduce((s, t) => s + inputCostUsd(t.model, t.usage), 0);
-  const totalOutput = turns.reduce((s, t) => s + outputCostUsd(t.model, t.usage), 0);
-  const totalClaude = turns.reduce((s, t) => s + claudeEquivalentCost(t.usage), 0);
+  const totalCost = turns.reduce((s, t2) => s + t2.cost, 0);
+  const totalInput = turns.reduce((s, t2) => s + inputCostUsd(t2.model, t2.usage), 0);
+  const totalOutput = turns.reduce((s, t2) => s + outputCostUsd(t2.model, t2.usage), 0);
+  const totalClaude = turns.reduce((s, t2) => s + claudeEquivalentCost(t2.usage), 0);
   let hit = 0;
   let miss = 0;
-  for (const t of turns) {
-    hit += t.usage.promptCacheHitTokens;
-    miss += t.usage.promptCacheMissTokens;
+  for (const t2 of turns) {
+    hit += t2.usage.promptCacheHitTokens;
+    miss += t2.usage.promptCacheMissTokens;
   }
   const cacheHitRatio = hit + miss > 0 ? hit / (hit + miss) : 0;
   const savingsVsClaude = totalClaude > 0 ? 1 - totalCost / totalClaude : 0;
@@ -8036,8 +9277,8 @@ function diffTranscripts(a, b) {
   return { a: aSide, b: bSide, pairs, firstDivergenceTurn };
 }
 function classifyDivergence(a, b, aTools, bTools) {
-  const aNames = aTools.map((t) => t.tool ?? "").sort();
-  const bNames = bTools.map((t) => t.tool ?? "").sort();
+  const aNames = aTools.map((t2) => t2.tool ?? "").sort();
+  const bNames = bTools.map((t2) => t2.tool ?? "").sort();
   if (aNames.join(",") !== bNames.join(",")) {
     return `tool calls differ: A=[${aNames.join(",") || "\u2014"}] B=[${bNames.join(",") || "\u2014"}]`;
   }
@@ -8067,7 +9308,7 @@ function tokenOverlap(a, b) {
   const tb = new Set(b.toLowerCase().split(/\s+/).filter(Boolean));
   if (ta.size === 0 && tb.size === 0) return 1;
   let shared = 0;
-  for (const t of ta) if (tb.has(t)) shared++;
+  for (const t2 of ta) if (tb.has(t2)) shared++;
   return 2 * shared / (ta.size + tb.size);
 }
 function levenshtein(a, b) {
@@ -8137,41 +9378,6 @@ function renderSummaryTable(report, _opts = {}) {
     )
   );
   lines.push(statRow("prefix hashes", a.stats.prefixHashes.length, b.stats.prefixHashes.length));
-  if (a.stats.harvestedTurns > 0 || b.stats.harvestedTurns > 0) {
-    lines.push(
-      row(
-        [
-          "harvest turns",
-          `${a.stats.harvestedTurns}`,
-          `${b.stats.harvestedTurns}`,
-          signed(b.stats.harvestedTurns - a.stats.harvestedTurns)
-        ],
-        [20, 14, 14, 14]
-      )
-    );
-    lines.push(
-      row(
-        [
-          "  subgoals",
-          `${a.stats.totalSubgoals}`,
-          `${b.stats.totalSubgoals}`,
-          signed(b.stats.totalSubgoals - a.stats.totalSubgoals)
-        ],
-        [20, 14, 14, 14]
-      )
-    );
-    lines.push(
-      row(
-        [
-          "  uncertainties",
-          `${a.stats.totalUncertainties}`,
-          `${b.stats.totalUncertainties}`,
-          signed(b.stats.totalUncertainties - a.stats.totalUncertainties)
-        ],
-        [20, 14, 14, 14]
-      )
-    );
-  }
   lines.push("");
   const aPrefixStable = a.stats.prefixHashes.length <= 1;
   const bPrefixStable = b.stats.prefixHashes.length <= 1;
@@ -8243,25 +9449,14 @@ function renderMarkdown(report) {
   out.push(
     `| prefix hashes | ${a.stats.prefixHashes.length} | ${b.stats.prefixHashes.length} | \u2014 |`
   );
-  if (a.stats.harvestedTurns > 0 || b.stats.harvestedTurns > 0) {
-    out.push(
-      `| harvest turns | ${a.stats.harvestedTurns} | ${b.stats.harvestedTurns} | ${signed(b.stats.harvestedTurns - a.stats.harvestedTurns)} |`
-    );
-    out.push(
-      `| harvest subgoals | ${a.stats.totalSubgoals} | ${b.stats.totalSubgoals} | ${signed(b.stats.totalSubgoals - a.stats.totalSubgoals)} |`
-    );
-    out.push(
-      `| harvest uncertainties | ${a.stats.totalUncertainties} | ${b.stats.totalUncertainties} | ${signed(b.stats.totalUncertainties - a.stats.totalUncertainties)} |`
-    );
-  }
   out.push("");
   out.push("## Turn-by-turn");
   out.push("");
   out.push(`| turn | kind | ${a.label} tool calls | ${b.label} tool calls | note |`);
   out.push("|---:|:---:|---|---|---|");
   for (const p of report.pairs) {
-    const aTools = p.aTools.map((t) => t.tool).filter(Boolean).join(", ") || "\u2014";
-    const bTools = p.bTools.map((t) => t.tool).filter(Boolean).join(", ") || "\u2014";
+    const aTools = p.aTools.map((t2) => t2.tool).filter(Boolean).join(", ") || "\u2014";
+    const bTools = p.bTools.map((t2) => t2.tool).filter(Boolean).join(", ") || "\u2014";
     out.push(`| ${p.turn} | ${p.kind} | ${aTools} | ${bTools} | ${p.divergenceNote ?? ""} |`);
   }
   out.push("");
@@ -9802,6 +10997,7 @@ export {
   CODE_SYSTEM_PROMPT,
   CacheFirstLoop,
   ChoiceRequestedError,
+  DEFAULT_AT_DIR_MAX_ENTRIES,
   DEFAULT_AT_MENTION_MAX_BYTES,
   DEFAULT_MAX_RESULT_CHARS,
   DEFAULT_MAX_RESULT_TOKENS,
@@ -9834,7 +11030,6 @@ export {
   Usage,
   VERSION,
   VolatileScratch,
-  aggregateBranchUsage,
   aggregateUsage,
   analyzeSchema,
   appendSessionMessage,
@@ -9854,13 +11049,11 @@ export {
   costUsd,
   decideOutcome,
   defaultConfigPath,
-  defaultSelector,
   defaultUsageLogPath,
   deleteSession,
   detectAtPicker,
   detectShellOperator,
   diffTranscripts,
-  emptyPlanState,
   expandAtMentions,
   fetchWithRetry,
   fixToolCallPairing,
@@ -9874,7 +11067,6 @@ export {
   formatSearchResults,
   getLatestVersion,
   globalSettingsPath,
-  harvest,
   healLoadedMessages,
   healLoadedMessagesByTokens,
   htmlToText,
@@ -9884,7 +11076,6 @@ export {
   isAllowed,
   isJsonRpcError,
   isNpxInstall,
-  isPlanStateEmpty,
   isPlausibleKey,
   listFilesSync,
   listFilesWithStatsAsync,
@@ -9928,7 +11119,6 @@ export {
   replayFromFile,
   resolveExecutable,
   restoreSnapshots,
-  runBranches,
   runCommand,
   runHooks,
   sanitizeMemoryName,