lark-remote 0.1.5 → 0.1.7

package/dist/card/card-budget.js

@@ -1,6 +1,4 @@
-import { truncateUtf8, truncateMarkdownTables, countMarkdownTables, FEISHU_MAX_TABLES, } from './text-truncate.js';
-// 飞书卡片大小限制（安全阈值，取 run-renderer 相同值）
-const CARD_BUDGET_BYTES = 28_000;
+import { truncateUtf8, truncateMarkdownTables, countMarkdownTables, FEISHU_MAX_TABLES, CARD_BUDGET_BYTES, } from './text-truncate.js';
 /**
  * 静态卡片体积保护
  *
@@ -17,7 +15,6 @@ export function enforceCardBudget(card, opts = {}) {
     const totalTables = countCardTables(JSON.parse(cardStr));
     if (totalTables > FEISHU_MAX_TABLES) {
         // 深拷贝后对每个 lark_md 文本做 truncateMarkdownTables
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const fixed = JSON.parse(cardStr);
         truncateCardMarkdownTables(fixed);
         const fixedStr = JSON.stringify(fixed);
@@ -38,7 +35,6 @@ export function enforceCardBudget(card, opts = {}) {
         return { card, wasTruncated: false, bytesBefore, bytesAfter: bytesBefore };
     }
     // 字节超限但 table 不超限
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return enforceByteBudget(JSON.parse(cardStr), opts, bytesBefore);
 }
 /**
@@ -59,12 +55,9 @@ export function enforceCardBudget(card, opts = {}) {
  *   阶段4 截断剩余顶层 div 文本
  *   阶段5 最终兜底 minimal card（骨架本身已超限的病理场景）
  */
