@tencent-ai/agent-harness 0.2.0-beta.1 → 0.2.0-beta.3

package/cli/dist-server/types/vendor/cbc-core/node/session/session-store.d.ts

@@ -2,7 +2,7 @@ import { Logger } from '@celljs/core';
 import { type AgentInputItem } from '../../../cbc-shared/node/index.js';
 import * as fs from 'fs/promises';
 import { LocalJsonlSessionStore } from './local-jsonl-session-store';
-import { type Session, SessionFactory, type SessionForkMutationOptions, type SessionGetOptions, type SessionRewindMutationOptions, SessionStore } from './session-protocol';
+import { type Session, SessionFactory, type SessionForkMutationOptions, type SessionGetOptions, type SessionRewindMutationOptions, SessionStore, type TranscriptPersistenceMetrics } from './session-protocol';
 import type { Lane, LanePointer, SessionKey, SessionStoreEntry } from './session-store-contract';
 import { SessionImageStorage as ImageBlobService, SessionRestoreHost, SessionStoragePaths, SessionToolOutputStorage as ToolResultBlobService } from './session-store-host-protocol';
 /**
@@ -10,6 +10,27 @@ import { SessionImageStorage as ImageBlobService, SessionRestoreHost, SessionSto
  * 达到此阈值且遇到 user message 时停止逆序读取，避免启动时全量读 JSONL。
  */
 export declare const DEFAULT_SESSION_MAX_ITEMS = 1000;
+/**
+ * 每追加这么多条 history 行，就把当前 session-meta 快照重新补写到文件尾部。
+ *
+ * 读侧按 item 数封顶逆序读，只在窗口内找 session-meta；写侧按内容去重，身份
+ * 不变就只有创建时那一行（文件第 1 行）。会话一长，读窗口够不到它 → resume
+ * 静默丢 `codebuddy.ai/mainAgent`（PTC 掉回 cli、REPL 消失）/ `multitaskMode`
+ * / `codebuddy.ai/a2aContexts` / `codebuddy.ai/hostKind`（#128860）。
+ *
+ * 取值远小于 {@link DEFAULT_SESSION_MAX_ITEMS}，读侧即使把上限调低也仍能覆盖；
+ * 代价是每 200 行多一条约 200 字节的行（≈0.1%）。
+ *
+ * **与 {@link SESSION_META_HEAD_SCAN_BYTES} 是配对约束，必须满足**
+ * `SESSION_META_TAIL_REFRESH_LINES × 单行平均字节 << SESSION_META_HEAD_SCAN_BYTES`：
+ * 写侧靠本行距把快照压在文件尾部，读侧只有 256KB 的文件头兜底窗口 —— 一旦尾部快照
+ * 滑出头部窗口，长会话 resume 丢键（#128860 本体）就会以另一种形式回归。
+ * 当前 200 × ~200B ≈ 40KB，对 256KB 有约 6× 余量。**调大本值或让单行显著变长
+ * （例如工具结果外置后仍很大的行）都必须同步核对另一侧**，spec 里有一条边界断言钉住。
+ */
+export declare const SESSION_META_TAIL_REFRESH_LINES = 200;
+/** 文件头 session-meta 兜底读取的字节窗口（存量会话用，不做全量回扫）。与上者配对，见其注释。导出以便 spec 钉住配对约束。 */
+export declare const SESSION_META_HEAD_SCAN_BYTES: number;
 /**
  * Keys of session.meta that persist across processes (the off-tree
  * session-meta line; bin resume only — served sessions never write). A
@@ -22,6 +43,37 @@ export declare const DEFAULT_SESSION_MAX_ITEMS = 1000;
  * Role / locks / parentSessionId stay runtime-only.
  */
 export declare const PERSISTED_SESSION_META_KEYS: readonly ['codebuddy.ai/mainAgent', 'codebuddy.ai/hostKind', 'multitaskMode', 'codebuddy.ai/a2aContexts'];
