@armadra/agent 0.7.1 → 0.7.2

package/dist/modes/interactive/program-status-ui.js

@@ -0,0 +1,229 @@
+/**
+ * 交互界面的终端程序状态（OSC 7501，src/tui/program-status.ts）：会话事件 → 根记录与子任务记录。
+ *
+ * 根记录（优先级自上而下）：
+ *   有待人处理的审批 → blocked:permission（msg = 工具 · 目标）
+ *   有待审批的计划 → blocked:question
+ *   上一回合因登录失效失败（`auth_expired`）→ blocked:auth（下一回合开始或换模型时解除）
+ *   回合进行中 → working（msg = 思考中 / 回复中 / 运行 bash / 压缩上下文，节流 + 同值去重）
+ *   回合结束 → done；出错 → error（msg = 错误首行）；用户中断 → idle；之后用户再按键 → idle
+ *   启动 / 切换会话 → idle
+ * 子记录：子 Agent 任务 `id=task/<短 id>`、title = 任务描述，working / blocked / done / error（中断为 idle）；
+ * 下一个主回合开始时清掉已结束的任务记录。退出交互模式前发不带 id 的 `state=clear`（用户主动退出，
+ * 不留记录）。
+ *
+ * 只在交互 TUI 里启用；print / rpc / acp 的 stdout 是数据或协议，不发。
+ */
+import { msg } from "../../i18n/index.js";
+import { ProgramStatusEmitter, idSegment, } from "../../tui/program-status.js";
+import { flat, toolSummary } from "./tool-summary.js";
+const AUTH_EXPIRED = /\bauth_expired\b/;
+/** 会话事件 → 状态记录（只读事件，不改会话）。 */
+export class ProgramStatusTracker {
+    emitter;
+    cwd;
+    running = false;
+    activity;
+    approvals = new Map();
+    plan;
+    auth;
+    outcome;
+    lastError;
+    tasks = new Map();
+    constructor(emitter, cwd = () => undefined) {
+        this.emitter = emitter;
+        this.cwd = cwd;
+    }
+    onEvent(event) {
+        const run = msg().interactive.view.run;
+        switch (event.type) {
+            case "session_start":
+                if (event.reason !== "startup")
+                    this.reset();
+                break;
+            case "agent_start":
+                this.running = true;
+                this.activity = run.thinking;
+                this.outcome = this.auth = this.lastError = undefined;
+                for (const [key, task] of this.tasks)
+                    if (task.state !== "working" && task.state !== "blocked")
+                        this.dropTask(key);
+                break;
+            case "message_update": {
+                const last = event.message.content.at(-1);
+                this.activity = last?.type === "text" ? run.replying : run.thinking;
+                break;
+            }
+            case "tool_execution_start":
+                if (event.parentToolCallId === undefined)
+                    this.activity = run.runningTool(event.toolName);
+                break;
+            case "compaction_start":
+                this.activity = run.compacting;
+                break;
+            case "message_end":
+                if (event.message.role === "assistant" && event.message.stopReason === "error")
+                    this.lastError = event.message.errorMessage ?? "error";
+                break;
+            case "agent_end":
+                if (!event.willRetry)
+                    this.outcome = this.outcomeOf(event.stopReason);
+                break;
+            case "agent_settled":
+                this.running = false;
+                this.outcome ??= { state: "done" };
+                break;
+            case "permission_request": {
+                const summary = flat(toolSummary(event.toolName, event.input, this.cwd()), 80);
+                const text = summary === "" ? event.toolName : `${event.toolName} · ${summary}`;
+                const taskId = event.context?.taskId;
+                this.approvals.set(event.requestId, { msg: text, ...(taskId ? { taskId } : {}) });
+                const task = taskId !== undefined ? this.tasks.get(taskId) : undefined;
+                if (task !== undefined)
+                    Object.assign(task, { state: "blocked", msg: text });
+                break;
+            }
+            case "permission_resolved": {
+                const taskId = this.approvals.get(event.requestId)?.taskId;
+                this.approvals.delete(event.requestId);
+                const task = taskId !== undefined ? this.tasks.get(taskId) : undefined;
+                const still = [...this.approvals.values()].some((p) => p.taskId === taskId);
+                if (task?.state === "blocked" && !still)
+                    Object.assign(task, { state: "working" });
+                break;
+            }
+            case "plan_proposed":
+                this.plan = msg().plan.dialog.title;
+                break;
+            case "plan_resolved":
+                this.plan = undefined;
+                break;
+            case "model_changed":
+                this.auth = undefined;
+                break;
+            case "subagent_start":
+                this.tasks.set(event.taskId, {
+                    id: `task/${idSegment(event.taskId)}`,
+                    title: event.description,
+                    state: "working",
+                    msg: event.agent,
+                });
+                break;
+            case "subagent_update": {
+                const task = this.tasks.get(event.taskId);
+                if (task?.state === "working" && event.toolName !== undefined)
+                    task.msg = run.runningTool(event.toolName);
+                break;
+            }
+            case "subagent_end": {
+                const task = this.tasks.get(event.taskId);
+                if (task === undefined)
+                    break;
+                const s = event.status;
+                task.state =
+                    s === "completed" ? "done" : s === "aborted" || s === "interrupted" ? "idle" : "error";
+                delete task.msg;
+                break;
+            }
+            default:
+                return;
+        }
+        this.sync();
+    }
+    /** 用户按键：已看到的 done / error 回到 idle。 */
+    acknowledge() {
+        if (this.running || this.outcome === undefined || this.outcome.state === "idle")
+            return;
+        this.outcome = { state: "idle" };
+        this.sync();
+    }
+    /** 当前根记录（测试也用）。 */
+    root() {
+        const pending = [...this.approvals.values()].at(-1);
+        if (pending !== undefined)
+            return blocked("permission", pending.msg);
+        if (this.plan !== undefined)
+            return blocked("question", this.plan);
+        if (this.auth !== undefined)
+            return blocked("auth", this.auth);
+        if (this.running)
+            return { state: "working", ...(this.activity !== undefined ? { msg: this.activity } : {}) };
+        return this.outcome ?? { state: "idle" };
+    }
+    /** 写出全部记录（发射器同值去重）。 */
+    sync() {
+        this.emitter.report(this.root());
+        for (const task of this.tasks.values())
+            this.emitter.report({
+                id: task.id,
+                state: task.state,
+                title: task.title,
+                ...(task.state === "blocked" ? { kind: "permission" } : {}),
+                ...(task.msg !== undefined ? { msg: task.msg } : {}),
+            });
+    }
+    outcomeOf(stopReason) {
+        if (stopReason === "aborted")
+            return { state: "idle" };
+        if (stopReason !== "error")
+            return { state: "done" };
+        const text = flat(this.lastError ?? "error", 200);
+        if (AUTH_EXPIRED.test(text))
+            this.auth = text;
+        return { state: "error", msg: text };
+    }
+    dropTask(key) {
+        const task = this.tasks.get(key);
+        this.tasks.delete(key);
+        if (task !== undefined)
+            this.emitter.report({ id: task.id, state: "clear" });
+    }
+    reset() {
+        this.running = false;
+        this.approvals.clear();
+        this.plan = this.auth = this.outcome = this.lastError = this.activity = undefined;
+        for (const key of [...this.tasks.keys()])
+            this.dropTask(key);
+    }
+}
+function blocked(kind, text) {
+    return { state: "blocked", kind, msg: text };
+}
+/**
+ * 交互模式装配。缺省只在真实终端（没有注入 `terminal`）启用；测试注入终端时给了 `programStatus` 才启用，
+ * 其余情况与 `ui.programStatus: "off"` 一样全部空操作。
+ */
+export function programStatusUi(deps) {
+    const { terminal, programStatus } = deps.options;
+    const mode = deps.runtime.config.ui?.programStatus ?? "auto";
+    if ((terminal !== undefined && programStatus === undefined) || mode === "off")
+        return { wrap: (handler) => handler, start: () => undefined, exit: () => undefined };
+    const emitter = new ProgramStatusEmitter({
+        write: (data) => deps.tui.terminal.write(data),
+        mode,
+        env: deps.env,
+        app: "ama",
+        ...programStatus,
+    });
+    const tracker = new ProgramStatusTracker(emitter, deps.cwd);
+    deps.tui.addInputListener((data) => {
+        if (emitter.handleInput(data))
+            return true;
+        tracker.acknowledge();
+        return false;
+    });
+    return {
+        wrap: (handler) => (event) => {
+            tracker.onEvent(event);
+            handler(event);
+        },
+        start: () => {
+            emitter.start();
+            tracker.sync();
+        },
+        exit: () => {
+            emitter.report({ state: "clear" });
+            emitter.dispose();
+        },
+    };
+}

