reasonix 0.30.4 → 0.31.0

package/dist/index.js

@@ -545,9 +545,1885 @@ var pauseGate = new PauseGate();
 
 // src/hooks.ts
 import { spawn } from "child_process";
-import { existsSync, readFileSync } from "fs";
+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 { join } from "path";
+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",
+    harvestHint: "opt into Pillar-2 plan-state extraction (costs +1 flash call per turn)",
+    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",
+    harvestOptInHint: "opt into Pillar-2 plan-state extraction",
+    branchHint: "run N parallel samples per turn (N>=2, manual only)",
+    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",
+    harvestHintShort: "Pillar-2 plan-state extraction",
+    branchHintShort: "parallel samples per turn (N>=2)",
+    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}."
+    },
+    harvest: { description: "toggle Pillar-2 plan-state extraction", argsHint: "[on|off]" },
+    branch: { description: "run N parallel samples per turn (N>=2)", argsHint: "<N|off>" },
+    effort: {
+      description: "reasoning_effort cap \u2014 max is default (agent-class), high is cheaper/faster",
+      argsHint: "<high|max>"
+    },
+    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]"
+    },
+    tool: { description: "dump full output of the Nth tool call (1=latest)", argsHint: "[N]" },
+    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)" },
+    think: { description: "dump the last turn's full R1 reasoning (reasoner only)" },
+    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)" },
+    rename: { description: "rename the current session on disk", argsHint: "<new-name>" },
+    resume: {
+      description: "show the launch command to resume a saved session",
+      argsHint: "<name>"
+    },
+    forget: { description: "delete the current session from disk" },
+    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]"
+    },
+    "apply-plan": {
+      description: "force-approve a pending / in-text plan (fallback if picker was missed)"
+    },
+    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: {
+      clearInfo: "\u25B8 terminal cleared (viewport + scrollback). Context (message log) is intact \u2014 next turn still sees everything. Use /new to start fresh, or /forget to delete the session entirely.",
+      newInfo: "\u25B8 new conversation \u2014 dropped {count} message(s) from context. Same session, fresh slate.",
+      helpTitle: "Commands:",
+      helpHelp: "  /help                    this message",
+      helpKeys: "  /keys                    keyboard shortcuts + prompt prefixes (!, @, /)",
+      helpStatus: "  /status                  show current settings",
+      helpPreset: "  /preset <auto|flash|pro> model bundle \u2014 see below",
+      helpModel: "  /model <id>              deepseek-v4-flash or deepseek-v4-pro",
+      helpPro: "  /pro [off]               arm v4-pro for NEXT turn only (one-shot, auto-disarms)",
+      helpHarvest: "  /harvest [on|off]        Pillar 2: structured plan-state extraction (OPT-IN \u2014 costs extra)",
+      helpBranch: "  /branch <N|off>          run N parallel samples (N>=2) \u2014 MANUAL ONLY, N\xD7 cost",
+      helpEffort: "  /effort <high|max>       reasoning_effort cap (max=full thinking, high=cheaper/faster)",
+      helpMcp: "  /mcp                     list MCP servers + tools attached to this session",
+      helpResource: "  /resource [uri]          browse + read MCP resources (no arg \u2192 list URIs; <uri> \u2192 fetch)",
+      helpPrompt: "  /prompt [name]           browse + fetch MCP prompts (no arg \u2192 list names; <name> \u2192 render)",
+      helpCompact: "  /compact                 fold older turns into a summary (cache-safe; auto-fires at 50% ctx)",
+      helpThink: "  /think                   dump the most recent turn's full R1 reasoning (reasoner only)",
+      helpTool: "  /tool [N]                list tool calls (or dump full output of #N, 1=most recent)",
+      helpCost: "  /cost [text]             bare \u2192 last turn's spend; with text \u2192 estimate cost of sending it next",
+      helpMemory: "  /memory [sub]            show pinned memory (REASONIX.md + ~/.reasonix/memory).",
+      helpMemorySub: "                            subs: list | show <name> | forget <name> | clear <scope> confirm",
+      helpSkill: "  /skill [sub]             list / run user skills (project/.reasonix/skills + ~/.reasonix/skills).",
+      helpSkillSub: "                            subs: list | show <name> | <name> [args] (injects skill body as user turn)",
+      helpRetry: "  /retry                   truncate & resend your last message (fresh sample from the model)",
+      helpApply: "  /apply [N|1,3|1-4]       (code mode) commit pending edit blocks (no arg \u2192 all; index \u2192 subset)",
+      helpDiscard: "  /discard [N|1,3|1-4]     (code mode) drop pending edits (no arg \u2192 all; index \u2192 subset)",
+      helpWalk: "  /walk                    (code mode) step through pending edits one block at a time (y/n per block, a apply rest, A flip AUTO)",
+      helpUndo: "  /undo                    (code mode) roll back the latest non-undone edit batch",
+      helpHistory: "  /history                 (code mode) list every edit batch this session",
+      helpShow: "  /show [id]               (code mode) dump a stored edit diff (newest when id omitted)",
+      helpCommit: '  /commit "msg"            (code mode) git add -A && git commit -m "msg"',
+      helpPlan: "  /plan [on|off]           (code mode) toggle read-only plan mode; writes gated behind submit_plan + your approval",
+      helpApplyPlan: "  /apply-plan              (code mode) force-approve pending/in-text plan (fallback)",
+      helpMode: "  /mode [review|auto|yolo] (code mode) review = queue \xB7 auto = apply+undo banner \xB7 yolo = apply+auto-shell. Shift+Tab cycles all three.",
+      helpJobs: "  /jobs                    (code mode) list background processes (run_background) \u2014 running and exited",
+      helpKill: "  /kill <id>               (code mode) stop a background job by id (SIGTERM \u2192 SIGKILL)",
+      helpLogs: "  /logs <id> [lines]       (code mode) tail a background job's output (default 80 lines)",
+      helpSessions: "  /sessions                list saved sessions (current is marked with \u25B8)",
+      helpForget: "  /forget                  delete the current session from disk",
+      helpNew: "  /new                     start fresh: drop all context + clear scrollback",
+      helpClear: "  /clear                   clear displayed scrollback only (context kept \u2014 model still sees it)",
+      helpLoop: "  /loop <interval> <prompt> auto-resubmit <prompt> every <interval> (5s..6h). /loop stop \xB7 type anything to cancel.",
+      helpExit: "  /exit                    quit (aliases: /quit, /q)",
+      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",
+      helpLimitationTitle: "Known limitation:",
+      helpLimitation1: "  Resizing the terminal mid-session may stack ghost header frames in",
+      helpLimitation2: "  scrollback (Ink library's live-region clear doesn't account for line",
+      helpLimitation3: "  re-wrapping at the new width). Scroll-up history is unaffected; the",
+      helpLimitation4: "  artifact is purely visual and clears the next time you /clear.",
+      keysTitle: "Keyboard & prompt shortcuts:",
+      keysEnter: "  Enter                  submit the current prompt",
+      keysNewline: "  Shift+Enter  /  Ctrl+J  insert a newline (multi-line prompt)",
+      keysContinue: "  \\<Enter>               bash-style line continuation",
+      keysArrow: "  \u2190 \u2192 \u2191 \u2193                move cursor / recall history at buffer boundary",
+      keysPage: "  PageUp / PageDown      jump to top / bottom of the WHOLE buffer (handy after a big paste)",
+      keysHomeEnd: "  Ctrl+A / Ctrl+E        jump to start / end of the CURRENT line",
+      keysClearLine: "  Ctrl+U                 clear the entire input buffer",
+      keysDeleteWord: "  Ctrl+W                 delete the word before the cursor",
+      keysBackspace: "  Backspace              delete left;  Delete   delete under cursor",
+      keysEsc: "  Esc                    abort the in-flight turn",
+      keysEditYn: "  y / n                  accept / reject pending edits (code mode)",
+      keysEditTab: "  Shift+Tab              cycle edit gate: review \u2194 AUTO (code mode, persists to config)",
+      keysEditUndo: "  u                      undo the latest non-undone edit batch (session-wide, not just banner)",
+      keysPromptTitle: "Prompt prefixes:",
+      keysSlash: "  /<name>                slash command; Tab/Enter picks from the suggestion list",
+      keysAtFile: "  @<path>                inline a file under [Referenced files] (code mode).",
+      keysAtFilePicker: "                           Trailing `@\u2026` opens a file picker; \u2191/\u2193 navigate, Tab/Enter pick.",
+      keysAtUrl: "  @https://...           fetch the URL, strip HTML, inline under [Referenced URLs].",
+      keysAtUrlCache: "                           Cached per session \u2014 same URL twice fetches once.",
+      keysBang: "  !<cmd>                 run <cmd> as shell in the sandbox root; output goes into context",
+      keysBangDetail: "                           so the model sees it next turn. No allowlist gate.",
+      keysHash: "  #<note>                append <note> to <project>/REASONIX.md (committable, team-shared).",
+      keysHashGlobal: "  #g <note>              append <note> to ~/.reasonix/REASONIX.md (global, never committed).",
+      keysHashBoth: "                           Both pin into the immutable prefix every future session.",
+      keysHashEscape: "                           Use `\\#literal` if you actually want a `#` heading sent to the model.",
+      keysPickersTitle: "Pickers (slash + @-mention):",
+      keysPickerNav: "  \u2191 / \u2193                  navigate the suggestion list",
+      keysPickerTab: "  Tab                    insert the highlighted item without submitting",
+      keysPickerEnter: "  Enter                  insert and (slash) run it, (@) keep editing",
+      keysMcpTitle: "MCP exploration:",
+      keysMcpServers: "  /mcp                   servers + tool/resource/prompt counts",
+      keysMcpResource: "  /resource [uri]        browse & read resources exposed by your MCP servers",
+      keysMcpPrompt: "  /prompt [name]         browse & fetch prompts exposed by your MCP servers",
+      keysUseful: "Useful slashes: /help \xB7 /context \xB7 /stats \xB7 /compact \xB7 /new \xB7 /exit",
+      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.",
+      applyPlanCodeOnly: "/apply-plan is only available inside `reasonix code`.",
+      applyPlanInfo: "\u25B8 plan approved \u2014 implementing",
+      applyPlanResubmit: "The plan above has been approved. Implement it now. You are out of plan mode \u2014 use edit_file / write_file / run_command as needed. Stick to the plan unless you discover a concrete reason to deviate; if you do, tell me and wait for a response before making that deviation.",
+      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}",
+      modelsFetching: "fetching /models from DeepSeek\u2026 run /models again in a moment. If it stays empty, your API key may lack permission or the network is blocked.",
+      modelsEmpty: "DeepSeek /models returned an empty list. Try /models again, or check your account status at api-docs.deepseek.com.",
+      modelsHeader: "Available models (DeepSeek /models \xB7 {count} total):",
+      modelsCurrent: "\u25B8 {id}  (current)",
+      modelsSwitch: "Switch with: /model <id>",
+      harvestOn: "harvest \u2192 on  (Pillar-2 plan-state extraction \xB7 +1 cheap flash call per turn \xB7 opt-in only; no preset turns it on)",
+      harvestOff: "harvest \u2192 off",
+      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>",
+      branchOff: "branch \u2192 off",
+      branchUsage: "usage: /branch <N>   (N>=2, or 'off')",
+      branchCapped: "branch budget capped at 8 to prevent runaway cost",
+      branchSet: "branch \u2192 {n}  (runs {n} parallel samples per turn \xB7 {n}\xD7 per-turn cost \xB7 streaming disabled \xB7 manual only, no preset enables branching)",
+      effortStatus: "reasoning_effort \u2192 {effort}  (use /effort high for cheaper/faster, /effort max for the agent-class default \xB7 persisted across relaunches)",
+      effortUsage: "usage: /effort <high|max>",
+      effortSet: "reasoning_effort \u2192 {effort} (persisted)",
+      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)"
+    },
+    sessions: {
+      forgetNoSession: "not in a session \u2014 nothing to forget",
+      forgetInfo: '\u25B8 deleted session "{name}" \u2014 current screen still shows the conversation, but next launch starts fresh',
+      forgetFailed: 'could not delete session "{name}" (already gone?)',
+      renameUsage: "usage: /rename <new-name>",
+      renameNoSession: "not in a session \u2014 nothing to rename",
+      renameFailed: 'could not rename \u2014 "{name}" already exists or sanitises to the same id as the current session',
+      renameInfo: '\u25B8 renamed session \u2192 "{name}". Restart the TUI to pick it up under its new name.',
+      resumeUsage: "usage: /resume <session-name>  \u2014 list with /sessions",
+      resumeNotFound: 'no session named "{name}" \u2014 list with /sessions',
+      resumeInfo: '\u25B8 to resume "{name}", quit and run: reasonix chat --session {name}\n  (mid-session swap requires a restart so the message log can rewind cleanly)'
+    },
+    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: {
+      thinkEmpty: "no reasoning cached. `/think` shows the full thinking-mode thought for the most recent turn \u2014 only thinking-mode models (deepseek-v4-flash / -v4-pro / -reasoner) produce it, and only once the turn completes.",
+      thinkInfo: "\u21B3 full thinking ({count} chars):",
+      toolEmpty: "no tool calls yet in this session. `/tool` lists them once the model has actually used a tool; `/tool N` dumps the full (untruncated) output of the Nth-most-recent.",
+      toolUsage: "usage: /tool [N]   (no arg \u2192 list; N=1 \u2192 most recent result in full, N=2 \u2192 previous, \u2026)",
+      toolOob: "only {count} tool call(s) in history \u2014 asked for #{n}. Try /tool with no arg to see the list.",
+      toolNotFound: "could not read tool call #{n}",
+      toolInfo: "\u21B3 tool<{name}> #{n} ({chars} chars):",
+      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   harvest={harvest} \xB7 branch={branch} \xB7 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."
+    },
+    semantic: {
+      codeOnly: "/semantic is only available inside `reasonix code` (needs a project root).",
+      checking: "\u25B8 checking semantic_search status\u2026"
+    },
+    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",
+    harvestHint: "\u542F\u7528 Pillar-2 \u8BA1\u5212\u72B6\u6001\u63D0\u53D6\uFF08\u6BCF\u8F6E\u989D\u5916\u6D88\u8017 1 \u6B21 flash \u8C03\u7528\uFF09",
+    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",
+    harvestOptInHint: "\u542F\u7528 Pillar-2 \u8BA1\u5212\u72B6\u6001\u63D0\u53D6",
+    branchHint: "\u6BCF\u8F6E\u8FD0\u884C N \u4E2A\u5E76\u884C\u91C7\u6837\uFF08N>=2\uFF0C\u4EC5\u624B\u52A8\uFF09",
+    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",
+    harvestHintShort: "Pillar-2 \u8BA1\u5212\u72B6\u6001\u63D0\u53D6",
+    branchHintShort: "\u6BCF\u8F6E\u5E76\u884C\u91C7\u6837\u6570\uFF08N>=2\uFF09",
+    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"
+    },
+    harvest: { description: "\u5207\u6362 Pillar-2 \u8BA1\u5212\u72B6\u6001\u63D0\u53D6", argsHint: "[on|off]" },
+    branch: { description: "\u6BCF\u8F6E\u8FD0\u884C N \u4E2A\u5E76\u884C\u91C7\u6837\uFF08N>=2\uFF09", argsHint: "<N|off>" },
+    effort: {
+      description: "reasoning_effort \u4E0A\u9650 \u2014 max \u4E3A\u9ED8\u8BA4\uFF08\u667A\u80FD\u4F53\u7EA7\uFF09\uFF0Chigh \u66F4\u4FBF\u5B9C/\u66F4\u5FEB",
+      argsHint: "<high|max>"
+    },
+    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]"
+    },
+    tool: { description: "\u8F6C\u50A8\u7B2C N \u4E2A\u5DE5\u5177\u8C03\u7528\u7684\u5B8C\u6574\u8F93\u51FA\uFF081=\u6700\u8FD1\uFF09", argsHint: "[N]" },
+    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"
+    },
+    think: { description: "\u8F6C\u50A8\u6700\u8FD1\u4E00\u8F6E\u7684\u5B8C\u6574 R1 \u63A8\u7406\uFF08\u4EC5\u63A8\u7406\u6A21\u578B\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" },
+    rename: { description: "\u91CD\u547D\u540D\u78C1\u76D8\u4E0A\u7684\u5F53\u524D\u4F1A\u8BDD", argsHint: "<new-name>" },
+    resume: {
+      description: "\u663E\u793A\u6062\u590D\u5DF2\u4FDD\u5B58\u4F1A\u8BDD\u7684\u542F\u52A8\u547D\u4EE4",
+      argsHint: "<name>"
+    },
+    forget: { description: "\u4ECE\u78C1\u76D8\u5220\u9664\u5F53\u524D\u4F1A\u8BDD" },
+    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]"
+    },
+    "apply-plan": {
+      description: "\u5F3A\u5236\u6279\u51C6\u5F85\u5904\u7406 / \u6587\u672C\u4E2D\u7684\u8BA1\u5212\uFF08\u5982\u679C\u9519\u8FC7\u4E86\u9009\u62E9\u5668\u65F6\u7684\u56DE\u9000\uFF09"
+    },
+    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: {
+      clearInfo: "\u25B8 \u7EC8\u7AEF\u5DF2\u6E05\u9664\uFF08\u89C6\u53E3 + \u6EDA\u52A8\u56DE\u653E\uFF09\u3002\u4E0A\u4E0B\u6587\uFF08\u6D88\u606F\u65E5\u5FD7\uFF09\u5B8C\u597D\u65E0\u635F \u2014 \u4E0B\u4E00\u8F6E\u4ECD\u80FD\u770B\u5230\u6240\u6709\u5185\u5BB9\u3002\u4F7F\u7528 /new \u5168\u65B0\u5F00\u59CB\uFF0C\u6216 /forget \u5220\u9664\u6574\u4E2A\u4F1A\u8BDD\u3002",
+      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",
+      helpHelp: "  /help                    \u663E\u793A\u6B64\u6D88\u606F",
+      helpKeys: "  /keys                    \u952E\u76D8\u5FEB\u6377\u952E + \u63D0\u793A\u524D\u7F00 (!, @, /)",
+      helpStatus: "  /status                  \u663E\u793A\u5F53\u524D\u8BBE\u7F6E",
+      helpPreset: "  /preset <auto|flash|pro> \u6A21\u578B\u7EC4\u5408 \u2014 \u89C1\u4E0B\u6587",
+      helpModel: "  /model <id>              deepseek-v4-flash \u6216 deepseek-v4-pro",
+      helpPro: "  /pro [off]               \u4E3A\u4E0B\u4E00\u8F6E\u542F\u7528 v4-pro\uFF08\u4E00\u6B21\u6027\uFF0C\u81EA\u52A8\u89E3\u9664\uFF09",
+      helpHarvest: "  /harvest [on|off]        Pillar 2\uFF1A\u7ED3\u6784\u5316\u8BA1\u5212\u72B6\u6001\u63D0\u53D6\uFF08\u53EF\u9009 \u2014 \u989D\u5916\u6536\u8D39\uFF09",
+      helpBranch: "  /branch <N|off>          \u8FD0\u884C N \u4E2A\u5E76\u884C\u91C7\u6837\uFF08N>=2\uFF09\u2014 \u4EC5\u624B\u52A8\uFF0CN \u500D\u6210\u672C",
+      helpEffort: "  /effort <high|max>       reasoning_effort \u4E0A\u9650\uFF08max=\u5B8C\u6574\u601D\u8003\uFF0Chigh=\u66F4\u4FBF\u5B9C/\u66F4\u5FEB\uFF09",
+      helpMcp: "  /mcp                     \u5217\u51FA\u9644\u52A0\u5230\u6B64\u4F1A\u8BDD\u7684 MCP \u670D\u52A1\u5668 + \u5DE5\u5177",
+      helpResource: "  /resource [uri]          \u6D4F\u89C8 + \u8BFB\u53D6 MCP \u8D44\u6E90\uFF08\u65E0\u53C2\u6570 \u2192 \u5217\u51FA URI\uFF1B<uri> \u2192 \u83B7\u53D6\uFF09",
+      helpPrompt: "  /prompt [name]           \u6D4F\u89C8 + \u83B7\u53D6 MCP \u63D0\u793A\uFF08\u65E0\u53C2\u6570 \u2192 \u5217\u51FA\u540D\u79F0\uFF1B<name> \u2192 \u6E32\u67D3\uFF09",
+      helpCompact: "  /compact                 \u6298\u53E0\u65E7\u8F6E\u6B21\u4E3A\u6458\u8981\uFF08cache-safe\uFF0C50% \u81EA\u52A8\u89E6\u53D1\uFF09",
+      helpThink: "  /think                   \u8F6C\u50A8\u6700\u8FD1\u4E00\u8F6E\u7684\u5B8C\u6574 R1 \u63A8\u7406\uFF08\u4EC5\u63A8\u7406\u6A21\u578B\uFF09",
+      helpTool: "  /tool [N]                \u5217\u51FA\u5DE5\u5177\u8C03\u7528\uFF08\u6216\u8F6C\u50A8\u7B2C N \u4E2A\u7684\u5B8C\u6574\u8F93\u51FA\uFF0C1=\u6700\u8FD1\uFF09",
+      helpCost: "  /cost [text]             \u7A7A \u2192 \u4E0A\u4E00\u8F6E\u82B1\u8D39\uFF1B\u5E26\u6587\u672C \u2192 \u4F30\u7B97\u53D1\u9001\u6210\u672C",
+      helpMemory: "  /memory [sub]            \u663E\u793A\u56FA\u5B9A\u8BB0\u5FC6\uFF08REASONIX.md + ~/.reasonix/memory\uFF09\u3002",
+      helpMemorySub: "                            \u5B50\u547D\u4EE4\uFF1Alist | show <name> | forget <name> | clear <scope> confirm",
+      helpSkill: "  /skill [sub]             \u5217\u51FA / \u8FD0\u884C\u7528\u6237\u6280\u80FD\uFF08project/.reasonix/skills + ~/.reasonix/skills\uFF09\u3002",
+      helpSkillSub: "                            \u5B50\u547D\u4EE4\uFF1Alist | show <name> | <name> [args]\uFF08\u5C06\u6280\u80FD\u4F53\u6CE8\u5165\u4E3A\u7528\u6237\u8F6E\u6B21\uFF09",
+      helpRetry: "  /retry                   \u622A\u65AD\u5E76\u91CD\u53D1\u60A8\u7684\u6700\u540E\u4E00\u6761\u6D88\u606F\uFF08\u6A21\u578B\u91CD\u65B0\u91C7\u6837\uFF09",
+      helpApply: "  /apply [N|1,3|1-4]       \uFF08\u4EE3\u7801\u6A21\u5F0F\uFF09\u63D0\u4EA4\u5F85\u5904\u7406\u7684\u7F16\u8F91\u5757\uFF08\u65E0\u53C2\u6570 \u2192 \u5168\u90E8\uFF1B\u7D22\u5F15 \u2192 \u5B50\u96C6\uFF09",
+      helpDiscard: "  /discard [N|1,3|1-4]     \uFF08\u4EE3\u7801\u6A21\u5F0F\uFF09\u4E22\u5F03\u5F85\u5904\u7406\u7684\u7F16\u8F91\uFF08\u65E0\u53C2\u6570 \u2192 \u5168\u90E8\uFF1B\u7D22\u5F15 \u2192 \u5B50\u96C6\uFF09",
+      helpWalk: "  /walk                    \uFF08\u4EE3\u7801\u6A21\u5F0F\uFF09\u9010\u5757\u9010\u6B65\u5904\u7406\u5F85\u5904\u7406\u7684\u7F16\u8F91\uFF08\u6BCF\u5757 y/n\uFF0Ca \u5E94\u7528\u5269\u4F59\uFF0CA \u5207\u6362 AUTO\uFF09",
+      helpUndo: "  /undo                    \uFF08\u4EE3\u7801\u6A21\u5F0F\uFF09\u56DE\u6EDA\u6700\u8FD1\u672A\u64A4\u6D88\u7684\u7F16\u8F91\u6279\u5904\u7406",
+      helpHistory: "  /history                 \uFF08\u4EE3\u7801\u6A21\u5F0F\uFF09\u5217\u51FA\u6B64\u4F1A\u8BDD\u7684\u6BCF\u4E2A\u7F16\u8F91\u6279\u5904\u7406",
+      helpShow: "  /show [id]               \uFF08\u4EE3\u7801\u6A21\u5F0F\uFF09\u8F6C\u50A8\u5B58\u50A8\u7684\u7F16\u8F91\u5DEE\u5F02\uFF08\u7701\u7565 id \u65F6\u4E3A\u6700\u65B0\uFF09",
+      helpCommit: '  /commit "msg"            \uFF08\u4EE3\u7801\u6A21\u5F0F\uFF09git add -A && git commit -m "msg"',
+      helpPlan: "  /plan [on|off]           \uFF08\u4EE3\u7801\u6A21\u5F0F\uFF09\u5207\u6362\u53EA\u8BFB\u8BA1\u5212\u6A21\u5F0F\uFF1B\u5199\u5165\u9700\u7ECF submit_plan + \u5BA1\u6279",
+      helpApplyPlan: "  /apply-plan              \uFF08\u4EE3\u7801\u6A21\u5F0F\uFF09\u5F3A\u5236\u6279\u51C6\u5F85\u5904\u7406/\u6587\u672C\u4E2D\u7684\u8BA1\u5212\uFF08\u56DE\u9000\uFF09",
+      helpMode: "  /mode [review|auto|yolo] \uFF08\u4EE3\u7801\u6A21\u5F0F\uFF09review = \u6392\u961F \xB7 auto = \u5E94\u7528+\u64A4\u6D88\u6A2A\u5E45 \xB7 yolo = \u5E94\u7528+\u81EA\u52A8 shell\u3002Shift+Tab \u5FAA\u73AF\u5207\u6362\u3002",
+      helpJobs: "  /jobs                    \uFF08\u4EE3\u7801\u6A21\u5F0F\uFF09\u5217\u51FA\u540E\u53F0\u8FDB\u7A0B\uFF08run_background\uFF09\u2014 \u8FD0\u884C\u4E2D\u548C\u5DF2\u9000\u51FA",
+      helpKill: "  /kill <id>               \uFF08\u4EE3\u7801\u6A21\u5F0F\uFF09\u6309 ID \u505C\u6B62\u540E\u53F0\u4F5C\u4E1A\uFF08SIGTERM \u2192 SIGKILL\uFF09",
+      helpLogs: "  /logs <id> [lines]       \uFF08\u4EE3\u7801\u6A21\u5F0F\uFF09\u8DDF\u8E2A\u540E\u53F0\u4F5C\u4E1A\u8F93\u51FA\uFF08\u9ED8\u8BA4\u6700\u540E 80 \u884C\uFF09",
+      helpSessions: "  /sessions                \u5217\u51FA\u5DF2\u4FDD\u5B58\u7684\u4F1A\u8BDD\uFF08\u5F53\u524D\u6807\u8BB0\u4E3A \u25B8\uFF09",
+      helpForget: "  /forget                  \u4ECE\u78C1\u76D8\u5220\u9664\u5F53\u524D\u4F1A\u8BDD",
+      helpNew: "  /new                     \u5168\u65B0\u5F00\u59CB\uFF1A\u4E22\u5F03\u6240\u6709\u4E0A\u4E0B\u6587 + \u6E05\u9664\u6EDA\u52A8\u56DE\u653E",
+      helpClear: "  /clear                   \u4EC5\u6E05\u9664\u663E\u793A\u7684\u6EDA\u52A8\u56DE\u653E\uFF08\u4E0A\u4E0B\u6587\u4FDD\u7559 \u2014 \u6A21\u578B\u4ECD\u80FD\u770B\u5230\uFF09",
+      helpLoop: "  /loop <interval> <prompt> \u6BCF <interval> \u81EA\u52A8\u91CD\u65B0\u63D0\u4EA4 <prompt>\uFF085\u79D2..6\u5C0F\u65F6\uFF09\u3002/loop stop \xB7 \u8F93\u5165\u4EFB\u4F55\u5185\u5BB9\u53D6\u6D88\u3002",
+      helpExit: "  /exit                    \u9000\u51FA\uFF08\u522B\u540D\uFF1A/quit, /q\uFF09",
+      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",
+      helpLimitationTitle: "\u5DF2\u77E5\u9650\u5236\uFF1A",
+      helpLimitation1: "  \u5728\u4F1A\u8BDD\u4E2D\u9014\u8C03\u6574\u7EC8\u7AEF\u5927\u5C0F\u53EF\u80FD\u4F1A\u5728\u6EDA\u52A8\u56DE\u653E\u4E2D\u5806\u53E0\u5E7D\u7075\u6807\u9898\u5E27",
+      helpLimitation2: "  \uFF08Ink \u5E93\u7684\u6D3B\u52A8\u533A\u57DF\u6E05\u9664\u672A\u8003\u8651\u65B0\u5BBD\u5EA6\u4E0B\u7684\u884C\u91CD\u6392\uFF09\u3002",
+      helpLimitation3: "  \u6EDA\u52A8\u5386\u53F2\u4E0D\u53D7\u5F71\u54CD\uFF1B\u8BE5\u7455\u75B5\u7EAF\u5C5E\u89C6\u89C9\u95EE\u9898\uFF0C",
+      helpLimitation4: "  \u4E0B\u6B21 /clear \u65F6\u6E05\u9664\u3002",
+      keysTitle: "\u952E\u76D8\u548C\u63D0\u793A\u5FEB\u6377\u952E\uFF1A",
+      keysEnter: "  Enter                  \u63D0\u4EA4\u5F53\u524D\u63D0\u793A",
+      keysNewline: "  Shift+Enter  /  Ctrl+J  \u63D2\u5165\u6362\u884C\uFF08\u591A\u884C\u63D0\u793A\uFF09",
+      keysContinue: "  \\<Enter>               bash \u98CE\u683C\u7684\u884C\u7EE7\u7EED",
+      keysArrow: "  \u2190 \u2192 \u2191 \u2193                \u79FB\u52A8\u5149\u6807 / \u5728\u7F13\u51B2\u533A\u8FB9\u754C\u53EC\u56DE\u5386\u53F2",
+      keysPage: "  PageUp / PageDown      \u8DF3\u8F6C\u5230\u6574\u4E2A\u7F13\u51B2\u533A\u7684\u9876\u90E8/\u5E95\u90E8\uFF08\u5927\u6BB5\u7C98\u8D34\u540E\u5F88\u6709\u7528\uFF09",
+      keysHomeEnd: "  Ctrl+A / Ctrl+E        \u8DF3\u8F6C\u5230\u5F53\u524D\u884C\u7684\u5F00\u5934/\u7ED3\u5C3E",
+      keysClearLine: "  Ctrl+U                 \u6E05\u9664\u6574\u4E2A\u8F93\u5165\u7F13\u51B2\u533A",
+      keysDeleteWord: "  Ctrl+W                 \u5220\u9664\u5149\u6807\u524D\u7684\u5355\u8BCD",
+      keysBackspace: "  Backspace              \u5411\u5DE6\u5220\u9664\uFF1BDelete   \u5220\u9664\u5149\u6807\u4E0B\u7684\u5B57\u7B26",
+      keysEsc: "  Esc                    \u4E2D\u6B62\u6B63\u5728\u8FDB\u884C\u7684\u8F6E\u6B21",
+      keysEditYn: "  y / n                  \u63A5\u53D7/\u62D2\u7EDD\u5F85\u5904\u7406\u7684\u7F16\u8F91\uFF08\u4EE3\u7801\u6A21\u5F0F\uFF09",
+      keysEditTab: "  Shift+Tab              \u5FAA\u73AF\u7F16\u8F91\u95E8\u63A7\uFF1Areview \u2194 AUTO\uFF08\u4EE3\u7801\u6A21\u5F0F\uFF0C\u6301\u4E45\u5316\u5230\u914D\u7F6E\uFF09",
+      keysEditUndo: "  u                      \u64A4\u6D88\u6700\u8FD1\u672A\u64A4\u6D88\u7684\u7F16\u8F91\u6279\u5904\u7406\uFF08\u4F1A\u8BDD\u8303\u56F4\uFF0C\u975E\u4EC5\u6A2A\u5E45\uFF09",
+      keysPromptTitle: "\u63D0\u793A\u524D\u7F00\uFF1A",
+      keysSlash: "  /<name>                \u659C\u6760\u547D\u4EE4\uFF1BTab/Enter \u4ECE\u5EFA\u8BAE\u5217\u8868\u4E2D\u9009\u62E9",
+      keysAtFile: "  @<path>                \u5C06\u6587\u4EF6\u5185\u8054\u5230 [Referenced files] \u4E0B\uFF08\u4EE3\u7801\u6A21\u5F0F\uFF09\u3002",
+      keysAtFilePicker: "                           \u5C3E\u90E8 `@\u2026` \u6253\u5F00\u6587\u4EF6\u9009\u62E9\u5668\uFF1B\u2191/\u2193 \u5BFC\u822A\uFF0CTab/Enter \u9009\u62E9\u3002",
+      keysAtUrl: "  @https://...           \u83B7\u53D6 URL\uFF0C\u5265\u79BB HTML\uFF0C\u5185\u8054\u5230 [Referenced URLs] \u4E0B\u3002",
+      keysAtUrlCache: "                           \u6BCF\u4F1A\u8BDD\u7F13\u5B58 \u2014 \u76F8\u540C URL \u83B7\u53D6\u4E24\u6B21\u53EA\u53D6\u4E00\u6B21\u3002",
+      keysBang: "  !<cmd>                 \u5728\u6C99\u7BB1\u6839\u76EE\u5F55\u8FD0\u884C <cmd>\uFF1B\u8F93\u51FA\u8FDB\u5165\u4E0A\u4E0B\u6587",
+      keysBangDetail: "                           \u4EE5\u4FBF\u6A21\u578B\u5728\u4E0B\u4E00\u8F6E\u770B\u5230\u3002\u65E0\u5141\u8BB8\u5217\u8868\u9650\u5236\u3002",
+      keysHash: "  #<note>                \u5C06 <note> \u8FFD\u52A0\u5230 <project>/REASONIX.md\uFF08\u53EF\u63D0\u4EA4\uFF0C\u56E2\u961F\u5171\u4EAB\uFF09\u3002",
+      keysHashGlobal: "  #g <note>              \u5C06 <note> \u8FFD\u52A0\u5230 ~/.reasonix/REASONIX.md\uFF08\u5168\u5C40\uFF0C\u4E0D\u63D0\u4EA4\uFF09\u3002",
+      keysHashBoth: "                           \u4E24\u8005\u90FD\u56FA\u5B9A\u5230\u6BCF\u4E2A\u672A\u6765\u4F1A\u8BDD\u7684\u4E0D\u53EF\u53D8\u524D\u7F00\u4E2D\u3002",
+      keysHashEscape: "                           \u4F7F\u7528 `\\#literal` \u5982\u679C\u60A8\u786E\u5B9E\u60F3\u53D1\u9001 `#` \u6807\u9898\u7ED9\u6A21\u578B\u3002",
+      keysPickersTitle: "\u9009\u62E9\u5668\uFF08\u659C\u6760 + @\u63D0\u53CA\uFF09\uFF1A",
+      keysPickerNav: "  \u2191 / \u2193                  \u5BFC\u822A\u5EFA\u8BAE\u5217\u8868",
+      keysPickerTab: "  Tab                    \u63D2\u5165\u9AD8\u4EAE\u9879\u76EE\u4F46\u4E0D\u63D0\u4EA4",
+      keysPickerEnter: "  Enter                  \u63D2\u5165\u5E76\uFF08\u659C\u6760\uFF09\u8FD0\u884C\uFF0C\uFF08@\uFF09\u7EE7\u7EED\u7F16\u8F91",
+      keysMcpTitle: "MCP \u63A2\u7D22\uFF1A",
+      keysMcpServers: "  /mcp                   \u670D\u52A1\u5668 + \u5DE5\u5177/\u8D44\u6E90/\u63D0\u793A\u8BA1\u6570",
+      keysMcpResource: "  /resource [uri]        \u6D4F\u89C8\u5E76\u8BFB\u53D6 MCP \u670D\u52A1\u5668\u66B4\u9732\u7684\u8D44\u6E90",
+      keysMcpPrompt: "  /prompt [name]         \u6D4F\u89C8\u5E76\u83B7\u53D6 MCP \u670D\u52A1\u5668\u66B4\u9732\u7684\u63D0\u793A",
+      keysUseful: "\u5E38\u7528\u659C\u6760\u547D\u4EE4\uFF1A/help \xB7 /context \xB7 /stats \xB7 /compact \xB7 /new \xB7 /exit",
+      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",
+      applyPlanCodeOnly: "/apply-plan \u4EC5\u5728 `reasonix code` \u4E2D\u53EF\u7528\u3002",
+      applyPlanInfo: "\u25B8 \u8BA1\u5212\u5DF2\u6279\u51C6 \u2014 \u6B63\u5728\u6267\u884C",
+      applyPlanResubmit: "\u4E0A\u65B9\u7684\u8BA1\u5212\u5DF2\u88AB\u6279\u51C6\u3002\u7ACB\u5373\u6267\u884C\u3002\u60A8\u5DF2\u9000\u51FA\u8BA1\u5212\u6A21\u5F0F \u2014 \u6839\u636E\u9700\u8981\u4F7F\u7528 edit_file / write_file / run_command\u3002\u9664\u975E\u53D1\u73B0\u5177\u4F53\u539F\u56E0\uFF0C\u5426\u5219\u8BF7\u9075\u5FAA\u8BA1\u5212\uFF1B\u5982\u679C\u786E\u5B9E\u9700\u8981\u504F\u79BB\uFF0C\u8BF7\u544A\u77E5\u5E76\u7B49\u5F85\u56DE\u590D\u540E\u518D\u8FDB\u884C\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}",
+      modelsFetching: "\u6B63\u5728\u4ECE DeepSeek \u83B7\u53D6 /models\u2026 \u7A0D\u540E\u518D\u8FD0\u884C /models\u3002\u5982\u679C\u6301\u7EED\u4E3A\u7A7A\uFF0C\u60A8\u7684 API \u5BC6\u94A5\u53EF\u80FD\u7F3A\u5C11\u6743\u9650\u6216\u7F51\u7EDC\u88AB\u963B\u6B62\u3002",
+      modelsEmpty: "DeepSeek /models \u8FD4\u56DE\u4E86\u7A7A\u5217\u8868\u3002\u518D\u8BD5 /models\uFF0C\u6216\u5728 api-docs.deepseek.com \u68C0\u67E5\u60A8\u7684\u8D26\u6237\u72B6\u6001\u3002",
+      modelsHeader: "\u53EF\u7528\u6A21\u578B\uFF08DeepSeek /models \xB7 \u5171 {count} \u4E2A\uFF09\uFF1A",
+      modelsCurrent: "\u25B8 {id}  \uFF08\u5F53\u524D\uFF09",
+      modelsSwitch: "\u5207\u6362\u65B9\u5F0F\uFF1A/model <id>",
+      harvestOn: "harvest \u2192 \u5F00\u542F  \uFF08Pillar-2 \u8BA1\u5212\u72B6\u6001\u63D0\u53D6 \xB7 \u6BCF\u8F6E\u989D\u5916 1 \u6B21\u5EC9\u4EF7 flash \u8C03\u7528 \xB7 \u4EC5\u624B\u52A8\u9009\u62E9\uFF1B\u65E0\u9884\u8BBE\u4F1A\u5F00\u542F\u5B83\uFF09",
+      harvestOff: "harvest \u2192 \u5173\u95ED",
+      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>",
+      branchOff: "branch \u2192 \u5173\u95ED",
+      branchUsage: "\u7528\u6CD5\uFF1A/branch <N>   \uFF08N>=2\uFF0C\u6216 'off'\uFF09",
+      branchCapped: "branch \u9884\u7B97\u4E0A\u9650\u4E3A 8\uFF0C\u9632\u6B62\u6210\u672C\u5931\u63A7",
+      branchSet: "branch \u2192 {n}  \uFF08\u6BCF\u8F6E\u8FD0\u884C {n} \u4E2A\u5E76\u884C\u91C7\u6837 \xB7 {n} \u500D\u6BCF\u8F6E\u6210\u672C \xB7 \u7981\u7528\u6D41\u5F0F \xB7 \u4EC5\u624B\u52A8\uFF0C\u65E0\u9884\u8BBE\u542F\u7528\u5206\u652F\uFF09",
+      effortStatus: "reasoning_effort \u2192 {effort}  \uFF08\u4F7F\u7528 /effort high \u66F4\u4FBF\u5B9C/\u66F4\u5FEB\uFF0C/effort max \u4E3A\u667A\u80FD\u4F53\u7EA7\u9ED8\u8BA4 \xB7 \u8DE8\u91CD\u542F\u6301\u4E45\u5316\uFF09",
+      effortUsage: "\u7528\u6CD5\uFF1A/effort <high|max>",
+      effortSet: "reasoning_effort \u2192 {effort}\uFF08\u5DF2\u6301\u4E45\u5316\uFF09",
+      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"
+    },
+    sessions: {
+      forgetNoSession: "\u4E0D\u5728\u4F1A\u8BDD\u4E2D \u2014 \u65E0\u5185\u5BB9\u53EF\u9057\u5FD8",
+      forgetInfo: '\u25B8 \u5DF2\u5220\u9664\u4F1A\u8BDD "{name}" \u2014 \u5F53\u524D\u5C4F\u5E55\u4ECD\u663E\u793A\u5BF9\u8BDD\uFF0C\u4F46\u4E0B\u6B21\u542F\u52A8\u5C06\u5168\u65B0\u5F00\u59CB',
+      forgetFailed: '\u65E0\u6CD5\u5220\u9664\u4F1A\u8BDD "{name}"\uFF08\u5DF2\u6D88\u5931\uFF1F\uFF09',
+      renameUsage: "\u7528\u6CD5\uFF1A/rename <new-name>",
+      renameNoSession: "\u4E0D\u5728\u4F1A\u8BDD\u4E2D \u2014 \u65E0\u5185\u5BB9\u53EF\u91CD\u547D\u540D",
+      renameFailed: '\u65E0\u6CD5\u91CD\u547D\u540D \u2014 "{name}" \u5DF2\u5B58\u5728\u6216\u6E05\u7406\u540E\u4E0E\u5F53\u524D\u4F1A\u8BDD ID \u76F8\u540C',
+      renameInfo: '\u25B8 \u4F1A\u8BDD\u5DF2\u91CD\u547D\u540D\u4E3A \u2192 "{name}"\u3002\u91CD\u542F TUI \u4EE5\u4F7F\u7528\u65B0\u540D\u79F0\u3002',
+      resumeUsage: "\u7528\u6CD5\uFF1A/resume <session-name>  \u2014 \u4F7F\u7528 /sessions \u5217\u51FA",
+      resumeNotFound: '\u6CA1\u6709\u540D\u4E3A "{name}" \u7684\u4F1A\u8BDD \u2014 \u4F7F\u7528 /sessions \u5217\u51FA',
+      resumeInfo: '\u25B8 \u8981\u6062\u590D "{name}"\uFF0C\u8BF7\u9000\u51FA\u5E76\u8FD0\u884C\uFF1Areasonix chat --session {name}\n  \uFF08\u4F1A\u8BDD\u4E2D\u5207\u6362\u9700\u8981\u91CD\u542F\uFF0C\u4EE5\u4FBF\u6D88\u606F\u65E5\u5FD7\u53EF\u4EE5\u5E72\u51C0\u5730\u56DE\u9000\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: {
+      thinkEmpty: "\u672A\u7F13\u5B58\u63A8\u7406\u5185\u5BB9\u3002`/think` \u663E\u793A\u6700\u8FD1\u4E00\u8F6E\u7684\u5B8C\u6574\u601D\u8003\u6A21\u5F0F\u601D\u7EF4 \u2014 \u4EC5\u601D\u8003\u6A21\u5F0F\u6A21\u578B\uFF08deepseek-v4-flash / -v4-pro / -reasoner\uFF09\u4EA7\u751F\u5B83\uFF0C\u4E14\u4EC5\u5728\u8F6E\u6B21\u5B8C\u6210\u540E\u3002",
+      thinkInfo: "\u21B3 \u5B8C\u6574\u601D\u8003\uFF08{count} \u5B57\u7B26\uFF09\uFF1A",
+      toolEmpty: "\u6B64\u4F1A\u8BDD\u4E2D\u5C1A\u65E0\u5DE5\u5177\u8C03\u7528\u3002`/tool` \u5728\u6A21\u578B\u5B9E\u9645\u4F7F\u7528\u5DE5\u5177\u540E\u5217\u51FA\u5B83\u4EEC\uFF1B`/tool N` \u8F6C\u50A8\u7B2C N \u4E2A\u6700\u8FD1\u7684\u5B8C\u6574\uFF08\u672A\u622A\u65AD\uFF09\u8F93\u51FA\u3002",
+      toolUsage: "\u7528\u6CD5\uFF1A/tool [N]   \uFF08\u65E0\u53C2\u6570 \u2192 \u5217\u8868\uFF1BN=1 \u2192 \u6700\u8FD1\u7684\u5B8C\u6574\u7ED3\u679C\uFF0CN=2 \u2192 \u4E0A\u4E00\u4E2A\uFF0C\u2026\uFF09",
+      toolOob: "\u5386\u53F2\u4E2D\u4EC5\u6709 {count} \u6B21\u5DE5\u5177\u8C03\u7528 \u2014 \u8BF7\u6C42\u4E86 #{n}\u3002\u5C1D\u8BD5\u4E0D\u5E26\u53C2\u6570\u7684 /tool \u67E5\u770B\u5217\u8868\u3002",
+      toolNotFound: "\u65E0\u6CD5\u8BFB\u53D6\u5DE5\u5177\u8C03\u7528 #{n}",
+      toolInfo: "\u21B3 tool<{name}> #{n}\uFF08{chars} \u5B57\u7B26\uFF09\uFF1A",
+      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    harvest={harvest} \xB7 branch={branch} \xB7 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"
+    },
+    semantic: {
+      codeOnly: "/semantic \u4EC5\u5728 `reasonix code` \u4E2D\u53EF\u7528\uFF08\u9700\u8981\u9879\u76EE\u6839\u76EE\u5F55\uFF09\u3002",
+      checking: "\u25B8 \u6B63\u5728\u68C0\u67E5 semantic_search \u72B6\u6001\u2026"
+    },
+    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
 var HOOK_EVENTS = [
   "PreToolUse",
   "PostToolUse",
@@ -564,15 +2440,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 +2567,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 +2614,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 +2644,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 +2678,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 +2748,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 +2930,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 +3187,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 +3213,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 +3231,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 +3247,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 +3265,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 +3295,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 +3394,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;
@@ -1711,51 +3590,58 @@ function summarizeBranch(chosen, samples) {
 }
 
 // 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 +3668,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 +3716,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 +3733,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 +3754,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 +3944,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;
@@ -2282,15 +4168,18 @@ var StormBreaker = class {
   windowSize;
   threshold;
   isMutating;
+  isStormExempt;
   recent = [];
-  constructor(windowSize = 6, threshold = 3, isMutating) {
+  constructor(windowSize = 6, threshold = 3, isMutating, isStormExempt) {
     this.windowSize = windowSize;
     this.threshold = threshold;
     this.isMutating = isMutating;
+    this.isStormExempt = isStormExempt;
   }
   inspect(call) {
     const name = call.function?.name;
     if (!name) return { suppress: false };
+    if (this.isStormExempt?.(call)) return { suppress: false };
     const args = call.function?.arguments ?? "";
     const mutating = this.isMutating ? this.isMutating(call) : false;
     const readOnly = !mutating;
@@ -2391,7 +4280,12 @@ var ToolCallRepair = class {
   opts;
   constructor(opts) {
     this.opts = opts;
-    this.storm = new StormBreaker(opts.stormWindow ?? 6, opts.stormThreshold ?? 3, opts.isMutating);
+    this.storm = new StormBreaker(
+      opts.stormWindow ?? 6,
+      opts.stormThreshold ?? 3,
+      opts.isMutating,
+      opts.isStormExempt
+    );
   }
   /** Called at start of every user turn — fresh intent shouldn't inherit old repetition state. */
   resetStorm() {
@@ -2534,9 +4428,15 @@ var CacheFirstLoop = class {
       }
       return def.readOnly !== true;
     };
+    const isStormExempt = (call) => {
+      const name = call.function?.name;
+      if (!name) return false;
+      return registry.get(name)?.stormExempt === true;
+    };
     this.repair = new ToolCallRepair({
       allowedToolNames: allowedNames,
       isMutating,
+      isStormExempt,
       stormThreshold: parsePositiveIntEnv(process.env.REASONIX_STORM_THRESHOLD),
       stormWindow: parsePositiveIntEnv(process.env.REASONIX_STORM_WINDOW)
     });
@@ -2670,6 +4570,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;
   }
@@ -2762,7 +4666,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;
       }
@@ -2771,7 +4678,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)
+          })
         };
       }
     }
