@huicai/cli 2026.709.53670 → 2026.710.97949

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@huicai/cli",
-  "version": "2026.709.53670",
-  "versionDisplay": "2026.07.09.53670",
+  "version": "2026.710.97949",
+  "versionDisplay": "2026.07.10.97949",
   "description": "在终端运行的智能体 CLI：以 HuiCai_AI 平台的 OpenAI 兼容 /v1 为模型后端，在用户本机执行文件/命令工具。",
   "type": "module",
   "bin": {
@@ -13,6 +13,7 @@
   "files": [
     "bin",
     "src",
+    "skills",
     "README.md",
     "LICENSE"
   ],

package/skills/api-design/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: api-design
+description: 设计或评审 HTTP/REST 接口。当用户要"设计接口/加个 API/评审接口/定义端点/改接口契约"时使用。
+version: 1.0.0
+---
+
+# 接口设计
+
+## 原则
+- **面向资源**：URL 用名词复数（`/orders/{id}/items`），动作用 HTTP 方法表达，别把动词塞进路径。
+- **方法语义**：GET 读且幂等无副作用；POST 创建/动作；PUT 全量替换（幂等）；PATCH 局部更新；DELETE 删除（幂等）。
+- **状态码**：2xx 成功（201 创建 + Location；204 无体）；4xx 客户端错（400 校验/401 未认证/403 越权/404 不存在/409 冲突/422 语义错/429 限流）；5xx 服务端错。
+- **一致的错误体**：`{ code, message, details? }`，机器可读 code + 人可读 message。
+- **入参校验**：类型/必填/范围/枚举；对非法输入返回明确原因。
+
+## 要点清单
+- **分页/排序/过滤**：约定统一参数（如 `page/size` 或游标 `cursor`）；大集合默认分页。
+- **幂等性**：写接口考虑幂等键（`Idempotency-Key`），防重复提交。
+- **版本化与兼容**：加字段兼容、删/改字段谨慎；破坏性变更走新版本。
+- **鉴权**：每个端点声明所需权限，校验资源归属。
+- **安全**：限流、载荷大小上限、避免在 URL 放敏感信息。
+- **文档**：请求/响应示例、错误清单、字段含义。
+
+## 评审时
+- 对照上面清单逐条核；指出不一致与风险；给出改后契约（路径/方法/状态码/请求响应示例）。

package/skills/code-review/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: code-review
+description: 系统化审查代码改动（正确性/边界/安全/可读性/测试）。当用户要求"审查/review/看看这段代码有没有问题/把关质量"，或提交前自查时使用。
+version: 1.0.0
+---
+
+# 代码审查
+
+对一处改动或一段代码做结构化审查。按下述顺序逐项过，**每条结论都指向具体文件:行**，给出可执行的修改建议而非泛泛而谈。
+
+## 流程
+1. **先定位范围**：用 `git diff`（有 git 时经 run_bash）或 read_file 通读改动；先理解意图，再挑毛病。
+2. **逐维度检查**（按严重度排序输出）：
+   - **正确性**：逻辑是否符合意图？边界值（空/0/负数/超长/并发）？off-by-one？异常路径与错误处理？
+   - **数据与状态**：可变共享状态、竞态、事务边界、缓存一致性、资源泄漏（文件/连接/定时器未释放）。
+   - **安全**：注入（SQL/命令/路径穿越）、鉴权与越权、敏感信息硬编码/日志泄漏、反序列化、SSRF。
+   - **接口契约**：入参校验、返回值/错误码约定、向后兼容、幂等性。
+   - **可读性**：命名、重复代码、过长函数、隐藏副作用、魔法数字、与周边代码风格是否一致。
+   - **测试**：关键路径与边界是否有测试覆盖？改动是否破坏既有测试？
+3. **验证**：能跑测试/编译就跑（run_bash），用事实说话，别只靠推理。
+
+## 输出格式
+- 按 `严重(必须改) / 建议 / 可选` 三档分组；
+- 每条：`文件:行 — 问题一句话 → 具体改法`；
+- 末尾一句总体结论（可合入 / 改完再合 / 有阻塞问题）。
+
+## 注意
+- 只审改动相关的问题，别扩散重写；尊重既有约定。
+- 不确定的地方标注"需确认"，不要臆断。

package/skills/commit-and-pr/SKILL.md

@@ -0,0 +1,36 @@
+---
+name: commit-and-pr
+description: 写规范的提交信息与 PR 描述（Conventional Commits）。当用户要"提交/commit/写提交信息/开 PR/写 PR 描述/总结本次改动"时使用。
+version: 1.0.0
+---
+
+# 提交与 PR
+
+## 提交前
+1. run_bash 跑 `git status` + `git diff`（含已暂存）通读**全部**改动，确认无调试代码/无关文件/密钥。
+2. 一次提交只做一件事；跨主题的改动拆成多个提交。
+
+## 提交信息（Conventional Commits）
+格式：`type(scope): 简明主题`，主题用祈使句、≤50 字、不加句号。
+- **type**：feat / fix / refactor / perf / docs / test / build / chore / style / ci。
+- 正文（可选，空一行后）：解释**为什么**这么改、影响面、权衡；关联 issue（`Refs #123`）。
+- 破坏性变更：正文加 `BREAKING CHANGE: ...`。
+
+示例：
+```
+fix(auth): 修复令牌过期后未刷新导致的 401
+
+原逻辑只在请求前检查过期，长响应期间过期不会重试。
+改为遇 401 自动刷新一次再重放。Refs #482
+```
+
+## PR 描述
+- **What**：一句话说清这个 PR 做了什么；
+- **Why**：动机/背景/要解决的问题；
+- **How**：关键实现思路与取舍（只讲非显而易见的）；
+- **测试**：怎么验证的（命令/步骤/截图）；
+- **风险与回滚**：影响面、兼容性、如何回退。
+
+## 注意
+- 未经用户明确要求，不要自行 `git push` 或建远程 PR；先展示信息草稿。
+- 提交信息如实描述，别夸大"已全部测试通过"除非真的跑过。

package/skills/debug-root-cause/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: debug-root-cause
+description: 系统化定位 bug 的根因（而非改表象）。当用户报"报错/崩溃/结果不对/偶发/线上故障/为什么会这样"并需要排查时使用。
+version: 1.0.0
+---
+
+# 根因定位
+
+目标是找到**根因**并用证据证明，而不是打补丁盖住症状。
+
+## 流程
+1. **复现与收敛**：先明确「预期 vs 实际」。找到最小复现步骤/输入。偶发问题记录触发条件与频率。
+2. **读现场**：完整读错误信息与**栈顶到栈底**；用 grep 定位报错字符串来源；read_file 看相关代码与其调用方。
+3. **建立假设**：列 2-3 个可能原因，按可能性与验证成本排序。别急着改。
+4. **二分定位**：用 run_bash 加日志/打印、缩小输入、`git bisect`（可行时）、注释法逐步夹逼到最小可疑范围。
+5. **验证根因**：能稳定「制造」和「消除」该 bug，才算找到根因。说明因果链：`A 导致 B 导致现象`。
+6. **修复**：改根因；评估同类隐患（同一模式是否在别处也存在）；补一个能覆盖此 bug 的回归测试。
+7. **回归**：跑测试/复现步骤确认修好且没引入新问题。
+
+## 常见根因清单
+- 空/未初始化/类型不符；边界与 off-by-one；异步竞态与未 await；缓存/状态不一致；
+- 环境差异（版本/配置/时区/编码/路径）；错误被吞掉；第三方契约变化；并发与锁。
+
+## 注意
+- 先证据后结论；每一步说清"这一步排除/证实了什么"。
+- 不能复现就别声称已修复——给出继续排查的手段。

package/skills/dependency-upgrade/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: dependency-upgrade
+description: 安全地升级第三方依赖/框架版本。当用户说"升级依赖/更新版本/升级框架/修依赖漏洞/迁移到新版本"时使用。
+version: 1.0.0
+---
+
+# 依赖升级
+
+## 流程
+1. **摸清现状**：列出当前版本与目标版本；确认是补丁/次要/大版本（语义化版本：大版本可能有破坏性变更）。
+2. **读变更**：查 CHANGELOG / 迁移指南 / 破坏性变更（breaking changes）与废弃项。心里有数再动。
+3. **小步升级**：优先逐个/逐级升，而非一次跳多个大版本；每步后跑测试与构建（run_bash）。
+4. **适配改动**：按迁移指南改调用点；处理废弃 API、改名、默认值变化、配置迁移。
+5. **验证**：全量测试 + 构建 + 关键路径冒烟；留意运行时（非编译期）才暴露的行为变化。
+6. **锁定**：更新锁文件；确认传递依赖无冲突/无新的高危漏洞。
+
+## 优先级判断
+- **安全漏洞**修复：优先、尽快；
+- 只为"用新版"：评估收益 vs 风险与工作量，别为升级而升级。
+
+## 注意
+- 升级和功能改动分开提交，便于二分与回滚。
+- 大版本升级先在分支验证；有回滚预案。
+- 如实报告哪些通过、哪些需人工适配，别声称"无痛升级"除非确已验证。

package/skills/explain-codebase/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: explain-codebase
+description: 快速摸清并讲清一个陌生代码库/模块的架构与关键路径。当用户问"这个项目怎么跑起来的/架构是什么/从哪看起/帮我理解这块代码"时使用。
+version: 1.0.0
+---
+
+# 讲清一个代码库
+
+目标：用最少的阅读，给出一张"够用的地图"，让人能上手。
+
+## 流程
+1. **鸟瞰**：读 README / package.json / 构建配置 / 目录树（list_files）。识别语言、框架、构建与运行方式、入口文件。
+2. **找入口与主干**：定位 main/启动脚本/路由表/主循环；顺着一条**典型请求或典型操作**从入口追到出口（"打通一条线"胜过泛读)。
+3. **抓关键抽象**：核心数据模型、主要模块边界与依赖方向、跨模块通信方式（调用/事件/队列/HTTP）。
+4. **定位关键机制**：鉴权、配置、错误处理、持久化、并发、外部集成分别在哪。
+5. **验证理解**：用 grep 核对假设；不确定处标注。
+
+## 输出
+- **一段话总览**：这是什么、怎么跑、核心思路；
+- **架构图（文字版）**：主要模块 + 依赖/数据流方向；
+- **关键路径**：一条端到端流程的文件:函数 链路；
+- **上手指引**：常用命令（构建/测试/运行）、改动某功能应从哪个文件入手；
+- **注意事项/坑**：非显而易见的约定。
+
+## 注意
+- 优先深追一条主线，别试图读完所有文件。
+- 结论都能指到具体文件:行；拿不准就说拿不准。

