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

package/cli/dist-server/types/workspace/cbc-core/lib/node/agent/runner-factory.d.ts

@@ -90,10 +90,10 @@ export declare class RunnerFactoryImpl implements RunnerFactory {
     /**
      * Mode B：把「立即发送」队列项注入正在运行的 turn（#73022）。
      *
-     * 调用点在 `callModelInputFilter`（见 `create()`），即**每次模型请求之前**，
-     * 且此时本轮工具已全部执行完、tool result 已回填。选这个边界是因为既不用
-     * 打断在跑的工具，也不会破坏 `tool_call` 与 `tool_result` 的配对——Codex 与
-     * Claude Code 同样选在这个位置。
+     * 调用点在 `callModelInputFilter`（见 `create()`），即**每次模型请求之前**。
+     * rich message / notification / drain prompt 仍在这里注入请求副本；真实 steer
+     * 由 `continuationInputProvider` 在 `prepareTurn` 前写入 SDK RunState，避免后续
+     * 工具 step 从权威状态重建请求时丢失。
      *
      * 注入内容已经进入本次模型请求，无需再为“曾经注入过”强制续圈。只有模型响应期间
      * 新到达、尚未被取出的消息，才由 `__codebuddySteerPending` 在收尾时实时判定是否
@@ -111,6 +111,22 @@ export declare class RunnerFactoryImpl implements RunnerFactory {
      *   `create()` 注释）。payload 与授权同为调用局部值，天然不跨 run 共享。
      */
     private injectSendNowItems;
+    /**
+     * Drain steer only at the SDK continuation boundary, before it prepares the next model step.
+     *
+     * The returned model items are installed by the SDK into RunState.generatedItems before
+     * `prepareTurn`. This makes steer authoritative input for every later tool/model step instead
+     * of an ephemeral `callModelInputFilter` addition. The visible history stays the bare user
+     * message; it is admitted exactly once, by the stream consumer, in RunState order.
+     */
+    private takeSteerContinuationInput;
+    /**
+     * Visible-history + ACP admission of one drained steer group.
+     *
+     * Ordering is the caller's responsibility (continuation-history-queue.ts); this only performs
+     * the writes and must never throw back into the run.
+     */
+    private admitSteerToVisibleHistory;
     /**
      * #100404：落定来源一（rich queue sendNow）的消费。
      *
@@ -139,11 +155,11 @@ export declare class RunnerFactoryImpl implements RunnerFactory {
      * （`session/session-manager.ts` 的 `MODEL_STREAM_STARTED`），涉及跨模块反向布线与
      * 事件类型白名单依赖，另开 issue 跟进。
      *
-     * **落史顺序反转（显式接受）**：`modelData.input` 的 push 顺序是来源一 → 二 → 三 → 四，
-     * 但来源一的 `addHistory` 推迟到本方法内执行，来源二/三/四仍在 `injectSendNowItems` 里
-     * 就地 addHistory。同一 model step 同时命中多个来源时，history 里队员消息会排在
-     * steer / 通知之后，与模型当时看到的输入顺序相反。已确认下游按 role/type 消费、不依赖
-     * 交错位置，故接受该反转，不做「四来源 historyItems 统一收敛」的重构。
+     * **落史顺序反转（显式接受）**：`modelData.input` 的 filter push 顺序是来源一 → 三 → 四，
+     * 但来源一的 `addHistory` 推迟到本方法内执行，来源三/四仍在 `injectSendNowItems` 里
+     * 就地 addHistory。同一 model step 同时命中多个来源时，history 里队员消息会排在通知
+     * 之后，与模型当时看到的输入顺序相反。steer 已在更早的 SDK continuation 边界同时进入
+     * RunState 与可见历史，不参与这段反转。下游按 role/type 消费、不依赖交错位置，故接受。
      *
      * at-most-once 由**作用域**保证，不再依赖「commit 前清暂存」这类补偿动作：`pending` 是
      * 单次 `callModelInputFilter` 调用的局部值，每次调用最多把它 commit 一次，也不可能被

package/cli/dist-server/types/workspace/cbc-core/lib/node/agent/tool-call-loop-guard-protocol.d.ts

@@ -27,7 +27,7 @@ export declare const TOOL_CALL_LOOP_STOPPED_MESSAGE = "Request aborted: user sto
  * - `ToolCallLoopDetector` 在**模型请求前**拦截，静默向模型注入停止消息，用户无感；
  *   它覆盖的是旧的三条规则（黑名单同参 4 次 / Read 同文件 40 次 / 非黑名单同参 40 次）。
  * - `ToolCallLoopGuard` 在**工具执行前**拦截，弹窗让用户自己决定继续还是停止；
- *   它覆盖新增的两条规则（同工具连续 40 次，Bash 单独放到 80 次 / 周期序列重复 10 轮）。
+ *   它覆盖新增的两条规则（同工具连续 40 次，Bash 与 Write 单独放到 80 次 / 周期序列重复 10 轮）。
  *
  * 两者刻意并存：旧规则的静默语义已被线上验证，不因新能力回归。
  */

package/cli/dist-server/types/workspace/cbc-core/lib/node/agent/tool-call-loop-pattern.d.ts

@@ -5,11 +5,11 @@
  */
 import type { ToolCallLoopTriggerType } from '../../../../telemetry/lib/common/event/types/craft.js';
 export interface ToolCallLoopThresholds {
-    /** 同一工具连续调用达到该次数即判定为循环。Bash 走单独阈值。 */
+    /** 同一工具连续调用达到该次数即判定为循环。Bash / Write 走单独阈值。 */
     consecutiveThreshold: number;
     /**
-     * Bash 连续调用的单独阈值。长任务里模型会连续跑很多条不同命令，
-     * 只看工具名时 40 次容易把正常推进误判成循环。
+     * Bash 与 Write 连续调用的单独阈值。长任务里模型会连续跑很多条命令、
+     * 或连续落很多个文件，只看工具名时 40 次容易把正常推进误判成循环。
      */
     bashConsecutiveThreshold: number;
     /** AAB 块需要连续重复的轮数。 */
@@ -22,8 +22,9 @@ export interface ToolCallLoopHit {
     /** 重复序列的周期长度；AAB 恒为 3，连续同工具恒为 1。 */
     patternLength: number;
 }
-/** 与 `ToolNames.BASH` 对齐。模式识别层不依赖 agent-protocol，避免把工具名枚举拉进来。 */
+/** 与 `ToolNames.BASH` / `ToolNames.WRITE` 对齐。模式识别层不依赖 agent-protocol，避免把工具名枚举拉进来。 */
 export declare const BASH_LOOP_TOOL_NAME = "Bash";
+export declare const WRITE_LOOP_TOOL_NAME = "Write";
 export declare const DEFAULT_TOOL_CALL_LOOP_THRESHOLDS: ToolCallLoopThresholds;
 /** AAB 块的长度。多工具循环只识别这一种形状，因此是常量而非可配阈值。 */
 export declare const AAB_PERIOD = 3;
@@ -43,7 +44,7 @@ export declare class ToolCallLoopTracker {
      * 记录一次即将执行的工具调用，返回本次是否命中循环。
      *
      * 命中优先级：先判连续同工具，再判 AAB 重复。两条规则的阈值默认不重叠
-     * （普通工具 40 次、Bash 80 次 vs AAB 重复 10 轮），实践中不会互相抢占。
+     * （普通工具 40 次、Bash / Write 80 次 vs AAB 重复 10 轮），实践中不会互相抢占。
      */
     record(toolName: string): ToolCallLoopHit | undefined;
     /**
@@ -59,7 +60,7 @@ export declare class ToolCallLoopTracker {
  * - `ABC`（三者互不相同）通常是正常的多步工作流（读文件 → 改文件 → 跑测试，
  *   然后换下一个文件），按周期重复判它循环误伤面太大；
  * - `ABAB` 这类两工具交替同样不判，避免把翻页 / 分批处理误当循环；
- * - `AAA…` 属于连续同工具，由 consecutiveThreshold / bashConsecutiveThreshold 那条规则负责。
+ * - `AAA…` 属于连续同工具，由 consecutiveThreshold / bashConsecutiveThreshold（Bash、Write）那条规则负责。
  *
  * `X ≠ Y` 顺带保证了 AAB 一定是本原周期（唯一可能的更短整除周期是 1，
  * 那要求三个元素全等），所以不需要额外的本原性校验。
@@ -69,8 +70,8 @@ export declare function matchesRepeatedAabSequence(history: readonly string[], r
  * 读取阈值配置。环境变量只用于 QA 快速复现，生产不设置即走默认值。
  * AAB 的周期是形状定义的一部分，不开放配置。
  *
- * `CBC_LOOP_GUARD_CONSECUTIVE_THRESHOLD` 只覆盖非 Bash 工具。Bash 用
- * `CBC_LOOP_GUARD_BASH_CONSECUTIVE_THRESHOLD`，避免 QA 把通用阈值压低时
+ * `CBC_LOOP_GUARD_CONSECUTIVE_THRESHOLD` 只覆盖非 Bash / Write 工具。Bash 与 Write
+ * 共用 `CBC_LOOP_GUARD_BASH_CONSECUTIVE_THRESHOLD`，避免 QA 把通用阈值压低时
  * 把长任务放宽一并关掉。
  */
 export declare function resolveToolCallLoopThresholds(env?: NodeJS.ProcessEnv): ToolCallLoopThresholds;

package/cli/dist-server/types/workspace/cbc-core/lib/node/context/compaction-lineage.d.ts

@@ -0,0 +1,39 @@
+import type { CompactionKind, CompactionTrigger } from '../../../../telemetry/lib/common/index.js';
+import type { Session } from '../session/session-protocol.js';
+export type { CompactionKind, CompactionTrigger };
+export declare function compactionKindOf(trigger: CompactionTrigger): CompactionKind;
+/** Compactions of a Session's context. Never resets, like `modelStepSeq`. */
+export interface CompactionLineage {
+    /** Completed compactions. */
+    count: number;
+    /** Compaction the current context starts from. */
+    lastId?: string;
+    /** Trigger of the completed compaction the next agent-loop model call reports. */
+    pending?: CompactionTrigger;
+}
+type LineageSession = Pick<Session, 'id' | 'history' | 'compactionLineage' | 'meta'>;
+/** Compaction lineage of `session`, restored from its history after resume. */
+export declare function getCompactionLineage(session: LineageSession): CompactionLineage;
+/**
+ * Numbers a compaction boundary item before it enters history and stamps the running
+ * compaction onto it; the next agent-loop model call reports it.
+ */
+export declare function recordCompactionBoundary(session: LineageSession, providerData: Record<string, unknown>): void;
+/** Compaction lineage of one model call (gateway headers, `chat_message_send`). */
+export interface ModelCallCompaction {
+    /** Completed compactions of the Session when the call is sent. */
+    readonly count: number;
+    /** Compaction the call's context starts from. */
+    readonly id?: string;
+    /** Compaction calls: class of the running compaction (`X-Compaction`). */
+    readonly kind?: CompactionKind;
+    /** First agent-loop call after a compaction: its class (`X-Context-Compacted`) and trigger. */
+    readonly contextCompacted?: CompactionKind;
+    readonly trigger?: CompactionTrigger;
+}
+/**
+ * Compaction lineage for the model call in the current async chain. Only the first
+ * agent-loop call after a compaction reports it, like Claude Code's
+ * `consumePendingContextCompacted`.
+ */
+export declare function resolveModelCallCompaction(session: LineageSession & Pick<Session, 'agentPurpose' | 'conversationRequestId'>): ModelCallCompaction;

package/cli/dist-server/types/workspace/cbc-core/lib/node/context/context-compact-summarizer.d.ts

@@ -16,6 +16,7 @@ import { CompactStrategy, type ContextCompactResult, ContextCompactSummarizeOpti
  * 不包含任何具体的压缩逻辑实现。
  */
 export declare class ContextCompactSummarizerImpl implements ContextCompactSummarizer {
+    private activeCompactions?;
     protected readonly productManager: ProductManager;
     protected readonly agentManager: AgentManager;
     protected readonly logger: Logger;
@@ -25,6 +26,7 @@ export declare class ContextCompactSummarizerImpl implements ContextCompactSumma
     protected readonly strategyProvider: Provider<CompactStrategy>;
     compactAndSummarize(session: Session, options?: ContextCompactSummarizeOptions): Promise<boolean>;
     compactWithResult(session: Session, options?: ContextCompactSummarizeOptions): Promise<ContextCompactResult>;
+    private compactWithResultOwned;
     /**
      * 按优先级匹配（PreMessage → MaxToken），跳过 Blocking（仅作最终兜底），执行第一个命中的策略；
      * 都不命中则安全网回落到 Blocking。逻辑与压缩 span 化之前完全一致，只是把散落的 `return` 收敛成

package/cli/dist-server/types/workspace/cbc-core/lib/node/context/context-protocol.d.ts

@@ -1,7 +1,10 @@
+import type { AgentInputItem } from '../../../../cbc-shared/lib/node/index.js';
+import type { CompactionTrigger } from '../../../../telemetry/lib/common/index.js';
 import { Session } from '../session/session-protocol.js';
 export declare const PromptContextProvider: unique symbol;
 export declare const PromptContextInitializer: unique symbol;
 export declare const ContextCompactSummarizer: unique symbol;
+export declare const ManualCompactRequestHandler: unique symbol;
 export declare const PromptRenderer: unique symbol;
 export declare const COMPACT_PROMPT = "compact-prompt";
 export declare const DEFAULT_TOKEN_THRESHOLD = 0.7;
@@ -190,6 +193,8 @@ export interface ContextCompactSummarizeOptions {
     type?: CompactType;
     /** Stable identity shared by live updates and the durable compact boundary. */
     compactionId?: string;
+    /** Why this compaction runs; defaults from `type` (manual / pre_message_threshold / emergency_threshold). */
+    trigger?: CompactionTrigger;
 }
 export type ContextCompactSkipReason = 'already_compacting' | 'pending_interruption' | 'auto_disabled' | 'empty_history' | 'already_compacted' | 'non_default_agent' | 'below_threshold';
 export type ContextCompactFailureReason = 'strategy_failed' | 'strategy_unavailable';
@@ -214,6 +219,8 @@ export declare function createCompactionId(): string;
 export declare const SESSION_META_COMPACT_TYPE: 'compactType';
 /** Current stable compaction identity, persisted onto the boundary item. */
 export declare const SESSION_META_COMPACTION_ID: 'compactionId';
+/** Trigger of the compaction the summarizer is running; unset for a typed `/compact`. */
+export declare const SESSION_META_COMPACTION_TRIGGER: 'compactionTrigger';
 /**
  * session.meta 上标记当前 compact 成功后会继续执行一次真实 agent run。
  *
@@ -321,6 +328,16 @@ export interface ContextCompactSummarizer {
     /** Compatibility wrapper for existing automatic-compaction callers. */
     compactAndSummarize(session: Session, options?: ContextCompactSummarizeOptions): Promise<boolean>;
 }
+/**
+ * Host-owned boundary for external `/compact` requests.
+ *
+ * AgentService invokes this before creating a normal run lifecycle when an
+ * interactive host opts in. Implementations must return false for internal compact
+ * inputs so strategy-owned internal runs cannot recursively re-enter this boundary.
+ */
+export interface ManualCompactRequestHandler {
+    tryHandle(input: string | AgentInputItem[], session: Session): Promise<boolean>;
+}
 export interface PromptRenderer {
     render(template: string, context?: PromptContext): Promise<string>;
 }

package/cli/dist-server/types/workspace/cbc-core/lib/node/context/index.d.ts

@@ -1,4 +1,5 @@
 export * from './context-protocol.js';
+export * from './compaction-lineage.js';
 export * from './context-host-protocol.js';
 export * from './prompt-context-provider.js';
 export * from './prompt-renderer.js';

package/cli/dist-server/types/workspace/cbc-core/lib/node/context/pre-message-compact-strategy.d.ts

@@ -4,8 +4,7 @@ import { CompactStrategyContext, ContextCompactSummarizeOptions } from './contex
 /**
  * PreMessage 压缩策略：在发送用户消息前触发。
  *
- * 触发条件：PRE_MESSAGE_AUTO 或 WorkBuddy 的 USER_COMMAND。
- * CBC 手动 /compact 不走该策略，继续由 compact agent 路径处理。
+ * 触发条件：PRE_MESSAGE_AUTO 或 USER_COMMAND（WorkBuddy / TUI 手动压缩）。
  *
  * 流程：
  * 1. Engineering compact (no LLM call)

package/cli/dist-server/types/workspace/cbc-core/lib/node/session/index.d.ts

@@ -36,6 +36,7 @@ export * from './stream-timeout-retry-budget.js';
 export { consumeRecoveryRequestPending } from './recovery-budget.js';
 export * from './session-run-state-machine-protocol.js';
 export * from './session-run-state-machine.js';
+export * from './model-request-retry-phase.js';
 export * from './session-run-state-projection-service.js';
 export * from './local-jsonl-session-store.js';
 export * from './transcript-branch.js';

package/cli/dist-server/types/workspace/cbc-core/lib/node/session/interruption-service.d.ts

@@ -93,6 +93,13 @@ export declare class InterruptionServiceImpl implements InterruptionService {
     protected readonly idleQueueDrainService?: IIdleQueueDrainService;
     protected readonly traceCollector?: SessionInterruptionTraceHost;
     protected get startupProfiler(): SessionInterruptionProfilerHost;
+    /**
+     * 标记「用户取消本轮」的拒绝项（`reject(item, { cancelTurn: true })`）。
+     * 语义是取消当前 turn，而不是「拒绝并让模型带反馈续跑」。
+     * 记在 WeakSet 而不是 `rawItem.providerData`（那会落进历史），也不改
+     * deferred 的 reject 形状（下游按 error 类型分支的逻辑保持不变）。
+     */
+    private readonly cancelTurnItems;
     /** Claim before calling out: sandbox callbacks can throw or synchronously re-enter. */
     private takeSandboxResolve;
     approve(item: RunToolApprovalItem, options?: {
@@ -101,6 +108,7 @@ export declare class InterruptionServiceImpl implements InterruptionService {
     }): void;
     reject(item: RunToolApprovalItem, options?: {
         decision?: 'deny' | 'rejectAndExitPlan';
+        cancelTurn?: boolean;
     }): void;
     /**
      * 取消指定 session 上所有未决的 interruption Deferred。

package/cli/dist-server/types/workspace/cbc-core/lib/node/session/model-request-retry-phase.d.ts

@@ -0,0 +1,16 @@
+import type { AgentRetryReason, Session } from './session-protocol.js';
+import { ModelRequestRetryPhase, SessionRunStateMachine } from './session-run-state-machine-protocol.js';
+export declare class ModelRequestRetryPhaseImpl implements ModelRequestRetryPhase {
+    protected readonly stateMachine: SessionRunStateMachine;
+    during<T>(session: Session | undefined, reason: AgentRetryReason, wait: () => Promise<T>): Promise<T>;
+    /**
+     * 辅助型调用复用主 session 却不回送 AGENT_ENDED（#52320），不得驱动其状态；
+     * 状态已离开 MODEL_REQUESTING 说明另有路径在推进，此时不抢写。
+     */
+    private enter;
+    /**
+     * 必须回到 MODEL_REQUESTING：RETRYING 不接收 TOOL_STARTED / MODEL_RESPONSE_DONE 等后续事件，
+     * 停留会让错误处理路径的转换被静默忽略。已被取消等事件推走时不再改写。
+     */
+    private leave;
+}

package/cli/dist-server/types/workspace/cbc-core/lib/node/session/model-response-interceptors.d.ts

@@ -215,6 +215,21 @@ export declare class MediaContentErrorInterceptor implements ModelResponseInterc
     private static readonly MAX_RETRY_ATTEMPTS;
     private static readonly MAX_MIME_MISMATCH_RETRY_ATTEMPTS;
     private static readonly GIF_UNSUPPORTED_ERROR_CODES;
+    /**
+     * Gateway business codes that mean "the model refused the images in this
+     * request" (`11135 InvalidInputImage`).
+     *
+     * The code is the only stable signal. The gateway folds several unrelated
+     * upstream causes into one hard-coded English sentence and overwrites the
+     * upstream text, so `ERROR_TYPE_PATTERNS` matching that sentence breaks the
+     * moment the wording is changed or localized (`docs/error-codes.md` already
+     * ships a Chinese user-facing string for this code). The code is carried on
+     * the error object all the way here — `error-analyzer` puts the parsed body
+     * code into the response, the SDK surfaces it as `APIError.error.code`, and
+     * `ErrorUtils.extractBizCode` recovers it — so key off it and keep the
+     * phrasing match only as a fallback for gateways that send no code.
+     */
+    private static readonly IMAGE_REJECTED_ERROR_CODES;
     private static readonly GIF_UNSUPPORTED_PLACEHOLDER;
     private static readonly ERROR_TYPE_PATTERNS;
     intercept(ctx: ModelResponseInterceptorContext): Promise<boolean | void>;

package/cli/dist-server/types/workspace/cbc-core/lib/node/session/session-manager-host-protocol.d.ts

@@ -1,5 +1,5 @@
 import type { AgentInputItem } from '../../../../cbc-shared/lib/node/index.js';
-import type { ModelResponseMetadata, Session } from './session-protocol.js';
+import type { ModelCallGeneration, ModelResponseMetadata, Session } from './session-protocol.js';
 export declare const SessionCheckpointHost: unique symbol;
 export interface SessionCheckpointHost {
     createCheckpoint(session: Session): Promise<void>;
@@ -57,7 +57,8 @@ export declare const SessionResponseTelemetryHost: unique symbol;
 export interface SessionResponseTelemetryHost {
     reportChatRequestResponseTelemetry(session: Session, result: NonNullable<Session['resultSubject']['value']>, isSuccessful: boolean, error: unknown, metadata: ModelResponseMetadata): Promise<void>;
     reportMessageResponseTelemetryStream(session: Session, usage: SessionResponseUsage | undefined, metadata: ModelResponseMetadata, error: unknown): Promise<void>;
-    reportChatMessageStatus(session: Session, errorCode: string, error?: unknown): Promise<void>;
+    /** Status of one model call (`generation`); run failures no model call owns are not reported. */
+    reportChatMessageStatus(session: Session, errorCode: string, generation: ModelCallGeneration, error?: unknown): Promise<void>;
 }
 export type SessionResponseTelemetrySnapshot = Pick<NonNullable<Session['telemetry']>, 'modelId' | 'modelName' | 'currentTurn' | 'traceId'>;
 export declare const SessionResponseObserver: unique symbol;

package/cli/dist-server/types/workspace/cbc-core/lib/node/session/session-manager.d.ts

@@ -4,7 +4,7 @@ import { Logger } from '../../../../telemetry/lib/common/index.js';
 import { BehaviorSubject } from 'rxjs';
 import { SessionRequestContextHost, SessionSettingsHost as SettingsManager, SessionUsageHost as UserStateManager } from './session-host-protocol.js';
 import { SessionBackgroundTaskHost as ToolManager, SessionCheckpointHost as CheckpointService, SessionProgressHost as ProgressSyncService, SessionResponseObserver as GalileoSessionBridge, SessionResponseTelemetryHost as TelemetryService, SessionSchedulerHost as CronSchedulerService, SessionSensitiveProjectionHost, SessionTaskLifecycleHost as AgentTaskManager } from './session-manager-host-protocol.js';
-import { AgentInputItemProcessor, InterruptionService, ModelResponseInterceptor, ModelResponseMetadata, Session, SessionFactory, SessionGetOptions, SessionHookManager, SessionManager, SessionStore } from './session-protocol.js';
+import { AgentInputItemProcessor, InterruptionService, ModelResponseInterceptor, ModelResponseMetadata, OverrideModelSource, Session, SessionFactory, SessionGetOptions, SessionHookManager, SessionManager, SessionStore } from './session-protocol.js';
 import { SessionRunStateMachine } from './session-run-state-machine-protocol.js';
 export declare class SessionManagerImpl implements SessionManager, ApplicationLifecycle<Application> {
     protected readonly sessionFactory: SessionFactory;
@@ -44,6 +44,8 @@ export declare class SessionManagerImpl implements SessionManager, ApplicationLi
     private readonly liveSessionsById;
     private overridePermissionModes;
     private overrideModels;
+    /** 与 overrideModels 同生命周期的意图来源（user / declared / materialized）。 */
+    private overrideModelSources;
     /**
      * Issue #12554：会话级 thinking override（按 sessionId 隔离）。
      * 由 ACP setSessionConfigOption('thought_level') 或 prompt _meta 写入。
@@ -190,9 +192,11 @@ export declare class SessionManagerImpl implements SessionManager, ApplicationLi
     rename(session: Session, name: string): Promise<void>;
     setOverridePermissionMode(sessionId: string, mode: PermissionMode): void;
     getOverridePermissionMode(sessionId: string): PermissionMode | undefined;
-    setOverrideModel(sessionId: string, model: string): void;
+    setOverrideModel(sessionId: string, model: string, source?: OverrideModelSource): void;
     getOverrideModel(sessionId: string): string | undefined;
-    setRuntimeModel(session: Session | undefined, modelId: string): void;
+    getOverrideModelSource(sessionId: string): OverrideModelSource | undefined;
+    clearOverrideModel(sessionId: string): void;
+    setRuntimeModel(session: Session | undefined, modelId: string, source?: OverrideModelSource): void;
     setRuntimeOutputStyle(session: Session | undefined, style: string): void;
     /**
      * Issue #83229：把 settings.json 中的 model / outputStyle 读一次"钉"进 session.options，

package/cli/dist-server/types/workspace/cbc-core/lib/node/session/session-protocol.d.ts

@@ -2,6 +2,7 @@ import { Deferred } from '@celljs/core';
 import { type AgentInputItem, ApprovalOptions, type Checkpoint, FinalStopReason, NotificationType, PermissionMode, ReasoningEffortLevel, type ResponseStreamEvent, type RunItem, type RunResult, type RunState, type RunToolApprovalItem, type SdkCapabilities, SessionEndReason, SessionStartSource, type StreamedRunResult, type TerminalEvent, type ToolDeferOverlaySnapshot, ToolPermissionContext, type Usage } from '../../../../cbc-shared/lib/node/index.js';
 import { Command } from '../../../../product/lib/common/index.js';
 import { BehaviorSubject, Subject } from 'rxjs';
+import type { CompactionLineage } from '../context/compaction-lineage.js';
 import { BackgroundTask } from './background-task-protocol.js';
 import type { SessionRunStateSnapshot } from './session-run-state-machine-protocol.js';
 import type { Lane, LanePointer, SessionKey, SessionStoreEntry } from './session-store-contract.js';
@@ -86,6 +87,7 @@ export type AgentState = 'agent_pending' | 'agent_start' | 'agent_tool_start' |
  *                              则 emit，触发 UI 显示"正在同步文件"提示)
  */
 export type AgentPhase = 'preparing' | 'model_requesting' | 'model_streaming' | 'model_done' | 'tool_executing' | 'waiting_for_permission' | 'waiting_for_user' | 'retrying' | 'finalization_file_projection_sync' | 'finalization_file_projection_sync_notify' | 'idle';
+export type AgentRetryReason = 'network';
 export interface AgentPhaseInfo {
     phase: AgentPhase;
     toolName?: string;
@@ -102,6 +104,13 @@ export interface AgentPhaseInfo {
         current: number;
         total: number;
     };
+    /**
+     * 仅 retrying phase 使用，经 ACP `_meta['codebuddy.ai/agentPhase']` 透传给上层。
+     * 缺省表示原因未分类（如流超时），不代表网络正常。
+     */
+    retry?: {
+        reason: AgentRetryReason;
+    };
 }
 export declare const AgentPhaseUtils: {
     /** Create an AgentPhaseInfo with the current timestamp. */
@@ -353,6 +362,14 @@ export interface Session {
      * field and pass it through as `options.maxTurns` explicitly.
      */
     lastRunMaxTurns?: number;
+    /**
+     * Latest agent-loop model call number (`providerData.stepSeq`). Unlike the
+     * SDK turn counter it survives runs, compaction and resume; see
+     * `allocateModelStepSeq`.
+     */
+    modelStepSeq?: number;
+    /** Compactions of this Session's context; see `getCompactionLineage`. */
+    compactionLineage?: CompactionLineage;
     queue: AgentInputItem[];
     queueSubject: BehaviorSubject<AgentInputItem[]>;
     /**
@@ -860,7 +877,7 @@ export interface SubagentInvocationRecord {
     lifecycle: SubagentLifecycleSnapshot;
 }
 export type SubagentLifecycleDescriptor = Omit<SubagentLifecycleSnapshot, 'status' | 'updatedAt' | 'usage'>;
-export type CombineEvent = (AgentInputItemEvent | ModelRawResponseEvent | ResultEndEvent | InterruptResultEvent | NoticeEvent | SubagentStatusEvent | CompactionLifecycleEvent | TerminalEvent) & CombineEventMeta;
+export type CombineEvent = (AgentInputItemEvent | AgentSdkStreamEvent | ModelRawResponseEvent | ResultEndEvent | InterruptResultEvent | NoticeEvent | SubagentStatusEvent | CompactionLifecycleEvent | TerminalEvent) & CombineEventMeta;
 export interface CompactionLifecycleEvent {
     type: 'compaction';
     data: {
@@ -875,6 +892,11 @@ export interface SubagentStatusEvent {
     type: 'subagent_status';
     data: SubagentLifecycleSnapshot;
 }
+/** Original SDK stream payload, observed by the existing single stream consumer. */
+export interface AgentSdkStreamEvent {
+    type: 'sdk';
+    data: import('../../../../cbc-shared/lib/node/index.js').RunStreamEvent;
+}
 export interface AgentInputItemEvent {
     type: 'input';
     data: AgentInputItem;
@@ -1063,6 +1085,13 @@ export interface SessionRewindMutationOptions {
     cwd: string;
     headMessageId: string | undefined;
 }
+/**
+ * model override 的意图来源：决定该值是否等价于「用户显式选择」。
+ * - 'user'：/model 命令、ACP set_model、SDK 控制信号等用户动作；
+ * - 'declared'：主 Agent 声明模型（declaredModel）联动写入；
+ * - 'materialized'：Web UI 会话装配期钉住的兜底解析值（非用户意图）。
+ */
+export type OverrideModelSource = 'user' | 'declared' | 'materialized';
 export interface SessionManager {
     getCurrent(): Session;
     setCurrent(session: Session): void;
@@ -1165,11 +1194,15 @@ export interface SessionManager {
     setOverridePermissionMode(sessionId: string, mode: PermissionMode): void;
     getOverridePermissionMode(sessionId: string): PermissionMode | undefined;
     /**
-     * 设置 session 的 model 覆盖值（来自 SDK control signal）
-     * 这些值会覆盖 CLI 参数和配置文件的设置
+     * 设置 session 的 model 覆盖值。source 记录意图来源，供「是否用户显式选择」判定：
+     * - 'user'（默认）：/model 命令、ACP set_model、SDK 控制信号等用户动作；
+     * - 'declared'：主 Agent 声明模型（declaredModel）联动写入；
+     * - 'materialized'：Web UI 会话装配期钉住的兜底解析值（非用户意图）。
      */
-    setOverrideModel(sessionId: string, model: string): void;
+    setOverrideModel(sessionId: string, model: string, source?: OverrideModelSource): void;
     getOverrideModel(sessionId: string): string | undefined;
+    getOverrideModelSource(sessionId: string): OverrideModelSource | undefined;
+    clearOverrideModel(sessionId: string): void;
     /**
      * 设置会话运行时模型：同步写 session.options.model + requestOptions.model + override map。
      *
@@ -1178,7 +1211,7 @@ export interface SessionManager {
      * 供 applyOverrideModel 每轮重建 requestOptions（Issue #82146）。/model 命令与模型面板
      * 共用此入口；ACP set_model（applyRuntimeSessionModel）仍为独立实现，待统一收敛。
      */
-    setRuntimeModel(session: Session | undefined, modelId: string): void;
+    setRuntimeModel(session: Session | undefined, modelId: string, source?: OverrideModelSource): void;
     /**
      * 设置会话运行时 outputStyle：同步写 session.options.outputStyle。
      *
@@ -1502,6 +1535,7 @@ export interface InterruptionService {
     approve(item: RunToolApprovalItem, options?: ApprovalOptions): void;
     reject(item: RunToolApprovalItem, options?: {
         decision?: 'deny' | 'rejectAndExitPlan';
+        cancelTurn?: boolean;
     }): void;
     waitFor(session: Session): Promise<void>;
     /** Resolve the main/leader session for a given session (returns self if already main). */
@@ -1712,6 +1746,12 @@ export interface TurnMetricsReporter {
      */
     unregister(sessionId: string): void;
 }
+/** Ids of one model call, as stamped by the model wrapper. */
+export interface ModelCallGeneration {
+    messageId: string;
+    conversationRequestId?: string;
+    stepSeq?: number;
+}
 export interface ModelResponseMetadata {
     /** 响应中的模型 ID */
     model?: string;
@@ -1725,6 +1765,8 @@ export interface ModelResponseMetadata {
      * 都带 providerData.messageId === 此值，handleContentFilteredResponse 据此剔除并替换为安全提示。
      */
     contentFilterMessageId?: string;
+    /** Correlation of the generation that just completed, as stamped by the model wrapper. */
+    generation?: ModelCallGeneration;
     usage?: {
         prompt_tokens: number;
         completion_tokens: number;

package/cli/dist-server/types/workspace/cbc-core/lib/node/session/session-run-state-machine-protocol.d.ts

@@ -1,5 +1,5 @@
 import type { Observable } from 'rxjs';
-import type { Session } from './session-protocol.js';
+import type { AgentRetryReason, Session } from './session-protocol.js';
 export declare const SessionRunStateMachine: unique symbol;
 export declare const SessionRunStateProjectionService: unique symbol;
 export declare const SESSION_RUN_STATE_PROJECTION_SCHEMA: 'session-run-state.v1';
@@ -144,6 +144,7 @@ export type SessionRunEvent = {
 } | {
     type: SessionRunEventType.RETRYING;
     reason?: string;
+    retryReason?: AgentRetryReason;
 } | {
     type: SessionRunEventType.COMPACT_STARTED;
     reason?: string;
@@ -189,6 +190,18 @@ export interface SessionRunStateMachine {
      */
     getChange$(session: Session, skipFirst?: boolean): Observable<void>;
 }
+export declare const ModelRequestRetryPhase: unique symbol;
+/**
+ * 模型请求层（宿主 provider）在同一次请求内部退避重发时，借此把会话投影为 retrying。
+ * 状态写入与守卫收口在 core，宿主只包住退避等待，不直接驱动状态机。
+ */
+export interface ModelRequestRetryPhase {
+    /**
+     * `wait` 期间会话显示 retrying 并携带 `reason`；结束（含抛错 / 取消）后恢复 model_requesting。
+     * 非本轮主请求（无 session、辅助型 purpose、状态不在 model_requesting）时只执行 `wait`。
+     */
+    during<T>(session: Session | undefined, reason: AgentRetryReason, wait: () => Promise<T>): Promise<T>;
+}
 /**
  * Pure derivations from a `SessionRunStatus`. The state machine implementation
  * MUST keep its instance methods (`getLifecycle`, `isBusy`, etc.) consistent

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

@@ -9,11 +9,18 @@ export declare function hasExhaustedStreamTimeoutRetryBudget(session: Session, i
 /**
  * `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 / no-token + finish_reason=error：上游瞬时失败，按 error 预算重试。
+ * reasoning-only / no-token + finish_reason=error：上游瞬时失败，按 error 预算重试；
+ * 已烧满上游硬时限的那些除外，见 {@link isRetryableEmptyStreamError} 的时长闸门（#132616）。
  * 流空闲超时 / 首 token 超时：按各自的超时预算重试。
  */
 export declare function shouldAutoRetryStreamTimeout(session: Session, error: unknown): boolean;

package/cli/dist-server/types/workspace/cbc-core/lib/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/workspace/cbc-core/lib/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;
     /**
      * 解析计划输出
      */