+/**
+ * 白名单里「缺席即删除」的键：只认最新那一行的存在性，不向更早的行按键继承。
+ *
+ * 其余键（mainAgent / hostKind / a2aContexts）只会被赋值、不会被 delete，所以
+ * 读侧按键继承——某个写方视野不全（只快照了自己关心的键）不能把别的键擦掉
+ * （#128860：`/multitask` 盖章写出只含 multitaskMode 的行，把 PTC 站立身份永久
+ * 抹掉，`/agent-mode` 变成 Standard(cli)）。
+ *
+ * `multitaskMode` 是唯一会被真正 delete 的键（multitask/session-flags.ts 的
+ * clearMultitaskSession），所以必须留在这里，否则"关掉多任务"会被更早的
+ * `true` 复活。**新增白名单键时**：只要它的"缺席"承载语义，就必须登记到本表。
+ *
+ * 注意「缺席」要能写进文件才算数：子集被删空时 `persistSessionMeta` 会补一条
+ * `meta: {}` 的墓碑行，否则最新那条仍是删除前的快照，缺席永远不会出现。墓碑是
+ * **整份空快照**：本表登记第二个键之后，为删 A 写的墓碑会连带把 B 也判成缺席，
+ * 届时得改成按键墓碑，别直接往表里加。
+ */
+export declare const SNAPSHOT_ONLY_SESSION_META_KEYS: ReadonlyArray<string>;
+/**
+ * 参与合并的一条 session-meta 行。
+ *
+ * `id` 可能是空串：#94203 才给这行加上自身 UUIDv7，更早写下的存量行没有 id
+ * （CHANGELOG 明确「兼容旧的无 ID 记录」）。任何按 id 判等的地方都必须先处理
+ * 这个缺失，见 {@link SessionStoreImpl.metaLineIdentity}。
+ */
+interface SessionMetaLine {
+    id: string;
+    meta: Record<string, unknown>;
+    /** 行原文（trim 后）。缺 id 的存量行靠它做判等。 */
+    raw: string;
+}
 /**
  * 解析 session 历史回放的 maxItems。
  *
@@ -46,6 +98,7 @@ export declare class SessionStoreImpl implements SessionStore {
     protected readonly paths: SessionStoragePaths;
     protected readonly restoreHost: SessionRestoreHost;
     private writeLocks;
+    private readonly transcriptMetrics;
     private readonly transcriptAuditOnce;
     private transcriptAuditSequence;
     /**
@@ -113,6 +166,16 @@ export declare class SessionStoreImpl implements SessionStore {
      * behavioral loop: externalize → Read → externalize → Read …).
      */
     private externalizeToolResultIfNeeded;
+    /**
+     * Externalize the UI-only copy of a tool result. Tool implementations commonly store
+     * the same payload again in providerData.toolResult.content/renderer; keeping that copy
+     * defeats output externalization and can make a single JSONL row hundreds of KiB.
+     *
+     * The render payload is persisted as one JSON document. History keeps a text renderer
+     * pointing at that file, so clients always have a visible fallback instead of trying to
+     * parse a <persisted-output> marker as the original media/custom renderer payload.
+     */
+    private externalizeToolRenderDataIfNeeded;
     /**
      * Handle externalization for structured array output.
      * Iterates through array elements and externalizes any input_text items that exceed the threshold.
@@ -139,7 +202,25 @@ export declare class SessionStoreImpl implements SessionStore {
      */
     getSessionMetaFilePath(id: string, parentSessionId?: string, cwd?: string): string;
     private lastPersistedMeta;
+    /** 各转录文件「距上次 session-meta 行」的 history 行数（进程内，用于尾部刷新节流）。 */
+    private historyLinesSinceMeta;
+    /** 读侧靠文件头兜底才拿到 meta 的转录文件：下一批 append 立即把快照补到尾部。 */
+    private staleTailMeta;
+    /**
+     * 「据已知，该转录尾部最新那条 session-meta 还带着非空子集」——决定子集被删空时
+     * 要不要补墓碑。
+     *
+     * 判据必须是**文件事实**而不是"本进程写过什么"：resume 只 `get()` 不 `save()`
+     * （agent-task.ts 的子代理恢复就是这样），进程内缓存恒空，冷启动后第一轮就关掉
+     * 多任务会写不出墓碑，"关掉"永远落不了盘。所以读侧 load 完也要维护它。
+     *
+     * 仍是进程内状态：同一转录被两个进程同时写时，另一方的非空写入本进程不可见
+     * （与 `lastPersistedMeta` 同一层限制）。
+     */
+    private tailMetaNonEmpty;
     private persistedMetaSubset;
+    /** 一条 off-tree session-meta 行的字节形式。空 `persisted` 即墓碑快照。 */
+    private metaSnapshotLine;
     /** The off-tree session-meta line, or undefined when there is nothing to persist. */
     protected sessionMetaLineFor(fileId: string, meta: Session['meta']): string | undefined;
     /**
@@ -150,7 +231,59 @@ export declare class SessionStoreImpl implements SessionStore {
      * .meta.json overwrite. Bin surface only — served sessions never reach
      * here (persistence gate; locked by spec).
      */
