mocode-ai 0.1.3 → 0.1.5

package/dist/agent/mode.js

@@ -0,0 +1,46 @@
+/**
+ * agent 模式的共享状态(零依赖纯叶子)。
+ *
+ * 把 `agentMode` 从 repl 的模块变量提到这里,让三方都能用、且不破坏依赖单向:
+ *  - `tools/builtins/switch-mode.ts` 写它(setAgentMode)——LLM 在 agent 循环里自切 plan↔auto。
+ *  - `agent/index.ts` 每步读它(getAgentMode)——决定 chat() 用全量 chatTools 还是 planChatTools 只读子集,
+ *    以及串行分支的 plan 防御 backstop。这样 LLM 中途切模式后,下一次 chat() 立即看到新工具集。
+ *  - `repl/index.ts` 读写它 + 注册 onModeChange 监听器(做 applyMode 重写 history[0] + refreshStatusBase
+ *    刷状态行 modeTag)。
+ *
+ * 依赖方向无环:本模块不 import 任何业务模块。`agent/index → tools/registry → tools/builtins/switch-mode
+ * → agent/mode` 链终点是本叶子,不回到 agent/index。`tools → agent/mode` 与既有 `tools → ui`(ask-human)、
+ * `tools → rollback`(registry)同性质——都是引叶子。
+ *
+ * listener 同步触发:setAgentMode 在变更模式后同步调 listener(无 async)。switch_mode 工具在 executeTool
+ * 内调 setAgentMode → listener 同步 applyMode(重写 history[0])+ refreshStatusBase;execute 返回字符串后,
+ * agent 串行分支继续,下一步 chat() 读到新模式 + 新系统提示,一致。
+ */
+let currentMode = 'auto';
+let listener = null;
+/** 当前 agent 模式。auto=全工具执行;plan=只读探查 + 产出计划(写盘/命令/记忆写入工具被 schema 剔除)。 */
+export function getAgentMode() {
+    return currentMode;
+}
+/**
+ * 设置 agent 模式。同模式 no-op(不触发 listener)。变更时同步触发 onModeChange 注册的监听器
+ * (repl 在 startRepl 注册:applyMode 重写 history[0] + refreshStatusBase 刷状态行)。
+ * 返回之前的模式,供调用方(如 runAgent 中断恢复)还原。
+ */
+export function setAgentMode(m) {
+    const prev = currentMode;
+    if (prev === m)
+        return prev;
+    currentMode = m;
+    try {
+        listener?.(m);
+    }
+    catch {
+        // listener 不应抛(applyMode/refreshStatusBase 都不抛);兜底,不阻断工具执行。
+    }
+    return prev;
+}
+/** 注册模式变更监听器(单一,后注册覆盖先注册)。repl 在 startRepl 启动时注册一次。 */
+export function onModeChange(cb) {
+    listener = cb;
+}

package/dist/agent/spawn.js

