@tencent-ai/agent-harness 0.2.0-beta.6 → 0.2.0-beta.8

package/cli/dist-server/types/node/session/session-history-clean-service.d.ts

@@ -0,0 +1,49 @@
+import { Application, ApplicationLifecycle, Logger } from '@celljs/core';
+import { FileVersionStore } from '../../workspace/cbc-checkpoint/lib/node/index.js';
+import { SessionHistoryCleanService, type SessionHistoryCleanupOptions, type SessionHistoryCleanupResult, SessionManager } from '../../vendor/cbc-core/node/index.js';
+import { type IPrewarmStateService } from '../prewarm/prewarm-protocol';
+import { SettingsManager } from '../settings';
+export { ENV_KEY_CODEBUDDY_DISABLE_SESSION_HISTORY_CLEANUP, isSessionHistoryCleanupDisabled } from './session-history-clean-flag';
+export declare class SessionHistoryCleanServiceImpl implements SessionHistoryCleanService, ApplicationLifecycle<Application> {
+    protected readonly logger: Logger;
+    protected readonly settingsManager: SettingsManager;
+    protected readonly fileVersionStore: FileVersionStore;
+    protected readonly sessionManager?: SessionManager;
+    protected readonly prewarmState?: IPrewarmStateService;
+    private cleanupInterval?;
+    private startupTimeout?;
+    initialize(): void;
+    start(): Promise<void>;
+    stop(): void;
+    cleanup(): Promise<void>;
+    cleanupLocalData(options?: SessionHistoryCleanupOptions): Promise<SessionHistoryCleanupResult>;
+    private runCleanup;
+    private createCleanupResult;
+    private resolveExplicitDays;
+    private resolveCleanupPeriodDays;
+    private ensureStorageDir;
+    private getSessionFilesRecursively;
+    private getSessionMetaFilePath;
+    private deleteExpiredSessionFile;
+    private getSessionJsonlLayout;
+    private isSessionJsonlInUse;
+    private isLikelyMainSessionId;
+    private isLikelySubagentSessionId;
+    private cleanupSessionArtifactsForJsonl;
+    private cleanupOrphanSessionArtifacts;
+    private cleanupOrphanSubagentArtifactDirs;
+    private cleanupOrphanSessionDir;
+    private hasGeneratedChild;
+    private cleanupGeneratedChildren;
+    private cleanupOldPathRecursively;
+    private pathExists;
+    private removeEmptyDirectory;
+    private isTraceCleanupCandidate;
+    /**
+     * Clean up expired trace files from all project directories.
+     * Uses the same retention period as session history (cleanupPeriodDays).
+     */
+    private cleanupExpiredTraces;
+    private cleanupSafeAuxiliaryPaths;
+    private getCleanupPeriodDays;
+}

package/cli/dist-server/types/node/session/session-hook-host-adapter.d.ts

@@ -0,0 +1,21 @@
+import { CoreHookExecutor, type HookInput, type Session, SessionHookHost } from '../../vendor/cbc-core/node/index.js';
+import type { HookEvent, HookExecutionOptions, HookExecutionResult, NotificationType } from '../../vendor/cbc-shared/node/index.js';
+import { Logger } from '../../workspace/telemetry/lib/common/index.js';
+import { HookManager } from '../hooks/hook-protocol';
+import { TerminalNotificationService } from '../notification/notification-protocol';
+export declare class CoreHookExecutorAdapter implements CoreHookExecutor {
+    protected readonly hooks: HookManager;
+    executeHooks(event: HookEvent, input: HookInput, options?: HookExecutionOptions): Promise<HookExecutionResult>;
+    hasHooks(event: HookEvent, toolName?: string): Promise<boolean>;
+}
+export declare class SessionHookHostAdapter implements SessionHookHost {
+    readonly notificationTitle: string;
+    protected readonly logger: Logger;
+    protected readonly notifications: TerminalNotificationService;
+    getWorkDir(): string;
+    sendNotification(message: string, type: NotificationType | undefined, session: Session | undefined): Promise<void>;
+    registerWatchPaths(paths: unknown, onChange: (path: string, event: 'change' | 'add' | 'unlink') => void | Promise<void>): {
+        watcherCount: number;
+        dispose(): void;
+    };
+}

package/cli/dist-server/types/node/session/session-host-adapter.d.ts

