@adhdev/daemon-core 0.9.82-rc.355 → 0.9.82-rc.357

package/src/providers/spec/fsm-driver.ts

@@ -32,7 +32,7 @@ import {
 import { evaluateFsm, type FsmClock, type TransitionEval, type FsmEvaluation } from './fsm-evaluator.js';
 import {
     type CliSpecV4, type FsmState, type FsmTransition,
-    initialState, stateById, statusForState, outgoingTransitions,
+    initialState, stateById, statusForState, modalKindForState, outgoingTransitions,
 } from './fsm-types.js';
 import { loadFsmSpec } from './fsm-loader.js';
 import { applyPreLaunchTrust } from './pre-launch-trust.js';
@@ -44,7 +44,7 @@ import { LOG } from '../../logging/logger.js';
 export type DashboardEvent =
     | { kind: 'pty_data'; chunk: string }
     | { kind: 'state_changed'; state: { id: string; label: string; title: string | null; status: 'idle' | 'generating' | 'approval' };
-        modal: { title: string | null; buttons: { index: number; label: string }[] } | null;
+        modal: { title: string | null; buttons: { index: number; label: string }[]; kind: 'approval' | 'picker' | 'confirm' | null } | null;
         controls: { id: string; label: string; action_type: string }[] }
     | { kind: 'notification'; id: string; title: string; body: string }
     | { kind: 'delegate'; id: string; task: string }
@@ -221,7 +221,7 @@ export function guessExt(mime: string): string {
 
 interface ModalSnapshot {
     title: string | null;
-    buttons: { index: number; label: string; key: string }[];
+    buttons: { index: number; label: string; key: string; current: boolean }[];
 }
 
 interface VisibleControl {
@@ -694,7 +694,12 @@ export class FsmDriver implements ISpecDriver {
             this.emit({
                 kind: 'state_changed',
                 state: next.state,
-                modal: next.modal ? { title: next.modal.title, buttons: next.modal.buttons.map(b => ({ index: b.index, label: b.label })) } : null,
+                // kind is the SEMANTIC modal class (approval vs picker/confirm)
+                // derived from the FSM state, NOT from the parsed buttons — the
+                // status field already collapsed it to 'approval' so the modal is
+                // surfaced. The auto-approve worker needs the distinction back to
+                // avoid answering a /model picker on the user's behalf.
+                modal: next.modal ? { title: next.modal.title, buttons: next.modal.buttons.map(b => ({ index: b.index, label: b.label })), kind: modalKindForState(state) } : null,
                 controls: next.controls.map(c => ({ id: c.id, label: c.label, action_type: c.actionType })),
             });
             this.fireNotifications(state.id, title);
@@ -1079,6 +1084,28 @@ export class FsmDriver implements ISpecDriver {
         if (!m) return;
         const btn = m.buttons.find(b => b.index === index);
         if (!btn) return;
+
+        const rule = stateById(this.spec, this.currentStateId)?.extract?.buttons;
+        if (rule?.select_mode === 'arrow_keys') {
+            // Cursor-list approval modal (claude-cli new TUI): number keys are
+            // IGNORED — sending `btn.key` ("1\r") types a literal "1" into the
+            // composer and the trailing CR submits it as a chat message. Drive
+            // the cursor from its current row to the target row with arrows,
+            // then confirm. The cursor opens on the first option, so when the
+            // marker isn't detected we step down from row 1 (index - 1).
+            const from = m.buttons.find(b => b.current)?.index ?? 1;
+            const up = rule.cursor_keys?.up ?? '\x1b[A';
+            const down = rule.cursor_keys?.down ?? '\x1b[B';
+            const delta = btn.index - from;
+            const step = delta >= 0 ? down : up;
+            const nav = step.repeat(Math.abs(delta));
+            // Confirm = key_for_index with the (now unused) {index} stripped:
+            // `{index}\r` → `\r`.
+            const confirm = (rule.key_for_index || '\r').replace(/\{index\}/g, '') || '\r';
+            if (nav) this.adapter.send_keys(nav);
+            this.adapter.send_keys(confirm);
+            return;
+        }
         this.adapter.send_keys(btn.key);
     }
 

package/src/providers/spec/fsm-types.ts

@@ -88,6 +88,27 @@ export interface FsmState {
     /** Modal states (approval/picker) expose modal buttons in the UI and are
      *  treated as "interesting" — the dashboard surfaces them distinctly. */
     modal?: boolean;
+    /**
+     * For a modal state, what KIND of modal it is — the semantic distinction the
+     * status field (always 'approval' for any modal, so the dashboard surfaces it)
+     * deliberately loses. The auto-approve worker uses this to decide whether it
+     * may answer the modal on the user's behalf:
+     *
+     *   - 'approval' — a tool/command/trust consent prompt ("Allow Bash?",
+     *     "Trust this folder?"). Auto-approve MAY fire (a background mesh worker
+     *     should not stall on these).
+     *   - 'picker'   — a selection menu the user opened (/model, /mode, …). There
+     *     is no "correct" answer to auto-pick; blindly selecting the first option
+     *     silently changes the model/mode. Auto-approve must NOT fire — the user
+     *     chooses.
+     *   - 'confirm'  — a non-consent yes/no the user must decide. Left to the user.
+     *
+     * Defaults to 'approval' for a modal state that omits it (preserves the
+     * pre-existing "auto-approve any modal" behaviour for un-migrated specs;
+     * picker/confirm states declare their kind explicitly). Non-modal states
+     * have no modal_kind.
+     */
+    modal_kind?: 'approval' | 'picker' | 'confirm';
     /** Status this state maps to for the dashboard/cli-adapter status field.
      *  One of: idle | generating | approval. Defaults: modal→approval,
      *  initial→idle, id==='busy'→generating, else idle. Explicit wins. */
@@ -236,3 +257,17 @@ export function statusForState(state: FsmState): 'idle' | 'generating' | 'approv
     if (state.id === 'busy' || state.id === 'generating') return 'generating';
     return 'idle';
 }
+
+/**
+ * The modal kind for a state, or null when the state is not modal. A modal state
+ * that omits `modal_kind` defaults to 'approval' so the established
+ * auto-approve-any-modal behaviour is preserved for specs that have not yet
+ * declared a kind; picker/confirm states must opt out by declaring their kind.
+ * This is the value the cli-adapter carries on `activeModal.kind` and the
+ * auto-approve gate reads — see cli-provider-instance.maybeAutoApproveStatus.
+ */
+export function modalKindForState(state: FsmState): 'approval' | 'picker' | 'confirm' | null {
+    if (state.modal_kind) return state.modal_kind;
+    if (state.modal) return 'approval';
+    return null;
+}

package/src/providers/spec/types.ts

@@ -34,6 +34,21 @@ export type ControlAction =
           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';
@@ -227,4 +242,21 @@ export interface ExtractButtons {
     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 };
 }