package/skills/perf-optimize/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: perf-optimize
+description: 定位并优化性能瓶颈（慢/CPU 高/内存涨/延迟大）。当用户说"太慢了/性能差/优化速度/内存泄漏/接口延迟高"时使用。
+version: 1.0.0
+---
+
+# 性能优化
+
+铁律：**先测量，后优化**。不要凭直觉改；不要过早优化。
+
+## 流程
+1. **定目标**：明确指标与场景（P95 延迟？吞吐？内存峰值？）与当前基线数值。
+2. **测量定位**：用 profiler / 计时日志 / benchmark（run_bash）找出**真正**的热点。80% 时间往往在少数点。别优化不重要的地方。
+3. **分析根因**，对号入座：
+   - **算法/复杂度**：不必要的 O(n²)、重复计算、能用哈希/索引替代的线性扫描；
+   - **I/O**：N+1 查询、缺索引、无批处理、无缓存、同步阻塞、无连接池；
+   - **内存**：大对象常驻、未释放、复制过多、泄漏（只增不减）；
+   - **并发**：锁竞争、串行化本可并行的工作；
+   - **网络**：往返次数多、载荷大、无压缩/无分页。
+4. **改一处、测一处**：每次只动一个变量，用同一基准对比确认真的变快，并确认**功能未变**（跑测试）。
+5. **收尾**：记录优化前后数值与做法；保留可读性，别为微小收益牺牲正确性/可维护性。
+
+## 注意
+- 缓存要考虑失效与一致性；并发优化要防竞态。
+- 拿数据说话，避免"感觉快了"。

package/skills/refactor-safely/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: refactor-safely
+description: 在不改变外部行为的前提下安全重构（拆函数/去重/改名/解耦）。当用户要"重构/优化结构/消除重复/降复杂度/清理代码"时使用。
+version: 1.0.0
+---
+
+# 安全重构
+
+重构的铁律：**行为不变，只改结构**。功能变更与重构不要混在一次改动里。
+
+## 流程
+1. **建立安全网**：先确认有测试能覆盖要动的代码；没有就**先补特征测试**（characterization test）锁住当前行为，再动手。
+2. **小步前进**：一次只做一种变换（提取函数 / 内联 / 改名 / 移动 / 去重 / 拆类）。每步后立即跑测试保持绿灯。
+3. **常见手法**：
+   - 提取重复逻辑为函数/常量；
+   - 拆过长函数为职责单一的小函数；
+   - 用早返回消除深层嵌套；
+   - 命名表达意图；消除魔法数字；
+   - 收窄可变作用域、减少副作用与隐藏依赖。
+4. **保持接口稳定**：对外签名/返回/错误约定尽量不变；必须变时评估调用方并同步更新。
+5. **验证**：全量测试 + 必要的手动核对；对照重构前后行为一致。
+
+## 注意
+- 不顺手改功能、不"顺便"修 bug（发现 bug 单独记录/单独改）。
+- 改动可回退、可解释；提交信息写清「重构：做了什么变换、为什么」。
+- 尊重既有风格与架构，别为个人偏好大改。