@@ -0,0 +1,34 @@
+import { type Session, SessionConsoleHost, SessionRequestContextHost, SessionSettingsHost, type SessionSettingsValues, SessionStartupHost, SessionUsageHost } from '../../vendor/cbc-core/node/index.js';
+import { ConsoleManager } from '../console';
+import { DirectoryTrustService } from '../permission';
+import { SettingsManager } from '../settings';
+import { UserStateManager } from '../tips';
+import { AutoModePermissionService } from '../tools/auto-mode/auto-mode-protocol';
+export declare class SessionSettingsHostAdapter implements SessionSettingsHost {
+    protected readonly settings: SettingsManager;
+    get<K extends keyof SessionSettingsValues>(key: K): Promise<SessionSettingsValues[K]>;
+    getStartupModel(): Promise<string | undefined>;
+}
+export declare class SessionUsageHostAdapter implements SessionUsageHost {
+    protected readonly usage?: UserStateManager;
+    incrementSession(): Promise<void>;
+    incrementPromptQueue(): Promise<void>;
+}
+export declare class SessionConsoleHostAdapter implements SessionConsoleHost {
+    protected readonly console: ConsoleManager;
+    error(...args: unknown[]): void;
+}
+export declare class SessionRequestContextHostAdapter implements SessionRequestContextHost {
+    get(): Session | undefined;
+    set(session: Session): void;
+}
+export declare class SessionStartupHostAdapter implements SessionStartupHost {
+    protected readonly trust: DirectoryTrustService;
+    protected readonly autoMode: AutoModePermissionService;
+    waitForPluginRefresh(): Promise<void>;
+    waitForDirectoryTrust(): Promise<void>;
+    isAutoModeAvailable(): Promise<{
+        available: boolean;
+    }>;
+    isSettingsAutoGrantAllowed(): Promise<boolean>;
+}

package/cli/dist-server/types/node/session/session-http-protocol.d.ts

@@ -0,0 +1 @@
+export declare const SESSION_MIDDLEWARE_PRIORITY: number;

package/cli/dist-server/types/node/session/session-interruption-host-adapter.d.ts

