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

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

@@ -118,6 +118,15 @@ export declare class SpecCliAdapter implements CliAdapter {
      * spirit as the approval FSM's `approvalCooldown` modal-lost hysteresis.
      */
     private static readonly INTERACTIVE_PROMPT_LOST_GRACE_MS;
+    /**
+     * Multi-question TUI capture: after Tabbing to a page, re-snapshot at this
+     * interval until its checkbox glyph column has settled, up to the timeout.
+     * The interval matches the legacy single fixed wait (120ms); the timeout
+     * bounds total capture time so a single-select page (which never shows
+     * glyphs) doesn't stall the capture indefinitely.
+     */
+    private static readonly CLAUDE_TUI_PAGE_POLL_INTERVAL_MS;
+    private static readonly CLAUDE_TUI_PAGE_SETTLE_TIMEOUT_MS;
     /**
      * Clear a held interactive prompt once the user has resolved it directly
      * in the terminal (the choice picker leaves the screen without going
@@ -144,9 +153,32 @@ export declare class SpecCliAdapter implements CliAdapter {
      * 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.
+     *
+     * For MULTI-question prompts the per-page Tab capture is the actual source
+     * of the bug: pages 2..N are snapshotted ~120ms after the Tab keypress,
+     * before their option-row glyph column has redrawn, so those questions
+     * freeze as single-select while page 1 (already settled) is correct. We
+     * cannot upgrade blindly — the live snapshot shows only ONE focused page —
+     * but we CAN read that page's question text/header and upgrade the matching
+     * question. As the user navigates the picker (or it settles), each page is
+     * eventually re-read and repaired.
      */
     private maybeUpgradeClaudeTuiMultiSelect;
     private readClaudeTuiHeaders;
+    /**
+     * Snapshot the currently-focused claude TUI page, polling until its
+     * option-row checkbox glyph column has settled (or a bounded timeout).
+     *
+     * Why poll: right after a Tab keypress the newly-focused page's glyph
+     * column has not redrawn yet, so an immediate snapshot shows the question +
+     * option labels but NO per-option checkbox markers — freezing that page as
+     * single-select. A fixed delay either races (too short) or is wasteful (too
+     * long). Instead we re-snapshot at a fixed interval and stop as soon as the
+     * frame shows multi-select glyphs, falling back to the last frame at the
+     * timeout. Single-select pages never show glyphs, so they always poll to the
+     * timeout — bounded small to keep capture snappy.
+     */
+    private snapshotSettledClaudeTuiPage;
     private captureClaudeTuiPrompt;
     getDebugState(): Record<string, any>;
     getTraceState(limit?: number): Record<string, any>;

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

@@ -52,6 +52,23 @@ export interface ClaudeInteractiveTuiPage {
  * as a secondary signal for layouts that render markers differently.
  */
 export declare function detectClaudeTuiMultiSelect(screenText: string): boolean;
+/**
+ * Read the question the live claude TUI picker is CURRENTLY focused on, plus
+ * whether that focused page renders multi-select checkbox markers.
+ *
+ * Used to repair a multi-question prompt after the fact: when the daemon
+ * Tab-captures pages 2..N it snapshots ~120ms after the Tab keypress, before
+ * the newly-focused page's option-row checkbox column has redrawn — so those
+ * questions get frozen as multiSelect:false even though the picker is
+ * multi-select. Re-reading the focused page on a later status tick (once it has
+ * settled) lets us attribute the now-visible glyphs to the matching question
+ * and upgrade just that one. Returns null when no picker question is on screen.
+ */
+export declare function readFocusedClaudeTuiQuestion(screenText: string): {
+    question: string;
+    header?: string;
+    multiSelect: boolean;
+} | null;
 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.294",
+  "version": "0.9.82-rc.296",
   "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.294",
+    "@adhdev/mesh-shared": "0.9.82-rc.296",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

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

@@ -32,6 +32,7 @@ import {
     detectClaudeAskUserQuestionPromptFromJson,
     detectClaudeAskUserQuestionPromptFromTuiPages,
     detectClaudeTuiMultiSelect,
+    readFocusedClaudeTuiQuestion,
     type ClaudeInteractiveTuiPage,
     type InteractivePrompt,
     type InteractivePromptResponse,
@@ -551,6 +552,16 @@ export class SpecCliAdapter implements CliAdapter {
      */
     private static readonly INTERACTIVE_PROMPT_LOST_GRACE_MS = 1500;
 
+    /**
+     * Multi-question TUI capture: after Tabbing to a page, re-snapshot at this
+     * interval until its checkbox glyph column has settled, up to the timeout.
+     * The interval matches the legacy single fixed wait (120ms); the timeout
+     * bounds total capture time so a single-select page (which never shows
+     * glyphs) doesn't stall the capture indefinitely.
+     */
+    private static readonly CLAUDE_TUI_PAGE_POLL_INTERVAL_MS = 120;
+    private static readonly CLAUDE_TUI_PAGE_SETTLE_TIMEOUT_MS = 600;
+
     /**
      * Clear a held interactive prompt once the user has resolved it directly
      * in the terminal (the choice picker leaves the screen without going
@@ -629,19 +640,22 @@ export class SpecCliAdapter implements CliAdapter {
      * 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.
+     *
+     * For MULTI-question prompts the per-page Tab capture is the actual source
+     * of the bug: pages 2..N are snapshotted ~120ms after the Tab keypress,
+     * before their option-row glyph column has redrawn, so those questions
+     * freeze as single-select while page 1 (already settled) is correct. We
+     * cannot upgrade blindly — the live snapshot shows only ONE focused page —
+     * but we CAN read that page's question text/header and upgrade the matching
+     * question. As the user navigates the picker (or it settles), each page is
+     * eventually re-read and repaired.
      */
     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;
+        if (questions.every(q => q.multiSelect)) return;
         let screenText = '';
         try {
             screenText = this.driver.snapshot();
@@ -649,8 +663,25 @@ export class SpecCliAdapter implements CliAdapter {
             return;
         }
         if (!screenText.includes('Enter to select')) return;
-        if (!detectClaudeTuiMultiSelect(screenText)) return;
-        questions[0].multiSelect = true;
+
+        if (questions.length === 1) {
+            if (questions[0].multiSelect) return;
+            if (!detectClaudeTuiMultiSelect(screenText)) return;
+            questions[0].multiSelect = true;
+            this.statusCallback?.();
+            return;
+        }
+
+        // Multi-question: attribute the focused page's glyphs to its question by
+        // matching header (preferred) or question text, then upgrade just that
+        // one. Never demote — a settled non-multi page is left as captured.
+        const focused = readFocusedClaudeTuiQuestion(screenText);
+        if (!focused || !focused.multiSelect) return;
+        const match = questions.find(q =>
+            (focused.header && q.header && q.header === focused.header)
+            || q.question === focused.question);
+        if (!match || match.multiSelect) return;
+        match.multiSelect = true;
         this.statusCallback?.();
     }
 
@@ -665,16 +696,53 @@ export class SpecCliAdapter implements CliAdapter {
         return headers;
     }
 
+    /**
+     * Snapshot the currently-focused claude TUI page, polling until its
+     * option-row checkbox glyph column has settled (or a bounded timeout).
+     *
+     * Why poll: right after a Tab keypress the newly-focused page's glyph
+     * column has not redrawn yet, so an immediate snapshot shows the question +
+     * option labels but NO per-option checkbox markers — freezing that page as
+     * single-select. A fixed delay either races (too short) or is wasteful (too
+     * long). Instead we re-snapshot at a fixed interval and stop as soon as the
+     * frame shows multi-select glyphs, falling back to the last frame at the
+     * timeout. Single-select pages never show glyphs, so they always poll to the
+     * timeout — bounded small to keep capture snappy.
+     */
+    private async snapshotSettledClaudeTuiPage(): Promise<string> {
+        let screenText = this.driver.snapshot();
+        const deadline = Date.now() + SpecCliAdapter.CLAUDE_TUI_PAGE_SETTLE_TIMEOUT_MS;
+        while (!detectClaudeTuiMultiSelect(screenText) && Date.now() < deadline) {
+            await new Promise(resolve => setTimeout(resolve, SpecCliAdapter.CLAUDE_TUI_PAGE_POLL_INTERVAL_MS));
+            screenText = this.driver.snapshot();
+        }
+        return screenText;
+    }
+
     private async captureClaudeTuiPrompt(firstScreen: string, headers: string[]): Promise<void> {
         const pages: ClaudeInteractiveTuiPage[] = [{ screenText: firstScreen, header: headers[0] }];
+        // Forward pass: Tab to each page 2..N and snapshot once its glyph column
+        // has settled, so pages 2+ capture their checkbox markers (not a racy
+        // pre-redraw frame).
         for (let index = 1; index < headers.length; index += 1) {
             this.driver.dispatch({ kind: 'pty_write', data: '\t' });
-            await new Promise(resolve => setTimeout(resolve, 120));
-            pages.push({ screenText: this.driver.snapshot(), header: headers[index] });
+            await new Promise(resolve => setTimeout(resolve, SpecCliAdapter.CLAUDE_TUI_PAGE_POLL_INTERVAL_MS));
+            pages.push({ screenText: await this.snapshotSettledClaudeTuiPage(), header: headers[index] });
         }
+        // Return pass: Shift-Tab back through pages N..2. As we land on each page
+        // again re-read it and OR-in any now-visible multi-select glyphs — a
+        // second chance to repair a page whose forward-pass frame was still racy.
         for (let index = headers.length - 1; index > 0; index -= 1) {
             this.driver.dispatch({ kind: 'pty_write', data: '\x1b[Z' });
-            await new Promise(resolve => setTimeout(resolve, 80));
+            await new Promise(resolve => setTimeout(resolve, SpecCliAdapter.CLAUDE_TUI_PAGE_POLL_INTERVAL_MS));
+            const reread = await this.snapshotSettledClaudeTuiPage();
+            // The page we just Shift-Tab'd ONTO is index-1 (we move backwards).
+            const landed = pages[index - 1];
+            if (landed
+                && !detectClaudeTuiMultiSelect(landed.screenText)
+                && detectClaudeTuiMultiSelect(reread)) {
+                landed.screenText = reread;
+            }
         }
 
         const prompt = detectClaudeAskUserQuestionPromptFromTuiPages(pages, {

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

@@ -184,15 +184,19 @@ export function detectClaudeTuiMultiSelect(screenText: string): boolean {
   if (/Space to (?:select|toggle)|toggle selection|select multiple|select all that apply/i.test(screenText)) {
     return true;
   }
-  // A checkbox glyph sitting in front of a NUMBERED option row only appears in
-  // the multi-select picker (e.g. "❯ [ ] 1. TypeScript" / "☐ 2. Python"). We
-  // require the numbered "N." option marker so we don't false-positive on the
-  // `✔ Submit` nav line (per-question answered-state ☐/☒) or on the headerless
-  // variant where the QUESTION line itself begins with `☐ ` (single-select).
-  const optionCheckbox = /^\s*(?:[❯›>]\s*)?(?:\[[ xX]\]|[☐☒◻◼])\s*\d+\.\s+\S/;
+  // A checkbox glyph on a NUMBERED option row only appears in the multi-select
+  // picker. The glyph sits EITHER before the number ("❯ [ ] 1. TypeScript" /
+  // "☐ 2. Python") OR after it ("❯ 1. [ ] 계란말이" — claude-cli >=2.1's layout).
+  // We require the numbered "N." option marker either way so we don't
+  // false-positive on the `✔ Submit` nav line (per-question answered-state
+  // ☐/☒) or on the headerless variant where the QUESTION line itself begins
+  // with `☐ ` (single-select).
+  const optionCheckbox = `(?:\\[[ xX]\\]|[☐☒◻◼])`;
+  const beforeNumber = new RegExp(`^\\s*(?:[❯›>]\\s*)?${optionCheckbox}\\s*\\d+\\.\\s+\\S`);
+  const afterNumber = new RegExp(`^\\s*(?:[❯›>]\\s*)?\\d+\\.\\s*${optionCheckbox}\\s+\\S`);
   for (const line of screenText.split(/\r?\n/)) {
     if (line.includes('✔ Submit')) continue; // header/nav line
-    if (optionCheckbox.test(line)) return true;
+    if (beforeNumber.test(line) || afterNumber.test(line)) return true;
   }
   return false;
 }
@@ -361,6 +365,31 @@ function parseClaudeInteractiveTuiQuestion(page: ClaudeInteractiveTuiPage, index
   };
 }
 
+/**
+ * Read the question the live claude TUI picker is CURRENTLY focused on, plus
+ * whether that focused page renders multi-select checkbox markers.
+ *
+ * Used to repair a multi-question prompt after the fact: when the daemon
+ * Tab-captures pages 2..N it snapshots ~120ms after the Tab keypress, before
+ * the newly-focused page's option-row checkbox column has redrawn — so those
+ * questions get frozen as multiSelect:false even though the picker is
+ * multi-select. Re-reading the focused page on a later status tick (once it has
+ * settled) lets us attribute the now-visible glyphs to the matching question
+ * and upgrade just that one. Returns null when no picker question is on screen.
+ */
+export function readFocusedClaudeTuiQuestion(
+  screenText: string,
+): { question: string; header?: string; multiSelect: boolean } | null {
+  if (!screenText.includes('Enter to select')) return null;
+  const parsed = parseClaudeInteractiveTuiQuestion({ screenText }, 0);
+  if (!parsed) return null;
+  return {
+    question: parsed.question,
+    ...(parsed.header ? { header: parsed.header } : {}),
+    multiSelect: parsed.multiSelect,
+  };
+}
+
 export function detectClaudeAskUserQuestionPromptFromTuiPages(
   pages: ClaudeInteractiveTuiPage[],
   options: { promptId: string; providerType?: string; createdAt?: number },
@@ -392,7 +421,18 @@ export function buildClaudeInteractiveTuiAnswerSteps(
     if (!answer) throw new Error(`Missing answer for ${question.questionId}`);
     const freeformText = answer.freeformText?.trim() ?? '';
 
-    if (question.multiSelect) {
+    // Defensive multi-select fallback: a checkbox picker is the ONLY way an
+    // answer can carry more than one selected label, so treat any such answer
+    // as multi-select even when `question.multiSelect` was captured as false.
+    // This guards the multi-question capture race: pages 2..N can freeze as
+    // single-select (their glyph column hadn't redrawn at Tab-snapshot time),
+    // and the old single-select branch would then either throw on 2+ checked
+    // boxes or emit a bare digit (cursor move, no toggle) for 1 box — silently
+    // dropping that page's selection. Keying off the answer's label count makes
+    // the keystroke protocol correct regardless of the captured flag.
+    const treatAsMultiSelect = question.multiSelect || answer.selectedLabels.length > 1;
+
+    if (treatAsMultiSelect) {
       // Multi-select: Claude TUI renders each option as a checkbox and the
       // footer reads "Space to select". A numeric digit jumps the cursor to
       // that option; Space toggles its checkbox. So for every selected label