@adhdev/daemon-core 0.9.82-rc.41 → 0.9.82-rc.410

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

@@ -0,0 +1,277 @@
+/**
+ * CLI provider types — v1.
+ *
+ * Mirrors the contract documented in
+ * adhdev-providers/docs/provider-contract/cli/v1.md.
+ *
+ * Extracted at build time into the Apache 2.0 npm package
+ * `@adhdev/provider-types`.
+ */
+import type { SettingsDef, CapabilitiesDef, SpawnDef, TimeoutsDef, ResumeDef, MeshCoordinatorDef, CompatibilityEntryDef, ControlDef, ProviderLifecycleStatus } from '../common/index.js';
+export interface CliScreenLine {
+    text: string;
+    /** Number of visible columns the line occupies. */
+    width: number;
+}
+export interface CliScreenSnapshot {
+    text: string;
+    lineCount: number;
+    lines: CliScreenLine[];
+    nonEmptyLines: CliScreenLine[];
+    firstNonEmptyLineIndex: number;
+    lastNonEmptyLineIndex: number;
+    firstNonEmptyLine: CliScreenLine | null;
+    lastNonEmptyLine: CliScreenLine | null;
+    promptLineIndex: number;
+    promptLine: CliScreenLine | null;
+    linesAbovePrompt: CliScreenLine[];
+    linesBelowPrompt: CliScreenLine[];
+}
+export type CliChatRole = 'user' | 'assistant' | 'system' | 'tool';
+export type CliChatKind = 'standard' | 'tool' | 'thinking' | 'system';
+export type CliBubbleState = 'visible' | 'collapsed' | 'hidden';
+export interface CliChatMessage {
+    role: CliChatRole;
+    /** Plain string is the common case; rich content (arrays / objects) is permitted but parsing differs by category. */
+    content: string | unknown;
+    timestamp?: number;
+    receivedAt?: number;
+    kind?: CliChatKind | string;
+    /** Stable id from the agent's native history when available. */
+    id?: string;
+    /** Display index, can drift. Prefer `providerUnitKey` for stable identity. */
+    index?: number;
+    /**
+     * Stable per-message identity used by ChatSourceMachine to compare native
+     * vs PTY transcripts. When the provider supports native history, this
+     * should be derivable from the on-disk session-id + turn-number.
+     */
+    providerUnitKey?: string;
+    bubbleId?: string;
+    bubbleState?: CliBubbleState;
+    senderName?: string;
+    meta?: Record<string, unknown>;
+    /** Provider-specific extensions are permitted; daemon ignores unknown keys. */
+    [extra: string]: unknown;
+}
+export interface CliApprovalModal {
+    message: string;
+    /** Raw button labels as the user sees them. Do not rewrite. */
+    buttons: string[];
+}
+/**
+ * Provided to `parseSession` and `parseOutput`. The richest input shape.
+ */
+export interface CliScriptInput {
+    /** Accumulated PTY output, ANSI cleaned. */
+    buffer: string;
+    /** Raw PTY bytes including ANSI sequences. */
+    rawBuffer: string;
+    /** Last ~1000 chars of buffer. */
+    recentBuffer: string;
+    /** The terminal screen as rendered by ghostty/xterm. */
+    screenText: string;
+    workspace?: string;
+    /** Same as workspace; legacy alias. */
+    workingDir?: string;
+    /** Last known provider session id. May be empty. */
+    providerSessionId?: string;
+    /** Alias used for some native-history flows. */
+    historySessionId?: string;
+    screen: CliScreenSnapshot;
+    bufferScreen: CliScreenSnapshot;
+    recentScreen: CliScreenSnapshot;
+    /** Accumulated from previous parse calls. */
+    messages: CliChatMessage[];
+    /** Current in-flight assistant text. */
+    partialResponse: string;
+    isWaitingForResponse?: boolean;
+    /** The user's prompt for the active turn. */
+    promptText?: string;
+    /** Provider settings from ~/.adhdev/config.json. */
+    settings?: Record<string, unknown>;
+    /** Command-specific args (e.g. handler invocation parameters). */
+    args?: Record<string, unknown>;
+    /** ms timestamp of process spawn. Useful for native rollover guards. */
+    spawnAt?: number;
+}
+/**
+ * Provided to `detectStatus`. Trimmed for hot-path performance.
+ */
+export interface CliStatusInput {
+    tail: string;
+    screenText?: string;
+    rawBuffer?: string;
+    isWaitingForResponse?: boolean;
+    screen: CliScreenSnapshot;
+    tailScreen: CliScreenSnapshot;
+}
+/**
+ * Provided to `parseApproval`.
+ */
+export interface CliApprovalInput {
+    buffer: string;
+    screenText?: string;
+    rawBuffer?: string;
+    tail: string;
+    screen: CliScreenSnapshot;
+    bufferScreen: CliScreenSnapshot;
+    tailScreen: CliScreenSnapshot;
+}
+export type CliStatus = 'idle' | 'generating' | 'waiting_approval' | 'starting' | 'error';
+export type CliTranscriptAuthority = 'provider' | 'daemon';
+export type CliTranscriptCoverage = 'full' | 'tail' | 'current-turn';
+export interface CliParsedSession {
+    status: CliStatus;
+    messages: CliChatMessage[];
+    modal: CliApprovalModal | null;
+    parsedStatus?: string | null;
+    errorMessage?: string;
+    errorReason?: string;
+    providerSessionId?: string;
+    transcriptAuthority?: CliTranscriptAuthority;
+    coverage?: CliTranscriptCoverage;
+}
+export interface CliReadChatPayload {
+    id: 'cli_session' | string;
+    status: CliStatus;
+    title: string;
+    messages: CliChatMessage[];
+    activeModal: CliApprovalModal | null;
+    providerSessionId?: string;
+    transcriptAuthority?: CliTranscriptAuthority;
+    coverage?: CliTranscriptCoverage;
+    controlValues?: Record<string, unknown>;
+}
+export type CliCreateStateFn<S = Record<string, unknown>> = () => S;
+export type CliParseSessionFn<S = unknown> = (state: S | undefined, input: CliScriptInput) => CliParsedSession;
+export type CliDetectStatusFn = (input: CliStatusInput) => CliStatus | null;
+export type CliParseApprovalFn = (input: CliApprovalInput) => CliApprovalModal | null;
+export type CliParseOutputFn<S = unknown> = (state: S | undefined, input: CliScriptInput) => CliReadChatPayload;
+export interface CliCapabilityHandlerResult {
+    ok?: boolean;
+    writeRaw?: string;
+    sendMessage?: string;
+    result?: unknown;
+}
+export type CliCapabilityHandlerFn<S = unknown> = (state: S | undefined, input: CliScriptInput) => CliCapabilityHandlerResult;
+export interface CliNativeHistoryReadInput {
+    historySessionId?: string;
+    workspace?: string;
+    /** ms timestamp of provider spawn. Use to reject pre-spawn rollovers. */
+    spawnAt?: number;
+}
+export interface CliNativeHistoryMessage {
+    role: CliChatRole;
+    content: unknown;
+    kind?: CliChatKind | string;
+    providerUnitKey?: string;
+    receivedAt?: number;
+    workspace?: string;
+    historySessionId?: string;
+}
+export interface CliNativeHistoryReadResult {
+    source: 'provider-native';
+    providerSessionId: string;
+    messages: CliNativeHistoryMessage[];
+    sourcePath: string;
+    sourceMtimeMs: number;
+    nativeHistoryCoverage: CliTranscriptCoverage;
+    workspace?: string;
+    unavailableReason?: string;
+}
+export type CliReadNativeHistoryFn = (input: CliNativeHistoryReadInput) => CliNativeHistoryReadResult | null;
+export interface CliListNativeHistoryEntry {
+    providerSessionId: string;
+    title?: string;
+    workspace?: string;
+    receivedAt?: number;
+    messageCount?: number;
+}
+export type CliListNativeHistoryFn = () => {
+    sessions: CliListNativeHistoryEntry[];
+};
+export interface CliNativeHistoryDef {
+    /** Built-in adapter $schema (e.g. "adhdev:native-history/claude-jsonl@1"). */
+    $schema?: string;
+    format: string;
+    watchPath: string;
+    mode: 'native-source' | 'daemon-mirror';
+    contractVersion?: string;
+    scripts?: {
+        readSession?: string;
+        listSessions?: string;
+    };
+}
+/**
+ * @deprecated Use {@link CliNativeHistoryDef}. Retained as an alias for one
+ * release so SDK consumers that referenced the v0 name keep compiling.
+ */
+export type CliCanonicalHistoryDef = CliNativeHistoryDef;
+export interface CliPatternEntry {
+    source: string;
+    flags?: string;
+}
+export interface CliPatternsDef {
+    prompt?: CliPatternEntry[];
+    generating?: CliPatternEntry[];
+    approval?: CliPatternEntry[];
+    ready?: CliPatternEntry[];
+    dialog?: CliPatternEntry[];
+}
+export interface CliProviderManifest {
+    /** Identity */
+    type: string;
+    name: string;
+    displayName?: string;
+    category: 'cli';
+    icon?: string;
+    aliases?: ReadonlyArray<string>;
+    /** Versioning */
+    engines?: {
+        adhdev?: string;
+    };
+    providerVersion?: string;
+    contractVersion?: number | string;
+    status?: ProviderLifecycleStatus;
+    details?: string;
+    disableUpstream?: boolean;
+    /** Process spawn */
+    binary: string;
+    versionCommand?: string;
+    spawn: SpawnDef;
+    /** Input/output behavior */
+    sendDelayMs?: number;
+    sendKey?: string;
+    submitStrategy?: 'wait_for_echo' | 'immediate';
+    requirePromptEchoBeforeSubmit?: boolean;
+    allowInputDuringGeneration?: boolean;
+    requiresFinalAssistantBeforeIdle?: boolean;
+    augmentStaleSnapshot?: boolean;
+    transcriptAuthority?: CliTranscriptAuthority;
+    transcriptContext?: 'full' | 'tail';
+    /** Patterns (legacy fallback) */
+    patterns?: CliPatternsDef;
+    /** Approval */
+    approvalKeys?: Readonly<Record<string, string>>;
+    approvalPositiveHints?: ReadonlyArray<string>;
+    /** Timeouts */
+    timeouts?: TimeoutsDef;
+    /** Resume */
+    resume?: ResumeDef;
+    /** Compatibility */
+    compatibility: ReadonlyArray<CompatibilityEntryDef>;
+    defaultScriptDir?: string;
+    /** Capabilities advertised to the dashboard */
+    capabilities?: CapabilitiesDef;
+    /** Mesh coordinator setup */
+    meshCoordinator?: MeshCoordinatorDef;
+    /** Native history (v1 canonical field name) */
+    nativeHistory?: CliNativeHistoryDef;
+    /** @deprecated v0 alias for `nativeHistory`. */
+    canonicalHistory?: CliCanonicalHistoryDef;
+    /** Settings (UI toggles persisted to ~/.adhdev/config.json) */
+    settings?: SettingsDef;
+    /** Controls (dashboard chips/buttons) */
+    controls?: ReadonlyArray<ControlDef>;
+}

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,91 @@
+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>;
+    /**
+     * When true, `env` is already a COMPLETE, sanitized environment (the spawn
+     * planner merged + stripped process.env already) and must be passed to the
+     * PTY verbatim — NOT overlaid on top of process.env. Overlaying would
+     * re-introduce the npm_/PNPM_/parent-session keys the planner explicitly
+     * stripped, so the spec path's spawn env would diverge from the legacy
+     * path's. Defaults to false (legacy overlay behaviour) for any caller that
+     * still passes a partial env.
+     */
+    envIsComplete?: boolean;
+    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;
+}
+/**
+ * One entry in the PTY input/output event timeline (debug-only). Captured at
+ * the single common point every spec@4 provider funnels through — this adapter
+ * — so the Spec Debug Snapshot can answer "what input / output preceded a status
+ * transition?". Observation only; nothing here feeds the FSM decision.
+ */
+export interface SpecPtyEvent {
+    /** Wall-clock ms. */
+    ts: number;
+    kind: 'spawn' | 'input' | 'output' | 'resize' | 'cursor' | 'exit';
+    /** Human-readable, control-char-escaped, length-capped preview. */
+    content: string;
+    /** Raw byte length before truncation (output/input only). */
+    bytes?: number;
+}
+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;
+    /** Debug-only ring buffer of PTY input/output/resize/cursor events. */
+    private events;
+    private lastCursorKey;
+    constructor(opts: TerminalAdapterOpts, handlers: TerminalAdapterHandlers);
+    start(): void;
+    resize(cols: number, rows: number): void;
+    snapshot(): string;
+    /**
+     * Full-buffer snapshot including scrollback history. Unlike snapshot()
+     * (visible viewport only), this survives a tall prompt whose top has
+     * scrolled off-screen — used for content-pattern extraction (modal
+     * buttons / approval anchors), NOT for cursor-relative conditions.
+     */
+    snapshotWithScrollback(): string;
+    getCursorPosition(): {
+        row: number;
+        col: number;
+    };
+    send_keys(text: string): void;
+    /** Debug-only: most-recent PTY input/output/resize/cursor events, oldest
+     *  first. Pure observation — never consulted by the FSM. */
+    getEventTimeline(limit?: number): SpecPtyEvent[];
+    private recordEvent;
+    kill(): void;
+    private onChunk;
+    private computeScreen;
+    private stopTimers;
+}