@gajae-code/coding-agent 0.2.4 → 0.3.0

package/dist/types/harness-control-plane/receipts.d.ts

@@ -0,0 +1,88 @@
+import type { GitDelta, ReceiptFamily, RecoveryClassification } from "./types";
+export interface ReceiptSubject {
+    workspace: string;
+    branch: string | null;
+    head: string | null;
+    commit: string | null;
+}
+export interface ReceiptEnvelope<E = Record<string, unknown>> {
+    receiptId: string;
+    schemaVersion: number;
+    sessionId: string;
+    family: ReceiptFamily;
+    valid: boolean;
+    createdAt: string;
+    source: string;
+    subject: ReceiptSubject;
+    evidence: E;
+    /** Hashes of out-of-line artifacts (diff patches, validation logs) folded into the receipt hash. */
+    artifactHashes: Record<string, string>;
+    sha256: string;
+}
+export declare const RECEIPT_SCHEMA_VERSION: 1;
+export declare function sha256Hex(input: string): string;
+export interface BuildReceiptInput<E> {
+    receiptId: string;
+    sessionId: string;
+    family: ReceiptFamily;
+    source: string;
+    subject: ReceiptSubject;
+    evidence: E;
+    artifactHashes?: Record<string, string>;
+    createdAt?: string;
+    valid?: boolean;
+}
+export declare function buildReceipt<E>(input: BuildReceiptInput<E>): ReceiptEnvelope<E>;
+export interface ValidationOutcome {
+    valid: boolean;
+    reasons: string[];
+}
+/** Recompute the hash and run structural family checks. Fail-closed. */
+export declare function validateReceipt(receipt: ReceiptEnvelope<unknown>): ValidationOutcome;
+export interface VanishEvidence {
+    classification: RecoveryClassification;
+    gitDelta: GitDelta;
+    gitStatusPorcelain: string;
+    untrackedManifest: {
+        path: string;
+        size: number;
+        sha256: string;
+    }[];
+    preservation: "snapshot" | "stash" | "block";
+    stashRef: string | null;
+    snapshotComplete: boolean;
+    forbiddenActions: string[];
+}
+export interface PromptAcceptanceEvidence {
+    promptSha256: string;
+    rpcCommandId: string;
+    preSubmitState: {
+        isStreaming: boolean;
+        steeringQueueDepth: number;
+        followupQueueDepth: number;
+    };
+    preSubmitCursor: number;
+    agentStartCursor: number;
+    acceptedAt: string;
+    singleFlight: true;
+}
+export interface ValidationEvidence {
+    command: string;
+    exactCommand: string;
+    cwd: string;
+    exitStatus: number;
+    pass: boolean;
+    commitUnderTest: string | null;
+}
+export interface CompletionEvidence {
+    finalCommit: string;
+    branch: string;
+    prUrl: string | null;
+    issueArtifact: string | null;
+    requiredValidationReceiptIds: string[];
+    finalLifecycle: string;
+    finalizedAt: string;
+    blockers: string[];
+}
+/** Classifications that MUST have a valid `vanish` receipt before the action proceeds. */
+export declare function requiresVanishBeforeAction(classification: RecoveryClassification): boolean;

package/dist/types/harness-control-plane/rpc-adapter.d.ts