@@ -0,0 +1,123 @@
+// 子 agent 封装:runAgentCore + 静默 hooks。独立 history / 可受限工具子集 / 低步数上限。
+// 供 task 工具(主 agent 派生子任务)调用——子 agent 的最终摘要回灌主 history。
+//
+// 与主 agent 的区别:
+//  - 不写主屏(layout.contentWrite):中间过程(流式正文 / 工具头 / diff)缓冲到内部字符串,
+//    结束返回给 task 工具(task 把它当 tool 结果回灌主 history,主 agent 据此继续)。
+//  - 独立 history:不共享主对话,避免子任务的工具噪声污染主上下文。
+//  - 系统提示复用主 agent 组装链(config.systemPrompt + memory 段 + skills 段)+ 子 agent 角色后缀。
+//  - 工具子集:按白名单从 chatTools 过滤;无白名单 = 全量(但 task 工具调用方通常会限定只读)。
+//  - 不调 beginTurn(不进主回滚链);但文件 mutation 仍经 executeTool→recordMutation,
+//    归入当前主轮次(语义:子 agent 的改动属于当前主轮,可随 /rollback 一起撤销)。
+//  - 步数上限默认更低(config.subAgentMaxSteps ?? 50),防子任务失控耗尽配额。
+//  - 中断透传:opts.signal(主 agent 的 abort signal)透传给 runAgentCore → chat/executeTool,
+//    主 Ctrl+C 树杀子 agent(chat 流式 abort + run_command/web_fetch 即时取消)。
+//  - 逻辑隔离(回滚):skipRollback=true,子 agent 的 write_file/edit_file 改动不进主回滚快照链,
+//    主 /rollback 不撤销子 agent 改动(靠 git 兜底)。子 agent 与主 agent 共享 cwd(文件改动可见)。
+import { chatTools } from '../llm/index.js';
+import { config } from '../config/index.js';
+import { effectiveSystemPrompt } from '../skills/index.js';
+import { buildMemorySection, buildMemoryIndexSection } from '../memory/index.js';
+import { ui } from '../ui/theme.js';
+import { runAgentCore } from './core.js';
+import { summarizeToolCall, summarizeToolResult, truncateDisplay } from '../ui/render.js';
+/** 子 agent 系统提示后缀:角色与约束。 */
+const SUBAGENT_SUFFIX = `
+
+## ⛯ SUB-AGENT MODE (you are a sub-agent)
+You are a sub-agent spawned by the main agent to handle an isolated sub-task. You have your own conversation history (independent of the main thread).
+- Focus solely on the assigned sub-task. Do NOT attempt to call the "task" tool (no recursive spawning).
+- Use the tools available to you to complete the sub-task.
+- When done, your final text reply will be returned to the main agent as a summary — make it concise and actionable: what you did, key findings, files changed, and any issues. The main agent will decide the next step based on your summary.`;
+/**
+ * 派生一个子 agent 执行独立子任务。
+ *
+ * 行为:
+ *  - 构造独立 history:[{system: 主系统提示 + SUBAGENT_SUFFIX + 自定义后缀}, {user: prompt}]
+ *  - 工具子集:按 opts.tools 白名单过滤 chatTools;无白名单 = 全量。
+ *  - 静默 hooks:流式正文 / 工具头 / 结果缓冲到 transcript;不写主屏(layout)。
+ *  - 返回 { summary, completed, transcript }。summary 给 task 工具回灌主 history。
+ *
+ * 中断:opts.signal 透传给子 runAgentCore——主 Ctrl+C 树杀子 agent(chat abort + 工具 abort)。
+ * 子 agent 跑在主 signal 下,主 abort 即子 abort;子 agent 的 abortRestore 还原子 history + 模式。
+ */
+export async function spawnAgent(opts) {
+    const maxSteps = opts.maxSteps ?? config.subAgentMaxSteps ?? 50;
+    // 构造子 agent 系统提示:复用主 agent 组装链 + 子 agent 角色后缀 + 自定义后缀。
+    const systemPrompt = effectiveSystemPrompt(config.systemPrompt +
+        buildMemorySection() +
+        buildMemoryIndexSection() +
+        SUBAGENT_SUFFIX +
+        (opts.systemPromptSuffix ? `\n\n${opts.systemPromptSuffix}` : ''));
+    // 工具子集:白名单过滤。无白名单 = 全量 chatTools,但始终剔除 task(防递归派生)。
+    let toolsOverride;
+    if (opts.tools && opts.tools.length > 0) {
+        const allow = new Set(opts.tools);
+        toolsOverride = chatTools.filter((t) => allow.has(t.function.name) && t.function.name !== 'task');
+    }
+    else {
+        toolsOverride = chatTools.filter((t) => t.function.name !== 'task');
+    }
+    // 独立 history(子 agent 自己持有,不共享主对话)。
+    // 只塞 system;user 消息由 runAgentCore 的 userInput 参数 push(与主 agent 一致)。
+    const history = [
+        { role: 'system', content: systemPrompt },
+    ];
+    // 静默 hooks:缓冲中间过程到 transcript,不写主屏。
+    let transcript = '';
+    const buf = [];
+    const writeBuf = (s) => {
+        buf.push(s);
+        transcript += s;
+    };
+    let lastChar = '';
+    const hooks = {
+        onText: (s) => {
+            writeBuf(s); // 缓冲流式正文(无 markdown 渲染,原始文本)
+            if (s)
+                lastChar = s[s.length - 1];
+        },
+        onToolCall: (name) => {
+            if (lastChar && lastChar !== '\n') {
+                writeBuf('\n');
+                lastChar = '\n';
+            }
+            // 子 agent 静默:不启 spinner(name 参数仅主 agent 用)
+        },
+        onToolHeader: (tc) => {
+            const summary = summarizeToolCall(tc.name, tc.arguments);
+            writeBuf(`  ● ${tc.name}  ${summary}\n`);
+        },
+        onToolResult: (tc, output) => {
+            const preview = summarizeToolResult(tc.name, output);
+            if (preview)
+                writeBuf(`  ↳ ${preview}\n`);
+        },
+        onTextEnd: () => {
+            if (lastChar && lastChar !== '\n') {
+                writeBuf('\n');
+                lastChar = '\n';
+            }
+        },
+        onToolBatchEnd: () => writeBuf('\n'),
+        onNoReply: () => writeBuf(`${ui.dim}(无回复)${ui.reset}\n`),
+        onMaxSteps: () => writeBuf(`  ● 达到最大步数(${maxSteps}),子 agent 停止。\n`),
+        onDone: (elapsedMs) => writeBuf(`  ✻ 子 agent 耗时 ${(elapsedMs / 1000).toFixed(1)}s\n`),
+        // onStepStart / onChatDone / onToolStart / onToolDone / onAbort:子 agent 静默,无需 spinner / 中断渲染。
+        // abort 还原(history 还原 + 模式还原)由 core 的 abortRestore 处理,hooks 只管展示。
+    };
+    const result = await runAgentCore({
+        history,
+        userInput: opts.prompt,
+        signal: opts.signal, // 主 Ctrl+C 树杀子 agent(chat abort + 工具 abort)
+        hooks,
+        maxSteps,
+        toolsOverride,
+        skipRollback: true, // 逻辑隔离:子 agent 文件改动不进主回滚快照链,主 /rollback 不撤销(靠 git 兜底)
+    });
+    return {
+        summary: result.finalText,
+        completed: result.completed,
+        transcript: truncateDisplay(transcript, 20000), // 防过大;调试用,回灌主 history 的是 summary 不是 transcript
+    };
+}

