mocode-ai 0.6.9 → 0.7.0

package/dist/config/index.js

@@ -262,11 +262,20 @@ This is your private working surface — write intermediate findings, decisions,
 and anything you might need to recall later. The file survives context compaction.
 
 ### WHEN TO WRITE
+The notepad is opt-in for complex work, not a routine task log. Use it only when the task has at least 3 meaningful steps, spans multiple investigation/implementation phases, or contains details that are genuinely at risk of being lost to context compaction.
+
+Do NOT create, read, or update the notepad for simple tasks, including:
+- Questions that can be answered directly
+- One-step commands or lookups
+- Small, localized edits that can be completed without intermediate notes
+- Work that only needs a few tool calls and fits comfortably in the current context
+
+For qualifying complex work:
 - After exploring code and discovering key constraints → add a section
-- Before making a design decision → record reasoning and alternatives considered
-- When accumulating data across tool calls → store intermediates
-- When you realize something you might forget after compaction → write it down
-- After completing a phase → summarize what you learned
+- Before making a consequential design decision → record reasoning and alternatives considered
+- When accumulating data across many tool calls → store concise intermediates
+- When you realize important information may be lost after compaction → write it down
+- After completing a substantial phase → summarize what you learned
 
 ### FORMAT (markdown, section-based)
 Use \`## <topic>\` headers to organize. Each section is self-contained.
@@ -313,7 +322,8 @@ Write the plan as a top-level \`## Plan:\` section. The system extracts this for
 Rules:
 - Only ONE active \`## Plan:\` section at a time.
 - Mark steps \`[x]\` as you complete them; append a line to \`### Progress\` after each phase.
-- When the plan is done, either delete the section or rename it to \`## Done: <title>\` so the status bar chip clears automatically.
+- Before your final response, reconcile every step with the work actually completed, then delete the plan section or rename it to \`## Done: <title>\`.
+- The host hides an unchanged active plan when an agent turn ends as a safety fallback; this does not edit the notepad. Keep updating the plan during execution so live progress remains accurate.
 
 ## Termination & Reporting
 - Stop immediately when no more tools are needed; give conclusions directly.

package/dist/index.js

@@ -81,7 +81,7 @@ async function main() {
         }
         const updateNotice = checkAndMaybeUpdate();
         const { startRepl } = await import('./repl/index.js');
-        await startRepl(loaded.history, loaded.id, updateNotice, sandboxRootOverride);
+        await startRepl(loaded.history, loaded.id, updateNotice, sandboxRootOverride, loaded.queryHistory);
     }
     else {
         const updateNotice = checkAndMaybeUpdate();

package/dist/project-skill/index.js

@@ -38,24 +38,12 @@ export function readProjectSkill() {
         return null;
     }
 }
-/** 内容硬上限(字符数)。超限拒绝写入，防止系统提示词膨胀。从 6000 降至 4000，与快照互补后内容更精简。 */
-const MAX_SKILL_CHARS = 4000;
-/**
- * 写入/更新项目 skill。先备份旧内容再写新内容。
- * 返回 { ok, error? }: ok=false 时 error 说明原因(超限/IO 失败)。
- */
+/** 写入/更新项目 skill。内容不设字符上限；写入前备份旧内容。 */
 export function writeProjectSkill(content) {
     const trimmed = content.trim();
-    if (trimmed.length > MAX_SKILL_CHARS) {
-        return {
-            ok: false,
-            error: `内容超过上限(${trimmed.length}/${MAX_SKILL_CHARS} 字符)。请精简后重试。`,
-        };
-    }
     const p = skillPath();
     const dir = path.dirname(p);
     try {
-        // 备份旧内容(如果有)
         if (existsSync(p)) {
             copyFileSync(p, backupPath());
         }
@@ -67,95 +55,22 @@ export function writeProjectSkill(content) {
         return { ok: false, error: `写入失败: ${e.message}` };
     }
 }
-/**
- * 追加内容到项目 skill 末尾(以 \n\n 分隔)。
- * 同样受 MAX_SKILL_CHARS 限制。
- */
+/** 追加内容到项目 skill 末尾(以 \n\n 分隔)，内容不设字符上限。 */
 export function appendProjectSkill(addition) {
     const existing = readProjectSkill() ?? '';
     const trimmed = addition.trim();
     if (!trimmed)
         return { ok: false, error: '追加内容为空' };
     const separator = existing ? '\n\n' : '';
-    const merged = existing + separator + trimmed;
-    return writeProjectSkill(merged);
+    return writeProjectSkill(existing + separator + trimmed);
 }
-/**
- * 调用 LLM 压缩内容。超限时自动精简，保留关键信息。
- * 返回压缩后的内容，失败返回 null。
- */
-export async function compressContent(content, signal) {
-    try {
-        // 动态导入避免循环依赖
-        const { chat } = await import('../llm/index.js');
-        const messages = [
-            {
-                role: 'system',
-                content: 'You are a technical writer. Compress the following project skill content to fit within ' +
-                    `${MAX_SKILL_CHARS} characters while preserving the most important information. ` +
-                    'Keep concrete examples, paths, and actionable insights. Remove redundancy and verbose explanations. ' +
-                    'Output ONLY the compressed content, no explanations.',
-            },
-            { role: 'user', content },
-        ];
-        const result = await chat(messages, {}, signal);
-        const compressed = result.content?.trim();
-        if (!compressed)
-            return null;
-        return compressed;
-    }
-    catch {
-        return null;
-    }
+/** 兼容旧调用名：字数限制取消后直接写入，不再调用 LLM 压缩。 */
+export async function writeProjectSkillWithCompression(content, _maxAttempts = 3, _signal) {
+    return { ...writeProjectSkill(content), compressed: false };
 }
-/**
- * 写入时自动压缩：超限则调用 LLM 压缩，最多尝试 maxAttempts 次。
- * 返回 { ok, error?, compressed? }，compressed 标记是否经过压缩。
- */
-export async function writeProjectSkillWithCompression(content, maxAttempts = 3, signal) {
-    let current = content;
-    let compressed = false;
-    for (let attempt = 0; attempt < maxAttempts; attempt++) {
-        const result = writeProjectSkill(current);
-        if (result.ok) {
-            return { ok: true, compressed };
-        }
-        // 非超限错误直接返回
-        if (!result.error?.includes('内容超过上限')) {
-            return result;
-        }
-        // 超限时调用 LLM 压缩
-        const compressedContent = await compressContent(current, signal);
-        if (!compressedContent) {
-            return {
-                ok: false,
-                error: `压缩失败: ${result.error}`,
-            };
-        }
-        current = compressedContent;
-        compressed = true;
-    }
-    // 多次压缩后仍超限
-    const finalCheck = writeProjectSkill(current);
-    if (finalCheck.ok) {
-        return { ok: true, compressed: true };
-    }
-    return {
-        ok: false,
-        error: `经过 ${maxAttempts} 次压缩仍超限: ${finalCheck.error}`,
-    };
-}
-/**
- * 追加时自动压缩：合并后超限则调用 LLM 压缩，最多尝试 maxAttempts 次。
- */
-export async function appendProjectSkillWithCompression(addition, maxAttempts = 3, signal) {
-    const existing = readProjectSkill() ?? '';
-    const trimmed = addition.trim();
-    if (!trimmed)
-        return { ok: false, error: '追加内容为空' };
-    const separator = existing ? '\n\n' : '';
-    const merged = existing + separator + trimmed;
-    return writeProjectSkillWithCompression(merged, maxAttempts, signal);
+/** 兼容旧调用名：字数限制取消后直接追加，不再调用 LLM 压缩。 */
+export async function appendProjectSkillWithCompression(addition, _maxAttempts = 3, _signal) {
+    return { ...appendProjectSkill(addition), compressed: false };
 }
 /**
  * 生成系统提示词注入段。

package/dist/project-snapshot/llm-snapshot.js

@@ -19,9 +19,9 @@ Do NOT explain WHY or HOW (that's Project Skill's job).
 5. Identify tech stack from dependencies
 
 ## Output Format
-Output a markdown document between these exact delimiters:
+Output only a markdown document between these exact delimiter lines. The delimiters are not Markdown fences and must each appear on their own line:
 
-\`\`\`snapshot-md
+<snapshot-md>
 # Project Snapshot
 
 ## Description
@@ -49,7 +49,7 @@ src/
   tools/
   ui/
 \`\`\`
-\`\`\`snapshot-md
+</snapshot-md>
 
 ## Rules
 1. **Description**: ≤80字，中文，从 README 和 package.json description 提炼。不要"一个..."开头。
@@ -60,7 +60,36 @@ src/
 6. 不要包含：设计决策、注意事项、坑点、约定 → 这些是 Skill 的职责。
 7. 总 markdown ≤ 2500 字符。
 8. 使用中文。
+9. 不要在 <snapshot-md> 和 </snapshot-md> 之外输出任何内容。
 `;
