@huicai/cli 2026.710.97949 → 2026.711.0

package/src/compaction.js

@@ -48,13 +48,17 @@ export function buildModelMessages(messages, state) {
  */
 export async function compactIfNeeded(messages, config, opts = {}) {
   const state = opts.state || {};
-  const threshold = opts.thresholdChars || DEFAULT_THRESHOLD_CHARS;
   const keep = opts.keepRecent || KEEP_RECENT_USER_TURNS;
   if (!messages || messages.length < 6) return 0;
 
+  // /autocompact 配置：负数=关闭自动压缩（仍可手动 force）；正数=自定义 token 阈值（并按 ~3 字符/token 联动字符阈值）
+  const configuredTokens = Number(config?.autoCompactTokens);
+  if (!opts.force && Number.isFinite(configuredTokens) && configuredTokens < 0) return 0;
+  const tokenLimit = configuredTokens > 0 ? configuredTokens : DEFAULT_AUTOCOMPACT_TOKENS;
+  const threshold = opts.thresholdChars || (configuredTokens > 0 ? configuredTokens * 3 : DEFAULT_THRESHOLD_CHARS);
+
   const effective = buildModelMessages(messages, state);
   if (!opts.force) {
-    const tokenLimit = Number(config?.autoCompactTokens) || DEFAULT_AUTOCOMPACT_TOKENS;
     const overTokens = Number(opts.lastPromptTokens) > tokenLimit;
     const overChars = totalChars(effective) > threshold;
     if (!overTokens && !overChars) return 0;

package/src/config.js

@@ -35,8 +35,10 @@ export function loadConfig() {
     model: (process.env.HUICAI_MODEL || file.model || DEFAULT_MODEL).trim(),
     // 单回合最大工具轮数（0/缺省 = 用内置默认 60）；可被 --max-turns 覆盖
     maxTurns: Number(process.env.HUICAI_MAX_TURNS || file.maxTurns) || 0,
-    // 自动压缩触发的 prompt_tokens 上限（缺省用 compaction 内置默认 80000）
+    // 自动压缩触发的 prompt_tokens 上限（0=用 compaction 内置默认 80000；负=/autocompact off 关闭）
     autoCompactTokens: Number(file.autoCompactTokens) || 0,
+    // 推理强度（reasoning_effort）：minimal|low|medium|high；空串=不透传（由模型默认）。模型不支持则被忽略。
+    reasoningEffort: (process.env.HUICAI_EFFORT || file.reasoningEffort || '').trim(),
     // 压缩摘要专用模型（缺省：当前模型；当前为伪模型时 compaction 内部回退 DEFAULT_MODEL——摘要绝不经智能体编排）
     compactModel: (process.env.HUICAI_COMPACT_MODEL || file.compactModel || '').trim(),
     // 长期记忆（memory_write + 系统提示词注入）：默认开；配置 memory:false 或 HUICAI_MEMORY=0 关闭
@@ -47,6 +49,24 @@ export function loadConfig() {
     markdown: process.env.HUICAI_MARKDOWN === '0' ? false : file.markdown !== false,
     // 客户端来源标识（对话落库审计用）：默认 cli；VSCode 扩展进程内置 HUICAI_CLIENT=vscode
     client: (process.env.HUICAI_CLIENT || 'cli').trim().toLowerCase(),
+    // 输出主题：default（彩色）| mono（无色）。终端自身掌控具体配色，这里主要控制开关。
+    theme: (process.env.HUICAI_THEME || file.theme || 'default').trim(),
+    // 强调色（提示符/高亮）：cyan|green|magenta|blue|yellow|red
+    accentColor: (file.accentColor || 'cyan').trim(),
+    // 交互渲染器偏好（下次启动生效）：auto（TTY 下富 TUI）| rich | plain
+    tui: (process.env.HUICAI_TUI || file.tui || 'auto').trim(),
+    // 调试输出：每轮打印模型/耗时/token 等（默认关）
+    debug: process.env.HUICAI_DEBUG === '1' ? true : file.debug === true,
+    // 自定义状态栏命令（TUI 底栏展示其 stdout；空=用默认）
+    statusLine: (file.statusLine || '').trim(),
+    // 顾问模型（更强的模型）：设置后暴露 ask_advisor 工具，供智能体遇难题时咨询第二意见
+    advisorModel: (process.env.HUICAI_ADVISOR || file.advisorModel || '').trim(),
+    // 按任务自动选模型：设一个更强模型 → 复杂回合（长提示/难点关键词/计划模式）自动用它，其余用当前（便宜）模型
+    autoModelStrong: (process.env.HUICAI_AUTOMODEL || file.autoModelStrong || '').trim(),
+    // 本项目 token 预算（软提醒；0=不限）
+    budgetTokens: Number(file.budgetTokens) || 0,
+    // 语义检索用嵌入模型：设置后 search_code 在 BM25 召回上做向量重排（真语义）；空=纯 BM25
+    embeddingModel: (process.env.HUICAI_EMBED_MODEL || file.embeddingModel || '').trim(),
   };
   cfg.baseUrl = cfg.baseUrl.replace(/\/+$/, ''); // 去尾斜杠
   return cfg;

package/src/context-report.js

@@ -0,0 +1,119 @@
+// /context 上下文占用可视化：按类别估算「当前发给模型的视图」各占多少 token，并画条形图。
+// 用 buildModelMessages 取真实模型视图（含非破坏式压缩摘要），故与实际发送口径一致。
+// token 为估算（CJK≈1.6/字，其余≈1/4 字符）；若有上一轮实测 prompt_tokens，则整体按实测缩放校准。
+
+import { buildModelMessages } from './compaction.js';
+import { c } from './colors.js';
+
+const CJK_RE = /[぀-ヿ㐀-鿿가-힯豈-﫿＀-￯]/g;
+
+/** 估算文本 token 数（中英混排启发式）。 */
+export function estimateTokens(text) {
+  if (!text) return 0;
+  const s = String(text);
+  const cjk = (s.match(CJK_RE) || []).length;
+  const other = s.length - cjk;
+  return Math.ceil(cjk * 1.6 + other / 4);
+}
+
+function msgChars(m) {
+  let n = 0;
+  if (typeof m.content === 'string') n += m.content.length;
+  else if (Array.isArray(m.content)) {
+    for (const part of m.content) {
+      if (part?.type === 'text' && part.text) n += part.text.length;
+      else if (part?.type === 'image_url') n += 800; // 多模态图片按占位近似
+    }
+  }
+  return n;
+}
+function tokOf(m) {
+  if (typeof m.content === 'string') return estimateTokens(m.content);
+  if (Array.isArray(m.content)) {
+    let t = 0;
+    for (const part of m.content) {
+      if (part?.type === 'text' && part.text) t += estimateTokens(part.text);
+      else if (part?.type === 'image_url') t += 300;
+    }
+    return t;
+  }
+  return 0;
+}
+
+function fmtTok(n) {
+  n = Math.round(Number(n) || 0);
+  return n >= 1000 ? (n / 1000).toFixed(1) + 'k' : String(n);
+}
+
+function bar(pct, width = 14) {
+  const filled = Math.max(0, Math.min(width, Math.round(pct * width)));
+  return '█'.repeat(filled) + '░'.repeat(width - filled);
+}
+
+/**
+ * 生成上下文占用报告文本。
+ * @param {object} p
+ * @param {any[]} p.messages 完整会话消息（含 system）
+ * @param {object} [p.compaction] 压缩状态 {upTo,summary}
+ * @param {object[]} [p.specs] 本回合会随请求发送的工具规格（估其常驻开销）
+ * @param {number} [p.lastPromptTokens] 上一轮实测 prompt_tokens（用于校准）
+ * @param {number} [p.autoCompactTokens] 自动压缩触发阈值
+ * @param {boolean} [p.platform] 平台伪模型（无本机工具/无压缩），仅粗统计
+ */
+export function contextReport({ messages, compaction, specs, lastPromptTokens, autoCompactTokens, platform }) {
+  const view = platform ? messages : buildModelMessages(messages, compaction || {});
+  const hasSummary = !!(compaction && compaction.summary && compaction.upTo > 1);
+
+  const buckets = {
+    system: { label: '系统提示词', tok: 0 },
+    tools: { label: '工具定义', tok: 0 },
+    summary: { label: '压缩摘要', tok: 0 },
+    user: { label: '用户消息', tok: 0 },
+    assistant: { label: '助手回复', tok: 0 },
+    toolcall: { label: '工具调用', tok: 0 },
+    toolresult: { label: '工具结果', tok: 0 },
+  };
+
+  view.forEach((m, i) => {
+    if (i === 0 && m.role === 'system') { buckets.system.tok += tokOf(m); return; }
+    if (i === 1 && hasSummary && m.role === 'user') { buckets.summary.tok += tokOf(m); return; }
+    if (m.role === 'user') buckets.user.tok += tokOf(m);
+    else if (m.role === 'assistant') {
+      buckets.assistant.tok += tokOf(m);
+      if (m.tool_calls) buckets.toolcall.tok += estimateTokens(JSON.stringify(m.tool_calls));
+    } else if (m.role === 'tool') buckets.toolresult.tok += tokOf(m);
+  });
+
+  if (specs && specs.length) buckets.tools.tok = estimateTokens(JSON.stringify(specs));
+
+  const order = ['system', 'tools', 'summary', 'user', 'assistant', 'toolcall', 'toolresult'];
+  let total = order.reduce((s, k) => s + buckets[k].tok, 0);
+
+  // 有实测值则整体缩放校准（让分类合计对齐真实 prompt_tokens）
+  let scale = 1;
+  if (lastPromptTokens > 0 && total > 0) scale = lastPromptTokens / total;
+  const scaled = (k) => buckets[k].tok * scale;
+  const scaledTotal = lastPromptTokens > 0 ? lastPromptTokens : total;
+
+  const lines = [];
+  lines.push(c.bold('上下文占用') + c.gray('（当前发给模型的视图 · 估算）'));
+  for (const k of order) {
+    const t = scaled(k);
+    if (t < 1 && buckets[k].tok === 0) continue;
+    const pct = scaledTotal > 0 ? t / scaledTotal : 0;
+    lines.push('  ' + buckets[k].label.padEnd(6, '　')
+      + ' ' + ('~' + fmtTok(t)).padStart(7)
+      + '  ' + c.cyan(bar(pct)) + ' ' + String(Math.round(pct * 100)).padStart(3) + '%');
+  }
+  lines.push(c.gray('  ' + '─'.repeat(34)));
+
+  const thr = Number(autoCompactTokens) || 80000;
+  const towardPct = Math.min(100, Math.round((scaledTotal / thr) * 100));
+  lines.push('  合计　　 ' + ('~' + fmtTok(scaledTotal)).padStart(7)
+    + c.gray(`   自动压缩阈值 ${fmtTok(thr)}（${towardPct}%）`));
+  if (lastPromptTokens > 0) lines.push(c.gray(`  实测上一轮 prompt_tokens：${fmtTok(lastPromptTokens)}（分类按此校准）`));
+  else lines.push(c.gray('  （尚无实测值，纯估算；发生一轮对话后更准）'));
+  if (hasSummary) lines.push(c.gray('  已启用上下文压缩：更早的历史以摘要形式计入，原文完整保留。'));
+  lines.push(c.gray('  /compact 立即压缩 · /context 再次查看'));
+  return lines.join('\n');
+}

package/src/context.js

@@ -7,6 +7,7 @@ import os from 'node:os';
 import { execSync } from 'node:child_process';
 import { loadMemory } from './memory.js';
 import { skillCatalog } from './skills.js';
+import { buildRepoMap } from './codeindex.js';
 
 function git(cwd) {
   const run = (cmd) => execSync(cmd, { cwd, stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
@@ -110,6 +111,13 @@ export function buildSystemPrompt(cwd, opts = {}) {
   if (editor) p += '\n# 编辑器上下文（来自 IDE 集成）\n' + editor;
   if (gdoc) p += `\n# 全局用户说明（~/.huicai/HUICAI.md）\n${gdoc}\n`;
   if (doc) p += `\n# 项目说明（${doc.name}）\n${doc.content}\n`;
+  // 项目地图：关键文件与主要符号的紧凑概览，帮智能体一开局就建立全局观（用 search_code 按概念深入）
+  if (opts.repoMap !== false) {
+    try {
+      const repoMap = buildRepoMap(cwd);
+      if (repoMap) p += `\n# 项目地图（关键文件与主要符号；用 search_code 按概念检索相关实现）\n${repoMap}\n`;
+    } catch { /* 大仓库/权限问题：跳过地图，不影响对话 */ }
+  }
   // 本地技能目录（渐进披露：仅名称+描述常驻，正文经 load_skill 按需载入）
   const skills = skillCatalog(cwd);
   if (skills) p += `\n# 可用技能（本地 Agent Skills）\n${skills}\n`;

package/src/cron.js

@@ -0,0 +1,64 @@
+// 极简 5 字段 cron 匹配器（分 时 日 月 周）：支持 * / N / N-M / N-M/S / */S / 列表(A,B,C)。
+// 周字段 0 与 7 均表示周日。日与周的「或/与」语义遵循标准 cron。
+
+function matchPart(part, value, min, max) {
+  part = part.trim();
+  let step = 1;
+  let range = part;
+  const slash = part.indexOf('/');
+  if (slash >= 0) {
+    step = parseInt(part.slice(slash + 1), 10) || 1;
+    range = part.slice(0, slash);
+  }
+  let lo;
+  let hi;
+  if (range === '*') {
+    lo = min;
+    hi = max;
+  } else if (range.includes('-')) {
+    const [a, b] = range.split('-');
+    lo = parseInt(a, 10);
+    hi = parseInt(b, 10);
+  } else {
+    lo = parseInt(range, 10);
+    hi = slash >= 0 ? max : lo; // "N/S" 表示从 N 起步长 S 到 max
+  }
+  if (Number.isNaN(lo) || Number.isNaN(hi)) return false;
+  if (value < lo || value > hi) return false;
+  return ((value - lo) % step) === 0;
+}
+
+function matchField(expr, value, min, max) {
+  return String(expr).split(',').some((p) => matchPart(p, value, min, max));
+}
+
+/** date 是否匹配 cron 表达式。 */
+export function cronMatches(expr, date = new Date()) {
+  const fields = String(expr).trim().split(/\s+/);
+  if (fields.length !== 5) return false;
+  const [minF, hourF, domF, monF, dowF] = fields;
+  const minute = date.getMinutes();
+  const hour = date.getHours();
+  const dom = date.getDate();
+  const mon = date.getMonth() + 1;
+  const dow = date.getDay(); // 0=周日
+
+  if (!matchField(minF, minute, 0, 59)) return false;
+  if (!matchField(hourF, hour, 0, 23)) return false;
+  if (!matchField(monF, mon, 1, 12)) return false;
+
+  const domStar = domF.trim() === '*';
+  const dowStar = dowF.trim() === '*';
+  const domOk = matchField(domF, dom, 1, 31);
+  const dowOk = matchField(dowF, dow, 0, 7) || (dow === 0 && matchField(dowF, 7, 0, 7));
+  // 标准 cron：日与周都非 * 时取「或」；否则取「与」
+  const dayOk = (domStar && dowStar) ? true
+    : (!domStar && !dowStar) ? (domOk || dowOk)
+      : (domStar ? dowOk : domOk);
+  return dayOk;
+}
+
+/** 校验一个 cron 表达式是否 5 字段（不校验字段合法性细节）。 */
+export function isValidCron(expr) {
+  return String(expr).trim().split(/\s+/).length === 5;
+}

package/src/daemon.js

@@ -0,0 +1,62 @@
+// huicai daemon：内置调度守护——按 cron 真正运行 /schedule 登记的任务（不再依赖系统 cron）。
+// 每分钟检查一次，对命中的任务派生 `huicai -p <prompt> --yolo --plain`（非交互自动放行），输出写日志。
+
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { listTasks } from './schedule.js';
+import { cronMatches } from './cron.js';
+import { huicaiBin } from './forks.js';
+
+export const DAEMON_LOG_DIR = path.join(os.homedir(), '.huicai', 'daemon');
+
+/**
+ * 运行调度守护。
+ * @param {{intervalMs?:number, log?:(s:string)=>void, once?:boolean, spawnImpl?:Function}} [opts]
+ *   once=true 只跑一次（供测试/单次触发）；spawnImpl 可注入（测试用）。
+ */
+export async function runDaemon({ intervalMs = 60000, log = (s) => process.stdout.write(s + '\n'), once = false, spawnImpl } = {}) {
+  const bin = huicaiBin();
+  if (!bin && !spawnImpl) throw new Error('无法定位 huicai 可执行文件（daemon 需在 CLI 环境运行）');
+  fs.mkdirSync(DAEMON_LOG_DIR, { recursive: true });
+  const doSpawn = spawnImpl || ((task) => {
+    const out = fs.openSync(path.join(DAEMON_LOG_DIR, task.id + '.log'), 'a');
+    const child = spawn(process.execPath, [bin, '-p', task.prompt, '--yolo', '--plain'],
+      { cwd: task.cwd, detached: true, stdio: ['ignore', out, out], env: process.env });
+    child.unref();
+    return child.pid;
+  });
+  const lastRun = new Map(); // id -> 'YYYY-MM-DDTHH:MM'，防同一分钟重复触发
+
+  const tick = () => {
+    const now = new Date();
+    const stamp = now.toISOString().slice(0, 16);
+    let fired = 0;
+    for (const t of listTasks()) {
+      if (!t.cron || !t.prompt) continue;
+      if (lastRun.get(t.id) === stamp) continue;
+      let due = false;
+      try { due = cronMatches(t.cron, now); } catch { due = false; }
+      if (!due) continue;
+      lastRun.set(t.id, stamp);
+      const pid = doSpawn(t);
+      fired++;
+      log(`[${stamp}] 触发 #${t.id}（pid ${pid}）：${String(t.prompt).replace(/\s+/g, ' ').slice(0, 60)}`);
+    }
+    return fired;
+  };
+
+  const n = tick();
+  if (once) return { fired: n };
+  log(`huicai 调度守护已启动：每 ${Math.round(intervalMs / 1000)}s 检查 ~/.huicai/schedule.json（${listTasks().length} 个任务）· Ctrl-C 退出`);
+  const timer = setInterval(tick, intervalMs);
+  await new Promise((resolve) => {
+    process.on('SIGINT', () => {
+      clearInterval(timer);
+      log('\n调度守护已停止。');
+      resolve();
+    });
+  });
+  return { fired: n };
+}

package/src/diffview.js

@@ -0,0 +1,115 @@
+// /diff：显示未提交改动（git status + git diff，含未跟踪文件），并汇总本会话智能体改过的文件。
+// 非 git 仓库时退化为「仅列出本会话改过的文件」（无基线无法给 diff，建议配合 /rewind）。
+
+import { execSync } from 'node:child_process';
+import { c } from './colors.js';
+
+const MAX_DIFF_LINES = 500;
+
+function git(cwd, args) {
+  return execSync(`git ${args}`, { cwd, stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: 8 * 1024 * 1024 })
+    .toString();
+}
+
+function isRepo(cwd) {
+  try {
+    return git(cwd, 'rev-parse --is-inside-work-tree').trim() === 'true';
+  } catch {
+    return false;
+  }
+}
+
+/** 本会话中智能体写过/编辑过的文件（从 write_file/edit_file 的工具调用参数提取，去重保序）。 */
+export function sessionEditedFiles(messages) {
+  const seen = new Set();
+  const out = [];
+  for (const m of messages || []) {
+    if (m.role !== 'assistant' || !Array.isArray(m.tool_calls)) continue;
+    for (const tc of m.tool_calls) {
+      const name = tc.function?.name;
+      if (name !== 'write_file' && name !== 'edit_file') continue;
+      let p;
+      try {
+        p = JSON.parse(tc.function?.arguments || '{}').path;
+      } catch {
+        continue;
+      }
+      if (p && !seen.has(p)) {
+        seen.add(p);
+        out.push(p);
+      }
+    }
+  }
+  return out;
+}
+
+/** 给 unified diff 上色。 */
+export function colorizeDiff(text) {
+  return String(text)
+    .split('\n')
+    .map((l) => {
+      if (l.startsWith('diff --git') || l.startsWith('index ') || l.startsWith('--- ') || l.startsWith('+++ ')) return c.bold(l);
+      if (l.startsWith('@@')) return c.cyan(l);
+      if (l.startsWith('+')) return c.green(l);
+      if (l.startsWith('-')) return c.red(l);
+      return l;
+    })
+    .join('\n');
+}
+
+function clip(text) {
+  const lines = String(text).split('\n');
+  if (lines.length <= MAX_DIFF_LINES) return text;
+  return lines.slice(0, MAX_DIFF_LINES).join('\n') + `\n…（diff 过长，仅显示前 ${MAX_DIFF_LINES} 行，用 git diff 查看完整）`;
+}
+
+/** 组装 /diff 输出文本。 */
+export function renderDiff(cwd, messages) {
+  const edited = sessionEditedFiles(messages);
+  const lines = [];
+  if (edited.length) {
+    lines.push(c.bold(`本会话智能体改过的文件（${edited.length}）`));
+    for (const f of edited) lines.push('  · ' + f);
+    lines.push('');
+  }
+
+  if (!isRepo(cwd)) {
+    if (!edited.length) return '当前目录无 git 仓库，且本会话尚无文件改动。';
+    lines.push(c.gray('（非 git 仓库，无法给出 diff；可用 /rewind 回滚本会话改动。）'));
+    return lines.join('\n');
+  }
+
+  let status = '';
+  try {
+    status = git(cwd, 'status --short').trim();
+  } catch { /* ignore */ }
+  if (!status) {
+    lines.push('工作区干净，无未提交改动。');
+    return lines.join('\n');
+  }
+  lines.push(c.bold('git 状态'));
+  lines.push(status.split('\n').map((l) => '  ' + l).join('\n'));
+
+  let diff = '';
+  try {
+    diff = git(cwd, 'diff --stat').trim();
+  } catch { /* ignore */ }
+  if (diff) {
+    lines.push('');
+    lines.push(c.bold('改动统计'));
+    lines.push(diff.split('\n').map((l) => '  ' + l).join('\n'));
+  }
+
+  let full = '';
+  try {
+    full = git(cwd, 'diff').trim(); // 已跟踪文件的未暂存改动
+  } catch { /* ignore */ }
+  if (full) {
+    lines.push('');
+    lines.push(c.bold('改动明细（未暂存）'));
+    lines.push(colorizeDiff(clip(full)));
+  }
+  lines.push('');
+  lines.push(c.gray('（未跟踪文件见上方 ?? 标记；已暂存改动用 git diff --staged 查看。）'));
+  return lines.join('\n');
+}

package/src/doctor.js

@@ -0,0 +1,72 @@
+// /doctor：本机环境体检（对齐 VSCode diagnostics）——node/登录/平台连通/模型/git/工作目录/钩子。
+// 网络类检查 best-effort，失败给出可读提示，绝不抛出中断命令。
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import { c } from './colors.js';
+import { CONFIG_PATH } from './config.js';
+import { listModels } from './api.js';
+import { loadHooks } from './hooks.js';
+
+const OK = () => c.green('✓');
+const NO = () => c.red('✗');
+const DOT = () => c.yellow('•');
+
+function isGitRepo(cwd) {
+  try {
+    return execSync('git rev-parse --is-inside-work-tree', { cwd, stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim() === 'true';
+  } catch {
+    return false;
+  }
+}
+
+function cwdWritable(cwd) {
+  try {
+    fs.accessSync(cwd, fs.constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** 生成体检报告文本（async：含一次平台连通探测）。 */
+export async function runDoctor(ctx) {
+  const { config, cwd } = ctx;
+  const lines = [c.bold('huicai 体检')];
+
+  const nodeMajor = Number(String(process.versions.node).split('.')[0]);
+  lines.push(`  ${nodeMajor >= 18 ? OK() : NO()} Node ${process.version}${nodeMajor >= 18 ? '' : c.yellow('（需 ≥18）')}`);
+  lines.push(`  ${DOT()} 配置文件 ${CONFIG_PATH}`);
+  lines.push(`  ${DOT()} 工作目录 ${cwd}${cwdWritable(cwd) ? '' : c.yellow('（不可写）')}`);
+
+  const loggedIn = !!(config.apiKey && config.baseUrl);
+  lines.push(`  ${loggedIn ? OK() : NO()} 登录 ${loggedIn ? '已登录 · ' + config.baseUrl : '未登录（/login 或 huicai login）'}`);
+
+  if (loggedIn) {
+    try {
+      const models = await listModels(config.baseUrl, config.apiKey);
+      lines.push(`  ${OK()} 平台连通 · ${models.length} 个模型/智能体可用`);
+      const m = config.model;
+      const known = m === 'auto' || models.some((x) => x.id === m);
+      lines.push(`  ${known ? OK() : NO()} 当前模型 ${m}${known ? '' : c.yellow('（不在账号可用列表，建议 /model auto）')}`);
+    } catch (e) {
+      lines.push(`  ${NO()} 平台连通失败：${e.message}`);
+    }
+  }
+
+  const git = isGitRepo(cwd);
+  lines.push(`  ${git ? OK() : DOT()} Git ${git ? '仓库' : c.yellow('当前目录非 git 仓库（/diff 与 /rewind code 在 git 下体验更佳）')}`);
+
+  try {
+    const hooks = loadHooks(cwd);
+    if (hooks.all.length) lines.push(`  ${DOT()} 钩子 已配置 ${hooks.all.length} 个（/hooks 查看）`);
+    if (hooks.projectIgnored) lines.push(`  ${DOT()} 钩子 ${hooks.projectIgnored} 个项目钩子未信任（HUICAI_PROJECT_HOOKS=1 启用）`);
+  } catch { /* 忽略 */ }
+
+  const mcpPath = path.join(process.env.HOME || process.env.USERPROFILE || '', '.huicai', 'mcp.json');
+  lines.push(`  ${DOT()} MCP ${fs.existsSync(mcpPath) ? '已配置 ~/.huicai/mcp.json' : '未配置（可选）'}`);
+
+  lines.push(c.gray('  （体检只读，不改动任何东西）'));
+  return lines.join('\n');
+}

package/src/forks.js

@@ -0,0 +1,59 @@
+// /fork + /tasks：派生后台智能体（detached 子进程跑 `huicai resume <copyId> -p ... --yolo --plain`），
+// 输出写日志文件，本进程内登记以便 /tasks 查看/终止。仅在能定位 huicai 可执行文件时可用（通常即 CLI）。
+
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const forks = []; // 本进程登记的后台任务 {pid, prompt, cwd, log, started}
+
+/** 定位当前 huicai 可执行入口（CLI 下即 process.argv[1]）；无法定位返回 null。 */
+export function huicaiBin() {
+  const a = process.argv[1] || '';
+  return /huicai/.test(a) ? a : null;
+}
+
+/** 派生后台智能体。@param {{prompt:string, cwd:string, sessionId?:string}} p @returns 登记记录 */
+export function forkAgent({ prompt, cwd, sessionId }) {
+  const bin = huicaiBin();
+  if (!bin) throw new Error('无法定位 huicai 可执行文件（请在 CLI 中使用 /fork）');
+  const logDir = path.join(os.homedir(), '.huicai', 'forks');
+  fs.mkdirSync(logDir, { recursive: true });
+  const logFile = path.join(logDir, Date.now().toString(36) + '.log');
+  const out = fs.openSync(logFile, 'a');
+  const args = [bin];
+  if (sessionId) args.push('resume', sessionId); // 继承对话副本
+  args.push('-p', prompt, '--yolo', '--plain'); // 非交互需 --yolo 自动放行
+  const child = spawn(process.execPath, args, { cwd, detached: true, stdio: ['ignore', out, out], env: process.env });
+  child.unref();
+  const rec = { pid: child.pid, prompt: prompt.replace(/\s+/g, ' ').slice(0, 80), cwd, log: logFile, started: Date.now() };
+  forks.push(rec);
+  return rec;
+}
+
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** 列出本会话派生的后台任务（附存活状态）。 */
+export function listForks() {
+  return forks.map((f) => ({ ...f, alive: isAlive(f.pid) }));
+}
+
+/** 终止某后台任务（仅限本会话派生的）。 */
+export function killFork(pid) {
+  const rec = forks.find((f) => f.pid === pid);
+  if (!rec) return { ok: false, reason: '不是本会话派生的任务' };
+  try {
+    process.kill(pid, 'SIGTERM');
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, reason: e.message };
+  }
+}