@foxden-app/foxclaw 0.5.77 → 0.6.3

package/.env.example

@@ -60,6 +60,17 @@ TELEGRAM_PREVIEW_THROTTLE_MS=800
 THREAD_LIST_LIMIT=10
 CODEX_CLI_BIN=/absolute/path/to/codex
 
+# Optional OpenCode bridge. This starts a second, independent Telegram bot
+# alongside every existing Codex runtime; never reuse a TG_BOT_TOKEN here.
+# FoxClaw manages a password-protected `opencode serve` bound to 127.0.0.1.
+# OPENCODE_BOT_TOKEN=<different_telegram_bot_token>
+# OPENCODE_CLI_BIN=/absolute/path/to/opencode
+# Optional fixed Basic Auth password. If omitted, FoxClaw generates one and
+# stores it with the managed server state (mode 0600).
+# OPENCODE_SERVER_PASSWORD=
+# OPENCODE_SERVER_STATE_PATH=
+# OPENCODE_SERVER_LOG_PATH=
+
 # Optional cross-node Codex auth sync.
 # Disabled by default. When enabled, FoxClaw uses Telegram Bot-to-Bot private
 # messages to move encrypted auth bundles between nodes. Enable Bot-to-Bot

package/CHANGELOG.md

@@ -2,6 +2,58 @@
 
 All notable FoxClaw changes are listed here. Each release note is bilingual so GitHub Releases and the npm package are useful to both Chinese and English readers.
 
