@gajae-code/coding-agent 0.11.11 → 0.12.0

package/dist/types/modes/components/irc-sidebar.d.ts

@@ -2,12 +2,50 @@ import { type Component, type ViewportAnchorProvider, type ViewportAnchorRender
 import type { IrcObservationLedger } from "../irc-observation-ledger";
 export declare const IRC_SIDEBAR_WIDTH_RATIO = 0.3;
 export declare const IRC_SIDEBAR_MAX_RENDER_ROWS = 2048;
+export declare const __ircSidebarPerfCounters: {
+    enabled: boolean;
+    projectionMemoHits: number;
+    projectionMemoMisses: number;
+    recordsVisited: number;
+    sourceBytes: number;
+    rows: number;
+    styledCacheHits: number;
+    styledCacheMisses: number;
+    wrapCalls: number;
+    snapshot(): {
+        projectionMemoHits: number;
+        projectionMemoMisses: number;
+        recordsVisited: number;
+        sourceBytes: number;
+        rows: number;
+        styledCacheHits: number;
+        styledCacheMisses: number;
+        wrapCalls: number;
+    };
+    enable(): void;
+    disable(): void;
+    reset(): void;
+};
 /** Computes transcript/sidebar widths while preserving at least half the terminal for the transcript. */
 export declare function computeIrcSplitWidths(width: number): {
     leftWidth: number;
     separatorWidth: number;
     rightWidth: number;
 };
+type SemanticLine = Readonly<{
+    kind: "header" | "body" | "elision" | "blank";
+    text: string;
+    sender?: string;
+    recipient?: string;
+    time?: string;
+}>;
+export type IrcSidebarSemanticProjection = Readonly<{
+    token: string;
+    lines: readonly SemanticLine[];
+}>;
+/** The authoritative bounded, display-neutral IRC sidebar projection. */
+export declare function getIrcSidebarSemanticProjection(ledger: IrcObservationLedger, width: number): IrcSidebarSemanticProjection;
+export declare function getIrcSidebarSemanticToken(ledger: IrcObservationLedger, width: number): string;
 export interface IrcSidebarTheme {
     fg(color: "dim" | "accent", text: string): string;
     bold(text: string): string;
@@ -26,7 +64,10 @@ export declare class IrcSplitViewComponent implements ViewportAnchorProvider {
     get visible(): boolean;
     effectiveSidebarVisible(width?: number): boolean;
     setVisible(visible: boolean): void;
+    invalidateTheme(): void;
+    resetSource(): void;
     render(width: number): string[];
     renderWithViewportAnchors(width: number): ViewportAnchorRender;
     invalidate(): void;
 }
+export {};

package/dist/types/modes/components/read-tool-group.d.ts

@@ -8,12 +8,11 @@ type ReadRenderArgs = {
     file_path?: string;
     sel?: string;
 };
-type ReadToolGroupOptions = {
-    showContentPreview?: boolean;
-};
 export declare class ReadToolGroupComponent extends Container implements ToolExecutionHandle {
     #private;
-    constructor(options?: ReadToolGroupOptions);
+    constructor(options?: {
+        showContentPreview?: boolean;
+    });
     updateArgs(args: ReadRenderArgs, toolCallId?: string): void;
     updateResult(result: {
         content: Array<{
@@ -32,5 +31,6 @@ export declare class ReadToolGroupComponent extends Container implements ToolExe
      */
     setManuallyExpanded(expanded: boolean): void;
     getComponent(): Component;
+    consumeVisibleTranscriptChange(): boolean;
 }
 export {};

package/dist/types/modes/components/session-observer-overlay.d.ts

@@ -9,4 +9,8 @@ export declare class SessionObserverOverlayComponent extends TranscriptViewerOve
     refreshFromRegistry(): void;
     handleInput(keyData: string): void;
 }
+/**
+ * This deliberately remains the eager full-history projection. PR2 owns projection
+ * virtualization/incrementalization; source acquisition above only controls snapshot safety.
+ */
 export declare function entriesFromMessages(entries: readonly SessionMessageEntry[]): TranscriptViewerEntry[];

package/dist/types/modes/components/settings-selector.d.ts

@@ -58,6 +58,8 @@ export interface SettingsCallbacks {
     getStatusLinePreview?: (width?: number) => string;
     /** Called when plugins change */
     onPluginsChanged?: () => void;
+    /** Called when an interactive setting cannot be committed. */
+    onError?: (message: string) => void;
     /** Called when settings panel is closed */
     onCancel: () => void;
 }

package/dist/types/modes/components/tool-execution.d.ts

@@ -5,6 +5,8 @@ export interface ToolExecutionOptions {
     editFuzzyThreshold?: number;
     editAllowFuzzy?: boolean;
     hashlineAutoDropPureInsertDuplicates?: boolean;
+    /** Internal observer for visible asynchronous renderer mutations. */
+    onVisibleTranscriptMutation?: () => void;
 }
 export interface ToolExecutionHandle {
     updateArgs(args: any, toolCallId?: string): void;
@@ -29,6 +31,11 @@ export interface ToolExecutionHandle {
      * back to {@link setExpanded}.
      */
     setManuallyExpanded?(expanded: boolean): void;
+    /**
+     * Internal capability for dispatchers that need exact synchronous visible-output
+     * detection. Optional so existing structural handles remain source compatible.
+     */
+    consumeVisibleTranscriptChange?(): boolean;
 }
 /**
  * Component that renders a tool call with its result (updateable)
@@ -52,6 +59,7 @@ export declare class ToolExecutionComponent extends Container {
         details?: any;
         isError?: boolean;
     }, isPartial?: boolean, _toolCallId?: string): void;
+    consumeVisibleTranscriptChange(): boolean;
     /**
      * Stop spinner animation and cleanup resources.
      */

package/dist/types/modes/controllers/event-controller.d.ts

@@ -3,7 +3,10 @@ import type { InteractiveModeContext } from "../../modes/types";
 import type { AgentSessionEvent } from "../../session/agent-session";
 /** Test-only performance counters for advisory baseline tests. */
 export declare const __eventControllerPerfCounters: {
+    enabled: boolean;
     messageUpdateContentVisits: number;
+    enable(): void;
+    disable(): void;
     reset(): void;
 };
 export declare class EventController {

package/dist/types/modes/interactive-mode.d.ts

@@ -181,6 +181,8 @@ export declare class InteractiveMode implements InteractiveModeContext {
     }): Promise<void>;
     flushPendingBashComponents(): void;
     isKnownSlashCommand(text: string): boolean;
+    /** Advances the sticky-viewport source only for semantic transcript output. */
+    recordVisibleTranscriptMutation(): void;
     addMessageToChat(message: AgentMessage, options?: {
         populateHistory?: boolean;
     }): Component[];

package/dist/types/modes/irc-observation-ledger.d.ts

@@ -1,5 +1,18 @@
 import type { ParsedIrcMessage } from "./utils/irc-message";
 type InlineMode = "persistent" | "ephemeral";
+export declare const IRC_OBSERVATION_LEDGER_MAX_RECORDS = 10000;
+export declare const IRC_OBSERVATION_LEDGER_MAX_RETAINED_UTF8_BYTES: number;
+export declare const IRC_OBSERVATION_LEDGER_MAX_SEEN_IDENTITIES = 100000;
+export declare const __ircLedgerPerfCounters: {
+    enabled: boolean;
+    epochAdvances: number;
+    snapshot(): {
+        epochAdvances: number;
+    };
+    enable(): void;
+    disable(): void;
+    reset(): void;
+};
 export type IrcObservationRecord = Readonly<ParsedIrcMessage & {
     mode: InlineMode;
     observedAt: number;
@@ -10,6 +23,7 @@ export type IrcObservationRecord = Readonly<ParsedIrcMessage & {
 /** Runtime-only IRC observations. This intentionally has no persistence layer. */
 export declare class IrcObservationLedger {
     #private;
+    get mutationEpoch(): number;
     /** Inline observations expire after 10 seconds; closed-panel observations persist inline. */
     observe(message: ParsedIrcMessage, panelVisibleAtObservation: boolean): IrcObservationRecord | undefined;
     getRecord(observationId: string): IrcObservationRecord | undefined;
@@ -17,6 +31,8 @@ export declare class IrcObservationLedger {
     getInlineProjection(now: number): readonly IrcObservationRecord[];
     /** Returns and clears IDs whose retained payload was released. */
     drainEvictedObservationIds(): readonly string[];
-    reset(): void;
+    reset(options?: {
+        retireCurrentSessionIdentities?: boolean;
+    }): void;
 }
 export {};

package/dist/types/modes/types.d.ts

@@ -218,6 +218,8 @@ export interface InteractiveModeContext {
     getAssistantViewportAnchorId?(message: AssistantMessage): string;
     findLastAssistantMessage(): AssistantMessage | undefined;
     extractAssistantText(message: AssistantMessage): string;
+    /** Records one semantic visible-transcript mutation for the sticky viewport. */
+    recordVisibleTranscriptMutation?(): void;
     updateEditorTopBorder(): void;
     updateEditorBorderColor(): void;
     rebuildChatFromMessages(policy: TranscriptRebuildPolicy): void;

package/dist/types/modes/utils/ui-helpers.d.ts

@@ -6,6 +6,22 @@ import { type SessionContext } from "../../session/session-manager";
 import { type ParsedIrcMessage } from "./irc-message";
 export type { TranscriptRebuildPolicy } from "../../modes/types";
 export declare function prepareTranscriptRebuild(ui: TUI, policy: TranscriptRebuildPolicy): void;
+export declare const RESUME_PROGRESS_COMMIT_TIMEOUT_MS = 250;
+export interface ResumeProgressLease {
+    readonly committed: Promise<boolean>;
+    clear(): void;
+}
+/**
+ * Mount a resume loader on the live status rail and wait for its render generation
+ * to commit before session I/O begins. The commit is advisory: a stopped or
+ * unavailable terminal resolves false and callers continue without blocking.
+ *
+ * Fail open (no-op lease, committed=false) when the status rail or UI lacks the
+ * child-mutation/render-commit surface required to mount progress. Headless and
+ * minimal controller contexts keep resume/migration semantics; full interactive
+ * TUI containers retain progress-before-switch.
+ */
+export declare function acquireResumeProgressLease(ctx: Pick<InteractiveModeContext, "ui" | "statusContainer">): ResumeProgressLease;
 interface RenderInitialMessagesOptions {
     preserveExistingChat?: boolean;
 }

package/dist/types/runtime-mcp/smithery-auth.d.ts

@@ -7,6 +7,11 @@ type SmitheryCliPollResponse = {
     apiKey?: string;
     message?: string;
 };
+/** Test seam: the Smithery origin and env API key as resolved from trusted env. */
+export declare function resolveSmitheryEnvForTest(): {
+    url: string;
+    apiKey: string | undefined;
+};
 export declare function getSmitheryLoginUrl(): string;
 export declare function createSmitheryCliAuthSession(): Promise<SmitheryCliAuthSession>;
 export declare function pollSmitheryCliAuthSession(sessionId: string, signal?: AbortSignal): Promise<SmitheryCliPollResponse>;

package/dist/types/sdk/broker/lifecycle.d.ts

@@ -73,6 +73,11 @@ export interface SessionLifecycleLaunchRequest {
 export declare function readSessionLifecycleLaunchRequest(value: string | undefined, now?: number): SessionLifecycleLaunchRequest;
 type CleanupEvidence = BrokerCleanupEvidence;
 export declare function validateBrokerModelPresetForTest(agentDir: string, requestedProfile: string): string | BrokerResponse;
+/** Test seam: the session-host command override as resolved from trusted env. */
+export declare function sdkSessionCommandOverrideForTest(): {
+    file: string;
+    args: string[];
+} | undefined;
 export declare function setProcessIncarnationForTest(broker: Broker, value: ((pid: number) => string | undefined) | undefined): void;
 /** The child writes this only after its endpoint and semantic ready event are both live. */
 export declare function writeSessionLifecycleReady(root: string, id: string, effectMarker: string): Promise<void>;

package/dist/types/sdk/bus/control-drain-lease.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Ordering seam for an in-band SDK identity transition.
+ *
+ * A request arrives through predecessor A, so a successful terminal response cannot
+ * be published until successor B is ready. Native builds may provide a true
+ * send-only connection lease; source/dev builds use the conservative fallback in
+ * which the predecessor server remains alive until the terminal write completes.
+ */
+export type TerminalSendOutcome = "written" | "disconnected" | "write_failed";
+/** Fence/capability hooks may return false to reject; undefined means ok. */
+export type IdentityControlGateResult = boolean | undefined;
+export type IdentityControlGate = () => IdentityControlGateResult | Promise<IdentityControlGateResult>;
+export interface IdentityControlSuccessPathInput {
+    /** Fence predecessor inbound work. The fence must not close its response writer. */
+    fence: IdentityControlGate;
+    /** Optional explicit proof that the predecessor writer is still usable. */
+    ensurePredecessorSendCapable?: IdentityControlGate;
+    /** Start successor B and resolve only after its public endpoint is ready. */
+    startSuccessor: () => Promise<void>;
+    /** Write and flush either the success or non-success terminal response. */
+    sendTerminal: () => Promise<TerminalSendOutcome>;
+    /** Release predecessor A after the terminal response has settled. */
+    stopPredecessor: () => Promise<void>;
+    /** Set only when a caller cannot use the retained-writer fallback. */
+    requireNativeControlDrain?: boolean;
+}
+export interface IdentityControlTerminalPathInput {
+    fenceInbound: IdentityControlGate;
+    ensurePredecessorSendCapable?: IdentityControlGate;
+    startSuccessorReady: () => Promise<void>;
+    sendTerminal: () => Promise<TerminalSendOutcome>;
+    stopPredecessor: () => Promise<void>;
+    requireNativeControlDrain?: boolean;
+}
+/**
+ * Probe the loaded native addon, never an environment flag or a TypeScript shim.
+ * Older/source installs intentionally report false so callers can select the
+ * retained-writer fallback or fail closed when detach is mandatory.
+ */
+export declare function isNativeControlDrainAvailable(): boolean;
+/**
+ * Run the only safe ordering for a successful identity-control response.
+ *
+ * The `finally` is deliberately around both successor startup and terminal
+ * delivery: a failed startup must not leave the fenced predecessor alive, and a
+ * failed/disconnected terminal write must still release it. When native detach
+ * is unavailable the caller is expected to keep A's server up (not call
+ * `stopAndWait`) until `sendTerminal` settles.
+ */
+export declare function runIdentityControlSuccessPath(input: IdentityControlSuccessPathInput): Promise<TerminalSendOutcome>;
+/** Compatibility spelling used by the host wiring design notes. */
+export declare function runIdentityControlTerminalPath(input: IdentityControlTerminalPathInput): Promise<TerminalSendOutcome>;

package/dist/types/sdk/bus/index.d.ts

@@ -30,6 +30,8 @@ import { type SdkStartupFailure } from "../startup-capability";
 import { type NotificationConfig } from "./config";
 import { NotificationSessionController } from "./session-control";
 import { type EnsureDaemonResult, type RegisterNotificationRootResult } from "./telegram-daemon";
+export type { IdentityControlSuccessPathInput, IdentityControlTerminalPathInput, TerminalSendOutcome, } from "./control-drain-lease";
+export { isNativeControlDrainAvailable, runIdentityControlSuccessPath, runIdentityControlTerminalPath, } from "./control-drain-lease";
 /** Where a `session_create` should run. Discriminated by `kind`. */
 export type SessionCreateTarget = {
     kind: "existing_path";
@@ -297,6 +299,8 @@ interface SessionRuntime {
     disposeGateListener: () => void;
     /** Whether notification-only delivery and answer resources are active. */
     notificationsActive: boolean;
+    /** Rejects new SDK frames while a leased terminal response drains. */
+    inboundFenced: boolean;
     /** Set as soon as terminal teardown is requested, before startup settles. */
     stopping: boolean;
     /** Recreates notification-only resources after `/notify on`. */
@@ -513,6 +517,17 @@ export declare class EphemeralTurnHost {
  * an identity for a transport that never became available is false success.
  */
 export declare function ensureConfiguredProviderDaemons(settings: Settings, cfg: NotificationConfig, ensureProviderDaemon?: (provider: "discord" | "slack", settings: Settings) => Promise<unknown>): Promise<void>;
+/**
+ * Classify whether a session identity event must await notification endpoint startup.
+ * Only an interactive selector resume may defer this ancillary startup; all other
+ * events, including branches and unknown origins, fail closed to awaiting it.
+ */
+export declare function shouldAwaitNotificationStartup(event: {
+    type: "session_switch" | "session_branch";
+    transition?: {
+        origin: string;
+    };
+}): boolean;
 export declare function createNotificationsExtension(api: ExtensionAPI, options?: {
     settings?: Settings;
     ensureTelegramDaemon?: (input: {
@@ -539,4 +554,3 @@ export declare function createNotificationsExtension(api: ExtensionAPI, options?
     readNotificationFile?: (path: string) => Promise<Buffer>;
     readNotificationDiffStat?: (cwd: string) => Promise<string | undefined>;
 }): void;
-export {};

package/dist/types/sdk/bus/kind-aware-reconciliation.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Kind-aware invocation reconciliation (prompt | skill) with optional durable store.
+ * Preserves Q26 admit/first-terminal/capacity/TTL semantics; indexes and caps are per-kind.
+ */
+import { type PromptCorrelation, type PromptReconciliationStatus, type TurnPromptReconciliation } from "./prompt-reconciliation";
+import type { ReconciliationKind, ReconciliationStore } from "./reconciliation-store";
+export type { ReconciliationKind };
+export interface KindCorrelation extends PromptCorrelation {
+    kind: ReconciliationKind;
+}
+export interface KindAwareReconciliation {
+    admit(kind: ReconciliationKind, clientRef?: string): void;
+    releaseAdmission(kind: ReconciliationKind, clientRef?: string): void;
+    noteAccepted(kind: ReconciliationKind, correlation: PromptCorrelation, clientRef?: string, extra?: {
+        skillName?: string;
+    }): Promise<void>;
+    noteTransition(kind: ReconciliationKind, correlation: PromptCorrelation | undefined, frame: {
+        type: "agent_start" | "agent_end";
+    } | {
+        type: "agent_failed";
+        error: unknown;
+    }): Promise<void>;
+    lookup(kind: ReconciliationKind, selector: {
+        commandId?: string;
+        turnId?: string;
+        clientRef?: string;
+    }): TurnPromptReconciliation;
+    cleanup(): void;
+    activeCount(kind: ReconciliationKind): number;
+    /** Hydrate from durable store (call once at session host start). */
+    hydrateFromStore(): Promise<void>;
+}
+export declare function createKindAwareReconciliation(options?: {
+    now?: () => number;
+    store?: ReconciliationStore | null;
+}): KindAwareReconciliation;
+export type { PromptReconciliationStatus };

package/dist/types/sdk/bus/prompt-reconciliation.d.ts

@@ -12,7 +12,8 @@
  * - Terminal records are retained for TERMINAL_TTL_MS and bounded to
  *   TERMINAL_CAPACITY, evicted oldest-terminal-first by terminalAt; only then
  *   does a lookup honestly report `unknown`.
- * - The durability floor is the live session process: restart means `unknown`.
+ * - Process-local durability floor is the live session process: restart means `unknown`.
+ *   Session-scoped durable retention (kind-aware store) is provided by reconciliation-store.ts (#3032).
  * - The clientRef index is session-runtime scoped; a ref conflicts only while
  *   retained and must never be reused as a retry mechanism.
  * - Terminal transitions settle once: the first terminal outcome wins.

package/dist/types/sdk/bus/reconciliation-store.d.ts

@@ -0,0 +1,65 @@
+import type { PromptCorrelation, PromptReconciliationStatus } from "./prompt-reconciliation";
+export declare const RECONCILIATION_STORE_VERSION = 1;
+export declare const RECONCILIATION_SESSION_ID_PATTERN: RegExp;
+export declare const RECONCILIATION_DIR_NAME = ".sdk-reconciliation";
+export type ReconciliationKind = "prompt" | "skill";
+export interface DurableReconciliationRecord extends PromptCorrelation {
+    kind: ReconciliationKind;
+    clientRef?: string;
+    status: PromptReconciliationStatus;
+    error?: {
+        code: string;
+        message: string;
+    };
+    acceptedAt: number;
+    startedAt?: number;
+    terminalAt?: number;
+    /** Skill-only safe token; never skill args bodies. */
+    skillName?: string;
+}
+export interface ReconciliationStoreDocument {
+    version: typeof RECONCILIATION_STORE_VERSION;
+    sessionId: string;
+    records: DurableReconciliationRecord[];
+}
+export interface ReconciliationStoreFs {
+    mkdir(directory: string, options: {
+        recursive: true;
+        mode: number;
+    }): Promise<unknown>;
+    readFile(file: string, encoding: "utf8"): Promise<string>;
+    writeFile(file: string, data: string, options: {
+        mode: number;
+    }): Promise<void>;
+    rename(from: string, to: string): Promise<void>;
+    unlink(file: string): Promise<void>;
+    open(file: string, flags: string): Promise<{
+        sync(): Promise<void>;
+        close(): Promise<void>;
+        writeFile(data: string, encoding: "utf8"): Promise<void>;
+    }>;
+}
+export declare function isSafeReconciliationSessionId(sessionId: string): boolean;
+/** Derive private store path; throws if sessionId is unsafe (path escape). */
+export declare function reconciliationStorePath(sessionFile: string, sessionId: string): string;
+/**
+ * Settle non-terminal durable records after process death: failed/process_restart.
+ * Meaning: reconciliation incomplete — not proof of agent failure.
+ */
+export declare function settleProcessRestart(records: DurableReconciliationRecord[], now: number): DurableReconciliationRecord[];
+export interface ReconciliationStore {
+    readonly path: string | null;
+    readonly sessionId: string;
+    /** Serialize mutations; reload not required for single-process host (in-memory + write). */
+    transact(mutator: (records: DurableReconciliationRecord[]) => DurableReconciliationRecord[]): Promise<void>;
+    load(): Promise<DurableReconciliationRecord[]>;
+    /** Snapshot currently held in memory after last load/transact. */
+    snapshot(): DurableReconciliationRecord[];
+    delete(): Promise<void>;
+}
+export declare function createReconciliationStore(options: {
+    sessionFile: string | null | undefined;
+    sessionId: string;
+    fs?: ReconciliationStoreFs;
+    now?: () => number;
+}): ReconciliationStore;

package/dist/types/sdk/host/control/operations.d.ts

@@ -13,7 +13,7 @@ export interface ControlSurface {
     answerAsk(id: string, answer: ControlValue): Promise<ControlValue> | ControlValue;
     answerGate(id: string, response: ControlValue, expectedSessionId?: string, idempotencyKey?: string): Promise<ControlValue> | ControlValue;
     approvePlan(id: string, choice: ControlValue, expectedSessionId?: string): Promise<ControlValue> | ControlValue;
-    invokeSkill(name: string, args: ControlValue): Promise<ControlValue> | ControlValue;
+    invokeSkill(name: string, args: ControlValue, clientRef?: string): Promise<ControlValue> | ControlValue;
     setPlanMode(on: boolean): Promise<ControlValue> | ControlValue;
     operateGoal(op: string, objective?: string): Promise<ControlValue> | ControlValue;
     replaceTodo(items: ControlValue): Promise<ControlValue> | ControlValue;

package/dist/types/sdk/host/host.d.ts

@@ -7,6 +7,8 @@ export interface SessionSdkHostOptions extends HostEndpointAdapters {
     query?: (connectionId: string, frame: SdkFrame) => unknown | Promise<unknown>;
     /** Best-effort diagnostic observation of accepted control/query frames. */
     onRequest?: SdkRequestObserver;
+    /** Runs before a control response is sent; identity transitions use sendTerminal. */
+    beforeControlResponse?: (connectionId: string, request: SdkFrame, response: SdkFrame, sendTerminal: () => Promise<void>) => void | Promise<void>;
     /** Runs only after a successful control response has been sent to the client. */
     afterControlResponse?: (connectionId: string, request: SdkFrame, response: SdkFrame) => void | Promise<void>;
     installProviderDefinitions?: (capability: string, definitions: unknown) => void;

package/dist/types/sdk/host/query/handlers.d.ts

@@ -37,6 +37,11 @@ export interface SessionSurface {
         turnId?: string;
         clientRef?: string;
     }): unknown | Promise<unknown>;
+    getSkillInvokeStatus?(selector: {
+        commandId?: string;
+        turnId?: string;
+        clientRef?: string;
+    }): unknown | Promise<unknown>;
     /** Q27 effective model-profile catalog from the live session registry. */
     getModelProfiles?(): unknown[] | Promise<unknown[]>;
     /** Query rows backed by the session's installed binding map. */

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

@@ -81,8 +81,10 @@ 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, ExtensionTranscriptEntry } from "../extensibility/extensions/types";
+import type { SessionSwitchEvent } from "../extensibility/shared-events";
 import { type Skill, type SkillWarning } from "../extensibility/skills";
 import { type FileSlashCommand } from "../extensibility/slash-commands";
+import { type MemoryGuardClaimsLease } from "../gjc-runtime/memory-guard-owner-claims";
 import { GoalRuntime } from "../goals/runtime";
 import type { Goal, GoalModeState } from "../goals/state";
 import type { HindsightSessionState } from "../hindsight/state";
@@ -101,6 +103,7 @@ 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 { MemoryGuardRestoreResult } from "./memory-guard-checkpoint-participant";
 import { type CustomMessage } from "./messages";
 import type { BranchSummaryEntry, CompactionEntry, NewSessionOptions, PreparedNewSession, RecoveryHydrationContext, RecoveryHydrationPromotionFence, SessionContext, SessionManager, SessionManagerCloseOutcome } from "./session-manager";
 import { ToolChoiceQueue } from "./tool-choice-queue";
@@ -314,6 +317,24 @@ export interface AgentSessionConfig {
     /** Optional provider-facing cache identity, distinct from logical session identity. */
     providerCacheSessionId?: string;
 }
+export interface AgentSessionMemoryGuardRestoreInput extends Omit<AgentSessionConfig, "sessionManager" | "recoveryHydrationContext"> {
+    staged: Extract<MemoryGuardRestoreResult, {
+        kind: "staged";
+    }>;
+    claimsLease: MemoryGuardClaimsLease;
+    claimsStateDir: string;
+}
+export interface AgentMemoryGuardPromotionFence extends RecoveryHydrationPromotionFence {
+    readonly claimsLease: MemoryGuardClaimsLease;
+}
+export type AgentMemoryGuardRestoreResult = {
+    kind: "staged";
+    session: AgentSession;
+    promotionFence: AgentMemoryGuardPromotionFence;
+} | {
+    kind: "blocked";
+    reason: "transcript-mismatch" | "hydration-context-mismatch" | "claim-mismatch" | "agent-messages-mismatch";
+};
 type MidRunMaintenanceLifecycle = Parameters<NonNullable<AgentLoopConfig["maintainContext"]>>[1];
 /** Options for AgentSession.prompt() */
 export interface PromptOptions {
@@ -336,8 +357,21 @@ export interface PromptOptions {
     /**
      * Invoked after all prompt preflight checks pass and immediately before agent execution begins.
      * Cancellation before this callback rejects the prompt.
+     * Prefer `onPreflightAcceptCommit` for async durable acceptance (#3031/#3032).
      */
     onPreflightAccepted?: () => void;
+    /**
+     * Awaitable durable-accept fence. Called after preflight and before queue mutation
+     * or `#promptAgentWithIdleRetry`. SDK bus installs a closure that fsyncs acceptance.
+     */
+    onPreflightAcceptCommit?: () => void | Promise<void>;
+    /** Skill-only: prepared metadata before the durable fence (path/lineCount/cleanedArgs). */
+    onSkillPrepared?: (meta: {
+        name: string;
+        path: string;
+        lineCount?: number;
+        cleanedArgs?: string;
+    }) => void;
 }
 /** Result from a handoff operation. */
 export interface HandoffResult {
@@ -755,10 +789,11 @@ export declare class AgentSession {
     /** All messages including custom types like BashExecutionMessage */
     get messages(): AgentMessage[];
     get transcriptPromptGeneration(): number;
+    static restoreFromMemoryGuardCheckpoint(input: AgentSessionMemoryGuardRestoreInput): Promise<AgentMemoryGuardRestoreResult>;
     /** The immutable recovery authority, present only before external ownership promotion. */
     get recoveryHydrationContext(): RecoveryHydrationContext | undefined;
     /** Enables normal session mutations after the owner has published its durable fence and writer lease. */
-    promoteRecoveryHydrationAfterOwnershipReadyFence(fence: RecoveryHydrationPromotionFence): Promise<void>;
+    promoteRecoveryHydrationAfterOwnershipReadyFence(fence: AgentMemoryGuardPromotionFence): Promise<void>;
     /** Main startup calls this exactly once, after a strict open returned `kind: "opened"`. */
     continuePersistedHistory(): Promise<void>;
     buildDisplaySessionContext(): SessionContext;
@@ -787,7 +822,7 @@ export declare class AgentSession {
     /** Live SDK configuration values exposed through the session query surface. */
     getSdkConfigItems(): Record<string, string>;
     setPlanModeState(state: PlanModeState | undefined): void;
-    invokeSkill(name: string, args?: string, options?: Pick<PromptOptions, "onPreflightAccepted">): Promise<{
+    invokeSkill(name: string, args?: string, options?: Pick<PromptOptions, "onPreflightAccepted" | "onPreflightAcceptCommit" | "onSkillPrepared">): Promise<{
         name: string;
         path: string;
         args?: string;
@@ -842,7 +877,7 @@ export declare class AgentSession {
      * @throws Error if no model selected or no API key available (when not streaming)
      */
     prompt(text: string, options?: PromptOptions): Promise<void>;
-    promptCustomMessage<T = unknown>(message: Pick<CustomMessage<T>, "customType" | "content" | "display" | "details" | "attribution">, options?: Pick<PromptOptions, "streamingBehavior" | "toolChoice" | "followUpQueuePolicy" | "onPreflightAccepted">): Promise<void>;
+    promptCustomMessage<T = unknown>(message: Pick<CustomMessage<T>, "customType" | "content" | "display" | "details" | "attribution">, options?: Pick<PromptOptions, "streamingBehavior" | "toolChoice" | "followUpQueuePolicy" | "onPreflightAccepted" | "onPreflightAcceptCommit">): Promise<void>;
     /**
      * Queue a steering message to interrupt the agent mid-run.
      */
@@ -882,6 +917,7 @@ export declare class AgentSession {
     sendUserMessage(content: string | (TextContent | ImageContent)[], options?: {
         deliverAs?: "steer" | "followUp";
         onPreflightAccepted?: () => void;
+        onPreflightAcceptCommit?: () => void | Promise<void>;
     }): Promise<void>;
     /**
      * Clear queued messages and return them.
@@ -1065,20 +1101,16 @@ export declare class AgentSession {
      * Get all available models with valid API keys.
      */
     getAvailableModels(): Model[];
-    /**
-     * Set thinking level.
-     * 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.
+     * Set thinking level from a control surface. Global changes commit before affecting live state.
      */
     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.
+     * Set thinking visibility from a control surface. Global changes commit before affecting live state.
      */
     setThinkingVisibilityForControl(visibility: "visible" | "hidden", persist: boolean): Promise<void>;
     /**
@@ -1316,7 +1348,9 @@ export declare class AgentSession {
      * Listeners are preserved and will continue receiving events.
      * @returns true if switch completed, false if cancelled by hook
      */
-    switchSession(sessionPath: string): Promise<boolean>;
+    switchSession(sessionPath: string, options?: {
+        transition?: SessionSwitchEvent["transition"];
+    }): Promise<boolean>;
     /**
      * Create a branch from a specific entry.
      * Emits before_branch/branch session events to hooks.