@gajae-code/coding-agent 0.9.5 → 0.10.0

package/dist/types/modes/components/gajae-pet-widget.d.ts

@@ -0,0 +1,59 @@
+import { type Component, type Container, type PetMode, type PetSkinId, type TUI } from "@gajae-code/tui";
+import type { CustomEditor } from "./custom-editor";
+/** Re-exported from the tui skin registry so widget-relative imports stay valid. */
+export type { PetMode, PetSkinId };
+/**
+ * Wraps the composer editor, reserving a right-side area beside it where the
+ * real-pixel pet is drawn. The editor just renders narrower; the pet pixels
+ * are emitted separately as an absolute-positioned overlay.
+ */
+export declare class PetFramedEditor implements Component {
+    #private;
+    constructor(editor: CustomEditor);
+    setReserve(columns: number): void;
+    canFit(width: number): boolean;
+    invalidate(): void;
+    render(width: number): string[];
+}
+/**
+ * The gajae pet: a 16x16 real-pixel sprite living in a reserved area beside
+ * the composer. It is nearest-neighbor scaled to the two terminal rows occupied
+ * by an empty one-line composer and lifted one row so its feet meet the input
+ * box's bottom edge.
+ *
+ * Rendering has two paths that share one payload builder:
+ * - a post-render emitter re-draws the sprite after every TUI write (line
+ *   renders clear the pet cells, so the overlay must be re-applied), and
+ * - frame advances write the payload directly to the terminal, because the
+ *   TUI skips writes entirely when no component line changed.
+ *
+ * Requires a sixel- or kitty-graphics terminal (`pixelProtocol()`).
+ */
+export declare class GajaePetWidget {
+    #private;
+    constructor(options: {
+        ui: TUI;
+        editor: CustomEditor;
+        editorContainer: Container;
+        floorContainer: Container;
+        isWorking: () => boolean;
+        /** Rows rendered below the composer box (pet floor + hook widgets). */
+        getComposerBottomOffset: () => number;
+        forcePixelProtocol?: "sixel" | "kitty";
+        /** Random [min, max] ms between auto-flexes; null disables. */
+        autoFlexGapMs?: [number, number] | null;
+    });
+    /** Protocol available for the real-pixel pet, if any. */
+    static pixelProtocol(): "sixel" | "kitty" | null;
+    get mode(): PetMode;
+    get isFlexing(): boolean;
+    setMode(mode: PetMode): void;
+    /** Live preview during a selector: change the sprite without re-mounting the
+     *  composer editor (that would tear down the open overlay). After a short idle
+     *  eye-roll it fires the signature burst once (RedGajae flex, BlueGajae para-para
+     *  then sob) so the selector demos the animation instead of waiting the random gap. */
+    previewMode(mode: PetMode): void;
+    dispose(): void;
+    /** Re-mount the composer editor (framed when a skin is active) after an overlay. */
+    remountComposer(): void;
+}

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

