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

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.";
@@ -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 : {};
@@ -41262,9 +41634,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,
@@ -49714,7 +50086,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 +50186,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({
@@ -50930,6 +51302,7 @@ export {
   createInteractionId,
   createMesh,
   createNativeHistoryDispatcher,
+  createSessionDelivery,
   createWorktree,
   deleteMesh,
   detectAllVersions,
@@ -50953,6 +51326,7 @@ export {
   forwardAgentStreamsToIdeInstance,
   getAIExtensions,
   getActiveDirectDispatches,
+  getActiveSessionDeliveries,
   getAvailableIdeIds,
   getCoordinatorForSession,
   getCurrentDaemonLogPath,
@@ -50975,6 +51349,7 @@ export {
   getQueue,
   getRecentActivity,
   getRecentCommands,
+  getRecentCompletionConflicts,
   getRecentDebugTrace,
   getRecentLogs,
   getSavedProviderSessions,
@@ -51062,6 +51437,7 @@ export {
   readLedgerEntries,
   readLedgerSlice,
   reconcileDirectDispatchCompletionFromTranscript,
+  recordCompletionConflict,
   recordDebugTrace,
   registerExtensionProviders,
   registerMeshCoordinator,
@@ -51075,6 +51451,7 @@ export {
   resolveChatMessageKind,
   resolveCurrentGlobalInstallSurface,
   resolveDebugRuntimeConfig,
+  resolveDeliveryDecision,
   resolveGitRepository,
   resolveMeshHostStatus,
   resolveMeshRefineValidationPlan,
@@ -51104,6 +51481,7 @@ export {
   updateDirectDispatchStatus,
   updateMesh,
   updateNode,
+  updateSessionDeliveryStatus,
   updateSessionTaskStatus,
   updateTaskStatus,
   upsertSavedProviderSession,