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

package/dist/cli-adapters/provider-cli-adapter.d.ts

@@ -64,6 +64,7 @@ export declare class ProviderCliAdapter implements CliAdapter {
     private pendingOutboundQueue;
     private pendingOutboundFlushTimer;
     private pendingOutboundFlushInFlight;
+    private pendingOutboundStaleTimer;
     private submitRetryTimer;
     private ptyWriteChain;
     private resizeSuppressUntil;
@@ -264,6 +265,7 @@ export declare class ProviderCliAdapter implements CliAdapter {
     }): Promise<void>;
     forceSendMessage(text: string, meshTaskId?: string): Promise<void>;
     private waitForForceSubmitSettle;
+    private static readonly STALE_QUEUE_WARN_MS;
     private enqueuePendingOutboundMessage;
     private shouldQueuePendingOutboundMessage;
     private schedulePendingOutboundFlush;

package/dist/index.d.ts

@@ -53,7 +53,7 @@ export { MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS, MESH_WORKTREE_BOOTSTRAP_CONFI
 export type { MeshRefineValidationCategory, MeshRefineValidationCommandPlan, MeshRefineValidationPlan, RepoMeshRefineConfig, RepoMeshRefineValidationCommandConfig, } from './mesh/refine-config.js';
 export { loadRepoSettings } from './config/repo-settings.js';
 export type { RepoSettings, LoadRepoSettingsOptions } from './config/repo-settings.js';
-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/dist/index.js

@@ -791,10 +791,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "dd0a9d78c0de3a18edc594b4ae7b39afac2d6b83" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "dd0a9d78" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "1.0.28-rc.6" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-25T07:34:35.835Z" : void 0);
+  const commit = readInjected(true ? "cb5f0a4f64296587a261176e08731f2f3ed78766" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "cb5f0a4f" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "1.0.28-rc.8" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-25T12:20:55.839Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -7731,6 +7731,10 @@ var init_mesh_runtime_store = __esm({
                 node_id TEXT,
                 session_id TEXT,
                 provider_type TEXT,
+                -- LEDGER-TASK-TRACEABILITY (B): the task a lifecycle entry pertains to,
+                -- promoted from payload.taskId so kind+task_id joins are index-backed
+                -- (legacy DBs get this column via migrateMeshIsolationColumns' ALTER).
+                task_id TEXT,
                 payload TEXT NOT NULL DEFAULT '{}'
             );
 
@@ -7902,6 +7906,15 @@ var init_mesh_runtime_store = __esm({
             `);
           this.db.exec(`DROP TABLE IF EXISTS mesh_direct_delivered_events`);
           this.db.exec(`DROP TABLE IF EXISTS mesh_completion_conflicts`);
+          const ledgerCols = this.tableColumns("mesh_event_ledger");
+          if (!ledgerCols.has("task_id")) {
+            this.db.exec(`ALTER TABLE mesh_event_ledger ADD COLUMN task_id TEXT`);
+          }
+          this.db.exec(`
+                CREATE INDEX IF NOT EXISTS idx_mesh_event_ledger_task
+                    ON mesh_event_ledger(mesh_id, task_id, timestamp)
+                    WHERE task_id IS NOT NULL
+            `);
         } catch (err) {
           if (!loggedMigrationFailure) {
             loggedMigrationFailure = true;
@@ -8853,8 +8866,8 @@ var init_mesh_runtime_store = __esm({
         }
         this.db.prepare(
           `INSERT OR IGNORE INTO mesh_event_ledger
-             (id, mesh_id, timestamp, kind, node_id, session_id, provider_type, payload)
-             VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+             (id, mesh_id, timestamp, kind, node_id, session_id, provider_type, task_id, payload)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
         ).run(
           entry.id,
           entry.meshId,
@@ -8863,6 +8876,7 @@ var init_mesh_runtime_store = __esm({
           entry.nodeId ?? null,
           entry.sessionId ?? null,
           entry.providerType ?? null,
+          entry.taskId ?? null,
           JSON.stringify(entry.payload ?? {})
         );
         this.maybeCheckpointWal();
@@ -8893,6 +8907,7 @@ var init_mesh_runtime_store = __esm({
           nodeId: r.node_id,
           sessionId: r.session_id,
           providerType: r.provider_type,
+          taskId: r.task_id ?? null,
           payload: (() => {
             try {
               return JSON.parse(r.payload);
@@ -8939,6 +8954,7 @@ var init_mesh_runtime_store = __esm({
           nodeId: r.node_id,
           sessionId: r.session_id,
           providerType: r.provider_type,
+          taskId: r.task_id ?? null,
           payload: (() => {
             try {
               return JSON.parse(r.payload);
@@ -8980,8 +8996,8 @@ var init_mesh_runtime_store = __esm({
         let imported = 0;
         const stmt = this.db.prepare(
           `INSERT OR IGNORE INTO mesh_event_ledger
-             (id, mesh_id, timestamp, kind, node_id, session_id, provider_type, payload)
-             VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+             (id, mesh_id, timestamp, kind, node_id, session_id, provider_type, task_id, payload)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
         );
         this.db.transaction(() => {
           for (const e of entries) {
@@ -8994,6 +9010,7 @@ var init_mesh_runtime_store = __esm({
               e.nodeId ?? null,
               e.sessionId ?? null,
               e.providerType ?? null,
+              e.taskId ?? null,
               JSON.stringify(e.payload ?? {})
             );
             if (result.changes > 0) imported++;
@@ -9373,6 +9390,7 @@ __export(mesh_ledger_exports, {
   isIntentionalCleanupStopEntry: () => isIntentionalCleanupStopEntry,
   isNoteExpired: () => isNoteExpired,
   isOperatingNoteTombstoned: () => isOperatingNoteTombstoned,
+  ledgerEntryTaskId: () => ledgerEntryTaskId,
   meshLedgerEvents: () => meshLedgerEvents,
   normalizeMeshWorkerResult: () => normalizeMeshWorkerResult,
   pruneOperatingNotes: () => pruneOperatingNotes,
@@ -9382,6 +9400,11 @@ __export(mesh_ledger_exports, {
   readOperatingNotes: () => readOperatingNotes,
   tombstoneOperatingNote: () => tombstoneOperatingNote
 });
+function ledgerEntryTaskId(entry) {
+  if (typeof entry.taskId === "string" && entry.taskId.trim()) return entry.taskId.trim();
+  const fromPayload = entry.payload && typeof entry.payload === "object" ? entry.payload.taskId : void 0;
+  return typeof fromPayload === "string" && fromPayload.trim() ? fromPayload.trim() : void 0;
+}
 function isIntentionalCleanupStopEntry(entry) {
   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) ? entry.payload : {};
@@ -9690,6 +9713,10 @@ function appendLedgerEntry(meshId, partial) {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     ...partial
   };
+  if (!entry.taskId && TASK_LIFECYCLE_LEDGER_KINDS.has(entry.kind)) {
+    const derived = ledgerEntryTaskId(entry);
+    if (derived) entry.taskId = derived;
+  }
   const filePath = getLedgerPath(meshId);
   if ((0, import_fs7.existsSync)(filePath)) {
     try {
@@ -9711,6 +9738,7 @@ function appendLedgerEntry(meshId, partial) {
       nodeId: entry.nodeId ?? null,
       sessionId: entry.sessionId ?? null,
       providerType: entry.providerType ?? null,
+      taskId: entry.taskId ?? null,
       payload: entry.payload
     });
   } catch {
@@ -9891,7 +9919,13 @@ function readLedgerFile(meshId) {
     if (!line.trim()) continue;
     try {
       const entry = JSON.parse(line);
-      if (entry.id && entry.kind) entries.push(entry);
+      if (entry.id && entry.kind) {
+        if (!entry.taskId) {
+          const derived = ledgerEntryTaskId(entry);
+          if (derived) entry.taskId = derived;
+        }
+        entries.push(entry);
+      }
     } catch {
     }
   }
@@ -9915,6 +9949,7 @@ function ensureLedgerImported(store, meshId) {
       nodeId: e.nodeId ?? null,
       sessionId: e.sessionId ?? null,
       providerType: e.providerType ?? null,
+      taskId: ledgerEntryTaskId(e) ?? null,
       payload: e.payload ?? {}
     })));
   } catch {
@@ -9923,16 +9958,21 @@ function ensureLedgerImported(store, meshId) {
 function readLedgerFromStore(meshId) {
   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,
-    ...r.nodeId ? { nodeId: r.nodeId } : {},
-    ...r.sessionId ? { sessionId: r.sessionId } : {},
-    ...r.providerType ? { providerType: r.providerType } : {},
-    payload: r.payload && typeof r.payload === "object" ? r.payload : {}
-  }));
+  return store.readLedgerEntriesOrdered(meshId).map((r) => {
+    const payload = r.payload && typeof r.payload === "object" ? r.payload : {};
+    const taskId = ledgerEntryTaskId({ taskId: r.taskId ?? void 0, payload });
+    return {
+      id: r.id,
+      meshId: r.meshId,
+      timestamp: r.timestamp,
+      kind: r.kind,
+      ...r.nodeId ? { nodeId: r.nodeId } : {},
+      ...r.sessionId ? { sessionId: r.sessionId } : {},
+      ...r.providerType ? { providerType: r.providerType } : {},
+      ...taskId ? { taskId } : {},
+      payload
+    };
+  });
 }
 function getCachedRawEntries(meshId) {
   const now = Date.now();
@@ -10159,7 +10199,7 @@ function rotateLedgerFile(meshId, currentPath) {
 `);
   }
 }
-var import_fs7, import_path7, import_crypto8, import_events, LEDGER_DIR_NAME, MAX_FILE_SIZE_BYTES, COMPACT_THRESHOLD_BYTES, ARCHIVE_TERMINAL_OLDER_THAN_MS, RECENT_FAILURE_WINDOW_MS, ARCHIVABLE_KINDS, DEFAULT_LEDGER_SLICE_LIMIT, MAX_LEDGER_SLICE_LIMIT, OPERATING_NOTE_KIND, OPERATING_NOTE_TOMBSTONE_KIND, OPERATING_NOTE_DEDUPE_WINDOW, OPERATING_NOTE_KEEP_LATEST, OPERATING_NOTE_CATEGORY_TTL_DAYS, MS_PER_DAY, meshLedgerEvents, ledgerReadCache, LEDGER_CACHE_TTL_MS, ledgerImportStoreRef, ledgerImportDone;
+var import_fs7, import_path7, import_crypto8, import_events, TASK_LIFECYCLE_LEDGER_KINDS, LEDGER_DIR_NAME, MAX_FILE_SIZE_BYTES, COMPACT_THRESHOLD_BYTES, ARCHIVE_TERMINAL_OLDER_THAN_MS, RECENT_FAILURE_WINDOW_MS, ARCHIVABLE_KINDS, DEFAULT_LEDGER_SLICE_LIMIT, MAX_LEDGER_SLICE_LIMIT, OPERATING_NOTE_KIND, OPERATING_NOTE_TOMBSTONE_KIND, OPERATING_NOTE_DEDUPE_WINDOW, OPERATING_NOTE_KEEP_LATEST, OPERATING_NOTE_CATEGORY_TTL_DAYS, MS_PER_DAY, meshLedgerEvents, ledgerReadCache, LEDGER_CACHE_TTL_MS, ledgerImportStoreRef, ledgerImportDone;
 var init_mesh_ledger = __esm({
   "src/mesh/mesh-ledger.ts"() {
     "use strict";
@@ -10171,6 +10211,17 @@ var init_mesh_ledger = __esm({
     import_events = require("events");
     init_mesh_runtime_store();
     init_contracts();
+    TASK_LIFECYCLE_LEDGER_KINDS = /* @__PURE__ */ new Set([
+      "task_dispatched",
+      "task_claimed",
+      "task_completed",
+      "task_failed",
+      "task_stalled",
+      "task_reclaimed",
+      "task_approval_needed",
+      "task_question_pending",
+      "p2p_dispatch_failed"
+    ]);
     LEDGER_DIR_NAME = "mesh-ledger";
     MAX_FILE_SIZE_BYTES = 10 * 1024 * 1024;
     COMPACT_THRESHOLD_BYTES = 2 * 1024 * 1024;
@@ -19156,6 +19207,43 @@ async function waitForLocalSessionReady(components, sessionId) {
   }
   LOG.warn("MeshQueue", `Auto-launched session ${sessionId} not interactive after ${LOCAL_LAUNCH_READY_TIMEOUT_MS}ms; dispatching anyway (adapter queue-until-ready will buffer)`);
 }
+function recordTaskDispatchedLedger(ctx, deliveryId) {
+  const task = ctx.task;
+  const routing = ctx.routingDecision;
+  const routingDecision = {
+    source: routing?.source ?? "queue",
+    selectedNodeId: ctx.nodeId,
+    ...localCoordinatorDaemonId() ? { daemonId: localCoordinatorDaemonId() } : {},
+    transport: ctx.transport,
+    // D: resolved execution profile — prefer the caller's resolved values, fall back
+    // to what the claimed task row carries (queue/idle drains carry it on the task).
+    resolvedProviderType: routing?.resolvedProviderType ?? ctx.providerType,
+    ...routing?.resolvedModel ?? task.model ? { resolvedModel: routing?.resolvedModel ?? task.model } : {},
+    ...routing?.resolvedThinkingLevel ?? task.thinkingLevel ? { resolvedThinkingLevel: routing?.resolvedThinkingLevel ?? task.thinkingLevel } : {},
+    ...routing?.resolvedDifficulty ?? task.difficulty ? { resolvedDifficulty: routing?.resolvedDifficulty ?? task.difficulty } : {},
+    ...typeof routing?.fitnessScore === "number" ? { fitnessScore: routing.fitnessScore } : {},
+    ...routing?.skippedCandidates?.length ? { skippedCandidates: routing.skippedCandidates } : {},
+    ...routing?.requiredTagsResult ? { requiredTagsResult: routing.requiredTagsResult } : {},
+    ...routing?.reason ? { reason: routing.reason } : {}
+  };
+  appendLedgerEntry(ctx.meshId, {
+    kind: "task_dispatched",
+    nodeId: ctx.nodeId,
+    sessionId: ctx.sessionId,
+    providerType: ctx.providerType,
+    taskId: task.id,
+    payload: {
+      taskId: task.id,
+      ...task.missionId ? { missionId: task.missionId } : {},
+      deliveryId,
+      transport: ctx.transport,
+      ...ctx.sourceCoordinatorSessionId ? { coordinatorSessionId: ctx.sourceCoordinatorSessionId } : {},
+      ...ctx.sourceCoordinatorDaemonId ? { coordinatorDaemonId: ctx.sourceCoordinatorDaemonId } : {},
+      ...Array.isArray(task.requiredTags) && task.requiredTags.length ? { requiredTags: task.requiredTags } : {},
+      routingDecision
+    }
+  });
+}
 function deliverTaskToSession(dispatchThunk, ctx, warmup) {
   const delivery = createSessionDelivery({
     meshId: ctx.meshId,
@@ -19169,6 +19257,10 @@ function deliverTaskToSession(dispatchThunk, ctx, warmup) {
     ...ctx.sourceCoordinatorSessionId ? { sourceCoordinatorSessionId: ctx.sourceCoordinatorSessionId } : {},
     ...ctx.sourceCoordinatorDaemonId ? { sourceCoordinatorDaemonId: ctx.sourceCoordinatorDaemonId } : {}
   });
+  try {
+    recordTaskDispatchedLedger(ctx, delivery.id);
+  } catch {
+  }
   let dispatchPromise;
   try {
     dispatchPromise = Promise.resolve(dispatchThunk());
@@ -19232,7 +19324,7 @@ function resolveClaimingSessionTranscriptProfile(components, sessionId) {
     return void 0;
   }
 }
-function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType) {
+function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType, routingDecision) {
   const mesh = getMeshWithCache(components, meshId);
   const node = mesh?.nodes.find((n) => meshNodeIdMatches(n, nodeId));
   if (isWorkspaceAutoFastForwardInFlight(readNonEmptyString(node?.workspace))) {
@@ -19309,6 +19401,24 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
     return false;
   }
   LOG.info("MeshQueue", `Node ${nodeId} (${sessionId}) pulled task ${task.id}`);
+  try {
+    appendLedgerEntry(meshId, {
+      kind: "task_claimed",
+      nodeId,
+      sessionId,
+      providerType,
+      taskId: task.id,
+      payload: {
+        taskId: task.id,
+        ...task.missionId ? { missionId: task.missionId } : {},
+        nodeId,
+        sessionId,
+        providerType,
+        claimedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    });
+  } catch {
+  }
   retractActionableSkipIfPreviouslyNotified(meshId, task.id);
   beginTaskDispatchInFlight(meshId, task.id);
   const silentIdlePushOnDispatch = resolveCoordinatorIdlePushPolicy(mesh?.policy) === "auto_silent_on_dispatch";
@@ -19346,7 +19456,8 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
           task,
           transport: "remote",
           ...sourceCoordinatorSessionId ? { sourceCoordinatorSessionId } : {},
-          ...localDaemonIdForDispatch ? { sourceCoordinatorDaemonId: localDaemonIdForDispatch } : {}
+          ...localDaemonIdForDispatch ? { sourceCoordinatorDaemonId: localDaemonIdForDispatch } : {},
+          ...routingDecision ? { routingDecision } : {}
         },
         // Warmup-aware deadline: this dispatch can be the FIRST command to a
         // peer whose mesh DataChannel is still opening — charge the cold-open
@@ -19413,7 +19524,8 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
       task,
       transport: "local",
       ...readNonEmptyString(task.sourceCoordinatorSessionId) ? { sourceCoordinatorSessionId: readNonEmptyString(task.sourceCoordinatorSessionId) } : {},
-      ...localCoordinatorDaemonId() ? { sourceCoordinatorDaemonId: localCoordinatorDaemonId() } : {}
+      ...localCoordinatorDaemonId() ? { sourceCoordinatorDaemonId: localCoordinatorDaemonId() } : {},
+      ...routingDecision ? { routingDecision } : {}
     }
   );
   return true;
@@ -19851,11 +19963,16 @@ function recordAutoLaunchEvent(meshId, args) {
       nodeId: args.nodeId,
       sessionId: args.sessionId,
       providerType: args.providerType,
+      // (B) promote taskId so this entry joins the task lifecycle timeline.
+      ...args.taskId ? { taskId: args.taskId } : {},
       payload: {
         phase: args.phase,
         taskId: args.taskId,
         reason: args.reason,
-        error: args.error
+        error: args.error,
+        // (D) resolved execution profile for the spawned worker.
+        ...args.model ? { resolvedModel: args.model } : {},
+        ...args.thinkingLevel ? { resolvedThinkingLevel: args.thinkingLevel } : {}
       }
     });
   } catch (e) {
@@ -19877,7 +19994,9 @@ function markAutoLaunch(meshId, taskId, args) {
     providerType: args.providerType,
     sessionId: args.sessionId,
     reason: args.reason,
-    error: args.error
+    error: args.error,
+    ...args.model ? { model: args.model } : {},
+    ...args.thinkingLevel ? { thinkingLevel: args.thinkingLevel } : {}
   });
   if (args.status === "skipped") {
     if (isActionableSkipReason(args.reason)) {
@@ -20077,6 +20196,14 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
       // pass it through for the 'fitness' strategy's task→slot ranking.
       { bumpCursor: true, task: { difficulty: task.difficulty, requiredTags: task.requiredTags } }
     ).map((c) => c.node);
+    const skippedCandidates = [];
+    const SKIPPED_CANDIDATES_MAX = 12;
+    const markSkip = (nodeIdForSkip, reason, extra) => {
+      markAutoLaunch(meshId, task.id, { status: "skipped", reason, nodeId: nodeIdForSkip, ...extra || {} });
+      if (nodeIdForSkip && skippedCandidates.length < SKIPPED_CANDIDATES_MAX) {
+        skippedCandidates.push({ nodeId: nodeIdForSkip, reason });
+      }
+    };
     for (const node of orderedCandidateNodes) {
       const nodeId = readMeshNodeId(node);
       if (!nodeId) continue;
@@ -20085,50 +20212,50 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
       const cooldownUntil = autoLaunchCooldownUntil.get(launchKey) || 0;
       if (cooldownUntil > 0 && now >= cooldownUntil) autoLaunchCooldownUntil.delete(launchKey);
       if (autoLaunchInProgress.has(launchKey)) {
-        markAutoLaunch(meshId, task.id, { status: "skipped", reason: "auto_launch_in_progress", nodeId });
+        markSkip(nodeId, "auto_launch_in_progress");
         continue;
       }
       if (now < cooldownUntil) {
-        markAutoLaunch(meshId, task.id, { status: "skipped", reason: "auto_launch_cooldown", nodeId });
+        markSkip(nodeId, "auto_launch_cooldown");
         continue;
       }
       if (isDirtyNode(node)) {
-        markAutoLaunch(meshId, task.id, { status: "skipped", reason: "dirty_workspace", nodeId });
+        markSkip(nodeId, "dirty_workspace");
         continue;
       }
       if (!isLaunchableNode(node)) {
-        markAutoLaunch(meshId, task.id, { status: "skipped", reason: "node_not_launch_ready", nodeId });
+        markSkip(nodeId, "node_not_launch_ready");
         continue;
       }
       if (!isMeshNodeFreshEnoughToLaunch(node, freshnessGate)) {
-        markAutoLaunch(meshId, task.id, { status: "skipped", reason: "node_stale_behind_upstream", nodeId });
+        markSkip(nodeId, "node_stale_behind_upstream");
         continue;
       }
       const launchTarget = resolveAutoLaunchTarget(components, node);
       if (launchTarget.mode === "skip") {
-        markAutoLaunch(meshId, task.id, { status: "skipped", reason: launchTarget.reason || "auto_launch_unavailable", nodeId });
+        markSkip(nodeId, launchTarget.reason || "auto_launch_unavailable");
         autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
         sweepExpiredCooldowns();
         continue;
       }
       if (nodeHasLiveSessionPendingClaim(components, meshId, nodeId, task, node)) {
-        markAutoLaunch(meshId, task.id, { status: "skipped", reason: "node_has_live_session_pending_claim", nodeId });
+        markSkip(nodeId, "node_has_live_session_pending_claim");
         continue;
       }
       if (!isTaskReadonly(task) && nodeHasActiveAssignment(meshId, nodeId)) {
-        markAutoLaunch(meshId, task.id, { status: "skipped", reason: "node_has_active_assignment", nodeId });
+        markSkip(nodeId, "node_has_active_assignment");
         continue;
       }
       const maxConcurrentSessions = Number(node?.policy?.maxConcurrentSessions);
       if (Number.isFinite(maxConcurrentSessions) && maxConcurrentSessions >= 0 && liveSessionCountForNode(components, meshId, nodeId) >= maxConcurrentSessions) {
-        markAutoLaunch(meshId, task.id, { status: "skipped", reason: "max_concurrent_sessions_reached", nodeId });
+        markSkip(nodeId, "max_concurrent_sessions_reached");
         continue;
       }
       autoLaunchInProgress.add(launchKey);
       try {
         const resolved = await resolveUsableProvider(components, nodeId, node, task.requiredTags, { difficulty: task.difficulty, requiredTags: task.requiredTags });
         if (!resolved.providerType) {
-          markAutoLaunch(meshId, task.id, { status: "skipped", reason: resolved.reason || "provider_unusable", nodeId });
+          markSkip(nodeId, resolved.reason || "provider_unusable");
           continue;
         }
         const rawEffectiveModel = typeof task.model === "string" && task.model.trim() ? task.model.trim() : resolved.model;
@@ -20139,7 +20266,7 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
         }
         const providerCap = resolveProviderMaxParallel(resolveNodeCapabilitySlots(node), resolved.providerType);
         if (providerCap !== void 0 && activeProviderAssignedCount(meshId, nodeId, resolved.providerType) >= providerCap) {
-          markAutoLaunch(meshId, task.id, { status: "skipped", reason: "max_provider_parallel_reached", nodeId, providerType: resolved.providerType });
+          markSkip(nodeId, "max_provider_parallel_reached", { providerType: resolved.providerType });
           continue;
         }
         const launchSettings = {
@@ -20167,7 +20294,7 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
             meshCoordinatorDaemonId: launchTarget.coordinatorDaemonId,
             meshCoordinatorNodeId: nodeId
           };
-          markAutoLaunch(meshId, task.id, { status: "started", nodeId, providerType: resolved.providerType });
+          markAutoLaunch(meshId, task.id, { status: "started", nodeId, providerType: resolved.providerType, ...effectiveModel ? { model: effectiveModel } : {}, ...effectiveThinkingLevel ? { thinkingLevel: effectiveThinkingLevel } : {} });
           let launchResult2;
           try {
             launchResult2 = await components.dispatchMeshCommand(launchTarget.daemonId, "launch_cli", withStatusProbeMarker({
@@ -20196,12 +20323,12 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
             return false;
           }
           const remoteSessionId = readNonEmptyString(payload.sessionId) || readNonEmptyString(payload.id) || readNonEmptyString(payload.runtimeSessionId);
-          markAutoLaunch(meshId, task.id, { status: "completed", nodeId, providerType: resolved.providerType, sessionId: remoteSessionId || void 0 });
+          markAutoLaunch(meshId, task.id, { status: "completed", nodeId, providerType: resolved.providerType, sessionId: remoteSessionId || void 0, ...effectiveModel ? { model: effectiveModel } : {}, ...effectiveThinkingLevel ? { thinkingLevel: effectiveThinkingLevel } : {} });
           autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
           sweepExpiredCooldowns();
           return true;
         }
-        markAutoLaunch(meshId, task.id, { status: "started", nodeId, providerType: resolved.providerType });
+        markAutoLaunch(meshId, task.id, { status: "started", nodeId, providerType: resolved.providerType, ...effectiveModel ? { model: effectiveModel } : {}, ...effectiveThinkingLevel ? { thinkingLevel: effectiveThinkingLevel } : {} });
         const launchResult = await components.cliManager.handleCliCommand("launch_cli", {
           cliType: resolved.providerType,
           dir: node.workspace,
@@ -20226,9 +20353,25 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
           sweepExpiredCooldowns();
           return false;
         }
-        markAutoLaunch(meshId, task.id, { status: "completed", nodeId, providerType: resolved.providerType, sessionId });
+        markAutoLaunch(meshId, task.id, { status: "completed", nodeId, providerType: resolved.providerType, sessionId, ...effectiveModel ? { model: effectiveModel } : {}, ...effectiveThinkingLevel ? { thinkingLevel: effectiveThinkingLevel } : {} });
         await waitForLocalSessionReady(components, sessionId);
-        tryAssignQueueTask(components, meshId, nodeId, sessionId, resolved.providerType);
+        const requiredTags = Array.isArray(task.requiredTags) ? task.requiredTags.filter((t) => !!t) : [];
+        const routingDecision = {
+          source: "autoLaunch",
+          fitnessScore: nodeFitnessForTask(node, { difficulty: task.difficulty, requiredTags: task.requiredTags }),
+          ...skippedCandidates.length ? { skippedCandidates } : {},
+          requiredTagsResult: {
+            required: requiredTags,
+            satisfied: !requiredTags.length || nodeSatisfiesRequiredTags(requiredTags, buildMeshNodeCapabilityTags(node, resolved.providerType)),
+            missing: requiredTags.filter((t) => !buildMeshNodeCapabilityTags(node, resolved.providerType).includes(t))
+          },
+          resolvedProviderType: resolved.providerType,
+          ...effectiveModel ? { resolvedModel: effectiveModel } : {},
+          ...effectiveThinkingLevel ? { resolvedThinkingLevel: effectiveThinkingLevel } : {},
+          ...task.difficulty ? { resolvedDifficulty: String(task.difficulty) } : {},
+          ...resolved.reason ? { reason: resolved.reason } : {}
+        };
+        tryAssignQueueTask(components, meshId, nodeId, sessionId, resolved.providerType, routingDecision);
         return true;
       } catch (e) {
         markAutoLaunch(meshId, task.id, { status: "failed", error: e?.message || String(e), nodeId });
@@ -29757,7 +29900,7 @@ var init_cli_state_engine = __esm({
         return true;
       }
       shouldDeferFinishForTranscript(parsed) {
-        const requiresFinalAssistant = !!this.provider.requiresFinalAssistantBeforeIdle;
+        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() : "";
@@ -30169,6 +30312,9 @@ var init_provider_cli_adapter = __esm({
       pendingOutboundQueue = [];
       pendingOutboundFlushTimer = null;
       pendingOutboundFlushInFlight = false;
+      // Stale-queue watchdog: fires STALE_QUEUE_WARN_MS after the oldest queued
+      // message was enqueued if nothing has been flushed yet.
+      pendingOutboundStaleTimer = null;
       // Submit retry timer — PTY-level, not state machine
       submitRetryTimer = null;
       // PTY-WRITE-SERIALIZE: a single per-session tail promise that serializes every
@@ -31202,6 +31348,9 @@ ${lastSnapshot}`;
       async waitForForceSubmitSettle() {
         await new Promise((resolve28) => setTimeout(resolve28, 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).
+      static STALE_QUEUE_WARN_MS = 15e3;
       enqueuePendingOutboundMessage(text, reason, meshTaskId) {
         const content = String(text || "");
         const duplicate = this.pendingOutboundQueue.some((message2) => message2.content === content);
@@ -31209,6 +31358,16 @@ ${lastSnapshot}`;
           return;
         }
         const queuedAt = Date.now();
+        const stableMs = this.lastScreenChangeAt ? queuedAt - this.lastScreenChangeAt : -1;
+        const gateContext = {
+          reason,
+          startupParseGate: this.startupParseGate,
+          ready: this.ready,
+          engineStatus: this.engine.currentStatus,
+          isWaitingForResponse: this.engine.isWaitingForResponse,
+          stableMs,
+          sessionId: this.engine.getTraceSessionId()
+        };
         const message = {
           id: `${queuedAt}:${this.pendingOutboundQueue.length}:${Math.random().toString(36).slice(2, 10)}`,
           role: "user",
@@ -31218,8 +31377,18 @@ ${lastSnapshot}`;
           ...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?.();
+        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) / 1e3).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);
+        }
       }
       shouldQueuePendingOutboundMessage(parsedStatusBeforeSend = null) {
         if (this.provider.allowInputDuringGeneration === true) return null;
@@ -31260,6 +31429,10 @@ ${lastSnapshot}`;
             try {
               await this.sendMessageNow(next.content, false, next.meshTaskId);
               this.pendingOutboundQueue.shift();
+              if (this.pendingOutboundQueue.length === 0 && this.pendingOutboundStaleTimer) {
+                clearTimeout(this.pendingOutboundStaleTimer);
+                this.pendingOutboundStaleTimer = null;
+              }
               this.onStatusChange?.();
             } catch (error) {
               LOG.warn("CLI", `[${this.cliType}] queued outbound flush failed: ${error?.message || error}`);
@@ -31591,6 +31764,10 @@ ${lastSnapshot}`;
           clearTimeout(this.pendingOutboundFlushTimer);
           this.pendingOutboundFlushTimer = null;
         }
+        if (this.pendingOutboundStaleTimer) {
+          clearTimeout(this.pendingOutboundStaleTimer);
+          this.pendingOutboundStaleTimer = null;
+        }
         this.pendingOutboundQueue = [];
         this.pendingOutboundFlushInFlight = false;
         if (this.ptyProcess) {
@@ -31619,6 +31796,10 @@ ${lastSnapshot}`;
           clearTimeout(this.pendingOutboundFlushTimer);
           this.pendingOutboundFlushTimer = null;
         }
+        if (this.pendingOutboundStaleTimer) {
+          clearTimeout(this.pendingOutboundStaleTimer);
+          this.pendingOutboundStaleTimer = null;
+        }
         this.pendingOutboundQueue = [];
         this.pendingOutboundFlushInFlight = false;
         if (this.ptyProcess) {
@@ -32663,6 +32844,7 @@ __export(index_exports, {
   killIdeProcess: () => killIdeProcess,
   launchIDE: () => launchIDE,
   launchWithCdp: () => launchWithCdp,
+  ledgerEntryTaskId: () => ledgerEntryTaskId,
   listCoordinatorsForWorkspace: () => listCoordinatorsForWorkspace,
   listHostedCliRuntimes: () => listHostedCliRuntimes,
   listMagiKindPanels: () => listMagiKindPanels,
@@ -52762,7 +52944,12 @@ ${buttons.join("\n")}`;
       fcFinalSummary = extractFinalSummaryFromMessages(evidence.messages);
     } catch {
     }
-    const missingEvidence = (resolveTranscriptAuthorityProfile(this.provider).timing === "floor" || fcEvidenceSource === "external-native") && !fcFinalSummary;
+    const synthTiming = resolveTranscriptAuthorityProfile(this.provider).timing;
+    const missingEvidence = (synthTiming === "floor" || synthTiming === "hold" || fcEvidenceSource === "external-native") && !fcFinalSummary;
+    if (missingEvidence && synthTiming === "hold") {
+      LOG.info("CLI", `[${this.type}] ${reason} held: hold-class transcript not yet landed (source=${fcEvidenceSource})`);
+      return false;
+    }
     const hasMeshContext = !!(this.settings.meshNodeFor || this.settings.meshActiveTaskId || this.settings.launchedByCoordinator);
     if (missingEvidence && !hasMeshContext) {
       LOG.info("CLI", `[${this.type}] ${reason} suppressed: missing final assistant evidence, no mesh context (source=${fcEvidenceSource})`);
@@ -77872,6 +78059,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   killIdeProcess,
   launchIDE,
   launchWithCdp,
+  ledgerEntryTaskId,
   listCoordinatorsForWorkspace,
   listHostedCliRuntimes,
   listMagiKindPanels,