package/dist/modes/interactive/session-events.d.ts

@@ -1,6 +1,10 @@
 /**
  * 交互界面的会话事件分派：`SessionEvent` → 消息区、工具视图、状态栏、运行指示。[B7]
  * 从 interactive-mode.ts 拆出（W5-U：第五波事件先交给 agent-ui.ts，预算到限的 agent_settled warning 不重复显示）。
+ *
+ * 状态栏刷新时机：用户消息落盘（message_end，紧跟 message_start）后立刻刷新，尾部估算马上反映进 Ctx；
+ * 流式中助手消息带 usage 时按 ≤ 2 Hz 采样在途请求的上下文量（StatusBar.noteStreaming），消息结束后回到统计值。
+ * 模型没有上下文窗口（`ctx ?`）时每个模型提示一次怎么补。
  */
 import type { AgentSession, SessionEvent } from "../../agent/types.js";
 import type { AgentUi } from "./agent-ui.js";

package/dist/modes/interactive/session-events.js

@@ -1,13 +1,31 @@
 /**
  * 交互界面的会话事件分派：`SessionEvent` → 消息区、工具视图、状态栏、运行指示。[B7]
  * 从 interactive-mode.ts 拆出（W5-U：第五波事件先交给 agent-ui.ts，预算到限的 agent_settled warning 不重复显示）。
+ *
+ * 状态栏刷新时机：用户消息落盘（message_end，紧跟 message_start）后立刻刷新，尾部估算马上反映进 Ctx；
+ * 流式中助手消息带 usage 时按 ≤ 2 Hz 采样在途请求的上下文量（StatusBar.noteStreaming），消息结束后回到统计值。
+ * 模型没有上下文窗口（`ctx ?`）时每个模型提示一次怎么补。
  */
 import { msg } from "../../i18n/index.js";
