@adhdev/daemon-core 0.9.82-rc.21 → 0.9.82-rc.211

package/dist/providers/sdk/v1/types/common/index.d.ts

@@ -0,0 +1,203 @@
+/**
+ * Shared types across provider categories.
+ *
+ * Extracted at build time into the Apache 2.0 npm package
+ * `@adhdev/provider-types`. External provider authors import from there;
+ * daemon-core imports from this file directly.
+ */
+export interface BooleanSettingDef {
+    type: 'boolean';
+    default: boolean;
+    public?: boolean;
+    label?: string;
+    description?: string;
+}
+export interface NumberSettingDef {
+    type: 'number';
+    default: number;
+    public?: boolean;
+    label?: string;
+    description?: string;
+    min?: number;
+    max?: number;
+}
+export interface StringSettingDef {
+    type: 'string';
+    default: string;
+    public?: boolean;
+    label?: string;
+    description?: string;
+}
+export interface SelectSettingDef {
+    type: 'select';
+    default: string;
+    options: ReadonlyArray<string | {
+        value: string;
+        label?: string;
+    }>;
+    public?: boolean;
+    label?: string;
+    description?: string;
+}
+export type SettingDef = BooleanSettingDef | NumberSettingDef | StringSettingDef | SelectSettingDef;
+export type SettingsDef = Readonly<Record<string, SettingDef>>;
+export interface CapabilityInputDef {
+    multipart?: boolean;
+    mediaTypes?: ReadonlyArray<'text' | 'image' | 'audio' | string>;
+    strategies?: ReadonlyArray<{
+        mediaType: string;
+        strategies: ReadonlyArray<string>;
+        native?: boolean;
+        degradation?: ReadonlyArray<string>;
+    }>;
+}
+export interface CapabilityOutputDef {
+    richContent?: boolean;
+    mediaTypes?: ReadonlyArray<string>;
+}
+export interface CapabilityControlsDef {
+    typedResults?: boolean;
+}
+export interface CapabilitiesDef {
+    input?: CapabilityInputDef;
+    output?: CapabilityOutputDef;
+    controls?: CapabilityControlsDef;
+}
+export interface EnvVarAuthDef {
+    type: 'env_var';
+    id: string;
+    name: string;
+    vars: ReadonlyArray<{
+        name: string;
+        description?: string;
+    }>;
+    link?: string;
+}
+export interface CliCommandAuthDef {
+    type: 'cli_command';
+    id: string;
+    name: string;
+    command: string;
+    link?: string;
+}
+export type AuthDef = EnvVarAuthDef | CliCommandAuthDef;
+export interface SpawnDef {
+    command: string;
+    args?: ReadonlyArray<string>;
+    shell?: boolean;
+    env?: Readonly<Record<string, string>>;
+}
+export interface TimeoutsDef {
+    /** Gap between writes before considering a chunk settled (ms). */
+    ptyFlush?: number;
+    /** Delay before sending an approval key (ms). */
+    dialogAccept?: number;
+    /** Window during which a freshly resolved modal is suppressed (ms). */
+    approvalCooldown?: number;
+    /** Fallback "still generating" assumption window (ms). */
+    generatingIdle?: number;
+    /** Grace before declaring generating→idle final (ms). */
+    idleFinish?: number;
+    /** Second-pass confirmation window (ms). */
+    idleFinishConfirm?: number;
+    /** PTY-quiet threshold before marking activity ended (ms). */
+    statusActivityHold?: number;
+    /** Hard upper bound on a single generation (ms). */
+    maxResponse?: number;
+    /** SIGTERM→SIGKILL window (ms). */
+    shutdownGrace?: number;
+    /** Post-write debounce (ms). */
+    outputSettle?: number;
+}
+export type StopStrategy = 'command' | 'ctrl_c' | 'signal';
+export type SessionIdFormat = 'uuid' | 'free' | 'string';
+export interface ResumeDef {
+    supported: boolean;
+    stopStrategy?: StopStrategy;
+    stopCommand?: string;
+    shutdownGraceMs?: number;
+    sessionIdFormat?: SessionIdFormat;
+    /** Args appended to spawn.args when starting a session under a daemon-issued id. `{{id}}` is replaced at launch. */
+    newSessionArgs?: ReadonlyArray<string>;
+    /** Args appended when resuming a specific session id. */
+    resumeSessionArgs?: ReadonlyArray<string>;
+    /** Args appended when "continue most recent" semantics are wanted. */
+    resumeArgs?: ReadonlyArray<string>;
+}
+export interface McpConfigDef {
+    mode: 'manual' | 'auto_import';
+    format?: string;
+    path?: string;
+    configPathCommand?: string;
+    serverName?: string;
+    requiresRestart?: boolean;
+    instructions?: string;
+    /** Template string used by daemon to render the actual config snippet at install time. */
+    template?: string;
+}
+export interface MeshCoordinatorDef {
+    supported: boolean;
+    mcpConfig?: McpConfigDef;
+    systemPromptInjection?: MeshCoordinatorSystemPromptInjectionDef;
+    delegatedWorkerIsolation?: MeshCoordinatorDelegatedWorkerIsolationDef;
+}
+export type MeshCoordinatorSystemPromptInjectionDef = {
+    mode: 'cli_arg';
+    flag: string;
+} | {
+    mode: 'config_override';
+    flag: string;
+    template: string;
+} | {
+    mode: 'context_file';
+    path: string;
+    wrapper?: string;
+} | {
+    mode: 'env_var';
+    name: string;
+};
+export interface MeshCoordinatorDelegatedWorkerIsolationDef {
+    env?: {
+        unset?: ReadonlyArray<string>;
+    };
+    args?: ReadonlyArray<MeshCoordinatorDelegatedWorkerArgRuleDef>;
+}
+export type MeshCoordinatorDelegatedWorkerArgRuleDef = {
+    mode: 'empty_mcp_config';
+    flag: string;
+    strictFlag?: string;
+} | {
+    mode: 'config_override';
+    flag: string;
+    key: string;
+    value: string;
+    dedupeKey?: string;
+};
+export interface CompatibilityEntryDef {
+    /** SemVer range against the agent's own version. Optional. */
+    ideVersion?: string;
+    /** Script subdirectory to load when this entry matches. e.g. "scripts/1.0". */
+    scriptDir: string;
+}
+export type ControlType = 'select' | 'action' | 'toggle';
+export interface ControlDef {
+    id: string;
+    type: ControlType;
+    label: string;
+    icon?: string;
+    placement?: string;
+    order?: number;
+    dynamic?: boolean;
+    hidden?: boolean;
+    options?: ReadonlyArray<unknown>;
+    listScript?: string;
+    setScript?: string;
+    invokeScript?: string;
+    readFrom?: string;
+    resultDisplay?: string;
+    defaultValue?: unknown;
+    confirmTitle?: string;
+    confirmMessage?: string;
+    confirmLabel?: string;
+}
+export type ProviderLifecycleStatus = 'Stable' | 'Beta' | 'Experimental' | 'Deprecated';

