@gajae-code/coding-agent 0.10.2 → 0.11.1

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;

package/dist/types/tools/browser/benchmark/run-suite.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Offline stealth benchmark harness (plan Phase 1).
+ *
+ * Drives a puppeteer Page (already stealth-patched by the browser tool) against
+ * self-contained offline detector fixtures and collects normalized results. The
+ * navigation/evaluation is injected so this stays unit-testable without a real
+ * browser; the integration test wires a live puppeteer Page.
+ */
+import type { Page } from "puppeteer-core";
+import type { DetectorResult } from "./detector-report";
+/** Minimal surface of a puppeteer Page that the harness needs. */
+export type SuitePage = Pick<Page, "goto" | "evaluate">;
+export interface SuiteFixture {
+    /** file:// (or http://) URL of the offline detector fixture. */
+    url: string;
+}
+/** Navigate to each fixture and collect a normalized DetectorResult per fixture. */
+export declare function runOfflineSuite(page: SuitePage, fixtures: readonly SuiteFixture[]): Promise<DetectorResult[]>;

package/dist/types/tools/browser/launch.d.ts

@@ -20,6 +20,25 @@ export interface LaunchHeadlessOptions {
         height: number;
         deviceScaleFactor?: number;
     };
+    /**
+     * Optional isolated warm-up profile directory (see profile-reuse.ts). When
+     * set, the headless browser launches against this isolated copy of the user's
+     * real Chrome profile so sessions inherit real cookies/storage/cache for
+     * stronger stealth. Callers resolve this via resolveProfileReuse and MUST
+     * pass an isolated copy, never a live profile dir.
+     */
+    profileWarmupDir?: string;
+    /**
+     * Optional opt-in geo alignment (see settings browser.geo.*). When set, the
+     * browser is launched with a matching timezone (TZ env) and/or UI language
+     * (--lang) at the source. Default unset = strict no-op: the real environment
+     * timezone/locale are preserved (never half-spoof). Only align these to a
+     * coherent value (e.g. one matching a configured proxy egress).
+     */
+    geo?: {
+        timezone?: string;
+        locale?: string;
+    };
 }
 export declare function launchHeadlessBrowser(opts: LaunchHeadlessOptions): Promise<Browser>;
 export declare function applyViewport(page: Page, viewport?: {
@@ -54,6 +73,9 @@ export declare function buildStealthInjectionScriptForTest(scripts?: readonly st
 export declare function applyStealthPatches(browser: Browser, page: Page, state: {
     browserSession: CDPSession | null;
     override: UserAgentOverride | null;
+}, geo?: {
+    readonly timezone?: string;
+    readonly locale?: string;
 }): Promise<void>;
 export declare function targetSupportsUserAgentOverrideForTest(target: Target): boolean;
 export declare function configureUserAgentTargetsForTest(browser: Browser, state: {

package/dist/types/tools/browser/profile-discovery.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Default Chrome profile discovery (plan Phase 2 wiring).
+ *
+ * Locates the user's real Chrome "Default" profile directory per OS so the
+ * default headless launch path can warm up synthetic sessions from an isolated
+ * copy of it (see profile-warmup.ts + profile-posture.ts). Pure path logic with
+ * an injectable existence check, so it is unit-testable without touching the
+ * real filesystem.
+ */
+export interface DiscoveryEnv {
+    platform: NodeJS.Platform;
+    home: string;
+    /** Injectable for tests; defaults to fs.existsSync at call sites. */
+    exists: (p: string) => boolean;
+    /** Windows LOCALAPPDATA override (tests / non-default installs). */
+    localAppData?: string;
+}
+/** Candidate Chrome user-data roots for the platform (most common first). */
+export declare function chromeUserDataRoots(env: DiscoveryEnv): string[];
+export interface DiscoveredProfile {
+    userDataDir: string;
+    profileDirectory: string;
+    profileDir: string;
+}
+/**
+ * Discover the default Chrome profile, or null when none is present.
+ * Only returns a profile whose directory actually exists.
+ */
+export declare function discoverDefaultChromeProfile(env: DiscoveryEnv, profileDirectory?: string): DiscoveredProfile | null;
+/** Convenience wrapper using the live OS environment + fs. */
+export declare function defaultDiscoveryEnv(exists: (p: string) => boolean): DiscoveryEnv;

package/dist/types/tools/browser/profile-posture.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Auto-default profile-reuse posture decision (plan Phase 2, Intent Reconciliation).
+ *
+ * User-confirmed policy: when a usable real Chrome profile is available, the
+ * browser tool uses it automatically (AUTO), emits a warning, and falls back to
+ * synthetic stealth when unavailable. The posture is overridable via a setting.
+ * This is pure decision logic (no browser, no filesystem side effects) so the
+ * launch/attach layer can call it and it can be unit-tested deterministically.
+ */
+/** Configured posture: `auto` (default) prefers the real profile; `opt-in` stays synthetic unless explicitly asked. */
+export type ProfileReusePosture = "auto" | "opt-in";
+export declare const DEFAULT_PROFILE_REUSE_POSTURE: ProfileReusePosture;
+export interface PostureInputs {
+    /** Configured posture; defaults to `auto` when unset. */
+    posture?: ProfileReusePosture;
+    /** A usable real Chrome profile was detected and is attachable/safe to copy. */
+    realProfileAvailable: boolean;
+    /** Caller explicitly requested real-profile reuse for this run (e.g. app.browser === "chrome"). */
+    explicitlyRequested?: boolean;
+}
+export interface PostureDecision {
+    /** `real` = use the (isolated copy of the) real profile; `synthetic` = synthetic stealth session. */
+    mode: "real" | "synthetic";
+    /** User-facing warning to emit when real credentials/state are about to be used. */
+    warning: string | null;
+    /** Machine-readable reason for logs/audit. */
+    reason: "auto-real" | "explicit-real" | "synthetic-fallback" | "synthetic-opt-in";
+}
+/**
+ * Decide whether to reuse the real profile or run synthetic.
+ *
+ * - `auto` + available            -> real (with warning)
+ * - `opt-in` + explicitly asked   -> real (with warning)
+ * - `opt-in` (no explicit ask)    -> synthetic
+ * - not available                 -> synthetic (fallback), even under `auto`
+ */
+export declare function decideProfilePosture(inputs: PostureInputs): PostureDecision;

package/dist/types/tools/browser/profile-reuse.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Profile-reuse orchestration (plan Phase 2 wiring).
+ *
+ * Single entry point the launch path calls to decide, for a default headless
+ * session, whether to warm up from an isolated copy of the user's real Chrome
+ * profile. Ties together discovery + posture + isolated warm-up. Filesystem
+ * effects (the copy) are performed only when the posture resolves to `real`.
+ * The heavy pieces are injectable so this is unit-testable without a browser.
+ */
+import { type DiscoveredProfile, type DiscoveryEnv } from "./profile-discovery";
+import { type ProfileReusePosture } from "./profile-posture";
+import { type WarmupManifest } from "./profile-warmup";
+export interface ResolveProfileReuseInputs {
+    posture?: ProfileReusePosture;
+    /** Caller explicitly requested real-profile reuse (e.g. app.browser === "chrome"). */
+    explicitlyRequested?: boolean;
+    discoveryEnv: DiscoveryEnv;
+    /** Destination for the isolated warm-up copy; defaults to an ephemeral temp dir. */
+    destDir?: string;
+    /** Injectable copier (defaults to collectWarmupArtifacts). */
+    copy?: (sourceProfileDir: string, destDir: string) => WarmupManifest;
+    /** Injectable temp-dir factory (defaults to fs.mkdtemp under os.tmpdir()). */
+    makeTempDir?: () => string;
+}
+export interface ProfileReuseResult {
+    mode: "real" | "synthetic";
+    reason: string;
+    warning: string | null;
+    discovered: DiscoveredProfile | null;
+    /** Isolated copy directory when mode === "real", else null. */
+    warmupDir: string | null;
+    manifest: WarmupManifest | null;
+}
+/**
+ * Resolve profile reuse for a default session. When the posture resolves to
+ * `real`, copies an allowlisted, lock-free subset of the discovered profile
+ * into an isolated dir and returns that dir for the launcher to use.
+ */
+export declare function resolveProfileReuse(inputs: ResolveProfileReuseInputs): ProfileReuseResult;

package/dist/types/tools/browser/profile-warmup.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Isolated profile warm-up (plan Phase 2, R-C3).
+ *
+ * Aggressive real-profile reuse seeds a session with the user's cookies /
+ * localStorage / cache. To stay safe (never lock or corrupt the live browser
+ * session) we NEVER bind the source profile directly: we copy an allowlisted
+ * subset of artifacts into an ephemeral, isolated directory and drive Chromium
+ * against that copy. Chromium single-instance lock files (SingletonLock/Socket/
+ * Cookie) are explicitly excluded so the isolated copy can never contend with a
+ * running browser.
+ *
+ * This module is pure filesystem logic (no browser, no network) so it is
+ * deterministically unit-testable.
+ */
+/** Chromium single-instance lock artifacts — must never be copied. */
+export declare const CHROME_LOCK_ARTIFACTS: readonly ["SingletonLock", "SingletonSocket", "SingletonCookie"];
+/**
+ * Profile-relative artifacts worth seeding for warm-up. Kept intentionally
+ * small: session state (cookies, storage) plus a light cache. Anything not
+ * listed is skipped, which also keeps the isolated copy cheap.
+ */
+export declare const WARMUP_ARTIFACTS: readonly ["Cookies", "Cookies-journal", "Local Storage", "Session Storage", "IndexedDB", "Network", "Preferences"];
+export interface WarmupManifest {
+    sourceProfileDir: string;
+    destDir: string;
+    copied: string[];
+    skippedMissing: string[];
+    /** Always empty unless a lock artifact was seen (never copied). */
+    excludedLocks: string[];
+}
+/**
+ * Copy warm-up artifacts from `sourceProfileDir` into an isolated `destDir`.
+ *
+ * Guarantees:
+ * - The source profile is only ever read, never written or locked.
+ * - Chromium lock artifacts are never copied (recorded in `excludedLocks`).
+ * - Missing artifacts are skipped, not fatal (recorded in `skippedMissing`).
+ */
+export declare function collectWarmupArtifacts(sourceProfileDir: string, destDir: string): WarmupManifest;

package/dist/types/tools/browser/registry.d.ts

@@ -1,6 +1,7 @@
 import type { Subprocess } from "bun";
 import type { Browser, CDPSession } from "puppeteer-core";
 import { type UserAgentOverride } from "./launch";
+import type { ProfileReusePosture } from "./profile-posture";
 export type BrowserKind = {
     kind: "headless";
     headless: boolean;
@@ -20,9 +21,14 @@ export type BrowserKind = {
     cdpUrl: string;
 };
 export type BrowserKindTag = BrowserKind["kind"];
+export interface BrowserGeo {
+    readonly timezone?: string;
+    readonly locale?: string;
+}
 export interface BrowserHandle {
     key: string;
     kind: BrowserKind;
+    readonly geo?: BrowserGeo;
     browser: Browser;
     cdpUrl?: string;
     pid?: number;
@@ -45,7 +51,20 @@ export interface AcquireBrowserOptions {
     };
     appArgs?: string[];
     signal?: AbortSignal;
+    /**
+     * Profile-reuse posture for the default headless path (from settings
+     * `browser.profileReuse`, resolved by the settings-aware caller). When set,
+     * the headless browser may warm up from an isolated copy of the user's real
+     * Chrome profile (see profile-reuse.ts). Omitted = synthetic session.
+     */
+    profileReuse?: ProfileReusePosture;
+    /**
+     * Opt-in geo alignment for the default headless path (from settings
+     * `browser.geo.*`). Default unset = no-op (real timezone/locale preserved).
+     */
+    geo?: BrowserGeo;
 }
+export declare function browserKeyForTest(kind: BrowserKind, opts: Pick<AcquireBrowserOptions, "geo" | "profileReuse">): string;
 export declare function acquireBrowser(kind: BrowserKind, opts: AcquireBrowserOptions): Promise<BrowserHandle>;
 export declare function buildChromeProfileLaunchArgs(kind: SpawnedChromeProfileKind, appArgs: readonly string[] | undefined, port: number): string[];
 export declare function buildChromeProfileLaunchArgsForTest(kind: SpawnedChromeProfileKind, appArgs: readonly string[] | undefined, port: number): string[];

package/dist/types/tools/browser/tab-protocol.d.ts

@@ -47,6 +47,10 @@ export type WorkerInitPayload = {
         height: number;
         deviceScaleFactor?: number;
     };
+    geo?: {
+        readonly timezone?: string;
+        readonly locale?: string;
+    };
     dialogs?: "accept" | "dismiss";
     url?: string;
     waitUntil?: "load" | "domcontentloaded" | "networkidle0" | "networkidle2";

package/dist/types/tools/index.d.ts

@@ -5,7 +5,7 @@ import type { Settings } from "../config/settings";
 import type { Skill } from "../extensibility/skills";
 import type { GoalModeState, GoalRuntime } from "../goals";
 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 { ForkContextSeed, ForkContextSeedOptions, PurgeQueuedCustomMessagesResult } from "../session/agent-session";
@@ -125,9 +125,10 @@ export interface AskRemoteReceipt {
 }
 export type AskAnswerSourceResult = AskRemoteReceipt | string | undefined;
 /**
- * Source of remote answers. `awaitAnswer` remains the legacy wire for existing
- * integrations; typed sources opt into `awaitAnswerRequest`. This keeps an old
- * string-only source from accidentally acquiring acknowledgement authority.
+ * Source of remote answers for interactive asks. `awaitAnswer` remains the legacy
+ * wire for existing integrations; typed sources opt into `awaitAnswerRequest`.
+ * This keeps a string-only source from accidentally acquiring acknowledgement
+ * authority while allowing SDK-routed interactions to settle durably.
  */
 export interface AskAnswerSource {
     awaitAnswer(question: string, options: string[], signal?: AbortSignal): Promise<string | undefined>;
@@ -232,12 +233,11 @@ export interface ToolSession {
     getPlanModeState?: () => PlanModeState | undefined;
     /** Goal mode state (if active or paused) */
     getGoalModeState?: () => GoalModeState | undefined;
-    /** Unattended workflow-gate emitter (present only when unattended mode is negotiated). */
+    /** SDK workflow-gate emitter, when a remote gate responder is connected. */
     getWorkflowGateEmitter?: () => WorkflowGateEmitter | undefined;
     /**
-     * Optional remote answer source for interactive asks. When present, the ask
-     * tool races the local UI selection against a remote answer (e.g. a Telegram
-     * reply via the notifications SDK) so asks can be answered without RPC mode.
+     * Optional SDK-routed answer source for interactive asks. When present, the
+     * tool races the local UI selection against the remote SDK answer.
      * No-op when undefined: the ask path behaves exactly as before.
      */
     getAskAnswerSource?: () => AskAnswerSource | undefined;

package/dist/types/tools/subagent-render.d.ts

@@ -11,6 +11,7 @@ import type { Component } from "@gajae-code/tui";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import { type SubagentToolDetails } from "./subagent";
+export { subagentAwaitRenderedStateSignature } from "./subagent";
 /** Test-only seam (PR3 deterministic cache-hit assertions). */
 export declare const subagentBodyCacheTestHooks: {
     readonly bodyRenders: number;

package/dist/types/tools/subagent.d.ts

@@ -56,8 +56,13 @@ export interface SubagentSnapshot {
     /** True when the requested model lacked credentials and fell back to the parent model. */
     modelFellBack?: boolean;
 }
+export type SubagentAwaitOutcome = "completed" | "timed_out" | "interrupted";
 export interface SubagentToolDetails {
     subagents: SubagentSnapshot[];
+    /** Await outcome for a live await receipt; omitted when no wait was started. */
+    awaitOutcome?: SubagentAwaitOutcome;
+    /** True only when the parent await was interrupted; the child was not cancelled. */
+    interrupted?: true;
 }
 export declare class SubagentTool implements AgentTool<typeof subagentSchema, SubagentToolDetails> {
     #private;
@@ -113,5 +118,5 @@ export declare class SubagentTool implements AgentTool<typeof subagentSchema, Su
  * countdown ticking is sacrificed by design; every real transition still changes
  * the signature.
  */
-export declare function subagentAwaitRenderedStateSignature(subagents: readonly SubagentSnapshot[]): string;
+export declare function subagentAwaitRenderedStateSignature(subagents: readonly SubagentSnapshot[], receipt?: Pick<SubagentToolDetails, "awaitOutcome" | "interrupted">): string;
 export {};