@adhdev/daemon-core 0.9.82-rc.260 → 0.9.82-rc.261

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

@@ -26,6 +26,23 @@ export declare class SpecCliAdapter implements CliAdapter {
     private activeInteractivePrompt;
     private interactivePromptTransport;
     private claudeTuiPromptCaptureInFlight;
+    /**
+     * Wall clock of the first frame on which a held interactive prompt was
+     * observed to have left the screen. Mirrors the approval FSM's
+     * `modalLostAt` hysteresis (see cli-state-engine.ts): claude-cli's TUI
+     * repaints the choice picker as several PTY chunks, so a single frame
+     * with no "Enter to select" footer is not proof the prompt is gone — it
+     * may just be mid-repaint. We only clear the held prompt once it has
+     * been absent across a short grace window. Reset to null the moment the
+     * prompt footer reappears.
+     *
+     * Without this, a choice prompt resolved *directly in the terminal* (the
+     * user picked an option without going through ADHDev's
+     * setInteractivePromptResponse) was never cleared from
+     * `activeInteractivePrompt`, so getStatus() re-emitted the same prompt
+     * forever — the choice-resolve-stuck bug.
+     */
+    private interactivePromptLostAt;
     private jsonLineTail;
     private exited;
     private spawned;
@@ -93,6 +110,27 @@ export declare class SpecCliAdapter implements CliAdapter {
     private readCurrentScreenSections;
     private extractProviderSessionIdFromScreen;
     private readClaudeScreenAssistantMessages;
+    /**
+     * Grace window a held interactive prompt must be absent from the screen
+     * before we treat it as resolved-in-terminal and clear it. claude-cli
+     * repaints the picker across multiple PTY chunks, so a single
+     * footer-less frame is not proof the prompt is gone. Sized in the same
+     * spirit as the approval FSM's `approvalCooldown` modal-lost hysteresis.
+     */
+    private static readonly INTERACTIVE_PROMPT_LOST_GRACE_MS;
+    /**
+     * Clear a held interactive prompt once the user has resolved it directly
+     * in the terminal (the choice picker leaves the screen without going
+     * through setInteractivePromptResponse). The approval path already does
+     * this via the FSM's modal-lost hysteresis; the interactive-prompt path
+     * had no equivalent, so a terminal-side answer left activeInteractivePrompt
+     * set and getStatus() re-emitted the same choice modal forever.
+     *
+     * Detection mirrors capture: the claude TUI picker is on-screen exactly
+     * while its "Enter to select" footer is rendered. When the footer is gone
+     * for INTERACTIVE_PROMPT_LOST_GRACE_MS the prompt is genuinely resolved.
+     */
+    private maybeClearResolvedClaudeTuiPrompt;
     private maybeCaptureClaudeTuiPrompt;
     private readClaudeTuiHeaders;
     private captureClaudeTuiPrompt;

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

@@ -82,6 +82,36 @@ export interface DriverHistoryEntry {
     busyHoldMs?: number;
     via?: string;
 }
+/**
+ * A frozen snapshot of the FULL FSM evaluation captured at the instant a
+ * transition fired — the rich `transitions[]` table (per-transition eligible /
+ * hold countdown / per-condition CondResult + remainingMs) that `getFsmDebug()`
+ * otherwise only computes live for the current instant. Kept in a separate ring
+ * buffer from `stateHistory` (which stays intentionally lightweight) so the
+ * "why did this rule fire just before the transition" question is answerable
+ * after the fact. before-only: this is the evaluation that PRODUCED the
+ * transition, not the post-transition state.
+ */
+export interface FsmSnapshotEntry {
+    /** State we transitioned out of. */
+    stateFrom: string;
+    /** State we transitioned into (the fired transition's destination). */
+    stateTo: string;
+    /** Wall-clock time the transition committed (ms). */
+    at: number;
+    /** The fired transition's destination state id (== stateTo; kept explicit
+     *  to mirror the rule that fired). */
+    firedTo: string;
+    /** Human label of the fired transition (e.g. "approval→busy"). */
+    firedLabel: string;
+    /** Why-it-fired summary, same shape produced for stateHistory.matchedRules. */
+    reason: string[];
+    /** Every outgoing transition from `stateFrom` as evaluated at `at`, each
+     *  with its eligible / hold / per-condition CondResult + remainingMs. This
+     *  is the full pre-transition evaluation table — the whole point of the
+     *  snapshot. */
+    transitions: TransitionEval[];
+}
 export interface ISpecDriver {
     subscribe(listener: (ev: DashboardEvent) => void): () => void;
     start(): void;
@@ -108,6 +138,7 @@ export interface ISpecDriver {
         forceAfterMs: number;
     } | null;
     getFsmDebug?(): unknown;
+    getFsmSnapshotHistory?(): ReadonlyArray<FsmSnapshotEntry>;
 }
 export interface SpecDriverOpts {
     specPath: string;
@@ -148,6 +179,10 @@ export declare class FsmDriver implements ISpecDriver {
     private specWatcher;
     /** Last full FSM evaluation, kept for the debugger. */
     private lastFsmEval;
+    /** Ring buffer (max 20) of the full FSM evaluation captured at each
+     *  transition — the rich pre-transition table that lastFsmEval only keeps
+     *  for the single most recent evaluation. Separate from stateHistory. */
+    private fsmSnapshotHistory;
     constructor(opts: SpecDriverOpts);
     subscribe(listener: (ev: DashboardEvent) => void): () => void;
     start(): void;
@@ -172,6 +207,7 @@ export declare class FsmDriver implements ISpecDriver {
         transitions: TransitionEval[];
     };
     getStateHistory(): ReadonlyArray<HistoryEntry>;
+    getFsmSnapshotHistory(): ReadonlyArray<FsmSnapshotEntry>;
     getSections(): Array<{
         id: string;
         text: string;
@@ -194,6 +230,11 @@ export declare class FsmDriver implements ISpecDriver {
     private evalFsmNow;
     private reevaluate;
     private commitTransition;
+    /** Snapshot the full FSM evaluation that produced a transition into the
+     *  separate fsmSnapshotHistory ring buffer (max 20). The transitions[]
+     *  table is captured by reference — it is freshly built per evaluation in
+     *  evaluateFsm and never mutated after, so no clone is needed. */
+    private pushFsmSnapshot;
     /** Re-derive the visible modal + controls for the current state and emit a
      *  state_changed if anything differs from the last emit. */
     private emitStateChanged;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.260",
+  "version": "0.9.82-rc.261",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/providers/spec/adapter.ts

@@ -62,9 +62,16 @@ export class TerminalAdapter {
         this.screenDebounceMs = opts.screenChangeDebounceMs ?? 80;
         this.tickIntervalMs = opts.tickIntervalMs ?? 0;
         // Import NodePtyTransportFactory lazily to avoid loading node-pty in
-        // environments that don't need it (tests, fixture runners).
-        const { NodePtyTransportFactory } = require('../../cli-adapters/pty-transport.js');
-        this.factory = opts.transportFactory ?? new NodePtyTransportFactory();
+        // environments that don't need it (tests, fixture runners) — only when
+        // no transport factory was injected. Doing it unconditionally pulled in
+        // the node-pty module (and broke source-level test runs) even when a
+        // fake factory was supplied.
+        if (opts.transportFactory) {
+            this.factory = opts.transportFactory;
+        } else {
+            const { NodePtyTransportFactory } = require('../../cli-adapters/pty-transport.js');
+            this.factory = new NodePtyTransportFactory();
+        }
         this.screen = new TerminalScreen(this.rows, this.cols);
     }
 

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

@@ -76,6 +76,23 @@ export class SpecCliAdapter implements CliAdapter {
     private activeInteractivePrompt: InteractivePrompt | null = null;
     private interactivePromptTransport: 'stream-json' | 'tui' | null = null;
     private claudeTuiPromptCaptureInFlight = false;
+    /**
+     * Wall clock of the first frame on which a held interactive prompt was
+     * observed to have left the screen. Mirrors the approval FSM's
+     * `modalLostAt` hysteresis (see cli-state-engine.ts): claude-cli's TUI
+     * repaints the choice picker as several PTY chunks, so a single frame
+     * with no "Enter to select" footer is not proof the prompt is gone — it
+     * may just be mid-repaint. We only clear the held prompt once it has
+     * been absent across a short grace window. Reset to null the moment the
+     * prompt footer reappears.
+     *
+     * Without this, a choice prompt resolved *directly in the terminal* (the
+     * user picked an option without going through ADHDev's
+     * setInteractivePromptResponse) was never cleared from
+     * `activeInteractivePrompt`, so getStatus() re-emitted the same prompt
+     * forever — the choice-resolve-stuck bug.
+     */
+    private interactivePromptLostAt: number | null = null;
     private jsonLineTail = '';
     private exited = false;
     private spawned = false;
@@ -380,6 +397,11 @@ export class SpecCliAdapter implements CliAdapter {
             // transition from the current state with its per-condition match
             // result + countdown — the canonical "why isn't it moving" answer.
             fsm: this.driver.getFsmDebug?.() ?? null,
+            // v4 FSM transition snapshot history (null for v3 specs). The full
+            // pre-transition evaluation table captured at each transition —
+            // answers "why did this rule fire" after the fact, unlike the live
+            // `fsm` field which only reflects the current instant.
+            fsmHistory: this.driver.getFsmSnapshotHistory?.() ?? null,
             // Extended fields
             name: this.cliName,
             status: this.getStatus().status,
@@ -421,11 +443,13 @@ export class SpecCliAdapter implements CliAdapter {
                 if (ev.state.title) {
                     LOG.debug('SpecAdapter', `[${this.cliType}] state.title=${JSON.stringify(ev.state.title)}`);
                 }
+                this.maybeClearResolvedClaudeTuiPrompt();
                 this.maybeCaptureClaudeTuiPrompt();
                 this.statusCallback?.();
                 return;
             case 'pty_data':
                 this.detectInteractivePromptFromPtyChunk(ev.chunk);
+                this.maybeClearResolvedClaudeTuiPrompt();
                 this.maybeCaptureClaudeTuiPrompt();
                 try { this.ptyDataCallback?.(ev.chunk); } catch { /* ignore */ }
                 return;
@@ -456,6 +480,7 @@ export class SpecCliAdapter implements CliAdapter {
                 if (!prompt) continue;
                 this.activeInteractivePrompt = prompt;
                 this.interactivePromptTransport = 'stream-json';
+                this.interactivePromptLostAt = null;
                 this.statusCallback?.();
             } catch {
                 // PTY output is not guaranteed to be machine JSON.
@@ -514,6 +539,56 @@ export class SpecCliAdapter implements CliAdapter {
         return messages;
     }
 
+    /**
+     * Grace window a held interactive prompt must be absent from the screen
+     * before we treat it as resolved-in-terminal and clear it. claude-cli
+     * repaints the picker across multiple PTY chunks, so a single
+     * footer-less frame is not proof the prompt is gone. Sized in the same
+     * spirit as the approval FSM's `approvalCooldown` modal-lost hysteresis.
+     */
+    private static readonly INTERACTIVE_PROMPT_LOST_GRACE_MS = 1500;
+
+    /**
+     * Clear a held interactive prompt once the user has resolved it directly
+     * in the terminal (the choice picker leaves the screen without going
+     * through setInteractivePromptResponse). The approval path already does
+     * this via the FSM's modal-lost hysteresis; the interactive-prompt path
+     * had no equivalent, so a terminal-side answer left activeInteractivePrompt
+     * set and getStatus() re-emitted the same choice modal forever.
+     *
+     * Detection mirrors capture: the claude TUI picker is on-screen exactly
+     * while its "Enter to select" footer is rendered. When the footer is gone
+     * for INTERACTIVE_PROMPT_LOST_GRACE_MS the prompt is genuinely resolved.
+     */
+    private maybeClearResolvedClaudeTuiPrompt(): void {
+        if (this.cliType !== 'claude-cli' || !this.activeInteractivePrompt) return;
+        // stream-json prompts are tracked by their tool-call lifecycle, not by
+        // screen footer, but claude renders the same TUI picker for both
+        // transports while awaiting an answer — so screen presence is a valid
+        // resolved-signal for either. (If the screen read fails, keep holding.)
+        let screenText = '';
+        try {
+            screenText = this.driver.snapshot();
+        } catch {
+            return;
+        }
+        const stillOnScreen = screenText.includes('Enter to select');
+        if (stillOnScreen) {
+            // Prompt reappeared / never left — reset the hysteresis timer.
+            this.interactivePromptLostAt = null;
+            return;
+        }
+        const lostAt = this.interactivePromptLostAt ?? Date.now();
+        if (this.interactivePromptLostAt === null) this.interactivePromptLostAt = lostAt;
+        if (Date.now() - lostAt < SpecCliAdapter.INTERACTIVE_PROMPT_LOST_GRACE_MS) return;
+        // Resolved in the terminal — drop the held prompt so getStatus() stops
+        // re-emitting it.
+        this.activeInteractivePrompt = null;
+        this.interactivePromptTransport = null;
+        this.interactivePromptLostAt = null;
+        this.statusCallback?.();
+    }
+
     private maybeCaptureClaudeTuiPrompt(): void {
         if (this.cliType !== 'claude-cli'
             || this.activeInteractivePrompt
@@ -529,6 +604,7 @@ export class SpecCliAdapter implements CliAdapter {
             if (!prompt) return;
             this.activeInteractivePrompt = prompt;
             this.interactivePromptTransport = 'tui';
+            this.interactivePromptLostAt = null;
             this.statusCallback?.();
             return;
         }
@@ -568,6 +644,7 @@ export class SpecCliAdapter implements CliAdapter {
         if (!prompt) return;
         this.activeInteractivePrompt = prompt;
         this.interactivePromptTransport = 'tui';
+        this.interactivePromptLostAt = null;
         this.statusCallback?.();
     }
 
@@ -626,6 +703,9 @@ export class SpecCliAdapter implements CliAdapter {
             // and countdown. This is the canonical "why isn't it transitioning"
             // answer — no screenshots needed.
             fsm: this.driver.getFsmDebug?.() ?? null,
+            // v4 FSM transition snapshot history — the captured pre-transition
+            // evaluation table at each transition (null for v3 specs).
+            fsmHistory: this.driver.getFsmSnapshotHistory?.() ?? null,
             messages,
             committedMessages: messages,
         };

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

@@ -28,7 +28,7 @@ import {
     resolveSections, sectionText, extractTitle, extractButtonsFromRule,
     type ResolvedSection, type TraceEntry,
 } from './evaluator.js';
-import { evaluateFsm, type FsmClock, type TransitionEval } from './fsm-evaluator.js';
+import { evaluateFsm, type FsmClock, type TransitionEval, type FsmEvaluation } from './fsm-evaluator.js';
 import {
     type CliSpecV4, type FsmState, type FsmTransition,
     initialState, stateById, statusForState, outgoingTransitions,
@@ -74,6 +74,37 @@ export interface DriverHistoryEntry {
     via?: string;
 }
 
+/**
+ * A frozen snapshot of the FULL FSM evaluation captured at the instant a
+ * transition fired — the rich `transitions[]` table (per-transition eligible /
+ * hold countdown / per-condition CondResult + remainingMs) that `getFsmDebug()`
+ * otherwise only computes live for the current instant. Kept in a separate ring
+ * buffer from `stateHistory` (which stays intentionally lightweight) so the
+ * "why did this rule fire just before the transition" question is answerable
+ * after the fact. before-only: this is the evaluation that PRODUCED the
+ * transition, not the post-transition state.
+ */
+export interface FsmSnapshotEntry {
+    /** State we transitioned out of. */
+    stateFrom: string;
+    /** State we transitioned into (the fired transition's destination). */
+    stateTo: string;
+    /** Wall-clock time the transition committed (ms). */
+    at: number;
+    /** The fired transition's destination state id (== stateTo; kept explicit
+     *  to mirror the rule that fired). */
+    firedTo: string;
+    /** Human label of the fired transition (e.g. "approval→busy"). */
+    firedLabel: string;
+    /** Why-it-fired summary, same shape produced for stateHistory.matchedRules. */
+    reason: string[];
+    /** Every outgoing transition from `stateFrom` as evaluated at `at`, each
+     *  with its eligible / hold / per-condition CondResult + remainingMs. This
+     *  is the full pre-transition evaluation table — the whole point of the
+     *  snapshot. */
+    transitions: TransitionEval[];
+}
+
 export interface ISpecDriver {
     subscribe(listener: (ev: DashboardEvent) => void): () => void;
     start(): void;
@@ -89,6 +120,7 @@ export interface ISpecDriver {
     hasIdleHoldPending(): boolean;
     getCompletionIdleDebounceState(): { active: boolean; ageMs: number; holdMs: number; forceAfterMs: number } | null;
     getFsmDebug?(): unknown;
+    getFsmSnapshotHistory?(): ReadonlyArray<FsmSnapshotEntry>;
 }
 
 export interface SpecDriverOpts {
@@ -182,6 +214,10 @@ export class FsmDriver implements ISpecDriver {
     private specWatcher: fs.FSWatcher | null = null;
     /** Last full FSM evaluation, kept for the debugger. */
     private lastFsmEval: ReturnType<typeof evaluateFsm> | null = null;
+    /** Ring buffer (max 20) of the full FSM evaluation captured at each
+     *  transition — the rich pre-transition table that lastFsmEval only keeps
+     *  for the single most recent evaluation. Separate from stateHistory. */
+    private fsmSnapshotHistory: FsmSnapshotEntry[] = [];
 
     constructor(private readonly opts: SpecDriverOpts) {
         this.loadSpecOrThrow();
@@ -272,6 +308,7 @@ export class FsmDriver implements ISpecDriver {
     }
 
     getStateHistory(): ReadonlyArray<HistoryEntry> { return this.stateHistory; }
+    getFsmSnapshotHistory(): ReadonlyArray<FsmSnapshotEntry> { return this.fsmSnapshotHistory; }
     getSections(): Array<{ id: string; text: string }> | null {
         try {
             const screen = this.adapter.snapshot();
@@ -385,7 +422,7 @@ export class FsmDriver implements ISpecDriver {
         this.prevScreenLines = currentLines;
 
         if (ev.fired) {
-            this.commitTransition(ev.fired, now);
+            this.commitTransition(ev.fired, now, ev);
             // After a transition, immediately re-derive controls/modal for the
             // new state and emit. Re-run once so a chain like approval→busy
             // that's already satisfied doesn't wait for the next PTY frame.
@@ -403,8 +440,11 @@ export class FsmDriver implements ISpecDriver {
         this.maybeMarkReady();
     }
 
-    private commitTransition(fired: TransitionEval, now: number): void {
+    private commitTransition(fired: TransitionEval, now: number, ev: FsmEvaluation): void {
         const from = this.currentStateId;
+        // Capture the full pre-transition evaluation BEFORE we mutate state, so
+        // the snapshot records why this transition fired from `from`.
+        this.pushFsmSnapshot(from, fired, now, ev);
         this.currentStateId = fired.to;
         this.stateEnteredAt = now;
         // Region change timestamps are relative to the previous state's
@@ -418,6 +458,23 @@ export class FsmDriver implements ISpecDriver {
         LOG.info('FsmDriver', `[${this.specTag()}] ${from} → ${fired.to} (${fired.label})`);
     }
 
+    /** Snapshot the full FSM evaluation that produced a transition into the
+     *  separate fsmSnapshotHistory ring buffer (max 20). The transitions[]
+     *  table is captured by reference — it is freshly built per evaluation in
+     *  evaluateFsm and never mutated after, so no clone is needed. */
+    private pushFsmSnapshot(from: string, fired: TransitionEval, now: number, ev: FsmEvaluation): void {
+        this.fsmSnapshotHistory.push({
+            stateFrom: from,
+            stateTo: fired.to,
+            at: now,
+            firedTo: fired.to,
+            firedLabel: fired.label,
+            reason: summarizeTransition(fired),
+            transitions: ev.transitions,
+        });
+        if (this.fsmSnapshotHistory.length > 20) this.fsmSnapshotHistory.shift();
+    }
+
     /** Re-derive the visible modal + controls for the current state and emit a
      *  state_changed if anything differs from the last emit. */
     private emitStateChanged(forceEmit: boolean): void {