@@ -2796,7 +4706,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;
@@ -2808,7 +4718,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));
@@ -2826,7 +4736,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) {
@@ -2834,7 +4744,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);
@@ -2845,25 +4755,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)
+              })
             };
           }
         }
@@ -3062,11 +4979,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;
       }
@@ -3077,7 +4995,7 @@ ${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 = "";
@@ -3102,7 +5020,7 @@ ${reason}`
         yield {
           turn: this._turn,
           role: "status",
-          content: "extracting plan state from reasoning\u2026"
+          content: t("loop.harvestStatus")
         };
       }
       const planState = preHarvestedPlanState ? preHarvestedPlanState : this.harvestEnabled ? await harvest(reasoningContent || null, this.client, this.harvestOptions, signal) : emptyPlanState();
@@ -3132,7 +5050,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
+          })
         };
       }
       const allSuppressed = report.stormsBroken > 0 && repairedCalls.length === 0 && toolCalls.length > 0;
@@ -3157,13 +5079,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",
@@ -3183,20 +5105,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") {
@@ -3205,9 +5135,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" });
@@ -3265,7 +5197,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 {
@@ -3308,12 +5244,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";
@@ -3326,7 +5262,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;
   }
@@ -3384,7 +5320,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;
@@ -3427,7 +5363,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;
@@ -3452,12 +5388,12 @@ 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) => s.mtimeMs).catch(() => 0)
     )
   );
   for (let i = 0; i < accepted.length; i++) {
@@ -3603,20 +5539,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;
   }
@@ -3653,19 +5589,19 @@ ${mem.content}
 import { createHash as createHash2 } from "crypto";
 import {
   existsSync as existsSync7,
-  mkdirSync as mkdirSync2,
-  readFileSync as readFileSync8,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync9,
   readdirSync as readdirSync4,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync2
+  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, readFileSync as readFileSync7, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
-import { homedir as homedir3 } from "os";
-import { 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):
@@ -3726,7 +5662,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;
   }
@@ -3739,11 +5675,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. */
@@ -3770,16 +5706,41 @@ var SkillStore = class {
     }
     return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
   }
+  /** Scaffold a new skill stub at the chosen scope. Refuses to overwrite. */
+  create(name, scope) {
+    if (!isValidSkillName(name)) {
+      return { error: `invalid skill name: "${name}" \u2014 use letters, digits, _, -, .` };
+    }
+    if (scope === "project" && !this.projectRoot) {
+      return { error: "project scope requires a workspace \u2014 run from `reasonix code`" };
+    }
+    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}` };
+    }
+    mkdirSync3(dirname4(flat), { recursive: true });
+    try {
+      writeFileSync3(flat, skillStubBody(name), { encoding: "utf8", flag: "wx" });
+    } catch (err) {
+      if (err.code === "EEXIST") {
+        return { error: `skill "${name}" already exists at ${flat}` };
+      }
+      throw err;
+    }
+    return { path: flat };
+  }
   /** Resolve one skill by name. Returns `null` if not found or malformed. */
   read(name) {
     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);
       }