-    protected persistSessionMeta(fileId: string, meta: Session['meta'], parentSessionId?: string, cwd?: string): Promise<void>;
+    protected persistSessionMeta(fileId: string, meta: Session['meta'], parentSessionId?: string, cwd?: string, options?: {
+        force?: boolean;
+    }): Promise<void>;
+    /**
+     * 尾部快照刚落盘后的进程内状态收尾 —— 四份状态必须一起动。
+     *
+     * `lastPersistedMeta` / `historyLinesSinceMeta` / `staleTailMeta` / `tailMetaNonEmpty`
+     * 都以 filePath 为键、都描述「这个转录尾部最新那条 meta 现在是什么」。任何往尾部
+     * 写快照的路径（persistSessionMeta / initializeForkHistory）都要走这里：在调用点
+     * 手写四行，下一次再加状态时必然漏一处 —— fork 初始化就是这么漏的（lastPersistedMeta
+     * 写了，另外三份没写，导致 fork 后关掉多任务写不出墓碑、行数计数带着旧值）。
+     */
+    private markTailMetaPersisted;
+    /**
+     * 让「最新 session-meta」始终留在读侧的逆序窗口内（#128860 根治的写入侧）。
+     *
+     * 只在 history 真正落盘之后调用：每 {@link SESSION_META_TAIL_REFRESH_LINES}
+     * 行补写一次快照；读侧走过文件头兜底的文件（存量长会话）立即补写一次，
+     * 这样同一个会话只会退化一次。
+     *
+     * 失败不能拖垮本轮 append —— 转录字节已经写成功了，meta 下一批还会重试。
+     */
+    private refreshTailSessionMeta;
+    /**
+     * 文件头的 session-meta 兜底读取。
+     *
+     * `session-meta` 创建行通常在文件靠前的位置（新建会话是第 1 行；子会话/迁移过的
+     * 会话可能更靠后），而 history 逆序读有 item 上限——长会话倒着读到不了那里
+     * （#128860）。这里只读文件头一小段，不做全量回扫：
+     * 29MB 的会话里末尾 1100 行只占 20% 字节，回扫到头会把 resume 的读 I/O 放大 5×。
+     *
+     * 返回窗口内所有 session-meta 的 meta（文件序，旧→新），由
+     * {@link composeSessionMeta} 统一合并。
+     */
+    protected readHeadSessionMeta(filePath: string): Promise<SessionMetaLine[] | undefined>;
+    /**
+     * 合并去重用的行身份。
+     *
+     * 不能直接用 `id`：#94203 之前的存量行没有 id，兜成空串会让「头部的创建行」
+     * 和「尾部的残缺行」撞成同一个键 —— 头部那条被当成"已经见过"丢掉，正好复现
+     * 本 issue 要修的丢键现场（本机实测 2607 条 meta 行里 1195 条没有 id）。
+     * 缺 id 时退回整行原文：内容相同的两行参与合并是幂等的，丢一条无害。
+     */
+    private metaLineIdentity;
+    /**
+     * 把若干条 session-meta（文件序，旧→新）合成一份 meta 事实。
+     *
+     * - {@link SNAPSHOT_ONLY_SESSION_META_KEYS}：只认最新那一行（缺席=已删除）。
+     * - 其余白名单键：按键向更早的行继承，最新的值优先。写方只快照了自己视野
+     *   里的键时，别人的键不会被顺带擦掉（#128860 的第二处：`/multitask` 写出
+     *   只含 multitaskMode 的行，PTC 站立身份被永久抹掉）。
+     */
+    protected composeSessionMeta(metaLinesOldestFirst: ReadonlyArray<SessionMetaLine>): Record<string, unknown> | undefined;
     private findSubagentSessionByStoreId;
     protected deserializeSessionFromJsonl(id: string, options?: SessionGetOptions): Promise<Session | undefined>;
     /**
@@ -225,13 +358,25 @@ export declare class SessionStoreImpl implements SessionStore {
      */
     protected isNonUserSession(session: Session): boolean;
     appendHistory(id: string, input: AgentInputItem[], parentSessionId?: string, session?: Session, cwd?: string): Promise<void>;
+    protected openJsonlFile(filePath: string, flags: string): ReturnType<typeof fs.open>;
+    /** Short, in-band only: this runs on the addHistory chain, so it is turn latency. */
+    protected transcriptRetryDelaysMs(): readonly number[];
+    protected sleepBeforeTranscriptRetry(delayMs: number): Promise<void>;
+    /** Cumulative transcript persistence counters (issue #119545 埋点). */
+    transcriptPersistenceMetrics(): Readonly<TranscriptPersistenceMetrics>;
     /**
-     * The transcript-line writer, extracted verbatim from the previous
-     * appendHistory body: exclusive-create or append open, chunked line
+     * The transcript-line writer: exclusive-create or append open, chunked line
      * writes, and on failure a rollback (unlink a file this batch created,
      * truncate to the original size otherwise) with forensic audit logs.
+     *
+     * A retryable failure gets a short in-band retry. When the budget runs out
+     * the batch is abandoned and reported as a typed error — the local copy is
+     * allowed to lose its tail, and `addHistory` keeps the turn running. Read
+     * paths repair the gap (unpaired tool calls are filtered out of model
+     * input), so the cost of a loss is a shorter history, not a broken one.
      */
     protected writeTranscriptLines(sessionFilePath: string, lines: string[], key?: SessionKey): Promise<void>;
+    private writeTranscriptLinesOnce;
     private readonly entriesStoreInstances;
     /**
      * The embedded SessionStore-contract backend — the single jsonl writer
@@ -312,3 +457,4 @@ export declare class SessionStoreImpl implements SessionStore {
     private cleanupFailedFork;
     rewindSession(source: Session, options: SessionRewindMutationOptions): Promise<void>;
 }
+export {};

package/cli/dist-server/types/vendor/cbc-core/node/session/stream-timeout-retry-budget.d.ts

@@ -6,9 +6,28 @@ import type { Session } from './session-protocol';
  * terminal results are suppressed only while a retry will actually be scheduled.
  */
 export declare function hasExhaustedStreamTimeoutRetryBudget(session: Session, isFirstTokenTimeout: boolean): boolean;
