lark-remote 0.5.10 → 0.5.12

package/dist/runner/kimi/acp/runner.js

@@ -144,6 +144,11 @@ export class KimiAcpRunner extends BaseAcpRunner {
      */
     compactBaselineRecords = [];
     /** 存活 terminal（kimi 把 Bash 执行下放客户端）：terminalId → 本地句柄。 */
+    // 已知限制（待验证 kimi 0.4x 契约）：句柄只在
+    // terminal/release 与连接关闭（cleanupTerminals）时删除。若服务端只 kill
+    // 不 release（中断 turn 的场景），已退出进程的句柄（含 ≤4MB output 缓冲）
+    // 会滞留到连接释放。kimi 契约上工具结束会发 release（mock 测试同驱动）；
+    // 若真机确认存在只 kill 不 release 的路径，再补 exit 后延迟回收。
     terminals = new Map();
     /** terminalId 自增序号（term-1, term-2, …）。 */
     terminalSeq = 0;
@@ -422,6 +427,11 @@ export class KimiAcpRunner extends BaseAcpRunner {
         while (true) {
             if (this.forceFinish || this.stopRequested)
                 return 'stopped';
+            // turn 已死亡（failTurn，如连接关闭）时不再轮询：forceFinish 与
+            // stopRequested 均为 false 的死亡路径会让循环空转到 10 分钟沉默超时，
+            // 结果还被 isCurrent() 丢弃——纯浪费的每秒文件读。
+            if (!this._isRunning)
+                return 'unknown';
             const records = reader.call(this.sessionReader, sessionId, opts.cwd);
             if (records.length !== lastTotalCount) {
                 lastTotalCount = records.length;
@@ -506,8 +516,15 @@ export class KimiAcpRunner extends BaseAcpRunner {
             // (error = "rejected"), otherwise the server hangs waiting for a
             // response. For question elicitation (§5.4), auto-respond cancelled.
             const rpParams = params;
-            if (method === ServerRequestMethod.REQUEST_PERMISSION &&
-                (rpParams.isQuestion || !rpParams.toolCall)) {
+            // elicitation/create 的表单属性全不可解析时（translator 返回 []）同样回
+            // cancelled 而不是 METHOD_NOT_FOUND：§5.4 的不变量是「识别到非工具审批
+            // 形态 → 自动回应 cancelled，防止服务端挂起」；错误响应虽也能解悬挂，
+            // 但 kimi 侧可能把 JSON-RPC error 当工具级失败让整个 turn 报错，而不是
+            // 跳过提问继续。
+            const isQuestionElicitation = method === ServerRequestMethod.REQUEST_PERMISSION &&
+                (rpParams.isQuestion || !rpParams.toolCall);
+            const isUnparseableElicitationForm = method === ServerRequestMethod.ELICITATION_CREATE;
+            if (isQuestionElicitation || isUnparseableElicitationForm) {
                 this.currentClient?.respond(id, { outcome: { outcome: 'cancelled' } });
                 getLogger().info(`[${this.logTag}] auto-responded cancelled to question elicitation requestId=${id}`);
             }
@@ -633,8 +650,27 @@ export class KimiAcpRunner extends BaseAcpRunner {
         proc.once('exit', (code, signal) => {
             handle.exitCode = code;
             handle.signal = signal;
-            resolveExit?.();
-            emitResult();
+            // 'exit' 可先于 stdout 缓冲派发：立刻 emit 会按旧快照推送 tool_result，
+            // 卡片面板丢尾部输出（terminal/output 反向 RPC 读到的是补齐后的全量，
+            // 只影响卡片）。等流 end 或 200ms 宽限——不等 'close'：它要等所有共享
+            // 管道的子孙进程退出，`nohup &` 类后台任务会把它拖到永远。
+            //
+            // wait_for_exit 必须在 tool_result 入队之后才 resolve：服务端拿到响应
+            // 后会立刻 release + end_turn，先 resolve 会让回合结果早于延迟推送的
+            // tool_result 到达，Bash 输出被丢弃（卡片面板空输出）。
+            const flushThenEmit = () => {
+                clearTimeout(emitTimer);
+                emitResult();
+                resolveExit?.();
+            };
+            const emitTimer = setTimeout(flushThenEmit, 200);
+            emitTimer.unref?.();
+            if (proc.stdout && !proc.stdout.destroyed) {
+                proc.stdout.once('end', flushThenEmit);
+            }
+            else {
+                flushThenEmit();
+            }
         });
         proc.once('error', (err) => {
             getLogger().warn(`[${this.logTag}] terminal process error: ${err.message}`);
@@ -642,8 +678,9 @@ export class KimiAcpRunner extends BaseAcpRunner {
                 handle.exitCode = 1;
                 handle.signal = null;
             }
-            resolveExit?.();
+            // 同 exit：tool_result 先入队，再放行 wait_for_exit。
             emitResult();
+            resolveExit?.();
         });
         const terminalId = `term-${++this.terminalSeq}`;
         this.terminals.set(terminalId, handle);

package/dist/runner/kimi/acp/translator.d.ts

@@ -29,6 +29,14 @@ import { type RequestPermissionParams, type AgentMessageChunkEvent, type AgentTh
 import { BaseAcpTranslator, type AcpTranslatorEvent } from '../../common/acp/base-translator.js';
 export declare class KimiAcpTranslator extends BaseAcpTranslator {
     protected readonly logTag = "kimi-acp-translator";
+    /**
+     * 非终态 tool_call_update 不附带空 tool_result：kimi 非 Bash 工具的
+     * in-progress 只带流式 args（rawOutput 缺省 → content ''），空 tool_result
+     * 会让 reducer 把运行中的工具提前置 ✅ + 空输出（终态到达后自愈，但终态
+     * 丢失时面板停在错误的「已完成」）。opencode 走基类默认 true（其
+     * in-progress 带输出快照，seam 契约钉死要发）。
+     */
+    protected emitToolResultForNonTerminalUpdate(content: unknown): boolean;
     /** Accumulated text per tool-call or message (keyed by a logical item id). */
     private textByItem;
     /** Accumulated thinking per item. */

package/dist/runner/kimi/acp/translator.js

@@ -42,6 +42,16 @@ const THINKING_ITEM_ID = 'thinking';
 // =============================================================================
 export class KimiAcpTranslator extends BaseAcpTranslator {
     logTag = 'kimi-acp-translator';
+    /**
+     * 非终态 tool_call_update 不附带空 tool_result：kimi 非 Bash 工具的
+     * in-progress 只带流式 args（rawOutput 缺省 → content ''），空 tool_result
+     * 会让 reducer 把运行中的工具提前置 ✅ + 空输出（终态到达后自愈，但终态
+     * 丢失时面板停在错误的「已完成」）。opencode 走基类默认 true（其
+     * in-progress 带输出快照，seam 契约钉死要发）。
+     */
+    emitToolResultForNonTerminalUpdate(content) {
+        return !(content === undefined || content === null || content === '');
+    }
     /** Accumulated text per tool-call or message (keyed by a logical item id). */
     textByItem = new Map();
     /** Accumulated thinking per item. */

package/dist/runner/pi/rpc/runner.js

@@ -113,9 +113,24 @@ export class PiRpcRunner extends ConnectionBasedRunner {
         const client = await this.manager.acquire(opts.cwd, { sessionId: opts.sessionId });
         this.manager.notifyActivity(opts.cwd);
         this.currentClient = client;
+        // 轮次代际锚点（与 BaseAcpRunner 同口径）：pi 的 shouldReuse 要求
+        // sessionId 匹配，/new、/resume 切换后的首条消息会让 acquire **同步
+        // dispose** 旧连接；terminator 等到进程退出后，旧 client 上残留的上一轮
+        // onClose 闭包会把假错误推进新 turn 的共享队列（用户消息未发出即丢失）。
+        // 旧轮迟到的 agent_settled 同理（新 turn 空转立即"成功"）。所有 hook
+        // 落地前必须过 isCurrentTurn。
+        const generation = this.turnGeneration;
         client.setHooks({
-            onEvent: (evt) => this.handleEvent(evt),
-            onClose: () => this.failTurn('Pi RPC connection closed'),
+            onEvent: (evt) => {
+                if (!this.isCurrentTurn(generation, client))
+                    return;
+                this.handleEvent(evt);
+            },
+            onClose: () => {
+                if (!this.isCurrentTurn(generation, client))
+                    return;
+                this.failTurn('Pi RPC connection closed');
+            },
         });
         let sessionId = opts.sessionId;
         if (!sessionId) {
@@ -157,9 +172,19 @@ export class PiRpcRunner extends ConnectionBasedRunner {
             const client = await this.manager.acquire(opts.cwd, { sessionId: opts.sessionId });
             this.manager.notifyActivity(opts.cwd);
             this.currentClient = client;
+            // 同 setupTurn：hook 带轮次代际锚点，旧连接的迟到回调不得进入本轮。
+            const generation = this.turnGeneration;
             client.setHooks({
-                onEvent: (evt) => this.handleEvent(evt),
-                onClose: () => this.failTurn('Pi RPC connection closed'),
+                onEvent: (evt) => {
+                    if (!this.isCurrentTurn(generation, client))
+                        return;
+                    this.handleEvent(evt);
+                },
+                onClose: () => {
+                    if (!this.isCurrentTurn(generation, client))
+                        return;
+                    this.failTurn('Pi RPC connection closed');
+                },
             });
             this.activeSessionId = opts.sessionId;
             const translator = new PiRpcTranslator();
@@ -170,7 +195,10 @@ export class PiRpcRunner extends ConnectionBasedRunner {
             this.currentTurnId = turnId;
             this.pushEvents([translator.produceTurnStarted(opts.sessionId, turnId)]);
             this.promptSettled = false;
-            const response = await client.request({ type: 'compact' });
+            // compact 是完整的 LLM 请求（同步跑完才回响应，协议文档自述），大上下文
+            // 压缩轻松超过默认 60s 请求超时——超时只会出假错误卡，压缩仍在后台完成。
+            // 活性交给 turn idle 看门狗与 /stop（与 ACP 侧 turn 级请求同口径）。
+            const response = await client.request({ type: 'compact' }, Number.POSITIVE_INFINITY);
             this.promptSettled = true;
             // Guard: a stop may have already ended this turn (deferred-stop during
             // compaction) — don't push a stale result into a (possibly reused) queue.

package/dist/runner/resolve-agent-choices.js

@@ -25,7 +25,11 @@ export function resolveAgentChoices(config) {
     const source = agentChoices;
     for (const { configKey, choicesKey } of fields) {
         const value = source[choicesKey];
-        if (!target[configKey] && value) {
+        // 只填「配置里根本没写」的字段（undefined）：显式清空（config.yaml 写了
+        // `model: ""`）是用户意志，旧真值判断 `!target[configKey]` 会把空串当
+        // 「未配置」，用残留 choices 把清空值填回去——重启后永远回不到默认。
+        // value 为空串同样不填（choices 里记录的「跟随默认」）。
+        if (target[configKey] === undefined && value) {
             target[configKey] = value;
         }
     }

package/dist/runner/sync-agent-choices.js

@@ -14,7 +14,10 @@ export function syncAgentChoices(config, agent) {
     const source = agentCfg;
     for (const { configKey, choicesKey } of fields) {
         const value = source[configKey];
-        if (value)
+        // 显式空串也要同步（用户清空 = 回到默认）：旧真值判断不同步空串，
+        // agentChoices 里残留上一次的选择——/config 卡片显示的与实际生效的
+        // 配置从此分叉，重启后 resolve 还会把残留填回 config。
+        if (value !== undefined)
             agentChoices[choicesKey] = value;
     }
     return updated;

package/dist/session/claude/session-index.js

@@ -62,8 +62,15 @@ export function parseSessionJsonl(filePath) {
         if (typeof obj.cwd === 'string' && obj.cwd) {
             cwdSet.add(obj.cwd);
         }
-        // Find first real user message for summary (same logic as summarizeSession)
-        if (!foundSummary && obj.type === 'user' && !!obj.message) {
+        // Find first real user message for summary (same logic as summarizeSession).
+        // 过滤谓词与 scalarScan 的 lastUserMessage 同源：isMeta（/clear 等命令回显
+        // 与项目规则注入）和 isCompactSummary（压缩摘要）不是用户说的话，当列表
+        // 标题会误导（codex 修过同型缺陷：注入文本被当成「最近输入」）。
+        if (!foundSummary &&
+            obj.type === 'user' &&
+            !obj.isCompactSummary &&
+            !obj.isMeta &&
+            !!obj.message) {
             const msg = obj.message;
             if (msg.content) {
                 const text = extractText(msg.content);

package/dist/session/codex/rollout-reader.js

@@ -455,6 +455,14 @@ export function readCodexSessionContent(sessionId, opts = {}) {
     if (!entry) {
         return { events: [] };
     }
+    // subagent rollout 不得当父会话历史返回：子线程 rollout 的
+    // session_meta.session_id 是父 id（§9.27），索引冲突解决在主文件缺失时会让
+    // 子文件占据该 id 的槽位，threadId 检查因等于父 id 而天然通过——list/active
+    // 都已过滤（isSubagent），按 id 读取必须同口径，否则「列表没有、active 报
+    // false、读内容却成功」三处语义互相矛盾。
+    if (entry.isSubagent) {
+        return { events: [] };
+    }
     // Cwd guard: when a cwd is provided, the session's working directory must
     // match. Without this, /resume <id> finds sessions by global ID lookup and
     // allows resuming a session from cwd B while the user is in cwd A.
@@ -495,6 +503,10 @@ export function readCodexSessionSummary(sessionId, opts = {}) {
     if (!entry) {
         return {};
     }
+    // subagent rollout 同样不得当父会话摘要（与 readCodexSessionContent 同口径）。
+    if (entry.isSubagent) {
+        return {};
+    }
     // Cwd guard: same semantics as readCodexSessionContent — when a cwd is
     // provided, the session's working directory must match.
     if (opts.cwd && !samePath(entry.cwd, opts.cwd)) {
@@ -560,42 +572,55 @@ function walkRolloutFiles(sessionsDir) {
     if (!fs.existsSync(sessionsDir))
         return [];
     const result = [];
-    try {
-        const years = fs.readdirSync(sessionsDir);
-        for (const year of years) {
-            if (!/^\d{4}$/.test(year))
+    // per-entry try/catch：目录在 readdir 与 stat 之间被删（并发归档/清理）时，
+    // 旧实现整个 walk 提前终止并返回部分结果——索引漏掉后续文件，会话从
+    // /resume 列表与 total 消失直到 5s TTL 重建。单条目失败只跳过自己。
+    const years = safeReaddir(sessionsDir);
+    for (const year of years) {
+        if (!/^\d{4}$/.test(year))
+            continue;
+        const yearPath = path.join(sessionsDir, year);
+        if (!safeIsDir(yearPath))
+            continue;
+        for (const month of safeReaddir(yearPath)) {
+            if (!/^\d{2}$/.test(month))
                 continue;
-            const yearPath = path.join(sessionsDir, year);
-            if (!fs.statSync(yearPath).isDirectory())
+            const monthPath = path.join(yearPath, month);
+            if (!safeIsDir(monthPath))
                 continue;
-            const months = fs.readdirSync(yearPath);
-            for (const month of months) {
-                if (!/^\d{2}$/.test(month))
+            for (const day of safeReaddir(monthPath)) {
+                if (!/^\d{2}$/.test(day))
                     continue;
-                const monthPath = path.join(yearPath, month);
-                if (!fs.statSync(monthPath).isDirectory())
+                const dayPath = path.join(monthPath, day);
+                if (!safeIsDir(dayPath))
                     continue;
-                const days = fs.readdirSync(monthPath);
-                for (const day of days) {
-                    if (!/^\d{2}$/.test(day))
-                        continue;
-                    const dayPath = path.join(monthPath, day);
-                    if (!fs.statSync(dayPath).isDirectory())
-                        continue;
-                    const files = fs
-                        .readdirSync(dayPath)
-                        .filter((f) => f.startsWith('rollout-') && f.endsWith('.jsonl'));
-                    for (const file of files) {
-                        result.push(path.join(dayPath, file));
-                    }
+                const files = safeReaddir(dayPath).filter((f) => f.startsWith('rollout-') && f.endsWith('.jsonl'));
+                for (const file of files) {
+                    result.push(path.join(dayPath, file));
                 }
             }
         }
     }
+    return result;
+}
+/** readdir 的竞态安全版：目录消失/不可读返回空并记 debug（外层不再中断）。 */
+function safeReaddir(dir) {
+    try {
+        return fs.readdirSync(dir);
+    }
     catch (err) {
-        getLogger().warn(`[codex-rollout-reader] failed to walk sessions dir: ${err}`);
+        getLogger().debug(`[codex-rollout-reader] readdir failed (raced delete?): ${err}`);
+        return [];
+    }
+}
+/** statSync 的竞态安全目录判定。 */
+function safeIsDir(p) {
+    try {
+        return fs.statSync(p).isDirectory();
+    }
+    catch {
+        return false;
     }
-    return result;
 }
 const INDEX_TTL_MS = 5_000; // 5 seconds — covers a single /resume flow
 const sessionIndexCache = new Map();

package/dist/session/common/usage-accumulator.d.ts

@@ -55,9 +55,18 @@ export declare class UsageAccumulator {
      */
     bumpCompact(): void;
 }
-/** 统一契约：上下文窗口占用 = 末轮 input + cacheRead + cacheCreation（不含 output/reasoning）。 */
+/**
+ * 统一契约：上下文窗口占用 = 末轮 input + output + cacheRead + cacheCreation。
+ *
+ * 口径以 design.md §9.13/§9.21 为准（文档在 6 处钉死该公式）：上下文占用衡量
+ * 「本轮结束后窗口里有多少 token」，末轮 output 已进入历史、下一个 prompt 会
+ * 全量携带；与 max() 另一侧的 compact postTokens（含全部内容的压缩后水位）
+ * 语义对齐。此前实现漏加 output（长收尾 turn 可低估数千~3 万 token），且
+ * compact 会话与非 compact 会话两口径不可比。
+ */
 export declare function contextWindowOccupancy(l: {
     input: number;
+    output: number;
     cacheRead: number;
     cacheCreation: number;
 }): number;

package/dist/session/common/usage-accumulator.js

@@ -69,9 +69,17 @@ export class UsageAccumulator {
         this._compactCount++;
     }
 }
-/** 统一契约：上下文窗口占用 = 末轮 input + cacheRead + cacheCreation（不含 output/reasoning）。 */
+/**
+ * 统一契约：上下文窗口占用 = 末轮 input + output + cacheRead + cacheCreation。
+ *
+ * 口径以 design.md §9.13/§9.21 为准（文档在 6 处钉死该公式）：上下文占用衡量
+ * 「本轮结束后窗口里有多少 token」，末轮 output 已进入历史、下一个 prompt 会
+ * 全量携带；与 max() 另一侧的 compact postTokens（含全部内容的压缩后水位）
+ * 语义对齐。此前实现漏加 output（长收尾 turn 可低估数千~3 万 token），且
+ * compact 会话与非 compact 会话两口径不可比。
+ */
 export function contextWindowOccupancy(l) {
-    return l.input + l.cacheRead + l.cacheCreation;
+    return l.input + l.output + l.cacheRead + l.cacheCreation;
 }
 /** 统一契约：session 全量累计字段组装（4 个 reader 共用：claude/dsh/kimi/pi；
  * codex 走 last_token_usage 口径、opencode 保留自己的条件赋值，原为逐字段复制的 4 连拷贝）。 */

package/dist/session/dsh/sessions.js

@@ -285,7 +285,11 @@ export class DshSessionReader {
                 const input = lastUsage.inputTokens ?? 0;
                 const cacheRead = lastUsage.cacheReadTokens ?? 0;
                 const cacheWrite = lastUsage.cacheWriteTokens ?? 0;
-                const flow = lastTurnUsage ?? {
+                // 在途 turn（turn/start 无 turn/end，run 进行中读历史）的采样优先于
+                // 上一轮：旧实现只认已结算的 lastTurnUsage，mid-run 读取会把当前 turn
+                // 已消耗的量显示成上一个完整 turn 的数字。
+                const flow = lastTurnUsage ??
+                    turnUsage ?? {
                     input,
                     output: lastUsage.outputTokens ?? 0,
                     cacheRead,
@@ -294,7 +298,8 @@ export class DshSessionReader {
                 sessionUsage = {
                     inputTokens: flow.input,
                     outputTokens: flow.output,
-                    contextLength: input + cacheRead + cacheWrite,
+                    // §9.21 口径：含末轮 output（下一 prompt 全量携带，与 postTokens 水位同语义）。
+                    contextLength: input + flow.output + cacheRead + cacheWrite,
                     cacheReadTokens: flow.cacheRead,
                     cacheCreationTokens: flow.cacheWrite,
                     totalTokens: flow.input + flow.output + flow.cacheRead + flow.cacheWrite,
@@ -432,11 +437,27 @@ const TEXT_MAX_BYTES = 2_000;
 /** 工具原始参数上限（标题已有摘要，正文只用于看完整命令）。 */
 const TOOL_INPUT_MAX_BYTES = 600;
 /** Map one DSH SessionEvent to display content events (+ title/usage side effects). */
+/**
+ * 单条畸形事件只跳过自己，不炸整张卡：DSH 服务端格式漂移时（time 非法、
+ * content 非数组），旧实现会让异常冒到外层 catch 把整个 resume 卡变成空卡
+ * （fail-whole）。时间戳缺失由卡片层兜底；content 非数组按无块处理。
+ */
+function safeEventTimestamp(time) {
+    if (typeof time !== 'string' && typeof time !== 'number')
+        return undefined;
+    const d = new Date(time);
+    return Number.isNaN(d.getTime()) ? undefined : d.toISOString();
+}
+function asBlocks(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((b) => !!b && typeof b === 'object');
+}
 function mapEvent(ev) {
     const out = { events: [] };
     switch (ev.type) {
         case 'user/message': {
-            const content = ev.data.content ?? [];
+            const content = asBlocks(ev.data.content);
             const text = content
                 .filter((c) => c.type === 'text')
                 .map((c) => c.text ?? '')
@@ -456,14 +477,13 @@ function mapEvent(ev) {
                 type: isNotice ? 'notice' : 'user',
                 ...(isNotice ? { title: '🔔 通知' } : {}),
                 content: isNotice ? truncateUtf8(text.trim(), NOTICE_MAX_BYTES) : text,
-                timestamp: new Date(ev.time).toISOString(),
+                timestamp: safeEventTimestamp(ev.time),
             });
             break;
         }
         case 'assistant/message': {
-            const content = ev.data.message
-                ?.content ?? [];
-            const timestamp = new Date(ev.time).toISOString();
+            const content = asBlocks(ev.data.message?.content);
+            const timestamp = safeEventTimestamp(ev.time);
             // DSH 的块类型是 text / reasoning / tool-call（不是 Anthropic 的
             // thinking）。只认 text 会让 resume 卡"只有工具调用、没有思考与输出"
             // （2026-10-19 反馈：一个 31 turn 的会话里 reasoning 块 371 个、text 12 个，
@@ -503,7 +523,7 @@ function mapEvent(ev) {
                 type: 'tool_use',
                 title: summary ? `🔧 ${name} — ${summary}` : `🔧 ${name}`,
                 content: truncateUtf8(args, TOOL_INPUT_MAX_BYTES),
-                timestamp: new Date(ev.time).toISOString(),
+                timestamp: safeEventTimestamp(ev.time),
             };
             break;
         }
@@ -515,7 +535,7 @@ function mapEvent(ev) {
                 type: 'tool_result',
                 title: isError ? '🔴 结果（失败）' : '🟢 结果',
                 content: truncateUtf8(raw, TOOL_RESULT_MAX_BYTES),
-                timestamp: new Date(ev.time).toISOString(),
+                timestamp: safeEventTimestamp(ev.time),
             });
             break;
         }

package/dist/session/kimi/sessions.js

@@ -227,7 +227,10 @@ export class KimiSessionReader {
                         entryWorkDir = extractWorkDir(state);
                     // Unreadable state — cannot determine cwd, entryWorkDir stays undefined
                 }
-                if (entryWorkDir !== realCwd) {
+                // cwd 判定与守卫（checkCwdGuard 的 samePath）同口径：严格字符串比较会
+                // 把大小写（darwin）/尾分隔符形态不同的会话从列表里滤掉，而 /resume <id>
+                // 的守卫却判等通过——「列表没有、按 id 却能读」。
+                if (entryWorkDir === undefined || !samePath(entryWorkDir, realCwd)) {
                     continue;
                 }
                 let summary = 'New Session';
@@ -332,9 +335,10 @@ export class KimiSessionReader {
                     cacheCreation: inputCacheCreation,
                 });
                 if (updateContextLength) {
-                    // unified contract: input + cacheRead + cacheCreation
-                    // (excludes output — generated, not part of the input window).
-                    mainContextLength = inputOther + inputCacheRead + inputCacheCreation;
+                    // unified contract (§9.21): input + output + cacheRead + cacheCreation.
+                    // 末轮 output 已进入历史、下一 prompt 全量携带——与 compact postTokens
+                    // 水位同语义（此前漏加 output 会系统性低估长收尾 turn）。
+                    mainContextLength = inputOther + output + inputCacheRead + inputCacheCreation;
                 }
             };
             for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
@@ -593,7 +597,7 @@ export class KimiSessionReader {
         // different cwd when state.json is unavailable.
         if (!cwdGuardPassed) {
             const indexWorkDir = indexEntry?.workDir;
-            if (indexWorkDir && indexWorkDir !== realCwd) {
+            if (indexWorkDir && !samePath(indexWorkDir, realCwd)) {
                 return null;
             }
             // v2 sessions have empty index workDir (v1-only field) and may lack

package/dist/session/opencode/sessions.js

@@ -243,14 +243,16 @@ export class OpencodeSessionReader {
                         // all render 0). Skip zero-total steps so per-turn usage reflects
                         // the last step that actually consumed tokens.
                         // ccusage-aligned: cache.write -> cacheCreationTokens.
-                        // contextLength = input + cacheRead + cacheCreation (excludes
-                        // output/reasoning) — the unified context-window occupancy
-                        // contract across all five readers.
+                        // contextLength = input + output + cacheRead + cacheCreation —
+                        // the unified context-window occupancy contract across all readers
+                        // (§9.21：末轮 output 已进入历史、下一 prompt 全量携带，与 compact
+                        // postTokens 水位同语义).
                         if ((part.tokens.total ?? 0) !== 0) {
                             usage = {
                                 inputTokens: part.tokens.input,
                                 outputTokens: part.tokens.output,
-                                contextLength: part.tokens.input +
+                                contextLength: (part.tokens.input ?? 0) +
+                                    (part.tokens.output ?? 0) +
                                     (part.tokens.cache?.read ?? 0) +
                                     (part.tokens.cache?.write ?? 0),
                                 cacheReadTokens: part.tokens.cache?.read,
@@ -460,7 +462,8 @@ export class OpencodeSessionReader {
                 latest = {
                     inputTokens: tokens.input,
                     outputTokens: tokens.output,
-                    contextLength: tokens.input + cacheRead + cacheWrite,
+                    // §9.21 口径：含末轮 output（与 postTokens 水位同语义）。
+                    contextLength: tokens.input + tokens.output + cacheRead + cacheWrite,
                     cacheReadTokens: cacheRead,
                     cacheCreationTokens: cacheWrite,
                     totalTokens: total,
@@ -628,7 +631,11 @@ export class OpencodeSessionReader {
      * stdout when it is redirected to a file fd, so we read the file instead.
      */
     captureExportViaFileFd(sessionId) {
-        const tmp = path.join(os.tmpdir(), `opencode-export-${sessionId}-${process.pid}-${Date.now()}.json`);
+        // sessionId 经 path.basename 净化：它来自用户 /resume <id> 输入或畸形 CLI
+        // 数据，含 / 或 .. 时 path.join 会归一化出 tmpdir 之外的路径（写入内容为
+        // CLI stdout，可能截断/覆盖目标文件）。
+        const safeId = path.basename(sessionId);
+        const tmp = path.join(os.tmpdir(), `opencode-export-${safeId}-${process.pid}-${Date.now()}.json`);
         let fd;
         try {
             const exportOpts = {

package/dist/session/session-store.js

@@ -230,9 +230,10 @@ export class SessionStore {
                 for (const [userId, data] of Object.entries(parsed)) {
                     if (typeof data === 'object' && data !== null) {
                         const entry = data;
-                        // All four session fields are required; a missing one indicates a
-                        // corrupt record — skip it entirely. cwd is allowed to be absent
-                        // (legitimately-empty cwd state, see round7 tests).
+                        // 四个 session 字段缺失 = 损坏记录，整条跳过。cwd 允许缺失：
+                        // 全新用户（未 /cd）先切 agent 时 previous/arrival 停车位已落盘，
+                        // cwd 尚为空——不能因 cwd 缺失把停车位整条丢掉
+                        // （anchor_r7_parked_previous_survives_rebuild_without_cwd）。
                         if (!entry.sessions ||
                             !entry.previousSessions ||
                             !entry.arrivalSessions ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lark-remote",
-  "version": "0.5.10",
+  "version": "0.5.12",
   "description": "Feishu (Lark) private-chat bridge to local coding agents — Claude Code / Codex / opencode / pi / kimi, with live-streaming CardKit 2.0 cards",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",