+import { formatModelRef } from "../../ai/providers/channels.js";
 import { cacheEventNotice, cacheNoticesEnabled } from "../session-report.js";
 import { compactionErrorText, ImageBudgetNotices, LIMIT_WARNING } from "./event-notices.js";
 export function createSessionEventHandler(deps) {
     const { view, tools, status, area, agentUi, indicator, session, setQueue, notice, render } = deps;
     const images = new ImageBudgetNotices((text) => notice("info", text));
+    const windowHinted = new Set();
+    /** 刷新状态栏；模型没有上下文窗口时每个模型提示一次。 */
+    const refresh = () => {
+        status.refresh();
+        if (status.current().contextWindow !== undefined)
+            return;
+        const model = session().state.model;
+        const ref = model === undefined ? undefined : formatModelRef(model);
+        if (ref === undefined || windowHinted.has(ref))
+            return;
+        windowHinted.add(ref);
+        view.addNotice("info", msg().interactive.statusLine.noWindow(ref));
+    };
     return (event) => {
         if (area.onEvent(event) || agentUi().onEvent(event)) {
             // [W7-A] 子任务出现 / 结束：运行提示行的「↓ Agent 栏」跟着变
@@ -21,7 +39,7 @@ export function createSessionEventHandler(deps) {
                 // 预算到限已由 limit_reached 给出友好提示
                 if (event.warning !== undefined && event.warning !== LIMIT_WARNING)
                     view.addNotice("warn", event.warning);
-                status.refresh();
+                refresh();
                 break;
             case "message_start": {
                 const message = event.message;
@@ -36,12 +54,16 @@ export function createSessionEventHandler(deps) {
             }
             case "message_update":
                 view.updateAssistant(event.message);
+                status.noteStreaming(event.message.usage);
                 break;
             case "message_end":
                 if (event.message.role === "assistant") {
                     view.endAssistant(event.message);
+                    status.clearStreaming();
                     status.refresh();
                 }
+                else if (event.message.role === "user")
+                    refresh();
                 break;
             case "tool_execution_start": {
                 const started = tools.start(event);
@@ -89,7 +111,7 @@ export function createSessionEventHandler(deps) {
             case "model_changed":
             case "thinking_level_changed":
             case "session_changed":
-                status.refresh();
+                refresh();
                 render();
                 return;
             default:

package/dist/modes/interactive/status-bar.d.ts

@@ -10,7 +10,9 @@
  *   `Manual · shift+tab 切换    sonnet-4-5 · medium · ↑12.3k ↓1.2k · cache 80% ♨ · $0.12 · ctx 34% · proj ⎇ main 5ae9e54 +12 −3 · 2h24m`
  *   右区顺序：模型 · 思考 · `↑ ↓` · cache · 费用 · rebill · ctx · git · 时长 · queue · codemode · 预设 · [宿主]。
  * - `full`（独立终端缺省，用户样例）：用量类项移到上方速率行（status-line.ts），本行为
- *   `Manual | 模型 思考 | Ctx 3.0% | 目录 ⎇ 分支 短提交 (+a,-d) | $费用 | 会话时长`；Ctx 一位小数、不换余量表。
+ *   `Manual | 模型 思考 | Ctx 3.0% 8.2k/272k auto | 目录 ⎇ 分支 短提交 (+a,-d) | $费用 | 会话时长`；Ctx 一位小数、
+ *   不换余量表，带已用量 / 窗口与自动压缩标记（status-ctx.ts）。
+ * - 上下文：估算值带 `≈`；着色阈值与档一裁剪对齐；流式中有 usage 时显示在途请求的值（`noteStreaming`，≤ 2 Hz）。
  *
  * - 用量来自 `session.getStats()`，只在 `refresh()` 时读取（事件驱动），渲染只拼字符串；时长按渲染时刻算。
  * - [W3-C2] `cache` 是**最近一次**请求的命中率；端点三态 `cache —` / `cache 未报告`；保温中追加 `♨`；
@@ -35,6 +37,7 @@
  *   数字变化不会让某项时有时无（40 列不抖动）。
  */
 import type { AgentSession, SessionCacheStats, SessionStats } from "../../agent/types.js";
+import type { Usage } from "../../ai/types.js";
 import type { StatusLineMode } from "../../config/types.js";
 import type { GitInfo } from "../../git/info.js";
 import { type QuotaView } from "./status-quota.js";
@@ -76,6 +79,11 @@ export declare function formatCost(cost: number): string;
 export declare function formatDuration(ms: number): string;
 /** `cache 83%` / `cache —` / `cache 未报告`，保温计时中追加 ` ♨`。 */
 export declare function cacheText(cache: SessionCacheStats, warm?: string): string;
+/**
+ * 会话累计计费量（不是上下文）：`Σ↑<输入含缓存读写> ↓<输出> R<缓存读> W<缓存写>`，R / W 为 0 不显示；
+ * ASCII 下 `Σ` → `sum `。
+ */
+export declare function tokensText(t: SessionStats["tokens"], g: Pick<Theme["glyphs"], "ascii" | "arrowUp" | "arrowDown">): string;
 /** 状态费用：会话费用 + 外部 Agent 以美元计的用量；会话费用未知为 undefined。 */
 export declare function statusCost(stats: SessionStats): number | undefined;
 export interface Part {
@@ -127,15 +135,26 @@ export interface UsageItems {
     host?: string;
 }
 /** 用量类项的文本（已着色；普通项 dim）。 */
-export declare function usageItems(stats: SessionStats, queue: number, source: StatusBarSource, theme: Theme): UsageItems;
+export declare function usageItems(stats: SessionStats, queue: number, source: StatusBarSource, theme: Theme, 
+/** full 速率行：`Σ` 标明会话累计，缓存读写分列 `R / W`；compact 保持 `↑ ↓`（宿主按此解析、窄屏省宽）。 */
+cumulative?: boolean): UsageItems;
 export declare class StatusBar implements Component {
     private readonly source;
     private readonly theme;
     private stats;
     private queue;
+    /** 在途请求的上下文量（message_update 的 usage，≤ 2 Hz 采样）；该消息结束后清掉。 */
+    private readonly live;
     constructor(source: StatusBarSource, theme: Theme);
     /** 用量、模型等变化后调用（事件驱动；流式期间不必每帧算）。 */
     refresh(): void;
+    /**
+     * 流式中的助手消息带了 usage（有的协议在开头就给输入量）：记下在途请求的上下文量，距上次采样
+     * ≥ 500 ms 才更新（≤ 2 Hz）。返回是否更新了。
+     */
+    noteStreaming(usage: Usage | undefined): boolean;
+    /** 助手消息结束：丢掉在途值，回到统计值。 */
+    clearStreaming(): void;
     setQueue(steering: number, followUp: number): void;
     /** 当前统计（速率行共用，避免重复 getStats）。 */
     current(): SessionStats;
@@ -144,7 +163,6 @@ export declare class StatusBar implements Component {
     private parts;
     /** `目录 ⎇ 分支 短提交 +a −b`：三项同组、各自按优先级丢弃；full 另带 `↑N ↓N` 并按参考配色。 */
     private gitParts;
-    private ctxText;
     render(width: number): string[];
     invalidate(): void;
 }

package/dist/modes/interactive/status-bar.js

@@ -10,7 +10,9 @@
  *   `Manual · shift+tab 切换    sonnet-4-5 · medium · ↑12.3k ↓1.2k · cache 80% ♨ · $0.12 · ctx 34% · proj ⎇ main 5ae9e54 +12 −3 · 2h24m`
  *   右区顺序：模型 · 思考 · `↑ ↓` · cache · 费用 · rebill · ctx · git · 时长 · queue · codemode · 预设 · [宿主]。
  * - `full`（独立终端缺省，用户样例）：用量类项移到上方速率行（status-line.ts），本行为
- *   `Manual | 模型 思考 | Ctx 3.0% | 目录 ⎇ 分支 短提交 (+a,-d) | $费用 | 会话时长`；Ctx 一位小数、不换余量表。
+ *   `Manual | 模型 思考 | Ctx 3.0% 8.2k/272k auto | 目录 ⎇ 分支 短提交 (+a,-d) | $费用 | 会话时长`；Ctx 一位小数、
+ *   不换余量表，带已用量 / 窗口与自动压缩标记（status-ctx.ts）。
+ * - 上下文：估算值带 `≈`；着色阈值与档一裁剪对齐；流式中有 usage 时显示在途请求的值（`noteStreaming`，≤ 2 Hz）。
  *
  * - 用量来自 `session.getStats()`，只在 `refresh()` 时读取（事件驱动），渲染只拼字符串；时长按渲染时刻算。
  * - [W3-C2] `cache` 是**最近一次**请求的命中率；端点三态 `cache —` / `cache 未报告`；保温中追加 `♨`；
@@ -38,7 +40,8 @@ import { msg } from "../../i18n/index.js";
 import { permissionModeLabel } from "../../permissions/modes.js";
 import { formatModelRef } from "../../ai/providers/channels.js";
 import { compactQuotaItem } from "./status-quota.js";
-import { Meter, levelColor, truncateToWidth, visibleWidth, } from "../../tui.js";
+import { LiveContext, compactCtxText, fullCtxParts } from "./status-ctx.js";
+import { truncateToWidth, visibleWidth } from "../../tui.js";
 export function formatTokens(count) {
     if (count < 1000)
         return String(count);
@@ -73,6 +76,22 @@ export function cacheText(cache, warm = "♨") {
             : "—";
     return `cache ${value}${cache.warming.state === "scheduled" ? ` ${warm}` : ""}`;
 }
+/**
+ * 会话累计计费量（不是上下文）：`Σ↑<输入含缓存读写> ↓<输出> R<缓存读> W<缓存写>`，R / W 为 0 不显示；
+ * ASCII 下 `Σ` → `sum `。
+ */
+export function tokensText(t, g) {
+    const prompt = t.input + t.cacheRead + t.cacheWrite;
+    const parts = [
+        `${g.ascii ? "sum " : "Σ"}${g.arrowUp}${formatTokens(prompt)}`,
+        `${g.arrowDown}${formatTokens(t.output)}`,
+    ];
+    if (t.cacheRead > 0)
+        parts.push(`R${formatTokens(t.cacheRead)}`);
+    if (t.cacheWrite > 0)
+        parts.push(`W${formatTokens(t.cacheWrite)}`);
+    return parts.join(" ");
+}
 /** 状态费用：会话费用 + 外部 Agent 以美元计的用量；会话费用未知为 undefined。 */
 export function statusCost(stats) {
     if (stats.cost === undefined)
@@ -86,8 +105,6 @@ export function statusCost(stats) {
 }
 /** 两区之间至少留的空格；不足时退回单区。 */
 const MIN_GAP = 4;
-/** ctx 改用余量表的最小宽度。 */
-const METER_WIDTH = 110;
 /** 按优先级丢弃后排成一行（两区 / 单区）；连接符都是 dim。 */
 export function layoutRow(parts, width, theme, style = {}) {
     const sep = style.sep ?? " · ";
@@ -161,7 +178,9 @@ export function abbreviateModel(ref, width) {
     return out;
 }
 /** 用量类项的文本（已着色；普通项 dim）。 */
-export function usageItems(stats, queue, source, theme) {
+export function usageItems(stats, queue, source, theme, 
+/** full 速率行：`Σ` 标明会话累计，缓存读写分列 `R / W`；compact 保持 `↑ ↓`（宿主按此解析、窄屏省宽）。 */
+cumulative = false) {
     const g = theme.glyphs;
     const dim = (text) => theme.fg("dim", text);
     const out = {};
@@ -169,7 +188,9 @@ export function usageItems(stats, queue, source, theme) {
     const prompt = t.input + t.cacheRead + t.cacheWrite;
     const cache = stats.cache;
     if (prompt + t.output > 0) {
-        out.tokens = dim(`${g.arrowUp}${formatTokens(prompt)} ${g.arrowDown}${formatTokens(t.output)}`);
+        out.tokens = dim(cumulative
+            ? tokensText(t, g)
+            : `${g.arrowUp}${formatTokens(prompt)} ${g.arrowDown}${formatTokens(t.output)}`);
         if (cache !== undefined)
             out.cache = dim(cacheText(cache, g.warm));
         else if (stats.cacheHitRate !== undefined) {
@@ -228,16 +249,33 @@ const COMPACT = {
     hint: 16,
     quota: 17,
 };
-/** full 布局本行的优先级（§1.2 下行表）。 */
-const FULL = { model: 0, ctx: 1, cost: 2, duration: 3, branch: 4, dir: 5, diff: 6, thinking: 7 };
+/**
+ * full 布局本行的优先级（§1.2 下行表）。Ctx 段由百分比、已用量（ctxUsed）、`/窗口`（ctxWindow）与
+ * `auto` 标记组成，窄时先丢 auto、`/窗口`，再丢已用量，百分比最后丢。
+ */
+const FULL = {
+    model: 0,
+    ctx: 1,
+    cost: 2,
+    duration: 3,
+    ctxUsed: 4,
+    branch: 5,
+    dir: 6,
+    diff: 7,
+    ctxWindow: 8,
+    thinking: 9,
+    ctxAuto: 13,
+};
 const FULL_HINT = 12;
-/** full 状态栏（用户样例）：段间 ` | `。 */
-const FULL_STYLE = { sep: " | " };
+/** full 状态栏（用户样例）：段间 ` | `；Ctx 段（status-ctx.ts）的成员自带前导空格 / 斜杠，组内不加连接符。 */
+const FULL_STYLE = { sep: " | ", groups: { ctx: { glue: "" } } };
 export class StatusBar {
     source;
     theme;
     stats;
     queue = 0;
+    /** 在途请求的上下文量（message_update 的 usage，≤ 2 Hz 采样）；该消息结束后清掉。 */
+    live = new LiveContext(() => this.source.now?.() ?? Date.now());
     constructor(source, theme) {
         this.source = source;
         this.theme = theme;
@@ -246,6 +284,17 @@ export class StatusBar {
     refresh() {
         this.stats = this.source.session().getStats();
     }
+    /**
+     * 流式中的助手消息带了 usage（有的协议在开头就给输入量）：记下在途请求的上下文量，距上次采样
+     * ≥ 500 ms 才更新（≤ 2 Hz）。返回是否更新了。
+     */
+    noteStreaming(usage) {
+        return this.live.note(usage);
+    }
+    /** 助手消息结束：丢掉在途值，回到统计值。 */
+    clearStreaming() {
+        this.live.clear();
+    }
     setQueue(steering, followUp) {
         this.queue = steering + followUp;
     }
@@ -309,7 +358,11 @@ export class StatusBar {
             right(usage.cost, COMPACT.cost);
         if (usage.rebill !== undefined)
             right(usage.rebill, COMPACT.rebill);
-        right(this.ctxText(stats.contextPercent, width, full), p.ctx, full ? { reserve: 10 } : {});
+        const ctx = this.live.view(stats, g.ascii);
+        if (full)
+            fullCtxParts(ctx, theme, FULL).forEach((part) => parts.push(part));
+        else
+            right(compactCtxText(ctx, width, theme), p.ctx);
         this.gitParts(p, full).forEach((part) => parts.push(part));
         if (full) {
             const cost = statusCost(stats);
@@ -384,20 +437,6 @@ export class StatusBar {
         }
         return out;
     }
-    ctxText(percent, width, decimal) {
-        const theme = this.theme;
-        if (percent === undefined)
-            return theme.fg("dim", decimal ? "Ctx ?" : "ctx ?");
-        const color = levelColor(percent / 100);
-        // full 按用户样例总是 `Ctx 3.0%`；compact 宽屏换余量表（现状）
-        if (!decimal && width >= METER_WIDTH) {
-            const meter = new Meter(percent / 100, { label: theme.fg("dim", "ctx"), theme });
-            return meter.render(80)[0] ?? "";
-        }
-        if (decimal)
-            return theme.fg("dim", "Ctx ") + theme.fg(color, `${percent.toFixed(1)}%`);
-        return theme.fg("dim", "ctx ") + theme.fg(color, `${Math.round(percent)}%`);
-    }
     render(width) {
         const style = this.layout() === "full" ? FULL_STYLE : {};
         return [layoutRow(this.parts(width), width, this.theme, style)];

package/dist/modes/interactive/status-ctx.d.ts

@@ -0,0 +1,55 @@
+/**
+ * 状态栏的上下文项（status-bar.ts 的一部分，单独成文件控制行数）。
+ *
+ * - full：`Ctx 3.0% 8.2k/272k auto`——百分比一位小数；已用量 / 窗口是绝对量；`auto` = 自动压缩开着
+ *   （关闭、熔断或窗口未知时不显示）。成员各自按优先级丢弃：先丢 `auto`、`/窗口`，再丢已用量，百分比最后丢；
+ *   会变的数字按最宽形状占位（不抖动）。
+ * - compact：`ctx 34%`，≥ 110 列换余量表；0 < 占用 < 1% 时保留一位小数（不显示成 0%）。
+ * - 上下文量不是来自 usage（压缩后新 usage 之前、启动前缀基线）时数字前加 `≈`（ASCII `~`）。
+ * - 着色：warning 与档一裁剪阈值对齐（`pruneAt / 窗口`，缺省 0.7），≥ 0.9 error。
+ * - 流式中：助手消息的 usage 已经给出在途请求的上下文量时，按 ≤ 2 Hz 采样显示它，消息结束后回到统计值。
+ */
+import type { SessionStats } from "../../agent/types.js";
+import type { Usage } from "../../ai/types.js";
+import { type Theme } from "../../tui.js";
+import { type Part } from "./status-bar.js";
+/** 流式 usage 的采样间隔（与 telemetry_tick 同节奏，≤ 2 Hz）。 */
+export declare const LIVE_CTX_INTERVAL_MS = 500;
+/** 上下文百分比：full 一位小数；compact 取整，但 0 < p < 1 时保留一位。 */
+export declare function ctxPercentText(percent: number, decimal: boolean): string;
+/** 上下文着色的 warning 阈值：与档一裁剪阈值对齐（`pruneAt / 窗口`），缺省 0.7。 */
+export declare function ctxWarnAt(stats: Pick<SessionStats, "context" | "contextWindow">): number;
+/** 上下文量不是来自 usage（全量估算 / 启动前缀基线）：`≈`（ASCII `~`），否则空串。 */
+export declare function ctxApprox(stats: Pick<SessionStats, "context">, ascii?: boolean): string;
+/** 状态栏上显示的上下文。 */
+export interface CtxView {
+    tokens: number | undefined;
+    window: number | undefined;
+    percent: number | undefined;
+    approx: string;
+    warnAt: number;
+    auto: boolean;
+}
+/** full 本行 Ctx 段各成员的优先级。 */
+export interface CtxPriorities {
+    ctx: number;
+    ctxUsed: number;
+    ctxWindow: number;
+    ctxAuto: number;
+}
+/** 在途请求的上下文量（message_update 的 usage）。 */
+export declare class LiveContext {
+    private readonly now;
+    private tokens;
+    private at;
+    constructor(now: () => number);
+    /** 记下 usage 给出的上下文量；距上次采样 < 500 ms 时不更新。返回是否更新了。 */
+    note(usage: Usage | undefined): boolean;
+    clear(): void;
+    /** 统计值 → 显示值（有在途值时以它为准，不再是估算）。 */
+    view(stats: SessionStats, ascii: boolean): CtxView;
+}
+/** compact：`ctx 34%`，宽屏换余量表。 */
+export declare function compactCtxText(ctx: CtxView, width: number, theme: Theme): string;
+/** full：`Ctx 3.0%` + ` 8.2k` + `/272k` + ` auto`（同组 `ctx`，组内不加连接符）。 */
+export declare function fullCtxParts(ctx: CtxView, theme: Theme, p: CtxPriorities): Part[];