package/skills/release-checklist/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: release-checklist
+description: 发布/上线前的系统化检查。当用户说"要发版/上线前检查/发布准备/打包发布/release"时使用。
+version: 1.0.0
+---
+
+# 发布前检查
+
+上线前逐项确认，宁可慢一步也别带病发布。
+
+## 代码与质量
+- [ ] 全量测试通过；关键路径手动冒烟；无遗留调试代码/临时开关。
+- [ ] 改动已 review；变更范围清楚、可回退。
+- [ ] 版本号已更新，遵循项目版本规范（如语义化或日期制）。
+
+## 配置与依赖
+- [ ] 新增配置项在各环境齐备且有默认；密钥/凭证不在代码里。
+- [ ] 依赖锁定；无已知高危漏洞；数据库迁移脚本可重放、可回滚。
+
+## 兼容与数据
+- [ ] 接口/协议向后兼容；破坏性变更有迁移方案与公告。
+- [ ] 数据迁移在预演环境验证过；大表变更评估锁与耗时。
+
+## 可观测与回滚
+- [ ] 日志/监控/告警覆盖新功能；有关键指标看板。
+- [ ] 明确回滚方案与触发条件；灰度/分批发布计划。
+
+## 发布
+- [ ] 变更记录（changelog）与发布说明就绪。
+- [ ] 低峰期发布；发布后盯核心指标一段时间。
+
+## 注意
+- 逐项用事实核对（跑命令/看配置），别只勾选。
+- 未经明确授权不执行不可逆的发布动作，先汇总待办与风险。

package/skills/security-audit/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: security-audit
+description: 对代码做安全自查（OWASP 常见风险）。当用户要"安全审计/查漏洞/这段代码安全吗/上线安全检查"，或涉及鉴权/输入处理/密钥时使用。
+version: 1.0.0
+---
+
+# 安全自查
+
+按 OWASP 常见风险逐项排查，聚焦本次改动与其数据流。**只报可利用的真实风险**，给出复现思路与修法。
+
+## 检查清单
+- **注入**：SQL/NoSQL/命令/LDAP 注入；是否用参数化查询/白名单，而非字符串拼接。
+- **路径穿越 / SSRF**：文件路径、URL 是否校验并限制在允许范围；用户可控地址是否可打内网。
+- **鉴权与越权**：每个敏感操作是否校验身份与**资源归属**（水平/垂直越权）；默认拒绝。
+- **敏感信息**：密钥/口令是否硬编码、是否进日志/报错/前端；传输是否加密。
+- **输入校验**：类型/长度/范围/编码；反序列化不可信数据；文件上传类型与大小。
+- **XSS / CSRF**（Web）：输出转义、CSP、CSRF token、SameSite Cookie。
+- **依赖**：已知漏洞组件、过时版本。
+- **加密**：别自造算法；密码用强哈希（bcrypt/argon2）加盐；随机数用 CSPRNG。
+- **错误处理**：不向用户暴露堆栈/内部细节；失败要安全（fail closed）。
+- **限流与滥用**：关键接口是否有速率限制与配额。
+
+## 输出
+- 按 `高/中/低` 风险分级；每条：`位置 — 风险与可被如何利用 → 修复建议`。
+- 无法确认的列为"需人工复核"。
+
+## 注意
+- 只做防御性分析与加固，不产出可直接攻击他人系统的利用代码。

package/skills/sql-tuning/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: sql-tuning
+description: 排查并优化慢 SQL / 数据库查询。当用户说"SQL 慢/查询超时/加索引/慢查询/数据库性能"时使用。
+version: 1.0.0
+---
+
+# SQL 优化
+
+## 流程
+1. **拿到执行计划**：`EXPLAIN`（或 `EXPLAIN ANALYZE`）看真实扫描方式与行数估计。别靠猜。
+2. **看几个关键点**：
+   - 是否**全表扫描**本可走索引？
+   - 索引是否命中（最左前缀、无隐式类型转换、无对列做函数运算导致失效）？
+   - 估算行数与实际是否差很多（统计信息过期）？
+   - 是否有大排序/临时表/文件排序（filesort）？
+3. **常见改法**：
+   - 为高选择性的过滤/连接/排序列建**合适的（组合）索引**；覆盖索引避免回表；
+   - 消除 **N+1**：批量查询 / JOIN / IN 替代循环单查；
+   - 只 SELECT 需要的列；分页用键集分页（keyset）替代大 OFFSET；
+   - 避免 `%xxx` 前导通配、`OR` 拆成 UNION、把计算移出 WHERE 的列；
+   - 大批量写用批处理/分批提交。
+4. **验证**：改后再 EXPLAIN + 实测耗时对比；确认结果集不变。
+
+## 注意
+- 索引不是越多越好（拖慢写入、占空间）；按查询模式加。
+- 分库分表/分片场景注意分片键、跨片聚合与去重的坑。
+- 改索引/大表 DDL 评估锁与线上影响，先在从库/低峰验证。

package/skills/write-tests/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: write-tests
+description: 为一段代码补高质量测试（单元/集成）。当用户要"加测试/补测试/提高覆盖率/TDD"，或改完关键逻辑需要测试兜底时使用。
+version: 1.0.0
+---
+
+# 写测试
+
+## 流程
+1. **先摸清工程约定**：用什么测试框架与断言库？测试文件放哪、怎么命名、怎么运行？读 2-3 个既有测试**照着写**，别引入新风格/新依赖。
+2. **理清被测契约**：函数/模块的输入输出、副作用、错误路径分别是什么。
+3. **设计用例**（覆盖优先级从高到低）：
+   - 正常主路径（happy path）1-2 个；
+   - **边界**：空/0/负/超大/超长/首尾元素/单元素；
+   - **错误路径**：非法入参、异常、超时、依赖失败；
+   - 不变量与幂等；必要的并发/顺序敏感场景。
+4. **写**：每个用例只测一件事，命名说清「输入→期望」；用最少的 mock（只挡外部 IO/网络/时间随机）。
+5. **跑**：run_bash 执行测试，全绿为止；顺手确认新测试**确实会因 bug 失败**（反向验证有效性）。
+
+## 好测试的标准
+- 确定性（不 flaky）、快、隔离（不依赖执行顺序/外部状态）、失败信息可读。
+- 测行为与契约，不测实现细节（避免一重构就红）。
+
+## 注意
+- 覆盖率是手段不是目的；优先覆盖高风险与易错边界。
+- 别为了让测试过而弱化断言或改产品代码逻辑。

package/src/agent.js

@@ -17,10 +17,12 @@
 //  - 文本化工具调用防泄漏（与平台侧同款）：模型把工具调用写成纯文本标记时（DeepSeek 系退化）
 //    过滤不显示、不进会话，并注入纠正指令重试（一次要求改走 tool_calls 通道，二次禁工具强制作答）。
 
+import fs from 'node:fs';
+import path from 'node:path';
 import { streamChat } from './api.js';
 import { MarkupFilter, stripMarkup } from './markup-filter.js';
 import { TOOL_SPECS, READONLY_TOOLS, runTool } from './tools.js';
-import { toolLabel, indent } from './render.js';
+import { toolLabel, indent, renderFileDiff } from './render.js';
 import { compactIfNeeded, buildModelMessages } from './compaction.js';
 import { makeTodoTool, formatTodos, TODO_TOOL_NAME } from './todo.js';
 import { makeMemoryTool } from './memory.js';