+## 0.6.3 - 2026-08-09
+
+### 中文
+- 修复 Codex app-server 重启只终止 Node 包装进程、未终止同一 detached 进程组内原生 Codex 子进程的问题。认证刷新或手动重载后，不再遗留旧服务持有 thread writer lock 并触发 `already has an active writer`。
+- 托管服务关闭现在先向整个进程组发送 `SIGTERM`，超时后升级为 `SIGKILL`；强制终止后仍存活会明确失败并阻止新实例叠加启动。加入忽略 `SIGTERM` 的父子进程树回归测试。
+
+### English
+- Fixed Codex app-server restarts terminating only the Node wrapper while leaving the native Codex child alive in the same detached process group. Auth refreshes and manual reloads no longer leave an old server holding a thread writer lock and causing `already has an active writer`.
+- Managed shutdown now sends `SIGTERM` to the whole process group, escalates to `SIGKILL` on timeout, and fails explicitly instead of starting another instance if the group still survives. Added a regression test with a parent/child process tree that ignores `SIGTERM`.
+
+## 0.6.2 - 2026-08-09
+
+### 中文
+- 修复 OpenCode 流式刷新并发竞态：Telegram 首次发送尚未返回时，后续增量与结束事件会排队复用同一消息，不再把 `/home`、半截路径和最终路径拆成多条或重复发送；观察流和工具状态也使用同一串行保证。
+- `/models` 改为 OpenCode 原生习惯的 Provider → Model 两层选择；`/setup` 对齐 Codex Bot 的同消息交互，集中显示并切换模型、variant、Agent/单次 Plan、权限和运行中新消息策略。
+- 补齐可保持语义的菜单：原生 `/undo`/`redo`、`/review`、归档恢复，显式 `/steer`/`queue`/`takeover`，以及 Rich、Voice、MCP Apps、Plugins、Hooks、Features 和 Provider auth 状态。Codex 专属账户、配额、Goal、Remote、设备登录与升级协调入口保留在菜单中，并说明不可等价支持的原因和替代操作。
+
+### English
+- Fixed an OpenCode streaming race. When the first Telegram send is still pending, later deltas and completion now serialize onto the same message instead of emitting `/home`, partial paths, and duplicated final output. Watch streams and tool status use the same serialization guarantee.
+- Changed `/models` to a native-style two-level Provider → Model selector. `/setup` now matches the Codex bot's in-place interaction and centralizes model, variant, Agent/one-shot Plan, access, and active-message behavior.
+- Added every semantics-preserving menu path: native `/undo`/`redo`, `/review`, archive restore, explicit `/steer`/`queue`/`takeover`, Rich, Voice, MCP Apps, Plugins, Hooks, Features, and provider-auth status. Codex-only account, quota, Goal, Remote, device-login, and update-coordinator entries remain visible with precise limitations and replacement workflows.
+
+## 0.6.1 - 2026-08-09
+
+### 中文
+- 新增独立 `OPENCODE_BOT_TOKEN` runtime，在不替换、不降级现有 Codex Bot 的前提下，由 Telegram 驱动本机 `opencode serve` 会话。支持全局会话列表、编号打开、观察、历史、Fork、Diff、压缩、文件搜索、Skills、MCP、Provider 与安全配置摘要。
+- 对齐 OpenCode 1.18.15 当前 HTTP/SSE 契约：使用 `/global/health`、跨目录 `/global/event`、`permission.asked`、`question.asked` 以及当前 reply API；加入 SSE 重连、漏事件轮询兜底、崩溃后托管进程重连和跨目录待审批/提问恢复。
+- Telegram 体验覆盖流式消息合并、最终 Rich Markdown、工具进度清理、图片/文件附件、模型与 variant、Agent/单次 Plan、read-only/default/full-access、运行中 steer/queue、审批按钮和多问题回答。`/undo`、`/rollback` 明确不做语义近似。
+- `opencode serve` 只绑定 `127.0.0.1` 并强制 Basic Auth；未配置密码时自动生成，以 `0600` 写入状态文件。OpenCode 必须使用不同的 Telegram Bot token，`doctor` 会做 CLI 与 token 隔离检查。
+- `v0.6.0` 保留为被回退的干扰提交快照，因此实际新实现使用 `0.6.1`，不复用同一版本号。
+
+### English
+- Added an independent `OPENCODE_BOT_TOKEN` runtime that drives local `opencode serve` sessions from Telegram without replacing or reducing existing Codex bots. It covers global session listing, numbered open, watch, history, fork, diff, compaction, file search, skills, MCP, providers, and a redacted config summary.
+- Aligned with the current OpenCode 1.18.15 HTTP/SSE contract: `/global/health`, cross-directory `/global/event`, `permission.asked`, `question.asked`, and current reply endpoints. Added SSE reconnects, polling fallback, managed-process reattachment after crashes, and cross-directory pending-request recovery.
+- Added merged streaming, final Rich Markdown, transient tool progress, image/file attachments, models and variants, Agent/one-shot Plan, three access presets, active-turn steer/queue, approval buttons, and multi-question answers. `/undo` and `/rollback` explicitly avoid semantic approximation.
+- `opencode serve` binds only to `127.0.0.1` and always uses Basic Auth. FoxClaw generates a password when omitted and writes state with mode `0600`. OpenCode requires a separate Telegram bot token, and `doctor` checks both CLI availability and token isolation.
+- `v0.6.0` remains the tagged snapshot of the reverted interference commit, so the corrected implementation is versioned `0.6.1` instead of reusing the same release number.
+
+## 0.5.78 - 2026-07-12
+
+### 中文
+- `/auth` 面板收敛为“设备登录”和“安全同步”两个维护入口，移除权限、重载 auth 和单独的全节点审计按钮。“安全同步”现在直接执行完整的全节点验证、最新有效副本协商、8 天临期刷新和最终分发；`/auth sync audit` 继续作为兼容别名。
+- 全节点审计现在也覆盖只存在于单个节点的旧候选：通过现有 AES-256-GCM 通道发送给其他节点做只验证、不导入的独立复核。任一节点验证有效就恢复并分发；没有有效结果且至少两个节点确认无效才标记 `?`。
+- Telegram `/status` 新增当前 bot 实际使用的 Codex Home，并与 `/auth`、`/threads` 等时效面板一样按 `TELEGRAM_PANEL_TTL_MS` 自动撤回，默认 5 分钟。
+- 完整支持 Codex 新增的 `max`、`ultra` 推理强度，包括模型能力读取、命令解析、设置持久化和下一轮请求透传，不再提示“未知推理强度”。
+
+### English
+- Simplified the `/auth` panel to Device login and Safe sync, removing the Permissions, Reload auth, and separate cluster-audit buttons. Safe sync now runs the complete all-node validation, newest-valid-copy reconciliation, 8-day stale refresh, and final distribution flow; `/auth sync audit` remains a compatibility alias.
+- All-node audits now cover legacy candidates found on only one node. The candidate is sent through the existing AES-256-GCM channel for independent validation without import. Any valid result restores and distributes it; it is marked `?` only when no valid result exists and at least two nodes reject it.
+- Telegram `/status` now shows the effective Codex Home for the current bot and expires through `TELEGRAM_PANEL_TTL_MS`, like `/auth` and `/threads`, with a five-minute default.
+- Added end-to-end support for the new Codex `max` and `ultra` reasoning efforts across model capability parsing, commands, persisted settings, and turn requests.
+
 ## 0.5.77 - 2026-07-11
 
 ### 中文

package/README.md

@@ -4,7 +4,7 @@
 
 **狸爪：一个更适配编程需求的移动端 Codex 控制器。**
 
