@huicai/cli 2026.710.97949 → 2026.711.0

package/src/commands.js

@@ -7,11 +7,37 @@ import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import { execSync } from 'node:child_process';
-import { saveConfig, DEFAULT_MODEL } from './config.js';
-import { listModels, fetchUsage } from './api.js';
-import { listSessions, relTime, turnCount } from './session.js';
-import { compactNow } from './compaction.js';
-import { loadAllowRules } from './settings.js';
+import { saveConfig, DEFAULT_MODEL, CONFIG_PATH } from './config.js';
+import { listModels, fetchUsage, streamChat } from './api.js';
+import { listSessions, relTime, turnCount, saveSession, createSession } from './session.js';
+import { compactNow, buildModelMessages } from './compaction.js';
+import { computeInsights, formatInsights } from './insights.js';
+import { setColorMode, setAccent, getAccent, ACCENTS } from './colors.js';
+import { detectVerifyCommand } from './autofix.js';
+import { loadAllowRules, describeRules, parseRule, addProjectRule, removeProjectRule, GLOBAL_SETTINGS_PATH, projectSettingsPath } from './settings.js';
+import { contextReport } from './context-report.js';
+import { renderDiff } from './diffview.js';
+import { loadHooks, formatHooks } from './hooks.js';
+import { copyToClipboard } from './clipboard.js';
+import { toMarkdown, recapConversation } from './transcript.js';
+import { runDoctor } from './doctor.js';
+import { TOOL_SPECS } from './tools.js';
+import { makeTodoTool } from './todo.js';
+import { makeMemoryTool } from './memory.js';
+
+const PLATFORM_MODEL_RE = /^(agent|workflow|datahuman)-/;
+
+// /add-dir：在系统提示词末尾维护「附加可访问目录」块（幂等：先剥离旧块再按 session.extraDirs 重建）。
+const EXTRA_DIRS_MARK = '\n\n# 附加可访问目录（可用 read_file/list_files/grep 以绝对路径访问；写入仍限主目录）\n';
+function applyExtraDirs(session) {
+  const sys = session.messages && session.messages[0];
+  if (!sys || sys.role !== 'system' || typeof sys.content !== 'string') return;
+  const idx = sys.content.indexOf(EXTRA_DIRS_MARK);
+  let content = idx >= 0 ? sys.content.slice(0, idx) : sys.content;
+  const dirs = session.extraDirs || [];
+  if (dirs.length) content += EXTRA_DIRS_MARK + dirs.map((d) => '- ' + d).join('\n') + '\n';
+  sys.content = content;
+}
 
 /** /init 的智能体式提示词：让模型实际调研项目后生成/完善 HUICAI.md（而非套静态模板）。 */
 export const INIT_PROMPT =
@@ -152,10 +178,14 @@ const BUILTINS = [
     },
   },
   {
-    name: 'cost', desc: '查看本次运行累计 token 用量',
+    name: 'cost', desc: '查看本次运行累计 token 用量（及预算进度）',
     run(ctx) {
+      const used = ctx.usage.prompt + ctx.usage.completion;
+      const b = Number(ctx.config.budgetTokens) || 0;
       ctx.print(`token 用量：输入 ${ctx.usage.prompt} / 输出 ${ctx.usage.completion}`
-        + (ctx.session.lastPromptTokens ? ` · 当前上下文 ~${ctx.session.lastPromptTokens} tok` : ''));
+        + (ctx.session.lastPromptTokens ? ` · 当前上下文 ~${ctx.session.lastPromptTokens} tok` : '')
+        + (b > 0 ? `\n预算：${used.toLocaleString()} / ${b.toLocaleString()} tokens（${Math.round((used / b) * 100)}%）`
+          + (used >= b ? ' ⚠ 已超预算' : used >= b * 0.8 ? ' ⚠ 接近预算' : '') : ''));
     },
   },
   {
@@ -181,7 +211,9 @@ const BUILTINS = [
         `目录      ${ctx.cwd}${branch ? `（git:${branch}）` : ''}`,
         `会话      ${s.id} · ${turnCount(s.messages)} 轮${s.lastPromptTokens ? ` · 上下文 ~${s.lastPromptTokens} tok` : ''}`,
         `token     输入 ${ctx.usage.prompt} / 输出 ${ctx.usage.completion}`,
-        `审批      ${ctx.permissions?.isYolo?.() ? '⚠ yolo 自动放行' : '写/执行需授权'} · 允许规则 ${rules.length} 条`,
+        `审批      ${ctx.permissions?.isYolo?.() ? '⚠ yolo 自动放行' : '写/执行需授权'}`
+          + ` · 允许规则 ${rules.length} 条${ctx.config.planMode ? ' · 📋 计划模式(只读)' : ''}`
+          + `${ctx.config.sandbox ? ' · 🧪 沙箱' : ''}${ctx.config.goal ? ' · 🎯 目标已设' : ''}`,
         `MCP       ${mcpNames.length ? mcpNames.join(', ') : '(未配置)'}`,
       ];
       ctx.print(lines.join('\n'));
@@ -260,6 +292,929 @@ const BUILTINS = [
         .join('\n'));
     },
   },
