@foxden-app/foxclaw 0.3.17 → 0.3.18

package/dist/codex_app/local_usage.d.ts

@@ -11,19 +11,20 @@ export interface CodexLocalUsageStats {
     turns: number;
     usageEvents: number;
     totals: CodexLocalUsageTotals;
-    outputSpeed: CodexLocalOutputSpeedStats;
+    responseThroughput: CodexLocalResponseThroughputStats;
     latestSessionMtimeMs: number | null;
 }
 export interface CodexLocalUsageSnapshot {
     computedAtMs: number;
     stats: CodexLocalUsageStats;
 }
-export interface CodexLocalOutputSpeedStats {
-    samples: number;
-    outputTokens: number;
+export interface CodexLocalResponseThroughputStats {
+    completedTurns: number;
+    visibleOutputTokens: number;
     seconds: number;
-    latestTokensPerSecond: number | null;
-    latestSampleAtMs: number | null;
+    recentCompletedTurns: number;
+    recentVisibleOutputTokens: number;
+    recentSeconds: number;
 }
 export declare function readCodexLocalUsageStats(codexHome?: string): Promise<CodexLocalUsageStats>;
 export declare function readCodexLocalUsageSnapshot(snapshotPath: string): Promise<CodexLocalUsageSnapshot | null>;

package/dist/codex_app/local_usage.js

@@ -3,6 +3,7 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import readline from 'node:readline';
+const RECENT_COMPLETED_TURNS = 10;
 export async function readCodexLocalUsageStats(codexHome = resolveCodexHome()) {
     const sessionFiles = await listJsonlFiles([
         path.join(codexHome, 'sessions'),
@@ -13,7 +14,7 @@ export async function readCodexLocalUsageStats(codexHome = resolveCodexHome()) {
     let sessionsWithUsage = 0;
     let usageEvents = 0;
     let latestSessionMtimeMs = null;
-    const outputSpeed = emptyOutputSpeedStats();
+    const completedTurnSamples = [];
     for (const filePath of sessionFiles) {
         const stat = await fs.stat(filePath).catch(() => null);
         if (stat) {
@@ -21,7 +22,7 @@ export async function readCodexLocalUsageStats(codexHome = resolveCodexHome()) {
         }
         const fileUsage = await readSessionUsage(filePath, turnIds);
         usageEvents += fileUsage.usageEvents;
-        addOutputSpeed(outputSpeed, fileUsage.outputSpeed);
+        completedTurnSamples.push(...fileUsage.completedTurnSamples);
         if (fileUsage.totalUsage) {
             sessionsWithUsage += 1;
             addUsage(totals, fileUsage.totalUsage);
@@ -33,7 +34,7 @@ export async function readCodexLocalUsageStats(codexHome = resolveCodexHome()) {
         turns: turnIds.size,
         usageEvents,
         totals,
-        outputSpeed,
+        responseThroughput: summarizeResponseThroughput(completedTurnSamples),
         latestSessionMtimeMs,
     };
 }
@@ -87,8 +88,8 @@ async function readSessionUsage(filePath, turnIds) {
     const reader = readline.createInterface({ input: stream, crlfDelay: Infinity });
     let totalUsage = null;
     let usageEvents = 0;
-    let generationStartMs = null;
-    const outputSpeed = emptyOutputSpeedStats();
+    let activeTurn = null;
+    const completedTurnSamples = [];
     try {
         for await (const line of reader) {
             if (!line.trim())
@@ -105,28 +106,49 @@ async function readSessionUsage(filePath, turnIds) {
             if (turnId) {
                 turnIds.add(turnId);
             }
-            if (timestampMs !== null && isGenerationBoundary(event)) {
-                generationStartMs = timestampMs;
+            if (timestampMs !== null
+                && turnId
+                && event?.type === 'event_msg'
+                && event?.payload?.type === 'task_started') {
+                activeTurn = { turnId, startedAtMs: timestampMs, visibleOutputTokens: 0 };
             }
             const info = event?.payload?.info;
             const lastTokenUsage = info?.last_token_usage ?? info?.lastTokenUsage;
             if (lastTokenUsage) {
                 usageEvents += 1;
-                addOutputSpeedSample(outputSpeed, lastTokenUsage, generationStartMs, timestampMs);
-                if (timestampMs !== null) {
-                    generationStartMs = timestampMs;
+                if (activeTurn) {
+                    activeTurn.visibleOutputTokens += visibleOutputTokens(lastTokenUsage);
                 }
             }
             const totalTokenUsage = info?.total_token_usage ?? info?.totalTokenUsage;
             if (totalTokenUsage) {
                 totalUsage = totalTokenUsage;
             }
+            const completedTurn = activeTurn;
+            if (completedTurn !== null
+                && timestampMs !== null
+                && turnId
+                && completedTurn.turnId === turnId
+                && event?.type === 'event_msg'
+                && (event?.payload?.type === 'task_complete' || event?.payload?.type === 'turn_aborted')) {
+                if (event.payload.type === 'task_complete' && completedTurn.visibleOutputTokens > 0) {
+                    const seconds = (timestampMs - completedTurn.startedAtMs) / 1000;
+                    if (Number.isFinite(seconds) && seconds > 0) {
+                        completedTurnSamples.push({
+                            completedAtMs: timestampMs,
+                            visibleOutputTokens: completedTurn.visibleOutputTokens,
+                            seconds,
+                        });
+                    }
+                }
+                activeTurn = null;
+            }
         }
     }
     finally {
         reader.close();
     }
-    return { usageEvents, totalUsage, outputSpeed };
+    return { usageEvents, totalUsage, completedTurnSamples };
 }
 function emptyTotals() {
     return {
@@ -137,22 +159,13 @@ function emptyTotals() {
         totalTokens: 0,
     };
 }
-function emptyOutputSpeedStats() {
-    return {
-        samples: 0,
-        outputTokens: 0,
-        seconds: 0,
-        latestTokensPerSecond: null,
-        latestSampleAtMs: null,
-    };
-}
 function isCodexLocalUsageStats(value) {
     if (!value || typeof value !== 'object') {
         return false;
     }
     const stats = value;
     const totals = stats.totals;
-    const speed = stats.outputSpeed;
+    const throughput = stats.responseThroughput;
     return isFiniteNumber(stats.sessionFiles)
         && isFiniteNumber(stats.sessionsWithUsage)
         && isFiniteNumber(stats.turns)
@@ -163,12 +176,13 @@ function isCodexLocalUsageStats(value) {
         && isFiniteNumber(totals?.outputTokens)
         && isFiniteNumber(totals?.reasoningOutputTokens)
         && isFiniteNumber(totals?.totalTokens)
-        && Boolean(speed)
-        && isFiniteNumber(speed?.samples)
-        && isFiniteNumber(speed?.outputTokens)
-        && isFiniteNumber(speed?.seconds)
-        && isNullableFiniteNumber(speed?.latestTokensPerSecond)
-        && isNullableFiniteNumber(speed?.latestSampleAtMs)
+        && Boolean(throughput)
+        && isFiniteNumber(throughput?.completedTurns)
+        && isFiniteNumber(throughput?.visibleOutputTokens)
+        && isFiniteNumber(throughput?.seconds)
+        && isFiniteNumber(throughput?.recentCompletedTurns)
+        && isFiniteNumber(throughput?.recentVisibleOutputTokens)
+        && isFiniteNumber(throughput?.recentSeconds)
         && isNullableFiniteNumber(stats.latestSessionMtimeMs);
 }
 function isFiniteNumber(value) {
@@ -187,34 +201,21 @@ function addUsage(totals, usage) {
     totals.reasoningOutputTokens += numberField(usage, 'reasoning_output_tokens', 'reasoningOutputTokens');
     totals.totalTokens += totalTokens || inputTokens + outputTokens;
 }
-function addOutputSpeed(target, source) {
-    target.samples += source.samples;
-    target.outputTokens += source.outputTokens;
-    target.seconds += source.seconds;
-    if (source.latestTokensPerSecond !== null
-        && source.latestSampleAtMs !== null
-        && (target.latestSampleAtMs === null || source.latestSampleAtMs > target.latestSampleAtMs)) {
-        target.latestTokensPerSecond = source.latestTokensPerSecond;
-        target.latestSampleAtMs = source.latestSampleAtMs;
-    }
+function visibleOutputTokens(usage) {
+    return Math.max(0, numberField(usage, 'output_tokens', 'outputTokens')
+        - numberField(usage, 'reasoning_output_tokens', 'reasoningOutputTokens'));
 }
-function addOutputSpeedSample(stats, usage, generationStartMs, timestampMs) {
-    if (generationStartMs === null || timestampMs === null || timestampMs <= generationStartMs) {
-        return;
-    }
-    const outputTokens = numberField(usage, 'output_tokens', 'outputTokens');
-    if (outputTokens <= 0) {
-        return;
-    }
-    const seconds = (timestampMs - generationStartMs) / 1000;
-    if (!Number.isFinite(seconds) || seconds <= 0) {
-        return;
-    }
-    stats.samples += 1;
-    stats.outputTokens += outputTokens;
-    stats.seconds += seconds;
-    stats.latestTokensPerSecond = outputTokens / seconds;
-    stats.latestSampleAtMs = timestampMs;
+function summarizeResponseThroughput(samples) {
+    const ordered = samples.slice().sort((left, right) => left.completedAtMs - right.completedAtMs);
+    const recent = ordered.slice(-RECENT_COMPLETED_TURNS);
+    return {
+        completedTurns: ordered.length,
+        visibleOutputTokens: ordered.reduce((total, sample) => total + sample.visibleOutputTokens, 0),
+        seconds: ordered.reduce((total, sample) => total + sample.seconds, 0),
+        recentCompletedTurns: recent.length,
+        recentVisibleOutputTokens: recent.reduce((total, sample) => total + sample.visibleOutputTokens, 0),
+        recentSeconds: recent.reduce((total, sample) => total + sample.seconds, 0),
+    };
 }
 function numberField(source, snakeKey, camelKey) {
     const snakeValue = source[snakeKey];
@@ -229,15 +230,3 @@ function parseTimestampMs(value) {
     const timestamp = Date.parse(value);
     return Number.isFinite(timestamp) ? timestamp : null;
 }
-function isGenerationBoundary(event) {
-    const payload = event?.payload;
-    if (event?.type === 'response_item' && payload?.type === 'function_call_output') {
-        return true;
-    }
-    if (event?.type !== 'event_msg') {
-        return false;
-    }
-    return payload?.type === 'task_started'
-        || payload?.type === 'exec_command_end'
-        || payload?.type === 'user_message';
-}

package/dist/controller/controller.d.ts

@@ -267,7 +267,7 @@ export declare class BridgeSessionCore {
     private buildNativeCollaborationMode;
     private buildCodexUsageStatusLines;
     private buildCodexLocalUsageStatusLines;
-    private formatCodexLocalOutputSpeedStatusLines;
+    private formatCodexLocalResponseThroughputStatusLines;
     private resolveFastStatusLabel;
     private readCachedCodexLocalUsageStats;
     private refreshCodexLocalUsageIfNeeded;

package/dist/controller/controller.js

@@ -4544,11 +4544,12 @@ export class BridgeSessionCore {
                 t(locale, 'status_codex_local_tokens', {
                     total: formatTokenCount(stats.totals.totalTokens),
                     input: formatTokenCount(stats.totals.inputTokens),
+                    visible: formatTokenCount(Math.max(0, stats.totals.outputTokens - stats.totals.reasoningOutputTokens)),
                     output: formatTokenCount(stats.totals.outputTokens),
                     cached: formatTokenCount(stats.totals.cachedInputTokens),
                     reasoning: formatTokenCount(stats.totals.reasoningOutputTokens),
                 }),
-                ...this.formatCodexLocalOutputSpeedStatusLines(locale, stats),
+                ...this.formatCodexLocalResponseThroughputStatusLines(locale, stats),
                 t(locale, 'status_codex_local_snapshot_at', {
                     value: formatLocalTimestamp(snapshot.computedAtMs / 1000),
                 }),
@@ -4559,16 +4560,21 @@ export class BridgeSessionCore {
             return [t(locale, 'status_codex_local_usage_unavailable', { error: formatShortStatusError(error) })];
         }
     }
-    formatCodexLocalOutputSpeedStatusLines(locale, stats) {
-        const speed = stats.outputSpeed;
-        if (speed.samples === 0 || speed.outputTokens <= 0 || speed.seconds <= 0) {
+    formatCodexLocalResponseThroughputStatusLines(locale, stats) {
+        const throughput = stats.responseThroughput;
+        if (throughput.completedTurns === 0
+            || throughput.visibleOutputTokens <= 0
+            || throughput.seconds <= 0
+            || throughput.recentCompletedTurns === 0
+            || throughput.recentVisibleOutputTokens <= 0
+            || throughput.recentSeconds <= 0) {
             return [];
         }
-        const avg = speed.outputTokens / speed.seconds;
-        return [t(locale, 'status_codex_local_speed', {
-                avg: formatCompactNumber(avg),
-                latest: speed.latestTokensPerSecond === null ? t(locale, 'unknown') : formatCompactNumber(speed.latestTokensPerSecond),
-                samples: formatTokenCount(speed.samples),
+        return [t(locale, 'status_codex_local_throughput', {
+                overall: formatCompactNumber(throughput.visibleOutputTokens / throughput.seconds),
+                recent: formatCompactNumber(throughput.recentVisibleOutputTokens / throughput.recentSeconds),
+                recentTurns: formatTokenCount(throughput.recentCompletedTurns),
+                turns: formatTokenCount(throughput.completedTurns),
             })];
     }
     async resolveFastStatusLabel(locale, settings) {

package/dist/i18n.d.ts

@@ -111,8 +111,8 @@ declare const MESSAGES: {
         readonly status_codex_usage_reset: ", resets {value}";
         readonly status_codex_usage_unavailable: "Codex usage: unavailable ({error})";
         readonly status_codex_local_history: "Codex local history: {sessions} sessions, {turns} turns, {events} usage records";
-        readonly status_codex_local_tokens: "Codex local tokens: total {total}; input {input}, output {output}, cached input {cached}, reasoning output {reasoning}";
-        readonly status_codex_local_speed: "Codex local output speed: avg {avg} token/s, latest {latest} token/s ({samples} samples)";
+        readonly status_codex_local_tokens: "Codex local tokens: total {total}; input {input}, visible output {visible}, reasoning output {reasoning}, total output {output}, cached input {cached}";
+        readonly status_codex_local_throughput: "Codex visible reply throughput (end-to-end, excluding reasoning): overall {overall} token/s, last {recentTurns} completed turns {recent} token/s ({turns} completed turns sampled)";
         readonly status_codex_local_snapshot_at: "Codex local stats snapshot: {value}";
         readonly status_codex_local_usage_refreshing: "Codex local history: building snapshot in background";
         readonly status_codex_local_usage_unavailable: "Codex local history: unavailable ({error})";
@@ -675,8 +675,8 @@ declare const MESSAGES: {
         readonly status_codex_usage_reset: "，重置时间 {value}";
         readonly status_codex_usage_unavailable: "Codex 用量：无法获取（{error}）";
         readonly status_codex_local_history: "Codex 本地历史：{sessions} 个会话，{turns} 轮，{events} 条用量记录";
-        readonly status_codex_local_tokens: "Codex 本地 Token：总计 {total}；输入 {input}，输出 {output}，缓存输入 {cached}，推理输出 {reasoning}";
-        readonly status_codex_local_speed: "Codex 本地输出速度：平均 {avg} token/s，最近 {latest} token/s（{samples} 个样本）";
+        readonly status_codex_local_tokens: "Codex 本地 Token：总计 {total}；输入 {input}，可见输出 {visible}，推理输出 {reasoning}，总输出 {output}，缓存输入 {cached}";
+        readonly status_codex_local_throughput: "Codex 可见答复吞吐（端到端，排除推理 token）：整体 {overall} token/s，最近 {recentTurns} 个完成轮次 {recent} token/s（{turns} 个完成轮次样本）";
         readonly status_codex_local_snapshot_at: "Codex 本地统计快照：{value}";
         readonly status_codex_local_usage_refreshing: "Codex 本地历史：正在后台生成统计快照";
         readonly status_codex_local_usage_unavailable: "Codex 本地历史：无法获取（{error}）";

package/dist/i18n.js

@@ -109,8 +109,8 @@ const MESSAGES = {
         status_codex_usage_reset: ', resets {value}',
         status_codex_usage_unavailable: 'Codex usage: unavailable ({error})',
         status_codex_local_history: 'Codex local history: {sessions} sessions, {turns} turns, {events} usage records',
-        status_codex_local_tokens: 'Codex local tokens: total {total}; input {input}, output {output}, cached input {cached}, reasoning output {reasoning}',
-        status_codex_local_speed: 'Codex local output speed: avg {avg} token/s, latest {latest} token/s ({samples} samples)',
+        status_codex_local_tokens: 'Codex local tokens: total {total}; input {input}, visible output {visible}, reasoning output {reasoning}, total output {output}, cached input {cached}',
+        status_codex_local_throughput: 'Codex visible reply throughput (end-to-end, excluding reasoning): overall {overall} token/s, last {recentTurns} completed turns {recent} token/s ({turns} completed turns sampled)',
         status_codex_local_snapshot_at: 'Codex local stats snapshot: {value}',
         status_codex_local_usage_refreshing: 'Codex local history: building snapshot in background',
         status_codex_local_usage_unavailable: 'Codex local history: unavailable ({error})',
@@ -673,8 +673,8 @@ const MESSAGES = {
         status_codex_usage_reset: '，重置时间 {value}',
         status_codex_usage_unavailable: 'Codex 用量：无法获取（{error}）',
         status_codex_local_history: 'Codex 本地历史：{sessions} 个会话，{turns} 轮，{events} 条用量记录',
-        status_codex_local_tokens: 'Codex 本地 Token：总计 {total}；输入 {input}，输出 {output}，缓存输入 {cached}，推理输出 {reasoning}',
-        status_codex_local_speed: 'Codex 本地输出速度：平均 {avg} token/s，最近 {latest} token/s（{samples} 个样本）',
+        status_codex_local_tokens: 'Codex 本地 Token：总计 {total}；输入 {input}，可见输出 {visible}，推理输出 {reasoning}，总输出 {output}，缓存输入 {cached}',
+        status_codex_local_throughput: 'Codex 可见答复吞吐（端到端，排除推理 token）：整体 {overall} token/s，最近 {recentTurns} 个完成轮次 {recent} token/s（{turns} 个完成轮次样本）',
         status_codex_local_snapshot_at: 'Codex 本地统计快照：{value}',
         status_codex_local_usage_refreshing: 'Codex 本地历史：正在后台生成统计快照',
         status_codex_local_usage_unavailable: 'Codex 本地历史：无法获取（{error}）',

package/docs/user-manual.md

@@ -230,7 +230,7 @@ Later commands are sorted by recent usage. Plain text, photos, and files continu
 
 ### 3.2 `/status`, `/account`, `/quota`, `/update`
 
-- `/status`: FoxClaw, app-server, current thread binding, model, access, and Codex usage summary. Local session, token, and output-speed metrics use a background-generated historical snapshot instead of scanning large logs during the request.
+- `/status`: FoxClaw, app-server, current thread binding, model, access, and Codex usage summary. Local session, token, and visible-reply-throughput metrics use a background-generated historical snapshot instead of scanning large logs during the request; throughput is computed end-to-end for completed turns, excluding reasoning tokens while including waiting and tool execution time.
 - `/account`: current Codex account.
 - `/quota`: Codex usage and quota window.
 - `/update`: upgrade FoxClaw, run checks, and restart the service; it refuses while a turn, approval, or question is active, then reports the result after restart.

package/docs/zh/user-manual.md

@@ -230,7 +230,7 @@ TG_ALLOWED_TOPIC_ID=42
 
 ### 3.2 `/status`、`/account`、`/quota`、`/update`
 
-- `/status`：查看 FoxClaw、app-server、当前绑定线程、模型、权限和 Codex 用量摘要。本地 session/Token/输出速度使用后台生成的历史快照，避免状态查询现场扫描大量日志。
+- `/status`：查看 FoxClaw、app-server、当前绑定线程、模型、权限和 Codex 用量摘要。本地 session/Token/可见答复吞吐使用后台生成的历史快照，避免状态查询现场扫描大量日志；答复吞吐按完成轮次端到端耗时计算，排除推理 token，但包含等待与工具执行时间。
 - `/account`：查看当前 Codex 登录账号。
 - `/quota`：查看 Codex 用量和额度窗口。
 - `/update`：升级 FoxClaw、自检并重启服务；当前有运行中回复、审批或待确认问题时会拒绝执行，重启后会回报结果。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foxden-app/foxclaw",
-  "version": "0.3.17",
+  "version": "0.3.18",
   "description": "Foxden local execution claw for controlling Codex from trusted chat interfaces.",
   "type": "module",
   "main": "dist/main.js",

package/skills/foxclaw/SKILL.md

@@ -190,10 +190,12 @@ Use this checklist when the user asks for standard closing actions, release wrap
    - If `doctor` fails only because `DEFAULT_CWD` is missing, report that separately; do not treat it as evidence that the service update failed.
 7. Publish to npm when requested:
    - Prefer GitHub Actions trusted publishing via `.github/workflows/publish.yml`: bump and commit the package version, push `main`, then push a matching `v<version>` tag. The tag version must match `package.json`.
+   - Treat `workflow_dispatch` only as a retry path from an existing matching release tag; do not manually run publishing from `main`.
    - Configure npmjs.com trusted publishing for `foxden-app/foxclaw` and workflow `publish.yml`; do not store npm tokens if OIDC trusted publishing is available.
    - Temporary fallback: store an npm automation/bypass-2FA token as the GitHub Actions secret `NPM_TOKEN`. Never print the token or commit it.
    - Check `npm whoami` and `npm view @foxden-app/foxclaw version`.
    - If the target version is already published, bump with `npm version patch --no-git-tag-version` before validation and commit.
+   - If a workflow fails before `npm publish`, inspect that failed GitHub Actions step before attributing it to npm trusted publishing.
    - Manual fallback only: run `BROWSER=true npm publish` in a TTY.
    - If npm returns `ENEEDAUTH`, report that npm publish is blocked by registry login and leave the package unreported as published.
    - Never print npm tokens or `.npmrc` auth values.

package/skills/npm-publish/SKILL.md

@@ -73,6 +73,8 @@ Use this path when the repo has `.github/workflows/publish.yml` and npmjs.com ha
    npm view <package-name> version
    ```
 
+If the workflow provides `workflow_dispatch` as a recovery path, dispatch it only from an existing release tag whose version matches `package.json`. Do not dispatch publishing from a branch containing an unpublished version unless the workflow explicitly resolves and validates a release tag.
+
 Do not store or print npm tokens when trusted publishing is available. If trusted publishing is not configured on npmjs.com, the workflow can use a GitHub Actions secret named `NPM_TOKEN` as a temporary fallback. Store only automation/bypass-2FA tokens there, never paste tokens in chat or commit them.
 
 ### Manual Publish
@@ -124,4 +126,5 @@ Press ENTER to open in the browser...
 - If `xdg-open` fails because the environment has no browser, rerun with `BROWSER=true npm publish`.
 - If the auth link expires or the publish process exits, rerun `BROWSER=true npm publish` to generate a new link.
 - If the user provides a classic authenticator OTP instead of using the web link, publish can be retried with `npm publish --otp <code>`, but prefer web auth when the user asks for a clickable confirmation link.
+- If a GitHub Actions release fails before the `npm publish` step, such as during checkout or action download authentication, do not diagnose it as a trusted publishing rejection. Inspect the failed step and GitHub Actions status first.
 - Never print npm tokens or `.npmrc` auth values.