@@ -0,0 +1,66 @@
+export interface RpcStateSnapshot {
+    isStreaming: boolean;
+    steeringQueueDepth: number;
+    followupQueueDepth: number;
+}
+/** Abstract handle to a live gajae-code RPC session. */
+export interface HarnessRpc {
+    getState(): Promise<RpcStateSnapshot>;
+    /** Send a prompt; resolves with the RPC command id and whether it was acked. Does NOT await agent_start. */
+    sendPrompt(prompt: string): Promise<{
+        commandId: string;
+        ack: boolean;
+    }>;
+    /** Monotonic count of events observed so far (the acceptance cursor). */
+    eventCursor(): number;
+    /** Resolve when an `agent_start` event arrives strictly after `afterCursor`, else null on timeout. */
+    waitForAgentStart(afterCursor: number, timeoutMs: number): Promise<{
+        cursor: number;
+    } | null>;
+    close(): Promise<void>;
+    /** Subscribe to parsed event frames (non-ready, non-response), fired AFTER the cursor advances. Returns unsubscribe. */
+    onEventFrame?(listener: (frame: Record<string, unknown>) => void): () => void;
+    /** Whether the underlying RPC subprocess is still alive. */
+    isLive?(): boolean;
+    /** ISO timestamp of the last observed event frame, or null. */
+    lastFrameAt?(): string | null;
+}
+export interface AcceptanceResult {
+    accepted: boolean;
+    reason: string;
+    commandId: string | null;
+    preSubmitCursor: number;
+    agentStartCursor: number | null;
+    preSubmitState: RpcStateSnapshot;
+}
+/**
+ * Single-flight acceptance: idle + empty-queue pre-state, ack, then the NEXT
+ * `agent_start` after the pre-submit cursor within `timeoutMs`.
+ */
+export declare function singleFlightAccept(rpc: HarnessRpc, prompt: string, timeoutMs: number): Promise<AcceptanceResult>;
+/**
+ * Real adapter: spawns `gjc --mode rpc --session-dir <dir>` and speaks the JSONL
+ * protocol from docs/rpc.md. Verified end-to-end in the M10 suite.
+ */
+export declare class GajaeCodeRpc implements HarnessRpc {
+    #private;
+    constructor(opts: {
+        sessionDir: string;
+        command?: string[];
+        cwd?: string;
+        env?: NodeJS.ProcessEnv;
+    });
+    onEventFrame(listener: (frame: Record<string, unknown>) => void): () => void;
+    isLive(): boolean;
+    lastFrameAt(): string | null;
+    getState(): Promise<RpcStateSnapshot>;
+    sendPrompt(prompt: string): Promise<{
+        commandId: string;
+        ack: boolean;
+    }>;
+    eventCursor(): number;
+    waitForAgentStart(afterCursor: number, timeoutMs: number): Promise<{
+        cursor: number;
+    } | null>;
+    close(): Promise<void>;
+}

package/dist/types/harness-control-plane/seams.d.ts

@@ -0,0 +1,21 @@
+/**
+ * v1 seams (M11). The control plane is harness-agnostic by design, but v1 ships ONLY the
+ * gajae-code adapter. Other harnesses and transports are explicit, designed-not-built seams
+ * that fail closed with a clear `seam_unsupported_in_v1` signal rather than silently degrading.
+ */
+import type { Harness } from "./types";
+export declare const SUPPORTED_HARNESSES: readonly Harness[];
+export declare const DEFERRED_SEAMS: readonly ["codex-adapter", "omx-adapter", "remote-transport", "global-daemon", "capability-token-auth", "web-viewer", "fleet-control-plane", "rich-tui-coview"];
+export type DeferredSeam = (typeof DEFERRED_SEAMS)[number];
+export declare function isHarnessSupported(harness: string): harness is Harness;
+export interface UnsupportedSeamResult {
+    ok: false;
+    error: string;
+    evidence: {
+        seam: true;
+        name: string;
+        supported: readonly Harness[];
+        deferred: readonly string[];
+    };
+}
+export declare function unsupportedSeam(name: string): UnsupportedSeamResult;

package/dist/types/harness-control-plane/session-lease.d.ts

