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

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.";
@@ -76164,9 +76543,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,
@@ -84572,7 +84951,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 +85049,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({