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

package/dist/index.mjs

@@ -3418,6 +3418,49 @@ var init_mesh_runtime_store = __esm({
                 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) {
@@ -3742,6 +3785,131 @@ var init_mesh_runtime_store = __esm({
       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
+        }));
+      }
     };
   }
 });
@@ -4155,6 +4323,167 @@ var init_cli_detector = __esm({
   }
 });
 
+// src/mesh/mesh-delivery-policy.ts
+import { randomUUID as randomUUID6 } from "crypto";
+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 = randomUUID6();
+  const record = {
+    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 record;
+}
+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: randomUUID6(),
+      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 IMMEDIATE_DELIVERY_STATUSES, BUSY_DELIVERY_STATUSES, TERMINAL_DELIVERY_STATUSES;
+var init_mesh_delivery_policy = __esm({
+  "src/mesh/mesh-delivery-policy.ts"() {
+    "use strict";
+    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"
+    ]);
+  }
+});
+
 // src/mesh/mesh-events.ts
 var mesh_events_exports = {};
 __export(mesh_events_exports, {
@@ -4501,7 +4830,18 @@ function buildMeshCompletionFingerprint(args) {
 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;
 }
@@ -4752,20 +5092,33 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
   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) => {
         LOG.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 {
         }
@@ -4773,13 +5126,26 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
       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) => {
     LOG.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;
@@ -5384,7 +5750,9 @@ function injectMeshSystemMessage(components, args) {
       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) {
       LOG.info("MeshEvents", `Suppressed duplicate completion for mesh ${args.meshId} session ${eventSessionId}`);
@@ -5400,7 +5768,9 @@ function injectMeshSystemMessage(components, args) {
       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) {
       LOG.info("MeshEvents", `Suppressed duplicate stopped event for mesh ${args.meshId} session ${eventSessionId}`);
@@ -5775,6 +6145,7 @@ var init_mesh_events = __esm({
     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;
@@ -14048,6 +14419,7 @@ function buildMeshAsyncRefineJobs(args) {
 // src/index.ts
 init_mesh_host_ownership();
 init_mesh_events();
+init_mesh_delivery_policy();
 
 // src/mesh/p2p-relay-failure.ts
 var NO_FALLBACK_REASON = "Repo Mesh command/data-plane is P2P-only; WS/REST command fallback is intentionally disabled to preserve the transport boundary.";
@@ -14317,8 +14689,8 @@ async function detectIDEs(providerLoader) {
       if (existsSync15(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}`,
@@ -20379,7 +20751,7 @@ function resolveLegacyProviderScript(fn, scriptName, params) {
 import * as fs6 from "fs";
 import * as os8 from "os";
 import * as path13 from "path";
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 init_logger();
 
 // src/logging/debug-trace.ts
@@ -21919,7 +22291,7 @@ function safeBundleIdSegment(value, fallback) {
 function createChatDebugBundleId(targetSessionId) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:.]/g, "").replace("T", "T").replace("Z", "Z");
   const sessionSegment = safeBundleIdSegment(targetSessionId, "unknown-session");
-  return `chat-debug-${timestamp}-${sessionSegment}-${randomUUID7().slice(0, 8)}`;
+  return `chat-debug-${timestamp}-${sessionSegment}-${randomUUID8().slice(0, 8)}`;
 }
 function buildChatDebugBundleSummary(bundle) {
   const target = bundle.target && typeof bundle.target === "object" ? bundle.target : {};
@@ -26801,7 +27173,15 @@ var SpecDriver = class {
    *  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);
@@ -26852,9 +27232,40 @@ var SpecDriver = class {
   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
   // ────────────────────────────────────────────────────────────────────
@@ -26878,7 +27289,10 @@ var SpecDriver = class {
   }
   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 });
@@ -26962,7 +27376,46 @@ var SpecDriver = class {
     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;
+          LOG.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);
@@ -26978,6 +27431,7 @@ var SpecDriver = class {
     }
     if (changed) {
       this.currentStateId = evState.id;
+      this.pushHistory(evState.id, evState.label);
       this.emit({
         kind: "state_changed",
         state: evState,
@@ -27411,7 +27865,11 @@ var SpecCliAdapter = class {
       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() {
@@ -32955,17 +33413,17 @@ function parseTranscriptFile(filePath, sessionId, workspaceFallback) {
 }
 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,
@@ -33167,8 +33625,8 @@ function readSession2(sessionPath) {
   if (!fs15.existsSync(sessionPath)) return null;
   const meta = readSessionMeta(sessionPath);
   const metaId = String(meta?.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;
@@ -40380,6 +40838,21 @@ var DaemonCommandRouter = class {
           } : 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
@@ -41262,9 +41735,9 @@ var DaemonCommandRouter = class {
           });
           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,
@@ -41707,7 +42180,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;
@@ -41742,7 +42215,7 @@ ${ptyResult.output.slice(-2e3)}`);
             };
           }
           try {
-            mkdirSync19(dirname11(mcpConfigPath), { recursive: true });
+            mkdirSync19(dirname12(mcpConfigPath), { recursive: true });
           } catch (error) {
             const message = `Could not prepare MCP config path for automatic setup: ${error?.message || error}`;
             LOG.error("MeshCoordinator", message);
@@ -41752,7 +42225,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 {
@@ -41790,7 +42263,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;
@@ -49714,7 +50187,7 @@ var SessionHostPtyTransportFactory = class {
 };
 
 // src/cli-adapters/raw-terminal-io.ts
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID11 } from "crypto";
 import {
   SessionHostClient as SessionHostClient2
 } from "@adhdev/session-host-core";
@@ -49814,7 +50287,7 @@ var RawTerminalAttachment = class _RawTerminalAttachment {
     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}-${randomUUID10().slice(0, 8)}`;
+    const clientId = options.clientId || `raw-terminal-${process.pid}-${randomUUID11().slice(0, 8)}`;
     const client = options.client || new SessionHostClient2({ endpoint: options.endpoint });
     await client.connect();
     const attachResponse = await client.request({
@@ -50732,11 +51205,11 @@ init_parse_session();
 // src/providers/sdk/v1/fixture-tooling/replay.ts
 init_provider_cli_shared();
 import { readFileSync as readFileSync31 } from "fs";
-import { dirname as dirname9, resolve as resolve21 } from "path";
+import { dirname as dirname10, resolve as resolve21 } from "path";
 
 // src/providers/sdk/v1/validators/taint.ts
 import { readFileSync as readFileSync32, existsSync as existsSync38 } from "fs";
-import { resolve as resolve22, dirname as dirname10, join as join43 } from "path";
+import { resolve as resolve22, dirname as dirname11, join as join43 } from "path";
 
 // src/providers/sdk/v1/validators/index.ts
 init_manifest();
@@ -50930,6 +51403,7 @@ export {
   createInteractionId,
   createMesh,
   createNativeHistoryDispatcher,
+  createSessionDelivery,
   createWorktree,
   deleteMesh,
   detectAllVersions,
@@ -50953,6 +51427,7 @@ export {
   forwardAgentStreamsToIdeInstance,
   getAIExtensions,
   getActiveDirectDispatches,
+  getActiveSessionDeliveries,
   getAvailableIdeIds,
   getCoordinatorForSession,
   getCurrentDaemonLogPath,
@@ -50975,6 +51450,7 @@ export {
   getQueue,
   getRecentActivity,
   getRecentCommands,
+  getRecentCompletionConflicts,
   getRecentDebugTrace,
   getRecentLogs,
   getSavedProviderSessions,
@@ -51062,6 +51538,7 @@ export {
   readLedgerEntries,
   readLedgerSlice,
   reconcileDirectDispatchCompletionFromTranscript,
+  recordCompletionConflict,
   recordDebugTrace,
   registerExtensionProviders,
   registerMeshCoordinator,
@@ -51075,6 +51552,7 @@ export {
   resolveChatMessageKind,
   resolveCurrentGlobalInstallSurface,
   resolveDebugRuntimeConfig,
+  resolveDeliveryDecision,
   resolveGitRepository,
   resolveMeshHostStatus,
   resolveMeshRefineValidationPlan,
@@ -51104,6 +51582,7 @@ export {
   updateDirectDispatchStatus,
   updateMesh,
   updateNode,
+  updateSessionDeliveryStatus,
   updateSessionTaskStatus,
   updateTaskStatus,
   upsertSavedProviderSession,