@armadra/agent 0.0.0-stage → 0.3.0

package/dist/modes/interactive/pickers.js

@@ -0,0 +1,115 @@
+/**
+ * 交互模式里的选择器（设计 §12.6）：居中覆盖层 + `SelectList`。[B7]
+ *
+ * - 模型：按供应商分组并标 key 状态（`modelItems`，与启动期共用），当前模型预选；
+ * - 会话：名字或首条提示、相对时间、消息数（`sessionItems`）；
+ * - 树：会话文件里全部用户消息，按分叉缩进，`●` 标出当前分支；选中项回填编辑器（由 commands.ts 处理）；
+ * - 权限模式（从严到宽）与思考级别。
+ */
+import { THINKING_LEVELS } from "../../ai/thinking.js";
+import { PERMISSION_MODES_STRICT_FIRST } from "../../permissions/types.js";
+import { Box, SelectList, } from "../../tui.js";
+import { contentText } from "./message-view.js";
+import { relativeTime } from "./startup-ui.js";
+export { modelItems, sessionItems } from "./startup-ui.js";
+/** 打开一个居中选择器；Enter 返回选中项，Esc / Ctrl+C 返回 undefined。 */
+export function openPicker(host, spec) {
+    return new Promise((resolve) => {
+        let handle;
+        const close = (item) => {
+            handle?.hide();
+            resolve(item);
+        };
+        const list = new SelectList(spec.items, {
+            theme: host.theme,
+            maxVisible: spec.maxVisible ?? 12,
+            filterable: spec.filterable ?? spec.items.length > 8,
+            ...(host.keybindings !== undefined ? { keybindings: host.keybindings } : {}),
+            ...(spec.emptyText !== undefined ? { emptyText: spec.emptyText } : {}),
+            onSelect: (item) => close(item),
+            onCancel: () => close(undefined),
+        });
+        if (spec.selected !== undefined)
+            list.selectValue(spec.selected);
+        const width = Math.max(20, Math.min(host.columns() - 2, 72));
+        handle = host.showOverlay(new Box(list, { title: spec.title, theme: host.theme }), {
+            anchor: "center",
+            width,
+        });
+    });
+}
+const PERMISSION_TEXT = {
+    plan: "只读，不改文件不跑命令",
+    default: "写入与命令逐次确认",
+    "auto-edit": "文件编辑自动放行，命令确认",
+    "full-auto": "全部放行（危险命令仍确认）",
+};
+export function permissionItems() {
+    return PERMISSION_MODES_STRICT_FIRST.map((mode) => ({
+        value: mode,
+        label: mode,
+        description: PERMISSION_TEXT[mode],
+    }));
+}
+export function thinkingItems(reasoning) {
+    return THINKING_LEVELS.map((level) => {
+        const item = { value: level, label: level };
+        if (!reasoning && level !== "off")
+            item.description = "当前模型不支持思考";
+        return item;
+    });
+}
+function userText(entry) {
+    if (entry.type !== "message" || entry.message.role !== "user")
+        return undefined;
+    return contentText(entry.message.content).replace(/\s+/g, " ").trim();
+}
+/** 只保留用户消息的树：每条用户消息挂到最近的用户消息祖先下。 */
+export function userMessageTree(entries) {
+    const byId = new Map(entries.map((e) => [e.id, e]));
+    const nodes = new Map();
+    const roots = [];
+    for (const entry of entries) {
+        const text = userText(entry);
+        if (text === undefined)
+            continue;
+        const node = { entry, text, children: [] };
+        nodes.set(entry.id, node);
+        let parentId = entry.parentId;
+        let parent;
+        const seen = new Set();
+        while (parentId !== null && !seen.has(parentId)) {
+            seen.add(parentId);
+            parent = nodes.get(parentId);
+            if (parent !== undefined)
+                break;
+            parentId = byId.get(parentId)?.parentId ?? null;
+        }
+        (parent?.children ?? roots).push(node);
+    }
+    return roots;
+}
+/**
+ * 树 → 列表项：分叉处子分支缩进一级，单链保持同级；`●` 在当前分支上、`○` 不在。
+ * value 是用户消息条目的 id。
+ */
+export function treeItems(entries, activeIds, now) {
+    const items = [];
+    const visit = (list, depth) => {
+        const fork = list.length > 1;
+        for (const node of list) {
+            const level = fork ? depth + 1 : depth;
+            const mark = activeIds.has(node.entry.id) ? "● " : "○ ";
+            const text = node.text.length > 60 ? `${node.text.slice(0, 59)}…` : node.text;
+            items.push({
+                value: node.entry.id,
+                label: `${"  ".repeat(level)}${mark}${text === "" ? "（空）" : text}`,
+                description: relativeTime(node.entry.timestamp, now),
+            });
+            visit(node.children, level);
+        }
+    };
+    const roots = userMessageTree(entries);
+    visit(roots, roots.length > 1 ? -1 : 0);
+    return items;
+}