+/**
+ * `finish_reason=error` 且没有可用输出的两种空流：reasoning-only 与 no-token。
+ * placeholder（空 200 / 心跳帧）仍是会话层终态，由拦截器切一次备站。
+ *
+ * 额外的时长闸门（#132616）：这两种 kind 之所以可重试，前提是「上游瞬时失败」——秒级
+ * 空响应重跑一次大概率就好了。但当这条流已经跑满上游的硬时限才收到 error 时，前提不成立：
+ * 同一段 prompt 重跑必然再次跑满同一个时限。实测 7 个会话全部重试、全部再次撞墙、0 次恢复，
+ * 而 `#130098` 把预算从 1 提到 3 之后，同样的输入会从 2×900s 变成 4×900s ≈ 60 分钟静默。
+ * 重试的期望收益不随 elapsed 增长，成本却线性增长，所以按 elapsed 收口。
+ */
 export declare function isRetryableEmptyStreamError(error: unknown): boolean;
 /**
  * Empty 200 / placeholder-only：拦截器最多切一次备站，会话层终态（#115866）。
- * reasoning-only + finish_reason=error：上游瞬时失败，会话层最多重试 1 次（#122115）。
+ * reasoning-only / no-token + finish_reason=error：上游瞬时失败，按 error 预算重试；
+ * 已烧满上游硬时限的那些除外，见 {@link isRetryableEmptyStreamError} 的时长闸门（#132616）。
+ * 流空闲超时 / 首 token 超时：按各自的超时预算重试。
  */
 export declare function shouldAutoRetryStreamTimeout(session: Session, error: unknown): boolean;
+/**
+ * 为一次流错误恢复认领额度，返回序号（1-based）；不可重试或已耗尽返回 `undefined`。
+ * 调用方必须先用 {@link shouldAutoRetryStreamTimeout} 判定，本函数只负责同步认领。
+ */
+export declare function claimStreamRecoveryAttempt(session: Session, error: unknown): number | undefined;
+/** 认领后没有真正发起恢复时退回额度。 */
+export declare function releaseStreamRecoveryAttempt(session: Session, error: unknown): void;

package/cli/dist-server/types/vendor/cbc-core/node/trace/turn-context.d.ts

@@ -34,6 +34,33 @@ export interface TurnContext {
     /** Canonical id assigned when the external user input is admitted. */
     conversationRequestId?: string;
 }
+export interface RequestOwner {
+    readonly session: Session;
+    readonly requestId: string;
+    readonly turn: TurnContext;
+    latestExecution?: object;
+}
+export type RequestTerminalOutcome = 'written' | 'failed' | 'unconfirmed';
+export interface RequestTerminal {
+    readonly attempt: object;
+    outcome?: RequestTerminalOutcome;
+    readonly completed: Promise<RequestTerminalOutcome>;
+}
+export declare function getRequestOwner(ref: object): RequestOwner | undefined;
+export declare function getRequestExecution(ref: object): object | undefined;
+export declare function associateRequestOwner(ref: object, owner: RequestOwner, execution?: object): void;
+/** Carry physical execution through admission without inventing a request owner. */
+export declare function associateRequestExecution(ref: object, execution: object): void;
+/** Reserve completion ownership at admission, retaining the prior result if startup fails. */
+export declare function beginRequestExecution(owner: RequestOwner, execution: object): void;
+/** A failed startup never owns a result; restore only the execution it actually replaced. */
+export declare function abandonRequestExecution(execution: object): Session['resultSubject']['value'];
+export declare function getRequestTerminal(owner: RequestOwner, destination: string): RequestTerminal | undefined;
+export declare function claimRequestTerminal(owner: RequestOwner, destination: string, attempt: object): boolean;
+export declare function settleRequestTerminal(owner: RequestOwner, destination: string, attempt: object, outcome: RequestTerminalOutcome): void;
+/** The admission boundary, not trace binding, creates a new logical request. */
+export declare function admitRequestOwner(session: Session, requestId: string): RequestOwner;
+export declare function runInRequestOwner<T>(owner: RequestOwner, callback: () => T): T;
 /** Transient provider-data key; stripped before history/model persistence. */
 export declare const TURN_CARRIER_CANDIDATE_KEY = "codebuddy.ai/turnCarrierCandidate";
 export declare const BAGGAGE_KEY_SESSION_ID = "codebuddy.session_id";
