@adhdev/daemon-core 0.9.82-rc.43 → 0.9.82-rc.430

package/dist/providers/spec/native-history-executor.d.ts

@@ -0,0 +1,41 @@
+import type { NativeHistoryConfig } from './types.js';
+export interface NativeHistoryInput {
+    agentType?: string;
+    sessionId?: string;
+    providerSessionId?: string;
+    historySessionId?: string;
+    workspace?: string;
+    /** Daemon-side wall clock at the moment the session was registered.
+     *  Native-history file lookups use this as the lower bound: any file
+     *  whose mtime is before the current session started can't be from
+     *  this session, so it's excluded from newest-recent matching. The
+     *  caller (chat-history pipeline) populates this from the session
+     *  registry; specs/executor never need to know how it's sourced. */
+    sessionStartedAtMs?: number;
+    /** Env overrides the daemon set on the spawned CLI. The mesh
+     *  coordinator points hermes at a per-coordinator HERMES_HOME so
+     *  the hermes process writes its state.db into a tmp directory
+     *  instead of ~/.hermes. expandPath consults this map before
+     *  process.env so the native-history reader follows the spawned
+     *  child's view of HERMES_HOME / similar overrides; without it
+     *  the reader would always look at ~/.hermes and miss every
+     *  coordinator-session transcript. */
+    envOverrides?: Record<string, string>;
+    args?: Record<string, unknown>;
+}
+export interface NativeHistoryMessage {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    receivedAt: number;
+    kind?: string;
+    workspace?: string;
+}
+export interface NativeHistoryResult {
+    messages: NativeHistoryMessage[];
+    providerSessionId?: string;
+    sourcePath: string;
+    sourceMtimeMs: number;
+    nativeHistoryCoverage?: 'full' | 'partial' | 'best-effort';
+    workspace?: string;
+}
+export declare function executeNativeHistory(cfg: NativeHistoryConfig, input: NativeHistoryInput): NativeHistoryResult | null;

package/dist/providers/spec/pre-launch-trust.d.ts

@@ -0,0 +1,16 @@
+import type { PreLaunchTrust } from './fsm-types.js';
+/**
+ * Idempotently add `workingDir` (realpath) to the trusted-folders array named
+ * by `trust.key` inside the JSON settings file at `trust.settings_path`.
+ *
+ * - Creates the file (and parent dir) if missing.
+ * - Preserves all other settings; only the trust array is touched.
+ * - No-ops if the path is already present.
+ * - Best-effort: any failure is logged and swallowed. A failed pre-trust must
+ *   not block the launch — the worst case is the old behavior (the FSM still
+ *   detects the trust modal as an approval state), not a crash.
+ *
+ * Returns the path that was added (realpath), or null if nothing changed /
+ * an error occurred — purely so callers/tests can assert the effect.
+ */
+export declare function applyPreLaunchTrust(trust: PreLaunchTrust, workingDir: string): string | null;

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

@@ -0,0 +1,4 @@
+import type { CliProviderModule } from '../../cli-adapters/provider-cli-adapter.js';
+import type { PtyTransportFactory } from '../../cli-adapters/pty-transport.js';
+import type { CliAdapter } from '../../cli-adapter-types.js';
+export declare function createCliAdapter(provider: CliProviderModule, workingDir: string, cliArgs: string[], extraEnv: Record<string, string>, transportFactory?: PtyTransportFactory): CliAdapter;

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

