lark-remote 0.1.5 → 0.1.7

package/CHANGELOG.md

@@ -5,6 +5,44 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.7] - 2026-08-18
+
+### 新增
+
+- pi RPC 模式 runner：通过持久连接复用共享 `ConnectionManager`，支持审批与上下文压缩
+- kimi / opencode ACP 模式 runner：纯 ACP 持久连接，支持审批 + Compact
+- 共享 ACP / JSON-RPC 连接层（`runner/common/acp`、`runner/common/jsonrpc`）：统一 codex / kimi / opencode / pi 的连接管理
+- 入站图片/文件自动落盘：往飞书私聊发图片/文件自动保存到 `.lark-remote-temp/`，可直接让 agent 处理
+- `/order alias`：注册快捷别名，输入 `$name` 即展开
+- 会话分页/截断共享辅助模块（`session/common/pagination`）
+- Codex 命令审批卡片示例图
+
+### 变更
+
+- codex runner 统一走 app-server 审批模式；移除 codex/kimi/opencode/pi 的 exec/jsonl 旧模式与死代码
+- `codex-bundled-test-helpers` 迁移至 `tests/lib/`
+- 用户文档：新增入站文件、`/order alias`、kimi acp 配置说明
+
+### 修复
+
+- 修复文档引用指向被排除的本地文档导致的破链
+
+## [0.1.6] - 2026-08-14
+
+### 新增
+
+- Codex App Server 集成：通过 stdio JSON-RPC 持久连接 Codex CLI，支持审批流（文件读写/命令执行）、Compact 上下文压缩、空闲超时自动断开
+- Approval 审批系统：`approval-coordinator` 协调超时/取消/回复，`approval-render` 渲染审批按钮卡片
+- Codex runner 工厂：自动选择直连模式或 App Server 模式
+- `rollout-reader`：Codex App Server rollout 开关读取
+- Run card 审批区域渲染 + context limit 百分比显示
+- 架构文档：`docs/zh/guides/codex-config.md`
+
+### 修复
+
+- `/update` 命令移除自动重启逻辑
+- Codex 配置枚举回归官方标准值
+
 ## [0.1.5] - 2026-08-14
 
 ### 新增
@@ -136,3 +174,4 @@ Initial release.
 [0.1.3]: https://github.com/bungabungawoda/lark-remote/releases/tag/v0.1.3
 [0.1.4]: https://github.com/bungabungawoda/lark-remote/releases/tag/v0.1.4
 [0.1.5]: https://github.com/bungabungawoda/lark-remote/releases/tag/v0.1.5
+[0.1.6]: https://github.com/bungabungawoda/lark-remote/releases/tag/v0.1.6

package/README.en.md

@@ -16,13 +16,17 @@ Designed for a single-user, peer-to-peer private chat. The agent's system prompt
 
 ## ⚠️ Security Warning (read first)
 
-This tool turns Feishu messages directly into local agent executions, and agents run with **full permissions** by default (Claude `bypassPermissions`, Codex `approval_policy=never` + full access) — effectively handing a shell on your machine to whoever can chat with the bot. You MUST:
+This tool turns Feishu messages directly into local agent executions. Claude runs with **full permissions** by default (fixed `bypassPermissions`); Codex uses the **app-server approval mode** (default `approvalPolicy=on-request` — command execution requires your confirmation on the Feishu card, sandbox defaults to `workspace-write`), which is relatively safe; other agents run with their CLI defaults. Agents can still read and write the local directories you specify. You MUST:
 
 - **Use it only in your own private (p2p) chat.** Never add the bot to any group chat; never let anyone else talk to it.
 - Restrict the app's visibility to **yourself only** in the Feishu Open Platform.
 - Don't run it on a machine holding data you can't afford to lose; prefer a dedicated user / machine / container.
 - Keep credentials such as `appSecret` in your local `config.yaml` only — **never commit them anywhere**.
 
+In Codex approval mode, an approval card arrives before any command runs — approve or reject it right in Feishu:
+
+![Codex command approval card example](docs/images/approval-card.png)
+
 ## Prerequisites
 
 - OS: macOS / Linux. **Windows is not supported yet** (relies on POSIX behaviors such as Unix signals, bash, and file locks)

