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

package/dist/index.js

@@ -38106,14 +38106,32 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     function legacyQueuePath(meshId) {
       return (0, import_path7.join)(getLedgerDir(), `${safeMeshId(meshId)}.queue.json`);
     }
+    function meshRuntimeStorePath() {
+      const dir = getLedgerDir();
+      const nextPath = (0, import_path7.join)(dir, "mesh-runtime.db");
+      if ((0, import_fs7.existsSync)(nextPath)) return nextPath;
+      const legacyPath = (0, import_path7.join)(dir, "beads.db");
+      if (!(0, import_fs7.existsSync)(legacyPath)) return nextPath;
+      try {
+        (0, import_fs7.renameSync)(legacyPath, nextPath);
+        for (const suffix of ["-wal", "-shm"]) {
+          const legacyCompanion = `${legacyPath}${suffix}`;
+          if ((0, import_fs7.existsSync)(legacyCompanion)) {
+            (0, import_fs7.renameSync)(legacyCompanion, `${nextPath}${suffix}`);
+          }
+        }
+      } catch {
+      }
+      return nextPath;
+    }
     var import_fs7;
     var import_path7;
     var import_module;
     var import_meta;
     var DatabaseCtor;
-    var BeadsDB;
-    var init_beads_db = __esm2({
-      "src/mesh/beads-db.ts"() {
+    var MeshRuntimeStore;
+    var init_mesh_runtime_store = __esm2({
+      "src/mesh/mesh-runtime-store.ts"() {
         "use strict";
         import_fs7 = require("fs");
         import_path7 = require("path");
@@ -38121,7 +38139,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         init_mesh_ledger();
         init_mesh_work_queue();
         import_meta = {};
-        BeadsDB = class _BeadsDB {
+        MeshRuntimeStore = class _MeshRuntimeStore {
           static instance;
           db;
           dbPath;
@@ -38144,7 +38162,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
           }
           static getInstance() {
             if (!this.instance) {
-              this.instance = new _BeadsDB((0, import_path7.join)(getLedgerDir(), "beads.db"));
+              this.instance = new _MeshRuntimeStore(meshRuntimeStorePath());
             }
             return this.instance;
           }
@@ -38209,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) {
@@ -38229,13 +38290,13 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
             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 (!(0, import_fs7.existsSync)(walPath)) return;
               const size = (0, import_fs7.statSync)(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
 `
@@ -38533,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
+            }));
+          }
         };
       }
     });
@@ -38544,7 +38730,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       __clearDirectDispatchesForTests: () => __clearDirectDispatchesForTests,
       __clearMeshQueueForTests: () => __clearMeshQueueForTests,
       __replaceMeshQueueForTests: () => __replaceMeshQueueForTests,
-      __resetBeadsDBForTests: () => __resetBeadsDBForTests,
+      __resetMeshRuntimeStoreForTests: () => __resetMeshRuntimeStoreForTests,
       buildMeshNodeCapabilityTags: () => buildMeshNodeCapabilityTags,
       cancelTask: () => cancelTask,
       claimNextTask: () => claimNextTask,
@@ -38622,7 +38808,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       return required2.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);
@@ -38642,55 +38828,55 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         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;
@@ -38704,22 +38890,22 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         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;
@@ -38738,26 +38924,26 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         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}
 `);
@@ -38765,26 +38951,26 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     }
     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 {
       }
     }
@@ -38798,7 +38984,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         "use strict";
         import_crypto5 = require("crypto");
         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"];
@@ -38949,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,
@@ -38978,7 +39326,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     }
     function sweepExpiredRemoteIdleSessions() {
       try {
-        BeadsDB.getInstance().pruneExpiredRemoteIdleSessions();
+        MeshRuntimeStore.getInstance().pruneExpiredRemoteIdleSessions();
       } catch {
       }
     }
@@ -39254,14 +39602,14 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     }
     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 {
@@ -39292,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;
     }
@@ -39543,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 {
             }
@@ -39564,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;
@@ -39881,7 +40266,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       }
       let remoteSessions = [];
       try {
-        remoteSessions = BeadsDB.getInstance().getRemoteIdleSessions();
+        remoteSessions = MeshRuntimeStore.getInstance().getRemoteIdleSessions();
       } catch {
       }
       for (const idle of remoteSessions) {
@@ -39891,7 +40276,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
           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 {
             }
           }
@@ -40093,7 +40478,7 @@ Next step: ${nextStep}`;
       if (intentionalCleanupStop) {
         if (eventSessionId && eventNodeId) {
           try {
-            BeadsDB.getInstance().deleteRemoteIdleSession(eventNodeId, eventSessionId);
+            MeshRuntimeStore.getInstance().deleteRemoteIdleSession(eventNodeId, eventSessionId);
           } catch {
           }
         }
@@ -40175,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}`);
@@ -40191,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}`);
@@ -40261,14 +40650,14 @@ Next step: ${nextStep}`;
         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) {
                 LOG2.warn("MeshQueue", `Failed to assign idle queue task after maintenance for ${nodeId}: ${e?.message || e}`);
               }