@@ -0,0 +1,222 @@
+export type Size = number | string;
+export interface SectionPattern {
+    section?: string;
+    pattern: string;
+    flags?: string;
+}
+/** Inline wait_for shape used by open_picker control actions. */
+export interface WaitForCondition {
+    section?: string;
+    regex?: string;
+    flags?: string;
+}
+export type ControlAction = {
+    type: 'send_keys';
+    keys: string;
+} | {
+    type: 'open_picker';
+    trigger_keys: string;
+    wait_for: WaitForCondition;
+    extract_choices: SectionPattern;
+    submit_key: string;
+    /**
+     * How a parsed choice is committed once the picker is open.
+     *   'index' (default) — type the on-screen number then `submit_key`
+     *     (`{index}\r`). Correct for CLIs whose picker is number-selectable
+     *     (codex-cli, hermes-cli).
+     *   'arrow_keys' — the picker is a cursor list that ignores number keys
+     *     (claude-cli /model): move the cursor from its current row to the
+     *     target row with up/down arrows, then confirm with the `submit_key`
+     *     tail (the `\r` left after stripping `{index}`). Requires the
+     *     extracted choices to flag the current cursor row.
+     */
+    select_mode?: 'index' | 'arrow_keys';
+    /** Arrow byte sequences for `select_mode: 'arrow_keys'`. Defaults to
+     *  ANSI cursor up/down (`` / ``) when omitted. */
+    cursor_keys?: {
+        up: string;
+        down: string;
+    };
+} | {
+    type: 'attach_image';
+    method: 'tempfile_then_keys';
+    keys_template: string;
+};
+export interface Control {
+    id: string;
+    label: string;
+    visible_when_state?: string[];
+    action: ControlAction;
+}
+export interface NotificationRule {
+    id: string;
+    when_state: string;
+    title: string;
+    body?: string;
+}
+export interface DelegateTrigger {
+    id: string;
+    when_state: string;
+    after_duration_ms?: number;
+    task_template: string;
+}
+export interface NativeHistoryConfig {
+    reader?: 'claude-cli' | 'codex-cli' | 'antigravity-cli' | 'hermes-cli';
+    source?: NativeHistorySource;
+    override_path?: string;
+}
+export type NativeHistorySource = NativeHistoryJsonlSource | NativeHistorySqliteSource;
+export interface NativeHistoryJsonlSource {
+    kind: 'jsonl';
+    path: string;
+    file_pattern?: string;
+    recent_window_ms?: number;
+    session_id_from?: 'filename_uuid' | 'first_record';
+    session_id_path?: string;
+    message_filter?: {
+        where: string;
+    };
+    message_map: NativeHistoryMessageMap;
+}
+export interface NativeHistorySqliteSource {
+    kind: 'sqlite';
+    path: string;
+    session_query: string;
+    message_query: string;
+    message_map: NativeHistoryMessageMap;
+}
+export interface NativeHistoryMessageMap {
+    role: string;
+    content: string;
+    content_strip?: string[];
+    content_unwrap?: string[];
+    timestamp_ms?: string;
+    kind?: string;
+    /**
+     * Declarative tool-bubble extraction. Without it the executor only emits
+     * the text-bearing parts of each record, so a turn that is purely a tool
+     * call or tool result (no prose) is dropped — the restored transcript
+     * loses every tool interaction. When present, the executor walks each
+     * record's content blocks and emits an extra `kind:'tool'` message for
+     * any block whose `$.type` matches a tool shape.
+     *
+     * Defaults target the Anthropic-style content-block shape that claude-cli
+     * and codex-cli persist (blocks of `{ type: 'tool_use' | 'tool_result',
+     * name, input, content }`); a provider with a different on-disk shape
+     * overrides the field paths. Set `tools: {}` to opt in with the defaults.
+     */
+    tools?: NativeHistoryToolMap;
+}
+/**
+ * How to surface tool-call / tool-result blocks as `kind:'tool'` bubbles.
+ * Every field is optional — the defaults read the Anthropic block shape.
+ * Paths are jsonpath-lite evaluated against a single content block (the
+ * element of `$.message.content[]`), not the whole record.
+ */
+export interface NativeHistoryToolMap {
+    /** Path to a block's discriminator. Default `$.type`. */
+    block_type?: string;
+    /** Block-type values that mean "a tool was invoked". Default
+     *  `['tool_use', 'function_call', 'custom_tool_call']`. */
+    call_types?: string[];
+    /** Block-type values that mean "a tool returned". Default
+     *  `['tool_result', 'function_call_output', 'custom_tool_call_output']`. */
+    result_types?: string[];
+    /** Path to the tool name on a call block. Default `$.name`. */
+    call_name?: string;
+    /** Path to the tool arguments on a call block. Default `$.input`. */
+    call_args?: string;
+    /** Path to the result payload on a result block. Default `$.content`. */
+    result_content?: string;
+}
+export interface AnchorContext {
+    prev?: string;
+    next?: string;
+    prev_flags?: string;
+    next_flags?: string;
+}
+export interface SectionDef {
+    from_top?: Size;
+    from_bottom?: Size;
+    until?: string;
+    /**
+     * Anchor regex(es). A single string anchors on the first/last matching line
+     * (per `anchor_last`). An array is an OR-set of candidate shapes: each
+     * candidate resolves its OWN anchor line independently (anchor_last → that
+     * candidate's last matching line, else its first), then the TOPMOST resolved
+     * line across candidates wins — a section's anchor marks the top of its
+     * block, so the highest recognized landmark bounds the whole block. This
+     * lets one section capture two shapes — e.g. a box-divider modal AND a
+     * divider-less modal whose only stable landmark is the question line above
+     * its numbered choices — while preventing a stray LOWER landmark (e.g. an
+     * input-box `────` rule below the choices) from clipping the block.
+     */
+    anchor?: string | string[];
+    anchor_flags?: string;
+    anchor_last?: boolean;
+    /**
+     * Context guard(s) for the anchor. A single object applies to every anchor
+     * pattern. An array is matched positionally against an `anchor` array (entry
+     * i guards anchor i); a positional `undefined`/null entry means "no guard"
+     * for that anchor. A scalar `anchor` ignores array form beyond index 0.
+     */
+    anchor_context?: AnchorContext | (AnchorContext | null)[];
+    lines?: number;
+    until_regex?: string;
+    until_regex_flags?: string;
+}
+export interface RegexCondition {
+    section?: string;
+    matches: string;
+    flags?: string;
+    cursor_row_min?: number;
+    cursor_row_max?: number;
+    cursor_col_min?: number;
+    cursor_col_max?: number;
+}
+export interface ChangedCondition {
+    cursor_above: number;
+    changed: boolean;
+    stable_ms?: number;
+}
+export interface AllCondition {
+    all: Condition[];
+}
+export interface AnyCondition {
+    any: Condition[];
+}
+export type Condition = RegexCondition | ChangedCondition | AllCondition | AnyCondition;
+export interface ExtractTitle {
+    section?: string;
+    regex?: string;
+    flags?: string;
+    first_line?: true;
+}
+export interface ExtractButtons {
+    section?: string;
+    pattern: string;
+    flags?: string;
+    key_for_index: string;
+    min_count?: number;
+    continuation_lines?: boolean;
+    /**
+     * How a button is committed when its modal is resolved (auto-approve or an
+     * explicit dashboard click).
+     *   'index' (default) — send `key_for_index` with `{index}` filled in
+     *     (`{index}\r` → `1\r`). Correct for modals whose buttons are
+     *     number-selectable (codex, hermes, antigravity number rows).
+     *   'arrow_keys' — the modal is a cursor list that IGNORES number keys
+     *     (claude-cli's new TUI approval modal): a typed `1` leaks into the
+     *     composer as literal text and `\r` submits it. Instead move the cursor
+     *     from its current row to the target row with up/down arrows, then
+     *     confirm with the `key_for_index` tail (the `\r` left after stripping
+     *     `{index}`). Mirrors the `open_picker` `select_mode` of the same name.
+     */
+    select_mode?: 'index' | 'arrow_keys';
+    /** Arrow byte sequences for `select_mode: 'arrow_keys'`. Defaults to ANSI
+     *  cursor up/down (`[A` / `[B`) when omitted. */
+    cursor_keys?: {
+        up: string;
+        down: string;
+    };
+}