-function enforceByteBudget(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-truncated, opts = {}, bytesBefore) {
+function enforceByteBudget(truncated, opts = {}, bytesBefore) {
     const { maxEventPanels = 5, maxPanelContentBytes = 2000, truncationHint = '📜 还有 {count} 个事件未显示', } = opts;
     const reasons = [];
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const elements = truncated.body?.elements ?? [];
     const size = () => Buffer.byteLength(JSON.stringify(truncated), 'utf8');
     const done = (wasTruncated) => ({
@@ -173,7 +166,6 @@ truncated, opts = {}, bytesBefore) {
 /**
  * 在卡片头部插入「N 个事件未显示」提示（仅在有面板被移除时）。
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function insertOmittedHint(elements, omitted, truncationHint) {
     if (omitted <= 0)
         return;
@@ -185,7 +177,6 @@ function insertOmittedHint(elements, omitted, truncationHint) {
 /**
  * 获取所有 collapsible_panel 的索引（结构化判定，不看标题文本）。
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function getPanelIndices(elements) {
     const indices = [];
     for (let i = 0; i < elements.length; i++) {
@@ -196,84 +187,47 @@ function getPanelIndices(elements) {
     return indices;
 }
 /**
- * Count all markdown tables across every lark_md text field in a card JSON.
- * Recursively walks elements, collapsible_panel.elements, column.elements, etc.
+ * 遍历卡片元素树（含 collapsible_panel.elements 与 column_set.columns[].elements）。
+ *
+ * count 与 truncate 两条路径共用同一遍历，避免两套递归漂移（G5 Duplication）。
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function countCardTables(card) {
-    let total = 0;
-    const elements = card?.body?.elements ?? [];
+function walkCardElements(elements, visit) {
     for (const el of elements) {
-        total += countElementTables(el);
+        visit(el);
+        if (Array.isArray(el.elements))
+            walkCardElements(el.elements, visit);
+        if (Array.isArray(el.columns)) {
+            for (const col of el.columns) {
+                if (Array.isArray(col.elements))
+                    walkCardElements(col.elements, visit);
+            }
+        }
     }
-    return total;
 }
 /**
- * Recursively count markdown tables in a single element and its children.
+ * Count all markdown tables across every lark_md text field in a card JSON.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function countElementTables(el) {
-    let count = 0;
-    // lark_md div text
-    if (el.text?.tag === 'lark_md' && typeof el.text.content === 'string') {
-        count += countMarkdownTables(el.text.content);
-    }
-    // collapsible_panel inner elements
-    if (Array.isArray(el.elements)) {
-        for (const child of el.elements) {
-            count += countElementTables(child);
-        }
-    }
-    // column_set → columns → elements
-    if (Array.isArray(el.columns)) {
-        for (const col of el.columns) {
-            if (Array.isArray(col.elements)) {
-                for (const child of col.elements) {
-                    count += countElementTables(child);
-                }
-            }
+function countCardTables(card) {
+    let total = 0;
+    walkCardElements(card?.body?.elements ?? [], (el) => {
+        if (el.text?.tag === 'lark_md' && typeof el.text.content === 'string') {
+            total += countMarkdownTables(el.text.content);
         }
-    }
-    return count;
+    });
+    return total;
 }
 /**
  * In-place truncate markdown tables in every lark_md text field of a card,
  * keeping at most FEISHU_MAX_TABLES per field.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function truncateCardMarkdownTables(card) {
-    const elements = card?.body?.elements ?? [];
-    for (const el of elements) {
-        truncateElementTables(el);
-    }
-}
-/**
- * Recursively truncate markdown tables in a single element and its children.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function truncateElementTables(el) {
-    // lark_md div text
-    if (el.text?.tag === 'lark_md' && typeof el.text.content === 'string') {
-        const truncated = truncateMarkdownTables(el.text.content);
-        if (truncated !== el.text.content) {
-            el.text.content = truncated;
-        }
-    }
-    // collapsible_panel inner elements
-    if (Array.isArray(el.elements)) {
-        for (const child of el.elements) {
-            truncateElementTables(child);
-        }
-    }
-    // column_set → columns → elements
-    if (Array.isArray(el.columns)) {
-        for (const col of el.columns) {
-            if (Array.isArray(col.elements)) {
-                for (const child of col.elements) {
-                    truncateElementTables(child);
-                }
+    walkCardElements(card?.body?.elements ?? [], (el) => {
+        if (el.text?.tag === 'lark_md' && typeof el.text.content === 'string') {
+            const truncated = truncateMarkdownTables(el.text.content);
+            if (truncated !== el.text.content) {
+                el.text.content = truncated;
             }
         }
-    }
+    });
 }
 //# sourceMappingURL=card-budget.js.map

package/dist/card/card-session.d.ts

@@ -52,10 +52,58 @@ export declare abstract class CardSession<S, RO = unknown> {
         renderOptions?: RO;
         startTimeoutMs?: number;
         settleTimeoutMs?: number;
+        /** update/push 合批窗口，默认 100ms（0 = 禁用合批，每事件立即 flush）。 */
+        coalesceMs?: number;
     });
+    /**
+     * 调度一次延迟 flush。已有 pending 调度则复用（合批核心）；否则起一个
+     * coalesceMs 定时器。flushInFlight 期间不再起 timer（避免重入叠加），但置
+     * pendingReschedule 以便 in-flight flush 完成后重新调度——否则 in-flight 期间
+     * 到达的 push/update 会停留为 stale 中间帧（P2-1）。
+     */
+    protected scheduleFlush(): void;
+    /**
+     * 执行一次 render + updateCard。合批窗口到期或 finish 即时 flush 时调用。
+     * flushInFlight 防止 timer 回调与 finish 的即时 flush 重入。
+     *
+     * 终态守卫：若 finish() 已把 state 转为终态，跳过本次 patch——避免 in-flight flush
+     * 用 pre-terminal state 覆盖 finish 已发的终态卡。finish() 自身会 await 任何
+     * in-flight flush 保证顺序，此守卫是双保险。
+     */
+    protected flush(): Promise<void>;
+    /**
+     * Whether the current state still permits a flush (i.e. is not yet terminal).
+     * Subclasses define their terminal set. Run treats 'finalizing' as non-terminal.
+     */
+    protected abstract isFlushableState(): boolean;
+    /**
+     * 取消待 flush 的合批调度（finish/settle 前清理，避免延迟 update 与终态
+     * 渲染竞争）。返回是否有被取消的 pending 调度。同时清掉 pendingReschedule，
+     * 防止 in-flight flush 的 finally 在 finish await 之后又起 dangling timer
+     * （finish 自身会渲染含累积事件的终态卡，无需 follow-up）。
+     */
+    protected cancelPendingFlush(): boolean;
     get currentState(): S;
     /** The messageId of the streaming card, available after `start()` resolves. */
     get cardMessageId(): string | undefined;
+    /**
+     * P1-3 合批窗口（ms）。连续事件各触发一次全卡 render + patch 是流式 CPU 主要
+     * 来源；窗口内多个事件复用同一次延迟 flush。窗口大小可通过 constructor 覆盖
+     * （测试用小窗口/0 禁用）。run/bash 子类共用的 flush 骨架（scheduleFlush/flush/
+     * cancelPendingFlush/settle）下沉到基类。
+     */
+    protected readonly coalesceMs: number;
+    private flushTimer;
+    private flushInFlight; /** P2-1：in-flight flush 期间到达的 push/update 标记。scheduleFlush 在
+     *  flushInFlight 时早退不调度新 timer，但事件已 reduce 进 state；若无此标志，
+     *  in-flight flush 完成后该事件无 follow-up render，停留为 stale 中间帧。
+     *  finally 检查此标志后重新 scheduleFlush，保证 in-flight 期间累积的事件最终被渲染。 */
+    private pendingReschedule;
+    /** 当前 in-flight flush 的 promise（若 flush 正在 await updateCard）。
+     *  finish() 在终态 patch 前 await 它，保证 in-flight 的 pre-terminal patch 先落地、
+     *  terminal patch 后落地——否则两条 controller.update 并发无 FIFO，
+     *  pre-terminal 可能在 terminal 之后 resolve 留下"思考中"终帧（P2）。 */
+    protected flushP: Promise<void> | undefined;
     start(): Promise<void>;
     settle(): Promise<StreamSettleResult>;
     /**

package/dist/card/card-session.js

@@ -40,6 +40,74 @@ export class CardSession {
             this.resolveController = resolve;
             this.rejectController = reject;
         });
+        this.coalesceMs = opts.coalesceMs ?? 100;
+    }
+    /**
+     * 调度一次延迟 flush。已有 pending 调度则复用（合批核心）；否则起一个
+     * coalesceMs 定时器。flushInFlight 期间不再起 timer（避免重入叠加），但置
+     * pendingReschedule 以便 in-flight flush 完成后重新调度——否则 in-flight 期间
+     * 到达的 push/update 会停留为 stale 中间帧（P2-1）。
+     */
+    scheduleFlush() {
+        if (this.flushTimer)
+            return;
+        if (this.flushInFlight) {
+            this.pendingReschedule = true;
+            return;
+        }
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = undefined;
+            void this.flush();
+        }, this.coalesceMs);
+    }
+    /**
+     * 执行一次 render + updateCard。合批窗口到期或 finish 即时 flush 时调用。
+     * flushInFlight 防止 timer 回调与 finish 的即时 flush 重入。
+     *
+     * 终态守卫：若 finish() 已把 state 转为终态，跳过本次 patch——避免 in-flight flush
+     * 用 pre-terminal state 覆盖 finish 已发的终态卡。finish() 自身会 await 任何
+     * in-flight flush 保证顺序，此守卫是双保险。
+     */
+    async flush() {
+        if (this.flushInFlight)
+            return;
+        if (!this.isFlushableState())
+            return;
+        this.flushInFlight = true;
+        const flushPromise = (async () => {
+            try {
+                await this.updateCard();
+            }
+            finally {
+                this.flushInFlight = false;
+                // flushInFlight 守卫保证同一时刻只有一个 in-flight flush，故可无条件清空。
+                this.flushP = undefined;
+                // P2-1：in-flight 期间若有 push/update 到达（pendingReschedule），重新调度一次
+                // flush 渲染累积事件，避免 stale 中间帧。终态守卫在 flush() 入口已拦截，
+                // 故 finish 后不会误触发。
+                if (this.pendingReschedule) {
+                    this.pendingReschedule = false;
+                    this.scheduleFlush();
+                }
+            }
+        })();
+        this.flushP = flushPromise;
+        return flushPromise;
+    }
+    /**
+     * 取消待 flush 的合批调度（finish/settle 前清理，避免延迟 update 与终态
+     * 渲染竞争）。返回是否有被取消的 pending 调度。同时清掉 pendingReschedule，
+     * 防止 in-flight flush 的 finally 在 finish await 之后又起 dangling timer
+     * （finish 自身会渲染含累积事件的终态卡，无需 follow-up）。
+     */
+    cancelPendingFlush() {
+        this.pendingReschedule = false;
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = undefined;
+            return true;
+        }
+        return false;
     }
     get currentState() {
         return this.state;
@@ -48,6 +116,24 @@ export class CardSession {
     get cardMessageId() {
         return this.messageId;
     }
+    /**
+     * P1-3 合批窗口（ms）。连续事件各触发一次全卡 render + patch 是流式 CPU 主要
+     * 来源；窗口内多个事件复用同一次延迟 flush。窗口大小可通过 constructor 覆盖
+     * （测试用小窗口/0 禁用）。run/bash 子类共用的 flush 骨架（scheduleFlush/flush/
+     * cancelPendingFlush/settle）下沉到基类。
+     */
+    coalesceMs;
+    flushTimer;
+    flushInFlight = false; /** P2-1：in-flight flush 期间到达的 push/update 标记。scheduleFlush 在
+     *  flushInFlight 时早退不调度新 timer，但事件已 reduce 进 state；若无此标志，
+     *  in-flight flush 完成后该事件无 follow-up render，停留为 stale 中间帧。
+     *  finally 检查此标志后重新 scheduleFlush，保证 in-flight 期间累积的事件最终被渲染。 */
+    pendingReschedule = false;
+    /** 当前 in-flight flush 的 promise（若 flush 正在 await updateCard）。
+     *  finish() 在终态 patch 前 await 它，保证 in-flight 的 pre-terminal patch 先落地、
+     *  terminal patch 后落地——否则两条 controller.update 并发无 FIFO，
+     *  pre-terminal 可能在 terminal 之后 resolve 留下"思考中"终帧（P2）。 */
+    flushP;
     async start() {
         if (this.streamOutcome) {
             // 二次调用也套 timeout 保护：若 controllerReady 永不 settle（首次超时失败），

package/dist/card/card-shared.d.ts

@@ -1,8 +1,4 @@
 import { type AgentKind } from '../runner/index.js';
-interface TruncateOptions {
-    suffix?: string;
-    normalizeWhitespace?: boolean;
-}
 /**
  * Display name for an agent kind in the run card header.
  *
@@ -11,7 +7,7 @@ interface TruncateOptions {
  * wire up the registry (notably unit tests of pure render helpers).
  */
 export declare function agentDisplayName(kind: string): string;
-export declare function truncate(str: string, max: number, options?: TruncateOptions): string;
+export { truncate } from '../common/truncate.js';
 interface TerminalLabelOptions {
     prefix?: string;
 }
@@ -27,10 +23,17 @@ export declare function stopButton(runId: string): object;
  */
 export declare function newSessionButton(): object;
 /**
- * Create a CardKit 2.0 "resume session" button with behaviors callback.
- * Carries both sessionId and agent so the handler routes to the correct
- * agent's session reader (P2 fix: completion cards from non-default agents
- * must carry agent to avoid wrong-reader fallback).
+ * Create a CardKit 2.0 Compact button for Codex app-server mode.
+ * Triggers thread/compact/start via the codex.compact callback.
+ */
+export declare function compactButton(runId: string): object;
+/**
+ * Create a CardKit 2.0 Compact button for resume cards (auto-resume / `/resume <id>`).
+ * Unlike compactButton (which targets a finished run's runId), this targets a
+ * sessionId directly: the bridge resolves the session and calls the app-server
+ * runner's runCompact() without a runId. Carries agent so the handler routes
+ * to the correct session reader + runner when the card was rendered for a
+ * non-default agent.
  */
+export declare function resumeCompactButton(sessionId: string, agent: string): object;
 export declare function resumeUseButton(sessionId: string, agent: AgentKind): object;
-export {};

package/dist/card/card-shared.js

@@ -25,26 +25,7 @@ export function agentDisplayName(kind) {
         return 'Kimi';
     return kind;
 }
-export function truncate(str, max, options) {
-    const suffix = options?.suffix ?? '…';
-    const normalize = options?.normalizeWhitespace ?? false;
-    let s = str;
-    if (normalize)
-        s = s.replace(/\s+/g, ' ').trim();
-    if (s.length <= max)
-        return s;
-    const suffixLen = suffix.length;
-    const budget = max - suffixLen;
-    if (budget <= 0)
-        return suffix;
-    let end = 0;
-    for (const ch of s) {
-        if (end + ch.length > budget)
-            break;
-        end += ch.length;
-    }
-    return s.slice(0, end) + suffix;
-}
+export { truncate } from '../common/truncate.js';
 const TERMINAL_LABELS = {
     done: '已完成',
     error: '出错',
@@ -97,11 +78,33 @@ export function newSessionButton() {
     };
 }
 /**
- * Create a CardKit 2.0 "resume session" button with behaviors callback.
- * Carries both sessionId and agent so the handler routes to the correct
- * agent's session reader (P2 fix: completion cards from non-default agents
- * must carry agent to avoid wrong-reader fallback).
+ * Create a CardKit 2.0 Compact button for Codex app-server mode.
+ * Triggers thread/compact/start via the codex.compact callback.
+ */
+export function compactButton(runId) {
+    return {
+        tag: 'button',
+        text: { content: '🗜 Compact' },
+        type: 'primary',
+        behaviors: [{ type: 'callback', value: { cmd: 'codex.compact', runId } }],
+    };
+}
+/**
+ * Create a CardKit 2.0 Compact button for resume cards (auto-resume / `/resume <id>`).
+ * Unlike compactButton (which targets a finished run's runId), this targets a
+ * sessionId directly: the bridge resolves the session and calls the app-server
+ * runner's runCompact() without a runId. Carries agent so the handler routes
+ * to the correct session reader + runner when the card was rendered for a
+ * non-default agent.
  */
+export function resumeCompactButton(sessionId, agent) {
+    return {
+        tag: 'button',
+        text: { content: '🗜 Compact' },
+        type: 'primary',
+        behaviors: [{ type: 'callback', value: { cmd: 'resume.compact', sessionId, agent } }],
+    };
+}
 export function resumeUseButton(sessionId, agent) {
     return {
         tag: 'button',

package/dist/card/run-card-session.d.ts

@@ -1,34 +1,9 @@
-import { CardSession, type CardChannel, type StreamSettleResult } from './card-session.js';
+import { CardSession, type CardChannel } from './card-session.js';
 import type { AgentEvent } from '../runner/index.js';
 import { type FinishMeta, type RunState, type RunTerminal } from './run-state.js';
 import { type RunCardRenderOptions } from './run-renderer.js';
 export type { CardChannel as RunCardChannel };
 export declare class RunCardSession extends CardSession<RunState, RunCardRenderOptions> {
-    /**
-     * P1-3 push 合批窗口（ms）。连续 text delta 各触发一次全卡 render + patch 是
-     * 流式 CPU 主要来源（§P1-3）。窗口内多个事件复用同一次
-     * 延迟 flush，只 render + controller.update 一次。100ms 内人眼无感，且 text
-     * 流式 patch 次数 -80%。窗口大小可通过 constructor 覆盖（测试用小窗口）。
-     */
-    private readonly coalesceMs;
-    private flushTimer;
-    private flushInFlight;
-    /**
-     * P2-1：in-flight flush 期间到达的 push 标记。scheduleFlush 在 flushInFlight
-     * 时早退不调度新 timer，但事件已 reduce 进 state；若无此标志，in-flight flush
-     * 完成后该事件无 follow-up render，停留为 stale 中间帧（生产 SDK 的
-     * controller.update 经 throttle + setTimeout 异步 resolve，故 flush 与
-     * 下一个 push 交叠是真实场景）。finally 检查此标志后重新 scheduleFlush，
-     * 保证 in-flight 期间累积的事件最终被渲染。
-     */
-    private pendingReschedule;
-    /**
-     * 当前 in-flight flush 的 promise（若 flush 正在 await updateCard）。
-     * finish() 在终态 patch 前 await 它，保证 in-flight 的 pre-terminal patch
-     * 先落地、terminal patch 后落地——否则两条 controller.update 并发无 FIFO，
-     * pre-terminal 可能在 terminal 之后 resolve 留下"思考中"终帧（P2）。
-     */
-    private flushP;
     constructor(opts: {
         connector: CardChannel;
         chatId: string;
@@ -44,35 +19,7 @@ export declare class RunCardSession extends CardSession<RunState, RunCardRenderO
     protected get errorPrefix(): string;
     protected renderCard(state: RunState, options: RunCardRenderOptions): object;
     protected hasOwnBudgetProtection(): boolean;
+    protected isFlushableState(): boolean;
     push(event: AgentEvent): Promise<void>;
-    /**
-     * 调度一次延迟 flush。已有 pending 调度则复用（合批核心）；否则起一个
-     * coalesceMs 定时器。flushInFlight 期间不再起 timer（避免重入叠加），但置
-     * pendingReschedule 以便 in-flight flush 完成后重新调度——否则 in-flight 期间
-     * 到达的 push 会停留为 stale 中间帧（P2-1）。
-     */
-    private scheduleFlush;
-    /**
-     * 执行一次 render + updateCard。合批窗口到期或 finish 立即 flush 时调用。
-     * flushInFlight 防止 timer 回调与 finish 的即时 flush 重入。
-     *
-     * 终态守卫：若 finish() 已把 state 转为终态（done/error/interrupted/idle_timeout），
-     * 跳过本次 patch——避免 in-flight flush 用 pre-terminal state 覆盖 finish 已发的
-     * 终态卡。finish() 自身会 await 任何 in-flight flush 保证顺序，此守卫是双保险。
-     */
-    private flush;
-    /**
-     * 取消待 flush 的合批调度（finish/settle 前清理，避免延迟 update 与终态
-     * 渲染竞争）。返回是否有被取消的 pending 调度。同时清掉 pendingReschedule，
-     * 防止 in-flight flush 的 finally 在 finish await 之后又起 dangling timer
-     * （finish 自身会渲染含累积事件的终态卡，无需 follow-up）。
-     */
-    private cancelPendingFlush;
     finish(terminal: Exclude<RunTerminal, 'running' | 'finalizing'>, meta?: FinishMeta): Promise<void>;
-    /**
-     * settle 前兜底取消合批调度。bridge 正常流程 finish→settle，finish 已 cancel；
-     * 但若未来有直调 settle（未经 finish）的路径，避免 dangling timer 在 release
-     * 后触发 void flush() 去更新已释放的 stream（harmless 但无谓）。
-     */
-    settle(): Promise<StreamSettleResult>;
 }

package/dist/card/run-card-session.js

@@ -2,31 +2,6 @@ import { CardSession } from './card-session.js';
 import { createInitialRunState, finishRun, reduceRunState, } from './run-state.js';
 import { renderRunCard } from './run-renderer.js';
 export class RunCardSession extends CardSession {
-    /**
-     * P1-3 push 合批窗口（ms）。连续 text delta 各触发一次全卡 render + patch 是
-     * 流式 CPU 主要来源（§P1-3）。窗口内多个事件复用同一次
-     * 延迟 flush，只 render + controller.update 一次。100ms 内人眼无感，且 text
-     * 流式 patch 次数 -80%。窗口大小可通过 constructor 覆盖（测试用小窗口）。
-     */
-    coalesceMs;
-    flushTimer;
-    flushInFlight = false;
-    /**
-     * P2-1：in-flight flush 期间到达的 push 标记。scheduleFlush 在 flushInFlight
-     * 时早退不调度新 timer，但事件已 reduce 进 state；若无此标志，in-flight flush
-     * 完成后该事件无 follow-up render，停留为 stale 中间帧（生产 SDK 的
-     * controller.update 经 throttle + setTimeout 异步 resolve，故 flush 与
-     * 下一个 push 交叠是真实场景）。finally 检查此标志后重新 scheduleFlush，
-     * 保证 in-flight 期间累积的事件最终被渲染。
-     */
-    pendingReschedule = false;
-    /**
-     * 当前 in-flight flush 的 promise（若 flush 正在 await updateCard）。
-     * finish() 在终态 patch 前 await 它，保证 in-flight 的 pre-terminal patch
-     * 先落地、terminal patch 后落地——否则两条 controller.update 并发无 FIFO，
-     * pre-terminal 可能在 terminal 之后 resolve 留下"思考中"终帧（P2）。
-     */
-    flushP;
     constructor(opts) {
         super(createInitialRunState(opts.runId), {
             connector: opts.connector,
@@ -35,8 +10,8 @@ export class RunCardSession extends CardSession {
             renderOptions: opts.renderOptions,
             startTimeoutMs: opts.startTimeoutMs,
             settleTimeoutMs: opts.settleTimeoutMs,
+            coalesceMs: opts.coalesceMs,
         });
-        this.coalesceMs = opts.coalesceMs ?? 100;
     }
     get logPrefix() {
         return '[card]';
@@ -53,6 +28,11 @@ export class RunCardSession extends CardSession {
         // enforceCardBudget stringify pass is redundant for run cards.
         return true;
     }
+    isFlushableState() {
+        // finish() 已转终态（done/error/interrupted/idle_timeout）时不再 patch；
+        // 'finalizing' 是非终态，in-flight/延迟 flush 仍可渲染累积事件。
+        return this.state.terminal === 'running' || this.state.terminal === 'finalizing';
+    }
     async push(event) {
         // state 每事件立即 reduce（始终最新），但 updateCard 延迟到合批窗口末尾。
         // 窗口内多次 push 复用同一 flushTimer，只 render + controller.update 一次
@@ -70,75 +50,6 @@ export class RunCardSession extends CardSession {
         }
         this.scheduleFlush();
     }
-    /**
-     * 调度一次延迟 flush。已有 pending 调度则复用（合批核心）；否则起一个
-     * coalesceMs 定时器。flushInFlight 期间不再起 timer（避免重入叠加），但置
-     * pendingReschedule 以便 in-flight flush 完成后重新调度——否则 in-flight 期间
-     * 到达的 push 会停留为 stale 中间帧（P2-1）。
-     */
-    scheduleFlush() {
-        if (this.flushTimer)
-            return;
-        if (this.flushInFlight) {
-            this.pendingReschedule = true;
-            return;
-        }
-        this.flushTimer = setTimeout(() => {
-            this.flushTimer = undefined;
-            void this.flush();
-        }, this.coalesceMs);
-    }
-    /**
-     * 执行一次 render + updateCard。合批窗口到期或 finish 立即 flush 时调用。
-     * flushInFlight 防止 timer 回调与 finish 的即时 flush 重入。
-     *
-     * 终态守卫：若 finish() 已把 state 转为终态（done/error/interrupted/idle_timeout），
-     * 跳过本次 patch——避免 in-flight flush 用 pre-terminal state 覆盖 finish 已发的
-     * 终态卡。finish() 自身会 await 任何 in-flight flush 保证顺序，此守卫是双保险。
-     */
-    async flush() {
-        if (this.flushInFlight)
-            return;
-        // finish() 已转终态：in-flight/延迟 flush 不再用旧 state patch
-        if (this.state.terminal !== 'running' && this.state.terminal !== 'finalizing') {
-            return;
-        }
-        this.flushInFlight = true;
-        const flushPromise = (async () => {
-            try {
-                await this.updateCard();
-            }
-            finally {
-                this.flushInFlight = false;
-                // flushInFlight 守卫保证同一时刻只有一个 in-flight flush，故可无条件清空。
-                this.flushP = undefined;
-                // P2-1：in-flight 期间若有 push 到达（pendingReschedule），重新调度一次
-                // flush 渲染累积事件，避免 stale 中间帧。终态守卫在 flush() 入口已拦截，
-                // 故 finish 后不会误触发。
-                if (this.pendingReschedule) {
-                    this.pendingReschedule = false;
-                    this.scheduleFlush();
-                }
-            }
-        })();
-        this.flushP = flushPromise;
-        return flushPromise;
-    }
-    /**
-     * 取消待 flush 的合批调度（finish/settle 前清理，避免延迟 update 与终态
-     * 渲染竞争）。返回是否有被取消的 pending 调度。同时清掉 pendingReschedule，
-     * 防止 in-flight flush 的 finally 在 finish await 之后又起 dangling timer
-     * （finish 自身会渲染含累积事件的终态卡，无需 follow-up）。
-     */
-    cancelPendingFlush() {
-        this.pendingReschedule = false;
-        if (this.flushTimer) {
-            clearTimeout(this.flushTimer);
-            this.flushTimer = undefined;
-            return true;
-        }
-        return false;
-    }
     async finish(terminal, meta = {}) {
         // 终态必须即时显示（spec）：取消合批窗口，不等延迟 flush 调度。
         this.cancelPendingFlush();
@@ -152,14 +63,5 @@ export class RunCardSession extends CardSession {
         await this.updateCard();
         this.release();
     }
-    /**
-     * settle 前兜底取消合批调度。bridge 正常流程 finish→settle，finish 已 cancel；
-     * 但若未来有直调 settle（未经 finish）的路径，避免 dangling timer 在 release
-     * 后触发 void flush() 去更新已释放的 stream（harmless 但无谓）。
-     */
-    async settle() {
-        this.cancelPendingFlush();
-        return super.settle();
-    }
 }
 //# sourceMappingURL=run-card-session.js.map