@adhdev/daemon-core 1.0.28-rc.7 → 1.0.28-rc.9

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

@@ -59,6 +59,7 @@ import {
     COMPLETED_FINALIZATION_RETRY_MS,
     COMPLETED_FINALIZATION_MAX_WAIT_MS,
     CANON_C_MISSING_ASSISTANT_MIN_ELAPSED_MS,
+    MISSING_ASSISTANT_TRANSCRIPT_GROWTH_QUIET_MS,
     NATIVE_HISTORY_MESH_IDLE_SETTLE_MS,
     PTY_PARSED_FINAL_ASSISTANT_QUIET_DWELL_MS,
     ANTIGRAVITY_HOLD_QUIET_DWELL_MS,
@@ -3140,6 +3141,56 @@ export class CliProviderInstance implements ProviderInstance {
             // from ever being emitted during the valley, without depending on the valley's length.
             const isTranscriptEvidenceGate = block.allowTimeout === true;
             LOG.debug('CLI', `[${this.type}] finalization block: reason=${blockReason} terminal=${block.terminal} allowTimeout=${isTranscriptEvidenceGate} waitedMs=${waitedMs} maxWait=${COMPLETED_FINALIZATION_MAX_WAIT_MS}`);
+            // (TRANSCRIPT-GROWTH-HOLD — CODEX-FSM-DEGENERATE-STABLE RCA, upper safety net)
+            // The FLOOR class (missing_final_assistant + noExternalTranscriptSource:
+            // codex-cli / kimi / cursor-cli / opencode) releases its weak emit once
+            // the idle has been CONTINUOUSLY quiet past the floor/cap — "quiet" as
+            // judged by the SAME screen parsing whose lie armed this completion
+            // (spinner escaped the status window, or a degenerate stable region
+            // accumulated a false 353s "quiet"). The daemon already observes the
+            // independent liveness signal that proves otherwise — the native
+            // transcript advancing (the stall watchdog logs exactly this: "PTY
+            // quiet 365s but transcript advancing") — but it was never wired into
+            // the idle/completion judgment. Wire it here: if the provider's native
+            // transcript file was appended within the growth-quiet window, the
+            // turn is demonstrably alive; HOLD (re-probe each retry — the hold
+            // releases at most MISSING_ASSISTANT_TRANSCRIPT_GROWTH_QUIET_MS after
+            // the transcript's last append) instead of emitting a completion the
+            // coordinator can never correct.
+            //
+            // Conservative by construction: this only ever DELAYS an emit on
+            // positive growth evidence. A pure-PTY provider (no native source →
+            // sample null), an unresolvable transcript, or a transcript whose
+            // mtime is unknown/quiet falls through to the unchanged floor/cap
+            // logic — missing information NEVER blocks an idle verdict (no
+            // false-busy wedge). Clean completions (in-turn final assistant
+            // present) never reach this branch, so genuine completion latency is
+            // untouched; claude-cli's write-lag CANON-C immediate emit is likewise
+            // untouched (its block deliberately omits noExternalTranscriptSource).
+            if (blockReason === 'missing_final_assistant' && block.noExternalTranscriptSource === true) {
+                let nativeSample: { msgCount: number; sourceMtimeMs: number } | null = null;
+                try { nativeSample = this.sampleNativeTranscriptProgress(); } catch { nativeSample = null; }
+                const sourceMtimeMs = nativeSample?.sourceMtimeMs ?? 0;
+                if (nativeSample && sourceMtimeMs > 0 && Date.now() - sourceMtimeMs < MISSING_ASSISTANT_TRANSCRIPT_GROWTH_QUIET_MS) {
+                    if (pending.loggedBlockReason !== 'native_transcript_advancing') {
+                        LOG.info('CLI', `[${this.type}] holding pending completed (native_transcript_advancing: msgCount=${nativeSample.msgCount} mtimeAge=${Date.now() - sourceMtimeMs}ms < ${MISSING_ASSISTANT_TRANSCRIPT_GROWTH_QUIET_MS}ms) — transcript still growing, screen-idle verdict not trusted`);
+                        if (this.isMeshWorkerSession()) {
+                            traceMeshEventDrop('completion_gate_hold', this.meshTraceCtx(), `native_transcript_advancing msgCount=${nativeSample.msgCount} mtimeAge=${Date.now() - sourceMtimeMs}ms`);
+                        }
+                        if (this.completionTraceOn()) this.recordCompletionGateTrace('hold', {
+                            blockReason: 'native_transcript_advancing',
+                            latestVisibleStatus,
+                            msgCount: nativeSample.msgCount,
+                            sourceMtimeAgeMs: Date.now() - sourceMtimeMs,
+                            growthQuietMs: MISSING_ASSISTANT_TRANSCRIPT_GROWTH_QUIET_MS,
+                            waitedMs,
+                        });
+                        pending.loggedBlockReason = 'native_transcript_advancing';
+                    }
+                    this.scheduleCompletedDebounceFlush(COMPLETED_FINALIZATION_RETRY_MS);
+                    return;
+                }
+            }
             if (!isTranscriptEvidenceGate && (block.terminal || waitedMs < COMPLETED_FINALIZATION_MAX_WAIT_MS)) {
                 if (pending.loggedBlockReason !== blockReason) {
                     LOG.info('CLI', `[${this.type}] waiting to emit completed until transcript finalizes (${blockReason})`);

package/src/providers/spec/evaluator.ts

@@ -107,7 +107,9 @@ export function resolveSections(
                     if (candIdx !== -1 && (idx === -1 || candIdx < idx)) idx = candIdx;
                 }
                 if (idx !== -1) {
-                    from = idx;
+                    from = typeof sec.above === 'number' && sec.above > 0
+                        ? Math.max(0, idx - Math.floor(sec.above))
+                        : idx;
                     to = total;
                     if (sec.until_regex !== undefined) {
                         try {
@@ -118,6 +120,12 @@ export function resolveSections(
                     } else if (sec.lines !== undefined) {
                         to = Math.min(total, from + sec.lines);
                     }
+                } else if (sec.anchor_miss === 'empty') {
+                    // Explicit empty-on-miss (see SectionDef.anchor_miss): the
+                    // section resolves to EMPTY rather than the whole-screen
+                    // fallback, so narrow-cue guards never see unrelated body.
+                    from = 0;
+                    to = 0;
                 }
             } catch { /* bad anchor regex */ }
         } else if (sec.from_top !== undefined) {

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

@@ -876,9 +876,33 @@ export class FsmDriver implements ISpecDriver {
                 curLines = currentLines;
                 prevLines = this.prevScreenLines;
             } else {
-                const start = Math.max(0, cursor.row - d.cursor_above);
-                curLines = currentLines.slice(start, cursor.row);
-                prevLines = this.prevScreenLines.slice(start, cursor.row);
+                // CODEX-FSM-DEGENERATE-STABLE fix: cursor.row is the backend's RAW
+                // row coordinate (ghostty getCursorPosition(), un-normalized), while
+                // currentLines is the VIEWPORT snapshot with blank ends trimmed
+                // (ghostty-vt-backend getText → trimBlankEnds). The two coordinate
+                // spaces diverge whenever trailing blank rows are trimmed away (or
+                // the backend counts scrollback rows): cursor.row then overshoots
+                // the array and slice(start, cursor.row) returns an EMPTY window.
+                // Two empty windows compare equal on every frame, so
+                // regionLastChangedAt never advances and stable_ms accumulates
+                // forever — the FSM read a generating screen as
+                // "stable cursor_above=4 353833ms / 1500ms" and committed a false
+                // busy→idle (live RCA: generating_completed at duration=402s while
+                // the native transcript kept growing).
+                //
+                // Invariant: an unmeasurable window must NEVER read as "stable".
+                // Clamp the window end to the content length (when the cursor sits
+                // in the trimmed blank region, the lines directly above it in
+                // content terms are the content tail), and when the window is still
+                // empty (no measurable content at all) mark the region CHANGED so
+                // the stable clock restarts instead of accumulating.
+                const window = stableCursorWindow(currentLines.length, cursor.row, d.cursor_above);
+                if (!window) {
+                    this.regionLastChangedAt.set(d.key, now);
+                    continue;
+                }
+                curLines = currentLines.slice(window.start, window.end);
+                prevLines = this.prevScreenLines.slice(window.start, window.end);
             }
             const cur = filterIgnoredLines(curLines, d.ignoreRe).join('\n');
             const prev = filterIgnoredLines(prevLines, d.ignoreRe).join('\n');
@@ -1570,3 +1594,19 @@ export function filterIgnoredLines(lines: string[], ignoreRe: RegExp | undefined
     if (!ignoreRe) return lines;
     return lines.filter(l => !ignoreRe.test(l));
 }
+
+/** Compute the [start, end) line window a cursor_above stable region measures,
+ *  reconciling the backend's raw cursor row with the blank-trimmed viewport
+ *  line array (see the CODEX-FSM-DEGENERATE-STABLE note in trackRegionChanges).
+ *  The window end is clamped to the content length so an overshooting cursor
+ *  row measures the content tail instead of slicing past the array into a
+ *  permanently-empty — and therefore permanently "unchanged" — window.
+ *  Returns null when no measurable window exists (cursor at/above row 0, or no
+ *  content): the caller must treat the region as CHANGED, never stable.
+ *  Exported for unit tests. */
+export function stableCursorWindow(lineCount: number, cursorRow: number, cursorAbove: number): { start: number; end: number } | null {
+    const end = Math.min(Math.max(0, cursorRow), Math.max(0, lineCount));
+    const start = Math.max(0, end - cursorAbove);
+    if (end <= start) return null;
+    return { start, end };
+}

package/src/providers/spec/types.ts

@@ -293,6 +293,31 @@ export interface SectionDef {
      * for that anchor. A scalar `anchor` ignores array form beyond index 0.
      */
     anchor_context?: AnchorContext | (AnchorContext | null)[];
+    /**
+     * Extends an anchored section N lines ABOVE its anchor line. The default
+     * anchored geometry starts the section AT the anchor line, which cannot
+     * express a status block that sits directly ABOVE its landmark (e.g.
+     * codex's live `Working (…)` spinner above the `› ` composer). With
+     * `above: K` the section starts at max(0, anchorLine - K), so the window
+     * stays pinned to the landmark regardless of output volume — unlike
+     * `from_bottom`, which counts from the LAST NON-BLANK line of a
+     * blank-trimmed viewport and lets the live status block escape the window
+     * once long output fills the tail (CODEX-FSM-DEGENERATE-STABLE RCA,
+     * defect 1: the spinner left the from_bottom:12 window while the worker
+     * was still generating).
+     */
+    above?: number;
+    /**
+     * Anchor-miss policy. Default (absent): an anchored section whose anchor
+     * matches NOTHING falls back to the whole screen (from=0, to=total) — the
+     * historical behavior modal sections rely on ("whole-screen fallback in
+     * non-modal frames is harmless"). 'empty' resolves the section to EMPTY
+     * instead, for sections whose guard regexes must never see unrelated body
+     * text: status_tail's spinner cues, whose whole-screen fallback would
+     * re-open the SPINNER-BODY-SELFMATCH defect on any frame where the
+     * composer landmark is momentarily absent (mid-redraw).
+     */
+    anchor_miss?: 'empty';
     lines?: number;
     until_regex?: string;
     until_regex_flags?: string;