package/README.md

@@ -16,13 +16,17 @@
 
 ## ⚠️ 安全警告（必读）
 
-本工具会把飞书消息直接转为本地 agent 执行，agent 默认以**完全权限**运行（Claude `bypassPermissions`、Codex `approval_policy=never` + full access），等价于把一台机器的 shell 交给聊天对端。请务必：
+本工具会把飞书消息直接转为本地 agent 执行。Claude 默认以**完全权限**运行（固定 `bypassPermissions`）；Codex 采用 **app-server 审批模式**（默认 `approvalPolicy=on-request`，执行命令需在飞书卡片上确认，沙箱默认 `workspace-write`），相对安全；其他 agent 以各自 CLI 的默认权限运行。agent 仍可读写你指定的本地目录，请务必：
 
 - **仅限你自己的私聊（p2p）使用**。不要把机器人拉进任何群聊，不要让任何其他人能与它对话。
 - 在飞书开放平台把应用可见范围限制到**只有你自己**。
 - 运行本工具的机器上不要存放与损失承受力不符的数据；建议在独立用户/机器/容器里运行。
 - `appSecret` 等凭据只在本地 `config.yaml`，**不要提交到任何仓库**。
 
+Codex 审批模式下，执行命令前会收到审批卡片，可直接在飞书里允许或拒绝：
+
+![Codex 命令审批卡片示例](docs/images/approval-card.png)
+
 ## 前置条件
 
 - 操作系统：macOS / Linux。**暂不支持 Windows**（依赖 Unix 信号、bash、文件锁等 POSIX 行为）
@@ -120,12 +124,16 @@ bridge 启动后不在终端输出，运行日志写入 `~/.lark-remote/logs/YYY
 | `/reconnect` | - | 重连飞书 |
 | `/restart` | - | 原地自重启 bridge（新进程同 config 接管） |
 | `/config get\|set` | `/c` | 查改运行时配置（agent-aware 卡片） |
-| `/order save\|list` | `/o` | 保存或列出常用指令 |
+| `/order save\|list\|alias` | `/o` | 收藏常用指令；`/order alias` 注册快捷别名（输入 `$name` 展开） |
 | `!<cmd>` | - | 执行 bash 命令并流式输出到卡片（绕过串行队列） |
 | `/exit` | `/e` | 退出 bridge |
 
 直接发非 `/` 开头的消息即转发给当前默认 agent。
 
+往飞书私聊发**图片/文件**会自动保存到当前目录的 `.lark-remote-temp/<YYYYMMDDHHmm>/`
+（建议把 `.lark-remote-temp/` 加进项目 `.gitignore`），随后说「请处理刚才保存的文件」
+即可让 agent 直接读本地文件。更多用法见 [docs/zh/usage.md](docs/zh/usage.md)。
+
 ## 测试
 
 ```bash

package/dist/bridge/approval-coordinator.d.ts