package/dist/providers/status-monitor.d.ts

@@ -3,16 +3,16 @@
  *
  * Common across all Provider categories (IDE/Extension/CLI/ACP).
  * - Approval waiting (waiting_approval) notification
- * - Notification when generating persists for extended duration
+ * - No-progress watchdog: alert when an active turn makes no progress for a while
  * - All config toggleable via Provider Settings
  */
 export interface MonitorConfig {
     /** Enable awaiting-approval notification */
     approvalAlert: boolean;
-    /** Prolonged generating notification enabled */
-    longGeneratingAlert: boolean;
-    /** Prolonged threshold (seconds) */
-    longGeneratingThresholdSec: number;
+    /** No-progress watchdog notification enabled */
+    noProgressAlert: boolean;
+    /** No-progress threshold (seconds) */
+    noProgressThresholdSec: number;
     /** Repeat notification cooldown (seconds) */
     alertCooldownSec: number;
 }
@@ -28,7 +28,7 @@ export declare class StatusMonitor {
     private config;
     private lastAlertTime;
     private generatingStartTimes;
-    private longGeneratingAlerted;
+    private noProgressAlerted;
     private lastProgressFingerprint;
     private lastProgressChangeAt;
     constructor(config?: Partial<MonitorConfig>);
@@ -40,7 +40,7 @@ export declare class StatusMonitor {
      * Check status transition → return notification event array.
      * Called from each onTick() or detectStatusTransition().
      */
-    check(agentKey: string, status: string, now: number, progressFingerprint?: string): MonitorEvent[];
+    check(agentKey: string, status: string, now: number, progressFingerprint?: string, approvalPending?: boolean): MonitorEvent[];
     /** Cooldown check — prevent sending the same notification too frequently */
     private shouldAlert;
     /** Reset (on agent terminate/restart) */

package/dist/providers/transcript-v2.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Chat Transcript Contract v2
+ *
+ * First-class message identity, monotonic sequence, strict enums. Designed to
+ * replace the v1 contract (contracts.ts ReadChatResult + types.ts ChatMessage)
+ * during the A2 big-bang. This module defines the contract; it does not yet
+ * change runtime behaviour. v1 keeps working until A2 flips the switch.
+ *
+ * Invariants v2 enforces (and v1 does not):
+ *   1. Every ChatMessageV2 has providerUnitKey, bubbleId, sequence — none optional.
+ *   2. sequence is a monotonic integer per (sessionId, source) tuple. Producers
+ *      never reuse it; consumers MAY assume strict ordering.
+ *   3. providerUnitKey is stable across re-reads: the same logical message
+ *      always yields the same key even if its index shifts or content is
+ *      edited mid-stream. Producers derive it from provider-owned identifiers
+ *      (turn id, native message id), not from content hashes or array index.
+ *   4. timestamp is producer-asserted wall-clock; orderingTimestamp is monotonic
+ *      and used for snapshot diffs. 1ms fallback increments are forbidden — if
+ *      a producer cannot supply a stable monotonic value, the daemon assigns
+ *      sequence at ingest and orderingTimestamp = ingestedAt.
+ *   5. visibility / source / role / kind are strict unions. No `(string & {})`
+ *      escape hatches.
+ *   6. Coverage is exactly one of full/tail/current-turn. Mixing it with
+ *      partialReason or unavailableReason is a contract violation.
+ *   7. workspace / sessionId are explicit on every ReadChatResultV2; the daemon
+ *      no longer infers them from message bodies.
+ */
+import type { MessagePart, ToolCallInfo } from './contracts.js';
+export declare const CHAT_CONTRACT_VERSION_V1: "1.0";
+export declare const CHAT_CONTRACT_VERSION_V2: "2.0";
+export type ChatContractVersion = typeof CHAT_CONTRACT_VERSION_V1 | typeof CHAT_CONTRACT_VERSION_V2;
+export declare const SUPPORTED_CHAT_CONTRACT_VERSIONS: readonly ChatContractVersion[];
+export declare const CHAT_ROLES_V2: readonly ["user", "assistant", "system"];
+export type ChatRoleV2 = typeof CHAT_ROLES_V2[number];
+export declare const CHAT_MESSAGE_KINDS_V2: readonly ["standard", "thought", "tool", "terminal", "system"];
+export type ChatMessageKindV2 = typeof CHAT_MESSAGE_KINDS_V2[number];
+export declare const CHAT_VISIBILITIES_V2: readonly ["user", "debug", "internal", "hidden"];
+export type ChatVisibilityV2 = typeof CHAT_VISIBILITIES_V2[number];
+export declare const CHAT_AUDIENCES_V2: readonly ["chat", "debug", "trace", "internal"];
+export type ChatAudienceV2 = typeof CHAT_AUDIENCES_V2[number];
+export declare const CHAT_SOURCES_V2: readonly ["assistant_text", "tool_call", "terminal_command", "runtime_activity", "runtime_status", "provider_chrome", "control"];
+export type ChatSourceV2 = typeof CHAT_SOURCES_V2[number];
+export declare const CHAT_BUBBLE_STATES_V2: readonly ["draft", "streaming", "final", "removed"];
+export type ChatBubbleStateV2 = typeof CHAT_BUBBLE_STATES_V2[number];
+/**
+ * Stable identity of a single chat message. All fields are required in v2.
+ *
+ * - providerUnitKey: provider-owned canonical id. Must be derivable from
+ *   provider primitives (native message id, turn id, bubble id), NOT from
+ *   array index or content hash. Stable across re-reads of the same logical
+ *   message even if neighbours change.
+ * - bubbleId: dashboard-owned bubble identity. May equal providerUnitKey when
+ *   the provider already exposes a bubble-grained id; otherwise daemon
+ *   derives it deterministically from providerUnitKey (e.g. `bubble:${key}`).
+ * - sequence: monotonic integer per (sessionId, source). Strictly increasing
+ *   over the lifetime of the session. Used for snapshot diffs and dedup.
+ * - turnKey: stable identifier for the conversation turn this message belongs
+ *   to. Required so consumers can group messages without re-deriving turns.
+ */
+export interface MessageIdentityV2 {
+    providerUnitKey: string;
+    bubbleId: string;
+    sequence: number;
+    turnKey: string;
+}
+/**
+ * Producer-asserted wall-clock time (ms since epoch). Forward jumps are
+ * permitted; consumers MUST NOT rely on this for ordering.
+ */
+export type ChatTimestampMs = number;
+/**
+ * Monotonic ordering value (ms since epoch, but assigned by the daemon at
+ * ingest to guarantee monotonicity even if the producer's wall clock skews).
+ * Used by snapshot diffs in place of timestamp.
+ */
+export type ChatOrderingTimestampMs = number;
+export interface ChatMessageV2 extends MessageIdentityV2 {
+    role: ChatRoleV2;
+    kind: ChatMessageKindV2;
+    content: string | MessagePart[];
+    bubbleState: ChatBubbleStateV2;
+    timestamp: ChatTimestampMs;
+    orderingTimestamp: ChatOrderingTimestampMs;
+    visibility: ChatVisibilityV2;
+    audience: ChatAudienceV2;
+    source: ChatSourceV2;
+    /** Sender display name (for shared sessions). Empty string when unused. */
+    senderName: string;
+    /** Tool calls associated with this message. Empty array when none. */
+    toolCalls: ToolCallInfo[];
+    /** Producer-defined metadata. Daemon never inspects this except for passthrough. */
+    meta: Readonly<Record<string, unknown>>;
+}
+export interface WorkspaceContextV2 {
+    /** Absolute realpath of the workspace the session is reading from. */
+    workspacePath: string;
+    /** Workspace the session was intended to operate on (may differ during cross-workspace ops). */
+    intendedWorkspacePath: string;
+}
+export interface SessionContextV2 {
+    /** Provider-owned session id (e.g. claude.jsonl uuid, codex session_meta.id). */
+    providerSessionId: string;
+    /** Optional daemon-side history alias used to disambiguate within a workspace. */
+    historySessionId?: string;
+}
+/**
+ * v1 allowed `coverage='full'` to coexist with `partialReason`/`unavailableReason`,
+ * which is a contract lie. v2 makes the three states mutually exclusive.
+ */
+export type CoverageHintV2 = {
+    kind: 'full';
+} | {
+    kind: 'tail';
+    tailMessageCount: number;
+} | {
+    kind: 'current-turn';
+    turnKey: string;
+} | {
+    kind: 'partial';
+    partialReason: string;
+} | {
+    kind: 'unavailable';
+    unavailableReason: string;
+};
+export type CanonicalHistoryModeV2 = 'native-source' | 'disabled' | 'materialized-mirror';
+export interface CanonicalHistoryDeclarationV2 {
+    contractVersion: ChatContractVersion;
+    format: string;
+    mode: CanonicalHistoryModeV2;
+    watchPath?: string;
+    scripts: {
+        readSession: string;
+        listSessions: string;
+    };
+}
+export type ReadChatStatusV2 = 'idle' | 'generating' | 'waiting_approval' | 'error' | 'panel_hidden' | 'streaming';
+export type ReadChatTurnStatusV2 = 'open' | 'waiting_approval' | 'complete' | 'error';
+export interface ReadChatResultV2 {
+    contractVersion: typeof CHAT_CONTRACT_VERSION_V2;
+    workspace: WorkspaceContextV2;
+    session: SessionContextV2;
+    coverage: CoverageHintV2;
+    status: ReadChatStatusV2;
+    messages: ChatMessageV2[];
+    currentTurnId: string;
+    turnStatus: ReadChatTurnStatusV2;
+    transcriptAuthority: 'provider' | 'daemon';
+}
+export declare class ChatContractViolationError extends Error {
+    readonly violationPath: string;
+    readonly contractVersion: ChatContractVersion;
+    constructor(contractVersion: ChatContractVersion, violationPath: string, detail: string);
+}
+/**
+ * Validate a v2 read_chat payload. Throws ChatContractViolationError on the
+ * first violation. v2 invariants beyond per-field checks:
+ *   - messages[*].sequence strictly increasing
+ *   - messages[*].orderingTimestamp monotonic non-decreasing
+ *   - coverage union is well-formed
+ */
+export declare function assertReadChatResultV2Payload(raw: unknown): ReadChatResultV2;
+export declare function isSupportedChatContractVersion(value: unknown): value is ChatContractVersion;
+/**
+ * Read a provider's declared chat contract version from its parsed
+ * provider.json `canonicalHistory.contractVersion` field.
+ *
+ * - Absent or unrecognized → treated as v1 (legacy behaviour preserved during
+ *   the A1 transition). A2 will tighten this to reject unsupported versions
+ *   at provider load time.
+ * - Present and supported → returned as-is.
+ *
+ * The returned version drives which validator (assertReadChatResultV2Payload
+ * vs the legacy validateReadChatResultPayload) processes the provider's
+ * read_chat output.
+ */
+export declare function readDeclaredChatContractVersion(canonicalHistory: unknown): ChatContractVersion;

package/dist/providers/types/interactive-prompt.d.ts

@@ -0,0 +1,84 @@
+export interface InteractivePrompt {
+    promptId: string;
+    origin: 'cli' | 'mcp' | 'agent';
+    providerType: string;
+    createdAt: number;
+    questions: InteractiveQuestion[];
+}
+export interface InteractiveQuestion {
+    questionId: string;
+    question: string;
+    header?: string;
+    multiSelect: boolean;
+    options: InteractiveOption[];
+    allowFreeform?: boolean;
+}
+export interface InteractiveOption {
+    label: string;
+    description?: string;
+    preview?: string;
+}
+export interface InteractivePromptResponse {
+    promptId: string;
+    answers: Record<string, InteractiveAnswer>;
+}
+export interface InteractiveAnswer {
+    selectedLabels: string[];
+    freeformText?: string;
+}
+export declare function normalizeInteractivePrompt(raw: unknown): InteractivePrompt | null;
+export declare function normalizeInteractivePromptResponse(raw: unknown): InteractivePromptResponse;
+export declare function buildClaudeInteractiveToolResult(response: InteractivePromptResponse): string;
+export interface ClaudeInteractiveTuiPage {
+    screenText: string;
+    header?: string;
+}
+/**
+ * Decide whether a captured claude-cli AskUserQuestion TUI page is multi-select.
+ *
+ * The original heuristic only matched the footer hint `/Space to select|toggle
+ * selections/i`. That string drifts between claude-cli versions, so when it
+ * changed the dashboard silently fell back to multiSelect:false and rendered
+ * single-select (radio) controls even though the on-screen picker showed
+ * checkboxes — the user could not check more than one box. (The CLI's own
+ * terminal still rendered `[ ]` correctly because it never depends on this
+ * parse.)
+ *
+ * Make detection robust by ALSO recognising the actual checkbox markers the
+ * multi-select picker draws on its option rows (`[ ]` / `[x]` / `☐` / `☒` /
+ * `◻` / `◼`). Single-select rows are drawn with a `❯`/number cursor only and
+ * carry none of these box glyphs, so their presence is a reliable signal. The
+ * broadened footer patterns ("Space to", "toggle", "select multiple") are kept
+ * as a secondary signal for layouts that render markers differently.
+ */
+export declare function detectClaudeTuiMultiSelect(screenText: string): boolean;
+/**
+ * Read the question the live claude TUI picker is CURRENTLY focused on, plus
+ * whether that focused page renders multi-select checkbox markers.
+ *
+ * Used to repair a multi-question prompt after the fact: when the daemon
+ * Tab-captures pages 2..N it snapshots ~120ms after the Tab keypress, before
+ * the newly-focused page's option-row checkbox column has redrawn — so those
+ * questions get frozen as multiSelect:false even though the picker is
+ * multi-select. Re-reading the focused page on a later status tick (once it has
+ * settled) lets us attribute the now-visible glyphs to the matching question
+ * and upgrade just that one. Returns null when no picker question is on screen.
+ */
+export declare function readFocusedClaudeTuiQuestion(screenText: string): {
+    question: string;
+    header?: string;
+    multiSelect: boolean;
+} | null;
+export declare function detectClaudeAskUserQuestionPromptFromTuiPages(pages: ClaudeInteractiveTuiPage[], options: {
+    promptId: string;
+    providerType?: string;
+    createdAt?: number;
+}): InteractivePrompt | null;
+export declare function buildClaudeInteractiveTuiAnswerSteps(prompt: InteractivePrompt, response: InteractivePromptResponse): string[];
+export declare function interactivePromptFromClaudeAskUserQuestion(input: unknown, options: {
+    promptId: string;
+    providerType: string;
+    createdAt?: number;
+    origin?: InteractivePrompt['origin'];
+}): InteractivePrompt | null;
+export declare function detectClaudeAskUserQuestionPromptFromJson(value: unknown, providerType?: string): InteractivePrompt | null;

package/dist/providers/working-dir.d.ts

@@ -0,0 +1,17 @@
+/**
+ * working-dir — shared helpers for deriving display names from a session's
+ * working directory. Used by CLI/ACP provider instances to build session/tab
+ * titles.
+ */
+/**
+ * OS-aware basename of a working directory path.
+ *
+ * Splits on BOTH POSIX (`/`) and Windows (`\`) separators so a win32 path like
+ * `D:\gh\adhdev-cloud` resolves to `adhdev-cloud` even when the daemon's own
+ * `path.basename` is POSIX-only — and a path that mixes separators still works.
+ * Trailing separators and root-only paths fall back to `'session'`, matching
+ * the historical `.split('/').filter(Boolean).pop() || 'session'` behavior.
+ *
+ * Mirrors the web dashboard's `getWorkspaceName` (`ws.split(/[/\\]/)`).
+ */
+export declare function workingDirBasename(p: string): string;