-FoxClaw（狸爪）的目标很直接：让你用手机控制本机的 Codex，把移动端变成一个真正能用的 web coding 入口。Telegram 或微信负责交互，`codex app-server` 负责本地执行；你发任务、看进度、批审批、切线程，Codex 在电脑上继续写代码。
+FoxClaw（狸爪）的目标很直接：让你用手机控制本机的 Codex 或 OpenCode，把移动端变成一个真正能用的 web coding 入口。Telegram 或微信负责交互，`codex app-server` / `opencode serve` 负责本地执行；你发任务、看进度、批审批、切线程，Agent 在电脑上继续写代码。
 
 这适合你离开办公桌去吃饭、在旅途中、在跑步机上，或者陪小孩逛公园的时候继续工作。人可以离开电脑，Codex 不必停；它会把关键进展、错误、审批请求和最终结果同步回手机。
 
@@ -120,6 +120,22 @@ FoxClaw 只响应 `TG_ALLOWED_USER_ID` 的消息——把机器人拉进群不
 
 </details>
 
+## OpenCode 独立 Bot（0.6.1+）
+
+现有 Codex Bot 不需要改。再向 `@BotFather` 创建一个独立机器人，把 token 写入：
+
+```dotenv
+OPENCODE_BOT_TOKEN=234567:different-opencode-bot-token
+# 可选；默认从 PATH 查找
+OPENCODE_CLI_BIN=/absolute/path/to/opencode
+```
+
+重启 FoxClaw 后，这个 Bot 会连接本机受 Basic Auth 保护、仅监听 `127.0.0.1` 的 `opencode serve`。未设置 `OPENCODE_SERVER_PASSWORD` 时，FoxClaw 自动生成密码并以 `0600` 保存到托管状态文件。`OPENCODE_BOT_TOKEN` 不能与 `TG_BOT_TOKENS` / `TG_BOT_TOKEN` 复用，否则两个 long-poll runtime 会争抢同一个 Telegram update。
+
+OpenCode Bot 保留与 Codex Bot 相同的主要操作习惯：直接发消息或附件、`/new`、`/threads` + `/open <编号>`、`/watch`、同消息内刷新的 `/setup`、Provider → Model 两层模型选择、variant、Agent/单次 Plan、三档权限、运行中 `/steer`/`/queue`/`/takeover`、流式合并、工具进度、审批按钮和问题选项。`/undo`/`/redo`、`/review` 与归档使用 OpenCode 原生 API；`/apps` 对应 MCP，Plugins、Hooks、Features 和语音入口也保持可用。Codex 账户、配额、Goal、Remote 和 Fast service tier 没有 OpenCode serve 等价 API，保留菜单入口并明确说明替代操作。
+
+OpenCode 自身的 Provider 登录仍在本机终端完成，例如 `opencode auth`。运行 `foxclaw doctor` 会在配置了 OpenCode Bot 时额外检查 OpenCode CLI 和 token 隔离。
+
 ## 多账号切换
 
 FoxClaw 的一大特色是自动多账号切换。当一个账号触发用量限制时，FoxClaw 会自动切换到下一个可用账号继续工作。

package/README_EN.md

@@ -4,7 +4,7 @@
 
 **A mobile Codex controller built for real programming workflows.**
 
-FoxClaw turns your phone into a practical web coding cockpit for your local Codex. Telegram or Weixin handles the chat interface, `codex app-server` handles local execution, and you can send tasks, inspect progress, approve actions, switch threads, and keep working without opening a laptop.
+FoxClaw turns your phone into a practical web coding cockpit for local Codex or OpenCode. Telegram or Weixin handles the chat interface, `codex app-server` / `opencode serve` handles local execution, and you can send tasks, inspect progress, approve actions, switch sessions, and keep working without opening a laptop.
 
 It is built for the moments when you leave your desk for lunch, commute, travel, use a treadmill, or take the kids to the park. You can step away from the keyboard while Codex keeps coding and sends progress, errors, approval requests, and final results back to your phone.
 
@@ -120,6 +120,22 @@ FoxClaw accepts messages only from `TG_ALLOWED_USER_ID`. Putting the bot in a gr
 
 </details>
 
