@foxden-app/foxclaw 0.7.3 → 0.10.0

package/dist/channels/telegram/telegram_channel_adapter.js

@@ -1,5 +1,6 @@
 /**
- * Telegram channel: inbound subscription + transport startup ordering for {@link BridgeSessionCore}.
+ * Telegram channel: inbound subscription + transport startup ordering for {@link BridgeSessionCore}
+ * or {@link UnifiedBridgeCore}.
  * Additional channels (e.g. Weixin) can compose the same core with their own adapters.
  */
 export class TelegramChannelAdapter {

package/dist/channels/weixin/weixin_channel_adapter.d.ts

@@ -2,6 +2,10 @@ import type { AppConfig } from '../../config.js';
 import type { BridgeSessionCore } from '../../controller/controller.js';
 import type { Logger } from '../../logger.js';
 import type { BridgeStore } from '../../store/database.js';
+import type { TelegramTextEvent } from '../../telegram/gateway.js';
+export interface IWeixinBridgeCore {
+    dispatchInboundLikeTelegramText(event: TelegramTextEvent): void;
+}
 export declare class WeixinChannelAdapter {
     private readonly core;
     private readonly store;
@@ -9,7 +13,7 @@ export declare class WeixinChannelAdapter {
     private readonly logger;
     private readonly abort;
     private loops;
-    constructor(core: BridgeSessionCore, store: BridgeStore, config: AppConfig, logger: Logger);
+    constructor(core: BridgeSessionCore | IWeixinBridgeCore, store: BridgeStore, config: AppConfig, logger: Logger);
     start(): Promise<void>;
     stop(): Promise<void>;
     private listAccounts;

package/dist/codex_app/adapter.d.ts

@@ -0,0 +1,20 @@
+import type { IEngineAdapter, EngineModel, EngineTurnRequest, EngineTurnExecution } from '../core/engine_spi.js';
+import type { CodexAppClient } from './client.js';
+import type { SandboxModeValue } from '../types.js';
+export declare class CodexEngineAdapter implements IEngineAdapter {
+    private readonly client;
+    readonly id: string;
+    readonly name: string;
+    private readonly defaultModel;
+    private readonly defaultApprovalPolicy;
+    private readonly defaultSandboxMode;
+    constructor(client: CodexAppClient, options?: {
+        id?: string;
+        name?: string;
+        defaultModel?: string | undefined;
+        defaultApprovalPolicy?: string;
+        defaultSandboxMode?: SandboxModeValue;
+    });
+    listModels(): Promise<EngineModel[]>;
+    executeTurn(request: EngineTurnRequest): EngineTurnExecution;
+}

package/dist/codex_app/adapter.js

@@ -0,0 +1,213 @@
+import { EventEmitter } from 'node:events';
+import { normalizeTurnActivityEvent } from '../controller/activity.js';
+import { buildAttachmentPrompt } from '../telegram/media.js';
+export class CodexEngineAdapter {
+    client;
+    id;
+    name;
+    defaultModel;
+    defaultApprovalPolicy;
+    defaultSandboxMode;
+    constructor(client, options = {}) {
+        this.client = client;
+        this.id = options.id ?? 'codex';
+        this.name = options.name ?? 'OpenAI Codex (App Server)';
+        this.defaultModel = options.defaultModel;
+        this.defaultApprovalPolicy = options.defaultApprovalPolicy ?? 'on-request';
+        this.defaultSandboxMode = options.defaultSandboxMode ?? 'workspace-write';
+    }
+    async listModels() {
+        try {
+            const models = await this.client.listModels();
+            const list = models.map((m) => ({
+                id: m.id,
+                name: m.displayName || m.id,
+                description: m.description,
+                isDefault: m.isDefault || m.id === this.defaultModel,
+            }));
+            if (!list.some((m) => m.id === 'gpt-6-sol')) {
+                list.push({
+                    id: 'gpt-6-sol',
+                    name: 'GPT-6-Sol',
+                    description: 'Next-generation flagship model with deep reasoning',
+                    isDefault: false,
+                });
+            }
+            return list;
+        }
+        catch {
+            return [];
+        }
+    }
+    executeTurn(request) {
+        const emitter = new EventEmitter();
+        let threadId = request.threadId;
+        let turnId = null;
+        let cancelled = false;
+        let promptText = request.prompt;
+        if (request.stagedAttachments && request.stagedAttachments.length > 0 && !request.prompt.includes('Telegram attachments:')) {
+            promptText = buildAttachmentPrompt(request.prompt, request.stagedAttachments);
+        }
+        let accumulatedResponse = '';
+        let finalResult = null;
+        let turnError = null;
+        const resultWaiters = [];
+        const resolveWaiters = (res) => {
+            while (resultWaiters.length > 0) {
+                resultWaiters.shift()(res);
+            }
+        };
+        const onNotification = (msg) => {
+            try {
+                const ev = normalizeTurnActivityEvent(msg);
+                if (!ev)
+                    return;
+                if (ev.turnId && turnId && ev.turnId !== turnId)
+                    return;
+                if (ev.kind === 'agent_message_delta') {
+                    accumulatedResponse += ev.delta;
+                    emitter.emit('delta', ev.delta);
+                }
+                else if (ev.kind === 'tool_started') {
+                    const cmdName = Array.isArray(ev.exec?.command) ? ev.exec.command.join(' ') : 'command';
+                    emitter.emit('tool', {
+                        name: cmdName,
+                        status: 'running',
+                    });
+                }
+                else if (ev.kind === 'tool_completed') {
+                    const cmdName = Array.isArray(ev.exec?.command) ? ev.exec.command.join(' ') : 'command';
+                    emitter.emit('tool', {
+                        name: cmdName,
+                        status: 'completed',
+                    });
+                }
+                else if (ev.kind === 'turn_completed') {
+                    cleanup();
+                    finalResult = {
+                        kind: 'result',
+                        status: ev.state === 'interrupted' ? 'INTERRUPTED' : 'SUCCESS',
+                        response: accumulatedResponse,
+                        conversationId: threadId,
+                    };
+                    emitter.emit('result', finalResult);
+                    resolveWaiters(finalResult);
+                }
+            }
+            catch {
+                // Ignore parsing errors for unrelated notifications
+            }
+        };
+        const cleanup = () => {
+            this.client.off('notification', onNotification);
+        };
+        this.client.on('notification', onNotification);
+        const effectiveModel = request.model && request.model !== 'default'
+            ? request.model
+            : (this.defaultModel && this.defaultModel !== 'default' ? this.defaultModel : null);
+        const run = async () => {
+            try {
+                if (!threadId) {
+                    const session = await this.client.startThread({
+                        cwd: request.cwd,
+                        model: effectiveModel,
+                        approvalPolicy: this.defaultApprovalPolicy,
+                        sandboxMode: this.defaultSandboxMode,
+                    });
+                    threadId = session.thread.threadId;
+                }
+                else {
+                    try {
+                        await this.client.resumeThread({
+                            threadId,
+                            cwd: request.cwd,
+                            approvalPolicy: this.defaultApprovalPolicy,
+                        });
+                    }
+                    catch {
+                        // thread might already be active on server
+                    }
+                }
+                if (cancelled) {
+                    cleanup();
+                    return;
+                }
+                if (!threadId) {
+                    throw new Error('Failed to resolve or create Codex thread for turn');
+                }
+                let turn;
+                try {
+                    turn = await this.client.startTurn({
+                        threadId,
+                        input: [{ type: 'text', text: promptText, text_elements: [] }],
+                        cwd: request.cwd,
+                        model: effectiveModel,
+                        effort: request.effort ?? null,
+                        serviceTier: request.serviceTier ?? undefined,
+                        collaborationMode: null,
+                        approvalPolicy: this.defaultApprovalPolicy,
+                        sandboxMode: this.defaultSandboxMode,
+                    });
+                }
+                catch (turnErr) {
+                    const errMsg = String(turnErr);
+                    if (errMsg.includes('not found') ||
+                        errMsg.includes('No thread') ||
+                        errMsg.includes('stale') ||
+                        errMsg.includes('invalid thread')) {
+                        const session = await this.client.startThread({
+                            cwd: request.cwd,
+                            model: effectiveModel,
+                            approvalPolicy: this.defaultApprovalPolicy,
+                            sandboxMode: this.defaultSandboxMode,
+                        });
+                        threadId = session.thread.threadId;
+                        turn = await this.client.startTurn({
+                            threadId,
+                            input: [{ type: 'text', text: promptText, text_elements: [] }],
+                            cwd: request.cwd,
+                            model: effectiveModel,
+                            effort: request.effort ?? null,
+                            serviceTier: request.serviceTier ?? undefined,
+                            collaborationMode: null,
+                            approvalPolicy: this.defaultApprovalPolicy,
+                            sandboxMode: this.defaultSandboxMode,
+                        });
+                    }
+                    else {
+                        throw turnErr;
+                    }
+                }
+                turnId = turn.id;
+            }
+            catch (err) {
+                cleanup();
+                turnError = err instanceof Error ? err : new Error(String(err));
+                emitter.emit('error', turnError);
+                resolveWaiters(null);
+            }
+        };
+        void run();
+        return {
+            turnId: turnId ?? undefined,
+            cancel: () => {
+                cancelled = true;
+                if (threadId && turnId) {
+                    void this.client.interruptTurn(threadId, turnId).catch(() => { });
+                }
+            },
+            waitForResult: async () => {
+                if (finalResult)
+                    return finalResult;
+                if (turnError)
+                    return null;
+                return new Promise((resolve) => {
+                    resultWaiters.push(resolve);
+                });
+            },
+            on: (event, listener) => {
+                emitter.on(event, listener);
+            },
+        };
+    }
+}

package/dist/codex_app/client.d.ts

@@ -49,7 +49,7 @@ interface StartTurnOptions {
     serviceTier?: string | null | undefined;
     collaborationMode: CodexCollaborationMode | null;
 }
-interface CodexAppServerRuntimeStatus {
+export interface CodexAppServerRuntimeStatus {
     pid: number | null;
     port: number | null;
     running: boolean;

package/dist/codex_app/client.js

@@ -284,6 +284,18 @@ export class CodexAppClient extends EventEmitter {
             models.push(...rows.map(mapModel));
             cursor = typeof result.nextCursor === 'string' ? result.nextCursor : null;
         } while (cursor);
+        if (!models.some((m) => m.id === 'gpt-6-sol' || m.model === 'gpt-6-sol')) {
+            models.push({
+                id: 'gpt-6-sol',
+                model: 'gpt-6-sol',
+                displayName: 'GPT-6-Sol',
+                description: 'Next-generation flagship model with deep reasoning',
+                isDefault: false,
+                supportedReasoningEfforts: ['low', 'medium', 'high', 'xhigh', 'max'],
+                defaultReasoningEffort: 'medium',
+                serviceTiers: [],
+            });
+        }
         return models;
     }
     async readAccount(refreshToken = false) {

package/dist/config.d.ts

@@ -9,7 +9,9 @@ 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_ANTIGRAVITY_AUTH_DIR: string;
 export declare const DEFAULT_CODEX_TELEGRAM_HOME: string;
+export declare const DEFAULT_ANTIGRAVITY_TELEGRAM_HOME: string;
 export declare const DEFAULT_AUTH_SYNC_STATE_PATH: string;
 export declare const DEFAULT_AUTH_SYNC_TEMP_DIR: string;
 export declare const DEFAULT_ENV_PATH: string;
@@ -42,6 +44,14 @@ export interface AppConfig {
     opencodeServerPassword: string | null;
     opencodeServerStatePath: string;
     opencodeServerLogPath: string;
+    antigravityBotToken: string | null;
+    antigravityBotTokens: string[];
+    antigravityMultiBotMode: boolean;
+    antigravityDefaultRuntimeBotToken: string | null;
+    antigravityHome: string | null;
+    antigravityCliBin: string;
+    antigravityAuthDir: string;
+    antigravityDefaultModel: string;
     storePath: string;
     logLevel: LogLevel;
     defaultCwd: string;
@@ -101,6 +111,8 @@ 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 validateAntigravityBotTokens(tokens: readonly string[], codexTokens: readonly string[], opencodeToken: string | null): void;
+export declare function validateAntigravityBotToken(token: string | null, codexTokens: readonly string[], opencodeToken: string | null): 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

@@ -12,7 +12,9 @@ export const DEFAULT_CODEX_APP_SERVER_STATE_PATH = path.join(APP_HOME, 'runtime'
 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_ANTIGRAVITY_AUTH_DIR = path.join(os.homedir(), '.gemini', 'antigravity-cli');
 export const DEFAULT_CODEX_TELEGRAM_HOME = path.join(APP_HOME, 'codex', 'telegram');
+export const DEFAULT_ANTIGRAVITY_TELEGRAM_HOME = path.join(APP_HOME, 'antigravity', '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');
 export const DEFAULT_ENV_PATH = path.join(APP_HOME, '.env');
@@ -55,6 +57,16 @@ export function loadConfig() {
     }
     const opencodeBotToken = optional('OPENCODE_BOT_TOKEN');
     validateOpencodeBotToken(opencodeBotToken, tgBotTokens);
+    const configuredAntigravityTokens = parseCommaSeparatedIds(process.env.ANTIGRAVITY_BOT_TOKENS);
+    const legacyAntigravityToken = optional('ANTIGRAVITY_BOT_TOKEN');
+    const antigravityDefaultRuntimeBotToken = selectDefaultRuntimeBotToken(configuredAntigravityTokens, legacyAntigravityToken);
+    const antigravityBotTokens = configuredAntigravityTokens.length > 0
+        ? configuredAntigravityTokens
+        : legacyAntigravityToken
+            ? [legacyAntigravityToken]
+            : [];
+    const antigravityBotToken = antigravityBotTokens[0] || null;
+    validateAntigravityBotTokens(antigravityBotTokens, tgBotTokens, opencodeBotToken);
     const config = {
         tgBotToken: tgBotTokens[0],
         tgBotTokens,
@@ -81,6 +93,14 @@ export function loadConfig() {
         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,
+        antigravityBotToken,
+        antigravityBotTokens,
+        antigravityMultiBotMode: configuredAntigravityTokens.length > 0,
+        antigravityDefaultRuntimeBotToken,
+        antigravityHome: process.env.ANTIGRAVITY_HOME?.trim() || null,
+        antigravityCliBin: process.env.ANTIGRAVITY_CLI_BIN || resolveCommand('agy') || '/home/wuya/.local/bin/agy',
+        antigravityAuthDir: process.env.ANTIGRAVITY_AUTH_DIR?.trim() || DEFAULT_ANTIGRAVITY_AUTH_DIR,
+        antigravityDefaultModel: process.env.ANTIGRAVITY_DEFAULT_MODEL?.trim() || 'gemini-3.8-flash-high',
         storePath: process.env.STORE_PATH || DEFAULT_STORE_PATH,
         logLevel: parseLogLevel(process.env.LOG_LEVEL || 'info'),
         defaultCwd: process.env.DEFAULT_CWD || process.cwd(),
@@ -156,6 +176,28 @@ export function validateOpencodeBotToken(token, codexTokens) {
         throw new Error('OPENCODE_BOT_TOKEN must use a different bot from TG_BOT_TOKENS/TG_BOT_TOKEN');
     }
 }
+export function validateAntigravityBotTokens(tokens, codexTokens, opencodeToken) {
+    if (tokens.length === 0)
+        return;
+    const seen = new Set();
+    for (const token of tokens) {
+        if (seen.has(token)) {
+            throw new Error(`ANTIGRAVITY_BOT_TOKENS contains duplicate Telegram bot token: ${token}`);
+        }
+        seen.add(token);
+        if (codexTokens.includes(token)) {
+            throw new Error('ANTIGRAVITY_BOT_TOKENS/ANTIGRAVITY_BOT_TOKEN must use a different bot from TG_BOT_TOKENS/TG_BOT_TOKEN');
+        }
+        if (opencodeToken && token === opencodeToken) {
+            throw new Error('ANTIGRAVITY_BOT_TOKENS/ANTIGRAVITY_BOT_TOKEN must use a different bot from OPENCODE_BOT_TOKEN');
+        }
+    }
+}
+export function validateAntigravityBotToken(token, codexTokens, opencodeToken) {
+    if (!token)
+        return;
+    validateAntigravityBotTokens([token], codexTokens, opencodeToken);
+}
 export function parseCodexApiProviders(raw) {
     if (!raw?.trim())
         return [];

package/dist/controller/controller.d.ts

@@ -2,8 +2,8 @@ import type { AppConfig } from '../config.js';
 import type { Logger } from '../logger.js';
 import type { BridgeStore } from '../store/database.js';
 import { type AuthSyncClusterAuditResult } from '../auth/cross_node_sync.js';
-import type { RuntimeStatus } from '../types.js';
-import type { TelegramGateway, TelegramTextEvent } from '../telegram/gateway.js';
+import type { AppLocale, RuntimeStatus } from '../types.js';
+import type { TelegramGateway, TelegramTextEvent, TelegramCallbackEvent } from '../telegram/gateway.js';
 import { BridgeMessagingRouter } from '../channels/bridge_messaging_router.js';
 import type { CodexAppClient } from '../codex_app/client.js';
 import type { SelfUpdateRuntime, SelfUpdateStatus } from '../update.js';
@@ -119,6 +119,7 @@ export declare class BridgeSessionCore {
      * (used by the Weixin adapter).
      */
     dispatchInboundLikeTelegramText(event: TelegramTextEvent): void;
+    hasPendingInteraction(scopeId: string): boolean;
     /** Start Codex app-server transport and attach RPC listeners. */
     startCodexApp(): Promise<void>;
     /** Begin Telegram Bot API long-polling after handlers and Codex are ready. */
@@ -135,7 +136,7 @@ export declare class BridgeSessionCore {
     private handleWatchCommand;
     private handleThreadArchiveIndexCommand;
     private handleThreadRenameIndexCommand;
-    private handleCallback;
+    handleCallback(event: TelegramCallbackEvent): Promise<void>;
     private handleApprovalTextCommand;
     private handleNotification;
     private handleServerRequest;
@@ -327,7 +328,7 @@ export declare class BridgeSessionCore {
     private clearProactiveAuthRefreshTimer;
     private runProactiveAuthRefresh;
     private recordProactiveAuthRefreshStatus;
-    private handleAuthCommand;
+    handleAuthCommand(scopeId: string, locale: AppLocale, args: string[]): Promise<void>;
     private handleAuthSyncCommand;
     private runAuthSafeSyncAll;
     private runAuthClusterAudit;
@@ -444,7 +445,9 @@ export declare class BridgeSessionCore {
     private handleNavigationCallback;
     private showWherePanel;
     private handleThreadListNavigationCallback;
-    private showThreadsPanel;
+    showThreadsPanel(scopeId: string, messageId?: number, searchTerm?: string | null, locale?: AppLocale, options?: {
+        offset?: number;
+    }, archived?: boolean): Promise<void>;
     private showModelSettingsPanel;
     private showSetupPanel;
     private showAccessSettingsPanel;

package/dist/controller/controller.js

@@ -26,6 +26,7 @@ import { normalizeAccessPreset, resolveAccessMode } from './access.js';
 import { diffObservedTurn, findLatestTurn, findLiveTurn } from './observer.js';
 import { applySessionLog, bootstrapSessionLog, splitJsonlChunk, } from './session_observer.js';
 import { renderActiveTurnStatus } from './status.js';
+import { formatMetricTokenCount } from '../store/token_usage.js';
 import { writeRuntimeStatus } from '../runtime.js';
 const AUTH_DELETE_REASON_NEEDS_REPAIR = 'needs_repair';
 const RESTART_PREVIEW_RECOVERY_RETRY_DELAYS_MS = [3000, 7000, 15_000, 30_000, 45_000, 60_000, 60_000, 60_000];
@@ -212,6 +213,12 @@ export class BridgeSessionCore {
             void this.handleAsyncError('channel.text', error, event.scopeId);
         });
     }
+    hasPendingInteraction(scopeId) {
+        return this.pendingThreadRenames.has(scopeId)
+            || this.pendingThreadNewCwds.has(scopeId)
+            || this.pendingUserInputs.has(scopeId)
+            || this.pendingForceTakeovers.has(scopeId);
+    }
     /** Start Codex app-server transport and attach RPC listeners. */
     async startCodexApp() {
         this.stopping = false;
@@ -324,12 +331,13 @@ export class BridgeSessionCore {
         this.updateStatus();
     }
     getRuntimeStatus() {
+        const appServer = typeof this.app.getServerStatus === 'function' ? this.app.getServerStatus() : null;
         return {
             running: true,
-            connected: this.app.isConnected(),
-            userAgent: this.app.getUserAgent(),
+            connected: typeof this.app.isConnected === 'function' ? this.app.isConnected() : false,
+            userAgent: typeof this.app.getUserAgent === 'function' ? this.app.getUserAgent() : null,
             codexHome: this.config.codexHome ?? path.join(os.homedir(), '.codex'),
-            codexAppServer: this.app.getServerStatus(),
+            ...(appServer ? { codexAppServer: appServer } : {}),
             botUsername: this.botUsername,
             currentBindings: this.store.countBindings(),
             pendingApprovals: this.store.countPendingApprovals(),
@@ -559,6 +567,9 @@ export class BridgeSessionCore {
                         if (codexUpdateLine) {
                             lines.push(t(locale, 'status_last_codex_update', { value: codexUpdateLine }));
                         }
+                        if (lastUpdate.agyUpdate) {
+                            lines.push(locale === 'zh' ? `Antigravity CLI：${lastUpdate.agyUpdate}` : `Antigravity CLI: ${lastUpdate.agyUpdate}`);
+                        }
                     }
                     else {
                         lines.push(t(locale, 'status_last_update_none'));
@@ -3481,7 +3492,9 @@ export class BridgeSessionCore {
             this.coordinator.statusUpdated(status);
             return;
         }
-        writeRuntimeStatus(this.config.statusPath, status);
+        if (this.config.statusPath) {
+            writeRuntimeStatus(this.config.statusPath, status);
+        }
     }
     async sendMessage(scopeId, text, inlineKeyboard) {
         return this.sendRichMarkdownMessage(scopeId, text, inlineKeyboard);
@@ -5044,6 +5057,9 @@ export class BridgeSessionCore {
             const rows = [
                 ['FoxClaw', `${status.fromVersion} -> ${status.toVersion ?? t(status.locale, 'unknown')}`, status.locale === 'zh' ? '升级完成，服务已重启' : 'Updated; service restarted'],
                 ['Codex CLI', formatSelfUpdateVersionTransition(status.codexFromVersion, status.codexToVersion, status.locale), formatCodexUpdateState(status)],
+                ...(status.agyFromVersion || status.agyUpdate ? [
+                    ['Antigravity (AGY)', formatSelfUpdateVersionTransition(status.agyFromVersion ?? null, status.agyToVersion ?? null, status.locale), status.agyUpdate ?? (status.locale === 'zh' ? '已检查更新' : 'Checked')]
+                ] : []),
                 [status.locale === 'zh' ? '集群广播' : 'Cluster broadcast', status.toVersion ?? t(status.locale, 'unknown'), broadcastLine],
             ];
             const notes = status.releaseNotes?.filter(note => note.trim()) ?? [];
@@ -5061,6 +5077,7 @@ export class BridgeSessionCore {
                 telegramBold(title),
                 escapeTelegramHtml(foxclawResult),
                 escapeTelegramHtml(codexUpdateLine ?? (status.locale === 'zh' ? 'Codex CLI：未执行升级。' : 'Codex CLI: not updated.')),
+                ...(status.agyUpdate ? [escapeTelegramHtml(`Antigravity CLI：${status.agyUpdate}`)] : []),
                 escapeTelegramHtml(broadcastLine),
                 releaseNotes ? escapeTelegramHtml(releaseNotes) : '',
             ].filter(Boolean).join('\n');
@@ -7049,11 +7066,11 @@ export class BridgeSessionCore {
                     events: formatTokenCount(stats.usageEvents),
                 }),
                 t(locale, 'status_codex_local_tokens', {
-                    total: formatTokenCount(stats.totals.totalTokens),
-                    input: formatTokenCount(stats.totals.inputTokens),
+                    total: formatCodexTokenCountWithMetric(stats.totals.totalTokens),
+                    input: formatCodexTokenCountWithMetric(stats.totals.inputTokens),
                     visible: formatTokenCount(Math.max(0, stats.totals.outputTokens - stats.totals.reasoningOutputTokens)),
-                    output: formatTokenCount(stats.totals.outputTokens),
-                    cached: formatTokenCount(stats.totals.cachedInputTokens),
+                    output: formatCodexTokenCountWithMetric(stats.totals.outputTokens),
+                    cached: formatCodexTokenCountWithMetric(stats.totals.cachedInputTokens),
                     reasoning: formatTokenCount(stats.totals.reasoningOutputTokens),
                 }),
                 ...this.formatCodexLocalResponseThroughputStatusLines(locale, stats),
@@ -7122,6 +7139,13 @@ export class BridgeSessionCore {
         this.localUsageCache = snapshot;
         this.localUsageCacheLoaded = true;
         await writeCodexLocalUsageSnapshot(this.codexLocalUsageSnapshotPath(), snapshot);
+        this.store.setBackendCumulativeTokenUsage({
+            inputTokens: stats.totals.inputTokens,
+            outputTokens: stats.totals.outputTokens,
+            cachedTokens: stats.totals.cachedInputTokens,
+            totalTokens: stats.totals.totalTokens,
+            turnsCount: stats.turns,
+        }, 'codex');
     }
     codexLocalUsageSnapshotPath() {
         return path.join(path.dirname(this.config.statusPath), this.runtimeSnapshotFilename(CODEX_LOCAL_USAGE_SNAPSHOT_FILENAME));
@@ -12031,6 +12055,12 @@ function formatTokenCount(value) {
     }
     return Math.round(value).toLocaleString('en-US');
 }
+function formatCodexTokenCountWithMetric(value) {
+    if (value >= 1_000_000) {
+        return `${formatMetricTokenCount(value)} (${formatTokenCount(value)})`;
+    }
+    return formatTokenCount(value);
+}
 function formatLocalTimestamp(seconds) {
     const date = new Date(seconds * 1000);
     const pad = (value) => String(value).padStart(2, '0');

package/dist/core/attachments.d.ts

@@ -0,0 +1,11 @@
+import type { Logger } from '../logger.js';
+import { type StagedTelegramAttachment, type TelegramInboundAttachment } from '../telegram/media.js';
+export interface TelegramFileDownloader {
+    getFile(fileId: string): Promise<{
+        file_id: string;
+        file_path?: string;
+        file_size?: number;
+    }>;
+    downloadResolvedFile(filePath: string, destination: string): Promise<unknown>;
+}
+export declare function stageInboundAttachments(downloader: TelegramFileDownloader, cwd: string, threadId: string, attachments: readonly TelegramInboundAttachment[], logger?: Logger): Promise<StagedTelegramAttachment[]>;

package/dist/core/attachments.js

@@ -0,0 +1,56 @@
+import fsPromises from 'node:fs/promises';
+import path from 'node:path';
+import { planAttachmentStoragePath, isNativeImageAttachment, TELEGRAM_BOT_API_DOWNLOAD_LIMIT_BYTES, } from '../telegram/media.js';
+export async function stageInboundAttachments(downloader, cwd, threadId, attachments, logger) {
+    const staged = [];
+    for (const attachment of attachments) {
+        try {
+            if (attachment.localPath) {
+                const planned = planAttachmentStoragePath(cwd, threadId, attachment, path.basename(attachment.localPath));
+                await fsPromises.mkdir(path.dirname(planned.localPath), { recursive: true });
+                await fsPromises.copyFile(attachment.localPath, planned.localPath);
+                const stat = await fsPromises.stat(planned.localPath);
+                const resolvedSize = stat.size;
+                staged.push({
+                    ...attachment,
+                    fileName: planned.fileName,
+                    fileSize: resolvedSize,
+                    localPath: planned.localPath,
+                    relativePath: planned.relativePath,
+                    nativeImage: isNativeImageAttachment(attachment),
+                });
+                continue;
+            }
+            const remoteFile = await downloader.getFile(attachment.fileId);
+            const resolvedSize = attachment.fileSize ?? remoteFile.file_size ?? null;
+            if (resolvedSize !== null && resolvedSize > TELEGRAM_BOT_API_DOWNLOAD_LIMIT_BYTES) {
+                logger?.warn('attachments.too_large', {
+                    fileId: attachment.fileId,
+                    size: resolvedSize,
+                });
+                continue;
+            }
+            if (!remoteFile.file_path) {
+                continue;
+            }
+            const planned = planAttachmentStoragePath(cwd, threadId, attachment, remoteFile.file_path);
+            await fsPromises.mkdir(path.dirname(planned.localPath), { recursive: true });
+            await downloader.downloadResolvedFile(remoteFile.file_path, planned.localPath);
+            staged.push({
+                ...attachment,
+                fileName: planned.fileName,
+                fileSize: resolvedSize,
+                localPath: planned.localPath,
+                relativePath: planned.relativePath,
+                nativeImage: isNativeImageAttachment(attachment),
+            });
+        }
+        catch (error) {
+            logger?.warn('attachments.download_failed', {
+                fileId: attachment.fileId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return staged;
+}