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

package/dist/mesh/mesh-ledger.d.ts

@@ -15,7 +15,7 @@
 import { EventEmitter } from 'events';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
 import { type MeshLedgerOriginatingCoordinatorV2 } from './contracts.js';
-export type MeshLedgerKind = 'task_dispatched' | 'task_completed' | 'task_failed' | 'task_stalled' | 'task_approval_needed' | 'task_question_pending' | 'p2p_dispatch_failed' | 'session_launched' | 'session_auto_launch' | 'session_stopped' | 'checkpoint_created' | 'node_cloned' | 'node_joined' | 'node_removed' | 'coordinator_started' | 'recovery_attempted' | 'ledger_replicated' | 'ledger_reconciled' | 'direct_fast_forward' | 'delivery_unroutable' | 'direct_dispatch_pruned' | 'event_held' | 'event_held_requeued' | 'task_reclaimed' | 'coordinator_operating_note' | 'coordinator_operating_note_tombstone' | 'mission_created' | 'mission_status_changed' | 'mission_goal_updated' | 'magi_dispatched' | 'magi_synthesis' | 'key_injection' | 'worktree_cleanup_candidate';
+export type MeshLedgerKind = 'task_dispatched' | 'task_claimed' | 'task_completed' | 'task_failed' | 'task_stalled' | 'task_approval_needed' | 'task_question_pending' | 'p2p_dispatch_failed' | 'session_launched' | 'session_auto_launch' | 'session_stopped' | 'checkpoint_created' | 'node_cloned' | 'node_joined' | 'node_removed' | 'coordinator_started' | 'recovery_attempted' | 'ledger_replicated' | 'ledger_reconciled' | 'direct_fast_forward' | 'delivery_unroutable' | 'direct_dispatch_pruned' | 'event_held' | 'event_held_requeued' | 'task_reclaimed' | 'coordinator_operating_note' | 'coordinator_operating_note_tombstone' | 'mission_created' | 'mission_status_changed' | 'mission_goal_updated' | 'magi_dispatched' | 'magi_synthesis' | 'key_injection' | 'worktree_cleanup_candidate';
 export interface MeshLedgerEntry {
     id: string;
     meshId: string;
@@ -24,8 +24,12 @@ export interface MeshLedgerEntry {
     nodeId?: string;
     sessionId?: string;
     providerType?: string;
+    taskId?: string;
     payload: Record<string, unknown>;
 }
+/** Resolve the taskId for a ledger entry, preferring the base field and falling
+ *  back to payload.taskId (legacy rows / entries that only carry it in payload). */
+export declare function ledgerEntryTaskId(entry: Pick<MeshLedgerEntry, 'taskId' | 'payload'>): string | undefined;
 export declare function isIntentionalCleanupStopEntry(entry: Pick<MeshLedgerEntry, 'kind' | 'payload'>): boolean;
 export type MeshWorkerResultStatus = 'completed' | 'failed' | 'blocked' | 'partial' | 'unknown';
 export type MeshProcessArtifactKind = 'process' | 'log' | 'port' | 'window' | 'session' | 'file' | 'url' | 'other';

package/dist/mesh/mesh-queue-assignment.d.ts

@@ -5,7 +5,25 @@ import type { RepoMeshSchedulingStrategy } from '../repo-mesh-types.js';
 export declare function isWorkspaceAutoFastForwardInFlight(workspace: string | undefined): boolean;
 export declare function __resetIdleAutoFastForwardForTests(): void;
 export declare function getMeshWithCache(components: DaemonComponents, meshId: string): any | undefined;
-export declare function tryAssignQueueTask(components: DaemonComponents, meshId: string, nodeId: string, sessionId: string, providerType: string): boolean;
+export interface MeshTaskRoutingDecision {
+    source: 'queue' | 'autoLaunch' | 'direct';
+    fitnessScore?: number;
+    skippedCandidates?: Array<{
+        nodeId: string;
+        reason: string;
+    }>;
+    requiredTagsResult?: {
+        required: string[];
+        satisfied: boolean;
+        missing: string[];
+    };
+    resolvedProviderType?: string;
+    resolvedModel?: string;
+    resolvedThinkingLevel?: string;
+    resolvedDifficulty?: string;
+    reason?: string;
+}
+export declare function tryAssignQueueTask(components: DaemonComponents, meshId: string, nodeId: string, sessionId: string, providerType: string, routingDecision?: MeshTaskRoutingDecision): boolean;
 export declare const AUTO_LAUNCH_AWAIT_CLAIM_MS = 90000;
 interface AwaitClaimBackoffState {
     cycles: number;

package/dist/mesh/mesh-runtime-store.d.ts

@@ -355,6 +355,7 @@ export declare class MeshRuntimeStore {
         nodeId?: string | null;
         sessionId?: string | null;
         providerType?: string | null;
+        taskId?: string | null;
         payload?: unknown;
     }): void;
     readLedgerEntries(meshId: string, opts?: {
@@ -370,6 +371,7 @@ export declare class MeshRuntimeStore {
         nodeId: string | null;
         sessionId: string | null;
         providerType: string | null;
+        taskId: string | null;
         payload: unknown;
     }>;
     /**
@@ -390,6 +392,7 @@ export declare class MeshRuntimeStore {
         nodeId: string | null;
         sessionId: string | null;
         providerType: string | null;
+        taskId: string | null;
         payload: unknown;
     }>;
     /** Remove all ledger entries for a mesh (mesh deletion / test cleanup). */
@@ -406,6 +409,7 @@ export declare class MeshRuntimeStore {
         nodeId?: string | null;
         sessionId?: string | null;
         providerType?: string | null;
+        taskId?: string | null;
         payload?: unknown;
     }>): number;
     /**

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.7",
+  "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.7",
-    "@adhdev/session-host-core": "1.0.28-rc.7",
+    "@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/index.ts

@@ -288,7 +288,7 @@ export { loadRepoSettings } from './config/repo-settings.js';
 export type { RepoSettings, LoadRepoSettingsOptions } from './config/repo-settings.js';
 
 // ── Mesh Task Ledger ──
-export { appendLedgerEntry, appendRemoteLedgerEntries, buildTaskCompletionEvidence, normalizeMeshWorkerResult, readLedgerEntries, readLedgerSlice, readLedgerSliceFromStore, getLedgerSummary, getLedgerDir, getSessionRecoveryContext, MAX_LEDGER_SLICE_LIMIT, tombstoneOperatingNote, readOperatingNotes, pruneOperatingNotes, isOperatingNoteTombstoned, OPERATING_NOTE_KIND, OPERATING_NOTE_TOMBSTONE_KIND, OPERATING_NOTE_DEDUPE_WINDOW, OPERATING_NOTE_KEEP_LATEST } from './mesh/mesh-ledger.js';
+export { appendLedgerEntry, appendRemoteLedgerEntries, buildTaskCompletionEvidence, normalizeMeshWorkerResult, readLedgerEntries, readLedgerSlice, readLedgerSliceFromStore, getLedgerSummary, getLedgerDir, getSessionRecoveryContext, ledgerEntryTaskId, MAX_LEDGER_SLICE_LIMIT, tombstoneOperatingNote, readOperatingNotes, pruneOperatingNotes, isOperatingNoteTombstoned, OPERATING_NOTE_KIND, OPERATING_NOTE_TOMBSTONE_KIND, OPERATING_NOTE_DEDUPE_WINDOW, OPERATING_NOTE_KEEP_LATEST } from './mesh/mesh-ledger.js';
 export type { AppendRemoteLedgerResult, MeshLedgerEntry, MeshLedgerKind, MeshLedgerSlice, MeshLedgerSummary, ReadLedgerOptions, ReadLedgerSliceOptions, SessionRecoveryContext, MeshTaskCompletionEvidence, MeshWorkerResultArtifact, MeshProcessArtifact, MeshValidationResultArtifact } from './mesh/mesh-ledger.js';
 export { fastForwardMeshNode } from './mesh/mesh-fast-forward.js';
 export type { MeshFastForwardNodeArgs, MeshFastForwardPlannedStep, MeshFastForwardResult } from './mesh/mesh-fast-forward.js';

package/src/mesh/mesh-ledger.ts

@@ -29,6 +29,11 @@ import {
 
 export type MeshLedgerKind =
     | 'task_dispatched'
+    // LEDGER-TASK-TRACEABILITY (C): a queue task transitioned pending→assigned (a
+    // node/session claimed it). Distinct from task_dispatched (the message was handed
+    // to the transport): claim precedes dispatch and marks the lifecycle handoff.
+    // payload: { taskId, nodeId, sessionId, providerType?, claimedAt }
+    | 'task_claimed'
     | 'task_completed'
     | 'task_failed'
     | 'task_stalled'
@@ -111,9 +116,40 @@ export interface MeshLedgerEntry {
     nodeId?: string;
     sessionId?: string;
     providerType?: string;
+    // LEDGER-TASK-TRACEABILITY (B): the task this entry pertains to, promoted from
+    // payload.taskId to a top-level base field so a task's lifecycle
+    // (task_dispatched → task_claimed → task_completed/failed/stalled/reclaimed) can
+    // be joined by kind+taskId without an O(n) per-entry payload scan. Optional and
+    // back-compat: legacy rows never carried it — readers fall back to payload.taskId,
+    // and appendLedgerEntry auto-derives it from payload.taskId for task-lifecycle
+    // kinds so every such entry is uniformly queryable.
+    taskId?: string;
     payload: Record<string, unknown>;
 }
 
+// LEDGER-TASK-TRACEABILITY (B): the kinds whose taskId base field is auto-derived
+// from payload.taskId at append time (so a join by kind+taskId is uniform). Other
+// kinds may still set taskId explicitly; this only backfills the common lifecycle.
+const TASK_LIFECYCLE_LEDGER_KINDS: ReadonlySet<MeshLedgerKind> = new Set<MeshLedgerKind>([
+    'task_dispatched',
+    'task_claimed',
+    'task_completed',
+    'task_failed',
+    'task_stalled',
+    'task_reclaimed',
+    'task_approval_needed',
+    'task_question_pending',
+    'p2p_dispatch_failed',
+]);
+
+/** Resolve the taskId for a ledger entry, preferring the base field and falling
+ *  back to payload.taskId (legacy rows / entries that only carry it in payload). */
+export function ledgerEntryTaskId(entry: Pick<MeshLedgerEntry, 'taskId' | 'payload'>): string | undefined {
+    if (typeof entry.taskId === 'string' && entry.taskId.trim()) return entry.taskId.trim();
+    const fromPayload = entry.payload && typeof entry.payload === 'object' ? (entry.payload as Record<string, unknown>).taskId : undefined;
+    return typeof fromPayload === 'string' && fromPayload.trim() ? fromPayload.trim() : undefined;
+}
+
 export function isIntentionalCleanupStopEntry(entry: Pick<MeshLedgerEntry, 'kind' | 'payload'>): boolean {
     if (entry.kind !== 'session_stopped' && entry.kind !== 'task_failed' && entry.kind !== 'task_stalled') return false;
     const payload = entry.payload && typeof entry.payload === 'object' && !Array.isArray(entry.payload)
@@ -796,6 +832,14 @@ export function appendLedgerEntry(
         ...partial,
     };
 
+    // LEDGER-TASK-TRACEABILITY (B): backfill the taskId base field from payload.taskId
+    // for task-lifecycle kinds so every dispatch/claim/complete/fail/stall/reclaim
+    // entry is uniformly join-able by kind+taskId. An explicit partial.taskId wins.
+    if (!entry.taskId && TASK_LIFECYCLE_LEDGER_KINDS.has(entry.kind)) {
+        const derived = ledgerEntryTaskId(entry);
+        if (derived) entry.taskId = derived;
+    }
+
     const filePath = getLedgerPath(meshId);
 
     // Compact or rotate based on file size
@@ -822,6 +866,7 @@ export function appendLedgerEntry(
             nodeId: entry.nodeId ?? null,
             sessionId: entry.sessionId ?? null,
             providerType: entry.providerType ?? null,
+            taskId: entry.taskId ?? null,
             payload: entry.payload,
         });
     } catch {
@@ -1074,7 +1119,15 @@ function readLedgerFile(meshId: string): MeshLedgerEntry[] {
         if (!line.trim()) continue;
         try {
             const entry = JSON.parse(line) as MeshLedgerEntry;
-            if (entry.id && entry.kind) entries.push(entry);
+            if (entry.id && entry.kind) {
+                // LEDGER-TASK-TRACEABILITY (B): backfill the base taskId from
+                // payload.taskId for legacy JSONL lines that predate the field.
+                if (!entry.taskId) {
+                    const derived = ledgerEntryTaskId(entry);
+                    if (derived) entry.taskId = derived;
+                }
+                entries.push(entry);
+            }
         } catch { /* skip malformed lines */ }
     }
     return entries;
@@ -1108,6 +1161,7 @@ function ensureLedgerImported(store: MeshRuntimeStore, meshId: string): void {
             nodeId: e.nodeId ?? null,
             sessionId: e.sessionId ?? null,
             providerType: e.providerType ?? null,
+            taskId: ledgerEntryTaskId(e) ?? null,
             payload: e.payload ?? {},
         })));
     } catch { /* import is best-effort; reads fall back to JSONL on store failure */ }