+## Independent OpenCode Bot (0.6.1+)
+
+Your existing Codex bots remain unchanged. Create one more independent bot with `@BotFather` and configure:
+
+```dotenv
+OPENCODE_BOT_TOKEN=234567:different-opencode-bot-token
+# Optional; defaults to PATH lookup
+OPENCODE_CLI_BIN=/absolute/path/to/opencode
+```
+
+After FoxClaw restarts, this bot uses a managed `opencode serve` protected by Basic Auth and bound only to `127.0.0.1`. When `OPENCODE_SERVER_PASSWORD` is unset, FoxClaw generates one and saves it in the managed state file with mode `0600`. Never reuse a token from `TG_BOT_TOKENS` / `TG_BOT_TOKEN`, because two long-poll runtimes would compete for the same Telegram updates.
+
+The OpenCode bot preserves the main Codex-bot habits: plain messages and attachments, `/new`, `/threads` plus numbered `/open`, `/watch`, an in-place `/setup` panel, a two-level Provider → Model selector, variants, Agent/one-shot Plan, three access presets, active-turn `/steer`/`queue`/`takeover`, merged streaming, tool progress, approval buttons, and question options. `/undo`/`redo`, `/review`, and archive operations use native OpenCode APIs; `/apps` maps to MCP, while Plugins, Hooks, Features, and voice entry points remain available. Codex account, quota, Goal, Remote, and Fast service-tier commands have no OpenCode serve equivalent, so their menu entries explain the limitation and replacement workflow.
+
+Provider authentication remains an OpenCode terminal operation, such as `opencode auth`. When an OpenCode bot is configured, `foxclaw doctor` also checks the OpenCode CLI and token isolation.
+
 ## Multi-Account Rotation
 
 A key FoxClaw feature is automatic multi-account switching. When one account's usage limit is triggered, FoxClaw automatically switches to the next available account and continues working.

package/dist/auth/cross_node_sync.d.ts