package/dist/modes/interactive/startup-ui.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 启动期的迷你界面：bootstrap 第 7 / 8 / 11 步的 `InteractiveUi` 回调（实施计划 §3.3）。[B7]
+ *
+ * 这些回调先于交互模式运行（会话、信任、模型还没定），所以每次问答新建一个只含问题与
+ * 选择列表 / 输入框的 `TUI`；答完把问答收成一行再 `stop()`——不清屏，问答留在回滚里。
+ * 取消（Esc / Ctrl+C）按各回调的约定返回 undefined（bootstrap 据此给退出码）。
+ *
+ * `modelItems` / `sessionItems` 同时供交互模式里的选择器（pickers.ts）使用。
+ */
+import type { Model, ProviderRegistryApi } from "../../ai/types.js";
+import type { InteractiveUi } from "../../cli/deps.js";
+import type { SessionListItem } from "../../session/types.js";
+import { type Keybindings, type SelectItem, type Terminal, type Theme } from "../../tui.js";
+export interface StartupUiOptions {
+    /** 每次问答新建的终端；缺省 `new ProcessTerminal()`。 */
+    terminal?: () => Terminal;
+    theme?: Theme;
+    keybindings?: Keybindings;
+    /** 会话列表的相对时间基准（测试注入）。 */
+    now?: () => number;
+}
+/** 选择器里模型的说明：名称（与 id 不同时）、上下文、`img`（收图片）。 */
+export declare function modelDescription(model: Model): string | undefined;
+/**
+ * 模型按「供应商 · 渠道」分组；有 key（或本地）的供应商排前，组标题标 key 状态。多渠道供应商的模型在
+ * 每个挂载的渠道下各出现一次，非首选渠道的值带 `@渠道`。
+ */
+export declare function modelItems(providers: ProviderRegistryApi): Promise<SelectItem[]>;
+/** `刚刚 / 5 分钟前 / 3 小时前 / 2 天前 / 2026-09-01`。 */
+export declare function relativeTime(iso: string, now: number): string;
+/** 会话：标签 = 名字或首条提示，描述 = 相对时间 · 消息数。 */
+export declare function sessionItems(items: readonly SessionListItem[], now: number): SelectItem[];
+export declare function createStartupUi(options?: StartupUiOptions): Required<InteractiveUi>;

package/dist/modes/interactive/startup-ui.js

