@adhdev/daemon-core 0.9.82-rc.293 → 0.9.82-rc.294

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

@@ -132,6 +132,20 @@ export declare class SpecCliAdapter implements CliAdapter {
      */
     private maybeClearResolvedClaudeTuiPrompt;
     private maybeCaptureClaudeTuiPrompt;
+    /**
+     * The TUI prompt is captured on the FIRST frame that renders the
+     * "Enter to select" footer. At that instant the option rows' checkbox
+     * column may not have drawn yet, so `detectClaudeTuiMultiSelect` returns
+     * false and the prompt is frozen as single-select — the dashboard then
+     * renders radio buttons even though the picker is multi-select.
+     *
+     * While the same TUI prompt is still on screen, re-check the live snapshot:
+     * if checkbox glyphs have since appeared, promote any single-select
+     * question to multi-select and re-emit status. Promotion is one-way
+     * (false→true only) — once a question is known multi-select we never demote
+     * it, since the glyph column can scroll out of view on later frames.
+     */
+    private maybeUpgradeClaudeTuiMultiSelect;
     private readClaudeTuiHeaders;
     private captureClaudeTuiPrompt;
     getDebugState(): Record<string, any>;

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

@@ -33,6 +33,25 @@ 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;
 export declare function detectClaudeAskUserQuestionPromptFromTuiPages(pages: ClaudeInteractiveTuiPage[], options: {
     promptId: string;
     providerType?: string;

package/package.json

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

package/src/config/chat-history.ts

@@ -1234,6 +1234,241 @@ function isBoundedTailRequest(limit: number, offset: number, excludeRecentCount:
     return true;
 }
 
+// Byte threshold below which a file is small enough that reading the whole
+// thing is cheaper than seeking. Reverse-seek pays off only on large files.
+const REVERSE_TAIL_SMALL_FILE_BYTES = 64 * 1024;
+// Chunk size for backward reads. We read the file tail one chunk at a time
+// (newest bytes first) until we have collected enough complete lines.
+const REVERSE_TAIL_CHUNK_BYTES = 64 * 1024;
+
+// Per-(file path) incremental tail cache. A hot session's daily JSONL file grows
+// append-only while it generates; the size+mtime signature on the bounded-tail
+// read cache therefore invalidates on every append and forces a full re-read.
+// Here we keep the most recently decoded tail LINES for a file plus the byte
+// length we read them from. When the file has only grown (append-only: size
+// increased, the previously-read prefix is unchanged) we read just the new bytes
+// from `size` onward and splice them onto the retained tail — no full re-parse.
+// Truncation/rotation (size shrank, or a fresh inode) drops the entry and falls
+// back to a full reverse-seek.
+interface IncrementalTailCacheEntry {
+    // File length (bytes) we have already consumed into `lines`.
+    size: number;
+    mtimeMs: number;
+    // Decoded complete lines (oldest-first) covering at least the tail window.
+    // Bounded to TAIL_LINES_RETAINED so memory stays flat for huge files.
+    lines: string[];
+    // True when `lines` is the entire file (head reached), so older pages can
+    // trust that nothing precedes the retained window.
+    coversWholeFile: boolean;
+}
+
+// How many trailing lines we retain per file. The bounded-tail caller never
+// asks for more than BOUNDED_TAIL_MAX_LIMIT + slack; keep a generous multiple so
+// repeated reads at the same window are served incrementally.
+const TAIL_LINES_RETAINED = BOUNDED_TAIL_MAX_LIMIT + 2 * BOUNDED_TAIL_SLACK;
+const INCREMENTAL_TAIL_CACHE_MAX_ENTRIES = 64;
+const incrementalTailCache = new Map<string, IncrementalTailCacheEntry>();
+
+function evictIncrementalTailCache(): void {
+    while (incrementalTailCache.size > INCREMENTAL_TAIL_CACHE_MAX_ENTRIES) {
+        const oldest = incrementalTailCache.keys().next().value;
+        if (oldest === undefined) break;
+        incrementalTailCache.delete(oldest);
+    }
+}
+
+// Split a Buffer into complete lines plus a leftover head fragment, partitioning
+// only on the newline byte (0x0A). 0x0A never appears inside a multibyte UTF-8
+// sequence, so decoding each complete byte segment is boundary-safe. The leftover
+// (bytes before the first newline) is returned undecoded so a caller stitching
+// chunks together never splits a multibyte char.
+function splitBufferLines(buf: Buffer): { head: Buffer; lines: string[] } {
+    const lines: string[] = [];
+    let lineEnd = buf.length;
+    let firstNewline = -1;
+    for (let i = buf.length - 1; i >= 0; i--) {
+        if (buf[i] !== 0x0a) continue;
+        if (i + 1 < lineEnd) {
+            lines.push(buf.toString('utf-8', i + 1, lineEnd));
+        }
+        lineEnd = i;
+        firstNewline = i;
+    }
+    // Lines were collected newest-first; restore oldest-first for the segment
+    // that follows the first (lowest-index) newline.
+    lines.reverse();
+    const head = firstNewline >= 0 ? buf.subarray(0, firstNewline) : buf;
+    return { head, lines };
+}
+
+// Read the last bytes of a file, newest-first, until we have at least `needed`
+// complete lines (or reach the start of the file). Returns lines oldest-first and
+// whether the whole file was consumed. Boundary-safe: lines are cut on the
+// newline byte only, so multibyte UTF-8 chars are never split, and a trailing
+// partial line (no terminating newline) is preserved as a complete final line.
+function readReverseTailLines(filePath: string, needed: number): { lines: string[]; coversWholeFile: boolean; size: number; mtimeMs: number } {
+    const fd = fs.openSync(filePath, 'r');
+    try {
+        const stat = fs.fstatSync(fd);
+        const size = stat.size;
+        let position = size;
+        // `carry` holds bytes belonging to a line that straddles the current
+        // chunk boundary (its start is in an older, not-yet-read chunk).
+        let carry: Buffer = Buffer.alloc(0);
+        const collected: string[] = [];
+
+        while (position > 0 && collected.length < needed) {
+            const chunkSize = Math.min(REVERSE_TAIL_CHUNK_BYTES, position);
+            position -= chunkSize;
+            const chunk = Buffer.alloc(chunkSize);
+            fs.readSync(fd, chunk, 0, chunkSize, position);
+            const combined = carry.length ? Buffer.concat([chunk, carry]) : chunk;
+            const { head, lines } = splitBufferLines(combined);
+            // `head` is the (possibly partial) line whose start lies further back;
+            // hold it for the next (older) chunk to complete.
+            carry = head;
+            // `lines` are oldest-first within this combined buffer; prepend them
+            // ahead of what we already collected (which is strictly newer).
+            for (let i = lines.length - 1; i >= 0; i--) {
+                collected.push(lines[i]);
+            }
+        }
+
+        const reachedStart = position <= 0;
+        if (reachedStart && carry.length) {
+            // Leftover head at the start of the file is itself a complete line.
+            collected.push(carry.toString('utf-8'));
+        }
+        // `collected` is newest-first; restore oldest-first.
+        collected.reverse();
+        return { lines: collected, coversWholeFile: reachedStart, size, mtimeMs: stat.mtimeMs };
+    } finally {
+        fs.closeSync(fd);
+    }
+}
+
+// Return the tail lines (oldest-first) for a single history file, reading as
+// little of the file as possible. Strategy:
+//   - Small files: one readFileSync (seeking is not worth the syscalls).
+//   - Large files: reverse byte-seek for the newest `needed` lines.
+//   - Append-only growth since the last read: read only the appended bytes and
+//     splice them onto the retained tail (no full re-parse) — this is what keeps
+//     a hot, still-generating session cheap to poll.
+// `needed` is a soft floor; we may return more (whole small files / retained
+// window). Lines include any trailing partial (unterminated) final line.
+function readFileTailLines(filePath: string, needed: number): { lines: string[]; coversWholeFile: boolean } {
+    let stat: fs.Stats;
+    try {
+        stat = fs.statSync(filePath);
+    } catch {
+        return { lines: [], coversWholeFile: true };
+    }
+    const size = stat.size;
+    const mtimeMs = stat.mtimeMs;
+    if (size === 0) {
+        incrementalTailCache.delete(filePath);
+        return { lines: [], coversWholeFile: true };
+    }
+
+    const cached = incrementalTailCache.get(filePath);
+    if (cached) {
+        if (cached.size === size && cached.mtimeMs === mtimeMs) {
+            // Unchanged since last read — reuse retained tail. Refresh LRU.
+            incrementalTailCache.delete(filePath);
+            incrementalTailCache.set(filePath, cached);
+            if (cached.coversWholeFile || cached.lines.length >= needed) {
+                return { lines: cached.lines, coversWholeFile: cached.coversWholeFile };
+            }
+            // Retained window is smaller than this request needs; fall through
+            // to a fresh reverse-seek for the larger window.
+        } else if (size > cached.size) {
+            // Append-only growth: the prefix [0, cached.size) is assumed
+            // unchanged (JSONL is append-only). Read just the new bytes and
+            // stitch them — but verify the byte at cached.size-1 is still the
+            // newline that terminated our last retained line, so a rewrite that
+            // happens to grow the file (compaction) is detected and rejected.
+            const incremental = tryIncrementalTailGrowth(filePath, cached, size, mtimeMs, needed);
+            if (incremental) return { lines: incremental.lines, coversWholeFile: incremental.coversWholeFile };
+        }
+        // size shrank (truncation/rotation) or incremental failed → drop & reload.
+        incrementalTailCache.delete(filePath);
+    }
+
+    if (size <= REVERSE_TAIL_SMALL_FILE_BYTES) {
+        let content: string;
+        try {
+            content = fs.readFileSync(filePath, 'utf-8');
+        } catch {
+            return { lines: [], coversWholeFile: true };
+        }
+        const lines = content.split('\n');
+        // A trailing newline yields a final empty element; drop only that one so
+        // an unterminated partial last line is still preserved.
+        if (lines.length && lines[lines.length - 1] === '') lines.pop();
+        storeIncrementalTailCache(filePath, size, mtimeMs, lines, true);
+        return { lines, coversWholeFile: true };
+    }
+
+    let result: { lines: string[]; coversWholeFile: boolean; size: number; mtimeMs: number };
+    try {
+        result = readReverseTailLines(filePath, needed);
+    } catch {
+        return { lines: [], coversWholeFile: true };
+    }
+    storeIncrementalTailCache(filePath, result.size, result.mtimeMs, result.lines, result.coversWholeFile);
+    return { lines: result.lines, coversWholeFile: result.coversWholeFile };
+}
+
+// Read appended bytes [cached.size, size) and splice them onto the retained tail.
+// Returns null if the prior byte is not a newline (the retained tail did not end
+// on a record boundary, e.g. the file was rewritten) so the caller can full-reload.
+function tryIncrementalTailGrowth(
+    filePath: string,
+    cached: IncrementalTailCacheEntry,
+    size: number,
+    mtimeMs: number,
+    needed: number,
+): { lines: string[]; coversWholeFile: boolean } | null {
+    const fd = fs.openSync(filePath, 'r');
+    try {
+        // Confirm the byte ending the previously-read prefix is still a newline.
+        if (cached.size > 0) {
+            const boundary = Buffer.alloc(1);
+            fs.readSync(fd, boundary, 0, 1, cached.size - 1);
+            if (boundary[0] !== 0x0a) return null;
+        }
+        const appendedLength = size - cached.size;
+        const appended = Buffer.alloc(appendedLength);
+        fs.readSync(fd, appended, 0, appendedLength, cached.size);
+        const newLines = appended.toString('utf-8').split('\n');
+        if (newLines.length && newLines[newLines.length - 1] === '') newLines.pop();
+        const merged = cached.lines.concat(newLines);
+        // Keep memory flat: retain only the trailing window.
+        const trimmed = merged.length > TAIL_LINES_RETAINED
+            ? merged.slice(merged.length - TAIL_LINES_RETAINED)
+            : merged;
+        const coversWholeFile = cached.coversWholeFile && trimmed.length === merged.length;
+        storeIncrementalTailCache(filePath, size, mtimeMs, trimmed, coversWholeFile);
+        if (coversWholeFile || trimmed.length >= needed) {
+            return { lines: trimmed, coversWholeFile };
+        }
+        // Should not happen (we only grew), but be safe.
+        return { lines: trimmed, coversWholeFile };
+    } catch {
+        return null;
+    } finally {
+        fs.closeSync(fd);
+    }
+}
+
+function storeIncrementalTailCache(filePath: string, size: number, mtimeMs: number, lines: string[], coversWholeFile: boolean): void {
+    const retained = lines.length > TAIL_LINES_RETAINED ? lines.slice(lines.length - TAIL_LINES_RETAINED) : lines;
+    const covers = coversWholeFile && retained.length === lines.length;
+    incrementalTailCache.delete(filePath);
+    incrementalTailCache.set(filePath, { size, mtimeMs, lines: retained, coversWholeFile: covers });
+    evictIncrementalTailCache();
+}
+
 // Read newest-first only as many files as needed to cover the requested window
 // plus slack. listHistoryFiles already returns files reversed (newest-first), so
 // we accumulate (de-duped) candidates from the end and stop once we have enough,
@@ -1250,19 +1485,22 @@ function readBoundedTailRecords(
 
     for (let f = 0; f < files.length; f++) {
         const filePath = path.join(dir, files[f]);
-        let content: string;
-        try {
-            content = fs.readFileSync(filePath, 'utf-8');
-        } catch {
-            continue;
-        }
-        const lines = content.trim().split('\n').filter(Boolean);
-        // Walk this file's lines newest-first so we fill the tail window from the
-        // bottom. seen-dedup keeps the same first-wins-by-newest semantics the
+        // Read only the file tail needed to top up the window — for a large
+        // single-day file this seeks the last `needed` lines instead of parsing
+        // the whole file. We re-derive the per-file floor each iteration from how
+        // many records are still missing (plus slack so dedup at the boundary is
+        // stable), capped at `needed`.
+        const remaining = Math.max(0, needed - collected.length);
+        const perFileNeeded = Math.min(needed, remaining + BOUNDED_TAIL_SLACK);
+        const { lines, coversWholeFile } = readFileTailLines(filePath, perFileNeeded);
+        // Walk this file's tail lines newest-first so we fill the tail window from
+        // the bottom. seen-dedup keeps the same first-wins-by-newest semantics the
         // full read produced (files are processed newest-first there too).
         for (let i = lines.length - 1; i >= 0; i--) {
+            const line = lines[i];
+            if (!line) continue;
             try {
-                const parsed = JSON.parse(lines[i]) as HistoryMessage;
+                const parsed = JSON.parse(line) as HistoryMessage;
                 const sanitizedMessage = sanitizeHistoryMessage(agentType, parsed);
                 if (!sanitizedMessage) continue;
                 const hash = buildHistoryMessageHash(agentType, sanitizedMessage);
@@ -1271,6 +1509,13 @@ function readBoundedTailRecords(
                 collected.push(sanitizedMessage);
             } catch { /* skip invalid lines */ }
         }
+        // If we only read this file's tail (its head was not reached), older
+        // messages remain within this very file — the conversation is NOT fully
+        // represented even if this is the last file, so hasMore must stay true.
+        if (!coversWholeFile) {
+            readAllFiles = false;
+            break;
+        }
         // Stop once we have the window AND there is at least one more file (so a
         // potential older boundary message exists). If this is the last file we
         // fall through and mark the whole history as read.

package/src/mesh/coordinator-prompt.ts

@@ -384,6 +384,7 @@ function buildRulesSection(coordinatorCliType?: string): string {
 - **Verify via git, not source.** Use \`mesh_git_status\` to confirm side effects. Treat agent summaries as self-reports, not verification.
 - **Limit parallelism.** Start with 1–2 tasks; scale only on success. Never duplicate a session because \`mesh_read_chat\` shows no final message while tool/terminal activity is ongoing. This caps *concurrent* load — it does not mean serialize independent work: when a new, independent request arrives and there is headroom under \`maxParallelTasks\`, dispatch it right away rather than waiting for an in-flight task or a user nudge (read-only diagnosis especially, since it has no merge cost).
 - **Check history first.** Call \`mesh_task_history\` at session start to avoid duplicate work and inform recovery. On failure, read task history before retrying.
+- **Sequence shared-base-moving merges.** Parallel dispatch is encouraged, but merging one worktree can advance another in-flight worktree's base — especially the oss submodule pointer — turning a clean fast-forward into a diverged rebase (patch-equivalence correctly blocks this). Before merging an in-flight worktree while siblings are also in flight, land in an intentional order, re-clone long-running worktrees from the advanced base, or expect to manually rebase + ff-only the laggards; merging an independent fix mid-flight can strand siblings into a rebase.
 - **Converge branches.** After worktree tasks: refine/fast-forward, or classify as \`pushed_feature_branch_needs_merge\` / \`blocked_review\` / \`cleanup_candidate\` / \`not_mergeable\`. Clean up with \`mesh_remove_node\`.
 - **Refinery is config-driven.** \`mesh_refine_node\` must run validation from \`.adhdev/refine.{json,yaml,yml}\` or \`repo-mesh.refine.*\`. Heuristics are scaffolding only.
 - **Submodule reachability = publish-needed.** \`submodule_reachability_failed\` → classify as \`blocked_review\`, request user approval to push to submodule main, then rerun \`mesh_refine_node\`.

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

@@ -37,6 +37,18 @@ type PersistableCliHistoryMessage = {
     receivedAt?: number;
 };
 
+// Status snapshots only ever surface the newest messages: the cloud 'live'
+// profile drops chat messages entirely (loaded lazily via read_chat on
+// subscribe) and the 'full' profile caps activeChat.messages to the last 60
+// (see status/normalize.ts). Unread/completion markers walk only the tail.
+// So getState()'s saved-history hydration — which runs once per resume/manual
+// CLI session on every status report — must read only a bounded tail, not the
+// entire transcript. A full MAX_SAFE_INTEGER read here makes the initial
+// status report O(transcript) × N(sessions), which is the real cold first-
+// connection bottleneck on chat-heavy machines. The window comfortably exceeds
+// the 60-message snapshot cap so dedup/collapse at the boundary stays stable.
+const STATUS_HYDRATION_TAIL_LIMIT = 200;
+
 type CompletedDebouncePending = {
     chatTitle: string;
     duration: number;
@@ -2190,13 +2202,21 @@ export class CliProviderInstance implements ProviderInstance {
         return newestMessageAt === 0;
     }
 
-    private syncCanonicalSavedHistoryIfNeeded(): boolean {
+    private syncCanonicalSavedHistoryIfNeeded(options: { full?: boolean } = {}): boolean {
         if (!this.providerSessionId) return false;
         const canonicalHistory = this.provider.nativeHistory;
         if (!canonicalHistory) return false;
 
+        // Per-status-report hydration reads only a bounded tail (snapshot needs at
+        // most the newest 60). The once-per-resume restore path passes full:true
+        // because seedSessionHistory needs the COMPLETE transcript to seed dedup
+        // state. The read-cache key encodes the window so the bounded and full
+        // reads don't share/clobber each other's 2s cache entry.
+        const limit = options.full ? Number.MAX_SAFE_INTEGER : STATUS_HYDRATION_TAIL_LIMIT;
+        const windowTag = options.full ? 'full' : `tail:${STATUS_HYDRATION_TAIL_LIMIT}`;
+
         if (isNativeSourceCanonicalHistory(canonicalHistory)) {
-            const cacheKey = [this.type, this.providerSessionId, this.workingDir].join('\0');
+            const cacheKey = [this.type, this.providerSessionId, this.workingDir, windowTag].join('\0');
             const now = Date.now();
             if (cacheKey === this.lastNativeSourceCanonicalCacheKey && now - this.lastNativeSourceCanonicalCheckAt < 2_000) {
                 return true;
@@ -2209,7 +2229,7 @@ export class CliProviderInstance implements ProviderInstance {
                 historySessionId: this.providerSessionId,
                 workspace: this.workingDir,
                 offset: 0,
-                limit: Number.MAX_SAFE_INTEGER,
+                limit,
                 historyBehavior: this.provider.historyBehavior,
                 scripts: this.provider.scripts as any,
             });
@@ -2226,7 +2246,7 @@ export class CliProviderInstance implements ProviderInstance {
         }
 
         try {
-            const cacheKey = [this.type, this.providerSessionId, this.workingDir, canonicalHistory.mode || 'materialized-mirror'].join('\0');
+            const cacheKey = [this.type, this.providerSessionId, this.workingDir, canonicalHistory.mode || 'materialized-mirror', windowTag].join('\0');
             const now = Date.now();
             if (cacheKey === this.lastNativeSourceCanonicalCacheKey && now - this.lastNativeSourceCanonicalCheckAt < 2_000) {
                 return true;
@@ -2237,15 +2257,14 @@ export class CliProviderInstance implements ProviderInstance {
             if (!materializeProviderNativeHistory(this.type, canonicalHistory, this.providerSessionId, this.workingDir, this.provider.scripts as any)) {
                 return false;
             }
-            // Full read is intentional: lastPersistedHistoryMessages is the COMPLETE
-            // session transcript — emitted as statusMessages and used as the
-            // prefix-comparison base for incremental appends — so a bounded tail
-            // would both truncate output and break prefix dedup. This is gated to
-            // once-per-2s (cache key above) for resume/manual launches only, so it
-            // does not run on the per-subscribe/per-poll dashboard tail path (that
-            // path goes through handleReadChat → readChatHistory with a bounded
-            // tailLimit, which is now O(tail)).
-            const restoredHistory = readChatHistory(this.type, 0, Number.MAX_SAFE_INTEGER, this.providerSessionId, 0, this.provider.historyBehavior);
+            // Bounded by default: the per-status-report path only needs the newest
+            // STATUS_HYDRATION_TAIL_LIMIT messages because the snapshot caps
+            // activeChat.messages to the last 60 (status/normalize.ts) and loads
+            // the rest lazily via read_chat on subscribe. The once-per-resume
+            // restore path passes full:true so seedSessionHistory still sees the
+            // COMPLETE transcript for prefix-dedup seeding. readChatHistory serves
+            // a bounded limit as an O(tail) read.
+            const restoredHistory = readChatHistory(this.type, 0, limit, this.providerSessionId, 0, this.provider.historyBehavior);
             this.lastPersistedHistoryMessages = restoredHistory.messages.map((message) => ({
                 role: message.role,
                 content: message.content,
@@ -2261,7 +2280,10 @@ export class CliProviderInstance implements ProviderInstance {
 
     private restorePersistedHistoryFromCurrentSession(): void {
         if (!this.providerSessionId) return;
-        this.syncCanonicalSavedHistoryIfNeeded();
+        // Restore is the once-per-resume seeding path: it needs the COMPLETE
+        // transcript so seedSessionHistory can prime dedup state. Pass full so the
+        // hydration read is unbounded here (and only here).
+        this.syncCanonicalSavedHistoryIfNeeded({ full: true });
         const restoredHistory = isNativeSourceCanonicalHistory(this.provider.nativeHistory)
             ? readProviderChatHistory(this.type, {
                 canonicalHistory: this.provider.nativeHistory,

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

@@ -31,6 +31,7 @@ import {
     buildClaudeInteractiveToolResult,
     detectClaudeAskUserQuestionPromptFromJson,
     detectClaudeAskUserQuestionPromptFromTuiPages,
+    detectClaudeTuiMultiSelect,
     type ClaudeInteractiveTuiPage,
     type InteractivePrompt,
     type InteractivePromptResponse,
@@ -445,12 +446,14 @@ export class SpecCliAdapter implements CliAdapter {
                 }
                 this.maybeClearResolvedClaudeTuiPrompt();
                 this.maybeCaptureClaudeTuiPrompt();
+                this.maybeUpgradeClaudeTuiMultiSelect();
                 this.statusCallback?.();
                 return;
             case 'pty_data':
                 this.detectInteractivePromptFromPtyChunk(ev.chunk);
                 this.maybeClearResolvedClaudeTuiPrompt();
                 this.maybeCaptureClaudeTuiPrompt();
+                this.maybeUpgradeClaudeTuiMultiSelect();
                 try { this.ptyDataCallback?.(ev.chunk); } catch { /* ignore */ }
                 return;
             case 'exit':
@@ -614,6 +617,43 @@ export class SpecCliAdapter implements CliAdapter {
         });
     }
 
+    /**
+     * The TUI prompt is captured on the FIRST frame that renders the
+     * "Enter to select" footer. At that instant the option rows' checkbox
+     * column may not have drawn yet, so `detectClaudeTuiMultiSelect` returns
+     * false and the prompt is frozen as single-select — the dashboard then
+     * renders radio buttons even though the picker is multi-select.
+     *
+     * While the same TUI prompt is still on screen, re-check the live snapshot:
+     * if checkbox glyphs have since appeared, promote any single-select
+     * question to multi-select and re-emit status. Promotion is one-way
+     * (false→true only) — once a question is known multi-select we never demote
+     * it, since the glyph column can scroll out of view on later frames.
+     */
+    private maybeUpgradeClaudeTuiMultiSelect(): void {
+        if (this.cliType !== 'claude-cli'
+            || this.interactivePromptTransport !== 'tui'
+            || !this.activeInteractivePrompt) return;
+        const questions = this.activeInteractivePrompt.questions;
+        // The live snapshot only shows the CURRENTLY focused question's rows, so
+        // we can only attribute the glyphs to a specific question when there is
+        // exactly one. Multi-question prompts are tab-captured per page at
+        // capture time and aren't re-evaluated here to avoid cross-contaminating
+        // a mixed single/multi prompt.
+        if (questions.length !== 1) return;
+        if (questions[0].multiSelect) return;
+        let screenText = '';
+        try {
+            screenText = this.driver.snapshot();
+        } catch {
+            return;
+        }
+        if (!screenText.includes('Enter to select')) return;
+        if (!detectClaudeTuiMultiSelect(screenText)) return;
+        questions[0].multiSelect = true;
+        this.statusCallback?.();
+    }
+
     private readClaudeTuiHeaders(screenText: string): string[] {
         const navLine = screenText.split(/\r?\n/).find(line => line.includes('✔ Submit') && /[☐☒]/.test(line));
         if (!navLine) return [];

package/src/providers/types/interactive-prompt.ts

@@ -180,7 +180,7 @@ function isClaudeTuiSelectFooter(text: string): boolean {
  * broadened footer patterns ("Space to", "toggle", "select multiple") are kept
  * as a secondary signal for layouts that render markers differently.
  */
-function detectClaudeTuiMultiSelect(screenText: string): boolean {
+export function detectClaudeTuiMultiSelect(screenText: string): boolean {
   if (/Space to (?:select|toggle)|toggle selection|select multiple|select all that apply/i.test(screenText)) {
     return true;
   }