@@ -0,0 +1,115 @@
+import { type InterruptionToolRiskApprovalMetadata, type Session, SessionApprovalMemoryHost, SessionBackgroundApprovalHost, SessionChannelPermissionHost, SessionInterruptionBroadcastHost, SessionInterruptionInteractionHost, SessionInterruptionProfilerHost, SessionInterruptionRecoveryHost, SessionInterruptionSecurityHost, SessionInterruptionToolHost, SessionInterruptionTraceHost, SessionPermissionHookHost, SessionSdkPermissionHost } from '../../vendor/cbc-core/node/index.js';
+import { type FunctionCallItem, type RunToolApprovalItem } from '../../vendor/cbc-shared/node/index.js';
+import { Logger } from '../../workspace/telemetry/lib/common/index.js';
+import { AcpBroadcastService } from '../acp/acp-protocol';
+import { rewriteUnknownToolForCodeMode } from '../agent/main-agent-session';
+import { BackgroundTaskToolApprovalService } from '../agent-task/agent-task-protocol';
+import { resolveSessionAskUserQuestionHandler } from '../ask/session-ask-user-question-handler';
+import { ChannelPermissionAdapter } from '../channel/channel-protocol';
+import { SdkHooksManager, SdkPermissionClient } from '../control-signal/control-signal-protocol';
+import { isLibraryRuntime } from '../library-runtime';
+import { shouldKeepLiveDetachedWorkerHitl } from '../multitask/session-flags';
+import { isUnrestrictedPermissionMode } from '../permission/codebuddy-sandbox-env';
+import { type SecurityReviewGate as SecurityReviewGateContract } from '../security-review/protocol';
+import { type SettingsManager as SettingsManagerContract } from '../settings/settings-protocol';
+import { bindResolvedSkillApprovalDecision, clearResolvedSkillApprovalDecision, getBoundSkillApprovalDecision, resolveSkillApprovalRejectionContent } from '../skills/skill-approval';
+import { type SandboxTelemetryReporter as SandboxTelemetryReporterContract } from '../telemetry/sandbox-telemetry-protocol';
+import { StartupProfiler } from '../telemetry/startup-profiler-protocol';
+import { getSandboxReviewOperation } from '../tools/sandbox-approval-review';
+import { ToolAlwaysApprovalService, ToolManager } from '../tools/tool-protocol';
+import { type ToolRiskReviewService as ToolRiskReviewServiceContract } from '../tools/tool-risk-review/protocol';
+type WorkflowSourceResolverType = import('../../workspace/cbc-workflow/lib/node/index.js').WorkflowSourceResolver;
+type TraceCollector = import('../trace/trace-collector-protocol').TraceCollectorService;
+export declare class CliSessionInterruptionToolHost implements SessionInterruptionToolHost {
+    protected readonly toolManager: ToolManager;
+    resolveRejectedResult(toolName: string, item: FunctionCallItem): ReturnType<SessionInterruptionToolHost['resolveRejectedResult']>;
+    isUnrestrictedPermissionMode: typeof isUnrestrictedPermissionMode;
+    bindSkillApprovalDecision: typeof bindResolvedSkillApprovalDecision;
+    clearSkillApprovalDecision: typeof clearResolvedSkillApprovalDecision;
+    getBoundSkillApprovalDecision: typeof getBoundSkillApprovalDecision;
+    resolveSkillApprovalRejectionContent: typeof resolveSkillApprovalRejectionContent;
+    readonly rejectionDisplay: string;
+    isDangerousCommand(command: string): boolean;
+}
+export declare class CliSessionApprovalMemoryHost implements SessionApprovalMemoryHost {
+    protected readonly service: ToolAlwaysApprovalService;
+    approve(...args: Parameters<SessionApprovalMemoryHost['approve']>): Promise<void>;
+    isApproved(...args: Parameters<SessionApprovalMemoryHost['isApproved']>): boolean;
+    getSessionApprovalRules(session: Session, item: RunToolApprovalItem): ReturnType<ToolAlwaysApprovalService['getSessionApprovalRules']>;
+}
+export declare class CliSessionInterruptionSecurityHost implements SessionInterruptionSecurityHost {
+    protected readonly gate: SecurityReviewGateContract;
+    protected readonly reviews?: ToolRiskReviewServiceContract;
+    protected readonly telemetry?: SandboxTelemetryReporterContract;
+    protected readonly logger?: Logger;
+    protected readonly settingsManager?: SettingsManagerContract;
+    getPresentedApproval(item: RunToolApprovalItem, approvalSession?: Session): InterruptionToolRiskApprovalMetadata | undefined;
+    attachApproval(session: Session, item: RunToolApprovalItem): InterruptionToolRiskApprovalMetadata | undefined;
+    getTrustedApproval(session: Session, item: RunToolApprovalItem): InterruptionToolRiskApprovalMetadata | undefined;
+    recordApprovalDecision(input: Parameters<SessionInterruptionSecurityHost['recordApprovalDecision']>[0]): void;
+    recordExecutionStatus(session: Session, toolCallId: string, status: 'not_started'): void;
+    getAssistedApprovalMode(session: Session, scope: 'tool' | 'sandbox'): ReturnType<SecurityReviewGateContract['getAssistedApprovalMode']>;
+    getSandboxReviewOperation: typeof getSandboxReviewOperation;
+    reviewSandboxOperation(operation: unknown, signal: AbortSignal, context?: Parameters<SessionInterruptionSecurityHost['reviewSandboxOperation']>[2]): ReturnType<SessionInterruptionSecurityHost['reviewSandboxOperation']>;
+    recordSandboxReviewResult(session: Session, input: Parameters<NonNullable<SessionInterruptionSecurityHost['recordSandboxReviewResult']>>[1]): void;
+    reportAutomaticApprovalOutcome(input: Parameters<NonNullable<SessionInterruptionSecurityHost['reportAutomaticApprovalOutcome']>>[0]): void;
+    recordSecurityApprovalDecision(session: Session, input: Parameters<SessionInterruptionSecurityHost['recordSecurityApprovalDecision']>[1]): void;
+}
+export declare class CliSessionBackgroundApprovalHost implements SessionBackgroundApprovalHost {
+    protected readonly service: BackgroundTaskToolApprovalService;
+    isBackgroundTaskSession(session: Session): boolean;
+    approve(...args: Parameters<SessionBackgroundApprovalHost['approve']>): void;
+    handleRejection(...args: Parameters<SessionBackgroundApprovalHost['handleRejection']>): ReturnType<SessionBackgroundApprovalHost['handleRejection']>;
+    shouldKeepLiveDetachedWorkerHitl: typeof shouldKeepLiveDetachedWorkerHitl;
+}
+export declare class CliSessionInterruptionInteractionHost implements SessionInterruptionInteractionHost {
+    protected readonly workflowSourceResolver?: WorkflowSourceResolverType;
+    protected readonly sdkHooksManager: SdkHooksManager;
+    protected readonly logger: Logger;
+    resolveAskHandler: typeof resolveSessionAskUserQuestionHandler;
+    isLibraryRuntime: typeof isLibraryRuntime;
+    /**
+     * 同一个判据在 AskUserQuestionTool 的可见性门控里也用着：SDK 没在
+     * initialize 里声明这个能力，就没人能渲染问题卡，推过去只会挂死。
+     */
+    supportsStreamJsonAskUserQuestion(): boolean;
+    preloadWorkflowSource(item: RunToolApprovalItem): Promise<void>;
+}
+export declare class CliSessionSdkPermissionHost implements SessionSdkPermissionHost {
+    protected readonly service: SdkPermissionClient;
+    requestPermission(...args: Parameters<SessionSdkPermissionHost['requestPermission']>): ReturnType<SessionSdkPermissionHost['requestPermission']>;
+    cancelByToolUseId(toolUseId: string, resolvedBy: string, decision?: 'allow' | 'deny'): void;
+}
+export declare class CliSessionPermissionHookHost implements SessionPermissionHookHost {
+    protected readonly service: SdkHooksManager;
+    getHooks(event: 'PermissionRequest'): ReturnType<SessionPermissionHookHost['getHooks']>;
+    invokeCallback(...args: Parameters<SessionPermissionHookHost['invokeCallback']>): Promise<void>;
+}
+export declare class CliSessionChannelPermissionHost implements SessionChannelPermissionHost {
+    protected readonly service?: ChannelPermissionAdapter;
+    isAvailable(): boolean;
+    createPermissionRequest(...args: Parameters<SessionChannelPermissionHost['createPermissionRequest']>): ReturnType<SessionChannelPermissionHost['createPermissionRequest']>;
+    cancelRequest(toolCallId: string): void;
+}
+export declare class CliSessionInterruptionBroadcastHost implements SessionInterruptionBroadcastHost {
+    protected readonly service?: AcpBroadcastService;
+    broadcastInterruptionRequest(...args: Parameters<SessionInterruptionBroadcastHost['broadcastInterruptionRequest']>): Promise<void>;
+    broadcastPermissionResolved(...args: Parameters<SessionInterruptionBroadcastHost['broadcastPermissionResolved']>): Promise<void>;
+}
+export declare class CliSessionInterruptionRecoveryHost implements SessionInterruptionRecoveryHost {
+    rewriteUnknownToolForCodeMode: typeof rewriteUnknownToolForCodeMode;
+    codeModeDirectCallGuidance(session: Session, toolName: string): string | undefined;
+    isDeferredTool(toolName: string): boolean;
+    getTasks(): ReturnType<SessionInterruptionRecoveryHost['getTasks']>;
+    getDebugEmptyDrainLoopCount(): number;
+}
+export declare class CliSessionInterruptionTraceHost implements SessionInterruptionTraceHost {
+    protected readonly service?: TraceCollector;
+    flushSession(...args: Parameters<SessionInterruptionTraceHost['flushSession']>): Promise<number | undefined>;
+}
+export declare class CliSessionInterruptionProfilerHost implements SessionInterruptionProfilerHost {
+    protected get profiler(): StartupProfiler | undefined;
+    markStart(phase: string, label: string): void;
+    markEnd(phase: string): void;
+}
+export {};