@@ -3794,21 +5755,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;
     }
@@ -3829,6 +5790,22 @@ var SkillStore = class {
 function parseRunAs(raw) {
   return raw?.trim() === "subagent" ? "subagent" : "inline";
 }
+function skillStubBody(name) {
+  return `---
+name: ${name}
+description: One-liner \u2014 what does this skill do?
+---
+
+# ${name}
+
+Replace this body with the playbook the model should follow when this skill is invoked.
+
+Tips:
+- Reference tools by name (run_command, edit_file, search_content, ...)
+- Add \`runAs: subagent\` to frontmatter to spawn an isolated subagent loop
+- Add \`allowed-tools: read_file, search_content\` to scope a subagent's tools
+`;
+}
 function skillIndexLine(s) {
   const safeDesc = s.description.replace(/\n/g, " ").trim();
   const tag = s.runAs === "subagent" ? " [\u{1F9EC} subagent]" : "";
@@ -4063,15 +6040,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)) mkdirSync2(p, { recursive: true });
+  if (!existsSync7(p)) mkdirSync4(p, { recursive: true });
 }
 function parseFrontmatter2(raw) {
   const lines = raw.split(/\r?\n/);
@@ -4116,7 +6093,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. */
@@ -4127,7 +6104,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() {
@@ -4135,14 +6112,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;
     }
@@ -4160,7 +6137,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,
@@ -4213,10 +6190,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}
 `;
-    writeFileSync2(file, content, "utf8");
+    writeFileSync4(file, content, "utf8");
     this.regenerateIndex(input.scope);
     return file;
   }
@@ -4242,7 +6219,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;
@@ -4257,16 +6234,16 @@ var MemoryStore = class {
         lines.push(`- [${name}](${name}.md) \u2014 (malformed, check frontmatter)`);
       }
     }
-    writeFileSync2(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;
   }
@@ -4280,7 +6257,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 [
@@ -4340,91 +6317,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";
@@ -4507,10 +6399,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;
@@ -4522,6 +6419,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 });
@@ -4529,6 +6427,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);
@@ -4551,6 +6450,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;
@@ -4566,6 +6466,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 });
@@ -4574,6 +6475,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));
@@ -4591,6 +6493,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();
@@ -4603,12 +6506,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);
@@ -4693,6 +6598,7 @@ function registerFilesystemTools(registry, opts) {
   - range: "A-B"  \u2192 inclusive line range A..B, 1-indexed (e.g. "120-180" around an edit site)
 When none of these is given AND the file is longer than ${DEFAULT_AUTO_PREVIEW_LINES} lines, the tool auto-returns a head+tail preview with an "N lines omitted" marker rather than dumping everything. If you need the middle, re-call with a range. Prefer search_content to locate a symbol first, then read_file with a range around the hit \u2014 one scoped read beats three full-file reads.`,
     readOnly: true,
