@ghenya/clinn 0.8.8 → 0.9.1

package/README.md

@@ -1,49 +1,35 @@
 # Clinn — 终端原生 AI 编程助手
 
-> DeepSeek 驱动 · 50+ 工具 · 对话记忆 · 虚拟浏览器 · 零依赖运行
+> Self-Evolving Terminal AI · Ink TUI · 50+ Tools · Session Memory
 
-Clinn 是一个运行在终端里的 AI Agent，直接和你的文件系统、Shell、网络交互。不需要 IDE、不需要插件——打开终端，说人话，它帮你干活。
-
-🌐 官方网站：[yxpil.com](https://yxpil.com)
+```bash
+npm install -g @ghenya/clinn
+clinn
+```
 
 ```
-██████  ██      ██ ███    ██ ███    ██
+██████ ██      ██ ███    ██ ███    ██
 ██      ██      ██ ████   ██ ████   ██
 ██      ██      ██ ██ ██  ██ ██ ██  ██
 ██      ██      ██ ██  ██ ██ ██  ██ ██
-██████  ███████ ██ ██   ████ ██   █ 0.7
+██████  ███████ ██ ██   ████ ██   █ 0.9
 ```
 
 ---
 
 ## 安装
 
-### macOS / Linux / WSL
-
 ```bash
-git clone https://github.com/PillowBots/clinn.git
-cd clinn
-bash install.sh
-```
-
-安装后全局可用：终端输入 `clinn` 即可启动。
+# npm 全局安装
+npm install -g @ghenya/clinn
 
-### Windows
-
-```bat
+# 或从 GitHub
 git clone https://github.com/PillowBots/clinn.git
-cd clinn
-install.bat
+cd clinn && bash install.sh
 ```
 
-或直接双击 `clinn.bat`。
-
-### 前置条件
-
 - Node.js >= 18
-- DeepSeek API Key（[获取地址](https://platform.deepseek.com/)）
-
-首次运行时会提示输入 API Key。
+- DeepSeek API Key ([获取](https://platform.deepseek.com/))
 
 ---
 
@@ -51,190 +37,116 @@ install.bat
 
 | 类别 | 工具 |
 |---|---|
-| **文件操作** | read, write, delete_file, move_file, copy_file, search_replace, edit_lines, read_lines, file_info |
-| **目录浏览** | ls, list_dir, tree, glob — 一键看完项目结构 |
-| **搜索** | grep, search_in_files, search_in_range, find_files |
-| **终端** | exec_console, check_command_status — 直接跑命令 |
-| **网络** | web_search（Bing 搜索）, web_fetch（网页抓取）, browse_page（虚拟浏览器反反爬） |
-| **记忆** | search_memory, save_memory, list_memory, delete_memory |
-| **对话** | forget_conversation, restart_session |
-| **任务** | todo_write, set_timer, skill |
-| **工具管理** | save_tool, delete_tool_file, list_saved_tools — AI 自己写的工具持久化保存 |
-| **诊断** | get_diagnostics |
-| **预览** | open_preview |
+| **文件操作** | read, write, delete_file, move_file, copy_file, search_replace, edit_lines |
+| **搜索** | grep (ripgrep优先), glob, search_in_files, find_files |
+| **终端** | exec_console, wait_command |
+| **网络** | web_search (Bing), web_fetch, browse_page (Puppeteer) |
+| **记忆** | mem_rom (永久), mem_ram (会话), search_memory, list_memory, delete_memory |
+| **对话** | forget_conversation, restart_session, compress_context |
+| **Session** | list_sessions, view_session, search_sessions — 全局历史搜索 |
+| **工具管理** | save_tool, delete_tool_file, list_saved_tools — AI 自写工具持久化 |
 
 ---
 
-## 使用方式
-
-启动后直接输入自然语言：
-
-```
-> 帮我分析这个项目的代码结构
-> 搜索项目里所有 TODO 注释
-> 把 README.md 里的英文翻译成中文
-> 液氮超频的最高纪录是多少？
-```
-
-### 内置命令
+## 内置命令
 
 | 命令 | 说明 |
 |---|---|
-| `/help` | 查看所有命令 |
-| `/tools` | 查看工具列表 |
-| `/history [n]` | 查看最近 n 条对话 |
-| `/history files` | 查看历史文件列表 |
-| `/history search <关键词>` | 搜索历史 |
-| `/reset` | 重置当前对话 |
-| `/ctx` | 查看上下文使用量 |
-| `/clear` | 清除上下文记忆 |
-| `/status` | 查看当前状态 |
-| `/trusted` | 查看受信任工具 |
-| `/trust <name>` | 永久信任工具 |
-| `/untrust <name>` | 取消信任 |
+| `/help` | 查看帮助 |
+| `/reset` | 重置对话 (新 session) |
+| `/clear` | 清除消息 |
+| `/ctx` | 上下文使用量 |
+| `/status` | 当前状态 |
+| `/tools` | 工具列表 |
+| `/history [n]` | 最近历史 |
+| `/history search <q>` | 搜索历史 |
+| `/sessions` | 列出 session |
+| `/session <id>` | 查看 session |
+| `/session_search <q>` | 全局搜索 |
+| `/memory` | 记忆统计 |
+| `/memory_list [n]` | 记忆列表 |
+| `/memory_search <q>` | 搜索记忆 |
+| `/compress` | 压缩上下文 |
+| `/trust <name>` | 信任工具 |
+| `/api` | API 配置 |
 | `/exit` | 退出 |
 
 ---
 
 ## 核心特性
 
-### 对话记忆与历史
+### Ink 全屏 TUI (v0.9)
 
-每次对话自动保存到 `Mem/history-YYYY-MM-DD.json`，包含完整的工具调用链路。支持历史搜索、回顾、分页浏览（less 分页器）。
+全屏终端界面，左侧 LOGO + 右侧欢迎框，消息折叠、工具调用折叠/展开、Ctrl+C 中断、消息队列排队执行。
 
-### 虚拟浏览器
+### 双级记忆系统 (v0.9)
 
-`browse_page` 工具基于 puppeteer-core + Chrome Headless，可绕过大部分反爬机制，用于抓取需要 JS 渲染的页面。
+- **mem_rom**：永久记忆，落盘 `~/.clinn/mem/persistent-memory.json`，重启不丢
+- **mem_ram**：会话记忆，仅本次窗口，关闭即丢
+- 搜索同时覆盖 ROM + RAM，带 `[ROM]`/`[RAM]` 标签
 
-### 自定义工具持久化
-
-AI 可以在对话中生成工具代码，通过 `save_tool` 持久化到 `Tools/custom/` 目录，下次启动自动加载。
-
-### 上下文实时监控
-
-- 90%：黄色提示 "建议 /clear 清除对话"
-- 95%：二次警告 "请尽快 /clear"
-- 不会再自动压缩上下文——由用户自己决定何时 `/clear`
+### Session 回顾与全局搜索 (v0.9)
 
-### 思考动画
+- 每次 `/reset` 或重启创建新 session
+- `/sessions` 列出所有历史会话
+- `/session_search` 全文搜索全部历史
 
-braille spinner 旋转指示 LLM 推理状态，120ms 一帧，流畅不刷屏。有内容输出时自动静默。
+### 虚拟浏览器
 
----
+`browse_page` 基于 puppeteer-core + Chrome Headless，可绕过大部分反爬机制。
 
-## 项目结构
+### 自定义工具持久化
 
-```
-Clinn/
-├── Src/
-│   ├── index.js        # CLI 入口、UI 渲染、斜杠命令
-│   ├── agent.js        # Agent 主逻辑、工具循环、记忆管理
-│   └── llm.js          # DeepSeek API 客户端、流式解析
-├── Tools/
-│   ├── index.js        # 工具注册、权限、自定义工具加载
-│   ├── file_tools.js   # 文件读写操作
-│   ├── edit_tools.js   # search_replace、edit_lines
-│   ├── search_tools.js # grep、find_files、web_fetch
-│   ├── extended_tools.js # web_search (Bing)、exec_console、todo_write 等
-│   ├── browser.js      # 虚拟浏览器 (puppeteer-core)
-│   ├── tokenizer.js    # Token 估算
-│   └── custom/         # 用户自定义工具持久化目录
-├── Mem/
-│   ├── index.js        # ConversationMemory
-│   ├── history.js      # 历史文件读写、搜索
-│   └── history-*.json  # 按日期存储的对话历史
-├── Logos/
-│   └── StartLogo.txt   # 启动 Logo
-├── config.json         # 配置文件
-├── install.sh          # macOS/Linux 安装脚本
-├── install.bat         # Windows 安装脚本
-├── clinn.bat           # Windows 快捷启动
-├── package.json
-└── public/             # 发布版本
-    └── clinn-v0.7.1/
-```
+AI 在对话中生成工具代码，通过 `save_tool` 持久化到 `~/.clinn/Tools/custom/`，下次启动自动加载。
 
 ---
 
 ## 配置
 
-编辑 `config.json`：
+编辑 `~/.clinn/config.json` 或对话内 `/api` 命令：
 
 ```json
 {
   "llm": {
-    "provider": "deepseek",
-    "apiKey": "YOUR_DEEPSEEK_API_KEY_HERE",
+    "apiKey": "YOUR_KEY",
     "baseURL": "https://api.deepseek.com/v1",
     "model": "deepseek-v4-pro",
-    "maxTokens": 8000,
+    "contextWindow": 131072,
+    "maxTokens": 16384,
     "temperature": 0.7
-  },
-  "memory": {
-    "maxHistory": 100,
-    "maxEntries": 800
-  },
-  "ui": {
-    "showLogo": true,
-    "dividerChar": "-"
   }
 }
 ```
 
 ---
 
-## 更新日志 (Changelog)
-
-### v0.7.9 — 版本查询
-
-- **`--version` / `-v`**：终端直接 `clinn --version` 查看版本
-- **`/version`**：对话内 `/version` 查看版本
-
-### v0.7.8 — Windows 兼容 & 权限修复
+## 更新日志
 
-- **bin 入口改为 `.js`**：`#!/usr/bin/env node` + `.js` 后缀，npm 自动生成跨平台 shim，解决 Windows 上 `不是内部或外部命令` 问题
-- **修复双重权限弹窗**：危险工具只弹一次 Y/N 确认
+### v0.9.0 — Ink TUI · 双级记忆 · Session 搜索
 
-### v0.7.1 — CLI 增强 & npm 发布
+- **Ink 7 全屏 TUI**：React 19 + Ink 7.0.5，左右分栏启动页，消息折叠，工具调用折叠/展开，颜色标记（红绿黄）
+- **双级记忆**：mem_rom（永久落盘）+ mem_ram（会话级），重启不丢
+- **Session 系统**：会话自动分组，全局全文搜索，历史回顾
+- **消息队列**：AI 忙时消息自动排队，可视队列
+- **Ctrl+C 中断**：不退出进程，中断执行或清空输入
+- **输入框字符计数**：长文本自动缩略显示末尾
+- **grep 升级**：ripgrep 优先，支持上下文行/files_only/count
+- **分隔线终端宽度对齐**，不再刷屏
 
-- **`/api` 命令**：直接在终端配置 API Key、API 地址、模型名称，无需编辑文件
-  - `/api` — 查看当前 API 设置（Key 脱敏显示）
-  - `/api key <KEY>` — 直接设置 API Key
-  - `/api url <URL>` — 切换 API 地址（兼容其他兼容接口）
-  - `/api model <MODEL>` — 切换模型
-- **npm 发布**：`npm install -g @ghenya/clinn` 全球安装，配置自动存 `~/.clinn/`
-- **历史/Mem/自定义工具路径统一到 `~/.clinn/`**
+### v0.8.0 — 上下文修复 · 语法校验 · 颜文字
 
-### v0.7.0 — 交互重构 & 稳定性
+- 上下文窗口 6K→105K (×17)，模型感知检测
+- Token 估算修正 (CJK ×0.8 + ASCII ×0.3)
+- 写文件后自动 node/py/json 语法校验
+- 动态颜文字引擎：关键词匹配，不再随机
+- Glob 纯 Node.js 跨平台，模板引擎 + 5 技能
 
-- **上下文监控三级预警**：90% 提示 / 95% 警告 / 不再自动压缩，用户自主 `/clear`
-- **工具执行静默化**：不再刷屏动画，只显示 `✓ tool_name` 完成标记
-- **思考动画**：braille spinner `⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏` 120ms 旋转指示推理状态
-- **修复死循环误判**：循环检测改为工具名+参数逐字比对，只有 300 次完全相同才拦截
-- **修复上下文百分比漂移**：统一用持久记忆计算，排除临时网页正文干扰
-- **全量对话历史**：`history-*.json` 保存完整工具调用链路
-- **web_search 切换 Bing**：cn.bing.com HTML 解析，国内可用
-- **虚拟浏览器**：browse_page 基于 puppeteer-core，反反爬
+### v0.7.0 — 交互重构 · npm 发布
 
-### v0.6.0 — 记忆系统
-
-- 对话记忆与历史文件持久化
-- `/history` 命令 + less 分页器浏览
-- 历史搜索功能
-- 表格结构转纯文本输出
-- 宁缺毋滥行宽控制
-
-### v0.5.0 — 首发
-
-- DeepSeek API 集成
-- 50+ 工具体系
-- 工具权限控制
-- 自定义工具持久化
-- install.sh / install.bat 一键安装
-- 流式响应输出
+- npm 发布：`npm install -g @ghenya/clinn`
+- `/api` 命令链式配置，上下文三级预警
+- web_search 切换 Bing，虚拟浏览器
 
 ---
 
-## 许可
-
 MIT License

package/Src/agent.cjs

@@ -2,7 +2,12 @@ const os = require("os");
 const LLMClient = require("./llm.cjs");
 const Tools = require("../Tools");
 const { ConversationMemory } = require("../Mem");
-const { saveTurn, searchHistory, getFileList, loadFileTurns } = require("../Mem/history");
+const {
+  saveTurn, searchHistory, getFileList, loadFileTurns,
+  startSession, endSession, listSessions, getSession,
+  loadSessionTurns, searchSessions, globalSearch,
+  migrateLegacySessions,
+} = require("../Mem/history");
 
 const MAX_ITERATIONS = 500;
 const MAX_TOOL_RESULT_CHARS = 3000;
@@ -84,6 +89,10 @@ class Agent {
     this.maxContextTokens = (config.llm?.contextWindow || getContextWindow(config.llm?.model)) * 0.8;
     this._lastToolCalls = [];
 
+    // session management
+    migrateLegacySessions();
+    this.sessionId = startSession();
+
     Tools.setTrusted(config.tools?.trustedTools || []);
     Tools.setPermissionCallback(async (name, args) => {
       if (callbacks.onPermission) return callbacks.onPermission(name, args);
@@ -98,10 +107,12 @@ class Agent {
     const self = this;
     const memTools = [
       "search_memory", "save_memory", "list_memory", "delete_memory",
+      "mem_rom", "mem_ram",
       "compress_context", "agent_self_invoke", "set_timer",
       "save_tool", "delete_tool_file", "list_saved_tools",
       "forget_conversation", "restart_session",
       "search_history", "list_history_files",
+      "list_sessions", "view_session", "search_sessions",
     ];
     for (const name of memTools) {
       const tool = Tools.getTool(name);
@@ -114,10 +125,16 @@ class Agent {
     switch (name) {
       case "search_memory":
         return this._fmtEntries(this.memory.searchEntries(args.query, args.limit || 5));
-      case "save_memory": {
+      case "save_memory":
+      case "mem_rom": {
+        const tags = args.tags ? args.tags.split(",").map((t) => t.trim()) : [];
+        const entry = this.memory.addRomEntry(args.content, tags);
+        return entry ? `[ROM] 已保存 #${entry.id}: ${entry.text}` : "[失败] 内容为空";
+      }
+      case "mem_ram": {
         const tags = args.tags ? args.tags.split(",").map((t) => t.trim()) : [];
-        const entry = this.memory.addEntry(args.content, tags);
-        return entry ? `[OK] 已保存 #${entry.id}: ${entry.text}` : "[失败] 内容为空";
+        const entry = this.memory.addRamEntry(args.content, tags);
+        return entry ? `[RAM] 已保存 #${entry.id}: ${entry.text}` : "[失败] 内容为空";
       }
       case "list_memory": {
         const all = this.memory.getAllEntries().slice(-(args.limit || 20));
@@ -131,7 +148,7 @@ class Agent {
         const compressed = this.memory.compressHistory();
         if (!compressed) return "[跳过] 对话太短";
         const summary = await this._summarize(compressed);
-        this.memory.addEntry(summary, ["auto-summary"]);
+        this.memory.addRamEntry(summary, ["auto-summary"]);
         this.memory.clear();
         return `[OK] 上下文已压缩, 摘要存入记忆: ${summary}`;
       }
@@ -174,16 +191,18 @@ class Agent {
           if (compressed) summary = await this._summarize(compressed);
         }
         this.memory.clear();
-        if (summary) { this.memory.addEntry(summary, ["auto-summary"]); }
+        if (summary) { this.memory.addRamEntry(summary, ["auto-summary"]); }
         return summary
           ? `[OK] 对话已遗忘, 摘要已保存: ${summary}`
           : "[OK] 对话历史已清空, 像全新对话一样";
       }
       case "restart_session": {
+        endSession(this.sessionId);
         this.memory.clear();
-        this.memory.clearEntries();
+        this.memory.clearRamEntries();
         this.llm.resetUsage();
-        return "[OK] 会话已完全重启: 历史+记忆+token计数均已重置. 可以开始全新任务.";
+        this.sessionId = startSession();
+        return "[OK] 会话已完全重启: 历史+记忆+token计数均已重置, 新session已创建. 可以开始全新任务.";
       }
       case "search_history": {
         const q = args.query || "";
@@ -199,6 +218,47 @@ class Agent {
         if (files.length === 0) return "(暂无历史对话文件)";
         return files.map((f) => `${f.file} | ${f.turns}轮 | ${f.size}KB | ${f.created.slice(0, 10)}`).join("\n");
       }
+      case "list_sessions": {
+        const sessions = listSessions(args.limit || 20);
+        if (sessions.length === 0) return "(暂无对话 session)";
+        const now = this.sessionId;
+        return sessions.map((s, i) => {
+          const marker = s.id === now ? " ◀ 当前" : "";
+          const status = s.status === "active" ? "●" : "○";
+          const date = s.started ? s.started.slice(0, 16) : "?";
+          return `${i + 1}. ${status} [${date}] ${s.title || "(无标题)"} | ${s.turnCount}轮${marker}`;
+        }).join("\n");
+      }
+      case "view_session": {
+        const sid = args.session_id || "";
+        if (!sid) return "[错误] 请提供 session_id (用 list_sessions 获取)";
+        const session = getSession(sid);
+        if (!session) return `[未找到] session ${sid}`;
+        const turns = loadSessionTurns(sid, args.limit || 50);
+        if (turns.length === 0) return `[空] session ${sid} 中没有对话轮次`;
+        const header = [
+          `=== Session: ${session.title || "(无标题)"} ===`,
+          `ID: ${session.id}  |  开始: ${session.started?.slice(0, 16) || "?"}  |  共 ${session.turnCount} 轮`,
+          ``,
+        ];
+        const body = turns.map((t, i) => {
+          return `[${i + 1}] ${t.time?.slice(0, 16) || "?"}\n` +
+            `  > 用户: ${t.user ? t.user.slice(0, 200) : ""}\n` +
+            `  < 回复: ${t.assistant ? t.assistant.slice(0, 300) : ""}`;
+        });
+        return header.join("\n") + "\n" + body.join("\n\n");
+      }
+      case "search_sessions": {
+        const q = args.query || "";
+        if (!q.trim()) return "[错误] 请提供搜索关键词";
+        const results = globalSearch(q, args.limit || 10);
+        if (results.length === 0) return `[无匹配] 在所有历史 session 中未找到 "${q}"`;
+        return results.map((r, i) => {
+          const date = r.sessionStarted ? r.sessionStarted.slice(0, 16) : "?";
+          const previews = r.topMatches.map((m) => `    · ${m.user.slice(0, 80)}`).join("\n");
+          return `${i + 1}. [${date}] ${r.sessionTitle} | 匹配 ${r.matchCount} 处 | 得分 ${r.totalScore}\n${previews}`;
+        }).join("\n\n");
+      }
       default:
         return `[未知内部工具] ${name}`;
     }
@@ -219,7 +279,10 @@ class Agent {
 
   _fmtEntries(entries) {
     if (!entries || entries.length === 0) return "(无记忆条目)";
-    return entries.map((e) => `#${e.id} [${e.tags?.join(",") || "-"}] ${e.text}`).join("\n");
+    return entries.map((e) => {
+      const tag = (e._type === "ram") ? "[RAM]" : "[ROM]";
+      return `${tag} #${e.id} [${e.tags?.join(",") || "-"}] ${e.text}`;
+    }).join("\n");
   }
 
   refreshTools() {
@@ -326,7 +389,7 @@ class Agent {
     this.memory.addAssistant(finalResponse);
 
     try {
-      saveTurn(userMessage, finalResponse, process.cwd(), allMsgs);
+      saveTurn(userMessage, finalResponse, process.cwd(), allMsgs, this.sessionId);
     } catch (_) {}
 
     if (opts._noAutoSave) return finalResponse;
@@ -341,7 +404,7 @@ class Agent {
           ];
           const res = await this.llm.chat(msgs);
           const habit = res.choices?.[0]?.message?.content?.trim().slice(0, 100);
-          if (habit) this.memory.addEntry(habit, ["habit"]);
+          if (habit) this.memory.addRamEntry(habit, ["habit"]);
         }
       } catch (_) {}
     });

package/Src/index.js

@@ -4,7 +4,7 @@ const readline = require("readline");
 const { spawn } = require("child_process");
 const Agent = require("./agent");
 const Tools = require("../Tools");
-const { listRecentTurns, searchHistory, getFileList, loadFileTurns } = require("../Mem/history");
+const { listRecentTurns, searchHistory, getFileList, loadFileTurns, listSessions, getSession, loadSessionTurns, globalSearch, endSession, startSession } = require("../Mem/history");
 
 const C = {
   reset: "\x1b[0m",
@@ -345,6 +345,8 @@ function showHelp() {
     ["/memory_clear", "清空所有记忆"], ["/compress", "手动压缩上下文"],
     ["/history [n]", "查看最近n条历史对话"], ["/history files", "查看历史文件列表"],
     ["/history search <q>", "搜索历史对话"], ["/history read <f>", "读取文件含完整工具调用"],
+    ["/sessions [n]", "列出对话session"], ["/session <id>", "查看某个session"],
+    ["/session_search <q>", "全局搜索session"],
     ["/tool_save <name>", "持久化保存工具"], ["/tool_list_saved", "列出持久化工具"],
     ["/tool_del_saved <name>", "删除持久化工具"],
     ["/trusted", "查看受信任工具"], ["/trust <name>", "永久信任工具"],
@@ -369,7 +371,7 @@ function showStatus() {
   console.log(`  模型: ${C.bold}${config.llm.model}${C.reset}  温度: ${config.llm.temperature}`);
   console.log(`  Tokens 累计: ${emoji("tokenIn")}${C.cyan}${usage.prompt}${C.reset}  ${emoji("tokenOut")}${C.magenta}${usage.completion}${C.reset}`);
   console.log(`  上下文使用: ${ctxBar(ctxPct)}`);
-  console.log(`  记忆: ${mem.entries || 0}/${mem.maxEntries || config.memory.maxEntries} 条目, 历史 ${mem.historyMessages || 0} 条`);
+  console.log(`  记忆: ROM${mem.romEntries || mem.entries || 0} RAM${mem.ramEntries || 0}  · 历史 ${mem.historyMessages || 0} 条`);
   const tools = Tools.listToolNames();
   console.log(`  工具: ${tools.length} 个 — ${tools.slice(0, 8).join(", ")}${tools.length > 8 ? " ..." : ""}`);
   console.log(div("="));
@@ -436,8 +438,10 @@ async function handleSlashCommand(input) {
       console.log(C.dim + `再见~ ${emoji("done")}` + C.reset);
       process.exit(0);
     case "reset":
+      endSession(agent.sessionId);
       agent.reset();
-      console.log(`${C.green}对话已重置${C.reset}`);
+      agent.sessionId = startSession();
+      console.log(`${C.green}对话已重置, 新 session 已创建${C.reset}`);
       break;
     case "tools": {
       const names = Tools.listToolNames();
@@ -563,7 +567,7 @@ async function handleSlashCommand(input) {
     case "memory": {
       const s = agent.memory.stats();
       console.log(div());
-      console.log(`  条目: ${s.entries}/${s.maxEntries}  历史消息: ${s.historyMessages}`);
+      console.log(`  条目: ROM${s.romEntries || s.entries} RAM${s.ramEntries || 0}  历史消息: ${s.historyMessages}`);
       console.log(div());
       break;
     }
@@ -572,7 +576,10 @@ async function handleSlashCommand(input) {
       const entries = agent.memory.getAllEntries().slice(-n);
       if (entries.length === 0) { console.log("(无记忆条目)"); break; }
       console.log(div());
-      for (const e of entries) console.log(`  ${C.yellow}#${e.id}${C.reset} ${C.dim}[${e.tags?.join(",") || "-"}]${C.reset} ${e.text}`);
+      for (const e of entries) {
+        const tag = e._type === "ram" ? `${C.yellow}[RAM]${C.reset}` : `${C.green}[ROM]${C.reset}`;
+        console.log(`  ${tag} ${C.yellow}#${e.id}${C.reset} ${C.dim}[${e.tags?.join(",") || "-"}]${C.reset} ${e.text}`);
+      }
       console.log(div());
       break;
     }
@@ -581,7 +588,10 @@ async function handleSlashCommand(input) {
       const results = agent.memory.searchEntries(rest, 10);
       if (results.length === 0) { console.log(`无匹配: ${rest}`); break; }
       console.log(div());
-      for (const e of results) console.log(`  ${C.yellow}#${e.id}${C.reset} ${e.text}`);
+      for (const e of results) {
+        const tag = e._type === "ram" ? `${C.yellow}[RAM]${C.reset}` : `${C.green}[ROM]${C.reset}`;
+        console.log(`  ${tag} ${C.yellow}#${e.id}${C.reset} ${e.text}`);
+      }
       console.log(div());
       break;
     }
@@ -593,8 +603,8 @@ async function handleSlashCommand(input) {
       break;
     }
     case "memory_clear":
-      agent.memory.clearEntries();
-      console.log(`${C.green}所有记忆条目已清空${C.reset}`);
+      agent.memory.clearAllEntries();
+      console.log(`${C.green}所有记忆条目已清空 (ROM+RAM)${C.reset}`);
       break;
     case "history": {
       const subCmd = rest ? rest.split(/\s+/)[0] : "";
@@ -662,6 +672,68 @@ async function handleSlashCommand(input) {
       await pipeToPager(wrapped);
       break;
     }
+    case "sessions": {
+      const limit = rest ? parseInt(rest, 10) || 20 : 20;
+      const sessions = listSessions(limit);
+      if (sessions.length === 0) { console.log("(暂无对话 session)"); break; }
+      let out = `${C.bold + C.cyan}对话 Sessions${C.reset}  (${sessions.length})\n` + div() + "\n";
+      for (const [i, s] of sessions.entries()) {
+        const marker = s.status === "active" ? `${C.green}●${C.reset}` : `${C.dim}○${C.reset}`;
+        const active = s.status === "active" ? ` ${C.green}◀ 当前${C.reset}` : "";
+        out += `  ${String(i + 1).padStart(2)}. ${marker} [${(s.started || "?").slice(0, 16)}] ${s.title || "(无标题)"} | ${s.turnCount}轮${active}\n`;
+      }
+      out += "\n" + div() + `\n用 ${C.cyan}/session <编号>${C.reset} 查看详情, ${C.yellow}/session_search <关键词>${C.reset} 搜索`;
+      console.log(out);
+      break;
+    }
+    case "session": {
+      if (!rest) { console.log(`用法: /session <session_id 或列表序号>\n请先用 /sessions 查看列表`); break; }
+      const sessions = listSessions(999);
+      let sid = rest.trim();
+      if (/^\d+$/.test(sid)) {
+        const idx = parseInt(sid) - 1;
+        if (idx < 0 || idx >= sessions.length) { console.log(`序号超出范围 (1-${sessions.length})`); break; }
+        sid = sessions[idx].id;
+      }
+      const session = getSession(sid);
+      if (!session) { console.log(`未找到 session: ${sid}`); break; }
+      const turns = loadSessionTurns(sid, 30);
+      let out = `${C.bold + C.cyan}=== ${session.title || "(无标题)"} ===${C.reset}\n`;
+      out += `ID: ${C.dim}${session.id}${C.reset}  |  ${(session.started || "?").slice(0, 16)}  |  ${session.turnCount}轮\n` + div() + "\n";
+      if (turns.length === 0) { out += "(这个 session 暂无对话轮次)\n"; }
+      else {
+        for (const [i, t] of turns.entries()) {
+          out += `${C.yellow}[${i + 1}] ${(t.time || "?").slice(0, 16)}${C.reset}\n`;
+          if (t.cwd) out += `  ${C.dim}${t.cwd}${C.reset}\n`;
+          out += `  ${C.cyan}▸${C.reset} ${(t.user || "").slice(0, 400)}\n`;
+          out += `  ${C.green}◂${C.reset} ${(t.assistant || "").slice(0, 400)}\n\n`;
+        }
+        out += `(共 ${turns.length} 轮, 显示最近 30 轮)`;
+      }
+      out += "\n" + div();
+      await pipeToPager(out);
+      break;
+    }
+    case "session_search": {
+      if (!rest) { console.log("用法: /session_search <关键词> [数量]\n在整个历史中搜索相关 session"); break; }
+      const parts = rest.trim().split(/\s+/);
+      const maybeNum = parseInt(parts[parts.length - 1], 10);
+      const limit = !isNaN(maybeNum) ? maybeNum : 10;
+      const query = !isNaN(maybeNum) ? parts.slice(0, -1).join(" ") : rest.trim();
+      const results = globalSearch(query, limit);
+      if (results.length === 0) { console.log(`全史搜索未找到 "${query}"`); break; }
+      let out = `${C.bold + C.yellow}搜索: "${query}"${C.reset}  — ${results.length} 个 session\n` + div() + "\n";
+      for (const [i, r] of results.entries()) {
+        out += `${C.yellow}${i + 1}.${C.reset} [${(r.sessionStarted || "?").slice(0, 16)}] ${r.sessionTitle} | ${r.matchCount}处 | 得分${r.totalScore}\n`;
+        for (const m of r.topMatches) {
+          out += `  ${C.dim}·${C.reset} ${m.user.slice(0, 100)}\n`;
+        }
+        out += "\n";
+      }
+      out += div() + `\n用 ${C.cyan}/session <编号>${C.reset} 查看详情`;
+      console.log(out);
+      break;
+    }
     case "compress": {
       console.log(`${C.yellow}正在压缩上下文...${C.reset}`);
       const result = await agent._handleAgentTool("compress_context", {});
@@ -963,6 +1035,7 @@ async function main() {
         `${C.cyan}tools${C.reset}`, `${C.cyan}status${C.reset}`, `${C.cyan}ctx${C.reset}`,
         `${C.cyan}temp${C.reset}`, `${C.cyan}token${C.reset}`,
         `${C.cyan}compress${C.reset}`, `${C.cyan}memory${C.reset}`, `${C.cyan}history${C.reset}`,
+        `${C.cyan}sessions${C.reset}`, `${C.cyan}session_search${C.reset}`,
         `${C.cyan}tool_save${C.reset}`, `${C.cyan}tool_del${C.reset}`,
       ];
       process.stdout.write("\n" + C.dim + menu.join("  ") + C.reset + "\n");