package/cli/dist-server/types/node/session/session-manager-host-adapter.d.ts

@@ -0,0 +1,100 @@
+import type { SecurityReviewConclusion } from '../../workspace/agent-client-protocol/lib/common/index.js';
+import { CheckpointService } from '../../workspace/cbc-checkpoint/lib/node/index.js';
+import { type ModelCallGeneration, type ModelResponseMetadata, type Session, SessionBackgroundTaskHost, SessionCheckpointHost, SessionInboxHost, SessionPermissionInitializer, SessionProgressHost, SessionResponseObserver, SessionResponseTelemetryHost, type SessionResponseTelemetrySnapshot, type SessionResponseUsage, SessionSandboxReleaseHost, SessionSchedulerHost, SessionSecurityReviewHost, SessionSensitiveProjectionHost, SessionTaskLifecycleHost, SessionTitleHost } from '../../vendor/cbc-core/node/index.js';
+import { type CronSchedulerServiceInterface } from '../../workspace/cbc-cron/lib/node/index.js';
+import { type PidFileEntry } from '../../workspace/cbc-daemon/lib/node/index.js';
+import type { AgentInputItem } from '../../vendor/cbc-shared/node/index.js';
+import { Logger } from '../../workspace/telemetry/lib/common/index.js';
+import { AgentTaskManager } from '../agent-task/agent-task-protocol';
+import { GalileoSessionBridge } from '../galileo/galileo-session-bridge-protocol';
+import { ProgressSyncService } from '../notification/notification-protocol';
+import { type SecurityReviewGate as SecurityReviewGateContract } from '../security-review/protocol';
+import { type SensitiveProtectionPolicy as ISensitiveProtectionPolicy } from '../sensitive-content/sensitive-content-protocol';
+import { TelemetryService } from '../telemetry/telemetry-protocol';
+import { ToolManager } from '../tools/tool-protocol';
+import { ToolResultContentReviewer } from '../tools/tool-risk-review/content-review';
+import { type ToolRiskReviewService as ToolRiskReviewServiceContract } from '../tools/tool-risk-review/protocol';
+export declare class SessionCheckpointHostImpl implements SessionCheckpointHost {
+    protected readonly checkpoints: CheckpointService;
+    createCheckpoint(session: Session): Promise<void>;
+}
+export declare class SessionPermissionInitializerImpl implements SessionPermissionInitializer {
+    initializeContext(session: Session): Promise<void>;
+}
+export declare class SessionProgressHostImpl implements SessionProgressHost {
+    protected readonly progress: ProgressSyncService;
+    start(session: Session): Promise<void>;
+    stop(sessionId: string): void;
+}
+export declare class SessionTaskLifecycleHostImpl implements SessionTaskLifecycleHost {
+    protected readonly tasks: AgentTaskManager;
+    clearBySession(sessionId: string): Promise<void>;
+}
+export declare class SessionBackgroundTaskHostImpl implements SessionBackgroundTaskHost {
+    protected readonly tools: ToolManager;
+    getBackgroundTasks(): ReadonlyArray<{
+        status: string;
+    }>;
+}
+export declare const CRON_READY_META_KEY = "cronReady";
+export declare const CRON_READY_AT_META_KEY = "cronReadyAt";
+export declare const CRON_STORAGE_DIR_META_KEY = "cronStorageDir";
+export declare const CRON_READY_LEASE_MS = 15000;
+export declare function hasPreferredDaemonScheduler(entries: PidFileEntry[], storageDir: string, currentPid?: number, now?: number): boolean;
+export declare class SessionSchedulerHostImpl implements SessionSchedulerHost {
+    protected readonly scheduler: CronSchedulerServiceInterface;
+    private readonly daemonCronSessions;
+    private daemonReadinessTimer;
+    start(session: Session): void;
+    stop(sessionId: string): void;
+    private resolveSessionRegistry;
+    private startDaemonReadinessHeartbeat;
+    private publishDaemonReadiness;
+}
+export declare class SessionInboxHostImpl implements SessionInboxHost {
+    register(session: Session): void;
+    unregister(sessionId: string): void;
+}
+export declare class SessionSandboxReleaseHostImpl implements SessionSandboxReleaseHost {
+    releaseSessionHttpIntercept(sessionId: string): void;
+}
+export declare class SessionTitleHostImpl implements SessionTitleHost {
+    update(title: string): void;
+}
+export declare class SessionSensitiveProjectionHostImpl implements SessionSensitiveProjectionHost {
+    get(historyItem: AgentInputItem): AgentInputItem | undefined;
+    link(historyItem: AgentInputItem, runtimeItem: AgentInputItem): void;
+}
+export declare class SessionSecurityReviewHostImpl implements SessionSecurityReviewHost {
+    protected readonly gate: SecurityReviewGateContract;
+    protected readonly logger: Logger;
+    protected readonly contentReviewer: ToolResultContentReviewer;
+    protected readonly sensitivePolicy: ISensitiveProtectionPolicy;
+    protected readonly riskReview?: ToolRiskReviewServiceContract;
+    canPrefetchContentReview(session: Session): Promise<boolean>;
+    isContentReviewEnabled(session: Session): boolean;
+    startContentReview(session: Session, item: AgentInputItem): void;
+    releaseSession(sessionId: string): void;
+    beginTurn(session: Session): void;
+    attachConclusions(session: Session, item: AgentInputItem): SecurityReviewConclusion[] | undefined;
+    broadcastConclusions(session: Session, item: AgentInputItem, conclusions: SecurityReviewConclusion[]): void;
+}
+export declare class SessionResponseTelemetryHostImpl implements SessionResponseTelemetryHost {
+    protected readonly telemetry: TelemetryService;
+    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, generation: ModelCallGeneration, error?: unknown): Promise<void>;
+}
+export declare class SessionResponseObserverImpl implements SessionResponseObserver {
+    protected readonly bridge: GalileoSessionBridge;
+    emitRequestStart(session: Session, snapshot: SessionResponseTelemetrySnapshot | undefined): void;
+    emitMessageStart(session: Session): void;
+    emitRequestSuccess(session: Session, snapshot: SessionResponseTelemetrySnapshot | undefined, metadata: ModelResponseMetadata): void;
+    addRequestSuccessSpanEvent(session: Session, snapshot: SessionResponseTelemetrySnapshot | undefined, metadata: ModelResponseMetadata): void;
+    emitRequestError(session: Session, snapshot: SessionResponseTelemetrySnapshot | undefined, error: unknown, metadata: ModelResponseMetadata): void;
+    addRequestErrorSpanEvent(session: Session, snapshot: SessionResponseTelemetrySnapshot | undefined, error: unknown, metadata: ModelResponseMetadata): void;
+    emitMessageError(session: Session, snapshot: SessionResponseTelemetrySnapshot | undefined, error: unknown): void;
+    addMessageErrorSpanEvent(session: Session, snapshot: SessionResponseTelemetrySnapshot | undefined, error: unknown): void;
+    emitMessageSuccess(session: Session): void;
+    addMessageSuccessSpanEvent(session: Session): void;
+}

