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

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

@@ -121,6 +121,12 @@ export declare class SpecCliAdapter implements CliAdapter {
      * — not this code — decides how a selection is keyed for each CLI.
      */
     private selectPickerChoice;
+    /** Parse the picker choices only if the picker already appears rendered on
+     *  the live screen (its `wait_for` condition currently matches and at least
+     *  one choice parses). Returns the parsed choices when open, else null so
+     *  the caller knows it must send the trigger to open it. Used to de-dup the
+     *  picker open in {@link selectPickerChoice}. */
+    private extractPickerChoicesIfRendered;
     /** Poll the live screen until the picker's `wait_for` condition matches,
      *  up to a short budget. Returns true if it rendered, false on timeout. */
     private waitForPickerRendered;

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

@@ -20,4 +20,5 @@ export declare function extractButtonsFromRule(rule: ExtractButtons, hay: string
     index: number;
     label: string;
     key: string;
+    current: boolean;
 }[];

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

@@ -19,6 +19,24 @@ 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';
     method: 'tempfile_then_keys';
@@ -181,4 +199,24 @@ 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;
+    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.355",
+  "version": "0.9.82-rc.356",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.355",
+    "@adhdev/mesh-shared": "0.9.82-rc.356",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/providers/cli-provider-instance.ts

@@ -2034,6 +2034,23 @@ export class CliProviderInstance implements ProviderInstance {
                 ? event.providerSessionId
                 : this.providerSessionId,
         };
+        // TASKIDLESS: stamp the mesh task primary key on lifecycle events emitted by
+        // a mesh worker session. The consumer (updateDirectDispatchStatus) was switched
+        // to key on task_id (CANON-B), but the producer never carried it — so every
+        // forwarded metadataEvent.taskId arrived undefined and the coordinator fell back
+        // to a session_id match, which can flip a sibling dispatch row. The session
+        // already knows its own taskId via attachMeshAssignment (settings.meshActiveTaskId);
+        // surface it here so updateDirectDispatchStatus hits the exact PK row and the
+        // session_id fallback is never exercised. Non-mesh sessions get no taskId
+        // (regression guard) — isMeshWorkerSession() gates the injection.
+        if (this.isMeshWorkerSession() && this.settings.meshActiveTaskId) {
+            const existingTaskId = typeof enrichedEvent.taskId === 'string' && enrichedEvent.taskId.trim()
+                ? enrichedEvent.taskId
+                : undefined;
+            if (!existingTaskId) {
+                enrichedEvent.taskId = this.settings.meshActiveTaskId;
+            }
+        }
         if (this.context?.emitProviderEvent) {
             this.context.emitProviderEvent(enrichedEvent);
         } else {

package/src/providers/spec/cli-adapter.ts

@@ -413,11 +413,18 @@ export class SpecCliAdapter implements CliAdapter {
         choiceLabel: string | undefined,
     ): Promise<unknown> {
         // Open + wait so the choice list is on screen before we resolve the
-        // label → index mapping (a fresh invoke may arrive with the picker
-        // closed; re-opening an open picker is a no-op on these CLIs).
-        this.driver.dispatch({ kind: 'click_control', control_id: ctl.id });
-        await this.waitForPickerRendered(action);
-        const options = this.extractPickerChoices(action);
+        // label → index mapping. The picker is normally ALREADY open here (a
+        // preceding list invoke leaves it rendered), so only send the trigger
+        // when it is not on screen. Re-sending the trigger to an open picker is
+        // NOT a harmless no-op on claude-cli: the trailing CR of `/model\r`
+        // lands as Enter on the cursor's current row and commits the wrong
+        // model before we navigate. De-dup the open to avoid that.
+        let options = this.extractPickerChoicesIfRendered(action);
+        if (!options) {
+            this.driver.dispatch({ kind: 'click_control', control_id: ctl.id });
+            await this.waitForPickerRendered(action);
+            options = this.extractPickerChoices(action);
+        }
 
         let index = choiceIndex;
         if ((index == null || !Number.isFinite(index)) && choiceLabel) {
@@ -432,8 +439,34 @@ export class SpecCliAdapter implements CliAdapter {
             return { ok: false, error: 'choiceIndex or choiceLabel required to select' };
         }
 
-        const keys = (action.submit_key || '{index}\r').replace(/\{index\}/g, String(index));
-        this.driver.dispatch({ kind: 'pty_write', data: keys });
+        if (action.select_mode === 'arrow_keys') {
+            // Cursor-list picker (claude-cli /model): number keys are ignored.
+            // The cursor starts on the active row (extract flags it `current`);
+            // step it to the target row with arrows, then confirm.
+            const current = options.find(o => o.current);
+            if (current == null) {
+                // Without a known cursor position a blind Enter would commit
+                // whatever row the cursor sits on — fail loud instead.
+                return {
+                    ok: false,
+                    error: 'arrow-nav picker: current cursor row not detected on screen',
+                    controlResult: { options: options.map(o => ({ value: o.label, label: o.label, current: o.current })) },
+                };
+            }
+            const up = action.cursor_keys?.up ?? '';
+            const down = action.cursor_keys?.down ?? '';
+            const delta = index - current.index;
+            const step = delta >= 0 ? down : up;
+            const nav = step.repeat(Math.abs(delta));
+            // Confirm key = submit_key with the (unused) {index} placeholder
+            // stripped — e.g. `{index}\r` → `\r`.
+            const confirm = (action.submit_key || '\r').replace(/\{index\}/g, '') || '\r';
+            if (nav) this.driver.dispatch({ kind: 'pty_write', data: nav });
+            this.driver.dispatch({ kind: 'pty_write', data: confirm });
+        } else {
+            const keys = (action.submit_key || '{index}\r').replace(/\{index\}/g, String(index));
+            this.driver.dispatch({ kind: 'pty_write', data: keys });
+        }
         const selected = options.find(o => o.index === index);
         return {
             ok: true,
@@ -446,6 +479,23 @@ export class SpecCliAdapter implements CliAdapter {
         };
     }
 
+    /** Parse the picker choices only if the picker already appears rendered on
+     *  the live screen (its `wait_for` condition currently matches and at least
+     *  one choice parses). Returns the parsed choices when open, else null so
+     *  the caller knows it must send the trigger to open it. Used to de-dup the
+     *  picker open in {@link selectPickerChoice}. */
+    private extractPickerChoicesIfRendered(
+        action: Extract<ControlAction, { type: 'open_picker' }>,
+    ): Array<{ index: number; label: string; current: boolean }> | null {
+        const wf = action.wait_for;
+        if (wf?.regex) {
+            const re = new RegExp(wf.regex, wf.flags ?? 'i');
+            if (!re.test(this.readScreenSectionText(wf.section))) return null;
+        }
+        const options = this.extractPickerChoices(action);
+        return options.length > 0 ? options : null;
+    }
+
     /** Poll the live screen until the picker's `wait_for` condition matches,
      *  up to a short budget. Returns true if it rendered, false on timeout. */
     private async waitForPickerRendered(action: Extract<ControlAction, { type: 'open_picker' }>): Promise<boolean> {

package/src/providers/spec/evaluator.ts

@@ -314,10 +314,10 @@ function compileLinePattern(ref: { pattern: string; flags?: string }): RegExp {
 export function extractButtonsFromRule(
     rule: ExtractButtons,
     hay: string,
-): { index: number; label: string; key: string }[] {
+): { index: number; label: string; key: string; current: boolean }[] {
     const keyTemplate = rule.key_for_index;
     const continuationLines = rule.continuation_lines ?? false;
-    const buttons: { index: number; label: string; key: string }[] = [];
+    const buttons: { index: number; label: string; key: string; current: boolean }[] = [];
 
     if (continuationLines) {
         const re = compileLinePattern(rule);
@@ -328,6 +328,7 @@ export function extractButtonsFromRule(
             const idx = Number(m[1]);
             let label = String(m[2] ?? '').trim();
             if (!Number.isFinite(idx) || idx <= 0 || !label) continue;
+            const current = hasCursorMarker(lines[i]);
             let j = i + 1;
             while (j < lines.length) {
                 const next = lines[j];
@@ -339,7 +340,7 @@ export function extractButtonsFromRule(
             }
             if (buttons.some(b => b.index === idx)) continue;
             const key = keyTemplate.replace(/\{index\}/g, String(idx));
-            buttons.push({ index: idx, label, key });
+            buttons.push({ index: idx, label, key, current });
             i = j - 1;
         }
     } else {
@@ -351,10 +352,19 @@ export function extractButtonsFromRule(
             if (!Number.isFinite(idx) || idx <= 0 || !label) continue;
             if (buttons.some(b => b.index === idx)) continue;
             const key = keyTemplate.replace(/\{index\}/g, String(idx));
-            buttons.push({ index: idx, label, key });
+            // The matched text begins at the cursor marker (the pattern's
+            // optional `[❯›>]` prefix); flag this row as the cursor's current
+            // position so `select_mode: 'arrow_keys'` can step from it.
+            buttons.push({ index: idx, label, key, current: hasCursorMarker(m[0]) });
         }
     }
 
     buttons.sort((a, b) => a.index - b.index);
     return buttons;
 }
+
+/** True when a button line carries a TUI cursor marker (`❯`, `›`, `>`) before
+ *  its number — i.e. the cursor currently sits on that row. */
+function hasCursorMarker(text: string): boolean {
+    return /^\s*[❯›>]/.test(text);
+}

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

@@ -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 {
@@ -1079,6 +1079,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/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 };
 }