@@ -299,6 +299,7 @@ export declare class CrossNodeAuthSync {
     private readonly pendingLeases;
     private readonly pendingTests;
     private readonly pendingAudits;
+    private readonly pendingAuditVerifications;
     private seenNonces;
     private lastPeerActivityAt;
     private timer;
@@ -338,11 +339,17 @@ export declare class CrossNodeAuthSync {
     private handleMessage;
     private handleAuditRequest;
     private handleAuditResponse;
+    private handleAuditVerificationRequest;
+    private handleAuditVerificationResponse;
     private handleAuditApply;
     private applyAuditState;
     private buildAuditReport;
+    private verifySingleNodeInvalidCandidates;
+    private verifyBundlesIntoAuditReport;
+    private validateAuditBundle;
     private reconcileAuditReports;
     private finishPendingAudit;
+    private finishPendingAuditVerification;
     private handleServiceUpdateRequest;
     private handlePullRequest;
     private handlePullResponse;

package/dist/auth/cross_node_sync.js

@@ -27,6 +27,7 @@ export class CrossNodeAuthSync {
     pendingLeases = new Map();
     pendingTests = new Map();
     pendingAudits = new Map();
+    pendingAuditVerifications = new Map();
     seenNonces = new Map();
     lastPeerActivityAt = new Map();
     timer = null;
@@ -523,6 +524,7 @@ export class CrossNodeAuthSync {
         }
         const [localReport, remote] = await Promise.all([localReportPromise, remoteReportsPromise]);
         const reports = [localReport, ...remote.reports.values()];
+        await this.verifySingleNodeInvalidCandidates(requestId, reports);
         const result = await this.reconcileAuditReports(requestId, reports, remote.missing);
         this.recordEvent({
             direction: 'local',
@@ -641,6 +643,12 @@ export class CrossNodeAuthSync {
             case 'audit.response':
                 this.handleAuditResponse(message, normalizePeerIdentity(peer));
                 return;
+            case 'audit.verify.request':
+                await this.handleAuditVerificationRequest(message, normalizePeerIdentity(peer));
+                return;
+            case 'audit.verify.response':
+                this.handleAuditVerificationResponse(message, normalizePeerIdentity(peer));
+                return;
             case 'audit.apply':
                 await this.handleAuditApply(message, senderNodeId, sourceLabel, normalizePeerIdentity(peer));
                 return;
@@ -686,6 +694,62 @@ export class CrossNodeAuthSync {
             this.finishPendingAudit(message.requestId);
         }
     }
+    async handleAuditVerificationRequest(message, peer) {
+        let report;
+        if (!this.callbacks.isIdle()) {
+            report = { nodeId: this.nodeId ?? 'local', status: 'busy', records: [], reason: 'runtime is not idle' };
+        }
+        else {
+            const records = [];
+            const bundles = Array.isArray(message.bundles)
+                ? message.bundles.filter(bundle => isValidBundle(bundle) && sha256(bundle.rawAuth) === bundle.authSha256)
+                : [];
+            for (const bundle of bundles) {
+                const validation = await this.validateAuditBundle(bundle);
+                records.push({
+                    candidateName: bundle.candidateName,
+                    authSha256: bundle.authSha256,
+                    status: validation.ok ? 'valid' : 'invalid',
+                    reason: validation.ok ? null : validation.reason ?? 'usage validation failed',
+                });
+            }
+            report = { nodeId: this.nodeId ?? 'local', status: 'completed', records, reason: null };
+        }
+        await this.sendToPeer(peer, {
+            kind: 'audit.verify.response',
+            requestId: message.requestId,
+            verificationId: message.verificationId,
+            report,
+        });
+        this.recordEvent({
+            direction: 'local',
+            kind: 'audit.verify.response',
+            stage: 'sent',
+            peer,
+            requestId: message.requestId,
+            candidateName: null,
+            detail: `${report.status}; records=${report.records.length}`,
+        });
+    }
+    handleAuditVerificationResponse(message, peer) {
+        const pending = this.pendingAuditVerifications.get(message.verificationId);
+        if (!pending || pending.finished || !isValidAuditVerificationReport(message.report))
+            return;
+        const matchedPeer = this.matchConfiguredPeer(peer) ?? peer;
+        pending.reports.set(matchedPeer, message.report);
+        this.recordEvent({
+            direction: 'local',
+            kind: 'audit.verify.response',
+            stage: 'received',
+            peer: matchedPeer,
+            requestId: message.requestId,
+            candidateName: null,
+            detail: `${message.report.status}; records=${message.report.records.length}; node=${message.report.nodeId}`,
+        });
+        if (pending.peers.every(peerName => pending.reports.has(peerName))) {
+            this.finishPendingAuditVerification(message.verificationId);
+        }
+    }
     async handleAuditApply(message, senderNodeId, sourceLabel, peer) {
         const outcome = await this.validateAndImport({ ...message.bundle, requestId: message.requestId }, senderNodeId, sourceLabel, peer, 'push', message.replaceExisting);
         if (!outcome.ok)
@@ -747,7 +811,7 @@ export class CrossNodeAuthSync {
                 lastRefreshMs: candidate.lastRefreshMs,
                 status: validation.ok ? 'valid' : 'invalid',
                 reason: validation.ok ? null : validation.reason ?? 'usage validation failed',
-                bundle: validation.ok ? bundle : null,
+                bundle,
             });
         }
         return {
@@ -757,6 +821,107 @@ export class CrossNodeAuthSync {
             reason: null,
         };
     }
+    async verifySingleNodeInvalidCandidates(requestId, reports) {
+        const completedReports = reports.filter(report => report.status === 'completed');
+        const entries = new Map();
+        for (const report of completedReports) {
+            for (const record of report.records) {
+                const candidateEntries = entries.get(record.candidateName) ?? [];
+                candidateEntries.push({ report, record });
+                entries.set(record.candidateName, candidateEntries);
+            }
+        }
+        const bundles = [];
+        for (const candidateEntries of entries.values()) {
+            if (candidateEntries.some(entry => entry.record.status === 'valid'))
+                continue;
+            const invalidNodes = new Set(candidateEntries.map(entry => entry.report.nodeId));
+            if (invalidNodes.size >= 2)
+                continue;
+            const latest = candidateEntries
+                .filter(entry => entry.record.bundle !== null)
+                .sort((left, right) => right.record.lastRefreshMs - left.record.lastRefreshMs)[0];
+            if (latest?.record.bundle)
+                bundles.push(latest.record.bundle);
+        }
+        if (bundles.length === 0)
+            return;
+        const localReport = completedReports.find(report => report.nodeId === this.nodeId);
+        if (localReport) {
+            await this.verifyBundlesIntoAuditReport(localReport, bundles);
+        }
+        if (!this.isReady())
+            return;
+        const verificationId = crypto.randomUUID();
+        const remoteReports = await new Promise((resolve) => {
+            const timer = setTimeout(() => this.finishPendingAuditVerification(verificationId), AUDIT_TIMEOUT_MS);
+            timer.unref();
+            this.pendingAuditVerifications.set(verificationId, {
+                peers: [...this.peers],
+                reports: new Map(),
+                resolve,
+                timer,
+                finished: false,
+            });
+            void this.sendToAll({ kind: 'audit.verify.request', requestId, verificationId, bundles }).catch(() => {
+                this.finishPendingAuditVerification(verificationId);
+            });
+        });
+        const bundlesByHash = new Map(bundles.map(bundle => [bundle.authSha256, bundle]));
+        for (const verification of remoteReports.values()) {
+            if (verification.status !== 'completed')
+                continue;
+            let target = completedReports.find(report => report.nodeId === verification.nodeId);
+            if (!target) {
+                target = { nodeId: verification.nodeId, status: 'completed', records: [], reason: null };
+                reports.push(target);
+                completedReports.push(target);
+            }
+            for (const record of verification.records) {
+                const bundle = bundlesByHash.get(record.authSha256);
+                if (!bundle || bundle.candidateName !== record.candidateName)
+                    continue;
+                if (record.status === 'valid') {
+                    target.records = target.records.filter(existing => existing.candidateName !== record.candidateName);
+                }
+                else if (target.records.some(existing => existing.candidateName === record.candidateName)) {
+                    continue;
+                }
+                target.records.push({
+                    candidateName: bundle.candidateName,
+                    accountId: bundle.accountId,
+                    quotaIdentityId: bundle.quotaIdentityId ?? null,
+                    lastRefreshMs: bundle.lastRefreshMs,
+                    status: record.status,
+                    reason: record.reason,
+                    bundle,
+                });
+            }
+        }
+    }
+    async verifyBundlesIntoAuditReport(report, bundles) {
+        for (const bundle of bundles) {
+            if (report.records.some(record => record.candidateName === bundle.candidateName))
+                continue;
+            const validation = await this.validateAuditBundle(bundle);
+            report.records.push({
+                candidateName: bundle.candidateName,
+                accountId: bundle.accountId,
+                quotaIdentityId: bundle.quotaIdentityId ?? null,
+                lastRefreshMs: bundle.lastRefreshMs,
+                status: validation.ok ? 'valid' : 'invalid',
+                reason: validation.ok ? null : validation.reason ?? 'usage validation failed',
+                bundle,
+            });
+        }
+    }
+    async validateAuditBundle(bundle) {
+        const expiresAt = readAccessTokenExpiresAtMs(bundle.rawAuth);
+        if (expiresAt === null || expiresAt <= Date.now() + REMOTE_ACCESS_TOKEN_MIN_TTL_MS) {
+            return { ok: false, reason: 'access token is expired or missing exp' };
+        }
+        return this.callbacks.validateCandidate(bundle.candidateName, bundle.rawAuth, bundle.accountId);
+    }
     async reconcileAuditReports(requestId, reports, missingPeers) {
         const completedReports = reports.filter(report => report.status === 'completed');
         const busyNodes = reports.filter(report => report.status === 'busy').map(report => report.nodeId);
@@ -872,6 +1037,15 @@ export class CrossNodeAuthSync {
         const missing = pending.peers.filter(peer => !pending.reports.has(peer));
         pending.resolve({ reports: pending.reports, missing });
     }
+    finishPendingAuditVerification(verificationId) {
+        const pending = this.pendingAuditVerifications.get(verificationId);
+        if (!pending || pending.finished)
+            return;
+        pending.finished = true;
+        clearTimeout(pending.timer);
+        this.pendingAuditVerifications.delete(verificationId);
+        pending.resolve(pending.reports);
+    }
     async handleServiceUpdateRequest(message, senderNodeId, sourceLabel, peer) {
         let result = {
             accepted: false,
@@ -1722,6 +1896,18 @@ function isValidAuditReport(value) {
             && (record.bundle === null || isValidBundle(record.bundle))
             && (record.status !== 'valid' || record.bundle !== null)));
 }
+function isValidAuditVerificationReport(value) {
+    return Boolean(value)
+        && typeof value.nodeId === 'string'
+        && (value.status === 'completed' || value.status === 'busy')
+        && Array.isArray(value.records)
+        && (typeof value.reason === 'string' || value.reason === null)
+        && value.records.every(record => (typeof record.candidateName === 'string'
+            && isAuthCandidateName(record.candidateName)
+            && typeof record.authSha256 === 'string'
+            && (record.status === 'valid' || record.status === 'invalid')
+            && (typeof record.reason === 'string' || record.reason === null)));
+}
 function auditIdentityKey(accountId, quotaIdentityId) {
     return `${accountId}\u0000${quotaIdentityId || accountId}`;
 }
@@ -1835,6 +2021,8 @@ function requestIdFromMessage(message) {
         case 'test.pong':
         case 'audit.request':
         case 'audit.response':
+        case 'audit.verify.request':
+        case 'audit.verify.response':
         case 'audit.apply':
         case 'audit.state':
         case 'service.update.request':
@@ -1859,6 +2047,8 @@ function candidateNameFromMessage(message) {
             return message.bundle?.candidateName ?? null;
         case 'audit.apply':
             return message.bundle.candidateName;
+        case 'audit.verify.request':
+            return message.bundles.length === 1 ? message.bundles[0]?.candidateName ?? null : null;
         case 'audit.state':
             return message.candidateName;
         default:

package/dist/codex_app/client.d.ts

@@ -176,4 +176,5 @@ export declare class CodexAppClient extends EventEmitter {
     private clearServerState;
     private clearServerStateForPid;
 }
+export declare function terminateManagedProcessGroup(pid: number, gracefulTimeoutMs?: number, forcedTimeoutMs?: number): Promise<'not-running' | 'terminated' | 'killed'>;
 export {};

package/dist/codex_app/client.js

@@ -710,24 +710,24 @@ export class CodexAppClient extends EventEmitter {
         const state = this.readServerState();
         const pid = child?.pid ?? state?.pid ?? null;
         this.child = null;
-        this.clearServerState();
-        if (pid === null || !isProcessAlive(pid)) {
+        if (pid === null || !isManagedProcessGroupAlive(pid)) {
+            this.clearServerState();
             return;
         }
         try {
-            process.kill(pid, 'SIGTERM');
+            const result = await terminateManagedProcessGroup(pid);
+            if (result === 'killed') {
+                this.logger.warn('codex.app-server.force_killed', { pid });
+            }
         }
         catch (error) {
             this.logger.warn('codex.app-server.kill_failed', {
                 pid,
                 error: error instanceof Error ? error.message : String(error),
             });
-            return;
-        }
-        const exited = await waitForProcessExit(pid, 3000);
-        if (!exited) {
-            this.logger.warn('codex.app-server.kill_timeout', { pid });
+            throw error;
         }
+        this.clearServerStateForPid(pid);
     }
     openServerLogFiles() {
         fs.mkdirSync(path.dirname(this.serverLogPath), { recursive: true });
@@ -831,15 +831,66 @@ function isProcessAlive(pid) {
         return error.code === 'EPERM';
     }
 }
-async function waitForProcessExit(pid, timeoutMs) {
+export async function terminateManagedProcessGroup(pid, gracefulTimeoutMs = 3000, forcedTimeoutMs = 2000) {
+    if (!isManagedProcessGroupAlive(pid)) {
+        return 'not-running';
+    }
+    signalManagedProcessGroup(pid, 'SIGTERM');
+    if (await waitForProcessGroupExit(pid, gracefulTimeoutMs)) {
+        return 'terminated';
+    }
+    signalManagedProcessGroup(pid, 'SIGKILL');
+    if (await waitForProcessGroupExit(pid, forcedTimeoutMs)) {
+        return 'killed';
+    }
+    throw new Error(`Codex app-server process group ${pid} did not exit after SIGKILL`);
+}
+function signalManagedProcessGroup(pid, signal) {
+    try {
+        process.kill(-pid, signal);
+    }
+    catch (error) {
+        if (error.code !== 'ESRCH') {
+            throw error;
+        }
+        try {
+            process.kill(pid, signal);
+        }
+        catch (fallbackError) {
+            if (fallbackError.code !== 'ESRCH') {
+                throw fallbackError;
+            }
+        }
+    }
+}
+function isManagedProcessGroupAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(-pid, 0);
+        return true;
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'EPERM') {
+            return true;
+        }
+        if (code === 'ESRCH') {
+            return isProcessAlive(pid);
+        }
+        throw error;
+    }
+}
+async function waitForProcessGroupExit(pid, timeoutMs) {
     const started = Date.now();
     while (Date.now() - started < timeoutMs) {
-        if (!isProcessAlive(pid)) {
+        if (!isManagedProcessGroupAlive(pid)) {
             return true;
         }
         await sleep(100);
     }
-    return !isProcessAlive(pid);
+    return !isManagedProcessGroupAlive(pid);
 }
 function mapThread(raw) {
     return {
@@ -1199,7 +1250,7 @@ function normalizeCollaborationMode(value) {
     return value === 'default' || value === 'plan' ? value : null;
 }
 function normalizeReasoningEffort(value) {
-    return typeof value === 'string' && ['none', 'minimal', 'low', 'medium', 'high', 'xhigh'].includes(value)
+    return typeof value === 'string' && ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'].includes(value)
         ? value
         : null;
 }

package/dist/config.d.ts

@@ -7,6 +7,8 @@ export declare const DEFAULT_LOG_PATH: string;
 export declare const DEFAULT_LOCK_PATH: string;
 export declare const DEFAULT_CODEX_APP_SERVER_STATE_PATH: string;
 export declare const DEFAULT_CODEX_APP_SERVER_LOG_PATH: string;
+export declare const DEFAULT_OPENCODE_SERVER_STATE_PATH: string;
+export declare const DEFAULT_OPENCODE_SERVER_LOG_PATH: string;
 export declare const DEFAULT_CODEX_TELEGRAM_HOME: string;
 export declare const DEFAULT_AUTH_SYNC_STATE_PATH: string;
 export declare const DEFAULT_AUTH_SYNC_TEMP_DIR: string;
@@ -35,6 +37,11 @@ export interface AppConfig {
     codexApiDefaultProvider: string | null;
     codexAppSyncOnOpen: boolean;
     codexAppSyncOnTurnComplete: boolean;
+    opencodeBotToken: string | null;
+    opencodeCliBin: string;
+    opencodeServerPassword: string | null;
+    opencodeServerStatePath: string;
+    opencodeServerLogPath: string;
     storePath: string;
     logLevel: LogLevel;
     defaultCwd: string;
@@ -93,6 +100,7 @@ export interface CodexApiProviderConfig {
 }
 export declare function loadConfig(): AppConfig;
 export declare function buildCodexApiProviderOverrides(providers: readonly CodexApiProviderConfig[], defaultProviderId?: string | null): string[];
+export declare function validateOpencodeBotToken(token: string | null, codexTokens: readonly string[]): void;
 export declare function parseCodexApiProviders(raw: string | undefined): CodexApiProviderConfig[];
 export declare function selectDefaultRuntimeBotToken(configuredTokens: string[], legacyToken: string | null): string | null;
 export declare function ensureAppDirs(config: AppConfig): void;

package/dist/config.js

@@ -10,6 +10,8 @@ export const DEFAULT_LOG_PATH = path.join(APP_HOME, 'logs', 'service.log');
 export const DEFAULT_LOCK_PATH = path.join(APP_HOME, 'runtime', 'bridge.lock');
 export const DEFAULT_CODEX_APP_SERVER_STATE_PATH = path.join(APP_HOME, 'runtime', 'codex-app-server.json');
 export const DEFAULT_CODEX_APP_SERVER_LOG_PATH = path.join(APP_HOME, 'logs', 'codex-app-server.log');
+export const DEFAULT_OPENCODE_SERVER_STATE_PATH = path.join(APP_HOME, 'runtime', 'opencode-server.json');
+export const DEFAULT_OPENCODE_SERVER_LOG_PATH = path.join(APP_HOME, 'logs', 'opencode-server.log');
 export const DEFAULT_CODEX_TELEGRAM_HOME = path.join(APP_HOME, 'codex', 'telegram');
 export const DEFAULT_AUTH_SYNC_STATE_PATH = path.join(APP_HOME, 'runtime', 'auth-sync.json');
 export const DEFAULT_AUTH_SYNC_TEMP_DIR = path.join(APP_HOME, 'runtime', 'auth-sync');
@@ -51,6 +53,8 @@ export function loadConfig() {
     if (tgBotTokens.length === 0) {
         throw new Error('TG_BOT_TOKENS or TG_BOT_TOKEN is required');
     }
+    const opencodeBotToken = optional('OPENCODE_BOT_TOKEN');
+    validateOpencodeBotToken(opencodeBotToken, tgBotTokens);
     const config = {
         tgBotToken: tgBotTokens[0],
         tgBotTokens,
@@ -72,6 +76,11 @@ export function loadConfig() {
         codexApiDefaultProvider: optionalSanitizedProviderId(process.env.CODEX_API_DEFAULT_PROVIDER),
         codexAppSyncOnOpen: boolEnv('CODEX_APP_SYNC_ON_OPEN', true),
         codexAppSyncOnTurnComplete: boolEnv('CODEX_APP_SYNC_ON_TURN_COMPLETE', false),
+        opencodeBotToken,
+        opencodeCliBin: process.env.OPENCODE_CLI_BIN || resolveCommand('opencode') || 'opencode',
+        opencodeServerPassword: optional('OPENCODE_SERVER_PASSWORD'),
+        opencodeServerStatePath: process.env.OPENCODE_SERVER_STATE_PATH || DEFAULT_OPENCODE_SERVER_STATE_PATH,
+        opencodeServerLogPath: process.env.OPENCODE_SERVER_LOG_PATH || DEFAULT_OPENCODE_SERVER_LOG_PATH,
         storePath: process.env.STORE_PATH || DEFAULT_STORE_PATH,
         logLevel: parseLogLevel(process.env.LOG_LEVEL || 'info'),
         defaultCwd: process.env.DEFAULT_CWD || process.cwd(),
@@ -140,6 +149,13 @@ export function buildCodexApiProviderOverrides(providers, defaultProviderId = nu
     }
     return overrides;
 }
+export function validateOpencodeBotToken(token, codexTokens) {
+    if (!token)
+        return;
+    if (codexTokens.includes(token)) {
+        throw new Error('OPENCODE_BOT_TOKEN must use a different bot from TG_BOT_TOKENS/TG_BOT_TOKEN');
+    }
+}
 export function parseCodexApiProviders(raw) {
     if (!raw?.trim())
         return [];
@@ -249,6 +265,8 @@ export function ensureAppDirs(config) {
         path.dirname(config.lockPath),
         path.dirname(config.codexAppServerStatePath),
         path.dirname(config.codexAppServerLogPath),
+        path.dirname(config.opencodeServerStatePath),
+        path.dirname(config.opencodeServerLogPath),
         path.dirname(config.authSyncStatePath),
     ];
     if (config.authSyncEnabled) {