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

package/dist/mesh/mesh-events-coordinator.d.ts

@@ -65,6 +65,7 @@ export declare function triggerMeshQueue(components: DaemonComponents, meshId: s
 export declare function isMeshCoordinatorEvent(eventName: unknown): eventName is string;
 export declare const MESH_FORCE_INJECT_EVENTS: ReadonlySet<string>;
 export declare function shouldForceInjectMeshEvent(eventName: unknown): boolean;
+export declare function buildRelayMetadataEvent(payload: Record<string, unknown>): Record<string, unknown>;
 export declare function handleMeshForwardEvent(components: DaemonComponents, payload: Record<string, unknown>): {
     success: boolean;
     forwarded: number;

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/fsm-driver.d.ts

@@ -19,6 +19,7 @@ export type DashboardEvent = {
             index: number;
             label: string;
         }[];
+        kind: 'approval' | 'picker' | 'confirm' | null;
     } | null;
     controls: {
         id: string;

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

@@ -30,6 +30,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. */
@@ -142,3 +163,12 @@ export declare function outgoingTransitions(spec: CliSpecV4, stateId: string): F
 /** Map a state to the dashboard status string, applying the documented
  *  defaults when `status` is not explicit. */
 export declare function statusForState(state: FsmState): 'idle' | 'generating' | 'approval';
+/**
+ * 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 declare function modalKindForState(state: FsmState): 'approval' | 'picker' | 'confirm' | null;

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.357",
   "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.357",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/cli-adapter-types.ts

@@ -14,6 +14,15 @@ export interface CliAdapterStatus {
     activeModal?: {
         message: string;
         buttons: string[];
+        /**
+         * Semantic modal class, when the adapter knows it (spec/FSM path):
+         * 'approval' = tool/command/trust consent (auto-approve may fire);
+         * 'picker' = a selection menu the user opened (/model, /mode — must NOT
+         * be auto-answered); 'confirm' = a yes/no left to the user. Absent/null
+         * for adapters that don't classify modals — the auto-approve gate then
+         * falls back to its structural heuristic.
+         */
+        kind?: 'approval' | 'picker' | 'confirm' | null;
     } | null;
     activeInteractivePrompt?: InteractivePrompt | null;
     providerSessionId?: string;

package/src/mesh/mesh-events-coordinator.ts

@@ -106,8 +106,51 @@ function sweepExpiredRemoteIdleSessions(): void {
 
 function getMeshWithCache(components: DaemonComponents, meshId: string): any | undefined {
     const localMesh = getMesh(meshId);
-    if (localMesh) return localMesh;
-    return components.router?.getCachedInlineMesh(meshId);
+    const cachedMesh = components.router?.getCachedInlineMesh(meshId);
+    if (!localMesh) return cachedMesh;
+    if (!cachedMesh) return localMesh;
+    return mergeInlineCacheOnlyNodes(localMesh, cachedMesh);
+}
+
+/**
+ * Claim-time membership view unification (CLAIMSTALL fix).
+ *
+ * The coordinator's claim path — triggerMeshQueue → autoLaunch candidate filter
+ * and the local/remote idle-session drain — reads mesh membership through
+ * getMeshWithCache, which historically returned the local-config mesh verbatim
+ * whenever one existed. A freshly cloned worktree node is registered ONLY into the
+ * router's inline mesh cache: clone_mesh_node's `meshRecord.inline` branch calls
+ * updateInlineMeshNode, NOT addNode, so the worktree node never reaches local
+ * config (meshes.json). The config-first view therefore omits the worktree node,
+ * while send_task — which resolves membership through getMeshForCommand(preferInline)
+ * over the same inline cache — sees it. That view asymmetry is the stall: a queue
+ * task pinned to the worktree node reports `target_node_id_unmatched` (autoLaunch
+ * candidate filter / targetPinUnmatched check) and the node's idle session is
+ * dropped from the drain pool (mesh.nodes.find miss), so claim never fires and the
+ * task is stranded pending — even though nodeId matching itself is correct.
+ *
+ * Fix: union the local-config nodes with any inline-cache-ONLY nodes, so the claim
+ * view matches the command (send_task) view. Base (non-worktree) nodes present in
+ * local config stay config-authoritative — their entry is taken verbatim from
+ * localMesh, so base node claim/matching is byte-for-byte unchanged. Only nodes
+ * that exist solely in the inline cache (the cloned worktree nodes) are appended.
+ * Identity comparison uses the shared 3-form normalizer (id / nodeId / node_id),
+ * identical to every other claim-path consumer — the matching logic is untouched,
+ * only which nodes are visible.
+ */
+function mergeInlineCacheOnlyNodes(localMesh: any, cachedMesh: any): any {
+    const localNodes = Array.isArray(localMesh?.nodes) ? localMesh.nodes : [];
+    const cachedNodes = Array.isArray(cachedMesh?.nodes) ? cachedMesh.nodes : [];
+    if (!cachedNodes.length) return localMesh;
+    const cacheOnly = cachedNodes.filter((cachedNode: any) => {
+        const cachedId = readMeshNodeId(cachedNode);
+        // Unidentifiable cache entries can never be a claim/route target — skip them
+        // rather than appending junk that no consumer can address.
+        if (!cachedId) return false;
+        return !localNodes.some((localNode: any) => meshNodeIdMatches(localNode, cachedId));
+    });
+    if (!cacheOnly.length) return localMesh;
+    return { ...localMesh, nodes: [...localNodes, ...cacheOnly] };
 }
 
 const INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS = 30 * 60 * 1000;
@@ -2143,6 +2186,88 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
     return { success: true, forwarded: 0 };
 }
 
+// Reconstruct the metadataEvent that injectMeshSystemMessage consumes from a forwarded
+// (cross-machine) mesh event. The remote relay hop arrives as a flat payload, NOT the
+// original provider event object, so this whitelists the fields the coordinator-side
+// pipeline reads and re-projects them. Kept pure + exported so the relay-path field
+// preservation (esp. taskId) is unit-testable without driving injectMeshSystemMessage.
+//
+// IMPORTANT asymmetry: the LOCAL in-process forward path (onMeshCoordinatorEventForwarded)
+// passes the whole event through as metadataEvent, so every field on the event survives
+// there for free. This remote-only path must explicitly mirror each field it needs.
+export function buildRelayMetadataEvent(payload: Record<string, unknown>): Record<string, unknown> {
+    const relayModalMessage = readNonEmptyString(payload.modalMessage);
+    const relayModalButtons = Array.isArray(payload.modalButtons)
+        ? (payload.modalButtons as unknown[]).filter((b): b is string => typeof b === 'string' && b.trim().length > 0)
+        : null;
+    return {
+        // Preserve the dispatch task id across the machine boundary. The `received` trace
+        // stage reads payload.taskId; without mirroring it here the rebuilt metadataEvent
+        // loses it, so injectMeshSystemMessage's traceCtx.taskId and the
+        // updateDirectDispatchStatus(eventTaskId) call go undefined — the EvtTrace
+        // queued/surfaced stages show task=- and the direct-dispatch ledger falls back to a
+        // session_id match (which can flip a sibling row). The local in-process forward path
+        // keeps event.taskId/meshActiveTaskId for free; this mirrors it for the remote relay.
+        // Same taskId/meshActiveTaskId ordering the local unroutable trace uses.
+        taskId: readNonEmptyString(payload.taskId) || readNonEmptyString(payload.meshActiveTaskId),
+        targetSessionId: readNonEmptyString(payload.targetSessionId) || readNonEmptyString(payload.sessionId) || readNonEmptyString(payload.instanceId),
+        providerType: readNonEmptyString(payload.providerType),
+        providerSessionId: readNonEmptyString(payload.providerSessionId),
+        // Preserve the originating coordinator SESSION id across the machine boundary so
+        // the completion routes back to the exact coordinator session (multi-coordinator).
+        // buildForwardPayloadFromPending spreads the worker event's metadata, so the id
+        // arrives as payload.meshCoordinatorSessionId; the top-level targetCoordinatorSessionId
+        // is also accepted as a fallback. injectMeshSystemMessage re-derives the routing
+        // anchors from this. Absent → daemon-level fallback (version-skew safe).
+        meshCoordinatorSessionId: readNonEmptyString(payload.meshCoordinatorSessionId) || readNonEmptyString(payload.targetCoordinatorSessionId),
+        // Carry the session identity fields the worker provider event emits so the
+        // coordinator's mirror (updateMeshOwnedSession) gets a real workspace/title/
+        // settings. Without these the remote-relay hop reconstructs metadataEvent with
+        // an empty workspace, and the dashboard flaps to the generic
+        // "Terminal (Mesh Node)" title (and degrades the provider label) between live
+        // events and the periodic get_status_metadata snapshot. The local in-process
+        // forward path (onMeshCoordinatorEventForwarded) already preserves these; this
+        // mirrors them for the remote-only relay path.
+        workspace: readNonEmptyString(payload.workspace) || readNonEmptyString(payload.workspaceName),
+        workspaceName: readNonEmptyString(payload.workspaceName) || readNonEmptyString(payload.workspace),
+        sessionTitle: readNonEmptyString(payload.sessionTitle),
+        sessionStatus: readNonEmptyString(payload.sessionStatus),
+        sessionChatStatus: readNonEmptyString(payload.sessionChatStatus),
+        providerName: readNonEmptyString(payload.providerName),
+        ...(payload.sessionSettings && typeof payload.sessionSettings === 'object' && !Array.isArray(payload.sessionSettings) ? { sessionSettings: payload.sessionSettings } : {}),
+        finalSummary: readNonEmptyString(payload.finalSummary) || readNonEmptyString(payload.summary),
+        // T2: carry the worker's status-snapshot last-message preview across the machine
+        // boundary so a summary-less completion still surfaces the assistant reply in the
+        // coordinator's inbox mirror. resolveMeshSurfacedSessionPreview reads these
+        // (assistant-role only) when finalSummary is absent.
+        lastMessagePreview: readNonEmptyString(payload.lastMessagePreview),
+        lastMessageRole: readNonEmptyString(payload.lastMessageRole),
+        ...(payload.lastMessageAt !== undefined ? { lastMessageAt: payload.lastMessageAt } : {}),
+        jobId: readNonEmptyString(payload.jobId),
+        interactionId: readNonEmptyString(payload.interactionId),
+        status: readNonEmptyString(payload.status),
+        targetDaemonId: readNonEmptyString(payload.targetDaemonId),
+        startedAt: readNonEmptyString(payload.startedAt),
+        completedAt: readNonEmptyString(payload.completedAt),
+        retryOfJobId: readNonEmptyString(payload.retryOfJobId),
+        ...(relayModalMessage ? { modalMessage: relayModalMessage } : {}),
+        ...(relayModalButtons && relayModalButtons.length > 0 ? { modalButtons: relayModalButtons } : {}),
+        ...(payload.result && typeof payload.result === 'object' && !Array.isArray(payload.result) ? { result: payload.result } : {}),
+        ...(payload.completionDiagnostic && typeof payload.completionDiagnostic === 'object' && !Array.isArray(payload.completionDiagnostic) ? { completionDiagnostic: payload.completionDiagnostic } : {}),
+        ...(payload.workerResult && typeof payload.workerResult === 'object' && !Array.isArray(payload.workerResult) ? { workerResult: payload.workerResult } : {}),
+        ...(payload.meshWorkerResult && typeof payload.meshWorkerResult === 'object' && !Array.isArray(payload.meshWorkerResult) ? { meshWorkerResult: payload.meshWorkerResult } : {}),
+        ...(payload.structuredResult && typeof payload.structuredResult === 'object' && !Array.isArray(payload.structuredResult) ? { structuredResult: payload.structuredResult } : {}),
+        ...(payload.timestamp !== undefined ? { timestamp: payload.timestamp } : {}),
+        intentional: payload.intentional === true,
+        intentionalStop: payload.intentionalStop === true,
+        operatorCleanup: payload.operatorCleanup === true,
+        reason: readNonEmptyString(payload.reason),
+        stopReason: readNonEmptyString(payload.stopReason),
+        cleanupReason: readNonEmptyString(payload.cleanupReason),
+        source: readNonEmptyString(payload.source),
+    };
+}
+
 export function handleMeshForwardEvent(components: DaemonComponents, payload: Record<string, unknown>) {
     const eventName = readNonEmptyString(payload.event);
     if (!isMeshCoordinatorEvent(eventName)) {
@@ -2184,73 +2309,13 @@ export function handleMeshForwardEvent(components: DaemonComponents, payload: Re
         event: eventName,
     });
     const nodeLabel = nodeId ? `Node '${nodeId}'` : workspace ? `Agent at ${workspace}` : 'Remote agent';
-    const relayModalMessage = readNonEmptyString(payload.modalMessage);
-    const relayModalButtons = Array.isArray(payload.modalButtons)
-        ? (payload.modalButtons as unknown[]).filter((b): b is string => typeof b === 'string' && b.trim().length > 0)
-        : null;
 
     return injectMeshSystemMessage(components, {
         meshId,
         nodeId,
         nodeLabel,
         event: eventName,
-        metadataEvent: {
-            targetSessionId: readNonEmptyString(payload.targetSessionId) || readNonEmptyString(payload.sessionId) || readNonEmptyString(payload.instanceId),
-            providerType: readNonEmptyString(payload.providerType),
-            providerSessionId: readNonEmptyString(payload.providerSessionId),
-            // Preserve the originating coordinator SESSION id across the machine boundary so
-            // the completion routes back to the exact coordinator session (multi-coordinator).
-            // buildForwardPayloadFromPending spreads the worker event's metadata, so the id
-            // arrives as payload.meshCoordinatorSessionId; the top-level targetCoordinatorSessionId
-            // is also accepted as a fallback. injectMeshSystemMessage re-derives the routing
-            // anchors from this. Absent → daemon-level fallback (version-skew safe).
-            meshCoordinatorSessionId: readNonEmptyString(payload.meshCoordinatorSessionId) || readNonEmptyString(payload.targetCoordinatorSessionId),
-            // Carry the session identity fields the worker provider event emits so the
-            // coordinator's mirror (updateMeshOwnedSession) gets a real workspace/title/
-            // settings. Without these the remote-relay hop reconstructs metadataEvent with
-            // an empty workspace, and the dashboard flaps to the generic
-            // "Terminal (Mesh Node)" title (and degrades the provider label) between live
-            // events and the periodic get_status_metadata snapshot. The local in-process
-            // forward path (onMeshCoordinatorEventForwarded) already preserves these; this
-            // mirrors them for the remote-only relay path.
-            workspace: readNonEmptyString(payload.workspace) || readNonEmptyString(payload.workspaceName),
-            workspaceName: readNonEmptyString(payload.workspaceName) || readNonEmptyString(payload.workspace),
-            sessionTitle: readNonEmptyString(payload.sessionTitle),
-            sessionStatus: readNonEmptyString(payload.sessionStatus),
-            sessionChatStatus: readNonEmptyString(payload.sessionChatStatus),
-            providerName: readNonEmptyString(payload.providerName),
-            ...(payload.sessionSettings && typeof payload.sessionSettings === 'object' && !Array.isArray(payload.sessionSettings) ? { sessionSettings: payload.sessionSettings } : {}),
-            finalSummary: readNonEmptyString(payload.finalSummary) || readNonEmptyString(payload.summary),
-            // T2: carry the worker's status-snapshot last-message preview across the machine
-            // boundary so a summary-less completion still surfaces the assistant reply in the
-            // coordinator's inbox mirror. resolveMeshSurfacedSessionPreview reads these
-            // (assistant-role only) when finalSummary is absent.
-            lastMessagePreview: readNonEmptyString(payload.lastMessagePreview),
-            lastMessageRole: readNonEmptyString(payload.lastMessageRole),
-            ...(payload.lastMessageAt !== undefined ? { lastMessageAt: payload.lastMessageAt } : {}),
-            jobId: readNonEmptyString(payload.jobId),
-            interactionId: readNonEmptyString(payload.interactionId),
-            status: readNonEmptyString(payload.status),
-            targetDaemonId: readNonEmptyString(payload.targetDaemonId),
-            startedAt: readNonEmptyString(payload.startedAt),
-            completedAt: readNonEmptyString(payload.completedAt),
-            retryOfJobId: readNonEmptyString(payload.retryOfJobId),
-            ...(relayModalMessage ? { modalMessage: relayModalMessage } : {}),
-            ...(relayModalButtons && relayModalButtons.length > 0 ? { modalButtons: relayModalButtons } : {}),
-            ...(payload.result && typeof payload.result === 'object' && !Array.isArray(payload.result) ? { result: payload.result } : {}),
-            ...(payload.completionDiagnostic && typeof payload.completionDiagnostic === 'object' && !Array.isArray(payload.completionDiagnostic) ? { completionDiagnostic: payload.completionDiagnostic } : {}),
-            ...(payload.workerResult && typeof payload.workerResult === 'object' && !Array.isArray(payload.workerResult) ? { workerResult: payload.workerResult } : {}),
-            ...(payload.meshWorkerResult && typeof payload.meshWorkerResult === 'object' && !Array.isArray(payload.meshWorkerResult) ? { meshWorkerResult: payload.meshWorkerResult } : {}),
-            ...(payload.structuredResult && typeof payload.structuredResult === 'object' && !Array.isArray(payload.structuredResult) ? { structuredResult: payload.structuredResult } : {}),
-            ...(payload.timestamp !== undefined ? { timestamp: payload.timestamp } : {}),
-            intentional: payload.intentional === true,
-            intentionalStop: payload.intentionalStop === true,
-            operatorCleanup: payload.operatorCleanup === true,
-            reason: readNonEmptyString(payload.reason),
-            stopReason: readNonEmptyString(payload.stopReason),
-            cleanupReason: readNonEmptyString(payload.cleanupReason),
-            source: readNonEmptyString(payload.source),
-        },
+        metadataEvent: buildRelayMetadataEvent(payload),
     });
 }
 

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

@@ -24,7 +24,7 @@ import { LOG } from '../logging/logger.js';
 import { traceMeshEventStage, traceMeshEventDrop } from '../mesh/mesh-event-trace.js';
 import type { ChatMessage } from '../types.js';
 import { buildPersistedProviderEffectMessage, normalizeProviderEffects } from './control-effects.js';
-import { formatAutoApprovalMessage, pickApprovalButton, pickAutoApprovalButton, looksLikeActiveApprovalPromptText } from './approval-utils.js';
+import { formatAutoApprovalMessage, pickApprovalButton, hasNegativeApprovalOption, looksLikeActiveApprovalPromptText } from './approval-utils.js';
 import { getCliScriptCommand, parseCliScriptResult } from './cli-script-results.js';
 import { mergeProviderPatchState, resolveProviderStateSurface } from './provider-patch-state.js';
 import { normalizeProviderSessionId } from './provider-session-id.js';
@@ -1622,10 +1622,34 @@ export class CliProviderInstance implements ProviderInstance {
         if (!modal || buttons.length === 0) {
             return autoApproveActive;
         }
-        const { index: buttonIndex, label: buttonLabel } = pickAutoApprovalButton(buttons);
-        if (buttonIndex < 0) {
-            // No concrete button matched — don't pick a random index, just
-            // surface the modal so the user can decide.
+        // Picker/confirm exclusion (provider-common). A /model or /mode picker is
+        // surfaced with status=waiting_approval so the dashboard shows it, but it
+        // has no "correct" answer to auto-pick — blindly selecting the first
+        // option silently switches the model (the "always Opus, before I even
+        // choose" bug). Two independent gates, BOTH must pass to fire:
+        //
+        //   (1) modal_kind — the spec/FSM tells us this is an 'approval' modal,
+        //       not a 'picker'/'confirm'. A modal whose kind is unknown (legacy
+        //       adapter, or a spec that predates modal_kind) reads as 'approval'
+        //       so genuine approvals keep auto-approving; only an explicit
+        //       'picker'/'confirm' is excluded here.
+        //   (2) structural anchor — a real approval offers an affirmative AND a
+        //       decline option (pickApprovalButton finds a positive that isn't a
+        //       decline, and hasNegativeApprovalOption confirms a No/Cancel/Deny
+        //       is present). A model picker ("1. Default  2. Opus  3. Sonnet")
+        //       has no decline, so even an un-migrated picker is caught here.
+        //
+        // Mirrors the SDK v1 detect-status approval heuristic (detect-status.ts).
+        const modalKind = typeof modal?.kind === 'string' ? modal.kind : 'approval';
+        if (modalKind !== 'approval') {
+            // Picker/confirm — leave it for the user; keep the modal surfaced.
+            return autoApproveActive;
+        }
+        const { index: buttonIndex, label: buttonLabel } = pickApprovalButton(buttons, this.provider);
+        if (buttonIndex < 0 || !hasNegativeApprovalOption(buttons)) {
+            // No affirmative matched, or no decline option present (→ not a real
+            // consent prompt, e.g. a picker that slipped past the kind gate).
+            // Surface the modal so the user decides; never pick blindly.
             return autoApproveActive;
         }
         // Modal *identity* signature — the question/button set only, NO volatile
@@ -2034,6 +2058,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

@@ -75,7 +75,7 @@ export class SpecCliAdapter implements CliAdapter {
     };
     private lastEvent: DashboardEvent | null = null;
     private latestState: { id: string; label: string; title: string | null; status: 'idle' | 'generating' | 'approval' } | null = null;
-    private latestModal: { title: string | null; buttons: { index: number; label: string }[] } | null = null;
+    private latestModal: { title: string | null; buttons: { index: number; label: string }[]; kind?: 'approval' | 'picker' | 'confirm' | null } | null = null;
     private statusCallback: (() => void) | null = null;
     private ptyDataCallback: ((data: string) => void) | null = null;
     private partialResponse = '';
@@ -193,8 +193,10 @@ export class SpecCliAdapter implements CliAdapter {
                 messages: [],
                 // Surface buttons when we have them; an approval state with no parsed
                 // modal this frame still stays waiting_approval (no activeModal yet).
+                // `kind` carries the semantic modal class through to the auto-approve
+                // gate so a /model picker (kind='picker') is never auto-answered.
                 activeModal: modal
-                    ? { message: modal.title ?? state.label, buttons: modal.buttons.map(b => b.label) }
+                    ? { message: modal.title ?? state.label, buttons: modal.buttons.map(b => b.label), kind: modal.kind ?? null }
                     : null,
                 activeInteractivePrompt: this.activeInteractivePrompt,
                 ...sessionFields,
@@ -413,11 +415,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 +441,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 +481,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);
+}