+/**
+ * 提取子 agent 输出中的 markdown。
+ * 优先使用无歧义标签，同时兼容历史自定义围栏和标准 Markdown 围栏。
+ */
+function extractSnapshotMarkdown(summary) {
+    const tagged = summary.match(/<snapshot-md>[ \t]*\r?\n?([\s\S]*?)\r?\n?[ \t]*<\/snapshot-md>/i);
+    if (tagged?.[1]?.trim())
+        return tagged[1].trim();
+    const legacy = summary.match(/```snapshot-md[ \t]*\r?\n([\s\S]*?)\r?\n```snapshot-md[ \t]*(?:\r?\n|$)/i);
+    if (legacy?.[1]?.trim())
+        return legacy[1].trim();
+    const opening = summary.match(/^```(?:snapshot-md|markdown)[ \t]*\r?$/im);
+    if (opening?.index === undefined)
+        return undefined;
+    let bodyStart = opening.index + opening[0].length;
+    if (summary[bodyStart] === '\n')
+        bodyStart += 1;
+    const body = summary.slice(bodyStart);
+    const closings = [...body.matchAll(/^`{3,}[ \t]*\r?$/gm)];
+    const closing = closings.at(-1);
+    if (closing?.index === undefined)
+        return undefined;
+    let content = body.slice(0, closing.index).trim();
+    // 有些模型会把内层和外层的结束围栏连成六个反引号。
+    if (closing[0].trim().length >= 6)
+        content = `${content}\n\`\`\``;
+    return content || undefined;
+}
 /**
  * 生成 LLM 快照（markdown 格式）
  * @param root 项目根目录
@@ -101,21 +130,15 @@ export async function generateLLMSnapshot(root, signal) {
                 transcript: result.transcript,
             };
         }
-        // 从 summary 中提取 markdown
-        const mdMatch = result.summary.match(/```snapshot-md\n([\s\S]*?)\n```snapshot-md/);
-        if (!mdMatch || !mdMatch[1]) {
-            // fallback: 尝试普通 markdown 代码块
-            const fallbackMatch = result.summary.match(/```markdown\n([\s\S]*?)\n```/);
-            if (!fallbackMatch || !fallbackMatch[1]) {
-                return {
-                    ok: false,
-                    error: '无法从子 agent 输出中提取 markdown',
-                    transcript: result.transcript,
-                };
-            }
-            return { ok: true, content: fallbackMatch[1].trim(), transcript: result.transcript };
+        const content = extractSnapshotMarkdown(result.summary);
+        if (!content) {
+            return {
+                ok: false,
+                error: '无法从子 agent 输出中提取 markdown',
+                transcript: result.transcript,
+            };
         }
-        return { ok: true, content: mdMatch[1].trim(), transcript: result.transcript };
+        return { ok: true, content, transcript: result.transcript };
     }
     catch (e) {
         return {

package/dist/repl/index.js

@@ -237,28 +237,51 @@ function renderContextBarInline(history) {
     const pctCol = pct >= config.compactThreshold ? ui.yellow : ui.accent;
     return `${ui.gray}[${pctCol}${bar}${ui.reset}] ${pctCol}${Math.round(pct * 100)}%${ui.reset} ${ui.dim}${k(est)}/${k(win)}${ui.reset}`;
 }
-/** 从 .mocode/sessions/<sessionId>/notes.md 读取活跃 plan 摘要(## Plan: 段)。每次状态栏刷新时同步读,文件小开销可忽略。 */
-function readPlanFromNotes() {
+// 宿主侧记录已结束轮次最后看到的 plan。notes.md 仍完整保留，只抑制未变化的旧 plan 状态栏，
+// 避免 agent 忘记把 `## Plan:` 改成 `## Done:` 时输入框上方永久悬挂。
+let settledPlanFingerprint;
+/** 读取 notes.md 中唯一活跃的 `## Plan:` 段。进度只统计该段，避免其他笔记 checkbox 污染计数。 */
+function readPlanStatusFromNotes() {
     const sessionId = getCurrentSessionId();
     if (!sessionId)
-        return '';
+        return null;
     const root = getSandboxRoot() ?? process.cwd();
     const p = path.join(root, '.mocode', 'sessions', sessionId, 'notes.md');
     try {
-        const c = fs.readFileSync(p, 'utf8');
-        const title = c.match(/^## Plan:\s*(.+)$/m)?.[1].trim();
+        const normalized = fs.readFileSync(p, 'utf8').replace(/\r\n?/g, '\n');
+        const lines = normalized.split('\n');
+        const start = lines.findIndex((line) => /^## Plan:\s*.+$/.test(line));
+        if (start < 0)
+            return null;
+        const endOffset = lines.slice(start + 1).findIndex((line) => /^##\s/.test(line));
+        const end = endOffset < 0 ? lines.length : start + 1 + endOffset;
+        const section = lines.slice(start, end).join('\n').trimEnd();
+        const title = lines[start].match(/^## Plan:\s*(.+)$/)?.[1].trim();
         if (!title)
-            return '';
-        const total = (c.match(/^\s*-\s*\[[ xX]\]\s*\d+\./gm) || []).length;
-        const done = (c.match(/^\s*-\s*\[[xX]\]\s*\d+\./gm) || []).length;
-        const current = c.match(/^\s*-\s*\[ \]\s*\d+\.\s*(.+)$/m)?.[1].trim();
+            return null;
+        const total = (section.match(/^\s*-\s*\[[ xX]\]\s*\d+\./gm) || []).length;
+        const done = (section.match(/^\s*-\s*\[[xX]\]\s*\d+\./gm) || []).length;
+        const current = section.match(/^\s*-\s*\[ \]\s*\d+\.\s*(.+)$/m)?.[1].trim();
         const summary = `plan: ${title} (${done}/${total})`;
-        return current ? `${summary} ▸ ${current}` : summary;
+        // mtime 让“相同内容被重写为一项新计划”也能重新出现，而不被旧轮次误抑制。
+        const fingerprint = `${sessionId}\0${fs.statSync(p).mtimeMs}\0${section}`;
+        return { fingerprint, summary: current ? `${summary} ▸ ${current}` : summary };
     }
     catch {
-        return '';
+        return null;
     }
 }
+/** 将当前 plan 标记为已结算。只影响状态栏，不修改 agent 的工作笔记。 */
+function settlePlanStatus() {
+    settledPlanFingerprint = readPlanStatusFromNotes()?.fingerprint;
+}
+/** 从 notes.md 读取活跃 plan 摘要；已结算且未变化的旧 plan 不再显示。 */
+function readPlanFromNotes() {
+    const plan = readPlanStatusFromNotes();
+    if (!plan || plan.fingerprint === settledPlanFingerprint)
+        return '';
+    return plan.summary;
+}
 /** 状态行基线:模型 / context / cwd / 模式标识 / 活跃 plan chip / 本轮 token。repl 在轮次边界、切模式、plan 变更时调。 */
 function refreshStatusBase(history, lastTurnUsage) {
     layout.setStatusBase({
@@ -536,6 +559,13 @@ function textOf(c) {
     }
     return String(c);
 }
+/** 从旧 session 的消息历史回填输入历史；新 session 使用独立 queryHistory，避免混入合成 user 消息。 */
+function queryHistoryFromMessages(messages) {
+    return messages
+        .filter((message) => message.role === 'user')
+        .map((message) => textOf(message.content))
+        .filter((query) => query.trim().length > 0);
+}
 /**
  * 把会话历史渲染成静态文本进内容区(回滚 / 续接 / --resume 后复显上下文):
  * user→❯ 回显、assistant→正文(+ tool_calls 折叠成 ● 摘要行)、tool→↳ 结果预览;system 跳过。
@@ -649,7 +679,7 @@ export function renderHistory(history) {
  * contentWrite 落入内容区(滚动区域内自动滚动,底栏不动)。history 由本模块持有,在轮次间持久;
  * agent 只读取并追加(+ 经 session/ 压缩)。每轮成功结束后自动落盘,退出后可用 --resume / /resume 续接。
  */
-export async function startRepl(initialHistory, sessionId, updateNotice = null, sandboxRootOverride) {
+export async function startRepl(initialHistory, sessionId, updateNotice = null, sandboxRootOverride, initialQueryHistory) {
     // 模式重置:agentMode 不落盘,每个 REPL 会话从 auto 开始(/resume / --resume 亦重置)。
     setAgentMode('auto');
     // 沙箱根:文件操作边界。优先级 --sandbox-root > SANDBOX_ROOT env > process.cwd()。
@@ -686,6 +716,10 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
     const history = initialHistory && initialHistory.length
         ? initialHistory
         : [{ role: 'system', content: buildSystemMessage(false) }];
+    // 新 session 使用独立输入历史；旧 session 没有该字段时从 user 消息兼容回填一次。
+    let queryHistory = initialQueryHistory
+        ? [...initialQueryHistory]
+        : queryHistoryFromMessages(history);
     if (initialHistory &&
         initialHistory.length &&
         history[0]?.role === 'system') {
@@ -839,7 +873,7 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
             currentSessionId = newSessionId();
         setCurrentSessionId(currentSessionId, process.cwd()); // 同步到 session/state,确保 notes.md 存在
         try {
-            saveSession(history, currentSessionId);
+            saveSession(history, currentSessionId, queryHistory);
         }
         catch {
             // 落盘失败不阻断
@@ -896,16 +930,15 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
                 layout.drawStatusBar();
             });
             // 本轮 token 累计(底栏模式 chip 右边显示)。undefined = 后端不开 include_usage。
+            // 状态栏统一在 finally 刷新，确保正常、中断、异常都经过同一 plan 收尾路径。
             lastTurnUsage = result.usage;
-            refreshStatusBase(history, lastTurnUsage); // 即时刷状态行显示本轮 token chip
-            layout.drawStatusBar();
             ok = !signal.aborted; // 中断(Ctrl+C)→ runAgent 已还原 history,ok=false 不弹审批
             // 成功轮次自动落盘(崩溃也保住上一轮);新会话首轮分配 id
             if (!currentSessionId)
                 currentSessionId = newSessionId();
             setCurrentSessionId(currentSessionId, process.cwd()); // 同步到 session/state,确保 notes.md 存在
             try {
-                saveSession(history, currentSessionId);
+                saveSession(history, currentSessionId, queryHistory);
             }
             catch {
                 // 落盘失败不阻断 REPL
@@ -920,6 +953,16 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
         }
         catch (e) {
             ok = false;
+            // 请求失败也保存已确认提交的 query，确保立即退出后仍可通过 ↑ 或 resume 找回。
+            if (!currentSessionId)
+                currentSessionId = newSessionId();
+            setCurrentSessionId(currentSessionId, process.cwd());
+            try {
+                saveSession(history, currentSessionId, queryHistory);
+            }
+            catch {
+                // 落盘失败不覆盖原始请求错误
+            }
             // 多模态相关错误友好提示:OpenAI/Anthropic 等会报 "does not support image" / "vision" / "multimodal" 等关键词,
             // 直接给原文对中文用户不友好。这里翻译成中文 + 提示 /model 换视觉模型。
             const msg = e instanceof Error ? e.message : String(e);
@@ -937,6 +980,13 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
         }
         finally {
             stopRunningListener();
+            // 纯 plan 轮正常结束后仍需等待审批/细化，继续展示；其余终态统一结算。
+            // 结算只隐藏当前 fingerprint，不修改 notes；后续内容或 mtime 变化会自动重新显示。
+            const waitingForPlanApproval = ok && planMode && getAgentMode() === 'plan';
+            if (!waitingForPlanApproval)
+                settlePlanStatus();
+            refreshStatusBase(history, lastTurnUsage);
+            layout.drawStatusBar();
         }
         layout.contentWrite('\n'); // 轮次之间空行
         return ok;
@@ -955,6 +1005,9 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
         }
         history.length = 0;
         history.push(...loaded.history);
+        queryHistory = loaded.queryHistory
+            ? [...loaded.queryHistory]
+            : queryHistoryFromMessages(loaded.history);
         setAgentMode('auto'); // 续接重置为 auto(mode 不落盘;listener 重写 history[0] 回 auto,与 loaded 幂等)
         currentSessionId = loaded.id;
         setCurrentSessionId(loaded.id, process.cwd()); // 切换会话:确保该会话的 notes.md 存在
@@ -985,6 +1038,7 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
             input = await promptWithSlashMenu({
                 prompt: PROMPT,
                 commands: buildSlashCommands(),
+                queryHistory,
                 onCycleMode: cycleMode,
                 // /rollback 预填优先;否则上一轮运行中 typeahead 打的字 → 预填进输入框,用户可改可发
                 ...(pendingPrefill
@@ -1011,9 +1065,12 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
         const cmd = line.split(/\s+/)[0];
         // 语言命令把视觉分隔放在确认文案之后；避免回显后先空一行、下一条命令却紧贴确认。
         echoInput(input, cmd !== '/language');
-        const { status, placeholder } = runningStateFor(cmd);
+        const state = runningStateFor(cmd);
+        const placeholder = line === '/snapshot_refresh' || line === '/project_skill init'
+            ? ''
+            : state.placeholder;
         refreshStatusBase(history);
-        layout.enterRunningMode(status, placeholder);
+        layout.enterRunningMode(state.status, placeholder);
         if (line === '/help') {
             layout.contentWrite(`${ui.bold}${t('help.title')}${ui.reset}\n`);
             layout.contentWrite(`${ui.dim}${t('help.hint')}${ui.reset}\n`);
@@ -1311,10 +1368,11 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
             }
             // buildSnapshot 是异步操作(完全由 LLM 生成)，显示进度提示
             layout.contentWrite(`${ui.dim}正在重新生成项目快照 (LLM 分析中)...${ui.reset}\n`);
+            const signal = startRunningListener('');
             try {
                 // 清除缓存，强制重新生成
                 clearSnapshotCache();
-                const result = await buildSnapshot(undefined, true);
+                const result = await buildSnapshot(signal, true);
                 if (result.snapshot) {
                     layout.contentWrite(`${ui.cyan}✓ 项目快照已刷新${ui.reset} (${result.snapshot.builtAt})\n`);
                     layout.contentWrite(`${ui.dim}已生成 markdown 快照，注入到系统提示词中${ui.reset}\n`);
@@ -1336,6 +1394,9 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
                 const msg = e instanceof Error ? e.message : String(e);
                 layout.contentWrite(`${ui.red}[错误]${ui.reset} 刷新快照失败: ${msg}\n`);
             }
+            finally {
+                stopRunningListener();
+            }
             continue;
         }
         if (line === '/sessions') {
@@ -1903,48 +1964,29 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
                     }
                     continue;
                 }
-                // /project_skill init — 扫描项目并生成/优化 skill
+                // /project_skill init — 作为一条普通主 Agent 请求生成/优化 skill，不再派生高消耗子 agent。
                 if (arg === 'init') {
                     if (!isProjectSkillEnabled()) {
                         layout.contentWrite(`${ui.yellow}⚠ 项目专属 Skill 尚未开启${ui.reset}，请先运行 ${ui.cyan}/project_skill on${ui.reset}\n`);
                         continue;
                     }
-                    const { readProjectSkill, writeProjectSkill } = await import('../project-skill/index.js');
-                    const existing = readProjectSkill();
-                    if (existing) {
-                        layout.contentWrite(`${ui.cyan}⏳ 正在深度探索项目并优化现有 skill...${ui.reset}\n`);
-                    }
-                    else {
-                        layout.contentWrite(`${ui.cyan}⏳ 正在深度探索项目（子 agent 将使用工具扫描代码、架构、配置等）...${ui.reset}\n`);
-                    }
-                    layout.contentWrite(`${ui.dim}提示: 按 Ctrl+C 可中断${ui.reset}\n\n`);
-                    // 派生子 agent 深度探索项目
-                    const { generateInitialSkill } = await import('../project-skill/initializer.js');
-                    const result = await generateInitialSkill(existing ?? undefined, currentAbort?.signal);
-                    // 显示探索过程日志
-                    if (result.transcript) {
-                        layout.contentWrite(`${ui.dim}--- 探索过程 ---${ui.reset}\n`);
-                        layout.contentWrite(result.transcript);
-                        layout.contentWrite(`${ui.dim}--- 探索结束 ---${ui.reset}\n\n`);
-                    }
-                    if (result.ok && result.content) {
-                        const writeResult = writeProjectSkill(result.content);
-                        if (writeResult.ok) {
-                            layout.contentWrite(`${ui.green}✓ 项目 Skill 已生成${ui.reset}\n`);
-                            layout.contentWrite(`${ui.dim}内容预览:${ui.reset}\n${result.content.slice(0, 500)}${result.content.length > 500 ? '...' : ''}\n`);
-                            layout.contentWrite(`\n${ui.dim}文件: ${ui.accent}.mocode/project-skill.md${ui.reset} (${result.content.length} 字符)\n`);
-                            layout.contentWrite(`${ui.dim}下次启动时会自动注入到系统提示词。Agent 也会在开发过程中持续更新。${ui.reset}\n`);
-                            layout.contentWrite(`${ui.dim}提示: 可用 ${ui.cyan}/project_skill view${ui.reset} 查看完整内容，或手动编辑文件完善。${ui.dim}${ui.reset}\n`);
-                        }
-                        else {
-                            layout.contentWrite(`${ui.red}✗ 写入失败:${ui.reset} ${writeResult.error}\n`);
-                        }
+                    const initPrompt = `请直接初始化或优化当前项目的 Project Skill，并完成写入。
+
+要求：
+1. 直接由你完成，禁止调用 task 工具或派生任何子 agent。
+2. 优先利用系统提示中已有的 Project Snapshot 和 Project Skill；不要重复扫描其中已有的目录、依赖、命令和模块清单。
+3. 最多进行 1 次 codegraph 探索；只有缺少关键依据时，才额外进行少量定点 read_file/grep。禁止全仓 glob 和逐文件扫描。
+4. Skill 只记录 Snapshot 无法提供的 WHY/HOW/GOTCHAS/CONVENTIONS：设计取舍、关键调用链、非直觉边界、项目约定和可操作坑点。使用具体路径和例子，删除重复或过时内容。
+5. 最终内容应完整、结构清晰。调用 project_skill_update，使用 action=write 一次性写入完整内容。
+6. 写入成功后只简短说明更新了哪些关键洞察，不要输出完整 Skill。`;
+                    const previousMode = getAgentMode();
+                    try {
+                        await runTurn(initPrompt, false, '');
                     }
-                    else {
-                        layout.contentWrite(`${ui.red}✗ 探索失败:${ui.reset} ${result.error}\n`);
-                        if (result.transcript) {
-                            layout.contentWrite(`${ui.dim}子 agent 输出了部分内容（见上方），但未能生成完整的 skill 文档。${ui.reset}\n`);
-                        }
+                    finally {
+                        // init 是一次明确写操作，临时使用 auto；完成后恢复用户原来的模式。
+                        if (previousMode === 'plan')
+                            setAgentMode('plan');
                     }
                     continue;
                 }
@@ -2097,6 +2139,8 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
             layout.enterInputMode(t('repl.idle'));
             continue;
         }
+        // 只记录已过撤回窗口的真实用户 query；slash 命令和合成执行轮不会走到这里。
+        queryHistory.push(joined);
         const initialPlan = getAgentMode() === 'plan'; // 轮首模式(在 runTurn 之前读)
         const ok = await runTurn(joined, initialPlan, placeholder);
         // plan 轮正常结束(未中断 / 未抛错)→ 看轮末模式决定:

package/dist/session/persist.js

@@ -44,22 +44,27 @@ function firstUserOf(history) {
 function sessionPath(id) {
     return path.join(config.sessionDir, id, 'session.json');
 }
-/** 保存会话到磁盘。全新且只有 system 的会话不创建文件；已有会话即使回滚为空也必须覆盖旧记录。 */
-export function saveSession(history, id) {
+/** 保存会话到磁盘。全新且没有 query 的会话不创建文件；已有会话即使回滚为空也必须覆盖旧记录。 */
+export function saveSession(history, id, queryHistory = []) {
     const meta = {
         id,
         createdAt: idToIso(id),
         model: config.model,
-        firstUser: history.length > 1 ? firstUserOf(history) : '',
+        firstUser: history.length > 1
+            ? firstUserOf(history)
+            : truncateDisplay((queryHistory[0] ?? '').replace(/\n/g, ' ').trim(), 40),
     };
     const currentPath = sessionPath(id);
     const legacyPath = path.join(config.sessionDir, `${id}.json`);
-    if (history.length <= 1 && !existsSync(currentPath) && !existsSync(legacyPath)) {
+    if (history.length <= 1 &&
+        queryHistory.length === 0 &&
+        !existsSync(currentPath) &&
+        !existsSync(legacyPath)) {
         return meta;
     }
     const dir = path.join(config.sessionDir, id);
     mkdirSync(dir, { recursive: true });
-    const record = { ...meta, history };
+    const record = { ...meta, history, queryHistory: [...queryHistory] };
     writeFileSync(currentPath, JSON.stringify(record), 'utf8');
     // 一旦写入新式目录，删除旧式扁平副本，避免已回滚消息仍残留在磁盘。
     if (existsSync(legacyPath))
@@ -86,6 +91,9 @@ export function loadSession(id) {
             model: rec.model ?? '',
             firstUser: rec.firstUser ?? '',
             history: rec.history,
+            queryHistory: Array.isArray(rec.queryHistory)
+                ? rec.queryHistory.filter((query) => typeof query === 'string')
+                : undefined,
         };
     }
     catch {

package/dist/tools/builtins/project-skill-update.js

@@ -38,13 +38,11 @@ export const projectSkillUpdateTool = {
         '**何时更新**：发现新架构模式、踩坑后总结、学到新约定、完成重要重构、用户纠正理解时。\n' +
         '\n' +
         '**注意事项**：\n' +
-        '- 保持精简，硬上限 4000 字符（约 1000 token）\n' +
+        '- 内容长度不设硬上限，按项目实际复杂度完整记录有价值的信息\n' +
         '- 写可操作的内容，避免空泛描述\n' +
         '- 用具体路径和例子（不要写"有多个模块"，要写"src/agent 负责 agent 循环"）\n' +
-        '- 定期整理，删除过时信息\n' +
-        '- 更新前建议先 `read` 看一下现有内容，避免重复\n' +
-        '\n' +
-        '**自动压缩**：内容超限时会自动调用 LLM 压缩（最多 3 次），无需手动精简。',
+        '- 定期整理，删除过时和重复信息\n' +
+        '- 更新前建议先 `read` 看一下现有内容，避免重复。',
     risk: 'safe',
     parameters: {
         type: 'object',

package/dist/ui/prompt.js

@@ -90,6 +90,59 @@ export async function promptWithSlashMenu(opts) {
     let resolved = false;
     let resolve;
     let reject;
+    const queryHistory = opts.queryHistory ?? [];
+    let historyIndex = queryHistory.length; // length = 草稿哨兵；0..length-1 = 历史项
+    let historyDraft = null;
+    /** 用历史 query 替换编辑缓冲；历史内容恢复为普通可编辑文本。 */
+    function loadHistoryEntry(value) {
+        lines = value.split('\n');
+        cl = lines.length - 1;
+        cc = lines[cl].length;
+        chip = null;
+        chipPre = '';
+        selected = 0;
+        menuTop = 0;
+        justSawCR = false;
+        computeFiltered();
+        redraw();
+    }
+    /** 在首次离开最新位置时保存完整草稿，然后向更旧的 query 移动。 */
+    function recallPrevious() {
+        if (queryHistory.length === 0 || historyIndex <= 0)
+            return;
+        if (historyIndex === queryHistory.length) {
+            historyDraft = {
+                lines: [...lines],
+                cl,
+                cc,
+                chip,
+                chipPre,
+            };
+        }
+        historyIndex--;
+        loadHistoryEntry(queryHistory[historyIndex]);
+    }
+    /** 向更新的 query 移动；越过最新历史时恢复进入历史前的草稿。 */
+    function recallNext() {
+        if (historyIndex >= queryHistory.length)
+            return;
+        historyIndex++;
+        if (historyIndex < queryHistory.length) {
+            loadHistoryEntry(queryHistory[historyIndex]);
+            return;
+        }
+        const draft = historyDraft;
+        lines = draft ? [...draft.lines] : [''];
+        cl = draft?.cl ?? 0;
+        cc = draft?.cc ?? 0;
+        chip = draft?.chip ?? null;
+        chipPre = draft?.chipPre ?? '';
+        selected = 0;
+        menuTop = 0;
+        justSawCR = false;
+        computeFiltered();
+        redraw();
+    }
     /** 菜单行(预渲染,带色)——向上展开进内容区底,由 layout 贴入。最多显示 MENU_MAX_VISIBLE 条,支持上下滚动。 */
     function menuLines() {
         if (!menuOpen || filtered.length === 0)
@@ -456,6 +509,8 @@ export async function promptWithSlashMenu(opts) {
         filtered = [];
         selected = 0;
         menuTop = 0;
+        historyIndex = queryHistory.length;
+        historyDraft = null;
         if (pasteTimer) {
             clearTimeout(pasteTimer);
             pasteTimer = null;
@@ -518,19 +573,11 @@ export async function promptWithSlashMenu(opts) {
                 pasteParts.push(s);
             return;
         }
-        // 滚动回看键(优先;不触发回尾):PgUp/PgDn 翻页,Ctrl+↑↓ 与 plain ↑/↓ 每次 5 行。
-        // plain ↑/↓ 仅在单行输入且菜单关闭时作滚动(多行编辑留给光标移动,菜单打开留给选项);
-        // 兼鼠标滚轮——alt 屏内(经 \x1B[?1007h)滚轮转发 ↑/↓,1 行/格太慢故放大到 5。
-        const plainArrowScroll = (key.name === 'up' || key.name === 'down') &&
-            !key.ctrl &&
-            !key.meta &&
-            !key.shift &&
-            lines.length <= 1 &&
-            !(menuOpen && filtered.length > 0);
+        // 滚动回看键(优先;不触发回尾):PgUp/PgDn 翻页，Ctrl+↑/↓ 每次 5 行。
+        // 裸 ↑/↓ 留给斜杠菜单、多行光标和 query 历史导航；鼠标滚轮由 SGR mouse 事件处理。
         if (key.name === 'pageup' ||
             key.name === 'pagedown' ||
-            (key.ctrl && (key.name === 'up' || key.name === 'down')) ||
-            plainArrowScroll) {
+            (key.ctrl && (key.name === 'up' || key.name === 'down'))) {
             const pageH = layout.getGeo().contentBottom;
             if (key.name === 'pageup')
                 layout.scrollBy(pageH);
@@ -622,6 +669,9 @@ export async function promptWithSlashMenu(opts) {
                     cc = Math.min(cc, lines[cl].length);
                     redraw();
                 }
+                else {
+                    recallPrevious();
+                }
                 return;
             case 'down':
                 if (menuOpen && filtered.length) {
@@ -633,6 +683,9 @@ export async function promptWithSlashMenu(opts) {
                     cc = Math.min(cc, lines[cl].length);
                     redraw();
                 }
+                else {
+                    recallNext();
+                }
                 return;
             case 'tab':
                 if (menuOpen && filtered[selected])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mocode-ai",
-  "version": "0.6.9",
+  "version": "0.7.0",
   "description": "终端编码 agent:LLM + tool-call 循环 + 流式输出(含思考)+ 16 个工具,接任意 OpenAI 兼容后端。",
   "type": "module",
   "bin": {