package/dist/providers/sdk/v1/validators/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Validators — public surface.
+ */
+export { analyzeOverrideTaint, formatTaintResult, type TaintLevel, type TaintCategory, type TaintFinding, type TaintResult, } from './taint.js';
+export { validateCliProviderManifest, formatManifestValidationIssues, type ManifestValidationIssue, type ManifestValidationResult, } from './manifest.js';

package/dist/providers/sdk/v1/validators/manifest.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Manifest validators — runtime JSON Schema check for v1 provider manifests.
+ *
+ * The schemas live under `schemas/{category}/provider.schema.json` and are
+ * the authoritative contract for what a v1 manifest may contain. Daemon
+ * code that loads a manifest at install or boot time runs it through
+ * `validateCliProviderManifest()` first; failures are reported back to
+ * the caller with structured paths so manifest authors can locate the
+ * offending field without guessing.
+ *
+ * Validation lives in the SDK layer (not in provider-loader) so dashboards,
+ * registry workers, and the provider publish flow can all reuse the
+ * same code path and produce identical error messages.
+ */
+export interface ManifestValidationIssue {
+    /** JSON Pointer-style path into the manifest. Empty string for the root. */
+    path: string;
+    /** Schema-keyword that failed. */
+    keyword: string;
+    /** Human-readable explanation. */
+    message: string;
+    /** Allowed values when the failure is an `enum` / `const` / `additionalProperties`. */
+    allowed?: unknown;
+}
+export interface ManifestValidationResult {
+    ok: boolean;
+    issues: ManifestValidationIssue[];
+}
+/**
+ * Validate a CLI provider.v1.json manifest. Returns `{ ok: true, issues: [] }`
+ * on success and `{ ok: false, issues: [...] }` on failure with each issue
+ * pointing at the offending field. Never throws — manifest parse errors
+ * should be caught by the caller before this is called.
+ */
+export declare function validateCliProviderManifest(manifest: unknown): ManifestValidationResult;
+/**
+ * Render a list of validation issues as a single multi-line string,
+ * suitable for log lines or daemon command error fields.
+ */
+export declare function formatManifestValidationIssues(issues: ManifestValidationIssue[]): string;