@@ -40280,7 +40669,7 @@ Next step: ${nextStep}`;
         const nodeId = readNonEmptyString2(args.nodeId) || readNonEmptyString2(args.metadataEvent.meshNodeId);
         if (sessionId && nodeId) {
           try {
-            BeadsDB.getInstance().deleteRemoteIdleSession(nodeId, sessionId);
+            MeshRuntimeStore.getInstance().deleteRemoteIdleSession(nodeId, sessionId);
           } catch {
           }
         }
@@ -40292,7 +40681,7 @@ Next step: ${nextStep}`;
         const nodeId = readNonEmptyString2(args.nodeId) || readNonEmptyString2(args.metadataEvent.meshNodeId);
         if (sessionId && nodeId) {
           try {
-            BeadsDB.getInstance().deleteRemoteIdleSession(nodeId, sessionId);
+            MeshRuntimeStore.getInstance().deleteRemoteIdleSession(nodeId, sessionId);
           } catch {
           }
         }
@@ -40582,8 +40971,9 @@ Next step: ${nextStep}`;
         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;
@@ -43527,11 +43917,12 @@ ${cont}` : cont;
           }
           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;
@@ -43791,7 +44182,25 @@ ${cont}` : cont;
             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);
@@ -46123,6 +46532,7 @@ ${lastSnapshot}`;
       createInteractionId: () => createInteractionId,
       createMesh: () => createMesh,
       createNativeHistoryDispatcher: () => createNativeHistoryDispatcher,
+      createSessionDelivery: () => createSessionDelivery,
       createWorktree: () => createWorktree,
       deleteMesh: () => deleteMesh,
       detectAllVersions: () => detectAllVersions,
@@ -46146,6 +46556,7 @@ ${lastSnapshot}`;
       forwardAgentStreamsToIdeInstance: () => forwardAgentStreamsToIdeInstance2,
       getAIExtensions: () => getAIExtensions,
       getActiveDirectDispatches: () => getActiveDirectDispatches,
+      getActiveSessionDeliveries: () => getActiveSessionDeliveries,
       getAvailableIdeIds: () => getAvailableIdeIds,
       getCoordinatorForSession: () => getCoordinatorForSession,
       getCurrentDaemonLogPath: () => getCurrentDaemonLogPath,
@@ -46168,6 +46579,7 @@ ${lastSnapshot}`;
       getQueue: () => getQueue,
       getRecentActivity: () => getRecentActivity,
       getRecentCommands: () => getRecentCommands,
+      getRecentCompletionConflicts: () => getRecentCompletionConflicts,
       getRecentDebugTrace: () => getRecentDebugTrace,
       getRecentLogs: () => getRecentLogs,
       getSavedProviderSessions: () => getSavedProviderSessions,
@@ -46255,6 +46667,7 @@ ${lastSnapshot}`;
       readLedgerEntries: () => readLedgerEntries,
       readLedgerSlice: () => readLedgerSlice,
       reconcileDirectDispatchCompletionFromTranscript: () => reconcileDirectDispatchCompletionFromTranscript,
+      recordCompletionConflict: () => recordCompletionConflict,
       recordDebugTrace: () => recordDebugTrace,
       registerExtensionProviders: () => registerExtensionProviders,
       registerMeshCoordinator: () => registerMeshCoordinator,
@@ -46268,6 +46681,7 @@ ${lastSnapshot}`;
       resolveChatMessageKind: () => resolveChatMessageKind,
       resolveCurrentGlobalInstallSurface: () => resolveCurrentGlobalInstallSurface,
       resolveDebugRuntimeConfig: () => resolveDebugRuntimeConfig,
+      resolveDeliveryDecision: () => resolveDeliveryDecision,
       resolveGitRepository: () => resolveGitRepository,
       resolveMeshHostStatus: () => resolveMeshHostStatus,
       resolveMeshRefineValidationPlan: () => resolveMeshRefineValidationPlan,
@@ -46297,6 +46711,7 @@ ${lastSnapshot}`;
       updateDirectDispatchStatus: () => updateDirectDispatchStatus,
       updateMesh: () => updateMesh,
       updateNode: () => updateNode,
+      updateSessionDeliveryStatus: () => updateSessionDeliveryStatus,
       updateSessionTaskStatus: () => updateSessionTaskStatus,
       updateTaskStatus: () => updateTaskStatus,
       upsertSavedProviderSession: () => upsertSavedProviderSession,
@@ -46567,14 +46982,19 @@ ${lastSnapshot}`;
         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;
