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

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

@@ -22,3 +22,24 @@ export declare function extractButtonsFromRule(rule: ExtractButtons, hay: string
     key: string;
     current: boolean;
 }[];
+/**
+ * Reduce a top→bottom-ordered list of parsed numbered entries to only the
+ * bottom-most contiguous block — the run whose indices descend by exactly 1
+ * scanning upward from the last entry.
+ *
+ * Picker and approval choices always render as the LAST contiguous numbered
+ * block at the bottom of the modal section. The conversation history above can
+ * carry its own stray "1./2./3." numbered lists (and blockquote `>` lines), and
+ * because section anchoring can pull body lines into the modal section, a naive
+ * top-down scan would bind the low option indices to those body lines and drop
+ * the real choices (the dashboard would show, and an arrow-key picker would
+ * commit, the wrong row). Selecting the bottom block makes the on-screen picker
+ * win regardless of body content. Since pickers number their options 1..N
+ * contiguously and bodies use indices ≥ 1, the upward chain always breaks the
+ * moment it would need a "0." above the picker's "1." — so the picker block is
+ * isolated cleanly. Entries are assumed already in screen order; the returned
+ * slice keeps that order.
+ */
+export declare function lastContiguousNumberedBlock<T extends {
+    index: number;
+}>(entries: T[]): T[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.357",
+  "version": "0.9.82-rc.358",
   "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.357",
+    "@adhdev/mesh-shared": "0.9.82-rc.358",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

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

@@ -1840,7 +1840,16 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         // transcript and record the genuine completion once the worker truly finishes (commonly
         // after a coordinator nudge / re-dispatch). A matched queue task, or a completion with
         // genuine evidence, is marked terminal as before.
-        const leaveDirectDispatchActive = !task && opts?.tentativeIfDirect === true;
+        // WARMUPGAP: a no-taskId completion from a session that holds no active assignment is a
+        // pre-assignment warmup / ghost event (a worker spawns, idles, and emits idle→generating→
+        // completed before any task is dispatched, with meshActiveTaskId unset so the event carries
+        // no taskId). Letting it through would hit the session_id fallback in updateDirectDispatchStatus
+        // and flip a sibling/stale dispatch row this event does not own — the real task later lands on
+        // a corrupted row and never reaches completed. Skip the dispatch update for that case. A
+        // taskId-carrying completion (real task), or any completion whose session currently holds an
+        // active assignment (legacy/relayed worker), still flips as before.
+        const leaveDirectDispatchActive = (!task && opts?.tentativeIfDirect === true)
+            || (!eventTaskId && !sessionHasActiveAssignment(args.meshId, sessionId));
         if (!leaveDirectDispatchActive) {
             // CANON-B: flip the exact dispatch row the completion echoed its taskId for; the
             // session_id fallback (no echoed taskId) still covers legacy/relayed workers.
@@ -1958,7 +1967,15 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
             // sibling must keep that row 'dispatched' so its own confirm can match it; acking
             // by session would mark it 'acked' prematurely and hide a genuine non-delivery.
             const startedTaskId = readNonEmptyString(args.metadataEvent.taskId) || undefined;
-            updateDirectDispatchStatus(args.meshId, sessionId, 'acked', startedTaskId);
+            // WARMUPGAP: only ack a dispatch row when the event names its task, or the session
+            // currently holds an active assignment. A no-taskId generating_started from an
+            // unassigned session is a pre-assignment warmup — the session_id fallback would ack a
+            // sibling/stale dispatch row this event does not own, marking it 'acked' prematurely and
+            // hiding a genuine non-delivery. Skip the dispatch ack for that ghost case (the delivery
+            // acks below are bound to actual deliveries and stay a no-op for a warmup session).
+            if (startedTaskId || sessionHasActiveAssignment(args.meshId, sessionId)) {
+                updateDirectDispatchStatus(args.meshId, sessionId, 'acked', startedTaskId);
+            }
             const activeDeliveries = ((): { id: string; taskId: string | null }[] => {
                 try { return MeshRuntimeStore.getInstance().getActiveSessionDeliveries(args.meshId, sessionId); }
                 catch { return []; }

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

@@ -19,6 +19,7 @@
 'use strict';
 
 import { FsmDriver, type DashboardEvent, type ISpecDriver } from './fsm-driver.js';
+import { lastContiguousNumberedBlock } from './evaluator.js';
 import { executeNativeHistory } from './native-history-executor.js';
 import * as fs from 'node:fs';
 import type { NativeHistoryConfig, Control, ControlAction } from './types.js';
@@ -521,21 +522,27 @@ export class SpecCliAdapter implements CliAdapter {
         const ec = action.extract_choices;
         if (!ec?.pattern) return [];
         const text = this.readScreenSectionText(ec.section);
-        const out: Array<{ index: number; label: string; current: boolean }> = [];
-        const seen = new Set<number>();
+        // Collect EVERY matching line in screen order with no top-down de-dup.
+        // The picker section can include conversation history above it (a stray
+        // "1./2./3." list, blockquote `>` lines); a `seen.has(idx)` first-wins
+        // scan would let those body lines claim the option indices and shadow
+        // the real choices — committing the wrong model under arrow-key nav.
+        const all: Array<{ index: number; label: string; current: boolean }> = [];
         for (const rawLine of text.split('\n')) {
             const line = rawLine.replace(/\r$/, '');
             const m = new RegExp(ec.pattern, ec.flags ?? '').exec(line);
             if (!m) continue;
             const idx = Number(m[1]);
-            if (!Number.isFinite(idx) || seen.has(idx)) continue;
+            if (!Number.isFinite(idx) || idx <= 0) continue;
             const label = (m[2] ?? '').replace(/\s+/g, ' ').trim();
             if (!label) continue;
             const current = /^\s*[❯›>]/.test(line) || /[✔✓●]\s*$/.test(label);
-            seen.add(idx);
-            out.push({ index: idx, label, current });
+            all.push({ index: idx, label, current });
         }
-        return out;
+        // Real options are the bottom-most contiguous numbered block; this also
+        // confines the `current` cursor flag to that block so a body `>` line is
+        // never mistaken for the cursor row.
+        return lastContiguousNumberedBlock(all);
     }
 
     /** Live text of a named screen section (or the whole screen when no

package/src/providers/spec/evaluator.ts

@@ -338,7 +338,10 @@ export function extractButtonsFromRule(
                 label += ' ' + next.trim();
                 j += 1;
             }
-            if (buttons.some(b => b.index === idx)) continue;
+            // No top-down de-dup here: a stray body "1." above the modal would
+            // otherwise claim the index and shadow the real choice. Collect
+            // every match in screen order and let lastContiguousNumberedBlock
+            // pick the bottom-most option block below.
             const key = keyTemplate.replace(/\{index\}/g, String(idx));
             buttons.push({ index: idx, label, key, current });
             i = j - 1;
@@ -350,17 +353,51 @@ export function extractButtonsFromRule(
             const idx = Number(m[1]);
             const label = String(m[2] ?? '').trim();
             if (!Number.isFinite(idx) || idx <= 0 || !label) continue;
-            if (buttons.some(b => b.index === idx)) continue;
             const key = keyTemplate.replace(/\{index\}/g, String(idx));
             // 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.
+            // Like the continuation path, no top-down de-dup — body numbered
+            // lines are filtered out by the bottom-block selection below.
             buttons.push({ index: idx, label, key, current: hasCursorMarker(m[0]) });
         }
     }
 
-    buttons.sort((a, b) => a.index - b.index);
-    return buttons;
+    // Buttons were collected in screen (top→bottom) order. The real choices are
+    // the bottom-most contiguous numbered block (the modal/picker always renders
+    // them last); reduce to that block so conversation-history numbered lists
+    // pulled into the modal section can never be mistaken for options.
+    const block = lastContiguousNumberedBlock(buttons);
+    block.sort((a, b) => a.index - b.index);
+    return block;
+}
+
+/**
+ * Reduce a top→bottom-ordered list of parsed numbered entries to only the
+ * bottom-most contiguous block — the run whose indices descend by exactly 1
+ * scanning upward from the last entry.
+ *
+ * Picker and approval choices always render as the LAST contiguous numbered
+ * block at the bottom of the modal section. The conversation history above can
+ * carry its own stray "1./2./3." numbered lists (and blockquote `>` lines), and
+ * because section anchoring can pull body lines into the modal section, a naive
+ * top-down scan would bind the low option indices to those body lines and drop
+ * the real choices (the dashboard would show, and an arrow-key picker would
+ * commit, the wrong row). Selecting the bottom block makes the on-screen picker
+ * win regardless of body content. Since pickers number their options 1..N
+ * contiguously and bodies use indices ≥ 1, the upward chain always breaks the
+ * moment it would need a "0." above the picker's "1." — so the picker block is
+ * isolated cleanly. Entries are assumed already in screen order; the returned
+ * slice keeps that order.
+ */
+export function lastContiguousNumberedBlock<T extends { index: number }>(entries: T[]): T[] {
+    if (entries.length <= 1) return entries.slice();
+    let start = entries.length - 1;
+    for (let i = entries.length - 1; i > 0; i -= 1) {
+        if (entries[i - 1].index === entries[i].index - 1) start = i - 1;
+        else break;
+    }
+    return entries.slice(start);
 }
 
 /** True when a button line carries a TUI cursor marker (`❯`, `›`, `>`) before