package/cli/dist-server/types/node/session/session-middleware.d.ts

@@ -0,0 +1,68 @@
+import { Logger } from '@celljs/core';
+import { PathResolver } from '@celljs/web';
+import { Context, Middleware, RequestMatcher } from '@celljs/web/lib/node';
+import { Session, SessionAdmissionService, SessionManager, SessionStartupApplier } from '../../vendor/cbc-core/node/index.js';
+import { SessionStartSource } from '../../vendor/cbc-shared/node/index.js';
+import { ChannelManager } from '../channel';
+import { CliProvider } from '../cli/cli-protocol';
+import { CommonRequest } from '../loopback';
+import { CliSettingsProvider } from '../settings/cli-settings-provider';
+import { ToolPermissionService } from '../tools';
+/**
+ * 把本次 /internal/agent body 摊进 session.options。
+ * Web ACP 续接可保留会话自己的权限模式；未 opt-in ACP 维持启动参数语义。
+ */
+export declare function mergeIncomingSessionOptions(session: Session, body: CommonRequest, source: SessionStartSource, options?: {
+    preserveExistingPermissionMode?: boolean;
+}): void;
+export declare class SessionMiddleWare implements Middleware {
+    readonly priority: number;
+    protected readonly admission: SessionAdmissionService;
+    protected readonly logger: Logger;
+    protected readonly requestMatcher: RequestMatcher;
+    protected readonly pathResolver: PathResolver;
+    protected readonly sessionManager: SessionManager;
+    protected readonly toolPermissionService: ToolPermissionService;
+    /**
+     * SessionStart 预检与权限模式落地。混合模式下 A2A 通道会绕过本中间件直接
+     * 建会话，所以这两件事必须由两条路径共用同一份实现，见
+     * {@link SessionStartupApplier}。
+     */
+    protected readonly startupApplier: SessionStartupApplier;
+    protected readonly channelManager?: ChannelManager;
+    protected readonly cliProvider?: CliProvider;
+    protected readonly cliSettingsProvider: CliSettingsProvider;
+    handle(ctx: Context, next: () => Promise<void>): Promise<void>;
+    private canHandle;
+    /**
+     * 新建智能体 / 交互 CLI 的 first POST：只在空白且无站立键的会话上
+     * 把 `--agent ptc|minimal|create|cli` 写成站立键。已有模式或历史不覆盖。
+     * ACP 请求（`acp:true`）不在这里盖，改由 opt-in 后的 newSession 处理。
+     */
+    private maybeStampNativeCliStandingAgent;
+    private incomingAcpHostKind;
+    private seedContextWindow;
+    private applyOverrideModel;
+    /**
+     * 规范化工具规约。该方法会就地修改 body：
+     *
+     *   - body.tools 字符串：解析 Defer/NoDefer 修饰，把剥离修饰后的纯名 join 回
+     *     字符串写回 body.tools；overlay snapshot 写到 body.toolDeferOverlay。
+     *     overlay 始终覆写（即便为空快照），避免 resume 场景下旧 overlay 残留——
+     *     用户重写 --tools 即视为重新表态。
+     *   - body.allowedTools / body.disallowedTools：校验不允许出现 Defer/NoDefer
+     *     前缀。这两个字段是权限规则字段，与"暴露策略"语义正交。
+     *
+     * 仅在 body.tools 字段被 *显式* 提供（非 undefined / 非 'default'）时才动它。
+     * tools 为 undefined 时保留 session.options 已有的 toolDeferOverlay（resume 场景）。
+     *
+     * 任何非法语法（含逗号在 spec 里、嵌套修饰、误用权限语法等）会抛 Error，
+     * 调用方原本的请求-响应流程会把错误信息回传给用户。
+     */
+    private normalizeToolSpecs;
+    /**
+     * 权限规则字段的 sanitize：扫描 entries 里是否有 `Defer(...)` / `NoDefer(...)`
+     * 前缀。命中即抛出清晰错误指引用户改写到 --tools。
+     */
+    private assertNoDeferModifier;
+}

