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

package/dist/providers/cli-provider-instance-types.d.ts

@@ -39,6 +39,7 @@ export type ExternalTranscriptProbe = {
 export declare const COMPLETED_FINALIZATION_RETRY_MS = 1000;
 export declare const COMPLETED_FINALIZATION_MAX_WAIT_MS = 30000;
 export declare const CANON_C_MISSING_ASSISTANT_MIN_ELAPSED_MS = 20000;
+export declare const MISSING_ASSISTANT_TRANSCRIPT_GROWTH_QUIET_MS = 60000;
 export declare const NATIVE_HISTORY_MESH_IDLE_SETTLE_MS = 4000;
 export declare const PTY_PARSED_FINAL_ASSISTANT_QUIET_DWELL_MS = 1200;
 export declare const ANTIGRAVITY_HOLD_QUIET_DWELL_MS = 3000;

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

@@ -475,4 +475,17 @@ export declare class FsmDriver implements ISpecDriver {
  *  not register as a region change. No filter → lines returned unchanged.
  *  Exported for unit tests of the stable_ms `ignore_lines` change-detection. */
 export declare function filterIgnoredLines(lines: string[], ignoreRe: RegExp | undefined): string[];
+/** 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 declare function stableCursorWindow(lineCount: number, cursorRow: number, cursorAbove: number): {
+    start: number;
+    end: number;
+} | null;
 export {};

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

@@ -268,6 +268,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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "1.0.28-rc.8",
+  "version": "1.0.28-rc.9",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -49,8 +49,8 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "1.0.28-rc.8",
-    "@adhdev/session-host-core": "1.0.28-rc.8",
+    "@adhdev/mesh-shared": "1.0.28-rc.9",
+    "@adhdev/session-host-core": "1.0.28-rc.9",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/commands/med-family/mesh-crud.ts

@@ -677,6 +677,20 @@ export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
                 ...(capabilities && capabilities.length ? { capabilities } : {}),
             });
             if (!node) return { success: false, error: 'Mesh not found' };
+            // MESH-MEMBERSHIP-INLINE-CACHE-SYNC: addNode() above only wrote the new
+            // node to the file-backed meshes.json. getMeshForCommand's inline-cache-
+            // preferred read (the default for mesh_status/mesh_list_nodes/get_mesh)
+            // resolves this SAME meshId from `inlineMeshCache` whenever a prior
+            // command warmed it (e.g. a cloud coordinator launch with inlineMesh —
+            // see mesh-coordinator-launch.ts). Without pushing the new node into
+            // that cache too, the live view keeps serving the pre-add snapshot until
+            // the daemon restarts and the cache is re-emptied. Only touch the cache
+            // when it already holds this mesh (nothing to fix for a pure local-config
+            // mesh that no caller has ever warmed).
+            const cachedMesh = ctx.getCachedInlineMesh(meshId);
+            if (cachedMesh) {
+                ctx.updateInlineMeshNode(meshId, cachedMesh, node);
+            }
             // mesh_status hands back a coordinator-memory aggregate
             // snapshot keyed on (meshId, queueRevision). Adding a
             // node touches neither, so without an explicit cache
@@ -1036,6 +1050,19 @@ export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
                 // the response is accurate.
                 if (!removed && !node) removed = true;
                 if (removed) ctx.invalidateAggregateMeshStatus(meshId);
+                // MESH-MEMBERSHIP-INLINE-CACHE-SYNC: mirror-image of the inline
+                // branch above. This mesh resolved from local_config (nothing had
+                // warmed inlineMeshCache for it YET at getMeshForCommand time), but
+                // another command (e.g. a cloud coordinator launch with inlineMesh)
+                // may have already warmed the cache for this same meshId from an
+                // earlier read. Splice the node out of the cached copy too, and
+                // tombstone it, so a dashboard's stale inlineMesh echo cannot merge
+                // the removed node back in (see removeInlineMeshNode's tombstone
+                // comment).
+                if (removed) {
+                    const cachedMesh = ctx.getCachedInlineMesh(meshId);
+                    if (cachedMesh) ctx.removeInlineMeshNode(meshId, cachedMesh, nodeId);
+                }
             }
 
             // Record in task ledger

package/src/mesh/mesh-reconcile-loop.ts

@@ -1583,6 +1583,40 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
         }
     }
 
+    // ── PHASE 0.5: merge file-config membership into the router's inline cache ─
+    // MESH-MEMBERSHIP-INLINE-CACHE-SYNC: getMeshForCommand's inline-cache-preferred
+    // read (mesh_status / mesh_list_nodes / get_mesh) resolves a meshId from
+    // router.inlineMeshCache whenever ANYTHING has warmed it (e.g. a cloud
+    // coordinator launch with inlineMesh — see mesh-coordinator-launch.ts). Once
+    // warmed, that cache — not meshes.json — is what every live read serves.
+    // add_mesh_node/remove_mesh_node now push their own writes into the cache
+    // too, but a change made by ANOTHER daemon (or a direct meshes.json edit)
+    // reaches only this daemon's file config, never its in-memory cache. This
+    // loop already re-reads listMeshes() every tick for its own queue work, so
+    // reuse that read to fold the current file-config membership into the cache
+    // via the same reconcileInlineMeshCache path getMeshForCommand itself uses
+    // (getCachedInlineMesh(meshId, incoming) merges — it does not overwrite —
+    // preferring cache-only nodes when the cache is newer, e.g. a just-cloned
+    // worktree not yet flushed to disk).
+    //
+    // Deliberately gated on `router.getCachedInlineMesh(mesh.id)` (no second arg)
+    // returning a hit FIRST: calling the merging overload unconditionally would
+    // warm the cache for every local-config mesh on every tick, flipping meshes
+    // that have NEVER been inline-cached from always-fresh 'local_config' reads
+    // to a resolution sourced from a snapshot that's only as fresh as the last
+    // 4s tick. Only merge into a cache entry that already exists.
+    if (components.router) {
+        for (const mesh of listMeshes()) {
+            try {
+                if (components.router.getCachedInlineMesh(mesh.id)) {
+                    components.router.getCachedInlineMesh(mesh.id, mesh);
+                }
+            } catch (e: any) {
+                LOG.warn('MeshReconcile', `Inline-cache membership merge failed for mesh ${mesh.id}: ${e?.message || e}`);
+            }
+        }
+    }
+
     // ── PHASE 1: pull remote node queues for every mesh this daemon hosts ──────
     // Cloud-only (dispatchMeshCommand present). Runs whether or not a live CLI
     // coordinator exists — this is what lets an MCP/LLM coordinator ever see a

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

@@ -115,6 +115,31 @@ export const COMPLETED_FINALIZATION_MAX_WAIT_MS = 30_000;
 // Sized so a short transcript-write lag resolves under it while staying well below the 30s
 // COMPLETED_FINALIZATION_MAX_WAIT_MS cap that force-releases the weak completion regardless.
 export const CANON_C_MISSING_ASSISTANT_MIN_ELAPSED_MS = 20_000;
+// (TRANSCRIPT-GROWTH-HOLD — CODEX-FSM-DEGENERATE-STABLE RCA, upper safety net)
+// Minimum QUIET time required on the provider's native transcript file before a
+// missing_final_assistant + noExternalTranscriptSource completion (the FLOOR
+// class: codex-cli / kimi / cursor-cli / opencode) may release its weak emit.
+// While the transcript file has been appended within this window, the turn is
+// demonstrably alive regardless of what the screen parser says — the FSM's
+// busy→idle that armed the completion was a lie (spinner escaped the status
+// window / degenerate stable region), so the flush HOLDS instead of firing.
+//
+// Conservative by construction: the hold engages ONLY on positive growth
+// evidence (a fresh source mtime). A provider with no native source, an
+// unresolvable transcript, or a transcript that has gone quiet for this window
+// falls through to the unchanged floor/cap logic — missing information never
+// blocks an idle verdict (no false-busy wedge), and each hold cycle is
+// re-verified against a FRESH sample, so the hold releases at most this long
+// after the transcript's last append.
+//
+// Sized from the live RCA: during the defect the rollout transcript advanced
+// ~once per 45s (msgCount 82→87 over ~4min) while the PTY was quiet for 365s,
+// so the window must exceed that append cadence or the hold leaks between
+// appends; 60s covers it with margin while staying well under the 180s
+// mesh-worker stall watchdog threshold, which keeps ownership of genuine long
+// stalls. It only ever delays the already-degraded missing_final_assistant
+// path — completions WITH an in-turn final assistant never see this hold.
+export const MISSING_ASSISTANT_TRANSCRIPT_GROWTH_QUIET_MS = 60_000;
 // (FALSEIDLE-BGCHILD-a) Minimum generating→idle settle window for native-history mesh worker
 // sessions. Native-history providers (e.g. claude-cli) normally flush the completion with
 // flushDelay=0 — the transcript is authoritative, so there is no reason to wait. But a worker

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;