package/dist/commands/config.js

@@ -1,31 +1,19 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
 import * as readline from 'node:readline';
-import dotenv from 'dotenv';
-/** ~/.mocode/config:全局配置(与 ~/.mocode/skills 同目录,任意终端 / 任意目录生效)。 */
-const CONFIG_PATH = path.join(os.homedir(), '.mocode', 'config');
+import { CONFIG_PATH, readConfigFile, writeConfigKeys } from '../config/file.js';
 function ask(rl, q) {
     return new Promise((resolve) => {
         rl.question(q, (ans) => resolve(ans.trim()));
     });
 }
-/** 读已有配置(没有则空对象),用于回填默认值与保留其它键。 */
-function readExisting() {
-    try {
-        return dotenv.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
-    }
-    catch {
-        return {};
-    }
-}
 /**
  * 首跑配置向导:交互填 LLM_BASE_URL / LLM_API_KEY / LLM_MODEL,写 ~/.mocode/config。
- * 只交互三键、保留文件里其它键(MAX_TOKENS / CONTEXT_WINDOW_TOKENS 等)。prompt 全纯文本(readline 光标按字符算,不能含 ANSI)。
- * 由 index.ts 在 `mocode config` 时动态加载,故不 import config/index.ts(避免缺配置时 requireEnv 直接退出)。
+ * 只交互三键、保留文件里其它键(MAX_TOKENS / CONTEXT_WINDOW_TOKENS / MOCODE_THEME 等)。
+ * prompt 全纯文本(readline 光标按字符算,不能含 ANSI)。
+ * 由 index.ts 在 `mocode config` 时动态加载,故不 import config/index.ts(避免缺配置时 requireEnv
+ * 直接退出);只 import config/file.ts(纯 I/O 叶子,无 env 校验 / process.exit)。
  */
 export async function runConfigWizard() {
-    const cur = readExisting();
+    const cur = readConfigFile();
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     console.log(`mocode 配置向导 — 写入 ${CONFIG_PATH}(Ctrl+C 取消)\n`);
     const baseURLIn = await ask(rl, `LLM_BASE_URL${cur.LLM_BASE_URL ? ` [${cur.LLM_BASE_URL}]` : ''}(如 https://open.bigmodel.cn/api/v3): `);
@@ -46,16 +34,10 @@ export async function runConfigWizard() {
     const model = modelIn || cur.LLM_MODEL || 'gpt-4o-mini';
     rl.close();
     // 合并:保留其它键,只覆盖三键。
-    const merged = {
-        ...cur,
+    writeConfigKeys({
         LLM_BASE_URL: baseURL,
         LLM_API_KEY: apiKey,
         LLM_MODEL: model,
-    };
-    const body = Object.entries(merged)
-        .map(([k, v]) => `${k}=${v}`)
-        .join('\n');
-    fs.mkdirSync(path.dirname(CONFIG_PATH), { recursive: true });
-    fs.writeFileSync(CONFIG_PATH, `${body}\n`, 'utf8');
+    });
     console.log(`\n已写入 ${CONFIG_PATH}。现在运行 \`mocode\` 即可启动(任意目录、任意终端)。`);
 }

package/dist/config/file.js

@@ -0,0 +1,48 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import dotenv from 'dotenv';
+/**
+ * ~/.mocode/config 全局 dotenv 配置的读写叶子(纯 node:fs / node:os / node:path + dotenv)。
+ *
+ * 独立于 `config/index.ts`——**不**触发 requireEnv / process.exit,故 `commands/config.ts`
+ * (首跑向导,刻意不 import config/index.ts)与 `repl/index.ts`(`/theme` 持久化)都能安全共享。
+ * 主题等 UI 偏好走 `updateConfigKey` 单键写;向导多键一次性写走 `writeConfigKeys`。
+ */
+/** ~/.mocode/config:全局配置(与 ~/.mocode/skills 同目录,任意终端 / 任意目录生效)。 */
+export const CONFIG_PATH = path.join(os.homedir(), '.mocode', 'config');
+/** 读已有配置(没有则空对象),用于回填默认值与保留其它键。 */
+export function readConfigFile() {
+    try {
+        return dotenv.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * 读-合并-写:把 entries 覆盖进 ~/.mocode/config,保留文件里其它键。
+ * mkdirSync 兜底(首跑无 ~/.mocode)。不吞 I/O 异常——向导路径让其抛(与历史行为一致);
+ * UI 偏好路径用 `updateConfigKey`(自带 try/catch 静默)。
+ */
+export function writeConfigKeys(entries) {
+    const merged = { ...readConfigFile(), ...entries };
+    const body = Object.entries(merged)
+        .map(([k, v]) => `${k}=${v}`)
+        .join('\n');
+    fs.mkdirSync(path.dirname(CONFIG_PATH), { recursive: true });
+    fs.writeFileSync(CONFIG_PATH, `${body}\n`, 'utf8');
+}
+/**
+ * 单键持久化(主题等 UI 偏好):写失败静默——下次启动读不到则回退默认,不阻断 REPL。
+ * 注意:shell env 设了同名键时,`config/index.ts` 的 loadEnvFiles 只 backfill undefined 的
+ * process.env,故文件写对**下次启动**可能被 shell 盖——调用方据此给 dim 警告。
+ */
+export function updateConfigKey(key, value) {
+    try {
+        writeConfigKeys({ [key]: value });
+    }
+    catch {
+        // 写失败不阻断(UI 偏好)
+    }
+}

package/dist/config/index.js

@@ -28,6 +28,8 @@ function loadEnvFiles() {
             process.env[k] = v;
     }
 }
+// 在 loadEnvFiles 回填前捕获:MOCODE_THEME 是否由 shell 设置(决定 /theme 写文件是否下次启动生效)。
+const themeFromShell = process.env.MOCODE_THEME !== undefined;
 loadEnvFiles();
 function requireEnv(key) {
     const v = process.env[key];
@@ -37,33 +39,79 @@ function requireEnv(key) {
     }
     return v;
 }
-const SYSTEM_PROMPT = `你是 mocode,一个终端编码 agent。你以"思考 → 调用工具 → 观察结果 → 再思考"的循环完成编程任务,直到问题解决。面向中文用户,回复用中文。
+const PLATFORM_NOTE = (() => {
+    if (process.platform === 'win32') {
+        return `## Environment (Windows)
+- You are on Windows; run_command runs commands via cmd.exe (/c). Unix shell builtins are NOT available here.
+- Windows equivalents: which→where, cat→type, ls→dir, rm→del/rd, cp→copy, mv→move. cmd.exe uses %VAR% (not $VAR); pipes (|) and redirects (>, >>) work, but no $(...) command substitution or backticks.
+- head/tail/find/grep/sed have no cmd.exe equivalent — use the dedicated tools (read_file for head/tail, glob for find, grep for grep), or invoke PowerShell via run_command if you need more.
+- Prefer the dedicated tools (read_file/glob/grep) over shell equivalents — they're cross-platform and already wired in.`;
+    }
+    if (process.platform === 'darwin') {
+        return `## Environment (macOS)
+- You are on macOS; run_command runs via bash -c (user default shell may be zsh). BSD coreutils, not GNU.
+- Pitfalls: sed -i needs an empty backup-ext arg (sed -i '' 's/x/y/' file); grep -P unavailable (use grep -E or the grep tool); find/readlink/date are BSD variants; readlink -f unsupported (use realpath, or greadlink -f if GNU coreutils installed via brew).
+- Prefer the dedicated tools (read_file/glob/grep) over shell equivalents — they sidestep BSD/GNU differences.`;
+    }
+    return `## Environment (Linux/Unix)
+- You are on ${process.platform}; run_command runs via bash -c. GNU coreutils — standard POSIX/GNU shell syntax is safe.
+- Still prefer the dedicated tools (read_file/glob/grep) over hand-rolled shell where they fit — they avoid quoting pitfalls and are already wired in.`;
+})();
+const SYSTEM_PROMPT = `You are mocode, a terminal coding agent. You complete programming tasks through a "think → call tool → observe result → think again" loop until the problem is solved. Reply to the user in Chinese.
+
+${PLATFORM_NOTE}
+
+## Workflow
+- Understand before acting: when unsure about requirements or code state, explore first; don't assume.
+- Small steps: break tasks into verifiable sub-steps. Before each step, think clearly about what to change and why.
+- Verify after change: run typecheck / tests / build via run_command to confirm it works. Never claim done without verification.
 
-## 工作流
-- 先理解再动手:不确定需求或代码现状时,先 read_file / grep / glob 探索,不凭空假设。
-- 小步推进:任务拆成可验证的子步骤,每步动手前想清楚改什么、为什么。
-- 改完即验证:用 run_command 跑 typecheck / 测试 / 构建确认有效,未验证不声称完成。
+## Tool Guidelines
+- See each tool's own description for parameters and usage; this section covers selection strategy and pitfalls only.
+- **Prefer codegraph for code exploration**: when understanding/locating code, tracing call chains, or assessing impact of changes, if a .codegraph/ index exists, use the codegraph tool first (explore to query by question, node to look up a single symbol) — it returns relevant source + call paths in one shot, more accurate and economical than piecing together via read_file/grep. Fall back to read_file / grep / glob only when codegraph is unavailable (no index), misses, you need to see just-changed content, or you're editing a single known small file. Build the index first with \`codegraph init\` if none exists.
+- Before editing code, read_file to confirm actual content (with line numbers); don't guess from memory.
+- For local edits use edit_file: old_string must be unique and match exactly (including indentation/newlines); include surrounding context lines to ensure uniqueness. Use write_file for new files or full rewrites.
+- Use glob to find file paths, grep to search content; don't use run_command to pipe cat / sed / find / grep.
+- run_command runs per platform (cmd on Windows, bash elsewhere); state intent before running commands with side effects (deleting files, installing packages, git push, resets, etc.).
+- Use web_search for information beyond training data (new versions, news, real-time data, latest APIs); don't answer potentially outdated info from memory.
+- Use web_fetch to read a specific URL (a link from search results, or a URL given by the user); it only fetches static HTML — if a JS-rendered page yields no body, switch to web_search (its results include cleaned body text).
+- Call ask_human when you hit a decision point requiring user input (multiple implementation approaches, unclear intent, or needing extra info to proceed) — list options for the user to pick (they can also choose "custom input" to answer freely). Don't call it frequently when the task is clear and you can decide yourself; if the user cancels, switch approach or proceed with available info — don't re-ask the same question.
 
-## 工具准则
-- 参数与用法见各工具自带说明;这里只讲选择策略与易踩坑。
-- 改代码前先 read_file 确认实际内容(带行号),不凭记忆猜。
-- 局部改用 edit_file:old_string 须唯一且精确匹配(含缩进/换行),多带上下文行确保唯一;新建或整体重写用 write_file。
-- 找路径用 glob,找内容用 grep;不要用 run_command 拼 cat / sed / find / grep。
-- run_command 按平台执行(Win 用 cmd、其他用 bash);有副作用的命令(删文件、装包、git push、重置等)执行前先简述意图。
-- 需要训练数据之外的最新信息(新版本、新闻、实时数据、最新 API)时用 web_search 联网搜索,不要凭记忆答可能过时的内容。
-- 要读取某个具体 URL 的内容(搜索结果里的链接、用户给的 URL)时用 web_fetch 抓取;它只抓静态 HTML,JS 渲染页面拿不到正文时改用 web_search(其结果自带清洗后的正文)。
+## Failure Handling
+- Tools return errors as strings (edit_file no match or non-unique, run_command non-zero exit, etc.). Analyze the root cause, adjust, then retry — don't resend the same call verbatim.
+- When a command errors, read the actual output before judging; don't skip it.
 
-## 失败处理
-- 工具以字符串返回错误(edit_file 未匹配或不唯一、run_command 非零退出码等)。先分析根因,调整后重试,不要原样重发同一条调用。
-- 命令报错时把真实输出读进去再判断,别跳过。
+## Safety & Boundaries
+- Confirm with the user before irreversible or outward-facing operations (delete, overwrite existing files, push, request external services), unless explicitly authorized.
+- Operate only within authorized scope; when unsure, ask — don't guess.
 
-## 安全与边界
-- 不可逆或外向操作(删除、覆盖既有文件、推送、请求外部服务)执行前向用户确认,除非已获明确授权。
-- 只在授权范围内操作;不确定就问,别猜。
+## Memory (cross-session long-term facts)
+- A "memory index" (id/title/summary only) is injected into the system prompt. Retrieve full body via memory_search (pass id or keyword); use memory_list to see the entire index.
+- Store non-obvious, cross-session-useful facts/decisions/pitfalls (architecture conventions, gotchas, user preferences, decisions made) with memory_save — only long-term stable items, not current bugs / temp files / undecided TODOs.
+- If an existing memory is outdated or contradicts new facts, correct it in-place with memory_update(id, …) (don't create a duplicate); archive clearly-stale ones with memory_forget(id).
+- Before saving, memory_search to check for an existing similar entry to avoid duplicates. Better to store less than to store trivially correct information.
+- A background reflection pass periodically mines and organizes memories from the session (no manual action needed), but key facts you proactively save are more reliable.
+
+## Plan vs Auto modes
+- Default is AUTO mode: you research and execute with all tools (read/edit/run_command/memory/web/skills).
+- For complex or multi-step tasks, the user may switch to PLAN mode (Shift+Tab): your editing/command/memory-write tools are then removed from your tool list, and you must research with read-only tools only and produce a step-by-step plan (no execution). On approval the session returns to auto mode to execute the plan.
+
+## Termination & Reporting
+- Stop immediately when no more tools are needed; give conclusions directly.
+- Report honestly: say success when successful, say where you're stuck when failing, and mention anything skipped. Reference code in "path:line" format (e.g., src/index.ts:42). Keep it concise.`;
+/**
+ * plan 模式追加到系统提示末尾的指令(切到 plan 模式时由 repl 拼进 history[0])。
+ * 与 SYSTEM_PROMPT 同语种(英文),指示:只读探查、产出步骤化计划、不执行、审批后回 auto。
+ */
+export const PLAN_MODE_SUFFIX = `
 
-## 终止与汇报
-- 无需更多工具时立即停止,直接给结论。
-- 如实汇报:成功说成功,失败说卡在哪,跳过的也要说。引用代码用 "path:行号" 格式(如 src/index.ts:42)。保持简洁。`;
+## ⛯ PLAN MODE (active now)
+You are in PLAN mode: investigate and design only — do NOT execute or change anything.
+- Your editing / command / memory-write tools (write_file, edit_file, run_command, memory_save, memory_update, memory_forget) have been REMOVED from your tool list. Use only the read-only tools available to you (read_file, glob, grep, codegraph, web_search, web_fetch, use_skill, ask_human, memory_search, memory_list) to investigate.
+- Research thoroughly: locate the relevant code, trace call paths, and understand existing patterns and conventions before designing. Prefer codegraph when a .codegraph/ index exists.
+- Then produce a clear, actionable implementation plan: files to change (with paths), what to change in each and why, the ordered steps, edge cases to handle, and how to verify (typecheck / tests / build). Be specific enough to execute against.
+- Present the plan as your final reply and STOP, unless the user explicitly asked you to "plan first then execute" / "先 plan 再 auto" / autonomous execution: in that case, after presenting the plan, call the switch_mode tool with mode="auto" to switch back to auto mode WITHIN THE SAME TURN and continue implementing the plan yourself (your write/edit/command/memory-write tools become available again immediately). The user will see no approval prompt because you self-switched.
+- If the user entered plan mode manually (via /plan or Shift+Tab) for a safety review and did NOT ask for autonomous execution, do NOT call switch_mode — present the plan and STOP; the user will approve via a prompt and execution happens in a follow-up turn.`;
 export const config = {
     baseURL: requireEnv('LLM_BASE_URL'),
     apiKey: requireEnv('LLM_API_KEY'),
@@ -74,7 +122,13 @@ export const config = {
     compactThreshold: Number(process.env.COMPACT_THRESHOLD) || 0.85,
     includeUsage: process.env.LLM_STREAM_USAGE !== 'false',
     autoCompact: process.env.AUTO_COMPACT !== 'false',
+    autoReflect: process.env.AUTO_REFLECT !== 'false',
+    reflectEveryN: Number(process.env.REFLECT_EVERY_N) || 5,
+    maxSteps: Number(process.env.MAX_STEPS) || 200,
+    subAgentMaxSteps: Number(process.env.SUB_AGENT_MAX_STEPS) || 50,
     sessionDir: path.join(process.cwd(), '.mocode', 'sessions'),
     searchApiKey: process.env.ANYSEARCH_API_KEY,
     searchBaseUrl: process.env.ANYSEARCH_BASE_URL || 'https://api.anysearch.com',
+    theme: process.env.MOCODE_THEME || 'default',
+    themeFromShell,
 };

package/dist/llm/index.js

@@ -1,6 +1,7 @@
 import OpenAI from 'openai';
 import { config } from '../config/index.js';
 import { tools } from '../tools/registry.js';
+import { PLAN_DISABLED_TOOLS } from '../tools/constants.js';
 const client = new OpenAI({
     baseURL: config.baseURL,
     apiKey: config.apiKey,
@@ -16,18 +17,23 @@ export const chatTools = tools.map((t) => ({
     },
 }));
 /**
- * 流式调一次 LLM:增量回调文本 / 思考,内部累加 tool_calls 片段。
- * 思考内容走 delta.reasoning_content(DeepSeek / GLM / Qwen 等推理模型,
- * SDK 类型无此字段,用 as any 取;不支持的模型则无思考,只流文本)。
+ * plan 模式用的受限工具 schema:剔除写盘 / 命令 / 记忆写入类(PLAN_DISABLED_TOOLS),
+ * 模型在 plan 模式下只看得到只读工具 → 调不到会改文件的工具。runAgent 在 plan 模式传给 chat()。
+ */
+export const planChatTools = chatTools.filter((t) => !PLAN_DISABLED_TOOLS.has(t.function.name));
+/**
+ * 流式调一次 LLM:增量回调文本,内部累加 tool_calls 片段。
  * tool_calls 跨 chunk 按 index 累加(id / name / arguments 拼接)。
  * include_usage 时末尾 chunk 携带 usage,先读再 continue(末尾 chunk 无 delta)。
  */
-export async function chat(messages, handlers = {}, signal) {
+export async function chat(messages, handlers = {}, signal, 
+/** 覆盖默认工具 schema;plan 模式传 planChatTools(只读子集),缺省=全量 chatTools。 */
+toolsOverride) {
     // signal 透传给 SDK 第二参(RequestOptions);abort 后 for await 抛错,chat 不 catch,透传 runAgent 处理。
     const stream = await client.chat.completions.create({
         model: config.model,
         messages,
-        tools: chatTools,
+        tools: toolsOverride ?? chatTools,
         stream: true,
         ...(config.maxTokens ? { max_tokens: config.maxTokens } : {}),
         ...(config.includeUsage ? { stream_options: { include_usage: true } } : {}),
@@ -48,10 +54,6 @@ export async function chat(messages, handlers = {}, signal) {
         const delta = chunk.choices[0]?.delta;
         if (!delta)
             continue; // 末尾 usage-only chunk 等无 delta
-        // 思考内容(非标准字段,SDK 类型无)
-        const reasoning = delta.reasoning_content ?? delta.reasoning;
-        if (reasoning)
-            handlers.onThinking?.(reasoning);
         if (delta.content) {
             content += delta.content;
             hasContent = true;

package/dist/memory/discover.js

@@ -0,0 +1,49 @@
+// memory 发现子系统:加载项目记忆 MOCODE.md(对标 skills/discover.ts 的叶子模式)。
+// 仅依赖 node 标准库,是叶子模块:不依赖 config/agent/llm/tools/skills,避免环。
+//
+// 约定:纯 MOCODE.md(不读 CLAUDE.md——mocode 是独立工具,接非 Claude 后端,
+// 有自己的工具集与约定,叫 CLAUDE.md 名不副实且可能读到 Claude 专属内容)。
+// 项目级从 cwd 向上逐级找,全局 ~/.mocode/MOCODE.md。全量注入 systemPrompt(超长截断);
+import { existsSync, readFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+/**
+ * 返回要查找的 MOCODE.md 路径列表,按「远→近」顺序(合并时近的在后,更突出):
+ * 全局 ~/.mocode/MOCODE.md → 项目级从根到 cwd 逐级 MOCODE.md。
+ * 向上遍历 cwd 到根收集 [cwd..root],反转为 [root..cwd](远→近),前拼全局。
+ */
+export function resolveMemoryFiles() {
+    const globalPath = path.join(os.homedir(), '.mocode', 'MOCODE.md');
+    const projectFiles = [];
+    let dir = process.cwd();
+    const root = path.parse(dir).root; // win32 'C:\\', POSIX '/'
+    for (;;) {
+        projectFiles.push(path.join(dir, 'MOCODE.md'));
+        if (dir === root || dir === path.dirname(dir))
+            break; // 到根:dirname 自身
+        dir = path.dirname(dir);
+    }
+    projectFiles.reverse(); // root..cwd(远→近)
+    return [globalPath, ...projectFiles];
+}
+/**
+ * 读取所有存在的 MOCODE.md,返回 { path, content }(content 已 trim)。
+ * 全程静默容错(不存在 / 读失败 → 跳过,不抛),风格对齐 skills/discover.ts 与 session/persist.ts。
+ */
+export function loadMemoryFiles() {
+    const files = resolveMemoryFiles();
+    const out = [];
+    for (const p of files) {
+        try {
+            if (!existsSync(p))
+                continue;
+            const content = readFileSync(p, 'utf8').trim();
+            if (content)
+                out.push({ path: p, content });
+        }
+        catch {
+            continue; // 读失败静默跳过
+        }
+    }
+    return out;
+}

package/dist/memory/index.js

@@ -0,0 +1,45 @@
+// memory barrel:Tier-1 MOCODE.md 懒加载(buildMemorySection,叶子)+ Tier-2 工具库 re-export。
+// Tier-2:store.ts(叶子,node:fs)做 JSONL CRUD/GC/索引段;reflect.ts(→llm,同 session/)做后台反思 pass。
+// 被 repl 依赖(注入 systemPrompt + 轮末触发反思 + 退出 drain)。Tier-1 仅依赖 discover.ts。
+import { loadMemoryFiles } from './discover.js';
+export { buildMemoryIndexSection, loadAll, gcMemories, } from './store.js';
+export { kickoffReflection, drainMemoryBackground, getLastReflectResult, clearLastReflectResult, snapshotTranscript, formatReflectResult, runReflection, } from './reflect.js';
+/** system 消息中 memory 段的字符上限(防过大占窗口——system 在 history[0],compactHistory 不压缩)。 */
+const MAX_MEMORY_CHARS = 20000;
+let cache = null;
+/**
+ * 合并全局 + 项目各级 MOCODE.md(远→近拼接,各段空行分隔),超 MAX_MEMORY_CHARS 截断 + 提示。
+ * 懒加载(首次调用触发扫描;启动期 repl 调一次)。无 MOCODE.md 返空串。
+ */
+export function loadMemory() {
+    if (cache !== null)
+        return cache;
+    const files = loadMemoryFiles();
+    if (files.length === 0) {
+        cache = '';
+        return cache;
+    }
+    const body = files.map((f) => f.content).join('\n\n');
+    if (body.length <= MAX_MEMORY_CHARS) {
+        cache = body;
+    }
+    else {
+        cache =
+            body.slice(0, MAX_MEMORY_CHARS) +
+                `\n\n…(项目记忆已截断 ${body.length - MAX_MEMORY_CHARS} 字符,完整见各级 MOCODE.md)`;
+    }
+    return cache;
+}
+/** 拼进系统提示的 memory 段;无 memory 返空串(零行为变化)。 */
+export function buildMemorySection() {
+    const mem = loadMemory();
+    if (!mem)
+        return '';
+    return [
+        '',
+        '',
+        '## Project Memory (MOCODE.md)',
+        'The following is project memory (architecture / conventions / commands and other cross-session long-term facts). Act accordingly:',
+        mem,
+    ].join('\n');
+}