package/cli/dist-server/types/node/session/session-response-host-adapter.d.ts

@@ -0,0 +1,9 @@
+import { type Session, SessionResponseTelemetry } from '../../vendor/cbc-core/node/index.js';
+import { TelemetryService } from '../telemetry/telemetry-protocol';
+export declare class SessionResponseTelemetryAdapter implements SessionResponseTelemetry {
+    protected readonly telemetry: TelemetryService;
+    recordCreditRefundConversationRequestEnd(session: Session, finishReason: string | undefined): void;
+    suppressCreditRefundConversationRequest(session: Session): void;
+    reportUserTaskFailedCreditRefund(session: Session, reason: 'abnormal_finish_reason'): Promise<void>;
+    reportChatMaxTokenReached(session: Session, responseModelId?: string): Promise<void>;
+}

package/cli/dist-server/types/node/session/session-store-host-adapter.d.ts

@@ -0,0 +1,23 @@
+import { type Session, SessionImageStorage, SessionRestoreHost, SessionStoragePaths, SessionToolOutputStorage } from '../../vendor/cbc-core/node/index.js';
+import { ImageBlobService, ToolResultBlobService } from '../blob-store';
+export declare class SessionStoragePathsAdapter implements SessionStoragePaths {
+    getHomeProjectDir(): string;
+    getHomeProjectsDir(): string;
+    getWorkDir(): string;
+    compressPath(path: string): string;
+    canonicalizeStorePath(path: string): string;
+}
+export declare class SessionImageStorageAdapter implements SessionImageStorage {
+    protected readonly blobs: ImageBlobService;
+    get processingErrorPlaceholder(): string;
+    isInvalidImageDataError(error: unknown): boolean;
+    storeFromDataUri(uri: string, source?: string, originalFilename?: string): Promise<unknown>;
+}
+export declare class SessionToolOutputStorageAdapter implements SessionToolOutputStorage {
+    protected readonly blobs: ToolResultBlobService;
+    shouldExternalize(output: string): boolean;
+    externalize(callId: string, output: string, storeId: string, parentSessionId?: string): Promise<string>;
+}
+export declare class SessionRestoreHostAdapter implements SessionRestoreHost {
+    restore(session: Session): void;
+}