+    stormExempt: true,
     parameters: {
       type: "object",
       properties: {
@@ -4773,6 +6679,7 @@ ${slice.join("\n")}`;
     parallelSafe: true,
     description: "List entries in a directory under the sandbox root. Returns one line per entry, marking directories with a trailing slash. Not recursive \u2014 use directory_tree for that.",
     readOnly: true,
+    stormExempt: true,
     parameters: {
       type: "object",
       properties: {
@@ -4888,10 +6795,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({
@@ -4925,7 +6832,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,
@@ -4934,7 +6841,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({
@@ -5741,12 +7648,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;
 }
@@ -5873,70 +7780,6 @@ function forkRegistryWithAllowList(parent, allow, alsoExclude) {
 // src/tools/shell.ts
 import * as pathMod7 from "path";
 
-// src/config.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync9, writeFileSync as writeFileSync3 } from "fs";
-import { homedir as homedir5 } from "os";
-import { dirname as dirname4, 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()) {
-  mkdirSync3(dirname4(path2), { recursive: true });
-  writeFileSync3(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";
@@ -6033,7 +7876,8 @@ var JobRegistry = class {
         },
         closedPromise: Promise.resolve(),
         signalClosed: () => {
-        }
+        },
+        outputWaiters: /* @__PURE__ */ new Set()
       };
       this.jobs.set(id2, job2);
       return {
@@ -6069,7 +7913,8 @@ var JobRegistry = class {
       readyPromise,
       signalReady: readyResolve,
       closedPromise,
-      signalClosed: closedResolve
+      signalClosed: closedResolve,
+      outputWaiters: /* @__PURE__ */ new Set()
     };
     this.jobs.set(id, job);
     let readyMatched = false;
@@ -6096,6 +7941,11 @@ ${job.output.slice(start)}`;
           }
         }
       }