@@ -0,0 +1,268 @@
+/**
+ * 启动期的迷你界面：bootstrap 第 7 / 8 / 11 步的 `InteractiveUi` 回调（实施计划 §3.3）。[B7]
+ *
+ * 这些回调先于交互模式运行（会话、信任、模型还没定），所以每次问答新建一个只含问题与
+ * 选择列表 / 输入框的 `TUI`；答完把问答收成一行再 `stop()`——不清屏，问答留在回滚里。
+ * 取消（Esc / Ctrl+C）按各回调的约定返回 undefined（bootstrap 据此给退出码）。
+ *
+ * `modelItems` / `sessionItems` 同时供交互模式里的选择器（pickers.ts）使用。
+ */
+import { existsSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+import { Container, Editor, ProcessTerminal, SelectList, TUI, Text, createTheme, defaultKeybindings, detectCapabilities, } from "../../tui.js";
+function resolveOptions(options) {
+    return {
+        terminal: options.terminal ?? (() => new ProcessTerminal()),
+        theme: options.theme ?? createTheme("dark", { caps: detectCapabilities() }),
+        keys: options.keybindings ?? defaultKeybindings,
+        now: options.now ?? Date.now,
+    };
+}
+/** 一个问题 + 正文的迷你 TUI；`finish(answer)` 把界面收成一行「标题 → 答案」后交还终端。 */
+function miniTui(r, prompt) {
+    const tui = new TUI(r.terminal(), { anchorToTop: false });
+    const body = new Container();
+    body.addChild(new Text(r.theme.fg("accent", "? ") + r.theme.bold(prompt.title)));
+    for (const line of prompt.lines ?? [])
+        body.addChild(new Text(r.theme.fg("dim", line)));
+    tui.addChild(body);
+    const finish = (answer) => {
+        tui.clear();
+        tui.addChild(new Text(r.theme.fg("accent", "? ") + r.theme.bold(prompt.title) + " " + r.theme.fg("dim", answer)));
+        tui.renderNow();
+        tui.stop();
+    };
+    return { tui, body, finish };
+}
+/** 选择题：返回选中项，Esc / Ctrl+C 返回 undefined。 */
+function askSelect(r, prompt) {
+    return new Promise((done) => {
+        const { tui, body, finish } = miniTui(r, prompt);
+        const list = new SelectList(prompt.items, {
+            theme: r.theme,
+            keybindings: r.keys,
+            maxVisible: 10,
+            filterable: prompt.filterable === true,
+            onSelect: (item) => {
+                finish(item.label);
+                done(item);
+            },
+            onCancel: () => {
+                finish("（已取消）");
+                done(undefined);
+            },
+        });
+        if (prompt.selected !== undefined)
+            list.selectValue(prompt.selected);
+        body.addChild(list);
+        body.addChild(new Text(r.theme.fg("dim", prompt.filterable === true
+            ? "输入过滤 · ↑↓ 选择 · Enter 确认 · Esc 取消"
+            : "↑↓ 选择 · Enter 确认 · Esc 取消")));
+        tui.start();
+        tui.setFocus(list);
+    });
+}
+/** 填空题：`validate` 返回错误文本时留在原地重输；Esc / Ctrl+C 返回 undefined。 */
+function askText(r, prompt) {
+    return new Promise((done) => {
+        const { tui, body, finish } = miniTui(r, prompt);
+        const error = new Text("");
+        const editor = new Editor({
+            theme: r.theme,
+            keybindings: r.keys,
+            maxVisibleLines: 3,
+            requestRender: () => tui.requestRender(),
+            ...(prompt.placeholder !== undefined ? { placeholder: prompt.placeholder } : {}),
+            onSubmit: (text) => {
+                const value = text.trim();
+                const problem = prompt.validate?.(value);
+                if (problem !== undefined) {
+                    error.setText(r.theme.fg("error", problem));
+                    editor.setText(value);
+                    return;
+                }
+                finish(value);
+                done(value);
+            },
+        });
+        body.addChild(editor);
+        body.addChild(error);
+        tui.addInputListener((data) => {
+            if (r.keys.matches(data, "tui.select.cancel") && !editor.isCompletionOpen) {
+                finish("（已取消）");
+                done(undefined);
+                return true;
+            }
+            return false;
+        });
+        tui.start();
+        tui.setFocus(editor);
+    });
+}
+// ---------------------------------------------------------------------------
+// 列表项（选择器共用）
+// ---------------------------------------------------------------------------
+/** 选择器里模型的说明：名称（与 id 不同时）、上下文、`img`（收图片）。 */
+export function modelDescription(model) {
+    const ctx = model.contextWindow;
+    const parts = [
+        model.name !== "" && model.name !== model.id ? model.name : undefined,
+        ctx === undefined
+            ? undefined
+            : ctx >= 1_000_000
+                ? `${Math.round(ctx / 100_000) / 10}M`
+                : `${Math.round(ctx / 1000)}k`,
+        model.input.includes("image") ? "img" : undefined,
+    ].filter((x) => x !== undefined);
+    return parts.length > 0 ? parts.join(" · ") : undefined;
+}
+/**
+ * 模型按「供应商 · 渠道」分组；有 key（或本地）的供应商排前，组标题标 key 状态。多渠道供应商的模型在
+ * 每个挂载的渠道下各出现一次，非首选渠道的值带 `@渠道`。
+ */
+export async function modelItems(providers) {
+    const groups = [];
+    for (const provider of providers.list()) {
+        if (provider.models.length === 0)
+            continue;
+        let status;
+        let ready = true;
+        if (!provider.requiresApiKey)
+            status = "本地";
+        else {
+            const key = await providers.resolveApiKey(provider.id).catch(() => ({ apiKey: undefined }));
+            ready = key.apiKey !== undefined;
+            status = ready ? "key ✓" : "无 key";
+        }
+        const item = (model, group, channel) => {
+            const suffix = channel !== undefined && channel !== model.channel ? `@${channel}` : "";
+            const out = {
+                value: `${provider.id}/${model.id}${suffix}`,
+                label: `${model.id}${suffix}`,
+                group,
+            };
+            const description = modelDescription(model);
+            if (description !== undefined)
+                out.description = description;
+            return out;
+        };
+        if (provider.channels === undefined) {
+            const group = `${provider.id} · ${status}`;
+            groups.push({ ready, items: provider.models.map((model) => item(model, group)) });
+            continue;
+        }
+        for (const channel of provider.channels) {
+            const group = `${provider.id} · ${channel.name} · ${status}`;
+            const models = provider.models.filter((m) => m.channels?.includes(channel.name));
+            if (models.length > 0)
+                groups.push({ ready, items: models.map((model) => item(model, group, channel.name)) });
+        }
+    }
+    return [...groups.filter((g) => g.ready), ...groups.filter((g) => !g.ready)].flatMap((g) => g.items);
+}
+/** `刚刚 / 5 分钟前 / 3 小时前 / 2 天前 / 2026-09-01`。 */
+export function relativeTime(iso, now) {
+    const at = Date.parse(iso);
+    if (!Number.isFinite(at))
+        return "";
+    const minutes = Math.floor((now - at) / 60_000);
+    if (minutes < 1)
+        return "刚刚";
+    if (minutes < 60)
+        return `${minutes} 分钟前`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours} 小时前`;
+    const days = Math.floor(hours / 24);
+    if (days < 30)
+        return `${days} 天前`;
+    return iso.slice(0, 10);
+}
+function oneLine(text, max = 60) {
+    const flat = text.replace(/\s+/g, " ").trim();
+    return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
+}
+/** 会话：标签 = 名字或首条提示，描述 = 相对时间 · 消息数。 */
+export function sessionItems(items, now) {
+    return [...items]
+        .sort((a, b) => b.modifiedAt.localeCompare(a.modifiedAt))
+        .map((item) => ({
+        value: item.id,
+        label: oneLine(item.name ?? item.firstPrompt ?? item.id.slice(0, 8)),
+        description: `${relativeTime(item.modifiedAt, now)} · ${item.messageCount} 条`,
+    }));
+}
+// ---------------------------------------------------------------------------
+// InteractiveUi
+// ---------------------------------------------------------------------------
+const TRUST_CHOICES = [
+    { value: "trust", label: "信任并记住", answer: { trusted: true, remember: true } },
+    { value: "once", label: "仅本次信任", answer: { trusted: true, remember: false } },
+    { value: "skip", label: "本次不信任", answer: { trusted: false, remember: false } },
+    { value: "never", label: "不信任并记住", answer: { trusted: false, remember: true } },
+];
+function isDirectory(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export function createStartupUi(options = {}) {
+    const r = resolveOptions(options);
+    return {
+        async promptTrust(cwd, resources) {
+            const shown = resources.slice(0, 6).map((p) => `  ${p}`);
+            if (resources.length > shown.length)
+                shown.push(`  …另有 ${resources.length - shown.length} 项`);
+            const picked = await askSelect(r, {
+                title: "信任这个目录的项目资源？",
+                lines: [cwd, ...shown],
+                items: TRUST_CHOICES.map(({ value, label }) => ({ value, label })),
+                selected: "once",
+            });
+            const choice = TRUST_CHOICES.find((c) => c.value === picked?.value);
+            return choice?.answer ?? { trusted: false, remember: false };
+        },
+        async pickSession(items) {
+            if (items.length === 0)
+                return undefined;
+            const picked = await askSelect(r, {
+                title: "恢复哪个会话？",
+                items: sessionItems(items, r.now()),
+                filterable: true,
+            });
+            return picked?.value;
+        },
+        async pickModel(providers, reason) {
+            const items = await modelItems(providers);
+            if (items.length === 0)
+                return undefined;
+            const picked = await askSelect(r, {
+                title: "选择模型",
+                lines: [reason],
+                items,
+                filterable: true,
+            });
+            return picked?.value;
+        },
+        askCwd(missing) {
+            return askText(r, {
+                title: "会话的工作目录不存在",
+                lines: [missing, "输入替代目录（Enter 确认 · Esc 取消）"],
+                placeholder: "目录路径",
+                validate: (text) => {
+                    if (text === "")
+                        return "请输入目录";
+                    const abs = resolve(text);
+                    if (!existsSync(abs))
+                        return `不存在：${abs}`;
+                    if (!isDirectory(abs))
+                        return `不是目录：${abs}`;
+                    return undefined;
+                },
+            });
+        },
+    };
+}

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

@@ -0,0 +1,48 @@
+/**
+ * 状态栏（设计 §12.6）：编辑器下方一行。[B7]
+ *
+ * `provider/model · think:medium · ↑12.3k ↓1.2k · cache 80% ♨ · $0.12 · rebill $0.11 · ctx 34%
+ *  · queue 1 · mode:default · codemode:only net! · preset:default · [宿主状态]`
+ *
+ * - 用量来自 `session.getStats()`（`↑` = 输入含缓存读写，`↓` = 输出），只在 `refresh()` 时读取
+ *   （事件驱动），渲染只拼字符串；
+ * - [W3-C2] `cache` 是**最近一次**请求的命中率（会话累计在 `/session`）；端点三态：`unknown` →
+ *   `cache —`，`silent` → `cache 未报告`；保温计时中追加 `♨`；会话有重计费时显示 `rebill $x`
+ *   （无价模型显示重计费 token）；会话层缓存未接线时回落到会话命中率 `cacheHitRate`；
+ * - `ctx ?` 表示模型没有上下文窗口；≥ 70% 黄、≥ 90% 红；没有用量时不显示 token / cache / 费用；
+ * - [W3-C2 A4] codemode 生效时显示 `codemode:on|only`，运行时 Node 的权限模型不隔离网络
+ *   （`detectSandboxCapability().strict` 为 false）时追加红色 `net!`；
+ * - 宿主状态读 `HostAdapterHandle.status()`（宿主 `ui.setStatus`），每次渲染现取；
+ * - 宽度不够时按优先级丢弃（宿主 → 预设 → rebill → 费用 → cache → token → think → 队列 →
+ *   codemode），模型、ctx、权限模式最后丢。
+ */
+import type { AgentSession, SessionCacheStats } from "../../agent/types.js";
+import { type Component, type Theme } from "../../tui.js";
+export interface StatusBarSource {
+    session(): AgentSession;
+    /** 工具预设名（`config.tools.preset`）。 */
+    preset(): string;
+    /** 宿主 `ui.setStatus` 的当前值；无宿主为 undefined。 */
+    hostStatus?(): ReadonlyMap<string, string> | undefined;
+    /** 生效的 codemode 方式（codemode 工具活动时）；off / 未注册为 undefined。 */
+    codemode?(): "on" | "only" | undefined;
+    /** 沙箱是否隔离网络（缺省 true，不标 `net!`）。 */
+    sandboxStrict?(): boolean;
+}
+export declare function formatTokens(count: number): string;
+export declare function formatCost(cost: number): string;
+/** `cache 83%` / `cache —` / `cache 未报告`，保温计时中追加 ` ♨`。 */
+export declare function cacheText(cache: SessionCacheStats): string;
+export declare class StatusBar implements Component {
+    private readonly source;
+    private readonly theme;
+    private stats;
+    private queue;
+    constructor(source: StatusBarSource, theme: Theme);
+    /** 用量、模型等变化后调用（事件驱动；流式期间不必每帧算）。 */
+    refresh(): void;
+    setQueue(steering: number, followUp: number): void;
+    private parts;
+    render(width: number): string[];
+    invalidate(): void;
+}

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

@@ -0,0 +1,139 @@
+/**
+ * 状态栏（设计 §12.6）：编辑器下方一行。[B7]
+ *
+ * `provider/model · think:medium · ↑12.3k ↓1.2k · cache 80% ♨ · $0.12 · rebill $0.11 · ctx 34%
+ *  · queue 1 · mode:default · codemode:only net! · preset:default · [宿主状态]`
+ *
+ * - 用量来自 `session.getStats()`（`↑` = 输入含缓存读写，`↓` = 输出），只在 `refresh()` 时读取
+ *   （事件驱动），渲染只拼字符串；
+ * - [W3-C2] `cache` 是**最近一次**请求的命中率（会话累计在 `/session`）；端点三态：`unknown` →
+ *   `cache —`，`silent` → `cache 未报告`；保温计时中追加 `♨`；会话有重计费时显示 `rebill $x`
+ *   （无价模型显示重计费 token）；会话层缓存未接线时回落到会话命中率 `cacheHitRate`；
+ * - `ctx ?` 表示模型没有上下文窗口；≥ 70% 黄、≥ 90% 红；没有用量时不显示 token / cache / 费用；
+ * - [W3-C2 A4] codemode 生效时显示 `codemode:on|only`，运行时 Node 的权限模型不隔离网络
+ *   （`detectSandboxCapability().strict` 为 false）时追加红色 `net!`；
+ * - 宿主状态读 `HostAdapterHandle.status()`（宿主 `ui.setStatus`），每次渲染现取；
+ * - 宽度不够时按优先级丢弃（宿主 → 预设 → rebill → 费用 → cache → token → think → 队列 →
+ *   codemode），模型、ctx、权限模式最后丢。
+ */
+import { truncateToWidth, visibleWidth } from "../../tui.js";
+export function formatTokens(count) {
+    if (count < 1000)
+        return String(count);
+    if (count < 10_000)
+        return `${(count / 1000).toFixed(1)}k`;
+    if (count < 1_000_000)
+        return `${Math.round(count / 1000)}k`;
+    return `${(count / 1_000_000).toFixed(1)}M`;
+}
+export function formatCost(cost) {
+    if (cost >= 0.01)
+        return `$${cost.toFixed(2)}`;
+    return `$${cost.toFixed(3)}`;
+}
+/** `cache 83%` / `cache —` / `cache 未报告`，保温计时中追加 ` ♨`。 */
+export function cacheText(cache) {
+    const rate = cache.lastHitRate ?? cache.hitRate;
+    const value = cache.reporting === "silent"
+        ? "未报告"
+        : cache.reporting === "reported" && rate !== undefined
+            ? `${Math.round(rate * 100)}%`
+            : "—";
+    return `cache ${value}${cache.warming.state === "scheduled" ? " ♨" : ""}`;
+}
+export class StatusBar {
+    source;
+    theme;
+    stats;
+    queue = 0;
+    constructor(source, theme) {
+        this.source = source;
+        this.theme = theme;
+    }
+    /** 用量、模型等变化后调用（事件驱动；流式期间不必每帧算）。 */
+    refresh() {
+        this.stats = this.source.session().getStats();
+    }
+    setQueue(steering, followUp) {
+        this.queue = steering + followUp;
+    }
+    parts() {
+        const theme = this.theme;
+        const session = this.source.session();
+        const state = session.state;
+        const stats = this.stats ?? session.getStats();
+        this.stats = stats;
+        const parts = [];
+        const model = state.model === undefined ? "?" : `${state.model.provider}/${state.model.id}`;
+        parts.push({ text: theme.fg("accent", model), priority: 0 });
+        parts.push({ text: `think:${state.thinkingLevel}`, priority: 5 });
+        const t = stats.tokens;
+        const prompt = t.input + t.cacheRead + t.cacheWrite;
+        if (prompt + t.output > 0) {
+            parts.push({ text: `↑${formatTokens(prompt)} ↓${formatTokens(t.output)}`, priority: 6 });
+            const cache = stats.cache;
+            if (cache !== undefined)
+                parts.push({ text: cacheText(cache), priority: 7 });
+            else if (stats.cacheHitRate !== undefined) {
+                parts.push({ text: `cache ${Math.round(stats.cacheHitRate * 100)}%`, priority: 7 });
+            }
+            if (stats.cost === undefined)
+                parts.push({ text: "$?", priority: 8 });
+            else if (stats.cost > 0)
+                parts.push({ text: formatCost(stats.cost), priority: 8 });
+            if (cache !== undefined && cache.reBilledTokens > 0) {
+                const amount = cache.reBilledUsd === undefined
+                    ? `${formatTokens(cache.reBilledTokens)} tok`
+                    : formatCost(cache.reBilledUsd);
+                parts.push({ text: theme.fg("warning", `rebill ${amount}`), priority: 9 });
+            }
+        }
+        const ctx = stats.contextPercent;
+        const ctxText = ctx === undefined ? "ctx ?" : `ctx ${Math.round(ctx)}%`;
+        parts.push({
+            text: ctx !== undefined && ctx >= 90
+                ? theme.fg("error", ctxText)
+                : ctx !== undefined && ctx >= 70
+                    ? theme.fg("warning", ctxText)
+                    : ctxText,
+            priority: 1,
+        });
+        if (this.queue > 0)
+            parts.push({ text: theme.fg("warning", `queue ${this.queue}`), priority: 4 });
+        const mode = `mode:${state.permissionMode}`;
+        parts.push({
+            text: state.permissionMode === "full-auto" ? theme.fg("warning", mode) : mode,
+            priority: 2,
+        });
+        const codemode = this.source.codemode?.();
+        if (codemode !== undefined) {
+            const strict = this.source.sandboxStrict?.() ?? true;
+            parts.push({
+                text: `codemode:${codemode}${strict ? "" : ` ${theme.fg("error", "net!")}`}`,
+                priority: 3,
+            });
+        }
+        parts.push({ text: `preset:${this.source.preset()}`, priority: 10 });
+        const host = this.source.hostStatus?.();
+        if (host !== undefined && host.size > 0) {
+            const values = [...host.values()].filter((v) => v.trim() !== "");
+            if (values.length > 0)
+                parts.push({ text: `[${values.join(" · ")}]`, priority: 11 });
+        }
+        return parts;
+    }
+    render(width) {
+        const parts = this.parts();
+        const sep = this.theme.fg("dim", " · ");
+        const join = (list) => list.map((p) => p.text).join(sep);
+        let kept = parts;
+        while (kept.length > 1 && visibleWidth(join(kept)) > width) {
+            const drop = kept.reduce((worst, p) => (p.priority > worst.priority ? p : worst));
+            kept = kept.filter((p) => p !== drop);
+        }
+        return [truncateToWidth(join(kept), width)];
+    }
+    invalidate() {
+        this.stats = undefined;
+    }
+}