package/cli/dist-server/types/node/session/tasks-controller.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Tasks Controller
+ *
+ * 提供任务模版推荐 API，采用异步后台方案：
+ *   POST /tasks/templates/refresh → 触发后台 AI 推荐（fire-and-forget），立即返回
+ *   GET  /tasks/templates         → 返回缓存的模版列表 + 当前状态
+ *
+ * 后台 AI 推荐通过 spawn cbc 子进程完成，结果缓存在内存中，前端通过轮询 GET 获取最新结果。
+ *
+ * 可配置项（环境变量）:
+ *   CODEBUDDY_TASK_RECOMMEND_TIMEOUT  AI 推荐超时时间（毫秒），默认 120000（120 秒）
+ *   CODEBUDDY_TASK_RECOMMEND_MODEL    AI 推荐使用的模型名（可选，不设置则使用默认模型）
+ */
+/** 任务模版数据结构 */
+export interface TaskTemplate {
+    id: string;
+    title: string;
+    description: string;
+    icon: string;
+    command: string;
+    interval: string;
+}
+/**
+ * 推荐子进程的最大 agentic 轮数。
+ *
+ * 不能设成 1：模型为了「根据当前工作目录的项目特征」作答，通常会先用一次
+ * Bash/Glob 探查项目结构，这会把第1 轮用光，于是直接撞上上限并返回
+ * `subtype=error_during_execution` +空 result（exit code仍是 0），
+ * 表现为「刷新模版」失败。留出探查+ 作答的余量。
+ */
+export declare const MAX_TURNS = 4;
+/**
+ * 推荐子进程的 spawn 环境。
+ *
+ * 走 {@link buildNestedCbcSpawnEnvironment} 剥离 `SERVER__PORT`/`SERVER__HOST`：
+ * 本控制器运行在 `--serve` 进程内，若子进程继承父进程正在监听的端口，会bind
+ * 到已占用地址并静默挂死，表现为「刷新模版」永远超时失败。
+ */
+export declare function buildRecommendationSpawnEnv(): NodeJS.ProcessEnv;
+export declare class TasksController {
+    private readonly logger;
+    private cachedTemplates;
+    private cacheStatus;
+    private cachedAt;
+    private cacheError;
+    /**
+     * GET /api/v1/tasks/templates
+     * 返回当前缓存的模版列表和加载状态。
+     * 前端通过轮询此端点获取 AI 推荐的最新结果。
+     *
+     * 即使没有 sessionId，也返回默认模版列表，让用户能看到任务视图。
+     */
+    getTemplates(): Promise<void>;
+    /**
+     * POST /api/v1/tasks/templates/refresh
+     * 触发后台 AI 推荐。立即返回当前状态，子进程在后台异步执行。
+     * 如果已有推荐进行中，不会重复启动。
+     * 即使没有 sessionId，也允许刷新（使用当前工作目录）。
+     */
+    refreshTemplates(): Promise<void>;
+    /**
+     * 在后台启动 cbc 子进程执行 AI 推荐。
+     * 完成后更新内存缓存。不会抛出异常（所有错误内部处理）。
+     */
+    private startBackgroundRecommendation;
+    /**
+     * 从 stream-json 输出格式解析 AI 结果。
+     * 每行是一个 JSON 对象，我们寻找 type: 'result' 或 type: 'assistant' 的消息。
+     */
+    private parseStreamJsonOutput;
+    /**
+     * 从 AI 回复文本中解析任务模版 JSON。
+     * 支持多种格式：纯 JSON 数组、```json 代码块、文本中嵌入的 JSON。
+     */
+    private parseTemplates;
+    /**
+     * 验证并清洗模版数据。
+     */
+    private validateTemplates;
+}

package/cli/dist-server/types/node/settings/current-session-model-transition-protocol.d.ts

@@ -0,0 +1,23 @@
+import type { Session } from '../../vendor/cbc-core/node/index.js';
+export declare const CurrentSessionModelTransition: unique symbol;
+export type CurrentSessionModelScope = 'global' | 'session';
+export type CurrentSessionModelTransitionResult = {
+    status: 'applied';
+    compacted: boolean;
+    message: string;
+} | {
+    status: 'applied_with_persistence_warning';
+    compacted: boolean;
+    message: string;
+} | {
+    status: 'rejected';
+    reason: 'busy' | 'too_small' | 'stale' | 'prepare_failed';
+    message: string;
+};
+export interface CurrentSessionModelTransition {
+    transition(input: {
+        session: Session;
+        targetModelId: string;
+        scope: CurrentSessionModelScope;
+    }): Promise<CurrentSessionModelTransitionResult>;
+}

package/cli/dist-server/types/node/settings/current-session-model-transition.d.ts

