@adhdev/daemon-standalone 0.9.82-rc.196 → 0.9.82-rc.198

package/dist/index.js

@@ -38227,6 +38227,49 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
                 metadata TEXT,
                 PRIMARY KEY (node_id, session_id)
             );
+
+            CREATE TABLE IF NOT EXISTS mesh_session_delivery (
+                id TEXT PRIMARY KEY,
+                mesh_id TEXT NOT NULL,
+                node_id TEXT,
+                session_id TEXT,
+                provider_type TEXT,
+                task_id TEXT,
+                kind TEXT NOT NULL,
+                priority INTEGER NOT NULL DEFAULT 0,
+                message TEXT NOT NULL,
+                status TEXT NOT NULL DEFAULT 'queued',
+                deliver_after TEXT,
+                expires_at TEXT,
+                attempt_count INTEGER NOT NULL DEFAULT 0,
+                source_coordinator_session_id TEXT,
+                source_coordinator_daemon_id TEXT,
+                last_error TEXT,
+                created_at TEXT NOT NULL,
+                updated_at TEXT NOT NULL
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_mesh_session_delivery_mesh_status
+                ON mesh_session_delivery(mesh_id, status, created_at);
+            CREATE INDEX IF NOT EXISTS idx_mesh_session_delivery_session
+                ON mesh_session_delivery(mesh_id, session_id, status);
+            CREATE INDEX IF NOT EXISTS idx_mesh_session_delivery_task
+                ON mesh_session_delivery(mesh_id, task_id);
+
+            CREATE TABLE IF NOT EXISTS mesh_completion_conflicts (
+                id TEXT PRIMARY KEY,
+                mesh_id TEXT NOT NULL,
+                fingerprint TEXT NOT NULL,
+                conflicting_task_id TEXT,
+                conflicting_session_id TEXT,
+                original_task_id TEXT,
+                original_session_id TEXT,
+                event TEXT NOT NULL,
+                created_at TEXT NOT NULL
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_mesh_completion_conflicts_mesh
+                ON mesh_completion_conflicts(mesh_id, created_at);
         `);
           }
           hasCompletionFingerprint(fingerprint) {
@@ -38551,6 +38594,131 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
           pruneExpiredRemoteIdleSessions() {
             this.db.prepare("DELETE FROM remote_idle_sessions WHERE expires_at <= ?").run(Date.now());
           }
+          // ── Session Delivery Queue ───────────────────────────────────────────────
+          insertSessionDelivery(entry) {
+            this.db.prepare(`
+            INSERT OR REPLACE INTO mesh_session_delivery (
+                id, mesh_id, node_id, session_id, provider_type, task_id, kind, priority,
+                message, status, deliver_after, expires_at, attempt_count,
+                source_coordinator_session_id, source_coordinator_daemon_id,
+                last_error, created_at, updated_at
+            ) VALUES (
+                @id, @meshId, @nodeId, @sessionId, @providerType, @taskId, @kind, @priority,
+                @message, @status, @deliverAfter, @expiresAt, 0,
+                @sourceCoordinatorSessionId, @sourceCoordinatorDaemonId,
+                NULL, @createdAt, @updatedAt
+            )
+        `).run({
+              id: entry.id,
+              meshId: entry.meshId,
+              nodeId: entry.nodeId ?? null,
+              sessionId: entry.sessionId ?? null,
+              providerType: entry.providerType ?? null,
+              taskId: entry.taskId ?? null,
+              kind: entry.kind,
+              priority: entry.priority ?? 0,
+              message: entry.message,
+              status: entry.status,
+              deliverAfter: entry.deliverAfter ?? null,
+              expiresAt: entry.expiresAt ?? null,
+              sourceCoordinatorSessionId: entry.sourceCoordinatorSessionId ?? null,
+              sourceCoordinatorDaemonId: entry.sourceCoordinatorDaemonId ?? null,
+              createdAt: entry.createdAt,
+              updatedAt: entry.updatedAt
+            });
+            this.maybeCheckpointWal();
+          }
+          updateSessionDeliveryStatus(id, status, opts) {
+            const now = (/* @__PURE__ */ new Date()).toISOString();
+            if (opts?.incrementAttempt) {
+              this.db.prepare(`
+                UPDATE mesh_session_delivery
+                SET status = @status, last_error = @lastError, attempt_count = attempt_count + 1, updated_at = @updatedAt
+                WHERE id = @id
+            `).run({ id, status, lastError: opts?.lastError ?? null, updatedAt: now });
+            } else {
+              this.db.prepare(`
+                UPDATE mesh_session_delivery
+                SET status = @status, last_error = @lastError, updated_at = @updatedAt
+                WHERE id = @id
+            `).run({ id, status, lastError: opts?.lastError ?? null, updatedAt: now });
+            }
+          }
+          getActiveSessionDeliveries(meshId, sessionId) {
+            const now = (/* @__PURE__ */ new Date()).toISOString();
+            const sql = sessionId ? `SELECT * FROM mesh_session_delivery WHERE mesh_id = ? AND session_id = ? AND status NOT IN ('delivered','completed','failed','expired','cancelled') AND (expires_at IS NULL OR expires_at > ?) ORDER BY priority DESC, created_at ASC` : `SELECT * FROM mesh_session_delivery WHERE mesh_id = ? AND status NOT IN ('delivered','completed','failed','expired','cancelled') AND (expires_at IS NULL OR expires_at > ?) ORDER BY priority DESC, created_at ASC`;
+            const rows = sessionId ? this.db.prepare(sql).all(meshId, sessionId, now) : this.db.prepare(sql).all(meshId, now);
+            return rows.map((r) => ({
+              id: r.id,
+              meshId: r.mesh_id,
+              nodeId: r.node_id,
+              sessionId: r.session_id,
+              providerType: r.provider_type,
+              taskId: r.task_id,
+              kind: r.kind,
+              priority: r.priority,
+              message: r.message,
+              status: r.status,
+              deliverAfter: r.deliver_after,
+              expiresAt: r.expires_at,
+              attemptCount: r.attempt_count,
+              sourceCoordinatorSessionId: r.source_coordinator_session_id,
+              sourceCoordinatorDaemonId: r.source_coordinator_daemon_id,
+              lastError: r.last_error,
+              createdAt: r.created_at,
+              updatedAt: r.updated_at
+            }));
+          }
+          expireStaleSessionDeliveries(meshId) {
+            const now = (/* @__PURE__ */ new Date()).toISOString();
+            this.db.prepare(`
+            UPDATE mesh_session_delivery
+            SET status = 'expired', updated_at = ?
+            WHERE mesh_id = ? AND expires_at IS NOT NULL AND expires_at <= ?
+              AND status NOT IN ('delivered','completed','failed','expired','cancelled')
+        `).run(now, meshId, now);
+          }
+          deleteSessionDeliveries(meshId) {
+            this.db.prepare("DELETE FROM mesh_session_delivery WHERE mesh_id = ?").run(meshId);
+          }
+          // ── Completion Conflict Diagnostics ──────────────────────────────────────
+          recordCompletionConflict(entry) {
+            this.db.prepare(`
+            INSERT OR IGNORE INTO mesh_completion_conflicts
+                (id, mesh_id, fingerprint, conflicting_task_id, conflicting_session_id,
+                 original_task_id, original_session_id, event, created_at)
+            VALUES (@id, @meshId, @fingerprint, @conflictingTaskId, @conflictingSessionId,
+                    @originalTaskId, @originalSessionId, @event, @createdAt)
+        `).run({
+              id: entry.id,
+              meshId: entry.meshId,
+              fingerprint: entry.fingerprint,
+              conflictingTaskId: entry.conflictingTaskId ?? null,
+              conflictingSessionId: entry.conflictingSessionId ?? null,
+              originalTaskId: entry.originalTaskId ?? null,
+              originalSessionId: entry.originalSessionId ?? null,
+              event: entry.event,
+              createdAt: entry.createdAt
+            });
+            this.maybeCheckpointWal();
+          }
+          getRecentCompletionConflicts(meshId, limitMs = 60 * 60 * 1e3) {
+            const cutoff = new Date(Date.now() - limitMs).toISOString();
+            const rows = this.db.prepare(
+              "SELECT * FROM mesh_completion_conflicts WHERE mesh_id = ? AND created_at >= ? ORDER BY created_at DESC LIMIT 50"
+            ).all(meshId, cutoff);
+            return rows.map((r) => ({
+              id: r.id,
+              meshId: r.mesh_id,
+              fingerprint: r.fingerprint,
+              conflictingTaskId: r.conflicting_task_id,
+              conflictingSessionId: r.conflicting_session_id,
+              originalTaskId: r.original_task_id,
+              originalSessionId: r.original_session_id,
+              event: r.event,
+              createdAt: r.created_at
+            }));
+          }
         };
       }
     });
@@ -38967,6 +39135,168 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         import_fs8 = require("fs");
       }
     });
+    function resolveDeliveryDecision(sessionStatus, opts) {
+      const status = (sessionStatus || "").trim().toLowerCase();
+      if (!status) {
+        return {
+          decision: "rejected",
+          reason: "unknown_session_status",
+          message: "Session status is unknown. Delivery rejected (fail-closed). Use mesh_launch_session to start a fresh session."
+        };
+      }
+      if (IMMEDIATE_DELIVERY_STATUSES.has(status)) {
+        return {
+          decision: "immediate",
+          reason: `session_${status}`,
+          message: `Session is ${status} \u2014 delivery allowed immediately.`
+        };
+      }
+      if (BUSY_DELIVERY_STATUSES.has(status)) {
+        if (opts?.allowBusyInjection) {
+          return {
+            decision: "immediate",
+            reason: `session_${status}_busy_injection_allowed`,
+            message: `Session is ${status} but provider supports busy injection. Delivered immediately.`
+          };
+        }
+        if (status === "waiting_approval" && opts?.kind === "approval") {
+          return {
+            decision: "immediate",
+            reason: "session_waiting_approval_approval_message",
+            message: "Session is waiting for approval \u2014 approval message delivered immediately."
+          };
+        }
+        return {
+          decision: "queued",
+          reason: `session_${status}_busy`,
+          message: `Session is ${status}. Task queued for delivery when session becomes idle. Do not inject directly into a busy session.`
+        };
+      }
+      if (TERMINAL_DELIVERY_STATUSES.has(status)) {
+        return {
+          decision: "rejected",
+          reason: `session_${status}_terminal`,
+          message: `Session is ${status} (terminal). Delivery rejected. Launch a new session before dispatching tasks.`
+        };
+      }
+      return {
+        decision: "rejected",
+        reason: "unrecognized_session_status",
+        message: `Session status '${sessionStatus}' is not recognized. Delivery rejected (fail-closed). Inspect session state before retrying.`
+      };
+    }
+    function createSessionDelivery(opts) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const id = (0, import_crypto6.randomUUID)();
+      const record2 = {
+        id,
+        meshId: opts.meshId,
+        nodeId: opts.nodeId,
+        sessionId: opts.sessionId,
+        providerType: opts.providerType,
+        taskId: opts.taskId,
+        kind: opts.kind,
+        priority: opts.priority ?? 0,
+        message: opts.message,
+        status: opts.status,
+        deliverAfter: opts.deliverAfter,
+        expiresAt: opts.expiresAt,
+        attemptCount: 0,
+        sourceCoordinatorSessionId: opts.sourceCoordinatorSessionId,
+        sourceCoordinatorDaemonId: opts.sourceCoordinatorDaemonId,
+        createdAt: now,
+        updatedAt: now
+      };
+      MeshRuntimeStore.getInstance().insertSessionDelivery({
+        id,
+        meshId: opts.meshId,
+        nodeId: opts.nodeId,
+        sessionId: opts.sessionId,
+        providerType: opts.providerType,
+        taskId: opts.taskId,
+        kind: opts.kind,
+        priority: opts.priority ?? 0,
+        message: opts.message,
+        status: opts.status,
+        deliverAfter: opts.deliverAfter,
+        expiresAt: opts.expiresAt,
+        sourceCoordinatorSessionId: opts.sourceCoordinatorSessionId,
+        sourceCoordinatorDaemonId: opts.sourceCoordinatorDaemonId,
+        createdAt: now,
+        updatedAt: now
+      });
+      return record2;
+    }
+    function updateSessionDeliveryStatus(id, status, opts) {
+      try {
+        MeshRuntimeStore.getInstance().updateSessionDeliveryStatus(id, status, opts);
+      } catch {
+      }
+    }
+    function getActiveSessionDeliveries(meshId, sessionId) {
+      try {
+        return MeshRuntimeStore.getInstance().getActiveSessionDeliveries(meshId, sessionId);
+      } catch {
+        return [];
+      }
+    }
+    function recordCompletionConflict(opts) {
+      try {
+        MeshRuntimeStore.getInstance().recordCompletionConflict({
+          id: (0, import_crypto6.randomUUID)(),
+          meshId: opts.meshId,
+          fingerprint: opts.fingerprint,
+          conflictingTaskId: opts.conflictingTaskId,
+          conflictingSessionId: opts.conflictingSessionId,
+          originalTaskId: opts.originalTaskId,
+          originalSessionId: opts.originalSessionId,
+          event: opts.event,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      } catch {
+      }
+    }
+    function getRecentCompletionConflicts(meshId, limitMs) {
+      try {
+        return MeshRuntimeStore.getInstance().getRecentCompletionConflicts(meshId, limitMs);
+      } catch {
+        return [];
+      }
+    }
+    var import_crypto6;
+    var IMMEDIATE_DELIVERY_STATUSES;
+    var BUSY_DELIVERY_STATUSES;
+    var TERMINAL_DELIVERY_STATUSES;
+    var init_mesh_delivery_policy = __esm2({
+      "src/mesh/mesh-delivery-policy.ts"() {
+        "use strict";
+        import_crypto6 = require("crypto");
+        init_mesh_runtime_store();
+        IMMEDIATE_DELIVERY_STATUSES = /* @__PURE__ */ new Set([
+          "idle",
+          "waiting_input",
+          "ready"
+        ]);
+        BUSY_DELIVERY_STATUSES = /* @__PURE__ */ new Set([
+          "generating",
+          "running",
+          "streaming",
+          "busy",
+          "starting",
+          "initializing",
+          "waiting_approval"
+        ]);
+        TERMINAL_DELIVERY_STATUSES = /* @__PURE__ */ new Set([
+          "stopped",
+          "failed",
+          "terminated",
+          "exited",
+          "closed",
+          "deleted",
+          "error"
+        ]);
+      }
+    });
     var mesh_events_exports = {};
     __export2(mesh_events_exports, {
       __resetIdleAutoFastForwardForTests: () => __resetIdleAutoFastForwardForTests,
@@ -39310,7 +39640,18 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     function isDuplicateMeshCompletionEvent(args) {
       const fingerprint = buildMeshCompletionFingerprint(args);
       if (!fingerprint) return false;
-      if (hasFingerprintSeen(fingerprint)) return true;
+      if (hasFingerprintSeen(fingerprint)) {
+        if (args.taskId) {
+          recordCompletionConflict({
+            meshId: args.meshId,
+            fingerprint,
+            conflictingTaskId: args.taskId,
+            conflictingSessionId: args.sessionId,
+            event: args.event
+          });
+        }
+        return true;
+      }
       recordFingerprintSeen(fingerprint);
       return false;
     }
@@ -39561,20 +39902,33 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       if (node?.daemonId && components.dispatchMeshCommand) {
         const isLocalNode = components.cliManager.adapters.has(sessionId);
         if (!isLocalNode) {
+          const delivery2 = createSessionDelivery({
+            meshId,
+            nodeId,
+            sessionId,
+            providerType,
+            taskId: task.id,
+            kind: "task",
+            message: task.message,
+            status: "delivering"
+          });
           components.dispatchMeshCommand(node.daemonId, "agent_command", {
             targetSessionId: sessionId,
             cliType: providerType,
             action: "send_chat",
             message: task.message
+          }).then(() => {
+            updateSessionDeliveryStatus(delivery2.id, "delivered");
           }).catch((e) => {
             LOG2.error("MeshQueue", `Failed to dispatch task via P2P to remote node ${nodeId}: ${e?.message}`);
+            updateSessionDeliveryStatus(delivery2.id, "failed", { lastError: e?.message, incrementAttempt: true });
             updateTaskStatus(meshId, task.id, "pending");
             try {
               appendLedgerEntry(meshId, {
                 kind: "dispatch_failed",
                 nodeId,
                 sessionId,
-                payload: { taskId: task.id, error: e?.message, retryable: true }
+                payload: { taskId: task.id, deliveryId: delivery2.id, error: e?.message, retryable: true }
               });
             } catch {
             }
@@ -39582,13 +39936,26 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
           return true;
         }
       }
+      const delivery = createSessionDelivery({
+        meshId,
+        nodeId,
+        sessionId,
+        providerType,
+        taskId: task.id,
+        kind: "task",
+        message: task.message,
+        status: "delivering"
+      });
       components.cliManager.handleCliCommand("agent_command", {
         targetSessionId: sessionId,
         cliType: providerType,
         action: "send_chat",
         message: task.message
+      }).then(() => {
+        updateSessionDeliveryStatus(delivery.id, "delivered");
       }).catch((e) => {
         LOG2.error("MeshQueue", `Failed to dispatch task locally to node ${nodeId}: ${e?.message}`);
+        updateSessionDeliveryStatus(delivery.id, "failed", { lastError: e?.message, incrementAttempt: true });
         updateTaskStatus(meshId, task.id, "failed");
       });
       return true;
@@ -40193,7 +40560,9 @@ Next step: ${nextStep}`;
           finalSummary: readNonEmptyString2(args.metadataEvent.finalSummary) || void 0,
           // Scope dedup to the coordinator daemon so two coordinators for the same mesh
           // don't suppress each other's completion events via shared fingerprint table.
-          coordinatorDaemonId: workerCoordinatorDaemonId || void 0
+          coordinatorDaemonId: workerCoordinatorDaemonId || void 0,
+          taskId: readNonEmptyString2(args.metadataEvent.taskId) || void 0,
+          nodeId: eventNodeId || void 0
         });
         if (duplicateCompletion) {
           LOG2.info("MeshEvents", `Suppressed duplicate completion for mesh ${args.meshId} session ${eventSessionId}`);
@@ -40209,7 +40578,9 @@ Next step: ${nextStep}`;
           providerSessionId: readNonEmptyString2(args.metadataEvent.providerSessionId) || void 0,
           timestamp: eventTimestamp,
           finalSummary: readNonEmptyString2(args.metadataEvent.finalSummary) || void 0,
-          coordinatorDaemonId: workerCoordinatorDaemonId || void 0
+          coordinatorDaemonId: workerCoordinatorDaemonId || void 0,
+          taskId: readNonEmptyString2(args.metadataEvent.taskId) || void 0,
+          nodeId: eventNodeId || void 0
         });
         if (duplicateStopped) {
           LOG2.info("MeshEvents", `Suppressed duplicate stopped event for mesh ${args.meshId} session ${eventSessionId}`);
@@ -40602,6 +40973,7 @@ Next step: ${nextStep}`;
         init_mesh_work_queue();
         init_mesh_runtime_store();
         init_mesh_fast_forward();
+        init_mesh_delivery_policy();
         REMOTE_IDLE_SESSION_TTL_MS = 5 * 60 * 1e3;
         meshByWorkspaceCache = /* @__PURE__ */ new Map();
         MESH_WORKSPACE_CACHE_TTL_MS = 5e3;
@@ -46160,6 +46532,7 @@ ${lastSnapshot}`;
       createInteractionId: () => createInteractionId,
       createMesh: () => createMesh,
       createNativeHistoryDispatcher: () => createNativeHistoryDispatcher,
+      createSessionDelivery: () => createSessionDelivery,
       createWorktree: () => createWorktree,
       deleteMesh: () => deleteMesh,
       detectAllVersions: () => detectAllVersions,
@@ -46183,6 +46556,7 @@ ${lastSnapshot}`;
       forwardAgentStreamsToIdeInstance: () => forwardAgentStreamsToIdeInstance2,
       getAIExtensions: () => getAIExtensions,
       getActiveDirectDispatches: () => getActiveDirectDispatches,
+      getActiveSessionDeliveries: () => getActiveSessionDeliveries,
       getAvailableIdeIds: () => getAvailableIdeIds,
       getCoordinatorForSession: () => getCoordinatorForSession,
       getCurrentDaemonLogPath: () => getCurrentDaemonLogPath,
@@ -46205,6 +46579,7 @@ ${lastSnapshot}`;
       getQueue: () => getQueue,
       getRecentActivity: () => getRecentActivity,
       getRecentCommands: () => getRecentCommands,
+      getRecentCompletionConflicts: () => getRecentCompletionConflicts,
       getRecentDebugTrace: () => getRecentDebugTrace,
       getRecentLogs: () => getRecentLogs,
       getSavedProviderSessions: () => getSavedProviderSessions,
@@ -46292,6 +46667,7 @@ ${lastSnapshot}`;
       readLedgerEntries: () => readLedgerEntries,
       readLedgerSlice: () => readLedgerSlice,
       reconcileDirectDispatchCompletionFromTranscript: () => reconcileDirectDispatchCompletionFromTranscript,
+      recordCompletionConflict: () => recordCompletionConflict,
       recordDebugTrace: () => recordDebugTrace,
       registerExtensionProviders: () => registerExtensionProviders,
       registerMeshCoordinator: () => registerMeshCoordinator,
@@ -46305,6 +46681,7 @@ ${lastSnapshot}`;
       resolveChatMessageKind: () => resolveChatMessageKind,
       resolveCurrentGlobalInstallSurface: () => resolveCurrentGlobalInstallSurface,
       resolveDebugRuntimeConfig: () => resolveDebugRuntimeConfig,
+      resolveDeliveryDecision: () => resolveDeliveryDecision,
       resolveGitRepository: () => resolveGitRepository,
       resolveMeshHostStatus: () => resolveMeshHostStatus,
       resolveMeshRefineValidationPlan: () => resolveMeshRefineValidationPlan,
@@ -46334,6 +46711,7 @@ ${lastSnapshot}`;
       updateDirectDispatchStatus: () => updateDirectDispatchStatus,
       updateMesh: () => updateMesh,
       updateNode: () => updateNode,
+      updateSessionDeliveryStatus: () => updateSessionDeliveryStatus,
       updateSessionTaskStatus: () => updateSessionTaskStatus,
       updateTaskStatus: () => updateTaskStatus,
       upsertSavedProviderSession: () => upsertSavedProviderSession,
@@ -49133,6 +49511,7 @@ ${lastSnapshot}`;
     }
     init_mesh_host_ownership();
     init_mesh_events();
+    init_mesh_delivery_policy();
     var NO_FALLBACK_REASON = "Repo Mesh command/data-plane is P2P-only; WS/REST command fallback is intentionally disabled to preserve the transport boundary.";
     var P2P_NEXT_ACTION = "Check daemon/P2P health, wait briefly for connection establishment, then do one bounded retry or requeue the mesh task after clearing stale target session metadata.";
     var NON_P2P_NEXT_ACTION = "Inspect the provider/command error and fix the underlying logic or configuration before retrying.";
@@ -49396,8 +49775,8 @@ ${lastSnapshot}`;
           if ((0, import_fs11.existsSync)(bundledCli)) resolvedCli = bundledCli;
         }
         if (!resolvedCli && appPath && os29 === "win32") {
-          const { dirname: dirname11 } = await import("path");
-          const appDir = dirname11(appPath);
+          const { dirname: dirname12 } = await import("path");
+          const appDir = dirname12(appPath);
           const candidates = [
             `${appDir}\\\\bin\\\\${def.cli}.cmd`,
             `${appDir}\\\\bin\\\\${def.cli}`,
@@ -61768,7 +62147,15 @@ ${formatManifestValidationIssues2(validation.issues)}`,
        *  explicit wake-up there's nothing to trigger the busy → idle
        *  downshift. */
       busyExpiryTimer = null;
+      /** Pending idle-commit timer. Armed when the evaluator first returns idle;
+       *  fires after idle_hold_ms if no non-idle reading has cancelled it. */
+      idleHoldTimer = null;
+      /** State snapshot captured when the idle hold was armed — emitted on commit. */
+      pendingIdleState = null;
       specWatcher = null;
+      /** Ring buffer of committed state transitions (max 50). */
+      stateHistory = [];
+      prevStateAt = 0;
       /** Subscribe to outbound events. Returns an unsubscribe fn. */
       subscribe(listener) {
         this.listeners.add(listener);
@@ -61819,9 +62206,40 @@ ${formatManifestValidationIssues2(validation.issues)}`,
       shutdown() {
         for (const t of this.delegateTimers.values()) clearTimeout(t);
         this.delegateTimers.clear();
+        this.cancelIdleHold();
+        if (this.busyExpiryTimer) {
+          clearTimeout(this.busyExpiryTimer);
+          this.busyExpiryTimer = null;
+        }
         this.specWatcher?.close();
         this.adapter.kill();
       }
+      cancelIdleHold() {
+        if (this.idleHoldTimer) {
+          clearTimeout(this.idleHoldTimer);
+          this.idleHoldTimer = null;
+        }
+        this.pendingIdleState = null;
+      }
+      pushHistory(stateId, label) {
+        const now = Date.now();
+        const durationMs = this.prevStateAt > 0 ? now - this.prevStateAt : 0;
+        this.prevStateAt = now;
+        this.stateHistory.push({ stateId, label, at: now, durationMs });
+        if (this.stateHistory.length > 50) this.stateHistory.shift();
+      }
+      getStateHistory() {
+        return this.stateHistory;
+      }
+      getLastBusyAt() {
+        return this.lastBusyAt;
+      }
+      hasIdleHoldPending() {
+        return this.idleHoldTimer !== null;
+      }
+      getSpecPath() {
+        return this.opts.specPath;
+      }
       // ────────────────────────────────────────────────────────────────────
       // Loading & adapter wiring
       // ────────────────────────────────────────────────────────────────────
@@ -61845,7 +62263,10 @@ ${formatManifestValidationIssues2(validation.issues)}`,
       }
       armSpecWatcher() {
         try {
-          this.specWatcher = fs10.watch(this.opts.specPath, { persistent: false }, () => {
+          const dir = path19.dirname(this.opts.specPath);
+          const base = path19.basename(this.opts.specPath);
+          this.specWatcher = fs10.watch(dir, { persistent: false }, (_event, filename) => {
+            if (filename && filename !== base) return;
             const res = loadSpec(this.opts.specPath);
             if (!res.ok) {
               this.emit({ kind: "spec_error", errors: res.errors });
@@ -61929,7 +62350,46 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         if (evState.id === "busy") {
           this.lastBusyAt = Date.now();
           this.lastBusyState = evState;
+          this.cancelIdleHold();
           this.scheduleBusyExpiry(busyWakeMs);
+        } else if (evState.id !== this.currentStateId && evState.id !== "busy") {
+          if (evState.id !== (this.spec.default_state ?? "idle")) {
+            this.cancelIdleHold();
+          }
+        }
+        const idleHoldMs = this.spec.debounce?.idle_hold_ms ?? 0;
+        const isIdleState = evState.id === (this.spec.default_state ?? "idle");
+        if (isIdleState && idleHoldMs > 0 && this.currentStateId !== evState.id) {
+          if (!this.idleHoldTimer) {
+            this.pendingIdleState = evState;
+            this.idleHoldTimer = setTimeout(() => {
+              this.idleHoldTimer = null;
+              const committed = this.pendingIdleState;
+              this.pendingIdleState = null;
+              if (!committed) return;
+              LOG2.debug("SpecDriver", `[${this.opts.specPath.split("/").slice(-3).join("/")}] idleHold committed after ${idleHoldMs}ms`);
+              this.currentStateId = committed.id;
+              this.currentEval = ev;
+              this.pushHistory(committed.id, committed.label);
+              this.emit({
+                kind: "state_changed",
+                state: committed,
+                modal: null,
+                controls: ev.controls.map((c) => ({ id: c.id, label: c.label, action_type: c.actionType }))
+              });
+              this.armOrCancelDelegateTimers(committed.id);
+              if (this.opts.emitTrace) this.emit({ kind: "spec_trace", entries: ev.trace });
+            }, idleHoldMs);
+          }
+          this.currentEval = ev;
+          const graceMs2 = this.spec.debounce?.startup_grace_ms ?? STARTUP_GRACE_MS;
+          if (!this.idleSeenOnce && Date.now() - this.startedAtMs >= graceMs2) {
+            this.idleSeenOnce = true;
+            const queued = this.pendingSends.splice(0);
+            for (const text of queued) setTimeout(() => this.actuallySendMessage(text), 50);
+          }
+          if (this.pickerInProgress) this.tryAdvancePicker(screen);
+          return;
         }
         const changed = forceEmit || evState.id !== this.currentStateId || !shallowSameModal(ev, this.currentEval) || !shallowSameControls(ev, this.currentEval);
         if (this.pickerInProgress) this.tryAdvancePicker(screen);
@@ -61945,6 +62405,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         }
         if (changed) {
           this.currentStateId = evState.id;
+          this.pushHistory(evState.id, evState.label);
           this.emit({
             kind: "state_changed",
             state: evState,
@@ -62376,7 +62837,11 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           activeInteractivePrompt: this.activeInteractivePrompt,
           exited: this.exited,
           screen,
-          sections
+          sections,
+          stateHistory: this.driver.getStateHistory(),
+          idleHoldPending: this.driver.hasIdleHoldPending(),
+          lastBusyAt: this.driver.getLastBusyAt(),
+          specPath: this.driver.getSpecPath()
         };
       }
       getRuntimeMetadata() {
@@ -67885,17 +68350,17 @@ Run 'adhdev doctor' for detailed diagnostics.`
     }
     function readSession(sessionPath) {
       if (!sessionPath || !path25.isAbsolute(sessionPath)) return null;
-      const basename13 = path25.basename(sessionPath, ".jsonl");
-      if (!isSafeSessionId(basename13)) return null;
+      const basename14 = path25.basename(sessionPath, ".jsonl");
+      if (!isSafeSessionId(basename14)) return null;
       if (!fs14.existsSync(sessionPath)) return null;
       const sourceMtimeMs = statMtimeMs(sessionPath);
-      const messages = parseTranscriptFile(sessionPath, basename13);
+      const messages = parseTranscriptFile(sessionPath, basename14);
       if (messages.length === 0) return null;
       const firstSystem = messages.find((m) => m.kind === "session_start");
       const workspace = firstSystem?.workspace || firstSystem?.content || void 0;
       return {
         messages,
-        providerSessionId: basename13,
+        providerSessionId: basename14,
         source: "provider-native",
         sourcePath: sessionPath,
         sourceMtimeMs,
@@ -68095,8 +68560,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
       if (!fs15.existsSync(sessionPath)) return null;
       const meta3 = readSessionMeta(sessionPath);
       const metaId = String(meta3?.id ?? "").trim();
-      const basename13 = path26.basename(sessionPath, ".jsonl");
-      const uuidMatch = basename13.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i);
+      const basename14 = path26.basename(sessionPath, ".jsonl");
+      const uuidMatch = basename14.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i);
       const filenameUuid2 = uuidMatch ? uuidMatch[1] : "";
       if (metaId && filenameUuid2 && metaId !== filenameUuid2) return null;
       const sessionId = metaId || filenameUuid2;
@@ -75282,6 +75747,21 @@ ${e?.stderr || ""}`
               } : null
             };
           }
+          case "get_spec_debug": {
+            const sessionId = typeof args?.targetSessionId === "string" ? args.targetSessionId.trim() : typeof args?.sessionId === "string" ? args.sessionId.trim() : "";
+            if (!sessionId) return { success: false, error: "targetSessionId required" };
+            const target = this.deps.sessionRegistry.get(sessionId);
+            if (!target) return { success: false, error: "Session not found", sessionId };
+            const adapter = this.deps.cliManager.findAdapter(target.providerType, { instanceKey: sessionId })?.adapter;
+            const snapshot = adapter && typeof adapter.getDebugSnapshot === "function" ? adapter.getDebugSnapshot() : null;
+            return {
+              success: true,
+              sessionId,
+              providerType: target.providerType,
+              isSpecProvider: snapshot !== null,
+              snapshot
+            };
+          }
           // ── User-level coordinator-prompt files (~/.adhdev/coordinator-prompts/).
           //    These live on this daemon's filesystem and never sync to the
           //    cloud / other daemons — they're per-machine config. The
@@ -76164,9 +76644,9 @@ ${e?.stderr || ""}`
               });
               let node;
               if (meshRecord.inline) {
-                const { randomUUID: randomUUID11 } = await import("crypto");
+                const { randomUUID: randomUUID12 } = await import("crypto");
                 node = {
-                  id: `node_${randomUUID11().replace(/-/g, "")}`,
+                  id: `node_${randomUUID12().replace(/-/g, "")}`,
                   workspace: result.worktreePath,
                   repoRoot: result.worktreePath,
                   daemonId: sourceNode.daemonId,
@@ -76609,7 +77089,7 @@ ${ptyResult.output.slice(-2e3)}`);
                 };
               }
               const { existsSync: existsSync39, readFileSync: readFileSync33, writeFileSync: writeFileSync21, copyFileSync: copyFileSync4, mkdirSync: mkdirSync19 } = await import("fs");
-              const { dirname: dirname11 } = await import("path");
+              const { dirname: dirname12 } = await import("path");
               const mcpConfigPath = coordinatorSetup.configPath;
               const hermesManualFallback = cliType === "hermes-cli" && configFormat === "hermes_config_yaml" ? createHermesManualMeshCoordinatorSetup(meshId, workspace) : null;
               let hermesBaseConfig = null;
@@ -76644,7 +77124,7 @@ ${ptyResult.output.slice(-2e3)}`);
                 };
               }
               try {
-                mkdirSync19(dirname11(mcpConfigPath), { recursive: true });
+                mkdirSync19(dirname12(mcpConfigPath), { recursive: true });
               } catch (error48) {
                 const message = `Could not prepare MCP config path for automatic setup: ${error48?.message || error48}`;
                 LOG2.error("MeshCoordinator", message);
@@ -76654,7 +77134,7 @@ ${ptyResult.output.slice(-2e3)}`);
               const hadExistingMcpConfig = existsSync39(mcpConfigPath);
               let existingMcpConfig = hermesBaseConfig?.config || {};
               if (hermesBaseConfig) {
-                copyHermesCoordinatorCredentialFiles(hermesBaseConfig.sourceHome, dirname11(mcpConfigPath));
+                copyHermesCoordinatorCredentialFiles(hermesBaseConfig.sourceHome, dirname12(mcpConfigPath));
               }
               if (hadExistingMcpConfig) {
                 try {
@@ -76692,7 +77172,7 @@ ${ptyResult.output.slice(-2e3)}`);
               const cliArgs = [];
               const launchEnv = {};
               if (configFormat === "hermes_config_yaml") {
-                launchEnv.HERMES_HOME = dirname11(mcpConfigPath);
+                launchEnv.HERMES_HOME = dirname12(mcpConfigPath);
                 launchEnv.HERMES_IGNORE_USER_CONFIG = "";
               }
               let autoImportContextFilePath;
@@ -84572,7 +85052,7 @@ data: ${JSON.stringify(msg.data)}
         });
       }
     };
-    var import_crypto6 = require("crypto");
+    var import_crypto7 = require("crypto");
     var import_session_host_core42 = require_dist2();
     var BASE_KEY_SEQUENCES = {
       enter: "\r",
@@ -84670,7 +85150,7 @@ data: ${JSON.stringify(msg.data)}
         const sessionId = String(options.sessionId || "").trim();
         if (!sessionId) throw new Error("sessionId is required");
         const mode = options.mode || "read";
-        const clientId = options.clientId || `raw-terminal-${process.pid}-${(0, import_crypto6.randomUUID)().slice(0, 8)}`;
+        const clientId = options.clientId || `raw-terminal-${process.pid}-${(0, import_crypto7.randomUUID)().slice(0, 8)}`;
         const client = options.client || new import_session_host_core42.SessionHostClient({ endpoint: options.endpoint });
         await client.connect();
         const attachResponse = await client.request({