mocode-ai 0.1.7 → 0.1.8

package/dist/context/encoders/tree.js

@@ -0,0 +1,86 @@
+/**
+ * File Tree Encoder(glob):扁平路径列表 → 按目录分组缩进树。
+ *
+ * 输入:glob 返回的路径(每行一条,\n 拼接),可能带尾部 `... (共 N 个,仅显示前 200)`。
+ * 输出:目录头(以 `/` 结尾)+ 其下 2 空格缩进的文件,顶部 `# N files · tree-encoded` 计数。
+ *
+ * 不变量(离线脚本断言):路径条数与集合保真——每个原始路径可从树还原:
+ *  目录头 `dir/` + 其下缩进行 `  file` → `dir/file`;根文件(无缩进、不以 `/` 结尾)→ 自身。
+ * 小输入(≤1 路径,含 `无匹配文件` 单行)原样返回:tree 无收益且避免计数头开销。
+ * 路径分隔符归一化(`\`→`/`):Windows 下 glob 可能返 `\`,树内统一 `/`。
+ */
+function normalizeSep(p) {
+    return p.replace(/\\/g, '/');
+}
+export const treeEncoder = {
+    kind: 'tree',
+    encode({ output }) {
+        const lines = output.split('\n');
+        // 分离路径与尾部标记(glob 的 `... (共 N 个...)`)。首个非路径行起全部视作 tail 原样保留。
+        const paths = [];
+        const tail = [];
+        let inTail = false;
+        for (const l of lines) {
+            if (!l)
+                continue;
+            if (!inTail && (l.startsWith('...') || /^\(共/.test(l))) {
+                inTail = true;
+            }
+            if (inTail)
+                tail.push(l);
+            else
+                paths.push(l);
+        }
+        if (paths.length <= 1) {
+            // ≤1 路径:tree 无收益(含 `无匹配文件`),原样返回。
+            return {
+                text: output,
+                meta: {
+                    kind: 'tree',
+                    originalLen: output.length,
+                    encodedLen: output.length,
+                    note: '≤1 path → passthrough',
+                },
+            };
+        }
+        // 按目录分组(保留首次出现顺序,保还原后顺序与原一致)
+        const groups = new Map();
+        const order = [];
+        for (const p of paths) {
+            const norm = normalizeSep(p);
+            const idx = norm.lastIndexOf('/');
+            const dir = idx >= 0 ? norm.slice(0, idx + 1) : ''; // 含尾斜杠
+            const file = idx >= 0 ? norm.slice(idx + 1) : norm;
+            if (!groups.has(dir)) {
+                groups.set(dir, []);
+                order.push(dir);
+            }
+            groups.get(dir).push(file);
+        }
+        const out = [`# ${paths.length} files · tree-encoded`];
+        for (const dir of order) {
+            const files = groups.get(dir);
+            if (dir === '') {
+                for (const f of files)
+                    out.push(f);
+            }
+            else {
+                out.push(dir);
+                for (const f of files)
+                    out.push(`  ${f}`);
+            }
+        }
+        if (tail.length)
+            out.push(...tail);
+        const text = out.join('\n');
+        return {
+            text,
+            meta: {
+                kind: 'tree',
+                originalLen: output.length,
+                encodedLen: text.length,
+                note: `${paths.length} files / ${order.length} dirs`,
+            },
+        };
+    },
+};

package/dist/repl/index.js

@@ -13,7 +13,7 @@ import * as mouse from '../ui/mouse.js';
 import { promptWithSlashMenu, promptTurnPicker, promptSessionPicker, promptThemePicker, promptRevertChoice, } from '../ui/prompt.js';
 import { promptIntervention } from '../ui/intervention.js';
 import { tools } from '../tools/registry.js';
-import { estimateMessagesTokens, estimateToolSchemaTokens, } from '../llm/index.js';
+import { estimateMessagesTokens, } from '../llm/index.js';
 import { compactHistory, contextState, newSessionId, saveSession, loadSession, listSessions, } from '../session/index.js';
 import { listTurns, planRollback, applyRollback, persistSnapshots, loadSnapshots, rebuildFromHistory, resetState, } from '../rollback/index.js';
 import { listSkills, effectiveSystemPrompt } from '../skills/index.js';
@@ -86,11 +86,11 @@ async function askLine(prompt) {
         rl.close();
     }
 }