+      if (job.outputWaiters.size > 0) {
+        const waiters = [...job.outputWaiters];
+        job.outputWaiters.clear();
+        for (const wake of waiters) wake();
+      }
     };
     child.stdout?.on("data", onData);
     child.stderr?.on("data", onData);
@@ -6157,6 +8007,39 @@ ${job.output.slice(start)}`;
       spawnError: job.spawnError
     };
   }
+  async waitForJob(id, opts = {}) {
+    const job = this.jobs.get(id);
+    if (!job) return null;
+    if (!job.running) {
+      return {
+        exited: true,
+        exitCode: job.exitCode,
+        latestOutput: job.output
+      };
+    }
+    const timeoutMs = Math.max(0, Math.min(3e4, opts.timeoutMs ?? 5e3));
+    const startOutput = job.output;
+    let wakeOutput = null;
+    const outputPromise = new Promise((resolve10) => {
+      wakeOutput = resolve10;
+      job.outputWaiters.add(resolve10);
+    });
+    let timer = null;
+    await Promise.race([
+      job.closedPromise,
+      outputPromise,
+      new Promise((resolve10) => {
+        timer = setTimeout(resolve10, timeoutMs);
+      })
+    ]);
+    if (timer) clearTimeout(timer);
+    if (wakeOutput) job.outputWaiters.delete(wakeOutput);
+    return {
+      exited: !job.running,
+      exitCode: job.exitCode,
+      latestOutput: latestOutputSince(startOutput, job.output)
+    };
+  }
   /** SIGTERM, wait graceMs, then SIGKILL. Idempotent on already-exited jobs. */
   async stop(id, opts = {}) {
     const job = this.jobs.get(id);
@@ -6236,6 +8119,11 @@ function snapshot(job) {
     spawnError: job.spawnError
   };
 }
+function latestOutputSince(before, after) {
+  if (!before) return after;
+  if (after.startsWith(before)) return after.slice(before.length);
+  return after;
+}
 
 // src/tools/shell/exec.ts
 import { spawn as spawn4, spawnSync } from "child_process";
@@ -7215,6 +9103,7 @@ function registerShellTools(registry, opts) {
     description: "Read the latest output of a background job started with `run_background`. By default returns the tail of the buffer (last 80 lines). Pass `since` (the `byteLength` from a previous call) to stream only new content incrementally. Tells you whether the job is still running, so you can stop polling when it's done.",
     readOnly: true,
     parallelSafe: true,
+    stormExempt: true,
     parameters: {
       type: "object",
       properties: {
@@ -7239,6 +9128,32 @@ function registerShellTools(registry, opts) {
       return formatJobRead(args.jobId, out);
     }
   });
+  registry.register({
+    name: "wait_for_job",
+    description: "Block until a background job exits or produces new output, bounded by `timeoutMs`. Use this instead of polling `job_output` with identical args when you're intentionally waiting for state to change. Returns JSON with `exited`, `exitCode`, and `latestOutput`.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        jobId: { type: "integer", description: "Job id returned by run_background." },
+        timeoutMs: {
+          type: "integer",
+          description: "Max time to block before returning if nothing changes. Clamped to 0..30000. Default 5000."
+        }
+      },
+      required: ["jobId"]
+    },
+    fn: async (args) => {
+      const out = await jobs.waitForJob(args.jobId, { timeoutMs: args.timeoutMs });
+      if (!out) return `job ${args.jobId}: not found (use list_jobs)`;
+      return {
+        jobId: args.jobId,
+        exited: out.exited,
+        exitCode: out.exitCode,
+        latestOutput: out.latestOutput
+      };
+    }
+  });
   registry.register({
     name: "stop_job",
     description: "Stop a background job started with `run_background`. SIGTERM first; SIGKILL after a short grace period if it doesn't exit cleanly. Returns the final output + exit code. Safe to call on an already-exited job.",
@@ -7260,6 +9175,7 @@ function registerShellTools(registry, opts) {
     description: "List every background job started this session \u2014 running and exited \u2014 with id, command, pid, status. Use when you've lost track of which job_id corresponds to which process, or to see what's still alive.",
     readOnly: true,
     parallelSafe: true,
+    stormExempt: true,
     parameters: { type: "object", properties: {} },
     fn: async () => {
       const all = jobs.list();
@@ -7834,15 +9750,15 @@ function computeReplayStats(records) {
   };
 }
 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;
@@ -7906,8 +9822,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"}]`;
   }