@@ -1116,16 +1170,23 @@ function ensureLedgerImported(store: MeshRuntimeStore, meshId: string): void {
 function readLedgerFromStore(meshId: string): MeshLedgerEntry[] {
     const store = MeshRuntimeStore.getInstance();
     ensureLedgerImported(store, meshId);
-    return store.readLedgerEntriesOrdered(meshId).map(r => ({
-        id: r.id,
-        meshId: r.meshId,
-        timestamp: r.timestamp,
-        kind: r.kind as MeshLedgerKind,
-        ...(r.nodeId ? { nodeId: r.nodeId } : {}),
-        ...(r.sessionId ? { sessionId: r.sessionId } : {}),
-        ...(r.providerType ? { providerType: r.providerType } : {}),
-        payload: (r.payload && typeof r.payload === 'object' ? r.payload : {}) as Record<string, unknown>,
-    }));
+    return store.readLedgerEntriesOrdered(meshId).map(r => {
+        const payload = (r.payload && typeof r.payload === 'object' ? r.payload : {}) as Record<string, unknown>;
+        // LEDGER-TASK-TRACEABILITY (B): prefer the column, fall back to payload.taskId
+        // for legacy rows written before the column existed (back-compat join).
+        const taskId = ledgerEntryTaskId({ taskId: r.taskId ?? undefined, payload });
+        return {
+            id: r.id,
+            meshId: r.meshId,
+            timestamp: r.timestamp,
+            kind: r.kind as MeshLedgerKind,
+            ...(r.nodeId ? { nodeId: r.nodeId } : {}),
+            ...(r.sessionId ? { sessionId: r.sessionId } : {}),
+            ...(r.providerType ? { providerType: r.providerType } : {}),
+            ...(taskId ? { taskId } : {}),
+            payload,
+        };
+    });
 }
 
 function getCachedRawEntries(meshId: string): MeshLedgerEntry[] {