@@ -0,0 +1,65 @@
+export interface SessionLease {
+    ownerId: string;
+    sessionId: string;
+    pid: number;
+    leaseTokenHash: string;
+    endpoint: {
+        kind: "unix-socket" | "fifo";
+        path: string;
+    } | null;
+    eventsPath: string;
+    heartbeatAt: string;
+    expiresAt: string;
+    leaseEpoch: number;
+    writer: {
+        ownerId: string;
+        leaseEpoch: number;
+    };
+}
+export declare class LeaseError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+export type LeaseStatus = "missing" | "live" | "expiredAlive" | "dead" | "epermAlive";
+type PidStatus = "alive" | "dead" | "eperm";
+export declare function readLease(root: string, sessionId: string): Promise<SessionLease | null>;
+export declare function isExpired(lease: SessionLease, clock?: () => number): boolean;
+export declare function classifyLeaseStatus(lease: SessionLease | null, opts?: {
+    clock?: () => number;
+    probe?: (pid: number) => PidStatus;
+}): LeaseStatus;
+/** Liveness probe via signal 0. Defaults to the real process table; injectable for tests. */
+export declare function isOwnerAlive(pid: number, probe?: (pid: number) => boolean): boolean;
+export declare function isStale(lease: SessionLease, opts?: {
+    clock?: () => number;
+    probe?: (pid: number) => boolean;
+}): boolean;
+export interface AcquireOptions {
+    ownerId: string;
+    pid: number;
+    endpoint?: SessionLease["endpoint"];
+    eventsPath: string;
+    ttlMs: number;
+    clock?: () => number;
+    probe?: (pid: number) => boolean | PidStatus;
+}
+export interface AcquiredLease {
+    lease: SessionLease;
+    token: string;
+}
+/**
+ * Acquire (or take over a stale) lease. Fails closed with `lease_held` when a live,
+ * unexpired lease is held by a different owner. Re-acquiring as the current owner refreshes.
+ */
+export declare function acquireLease(root: string, sessionId: string, opts: AcquireOptions): Promise<AcquiredLease>;
+/** Refresh the lease expiry. Only the recorded owner may heartbeat (single-writer). */
+export declare function heartbeat(root: string, sessionId: string, ownerId: string, ttlMs: number, clock?: () => number): Promise<SessionLease>;
+/** Whether `ownerId` is the live, unexpired single writer permitted to append events. */
+export declare function canWriteEvents(lease: SessionLease, ownerId: string, clock?: () => number): boolean;
+/** Release the lease (owner shutdown). Only the holder may release. */
+export declare function releaseLease(root: string, sessionId: string, ownerId: string): Promise<void>;
+export declare function reapDeadOwnerArtifacts(root: string, sessionId: string, expectedOwnerId: string, expectedEpoch: number, opts?: {
+    clock?: () => number;
+    probe?: (pid: number) => PidStatus;
+}): Promise<boolean>;
+export {};

package/dist/types/harness-control-plane/state-machine.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Lifecycle state machine + the universal `{state, evidence, nextAllowedActions}` contract.
+ *
+ * `nextAllowedActions` is the forcing function: it tells the caller exactly which
+ * primitives are currently permitted and, when not, why. Owner-routed verbs
+ * (`submit`) report `owner-not-live` when no `RuntimeOwner` holds the session lease.
+ */
+import type { HarnessLifecycle, NextAllowedAction, PrimitiveResponse, SessionState, SessionStateView } from "./types";
+export declare function isTerminal(lifecycle: HarnessLifecycle): boolean;
+export declare function canTransition(from: HarnessLifecycle, to: HarnessLifecycle): boolean;
+export declare function assertTransition(from: HarnessLifecycle, to: HarnessLifecycle): void;
+/**
+ * Derive the permitted next actions for a session given its lifecycle and whether
+ * a live owner currently holds the lease.
+ */
+export declare function nextAllowedActions(lifecycle: HarnessLifecycle, ownerLive: boolean): NextAllowedAction[];
+export declare function buildStateView(state: SessionState, ownerLive: boolean): SessionStateView;
+/** Build the universal contract response carried by every primitive. */
+export declare function buildResponse<E extends Record<string, unknown>>(state: SessionState, ownerLive: boolean, evidence: E, ok?: boolean): PrimitiveResponse<E>;

package/dist/types/harness-control-plane/storage.d.ts