@@ -7937,7 +9853,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) {
@@ -8130,8 +10046,8 @@ function renderMarkdown(report) {
   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("");
@@ -8192,16 +10108,16 @@ function truncate(s, n) {
 }
 
 // src/version.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync12, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync12, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir6 } from "os";
-import { dirname as dirname5, join as join11 } from "path";
+import { dirname as dirname6, join as join11 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var REGISTRY_URL = "https://registry.npmjs.org/reasonix/latest";
 var LATEST_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 var LATEST_FETCH_TIMEOUT_MS = 2e3;
 function readPackageVersion() {
   try {
-    let dir = dirname5(fileURLToPath2(import.meta.url));
+    let dir = dirname6(fileURLToPath2(import.meta.url));
     for (let i = 0; i < 6; i++) {
       const p = join11(dir, "package.json");
       if (existsSync9(p)) {
@@ -8210,7 +10126,7 @@ function readPackageVersion() {
           return pkg.version;
         }
       }
-      const parent = dirname5(dir);
+      const parent = dirname6(dir);
       if (parent === dir) break;
       dir = parent;
     }
@@ -8236,8 +10152,8 @@ function readCache(homeDirOverride) {
 function writeCache(entry, homeDirOverride) {
   try {
     const p = cachePath(homeDirOverride);
-    mkdirSync4(dirname5(p), { recursive: true });
-    writeFileSync4(p, JSON.stringify(entry), "utf8");
+    mkdirSync5(dirname6(p), { recursive: true });
+    writeFileSync5(p, JSON.stringify(entry), "utf8");
   } catch {
   }
 }
@@ -9041,15 +10957,15 @@ import {
   existsSync as existsSync10,
   fstatSync,
   ftruncateSync,
-  mkdirSync as mkdirSync5,
+  mkdirSync as mkdirSync6,
   openSync as openSync2,
   readFileSync as readFileSync13,
   readSync,
   unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync5,
+  writeFileSync as writeFileSync6,
   writeSync
 } from "fs";
-import { dirname as dirname6, resolve as resolve9 } from "path";
+import { dirname as dirname7, resolve as resolve9 } from "path";
 var BLOCK_RE = /^(\S[^\n]*)\n<{7} SEARCH\n([\s\S]*?)\n?={7}\n([\s\S]*?)\n?>{7} REPLACE/gm;
 function parseEditBlocks(text) {
   const out = [];
@@ -9079,7 +10995,7 @@ function applyEditBlock(block, rootDir) {
   const searchEmpty = block.search.length === 0;
   if (searchEmpty) {
     try {
-      mkdirSync5(dirname6(absTarget), { recursive: true });
+      mkdirSync6(dirname7(absTarget), { recursive: true });
       const fd = openSync2(absTarget, "wx");
       try {
         writeSync(fd, block.replace);
@@ -9194,7 +11110,7 @@ function restoreSnapshots(snapshots, rootDir) {
           message: "removed (the edit had created it)"
         };
       }
-      writeFileSync5(abs, snap.prevContent, "utf8");
+      writeFileSync6(abs, snap.prevContent, "utf8");
       return {
         path: snap.path,
         status: "applied",
@@ -9370,6 +11286,7 @@ You have TWO tools for running shell commands, and picking the right one is non-
 
 After \`run_background\`, tools available to you:
 - \`job_output(jobId, tailLines?)\` \u2014 read recent logs to verify startup / debug errors.
+- \`wait_for_job(jobId, timeoutMs?)\` \u2014 block until the job exits or emits new output. Prefer this over repeating identical \`job_output\` calls while you're intentionally waiting.
 - \`list_jobs\` \u2014 see every job this session (running + exited).
 - \`stop_job(jobId)\` \u2014 SIGTERM \u2192 SIGKILL after grace. Stop before switching port / config.
 
@@ -9457,17 +11374,17 @@ import {
   closeSync as closeSync3,
   existsSync as existsSync12,
   fstatSync as fstatSync2,
-  mkdirSync as mkdirSync6,
+  mkdirSync as mkdirSync7,
   openSync as openSync3,
   readFileSync as readFileSync15,
   readSync as readSync2,
   renameSync as renameSync2,
   statSync as statSync5,
   unlinkSync as unlinkSync4,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync7
 } from "fs";
 import { homedir as homedir7 } from "os";
-import { dirname as dirname7, join as join13 } from "path";
+import { dirname as dirname8, join as join13 } from "path";
 function defaultUsageLogPath(homeDirOverride) {
   return join13(homeDirOverride ?? homedir7(), ".reasonix", "usage.jsonl");
 }
@@ -9508,7 +11425,7 @@ function compactUsageLogIfLarge(path2, now) {
   if (kept.length === lines.filter((l) => l.trim()).length) return;
   const tmp = `${path2}.compacting`;
   try {
-    writeFileSync6(tmp, kept.length > 0 ? `${kept.join("\n")}
+    writeFileSync7(tmp, kept.length > 0 ? `${kept.join("\n")}
 ` : "", "utf8");
     renameSync2(tmp, path2);
   } catch {
@@ -9534,7 +11451,7 @@ function appendUsage(input) {
   if (input.subagent) record.subagent = input.subagent;
   const path2 = input.path ?? defaultUsageLogPath();
   try {
-    mkdirSync6(dirname7(path2), { recursive: true });
+    mkdirSync7(dirname8(path2), { recursive: true });
     appendFileSync2(path2, `${JSON.stringify(record)}
 `, "utf8");
     compactUsageLogIfLarge(path2, record.ts);