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

package/dist/index.mjs

@@ -3290,8 +3290,8 @@ var init_mesh_fast_forward = __esm({
   }
 });
 
-// src/mesh/beads-db.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync5, readFileSync as readFileSync9, statSync as statSync4 } from "fs";
+// src/mesh/mesh-runtime-store.ts
+import { existsSync as existsSync11, mkdirSync as mkdirSync5, readFileSync as readFileSync9, renameSync as renameSync3, statSync as statSync4 } from "fs";
 import { dirname as dirname2, join as join12 } from "path";
 import { createRequire } from "module";
 function loadDatabaseCtor() {
@@ -3306,13 +3306,31 @@ function safeMeshId(meshId) {
 function legacyQueuePath(meshId) {
   return join12(getLedgerDir(), `${safeMeshId(meshId)}.queue.json`);
 }
-var DatabaseCtor, BeadsDB;
-var init_beads_db = __esm({
-  "src/mesh/beads-db.ts"() {
+function meshRuntimeStorePath() {
+  const dir = getLedgerDir();
+  const nextPath = join12(dir, "mesh-runtime.db");
+  if (existsSync11(nextPath)) return nextPath;
+  const legacyPath = join12(dir, "beads.db");
+  if (!existsSync11(legacyPath)) return nextPath;
+  try {
+    renameSync3(legacyPath, nextPath);
+    for (const suffix of ["-wal", "-shm"]) {
+      const legacyCompanion = `${legacyPath}${suffix}`;
+      if (existsSync11(legacyCompanion)) {
+        renameSync3(legacyCompanion, `${nextPath}${suffix}`);
+      }
+    }
+  } catch {
+  }
+  return nextPath;
+}
+var DatabaseCtor, MeshRuntimeStore;
+var init_mesh_runtime_store = __esm({
+  "src/mesh/mesh-runtime-store.ts"() {
     "use strict";
     init_mesh_ledger();
     init_mesh_work_queue();
-    BeadsDB = class _BeadsDB {
+    MeshRuntimeStore = class _MeshRuntimeStore {
       static instance;
       db;
       dbPath;
@@ -3335,7 +3353,7 @@ var init_beads_db = __esm({
       }
       static getInstance() {
         if (!this.instance) {
-          this.instance = new _BeadsDB(join12(getLedgerDir(), "beads.db"));
+          this.instance = new _MeshRuntimeStore(meshRuntimeStorePath());
         }
         return this.instance;
       }
@@ -3400,6 +3418,49 @@ var init_beads_db = __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) {
@@ -3420,13 +3481,13 @@ var init_beads_db = __esm({
         this.db.prepare("DELETE FROM mesh_completion_fingerprints WHERE expires_at <= ?").run(Date.now());
       }
       maybeCheckpointWal() {
-        if (++this.walWriteCounter < _BeadsDB.WAL_CHECK_INTERVAL) return;
+        if (++this.walWriteCounter < _MeshRuntimeStore.WAL_CHECK_INTERVAL) return;
         this.walWriteCounter = 0;
         try {
           const walPath = `${this.dbPath}-wal`;
           if (!existsSync11(walPath)) return;
           const size = statSync4(walPath).size;
-          if (size < _BeadsDB.WAL_MAX_BYTES) return;
+          if (size < _MeshRuntimeStore.WAL_MAX_BYTES) return;
           process.stderr.write(
             `[adhdev-mesh] WAL file ${Math.round(size / 1024 / 1024)}MB exceeds threshold; forcing checkpoint
 `
@@ -3724,6 +3785,131 @@ var init_beads_db = __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
+        }));
+      }
     };
   }
 });
@@ -3737,7 +3923,7 @@ __export(mesh_work_queue_exports, {
   __clearDirectDispatchesForTests: () => __clearDirectDispatchesForTests,
   __clearMeshQueueForTests: () => __clearMeshQueueForTests,
   __replaceMeshQueueForTests: () => __replaceMeshQueueForTests,
-  __resetBeadsDBForTests: () => __resetBeadsDBForTests,
+  __resetMeshRuntimeStoreForTests: () => __resetMeshRuntimeStoreForTests,
   buildMeshNodeCapabilityTags: () => buildMeshNodeCapabilityTags,
   cancelTask: () => cancelTask,
   claimNextTask: () => claimNextTask,
@@ -3816,7 +4002,7 @@ function nodeSatisfiesRequiredTags(requiredTags, capabilityTags) {
   return required.every((tag) => available.has(tag));
 }
 function withQueueLock(_meshId, fn) {
-  return BeadsDB.getInstance().transaction(fn);
+  return MeshRuntimeStore.getInstance().transaction(fn);
 }
 function enqueueTask(meshId, message, opts) {
   requireMeshHostQueueOwner(opts);
@@ -3836,55 +4022,55 @@ function enqueueTask(meshId, message, opts) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  BeadsDB.getInstance().insertQueueEntry(entry);
+  MeshRuntimeStore.getInstance().insertQueueEntry(entry);
   return entry;
 }
 function getQueue(meshId, opts) {
-  return BeadsDB.getInstance().getQueueEntries(meshId, opts?.status?.length ? opts.status : void 0);
+  return MeshRuntimeStore.getInstance().getQueueEntries(meshId, opts?.status?.length ? opts.status : void 0);
 }
 function getMeshQueueRevision(meshId) {
-  return BeadsDB.getInstance().getQueueRevision(meshId);
+  return MeshRuntimeStore.getInstance().getQueueRevision(meshId);
 }
 function claimNextTask(meshId, nodeId, sessionId, capabilityTags) {
-  return BeadsDB.getInstance().claimNextQueueTask(meshId, nodeId, sessionId, capabilityTags);
+  return MeshRuntimeStore.getInstance().claimNextQueueTask(meshId, nodeId, sessionId, capabilityTags);
 }
 function updateTaskStatus(meshId, taskId, status, opts) {
   requireMeshHostQueueOwner(opts);
   return withQueueLock(meshId, () => {
-    const entry = BeadsDB.getInstance().findQueueEntryById(meshId, taskId);
+    const entry = MeshRuntimeStore.getInstance().findQueueEntryById(meshId, taskId);
     if (!entry) return null;
     entry.status = status;
-    BeadsDB.getInstance().updateQueueEntry(entry);
+    MeshRuntimeStore.getInstance().updateQueueEntry(entry);
     return entry;
   });
 }
 function recordTaskAutoLaunch(meshId, taskId, autoLaunch) {
   return withQueueLock(meshId, () => {
-    const entry = BeadsDB.getInstance().findQueueEntryById(meshId, taskId);
+    const entry = MeshRuntimeStore.getInstance().findQueueEntryById(meshId, taskId);
     if (!entry) return null;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     entry.autoLaunch = { ...autoLaunch, updatedAt: now };
-    BeadsDB.getInstance().updateQueueEntry(entry);
+    MeshRuntimeStore.getInstance().updateQueueEntry(entry);
     return entry;
   });
 }
 function cancelTask(meshId, taskId, opts) {
   requireMeshHostQueueOwner(opts);
   return withQueueLock(meshId, () => {
-    const entry = BeadsDB.getInstance().findQueueEntryById(meshId, taskId);
+    const entry = MeshRuntimeStore.getInstance().findQueueEntryById(meshId, taskId);
     if (!entry) return null;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     entry.status = "cancelled";
     entry.cancelledAt = now;
     if (opts?.reason) entry.cancelReason = opts.reason;
-    BeadsDB.getInstance().updateQueueEntry(entry);
+    MeshRuntimeStore.getInstance().updateQueueEntry(entry);
     return entry;
   });
 }
 function requeueTask(meshId, taskId, opts) {
   requireMeshHostQueueOwner(opts);
   return withQueueLock(meshId, () => {
-    const entry = BeadsDB.getInstance().findQueueEntryById(meshId, taskId);
+    const entry = MeshRuntimeStore.getInstance().findQueueEntryById(meshId, taskId);
     if (!entry) return null;
     entry.status = "pending";
     delete entry.assignedNodeId;
@@ -3898,22 +4084,22 @@ function requeueTask(meshId, taskId, opts) {
     entry.requeuedAt = (/* @__PURE__ */ new Date()).toISOString();
     entry.requeueCount = (entry.requeueCount || 0) + 1;
     if (opts?.reason) entry.requeueReason = opts.reason;
-    BeadsDB.getInstance().updateQueueEntry(entry);
+    MeshRuntimeStore.getInstance().updateQueueEntry(entry);
     return entry;
   });
 }
 function updateSessionTaskStatus(meshId, sessionId, status, opts) {
   return withQueueLock(meshId, () => {
     const occurredAtIso = opts?.occurredAt ? new Date(opts.occurredAt).toISOString() : void 0;
-    const entry = BeadsDB.getInstance().findAssignedBySession(meshId, sessionId, occurredAtIso);
+    const entry = MeshRuntimeStore.getInstance().findAssignedBySession(meshId, sessionId, occurredAtIso);
     if (!entry) return null;
     entry.status = status;
-    BeadsDB.getInstance().updateQueueEntry(entry);
+    MeshRuntimeStore.getInstance().updateQueueEntry(entry);
     return entry;
   });
 }
 function getMeshQueueStats(meshId) {
-  const rows = BeadsDB.getInstance().getQueueStatsByStatus(meshId);
+  const rows = MeshRuntimeStore.getInstance().getQueueStatsByStatus(meshId);
   const counts = {};
   for (const r of rows) counts[r.status] = r.count;
   const pending = counts["pending"] ?? 0;
@@ -3932,26 +4118,26 @@ function getMeshQueueStats(meshId) {
     cancelled,
     activeCounts: { pending, assigned },
     historicalCounts: { completed, failed, cancelled },
-    activeAssignments: BeadsDB.getInstance().getActiveAssignmentDetails(meshId)
+    activeAssignments: MeshRuntimeStore.getInstance().getActiveAssignmentDetails(meshId)
   };
 }
 function __replaceMeshQueueForTests(meshId, queue) {
-  BeadsDB.getInstance().transaction(() => {
-    BeadsDB.getInstance().replaceQueue(meshId, queue);
+  MeshRuntimeStore.getInstance().transaction(() => {
+    MeshRuntimeStore.getInstance().replaceQueue(meshId, queue);
   });
 }
 function __clearMeshQueueForTests(meshId) {
-  BeadsDB.getInstance().deleteQueue(meshId);
+  MeshRuntimeStore.getInstance().deleteQueue(meshId);
 }
 function __clearDirectDispatchesForTests(meshId) {
-  BeadsDB.getInstance().deleteDirectDispatches(meshId);
+  MeshRuntimeStore.getInstance().deleteDirectDispatches(meshId);
 }
-function __resetBeadsDBForTests() {
-  BeadsDB.resetForTests();
+function __resetMeshRuntimeStoreForTests() {
+  MeshRuntimeStore.resetForTests();
 }
 function insertDirectDispatch(meshId, data) {
   try {
-    BeadsDB.getInstance().insertDirectDispatch({ ...data, meshId });
+    MeshRuntimeStore.getInstance().insertDirectDispatch({ ...data, meshId });
   } catch (e) {
     process.stderr.write(`[adhdev-mesh] insertDirectDispatch failed for task ${data.taskId}: ${e?.message || e}
 `);
@@ -3959,26 +4145,26 @@ function insertDirectDispatch(meshId, data) {
 }
 function getActiveDirectDispatches(meshId) {
   try {
-    return BeadsDB.getInstance().getActiveDirectDispatches(meshId);
+    return MeshRuntimeStore.getInstance().getActiveDirectDispatches(meshId);
   } catch {
     return [];
   }
 }
 function updateDirectDispatchStatus(meshId, sessionId, status) {
   try {
-    BeadsDB.getInstance().updateDirectDispatchStatus(meshId, sessionId, status);
+    MeshRuntimeStore.getInstance().updateDirectDispatchStatus(meshId, sessionId, status);
   } catch {
   }
 }
 function cleanupTerminalDirectDispatches(olderThanMs = 7 * 24 * 60 * 6e4) {
   try {
-    BeadsDB.getInstance().cleanupTerminalDirectDispatches(olderThanMs);
+    MeshRuntimeStore.getInstance().cleanupTerminalDirectDispatches(olderThanMs);
   } catch {
   }
 }
 function markStaleDirectDispatches(meshId, olderThanMs = 60 * 6e4) {
   try {
-    BeadsDB.getInstance().markStaleDirectDispatches(meshId, olderThanMs);
+    MeshRuntimeStore.getInstance().markStaleDirectDispatches(meshId, olderThanMs);
   } catch {
   }
 }
@@ -3987,7 +4173,7 @@ var init_mesh_work_queue = __esm({
   "src/mesh/mesh-work-queue.ts"() {
     "use strict";
     init_mesh_host_ownership();
-    init_beads_db();
+    init_mesh_runtime_store();
     ACTIVE_MESH_QUEUE_STATUSES = ["pending", "assigned"];
     HISTORICAL_MESH_QUEUE_STATUSES = ["completed", "failed", "cancelled"];
     MESH_TASK_MODES = ["code_change", "validation", "live_debug_readonly", "launch_app", "convergence"];
@@ -4137,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, {
@@ -4151,7 +4498,7 @@ __export(mesh_events_exports, {
   triggerMeshQueue: () => triggerMeshQueue,
   tryAssignQueueTask: () => tryAssignQueueTask
 });
-import { appendFileSync as appendFileSync2, existsSync as existsSync13, readFileSync as readFileSync10, renameSync as renameSync3, statSync as statSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync13, readFileSync as readFileSync10, renameSync as renameSync4, statSync as statSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "fs";
 import { join as join14 } from "path";
 function getCachedMeshByWorkspace(workspace) {
   const now = Date.now();
@@ -4169,7 +4516,7 @@ function __resetIdleAutoFastForwardForTests() {
 }
 function sweepExpiredRemoteIdleSessions() {
   try {
-    BeadsDB.getInstance().pruneExpiredRemoteIdleSessions();
+    MeshRuntimeStore.getInstance().pruneExpiredRemoteIdleSessions();
   } catch {
   }
 }
@@ -4338,7 +4685,7 @@ function queuePendingMeshCoordinatorEvent(event) {
 function atomicDrainFile(path40) {
   const tmpPath = `${path40}.draining`;
   try {
-    renameSync3(path40, tmpPath);
+    renameSync4(path40, tmpPath);
   } catch {
     return null;
   }
@@ -4445,14 +4792,14 @@ function shouldSuppressIntentionalCleanupStop(args) {
 }
 function hasFingerprintSeen(fingerprint) {
   try {
-    return BeadsDB.getInstance().hasCompletionFingerprint(fingerprint);
+    return MeshRuntimeStore.getInstance().hasCompletionFingerprint(fingerprint);
   } catch {
     return false;
   }
 }
 function recordFingerprintSeen(fingerprint) {
   try {
-    const db = BeadsDB.getInstance();
+    const db = MeshRuntimeStore.getInstance();
     db.recordCompletionFingerprint(fingerprint, RECENT_COMPLETION_FINGERPRINT_TTL_MS);
     db.sweepExpiredFingerprints();
   } catch {
@@ -4483,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;
 }
@@ -4734,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 {
         }
@@ -4755,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;
@@ -5072,7 +5456,7 @@ async function triggerMeshQueue(components, meshId) {
   }
   let remoteSessions = [];
   try {
-    remoteSessions = BeadsDB.getInstance().getRemoteIdleSessions();
+    remoteSessions = MeshRuntimeStore.getInstance().getRemoteIdleSessions();
   } catch {
   }
   for (const idle of remoteSessions) {
@@ -5082,7 +5466,7 @@ async function triggerMeshQueue(components, meshId) {
       const assigned = tryAssignQueueTask(components, meshId, idle.nodeId, idle.sessionId, idle.providerType);
       if (assigned) {
         try {
-          BeadsDB.getInstance().deleteRemoteIdleSession(idle.nodeId, idle.sessionId);
+          MeshRuntimeStore.getInstance().deleteRemoteIdleSession(idle.nodeId, idle.sessionId);
         } catch {
         }
       }
@@ -5284,7 +5668,7 @@ function injectMeshSystemMessage(components, args) {
   if (intentionalCleanupStop) {
     if (eventSessionId && eventNodeId) {
       try {
-        BeadsDB.getInstance().deleteRemoteIdleSession(eventNodeId, eventSessionId);
+        MeshRuntimeStore.getInstance().deleteRemoteIdleSession(eventNodeId, eventSessionId);
       } catch {
       }
     }
@@ -5366,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}`);
@@ -5382,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}`);
@@ -5452,14 +5840,14 @@ function injectMeshSystemMessage(components, args) {
     if (sessionId && nodeId && providerType) {
       sweepExpiredRemoteIdleSessions();
       try {
-        BeadsDB.getInstance().setRemoteIdleSession(nodeId, sessionId, providerType, Date.now() + REMOTE_IDLE_SESSION_TTL_MS);
+        MeshRuntimeStore.getInstance().setRemoteIdleSession(nodeId, sessionId, providerType, Date.now() + REMOTE_IDLE_SESSION_TTL_MS);
       } catch {
       }
       setImmediate(() => {
         maybeAutoFastForwardIdleNode(components, { meshId: args.meshId, nodeId, sessionId, providerType }).finally(() => {
           try {
             const assigned = tryAssignQueueTask(components, args.meshId, nodeId, sessionId, providerType);
-            if (assigned) BeadsDB.getInstance().deleteRemoteIdleSession(nodeId, sessionId);
+            if (assigned) MeshRuntimeStore.getInstance().deleteRemoteIdleSession(nodeId, sessionId);
           } catch (e) {
             LOG.warn("MeshQueue", `Failed to assign idle queue task after maintenance for ${nodeId}: ${e?.message || e}`);
           }
@@ -5471,7 +5859,7 @@ function injectMeshSystemMessage(components, args) {
     const nodeId = readNonEmptyString2(args.nodeId) || readNonEmptyString2(args.metadataEvent.meshNodeId);
     if (sessionId && nodeId) {
       try {
-        BeadsDB.getInstance().deleteRemoteIdleSession(nodeId, sessionId);
+        MeshRuntimeStore.getInstance().deleteRemoteIdleSession(nodeId, sessionId);
       } catch {
       }
     }
@@ -5483,7 +5871,7 @@ function injectMeshSystemMessage(components, args) {
     const nodeId = readNonEmptyString2(args.nodeId) || readNonEmptyString2(args.metadataEvent.meshNodeId);
     if (sessionId && nodeId) {
       try {
-        BeadsDB.getInstance().deleteRemoteIdleSession(nodeId, sessionId);
+        MeshRuntimeStore.getInstance().deleteRemoteIdleSession(nodeId, sessionId);
       } catch {
       }
     }
@@ -5755,8 +6143,9 @@ var init_mesh_events = __esm({
     init_logger();
     init_mesh_ledger();
     init_mesh_work_queue();
-    init_beads_db();
+    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;
@@ -8706,11 +9095,12 @@ var init_cli_state_engine = __esm({
       }
       applyGenerating(ctx) {
         const { modal, parsedMessages, lastParsedAssistant, parsedStatus, prevStatus } = ctx;
+        const noActiveTurn = !this.currentTurnScope;
+        if (!this.isWaitingForResponse && noActiveTurn && !modal) return;
         this.clearIdleFinishCandidate("generating");
         this.cancelPendingIdleFinish("generating_signal_returned");
         const snap = this.transport.getSnapshot();
         const effectiveScreenText = snap.screenText || snap.accumulatedBuffer;
-        const noActiveTurn = !this.currentTurnScope;
         const looksIdleChrome = /(^|\n)\s*[❯›>]\s*(?:\n|$)/m.test(effectiveScreenText);
         const parsedShowsLiveProgress = parsedStatus === "generating" && !!lastParsedAssistant;
         if (prevStatus === "idle" && !this.isWaitingForResponse && noActiveTurn && !modal && looksIdleChrome && !parsedShowsLiveProgress) return;
@@ -8970,7 +9360,25 @@ var init_cli_state_engine = __esm({
         const parsedStatus = typeof parsed?.status === "string" ? parsed.status.trim() : "";
         if (parsedStatus !== "idle") return true;
         if (parsed?.activeModal || parsed?.modal) return true;
-        return !this.parsedStatusHasFinalStandardAssistantMessage(parsed);
+        const messages = Array.isArray(parsed?.messages) ? parsed.messages : [];
+        let lastUserIdx = -1;
+        for (let i = messages.length - 1; i >= 0; i--) {
+          if (messages[i]?.role === "user") {
+            lastUserIdx = i;
+            break;
+          }
+        }
+        if (lastUserIdx < 0) {
+          if (messages.length === 0) return false;
+          return !this.parsedStatusHasFinalStandardAssistantMessage(parsed);
+        }
+        const hasCurrentTurnAssistant = messages.slice(lastUserIdx + 1).some((m) => {
+          if (!m || m.role !== "assistant") return false;
+          if (typeof m.content !== "string" || !m.content.trim()) return false;
+          const kind = typeof m.kind === "string" && m.kind.trim() ? m.kind.trim() : "standard";
+          return kind === "standard" && m.meta?.streaming !== true;
+        });
+        return !hasCurrentTurnAssistant;
       }
       rescheduleTranscriptFinishCheck(reason) {
         this.clearIdleFinishCandidate(reason);
@@ -11432,14 +11840,19 @@ function buildClaudeInteractiveTuiAnswerSteps(prompt, response) {
     if (question.multiSelect) throw new Error("Claude TUI multi-select prompts are not supported yet");
     const answer = response.answers[question.questionId];
     if (!answer) throw new Error(`Missing answer for ${question.questionId}`);
-    if (answer.freeformText) throw new Error("Claude TUI freeform answers are not supported yet");
-    if (answer.selectedLabels.length !== 1) throw new Error(`Expected one selected label for ${question.questionId}`);
-    const selectedIndex = question.options.findIndex((option) => option.label === answer.selectedLabels[0]);
-    if (selectedIndex < 0) throw new Error(`Unknown option for ${question.questionId}: ${answer.selectedLabels[0]}`);
-    for (let i = 0; i < selectedIndex; i += 1) {
-      steps.push("\x1B[B");
+    const freeformText = answer.freeformText?.trim() ?? "";
+    if (freeformText) {
+      const typeOptionIndex = question.options.findIndex((o) => /^Type something\.?$/i.test(o.label));
+      const optionNumber = typeOptionIndex >= 0 ? typeOptionIndex + 1 : question.options.length;
+      steps.push(String(optionNumber));
+      for (const ch of freeformText) steps.push(ch);
+      steps.push("\r");
+    } else {
+      if (answer.selectedLabels.length !== 1) throw new Error(`Expected one selected label for ${question.questionId}`);
+      const selectedIndex = question.options.findIndex((option) => option.label === answer.selectedLabels[0]);
+      if (selectedIndex < 0) throw new Error(`Unknown option for ${question.questionId}: ${answer.selectedLabels[0]}`);
+      steps.push(String(selectedIndex + 1));
     }
-    steps.push("\r");
   }
   steps.push("\r");
   return steps;
@@ -14006,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.";
@@ -19772,6 +20186,7 @@ function normalizeManagedStatus(status, opts) {
   if (hasApprovalButtons(opts?.activeModal)) return "waiting_approval";
   const normalized = String(status || "idle").trim().toLowerCase();
   if (normalized === "waiting_approval") return "waiting_approval";
+  if (normalized === "waiting_choice") return "waiting_choice";
   if (WORKING_STATUSES.has(normalized)) return "generating";
   if (normalized === "error") return "error";
   if (normalized === "stopped") return "stopped";
@@ -20336,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
@@ -21876,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 : {};
@@ -25790,10 +26205,47 @@ function resolveSections(spec, lines) {
   for (const sec of spec.layout.sections) {
     let from = 0;
     let to = total;
-    if (sec.from_top !== void 0) {
+    if (sec.anchor_regex !== void 0) {
+      try {
+        const re = new RegExp(sec.anchor_regex, sec.anchor_flags ?? "");
+        const prevRe = sec.anchor_context?.prev !== void 0 ? new RegExp(sec.anchor_context.prev, sec.anchor_context.prev_flags ?? "") : null;
+        const nextRe = sec.anchor_context?.next !== void 0 ? new RegExp(sec.anchor_context.next, sec.anchor_context.next_flags ?? "") : null;
+        const matches = (i) => re.test(lines[i]) && (prevRe === null || i > 0 && prevRe.test(lines[i - 1])) && (nextRe === null || i < total - 1 && nextRe.test(lines[i + 1]));
+        let idx = -1;
+        if (sec.anchor_last) {
+          for (let i = total - 1; i >= 0; i--) {
+            if (matches(i)) {
+              idx = i;
+              break;
+            }
+          }
+        } else {
+          for (let i = 0; i < total; i++) {
+            if (matches(i)) {
+              idx = i;
+              break;
+            }
+          }
+        }
+        if (idx !== -1) {
+          from = idx;
+          to = total;
+          if (sec.until_regex !== void 0) {
+            try {
+              const ure = new RegExp(sec.until_regex, sec.until_regex_flags ?? "");
+              const end = lines.findIndex((l, i) => i > idx && ure.test(l));
+              if (end !== -1) to = end;
+            } catch {
+            }
+          } else if (sec.lines !== void 0) {
+            to = Math.min(total, from + sec.lines);
+          }
+        }
+      } catch {
+      }
+    } else if (sec.from_top !== void 0) {
       from = resolveSize(sec.from_top, total);
-    }
-    if (sec.from_bottom !== void 0) {
+    } else if (sec.from_bottom !== void 0) {
       const sz = resolveSize(sec.from_bottom, total);
       from = total - sz;
       to = total;
@@ -26111,6 +26563,9 @@ var SCHEMA = {
       "type": "string",
       "minLength": 1
     },
+    "requiresFinalAssistantBeforeIdle": {
+      "type": "boolean"
+    },
     "debounce": {
       "type": "object",
       "additionalProperties": false,
@@ -26125,7 +26580,8 @@ var SCHEMA = {
             "section": { "type": "string", "minLength": 1 },
             "regex": { "type": "string", "minLength": 1 },
             "flags": { "type": "string" },
-            "hold_ms": { "type": "integer", "minimum": 0 }
+            "hold_ms": { "type": "integer", "minimum": 0 },
+            "force_after_ms": { "type": "integer", "minimum": 0 }
           }
         }
       }
@@ -26173,7 +26629,23 @@ var SCHEMA = {
               "type": "string"
             }
           }
-        }
+        },
+        "anchor_regex": { "type": "string", "minLength": 1 },
+        "anchor_flags": { "type": "string" },
+        "anchor_last": { "type": "boolean" },
+        "anchor_context": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "prev": { "type": "string" },
+            "prev_flags": { "type": "string" },
+            "next": { "type": "string" },
+            "next_flags": { "type": "string" }
+          }
+        },
+        "lines": { "type": "integer", "minimum": 1 },
+        "until_regex": { "type": "string", "minLength": 1 },
+        "until_regex_flags": { "type": "string" }
       }
     },
     "sectionRegex": {
@@ -26609,6 +27081,7 @@ function resolveSpecPath(providerDir) {
 }
 
 // src/providers/spec/driver.ts
+init_logger();
 var STARTUP_GRACE_MS = 2500;
 var BUSY_HOLD_MS = 6e3;
 var SUBMIT_DELAY_FLOOR_MS = 200;
@@ -26636,9 +27109,16 @@ function matchesCompletionIdleRule(spec, ev, screen) {
     return null;
   }
 }
-function matchesCompletionIdleTargetState(spec, ev, screen) {
+function matchesCompletionIdleTargetState(spec, ev, screen, cursor) {
   const target = spec.states.find((state) => state.id === spec.default_state) ?? spec.states.find((state) => state.id === "idle");
-  if (!target?.when?.regex) return false;
+  if (!target?.when) return false;
+  const hasCursorGuard = target.when.cursor_row_min !== void 0 || target.when.cursor_row_max !== void 0 || target.when.cursor_col_min !== void 0 || target.when.cursor_col_max !== void 0;
+  if (hasCursorGuard && cursor !== void 0) {
+    const { cursor_row_min, cursor_row_max, cursor_col_min, cursor_col_max } = target.when;
+    const cursorOk = (cursor_row_min === void 0 || cursor.row >= cursor_row_min) && (cursor_row_max === void 0 || cursor.row <= cursor_row_max) && (cursor_col_min === void 0 || cursor.col >= cursor_col_min) && (cursor_col_max === void 0 || cursor.col <= cursor_col_max);
+    if (cursorOk) return true;
+  }
+  if (!target.when.regex) return false;
   const haystack = target.when.section ? ev.sections.find((section) => section.id === target.when.section)?.text ?? "" : screen;
   if (!haystack) return false;
   try {
@@ -26800,6 +27280,7 @@ var SpecDriver = class {
     if (this.busyExpiryTimer) clearTimeout(this.busyExpiryTimer);
     this.busyExpiryTimer = setTimeout(() => {
       this.busyExpiryTimer = null;
+      LOG.debug("SpecDriver", `[${this.opts.specPath.split("/").slice(-3).join("/")}] busyExpiry fired holdMs=${holdMs}`);
       this.reevaluate();
     }, Math.max(holdMs + 50, 100));
   }
@@ -26824,11 +27305,16 @@ var SpecDriver = class {
         if (completionKey !== this.completionIdleKey) {
           this.completionIdleKey = completionKey;
           this.completionIdleFirstSeenAt = now;
+          LOG.debug("SpecDriver", `[${this.opts.specPath.split("/").slice(-3).join("/")}] completion_idle_after matched: key="${completionKey}"`);
         }
         const holdMs = Math.max(0, completionIdleRule.hold_ms || 0);
+        const forceAfterMs = typeof completionIdleRule.force_after_ms === "number" ? completionIdleRule.force_after_ms : null;
         const ageMs = now - this.completionIdleFirstSeenAt;
         if (ageMs >= holdMs) {
-          if (matchesCompletionIdleTargetState(this.spec, ev, screen)) {
+          const targetMatches = matchesCompletionIdleTargetState(this.spec, ev, screen, cursor);
+          const forced = !targetMatches && forceAfterMs !== null && ageMs >= holdMs + forceAfterMs;
+          LOG.debug("SpecDriver", `[${this.opts.specPath.split("/").slice(-3).join("/")}] completion_idle_after hold expired ageMs=${ageMs} targetState=${targetMatches} forced=${forced} screenTail="${screen.split(/\r?\n/).slice(-3).join("\\n").slice(-200)}"`);
+          if (targetMatches || forced) {
             const idle = this.spec.states.find((state) => state.id === this.spec.default_state) ?? this.spec.states.find((state) => state.id === "idle");
             evState = idle ? { id: idle.id, label: idle.label, title: null } : { id: "idle", label: "Ready", title: null };
           } else {
@@ -27969,16 +28455,19 @@ var CliProviderInstance = class {
       controlValues: this.controlValues
     });
     const activeChatStatus = parseErrorMessage ? "error" : autoApproveActive && parsedStatus?.status === "waiting_approval" ? "generating" : adapterStatus.status !== "idle" ? visibleStatus : suppressStaleParsedBusyStatus ? visibleStatus : parsedChatStatus || visibleStatus;
+    const hasInteractivePrompt = !!this.activeInteractivePrompt;
+    const finalStatus = hasInteractivePrompt ? "waiting_choice" : visibleStatus;
+    const finalChatStatus = hasInteractivePrompt ? "waiting_choice" : activeChatStatus;
     return {
       type: this.type,
       name: this.provider.name,
       category: "cli",
-      status: visibleStatus,
+      status: finalStatus,
       mode: this.presentationMode,
       activeChat: {
         id: activeChatId,
         title: parsedStatus?.title || dirName,
-        status: activeChatStatus,
+        status: finalChatStatus,
         messages: statusMessages,
         activeModal: autoApproveActive ? null : parsedStatus?.activeModal ?? adapterStatus.activeModal,
         activeInteractivePrompt: this.activeInteractivePrompt,
@@ -28449,6 +28938,7 @@ var CliProviderInstance = class {
     const adapterOwnsMessagesElsewhere = this.adapter?.chatMessagesOwnedExternally === true;
     const finalAssistantEvidence = this.completionFinalAssistantEvidence(parsed?.messages);
     const allowMissingAssistantTimeout = !!(this.settings.meshNodeFor || this.settings.meshActiveTaskId || this.settings.launchedByCoordinator);
+    LOG.debug("CLI", `[${this.type}] finalAssistantEvidence: present=${finalAssistantEvidence.present} source=${finalAssistantEvidence.source} adapterOwnsMessagesElsewhere=${adapterOwnsMessagesElsewhere} parsedStatus=${parsedStatus}`);
     if (!finalAssistantEvidence.present) {
       if (adapterOwnsMessagesElsewhere) {
         if (finalAssistantEvidence.source === "external-native") {
@@ -28457,6 +28947,10 @@ var CliProviderInstance = class {
             LOG.info("CLI", `[${this.type}] external transcript probe: msgCount=${probe.msgCount} lastRole=${probe.lastRole || "none"} lastKind=${probe.lastKind || "none"} contentLen=${probe.contentLen} sourceMtime=${probe.sourceMtimeMs ?? "unknown"} mtimeAge=${probe.mtimeAgeMs ?? "unknown"}ms`);
             pending.loggedTranscriptProbe = true;
           }
+          LOG.debug("CLI", `[${this.type}] external-native probe result: lastRole=${probe?.lastRole} contentLen=${probe?.contentLen}`);
+          if (probe?.lastRole === "assistant" && (probe.contentLen ?? 0) > 0) {
+            return null;
+          }
           if (this.type === "antigravity-cli") {
             return null;
           }
@@ -28466,6 +28960,7 @@ var CliProviderInstance = class {
           return { reason: "missing_final_assistant", terminal: true, allowTimeout: allowMissingAssistantTimeout };
         }
       } else {
+        LOG.debug("CLI", `[${this.type}] missing_final_assistant (not ownsExternal) requiresFinalAssistant=${!!this.provider.requiresFinalAssistantBeforeIdle}`);
         return {
           reason: "missing_final_assistant",
           terminal: this.provider.requiresFinalAssistantBeforeIdle === true,
@@ -28499,6 +28994,7 @@ var CliProviderInstance = class {
     const latestAutoApproveActive = latestStatus.status === "waiting_approval" && this.shouldAutoApprove();
     const externalNativeFinal = this.getExternalNativeFinalReconciliation(void 0, latestStatus);
     const latestVisibleStatus = externalNativeFinal && isCliGeneratingLikeStatus(latestStatus.status) ? "idle" : latestAutoApproveActive ? "generating" : latestStatus.status;
+    LOG.debug("CLI", `[${this.type}] flush attempt: adapterStatus=${latestStatus.status} latestVisible=${latestVisibleStatus} externalNativeFinal=${!!externalNativeFinal} generatingStartedAt=${this.generatingStartedAt} isWaitingForResponse=${!!this.adapter?.isWaitingForResponse} hasPartial=${!!this.adapter.getPartialResponse?.()}`);
     if (latestVisibleStatus !== "idle") {
       LOG.info("CLI", `[${this.type}] cancelled pending completed (resumed ${latestVisibleStatus})`);
       this.completedDebouncePending = null;
@@ -28509,6 +29005,7 @@ var CliProviderInstance = class {
     if (block2) {
       const blockReason = block2.reason;
       const waitedMs = Date.now() - pending.firstObservedAt;
+      LOG.debug("CLI", `[${this.type}] finalization block: reason=${blockReason} terminal=${block2.terminal} waitedMs=${waitedMs} maxWait=${COMPLETED_FINALIZATION_MAX_WAIT_MS}`);
       if (block2.terminal && !block2.allowTimeout || waitedMs < COMPLETED_FINALIZATION_MAX_WAIT_MS) {
         if (pending.loggedBlockReason !== blockReason) {
           LOG.info("CLI", `[${this.type}] waiting to emit completed until transcript finalizes (${blockReason})`);
@@ -28623,9 +29120,13 @@ var CliProviderInstance = class {
     if (newStatus !== this.lastStatus) {
       LOG.info("CLI", `[${this.type}] status: ${this.lastStatus} \u2192 ${newStatus}`);
       if (this.lastStatus === "idle" && newStatus === "generating") {
+        if (this.completedDebouncePending && this.generatingStartedAt === 0) {
+          LOG.debug("CLI", `[${this.type}] ignoring post-completion PTY generating blip (generatingStartedAt=0)`);
+          return;
+        }
         this.suppressIdleHistoryReplay = false;
         if (this.completedDebouncePending) {
-          LOG.info("CLI", `[${this.type}] cancelled pending completed (resumed generating)`);
+          LOG.info("CLI", `[${this.type}] cancelled pending completed (resumed generating) generatingStartedAt=${this.generatingStartedAt} isWaitingForResponse=${!!this.adapter?.isWaitingForResponse}`);
           if (this.completedDebounceTimer) {
             clearTimeout(this.completedDebounceTimer);
             this.completedDebounceTimer = null;
@@ -28723,7 +29224,10 @@ var CliProviderInstance = class {
             firstObservedAt: now,
             previousStatus: this.lastStatus
           };
-          this.scheduleCompletedDebounceFlush(3e3);
+          const ownsExternalHistory = !!this.adapter?.chatMessagesOwnedExternally;
+          const flushDelay = ownsExternalHistory ? 0 : 3e3;
+          LOG.debug("CLI", `[${this.type}] set completedDebouncePending duration=${duration}s ownsExternalHistory=${ownsExternalHistory} flushDelay=${flushDelay}ms generatingStartedAt=${this.generatingStartedAt}`);
+          this.scheduleCompletedDebounceFlush(flushDelay);
         }
       } else if (newStatus === "idle" && this.lastStatus === "starting") {
         this.pushEvent({ event: "agent:ready", chatTitle, timestamp: now });
@@ -41130,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,
@@ -49582,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";
@@ -49682,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({
@@ -50798,6 +51302,7 @@ export {
   createInteractionId,
   createMesh,
   createNativeHistoryDispatcher,
+  createSessionDelivery,
   createWorktree,
   deleteMesh,
   detectAllVersions,
@@ -50821,6 +51326,7 @@ export {
   forwardAgentStreamsToIdeInstance,
   getAIExtensions,
   getActiveDirectDispatches,
+  getActiveSessionDeliveries,
   getAvailableIdeIds,
   getCoordinatorForSession,
   getCurrentDaemonLogPath,
@@ -50843,6 +51349,7 @@ export {
   getQueue,
   getRecentActivity,
   getRecentCommands,
+  getRecentCompletionConflicts,
   getRecentDebugTrace,
   getRecentLogs,
   getSavedProviderSessions,
@@ -50930,6 +51437,7 @@ export {
   readLedgerEntries,
   readLedgerSlice,
   reconcileDirectDispatchCompletionFromTranscript,
+  recordCompletionConflict,
   recordDebugTrace,
   registerExtensionProviders,
   registerMeshCoordinator,
@@ -50943,6 +51451,7 @@ export {
   resolveChatMessageKind,
   resolveCurrentGlobalInstallSurface,
   resolveDebugRuntimeConfig,
+  resolveDeliveryDecision,
   resolveGitRepository,
   resolveMeshHostStatus,
   resolveMeshRefineValidationPlan,
@@ -50972,6 +51481,7 @@ export {
   updateDirectDispatchStatus,
   updateMesh,
   updateNode,
+  updateSessionDeliveryStatus,
   updateSessionTaskStatus,
   updateTaskStatus,
   upsertSavedProviderSession,