-/** /context 的用量条(详情版,进内容区):优先用上次 chat() 返回的实测 usage,否则用启发式估算。 */
+/** /context 的用量条(详情版,进内容区):只算对话内容(不含 system prompt),方便用户感知自己发了多少、agent 回复了多少。 */
 function renderContextBar(history) {
-    const schema = estimateToolSchemaTokens();
-    const est = contextState.lastUsage?.totalTokens ??
-        estimateMessagesTokens(history) + schema;
+    // 过滤掉 system 消息,只算对话内容
+    const dialog = history.filter(m => m.role !== 'system');
+    const est = estimateMessagesTokens(dialog);
     const win = config.contextWindowTokens;
     const pct = Math.min(1, est / win);
     const W = 10;
@@ -101,11 +101,12 @@ function renderContextBar(history) {
     const pctCol = pct >= config.compactThreshold ? ui.yellow : ui.cyan;
     return `${ui.gray}[${pctCol}${bar}${ui.reset}] ${Math.round(pct * 100)}%  ${k(est)}/${k(win)} tokens · ${history.length} 条消息 (${src})${ui.reset}`;
 }
-/** 状态行用量条(精简版,进底栏):[bar] pct% k/k。 */
+/** 状态行用量条(精简版,进底栏):[bar] pct% k/k。
+ * 只计算对话内容(不含 system prompt),让用户感知"我发了多少、agent 回复了多少"占用 context。 */
 function renderContextBarInline(history) {
-    const schema = estimateToolSchemaTokens();
-    const est = contextState.lastUsage?.totalTokens ??
-        estimateMessagesTokens(history) + schema;
+    // 过滤掉 system 消息,只算对话内容
+    const dialog = history.filter(m => m.role !== 'system');
+    const est = estimateMessagesTokens(dialog);
     const win = config.contextWindowTokens;
     const pct = Math.min(1, est / win);
     const W = 10;
@@ -189,9 +190,8 @@ function onRunningKey(_str, key) {
     }
     // 用户在交互(非滚动键)→ 暂停流式物理写,避免光标去 contentRow 扰动 IME 候选窗(停手后自动 flush)
     layout.setUserActive();
-    // 其他键:若处于滚动回看,先回尾再处理(打字即回底)
-    if (layout.isScrolled())
-        layout.resetScroll();
+    // 滚动回看时打字 / 编辑(typeahead)不回尾——保持历史视图,便于运行中边看历史边预输入;
+    // 回尾时机:Enter 在运行态是 no-op,真正回尾发生在 agent 结束后 INPUT 态按 Enter 提交(见 prompt.ts submit 前)。
     // Ctrl+C 4 层语义(RUNNING 态):有 typeahead → 清空(层 1,不中断);空 → abort(层 2,中断 agent)。
     // 两次 Ctrl+C 才中断(先清 typeahead 再 abort),与 INPUT 态 onCtrlC 的 fish 式一致。
     // raw 模式下 Ctrl+C 是按键不触发 SIGINT;signal 经 executeTool 串进工具,run_command/web_fetch 即时被杀。

package/dist/session/compact.js

@@ -23,6 +23,47 @@ export function truncateMid(text, max) {
     const out = text.slice(0, head) + marker + text.slice(text.length - tail);
     return out.length > max ? out.slice(0, max) : out;
 }
+/**
+ * Provenance 压缩:旧 tool_calls.arguments 超长时,把大字符串字段替换为 "<N 字符,已省略>" stub,
+ * 保留 path(/rollback planRollback 靠 JSON.parse(arguments).path 找文件,见 rollback/index.ts)+ 其余短字段。
+ * 比 truncateMid 的 head+tail 片段更短且更易读:LLM/摘要器看到 "<5000 字符,已省略>" 即知"写过 5000 字符",
+ * 而非混乱的 head+tail 片段。
+ *
+ * 保:JSON 合法(parse/stringify 失败均原样返回)+ tool_call_id 配对不动(只改 arguments 内容,不改
+ * tool_calls 数组结构)+ path 永不省(rollback 依赖)。永不抛错(对齐「调度器永不抛错」契约)。
+ *
+ * 触发:整体 arguments > MAX_OLD_TOOL_STUB 才进(同原 truncateMid 门槛);字段级也 > MAX_OLD_TOOL_STUB 才 stub。
+ */
+function stubToolCallArguments(argsRaw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(argsRaw);
+    }
+    catch {
+        return argsRaw; // 非合法 JSON(模型偶发):不碰
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return argsRaw;
+    const obj = parsed;
+    let changed = false;
+    for (const k of Object.keys(obj)) {
+        if (k === 'path')
+            continue; // path 永不省:/rollback planRollback 靠它定位文件
+        const v = obj[k];
+        if (typeof v === 'string' && v.length > MAX_OLD_TOOL_STUB) {
+            obj[k] = `<${v.length} 字符,已省略>`;
+            changed = true;
+        }
+    }
+    if (!changed)
+        return argsRaw;
+    try {
+        return JSON.stringify(obj);
+    }
+    catch {
+        return argsRaw; // stringify 失败(理论不会):不碰
+    }
+}
 /**
  * push-time 第一层:工具结果进 history 前裁到 MAX_HISTORY_RESULT。
  * 显示层(summarizeToolResult)仍用原 output,不受影响。
@@ -208,8 +249,8 @@ export async function compactHistory(history, opts) {
     // 第一层:微压缩——旧区原地截短(保 tool_call_id,无 LLM 调用)
     // 覆盖三类大字段,均只裁模型/工具产物,不动 user 原话与 system(摘要):
     //   ① tool 结果 content;
-    //   ② 旧 assistant 的 tool_calls.arguments —— 保 JSON 合法:整体超长才进,
-    //     逐字段值裁中截后重新 stringify(不裸中截会劈断 JSON、严格后端 400);parse 失败跳过;
+    //   ② 旧 assistant 的 tool_calls.arguments —— provenance stub:整体超长才进,大字段
+    //     替换为 "<N 字符,已省略>"(保 path + JSON 合法,见 stubToolCallArguments);
     //   ③ 旧 assistant 正文 content(模型长解释,回看价值低)。
     let microcompactDone = false;
     for (const g of oldGroups) {
@@ -227,27 +268,17 @@ export async function compactHistory(history, opts) {
                 as.content = truncateMid(as.content, MAX_OLD_TOOL_STUB);
                 microcompactDone = true;
             }
-            // ② tool_calls 参数:整体超长才进,逐字段裁值,保 JSON 合法
+            // ② tool_calls 参数:整体超长才进,provenance stub 大字段(保 path + JSON 合法)。
+            //   stubToolCallArguments:大字符串字段 → "<N 字符,已省略>";path 永不省(/rollback 依赖)。
             if (Array.isArray(as.tool_calls)) {
                 for (const tc of as.tool_calls) {
                     const args = tc?.function?.arguments;
                     if (typeof args !== 'string' || args.length <= MAX_OLD_TOOL_STUB)
                         continue;
-                    try {
-                        const parsed = JSON.parse(args);
-                        if (parsed && typeof parsed === 'object') {
-                            for (const k of Object.keys(parsed)) {
-                                const v = parsed[k];
-                                if (typeof v === 'string' && v.length > MAX_OLD_TOOL_STUB) {
-                                    parsed[k] = truncateMid(v, MAX_OLD_TOOL_STUB);
-                                }
-                            }
-                            tc.function.arguments = JSON.stringify(parsed);
-                            microcompactDone = true;
-                        }
-                    }
-                    catch {
-                        // arguments 非合法 JSON(模型偶发):不裁,沿用「调度器永不抛错」
+                    const stubbed = stubToolCallArguments(args);
+                    if (stubbed !== args) {
+                        tc.function.arguments = stubbed;
+                        microcompactDone = true;
                     }
                 }
             }

package/dist/ui/layout.js

@@ -1,5 +1,8 @@
 import { stdin, stdout } from 'node:process';
-import { charWidth, displayWidth, truncateDisplay, ansiDisplayWidth, wrapByDisplayWidth, fmtElapsed, } from './render.js';
+import { appendFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { charWidth, displayWidth, truncateDisplay, truncateDisplayHead, ansiDisplayWidth, wrapByDisplayWidth, fmtElapsed, } from './render.js';
 import { ui } from './theme.js';
 import * as content from './content.js';
 import * as mouse from './mouse.js';
@@ -7,11 +10,17 @@ import { renderMarkdown } from './markdown.js';
 // ── 内部状态 ──
 let active = false;
 let mode = 'input';
-let footerH = 4; // 1 状态行 + 1 上线 + 输入行数 + 1 下线(上下线框住输入区)
+let footerH = 5; // 1 虚拟空行 + 1 状态行 + 1 上线 + 输入行数 + 1 下线(虚拟空行隔开内容与状态栏,上下线框住输入区)
 let contentRow = 1; // 续写位行(1-based,屏坐标,[1,contentBottom])
 let contentCol = 1; // 续写位列(1-based)
+// 上一次 paintLiveAtCursor 实际画帧的屏坐标(0=未画)。clearLiveAtCursor 清"这行"而非当前续写位——
+// 防 spinner 运行期间续写位漂移时清错行、旧帧行残留(见 557e678 移除 isStreamingPaused 后的间歇性 frame 泄漏)。
+let frameRow = 0;
+let frameCol = 0;
 let segmentStartRow = 1; // 当前 md 段起始屏行(供 contentWriteMd 定位段末续写位;段内行数由 content 段标记跟踪)
 let scrollOffset = 0; // 滚动回看距尾行数(0=尾,跟随新内容);>0 时 viewport 显历史、状态行显滚动指示
+let scrollLockUntil = 0; // 发消息轮首滚动锁(绝对时间戳 ms,0=未锁):吸收 stdin 残留滚轮事件,防 resetScroll 回尾后被重新滚上去
+const SCROLL_LOCK_MS = 400; // 锁时长:覆盖 OS 缓冲残留 + 常规滚轮惯性;LLM TTFB 多 >200ms,不影响轮中后段滚动
 let base = null;
 let statusText = '';
 let spinnerFrame;
@@ -86,25 +95,27 @@ export function setRegion(fh) {
         contentRow = g.contentBottom; // 底栏撑高挤掉内容:钳到新区底
     return g;
 }
-/** 运行态真光标(隐藏)的归位点 = 输入框光标位:行 = 动态 contentBottom+3(resize 安全),列对齐 renderDimInputRow 的假光标(空→3,有字→❯+截断文本宽+1)。供 IME 锚定。 */
+/** 运行态真光标(隐藏)的归位点 = 输入框光标位:行 = 动态 contentBottom+4(resize 安全),列对齐 renderDimInputRow 的假光标(空→3,有字→❯+截断文本宽+1)。供 IME 锚定。 */
 function runningCaretPos() {
     const g = getGeo();
     const text = lastView?.dim ? lastView.lines[0] ?? '' : '';
     const contentW = Math.max(0, g.cols - 3); // ❯ =2 + 光标=1
-    const w = displayWidth(truncateDisplay(text, contentW));
-    return { row: g.contentBottom + 3, col: Math.min(g.cols, 2 + w + 1) };
+    const w = displayWidth(truncateDisplayHead(text, contentW));
+    return { row: g.contentBottom + 4, col: Math.min(g.cols, 2 + w + 1) };
 }
 export function contentMode() {
     if (!active)
         return;
     const g = getGeo();
-    if (mode === 'running' && scrollOffset === 0) {
-        // 运行态:真光标归输入框光标位(供 IME 锚定,气泡不跟流式跑);假光标做可见指示
+    if (mode === 'running') {
+        // 运行态(回尾 / 滚动回看均):真光标归输入框光标位(供 IME 锚定,气泡不跟流式跑)。
+        // 滚动态也归输入框——否则上滑看历史时打字,IME 候选气泡会锚到内容区底而非输入框
+        // (conhost IME 不跟随 cup 后续移动,须让打字前光标已在输入框)。
         const p = runningCaretPos();
         stdout.write(cup(p.row, p.col));
     }
     else {
-        // INPUT 态 / 滚动回看:归续写位(滚动回看时归内容区底,viewport 锁历史)
+        // INPUT 态:回尾归续写位,滚动回看归内容区底(viewport 锁历史;INPUT 态无 IME 锚定需求)
         stdout.write(cup(scrollOffset === 0 ? contentRow : g.contentBottom, scrollOffset === 0 ? contentCol : 1));
     }
 }
@@ -252,10 +263,10 @@ export function contentWrite(s) {
             scrollOffset = Math.max(0, Math.min(scrollOffset + delta, maxOff));
         }
     }
-    // 物理写(回尾 offset=0 且未暂停):cup 写起点 + s + (pending 时补 \n 提交换行)+ (运行态 cup 回输入框)。
-    // 用户打字中(isStreamingPaused)跳过物理写、只喂缓冲——光标不入内容区,IME 候选窗不跟流式跑;
-    // 停手后 setUserActive 的 flush 定时器 repaintViewport 重画缓冲内容。
-    if (scrollOffset === 0 && !isStreamingPaused()) {
+    // 物理写(回尾 offset=0):cup 写起点 + s + (pending 时补 \n 提交换行)+ (运行态 cup 回输入框)。
+    // 打字中不再暂停物理写——单次 write 结尾 cup 回 runningCaretPos(输入框),IME 锚定不动(跟踪每次 write
+    // 最终位置);旧设计 isStreamingPaused 暂停写致流式卡顿,现单次写归位已无需暂停。
+    if (scrollOffset === 0) {
         let out = cup(startRow, startCol) + s;
         if (pendingWrap)
             out += '\n'; // 滚动区域底行触发 DECSTBM 上滚、中段 LF 下移到 (下一行,1)
@@ -290,7 +301,7 @@ function commitMd() {
  *
  * 续写位 = 段末下一行(段占 lines.length 行从 segmentStartRow 起);超可视区则滚动留 contentBottom。
  * 物理重画用 repaintViewport(全内容区,原子一次 write 无闪烁)— md 段是缓冲尾,viewport 显尾即显段。
- * 用户打字中(isStreamingPaused)或滚动回看(scrollOffset>0)只更新缓冲,停手 flush / 回尾时显。
+ * 滚动回看(scrollOffset>0)只更新缓冲不物理写(回尾时显);打字中照常物理写——单次 write 结尾 cup 回输入框,IME 锚定不动。
  */
 export function contentWriteMd(s) {
     if (!active || !ui.isTTY) {
@@ -319,8 +330,8 @@ export function contentWriteMd(s) {
             scrollOffset = Math.max(0, Math.min(scrollOffset + delta, maxOff));
         }
     }
-    if (scrollOffset === 0 && !isStreamingPaused()) {
-        repaintViewport();
+    if (scrollOffset === 0) {
+        repaintViewport(); // 单次 write 结尾 cup 回 runningCaretPos(运行态),IME 锚输入框;打字中不再暂停
         if (mode === 'running') {
             const p = runningCaretPos();
             stdout.write(cup(p.row, p.col));
@@ -351,8 +362,11 @@ export function clearContent() {
     setRegion(footerH);
     contentRow = 1;
     contentCol = 1;
+    frameRow = 0;
+    frameCol = 0;
     segmentStartRow = 1;
     scrollOffset = 0;
+    scrollLockUntil = 0;
     mdActive = false;
     mdBuf = '';
     content.reset();
@@ -378,14 +392,24 @@ export function repaintViewport() {
         const line = slice[r - 1] ?? '';
         p += cup(r, 1) + esc.clearLine + line;
     }
+    // 光标:合并进同一 write(若拆成两次 stdout.write,行写完光标会暂留 contentRow/contentBottom,
+    // 流式每 chunk 调一次 → contentBottom 频繁现块状光标白块;打字第一键赶上这瞬 IME 候选气泡锚到 contentBottom)。
+    // 运行态(回尾 / 滚动均)归输入框 runningCaretPos(供 IME 锚定);INPUT 态回尾归续写位 / 滚动归内容区底。
+    if (mode === 'running') {
+        const c = runningCaretPos();
+        p += cup(c.row, c.col);
+    }
+    else {
+        p += cup(scrollOffset === 0 ? contentRow : g.contentBottom, scrollOffset === 0 ? contentCol : 1);
+    }
     stdout.write(p);
-    // 光标:offset=0 回续写位(尾行末,contentWrite 维护);offset>0 留内容区底
-    stdout.write(cup(scrollOffset === 0 ? contentRow : g.contentBottom, scrollOffset === 0 ? contentCol : 1));
 }
 /** 滚动 delta 行(正=往新、负=往旧);钳 [0, max(0, total-contentBottom)];变则重画 + 刷底栏(显指示、光标回输入框)。 */
 export function scrollBy(delta) {
     if (!active)
         return;
+    if (Date.now() < scrollLockUntil)
+        return; // 轮首滚动锁:吸收发消息前后 stdin 残留滚轮事件,保 agent 输出从底部开始
     const g = getGeo();
     const total = content.totalRows();
     const maxOff = Math.max(0, total - g.contentBottom);
@@ -404,6 +428,21 @@ export function resetScroll() {
     repaintViewport();
     repaint();
 }
+/** 发消息轮首短时锁住滚动:吸收 stdin 残留滚轮事件(发消息前后的滚轮惯性 / OS 缓冲延迟到达),
+ *  防 resetScroll 回尾后被 onRunningKey 接到的残留事件重新滚上去——致 agent 输出进缓冲、显示在历史区。
+ *  锁只挡 scrollBy(滚轮 / PgUp-PgDn);不影响 contentWrite 写屏(offset=0 时照常物理写,agent 输出从底部开始)。
+ *  默认 SCROLL_LOCK_MS 后自动解锁;enterInputMode(轮末)也清锁。用户轮中后段仍可上滑(满足"输出时能看历史")。 */
+export function lockScrollToBottom(ms = SCROLL_LOCK_MS) {
+    scrollLockUntil = Date.now() + ms;
+}
+/** 解锁(轮末 enterInputMode / 测试用)。 */
+export function unlockScroll() {
+    scrollLockUntil = 0;
+}
+/** 轮首滚动锁是否生效(测试用)。 */
+export function isScrollLocked() {
+    return Date.now() < scrollLockUntil;
+}
 // ── 状态行 ──
 /** 组合状态行可见串(带色),按 cols 截断防溢出(不折到输入行)。 */
 function composeStatus(status, cols) {
@@ -458,14 +497,14 @@ function composeStatus(status, cols) {
 export function drawStatusBar(status) {
     if (!active || !base)
         return;
-    if (isStreamingPaused())
-        return; // 用户打字中:状态行暂不刷(避免光标去 statusRow 扰动 IME),停手后 flush 会刷
     const s = status ?? { ...base, status: statusText, spinnerFrame };
     const g = getGeo();
-    const statusRow = g.contentBottom + 1;
-    // 一次写入:cup 状态行 + clearLine + 状态 + cup 回(运行态→输入框供 IME 锚定;否则续写位/内容区底)
+    const statusRow = g.contentBottom + 2; // +1 虚拟空行(内容与状态栏间隔),+2 状态行
+    // 一次写入:cup 状态行 + clearLine + 状态 + cup 回(运行态→输入框供 IME 锚定;否则续写位/内容区底)。
+    // 打字中不再跳过——单次 write 结尾 cup 回 runningCaretPos,IME 锚输入框不动;旧 isStreamingPaused 门致状态行 / 心跳打字时冻住。
     let out = cup(statusRow, 1) + esc.clearLine + composeStatus(s, g.cols);
-    if (mode === 'running' && scrollOffset === 0) {
+    if (mode === 'running') {
+        // 运行态(回尾 / 滚动回看均):cup 回输入框光标位(供 IME 锚定)。
         const p = runningCaretPos();
         out += cup(p.row, p.col);
     }
@@ -504,32 +543,76 @@ function stopTurnTimer() {
         turnTimer = null;
     }
 }
+// ── 临时诊断:spinner frame 泄漏追踪(定位 557e678 后的间歇性泄漏后删除)──
+// 记 paintLiveAtCursor/clearLiveAtCursor 的可疑时序:续写位漂移、clear 被守卫跳过、清错行。
+// 同步追加到 ~/.mocode/spinner-debug.log,全 try/catch 不抛、不阻塞、不抢屏。
+let _dbgSpinnerPath = '';
+function dbgSpinner(msg) {
+    try {
+        if (!_dbgSpinnerPath)
+            _dbgSpinnerPath = join(homedir(), '.mocode', 'spinner-debug.log');
+        appendFileSync(_dbgSpinnerPath, `[${new Date().toISOString()}] ${msg}\n`);
+    }
+    catch {
+        // 诊断日志失败不影响渲染
+    }
+}
 /**
  * 在续写位画一行瞬时活动文本(spinner 帧):不进缓冲、不推进续写位,逐行 clearLine 重画。
- * 仅 TTY + offset=0(实时尾)时物理写屏;滚动态跳过(由状态行 spinner 兜底,且避免覆盖 viewport 历史行)。
+ * 仅 TTY + offset=0(实时尾)+ 非打字暂停态时物理写屏;滚动态跳过(由状态行 spinner 兜底,且避免覆盖 viewport 历史行)。
  * 配合 clearLiveAtCursor 在 spinner 停时清掉,随后 contentWrite 的结果即写在该行(spinner 不入历史缓冲)。
+ *
+ * 记 frameRow/frameCol = 实际画帧位置;clearLiveAtCursor 清"这行"而非当前续写位,防续写位漂移时清错行。
+ * 续写位漂移时(运行期间被某次 contentWrite 推进,罕见但 557e678 后可能)先清旧 frameRow 再画新位,避免旧帧残留。
+ * 打字暂停态(isStreamingPaused)spinner 不画帧——恢复 557e678 前的 spinner 隐形行为(只关 spinner,不动 contentWrite)。
  */
 export function paintLiveAtCursor(text) {
-    if (!active || !ui.isTTY || scrollOffset !== 0 || isStreamingPaused())
+    if (!active || !ui.isTTY || scrollOffset !== 0 || isStreamingPaused()) {
+        // 临时诊断:画帧被守卫跳过,但此前画过帧(frameRow)→ 该帧不会被这次 paint 覆盖,泄漏嫌疑
+        if (frameRow && scrollOffset !== 0)
+            dbgSpinner(`PAINT-SKIPPED frame=(${frameRow},${frameCol}) cur=(${contentRow},${contentCol}) off=${scrollOffset} paused=${isStreamingPaused()}`);
         return;
-    // 一次写入:cup 续写位 + clearLine + 帧 + (运行态 cup 回输入框)——避免光标在续写位歇脚被 IME 跟踪
-    let out = cup(contentRow, contentCol) + esc.clearLine + text;
+    }
+    // 临时诊断:续写位 != 上次画帧位置 = spinner 运行期间续写位漂移(泄漏根因嫌疑)
+    if (frameRow && (frameRow !== contentRow || frameCol !== contentCol)) {
+        dbgSpinner(`DRIFT-PAINT old=(${frameRow},${frameCol}) cur=(${contentRow},${contentCol}) mode=${mode} off=${scrollOffset}`);
+    }
+    let out = '';
+    if (frameRow && (frameRow !== contentRow || frameCol !== contentCol)) {
+        out += cup(frameRow, frameCol) + esc.clearLine; // 续写位漂移:先清旧帧行,否则残留
+    }
+    out += cup(contentRow, contentCol) + esc.clearLine + text;
     if (mode === 'running') {
         const p = runningCaretPos();
         out += cup(p.row, p.col);
     }
     stdout.write(out);
+    frameRow = contentRow;
+    frameCol = contentCol;
 }
-/** 清掉续写位那行瞬时活动文本(配合 paintLiveAtCursor)。 */
+/** 清掉 paintLiveAtCursor 画过的那行瞬时活动文本。清"实际画过的位置"(frameRow),非当前续写位。
+ *  不加 isStreamingPaused 守卫——stop 时必须无条件清(只写一次、结尾 cup 回输入框,不扰 IME);否则打字中 stop 会跳过清帧、制造泄漏。 */
 export function clearLiveAtCursor() {
-    if (!active || !ui.isTTY || scrollOffset !== 0 || isStreamingPaused())
+    // 临时诊断:clear 被守卫跳过,但此前画过帧(frameRow)→ 帧残留(泄漏嫌疑)
+    if (frameRow && (!active || !ui.isTTY || scrollOffset !== 0)) {
+        dbgSpinner(`CLEAR-SKIPPED frame=(${frameRow},${frameCol}) cur=(${contentRow},${contentCol}) off=${scrollOffset} active=${active}`);
+    }
+    if (!active || !ui.isTTY || scrollOffset !== 0)
         return;
-    let out = cup(contentRow, contentCol) + esc.clearLine;
+    if (!frameRow)
+        return; // 没画过就不清(避免误清当前续写位内容)
+    // 临时诊断:画帧位置 != 当前续写位 → 旧设计(清续写位)会清错行
+    if (frameRow !== contentRow || frameCol !== contentCol) {
+        dbgSpinner(`CLEAR-MISMATCH frame=(${frameRow},${frameCol}) cur=(${contentRow},${contentCol}) mode=${mode}`);
+    }
+    let out = cup(frameRow, frameCol) + esc.clearLine; // 清"画过的行",非"当前续写位"
     if (mode === 'running') {
         const p = runningCaretPos();
         out += cup(p.row, p.col);
     }
     stdout.write(out);
+    frameRow = 0;
+    frameCol = 0;
 }
 /** 更新状态行基线(模型 / context / cwd / 模式标识)。repl 在轮次边界与切模式时调。 */
 export function setStatusBase(b) {
@@ -643,7 +726,7 @@ export function paintInput(view) {
             startVis: 0,
         }
         : windowInputVis(view.lines, view.cursorLine, view.cursorCol, preGeo.cols, promptW, preGeo.rows);
-    const needFooterH = 3 + vis.inputRows; // 1 状态 + 1 上线 + 输入行 + 1 下线
+    const needFooterH = 4 + vis.inputRows; // 1 虚拟空 + 1 状态 + 1 上线 + 输入行 + 1 下线
     let g = preGeo;
     if (needFooterH !== footerH) {
         // setRegion 自己 write(DECSTBM + 清行 + 归位):先把已累积的擦除 flush 出去保序(擦除用的是旧几何的
@@ -661,15 +744,17 @@ export function paintInput(view) {
         const line = slice[g.contentBottom - 1] ?? '';
         buf += cup(g.contentBottom, 1) + esc.clearLine + line;
     }
+    // 2c. 虚拟空行(内容区与状态栏之间的视觉间隔,属底栏非内容):恒清空,防底栏撑高时旧内容残留该行
+    buf += cup(g.contentBottom + 1, 1) + esc.clearLine;
     // 3. 状态行(footerH 变或始终重画——便宜且避免旧状态行残留)
-    const statusRow = g.contentBottom + 1;
+    const statusRow = g.contentBottom + 2; // +1 虚拟空行,+2 状态行
     const status = { ...base, status: statusText, spinnerFrame };
     buf += cup(statusRow, 1) + esc.clearLine + composeStatus(status, g.cols);
     // 3b. 上线(输入框顶):满屏宽细线 ─(cyan),框住输入区上边界
-    buf += cup(g.contentBottom + 2, 1) + esc.clearLine + ui.cyan + '─'.repeat(g.cols) + ui.reset;
-    // 4. 输入行(g.contentBottom+3 .. rows-1)——按可视行画,首行带 prompt、其余缩进 promptW
-    const firstInputRow = g.contentBottom + 3;
-    const inputRowsAvail = g.footerH - 3; // 去掉状态/上线/下线,留输入行
+    buf += cup(g.contentBottom + 3, 1) + esc.clearLine + ui.cyan + '─'.repeat(g.cols) + ui.reset;
+    // 4. 输入行(g.contentBottom+4 .. rows-1)——按可视行画,首行带 prompt、其余缩进 promptW
+    const firstInputRow = g.contentBottom + 4;
+    const inputRowsAvail = g.footerH - 4; // 去掉虚拟空/状态/上线/下线,留输入行
     const indent = ' '.repeat(promptW);
     const showCaret = view.caret !== false; // 默认 true;picker 等非文本输入传 false 关闭块状光标
     for (let i = 0; i < inputRowsAvail; i++) {
@@ -704,9 +789,11 @@ export function paintInput(view) {
     }
     // 6. 光标
     if (view.dim) {
-        // 运行态:真光标归输入框光标位(供 IME 锚定);滚动回看时归内容区底(viewport 锁历史)
+        // 运行态(回尾 / 滚动回看均):真光标归输入框光标位(供 IME 锚定,气泡在输入框而非内容区)。
+        // 滚动态也归输入框——上滑看历史时打字,IME 候选气泡须锚到输入框(conhost IME 不跟随 cup 后续移动,
+        // 须让打字前光标已在输入框);viewport 锁历史靠 scrollOffset,不靠光标位置。
         const p = runningCaretPos();
-        buf += cup(scrollOffset === 0 ? p.row : g.contentBottom, scrollOffset === 0 ? p.col : 1);
+        buf += cup(p.row, p.col);
     }
     else {
         const r = firstInputRow + vis.visLine;
@@ -727,8 +814,9 @@ function renderDimInputRow(prompt, text, placeholder, cols) {
     const caret = `${ui.reverse} ${ui.reset}`; // 反白块状光标(1 cell,与 INPUT 态同款)
     const contentW = Math.max(0, cols - promptW - 1);
     if (text.length > 0) {
-        // 有打字:❯ dim + 文本(dim) + 反白光标(末尾)
-        return `${ui.dim}${prompt}${truncateDisplay(text, contentW)}${ui.reset}${caret}`;
+        // 有打字:❯ dim + 文本(dim,超长时从头部截断保留尾部——光标恒在末尾,须始终看到刚打的字,
+        // 而非 truncateDisplay 那样保留开头、把刚打的内容截没,显示成卡在开头不动的假象) + 反白光标(末尾)
+        return `${ui.dim}${prompt}${truncateDisplayHead(text, contentW)}${ui.reset}${caret}`;
     }
     // 空:❯ dim + 反白光标(打字起点) + dim 占位 ghost
     const p = placeholder ? truncateDisplay(placeholder, contentW) : '';
@@ -744,11 +832,8 @@ export function paintRunningInputEcho(text, placeholder) {
     if (!active || !base)
         return;
     const g = getGeo();
-    const inputRow = g.contentBottom + 3; // 运行态 footerH 恒 4:状态(+1)+上线(+2)+输入行(+3);下线在 rows
-    stdout.write(cup(inputRow, 1) +
-        esc.clearLine +
-        renderDimInputRow('❯ ', text, placeholder, g.cols));
-    // 同步 lastView:text 与 placeholder 拆开存,使滚动/resize 的 repaint 重画时光标位置正确(空→起点,有字→末尾)
+    const inputRow = g.contentBottom + 4; // 运行态 footerH 恒 5:虚拟空(+1)+状态(+2)+上线(+3)+输入行(+4);下线在 rows
+    // 先同步 lastView(供 runningCaretPos 算真光标位 = 新文本末尾,与假光标同位)
     lastView = {
         prompt: '❯ ',
         lines: [text],
@@ -758,9 +843,14 @@ export function paintRunningInputEcho(text, placeholder) {
         menu: null,
         dim: true,
     };
-    // 真光标归输入框光标位(供 IME 锚定,与假光标同位);滚动回看时归内容区底
+    // 单次 write:cup 输入行 + clearLine + dim 文本/假光标 + cup 真光标到输入框(供 IME 锚定)。
+    // 滚动态也归输入框——旧设计滚动态归 contentBottom,致 IME 候选气泡锚到内容区底白块
+    // (conhost IME 不跟随 cup 后续移动,须让打字前光标已在输入框);拆两次 write 会暂留 contentBottom 显白块。
     const p = runningCaretPos();
-    stdout.write(cup(scrollOffset === 0 ? p.row : g.contentBottom, scrollOffset === 0 ? p.col : 1));
+    stdout.write(cup(inputRow, 1) +
+        esc.clearLine +
+        renderDimInputRow('❯ ', text, placeholder, g.cols) +
+        cup(p.row, p.col));
 }
 /** 重画当前视图(resize / 内部用)。 */
 export function repaint() {
@@ -779,6 +869,9 @@ export function enterInputMode(status = '空闲') {
     runningFrame = -1; // 回 INPUT 态:停状态行 chip 旋转,composeStatus 退回静态 ◆
     turnStart = null; // 停走时
     stopTurnTimer();
+    scrollLockUntil = 0; // 轮末:清轮首滚动锁,INPUT 态可自由滚动
+    frameRow = 0; // 轮末:清 spinner 帧位置(防下轮残留)
+    frameCol = 0;
     // 运行态若有未 flush 的缓冲内容(用户打字暂停了流式写),切回 INPUT 前重画内容区显示之,免丢内容
     if (flushTimer) {
         clearTimeout(flushTimer);
@@ -790,7 +883,7 @@ export function enterInputMode(status = '空闲') {
             repaintViewport();
     }
     if (active && base) {
-        setRegion(4); // 1 状态 + 1 上线 + 1 输入 + 1 下线
+        setRegion(5); // 1 虚拟空 + 1 状态 + 1 上线 + 1 输入 + 1 下线
         paintInput({
             prompt: '❯ ',
             lines: [''],
@@ -801,15 +894,16 @@ export function enterInputMode(status = '空闲') {
         stdout.write(esc.cursorShow); // 回 INPUT 态:显真光标(运行态藏了)
     }
 }
-/** 进入运行态:底栏输入行改 dim 占位,光标回续写位。footerH 恒 4(状态+上线+输入+下线)。新轮回尾(确保新内容可见)。 */
+/** 进入运行态:底栏输入行改 dim 占位,光标回续写位。footerH 恒 5(虚拟空+状态+上线+输入+下线)。新轮回尾(确保新内容可见)。 */
 export function enterRunningMode(status, placeholder) {
     mode = 'running';
     statusText = status;
     spinnerFrame = undefined;
     turnStart = Date.now(); // 起走时(整轮从发起到 enterInputMode 止)
     resetScroll(); // 若上轮 INPUT 滚动过(未打字回底),新轮回尾
+    lockScrollToBottom(); // 轮首短时锁:吸收发消息前后残留滚轮事件,保 agent 输出从底部开始(锁过期或轮末 enterInputMode 解)
     if (active && base) {
-        setRegion(4); // 1 状态 + 1 上线 + 1 输入 + 1 下线
+        setRegion(5); // 1 虚拟空 + 1 状态 + 1 上线 + 1 输入 + 1 下线
         paintInput({
             prompt: '❯ ',
             lines: [''],
@@ -833,11 +927,12 @@ export function enterAltScreen() {
     active = true;
     stdout.write(esc.altOn);
     stdout.write(esc.mouseOn); // SGR 鼠标追踪:滚轮发 \x1B[<btn;col;rowM 报表,经 mouse.consumeMouse 重组 → scrollBy(滚轮滚动靠此 + onKey/onRunningKey 顶部守卫)
-    setRegion(4); // 1 状态 + 1 上线 + 1 输入 + 1 下线(底栏始终含上下线)
+    setRegion(5); // 1 虚拟空 + 1 状态 + 1 上线 + 1 输入 + 1 下线(底栏始终含上下线)
     contentRow = 1;
     contentCol = 1;
     segmentStartRow = 1;
     scrollOffset = 0;
+    scrollLockUntil = 0;
     mdActive = false;
     mdBuf = '';
     content.reset();
@@ -874,6 +969,9 @@ export function exitAltScreen() {
     active = false;
     stopTurnTimer(); // 兜底清走时计时器(防异常退出泄漏)
     turnStart = null;
+    scrollLockUntil = 0; // 清轮首滚动锁(防状态泄漏到下次进 alt 屏)
+    frameRow = 0; // 清 spinner 帧位置(防状态泄漏到下次进 alt 屏)
+    frameCol = 0;
     mouse.resetMouse(); // 清鼠标重组残留(防退出后状态泄漏到下次进 alt 屏)
     // raw 还原独立 try:非 TTY / 不支持时 setRawMode 抛错,不应阻断 stdout 恢复(alt 退屏必须执行)。
     try {