@gajae-code/coding-agent 0.10.1 → 0.11.0

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

@@ -1,7 +1,7 @@
 /**
  * AgentSession - Core abstraction for agent lifecycle and session management.
  *
- * This class is shared between all run modes (interactive, print, rpc).
+ * This class is shared by interactive, print, ACP, and SDK-hosted session callers.
  * It encapsulates:
  * - Agent state access
  * - Event subscription with automatic session persistence
@@ -12,7 +12,7 @@
  *
  * Modes use this class and add their own I/O layer on top.
  */
-import { type Agent, type AgentEvent, type AgentMessage, type AgentState, type AgentTool, type ResolvedThinkingLevel, type StablePrefixSnapshot, ThinkingLevel } from "@gajae-code/agent-core";
+import { type Agent, type AgentContext, type AgentEvent, type AgentLoopConfig, type AgentMessage, type AgentState, type AgentTool, type MidRunMaintenanceOutcome, type StablePrefixSnapshot, ThinkingLevel } from "@gajae-code/agent-core";
 import { type CompactionResult, type EmergencyCompactionSample } from "@gajae-code/agent-core/compaction";
 import type { AssistantMessage, Effort, ImageContent, Message, MessageAttribution, Model, ProviderSessionState, ServiceTier, SimpleStreamOptions, TextContent, ToolCall, ToolChoice, Usage, UsageReport } from "@gajae-code/ai";
 export interface ForkContextSeedMetadata {
@@ -60,23 +60,26 @@ import type { LoadedCustomCommand } from "../extensibility/custom-commands";
 import type { CustomTool } from "../extensibility/custom-tools/types";
 import type { ExtensionRunner } from "../extensibility/extensions";
 import type { CompactOptions, ContextUsage } from "../extensibility/extensions/types";
-import type { Skill, SkillWarning } from "../extensibility/skills";
+import { type Skill, type SkillWarning } from "../extensibility/skills";
 import { type FileSlashCommand } from "../extensibility/slash-commands";
 import { GoalRuntime } from "../goals/runtime";
 import type { Goal, GoalModeState } from "../goals/state";
 import type { HindsightSessionState } from "../hindsight/state";
-import type { WorkflowGateEmitter } from "../modes/shared/agent-wire/unattended-session";
+import { type WorkflowGateEmitter } from "../modes/shared/agent-wire/workflow-gate-broker";
 import type { PlanModeState } from "../plan-mode/state";
 import { type AgentRegistry } from "../registry/agent-registry";
 import { type DiscoverableMCPSearchIndex, type DiscoverableMCPTool } from "../runtime-mcp/discoverable-tool-metadata";
 import { MCPManager } from "../runtime-mcp/manager";
+import type { NotificationSessionController } from "../sdk/bus/session-control";
 import { type SecretObfuscator } from "../secrets/obfuscator";
 import { type DiscoverableTool, type DiscoverableToolSearchIndex } from "../tool-discovery/tool-index";
 import type { AskAnswerSource, ToolSession } from "../tools";
 import type { CheckpointState } from "../tools/checkpoint";
 import { type TodoItem, type TodoPhase } from "../tools/todo-write";
 import { type WorkspaceTree } from "../workspace-tree";
-import type { ClientBridge } from "./client-bridge";
+import { type DefaultModelSelectionResult } from "./default-model-selection";
+export { DefaultModelSelectionRecoveryError } from "./default-model-selection";
+import type { ClientBridge, ClientBridgePermissionOption, ClientBridgePermissionOutcome, ClientBridgePermissionToolCall } from "./client-bridge";
 import { type ContributionPrepOptions, type ContributionPrepResult } from "./contribution-prep";
 import { type CustomMessage } from "./messages";
 import type { BranchSummaryEntry, CompactionEntry, NewSessionOptions, SessionContext, SessionManager, SessionManagerCloseOutcome } from "./session-manager";
@@ -111,14 +114,16 @@ export type AgentSessionEvent = AgentEvent | {
     attempt: number;
     finalError?: string;
 } | {
-    type: "retry_fallback_applied";
+    type: "model_fallback_switched";
+    eventId: string;
     from: string;
     to: string;
+    reason: string;
     role: string;
-} | {
-    type: "retry_fallback_succeeded";
-    model: string;
-    role: string;
+    scope: string;
+    activeIndex: number;
+    chainLength: number;
+    attemptsUsed: number;
 } | {
     type: "ttsr_triggered";
     rules: Rule[];
@@ -164,6 +169,8 @@ export interface AgentSessionConfig {
     agent: Agent;
     sessionManager: SessionManager;
     settings: Settings;
+    /** Shared Gate-A-eligible notification session controller, when this host supports it. */
+    notificationSessionController?: NotificationSessionController;
     /** Models to cycle through with Alt+N (from --models flag) */
     scopedModels?: ScopedModelSelection[];
     /** Initial session thinking selector. */
@@ -202,7 +209,7 @@ export interface AgentSessionConfig {
     /** Current session message-to-LLM conversion pipeline */
     convertToLlm?: (messages: AgentMessage[]) => Message[] | Promise<Message[]>;
     /** System prompt builder that can consider tool availability. Returns ordered provider-facing blocks. */
-    rebuildSystemPrompt?: (toolNames: string[], tools: Map<string, AgentTool>) => Promise<{
+    rebuildSystemPrompt?: (toolNames: string[], tools: Map<string, AgentTool>, candidateModel?: Model) => Promise<{
         systemPrompt: string[];
     }>;
     /** Initial workspace tree snapshot used for the first volatile per-turn context message. */
@@ -268,6 +275,7 @@ export interface AgentSessionConfig {
     /** Optional provider-facing cache identity, distinct from logical session identity. */
     providerCacheSessionId?: string;
 }
+type MidRunMaintenanceLifecycle = Parameters<NonNullable<AgentLoopConfig["maintainContext"]>>[1];
 /** Options for AgentSession.prompt() */
 export interface PromptOptions {
     /** Whether to expand file-based prompt templates (default: true) */
@@ -286,6 +294,11 @@ export interface PromptOptions {
     attribution?: MessageAttribution;
     /** Skip pre-send compaction checks for this prompt (internal use for maintenance flows). */
     skipCompactionCheck?: boolean;
+    /**
+     * Invoked after all prompt preflight checks pass and immediately before agent execution begins.
+     * Cancellation before this callback rejects the prompt.
+     */
+    onPreflightAccepted?: () => void;
 }
 /** Result from a handoff operation. */
 export interface HandoffResult {
@@ -303,17 +316,18 @@ export interface ModelCycleResult {
     /** Whether cycling through scoped models (--models flag) or all available */
     isScoped: boolean;
 }
+export type ModelChangeCause = "user-selection" | "profile-activation" | "fallback-switch" | "restore" | "rollback" | "startup-override" | "temporary-operation";
+export type TemporaryModelReason = "plan-mode" | "context-promotion" | "temporary-cycle" | "profile-preview" | "extension-temporary" | "other";
+/** Opaque handle for a non-destructive temporary provider-session scope. */
+export interface TemporaryProviderSessionScope {
+    readonly reason: TemporaryModelReason;
+}
 /** Result from cycleRoleModels() */
 export interface RoleModelCycleResult {
     model: Model;
     thinkingLevel: ThinkingLevel | undefined;
     role: string;
 }
-export interface DefaultModelSelectionResult {
-    readonly provider: string;
-    readonly modelId: string;
-    readonly thinkingLevel: ResolvedThinkingLevel;
-}
 /** Session statistics for /session command */
 export interface SessionStats {
     sessionFile: string | undefined;
@@ -394,6 +408,7 @@ export declare class AgentSession {
     readonly agent: Agent;
     readonly sessionManager: SessionManager;
     readonly settings: Settings;
+    readonly notificationSessionController: NotificationSessionController | undefined;
     readonly taskDepth: number;
     readonly yieldQueue: YieldQueue;
     readonly configWarnings: string[];
@@ -435,6 +450,12 @@ export declare class AgentSession {
     setStandingResolveHandler(handler: ((input: unknown) => Promise<unknown> | unknown) | null): void;
     /** Provider-scoped mutable state store for transport/session caches. */
     get providerSessionState(): Map<string, ProviderSessionState>;
+    /** Suspend provider state without closing it while a temporary model is active. */
+    beginTemporaryProviderSessionScope(reason: TemporaryModelReason): TemporaryProviderSessionScope;
+    /** Restore a temporary scope, unwinding any auto-owned scopes above it. */
+    restoreTemporaryProviderSessionScope(token: TemporaryProviderSessionScope): boolean;
+    /** Promote a temporary scope. The suspended provider state is permanently closed. */
+    commitTemporaryProviderSessionScope(token: TemporaryProviderSessionScope): boolean;
     buildForkContextSeed(options: ForkContextSeedOptions): Promise<ForkContextSeed>;
     getHindsightSessionState(): HindsightSessionState | undefined;
     setHindsightSessionState(state: HindsightSessionState | undefined): HindsightSessionState | undefined;
@@ -567,6 +588,12 @@ export declare class AgentSession {
      * no fold target exists.
      */
     hasForegroundBashBackgroundRequestHandler(): boolean;
+    /** Set the SDK permission policy used by guarded ACP tool execution. */
+    setSdkPermissionMode(mode: "prompt" | "allow" | "deny"): void;
+    /** Current SDK permission policy for guarded ACP tool execution. */
+    get sdkPermissionMode(): "prompt" | "allow" | "deny";
+    /** Register or clear the SDK reverse permission provider for this session. */
+    setSdkPermissionProvider(provider: ((toolCall: ClientBridgePermissionToolCall, options: ClientBridgePermissionOption[], signal?: AbortSignal) => Promise<ClientBridgePermissionOutcome>) | undefined): void;
     /**
      * Ask the active managed foreground bash call to return as a background job.
      * Returns false when no supported foreground tool is currently backgroundable.
@@ -613,10 +640,6 @@ export declare class AgentSession {
      * This allows /mcp add/remove/reauth to take effect without restarting the session.
      */
     refreshMCPTools(mcpTools: CustomTool[]): Promise<void>;
-    /**
-     * Replace RPC host-owned tools and refresh the active tool set before the next model call.
-     */
-    refreshRpcHostTools(rpcTools: AgentTool[]): Promise<void>;
     /**
      * Refresh plugin sub-skill tools after workflow/sub-skill activation or phase changes.
      */
@@ -657,7 +680,25 @@ export declare class AgentSession {
     get scopedModels(): ReadonlyArray<ScopedModelSelection>;
     /** Prompt templates */
     getPlanModeState(): PlanModeState | undefined;
+    /** Live SDK configuration values exposed through the session query surface. */
+    getSdkConfigItems(): Record<string, string>;
     setPlanModeState(state: PlanModeState | undefined): void;
+    invokeSkill(name: string, args?: string): Promise<{
+        name: string;
+        path: string;
+        args?: string;
+        lineCount?: number;
+    }>;
+    setSdkPlanMode(on: boolean): PlanModeState | undefined;
+    operateGoal(op: "create" | "get" | "resume" | "pause" | "complete" | "drop", objective?: string): Promise<unknown>;
+    getTranscript(): Array<{
+        id: string;
+        role: string;
+        textSummary: string;
+        ts: string;
+        body: string;
+    }>;
+    getTranscriptBody(entryId: string): string | undefined;
     getGoalModeState(): GoalModeState | undefined;
     setGoalModeState(state: GoalModeState | undefined): void;
     getWorkflowGateEmitter(): WorkflowGateEmitter | undefined;
@@ -738,6 +779,7 @@ export declare class AgentSession {
      */
     sendUserMessage(content: string | (TextContent | ImageContent)[], options?: {
         deliverAs?: "steer" | "followUp";
+        onPreflightAccepted?: () => void;
     }): Promise<void>;
     /**
      * Clear queued messages and return them.
@@ -749,6 +791,12 @@ export declare class AgentSession {
     };
     /** Number of pending messages (includes steering, follow-up, and next-turn messages) */
     get queuedMessageCount(): number;
+    /** Typed pending-message counts per queue (steering, follow-up, next-turn). */
+    get pendingMessageCounts(): {
+        steering: number;
+        followUp: number;
+        nextTurn: number;
+    };
     /** Whether the agent has queued steering messages that a `user_interrupt`
      *  abort would resume into (steer-on-interrupt). Drives the Esc-on-steer UX:
      *  the first Esc consumes the steer and auto-continues, a second Esc aborts. */
@@ -779,6 +827,14 @@ export declare class AgentSession {
     getTodoPhases(): TodoPhase[];
     setTodoPhases(phases: TodoPhase[]): void;
     applyCompactionPostAppendForTests(compactionEntryId: string, firstKeptEntryId: string, fromExtension?: boolean): Promise<CompactionEntry | undefined>;
+    /** Read-only test seam for active mid-run EventStream drain barriers. */
+    get activeMidRunBarrierCountForTests(): number;
+    /** Read-only test seam for active mid-run maintenance invocations. */
+    get activeMidRunMaintenanceCountForTests(): number;
+    /** Test seam: drive the cooperative mid-run maintenance checkpoint directly. */
+    runMidRunMaintenanceForTests(context: AgentContext, lifecycle?: MidRunMaintenanceLifecycle): Promise<MidRunMaintenanceOutcome>;
+    /** Test seam: estimate mid-run context tokens for a given context view. */
+    estimateMidRunContextTokensForTests(messages: readonly AgentMessage[]): number;
     /**
      * Abort current operation and wait for agent to become idle.
      */
@@ -824,9 +880,28 @@ export declare class AgentSession {
     setModel(model: Model, role?: string, options?: {
         selector?: string;
         thinkingLevel?: ThinkingLevel;
+        cause?: ModelChangeCause;
     }): Promise<void>;
     setActiveModelProfile(name: string | undefined): void;
     getActiveModelProfile(): string | undefined;
+    /** Return the persisted configured fallback selectors for a model role. */
+    getConfiguredModelChain(role: string): readonly string[] | undefined;
+    /** Persist the configured fallback selectors for a model role. */
+    setConfiguredModelChain(role: string, entries: readonly string[], origin: string, identity?: string, explicitHead?: boolean): void;
+    /**
+     * Replace only the in-memory default fallback controller. Used when startup
+     * falls through an unavailable persisted chain to the global default, which
+     * must not mutate the persisted configured intent.
+     */
+    setDefaultFallbackRuntimeModel(selector: string): void;
+    /**
+     * Seed default fallback state after guarded auth-aware model resolution skips chain entries.
+     * The configured chain's role, origin, and identity are retained by the controller.
+     */
+    seedDefaultFallbackResolution(activeIndex: number, skips: Array<{
+        selector: string;
+        reason: string;
+    }>): void;
     /**
      * The model selector ("provider/id") that resume restores as the session
      * default — the latest session-log `model_change` with role="default".
@@ -858,7 +933,13 @@ export declare class AgentSession {
      */
     setModelTemporary(model: Model, thinkingLevel?: ThinkingLevel, options?: {
         persistAsSessionDefault?: boolean;
-    }): Promise<void>;
+        cause?: ModelChangeCause;
+        reason?: TemporaryModelReason;
+        providerSessionScope?: TemporaryProviderSessionScope;
+        signal?: AbortSignal;
+    }): Promise<TemporaryProviderSessionScope | void>;
+    /** Set a durable per-session model from a control surface without exposing credential errors. */
+    setModelTemporaryForControl(model: Model, expectedSessionId?: string): Promise<boolean>;
     setDefaultModelSelection(model: Model, thinkingLevel: ThinkingLevel | undefined): Promise<DefaultModelSelectionResult>;
     /**
      * Cycle to next/previous model.
@@ -885,6 +966,17 @@ export declare class AgentSession {
      * Saves the effective metadata-clamped level to the session, and to settings when requested.
      */
     setThinkingLevel(level: ThinkingLevel | undefined, persist?: boolean): void;
+    /**
+     * Set thinking level from a control surface. Global changes are durable or rolled back.
+     */
+    setThinkingLevelForControl(level: ThinkingLevel, persist: boolean): Promise<void>;
+    getThinkingScopeForControl(): "session" | "global config";
+    getThinkingVisibility(): "visible" | "hidden";
+    setThinkingVisibility(visibility: "visible" | "hidden", persist?: boolean): void;
+    /**
+     * Set thinking visibility from a control surface. Global changes are durable or rolled back.
+     */
+    setThinkingVisibilityForControl(visibility: "visible" | "hidden", persist: boolean): Promise<void>;
     /**
      * Cycle to next thinking level.
      * @returns New level, or undefined if model doesn't support thinking
@@ -1190,6 +1282,7 @@ export declare class AgentSession {
         estimateCount: number;
     };
     fetchUsageReports(signal?: AbortSignal): Promise<UsageReport[] | null>;
+    fetchUsageReportsForControl(): Promise<UsageReport[] | null>;
     /**
      * Export session to HTML.
      * @param outputPath Optional output path (defaults to session directory)

package/dist/types/session/default-model-selection.d.ts

@@ -0,0 +1,25 @@
+import type { ResolvedThinkingLevel } from "@gajae-code/agent-core";
+export type DefaultModelSelectionRollbackStage = "durable" | "session" | "live";
+export declare const DEFAULT_MODEL_SELECTION_RECOVERY_MESSAGE = "Default model selection could not be completed after durable selection.";
+export type DefaultModelSelectionRecovery = {
+    readonly message: string;
+    readonly rollback: {
+        readonly disposition: "restored" | "partial" | "unknown";
+        readonly failures: readonly {
+            readonly stage: DefaultModelSelectionRollbackStage;
+            readonly message: string;
+        }[];
+    };
+};
+export interface DefaultModelSelectionResult {
+    readonly provider: string;
+    readonly modelId: string;
+    readonly thinkingLevel: ResolvedThinkingLevel;
+}
+export declare function parseDefaultModelSelectionRecovery(value: unknown): DefaultModelSelectionRecovery | undefined;
+export declare class DefaultModelSelectionRecoveryError extends Error {
+    readonly name = "DefaultModelSelectionRecoveryError";
+    readonly code = "default_model_selection_recovery";
+    readonly recovery: DefaultModelSelectionRecovery;
+    constructor(_message: string, recovery: DefaultModelSelectionRecovery);
+}

package/dist/types/session/fallback-chain-controller.d.ts

@@ -0,0 +1,52 @@
+export type FallbackTriggerClass = "rate_limit" | "quota" | "auth" | "server" | "other";
+/** Immutable configured fallback intent. Transient attempt state never belongs here. */
+export interface ConfiguredFallbackChain {
+    role: string;
+    entries: readonly string[];
+    origin: string;
+    identity?: string;
+    explicitHead: boolean;
+}
+export interface FallbackFailure {
+    selector: string;
+    triggerClass: FallbackTriggerClass;
+    reason: string;
+}
+export type FallbackFailureResult = "retry" | "advance" | "exhausted";
+/**
+ * In-memory policy state for one fallback-chain scope. A controller is deliberately
+ * not serializable: configured chain intent is durable, current position is not.
+ */
+export declare class FallbackChainController {
+    #private;
+    readonly chain: ConfiguredFallbackChain;
+    readonly maxAttempts: number;
+    activeIndex: number;
+    attemptsUsed: number;
+    tried: FallbackFailure[];
+    skips: Array<{
+        selector: string;
+        reason: string;
+    }>;
+    exhaustedForTurn: boolean;
+    constructor(chain: ConfiguredFallbackChain, maxAttempts: number);
+    currentSelector(): string | undefined;
+    onResolutionSkip(reason: string): boolean;
+    /** Charge an upstream request at its concrete transport boundary. */
+    onAttemptStarted(): void;
+    /** Start a logically new request without losing its sticky selected entry. */
+    resetAttemptBudget(): void;
+    /** Seed a controller from auth-aware resolution without charging requests. */
+    seedResolution(activeIndex: number, skips: Array<{
+        selector: string;
+        reason: string;
+    }>): void;
+    onAttemptFailure(triggerClass: FallbackTriggerClass, reason: string): FallbackFailureResult;
+    advance(): boolean;
+    isExhausted(): boolean;
+    resetForNewTurn(): void;
+    resetSticky(): void;
+}
+export declare function cappedExponentialWithFullJitter(baseDelayMs: number, maxDelayMs: number, attemptK: number, random?: () => number): number;
+/** Retry-After is intentionally uncapped. */
+export declare function effectiveFallbackDelay(baseDelayMs: number, maxDelayMs: number, attemptK: number, retryAfterMs: number | undefined, random?: () => number): number;

package/dist/types/session/session-manager.d.ts

@@ -1,4 +1,5 @@
 import { type AgentMessage } from "@gajae-code/agent-core";
+import type { ConfiguredModelChainEntry as SharedConfiguredModelChainEntry } from "@gajae-code/agent-core/compaction";
 import type { ImageContent, Message, MessageAttribution, ServiceTier, TextContent } from "@gajae-code/ai";
 import type { TtsrInjectionRecord } from "../export/ttsr";
 import { ArtifactManager } from "./artifacts";
@@ -97,6 +98,9 @@ export interface ModelChangeEntry extends SessionEntryBase {
     /** Effective thinking level when the change was recorded. */
     thinkingLevel?: string | null;
 }
+/** Persisted configured fallback chain for one model role. */
+export type ConfiguredModelChainEntry = SharedConfiguredModelChainEntry;
+export type ConfiguredModelChain = Pick<ConfiguredModelChainEntry, "role" | "entries" | "origin" | "identity" | "explicitHead" | "cleared">;
 export interface ServiceTierChangeEntry extends SessionEntryBase {
     type: "service_tier_change";
     serviceTier: ServiceTier | null;
@@ -206,9 +210,27 @@ export interface CustomMessageEntry<T = unknown> extends SessionEntryBase {
     evictedContent?: EvictedContentMarker;
 }
 /** Session entry - has id/parentId for tree structure (returned by "read" methods in SessionManager) */
-export type SessionEntry = SessionMessageEntry | ThinkingLevelChangeEntry | ModelChangeEntry | ServiceTierChangeEntry | CompactionEntry | BranchSummaryEntry | CustomEntry | CustomMessageEntry | LabelEntry | TtsrInjectionEntry | MCPToolSelectionEntry | SessionInitEntry | ModeChangeEntry;
+export type SessionEntry = SessionMessageEntry | ThinkingLevelChangeEntry | ModelChangeEntry | ServiceTierChangeEntry | CompactionEntry | BranchSummaryEntry | CustomEntry | CustomMessageEntry | LabelEntry | TtsrInjectionEntry | MCPToolSelectionEntry | SessionInitEntry | ModeChangeEntry | ConfiguredModelChainEntry;
 /** Raw file entry (includes header) */
 export type FileEntry = SessionHeader | SessionEntry;
+export type DefaultModelSelectionStage = {
+    readonly entryRevision: number;
+    readonly headerExportRevision: number;
+    readonly sessionId: string;
+    readonly sessionFile: string | undefined;
+    readonly entries: readonly FileEntry[];
+    readonly tempPath: string | undefined;
+    readonly persistsToExistingFile: boolean;
+};
+export type DefaultModelSelectionPromotion = {
+    readonly kind: "promoted";
+} | {
+    readonly kind: "not_promoted";
+    readonly error?: Error;
+} | {
+    readonly kind: "unknown";
+    readonly error: Error;
+};
 /** Tree node for getTree() - defensive copy of session structure */
 export interface SessionTreeNode {
     entry: SessionEntry;
@@ -222,6 +244,8 @@ export interface SessionContext {
     serviceTier?: ServiceTier;
     /** Model roles: { default: "provider/modelId", small: "provider/modelId", ... } */
     models: Record<string, string>;
+    /** Configured fallback chains for model roles on the active branch. */
+    configuredModelChains: Record<string, ConfiguredModelChain>;
     /** Names of TTSR rules that have been injected this session */
     injectedTtsrRules: string[];
     /** Rich TTSR rule injection records for repeat resume. */
@@ -269,6 +293,21 @@ export interface StrictSessionOpenFailure {
     kind: "error";
     reason: ResumeTailError["reason"] | "identity-mismatch";
 }
+/** Exact transcript bytes and authority captured from one descriptor-bound read. */
+export interface CapturedSessionTranscriptSnapshot {
+    sourcePath: string;
+    identity: ResumeSessionIdentity;
+    content: Uint8Array;
+    storage: SessionStorage;
+}
+export type StrictSessionCaptureResult = {
+    kind: "captured";
+    snapshot: CapturedSessionTranscriptSnapshot;
+} | ResumeTailError;
+export type StrictSessionForkResult = {
+    kind: "forked";
+    manager: SessionManager;
+} | StrictSessionOpenFailure;
 /** Result of opening an inspected session without create-or-rewrite fallback. */
 export type StrictSessionOpenResult = StrictSessionOpenSuccess | StrictSessionOpenFailure;
 export interface SessionInfo {
@@ -410,6 +449,7 @@ interface SessionManagerStateSnapshot {
     titleSource: "auto" | "user" | undefined;
     sessionFile: string | undefined;
     flushed: boolean;
+    ensuredOnDisk: boolean;
     needsFullRewriteOnNextPersist: boolean;
     fileEntries: FileEntry[];
     materializedFileEntries: FileEntry[];
@@ -459,6 +499,11 @@ export declare class SessionManager {
      */
     moveTo(newCwd: string): Promise<void>;
     isPersisted(): boolean;
+    stageDefaultModelSelection(model: string, thinkingLevel: string | undefined, options?: {
+        readonly appendThinkingLevel: boolean;
+    }): Promise<DefaultModelSelectionStage>;
+    promoteDefaultModelSelection(stage: DefaultModelSelectionStage): DefaultModelSelectionPromotion;
+    discardDefaultModelSelectionStage(stage: DefaultModelSelectionStage): Promise<void>;
     /**
      * Force-persist all current entries to disk, even when no assistant message exists yet.
      * Used by ACP mode where session/new must create a discoverable session immediately.
@@ -543,6 +588,8 @@ export declare class SessionManager {
      */
     setSessionName(name: string, source?: "auto" | "user"): Promise<boolean>;
     _persist(entry: SessionEntry): void;
+    /** Append a configured fallback chain as child of current leaf, then advance leaf. Returns entry id. */
+    appendConfiguredModelChain(chain: ConfiguredModelChain): string;
     /** Append a message as child of current leaf, then advance leaf. Returns entry id.
      * Does not allow writing CompactionSummaryMessage and BranchSummaryMessage directly.
      * Reason: we want these to be top-level entries in the session, not message session entries,
@@ -713,6 +760,8 @@ export declare class SessionManager {
      * Resolve the canonical default session directory for a cwd.
      */
     static getDefaultSessionDir(cwd: string, agentDir?: string, storage?: SessionStorage): string;
+    /** Resolve the default session directory without creating or migrating storage. */
+    static getDefaultSessionDirReadOnly(cwd: string, agentDir?: string): string;
     /**
      * Create a new session.
      * @param cwd Working directory (stored in session header)
@@ -734,6 +783,14 @@ export declare class SessionManager {
      * List sessions for the resume picker without recovery or other maintenance writes.
      */
     static listForResumePickerReadOnly(cwd: string, sessionDir?: string, storage?: SessionStorage): Promise<SessionInfo[]>;
+    /** Capture exact source content for a strict fork without granting write ownership. */
+    static captureTranscriptStrict(filePath: string, storage?: SessionStorage): StrictSessionCaptureResult;
+    /**
+     * Fork strictly from captured source bytes. The source pathname is used only to
+     * revalidate captured authority before destination initialization and transcript
+     * persistence; destination history always comes from the captured bytes.
+     */
+    static forkFromCaptured(snapshot: CapturedSessionTranscriptSnapshot, cwd: string, sessionDir?: string): Promise<StrictSessionForkResult>;
     /** Inspect a selected session without acquiring write-capable ownership. */
     static inspectSessionTailReadOnly(filePath: string, storage?: SessionStorage): Promise<ResumeTailInspection>;
     /**

package/dist/types/setup/credential-auto-import.d.ts

@@ -2,9 +2,40 @@ import type { AuthCredentialIfAbsentReason, AuthCredentialIfAbsentSnapshotResult
 import type { ModelRegistry } from "../config/model-registry";
 import { type CredentialDiscoveryResult, type CredentialOrigin, type DiscoveryOptions, type ImportableCredential } from "./credential-import";
 export declare const CREDENTIAL_AUTO_IMPORT_ROTATION_WARNING = "Refreshing in gjc may log out the Claude/Codex CLI because OAuth refresh tokens can rotate.";
+export declare const CREDENTIAL_AUTO_IMPORT_PERSISTENCE_WARNING = "Credential import preference could not be saved; external credentials may be offered again.";
+export declare const CREDENTIAL_AUTO_IMPORT_REFRESH_WARNING = "Imported credentials were saved, but provider availability could not be refreshed.";
+export declare const CREDENTIAL_AUTO_IMPORT_DISCOVERY_WARNING = "External credential discovery could not be completed. Use /provider to import credentials manually.";
+export declare const CREDENTIAL_AUTO_IMPORT_RETRY_WARNING = "Some external credentials could not be imported. Use /provider to retry.";
+export declare const CREDENTIAL_AUTO_IMPORT_STATE_UNREADABLE_WARNING = "Credential import preference could not be read. External credential discovery was skipped; use /provider to import credentials manually.";
 export type CredentialAutoImportSourceLabel = "claude-code-file" | "claude-code-keychain" | "codex-file";
 export type CredentialAutoImportTrigger = "startup" | "bare-login" | "setup-cli";
+export type InitialImportResolution = "accepted" | "declined";
+export type CredentialAutoImportStateProblem = "invalid-initial-import-resolution" | "invalid-last-import-version" | "malformed-json" | "malformed-root";
+export interface CredentialAutoImportStateFile {
+    lastImportVersion?: string;
+    initialImportResolution?: InitialImportResolution;
+}
+export interface CredentialAutoImportStateReadResult {
+    state: CredentialAutoImportStateFile;
+    problems: CredentialAutoImportStateProblem[];
+    unreadable: boolean;
+}
+export interface CredentialAutoImportStateMutation {
+    lastImportVersion?: string;
+    initialImportResolution?: InitialImportResolution;
+}
+export interface CredentialAutoImportStateStore {
+    read: () => Promise<CredentialAutoImportStateReadResult>;
+    write: (mutation: CredentialAutoImportStateMutation) => Promise<boolean>;
+}
+export interface CredentialAutoImportStateStoreDependencies {
+    withFileLock?: <T>(filePath: string, transaction: () => Promise<T>) => Promise<T>;
+    rename?: (oldPath: string, newPath: string) => Promise<void>;
+}
 export declare function getCredentialAutoImportStatePath(agentDir?: string): string;
+export declare function createCredentialAutoImportStateStore(agentDir?: string, dependencies?: CredentialAutoImportStateStoreDependencies): CredentialAutoImportStateStore;
+export declare function readCredentialAutoImportState(agentDir?: string): Promise<CredentialAutoImportStateReadResult>;
+export declare function isCredentialAutoImportStateResolvedForVersion(state: CredentialAutoImportStateFile, version: string): boolean;
 export declare function readCredentialImportMarker(agentDir?: string): Promise<string | undefined>;
 export declare function writeCredentialImportMarker(version: string, agentDir?: string): Promise<boolean>;
 export declare enum CredentialAutoImportFailureClass {
@@ -37,6 +68,9 @@ export interface CredentialAutoImportResult {
     discovery?: CredentialDiscoveryResult;
     globalDiscoveryFailure?: CredentialAutoImportFailure;
 }
+export declare function formatCredentialAutoImportCandidateLabel(candidate: Pick<ImportableCredential, "provider" | "origin">): string;
+export declare function formatCredentialAutoImportPrompt(candidates: readonly Pick<ImportableCredential, "provider" | "origin">[]): string;
+export declare function logCredentialAutoImportFailures(trigger: CredentialAutoImportTrigger, failures: readonly Pick<CredentialAutoImportFailure, "failureClass">[]): void;
 export type CredentialAutoImportAuthStorage = Pick<AuthStorage, "importCredentialIfAbsent">;
 export interface CredentialAutoImportOptions {
     authStorage: CredentialAutoImportAuthStorage;
@@ -48,16 +82,12 @@ export interface CredentialAutoImportOptions {
 export declare function runExternalCredentialAutoImport({ authStorage, discover, discoveryOptions, }: CredentialAutoImportOptions): Promise<CredentialAutoImportResult>;
 export declare function buildCredentialAutoImportNotice(result: Pick<CredentialAutoImportResult, "imported">): string | undefined;
 export declare function formatCredentialAutoImportResult(result: CredentialAutoImportResult): string[];
-export interface CredentialImportMarkerStore {
-    read: () => Promise<string | undefined> | string | undefined;
-    write: (version: string) => Promise<boolean> | boolean;
-}
 export interface StartupCredentialAutoImportOptions {
     authStorage: CredentialAutoImportOptions["authStorage"];
     modelRegistry: Pick<ModelRegistry, "refresh">;
     discover?: CredentialAutoImportOptions["discover"];
     version?: string;
     agentDir?: string;
-    markerStore?: CredentialImportMarkerStore;
+    stateStore?: CredentialAutoImportStateStore;
 }
-export declare function runStartupCredentialAutoImportIfNeeded({ authStorage: activeAuthStorage, modelRegistry: activeModelRegistry, discover, version, agentDir, markerStore, }: StartupCredentialAutoImportOptions): Promise<string | undefined>;
+export declare function runStartupCredentialAutoImportIfNeeded({ authStorage: activeAuthStorage, modelRegistry: activeModelRegistry, discover, version, agentDir, stateStore, }: StartupCredentialAutoImportOptions): Promise<string | undefined>;

package/dist/types/tools/ask-answer-registry.d.ts

@@ -6,7 +6,7 @@
  * through the extension/runner/controller wiring. A session has at most one
  * source; registering returns a disposer.
  */
-import type { WorkflowGateEmitter } from "../modes/shared/agent-wire/unattended-session";
+import type { WorkflowGateEmitter } from "../modes/shared/agent-wire/workflow-gate-broker";
 import type { AskAnswerSource } from "./index";
 /** Register `source` for `sessionId`. Returns a disposer that clears it. */
 export declare function registerAskAnswerSource(sessionId: string, source: AskAnswerSource): () => void;

package/dist/types/tools/browser/benchmark/detector-report.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Offline stealth-detector benchmark model.
+ *
+ * Pure, deterministic logic for the anti-detection benchmark suite: it converts
+ * a browser-collected fingerprint probe into a normalized per-detector verdict,
+ * implements the falsifiable CI gate (see plan Phase 1 / R-T3), and renders a
+ * before/after report. No browser or network access lives here so it can be
+ * unit-tested deterministically; the harness that drives the real browser tool
+ * against vendored detector fixtures feeds its output into these functions.
+ */
+export type SignalStatus = "pass" | "fail";
+/** A single boolean fingerprint signal, e.g. "navigator.webdriver is undefined". */
+export interface DetectorSignal {
+    /** Stable identifier, used to diff across runs. */
+    id: string;
+    /** Human-readable label for the report. */
+    label: string;
+    /** `pass` means the signal looks human; `fail` means it leaks automation. */
+    status: SignalStatus;
+    /** Optional observed value for debugging. */
+    detail?: string;
+}
+export type AutomatedVerdict = "human" | "bot" | "unknown";
+/** Normalized result for one detector (e.g. bot.sannysoft, CreepJS). */
+export interface DetectorResult {
+    detector: string;
+    signals: DetectorSignal[];
+    /** Overall automated/not classification when the detector exposes one. */
+    automatedVerdict: AutomatedVerdict;
+    /** Absolute trust score (observability-only, never a hard gate). */
+    trustScore: number | null;
+}
+/** Shape emitted by the offline probe fixture on `window.__stealthProbe`. */
+export interface RawProbe {
+    detector: string;
+    signals: Array<{
+        id: string;
+        label: string;
+        pass: boolean;
+        detail?: string;
+    }>;
+    automatedVerdict?: AutomatedVerdict;
+    trustScore?: number | null;
+}
+/** Convert a raw browser-collected probe into a normalized {@link DetectorResult}. */
+export declare function parseProbe(raw: RawProbe): DetectorResult;
+export interface GateOutcome {
+    pass: boolean;
+    reasons: string[];
+}
+/**
+ * Falsifiable CI gate (plan Phase 1 / R-T3, R-C1, R-C2):
+ *   (a) zero failing signals in the current run, AND
+ *       current pass-count >= baseline pass-count (no silent regression), AND
+ *   (b) either at least one signal that failed at baseline now passes,
+ *       OR the baseline was already all-green (empty-gap regression lock).
+ * The absolute `trustScore` is never consulted here; it is observability-only.
+ */
+export declare function evaluateGate(baseline: DetectorResult, current: DetectorResult): GateOutcome;
+/** Aggregate gate across every detector; passes only when all detectors pass. */
+export declare function evaluateSuiteGate(baseline: readonly DetectorResult[], current: readonly DetectorResult[]): GateOutcome;
+/** Render a deterministic before/after markdown report for one run. */
+export declare function renderReport(baseline: readonly DetectorResult[], current: readonly DetectorResult[]): string;