@@ -67,7 +69,7 @@ export function capToolResult(text) {
  * @param {{spec:object,run:Function,readOnly:boolean}[]} [p.extraTools] 动态外部工具（MCP / 子智能体）
  * @param {number} [p.depth] 子智能体递归深度（0=顶层；todo/memory 仅顶层提供）
  * @param {{write:(s:string)=>void}} [p.io] 输出通道（子智能体传静默通道）
- * @param {object} [p.events] 结构化事件：onDelta/onReasoning/onAssistantText/onToolStart/onToolResult/onSkip/onInfo/onTodo/onMemory/onTurnEnd
+ * @param {object} [p.events] 结构化事件：onDelta/onReasoning/onAssistantText/onToolStart/onToolResult/onFileDiff/onSkip/onInfo/onTodo/onMemory/onTurnEnd
  * @param {{list:any[]}} [p.todoState] 任务清单状态（调用方持有可跨轮保留）
  * @param {{upTo?:number, summary?:string}} [p.compaction] 压缩状态（随会话持久化；原消息不被修改）
  * @param {() => (string|null)} [p.pullQueued] 取一条用户排队消息（无则 null）
@@ -287,6 +289,17 @@ export async function runTurn({
       else out(c.gray(`  ⊘ ${toolLabel(item.name, item.args)} — 已跳过\n`));
       messages.push({ role: 'tool', tool_call_id: item.tc.id, content: reason || '未授权，未执行。' });
     };
+    // 写文件类工具（edit_file/write_file）成功后向 UI 展示「更改的行」（display-only，不进模型上下文）。
+    // 以「执行前后文件内容对比」判定：未改动/失败/被拒 → before==after → 空 diff，天然不显示。
+    const isFileWrite = (name) => name === 'edit_file' || name === 'write_file';
+    const readSafe = (abs) => { try { return fs.readFileSync(abs, 'utf8'); } catch { return ''; } };
+    const emitFileDiff = (item, before) => {
+      const abs = path.resolve(cwd, String(item.args.path));
+      const diff = renderFileDiff(before, readSafe(abs), { path: String(item.args.path) });
+      if (!diff) return;
+      if (ev) ev.onFileDiff?.(diff);
+      else out(diff + '\n');
+    };
 
     let i = 0;
     while (i < parsed.length) {
@@ -332,8 +345,12 @@ export async function runTurn({
         continue;
       }
       emitStart(cur);
+      const before = isFileWrite(cur.name) && cur.args?.path
+        ? readSafe(path.resolve(cwd, String(cur.args.path)))
+        : null;
       const result = await execOne(cur);
       emitResult(cur, result);
+      if (before != null) emitFileDiff(cur, before);
       i++;
     }
 

package/src/banner.js

@@ -0,0 +1,83 @@
+// 启动欢迎横幅：渐变 ASCII 字标 + 上下文信息 + 快捷提示（对标 Claude CLI 进入时的欢迎屏）。
+// 零依赖；真彩(COLORTERM=truecolor)时走 24-bit 青→紫渐变，仅 16 色时退化为青色，NO_COLOR/非 TTY 输出朴素字标。
+
+import { c, colorEnabled } from './colors.js';
+
+// 5 行块字（每字形 5 列宽，字间 1 空格）。
+const FONT = {
+  H: ['█   █', '█   █', '█████', '█   █', '█   █'],
+  U: ['█   █', '█   █', '█   █', '█   █', '█████'],
+  I: ['█████', '  █  ', '  █  ', '  █  ', '█████'],
+  C: ['█████', '█    ', '█    ', '█    ', '█████'],
+  A: ['█████', '█   █', '█████', '█   █', '█   █'],
+  ' ': ['     ', '     ', '     ', '     ', '     '],
+};
+
+function wordmark(word) {
+  const rows = ['', '', '', '', ''];
+  [...word].forEach((ch, idx) => {
+    const g = FONT[ch] || FONT[' '];
+    for (let r = 0; r < 5; r++) rows[r] += (idx ? ' ' : '') + g[r];
+  });
+  return rows;
+}
+
+const truecolor = colorEnabled && /truecolor|24bit/i.test(process.env.COLORTERM || '');
+const lerp = (a, b, t) => Math.round(a + (b - a) * t);
+
+// 按列做水平渐变；无真彩退化为青色；无色原样返回。
+function gradientRow(row, from, to) {
+  if (!colorEnabled) return row;
+  const chars = [...row];
+  const n = chars.length;
+  let out = '';
+  for (let i = 0; i < n; i++) {
+    const ch = chars[i];
+    if (ch === ' ') { out += ' '; continue; }
+    if (!truecolor) { out += `\x1b[36m${ch}`; continue; }
+    const t = n <= 1 ? 0 : i / (n - 1);
+    out += `\x1b[38;2;${lerp(from[0], to[0], t)};${lerp(from[1], to[1], t)};${lerp(from[2], to[2], t)}m${ch}`;
+  }
+  return out + '\x1b[0m';
+}
+
+const PAD = '  ';
+const FROM = [0, 229, 255];  // 青
+const TO = [168, 85, 247];   // 紫
+
+/**
+ * 生成欢迎横幅字符串（不含结尾换行）。
+ * @param {object} p
+ * @param {string} p.model 当前模型 / 平台目标
+ * @param {string} p.cwd 工作目录
+ * @param {string} [p.version] 版本展示串
+ * @param {boolean} [p.platform] 是否平台伪模型（agent-/workflow-/datahuman-）
+ * @param {boolean} [p.yolo] 是否已开自动放行
+ * @param {string} [p.consult] 混合模式咨询目标展示名
+ * @param {boolean} [p.ink] 是否 ink 富终端（附注一行）
+ */
+export function renderWelcome({ model, cwd, version, platform, yolo, consult, ink } = {}) {
+  const cols = process.stdout.columns || 60;
+  const sep = c.gray('─'.repeat(Math.min(Math.max(cols - 2, 24), 50)));
+  const L = [''];
+
+  if (colorEnabled) {
+    for (const row of wordmark('HUICAI')) L.push(PAD + gradientRow(row, FROM, TO));
+  } else {
+    L.push(PAD + 'H U I C A I');
+  }
+
+  L.push('');
+  L.push(PAD + c.bold('HuiCai AI') + c.gray(' · 终端智能体') + (version ? c.gray('  v' + version) : '')
+    + (ink ? c.gray('  · ink') : ''));
+  L.push(PAD + sep);
+  L.push(PAD + c.gray(platform ? '目标  ' : '模型  ') + c.cyan(model || c.gray('(未设置，/model 设置)'))
+    + (platform ? c.gray('  · 平台编排（无本机工具）') : ''));
+  L.push(PAD + c.gray('目录  ') + cwd);
+  if (consult) L.push(PAD + c.gray('咨询  ') + c.magenta(consult) + c.gray('  · 混合模式（本机工具 + 平台咨询）'));
+  if (yolo) L.push(PAD + c.yellow('⚠ 自动放行(yolo) 已开：写文件/执行命令不再逐次确认'));
+  L.push('');
+  L.push(PAD + c.magenta('✦ ') + c.gray('/help 命令 · @文件 引用 · !命令 直通 shell · Ctrl+C 中断'));
+
+  return L.join('\n');
+}

package/src/commands.js

@@ -217,6 +217,15 @@ const BUILTINS = [
       ctx.print(ctx.cwd);
     },
   },
+  {
+    name: 'markdown', desc: '切换助手回复的 Markdown 渲染（TUI 富文本；关闭则显示原始文本，便于复制）',
+    run(ctx) {
+      const next = ctx.config.markdown === false; // 当前关→开，否则→关
+      ctx.config.markdown = next;
+      saveConfig({ markdown: next });
+      ctx.print('Markdown 渲染：' + (next ? '开（下一条回复起生效）' : '关（显示原始 Markdown 文本）'));
+    },
+  },
   {
     name: 'init', desc: '让智能体调研项目并生成/完善 HUICAI.md',
     run() {
@@ -259,6 +268,13 @@ const BUILTINS = [
   },
 ];
 
+/** 全部可用命令（内置 + 自定义），供斜杠自动补全弹层用。返回 [{name,args,desc}]。 */
+export function listCommands(cwd) {
+  const builtins = BUILTINS.map((b) => ({ name: b.name, args: b.args || '', desc: b.desc }));
+  const custom = loadCustomCommands(cwd).map((c) => ({ name: c.name, args: '', desc: c.desc }));
+  return [...builtins, ...custom];
+}
+
 /** 读取自定义命令：项目 .huicai/commands/*.md 优先于全局同名。 */
 export function loadCustomCommands(cwd) {
   const dirs = [

package/src/config.js

@@ -43,6 +43,8 @@ export function loadConfig() {
     memoryEnabled: process.env.HUICAI_MEMORY === '0' ? false : file.memory !== false,
     // 思考过程流式展示：默认开；配置 showReasoning:false 或 HUICAI_REASONING=0 关闭
     showReasoning: process.env.HUICAI_REASONING === '0' ? false : file.showReasoning !== false,
+    // 助手回复 Markdown 渲染（TUI 富文本）：默认开；配置 markdown:false 或 HUICAI_MARKDOWN=0 关闭（显示原始文本）
+    markdown: process.env.HUICAI_MARKDOWN === '0' ? false : file.markdown !== false,
     // 客户端来源标识（对话落库审计用）：默认 cli；VSCode 扩展进程内置 HUICAI_CLIENT=vscode
     client: (process.env.HUICAI_CLIENT || 'cli').trim().toLowerCase(),
   };

package/src/render.js

@@ -40,6 +40,85 @@ export function renderEditDiff(oldStr, newStr) {
   return out.join('\n');
 }
 
+/**
+ * 逐行 LCS diff：返回 [{type:' '|'-'|'+', text}]。超大文本退化为「全删+全增」以防 O(n·m) 爆内存。
+ */
+export function diffLines(oldText, newText) {
+  // 空文本视为「零行」（新建文件时旧内容为空，不应显示一条幽灵空行删除）
+  const split = (t) => (t == null || t === '' ? [] : String(t).split('\n'));
+  const a = split(oldText);
+  const b = split(newText);
+  const n = a.length, m = b.length;
+  if (n * m > 4_000_000) {
+    return [...a.map((t) => ({ type: '-', text: t })), ...b.map((t) => ({ type: '+', text: t }))];
+  }
+  // dp[i][j] = a[i..] 与 b[j..] 的最长公共子序列长度
+  const dp = Array.from({ length: n + 1 }, () => new Uint32Array(m + 1));
+  for (let i = n - 1; i >= 0; i--) {
+    for (let j = m - 1; j >= 0; j--) {
+      dp[i][j] = a[i] === b[j] ? dp[i + 1][j + 1] + 1 : Math.max(dp[i + 1][j], dp[i][j + 1]);
+    }
+  }
+  const ops = [];
+  let i = 0, j = 0;
+  while (i < n && j < m) {
+    if (a[i] === b[j]) { ops.push({ type: ' ', text: a[i] }); i++; j++; }
+    else if (dp[i + 1][j] >= dp[i][j + 1]) { ops.push({ type: '-', text: a[i] }); i++; }
+    else { ops.push({ type: '+', text: b[j] }); j++; }
+  }
+  while (i < n) ops.push({ type: '-', text: a[i++] });
+  while (j < m) ops.push({ type: '+', text: b[j++] });
+  return ops;
+}
+
+/**
+ * 把一次文件更改渲染为「带行号的统一 diff」（对标 Claude Code 编辑后展示更改的行）：
+ * 增行绿色 `+`、删行红色 `-`、上下文灰色；仅显示变更行及其上下 context 行，中间大段用 ⋯ 省略。
+ * 无变化返回空串。返回的是带 ANSI 的字符串（可直接 write，也可放进 ink <Text>）。
+ * @param {string} oldText
+ * @param {string} newText
+ * @param {{path?:string, context?:number, maxLines?:number}} [opts]
+ */
+export function renderFileDiff(oldText, newText, opts = {}) {
+  const { path = '', context = 3, maxLines = 80 } = opts;
+  const ops = diffLines(oldText, newText);
+  let adds = 0, dels = 0;
+  for (const o of ops) { if (o.type === '+') adds++; else if (o.type === '-') dels++; }
+  if (adds === 0 && dels === 0) return '';
+
+  // 标注每行的旧/新行号
+  const rows = [];
+  let oldNo = 0, newNo = 0;
+  for (const o of ops) {
+    if (o.type === ' ') { oldNo++; newNo++; rows.push({ type: ' ', text: o.text, no: oldNo }); }
+    else if (o.type === '-') { oldNo++; rows.push({ type: '-', text: o.text, no: oldNo }); }
+    else { newNo++; rows.push({ type: '+', text: o.text, no: newNo }); }
+  }
+  // 需展示的行 = 变更行及其上下 context 行
+  const show = new Array(rows.length).fill(false);
+  rows.forEach((r, idx) => {
+    if (r.type === ' ') return;
+    for (let k = Math.max(0, idx - context); k <= Math.min(rows.length - 1, idx + context); k++) show[k] = true;
+  });
+
+  const width = String(Math.max(oldNo, newNo)).length;
+  const pad = (no) => String(no == null ? '' : no).padStart(width);
+  const out = [(path ? c.bold(path) + '  ' : '') + c.green('+' + adds) + ' ' + c.red('−' + dels)];
+  let elided = false, shown = 0, truncated = false;
+  for (let idx = 0; idx < rows.length; idx++) {
+    if (!show[idx]) { if (!elided) { out.push(c.gray('  ' + ' '.repeat(width) + ' ⋯')); elided = true; } continue; }
+    elided = false;
+    if (shown >= maxLines) { truncated = true; break; }
+    const r = rows[idx];
+    if (r.type === '+') out.push(c.green('  ' + pad(r.no) + ' + ') + c.green(r.text));
+    else if (r.type === '-') out.push(c.red('  ' + pad(r.no) + ' - ') + c.red(r.text));
+    else out.push(c.gray('  ' + pad(r.no) + '   ' + r.text));
+    shown++;
+  }
+  if (truncated) out.push(c.gray(`  …（差异较大，仅显示前 ${maxLines} 行；共 +${adds} −${dels}）`));
+  return out.join('\n');
+}
+
 export function indent(s, pad = '    ') {
   return String(s)
     .split('\n')

package/src/repl.js

@@ -12,6 +12,7 @@ import { makeConsultTool } from './consult.js';
 import { runSlash } from './commands.js';
 import { expandAtMentions, buildUserContent, runBangCommand, loadHistory, appendHistory } from './input.js';
 import { makeSkillTools } from './skills.js';
+import { renderWelcome } from './banner.js';
 
 /** 汇集动态工具：本地技能（load_skill）+ 本地 MCP 工具 + dispatch_agent 子智能体。返回 {extraTools, clients}。 */
 export async function buildExtraTools(config, cwd) {
@@ -31,19 +32,15 @@ export async function buildExtraTools(config, cwd) {
   return { extraTools, clients: mcp.clients };
 }
 
-function banner(config, cwd, permissions) {
-  process.stdout.write(c.bold(c.magenta('\n  huicai')) + c.gray(' · 终端智能体') + '\n');
-  const platform = /^(agent|workflow|datahuman)-/.test(String(config.model || ''));
-  process.stdout.write(
-    c.gray(`  ${platform ? '目标' : '模型'} ${config.model || '(未设置, /model 设置)'}`
-      + `${platform ? ' · 平台编排（分享页同款对话，无本机工具）' : ''} · 目录 ${cwd}`) + '\n',
-  );
-  process.stdout.write(
-    c.gray(
-      `  ${permissions.isYolo() ? '⚠ 自动放行(yolo) 已开 · ' : ''}` +
-      '/help 命令 · @文件 引用 · !命令 直通 shell · Ctrl+C 中断本回合',
-    ) + '\n',
-  );
+function banner(config, cwd, permissions, version) {
+  process.stdout.write(renderWelcome({
+    model: config.model,
+    cwd,
+    version,
+    platform: /^(agent|workflow|datahuman)-/.test(String(config.model || '')),
+    yolo: permissions.isYolo(),
+    consult: config.consult ? (config.consultLabel || config.consult) : null,
+  }) + '\n');
 }
 
 export async function startRepl({ config, cwd, yolo, initialPrompt, session, version }) {
@@ -66,7 +63,7 @@ export async function startRepl({ config, cwd, yolo, initialPrompt, session, ver
     else process.stdout.write('\n' + c.gray('输入 /exit 退出。') + '\n');
   });
 
-  banner(config, cwd, permissions);
+  banner(config, cwd, permissions, version);
   echoResumed(session);
   const { extraTools, clients } = await buildExtraTools(config, cwd); // 连接 MCP（若已配置）
 

package/src/skills.js

@@ -7,6 +7,12 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+// 随 CLI 一起分发的内置技能目录（<包根>/skills）。作为「只读、最低优先级」的技能来源：
+// 用户在项目 .huicai/skills 或全局 ~/.huicai/skills 建同名技能即可覆盖。仅进入「发现/载入」读路径，
+// 不进入 skillDirs()（pull 写入目标仍是用户目录，勿写包内）。
+export const BUNDLED_SKILLS_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'skills');
 
 /** 附件允许的文本扩展名（与平台 SkillFile.TEXT_EXTS 对齐；二进制不收） */
 const TEXT_EXTS = new Set([
@@ -67,13 +73,18 @@ function collectFiles(dir, base = '', depth = 0, out = []) {
  */
 export function loadLocalSkills(cwd) {
   const byName = new Map();
-  const dirs = skillDirs(cwd);
-  dirs.forEach((base, i) => {
+  // 优先级：项目 > 全局 > 内置（同名先扫者生效，故用户目录可覆盖内置技能）
+  const dirs = [
+    ...(cwd ? [{ dir: path.join(cwd, '.huicai', 'skills'), scope: 'project' }] : []),
+    { dir: path.join(os.homedir(), '.huicai', 'skills'), scope: 'global' },
+    { dir: BUNDLED_SKILLS_DIR, scope: 'builtin' },
+  ];
+  for (const { dir: base, scope } of dirs) {
     let entries;
     try {
       entries = fs.readdirSync(base, { withFileTypes: true });
     } catch {
-      return;
+      continue;
     }
     for (const e of entries) {
       if (!e.isDirectory()) continue;
@@ -86,17 +97,17 @@ export function loadLocalSkills(cwd) {
       }
       const fm = parseFrontmatter(raw);
       const name = (fm.name || e.name).trim();
-      if (!name || byName.has(name)) continue;   // 先扫项目级，同名时项目级生效
+      if (!name || byName.has(name)) continue;   // 同名：先扫者（更高优先级）生效
       byName.set(name, {
         name,
         description: fm.description || '',
         version: fm.version || '',
         dir,
-        scope: i === 0 && dirs.length > 1 ? 'project' : 'global',
+        scope,
         files: collectFiles(dir),
       });
     }
-  });
+  }
   return [...byName.values()];
 }
 

package/src/tui/app.js

@@ -13,11 +13,15 @@
 import React, { useState, useRef, useReducer, useEffect, useMemo } from 'react';
 import { render, Box, Text, Static, useInput, useApp } from 'ink';
 import { runTurn } from '../agent.js';
+import { fetchUsage } from '../api.js';
 import { toolLabel } from '../render.js';
+import { renderMarkdown, looksLikeMarkdown } from '../markdown.js';
+import { renderWelcome } from '../banner.js';
 import { createSession, saveSession } from '../session.js';
 import { buildExtraTools } from '../repl.js';
 import { closeMcp } from '../mcp.js';
-import { runSlash } from '../commands.js';
+import { runSlash, listCommands } from '../commands.js';
+import { usageStatus, fmtReset } from '../usage.js';
 import { expandAtMentions, buildUserContent, runBangCommand, loadHistory, appendHistory } from '../input.js';
 import { loadAllowRules, matchAllowRules, suggestRule, addProjectAllowRule, riskWarning } from '../settings.js';
 
@@ -35,12 +39,13 @@ function clipLines(s, maxLines = 12) {
 }
 
 function fmtTok(n) {
+  n = Number(n) || 0;
   return n >= 1000 ? (n / 1000).toFixed(1) + 'k' : String(n);
 }
 
 const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 
-function App({ config, cwd, session: initialSession, extraTools, yolo, initialPrompt, version, onExit }) {
+export function App({ config, cwd, session: initialSession, extraTools, yolo, initialPrompt, version, onExit }) {
   const app = useApp();
   const logRef = useRef([]); // 已定稿记录：{id,kind,text}
   const idRef = useRef(0);
@@ -72,6 +77,11 @@ function App({ config, cwd, session: initialSession, extraTools, yolo, initialPr
   const [todos, setTodos] = useState([]);
   const [queueLen, setQueueLen] = useState(0);
   const [spin, setSpin] = useState(0);
+  const [win, setWin] = useState(null); // Token 用量窗口（5小时/7天）最新快照
+  const winRef = useRef(null);           // 同上，供异步路径同步读取（发起回合前的用尽拦截）
+  const [sugIdx, setSugIdx] = useState(0); // 斜杠命令补全：选中项
+  const [hideSug, setHideSug] = useState(false); // 斜杠命令补全：Esc 临时收起
+  const allCommands = useMemo(() => listCommands(cwd), [cwd]); // 命令清单（含自定义），一次性
 
   const addLog = (kind, text) => {
     logRef.current.push({ id: idRef.current++, kind, text });
@@ -79,7 +89,11 @@ function App({ config, cwd, session: initialSession, extraTools, yolo, initialPr
   };
   const flushLive = () => {
     if (liveRef.current) {
-      addLog('assistant', liveRef.current);
+      // 定稿时把助手正文渲染为 Markdown（ink <Text> 原样保留内嵌 ANSI）；流式期间仍显示原文，完成即定稿为富文本。
+      // 纯散文（无 Markdown 结构）直接留原文，避免无谓处理与边角改动。
+      const raw = liveRef.current;
+      const md = config.markdown !== false && looksLikeMarkdown(raw);
+      addLog('assistant', md ? renderMarkdown(raw) : raw);
       liveRef.current = '';
     }
   };
@@ -95,6 +109,22 @@ function App({ config, cwd, session: initialSession, extraTools, yolo, initialPr
     return () => clearInterval(t);
   }, [status]);
 
+  // Token 用量窗口：进入时拉一次，之后每回合结束 + 定时刷新（best-effort，离线/平台不支持则静默）
+  const refreshUsage = async () => {
+    if (!config.apiKey) return;
+    try {
+      const u = await fetchUsage(config.baseUrl, config.apiKey);
+      winRef.current = u;
+      setWin(u);
+    } catch { /* 忽略 */ }
+  };
+  useEffect(() => {
+    void refreshUsage();
+    const t = setInterval(() => { void refreshUsage(); }, 180000);
+    return () => clearInterval(t);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
   const thinkRef = useRef(''); // 思考过程（reasoning）流式缓冲，仅动态区展示不入定稿记录
   const events = {
     onDelta: (t) => {
@@ -112,6 +142,7 @@ function App({ config, cwd, session: initialSession, extraTools, yolo, initialPr
       addLog('tool', toolLabel(name, args));
     },
     onToolResult: (name, res) => addLog('toolresult', shortLine(res)),
+    onFileDiff: (diff) => addLog('diff', diff), // 文件更改的行（已带 ANSI，Static 原样呈现）
     onSkip: (name, args) => addLog('skip', toolLabel(name, args) + ' — 已跳过'),
     onInfo: (t) => {
       flushLive();
@@ -150,6 +181,12 @@ function App({ config, cwd, session: initialSession, extraTools, yolo, initialPr
   };
 
   const runUserTurn = async (text) => {
+    // 用量窗口已用尽 → 终止：不发起新回合（进行中的回合由平台 429 终态自然结束）
+    const gate = usageStatus(winRef.current);
+    if (gate && gate.level === 'exhausted') {
+      addLog('info', `✗ Token 用量窗口（${gate.label}）已用尽，暂无法继续。${fmtReset(gate.resetAtEpochMs)}`);
+      return;
+    }
     const { text: expanded, images } = await expandAtMentions(text, cwd, config);
     sessionRef.current.messages.push({ role: 'user', content: buildUserContent(expanded, images) });
     setBusy(true);
@@ -181,6 +218,7 @@ function App({ config, cwd, session: initialSession, extraTools, yolo, initialPr
       addLog('info', '已清空排队消息');
     }
     setBusy(false);
+    void refreshUsage(); // 回合结束刷新用量窗口（含被 429 用尽的情形 → 更新右下角提示 + 拦截下一回合）
   };
 
   const doExit = () => {
@@ -289,6 +327,16 @@ function App({ config, cwd, session: initialSession, extraTools, yolo, initialPr
     }
   };
 
+  // 斜杠命令自动补全：仅在「以 / 开头且尚未输入空格（还在打命令名）」时给候选
+  const slashMatch = /^\/(\S*)$/.exec(inp.text);
+  const slashQuery = slashMatch ? slashMatch[1] : null;
+  const suggestions = slashQuery == null
+    ? []
+    : allCommands.filter((cmd) => cmd.name.toLowerCase().startsWith(slashQuery.toLowerCase())).slice(0, 8);
+  const popupOpen = suggestions.length > 0 && !hideSug;
+  // 候选变化时复位选中项与「Esc 收起」态（继续打字即重新弹出）
+  useEffect(() => { setSugIdx(0); setHideSug(false); }, [slashQuery]);
+
   useInput((ch, key) => {
     // 授权提示优先（y 一次 / a 本会话 / A 永久规则 / n·Esc·回车 拒绝）
     if (pendingRef.current) {
@@ -318,6 +366,18 @@ function App({ config, cwd, session: initialSession, extraTools, yolo, initialPr
       if (ch === 'n' || key.escape || key.return) return done({ allow: false, reason: '用户拒绝了该操作。' });
       return;
     }
+    // 斜杠命令补全弹层打开时，接管 上下选择 / Tab 补全 / 回车执行 / Esc 收起；其它键落到下方输入以继续过滤
+    if (popupOpen) {
+      const pick = () => suggestions[Math.min(sugIdx, suggestions.length - 1)];
+      if (key.upArrow) return setSugIdx((x) => (x - 1 + suggestions.length) % suggestions.length);
+      if (key.downArrow) return setSugIdx((x) => (x + 1) % suggestions.length);
+      if (key.tab) {
+        const name = pick().name;
+        return setInp({ text: '/' + name + ' ', cursor: name.length + 2 });
+      }
+      if (key.return) return void submit('/' + pick().name);
+      if (key.escape) return setHideSug(true);
+    }
     if (key.escape) {
       if (statusRef.current === 'busy' && abortRef.current) {
         abortRef.current.abort();
@@ -373,6 +433,11 @@ function App({ config, cwd, session: initialSession, extraTools, yolo, initialPr
   const before = inp.text.slice(0, inp.cursor);
   const at = inp.text[inp.cursor] ?? ' ';
   const after = inp.text.slice(inp.cursor + 1);
+  const termWidth = Math.max(8, process.stdout.columns || 80); // 输入栏上下蓝线宽度（随终端自适应）
+  const uStat = usageStatus(win); // 用量告警（null=正常，不显示）
+  const uWarn = !uStat ? '' : uStat.level === 'exhausted'
+    ? `⛔ ${uStat.label}用量已用尽${fmtReset(uStat.resetAtEpochMs) ? ' · ' + fmtReset(uStat.resetAtEpochMs) : ''}`
+    : `⚠ ${uStat.label}用量 ${Math.round(uStat.pct * 100)}%（${fmtTok(uStat.used)}/${fmtTok(uStat.limit)}）`;
 
   return h(
     Box,
@@ -420,28 +485,44 @@ function App({ config, cwd, session: initialSession, extraTools, yolo, initialPr
           h(Text, null, '[y] 允许一次 · [a] 本会话 · [A] 永久(写入项目设置) · [n/Esc] 拒绝'),
         )
       : null,
+    // 斜杠命令补全弹层（输入 / 即弹；↑↓ 选择 · Tab 补全 · ⏎ 执行 · Esc 关闭）
+    popupOpen
+      ? h(
+          Box,
+          { flexDirection: 'column', marginTop: 1 },
+          h(Text, { color: 'gray' }, '  斜杠命令 · ↑↓ 选择 · Tab 补全 · ⏎ 执行 · Esc 关闭'),
+          ...suggestions.map((s, i) =>
+            h(
+              Box,
+              { key: s.name },
+              h(Text, { color: 'cyan', bold: i === sugIdx },
+                (i === sugIdx ? ' ❯ ' : '   ') + '/' + s.name + (s.args ? ' ' + s.args : '')),
+              h(Text, { color: 'gray' }, '  ' + String(s.desc || '').replace(/\s+/g, ' ').slice(0, 46)),
+            ),
+          ),
+        )
+      : null,
+    // 输入栏：上下各一条蓝色横线包住输入行（弹层打开时其自带间距，蓝线贴紧）
+    h(Box, { marginTop: popupOpen ? 0 : 1 }, h(Text, { color: 'blue' }, '─'.repeat(termWidth))),
     // 输入行（带光标；忙时输入会排队）
     h(
       Box,
-      { marginTop: 1 },
+      null,
       h(Text, { color: status === 'busy' ? 'yellow' : 'cyan' }, status === 'busy' ? '⧗ ' : '› '),
       h(Text, null, before),
       h(Text, { inverse: true }, at),
       h(Text, null, after),
     ),
-    // 状态栏
+    h(Text, { color: 'blue' }, '─'.repeat(termWidth)),
+    // 底栏：左=目录/模型/队列；右下角=用量告警（仅 ≥80% 或用尽时实时出现）
     h(
       Box,
-      null,
-      h(
-        Text,
-        { color: 'gray' },
+      { justifyContent: 'space-between' },
+      h(Text, { color: 'gray' },
         `${cwdName} · ${config.model}${yoloRef.current ? ' · ⚠ yolo' : ''}`
-          + ` · tok ${usage.prompt}/${usage.completion}`
-          + (ctxTok ? ` · ctx ~${fmtTok(ctxTok)}` : '')
           + (queueLen ? ` · 排队 ${queueLen}` : '')
-          + ' · /help',
-      ),
+          + ' · /help'),
+      uWarn ? h(Text, { color: uStat.level === 'exhausted' ? 'red' : 'yellow', bold: true }, uWarn) : h(Text, null, ''),
     ),
   );
 }
@@ -451,6 +532,7 @@ function LogLine({ item }) {
   const { kind, text } = item;
   if (kind === 'user') return h(Box, { marginTop: 1 }, h(Text, { color: 'cyan', bold: true }, '› '), h(Text, { bold: true }, text));
   if (kind === 'assistant') return h(Box, null, h(Text, null, text));
+  if (kind === 'diff') return h(Box, { marginLeft: 2 }, h(Text, null, text)); // 更改的行（已带 ANSI）
   if (kind === 'tool') return h(Text, { color: 'cyan' }, '  ⏺ ' + text);
   if (kind === 'toolresult') return h(Text, { color: 'gray' }, '     ' + text);
   if (kind === 'skip') return h(Text, { color: 'gray' }, '  ⊘ ' + text);
@@ -466,7 +548,15 @@ function LogLine({ item }) {
  * 启动 ink TUI。先（在 ink 接管屏幕前）连接 MCP 并打印连接信息，再进入全屏界面；退出后关闭 MCP。
  */
 export async function runInk({ config, cwd, session, yolo, initialPrompt, version }) {
-  process.stdout.write(`\n  huicai · 终端智能体（ink TUI） · ${config.model}\n`);
+  process.stdout.write(renderWelcome({
+    model: config.model,
+    cwd,
+    version,
+    platform: /^(agent|workflow|datahuman)-/.test(String(config.model || '')),
+    yolo,
+    consult: config.consult ? (config.consultLabel || config.consult) : null,
+    ink: true,
+  }) + '\n');
   const { extraTools, clients } = await buildExtraTools(config, cwd);
   const { waitUntilExit } = render(
     h(App, { config, cwd, session, extraTools, yolo, initialPrompt, version, onExit: () => closeMcp(clients) }),

package/src/usage.js

@@ -0,0 +1,43 @@
+// Token 用量窗口告警判定（纯函数，零依赖）。从 /v1/usage 的快照推导「是否该提示 / 是否用尽」。
+// limit 约定：>0 上限；-1 无限；0 该档未开放。两窗（5小时/7天）取占比最高者。
+
+/**
+ * @param {{allowed?:boolean, used5h?:number, limit5h?:number, used7d?:number, limit7d?:number, resetAtEpochMs?:number|null}|null} win
+ * @returns {{level:'warn'|'exhausted', label:string, used:number, limit:number, pct:number, resetAtEpochMs?:number|null}|null}
+ *   null = 正常（<80% 或无可判定窗口）。warn ≥80%；exhausted ≥100% 或平台判定 allowed=false。
+ */
+export function usageStatus(win) {
+  if (!win) return null;
+  let worst = null;
+  for (const w of [
+    { label: '5小时', used: win.used5h, limit: win.limit5h },
+    { label: '7天', used: win.used7d, limit: win.limit7d },
+  ]) {
+    if (typeof w.limit !== 'number' || w.limit <= 0 || typeof w.used !== 'number') continue; // -1 无限 / 0 未开放
+    const pct = w.used / w.limit;
+    if (!worst || pct > worst.pct) worst = { ...w, pct };
+  }
+  if (win.allowed === false) {
+    return {
+      level: 'exhausted',
+      label: worst?.label || '窗口',
+      used: worst?.used,
+      limit: worst?.limit,
+      pct: worst ? worst.pct : 1,
+      resetAtEpochMs: win.resetAtEpochMs,
+    };
+  }
+  if (!worst) return null;
+  if (worst.pct >= 1) return { level: 'exhausted', ...worst, resetAtEpochMs: win.resetAtEpochMs };
+  if (worst.pct >= 0.8) return { level: 'warn', ...worst, resetAtEpochMs: win.resetAtEpochMs };
+  return null;
+}
+
+/** 剩余时长（到 resetAtEpochMs）转「N小时M分后重置」；已过或缺省返回空串。 */
+export function fmtReset(ms) {
+  const d = (ms || 0) - Date.now();
+  if (d <= 0) return '';
+  const h = Math.floor(d / 3600000);
+  const m = Math.round((d % 3600000) / 60000);
+  return h > 0 ? `${h}小时${m}分后重置` : `${m}分后重置`;
+}