@@ -44,6 +44,11 @@ export interface HookSelectorOptions {
      * completion behavior as the main prompt editor.
      */
     autocompleteProvider?: AutocompleteProvider;
+    /**
+     * Maps raw single-key accelerators to option labels. Unset maps preserve
+     * the legacy selector key handling exactly.
+     */
+    acceleratorMap?: Readonly<Record<string, string>>;
 }
 export declare class HookSelectorComponent extends Container {
     #private;

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

@@ -0,0 +1,32 @@
+import { type Component, type ViewportAnchorProvider, type ViewportAnchorRender } from "@gajae-code/tui";
+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;
+/** 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;
+};
+export interface IrcSidebarTheme {
+    fg(color: "dim" | "accent", text: string): string;
+    bold(text: string): string;
+    readonly boxSharp: {
+        readonly vertical: string;
+    };
+}
+export type IrcSidebarThemeSource = IrcSidebarTheme | (() => IrcSidebarTheme);
+/** Read-only IRC history alongside the active transcript. */
+export declare class IrcSplitViewComponent implements ViewportAnchorProvider {
+    #private;
+    private readonly leftPane;
+    private readonly ledger;
+    private readonly componentTheme;
+    constructor(leftPane: Component, ledger: IrcObservationLedger, componentTheme: IrcSidebarThemeSource);
+    get visible(): boolean;
+    effectiveSidebarVisible(width?: number): boolean;
+    setVisible(visible: boolean): void;
+    render(width: number): string[];
+    renderWithViewportAnchors(width: number): ViewportAnchorRender;
+    invalidate(): void;
+}

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

@@ -0,0 +1,11 @@
+import { Container, SelectList } from "@gajae-code/tui";
+import type { PetMode } from "./gajae-pet-widget";
+/**
+ * Theme-style picker for the gajae pet skin (Off / RedGajae / BlueGajae). Preview
+ * fires as the selection moves; select commits, cancel restores.
+ */
+export declare class PetSelectorComponent extends Container {
+    #private;
+    constructor(current: PetMode, onSelect: (mode: PetMode) => void, onCancel: () => void, onPreview: (mode: PetMode) => void);
+    getSelectList(): SelectList;
+}

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

@@ -1,28 +1,41 @@
 import { type Component, Container } from "@gajae-code/tui";
-import type { SessionInfo } from "../../session/session-manager";
-/**
- * Custom session list component with multi-line items and search
- */
+import type { ResumeSessionIdentity, ResumeTailInspection, SessionInfo } from "../../session/session-manager";
+export interface SelectedSession {
+    kind: "selected";
+    path: string;
+    identity: ResumeSessionIdentity;
+    action: "continue-tail" | "open-idle";
+}
+export interface CancelledSessionSelection {
+    kind: "cancelled";
+}
+export type SessionSelectionResult = SelectedSession | CancelledSessionSelection;
+export type SessionInspector = (sessionPath: string) => Promise<ResumeTailInspection>;
 declare class SessionList implements Component {
     #private;
     private readonly allSessions;
     private readonly showCwd;
-    onSelect?: (sessionPath: string) => void;
+    onSelect?: (session: SessionInfo) => void;
     onCancel?: () => void;
     onExit: () => void;
     onDeleteRequest?: (session: SessionInfo) => void;
     constructor(allSessions: SessionInfo[], showCwd?: boolean);
+    setInputFrozen(frozen: boolean): void;
     removeSession(sessionPath: string): void;
     invalidate(): void;
     render(width: number): string[];
     handleInput(keyData: string): void;
 }
-/**
- * Component that renders a session selector with optional confirmation dialog
- */
+/** A one-shot resume consent selector. It never opens or mutates sessions. */
 export declare class SessionSelectorComponent extends Container {
     #private;
-    constructor(sessions: SessionInfo[], onSelect: (sessionPath: string) => void, onCancel: () => void, onExit: () => void, onDelete?: (session: SessionInfo) => Promise<boolean>);
+    private readonly onSelect;
+    private readonly onCancel;
+    private readonly onExit;
+    private readonly onDelete?;
+    private readonly inspector?;
+    private readonly onSelection?;
+    constructor(sessions: SessionInfo[], onSelect: (sessionPath: string) => void, onCancel: () => void, onExit: () => void, onDelete?: ((session: SessionInfo) => Promise<boolean>) | undefined, inspector?: SessionInspector | undefined, onSelection?: ((selection: SessionSelectionResult) => void) | undefined);
     setOnRequestRender(callback: () => void): void;
     handleInput(keyData: string): void;
     getSessionList(): SessionList;

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

@@ -39,6 +39,8 @@ export interface SettingsCallbacks {
     onThemePreview?: (theme: string) => void | Promise<void>;
     /** Called to restore the rendered theme when theme settings preview is cancelled */
     onThemePreviewCancel?: (theme: string) => void | Promise<void>;
+    /** Called to live-preview the gajae pet skin while browsing the pet setting. */
+    onPetPreview?: (mode: string) => void;
     /** Called for status line preview while configuring */
     onStatusLinePreview?: (settings: StatusLinePreviewSettings) => void;
     /** Get current rendered status line for inline preview */

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

@@ -51,4 +51,5 @@ export declare class ToolExecutionComponent extends Container {
     setExpanded(expanded: boolean): void;
     setShowImages(show: boolean): void;
     invalidate(): void;
+    render(width: number): string[];
 }

package/dist/types/modes/components/user-message.d.ts

@@ -3,5 +3,6 @@ import { Container } from "@gajae-code/tui";
  * Component that renders a user message
  */
 export declare class UserMessageComponent extends Container {
-    constructor(text: string, synthetic?: boolean);
+    #private;
+    constructor(text: string, synthetic?: boolean, viewportAnchorId?: string);
 }

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

@@ -1,3 +1,4 @@
+import { type Component } from "@gajae-code/tui";
 import type { InteractiveModeContext } from "../../modes/types";
 import type { AgentSessionEvent } from "../../session/agent-session";
 /** Test-only performance counters for advisory baseline tests. */
@@ -12,6 +13,9 @@ export declare class EventController {
     dispose(): void;
     subscribeToAgent(): void;
     handleEvent(event: AgentSessionEvent): Promise<void>;
+    clearIrcExpiryTimers(): void;
+    resetIrcObservations(): void;
+    reconcileIrcExpiryTimers(componentsByObservationId: Map<string, readonly Component[]>): void;
     sendCompletionNotification(): void;
     handleBackgroundEvent(event: AgentSessionEvent): Promise<void>;
 }

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

@@ -29,6 +29,7 @@ export declare class SelectorController {
     showEffortSelector(): void;
     showSettingsSelector(): void;
     showThemeSelector(): void;
+    showPetSelector(): void;
     showHistorySearch(): void;
     /**
      * Show the Extension Control Center dashboard.

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

@@ -18,16 +18,20 @@ import type { AssistantMessageComponent } from "./components/assistant-message";
 import type { BashExecutionComponent } from "./components/bash-execution";
 import { CustomEditor } from "./components/custom-editor";
 import type { EvalExecutionComponent } from "./components/eval-execution";
+import { GajaePetWidget, type PetMode } from "./components/gajae-pet-widget";
 import type { HookEditorComponent } from "./components/hook-editor";
 import type { HookInputComponent } from "./components/hook-input";
 import type { HookSelectorComponent } from "./components/hook-selector";
 import { StatusLineComponent } from "./components/status-line";
 import type { ToolExecutionHandle } from "./components/tool-execution";
 import { type WelcomeLogoMode } from "./components/welcome";
+import { IrcObservationLedger } from "./irc-observation-ledger";
 import { OAuthManualInputManager } from "./oauth-manual-input";
 import type { Theme } from "./theme/theme";
-import type { CompactionQueuedMessage, InteractiveModeContext, SubmittedUserInput, TodoItem, TodoPhase } from "./types";
+import type { CompactionQueuedMessage, InteractiveModeContext, IrcArrivalSnapshot, SubmittedUserInput, TodoItem, TodoPhase, TranscriptRebuildPolicy } from "./types";
+import type { ParsedIrcMessage } from "./utils/irc-message";
 export declare const DEFAULT_COMPOSER_PLACEHOLDER: string;
+export declare function getWelcomeTranscriptReservedRows(chatContainer: Container, width: number): number;
 export type WelcomeBannerSettingMode = "auto" | "unicode" | "square" | "ascii";
 export declare function resolveWelcomeLogoMode(mode: WelcomeBannerSettingMode, env?: Record<string, string | undefined>, platform?: NodeJS.Platform): WelcomeLogoMode;
 /** Options for creating an InteractiveMode instance (for future API use) */
@@ -51,6 +55,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     keybindings: KeybindingsManager;
     agent: Agent;
     historyStorage?: HistoryStorage;
+    readonly ircLedger: IrcObservationLedger;
     ui: TUI;
     chatContainer: Container;
     pendingMessagesContainer: Container;
@@ -61,6 +66,8 @@ export declare class InteractiveMode implements InteractiveModeContext {
     editorContainer: Container;
     hookWidgetContainerAbove: Container;
     hookWidgetContainerBelow: Container;
+    petFloorContainer: Container;
+    petWidget: GajaePetWidget | undefined;
     statusLine: StatusLineComponent;
     isInitialized: boolean;
     isBackgrounded: boolean;
@@ -132,7 +139,10 @@ export declare class InteractiveMode implements InteractiveModeContext {
     updateEditorChrome(): void;
     updateEditorBorderColor(): void;
     updateEditorTopBorder(): void;
-    rebuildChatFromMessages(): void;
+    setPetMode(mode: PetMode): void;
+    previewPetMode(mode: PetMode): void;
+    restoreComposer(): void;
+    rebuildChatFromMessages(policy: TranscriptRebuildPolicy): void;
     /** Apply any deferred model switch after the current stream ends. */
     flushPendingModelSwitch(): Promise<void>;
     handlePlanModeCommand(initialPrompt?: string): Promise<void>;
@@ -166,15 +176,22 @@ export declare class InteractiveMode implements InteractiveModeContext {
     addMessageToChat(message: AgentMessage, options?: {
         populateHistory?: boolean;
     }): Component[];
+    addLiveIrcObservationToChat(message: ParsedIrcMessage, arrival: IrcArrivalSnapshot): Component[];
+    removeRenderedIrcInlineComponents(observationId: string): readonly Component[] | undefined;
+    resetRenderedIrcInlineComponents(): readonly (readonly Component[])[];
     renderSessionContext(sessionContext: SessionContext, options?: {
         updateFooter?: boolean;
         populateHistory?: boolean;
     }): void;
+    rebuildInitialMessages(policy: TranscriptRebuildPolicy, prebuiltContext?: SessionContext, options?: {
+        preserveExistingChat?: boolean;
+    }): void;
     renderInitialMessages(prebuiltContext?: SessionContext, options?: {
         preserveExistingChat?: boolean;
     }): void;
     getUserMessageText(message: Message): string;
     findLastAssistantMessage(): AssistantMessage | undefined;
+    getAssistantViewportAnchorId(message: AssistantMessage): string;
     extractAssistantText(message: AssistantMessage): string;
     handleExportCommand(text: string): Promise<void>;
     handleDumpCommand(): void;
@@ -213,6 +230,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     openInBrowser(urlOrPath: string): void;
     showSettingsSelector(): void;
     showThemeSelector(): void;
+    showPetSelector(): void;
     showHistorySearch(): void;
     showExtensionsDashboard(): void;
     showAgentsDashboard(): void;
@@ -244,6 +262,10 @@ export declare class InteractiveMode implements InteractiveModeContext {
     }): Promise<void>;
     toggleToolOutputExpansion(): void;
     setToolsExpanded(expanded: boolean): void;
+    captureIrcArrivalSnapshot(): IrcArrivalSnapshot;
+    toggleIrcSidebar(): void;
+    applyIrcSidebarAvailability(enabled: boolean): void;
+    resetIrcSidebarSession(): void;
     toggleThinkingBlockVisibility(): void;
     toggleTodoExpansion(): void;
     setTodos(todos: TodoItem[] | TodoPhase[]): void;

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

@@ -0,0 +1,22 @@
+import type { ParsedIrcMessage } from "./utils/irc-message";
+type InlineMode = "persistent" | "ephemeral";
+export type IrcObservationRecord = Readonly<ParsedIrcMessage & {
+    mode: InlineMode;
+    observedAt: number;
+    sequence: number;
+    expiresAt?: number;
+    retainedUtf8Bytes: number;
+}>;
+/** Runtime-only IRC observations. This intentionally has no persistence layer. */
+export declare class IrcObservationLedger {
+    #private;
+    /** Inline observations expire after 10 seconds; closed-panel observations persist inline. */
+    observe(message: ParsedIrcMessage, panelVisibleAtObservation: boolean): IrcObservationRecord | undefined;
+    getRecord(observationId: string): IrcObservationRecord | undefined;
+    getSidebarRecords(): readonly IrcObservationRecord[];
+    getInlineProjection(now: number): readonly IrcObservationRecord[];
+    /** Returns and clears IDs whose retained payload was released. */
+    drainEvictedObservationIds(): readonly string[];
+    reset(): void;
+}
+export {};

package/dist/types/modes/shared/agent-wire/deep-interview-gate.d.ts

@@ -42,6 +42,8 @@ export interface AskGateQuestion {
     deepInterview?: AskGateDeepInterviewState;
     /** Override the emitted workflow gate address for non-deep-interview ask prompts. */
     workflowGate?: AskGateWorkflowGateMeta;
+    allowEmpty?: boolean;
+    navigationLabel?: "Next" | "Done";
 }
 export interface AskGateResult {
     id: string;
@@ -90,5 +92,11 @@ export declare function questionToGate(question: AskGateQuestion): OpenGateInput
  * semantically invalid answer.
  */
 export declare function gateAnswerToResult(question: AskGateQuestion, answer: unknown): AskGateResult;
+/**
+ * Classify an accepted ask-domain gate answer independently of its transport.
+ * Schema-invalid and semantically invalid answers throw, so callers leave the
+ * durable gate pending rather than treating them as a non-committing answer.
+ */
+export declare function classifyAskGateDisposition(gate: Pick<OpenGateInput, "context" | "options">, answer: unknown): "commit" | "resolve_without_commit";
 /** Convenience: map a batch of ask questions to gate open-inputs. */
 export declare function questionsToGates(questions: AskGateQuestion[]): OpenGateInput[];

package/dist/types/modes/shared/agent-wire/unattended-run-controller.d.ts

@@ -156,6 +156,11 @@ export declare class UnattendedRunController {
     /** Returns the in-flight/settled abort completion once aborting has begun. */
     get abortCompletion(): Promise<void> | undefined;
     private fireAbort;
+    /**
+     * Invoke every configured abort hook exactly once with per-hook isolation, so a
+     * failing hook never prevents the other cancellation surfaces from running.
+     * Returns the number of hooks that rejected.
+     */
     private runAbortHooks;
 }
 export {};

package/dist/types/modes/shared/agent-wire/unattended-session.d.ts

@@ -15,10 +15,45 @@
  * RPC server can route `negotiate_unattended` + `workflow_gate_response` here.
  */
 import type { Model } from "@gajae-code/ai";
+import type { AskSelectedAckOutcome } from "../../../tools";
 import type { RpcCommand, RpcUnattendedAccepted, RpcUnattendedDeclaration, RpcWorkflowGate, RpcWorkflowGateResolution, RpcWorkflowGateResponse } from "../../rpc/rpc-types";
 import type { RpcUnattendedControlPlane } from "./command-dispatch";
 import { type UnattendedAbortHooks, type UnattendedAuditEvent, UnattendedRunController } from "./unattended-run-controller";
 import { type GateStore, type OpenGateInput } from "./workflow-gate-broker";
+export interface WorkflowGateTerminalController {
+    completeGateInteractions(gateId: string): void | Promise<void>;
+    cancelGateInteractions(gateId: string, reason: string): void | Promise<void>;
+}
+export interface WorkflowGateTerminalEvent {
+    gateId: string;
+    kind: "accepted" | "cancelled";
+    origin?: "rpc" | "bridge" | "other" | "telegram_notification";
+    reason?: string;
+}
+export interface NotificationGateResolutionOptions {
+    interactionActionId: string;
+    replyReceiptId: string;
+    answerJson: string;
+    idempotencyKey?: string;
+    requestSelectedAck(input: {
+        replyReceiptId: string;
+        actionId: string;
+        commitKey: string;
+        daemonDeadlineAt: number;
+        hostTimeoutMs: number;
+    }): Promise<AskSelectedAckOutcome>;
+    resolveClaim(): void;
+    closeClaimInvalid(reason: string): void;
+}
+export interface AskSelectedAckRecoveryParticipant {
+    requestRecoveredAskSelectedAck(input: {
+        sessionId: string;
+        actionId: string;
+        commitKey: string;
+        deadlineAt: number;
+        hostTimeoutMs: number;
+    }): Promise<AskSelectedAckOutcome>;
+}
 /**
  * Derive an explicit `providerSupportsTokenCostMetrics` capability from the
  * active model so unattended negotiation fails closed when token/cost usage
@@ -41,7 +76,10 @@ export interface WorkflowGateEmitter {
      */
     onGateEmitted?(listener: (gate: RpcWorkflowGate) => void): () => void;
     resolveGate?(response: RpcWorkflowGateResponse): Promise<RpcWorkflowGateResolution>;
+    resolveGateFromNotification?(response: RpcWorkflowGateResponse, options: NotificationGateResolutionOptions): Promise<RpcWorkflowGateResolution>;
+    registerGateTerminalController?(controller: WorkflowGateTerminalController): () => void;
     listPendingGates?(): RpcWorkflowGate[];
+    setAckRecoveryParticipant?(participant: AskSelectedAckRecoveryParticipant | null): void;
 }
 export interface UnattendedSessionOptions {
     runId: string;
@@ -72,10 +110,17 @@ export declare class UnattendedSessionControlPlane implements RpcUnattendedContr
     /** Observe every emitted gate (e.g. so an extension can map an ask to its gate_id). */
     onGateEmitted(listener: (gate: RpcWorkflowGate) => void): () => void;
     get controller(): UnattendedRunController | undefined;
+    registerGateTerminalController(controller: WorkflowGateTerminalController): () => void;
+    setAckRecoveryParticipant(participant: AskSelectedAckRecoveryParticipant | null): void;
     negotiate(declaration: RpcUnattendedDeclaration): RpcUnattendedAccepted;
     preflightCommand(command: RpcCommand): void;
     reconcileUsage(phase?: string): void;
     resolveGate(response: RpcWorkflowGateResponse): Promise<RpcWorkflowGateResolution>;
+    resolveGateFromNotification(response: RpcWorkflowGateResponse, options: NotificationGateResolutionOptions): Promise<RpcWorkflowGateResolution>;
+    startRecoveryOnce(options?: {
+        participantGraceMs?: number;
+    }): Promise<void>;
+    dispose(reason?: string): void;
     listPendingGates(): import("../../rpc/rpc-types").RpcWorkflowGate[];
     emitGate(input: OpenGateInput): Promise<unknown>;
     recover(): Promise<void>;

package/dist/types/modes/shared/agent-wire/workflow-gate-broker.d.ts

@@ -1,4 +1,32 @@
-import type { RpcWorkflowGate, RpcWorkflowGateContext, RpcWorkflowGateKind, RpcWorkflowGateOption, RpcWorkflowGateResolution, RpcWorkflowGateResponse, RpcWorkflowStage } from "../../rpc/rpc-types";
+import type { AskSelectedAckOutcome } from "../../../tools";
+import type { RpcWorkflowGate, RpcWorkflowGateContext, RpcWorkflowGateKind, RpcWorkflowGateOption, RpcWorkflowGateResolution, RpcWorkflowGateResponse, RpcWorkflowGateValidationError, RpcWorkflowStage } from "../../rpc/rpc-types";
+export type PersistedSemanticDisposition = "commit" | "resolve_without_commit";
+export type PersistedResolutionOrigin = {
+    kind: "generic";
+    channel: "rpc" | "bridge" | "other";
+} | {
+    kind: "telegram_notification";
+    interactionActionId: string;
+} | {
+    kind: "legacy_unknown";
+};
+export type PersistedAckPolicy = {
+    kind: "none";
+    reason: "non_telegram" | "semantic_noncommit" | "legacy_unproven";
+} | {
+    kind: "telegram_selected_v1";
+    commitKey: string;
+    actionId: string;
+    state: "pending" | "attempt_started" | "delivered" | "failed" | "unknown";
+    outcome?: AskSelectedAckOutcome;
+    updatedAt: string;
+};
+export interface GateResolutionOptions {
+    semanticDisposition?: PersistedSemanticDisposition;
+    resolutionOrigin?: PersistedResolutionOrigin;
+    ackPolicy?: PersistedAckPolicy;
+    beforeAdvance?: () => Promise<void>;
+}
 export interface PersistedGate {
     gate: RpcWorkflowGate;
     status: "pending" | "accepted";
@@ -8,6 +36,9 @@ export interface PersistedGate {
     answer?: unknown;
     resolution?: RpcWorkflowGateResolution;
     advanced: boolean;
+    semanticDisposition?: PersistedSemanticDisposition;
+    resolutionOrigin?: PersistedResolutionOrigin;
+    ackPolicy?: PersistedAckPolicy;
 }
 export interface GateStore {
     nextSeq(stage: RpcWorkflowStage): number;
@@ -74,6 +105,8 @@ export interface BrokerHooks {
      * it for any gate left `accepted` but not `advanced` by a crash.
      */
     advance?(gate: RpcWorkflowGate, answer: unknown): void | Promise<void>;
+    /** Runs after durable acceptance and before advance, including crash recovery. */
+    finalizeAccepted?(record: PersistedGate): Promise<void>;
     /** Append-only audit sink. */
     audit?(event: GateAuditEvent): void;
 }
@@ -92,7 +125,13 @@ export declare class WorkflowGateBroker {
     private readonly runId;
     private readonly store;
     private readonly hooks;
+    private readonly recovering;
+    private readonly gateLocks;
+    private withGateLock;
     constructor(runId: string, store: GateStore, hooks?: BrokerHooks);
+    classifyDisposition(gateId: string, answer: unknown): PersistedSemanticDisposition;
+    validationError(gateId: string, keyword: string, message: string): RpcWorkflowGateValidationError;
+    updateAckPolicy(gateId: string, ackPolicy: PersistedAckPolicy): void;
     private runShort;
     /** Open and emit a gate. The pending record is persisted BEFORE emission. */
     openGate(input: OpenGateInput): RpcWorkflowGate;
@@ -101,7 +140,8 @@ export declare class WorkflowGateBroker {
      * On success the resolution is persisted BEFORE `advance` is invoked exactly
      * once. Invalid answers leave the gate pending (per #315 acceptance).
      */
-    resolve(response: RpcWorkflowGateResponse): Promise<RpcWorkflowGateResolution>;
+    resolve(response: RpcWorkflowGateResponse, options?: GateResolutionOptions): Promise<RpcWorkflowGateResolution>;
+    private resolveUnlocked;
     /**
      * Recover any gate left `accepted` but not `advanced` by a crash between the
      * durable accept and the advanced commit. Replays `advance` (which must be