@@ -0,0 +1,53 @@
+import type { EventEnvelope, ReceiptFamily, SessionState } from "./types";
+export declare const MAX_UNIX_SOCKET_PATH_BYTES = 100;
+export declare function controlSocketPath(root: string, sessionId: string, env?: NodeJS.ProcessEnv): string;
+export declare class StorageError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+/** Resolve the harness state root from explicit value, env, or cwd default. */
+export declare function resolveHarnessRoot(opts?: {
+    root?: string;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}): string;
+export declare function assertSafeSessionId(id: string): void;
+export declare function generateSessionId(prefix?: string): string;
+export interface SessionPaths {
+    dir: string;
+    state: string;
+    lease: string;
+    events: string;
+    receiptsIndex: string;
+    receiptsDir: string;
+    artifactsDir: string;
+    controlSock: string;
+    controlFifo: string;
+    gjcSessionDir: string;
+}
+export declare function sessionPaths(root: string, sessionId: string): SessionPaths;
+export declare function readSessionState(root: string, sessionId: string): Promise<SessionState | null>;
+export declare function writeSessionState(root: string, state: SessionState): Promise<void>;
+export declare function sessionExists(root: string, sessionId: string): Promise<boolean>;
+/** Append a single severity envelope to events.jsonl. Single-writer discipline is the owner's job (M3). */
+export declare function appendEvent(root: string, sessionId: string, envelope: EventEnvelope): Promise<void>;
+/** Read events from cursor (exclusive). Tail-only: never mutates the log. */
+export declare function readEvents(root: string, sessionId: string, fromCursor?: number): Promise<EventEnvelope[]>;
+export interface ReceiptIndexEntry {
+    receiptId: string;
+    family: ReceiptFamily;
+    valid: boolean;
+    createdAt: string;
+    path: string;
+}
+/**
+ * Persist a receipt immutably. Fails closed if the receipt id already exists,
+ * then appends an index entry to receipts.jsonl.
+ */
+export declare function writeReceiptImmutable(root: string, sessionId: string, family: ReceiptFamily, receiptId: string, value: {
+    receiptId: string;
+    family: ReceiptFamily;
+    valid: boolean;
+    createdAt: string;
+}): Promise<ReceiptIndexEntry>;
+export declare function readReceiptIndex(root: string, sessionId: string, family?: ReceiptFamily): Promise<ReceiptIndexEntry[]>;

