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

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "1.0.28-rc.6",
+  "version": "1.0.28-rc.8",
   "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.6",
-    "@adhdev/session-host-core": "1.0.28-rc.6",
+    "@adhdev/mesh-shared": "1.0.28-rc.8",
+    "@adhdev/session-host-core": "1.0.28-rc.8",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/cli-adapters/cli-state-engine.ts

@@ -1604,7 +1604,15 @@ export class CliStateEngine {
         // background-tool race this was meant to guard against. If a provider
         // really needs the gate, the manifest can set
         // `requiresFinalAssistantBeforeIdle: true`.
-        const requiresFinalAssistant = !!this.provider.requiresFinalAssistantBeforeIdle;
+        //
+        // This is a completion-timing JUDGMENT, so it goes through the shared
+        // transcript-authority profile rather than reading the raw flag: the
+        // 'floor' class is exactly `requiresFinalAssistantBeforeIdle && !hold`
+        // (see resolveTranscriptAuthorityProfile), which is equivalent to the
+        // old `!!requiresFinalAssistantBeforeIdle` for every real provider
+        // because none declares both flags — a hold provider (antigravity)
+        // sets holdCompletionForTranscript only, so it was already false here.
+        const requiresFinalAssistant = resolveTranscriptAuthorityProfile(this.provider).timing === 'floor';
         if (!requiresFinalAssistant) return false;
         if (!this.isWaitingForResponse || !this.currentTurnScope || this.hasActionableApproval()) return false;
         const parsedStatus = typeof parsed?.status === 'string' ? parsed.status.trim() : '';

package/src/cli-adapters/provider-cli-adapter.ts

@@ -232,6 +232,9 @@ export class ProviderCliAdapter implements CliAdapter {
     private pendingOutboundQueue: PendingOutboundMessage[] = [];
     private pendingOutboundFlushTimer: NodeJS.Timeout | null = null;
     private pendingOutboundFlushInFlight = false;
+    // Stale-queue watchdog: fires STALE_QUEUE_WARN_MS after the oldest queued
+    // message was enqueued if nothing has been flushed yet.
+    private pendingOutboundStaleTimer: NodeJS.Timeout | null = null;
     // Submit retry timer — PTY-level, not state machine
     private submitRetryTimer: NodeJS.Timeout | null = null;
 
@@ -1715,6 +1718,10 @@ export class ProviderCliAdapter implements CliAdapter {
         await new Promise<void>(resolve => setTimeout(resolve, FORCE_SUBMIT_SETTLE_MS));
     }
 
+    // Stale-queue threshold: warn if a queued message has not been flushed
+    // within this many milliseconds (instrumentation only, no behavior change).
+    private static readonly STALE_QUEUE_WARN_MS = 15000;
+
     private enqueuePendingOutboundMessage(text: string, reason: string, meshTaskId?: string): void {
         const content = String(text || '');
         const duplicate = this.pendingOutboundQueue.some((message) => message.content === content);
@@ -1722,6 +1729,18 @@ export class ProviderCliAdapter implements CliAdapter {
             return;
         }
         const queuedAt = Date.now();
+        const stableMs = this.lastScreenChangeAt ? (queuedAt - this.lastScreenChangeAt) : -1;
+        // Diagnostic context: which gate caused the silent-queue and the full
+        // session readiness snapshot at the moment of enqueue.
+        const gateContext = {
+            reason,
+            startupParseGate: this.startupParseGate,
+            ready: this.ready,
+            engineStatus: this.engine.currentStatus,
+            isWaitingForResponse: this.engine.isWaitingForResponse,
+            stableMs,
+            sessionId: this.engine.getTraceSessionId(),
+        };
         const message: PendingOutboundMessage = {
             id: `${queuedAt}:${this.pendingOutboundQueue.length}:${Math.random().toString(36).slice(2, 10)}`,
             role: 'user',
@@ -1731,8 +1750,23 @@ export class ProviderCliAdapter implements CliAdapter {
             ...(typeof meshTaskId === 'string' && meshTaskId.trim() ? { meshTaskId } : {}),
         };
         this.pendingOutboundQueue.push(message);
-        LOG.info('CLI', `[${this.cliType}] queued outbound message while busy (${reason}); queue=${this.pendingOutboundQueue.length}`);
+        LOG.info('CLI', `[${this.cliType}] queued outbound message; gate=${JSON.stringify(gateContext)}; queue=${this.pendingOutboundQueue.length}`);
         this.onStatusChange?.();
+        // Stale-queue watchdog: emit a warn-level log if the enqueued message
+        // has not been flushed after STALE_QUEUE_WARN_MS. This fires once per
+        // enqueue event (not once per message still in queue) so it does not
+        // spam on a persistently stuck queue; it simply surfaces that the queue
+        // is stuck and records the current gate state at warn time.
+        if (!this.pendingOutboundStaleTimer) {
+            this.pendingOutboundStaleTimer = setTimeout(() => {
+                this.pendingOutboundStaleTimer = null;
+                if (this.pendingOutboundQueue.length === 0) return;
+                const oldest = this.pendingOutboundQueue[0];
+                const staleSec = ((Date.now() - oldest.queuedAt) / 1000).toFixed(1);
+                const nowStableMs = this.lastScreenChangeAt ? (Date.now() - this.lastScreenChangeAt) : -1;
+                LOG.warn('CLI', `[${this.cliType}] STALE QUEUE: ${this.pendingOutboundQueue.length} message(s) undelivered for ${staleSec}s; gate=startupParseGate:${this.startupParseGate} ready:${this.ready} engineStatus:${this.engine.currentStatus} isWaitingForResponse:${this.engine.isWaitingForResponse} stableMs:${nowStableMs} sessionId:${this.engine.getTraceSessionId()} enqueueReason:${oldest.id}`);
+            }, ProviderCliAdapter.STALE_QUEUE_WARN_MS);
+        }
     }
 
     private shouldQueuePendingOutboundMessage(parsedStatusBeforeSend: any | null = null): string | null {
@@ -1785,6 +1819,11 @@ export class ProviderCliAdapter implements CliAdapter {
                 try {
                     await this.sendMessageNow(next.content, false, next.meshTaskId);
                     this.pendingOutboundQueue.shift();
+                    // Clear stale watchdog once the queue drains.
+                    if (this.pendingOutboundQueue.length === 0 && this.pendingOutboundStaleTimer) {
+                        clearTimeout(this.pendingOutboundStaleTimer);
+                        this.pendingOutboundStaleTimer = null;
+                    }
                     this.onStatusChange?.();
                 } catch (error: any) {
                     LOG.warn('CLI', `[${this.cliType}] queued outbound flush failed: ${error?.message || error}`);
@@ -2174,6 +2213,7 @@ export class ProviderCliAdapter implements CliAdapter {
         this.pendingTerminalQueryTail = '';
         this.ptyOutputChunks = [];
         if (this.pendingOutboundFlushTimer) { clearTimeout(this.pendingOutboundFlushTimer); this.pendingOutboundFlushTimer = null; }
+        if (this.pendingOutboundStaleTimer) { clearTimeout(this.pendingOutboundStaleTimer); this.pendingOutboundStaleTimer = null; }
         this.pendingOutboundQueue = [];
         this.pendingOutboundFlushInFlight = false;
         if (this.ptyProcess) {
@@ -2197,6 +2237,7 @@ export class ProviderCliAdapter implements CliAdapter {
         this.pendingTerminalQueryTail = '';
         this.ptyOutputChunks = [];
         if (this.pendingOutboundFlushTimer) { clearTimeout(this.pendingOutboundFlushTimer); this.pendingOutboundFlushTimer = null; }
+        if (this.pendingOutboundStaleTimer) { clearTimeout(this.pendingOutboundStaleTimer); this.pendingOutboundStaleTimer = null; }
         this.pendingOutboundQueue = [];
         this.pendingOutboundFlushInFlight = false;
         if (this.ptyProcess) {

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[] {