@@ -0,0 +1,131 @@
+/**
+ * ApprovalCoordinator: tracks and manages approval requests for a single run.
+ *
+ * Handles the lifecycle of command/file/permissions approval requests:
+ * - onRequested: add to tracking, arm timeout timer
+ * - onResolved: update state, clear timer
+ * - submit: validate → atomic state transition → async respond
+ * - togglePerm: flip permission item selection
+ * - onTurnEnded: mark all as expired
+ */
+import type { ApprovalRequestedEvent, ApprovalView, AgentEvent } from '../runner/types.js';
+import type { ApprovalAction } from '../runner/types.js';
+type ApprovalState = 'pending' | 'submitting' | 'resolved' | 'failed' | 'expired';
+export interface TrackedApproval {
+    requestId: number | string;
+    kind: 'command' | 'file' | 'permissions' | 'question';
+    state: ApprovalState;
+    view: ApprovalView;
+    createdAt: number;
+    timeoutTimer: ReturnType<typeof setTimeout> | null;
+    /** AskUserQuestion 已答问题索引 → 答案 label[]（kind === 'question'）。 */
+    answers?: Map<number, string[]>;
+}
+type ApprovalResponder = (requestId: number | string, response: unknown) => Promise<void>;
+export type { ApprovalAction } from '../runner/types.js';
+export interface ApprovalToggleAction {
+    permId: string;
+    selected: boolean;
+}
+export declare class ApprovalCoordinator {
+    private approvals;
+    /** 已提交过的 nonce（按 requestId）：同一按钮连点/飞书重投递只生效一次。 */
+    private submittedNonces;
+    private readonly approvalTimeoutMs;
+    private readonly responder;
+    private readonly interruptTurn;
+    private readonly pushToCard;
+    constructor(opts: {
+        approvalTimeoutMs: number;
+        responder: ApprovalResponder;
+        interruptTurn: () => Promise<void>;
+        pushToCard: (events: AgentEvent[]) => Promise<void>;
+    });
+    /**
+     * Handle an approval_requested event.
+     */
+    onRequested(event: ApprovalRequestedEvent): void;
+    /**
+     * Handle an approval_resolved event.
+     */
+    onResolved(requestId: number | string): void;
+    /**
+     * Handle turn ended — mark all pending approvals as expired.
+     */
+    onTurnEnded(): void;
+    /**
+     * Submit an approval decision.
+     */
+    submit(action: ApprovalAction, ctx: {
+        requestId: number | string;
+        nonce?: string;
+    }): Promise<void>;
+    /**
+     * Toggle a permission item's selected state.
+     */
+    togglePerm(action: ApprovalToggleAction, ctx: {
+        requestId: number | string;
+    }): Promise<void>;
+    /**
+     * Claude AskUserQuestion 选项点击。
+     *
+     * - 单选：点击即选中该选项；全部问题答完时自动通过 responder 提交答案。
+     * - 多选：切换 selected 并推 approval_view_updated 重渲染，等待
+     *   submitAnswers() 显式提交。
+     */
+    toggleAnswer(action: {
+        questionIndex: number;
+        option: string;
+    }, ctx: {
+        requestId: number | string;
+        nonce?: string;
+    }): Promise<void>;
+    /**
+     * Claude AskUserQuestion 多选问题的「提交答案」按钮。
+     * 提交该问题当前勾选的选项；全部问题答完时通过 responder 提交。
+     */
+    submitAnswers(action: {
+        questionIndex: number;
+    }, ctx: {
+        requestId: number | string;
+        nonce?: string;
+    }): Promise<void>;
+    /**
+     * AskUserQuestion 自定义答案（Other，review P3-4）：自由文本直接作为该
+     * 单选问题的答案。与单选 toggle 同语义：全部问题答完自动提交。
+     */
+    answerCustom(action: {
+        questionIndex: number;
+        text: string;
+    }, ctx: {
+        requestId: number | string;
+        nonce?: string;
+    }): Promise<void>;
+    /**
+     * Update a pending approval's view (out-of-order item/started arrives late).
+     * Only applies while the approval is still pending — resolved/expired
+     * approvals must not be resurrected or rewritten.
+     */
+    updateView(requestId: number | string, view: ApprovalView): void;
+    /**
+     * Get the number of pending approvals.
+     */
+    pendingCount(): number;
+    private clearTimer;
+    /** nonce 去重：同一 nonce 只允许生效一次（防连点/飞书重投递）。 */
+    private assertFreshNonce;
+    /** 记录问题答案到 tracked.answers（懒初始化 Map）。 */
+    private recordAnswer;
+    private getPendingQuestion;
+    private allQuestionsAnswered;
+    /** 推送 question 卡片视图更新（选项勾选状态变化）。 */
+    private pushQuestionViewUpdate;
+    /** 全部问题已答：构建 answers 并提交（非空校验 + 原子状态迁移）。 */
+    private respondQuestionAnswers;
+    /** 推 approval_resolved 到卡片（移除审批区；幂等，失败仅记日志）。 */
+    private pushResolved;
+    private expireApproval;
+    private actionToDecision;
+}
+/** Map a card decision string to the ApprovalAction used across the bridge. */
+export declare function decisionToApprovalAction(decision: string): ApprovalAction;

package/dist/bridge/approval-coordinator.js