@@ -0,0 +1,15 @@
+import { AgentManager, type ManualCompactRequestHandler as ManualCompactRequestHandlerContract, SessionManager, SessionRunStateMachine } from '../../vendor/cbc-core/node/index.js';
+import { CliSettingsProvider } from './cli-settings-provider';
+import { type CurrentSessionModelTransition as CurrentSessionModelTransitionContract, type CurrentSessionModelTransitionResult } from './current-session-model-transition-protocol';
+import { SettingsManager } from './settings-protocol';
+/** TUI-only safe current-session model switch. ACP and daemon have separate owners. */
+export declare class CurrentSessionModelTransitionImpl implements CurrentSessionModelTransitionContract {
+    protected readonly agentManager: AgentManager;
+    protected readonly sessionManager: SessionManager;
+    protected readonly stateMachine: SessionRunStateMachine;
+    protected readonly settingsManager: SettingsManager;
+    protected readonly cliSettingsProvider: CliSettingsProvider;
+    protected readonly manualCompactRequestHandler: ManualCompactRequestHandlerContract;
+    transition(input: Parameters<CurrentSessionModelTransitionContract['transition']>[0]): Promise<CurrentSessionModelTransitionResult>;
+    private getModelInputHistory;
+}

package/cli/dist-server/types/node/settings/index.d.ts

@@ -0,0 +1,8 @@
+export * from './settings-protocol';
+export * from './settings-manager';
+export * from './settings-controller';
+export * from './settings-validate-middleware';
+export * from './cli-settings-provider';
+export * from './cli-setting-sources-provider';
+export * from './current-session-model-transition-protocol';
+export * from './current-session-model-transition';

package/cli/dist-server/types/node/settings/settings-controller.d.ts

@@ -0,0 +1,23 @@
+import { Settings, SettingsManager } from './settings-protocol';
+export interface SettingsOptions {
+    global: boolean;
+}
+export interface KeyRequest {
+    key: keyof Settings;
+}
+export interface KeyValueRequest extends SettingsOptions {
+    key: keyof Settings;
+    value: any;
+}
+export interface KeyValuesRequest extends SettingsOptions {
+    key: keyof Settings;
+    values: any[];
+}
+export declare class SettingsController {
+    protected readonly settingsManager: SettingsManager;
+    set(request: KeyValueRequest): Promise<void>;
+    get(request: KeyRequest): Promise<Settings[keyof Settings]>;
+    add(request: KeyValuesRequest): Promise<void>;
+    remove(request: KeyValuesRequest): Promise<void>;
+    list(): Promise<Settings>;
+}

package/cli/dist-server/types/node/settings/settings-manager.d.ts

@@ -69,6 +69,7 @@ export declare class SettingsManagerImpl implements SettingsManager {
      */
     protected deepMerge(target: any, source: any): void;
     protected readSettingsWithRetry(scope: SettingsScope, maxRetries?: number, forceFresh?: boolean): Promise<Settings>;
+    private readSettingsFromDisk;
     /** Small test seam around the asynchronous read that owns cache population. */
     protected readSettingsFile(filePath: string): Promise<string>;
     get<K extends keyof Settings>(key: K, scope?: SettingsScope): Promise<Settings[K]>;

package/cli/dist-server/types/node/settings/settings-protocol.d.ts

@@ -77,6 +77,8 @@ export declare const GLOBAL_SETTING_KEYS: string[];
 export declare const PROJECT_SETTING_KEYS: string[];
 export declare const ENV_KEY_CODEBUDDY_INTERNET_ENVIRONMENT = "CODEBUDDY_INTERNET_ENVIRONMENT";
 export declare const ENV_KEY_CODEBUDDY_INTERNET_ENVIROMENT = "CODEBUDDY_INTERNET_ENVIROMENT";
+/** Keep the live context percentage visible in the TUI input status area. */
+export declare const ENV_KEY_CODEBUDDY_SHOW_CONTEXT_USAGE = "CODEBUDDY_SHOW_CONTEXT_USAGE";
 export declare const ENV_PRODUCT_CLI_ACCOUNT_TYPE = "ENV_PRODUCT_CLI_ACCOUNT_TYPE";
 export declare const ENV_KEY_CODEBUDDY_AUTH_TOKEN = "CODEBUDDY_AUTH_TOKEN";
 export declare const ENV_KEY_CODEBUDDY_CUSTOM_HEADERS = "CODEBUDDY_CUSTOM_HEADERS";
@@ -249,6 +251,8 @@ export interface Settings {
     extraKnownMarketplaces?: MarketplaceConfig;
     /** 是否展示tokens计数器 */
     showTokensCounter?: boolean;
+    /** 是否始终展示当前会话的上下文窗口使用率 */
+    showContextUsage?: boolean;
     /**
      * 是否在每轮回复结束后展示本轮耗时（`✔ Worked for 1m 31s`）。默认 true。
      *

package/cli/dist-server/types/node/settings/settings-validate-middleware.d.ts

@@ -0,0 +1,9 @@
+import { PathResolver } from '@celljs/web';
+import { Context, Middleware, RequestMatcher } from '@celljs/web/lib/node';
+export declare class SettingsValidateMiddleWare implements Middleware {
+    protected readonly requestMatcher: RequestMatcher;
+    protected readonly pathResolver: PathResolver;
+    readonly priority: number;
+    handle(ctx: Context, next: () => Promise<void>): Promise<void>;
+    private canHandle;
+}