@offerpilot/axiomruntime 0.0.3 → 0.0.5

package/dist/core/runner/tool-runner.js

@@ -7,6 +7,7 @@ import { writeLog } from "../logs/log-service.js";
 import { isRecord } from "../utils/is-record.js";
 import { resolveToolCommand } from "./command-resolver.js";
 import { getRunnerEngine } from "./engine-registry.js";
+import { startOpenAiUsageProxy } from "./openai-usage-proxy.js";
 import { CLAUDE_ROOT_PERMISSION_WARNING, resolveClaudePermissionMode } from "./claude-permission-policy.js";
 import { finishSession, startSession } from "../sessions/session-service.js";
 export async function runTool(tool, provider, model, options = {}) {
@@ -21,55 +22,101 @@ export async function runTool(tool, provider, model, options = {}) {
         console.warn(`Warning: ${launchPolicy.warning}`);
     }
     const effectiveProvider = launchPolicy.provider;
-    const env = buildRunnerEnv(tool, effectiveProvider, model);
-    const temporaryFiles = [];
-    const claudeSettingsPath = engine.requiresSettingsFile
-        ? writeTemporaryClaudeSettings(effectiveProvider, { permissionMode: launchPolicy.claudeSettingsPermissionMode })
-        : null;
-    if (claudeSettingsPath)
-        temporaryFiles.push(claudeSettingsPath);
-    const args = buildRunnerArgs(tool, effectiveProvider, model, claudeSettingsPath);
-    const effectiveBaseUrl = getToolBaseUrl(tool, effectiveProvider);
-    await writeLog({
-        category: "usage",
-        action: "tool_spawn",
-        message: `Spawning ${tool}: ${provider.name} / ${model}`,
-        metadata: {
-            tool,
-            provider: provider.name,
-            model,
-            mode: effectiveProvider.mode,
-            configuredMode: provider.mode,
-            permissionConstraint: launchPolicy.reason,
-            baseUrl: effectiveBaseUrl,
-            configuredBaseUrl: provider.baseUrl,
-            apiKeyFingerprint: getSecretFingerprint(provider.apiKey),
-            command,
-            args,
-            authInjection: engine.authInjection
-        }
-    });
-    const session = await startSession({
-        tool,
+    const usageProxy = await startOpenAiUsageProxy({
         provider: effectiveProvider,
         model,
-        projectPath: process.cwd(),
-        fallbackFrom: options.fallbackFrom ?? null
+        tool,
+        engine: tool
     });
+    const temporaryFiles = [];
+    const setup = await (async () => {
+        try {
+            const routedProvider = { ...effectiveProvider, baseUrl: usageProxy.baseUrl };
+            const env = buildRunnerEnv(tool, routedProvider, model);
+            const claudeSettingsPath = engine.requiresSettingsFile
+                ? writeTemporaryClaudeSettings(routedProvider, { permissionMode: launchPolicy.claudeSettingsPermissionMode })
+                : null;
+            if (claudeSettingsPath)
+                temporaryFiles.push(claudeSettingsPath);
+            const args = buildRunnerArgs(tool, routedProvider, model, claudeSettingsPath);
+            const effectiveBaseUrl = getToolBaseUrl(tool, effectiveProvider);
+            await writeLog({
+                category: "usage",
+                action: "tool_spawn",
+                message: `Spawning ${tool}: ${provider.name} / ${model}`,
+                metadata: {
+                    tool,
+                    provider: provider.name,
+                    model,
+                    mode: effectiveProvider.mode,
+                    configuredMode: provider.mode,
+                    permissionConstraint: launchPolicy.reason,
+                    baseUrl: effectiveBaseUrl,
+                    transportBaseUrl: usageProxy.baseUrl,
+                    configuredBaseUrl: provider.baseUrl,
+                    apiKeyFingerprint: getSecretFingerprint(provider.apiKey),
+                    command,
+                    args,
+                    authInjection: engine.authInjection
+                }
+            });
+            const session = await startSession({
+                tool,
+                provider: effectiveProvider,
+                model,
+                projectPath: process.cwd(),
+                fallbackFrom: options.fallbackFrom ?? null
+            });
+            return { args, env, session };
+        }
+        catch (error) {
+            cleanupTemporaryFiles(temporaryFiles);
+            await usageProxy.close().catch(() => undefined);
+            throw error;
+        }
+    })();
+    const { args, env, session } = setup;
     return new Promise((resolve, reject) => {
-        const child = spawn(command, args, {
-            stdio: "inherit",
-            env
-        });
-        child.on("error", (error) => {
+        let finished = false;
+        const finish = async (exitCode, error) => {
+            if (finished)
+                return;
+            finished = true;
             cleanupTemporaryFiles(temporaryFiles);
-            void finishSession(session.id, 1);
-            reject(new Error(`Failed to start ${command}. Run \`ai doctor\` to check local CLI installation. ${error.message}`));
+            await usageProxy.close().catch(async (closeError) => {
+                await writeLog({
+                    level: "warn",
+                    category: "usage",
+                    action: "usage_proxy_close_failed",
+                    message: `Failed to close usage proxy for ${tool}: ${closeError instanceof Error ? closeError.message : String(closeError)}`,
+                    metadata: { tool, provider: provider.name, model }
+                }).catch(() => undefined);
+            });
+            await finishSession(session.id, exitCode).catch(() => undefined);
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve(exitCode);
+            }
+        };
+        let child;
+        try {
+            child = spawn(command, args, {
+                stdio: "inherit",
+                env
+            });
+        }
+        catch (error) {
+            void finish(1, new Error(`Failed to start ${command}. Run \`ai doctor\` to check local CLI installation. ${error instanceof Error ? error.message : String(error)}`));
+            return;
+        }
+        child.on("error", (error) => {
+            void finish(1, new Error(`Failed to start ${command}. Run \`ai doctor\` to check local CLI installation. ${error.message}`));
         });
         child.on("close", (code) => {
-            cleanupTemporaryFiles(temporaryFiles);
             const exitCode = code ?? 0;
-            void finishSession(session.id, exitCode).finally(() => resolve(exitCode));
+            void finish(exitCode);
         });
     });
 }

package/dist/telegram/engine/claude-engine.js

@@ -4,6 +4,7 @@ import { requiresDangerousConfirmation } from "../interaction/approval.js";
 import { writeTelegramLog } from "../log.js";
 import { isRecord } from "../../core/utils/is-record.js";
 import { CLAUDE_ROOT_PERMISSION_WARNING, resolveClaudePermissionMode } from "../../core/runner/claude-permission-policy.js";
+import { sumKnownProxyCosts, sumProxyUsage } from "../../core/runner/openai-usage-proxy.js";
 export class ClaudeEngine {
     name = "claude";
     processes = new Map();
@@ -16,42 +17,41 @@ export class ClaudeEngine {
         this.controllers.set(params.chatId, controller);
         const signal = params.signal ?? controller.signal;
         const startTime = Date.now();
-        if (permissionMode === "bypassPermissions" && requiresDangerousConfirmation(params.prompt)) {
-            const approved = await params.onPermission(createCommandPermissionRequest("Claude prompt", params.prompt));
-            if (!approved) {
-                cleanupRuntime(runtime);
-                throw new Error("Dangerous command denied.");
+        try {
+            if (permissionMode === "bypassPermissions" && requiresDangerousConfirmation(params.prompt)) {
+                const approved = await params.onPermission(createCommandPermissionRequest("Claude prompt", params.prompt));
+                if (!approved) {
+                    throw new Error("Dangerous command denied.");
+                }
             }
-        }
-        const args = buildClaudeArgs({
-            prompt: params.prompt,
-            model: runtime.model,
-            settingsPath: runtime.claudeSettingsPath,
-            permissionMode,
-            resume: params.resume,
-            allowedTools: params.allowedTools
-        });
-        const permissionWarning = runtime.claudePermission?.constrained ? CLAUDE_ROOT_PERMISSION_WARNING : null;
-        await params.onProgress?.({ phase: "thinking", message: permissionWarning ?? "Claude started" });
-        if (permissionWarning) {
-            await writeTelegramLog({
-                level: "warn",
-                action: "claude_permission_constrained",
-                message: permissionWarning,
-                metadata: { requestedPermissionMode, effectivePermissionMode: permissionMode, reason: runtime.claudePermission?.reason }
+            const args = buildClaudeArgs({
+                prompt: params.prompt,
+                model: runtime.model,
+                settingsPath: runtime.claudeSettingsPath,
+                permissionMode,
+                resume: params.resume,
+                allowedTools: params.allowedTools
             });
-        }
-        await writeTelegramLog({
-            action: "claude_start",
-            message: `Starting Claude for Telegram chat ${params.chatId}`,
-            metadata: {
-                ...summarizeRuntime(runtime.provider, runtime.model, "claude"),
-                cwd: params.cwd,
-                requestedPermissionMode,
-                effectivePermissionMode: permissionMode
+            const permissionWarning = runtime.claudePermission?.constrained ? CLAUDE_ROOT_PERMISSION_WARNING : null;
+            await params.onProgress?.({ phase: "thinking", message: permissionWarning ?? "Claude started" });
+            if (permissionWarning) {
+                await writeTelegramLog({
+                    level: "warn",
+                    action: "claude_permission_constrained",
+                    message: permissionWarning,
+                    metadata: { requestedPermissionMode, effectivePermissionMode: permissionMode, reason: runtime.claudePermission?.reason }
+                });
             }
-        });
-        try {
+            await writeTelegramLog({
+                action: "claude_start",
+                message: `Starting Claude for Telegram chat ${params.chatId}`,
+                metadata: {
+                    ...summarizeRuntime(runtime.provider, runtime.model, "claude"),
+                    cwd: params.cwd,
+                    requestedPermissionMode,
+                    effectivePermissionMode: permissionMode
+                }
+            });
             const progressParser = createJsonLineAccumulator((event) => handleClaudeProgressEvent(event, params.onProgress));
             const result = await spawnCapture({
                 command: runtime.command,
@@ -79,6 +79,8 @@ export class ClaudeEngine {
             await params.onProgress?.({ phase: "done" });
             return {
                 ...parsed,
+                cost: parsed.cost ?? sumKnownProxyCosts(runtime.usageProxy.getRecords()),
+                usage: sumProxyUsage(runtime.usageProxy.getRecords()),
                 provider: runtime.provider.name,
                 model: runtime.model
             };
@@ -86,7 +88,7 @@ export class ClaudeEngine {
         finally {
             this.processes.delete(params.chatId);
             this.controllers.delete(params.chatId);
-            cleanupRuntime(runtime);
+            await cleanupRuntime(runtime);
         }
     }
     abort(chatId) {

package/dist/telegram/engine/codex-engine.js

@@ -3,7 +3,7 @@ import os from "node:os";
 import path from "node:path";
 import { cleanupRuntime, createCommandPermissionRequest, formatEngineTimeout, prepareEngineRuntime, summarizeRuntime } from "./engine-utils.js";
 import { createJsonLineAccumulator, extractJsonLines, spawnCapture, stripAnsi, terminateProcessTree } from "./process-utils.js";
-import { startOpenAiUsageProxy } from "../../core/runner/openai-usage-proxy.js";
+import { sumKnownProxyCosts, sumProxyUsage } from "../../core/runner/openai-usage-proxy.js";
 import { requiresDangerousConfirmation } from "../interaction/approval.js";
 import { writeTelegramLog } from "../log.js";
 import { isRecord } from "../../core/utils/is-record.js";
@@ -18,28 +18,21 @@ export class CodexEngine {
         const signal = params.signal ?? controller.signal;
         const startTime = Date.now();
         const permissionMode = params.permissionMode ?? "default";
-        if (permissionMode === "bypassPermissions" && requiresDangerousConfirmation(params.prompt)) {
-            const approved = await params.onPermission(createCommandPermissionRequest("Codex prompt", params.prompt));
-            if (!approved) {
-                cleanupRuntime(runtime);
-                throw new Error("Dangerous command denied.");
-            }
-        }
-        let usageProxy = null;
-        await params.onProgress?.({ phase: "thinking", message: "Codex started" });
-        await writeTelegramLog({
-            action: "codex_start",
-            message: `Starting Codex for Telegram chat ${params.chatId}`,
-            metadata: { ...summarizeRuntime(runtime.provider, runtime.model, "codex"), cwd: params.cwd }
-        });
         try {
-            usageProxy = await startOpenAiUsageProxy({
-                provider: runtime.provider,
-                model: runtime.model,
-                tool: "telegram"
+            if (permissionMode === "bypassPermissions" && requiresDangerousConfirmation(params.prompt)) {
+                const approved = await params.onPermission(createCommandPermissionRequest("Codex prompt", params.prompt));
+                if (!approved) {
+                    throw new Error("Dangerous command denied.");
+                }
+            }
+            await params.onProgress?.({ phase: "thinking", message: "Codex started" });
+            await writeTelegramLog({
+                action: "codex_start",
+                message: `Starting Codex for Telegram chat ${params.chatId}`,
+                metadata: { ...summarizeRuntime(runtime.provider, runtime.model, "codex"), cwd: params.cwd }
             });
             const args = buildCodexArgs(params.prompt, runtime.model, params.cwd, permissionMode, {
-                baseUrl: usageProxy.baseUrl
+                baseUrl: runtime.usageProxy.baseUrl
             }, params.resume, params.imagePaths);
             const progressParser = createJsonLineAccumulator((event) => handleCodexProgressEvent(event, params.onProgress));
             const result = await spawnCapture({
@@ -49,8 +42,8 @@ export class CodexEngine {
                 env: {
                     ...runtime.env,
                     OPENAI_API_KEY: runtime.provider.apiKey,
-                    OPENAI_BASE_URL: usageProxy.baseUrl,
-                    AI_GATEWAY_BASE_URL: usageProxy.baseUrl
+                    OPENAI_BASE_URL: runtime.usageProxy.baseUrl,
+                    AI_GATEWAY_BASE_URL: runtime.usageProxy.baseUrl
                 },
                 signal,
                 timeoutMs: params.timeoutMs,
@@ -83,8 +76,8 @@ export class CodexEngine {
             return {
                 ...parsed,
                 sessionId,
-                cost: sumKnownProxyCosts(usageProxy.getRecords()),
-                usage: sumProxyUsage(usageProxy.getRecords()),
+                cost: sumKnownProxyCosts(runtime.usageProxy.getRecords()),
+                usage: sumProxyUsage(runtime.usageProxy.getRecords()),
                 provider: runtime.provider.name,
                 model: runtime.model
             };
@@ -92,8 +85,7 @@ export class CodexEngine {
         finally {
             this.processes.delete(params.chatId);
             this.controllers.delete(params.chatId);
-            await usageProxy?.close().catch(() => undefined);
-            cleanupRuntime(runtime);
+            await cleanupRuntime(runtime);
         }
     }
     abort(chatId) {
@@ -415,21 +407,3 @@ function readChangedFiles(event) {
         return [event.path];
     return [];
 }
-function sumKnownProxyCosts(records) {
-    const knownCosts = records
-        .map((record) => record.costUsd)
-        .filter((cost) => typeof cost === "number" && Number.isFinite(cost) && cost >= 0);
-    if (!knownCosts.length)
-        return undefined;
-    return Number(knownCosts.reduce((sum, cost) => sum + cost, 0).toFixed(8));
-}
-function sumProxyUsage(records) {
-    if (!records.length)
-        return undefined;
-    return records.reduce((sum, record) => ({
-        inputTokens: sum.inputTokens + record.usage.inputTokens,
-        outputTokens: sum.outputTokens + record.usage.outputTokens,
-        totalTokens: sum.totalTokens + record.usage.totalTokens,
-        cacheReadInputTokens: (sum.cacheReadInputTokens ?? 0) + (record.usage.cacheReadInputTokens ?? 0)
-    }), { inputTokens: 0, outputTokens: 0, totalTokens: 0, cacheReadInputTokens: 0 });
-}

package/dist/telegram/engine/engine-utils.js

@@ -3,6 +3,7 @@ import { resolveExactProviderForTool, resolveProviderForTool } from "../../core/
 import { buildRunnerEnv, cleanupTemporaryFiles, getToolBaseUrl, writeTemporaryClaudeSettings } from "../../core/runner/tool-runner.js";
 import { resolveClaudePermissionMode } from "../../core/runner/claude-permission-policy.js";
 import { resolveToolCommand } from "../../core/runner/command-resolver.js";
+import { startOpenAiUsageProxy } from "../../core/runner/openai-usage-proxy.js";
 export async function prepareEngineRuntime(tool, providerName, modelName, permissionMode) {
     // Telegram resolves and orders fallback candidates before invoking an
     // engine. Once a candidate is selected, execute it exactly so the engine
@@ -18,26 +19,41 @@ export async function prepareEngineRuntime(tool, providerName, modelName, permis
         ? resolveClaudePermissionMode(permissionMode ?? "default")
         : null;
     const effectiveProvider = claudePermission?.constrained ? { ...provider, mode: "ask" } : provider;
-    const env = {
-        ...buildRunnerEnv(tool, effectiveProvider, model),
-        AI_GATEWAY_SOURCE: "telegram"
-    };
     const temporaryFiles = [];
-    const claudeSettingsPath = tool === "claude"
-        ? writeTemporaryClaudeSettings(provider, {
-            permissionMode: permissionMode === "readOnly"
-                ? "readOnly"
-                : claudePermission?.privileged
-                    ? "safeDefault"
-                    : "provider"
-        })
-        : null;
-    if (claudeSettingsPath)
-        temporaryFiles.push(claudeSettingsPath);
-    return { provider, model, env, command, temporaryFiles, claudeSettingsPath, claudePermission };
+    const usageProxy = await startOpenAiUsageProxy({
+        provider: effectiveProvider,
+        model,
+        tool: "telegram",
+        engine: tool
+    });
+    try {
+        const routedProvider = { ...effectiveProvider, baseUrl: usageProxy.baseUrl };
+        const env = {
+            ...buildRunnerEnv(tool, routedProvider, model),
+            AI_GATEWAY_SOURCE: "telegram"
+        };
+        const claudeSettingsPath = tool === "claude"
+            ? writeTemporaryClaudeSettings(routedProvider, {
+                permissionMode: permissionMode === "readOnly"
+                    ? "readOnly"
+                    : claudePermission?.privileged
+                        ? "safeDefault"
+                        : "provider"
+            })
+            : null;
+        if (claudeSettingsPath)
+            temporaryFiles.push(claudeSettingsPath);
+        return { provider, model, env, command, temporaryFiles, claudeSettingsPath, claudePermission, usageProxy };
+    }
+    catch (error) {
+        cleanupTemporaryFiles(temporaryFiles);
+        await usageProxy.close().catch(() => undefined);
+        throw error;
+    }
 }
-export function cleanupRuntime(runtime) {
+export async function cleanupRuntime(runtime) {
     cleanupTemporaryFiles(runtime.temporaryFiles);
+    await runtime.usageProxy.close().catch(() => undefined);
 }
 export function resolveWorkingCommand(tool) {
     return resolveToolCommand(tool);

package/docs/USAGE.html

@@ -531,6 +531,12 @@ ai setup</pre>
                 <td>用默认 provider 和默认模型启动 Claude Code 或 Codex。</td>
                 <td>不指定时使用 <code>level: 1</code>。</td>
               </tr>
+              <tr data-search="image generate image prompt model b64 url">
+                <td><span class="group-label">使用</span></td>
+                <td><code class="cmd">ai image 51talk-image "一只戴墨镜的猫"</code></td>
+                <td>调用已配置的图片 Provider 和默认模型生成图片并保存到当前目录。</td>
+                <td>支持 Provider fallback；真实 usage 写入 <code>usage.json</code>。</td>
+              </tr>
               <tr data-search="use provider model named">
                 <td><span class="group-label">使用</span></td>
                 <td><code class="cmd">ai use claude 51talk claude-opus-4-6</code><br /><code class="cmd">ai use codex 51talk gpt-5.5</code></td>
@@ -632,6 +638,20 @@ ai use claude 51talk
 ai use codex 51talk gpt-5.5</pre>
                 <p>不指定 provider 时使用 <code>level: 1</code>；不指定模型时使用 provider 默认 <code>model</code>。</p>
               </div>
+              <div class="note">
+                <h3>生成图片</h3>
+                <pre>ai image
+ai image 51talk-image "一只戴墨镜的猫，数字插画"
+ai image 51talk-image gpt-image-2 "一只戴墨镜的猫，数字插画"</pre>
+                <ul>
+                  <li>直接运行 <code>ai image</code> 时，会依次选择 Provider、具体模型并输入提示词。</li>
+                  <li>第一个参数是 Provider 名；第二个参数匹配模型缓存时作为具体模型，否则从第二个参数开始作为提示词并使用默认模型。</li>
+                  <li>命令执行前会自动刷新模型缓存；也可以先运行 <code>ai status</code> 检查。指定模型时建议给提示词加引号。</li>
+                  <li><code>b64_json</code> 会以 <code>0600</code> 权限保存到当前目录并输出绝对路径；远程响应只接受无凭证的 <code>https</code> URL。</li>
+                  <li>图片请求最长等待 120 秒；超时会自动失败并尝试下一个 Provider。</li>
+                  <li>请求经过 execution-scoped Transport Proxy，真实 usage 复用唯一 <code>UsageObserver</code> 账本。</li>
+                </ul>
+              </div>
               <div class="note">
                 <h3>运行规则</h3>
                 <ul>
@@ -640,6 +660,7 @@ ai use codex 51talk gpt-5.5</pre>
                   <li><code>ai use codex</code> 使用本次子进程的 <code>-c model_provider=...</code> 固定所选 provider，并通过 <code>env_key = "OPENAI_API_KEY"</code> 使用 AI Gateway 注入的 Key；不会修改 Codex 全局认证或配置。</li>
                   <li>provider 的 <code>mode</code> 为 <code>auto</code> 时，非 root 执行 Claude Code 会追加 <code>--dangerously-skip-permissions</code>；<code>ask</code> 模式不会追加，并会在启动前确认。root 下请求 <code>auto</code> 会被安全约束为默认权限，临时 settings 中继承的 bypass 配置也会被清除。</li>
                   <li>OpenAI 兼容地址用于 Codex 时会使用 <code>/v1</code>，用于 Claude 时会去掉 <code>/v1</code>。</li>
+                  <li>Claude 与 Codex 的本次子进程都会通过 execution-scoped 本地代理转发；原生终端交互不变，provider 返回的真实 usage 会按 provider/model 写入 <code>usage.json</code>。</li>
                   <li>日志只记录 Key 指纹，不记录完整 API Key。</li>
                 </ul>
               </div>
@@ -658,9 +679,10 @@ ai set codex proxy off</pre>
                   <li><code>provider name model-id</code> 显式选择该 provider 已探测的 <code>gpt-*</code> 模型；只给 provider 时自动选最新 GPT。</li>
                   <li><code>provider</code> 不带名称时依次交互选择已添加的 provider 和 GPT 模型；没有可用 GPT 时提示运行 <code>ai status</code>，不修改配置。</li>
                   <li>自动选择先比较 GPT 数字版本，同版本优先 <code>sol</code>、<code>pro</code>、alias、<code>codex</code>、<code>terra</code>、<code>mini</code>、<code>luna</code>、<code>nano</code>，并优先滚动 alias。API Key 只写入 mode <code>0600</code> 的 <code>auth.json</code>。</li>
+                  <li>写入 <code>config.toml</code> 前会规范化 <code>base_url</code>：末尾没有 <code>/v1</code> 时自动补上，已有时不重复追加。</li>
                   <li>原有 project、MCP、plugin、feature 设置会保留；任一步失败会恢复原 <code>config.toml</code> 和 <code>auth.json</code>。</li>
                   <li>切换自定义 provider 会替换当前 ChatGPT token；切回 ChatGPT 时需重新登录。</li>
-                  <li>成功后 macOS 会重启 <code>Codex.app</code> 或当前名称的 <code>ChatGPT.app</code>；无法自动重启时按提示手动操作。</li>
+                  <li>成功后 macOS 会重启 <code>Codex.app</code> 或当前名称的 <code>ChatGPT.app</code>，并清理重启进程继承的 <code>OPENAI_API_KEY</code>，确保客户端读取刚写入的 <code>auth.json</code>；无法自动重启时按提示手动操作。</li>
                   <li><code>proxy</code> 把裸 <code>host:port</code> 规范化为 HTTP origin，只更新 <code>shell_environment_policy.set</code> 的大小写 HTTP(S)/ALL proxy keys；<code>off</code> 清除这些 managed keys，不修改 <code>auth.json</code>。</li>
                   <li>Proxy URL 禁止包含账号密码、path、query 或 fragment，command usage log 会整体脱敏。macOS 会同步当前登录会话的 user launchd environment；失败时恢复原 config 且不重启，注销或重启 macOS 后需重新运行本命令。</li>
                 </ul>
@@ -799,7 +821,7 @@ ai provider list
 ai log
 ai log --print
 ai context</pre>
-                <p><code>status</code> 会刷新 provider 健康度和模型缓存，展示 Claude/Codex 各自实际 baseUrl、兼容模型、token 使用量和使用占比。</p>
+                <p><code>status</code> 会刷新 provider 健康度和模型缓存，展示 Claude/Codex 各自实际 baseUrl、兼容模型、token 使用量和使用占比。CLI 与 Telegram 的 Claude/Codex 新请求只要 provider 返回结构化 usage 都会计入；周统计按 provider 精确名称聚合，同一 provider 的不同模型合并，事件仍保留 model 明细。升级前未经过代理的旧历史不会估算补录。</p>
               </div>
               <div class="note">
                 <h3>诊断与自动修复</h3>

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@offerpilot/axiomruntime",
-  "version": "0.0.3",
-  "description": "CLI-first foundation for an enterprise AI Runtime with provider routing and governed execution.",
+  "version": "0.0.5",
+  "description": "CLI-first local AI Runtime for isolated multi-provider Claude Code and Codex execution with Telegram remote control.",
   "homepage": "https://gitlab.com/linlangli/agent-router",
   "repository": {
     "type": "git",

package/docs/README.md

@@ -1,98 +0,0 @@
-# AI Runtime 文档总览
-
-本项目采用分层文档体系：英文正典（`AGENTS.md`、`AI_RUNTIME_ARCHITECTURE.md`、`CONVENTIONS.md`）定义仓库规则与目标架构；中英混合的 `doc_2.0` 文档层（根文档在 `docs/`，模块文档在 `docs/modules/`）承载产品规范、宪法摘要、模块设计与强制条款；面向用户的中文文档负责操作说明。各层描述的是同一个产品，不是多套路线。
-
-## 给用户和中文评审者
-
-| 文档 | 内容 |
-|---|---|
-| [项目 README](../README.md) | 产品定位、当前能力、安装与常用入口 |
-| [doc_2.0 规范层完整索引](#doc_20-规范层完整索引) | 分层架构、模块文档、规范条款、路线图的统一索引（见下方章节）|
-| [使用指南](usage.md) | CLI、Provider、Telegram、会话和诊断操作 |
-| [HTML 命令手册](USAGE.html) | 可浏览的命令索引 |
-| [整体架构与当前实现快照](00-overview.md) | 分层俯瞰、现状映射与从旧 ARCHITECTURE 迁入的实现快照 |
-| [产品架构全景图](architecture-map.md) | 中文架构图、执行主链、学习闭环与权威所有权说明 |
-| [自动记忆系统方案](modules/06-memory.md) | Memory、Knowledge、Skill 与学习治理设计（配套 [contracts](contracts.md)、[07-learning-governance](modules/07-learning-governance.md)）|
-| [Telegram Bot 方案](modules/01-surfaces.md) | Telegram 入口的交互和实现设计 |
-
-## 给 AI 和维护者
-
-以下文档使用英文，并作为架构与实现的权威来源：
-
-| 文档 | 内容 |
-|---|---|
-| [Repository Instructions](../AGENTS.md) | AI 在仓库内工作的规则、文档优先级和交付标准 |
-| [Target Architecture](AI_RUNTIME_ARCHITECTURE.md) | Enterprise AI Runtime 目标架构与演进路径 |
-| [Development Conventions](CONVENTIONS.md) | 工程、发布、文档同步和模块边界规范 |
-| [Portable AI Specification](AI_RUNTIME_PORTABLE_SPEC.md) | 可直接提供给其他 AI 的英文单文件完整上下文；仓库内属于便携快照，不替代分层权威文档 |
-
-产品宪法摘要、产品规范与验收标准构成中英混合的 `doc_2.0` 文档层：宪法摘要见 [00-overview.md](00-overview.md)，跨模块强制条款（R1–R36 / Q1–Q6）见 [enforcement-decisions.md](enforcement-decisions.md)。
-
-除宪法摘要外，正典文档与 `doc_2.0` 规范层都是随开发持续更新的 Living Documents：每个开发任务结束前检查影响，每个里程碑或发布进行完整审计。宪法摘要（见 [00-overview.md](00-overview.md)）只在人类明确调整使命、北极星或三条硬不变量时修改。
-
-## doc_2.0 规范层完整索引
-
-> `doc_2.0` 是按**分层架构**重构的文档集：一份项目整体文档 + 每个独立模块一份文档。语言模式为**中英混合**（叙述中文，标识符英文原样保留，以保 AI 识别准确率）。权威顺序与冲突处理见下方「文档冲突处理」。
-
-### 起点
-
-| 文档 | 内容 |
-|---|---|
-| [00-overview.md](00-overview.md) | ⭐项目整体文档：三条不变量、分层全景、模块清单、现状映射 |
-| [glossary.md](glossary.md) | 中英术语表（一致性锁） |
-| [contracts.md](contracts.md) | L0 端口契约清单，含统一 Capability Observability envelope、Sink 与授权查询契约 |
-| [extraction-readiness.md](extraction-readiness.md) | 模块产品化就绪度判据 |
-| [enforcement-decisions.md](enforcement-decisions.md) | ⭐规范约定 + R1–R36 强制实施决策 + Q1–Q6 质量/运维决策（跨模块权威引用源）|
-| [roadmap.md](roadmap.md) | Release R0–R3 纵向产品闭环、Phase 0–13 技术计划与贯穿全程可观测性 |
-| [testing.md](testing.md) | 测试计划：核心记忆/Telegram/CLI/Auth/检索质量/长期仿真/Memory、Skill 与 Capability 可观测性 |
-| [service-level-objectives.md](service-level-objectives.md) | `local/team/enterprise` 的 SLO、RTO、RPO、容量与恢复演练门槛 |
-| [usage.md](usage.md) | 用户使用指南：逐命令用法（交互模式/Claude·Codex/Telegram/Provider/会话/日志等）|
-
-### 模块文档（每个独立模块单独维护，位于 `modules/`）
-
-| # | 模块 | 文档 | 状态 |
-|---|---|---|---|
-| ① | Surfaces | [modules/01-surfaces.md](modules/01-surfaces.md) | ✅ |
-| ② | Orchestration | [modules/02-orchestration.md](modules/02-orchestration.md) | ✅ |
-| ③ | Capabilities | [modules/03-capabilities.md](modules/03-capabilities.md) | ✅ |
-| ④ | Execution Kernel | [modules/04-execution-kernel.md](modules/04-execution-kernel.md) | ✅ |
-| ⑤ | Transport Proxy | [modules/05-transport-proxy.md](modules/05-transport-proxy.md) | ✅ |
-| ⑥ | Memory | [modules/06-memory.md](modules/06-memory.md) | ✅ |
-| ⑦ | Learning & Governance | [modules/07-learning-governance.md](modules/07-learning-governance.md) | ✅ |
-| ⑧ | Policy | [modules/08-policy.md](modules/08-policy.md) | ✅ |
-| ⑨ | Security | [modules/09-security.md](modules/09-security.md) | ✅ |
-| ⑩ | Adapters/Plugins | [modules/10-adapters-plugins.md](modules/10-adapters-plugins.md) | ✅ |
-| ⑪ | Storage | [modules/11-storage.md](modules/11-storage.md) | ✅ |
-
-每份模块文档固定 11 节：`定位 → 单一职责边界 → 内部构件 → 对外/消费端口 → 依赖 → 数据所有权 → 降级/kill switch → 产品化就绪度 → 现状映射 → 验收标准 → 相关文档`。以 [modules/05-transport-proxy.md](modules/05-transport-proxy.md) 为样板。
-
-## 文档冲突处理
-
-不同问题只有一个权威归属：
-
-| 问题 | 唯一权威位置 |
-|---|---|
-| mission / North Star / 三条硬不变量 | [00-overview.md](00-overview.md) 的宪法摘要；仅人类明确决策可修改 |
-| 分层、模块 ownership、依赖方向、插件原则 | [AI_RUNTIME_ARCHITECTURE.md](AI_RUNTIME_ARCHITECTURE.md) + [CONVENTIONS.md](CONVENTIONS.md) |
-| canonical identifier、Port、跨进程 schema、错误/版本语义 | [contracts.md](contracts.md) |
-| 跨模块产品行为和安全/质量硬门槛 | [enforcement-decisions.md](enforcement-decisions.md) 的 R/Q 条款 |
-| 单模块职责、数据所有权、降级和模块验收 | 对应 `modules/*.md` 的正文 1–11 节 |
-| 交付顺序与测试覆盖 | [roadmap.md](roadmap.md) + [testing.md](testing.md) |
-| 历史实现、迁移代码、旧文档保留材料 | 模块附录，仅作 supporting material，不是独立权威源 |
-
-模块附录中的旧字段、代码块、状态说明或实现建议不得覆盖当前 L0 契约、R/Q 条款或模块正文。发现冲突时不能按“更具体”或“更旧”自动取舍：当前任务必须同步修正文档，无法当场修复时显式记录 conflict、owner 和 exit condition。`doc_2.0` 中的 canonical identifier 必须与 `contracts.md` 一致。
-
-所有附录标题下必须声明 `Appendix Status`：
-
-| `Appendix Status` | 含义 | 可否作为新实现依据 |
-|---|---|---|
-| `CONSTITUTION SUMMARY` | 经人类批准的使命/North Star/硬不变量摘要 | 可以，仅限宪章范围 |
-| `SUPPORTING SPEC` | 补充正文的详细行为；不得覆盖正文/L0/RQ | 可以，但先归一化到 canonical contract |
-| `CURRENT SNAPSHOT` | 某一时点实现事实 | 不可以直接推导目标设计 |
-| `MIGRATION FIXTURE` | legacy schema/样本/兼容输入 | 仅用于 migration 与 compatibility test |
-| `DESIGN SOURCE` | 保留的方案、推理或成熟设计来源 | 只能作为 ADR 输入 |
-| `DEPRECATED REFERENCE` | 已被新规范取代、等待删除的材料 | 不可以 |
-
-缺少状态标签的附录视为 `DEPRECATED REFERENCE`。引用附录时必须同时引用它所服从的正文、contract 或 R/Q 条款。
-
-宪法摘要只能由人类明确决策后修改。代码、单次模型输出或局部功能文档不能反向改变项目定位。