package/dist/providers/sdk/v1/validators/taint.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Static taint analyzer for extended-tier override JS.
+ *
+ * Goal: classify the override JS shipped with an extended-tier provider into
+ * one of three risk tiers, so the dashboard + daemon trust prompt can
+ * surface accurate language to the operator instead of a single generic
+ * "this provider contains JS" warning.
+ *
+ *   - clean    : no flagged APIs at all. The override looks like pure string
+ *                manipulation. Still extended-tier, but the warning copy is
+ *                "this provider contains JS; nothing dangerous was detected".
+ *   - elevated : touches process / dynamic codegen / dynamic require / eval
+ *                / Function constructor / child_process. The warning copy is
+ *                explicit ("this provider can run shell commands / dynamically
+ *                load code").
+ *   - hostile  : combines elevated APIs with network egress, AND uses obvious
+ *                obfuscation (base64-decoded strings fed into Function / eval).
+ *                The publish endpoint should reject these.
+ *
+ * Implementation note: this is a *static* analyzer — string + light AST scan
+ * via Node's built-in parser. It is intentionally fail-loud: anything that
+ * looks suspicious is flagged. False positives are fine; this exists to gate
+ * the trust prompt, not to be a real sandbox. The real sandbox lives in
+ * Phase 5 (isolated-vm).
+ *
+ * Used by:
+ *   - `adhdev provider validate` (CLI tier classification)
+ *   - registry publish endpoint static-check
+ *   - daemon at provider-load time, to size the warning
+ */
+export type TaintLevel = 'clean' | 'elevated' | 'hostile';
+export interface TaintFinding {
+    /** What was found, e.g. "child_process.exec". */
+    api: string;
+    /** Coarse category. */
+    category: TaintCategory;
+    /** File the finding came from. */
+    file: string;
+    /** Line number (1-indexed) of the first character of the matched token. */
+    line: number;
+    /** The surrounding source excerpt, trimmed. */
+    excerpt: string;
+}
+export type TaintCategory = 'process-control' | 'shell-exec' | 'fs-write' | 'fs-read' | 'network' | 'dynamic-codegen' | 'dynamic-require' | 'obfuscation' | 'global-mutation';
+export interface TaintResult {
+    level: TaintLevel;
+    findings: TaintFinding[];
+    files: string[];
+}
+export declare function analyzeOverrideTaint(manifestPath: string): TaintResult;
+/** Format a result as a single CLI-friendly block. */
+export declare function formatTaintResult(result: TaintResult): string;

package/dist/providers/spec/adapter.d.ts

@@ -0,0 +1,52 @@
+import type { PtyTransportFactory } from '../../cli-adapters/pty-transport.js';
+export type { PtyTransportFactory };
+export interface TerminalAdapterOpts {
+    binary: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    cols?: number;
+    rows?: number;
+    /** Coalesce screen snapshots: emit on_screen_changed at most this often. */
+    screenChangeDebounceMs?: number;
+    tickIntervalMs?: number;
+    transportFactory?: PtyTransportFactory;
+}
+export interface TerminalAdapterHandlers {
+    init?(info: {
+        pid: number;
+    }): void;
+    on_pty_data?(chunk: string): void;
+    on_screen_changed?(snapshot: string): void;
+    on_exit?(info: {
+        exitCode: number;
+    }): void;
+    tick?(): void;
+}
+export declare class TerminalAdapter {
+    private readonly opts;
+    private readonly handlers;
+    private rows;
+    private cols;
+    private readonly screenDebounceMs;
+    private readonly tickIntervalMs;
+    private readonly factory;
+    private screen;
+    private pty;
+    private screenTimer;
+    private tickTimer;
+    private lastScreen;
+    constructor(opts: TerminalAdapterOpts, handlers: TerminalAdapterHandlers);
+    start(): void;
+    resize(cols: number, rows: number): void;
+    snapshot(): string;
+    getCursorPosition(): {
+        row: number;
+        col: number;
+    };
+    send_keys(text: string): void;
+    kill(): void;
+    private onChunk;
+    private computeScreen;
+    private stopTimers;
+}

package/dist/providers/spec/cli-adapter.d.ts

@@ -0,0 +1,101 @@
+import type { CliAdapter, CliAdapterStatus } from '../../cli-adapter-types.js';
+import type { PtyTransportFactory } from '../../cli-adapters/pty-transport.js';
+import { type InteractivePromptResponse } from '../types/interactive-prompt.js';
+export declare class SpecCliAdapter implements CliAdapter {
+    readonly cliType: string;
+    readonly cliName: string;
+    readonly workingDir: string;
+    /**
+     * Marker the daemon's finalization gate checks: `getStatus()` returns
+     * `messages: []` by design here (chat history lives in the daemon's
+     * native-history pipeline, not the adapter). Without this flag,
+     * cli-provider-instance's `missing_final_assistant` gate would stall
+     * every turn until the 30s safety timeout because it expects the
+     * adapter to surface the final assistant message.
+     */
+    readonly chatMessagesOwnedExternally: true;
+    private driver;
+    private spec;
+    private lastEvent;
+    private latestState;
+    private latestModal;
+    private statusCallback;
+    private ptyDataCallback;
+    private partialResponse;
+    private activeInteractivePrompt;
+    private interactivePromptTransport;
+    private claudeTuiPromptCaptureInFlight;
+    private jsonLineTail;
+    private exited;
+    private spawned;
+    private providerSessionId;
+    /** Wall clock at the moment spawn() ran. Used as the cutoff for
+     *  native-history file selection so a prior session's transcript
+     *  can't leak into this session before the agent has written its
+     *  own records. */
+    private spawnedAtMs;
+    /** Env vars the daemon set on the spawned child. Mesh coordinator
+     *  points hermes at a per-coordinator HERMES_HOME so the dashboard's
+     *  native-history reader needs that override to find the right
+     *  state.db; without it the reader sees ~/.hermes/state.db which
+     *  the coordinator-launched hermes never writes to. The choice to
+     *  redirect HERMES_HOME is a workaround for an unresolved hermes
+     *  upstream feature gap (see hermes-agent#23130 — runtime-supplied
+     *  MCP config), so this routing keeps the dashboard honest until
+     *  hermes ships a runtime MCP override. */
+    private spawnedEnv;
+    constructor(specPath: string, workingDir: string, cliArgs: string[], extraEnv: Record<string, string>, transportFactory?: PtyTransportFactory);
+    spawn(): Promise<void>;
+    sendMessage(text: string): Promise<void>;
+    getStatus(): CliAdapterStatus;
+    private maybeRefreshNativeHistory;
+    getScriptParsedStatus(): unknown;
+    getPartialResponse(): string;
+    shutdown(): void;
+    cancel(): void;
+    isProcessing(): boolean;
+    isReady(): boolean;
+    setOnStatusChange(cb: () => void): void;
+    setOnPtyData(cb: (data: string) => void): void;
+    writeRaw(data: string): void;
+    resize(cols: number, rows: number): void;
+    resolveModal(buttonIndex: number): void;
+    resolveAction(data: unknown): Promise<void>;
+    setInteractivePromptResponse(response: InteractivePromptResponse): Promise<void>;
+    isApprovalRecentlyResolved(): boolean;
+    clearHistory(): void;
+    updateRuntimeSettings(): void;
+    setServerConn(): void;
+    /**
+     * Map an invokeScript(name, args) call onto a control_bar entry.
+     *
+     * scriptName is matched against control.id. The control's action.type
+     * drives the dispatch:
+     *
+     *   send_keys     → click_control                   (e.g. stop)
+     *   open_picker   → click_control then resolve when extract_choices
+     *                   surface; choice index comes from args.choiceIndex
+     *                   or args.choice (string label match), defaulting to 0
+     *   attach_image  → attach_image dispatch; expects args.blob (data url
+     *                   or base64) and args.mime
+     *
+     * Callers that pass an unknown control id get a { not_found } response.
+     * No control matched, no driver call — keeps the surface honest.
+     */
+    invokeScript(scriptName: string, args?: Record<string, unknown>): Promise<unknown>;
+    getDebugSnapshot(): unknown;
+    getRuntimeMetadata(): unknown;
+    updateRuntimeMeta(meta?: Record<string, unknown>): void;
+    refreshProviderDefinition(): void;
+    private handleEvent;
+    private detectInteractivePromptFromPtyChunk;
+    private readCurrentScreenSections;
+    private extractProviderSessionIdFromScreen;
+    private readClaudeScreenAssistantMessages;
+    private maybeCaptureClaudeTuiPrompt;
+    private readClaudeTuiHeaders;
+    private captureClaudeTuiPrompt;
+    getDebugState(): Record<string, any>;
+    getTraceState(limit?: number): Record<string, any>;
+    getProviderResolutionMeta(): Record<string, any>;
+}

package/dist/providers/spec/driver.d.ts

@@ -0,0 +1,225 @@
+import type { PtyTransportFactory } from '../../cli-adapters/pty-transport.js';
+import { type SpecEvaluation, type TraceEntry } from './evaluator.js';
+import type { CliSpec } from './types.js';
+export type DashboardEvent = {
+    kind: 'pty_data';
+    chunk: string;
+} | {
+    kind: 'state_changed';
+    state: {
+        id: string;
+        label: string;
+        title: string | null;
+    };
+    modal: {
+        title: string | null;
+        buttons: {
+            index: number;
+            label: string;
+        }[];
+    } | null;
+    controls: {
+        id: string;
+        label: string;
+        action_type: string;
+    }[];
+} | {
+    kind: 'notification';
+    id: string;
+    title: string;
+    body: string;
+} | {
+    kind: 'delegate';
+    id: string;
+    task: string;
+} | {
+    kind: 'spec_trace';
+    entries: TraceEntry[];
+} | {
+    kind: 'exit';
+    exit_code: number;
+} | {
+    kind: 'spec_error';
+    errors: string[];
+};
+export type DashboardCommand = {
+    kind: 'send_message';
+    text: string;
+} | {
+    kind: 'pty_write';
+    data: string;
+} | {
+    kind: 'click_control';
+    control_id: string;
+    payload?: unknown;
+} | {
+    kind: 'click_modal_button';
+    index: number;
+} | {
+    kind: 'attach_image';
+    blob: string;
+    mime: string;
+} | {
+    kind: 'resize';
+    cols: number;
+    rows: number;
+} | {
+    kind: 'cancel';
+} | {
+    kind: 'shutdown';
+};
+export interface SpecDriverOpts {
+    specPath: string;
+    workingDir: string;
+    extraEnv?: Record<string, string>;
+    cols?: number;
+    rows?: number;
+    /** Set false to skip the spec.json fs.watch. */
+    hotReload?: boolean;
+    /** Set true to forward trace entries on every state_changed. */
+    emitTrace?: boolean;
+    /** Inject the daemon's PTY transport (typically SessionHostPtyTransportFactory). */
+    transportFactory?: PtyTransportFactory;
+    /**
+     * Extra CLI args appended to spec.spawn_args. Used by the daemon to
+     * pass per-launch arguments like `--session-id <uuid>` so the agent
+     * uses the daemon's providerSessionId instead of generating its own.
+     */
+    extraCliArgs?: string[];
+}
+/**
+ * Pick the effective delay (ms) to wait between writing the prompt body and
+ * writing the submit_key. Exported for tests; production callers go through
+ * actuallySendMessage. Floors to SUBMIT_DELAY_FLOOR_MS so specs that omit
+ * delay_ms_before_submit (e.g. claude, antigravity) still get baseline
+ * protection against the paste→submit race. Adds line-count bonus so
+ * multi-line prompts get more settling time on TUIs that re-render per
+ * embedded `\n`.
+ */
+export declare function resolveSubmitDelayMs(specBeforeSubmit: number | undefined, text: string): number;
+export declare function matchesCompletionIdleRule(spec: CliSpec, ev: SpecEvaluation, screen: string): string | null;
+export declare function matchesCompletionIdleTargetState(spec: CliSpec, ev: SpecEvaluation, screen: string, cursor?: {
+    row: number;
+    col: number;
+}): boolean;
+export declare class SpecDriver {
+    private readonly opts;
+    private spec;
+    private adapter;
+    private listeners;
+    private currentStateId;
+    /** Have we ever seen the spec's idle state *after* the startup grace
+     *  window? Until we do, the agent's startup banner may still be
+     *  painting and any send_message we forward to the PTY will be wiped
+     *  when the banner clears the screen. Queue + drain on first valid
+     *  idle. */
+    private idleSeenOnce;
+    private startedAtMs;
+    private pendingSends;
+    private currentEval;
+    private pickerInProgress;
+    private delegateTimers;
+    /** Timestamp of the last time the evaluator returned busy. Used to debounce
+     *  the busy → idle transition (see reevaluate). */
+    private lastBusyAt;
+    /** The exact busy state object we last saw — held alongside lastBusyAt so
+     *  the hold can re-emit the same { id: 'busy', label, title } payload the
+     *  dashboard already learned about. currentEval can't fill this role
+     *  because the evaluator already moved past busy by the time the hold
+     *  kicks in. */
+    private lastBusyState;
+    /** Timestamp of the last time we entered a modal state (approval/picker or
+     *  any non-busy non-idle state). Used to suppress brief busy blips that
+     *  appear while the modal is still on screen — Claude Code streams body
+     *  text that transiently shows a spinner even while an approval modal is
+     *  visible, causing rapid approval→busy→approval flicker on the dashboard. */
+    private lastModalAt;
+    /** The modal state snapshot held across busy blips. */
+    private lastModalState;
+    /** Timestamp of when we last *exited* a modal state (approval/picker → idle
+     *  or directly via completion_idle_after).  Used to suppress completion_idle_after
+     *  firings that were queued before the modal appeared and expire immediately
+     *  after the modal is dismissed — without this the agent appears idle even
+     *  though it is still generating. */
+    private lastModalExitAt;
+    private completionIdleFirstSeenAt;
+    private completionIdleKey;
+    /** Previous screen lines — passed to evaluate() for `changed` condition detection. */
+    private prevScreenLines;
+    /** Timer that re-runs evaluate() once the hold window expires. Needed
+     *  because the PTY stops emitting once the agent finishes; without an
+     *  explicit wake-up there's nothing to trigger the busy → idle
+     *  downshift. */
+    private busyExpiryTimer;
+    /** Set true while reevaluate() is invoked from busyExpiryTimer callback. */
+    private busyExpiryFired;
+    /** Pending idle-commit timer. Armed when the evaluator first returns idle;
+     *  fires after idle_hold_ms if no non-idle reading has cancelled it. */
+    private idleHoldTimer;
+    /** State snapshot captured when the idle hold was armed — emitted on commit. */
+    private pendingIdleState;
+    private specWatcher;
+    /** Ring buffer of committed state transitions (max 50). */
+    private stateHistory;
+    private prevStateAt;
+    constructor(opts: SpecDriverOpts);
+    /** Subscribe to outbound events. Returns an unsubscribe fn. */
+    subscribe(listener: (ev: DashboardEvent) => void): () => void;
+    start(): void;
+    dispatch(cmd: DashboardCommand): void;
+    snapshot(): string;
+    getCursorPosition(): {
+        row: number;
+        col: number;
+    };
+    shutdown(): void;
+    private cancelIdleHold;
+    private pushHistory;
+    getStateHistory(): ReadonlyArray<{
+        stateId: string;
+        label: string;
+        at: number;
+        durationMs: number;
+        reason: string;
+        matchedStateId?: string;
+        matchedRules?: string[];
+        debounceKind?: string;
+        idleHoldMs?: number;
+        busyHoldMs?: number;
+    }>;
+    getLastBusyAt(): number;
+    hasIdleHoldPending(): boolean;
+    getSpecPath(): string;
+    getCompletionIdleDebounceState(): {
+        active: boolean;
+        ageMs: number;
+        holdMs: number;
+        forceAfterMs: number;
+    } | null;
+    getScreen(): string;
+    getSections(): Array<{
+        id: string;
+        text: string;
+    }> | null;
+    private loadSpecOrThrow;
+    private buildAdapterOpts;
+    private armSpecWatcher;
+    private emitInitialState;
+    /** Re-arm the timer that wakes the driver up after BUSY_HOLD_MS so it
+     *  can decide whether to downshift to idle. Always uses the most recent
+     *  hold value so a spec hot-reload that shortens the hold takes effect
+     *  on the next busy entry. Safe to call repeatedly; only the last call
+     *  fires. */
+    private scheduleBusyExpiry;
+    private reevaluate;
+    private armOrCancelDelegateTimers;
+    private fireDelegate;
+    private handleSendMessage;
+    private actuallySendMessage;
+    private handleClickControl;
+    private handleClickModalButton;
+    private handleAttachImage;
+    private tryAdvancePicker;
+    private handleExit;
+    private emit;
+}