+  {
+    name: 'context', desc: '可视化当前上下文占用（各类别 token 估算）',
+    run(ctx) {
+      const platform = PLATFORM_MODEL_RE.test(String(ctx.config.model || ''));
+      let specs = [];
+      if (!platform) {
+        try {
+          const todo = makeTodoTool({ state: { list: [] }, emit() {} }).spec;
+          const mem = ctx.config.memoryEnabled !== false ? makeMemoryTool({ cwd: ctx.cwd, emit() {} }).spec : null;
+          specs = [...TOOL_SPECS, todo, ...(mem ? [mem] : []),
+            ...((ctx.extraTools || []).map((t) => t.spec).filter(Boolean))];
+        } catch {
+          specs = TOOL_SPECS;
+        }
+      }
+      ctx.print(contextReport({
+        messages: ctx.session.messages,
+        compaction: ctx.session.compaction || {},
+        specs,
+        lastPromptTokens: ctx.session.lastPromptTokens || 0,
+        autoCompactTokens: Number(ctx.config.autoCompactTokens) || 0,
+        platform,
+      }));
+    },
+  },
+  {
+    name: 'permissions', args: '[allow|deny <规则> | remove <规则>]', desc: '查看/增删工具权限规则（allow/deny）',
+    run(ctx, arg) {
+      const parts = String(arg || '').trim().split(/\s+/).filter(Boolean);
+      const sub = (parts.shift() || '').toLowerCase();
+      const rule = parts.join(' ').trim();
+      if (!sub) {
+        const d = describeRules(ctx.cwd);
+        const fmt = (arr) => (arr.length ? arr.map((r) => '      ' + r).join('\n') : '      （无）');
+        ctx.print(
+          '权限规则（deny 优先于 allow/yolo，对只读工具也生效）\n'
+          + '  全局 ~/.huicai/settings.json\n'
+          + '    允许:\n' + fmt(d.global.allow) + '\n    拒绝:\n' + fmt(d.global.deny) + '\n'
+          + '  项目 .huicai/settings.json\n'
+          + '    允许:\n' + fmt(d.project.allow) + '\n    拒绝:\n' + fmt(d.project.deny) + '\n'
+          + '  用法：/permissions allow <规则> · /permissions deny <规则> · /permissions remove <规则>\n'
+          + '  规则语法：`工具名` 或 `工具名(模式*)`，如 run_bash(git *)、edit_file、read_file(**/.env*)',
+        );
+        return;
+      }
+      if (sub === 'allow' || sub === 'deny') {
+        if (!rule || !parseRule(rule)) {
+          ctx.print('规则无效。示例：run_bash(git *)、edit_file、fetch_url(https://a.com*)');
+          return;
+        }
+        try {
+          const p = addProjectRule(ctx.cwd, sub, rule);
+          ctx.permissions?.reloadRules?.();
+          ctx.print(`已添加${sub === 'deny' ? '拒绝' : '允许'}规则：${rule} → ${p}`);
+        } catch (e) {
+          ctx.print('写入失败：' + e.message);
+        }
+        return;
+      }
+      if (sub === 'remove' || sub === 'rm') {
+        if (!rule) {
+          ctx.print('用法：/permissions remove <规则原文>（仅移除项目设置里的规则）');
+          return;
+        }
+        const r = removeProjectRule(ctx.cwd, rule);
+        ctx.permissions?.reloadRules?.();
+        ctx.print(r.removed ? `已移除规则：${rule}` : `未在项目设置中找到该规则：${rule}`);
+        return;
+      }
+      ctx.print('未知子命令。用法：/permissions [allow|deny|remove] <规则>');
+    },
+  },
+  {
+    name: 'diff', desc: '查看未提交改动（git）与本会话智能体改过的文件',
+    run(ctx) {
+      ctx.print(renderDiff(ctx.cwd, ctx.session.messages));
+    },
+  },
+  {
+    name: 'pr', args: '[commit|address]', desc: '自动提交并开 PR（生成规范 commit→建分支→push→gh 开 PR）；address=按 review 评论自动改',
+    async run(ctx, arg) {
+      const a = String(arg || '').trim().toLowerCase();
+      if (a === 'address' || a === 'comments') {
+        return { prompt: '请处理当前分支/PR 的 review 评论：用 `gh pr view --comments`（无 PR 则先 `gh pr status`）读取评论，'
+          + '逐条理解并修改代码解决，然后 git add/commit（规范信息）+ git push；完成后逐条说明如何处理的。若未装 gh 或无 PR，先告知。' };
+      }
+      const { runPrFlow } = await import('./gitflow.js');
+      try {
+        const r = await runPrFlow({ cwd: ctx.cwd, config: ctx.config, emit: (t) => ctx.print(t), push: a !== 'commit', openPr: a !== 'commit' });
+        if (!r.ok) {
+          ctx.print('✗ ' + r.error);
+          return;
+        }
+        ctx.print(r.pr ? '✅ 已开 PR：' + r.pr : '✅ 完成（分支 ' + r.branch + '）' + (r.note ? '：' + r.note : ''));
+      } catch (e) {
+        ctx.print('PR 流程出错：' + e.message);
+      }
+    },
+  },
+  {
+    name: 'plan', args: '[on|off|approve]', desc: '计划模式：只读调研出方案→/plan approve 批准并分步执行',
+    run(ctx, arg) {
+      const a = String(arg || '').trim().toLowerCase();
+      if (a === 'approve' || a === 'go') {
+        ctx.config.planMode = false;
+        ctx.permissions?.setPlanMode?.(false);
+        ctx.print('计划已批准，开始分步执行。');
+        return { prompt: '计划已获批准。现在请按你刚才制定的计划（todo 列表）逐步执行：'
+          + '每完成一步用 todo_write 更新状态并简要自检；遇到与计划不符及时调整并说明；'
+          + '全部完成后总结改了什么、以及如何验证（可用 /verify 让我自动跑验证）。' };
+      }
+      const next = a === 'on' ? true : a === 'off' ? false : !ctx.config.planMode;
+      ctx.config.planMode = next;
+      ctx.permissions?.setPlanMode?.(next);
+      ctx.print(next
+        ? '计划模式：开。只做只读调研并用 todo_write 产出分步方案；写/执行会被拦截。'
+          + '\n  方案满意后用 /plan approve 批准并自动分步执行；或 /plan off 手动执行。'
+        : '计划模式：关。恢复正常执行（写/执行仍按权限审批）。');
+    },
+  },
+  {
+    name: 'rewind', args: '[N [chat|code|both]]', desc: '检查点回滚：无参列出；/rewind N 回退对话，加 code/both 一并回滚文件',
+    run(ctx, arg) {
+      const cps = ctx.checkpoints;
+      if (!cps || !cps.list.length) {
+        ctx.print('暂无检查点（每个用户回合前自动记录，发生对话后可用）。');
+        return;
+      }
+      const parts = String(arg || '').trim().split(/\s+/).filter(Boolean);
+      if (!parts.length) {
+        const lines = ['检查点（回滚到某个回合之前）'];
+        for (const cp of cps.list) {
+          lines.push(`  #${cp.id}  ${relTime(cp.time)}  ${cp.label}`
+            + (cp.journal.length ? ` · 改动 ${cp.journal.length} 处` : ''));
+        }
+        lines.push('  用法：/rewind N（仅回退对话，安全）· /rewind N code（回滚文件）· /rewind N both');
+        lines.push('  提示：code/both 会覆盖当前文件，建议先 /diff 查看。');
+        ctx.print(lines.join('\n'));
+        return;
+      }
+      const id = Number(parts[0]);
+      if (!Number.isFinite(id)) {
+        ctx.print('用法：/rewind N [chat|code|both]');
+        return;
+      }
+      const mode = ['chat', 'code', 'both'].includes(parts[1]) ? parts[1] : 'chat';
+      const s = cps.restore(id, mode, { session: ctx.session, cwd: ctx.cwd });
+      if (!s.ok) {
+        ctx.print(s.error);
+        return;
+      }
+      const bits = [];
+      if (s.conversation) bits.push('对话已回退到该回合之前');
+      if (s.filesRestored.length) bits.push(`恢复文件 ${s.filesRestored.length} 个`);
+      if (s.filesDeleted.length) bits.push(`删除新建文件 ${s.filesDeleted.length} 个`);
+      if (s.filesSkipped.length) bits.push(`跳过(过大) ${s.filesSkipped.length} 个`);
+      if (s.filesFailed.length) bits.push(`失败 ${s.filesFailed.length} 个`);
+      try {
+        saveSession(ctx.session);
+      } catch { /* best-effort */ }
+      ctx.print('已回滚到 #' + id + '：' + (bits.join('；') || '无变化')
+        + (s.filesFailed.length ? '\n  失败：' + s.filesFailed.join('；') : ''));
+      if (s.conversation) return { action: 'refresh' };
+    },
+  },
+  {
+    name: 'hooks', desc: '查看已配置的工具事件钩子（Pre/PostToolUse/UserPromptSubmit/Stop）',
+    run(ctx) {
+      ctx.print(formatHooks(loadHooks(ctx.cwd)));
+    },
+  },
+  {
+    name: 'copy', args: '[N]', desc: '复制助手回复到剪贴板（默认最后一条；N=倒数第 N 条）',
+    async run(ctx, arg) {
+      const replies = ctx.session.messages.filter(
+        (m) => m.role === 'assistant' && typeof m.content === 'string' && m.content.trim());
+      if (!replies.length) {
+        ctx.print('还没有可复制的助手回复。');
+        return;
+      }
+      const n = Math.max(1, parseInt(arg, 10) || 1);
+      const msg = replies[replies.length - n];
+      if (!msg) {
+        ctx.print(`只有 ${replies.length} 条助手回复。`);
+        return;
+      }
+      const r = await copyToClipboard(msg.content);
+      ctx.print(r.ok
+        ? `已复制${n > 1 ? `倒数第 ${n} 条` : '最后一条'}回复到剪贴板（${msg.content.length} 字）`
+        : `复制失败（未找到 ${r.tool}）。以下为该回复内容：\n\n${msg.content}`);
+    },
+  },
+  {
+    name: 'export', args: '[文件路径]', desc: '导出当前对话为 Markdown 文件',
+    run(ctx, arg) {
+      const md = toMarkdown(ctx.session);
+      const name = String(arg || '').trim()
+        || `huicai-对话-${new Date().toISOString().slice(0, 19).replace(/[:T]/g, '-')}.md`;
+      const abs = path.isAbsolute(name) ? name : path.join(ctx.cwd, name);
+      try {
+        fs.writeFileSync(abs, md, 'utf8');
+        ctx.print('已导出对话到 ' + abs);
+      } catch (e) {
+        ctx.print('导出失败：' + e.message);
+      }
+    },
+  },
+  {
+    name: 'rename', args: '<新标题>', desc: '重命名当前会话',
+    run(ctx, arg) {
+      const t = String(arg || '').trim();
+      if (!t) {
+        ctx.print('当前标题：' + (ctx.session.title || '(未命名)') + '\n  用法：/rename <新标题>');
+        return;
+      }
+      ctx.session.title = t.slice(0, 80);
+      try {
+        saveSession(ctx.session);
+      } catch { /* best-effort */ }
+      ctx.print('会话已重命名为：' + ctx.session.title);
+    },
+  },
+  {
+    name: 'recap', desc: '用一句话总结当前对话进展（直连原始模型，不写入对话）',
+    async run(ctx) {
+      if (!ctx.session.messages.some((m) => m.role !== 'system')) {
+        ctx.print('对话还没有内容。');
+        return;
+      }
+      try {
+        ctx.print('小结：' + await recapConversation(ctx.session.messages, ctx.config));
+      } catch (e) {
+        ctx.print('生成小结失败：' + e.message);
+      }
+    },
+  },
+  {
+    name: 'distill', desc: '从当前对话提炼项目知识，写入长期记忆（供后续会话自动加载）',
+    async run(ctx) {
+      if (ctx.config.memoryEnabled === false) {
+        ctx.print('长期记忆已关闭（config.memory=false）。');
+        return;
+      }
+      if (!ctx.session.messages.some((m) => m.role !== 'system')) {
+        ctx.print('对话还没有内容。');
+        return;
+      }
+      const { distillMemory } = await import('./transcript.js');
+      const { loadMemory, appendMemory } = await import('./memory.js');
+      try {
+        const facts = await distillMemory(ctx.session.messages, ctx.config, loadMemory(ctx.cwd));
+        if (!facts.length) {
+          ctx.print('未提炼出值得长期记住的新知识。');
+          return;
+        }
+        let n = 0;
+        for (const f of facts) if (appendMemory(ctx.cwd, f)) n++;
+        ctx.print(`已写入 ${n} 条项目知识到长期记忆：\n` + facts.map((f) => '  · ' + f).join('\n'));
+      } catch (e) {
+        ctx.print('提炼失败：' + e.message);
+      }
+    },
+  },
+  {
+    name: 'doctor', desc: '本机环境体检（登录/网络/模型/git/工作目录/钩子）',
+    async run(ctx) {
+      try {
+        ctx.print(await runDoctor(ctx));
+      } catch (e) {
+        ctx.print('体检失败：' + e.message);
+      }
+    },
+  },
+  {
+    name: 'config', desc: '查看配置文件路径与当前生效配置（密钥脱敏）',
+    run(ctx) {
+      const cfg = ctx.config;
+      const redact = (k) => (k ? k.slice(0, 4) + '…' + k.slice(-4) + `（${k.length}位）` : '(未设置)');
+      const ac = Number(cfg.autoCompactTokens);
+      ctx.print([
+        '配置',
+        '  文件      ' + CONFIG_PATH,
+        '  平台      ' + cfg.baseUrl,
+        '  密钥      ' + redact(cfg.apiKey),
+        '  模型      ' + cfg.model,
+        '  推理强度  ' + (cfg.reasoningEffort || 'off'),
+        '  自动压缩  ' + (ac < 0 ? '关闭' : ac > 0 ? ac.toLocaleString() + ' tokens' : '默认(80k)'),
+        '  记忆      ' + (cfg.memoryEnabled === false ? '关' : '开'),
+        '  Markdown  ' + (cfg.markdown === false ? '关' : '开'),
+        '  全局设置  ' + GLOBAL_SETTINGS_PATH,
+        '  项目设置  ' + projectSettingsPath(ctx.cwd),
+        '  （多数项有对应斜杠命令直接改：/model /effort /autocompact /permissions …）',
+      ].join('\n'));
+    },
+  },
+  {
+    name: 'effort', args: '[minimal|low|medium|high|off]', desc: '设置推理强度（reasoning_effort 透传；模型不支持则忽略）',
+    run(ctx, arg) {
+      const a = String(arg || '').trim().toLowerCase();
+      if (!a) {
+        ctx.print('当前推理强度：' + (ctx.config.reasoningEffort || 'off')
+          + '\n  用法：/effort minimal|low|medium|high|off');
+        return;
+      }
+      if (!['minimal', 'low', 'medium', 'high', 'off'].includes(a)) {
+        ctx.print('取值：minimal | low | medium | high | off');
+        return;
+      }
+      ctx.config.reasoningEffort = a === 'off' ? '' : a;
+      saveConfig({ reasoningEffort: ctx.config.reasoningEffort });
+      ctx.print('推理强度：' + (ctx.config.reasoningEffort || 'off') + '（下一条消息起生效；模型不支持则被忽略）');
+    },
+  },
+  {
+    name: 'autocompact', args: '[N|off|status]', desc: '自动压缩上下文的触发阈值（token 数；off 关闭）',
+    run(ctx, arg) {
+      const a = String(arg || '').trim().toLowerCase();
+      const ac = Number(ctx.config.autoCompactTokens) || 0;
+      if (!a || a === 'status') {
+        ctx.print('自动压缩：' + (ac < 0 ? '已关闭' : ac > 0 ? `阈值 ${ac.toLocaleString()} tokens` : '默认阈值 80,000 tokens')
+          + '\n  /autocompact <N> 设定 · /autocompact off 关闭 · /autocompact status 查看');
+        return;
+      }
+      if (a === 'off') {
+        ctx.config.autoCompactTokens = -1;
+        saveConfig({ autoCompactTokens: -1 });
+        ctx.print('已关闭自动压缩（仍可 /compact 手动压缩）。');
+        return;
+      }
+      const n = parseInt(a, 10);
+      if (!Number.isFinite(n) || n < 1000) {
+        ctx.print('请给 ≥1000 的 token 阈值，或 off / status。');
+        return;
+      }
+      ctx.config.autoCompactTokens = n;
+      saveConfig({ autoCompactTokens: n });
+      ctx.print('自动压缩阈值设为 ' + n.toLocaleString() + ' tokens（字符阈值同步联动）。');
+    },
+  },
+  {
+    name: 'review', desc: '审查当前未提交改动（找 bug 与可简化处）',
+    run() {
+      return { prompt: '请审查当前工作区的未提交改动：先用 run_bash 跑 `git diff`（及 `git status`）查看改了什么，'
+        + '聚焦正确性 bug、边界与错误处理、可复用/可简化处、安全隐患。若本地有 code-review 技能可 load_skill 参照其方法。'
+        + '逐条给出：问题、定位（文件:行）、修改建议，按严重度排序；不确定的地方说明。' };
+    },
+  },
+  {
+    name: 'security-review', desc: '对当前改动做安全审查',
+    run() {
+      return { prompt: '请对当前工作区改动做安全审查：注入（SQL/命令/路径穿越）、越权、密钥/凭据泄漏、SSRF、不安全依赖、'
+        + '反序列化、XSS 等。先 run_bash 跑 `git diff` 查看改动。若本地有 security-audit 技能可 load_skill 参照。'
+        + '给出风险点、可利用场景、影响与修复建议，按严重度排序。' };
+    },
+  },
+  {
+    name: 'scan', args: '[fix]', desc: '安全/质量扫描（自动选可用的 npm audit/semgrep/trivy/gitleaks 等）；fix=让智能体逐条修',
+    async run(ctx, arg) {
+      const { detectScanners, runScanners } = await import('./scan.js');
+      const scanners = detectScanners(ctx.cwd);
+      if (!scanners.length) {
+        ctx.print('未检测到可用扫描器。可安装 semgrep / trivy / gitleaks，或项目含 package.json（npm audit）等。');
+        return;
+      }
+      if (String(arg || '').trim().toLowerCase() === 'fix') {
+        return { prompt: '请对本项目做安全/质量扫描并修复：依次运行并理解这些扫描器的输出——'
+          + scanners.map((s) => '`' + s.command + '`（' + s.why + '）').join('、')
+          + '；对发现的问题逐个修复（升级/更换依赖、修代码、移除硬编码密钥等），修完重跑对应扫描确认清零；最后汇总修了什么。' };
+      }
+      ctx.print('运行扫描器：' + scanners.map((s) => s.name).join(', ') + '（可能较慢）…');
+      const results = await runScanners(ctx.cwd, scanners);
+      for (const r of results) {
+        ctx.print(`\n── ${r.name}（${r.code === 0 ? '✅ 无高危' : '⚠ 有发现'}）──`);
+        ctx.print(r.output.split('\n').slice(0, 20).join('\n'));
+      }
+      ctx.print('\n（/scan fix 让智能体逐条修复）');
+    },
+  },
+  {
+    name: 'cover', desc: '覆盖率驱动测试生成：跑覆盖率→定位未覆盖的改动→补测试→复测',
+    run() {
+      return { prompt: '请做覆盖率驱动的测试补全：'
+        + '\n1) 跑测试覆盖率（按项目选：npm test -- --coverage / jest --coverage / pytest --cov / go test -cover / mvn test 等）；'
+        + '\n2) 重点看**最近改动**且覆盖率低或未覆盖的函数与分支；'
+        + '\n3) 为这些薄弱处补写有意义的测试（覆盖正常/边界/错误路径），遵循项目既有测试风格与框架；'
+        + '\n4) 重跑测试与覆盖率，确认通过且覆盖率提升；最后汇报补了哪些测试、覆盖率变化。' };
+    },
+  },
+  {
+    name: 'verify', args: '[验证命令]', desc: '修到通过：跑测试/构建，失败自动定位修复并重跑，直到通过或达上限',
+    run(ctx, arg) {
+      let command = String(arg || '').trim();
+      if (!command) {
+        command = detectVerifyCommand(ctx.cwd) || '';
+        if (!command) {
+          ctx.print('未能自动探测验证命令。用法：/verify <命令>（如 /verify npm test）');
+          return;
+        }
+        ctx.print('自动探测到验证命令：' + command);
+      }
+      const maxIters = Math.min(10, Math.max(1, Number(ctx.config.verifyMaxIters) || 5));
+      return { action: 'autofix', command, maxIters };
+    },
+  },
+  {
+    name: 'simplify', desc: '审查改动的可复用/简化/抽象层级并直接清理（只清理不找 bug）',
+    run() {
+      return { prompt: '请只做质量清理（不找 bug）：审查最近改动的复用（是否重复造轮子、可否复用现有工具/函数）、简化（是否有更直接的写法）、'
+        + '效率、以及抽象层级是否合适；把确定的改进直接用 edit_file 应用，保持与项目既有风格一致，改后跑测试/构建自检。'
+        + '若本地有 refactor-safely 技能可 load_skill 参照。最后说明改了什么、为什么。' };
+    },
+  },
+  {
+    name: 'insights', desc: '本机会话使用洞察（数量/轮数/活跃度/按项目·模型分布）',
+    run(ctx) {
+      ctx.print(formatInsights(computeInsights(listSessions(null), { cwd: ctx.cwd })));
+    },
+  },
+  {
+    name: 'goal', args: '[目标 | clear]', desc: '设定目标（每轮注入，模型停止前自检是否达成；clear 清除）',
+    run(ctx, arg) {
+      const a = String(arg || '').trim();
+      if (!a) {
+        ctx.print(ctx.config.goal
+          ? '当前目标：' + ctx.config.goal + '\n  /goal <新目标> 修改 · /goal clear 清除'
+          : '未设定目标。用法：/goal <目标>（模型会在停止前自检是否达成）');
+        return;
+      }
+      if (a === 'clear') {
+        ctx.config.goal = '';
+        ctx.print('已清除目标。');
+        return;
+      }
+      ctx.config.goal = a;
+      ctx.print('已设定目标：' + a + '（每轮注入，模型将在停止前自检是否达成）');
+    },
+  },
+  {
+    name: 'btw', args: '<问题>', desc: '问一个旁支问题（带当前上下文，但不写入对话、不调用工具）',
+    async run(ctx, arg) {
+      const q = String(arg || '').trim();
+      if (!q) {
+        ctx.print('用法：/btw <问题>（快速旁支问答，不影响主对话）');
+        return;
+      }
+      const model = PLATFORM_MODEL_RE.test(String(ctx.config.model || ''))
+        ? (ctx.config.compactModel || DEFAULT_MODEL) : ctx.config.model;
+      try {
+        const view = buildModelMessages(ctx.session.messages, ctx.session.compaction || {});
+        const r = await streamChat({
+          baseUrl: ctx.config.baseUrl,
+          apiKey: ctx.config.apiKey,
+          model,
+          messages: [...view, { role: 'user', content: '（这是一个旁支问题，请结合上文直接简答，不要调用工具、不要展开无关内容）\n' + q }],
+        });
+        ctx.print('↪ ' + ((r.content || '(无回复)').trim()));
+      } catch (e) {
+        ctx.print('旁支问答失败：' + e.message);
+      }
+    },
+  },
+  {
+    name: 'ide', desc: '查看 IDE 集成状态（编辑器上下文与内联审阅）',
+    run(ctx) {
+      const active = !!process.env.HUICAI_IDE_PORT;
+      const file = process.env.HUICAI_IDE_FILE;
+      const sel = process.env.HUICAI_IDE_SELECTION;
+      const diag = process.env.HUICAI_IDE_DIAGNOSTICS;
+      const lines = ['IDE 集成'];
+      lines.push('  内联审阅  ' + (active ? '已连接（write/edit 交编辑器做 diff 审阅）' : '未连接（CLI 直接写盘）'));
+      lines.push('  客户端    ' + (ctx.config.client || 'cli'));
+      lines.push('  当前文件  ' + (file || '(无)'));
+      lines.push('  选区      ' + (sel ? sel.length + ' 字' : '(无)'));
+      lines.push('  诊断      ' + (diag ? '有（来自 Problems 面板）' : '(无)'));
+      if (!active) lines.push('  （在 VS Code/IDEA 的 huicai 面板或其启动的终端里运行可启用内联审阅与编辑器上下文）');
+      ctx.print(lines.join('\n'));
+    },
+  },
+  {
+    name: 'branch', args: '[标题]', desc: '把当前对话另存为一个可 --resume 的分支副本（当前会话继续）',
+    run(ctx, arg) {
+      const src = ctx.session;
+      if (!src.messages.some((m) => m.role !== 'system')) {
+        ctx.print('当前对话为空，无需分支。');
+        return;
+      }
+      const copy = createSession({ cwd: ctx.cwd, model: src.model, messages: src.messages.map((m) => ({ ...m })) });
+      try {
+        copy.compaction = JSON.parse(JSON.stringify(src.compaction || {}));
+      } catch {
+        copy.compaction = {};
+      }
+      copy.title = ((String(arg || '').trim() || src.title || '对话').slice(0, 70)) + '（分支）';
+      copy.lastPromptTokens = src.lastPromptTokens || 0;
+      try {
+        saveSession(copy);
+        saveSession(src);
+      } catch { /* best-effort */ }
+      ctx.print(`已保存分支副本「${copy.title}」（${copy.id}）。\n  当前会话继续；分支可用 huicai --resume 恢复到此刻状态。`);
+    },
+  },
+  {
+    name: 'theme', args: '[default|mono]', desc: '输出主题：default 彩色 / mono 无色',
+    run(ctx, arg) {
+      const a = String(arg || '').trim().toLowerCase();
+      if (!a) {
+        ctx.print('当前主题：' + (ctx.config.theme || 'default')
+          + '\n  /theme default | mono（终端配色由终端掌控；mono=关闭颜色，便于复制/管道）');
+        return;
+      }
+      if (!['default', 'mono'].includes(a)) {
+        ctx.print('取值：default | mono');
+        return;
+      }
+      ctx.config.theme = a;
+      setColorMode(a);
+      saveConfig({ theme: a });
+      ctx.print('主题：' + a + (a === 'mono' ? '（已关闭颜色）' : '（彩色）'));
+    },
+  },
+  {
+    name: 'color', args: '[' + ACCENTS.join('|') + ']', desc: '设置强调色（提示符/高亮）',
+    run(ctx, arg) {
+      const a = String(arg || '').trim().toLowerCase();
+      if (!a) {
+        ctx.print('当前强调色：' + getAccent() + '\n  可选：' + ACCENTS.join(' / '));
+        return;
+      }
+      if (!setAccent(a)) {
+        ctx.print('可选：' + ACCENTS.join(' / '));
+        return;
+      }
+      ctx.config.accentColor = a;
+      saveConfig({ accentColor: a });
+      ctx.print('强调色：' + a);
+    },
+  },
+  {
+    name: 'tui', args: '[auto|rich|plain]', desc: '交互渲染器偏好（下次启动生效）',
+    run(ctx, arg) {
+      const a = String(arg || '').trim().toLowerCase();
+      if (!a) {
+        ctx.print('当前渲染器偏好：' + (ctx.config.tui || 'auto')
+          + '\n  auto（TTY 下富 TUI）| rich | plain（下次启动生效；本次可加 --tui/--plain 覆盖）');
+        return;
+      }
+      if (!['auto', 'rich', 'plain'].includes(a)) {
+        ctx.print('取值：auto | rich | plain');
+        return;
+      }
+      ctx.config.tui = a;
+      saveConfig({ tui: a });
+      ctx.print('渲染器偏好：' + a + '（下次启动生效）');
+    },
+  },
+  {
+    name: 'advisor', args: '[模型id|off]', desc: '设置顾问模型（更强模型）：智能体遇难题可 ask_advisor 咨询第二意见',
+    async run(ctx, arg) {
+      const a = String(arg || '').trim();
+      if (!a) {
+        ctx.print(ctx.config.advisorModel
+          ? '当前顾问模型：' + ctx.config.advisorModel + '（智能体可用 ask_advisor 咨询）'
+          : '未设置顾问模型。用法：/advisor <模型id>（设一个更强的模型；/models 看可用）· /advisor off 关闭');
+        return;
+      }
+      const v = a === 'off' ? '' : a;
+      ctx.config.advisorModel = v;
+      saveConfig({ advisorModel: v });
+      // 即时生效：重建 ask_advisor 工具进 extraTools（无需重开会话）
+      if (Array.isArray(ctx.extraTools)) {
+        const i = ctx.extraTools.findIndex((t) => t.spec?.function?.name === 'ask_advisor');
+        if (i >= 0) ctx.extraTools.splice(i, 1);
+        if (v) {
+          const { makeAdvisorTool } = await import('./advisor.js');
+          const t = makeAdvisorTool({ config: ctx.config });
+          if (t) ctx.extraTools.push(t);
+        }
+      }
+      ctx.print(v ? '顾问模型已设为 ' + v + '（ask_advisor 工具已可用）' : '已关闭顾问模型。');
+    },
+  },
+  {
+    name: 'automodel', args: '[强模型id|off]', desc: '按任务自动选模型：复杂回合自动升配到该强模型，其余用当前模型',
+    run(ctx, arg) {
+      const a = String(arg || '').trim();
+      if (!a) {
+        ctx.print(ctx.config.autoModelStrong
+          ? '自动升配：开（复杂回合→' + ctx.config.autoModelStrong + '，其余→' + ctx.config.model + '）'
+          : '未开启。用法：/automodel <强模型id>（复杂回合自动用它；简单回合仍用当前便宜模型）· /models 看可用');
+        return;
+      }
+      const v = a.toLowerCase() === 'off' ? '' : a;
+      ctx.config.autoModelStrong = v;
+      saveConfig({ autoModelStrong: v });
+      ctx.print(v ? '按任务自动选模型：开（复杂回合→' + v + '，其余→' + ctx.config.model + '）' : '已关闭自动升配。');
+    },
+  },
+  {
+    name: 'embed', args: '[嵌入模型id|off]', desc: 'search_code 向量语义重排：设一个嵌入模型走 /v1/embeddings 重排（空/off=纯 BM25）',
+    run(ctx, arg) {
+      const a = String(arg || '').trim();
+      if (!a) {
+        ctx.print(ctx.config.embeddingModel
+          ? 'search_code 向量重排：开（嵌入模型 ' + ctx.config.embeddingModel + '）'
+          : '未启用向量重排（纯 BM25，离线可用）。用法：/embed <嵌入模型id>（需平台有该嵌入模型）· /embed off');
+        return;
+      }
+      const v = a.toLowerCase() === 'off' ? '' : a;
+      ctx.config.embeddingModel = v;
+      saveConfig({ embeddingModel: v });
+      ctx.print(v
+        ? 'search_code 向量语义重排：开（嵌入模型 ' + v + '；下次检索生效，BM25 召回后按向量相似度重排）'
+        : '已关闭向量重排（回到纯 BM25）。');
+    },
+  },
+  {
+    name: 'budget', args: '[token数|off|status]', desc: '设置本项目 token 预算（软提醒；/cost 看进度）',
+    run(ctx, arg) {
+      const a = String(arg || '').trim().toLowerCase();
+      const used = (ctx.usage?.prompt || 0) + (ctx.usage?.completion || 0);
+      if (!a || a === 'status') {
+        const b = Number(ctx.config.budgetTokens) || 0;
+        ctx.print(b > 0
+          ? `token 预算：${used.toLocaleString()} / ${b.toLocaleString()}（${Math.round((used / b) * 100)}%）`
+          : `未设预算（本次已用 ${used.toLocaleString()} tokens）。/budget <token数> 设定`);
+        return;
+      }
+      if (a === 'off') {
+        ctx.config.budgetTokens = 0;
+        saveConfig({ budgetTokens: 0 });
+        ctx.print('已取消预算。');
+        return;
+      }
+      const n = parseInt(a, 10);
+      if (!Number.isFinite(n) || n < 1000) {
+        ctx.print('请给 ≥1000 的 token 数，或 off / status。');
+        return;
+      }
+      ctx.config.budgetTokens = n;
+      saveConfig({ budgetTokens: n });
+      ctx.print('token 预算设为 ' + n.toLocaleString() + '（软提醒；/cost 显示进度）。');
+    },
+  },
+  {
+    name: 'debug', args: '[on|off]', desc: '调试输出（每轮打印模型/耗时/token）',
+    run(ctx, arg) {
+      const a = String(arg || '').trim().toLowerCase();
+      const next = a === 'on' ? true : a === 'off' ? false : !ctx.config.debug;
+      ctx.config.debug = next;
+      saveConfig({ debug: next });
+      ctx.print('调试输出：' + (next ? '开（下一条消息起每轮打印 [debug] 行）' : '关'));
+    },
+  },
+  {
+    name: 'sandbox', args: '[on|off]', desc: '沙箱模式：禁 shell 与联网（仍可读写本地文件）',
+    run(ctx, arg) {
+      const a = String(arg || '').trim().toLowerCase();
+      const next = a === 'on' ? true : a === 'off' ? false : !ctx.config.sandbox;
+      ctx.config.sandbox = next;
+      ctx.permissions?.setSandbox?.(next);
+      ctx.print(next
+        ? '沙箱模式：开。run_bash 与 fetch_url 将被拒绝；本地文件读写照常。'
+        : '沙箱模式：关（写/执行仍按权限审批）。');
+    },
+  },
+  {
+    name: 'reload-skills', desc: '从磁盘重新加载技能（新增/改名技能生效；改正文已实时生效）',
+    async run(ctx) {
+      const { makeSkillTools, loadLocalSkills } = await import('./skills.js');
+      if (Array.isArray(ctx.extraTools)) {
+        for (let i = ctx.extraTools.length - 1; i >= 0; i--) {
+          const n = ctx.extraTools[i]?.spec?.function?.name;
+          if (n === 'load_skill' || n === 'read_skill_file') ctx.extraTools.splice(i, 1);
+        }
+        ctx.extraTools.push(...makeSkillTools(ctx.cwd));
+      }
+      const skills = loadLocalSkills(ctx.cwd);
+      ctx.print(skills.length
+        ? `已重载 ${skills.length} 个技能：${skills.map((s) => s.name).join(', ')}`
+          + '\n  （load_skill 现可载入其中任意一个；系统提示词内的技能目录将在下次新会话刷新）'
+        : '未发现本地技能（.huicai/skills 或 ~/.huicai/skills）。');
+    },
+  },
+  {
+    name: 'add-dir', args: '[目录 | list | remove <目录>]', desc: '添加可读/搜索的附加目录（写入仍限主目录）',
+    run(ctx, arg) {
+      const s = ctx.session;
+      if (!Array.isArray(s.extraDirs)) s.extraDirs = [];
+      const parts = String(arg || '').trim().split(/\s+/).filter(Boolean);
+      const sub = (parts[0] || '').toLowerCase();
+      if (!arg || sub === 'list') {
+        ctx.print(s.extraDirs.length
+          ? '附加目录：\n' + s.extraDirs.map((d) => '  ' + d).join('\n')
+            + '\n  /add-dir <目录> 添加 · /add-dir remove <目录> 移除'
+          : '暂无附加目录。用法：/add-dir <目录>（可读/搜索，写仍限主目录）');
+        return;
+      }
+      if (sub === 'remove' || sub === 'rm') {
+        const d = path.resolve(ctx.cwd, parts.slice(1).join(' '));
+        const before = s.extraDirs.length;
+        s.extraDirs = s.extraDirs.filter((x) => x !== d);
+        applyExtraDirs(s);
+        try { saveSession(s); } catch { /* best-effort */ }
+        ctx.print(s.extraDirs.length < before ? '已移除：' + d : '未找到该附加目录：' + d);
+        return;
+      }
+      const d = path.resolve(ctx.cwd, String(arg).trim());
+      let ok = false;
+      try { ok = fs.statSync(d).isDirectory(); } catch { /* not a dir */ }
+      if (!ok) {
+        ctx.print('目录不存在：' + d);
+        return;
+      }
+      if (d === ctx.cwd) {
+        ctx.print('这已是主工作目录。');
+        return;
+      }
+      if (!s.extraDirs.includes(d)) s.extraDirs.push(d);
+      applyExtraDirs(s);
+      try { saveSession(s); } catch { /* best-effort */ }
+      ctx.print('已添加可访问目录：' + d
+        + '\n  （模型可用 read_file/list_files/grep 以绝对路径访问；写入仍限主目录）');
+    },
+  },
+  {
+    name: 'agents', desc: '列出可用子智能体人格（.huicai/agents/*.md；dispatch_agent 可指定）',
+    async run(ctx) {
+      const { loadAgents } = await import('./subagent.js');
+      const agents = loadAgents(ctx.cwd);
+      ctx.print(agents.length
+        ? '子智能体人格（dispatch_agent 的 agent 参数可指定）：\n'
+          + agents.map((a) => `  ${a.name}${a.description ? ' — ' + a.description.replace(/\s+/g, ' ').slice(0, 60) : ''}`).join('\n')
+        : '未定义子智能体人格。\n  在 .huicai/agents/<名字>.md 写 frontmatter(name/description)+正文(人格提示词)即可；\n'
+          + '  dispatch_agent 默认用通用只读子智能体（无需定义也能用）。');
+    },
+  },
+  {
+    name: 'orchestrate', args: '<目标>', desc: '把一个目标自动分解为并行子任务、多智能体协作完成',
+    run(ctx, arg) {
+      const goal = String(arg || '').trim();
+      if (!goal) {
+        ctx.print('用法：/orchestrate <较大的目标>（我会分解为并行子任务，用 dispatch_agents 并行推进后综合）');
+        return;
+      }
+      return { prompt: `目标：${goal}\n\n请作为编排者按以下方式完成：`
+        + '\n1) 先把目标分解为若干**独立、可并行**的子任务（研究/检索/分析/定位）；'
+        + '\n2) 用 dispatch_agents 一次性并行委派这些子任务（每个自足，可指定合适的子智能体人格）；'
+        + '\n3) 汇总各子智能体的结论，形成整体方案或结果；'
+        + '\n4) 若需落地改动，再据此逐步执行并自检（可用 /verify 让我自动跑验证）。'
+        + '\n优先用 dispatch_agents 并行，减少串行等待。' };
+    },
+  },
+  {
+    name: 'batch', args: '<大改动目标>', desc: '把一个大改动拆成独立子任务，在隔离 git worktree 中并行推进',
+    run(ctx, arg) {
+      const goal = String(arg || '').trim();
+      if (!goal) {
+        ctx.print('用法：/batch <一个可拆分的大改动目标>（拆成互不冲突的子任务，各在隔离 worktree 中落地）');
+        return;
+      }
+      return { prompt: `目标（需拆分并行落地）：${goal}\n\n请这样做：`
+        + '\n1) 先把目标拆成若干**相互独立、可并行**的改动子任务（尽量互不冲突的文件/模块）；'
+        + '\n2) 对每个子任务，用 `git worktree add -b huicai-batch/<名> <路径>` 建隔离工作区，在其中完成该子任务的改动并 commit（不影响主工作区）；'
+        + '\n3) 全部完成后，汇总每个 worktree 的分支与改动；需要时可对每个分支执行 `huicai pr` 开 PR。'
+        + '\n（并行调研可用 dispatch_agents；改动务必隔离在各自 worktree，避免互相踩踏。完成后可 `git worktree remove` 清理。）' };
+    },
+  },
+  {
+    name: 'fork', args: '<后台任务提示词>', desc: '派生后台智能体（继承当前对话副本，--yolo 自动放行，输出写日志）',
+    async run(ctx, arg) {
+      const prompt = String(arg || '').trim();
+      if (!prompt) {
+        ctx.print('用法：/fork <让后台智能体做什么>（以当前对话副本为上下文，后台运行，--yolo 自动放行）');
+        return;
+      }
+      // 先另存对话副本，避免后台进程与前台写同一会话文件
+      const copy = createSession({ cwd: ctx.cwd, model: ctx.session.model, messages: ctx.session.messages.map((m) => ({ ...m })) });
+      try { copy.compaction = JSON.parse(JSON.stringify(ctx.session.compaction || {})); } catch { copy.compaction = {}; }
+      copy.title = '(fork) ' + (ctx.session.title || '');
+      try { saveSession(copy); } catch { /* best-effort */ }
+      const { forkAgent } = await import('./forks.js');
+      let rec;
+      try {
+        rec = forkAgent({ prompt, cwd: ctx.cwd, sessionId: copy.id });
+      } catch (e) {
+        ctx.print('无法派生后台任务：' + e.message);
+        return;
+      }
+      ctx.print(`已派生后台智能体 pid ${rec.pid}（--yolo 自动放行）`
+        + `\n  上下文：当前对话副本 ${copy.id}\n  日志：${rec.log}\n  /tasks 查看 · /tasks kill ${rec.pid} 终止`);
+    },
+  },
+  {
+    name: 'tasks', args: '[kill <pid>]', desc: '查看/终止本会话派生的后台任务（/fork）',
+    async run(ctx, arg) {
+      const { listForks, killFork } = await import('./forks.js');
+      const parts = String(arg || '').trim().split(/\s+/).filter(Boolean);
+      if (parts[0] === 'kill') {
+        const pid = Number(parts[1]);
+        if (!Number.isFinite(pid)) {
+          ctx.print('用法：/tasks kill <pid>');
+          return;
+        }
+        const r = killFork(pid);
+        ctx.print(r.ok ? '已终止 pid ' + pid : '终止失败：' + (r.reason || ''));
+        return;
+      }
+      const list = listForks();
+      if (!list.length) {
+        ctx.print('本会话暂无后台任务（/fork <提示词> 派生）。');
+        return;
+      }
+      ctx.print('后台任务：\n' + list.map((f) =>
+        `  pid ${f.pid} · ${f.alive ? '运行中' : '已结束'} · ${relTime(f.started)} · ${f.prompt}\n     日志 ${f.log}`,
+      ).join('\n') + '\n  /tasks kill <pid> 终止');
+    },
+  },
+  {
+    name: 'schedule', args: '[list | add "<cron>" "<提示词>" | remove <id>]', desc: '管理定时任务（生成 crontab 行交系统 cron 运行）',
+    async run(ctx, arg) {
+      const s = await import('./schedule.js');
+      const raw = String(arg || '').trim();
+      const bin = 'huicai';
+      if (!raw || raw === 'list') {
+        const list = s.listTasks();
+        if (!list.length) {
+          ctx.print('暂无定时任务。\n  添加：/schedule add "*/30 * * * *" "跑测试并把结果写入 report.md"'
+            + '\n  （随后把打印的 crontab 行加入 crontab -e）');
+          return;
+        }
+        ctx.print('定时任务：\n' + list.map((t) =>
+          `  #${t.id}  ${t.cron}  ${t.prompt.replace(/\s+/g, ' ').slice(0, 40)}\n     crontab: ${s.crontabLine(t, bin)}`,
+        ).join('\n') + '\n  /schedule remove <id> 删除');
+        return;
+      }
+      if (/^add\b/.test(raw)) {
+        const quoted = raw.match(/"([^"]*)"/g);
+        if (!quoted || quoted.length < 2) {
+          ctx.print('用法：/schedule add "<cron>" "<提示词>"（cron 与提示词都要加引号）');
+          return;
+        }
+        const cron = quoted[0].slice(1, -1).trim();
+        const prompt = quoted[1].slice(1, -1).trim();
+        if (cron.split(/\s+/).length !== 5) {
+          ctx.print('cron 需 5 个字段，如 "*/30 * * * *"（分 时 日 月 周）');
+          return;
+        }
+        const { id } = s.addTask({ cron, prompt, cwd: ctx.cwd });
+        ctx.print('已添加定时任务 #' + id + '\n  加入 crontab（crontab -e）：\n  ' + s.crontabLine({ id, cron, prompt, cwd: ctx.cwd }, bin));
+        return;
+      }
+      if (/^(remove|rm)\b/.test(raw)) {
+        const id = raw.split(/\s+/)[1];
+        ctx.print(s.removeTask(id) ? '已删除定时任务 ' + id : '未找到定时任务 ' + id);
+        return;
+      }
+      ctx.print('用法：/schedule list · /schedule add "<cron>" "<提示词>" · /schedule remove <id>');
+    },
+  },
+  {
+    name: 'cd', args: '<目录>', desc: '切换工作目录（在新目录开启新会话；IDE 中请用「打开文件夹」）',
+    run(ctx, arg) {
+      const d = String(arg || '').trim();
+      if (!d) {
+        ctx.print('当前工作目录：' + ctx.cwd + '\n  用法：/cd <目录>（将在新目录开启新会话，旧会话已保存）');
+        return;
+      }
+      const abs = path.resolve(ctx.cwd, d);
+      let ok = false;
+      try { ok = fs.statSync(abs).isDirectory(); } catch { /* not a dir */ }
+      if (!ok) {
+        ctx.print('目录不存在：' + abs);
+        return;
+      }
+      if (abs === ctx.cwd) {
+        ctx.print('已在该目录。');
+        return;
+      }
+      return { action: 'cd', cwd: abs };
+    },
+  },
+  {
+    name: 'loop', args: '<秒> <提示词> | off', desc: '每隔 N 秒自动重跑一个提示词（off 停止）',
+    run(ctx, arg) {
+      const raw = String(arg || '').trim();
+      if (!raw) {
+        ctx.print('用法：/loop <秒> <提示词>（如 /loop 300 检查构建是否通过）· /loop off 停止');
+        return;
+      }
+      if (raw === 'off') return { action: 'loop', stop: true };
+      const m = /^(\d+)\s+([\s\S]+)$/.exec(raw);
+      if (!m) {
+        ctx.print('用法：/loop <秒> <提示词> · /loop off');
+        return;
+      }
+      return { action: 'loop', seconds: Math.max(10, parseInt(m[1], 10)), prompt: m[2].trim() };
+    },
+  },
+  {
+    name: 'statusline', args: '<shell命令> | off', desc: '自定义 TUI 底栏（运行该命令，展示其 stdout）',
+    run(ctx, arg) {
+      const raw = String(arg || '').trim();
+      if (!raw) {
+        ctx.print('当前状态栏命令：' + (ctx.config.statusLine || '(默认)')
+          + '\n  /statusline <shell命令>（stdout 显示在 TUI 底栏）· /statusline off 恢复默认');
+        return;
+      }
+      const v = raw === 'off' ? '' : raw;
+      ctx.config.statusLine = v;
+      saveConfig({ statusLine: v });
+      ctx.print(v ? '状态栏命令已设置（TUI 底栏生效）：' + v : '已恢复默认状态栏。');
+    },
+  },
+  {
+    name: 'background', desc: '保存当前会话并给出在别处继续/后台运行的方式',
+    run(ctx) {
+      try { saveSession(ctx.session); } catch { /* best-effort */ }
+      ctx.print(`会话已保存（${ctx.session.id}）。`
+        + `\n  · 在别处继续：huicai resume ${ctx.session.id}`
+        + '\n  · 后台跑一个任务：/fork <提示词>（派生后台智能体，日志可查）'
+        + '\n  · 定时运行：/schedule add "<cron>" "<提示词>"');
+    },
+  },
   {
     name: 'exit', desc: '退出',
     run() {