@armadra/agent 0.5.1 → 0.6.1

package/dist/agent/session-plan.js

@@ -25,6 +25,7 @@ import { PLAN_APPROVED_PROMPT, PLAN_APPROVED_TYPE, PLAN_MODE_BRIEF, PLAN_MODE_EX
 import { PLAN_CUSTOM_TYPE, PLAN_STATE_CUSTOM_TYPE, currentTodos, executionMode, latestPlan, latestPlanState, maxPlanVersion, resolvePlanDirectory, writePlanFile, } from "../plan/store.js";
 import { APPROVE_REPLY, PLAN_NOTICE_TYPE, registerPlanController, } from "../plan/controller.js";
 import { TODO_CUSTOM_TYPE } from "../tools/todo.js";
+import { msg } from "../i18n/index.js";
 export function createPlanExtensionFactory(options) {
     return ({ core }) => (core.depth > 0 ? undefined : new PlanExtension(core, options));
 }
@@ -330,8 +331,7 @@ class PlanExtension {
     }
     noticeText(plan) {
         const target = permissionModeLabel(executionMode(undefined, this.pre));
-        const where = plan.filePath === undefined ? "" : `（${plan.filePath}）`;
-        return `计划 v${plan.version} 待审批${where}：回复 1 批准并执行（${target}）· 2 以 Accept edits 执行 · 3 以 Auto 执行；回复其它内容作为修改意见，留在 Plan 模式。`;
+        return msg().session.plan.pendingNotice(plan.version, plan.filePath, target);
     }
     // -------------------------------------------------------------------------
     // 审批与交接

package/dist/agent/session-state.d.ts

@@ -11,6 +11,7 @@ import type { SessionManager } from "../session/manager.js";
 import type { SessionEntry } from "../session/types.js";
 import type { Agent } from "./agent.js";
 import type { SessionCacheStats, SessionState, SessionStats } from "./types.js";
+import type { QuotaUpdateEvent } from "./types-w6.js";
 export interface StateInput {
     agent: Agent;
     manager: SessionManager;
@@ -31,6 +32,8 @@ export interface StatsInput {
     contextWindow: number | undefined;
     /** [W3-C1b] 会话层缓存控制器的统计（未接线时缺省）。 */
     cache?: SessionCacheStats;
+    /** [W6-O] 最近一次 `quota_update`。 */
+    quota?: QuotaUpdateEvent | undefined;
 }
 export declare function computeStats(input: StatsInput): SessionStats;
 /** 缓存命中率 = cacheRead /（input + cacheRead + cacheWrite）；分母为 0 → undefined（设计 §9.1）。 */

package/dist/agent/session-state.js

@@ -37,8 +37,21 @@ function addUsage(totals, usage) {
             ? usage.totalTokens
             : usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
 }
+/** [W6-O] 订阅计费（`billing: "subscription"`）的请求单列，不折算美元。 */
+function addSubscription(stats, provider, usage) {
+    if (usage.billing !== "subscription")
+        return;
+    const sub = (stats.subscription ??= { requests: 0, byProvider: {} });
+    sub.requests++;
+    const row = (sub.byProvider[provider] ??= { requests: 0, input: 0, output: 0, cacheRead: 0 });
+    row.requests++;
+    row.input += usage.input;
+    row.output += usage.output;
+    row.cacheRead += usage.cacheRead;
+}
 export function computeStats(input) {
     const tokens = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 };
+    const sub = {};
     let userMessages = 0;
     let assistantMessages = 0;
     let toolCalls = 0;
@@ -61,11 +74,13 @@ export function computeStats(input) {
                 toolCalls += message.content.filter((block) => block.type === "toolCall").length;
                 addUsage(tokens, message.usage);
                 addCost(message.usage);
+                addSubscription(sub, message.provider, message.usage);
             }
         }
         else if (entry.type === "usage") {
             addUsage(tokens, entry.usage);
             addCost(entry.usage);
+            addSubscription(sub, entry.provider, entry.usage);
         }
         else if ((entry.type === "compaction" || entry.type === "branch_summary") && entry.usage) {
             addUsage(tokens, entry.usage);
@@ -95,6 +110,11 @@ export function computeStats(input) {
         stats.cacheHitRate = rate;
     if (input.cache !== undefined)
         stats.cache = input.cache;
+    if (sub.subscription !== undefined) {
+        stats.subscription = sub.subscription;
+        if (input.quota !== undefined)
+            stats.subscription.quota = input.quota;
+    }
     return stats;
 }
 /** 缓存命中率 = cacheRead /（input + cacheRead + cacheWrite）；分母为 0 → undefined（设计 §9.1）。 */

package/dist/agent/session-subagent.d.ts

@@ -14,11 +14,14 @@
  * - 轮数耗尽且最后停在工具结果上：以 `toolChoice:"none"` 再跑一轮要最终报告，状态 `max_turns`。
  * - broker 包一层，请求带 `context{depth, parentToolCallId, taskId}`，审批事件转发到父会话；
  *   [RW-B] 父的检查点钩子（worktree 里运行时不记）；[W3-C1b] 子会话命中与重计费汇总进父。
+ * - [W6-A] 句柄外露 `observe` / `entries`（子 Agent 视图跟随）与 `message`（视图里直接发的消息，
+ *   `origin: "direct"`：运行中 followUp，空闲开新一轮）；一轮收尾时才入队、没赶上的 followUp 接着再跑一轮。
  */
 import type { CheckpointHooks } from "../checkpoints/types.js";
 import type { PermissionPipelineApi } from "../permissions/types.js";
 import { SessionManager } from "../session/manager.js";
 import type { AgentMessage } from "../session/types.js";
+import type { MessageOrigin } from "../ai/types.js";
 import type { SubagentRequest, SubagentResult, SubagentRunner } from "../tools/types.js";
 import type { AgentSessionOptions } from "./session-core.js";
 import { DEFAULT_SUBAGENT_CONCURRENCY, SubagentPool, TASK_CUSTOM_TYPE, type AmaRunnerSpec, type RegistryHost } from "./subagent-registry.js";
@@ -49,7 +52,18 @@ export interface SubagentParent extends RegistryHost {
 export interface ChildSession {
     readonly manager: SessionManager;
     readonly messages: readonly AgentMessage[];
-    prompt(text: string): Promise<unknown>;
+    prompt(text: string, options?: {
+        origin?: MessageOrigin;
+    }): Promise<unknown>;
+    /** [W6-A] 视图里直接发的消息（运行中排到回合结束）。 */
+    followUp?(text: string, options?: {
+        origin?: MessageOrigin;
+    }): Promise<unknown>;
+    /** [W6-A] 取出排队消息（一轮收尾时才入队、没被消费的）。 */
+    clearQueue?(): {
+        steering: string[];
+        followUp: string[];
+    };
     abort(): Promise<void>;
     subscribe(listener: (event: SessionEvent) => void): () => void;
     getStats(): SessionStats;

package/dist/agent/session-subagent.js

@@ -14,6 +14,8 @@
  * - 轮数耗尽且最后停在工具结果上：以 `toolChoice:"none"` 再跑一轮要最终报告，状态 `max_turns`。
  * - broker 包一层，请求带 `context{depth, parentToolCallId, taskId}`，审批事件转发到父会话；
  *   [RW-B] 父的检查点钩子（worktree 里运行时不记）；[W3-C1b] 子会话命中与重计费汇总进父。
+ * - [W6-A] 句柄外露 `observe` / `entries`（子 Agent 视图跟随）与 `message`（视图里直接发的消息，
+ *   `origin: "direct"`：运行中 followUp，空闲开新一轮）；一轮收尾时才入队、没赶上的 followUp 接着再跑一轮。
  */
 import { AmaError } from "../errors.js";
 import { PermissionPipeline } from "../permissions/pipeline.js";
@@ -183,17 +185,27 @@ async function startAmaChild(parent, spec, createChild, run) {
     const onAbort = () => void child.abort();
     run.signal.addEventListener("abort", onAbort, { once: true });
     let billed = { cacheRead: 0, prompt: 0, reBilled: 0 };
-    const runOnce = async (prompt) => {
+    let active = false;
+    const runOnce = async (prompt, origin) => {
         const startTurns = turns;
         let error;
+        active = true;
         try {
             if (run.signal.aborted)
                 throw new AmaError("aborted", "aborted");
-            await child.prompt(prompt);
+            await child.prompt(prompt, origin === undefined ? {} : { origin });
+            // [W6-A] 收尾阶段才入队的 followUp（只可能来自视图）留在队列里：接着再跑一轮
+            for (;;) {
+                const left = child.clearQueue?.().followUp ?? [];
+                if (left.length === 0 || run.signal.aborted)
+                    break;
+                await child.prompt(left.join("\n\n"), { origin: "direct" });
+            }
         }
         catch (caught) {
             error = caught instanceof Error ? caught.message : String(caught);
         }
+        active = false;
         const exhausted = error === undefined && !run.signal.aborted && turns - startTurns >= maxTurns && toolUse;
         if (exhausted) {
             finalRound = true;
@@ -216,7 +228,7 @@ async function startAmaChild(parent, spec, createChild, run) {
             result.sessionFile = file;
         return result;
     };
-    let current = runOnce(run.prompt);
+    let current = runOnce(run.prompt, spec.origin);
     const handle = {
         id: manager.id,
         model: `${model.provider}/${model.id}`,
@@ -224,6 +236,17 @@ async function startAmaChild(parent, spec, createChild, run) {
         send: async (text) => {
             current = runOnce(text);
         },
+        observe: (listener) => child.subscribe(listener),
+        entries: () => child.manager.branch(),
+        message: async (text, when) => {
+            if (when === "send") {
+                current = runOnce(text, "direct");
+                return;
+            }
+            if (!active || child.followUp === undefined)
+                throw new AmaError("task_idle", "the sub-agent is not running");
+            await child.followUp(text, { origin: "direct" });
+        },
         wait: () => current,
         stop: () => child.abort(),
         dispose: async () => {

package/dist/agent/session-telemetry.d.ts

@@ -12,12 +12,17 @@
  *   只由增量驱动、不起计时器）；
  *   `ticks: false`（`ui.animation: false`）时不发，界面在 message_end 时刷新。
  *
+ * [W6-C0] 拆成「测量」与「发 tick」：子会话（depth > 0）也装、只测量不发 tick；每个请求结束时通知
+ * `onRequestEnd` 的订阅者（`session-trace-writer.ts` 据此写 `ama.trace step`）；`telemetryOf(core)` 取本会话实例。
+ *
  * 数据从 `getStats().telemetry` 取（`contributeStats`）：进行中的请求出了首 token 后 `last` 即指向它（只有
  * `requestAt / firstTokenAt / ttftMs`），结束后补齐 `doneAt / outputTokens / tps`；`sessionStartedAt` 是扩展创建（本进程打开会话）的时刻。
  */
+import type { AssistantMessage } from "../ai/types.js";
+import type { SessionCore } from "./session-core.js";
 import type { SessionExtension, SessionExtensionFactory } from "./session-extensions.js";
 import type { SessionEvent } from "./types.js";
-import type { SessionTelemetry } from "./types-w5.js";
+import type { RequestTelemetry, SessionTelemetry } from "./types-w5.js";
 export declare const TELEMETRY_TICK_MS = 500;
 export declare const TELEMETRY_WINDOW_MS = 2000;
 export interface TelemetryDeps {
@@ -27,13 +32,22 @@ export interface TelemetryDeps {
     /** false：不发 tick（`ui.animation: false`）。缺省 true。 */
     ticks?: boolean;
 }
+/** 一个 turn 请求结束（成功、失败或被中断）时的记录。 */
+export type RequestEndListener = (record: RequestTelemetry, message: AssistantMessage | undefined) => void;
 export type TelemetryExtension = SessionExtension & {
     snapshot(): SessionTelemetry;
+    /** [W6-C0] 订阅请求结束；返回取消函数。 */
+    onRequestEnd(listener: RequestEndListener): () => void;
 };
+/** [W6-C0] 本会话的遥测扩展（组装表装了才有）。 */
+export declare function telemetryOf(core: SessionCore): TelemetryExtension | undefined;
 /** 一段增量文本的 token 估算（不取整，逐块累加不放大）。 */
 export declare function deltaTokens(text: string): number;
 export declare function createTelemetryExtension(deps?: TelemetryDeps): TelemetryExtension;
-/** 组装表用的工厂：只装主会话（depth 0）；`ui.animation: false` 不发 tick。 */
+/**
+ * 组装表用的工厂：主会话测量并发 tick（`ui.animation: false` 不发）；[W6-C0] 子会话（depth > 0）也装，
+ * 只测量（供 `ama.trace` 与子 Agent 视图），不发 tick。
+ */
 export declare function telemetryFactory(ui?: {
     animation?: boolean;
 }): SessionExtensionFactory;

package/dist/agent/session-telemetry.js

@@ -12,6 +12,9 @@
  *   只由增量驱动、不起计时器）；
  *   `ticks: false`（`ui.animation: false`）时不发，界面在 message_end 时刷新。
  *
+ * [W6-C0] 拆成「测量」与「发 tick」：子会话（depth > 0）也装、只测量不发 tick；每个请求结束时通知
+ * `onRequestEnd` 的订阅者（`session-trace-writer.ts` 据此写 `ama.trace step`）；`telemetryOf(core)` 取本会话实例。
+ *
  * 数据从 `getStats().telemetry` 取（`contributeStats`）：进行中的请求出了首 token 后 `last` 即指向它（只有
  * `requestAt / firstTokenAt / ttftMs`），结束后补齐 `doneAt / outputTokens / tps`；`sessionStartedAt` 是扩展创建（本进程打开会话）的时刻。
  */
@@ -19,6 +22,11 @@ export const TELEMETRY_TICK_MS = 500;
 export const TELEMETRY_WINDOW_MS = 2000;
 /** 不足这么长（自首 token 起）不算速率：开头几块或整块到达的回复会把速率放大到无意义。 */
 const MIN_SPAN_MS = 250;
+const byCore = new WeakMap();
+/** [W6-C0] 本会话的遥测扩展（组装表装了才有）。 */
+export function telemetryOf(core) {
+    return byCore.get(core);
+}
 /** 一段增量文本的 token 估算（不取整，逐块累加不放大）。 */
 export function deltaTokens(text) {
     let wide = 0;
@@ -122,6 +130,7 @@ export function createTelemetryExtension(deps = {}) {
     let sumOutput = 0;
     let sumMs = 0;
     let lastTickAt = Number.NEGATIVE_INFINITY;
+    const listeners = new Set();
     const finish = (tracker, message) => {
         if (tracker.finished)
             return;
@@ -130,6 +139,8 @@ export function createTelemetryExtension(deps = {}) {
             current = undefined;
         const r = tracker.record;
         last = { ...r };
+        for (const listener of listeners)
+            listener({ ...r }, message);
         const failed = message === undefined || message.stopReason === "error";
         if (!failed && r.firstTokenAt !== undefined && r.doneAt !== undefined) {
             const ms = r.doneAt - r.firstTokenAt;
@@ -218,14 +229,25 @@ export function createTelemetryExtension(deps = {}) {
             stats.telemetry = snapshot();
         },
         snapshot,
+        onRequestEnd(listener) {
+            listeners.add(listener);
+            return () => void listeners.delete(listener);
+        },
     };
 }
-/** 组装表用的工厂：只装主会话（depth 0）；`ui.animation: false` 不发 tick。 */
+/**
+ * 组装表用的工厂：主会话测量并发 tick（`ui.animation: false` 不发）；[W6-C0] 子会话（depth > 0）也装，
+ * 只测量（供 `ama.trace` 与子 Agent 视图），不发 tick。
+ */
 export function telemetryFactory(ui) {
-    return ({ core }) => core.depth > 0
-        ? undefined
-        : createTelemetryExtension({
-            emit: (event) => core.emit(event),
-            ticks: ui?.animation !== false,
-        });
+    return ({ core }) => {
+        const extension = core.depth > 0
+            ? createTelemetryExtension({ ticks: false })
+            : createTelemetryExtension({
+                emit: (event) => core.emit(event),
+                ticks: ui?.animation !== false,
+            });
+        byCore.set(core, extension);
+        return extension;
+    };
 }

package/dist/agent/session-tools.js

@@ -41,7 +41,8 @@ function requestContext(core, request) {
             taskId = data.taskId;
     }
     const origin = source?.origin;
-    if (depth === 0 && taskId === undefined && origin === undefined)
+    const toolCallId = source?.toolCallId;
+    if (depth === 0 && taskId === undefined && origin === undefined && toolCallId === undefined)
         return undefined;
     const context = {};
     if (depth > 0)
@@ -50,6 +51,8 @@ function requestContext(core, request) {
         context.taskId = taskId;
     if (origin !== undefined)
         context.origin = origin;
+    if (toolCallId !== undefined)
+        context.toolCallId = toolCallId;
     return context;
 }
 /** 审批链：依次问每个 broker，第一个给出决定的为准；全部弃权 → deny。 */
@@ -199,7 +202,7 @@ export async function gateToolCall(core, call, ctx) {
             toolName: call.name,
             input,
             reason: approvalReason,
-            context: { depth: core.depth, readFiles: core.readFiles },
+            context: { depth: core.depth, readFiles: core.readFiles, toolCallId: call.id },
         };
         if (hookReason !== undefined)
             request.hookReason = hookReason;

package/dist/agent/session-trace-writer.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 轨迹写入（docs/wave6-plan.md §2.2、D5）。[W6-C0]
+ *
+ * 会话扩展：订阅事件，把计时写成 `custom{customType:"ama.trace"}` 条目（`trace/types.ts` 的 `TraceEntryData`）。
+ * - `step`：每个 turn 请求一条（成功、失败、被重试掉的都写），在 `turn_end` 时写——此时 assistant 与该批
+ *   toolResult 都已落盘，所以条目在 toolResult 之后（无工具时紧跟 assistant）。请求计时来自遥测扩展
+ *   （`telemetryOf(core).onRequestEnd`），工具起止来自 `tool_execution_start / end`，审批等待来自带
+ *   `context.toolCallId` 的 `permission_request` → `permission_resolved`；中断而没有 `turn_end` 时由
+ *   `agent_end` 兜底写一条 `status: "aborted"`。
+ * - `retry_wait`（`auto_retry_start`）、`fallback`（`model_fallback`）、`compaction`（`compaction_start / end`）、
+ *   `aux`（`usage` 条目：保温 / 分类器请求）、`external_turn`（外部 Agent 回合骨架，由任务注册表经
+ *   `appendTraceEntry` 写，见 `agents/task-record.ts`）。
+ *
+ * 约束：只追加、不改已落条目；`custom` 不进上下文（投影跳过），所以请求字节与缓存前缀不变；只记 id、
+ * 时间与计数，**不记正文**（提示、参数、结果、外部工具标题）。depth > 0 的子会话也装（只落盘，不发事件）。
+ */
+import { type TraceEntryData } from "../trace/types.js";
+import type { SessionCore } from "./session-core.js";
+import type { SessionExtension, SessionExtensionFactory } from "./session-extensions.js";
+export interface TraceWriterDeps {
+    now?(): number;
+}
+/** 追加一条 `ama.trace`（不发 `entry_appended` 以外的事件）。 */
+export declare function appendTraceEntry(core: Pick<SessionCore, "appendEntry">, data: TraceEntryData): void;
+export declare function createTraceWriter(core: SessionCore, deps?: TraceWriterDeps): SessionExtension;
+/** 组装表用的工厂：主会话与子会话都装。 */
+export declare function traceWriterFactory(deps?: TraceWriterDeps): SessionExtensionFactory;

package/dist/agent/session-trace-writer.js

@@ -0,0 +1,253 @@
+/**
+ * 轨迹写入（docs/wave6-plan.md §2.2、D5）。[W6-C0]
+ *
+ * 会话扩展：订阅事件，把计时写成 `custom{customType:"ama.trace"}` 条目（`trace/types.ts` 的 `TraceEntryData`）。
+ * - `step`：每个 turn 请求一条（成功、失败、被重试掉的都写），在 `turn_end` 时写——此时 assistant 与该批
+ *   toolResult 都已落盘，所以条目在 toolResult 之后（无工具时紧跟 assistant）。请求计时来自遥测扩展
+ *   （`telemetryOf(core).onRequestEnd`），工具起止来自 `tool_execution_start / end`，审批等待来自带
+ *   `context.toolCallId` 的 `permission_request` → `permission_resolved`；中断而没有 `turn_end` 时由
+ *   `agent_end` 兜底写一条 `status: "aborted"`。
+ * - `retry_wait`（`auto_retry_start`）、`fallback`（`model_fallback`）、`compaction`（`compaction_start / end`）、
+ *   `aux`（`usage` 条目：保温 / 分类器请求）、`external_turn`（外部 Agent 回合骨架，由任务注册表经
+ *   `appendTraceEntry` 写，见 `agents/task-record.ts`）。
+ *
+ * 约束：只追加、不改已落条目；`custom` 不进上下文（投影跳过），所以请求字节与缓存前缀不变；只记 id、
+ * 时间与计数，**不记正文**（提示、参数、结果、外部工具标题）。depth > 0 的子会话也装（只落盘，不发事件）。
+ */
+import { formatModelRef } from "../ai/providers/channels.js";
+import { TRACE_CUSTOM_TYPE, TRACE_REASON_MAX, } from "../trace/types.js";
+import { telemetryOf } from "./session-telemetry.js";
+/** 追加一条 `ama.trace`（不发 `entry_appended` 以外的事件）。 */
+export function appendTraceEntry(core, data) {
+    core.appendEntry({ type: "custom", customType: TRACE_CUSTOM_TYPE, data });
+}
+function clip(text) {
+    if (text === undefined)
+        return undefined;
+    const one = text.replace(/\s+/g, " ").trim();
+    return one.length > TRACE_REASON_MAX ? `${one.slice(0, TRACE_REASON_MAX - 1)}…` : one;
+}
+const AUX_PURPOSE = {
+    warm: "cache_warm",
+    classify: "permission_classify",
+};
+export function createTraceWriter(core, deps = {}) {
+    const now = deps.now ?? Date.now;
+    let request;
+    let assistantEntryId;
+    let attempt = 1;
+    let fallbackFrom;
+    /** 本次 turn 请求发出时是否处于回退（切回主模型可能早于 turn_end）。 */
+    let requestFallbackFrom;
+    const tools = new Map();
+    const subcalls = new Map();
+    /** toolCallId → 审批等待（请求可能早于 tool_execution_start）。 */
+    const approvals = new Map();
+    const pendingApprovals = new Map();
+    let compaction;
+    let compactionEntryId;
+    /** 非 turn 请求（保温 / 分类器）最近一次的开始时刻。 */
+    const auxStarted = new Map();
+    let unsubscribe;
+    const write = (data) => {
+        try {
+            appendTraceEntry(core, data);
+        }
+        catch (error) {
+            core.log("warn", `ama.trace append failed: ${String(error)}`);
+        }
+    };
+    const subscribe = () => {
+        if (unsubscribe !== undefined)
+            return;
+        unsubscribe = telemetryOf(core)?.onRequestEnd((record) => {
+            request = record;
+        });
+    };
+    const dirty = () => request !== undefined || tools.size > 0 || subcalls.size > 0;
+    const writeStep = (message, aborted) => {
+        const ids = new Set(message?.content.flatMap((block) => (block.type === "toolCall" ? [block.id] : [])) ?? []);
+        const stepTools = [];
+        for (const [id, timing] of tools) {
+            if (ids.size > 0 && !ids.has(id) && !aborted)
+                continue;
+            const approvalMs = approvals.get(id);
+            stepTools.push(approvalMs === undefined ? timing : { ...timing, approvalMs });
+            tools.delete(id);
+            approvals.delete(id);
+        }
+        const step = { kind: "step", attempt };
+        if (assistantEntryId !== undefined)
+            step.assistantEntryId = assistantEntryId;
+        const r = request;
+        if (r !== undefined) {
+            step.requestAt = r.requestAt;
+            if (r.firstTokenAt !== undefined)
+                step.firstTokenAt = r.firstTokenAt;
+            if (r.doneAt !== undefined)
+                step.doneAt = r.doneAt;
+            if (r.outputTokens !== undefined)
+                step.outputTokens = r.outputTokens;
+            if (r.tps !== undefined)
+                step.tps = Math.round(r.tps * 10) / 10;
+        }
+        if (requestFallbackFrom !== undefined)
+            step.fallbackFrom = requestFallbackFrom;
+        requestFallbackFrom = undefined;
+        if (aborted)
+            step.status = "aborted";
+        if (stepTools.length > 0)
+            step.tools = stepTools;
+        if (subcalls.size > 0)
+            step.subcalls = [...subcalls.values()];
+        subcalls.clear();
+        request = undefined;
+        assistantEntryId = undefined;
+        write(step);
+        // 成功的请求之后，下一次请求重新从第 1 次尝试算
+        if (!aborted && message !== undefined && message.stopReason !== "error")
+            attempt = 1;
+    };
+    const onEvent = (event) => {
+        subscribe();
+        switch (event.type) {
+            case "entry_appended": {
+                const entry = event.entry;
+                if (entry.type === "message" && entry.message.role === "assistant")
+                    assistantEntryId = entry.id;
+                else if (entry.type === "compaction")
+                    compactionEntryId = entry.id;
+                else if (entry.type === "usage") {
+                    const startedAt = auxStarted.get(entry.kind);
+                    auxStarted.delete(entry.kind);
+                    write({
+                        kind: "aux",
+                        purpose: entry.kind,
+                        usageEntryId: entry.id,
+                        ...(startedAt !== undefined ? { startedAt } : {}),
+                        endedAt: now(),
+                    });
+                }
+                return;
+            }
+            case "tool_execution_start":
+                if (event.parentToolCallId !== undefined)
+                    subcalls.set(event.toolCallId, {
+                        id: event.toolCallId,
+                        parentId: event.parentToolCallId,
+                        name: event.toolName,
+                        startedAt: now(),
+                    });
+                else
+                    tools.set(event.toolCallId, { id: event.toolCallId, startedAt: now() });
+                return;
+            case "tool_execution_end": {
+                const sub = subcalls.get(event.toolCallId);
+                if (event.parentToolCallId !== undefined && sub !== undefined) {
+                    sub.endedAt = now();
+                    if (event.isError)
+                        sub.isError = true;
+                    return;
+                }
+                const timing = tools.get(event.toolCallId) ?? { id: event.toolCallId, startedAt: now() };
+                timing.endedAt = now();
+                if (event.denied === true)
+                    timing.denied = true;
+                tools.set(event.toolCallId, timing);
+                return;
+            }
+            case "permission_request": {
+                const toolCallId = event.context?.toolCallId;
+                if (toolCallId !== undefined)
+                    pendingApprovals.set(event.requestId, { toolCallId, at: now() });
+                return;
+            }
+            case "permission_resolved": {
+                const pending = pendingApprovals.get(event.requestId);
+                if (pending === undefined)
+                    return;
+                pendingApprovals.delete(event.requestId);
+                approvals.set(pending.toolCallId, (approvals.get(pending.toolCallId) ?? 0) + (now() - pending.at));
+                return;
+            }
+            case "turn_end":
+                writeStep(event.message, false);
+                return;
+            case "agent_end":
+                if (dirty())
+                    writeStep(undefined, true);
+                return;
+            case "auto_retry_start":
+                attempt = event.attempt + 1;
+                write({
+                    kind: "retry_wait",
+                    attempt,
+                    delayMs: event.delayMs,
+                    startedAt: now(),
+                    ...(event.errorMessage !== "" ? { reason: clip(event.errorMessage) } : {}),
+                });
+                return;
+            case "model_fallback": {
+                const from = formatModelRef(event.from);
+                fallbackFrom = from;
+                attempt += 1;
+                const reason = clip(event.reason);
+                write({
+                    kind: "fallback",
+                    from,
+                    to: formatModelRef(event.to),
+                    ...(reason !== undefined && reason !== "" ? { reason } : {}),
+                });
+                return;
+            }
+            case "model_changed":
+                // 回退结束切回主模型（或用户换模型）：之后的请求不再算回退
+                if (fallbackFrom !== undefined && formatModelRef(event.model) === fallbackFrom)
+                    fallbackFrom = undefined;
+                return;
+            case "compaction_start":
+                compaction = { trigger: event.trigger, at: now() };
+                compactionEntryId = undefined;
+                return;
+            case "compaction_end": {
+                const started = compaction;
+                compaction = undefined;
+                write({
+                    kind: "compaction",
+                    trigger: event.trigger,
+                    startedAt: started?.at ?? now(),
+                    endedAt: now(),
+                    ...(compactionEntryId !== undefined ? { compactionEntryId } : {}),
+                    ...(event.aborted ? { aborted: true } : {}),
+                });
+                compactionEntryId = undefined;
+                return;
+            }
+            default:
+                return;
+        }
+    };
+    return {
+        id: "trace-writer",
+        wrapStream(stream) {
+            return (model, context, options) => {
+                const kind = options.purpose ?? "turn";
+                if (kind === "turn")
+                    requestFallbackFrom = fallbackFrom;
+                const purpose = AUX_PURPOSE[kind];
+                if (purpose !== undefined)
+                    auxStarted.set(purpose, now());
+                return stream(model, context, options);
+            };
+        },
+        onEvent,
+        dispose() {
+            unsubscribe?.();
+            unsubscribe = undefined;
+        },
+    };
+}
+/** 组装表用的工厂：主会话与子会话都装。 */
+export function traceWriterFactory(deps = {}) {
+    return ({ core }) => createTraceWriter(core, deps);
+}

package/dist/agent/session.d.ts

@@ -45,6 +45,8 @@ export declare class AgentSessionImpl implements AgentSession, SessionCore {
     private turns;
     private readonly subagentPool;
     private disposed;
+    /** [W6-O] 最近一次订阅配额（`quota_update`）。 */
+    private lastQuota;
     private classifier;
     /** 已入队、尚未投递的消息（投递时发 queue_update）。 */
     private readonly queuedMessages;

package/dist/agent/session.js

@@ -47,6 +47,8 @@ export class AgentSessionImpl {
     turns = 0;
     subagentPool;
     disposed = false;
+    /** [W6-O] 最近一次订阅配额（`quota_update`）。 */
+    lastQuota;
     classifier;
     /** 已入队、尚未投递的消息（投递时发 queue_update）。 */
     queuedMessages = new WeakSet();
@@ -97,6 +99,15 @@ export class AgentSessionImpl {
                 const idle = options.idleTimeoutMs;
                 return {
                     sessionId: this.manager.id,
+                    // [W6-O] ChatGPT 订阅配额 → quota_update 事件（/session 显示最近一次）
+                    onQuota: (update) => {
+                        this.lastQuota = {
+                            type: "quota_update",
+                            provider: this.settings.model.provider,
+                            ...update,
+                        };
+                        this.emit(this.lastQuota);
+                    },
                     ...(apiKey === undefined ? {} : { apiKey }),
                     ...(idle === undefined ? {} : { idleTimeoutMs: idle }),
                 };
@@ -416,6 +427,7 @@ export class AgentSessionImpl {
             contextTokens,
             contextWindow,
             cache: this.cache.stats({ tokens: contextTokens, window: contextWindow }),
+            quota: this.lastQuota,
         });
         return this.extensions.contributeStats(stats);
     }