@@ -0,0 +1,409 @@
+/**
+ * ApprovalCoordinator: tracks and manages approval requests for a single run.
+ *
+ * Handles the lifecycle of command/file/permissions approval requests:
+ * - onRequested: add to tracking, arm timeout timer
+ * - onResolved: update state, clear timer
+ * - submit: validate → atomic state transition → async respond
+ * - togglePerm: flip permission item selection
+ * - onTurnEnded: mark all as expired
+ */
+import { getLogger } from '../logger/index.js';
+// =============================================================================
+// Coordinator
+// =============================================================================
+export class ApprovalCoordinator {
+    approvals = new Map();
+    /** 已提交过的 nonce（按 requestId）：同一按钮连点/飞书重投递只生效一次。 */
+    submittedNonces = new Map();
+    approvalTimeoutMs;
+    responder;
+    interruptTurn;
+    pushToCard;
+    constructor(opts) {
+        this.approvalTimeoutMs = opts.approvalTimeoutMs;
+        this.responder = opts.responder;
+        this.interruptTurn = opts.interruptTurn;
+        this.pushToCard = opts.pushToCard;
+    }
+    /**
+     * Handle an approval_requested event.
+     */
+    onRequested(event) {
+        const existing = this.approvals.get(event.requestId);
+        if (existing) {
+            // Already tracked — update state
+            existing.state = 'pending';
+            existing.view = event.view;
+            return;
+        }
+        const timer = setTimeout(() => {
+            this.expireApproval(event.requestId);
+        }, this.approvalTimeoutMs);
+        const tracked = {
+            requestId: event.requestId,
+            kind: event.kind,
+            state: 'pending',
+            view: event.view,
+            createdAt: Date.now(),
+            timeoutTimer: timer,
+        };
+        this.approvals.set(event.requestId, tracked);
+    }
+    /**
+     * Handle an approval_resolved event.
+     */
+    onResolved(requestId) {
+        const tracked = this.approvals.get(requestId);
+        if (!tracked)
+            return;
+        tracked.state = 'resolved';
+        this.clearTimer(tracked);
+    }
+    /**
+     * Handle turn ended — mark all pending approvals as expired.
+     */
+    onTurnEnded() {
+        for (const [, tracked] of this.approvals) {
+            if (tracked.state === 'pending') {
+                tracked.state = 'expired';
+                this.clearTimer(tracked);
+            }
+        }
+    }
+    /**
+     * Submit an approval decision.
+     */
+    async submit(action, ctx) {
+        const tracked = this.approvals.get(ctx.requestId);
+        if (!tracked) {
+            throw new Error(`Approval request ${ctx.requestId} not found`);
+        }
+        // nonce 去重：同一张卡片渲染出的按钮连续点击（或飞书重投递）携带相同
+        // nonce，只允许生效一次；不同渲染的按钮 nonce 不同，状态机（pending →
+        // submitting）仍然兜底防二次提交。
+        this.assertFreshNonce(ctx.requestId, ctx.nonce);
+        if (tracked.state !== 'pending') {
+            throw new Error(`Approval request ${ctx.requestId} is no longer pending (state=${tracked.state})`);
+        }
+        // Validate action against available decisions. decline/cancel are always
+        // allowed as a safety override: denying/interrupting is a universal human
+        // affordance even when the server's list omits them (observed in practice).
+        const decision = this.actionToDecision(action);
+        const safetyOverride = decision === 'decline' || decision === 'cancel';
+        if (!tracked.view.availableDecisions.includes(decision) && !safetyOverride) {
+            throw new Error(`Decision "${decision}" not in available decisions: ${tracked.view.availableDecisions.join(', ')}`);
+        }
+        // Atomic state transition: pending → submitting（同步，无 await）
+        tracked.state = 'submitting';
+        this.clearTimer(tracked);
+        // Send response via the responder
+        try {
+            await this.responder(ctx.requestId, action);
+            tracked.state = 'resolved';
+            // 提交成功后立即从卡片移除审批区（agent 无关）：claude 控制协议没有
+            // resolved 回发，不推就会「已点允许按钮仍在」残留 UI；codex 的 server
+            // 稍后也会发 approval_resolved，reducer 按 requestId 过滤幂等。
+            this.pushResolved(ctx.requestId);
+        }
+        catch {
+            tracked.state = 'failed';
+        }
+    }
+    /**
+     * Toggle a permission item's selected state.
+     */
+    async togglePerm(action, ctx) {
+        const tracked = this.approvals.get(ctx.requestId);
+        if (!tracked) {
+            throw new Error(`Approval request ${ctx.requestId} not found`);
+        }
+        if (tracked.kind !== 'permissions') {
+            throw new Error(`Approval request ${ctx.requestId} is not a permissions request`);
+        }
+        if (tracked.state !== 'pending') {
+            throw new Error(`Approval request ${ctx.requestId} is no longer pending`);
+        }
+        const items = tracked.view.permissions?.items;
+        if (!items) {
+            throw new Error(`Approval request ${ctx.requestId} has no permissions items`);
+        }
+        const item = items.find((i) => i.id === action.permId);
+        if (!item) {
+            throw new Error(`Permission item ${action.permId} not found in request ${ctx.requestId}`);
+        }
+        item.selected = action.selected;
+    }
+    /**
+     * Claude AskUserQuestion 选项点击。
+     *
+     * - 单选：点击即选中该选项；全部问题答完时自动通过 responder 提交答案。
+     * - 多选：切换 selected 并推 approval_view_updated 重渲染，等待
+     *   submitAnswers() 显式提交。
+     */
+    async toggleAnswer(action, ctx) {
+        const tracked = this.getPendingQuestion(ctx.requestId);
+        const questions = tracked.view.questions;
+        const q = questions[action.questionIndex];
+        if (!q) {
+            throw new Error(`Question ${action.questionIndex} not found in request ${ctx.requestId}`);
+        }
+        const option = q.options.find((o) => o.label === action.option);
+        if (!option) {
+            throw new Error(`Option "${action.option}" not found in question ${action.questionIndex}`);
+        }
+        const selected = new Set(q.selected ?? []);
+        if (q.multiSelect) {
+            // review P2-1：多选切换按钮同一 nonce 重复投递（双击/飞书重投递）只应
+            // toggle 一次，否则勾选会被二次 toggle 抵消。单选用例的重复防护在
+            // respondQuestionAnswers（提交即幂等，选中是 set 语义）。
+            this.assertFreshNonce(ctx.requestId, ctx.nonce);
+            if (selected.has(action.option)) {
+                selected.delete(action.option);
+            }
+            else {
+                selected.add(action.option);
+            }
+            q.selected = [...selected];
+            this.pushQuestionViewUpdate(ctx.requestId, tracked);
+            return;
+        }
+        // 单选：替换选择；全部问题答完立即提交，否则等待后续问题。
+        q.selected = [action.option];
+        this.recordAnswer(tracked, action.questionIndex, [action.option]);
+        if (this.allQuestionsAnswered(tracked)) {
+            return this.respondQuestionAnswers(tracked, ctx);
+        }
+        this.pushQuestionViewUpdate(ctx.requestId, tracked);
+    }
+    /**
+     * Claude AskUserQuestion 多选问题的「提交答案」按钮。
+     * 提交该问题当前勾选的选项；全部问题答完时通过 responder 提交。
+     */
+    async submitAnswers(action, ctx) {
+        const tracked = this.getPendingQuestion(ctx.requestId);
+        const questions = tracked.view.questions;
+        const q = questions[action.questionIndex];
+        if (!q) {
+            throw new Error(`Question ${action.questionIndex} not found in request ${ctx.requestId}`);
+        }
+        if (!q.multiSelect) {
+            throw new Error('该问题为单选，请直接点击选项');
+        }
+        const selected = q.selected ?? [];
+        if (selected.length === 0) {
+            throw new Error('请先选择至少一个选项');
+        }
+        this.recordAnswer(tracked, action.questionIndex, selected);
+        if (this.allQuestionsAnswered(tracked)) {
+            return this.respondQuestionAnswers(tracked, ctx);
+        }
+    }
+    /**
+     * AskUserQuestion 自定义答案（Other，review P3-4）：自由文本直接作为该
+     * 单选问题的答案。与单选 toggle 同语义：全部问题答完自动提交。
+     */
+    async answerCustom(action, ctx) {
+        const tracked = this.getPendingQuestion(ctx.requestId);
+        const questions = tracked.view.questions;
+        const q = questions[action.questionIndex];
+        if (!q) {
+            throw new Error(`Question ${action.questionIndex} not found in request ${ctx.requestId}`);
+        }
+        if (q.multiSelect) {
+            throw new Error('自定义答案仅支持单选');
+        }
+        const text = action.text.trim();
+        if (!text) {
+            throw new Error('请输入自定义答案');
+        }
+        q.selected = [text];
+        this.recordAnswer(tracked, action.questionIndex, [text]);
+        if (this.allQuestionsAnswered(tracked)) {
+            return this.respondQuestionAnswers(tracked, ctx);
+        }
+        this.pushQuestionViewUpdate(ctx.requestId, tracked);
+    }
+    /**
+     * Update a pending approval's view (out-of-order item/started arrives late).
+     * Only applies while the approval is still pending — resolved/expired
+     * approvals must not be resurrected or rewritten.
+     */
+    updateView(requestId, view) {
+        const tracked = this.approvals.get(requestId);
+        if (!tracked || tracked.state !== 'pending')
+            return;
+        tracked.view = view;
+    }
+    /**
+     * Get the number of pending approvals.
+     */
+    pendingCount() {
+        let count = 0;
+        for (const [, tracked] of this.approvals) {
+            if (tracked.state === 'pending')
+                count++;
+        }
+        return count;
+    }
+    // =========================================================================
+    // Internal
+    // =========================================================================
+    clearTimer(tracked) {
+        if (tracked.timeoutTimer !== null) {
+            clearTimeout(tracked.timeoutTimer);
+            tracked.timeoutTimer = null;
+        }
+    }
+    /** nonce 去重：同一 nonce 只允许生效一次（防连点/飞书重投递）。 */
+    assertFreshNonce(requestId, nonce) {
+        if (nonce === undefined)
+            return;
+        const seen = this.submittedNonces.get(requestId) ?? new Set();
+        if (seen.has(nonce)) {
+            throw new Error(`Approval request ${requestId} already submitted (duplicate nonce)`);
+        }
+        seen.add(nonce);
+        this.submittedNonces.set(requestId, seen);
+    }
+    /** 记录问题答案到 tracked.answers（懒初始化 Map）。 */
+    recordAnswer(tracked, questionIndex, values) {
+        tracked.answers ??= new Map();
+        tracked.answers.set(questionIndex, values);
+    }
+    getPendingQuestion(requestId) {
+        const tracked = this.approvals.get(requestId);
+        if (!tracked) {
+            throw new Error(`Approval request ${requestId} not found`);
+        }
+        if (tracked.kind !== 'question') {
+            throw new Error(`Approval request ${requestId} is not a question request`);
+        }
+        if (tracked.state !== 'pending') {
+            throw new Error(`Approval request ${requestId} is no longer pending`);
+        }
+        return tracked;
+    }
+    allQuestionsAnswered(tracked) {
+        const questions = tracked.view.questions ?? [];
+        if (questions.length === 0)
+            return false;
+        for (let i = 0; i < questions.length; i++) {
+            const answered = (tracked.answers?.get(i)?.length ?? 0) > 0;
+            if (!answered)
+                return false;
+        }
+        return true;
+    }
+    /** 推送 question 卡片视图更新（选项勾选状态变化）。 */
+    pushQuestionViewUpdate(requestId, tracked) {
+        void this.pushToCard([
+            {
+                type: 'approval_view_updated',
+                requestId,
+                view: tracked.view,
+                timestamp: new Date().toISOString(),
+            },
+        ]).catch((err) => {
+            getLogger().warn(`[approval-coordinator] question view update failed requestId=${requestId}: ${err instanceof Error ? err.message : String(err)}`);
+        });
+    }
+    /** 全部问题已答：构建 answers 并提交（非空校验 + 原子状态迁移）。 */
+    async respondQuestionAnswers(tracked, ctx) {
+        this.assertFreshNonce(ctx.requestId, ctx.nonce);
+        if (tracked.state !== 'pending') {
+            throw new Error(`Approval request ${ctx.requestId} is no longer pending (state=${tracked.state})`);
+        }
+        const questions = tracked.view.questions ?? [];
+        const answers = {};
+        for (let i = 0; i < questions.length; i++) {
+            const selected = tracked.answers?.get(i) ?? [];
+            answers[questions[i].question] = questions[i].multiSelect ? selected : selected[0];
+        }
+        tracked.state = 'submitting';
+        this.clearTimer(tracked);
+        try {
+            await this.responder(ctx.requestId, { action: 'answer', answers });
+            tracked.state = 'resolved';
+            this.pushResolved(ctx.requestId);
+        }
+        catch {
+            tracked.state = 'failed';
+        }
+    }
+    /** 推 approval_resolved 到卡片（移除审批区；幂等，失败仅记日志）。 */
+    pushResolved(requestId) {
+        void this.pushToCard([
+            {
+                type: 'approval_resolved',
+                requestId,
+                outcome: 'resolved',
+                timestamp: new Date().toISOString(),
+            },
+        ]).catch((err) => {
+            getLogger().warn(`[approval-coordinator] resolved card event failed requestId=${requestId}: ${err instanceof Error ? err.message : String(err)}`);
+        });
+    }
+    expireApproval(requestId) {
+        const tracked = this.approvals.get(requestId);
+        if (!tracked || tracked.state !== 'pending')
+            return;
+        tracked.state = 'expired';
+        this.clearTimer(tracked);
+        // 闭环：审批过期时向 server 发送 cancel（真实协议决策空间中的「停止等待」语义），
+        // 避免 server 无限等待审批响应。decline 仅是本桥 UI 安全兜底，不在真实协议内。
+        // 此前只改本地状态，server 只能等 runner 的 turn 超时兜底（用户「点了允许还超时」）。
+        void this.responder(requestId, { action: 'cancel' }).catch((err) => {
+            getLogger().warn(`[approval-coordinator] expiry cancel failed requestId=${requestId}: ${err instanceof Error ? err.message : String(err)}`);
+            // 响应失败不是「正常过期」：状态升级为 failed，避免误判为已正常通知
+            // server（spec R1：responder 抛错时状态置 failed）。
+            tracked.state = 'failed';
+            // 兜底：cancel 未能送达时主动中断 turn，避免 server 无限等待审批响应。
+            void this.interruptTurn().catch((interruptErr) => {
+                getLogger().warn(`[approval-coordinator] expiry interrupt failed requestId=${requestId}: ${interruptErr instanceof Error ? interruptErr.message : String(interruptErr)}`);
+            });
+        });
+        // 通知卡片进入过期态（run-renderer 渲染「⏰ 审批已过期」并隐藏按钮）。
+        void this.pushToCard([{ type: 'approval_expired', requestId }]).catch((err) => {
+            getLogger().warn(`[approval-coordinator] expiry card event failed requestId=${requestId}: ${err instanceof Error ? err.message : String(err)}`);
+        });
+    }
+    actionToDecision(action) {
+        switch (action.action) {
+            case 'accept':
+                return 'accept';
+            case 'accept_for_session':
+                return 'acceptForSession';
+            case 'accept_with_execpolicy_amendment':
+                return 'acceptWithExecpolicyAmendment';
+            case 'accept_all':
+                return 'acceptAll';
+            case 'answer':
+                return 'answer';
+            case 'decline':
+                return 'decline';
+            case 'cancel':
+                return 'cancel';
+        }
+    }
+}
+/** Map a card decision string to the ApprovalAction used across the bridge. */
+export function decisionToApprovalAction(decision) {
+    switch (decision) {
+        case 'accept':
+            return { action: 'accept' };
+        case 'acceptForSession':
+            return { action: 'accept_for_session' };
+        case 'acceptWithExecpolicyAmendment':
+            return { action: 'accept_with_execpolicy_amendment' };
+        case 'acceptAll':
+            return { action: 'accept_all' };
+        case 'decline':
+            return { action: 'decline' };
+        case 'cancel':
+            return { action: 'cancel' };
+        default:
+            return { action: 'decline' };
+    }
+}
+//# sourceMappingURL=approval-coordinator.js.map