@@ -49091,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.";
@@ -54797,6 +55218,7 @@ ${effect.notification.body || ""}`.trim();
       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";
@@ -60765,10 +61187,47 @@ ${formatManifestValidationIssues2(validation.issues)}`,
       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;
@@ -61082,6 +61541,9 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           "type": "string",
           "minLength": 1
         },
+        "requiresFinalAssistantBeforeIdle": {
+          "type": "boolean"
+        },
         "debounce": {
           "type": "object",
           "additionalProperties": false,
@@ -61096,7 +61558,8 @@ ${formatManifestValidationIssues2(validation.issues)}`,
                 "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 }
               }
             }
           }
@@ -61144,7 +61607,23 @@ ${formatManifestValidationIssues2(validation.issues)}`,
                   "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": {
@@ -61576,6 +62055,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     function resolveSpecPath(providerDir) {
       return path18.join(providerDir, "spec.json");
     }
+    init_logger();
     var STARTUP_GRACE_MS = 2500;
     var BUSY_HOLD_MS = 6e3;
     var SUBMIT_DELAY_FLOOR_MS = 200;
@@ -61603,9 +62083,16 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         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 {
@@ -61767,6 +62254,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         if (this.busyExpiryTimer) clearTimeout(this.busyExpiryTimer);
         this.busyExpiryTimer = setTimeout(() => {
           this.busyExpiryTimer = null;
+          LOG2.debug("SpecDriver", `[${this.opts.specPath.split("/").slice(-3).join("/")}] busyExpiry fired holdMs=${holdMs}`);
           this.reevaluate();
         }, Math.max(holdMs + 50, 100));
       }
@@ -61791,11 +62279,16 @@ ${formatManifestValidationIssues2(validation.issues)}`,
             if (completionKey !== this.completionIdleKey) {
               this.completionIdleKey = completionKey;
               this.completionIdleFirstSeenAt = now;
+              LOG2.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;
+              LOG2.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 {
@@ -62926,16 +63419,19 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           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,
@@ -63406,6 +63902,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         const adapterOwnsMessagesElsewhere = this.adapter?.chatMessagesOwnedExternally === true;
         const finalAssistantEvidence = this.completionFinalAssistantEvidence(parsed?.messages);
         const allowMissingAssistantTimeout = !!(this.settings.meshNodeFor || this.settings.meshActiveTaskId || this.settings.launchedByCoordinator);
+        LOG2.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") {
@@ -63414,6 +63911,10 @@ ${formatManifestValidationIssues2(validation.issues)}`,
                 LOG2.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;
               }
+              LOG2.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;
               }
@@ -63423,6 +63924,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
               return { reason: "missing_final_assistant", terminal: true, allowTimeout: allowMissingAssistantTimeout };
             }
           } else {
+            LOG2.debug("CLI", `[${this.type}] missing_final_assistant (not ownsExternal) requiresFinalAssistant=${!!this.provider.requiresFinalAssistantBeforeIdle}`);
             return {
               reason: "missing_final_assistant",
               terminal: this.provider.requiresFinalAssistantBeforeIdle === true,
@@ -63456,6 +63958,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         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;
+        LOG2.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") {
           LOG2.info("CLI", `[${this.type}] cancelled pending completed (resumed ${latestVisibleStatus})`);
           this.completedDebouncePending = null;
@@ -63466,6 +63969,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         if (block2) {
           const blockReason = block2.reason;
           const waitedMs = Date.now() - pending.firstObservedAt;
+          LOG2.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) {
               LOG2.info("CLI", `[${this.type}] waiting to emit completed until transcript finalizes (${blockReason})`);
@@ -63580,9 +64084,13 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         if (newStatus !== this.lastStatus) {
           LOG2.info("CLI", `[${this.type}] status: ${this.lastStatus} \u2192 ${newStatus}`);
           if (this.lastStatus === "idle" && newStatus === "generating") {
+            if (this.completedDebouncePending && this.generatingStartedAt === 0) {
+              LOG2.debug("CLI", `[${this.type}] ignoring post-completion PTY generating blip (generatingStartedAt=0)`);
+              return;
+            }
             this.suppressIdleHistoryReplay = false;
             if (this.completedDebouncePending) {
-              LOG2.info("CLI", `[${this.type}] cancelled pending completed (resumed generating)`);
+              LOG2.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;
@@ -63680,7 +64188,10 @@ ${formatManifestValidationIssues2(validation.issues)}`,
                 firstObservedAt: now,
                 previousStatus: this.lastStatus
               };
-              this.scheduleCompletedDebounceFlush(3e3);
+              const ownsExternalHistory = !!this.adapter?.chatMessagesOwnedExternally;
+              const flushDelay = ownsExternalHistory ? 0 : 3e3;
+              LOG2.debug("CLI", `[${this.type}] set completedDebouncePending duration=${duration3}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 });
@@ -76032,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,
@@ -84440,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",
@@ -84538,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({