package/dist/types/harness-control-plane/types.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Core types for the gajae-code-native coding-harness operations control plane (v1).
+ *
+ * See the approved consensus plan at
+ * `.gjc/plans/ralplan/2026-06-02-0853-3e33/stage-02-revision.md` and the spec at
+ * `.gjc/specs/deep-interview-harness-control-plane.md`.
+ *
+ * v1 implements the gajae-code adapter only. omx/codex/remote/auth are deferred seams.
+ */
+/** Harnesses the control plane can operate. v1 implements `gajae-code` only. */
+export type Harness = "gajae-code" | "codex" | "omx";
+/** Lifecycle states of an operated session. */
+export type HarnessLifecycle = "new" | "started" | "submitted" | "observing" | "recovering" | "validating" | "finalizing" | "completed" | "blocked" | "retired";
+/** Event severities emitted by the owner. */
+export type Severity = "info" | "warn" | "critical";
+/** Bounded git delta classification surfaced by `observe`. */
+export type GitDelta = "clean" | "dirty" | "zero-delta" | "unknown";
+/** Risk classification surfaced by `observe`. */
+export type RiskKind = "normal" | "prompt-not-accepted" | "deleted-worktree" | "vanished-dirty";
+/** Deterministic recovery classifications. */
+export type RecoveryClassification = "continue" | "send-enter" | "reinject-prompt" | "restart-clean" | "restart-preserve-delta" | "fallback-codex-exec" | "human-check";
+/** Receipt families persisted under the session storage dir. */
+export type ReceiptFamily = "vanish" | "prompt-acceptance" | "validation" | "completion";
+/** The CLI verbs / primitives exposed by `gjc harness <verb>`. */
+export type HarnessVerb = "start" | "submit" | "observe" | "classify" | "recover" | "validate" | "finalize" | "retire" | "events" | "monitor" | "operate";
+/** Submission transports. */
+export type SubmitMode = "paste-buffer" | "stdin" | "file";
+/** A single entry in the forcing-function `nextAllowedActions` list. */
+export interface NextAllowedAction {
+    verb: HarnessVerb;
+    available: boolean;
+    /** Present when `available` is false; explains why the verb is currently disallowed. */
+    reason?: string;
+}
+/** Compact, model-facing view of session state included in every response. */
+export interface SessionStateView {
+    sessionId: string;
+    lifecycle: HarnessLifecycle;
+    harness: Harness;
+    ownerLive: boolean;
+    blockers: string[];
+}
+/**
+ * The universal contract: EVERY primitive response carries `{state, evidence, nextAllowedActions}`.
+ * `ok` is a transport-level convenience; semantic blocking is expressed via state + nextAllowedActions.
+ */
+export interface PrimitiveResponse<E = Record<string, unknown>> {
+    ok: boolean;
+    state: SessionStateView;
+    evidence: E;
+    nextAllowedActions: NextAllowedAction[];
+}
+/** Re-grabbable session handle returned by `start` / `operate`. */
+export interface SessionHandle {
+    sessionId: string;
+    harness: Harness;
+    repo: string | null;
+    workspace: string;
+    branch: string | null;
+    base: string | null;
+    issueOrPr: string | null;
+    processHandle: {
+        kind: "runtime-owner";
+        ownerId: string | null;
+        pid: number | null;
+    };
+    rpcHandle: {
+        kind: "rpc-subprocess";
+        pid: number | null;
+        sessionDir: string;
+    };
+    ownerHandle: {
+        leasePath: string;
+        endpoint: string | null;
+        heartbeatAt: string | null;
+    };
+    routerHandle: {
+        kind: "default-in-owner";
+        policy: string;
+        eventsPath: string;
+    };
+    viewportHandle: {
+        kind: "event-monitor";
+        tmuxSessionName: string | null;
+        viewOnly: true;
+    };
+    startedAt: string;
+    updatedAt: string;
+}
+/** Persisted per-session record (state.json). */
+export interface SessionState {
+    schemaVersion: number;
+    sessionId: string;
+    lifecycle: HarnessLifecycle;
+    harness: Harness;
+    handle: SessionHandle;
+    /** Per-classification retry counters consumed by the recovery policy. */
+    retries: Record<string, number>;
+    blockers: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+/** Bounded observed-signal vocabulary surfaced by `observe` (the owner only ever emits these). */
+export type ObservedSignal = "SessionStart" | "prompt-accepted" | "tool-call" | "test-running" | "commit-created" | "completed" | "error" | "streaming" | "idle";
+export declare const OBSERVED_SIGNALS: readonly ObservedSignal[];
+/** Bounded observation surfaced by `observe` — never a raw pane/transcript dump. */
+export interface Observation {
+    lifecycle: HarnessLifecycle;
+    ownerLive: boolean;
+    cwd: string;
+    branch: string | null;
+    gitDelta: GitDelta;
+    lastActivityAt: string | null;
+    observedSignals: string[];
+    risk: RiskKind;
+    /** RPC subprocess liveness, distinct from owner-process/lease liveness. Optional for back-compat. */
+    rpcLive?: boolean;
+    /** ISO timestamp of the most recent RPC frame the owner observed, if any. */
+    rpcLastFrameAt?: string | null;
+}
+/** Input to the deterministic recovery classifier. */
+export interface ClassifyInput {
+    observation: Observation;
+    /** Remaining retry budget per classification family. */
+    retryBudget: RetryBudget;
+    /** Whether an accepted prompt was in flight when the owner/RPC was last seen. */
+    acceptedPromptActive?: boolean;
+}
+/** Default and supplied retry budgets. */
+export interface RetryBudget {
+    reinjectPrompt: number;
+    zeroDeltaVanish: number;
+    dirtyVanishPreserve: number;
+    validationRepair: number;
+}
+/** Result of the deterministic recovery classifier. */
+export interface RecoveryDecision {
+    classification: RecoveryClassification;
+    reason: string;
+    severity: Severity;
+    /** Whether executing the recommended action requires a live owner. */
+    ownerRequired: boolean;
+    /** Receipt family that MUST be valid before the action may proceed (e.g. `vanish`). */
+    requiredReceiptFamily: ReceiptFamily | null;
+}
+/** Severity-tagged event envelope written exclusively by the owner. */
+export interface EventEnvelope<E = Record<string, unknown>> {
+    eventId: string;
+    cursor: number;
+    createdAt: string;
+    severity: Severity;
+    kind: string;
+    state: SessionStateView;
+    evidence: E;
+    nextAllowedActions: NextAllowedAction[];
+    writer: {
+        ownerId: string;
+        leaseEpoch: number;
+    };
+}
+export declare const SESSION_SCHEMA_VERSION: 1;
+export declare const DEFAULT_RETRY_BUDGET: RetryBudget;

package/dist/types/hooks/skill-keywords.d.ts

@@ -1,3 +1,4 @@
+import { type CanonicalGjcWorkflowSkill } from "../skill-state/active-state";
 export interface SkillKeywordDefinition {
     keyword: string;
     skill: GjcWorkflowSkill;
@@ -5,7 +6,7 @@ export interface SkillKeywordDefinition {
     guidance: string;
 }
 export declare const GJC_WORKFLOW_SKILLS: readonly ["deep-interview", "ralplan", "ultragoal", "team"];
-export type GjcWorkflowSkill = (typeof GJC_WORKFLOW_SKILLS)[number];
+export type GjcWorkflowSkill = CanonicalGjcWorkflowSkill;
 export declare const GJC_SKILL_KEYWORD_DEFINITIONS: readonly SkillKeywordDefinition[];
 export declare function isGjcWorkflowSkill(value: string): value is GjcWorkflowSkill;
 export declare function compareSkillKeywordMatches(a: {

package/dist/types/hooks/skill-state.d.ts

@@ -1,5 +1,5 @@
 import type { SkillDiscoverySettings } from "../config/skill-settings-defaults";
-import type { SkillActiveEntry as CanonicalSkillActiveEntry, WorkflowHudSummary } from "../skill-state/active-state";
+import { type SkillActiveState } from "../skill-state/active-state";
 import { type GjcWorkflowSkill } from "./skill-keywords";
 export declare const GJC_STATE_DIR = ".gjc/state";
 export declare const SKILL_ACTIVE_STATE_FILE = "skill-active-state.json";
@@ -14,34 +14,7 @@ export interface SkillKeywordMatch {
     skill: GjcWorkflowSkill;
     priority: number;
 }
-export interface SkillActiveEntry extends Omit<CanonicalSkillActiveEntry, "skill"> {
-    skill: GjcWorkflowSkill;
-    phase?: string;
-    active?: boolean;
-    activated_at?: string;
-    updated_at?: string;
-    session_id?: string;
-    thread_id?: string;
-    turn_id?: string;
-    hud?: WorkflowHudSummary;
-    stale?: boolean;
-}
-export interface SkillActiveState {
-    version: number;
-    active: boolean;
-    skill: GjcWorkflowSkill;
-    keyword: string;
-    phase: string;
-    activated_at: string;
-    updated_at: string;
-    source: "gjc-skill-state-hook";
-    session_id?: string;
-    thread_id?: string;
-    turn_id?: string;
-    initialized_mode?: GjcWorkflowSkill;
-    initialized_state_path?: string;
-    active_skills: SkillActiveEntry[];
-}
+export type { SkillActiveEntry, SkillActiveState } from "../skill-state/active-state";
 export interface ModeState {
     active?: boolean;
     current_phase?: string;

package/dist/types/modes/acp/acp-client-bridge.d.ts

@@ -1,6 +1,6 @@
 /**
  * ACP-side `ClientBridge` implementation. Wraps `AgentSideConnection` so the
- * `read`/`write`/`bash`/`edit` tools (and the permission gate in
+ * `read`/`write`/`bash`/`monitor`/`edit` tools (and the permission gate in
  * `AgentSession`) can route through the client when it advertises the
  * relevant capabilities at `initialize` time.
  */

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

@@ -21,6 +21,7 @@ export interface HookSelectorOptions {
      * byte-identical to the previous implementation for all consumers.
      */
     wrapFocused?: boolean;
+    scrollTitleRows?: number;
 }
 export declare class HookSelectorComponent extends Container {
     #private;

package/dist/types/modes/components/skill-hud/render.d.ts

@@ -1,2 +1,2 @@
-import type { SkillActiveEntry } from "../../../skill-state/active-state";
+import { type SkillActiveEntry } from "../../../skill-state/active-state";
 export declare function renderSkillHudBar(entries: readonly SkillActiveEntry[], width: number): string | null;

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

@@ -61,6 +61,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     isInitialized: boolean;
     isBackgrounded: boolean;
     isBashMode: boolean;
+    isBashNoContext: boolean;
     toolOutputExpanded: boolean;
     todoExpanded: boolean;
     planModeEnabled: boolean;
@@ -85,6 +86,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     retryLoader: Loader | undefined;
     autoCompactionEscapeHandler?: () => void;
     retryEscapeHandler?: () => void;
+    retryCountdownTimer?: ReturnType<typeof setInterval>;
     unsubscribe?: () => void;
     onInputCallback?: (input: SubmittedUserInput) => void;
     optimisticUserMessageSignature: string | undefined;