@@ -83,7 +110,7 @@ export declare function bindCurrentTurnContext(session: Session, conversationReq
 /** Carrier for one exact admitted request; never returns the latest other turn. */
 export declare function turnCarrierForRequest(session: Session, conversationRequestId: string | undefined): W3CTraceContextMeta;
 /** Release an exact request binding. */
-export declare function releaseTurnContext(session: Session, conversationRequestId: string | undefined): void;
+export declare function releaseTurnContext(session: Session, conversationRequestId: string | undefined, owner?: RequestOwner): void;
 /** The current turn as an injectable three-key carrier; `{}` outside a turn. */
 export declare function currentTurnCarrier(): W3CTraceContextMeta;
 /**

package/cli/dist-server/types/vendor/cbc-core/node/utils/command-message-utils.d.ts

@@ -58,6 +58,26 @@ export declare abstract class CommandMessageUtils {
      * 解析XML格式的命令输出
      */
     static parseOutput(xmlText: string): ParseCommandMessage | undefined;
+    /**
+     * 是否为本地命令在会话历史里留下的记账项：caveat、命令回显（`<command-name>`）、
+     * 命令输出（`<local-command-stdout>`）、本地 bash 的输入输出、plan 输出。
+     *
+     * 这些 item 的 role 是 user、也不带 skipRun，因此按「真实用户消息」判定会命中；
+     * 但它们只是本地命令的痕迹，**不代表用户开启了新一轮对话**。调用方（如 TUI 的
+     * loading 计时器）需要区分「新一轮」和「本地命令留痕」时用这个判据。
+     *
+     * 识别口径复用 parseInput / parseOutput / parsePlanOutput，避免调用方各自
+     * 维护一份 XML 标签清单而漂移。
+     */
+    static isLocalCommandRecord(text: string): boolean;
+    /**
+     * {@link isLocalCommandRecord} 的 item 版本。
+     *
+     * 必须读 **原始** content：`MessageContentUtils.extractTextContent` 已经把命令 XML
+     * 拆开（`<command-name>/doctor</command-name>` → `/doctor`），拿它的结果再判就永远
+     * 判不出来。
+     */
+    static isLocalCommandRecordItem(item: UserMessageItem): boolean;
     /**
      * 解析计划输出
      */

package/cli/dist-server/types/vendor/cbc-core/node/utils/history-utils.d.ts

@@ -226,10 +226,10 @@ export declare abstract class HistoryUtils {
      * <conversation_history_summary>…</conversation_history_summary> 包裹的正文)。
      *
      * 规则(与 replaceCompactWithSummary / getCompactHistory 对齐):
-     *   1. 仅查看 `providerData.agent === AgentNames.COMPACT` 且为 assistant 的 message
-     *   2. 从后向前扫描,命中第一条满足格式的 compact assistant 即返回
-     *   3. "满足格式"由 `SummaryUtils.extractCompactSummaryFromText` 统一判定
-     *      (内含结构校验 + 非空正文双闸)
+     *   1. 查看 compact-agent assistant，或 PreMessage/MaxToken 写入的显式 compact boundary
+     *   2. 从后向前扫描,命中第一条可用摘要即返回
+     *   3. compact assistant 继续要求结构化 summary envelope；显式 boundary 同时支持
+     *      工程压缩的 `<cb_summary>` 与 LLM summary envelope
      *   4. 全程扫描都拿不到 → 返回 `undefined`(history 中**从未**出现过合法摘要)
      *
      * ⚠️ 不适合用于"判断本次 compact run 是否成功"!
@@ -364,6 +364,29 @@ export declare abstract class HistoryUtils {
      */
     static filterApiErrorMessages(history: AgentInputItem[]): AgentInputItem[];
     static filterRenameHistory(history: AgentInputItem[]): AgentInputItem[];
+    /**
+     * 让 model input 里的 tool_call 与 tool_result 严格一一配对（issue #119545）。
+     *
+     * 背景：工具结果丢失（状态机吞掉 TOOL_ENDED、持久化缺口、压缩切断）后，历史里会留下
+     * 只有 call、没有任何 result 的孤儿。上游对 tool_calls 强制配对，一条孤儿就让整个
+     * 请求 400，会话从此不可恢复——而本地历史里的孤儿是持久化的，每次恢复都会重现。
+     *
+     * 三类都处理，因为上游拒的是"不配对"这件事本身，方向无关：
+     * 1. call 没有任何同 callId 的结果项 → 丢 call；
+     * 2. 同一 callId 出现多条 call（重放/重试残留）→ 只留最后一条；
+     * 3. 结果项的 callId 没有留下来的 call（头部被截断，或 call 属于上面两类）→ 丢结果。
+     *
+     * 判据只看"存在性"，不看结果的真伪：skipRun 占位/拒绝、partial aborted 等伪结果都算
+     * 配对，它们的取舍归 filterTruncatedToolCalls，两者职责不重叠。改写只落在当轮副本上，
+     * 因此日志按轮聚合成一条并截断样本。
+     */
+    static filterUnpairedToolCalls(modelData: {
+        input: AgentInputItem[];
+        instructions?: string;
+    }, logger?: Logger): {
+        input: AgentInputItem[];
+        instructions?: string;
+    };
     static getItemsNeedingFill(history: AgentInputItem[]): FunctionCallItem[];
     static getFillItemsForNeedingFill(itemsNeedingFill: FunctionCallItem[]): FunctionCallResultItem[];
     /**

package/cli/dist-server/types/vendor/cbc-core/node/utils/index.d.ts

@@ -23,5 +23,6 @@ export * from './queue-dispatch-utils';
 export * from './run-result-utils';
 export * from './session-utils';
 export * from './summary-utils';
+export * from './string-retention-utils';
 export * from './token-utils';
 export * from './usage-utils';

package/cli/dist-server/types/vendor/cbc-core/node/utils/input-item-utils.d.ts

@@ -256,6 +256,14 @@ export declare abstract class InputItemUtils {
     static isUserInterrupted(item: AgentInputItem): boolean;
     static isSuccessfulFunctionCallResultItem(item: AgentInputItem): item is FunctionCallResultItem;
     static isCompactBoundaryMessage(item: AgentInputItem): boolean;
+    /**
+     * 仅凭 providerData 结构化标记判定 compact boundary，不使用内容正则兜底。
+     *
+     * 会删除或改写消息的路径（如 replaceCompactWithSummary）必须用这个版本：
+     * 内容兜底会把用户粘贴的 `<cb_summary>` / `<conversation_history_summary>` 文本
+     * 误判为 boundary，导致真实用户输入被移除。
+     */
+    static isStructuredCompactBoundaryMessage(item: AgentInputItem): boolean;
     static isReplayRecoverableCompactMessage(item: AgentInputItem): item is UserMessageItem;
     static isCompactUserMessage(item: AgentInputItem): item is UserMessageItem;
     private static hasCompactBoundaryContent;

package/cli/dist-server/types/vendor/cbc-core/node/utils/message-utils.d.ts

@@ -79,6 +79,18 @@ export declare abstract class MessageUtils {
     static createFilteredCopyForCompaction(messages: AgentInputItem[]): AgentInputItem[];
     private static filterHiddenSystemRemindersForCompaction;
     static stripSystemRemindersOutsideUserQuery(text: string): string;
+    /**
+     * 压缩链路的统计日志出口。
+     *
+     * **禁止改回 `process.stderr.write` / `process.stdout.write`**（issue #76749）：
+     * TUI 下裸写 stderr 会破坏 Ink 帧间光标定位，导致行级 diff 错位、spinner 残留。
+     * 走 logger 落盘即可，既保留排查信息又不碰 TTY。
+     *
+     * `catch` 有意整段吞掉，不做分级上报：日志出口的任何失败（容器未就绪、logger 自身
+     * 抛错）都不得影响压缩本身；而「失败时改走 stderr 兜底」恰会在异常路径上重新引入
+     * 本 issue 要修掉的 TTY 裸写。统计丢失是可接受的降级。
+     */
+    private static logCompaction;
     /**
      * Microcompact: clear output of old tool results (> 1 hour) to reduce token count.
      * Modifies items in place. Should be called BEFORE createFilteredCopyForCompaction.

package/cli/dist-server/types/vendor/cbc-core/node/utils/model-utils.d.ts

@@ -70,6 +70,13 @@ export declare abstract class ModelUtils {
      */
     private static readRuntimeModelId;
     static isHunyuanModel(session: Session): Promise<boolean>;
+    /**
+     * ImageGen 实际使用的图片模型是否为混元。
+     *
+     * 取「产品配置里第一个带 text-to-image tag 的模型」，与 image-service 的解析顺序一致；
+     * 配置里没有图片模型时会走客户端的混元兜底模型，同样按混元处理。
+     */
+    static isHunyuanImageModel(): Promise<boolean>;
     static isMandatoryApprovalTarget(session: Session, targetToolName: string): Promise<boolean>;
 }
 export {};

package/cli/dist-server/types/vendor/cbc-core/node/utils/queue-dispatch-utils.d.ts

@@ -17,7 +17,8 @@ import type { Session } from '../session/session-protocol';
  * 取；CLI **不再自动 drain**。后果有两条，改这块代码前必须知道：
  *  1. `session.queue` 降级为 rich queue 的**展示镜像**（只给 CLI TUI 看），镜像段由
  *     `RichMessageQueueManagerImpl.syncToSessionQueue` 整体重建；
- *  2. 上面列举的那些 legacy 自动 drain 路径**全部被显式短路**。
+ *  2. 主会话的 legacy 自动 drain 路径被短路。子任务没有客户端派发者，仍由
+ *     MessageQueueAgentRunInterceptor 消费非镜像项（包括普通 user 消息）。
  *
  * 因此在 Mode B 下 `session.queue` 是两个所有者共用的数组：镜像段属于 rich queue，
  * 系统注入项（后台任务通知 / channel / teammate / ACP steer 等）属于各自的注入方。任何一方读写它时
@@ -63,9 +64,30 @@ export declare abstract class QueueDispatchUtils {
      * 从 `session.queue` 里挑出「自动 drain 通道」该消费的项。
      *
      * Mode A：整个队列都是待发输入，原样返回（保持既有行为）。
-     * Mode B：只返回系统注入项，rich queue 的展示镜像不属于本通道。
+     * Mode B 主会话：只返回系统注入项。子任务：所有非镜像项都是真实待发输入。
      */
     static ownedQueueItems(session: Session): AgentInputItem[];
+    /** Task runtimes have no client queue dispatcher, including restored child sessions. */
+    static isTaskQueue(session: Session): boolean;
+    /** The legacy interceptor owns all Mode A input and Mode B task input, never rich mirrors. */
+    static usesLocalQueueDispatch(session: Session): boolean;
+    static autoDrainQueueItems(session: Session): AgentInputItem[];
+    /**
+     * Observe which items one drain invocation actually consumed.
+     *
+     * **`input` is matched by array *identity*, not contents** — a copy observes
+     * nothing, and the caller then reads a failed drain as having consumed
+     * nothing. Per instance rather than per session because a session-wide
+     * snapshot cannot tell this batch apart from a competing run's.
+     *
+     * @returns disposer; call it once the run settles.
+     */
+    static observeQueueDrain(input: AgentInputItem[], observer: (items: AgentInputItem[], signal?: AbortSignal) => void): () => void;
+    /**
+     * Report the items consumed for `input`. No-op when nobody observes that
+     * exact array instance — see {@link observeQueueDrain} for the contract.
+     */
+    static recordQueueDrain(input: AgentInputItem[], items: AgentInputItem[], signal?: AbortSignal): void;
     /**
      * Async check — reads product config when env var is not set.
      */

package/cli/dist-server/types/vendor/cbc-core/node/utils/session-utils.d.ts

@@ -11,7 +11,10 @@ export declare abstract class SessionUtils {
      * session 中发生实际可见的 ID 冲突。
      */
     static subAgentId(): string;
-    static isSubAgent(session: Session): boolean;
+    static isSubAgent(session: {
+        id?: string;
+        storeId?: string;
+    }): boolean;
     /**
      * Clone one history item for a fork without duplicating large string payloads.
      *

package/cli/dist-server/types/vendor/cbc-core/node/utils/string-retention-utils.d.ts

@@ -0,0 +1,4 @@
+/** Materialize an independent string without changing its UTF-16 code units. */
+export declare function copyString(value: string): string;
+/** Truncate by JavaScript string length and detach the retained prefix from its parent. */
+export declare function truncateAndCopyString(value: string, maxLength: number, suffix?: string): string;

package/cli/dist-server/types/vendor/cbc-core/node/utils/token-utils.d.ts

@@ -64,7 +64,9 @@ export declare class TokenUtils {
      * tool call 执行后产生的 function_call_result（这些结果在 API 返回后才追加到 history）。
      * 为了更准确地判断是否需要触发压缩，需要把这部分 token 补上。
      *
-     * 从 history 末尾往前扫描，收集连续的 function_call_result 条目直到遇到其他类型为止。
+     * 从 history 末尾往前扫描，只收集紧挨在末尾的连续 function_call_result。
+     * 一遇到非 function_call_result（含 function_call）即停止：function_call 属于上一轮
+     * 已经进过请求的内容，穿过它会把更早轮次的 result 重复计入 inputTokens（#133055）。
      * 注意：估算前会移除图片内容，避免 base64 图片数据导致 token 严重偏高。
      */
     static estimateTrailingToolResultTokens(history: any[]): number;

package/cli/dist-server/types/vendor/cbc-shared/node/agent/openai-agents-types.d.ts

@@ -31,6 +31,7 @@ import type { AgentOutputType, getAllMcpTools as getAllMcpToolsFn, MaxTurnsExcee
 import type { TextOutput, UnknownContext, UserContent } from '@openai/agents-core/types';
 import type { AcpTerminalStateItem, FileHistorySnapshotItem, ModelUsageItem, ResendForkNoticeItem } from './custom-input-item-types';
 export * from './custom-input-item-types';
+export type { RunStreamEvent } from '@openai/agents-core';
 export type Agent<TContext = UnknownContext, TOutput extends AgentOutputType = TextOutput> = AgentTypeCtor<TContext, TOutput>;
 export type RunContext<TContext = UnknownContext> = RunContextTypeCtor<TContext>;
 export type Runner = RunnerTypeCtor;

package/cli/dist-server/types/vendor/cbc-shared/node/checkpoint/checkpoint-types.d.ts

@@ -64,4 +64,10 @@ export interface CheckpointFileChangeStats {
     additions: number;
     /** 删除行数 */
     deletions: number;
+    /**
+     * 行数为近似值（PTC/Code Mode 兜底：files 来自本轮 trackFile 快照，additions/deletions
+     * 暂记 0）。需要精确行数的调用方（如 TUI rewind 面板）据此异步调用
+     * compareWithCurrentFiles 补齐后清除本标记。仅内存态，不持久化。
+     */
+    approximate?: boolean;
 }

package/cli/dist-server/types/vendor/cbc-shared/node/hooks/hook-types.d.ts

@@ -83,7 +83,13 @@ export declare enum HookEvent {
     FILE_CHANGED = "FileChanged",
     CWD_CHANGED = "CwdChanged",
     /** Terminal event; does not support continueRequest. */
-    FINAL_STOP = "FinalStop"
+    FINAL_STOP = "FinalStop",
+    /**
+     * Triggered when a user-typed command/skill expands into a prompt, before
+     * it reaches the model. Can block the expansion.
+     * Claude Code parity: matcher filters on `command_name`.
+     */
+    USER_PROMPT_EXPANSION = "UserPromptExpansion"
 }
 /** Hook script stdout payload. */
 export interface HookOutput {

package/cli/dist-server/types/vendor/cbc-shared/node/index.d.ts

@@ -1,6 +1,8 @@
 export * from './agent/openai-agents-types';
 export * from './agent-home/agent-home-envelope-body';
 export * from './utils/abort-utils';
+export * from './utils/retry-backoff';
+export * from './utils/retry-policy';
 export * from './settings/settings-types';
 export * from './tools/tool-permission-types';
 export * from './tools/tool-permission-messages';

package/cli/dist-server/types/vendor/cbc-shared/node/model/model-errors.d.ts

@@ -17,10 +17,26 @@ export declare class StreamTimeoutError extends CustomError {
 }
 /**
  * placeholder：空 200 / 心跳占位，拦截器最多切一次备站，会话层终态。
- * reasoning-only：已流出思考、finish_reason=error 且无可用输出（#63761 / #122115），
- * 会话层允许 1 次有界重试。
+ * reasoning-only：已流出思考、finish_reason=error 且无可用输出（#63761 / #122115）。
+ * no-token：finish_reason=error 到达时一个模型 token 都没有（连 reasoning 也没有）。
+ *
+ * reasoning-only 与 no-token 按「上游瞬时失败」处理，会话层按 error 恢复预算重试——
+ * 但仅限流没跑太久的那些：已经烧满上游硬时限的同样形态重跑必然再次跑满，由
+ * `isRetryableEmptyStreamError` 按 {@link EmptyStreamError.elapsedMs} 收口（#132616）。
+ * placeholder 必须与 no-token 分开——两者共用一个值时，放开 no-token 会连带
+ * 推翻空 200 的终态判定。
+ */
+export type EmptyStreamKind = 'placeholder' | 'reasoning-only' | 'no-token';
+/**
+ * 空流错误的结构化 category，两条上报通道共用一个值。
+ *
+ * ACP 侧 `classifyErrorAsRequestError` 早就用它（前端按此映射业务码 3008「模型服务未返回消息」）；
+ * stream-json 侧此前没有任何结构化维度，`errors_info` 整体缺席，sandbox-proxy 的
+ * `BuildErrorMessageFromCLIErrors` 只能兜底成 `category=internal`，再由
+ * `ClassifyInBandPromptError` 推出 `error_origin=cli`——把上游故障记成 CLI 内部错误。
+ * 挂到错误对象的 `data` 上让两条通道读到同一个值，不再各说各话。
  */
-export type EmptyStreamKind = 'placeholder' | 'reasoning-only';
+export declare const EMPTY_STREAM_ERROR_CATEGORY = "empty_model_response";
 /**
  * 空流错误
  * 语义上仍然是"上游没有提供模型输出"，所以继承 StreamTimeoutError
@@ -29,10 +45,26 @@ export type EmptyStreamKind = 'placeholder' | 'reasoning-only';
  * 典型触发：某些 OpenAI 兼容网关在后端异常时没有透传错误码，而是发一帧全空
  * `{"delta":{"role":"assistant","content":"","tool_calls":[],"refusal":""},"finish_reason":""}`
  * 然后直接关闭连接——用户看到的现象是 cbc 当前轮"空响应"并被 ACP 分类为 refusal。
+ *
+ * message **必须**按 kind 分开写：三种 kind 共用一句「only placeholder chunks」会谎报失败形态。
+ * 0924 沙箱实测的 reasoning-only 样本里上游发了 20397 帧 / 9.5 MB 真实 reasoning，
+ * 与「只有占位帧」正相反；而下游报表、看板、排障全靠这个字符串归因，于是把上游
+ * ~900s 时限问题记成了 CLI 内部错误（#132616）。
  */
 export declare class EmptyStreamError extends StreamTimeoutError {
     readonly emptyStreamKind: EmptyStreamKind;
-    constructor(chunkCount: number, totalBytes: number, kind?: EmptyStreamKind);
+    /**
+     * 流从打开到判定空流的时长。
+     *
+     * 用来区分「上游瞬时抖动（秒级空响应）」和「跑满上游硬时限（0924 实测 ~900s）」——
+     * 后者重跑同一段 prompt 必然再次跑满，重试只是把静默时长翻倍，见
+     * `isRetryableEmptyStreamError` 的时长闸门。
+     */
+    readonly elapsedMs: number;
+    readonly data: Readonly<{
+        category: "empty_model_response";
+    }>;
+    constructor(chunkCount: number, totalBytes: number, kind?: EmptyStreamKind, elapsedMs?: number);
 }
 /**
  * 认证缺失错误

package/cli/dist-server/types/vendor/cbc-shared/node/tools/tool-names.d.ts

@@ -63,6 +63,7 @@ export declare enum ToolNames {
     WAIT_FOR_MCP_SERVERS = "WaitForMcpServers",
     WORKFLOW = "Workflow",
     VIDEO_GEN = "VideoGen",
+    AUDIO_TRANSCRIBE = "AudioTranscribe",
     REPORT_FINDINGS = "ReportFindings",
     MONITOR = "Monitor",
     LIST_AGENTS = "ListAgents",