@adhdev/daemon-core 0.9.82-rc.467 → 0.9.82-rc.469

package/dist/index.mjs

@@ -404,10 +404,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "e0f04b7d54855e0f0d5ed4200078d95596ab9f6f" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "e0f04b7d" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.467" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-05T10:01:33.435Z" : void 0);
+  const commit = readInjected(true ? "7e34ff6bc7c6528fca49478a57e0a83620f3a063" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "7e34ff6b" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.469" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-05T12:18:38.077Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -2765,12 +2765,57 @@ function summarizeGitShape(status) {
     submodules
   };
 }
-var DAEMON_ID_PREFIXES, MAGI_RAW_ANSWER_CAP;
+var DAEMON_ID_PREFIXES, MAGI_RAW_ANSWER_CAP, CANONICAL_MESH_TOOL_NAMES, CANONICAL_MESH_TOOL_COUNT;
 var init_dist = __esm({
   "../mesh-shared/dist/index.mjs"() {
     "use strict";
     DAEMON_ID_PREFIXES = ["daemon_", "standalone_"];
     MAGI_RAW_ANSWER_CAP = 4e3;
+    CANONICAL_MESH_TOOL_NAMES = [
+      "mesh_status",
+      "mesh_list_nodes",
+      "mesh_enqueue_task",
+      "mesh_view_queue",
+      "mesh_queue_cancel",
+      "mesh_queue_requeue",
+      "mesh_send_task",
+      "mesh_read_chat",
+      "mesh_read_debug",
+      "mesh_launch_session",
+      "mesh_git_status",
+      "mesh_read_node_logs",
+      "mesh_fast_forward_node",
+      "mesh_restart_daemon",
+      "mesh_checkpoint",
+      "mesh_approve",
+      "mesh_clone_node",
+      "mesh_remove_node",
+      "mesh_refine_node",
+      "mesh_refine_batch",
+      "mesh_refine_config",
+      "mesh_change_impact_config",
+      "mesh_init",
+      "mesh_reinit",
+      "mesh_write_mesh_json_config",
+      "mesh_refine_plan",
+      "mesh_cleanup_sessions",
+      "mesh_prune_stale_direct",
+      "mesh_task_history",
+      "mesh_record_note",
+      "mesh_forget_note",
+      "mesh_reconcile_ledger",
+      "mesh_requeue_held_events",
+      "mesh_mission_upsert",
+      "mesh_mission_list",
+      "mesh_review_inbox",
+      "mesh_magi_review",
+      "mesh_magi_collect",
+      "mesh_magi_panel_set",
+      "mesh_magi_panel_list",
+      "mesh_magi_kind_panel_set",
+      "mesh_magi_kind_panel_list"
+    ];
+    CANONICAL_MESH_TOOL_COUNT = CANONICAL_MESH_TOOL_NAMES.length;
   }
 });
 
@@ -3792,24 +3837,39 @@ var init_coordinator_prompt = __esm({
 | \`mesh_queue_cancel\` | Cancel a queue task without deleting audit history |
 | \`mesh_queue_requeue\` | Return a task to pending for retry; clears stale session targets |
 | \`mesh_send_task\` | Legacy push: enqueue a task targeted at a specific node |
+| \`mesh_mission_upsert\` | Create/update a persistent mission so a multi-task plan survives coordinator restarts; set status completed/abandoned when the outcome is decided |
+| \`mesh_mission_list\` | List every mission with goal, status, and live task progress \u2014 the authority for "what work remains" (never hidden by status) |
 | \`mesh_launch_session\` | Start a new agent session on a node |
 | \`mesh_read_chat\` | Read recent chat messages from a delegated agent session |
 | \`mesh_read_debug\` | Collect a daemon-side chat/parser debug bundle for a session |
 | \`mesh_task_history\` | Read the task ledger \u2014 dispatches, completions, failures. Use to understand what has been done before deciding next steps |
+| \`mesh_reconcile_ledger\` | Reconcile daemon-local ledgers over P2P \u2014 import missing entries from remote nodes into the coordinator local ledger |
+| \`mesh_requeue_held_events\` | Restore recoverable held coordinator events (T6 quarantine / pending-trim) back to the pending queue; lossless, no double-requeue |
+| \`mesh_review_inbox\` | List local worktree nodes needing human review \u2014 merge candidates and Refinery-blocked results with evidence/diff summaries |
 | \`mesh_record_note\` | Record a durable, provider-neutral operating note (provider quirk / pattern to avoid / recovery lesson). Future coordinators see it under "## Operating Notes" at launch |
 | \`mesh_forget_note\` | Retract a stale/wrong operating note by note_id or exact text so it stops riding into future coordinators' prompts (append-only tombstone; history preserved) |
 | \`mesh_git_status\` | Check git status on a specific node |
 | \`mesh_read_node_logs\` | Fetch a remote node's daemon log tail directly over P2P (grep/since/byte-bounded, secrets redacted) \u2014 no session/PowerShell needed to debug a node's daemon |
 | \`mesh_fast_forward_node\` | Safely dry-run or explicitly execute an obvious clean fast-forward without launching an agent session |
+| \`mesh_restart_daemon\` | Update a node's daemon to the latest published version on its channel and restart it (the dashboard "preview update" path, as a mesh command) |
 | \`mesh_checkpoint\` | Create a git checkpoint on a node |
 | \`mesh_approve\` | Approve/reject a pending agent action |
 | \`mesh_clone_node\` | Create a worktree node for isolated parallel branch work |
 | \`mesh_refine_node\` | Validate and merge a completed worktree node back into its base branch |
+| \`mesh_refine_batch\` | Batch Refinery: converge multiple sibling worktree nodes onto the base branch in one conflict-aware sequential pipeline |
+| \`mesh_refine_plan\` | Dry-run Refinery plan for a worktree node \u2014 config source, validation commands, merge/cleanup intent \u2014 without executing validation or git merge |
+| \`mesh_refine_config\` | Refinery config helper (read-only) \u2014 unified entry for schema/validate/suggest via a required \`mode\` |
+| \`mesh_change_impact_config\` | Change Impact config helper \u2014 unified entry for schema/validate/suggest via a required \`mode\` |
 | \`mesh_remove_node\` | Remove a node (cleans up worktree if applicable) |
 | \`mesh_cleanup_sessions\` | Manually clean up delegated session records for a node |
+| \`mesh_prune_stale_direct\` | Prune orphaned staleDirect dispatch records (dry-run by default); live/pending work and audit history preserved |
 | \`mesh_init\` | Guided onboarding for a fresh repo: dry-run scan \u2192 suggest \`.adhdev/*\` configs (refine/bootstrap/change-impact) + providerPriority + current-config echo; gated write on approval |
 | \`mesh_reinit\` | Re-onboard an already-configured repo: re-suggest with overwrite semantics + current-vs-suggested diff; dry-run preview first, per-section approval before write |
 | \`mesh_write_mesh_json_config\` | Gated write of \`.adhdev/mesh.json\` (repo coordinator-prompt config) from the mesh entry \u2014 dry-run/overwrite like mesh_init |
+| \`mesh_magi_review\` | Cross-verify a read-only investigation across a standing panel of independent mesh agents (different machines/providers) instead of a single worker |
+| \`mesh_magi_collect\` | Collect + synthesize a previously dispatched MAGI fan-out by its consensus group id (async companion to mesh_magi_review wait:false) |
+| \`mesh_magi_panel_set\` | Upsert a named MAGI panel (standing set of independent node\xD7provider members) into machine-local config |
+| \`mesh_magi_panel_list\` | List configured MAGI panels and resolve each member's availability against the current mesh (read-only) |
 | \`mesh_magi_kind_panel_set\` | Bind a task_kind \u2192 MAGI kind-panel slots (machine-local, wholesale replacement \u2014 approve current-vs-new first) |
 | \`mesh_magi_kind_panel_list\` | List configured task_kind \u2192 MAGI kind-panel slot bindings (machine-local, read-only) |`;
     TOOL_EXPOSURE_PREFLIGHT_SECTION = `## Tool Exposure Preflight
@@ -5267,29 +5327,6 @@ function getActiveSessionDeliveries(meshId, sessionId) {
     return [];
   }
 }
-function recordCompletionConflict(opts) {
-  try {
-    MeshRuntimeStore.getInstance().recordCompletionConflict({
-      id: randomUUID5(),
-      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 [];
-  }
-}
 function markSessionDeliveriesTerminal(meshId, sessionId, terminalStatus) {
   try {
     const active = MeshRuntimeStore.getInstance().getActiveSessionDeliveries(meshId, sessionId);
@@ -5363,6 +5400,8 @@ __export(mesh_work_queue_exports, {
   ACTIVE_MESH_QUEUE_STATUSES: () => ACTIVE_MESH_QUEUE_STATUSES,
   HISTORICAL_MESH_QUEUE_STATUSES: () => HISTORICAL_MESH_QUEUE_STATUSES,
   MESH_TASK_MODES: () => MESH_TASK_MODES,
+  MESH_TASK_PRIORITIES: () => MESH_TASK_PRIORITIES,
+  NOT_BEFORE_RELATIVE_THRESHOLD_MS: () => NOT_BEFORE_RELATIVE_THRESHOLD_MS,
   __clearDirectDispatchesForTests: () => __clearDirectDispatchesForTests,
   __clearMeshQueueForTests: () => __clearMeshQueueForTests,
   __replaceMeshQueueForTests: () => __replaceMeshQueueForTests,
@@ -5383,15 +5422,19 @@ __export(mesh_work_queue_exports, {
   insertDirectDispatch: () => insertDirectDispatch,
   isTaskReadonly: () => isTaskReadonly,
   markStaleDirectDispatches: () => markStaleDirectDispatches,
+  meshTaskNotBeforeReady: () => meshTaskNotBeforeReady,
+  meshTaskPriorityRank: () => meshTaskPriorityRank,
   nodeSatisfiesRequiredTags: () => nodeSatisfiesRequiredTags,
   normalizeMeshCapabilityTags: () => normalizeMeshCapabilityTags,
   normalizeMeshTaskMode: () => normalizeMeshTaskMode,
+  normalizeMeshTaskPriority: () => normalizeMeshTaskPriority,
   reclaimStrandedAssignedTask: () => reclaimStrandedAssignedTask,
   recordDirectDispatchTask: () => recordDirectDispatchTask,
   recordMeshToolCall: () => recordMeshToolCall,
   recordTaskAutoLaunch: () => recordTaskAutoLaunch,
   requeueTask: () => requeueTask,
   resolveConvergeRequiredTags: () => resolveConvergeRequiredTags,
+  resolveNotBefore: () => resolveNotBefore,
   taskDependenciesSatisfied: () => taskDependenciesSatisfied,
   updateDirectDispatchStatus: () => updateDirectDispatchStatus,
   updateSessionTaskStatus: () => updateSessionTaskStatus,
@@ -5399,6 +5442,41 @@ __export(mesh_work_queue_exports, {
   validateMeshTaskModeRequest: () => validateMeshTaskModeRequest
 });
 import { randomUUID as randomUUID6 } from "crypto";
+function meshTaskPriorityRank(priority) {
+  switch (priority) {
+    case "high":
+      return 2;
+    case "low":
+      return 0;
+    default:
+      return 1;
+  }
+}
+function normalizeMeshTaskPriority(value) {
+  return value === "low" || value === "normal" || value === "high" ? value : void 0;
+}
+function resolveNotBefore(value, nowMs = Date.now()) {
+  if (value === void 0 || value === null) return void 0;
+  let absMs;
+  if (typeof value === "number" && Number.isFinite(value)) {
+    absMs = value < NOT_BEFORE_RELATIVE_THRESHOLD_MS ? nowMs + value : value;
+  } else if (typeof value === "string" && value.trim()) {
+    const parsed = Date.parse(value.trim());
+    if (Number.isNaN(parsed)) return void 0;
+    absMs = parsed;
+  } else {
+    return void 0;
+  }
+  if (absMs <= nowMs) return new Date(nowMs).toISOString();
+  return new Date(absMs).toISOString();
+}
+function meshTaskNotBeforeReady(task, nowMs = Date.now()) {
+  const nb = task?.notBefore;
+  if (!nb) return true;
+  const parsed = Date.parse(nb);
+  if (Number.isNaN(parsed)) return true;
+  return parsed <= nowMs;
+}
 function isTaskReadonly(task) {
   if (!task) return false;
   return task.readonly === true || task.taskMode === "live_debug_readonly";
@@ -5726,6 +5804,9 @@ function enqueueTask(meshId, message, opts) {
   }
   const id = typeof opts?.id === "string" && opts.id.trim() ? opts.id.trim() : randomUUID6();
   const dependsOn = normalizeDependsOn(opts?.dependsOn);
+  const priority = normalizeMeshTaskPriority(opts?.priority);
+  const notBefore = resolveNotBefore(opts?.notBefore);
+  const maxRetries = typeof opts?.maxRetries === "number" && Number.isFinite(opts.maxRetries) && opts.maxRetries >= 0 ? Math.floor(opts.maxRetries) : void 0;
   return withQueueLock(meshId, () => {
     if (MeshRuntimeStore.getInstance().findQueueEntryById(meshId, id)) {
       throw new Error(`duplicate_task_id: task '${id}' already exists in mesh '${meshId}'`);
@@ -5749,6 +5830,12 @@ function enqueueTask(meshId, message, opts) {
       targetSessionId: opts?.targetSessionId,
       requiredTags: resolvedRequiredTags,
       ...dependsOn.length > 0 ? { dependsOn } : {},
+      // G6: only persist a non-default priority so legacy/normal rows stay minimal.
+      ...priority && priority !== "normal" ? { priority } : {},
+      // G7: hold-until gate (stored ISO). Omitted when absent/immediate.
+      ...notBefore ? { notBefore } : {},
+      // P3: explicit retry cap. Omitted → requeue path falls back to policy default.
+      ...maxRetries !== void 0 ? { maxRetries } : {},
       ...typeof opts?.missionId === "string" && opts.missionId.trim() ? { missionId: opts.missionId.trim() } : {},
       ...typeof opts?.consensusGroupId === "string" && opts.consensusGroupId.trim() ? { consensusGroupId: opts.consensusGroupId.trim() } : {},
       ...typeof opts?.model === "string" && opts.model.trim() ? { model: opts.model.trim() } : {},
@@ -6089,7 +6176,7 @@ function recordMeshToolCall(opts) {
     return { rateLimitExceeded: false, callsInWindow: 0, advisory: null };
   }
 }
-var ACTIVE_MESH_QUEUE_STATUSES, HISTORICAL_MESH_QUEUE_STATUSES, MESH_TASK_MODES, LIVE_DEBUG_READONLY_FORBIDDEN, NEGATION_CUES, NEGATION_WINDOW_TOKENS, GIT_MUTATION_SUBCOMMANDS, GIT_STASH_READONLY_SUBCOMMANDS, DEPENDENCY_FAILURE_TERMINALS, MAX_STRANDED_RECLAIMS;
+var ACTIVE_MESH_QUEUE_STATUSES, HISTORICAL_MESH_QUEUE_STATUSES, MESH_TASK_MODES, MESH_TASK_PRIORITIES, NOT_BEFORE_RELATIVE_THRESHOLD_MS, LIVE_DEBUG_READONLY_FORBIDDEN, NEGATION_CUES, NEGATION_WINDOW_TOKENS, GIT_MUTATION_SUBCOMMANDS, GIT_STASH_READONLY_SUBCOMMANDS, DEPENDENCY_FAILURE_TERMINALS, MAX_STRANDED_RECLAIMS;
 var init_mesh_work_queue = __esm({
   "src/mesh/mesh-work-queue.ts"() {
     "use strict";
@@ -6105,6 +6192,8 @@ var init_mesh_work_queue = __esm({
     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"];
+    MESH_TASK_PRIORITIES = ["low", "normal", "high"];
+    NOT_BEFORE_RELATIVE_THRESHOLD_MS = 365 * 24 * 60 * 60 * 1e3;
     LIVE_DEBUG_READONLY_FORBIDDEN = [
       { label: "source_edit", pattern: /\b(edit|modify|patch|apply\s+patch|write\s+(?:to\s+)?(?:file|source)|overwrite|delete\s+file|remove\s+file|create\s+file|touch\s+file)\b/i },
       { label: "checkpoint", pattern: /\b(checkpoint|mesh_checkpoint)\b/i },
@@ -6159,7 +6248,7 @@ var init_mesh_work_queue = __esm({
 });
 
 // src/mesh/mesh-runtime-store.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync6, renameSync as renameSync3, statSync as statSync5 } from "fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync6, renameSync as renameSync3, statSync as statSync5, unlinkSync as unlinkSync2 } from "fs";
 import { dirname as dirname2, join as join9 } from "path";
 function loadDatabaseCtor() {
   if (DatabaseCtor) return DatabaseCtor;
@@ -6172,9 +6261,28 @@ function safeMeshId(meshId) {
 function legacyQueuePath(meshId) {
   return join9(getLedgerDir(), `${safeMeshId(meshId)}.queue.json`);
 }
+function cleanupStrayRootRuntimeDb(canonicalPath) {
+  try {
+    const strayPath = join9(getConfigDir(), "mesh-runtime.db");
+    if (strayPath === canonicalPath) return;
+    if (!existsSync8(strayPath)) return;
+    if (statSync5(strayPath).size !== 0) return;
+    unlinkSync2(strayPath);
+    if (!loggedStrayCleanup) {
+      loggedStrayCleanup = true;
+      LOG.info("MeshRuntimeStore", `Removed stray 0-byte root mesh-runtime.db at ${strayPath}`);
+    }
+  } catch (err) {
+    if (!loggedStrayCleanup) {
+      loggedStrayCleanup = true;
+      LOG.warn("MeshRuntimeStore", `Stray root mesh-runtime.db cleanup failed (ignored): ${err?.message || err}`);
+    }
+  }
+}
 function meshRuntimeStorePath() {
   const dir = getLedgerDir();
   const nextPath = join9(dir, "mesh-runtime.db");
+  cleanupStrayRootRuntimeDb(nextPath);
   if (existsSync8(nextPath)) return nextPath;
   const legacyPath = join9(dir, "beads.db");
   if (!existsSync8(legacyPath)) return nextPath;
@@ -6198,16 +6306,18 @@ function meshRuntimeStorePath() {
   }
   return nextPath;
 }
-var DatabaseCtor, loggedMigrationFailure, MeshRuntimeStore;
+var DatabaseCtor, loggedMigrationFailure, loggedStrayCleanup, MeshRuntimeStore;
 var init_mesh_runtime_store = __esm({
   "src/mesh/mesh-runtime-store.ts"() {
     "use strict";
     init_logger();
     init_load_better_sqlite3();
+    init_config();
     init_mesh_ledger();
     init_mesh_work_queue();
     init_dist();
     loggedMigrationFailure = false;
+    loggedStrayCleanup = false;
     MeshRuntimeStore = class _MeshRuntimeStore {
       static instance;
       db;
@@ -6356,20 +6466,9 @@ var init_mesh_runtime_store = __esm({
             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);
+            -- MESH-COMPLEXITY-AUDIT Part 8-2: mesh_completion_conflicts removed
+            -- (write-only fingerprint-collision diagnostic, no production reader,
+            -- no no-loss role). Dropped in migrateMeshIsolationColumns step 6.
 
             CREATE TABLE IF NOT EXISTS mesh_tool_call_log (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -6550,6 +6649,8 @@ var init_mesh_runtime_store = __esm({
                     ON mesh_pending_events(mesh_id, event_id)
                     WHERE event_id IS NOT NULL
             `);
+          this.db.exec(`DROP TABLE IF EXISTS mesh_direct_delivered_events`);
+          this.db.exec(`DROP TABLE IF EXISTS mesh_completion_conflicts`);
         } catch (err) {
           if (!loggedMigrationFailure) {
             loggedMigrationFailure = true;
@@ -6859,24 +6960,27 @@ var init_mesh_runtime_store = __esm({
           }
           const nodeIdForms = expandDaemonIdForms(nodeId);
           const nodePinnedPlaceholders = nodeIdForms.map(() => "?").join(", ");
-          const rows = [
-            ...this.db.prepare(`
+          const parseTier = (query, ...params) => {
+            const tierRows = this.db.prepare(query).all(...params);
+            return tierRows.map((row) => JSON.parse(row.payload)).sort((a, b) => meshTaskPriorityRank(b.priority) - meshTaskPriorityRank(a.priority));
+          };
+          const candidates = [
+            ...parseTier(`
                     SELECT payload FROM mesh_queue
                     WHERE mesh_id = ? AND status = 'pending' AND target_session_id = ?
                     ORDER BY created_at ASC
-                `).all(meshId, sessionId),
-            ...this.db.prepare(`
+                `, meshId, sessionId),
+            ...parseTier(`
                     SELECT payload FROM mesh_queue
                     WHERE mesh_id = ? AND status = 'pending' AND target_node_id IN (${nodePinnedPlaceholders}) AND target_session_id IS NULL
                     ORDER BY created_at ASC
-                `).all(meshId, ...nodeIdForms),
-            ...this.db.prepare(`
+                `, meshId, ...nodeIdForms),
+            ...parseTier(`
                     SELECT payload FROM mesh_queue
                     WHERE mesh_id = ? AND status = 'pending' AND target_node_id IS NULL AND target_session_id IS NULL
                     ORDER BY created_at ASC
-                `).all(meshId)
+                `, meshId)
           ];
-          const candidates = rows.map((row) => JSON.parse(row.payload));
           const depIds = [...new Set(candidates.flatMap((c) => Array.isArray(c.dependsOn) ? c.dependsOn : []))];
           const depStatus = /* @__PURE__ */ new Map();
           if (depIds.length > 0) {
@@ -6891,6 +6995,8 @@ var init_mesh_runtime_store = __esm({
             if (isTaskReadonly(candidate)) return true;
             return !nodeBusy;
           };
+          const claimNowMs = Date.now();
+          const notBeforeReady = (candidate) => meshTaskNotBeforeReady(candidate, claimNowMs);
           const nodeIsWorktree = opts?.nodeIsWorktree === true;
           const convergenceAllows = (candidate) => candidate.taskMode !== "convergence" || !nodeIsWorktree;
           const targetMatches = (candidate) => {
@@ -6900,7 +7006,7 @@ var init_mesh_runtime_store = __esm({
             }
             return true;
           };
-          const entry = candidates.find((candidate) => nodeSatisfiesRequiredTags(candidate.requiredTags, capabilityTags) && dependenciesSatisfied(candidate) && convergenceAllows(candidate) && targetMatches(candidate) && nodeConflictAllows(candidate));
+          const entry = candidates.find((candidate) => nodeSatisfiesRequiredTags(candidate.requiredTags, capabilityTags) && dependenciesSatisfied(candidate) && notBeforeReady(candidate) && convergenceAllows(candidate) && targetMatches(candidate) && nodeConflictAllows(candidate));
           if (!entry) return null;
           const now = (/* @__PURE__ */ new Date()).toISOString();
           entry.status = "assigned";
@@ -7260,43 +7366,11 @@ var init_mesh_runtime_store = __esm({
         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
-        }));
-      }
+      // MESH-COMPLEXITY-AUDIT Part 8-2: recordCompletionConflict /
+      // getRecentCompletionConflicts (and their mesh_completion_conflicts table)
+      // were removed. They were a write-only diagnostic of fingerprint-dedup
+      // collisions with no production reader and no part in the no-loss delivery
+      // contract; the table is dropped in migrateMeshIsolationColumns (step 6).
       /**
        * Record a mesh tool call and check whether this mesh+tool combination is
        * being called too rapidly (sliding window rate guard).
@@ -11510,7 +11584,7 @@ var init_mesh_events_utils = __esm({
 });
 
 // src/mesh/mesh-events-pending.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync15, readFileSync as readFileSync12, renameSync as renameSync4, statSync as statSync6, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync15, readFileSync as readFileSync12, renameSync as renameSync4, statSync as statSync6, unlinkSync as unlinkSync3, writeFileSync as writeFileSync6 } from "fs";
 import { join as join16 } from "path";
 import { randomUUID as randomUUID8 } from "crypto";
 function normalizeCoordinatorDaemonIds(coordinatorDaemonId) {
@@ -11537,7 +11611,11 @@ function ledgerRecordQuarantinedEvent(event, reason) {
         targetCoordinatorDaemonId: event.targetCoordinatorDaemonId ?? null,
         ...readNonEmptyString2(event.eventId) ? { eventId: event.eventId } : {},
         queuedAt: event.queuedAt,
-        ...finalSummary ? { finalSummary } : {}
+        ...finalSummary ? { finalSummary } : {},
+        // Full original event so mesh_requeue_held_events can restore it
+        // losslessly (event_held→pending). The summary/label fields above stay
+        // for human-readable audit; `heldEvent` is the machine recovery copy.
+        heldEvent: event
       }
     });
   } catch (e) {
@@ -11848,8 +11926,11 @@ function trimPendingEventsIfNeeded(path45) {
             nodeLabel: event.nodeLabel,
             ...event.workspace ? { workspace: event.workspace } : {},
             targetCoordinatorDaemonId: event.targetCoordinatorDaemonId ?? null,
+            ...readNonEmptyString2(event.eventId) ? { eventId: event.eventId } : {},
             queuedAt: event.queuedAt,
-            ...finalSummary ? { finalSummary } : {}
+            ...finalSummary ? { finalSummary } : {},
+            // Full original event for lossless mesh_requeue_held_events restore.
+            heldEvent: event
           }
         });
         LOG.warn("MeshEvents", `Pending-events trim dropping undelivered ${event.event} for mesh ${event.meshId} \u2014 recorded to ledger (recoverable)`);
@@ -11986,13 +12067,13 @@ function atomicDrainFile(path45) {
   try {
     const content = readFileSync12(tmpPath, "utf-8");
     try {
-      unlinkSync2(tmpPath);
+      unlinkSync3(tmpPath);
     } catch {
     }
     return content;
   } catch {
     try {
-      unlinkSync2(tmpPath);
+      unlinkSync3(tmpPath);
     } catch {
     }
     return null;
@@ -12010,7 +12091,7 @@ function selectiveDrainFile(path45, predicate) {
     content = readFileSync12(tmpPath, "utf-8");
   } catch {
     try {
-      unlinkSync2(tmpPath);
+      unlinkSync3(tmpPath);
     } catch {
     }
     return [];
@@ -12035,7 +12116,7 @@ function selectiveDrainFile(path45, predicate) {
     if (keptLines.length > 0) {
       writeFileSync6(path45, keptLines.join("\n") + "\n", "utf-8");
     }
-    unlinkSync2(tmpPath);
+    unlinkSync3(tmpPath);
   } catch {
     try {
       if (existsSync15(tmpPath) && !existsSync15(path45)) renameSync4(tmpPath, path45);
@@ -12176,6 +12257,83 @@ function getPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId, opts) {
   });
   return reconcilePendingMeshCoordinatorEvents(meshId, routed);
 }
+function readHeldTaskId(restored, payload) {
+  const fromMeta = restored?.metadataEvent && typeof restored.metadataEvent === "object" ? readNonEmptyString2(restored.metadataEvent.taskId) : "";
+  return fromMeta || readNonEmptyString2(payload.taskId) || "";
+}
+function requeueHeldMeshCoordinatorEvents(meshId, filter) {
+  const result = {
+    meshId,
+    matched: 0,
+    alreadyRequeued: 0,
+    unrecoverable: 0,
+    requeued: 0,
+    dedupSuppressed: 0,
+    entries: []
+  };
+  const all = readLedgerEntries(meshId);
+  const requeuedIds = /* @__PURE__ */ new Set();
+  for (const entry of all) {
+    if (entry.kind !== "event_held_requeued") continue;
+    const id = readNonEmptyString2(entry.payload?.heldEntryId);
+    if (id) requeuedIds.add(id);
+  }
+  const sinceMs = filter?.since ? new Date(filter.since).getTime() : NaN;
+  const wantEvent = readNonEmptyString2(filter?.event);
+  const wantNode = readNonEmptyString2(filter?.nodeId);
+  const wantTask = readNonEmptyString2(filter?.taskId);
+  const wantReason = readNonEmptyString2(filter?.reason);
+  for (const entry of all) {
+    if (entry.kind !== "event_held") continue;
+    const payload = entry.payload && typeof entry.payload === "object" ? entry.payload : {};
+    if (payload.recoverable !== true) continue;
+    const restored = payload.heldEvent && typeof payload.heldEvent === "object" ? { ...payload.heldEvent } : void 0;
+    const eventName = restored?.event || readNonEmptyString2(payload.event);
+    const nodeId = restored?.nodeId || entry.nodeId || readNonEmptyString2(payload.nodeId) || void 0;
+    const taskId = readHeldTaskId(restored, payload);
+    const reason = readNonEmptyString2(payload.reason) || void 0;
+    if (wantEvent && eventName !== wantEvent) continue;
+    if (wantNode && nodeId !== wantNode) continue;
+    if (wantTask && taskId !== wantTask) continue;
+    if (wantReason && reason !== wantReason) continue;
+    if (filter?.since && !Number.isNaN(sinceMs) && new Date(entry.timestamp).getTime() < sinceMs) continue;
+    result.matched++;
+    if (requeuedIds.has(entry.id)) {
+      result.alreadyRequeued++;
+      result.entries.push({ heldEntryId: entry.id, event: eventName, ...nodeId ? { nodeId } : {}, ...taskId ? { taskId } : {}, ...reason ? { reason } : {}, outcome: "already_requeued" });
+      continue;
+    }
+    if (!restored || !readNonEmptyString2(restored.event) || !readNonEmptyString2(restored.meshId)) {
+      result.unrecoverable++;
+      result.entries.push({ heldEntryId: entry.id, event: eventName, ...nodeId ? { nodeId } : {}, ...taskId ? { taskId } : {}, ...reason ? { reason } : {}, outcome: "unrecoverable" });
+      continue;
+    }
+    const beforeDup = hasPendingCoordinatorEventDuplicate(restored);
+    let ok = false;
+    try {
+      ok = queuePendingMeshCoordinatorEvent(restored);
+    } catch (e) {
+      LOG.warn("MeshEvents", `Requeue of held ${eventName} for mesh ${meshId} failed: ${e?.message || e}`);
+    }
+    appendLedgerEntry(meshId, {
+      kind: "event_held_requeued",
+      ...nodeId ? { nodeId } : {},
+      payload: {
+        heldEntryId: entry.id,
+        event: eventName,
+        requeued: ok,
+        ...taskId ? { taskId } : {},
+        ...reason ? { reason } : {},
+        ...beforeDup ? { dedupSuppressed: true } : {}
+      }
+    });
+    requeuedIds.add(entry.id);
+    result.requeued++;
+    if (beforeDup) result.dedupSuppressed++;
+    result.entries.push({ heldEntryId: entry.id, event: eventName, ...nodeId ? { nodeId } : {}, ...taskId ? { taskId } : {}, ...reason ? { reason } : {}, outcome: "requeued" });
+  }
+  return result;
+}
 function clearPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
   if (!meshId) return;
   try {
@@ -12185,7 +12343,7 @@ function clearPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
   const paths = coordinatorDaemonId ? [getPendingEventsPath(meshId, coordinatorDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
   for (const path45 of paths) {
     if (existsSync15(path45)) try {
-      unlinkSync2(path45);
+      unlinkSync3(path45);
     } catch {
     }
   }
@@ -14211,7 +14369,7 @@ function driveExpiredAwaitClaim(components, meshId, task, ctx) {
 async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
   const queue = getQueue(meshId);
   const statusById = new Map(queue.map((task) => [task.id, task.status]));
-  const pending = queue.filter((task) => task.status === "pending");
+  const pending = queue.filter((task) => task.status === "pending").sort((a, b) => meshTaskPriorityRank(b.priority) - meshTaskPriorityRank(a.priority));
   {
     const pendingIds = new Set(pending.map((t) => t.id));
     const prefix = `${meshId}::`;
@@ -14227,6 +14385,10 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
       markAutoLaunch(meshId, task.id, { status: "skipped", reason: "dependencies_unsatisfied" });
       continue;
     }
+    if (!meshTaskNotBeforeReady(task)) {
+      markAutoLaunch(meshId, task.id, { status: "skipped", reason: "not_before_delayed" });
+      continue;
+    }
     const isReadonly = isTaskReadonly(task);
     if (isReadonly) {
       if (activeReadonlyAssignedCount(meshId) >= maxReadonlyParallelTasks) {
@@ -17362,15 +17524,6 @@ function isDuplicateMeshCompletionEvent(args) {
   const fingerprint = buildMeshCompletionFingerprint(args);
   if (!fingerprint) return false;
   if (hasFingerprintSeen(args.meshId, fingerprint)) {
-    if (args.taskId) {
-      recordCompletionConflict({
-        meshId: args.meshId,
-        fingerprint,
-        conflictingTaskId: args.taskId,
-        conflictingSessionId: args.sessionId,
-        event: args.event
-      });
-    }
     return true;
   }
   recordFingerprintSeen(args.meshId, fingerprint);
@@ -18448,6 +18601,347 @@ var init_mesh_reconcile_identity = __esm({
   }
 });
 
+// src/mesh/mesh-reconcile-acked-hold.ts
+function resolveTunedReconcileMs(envName, def, min, max) {
+  const raw = readNonEmptyString2(process.env[envName]);
+  if (raw) {
+    const parsed = Number.parseInt(raw, 10);
+    if (Number.isFinite(parsed) && parsed >= min && parsed <= max) return parsed;
+  }
+  return def;
+}
+function resolveAckedDeathDeadlineMs() {
+  return resolveTunedReconcileMs("MESH_INFLIGHT_ACKED_DEATH_DEADLINE_MS", 8 * 6e4, 0, 60 * 6e4);
+}
+function resolveAckedTranscriptFastTrackGraceMs() {
+  return resolveTunedReconcileMs("MESH_INFLIGHT_ACKED_TRANSCRIPT_FASTTRACK_GRACE_MS", 4e4, 0, 5 * 6e4);
+}
+function inFlightSynthKey(meshId, taskId) {
+  return `${meshId}::${taskId}`;
+}
+function taskIdFromSynthKey(meshId, synthKey) {
+  const prefix = `${meshId}::`;
+  return synthKey.startsWith(prefix) ? synthKey.slice(prefix.length) : synthKey;
+}
+function holdStore() {
+  try {
+    return MeshRuntimeStore.getInstance();
+  } catch {
+    return void 0;
+  }
+}
+function getHoldState(synthKey, meshId) {
+  const cached3 = inFlightAckedHoldState.get(synthKey);
+  if (cached3) return cached3;
+  const store = holdStore();
+  if (!store) return void 0;
+  let row;
+  try {
+    row = store.getInflightHold(taskIdFromSynthKey(meshId, synthKey));
+  } catch {
+    return void 0;
+  }
+  if (!row) return void 0;
+  const state = {
+    liveConfirmedSinceAck: row.holdReason === "live",
+    consecutiveReadFailures: row.readFailureCount ?? 0,
+    ...row.firstIdleSinceAck !== null && row.firstIdleSinceAck !== void 0 ? { transcriptIdleSinceMs: row.firstIdleSinceAck } : {}
+  };
+  inFlightAckedHoldState.set(synthKey, state);
+  return state;
+}
+function setHoldState(synthKey, meshId, state) {
+  inFlightAckedHoldState.set(synthKey, state);
+  const store = holdStore();
+  if (!store) return;
+  try {
+    store.upsertInflightHold({
+      taskId: taskIdFromSynthKey(meshId, synthKey),
+      meshId,
+      holdReason: state.liveConfirmedSinceAck ? "live" : "unconfirmed",
+      firstIdleSinceAck: state.transcriptIdleSinceMs ?? null,
+      readFailureCount: state.consecutiveReadFailures
+    });
+  } catch {
+  }
+}
+function deleteHoldState(synthKey, meshId) {
+  inFlightAckedHoldState.delete(synthKey);
+  const store = holdStore();
+  if (!store) return;
+  try {
+    store.deleteInflightHold(taskIdFromSynthKey(meshId, synthKey));
+  } catch {
+  }
+}
+function rehydrateAckedHoldsForMesh(meshId) {
+  if (rehydratedHoldMeshes.has(meshId)) return;
+  rehydratedHoldMeshes.add(meshId);
+  const store = holdStore();
+  if (!store) return;
+  let rows;
+  try {
+    rows = store.listInflightHoldsByMesh(meshId);
+  } catch {
+    return;
+  }
+  for (const row of rows) {
+    const synthKey = inFlightSynthKey(meshId, row.taskId);
+    if (inFlightAckedHoldState.has(synthKey)) continue;
+    inFlightAckedHoldState.set(synthKey, {
+      liveConfirmedSinceAck: row.holdReason === "live",
+      consecutiveReadFailures: row.readFailureCount ?? 0,
+      ...row.firstIdleSinceAck !== null && row.firstIdleSinceAck !== void 0 ? { transcriptIdleSinceMs: row.firstIdleSinceAck } : {}
+    });
+  }
+  if (rows.length > 0) {
+    LOG.info("MeshReconcile", `Rehydrated ${rows.length} persisted acked-hold row(s) for mesh ${meshId} after (re)start`);
+  }
+}
+function collectHeldSynthKeysForMesh(meshId) {
+  const heldKeys = /* @__PURE__ */ new Set();
+  for (const key2 of inFlightAckedHoldState.keys()) {
+    if (key2.startsWith(`${meshId}::`)) heldKeys.add(key2);
+  }
+  const store = holdStore();
+  if (store) {
+    try {
+      for (const row of store.listInflightHoldsByMesh(meshId)) {
+        heldKeys.add(inFlightSynthKey(meshId, row.taskId));
+      }
+    } catch {
+    }
+  }
+  return heldKeys;
+}
+var ACKED_DEATH_CONSECUTIVE_READ_FAILURES, inFlightAckedHoldState, rehydratedHoldMeshes;
+var init_mesh_reconcile_acked_hold = __esm({
+  "src/mesh/mesh-reconcile-acked-hold.ts"() {
+    "use strict";
+    init_logger();
+    init_mesh_runtime_store();
+    init_mesh_events_utils();
+    ACKED_DEATH_CONSECUTIVE_READ_FAILURES = 3;
+    inFlightAckedHoldState = /* @__PURE__ */ new Map();
+    rehydratedHoldMeshes = /* @__PURE__ */ new Set();
+  }
+});
+
+// src/mesh/mesh-reconcile-config.ts
+function resolveAutoPruneMinAgeMs() {
+  const raw = readNonEmptyString2(process.env.MESH_AUTO_PRUNE_MIN_AGE_MS);
+  if (raw) {
+    const parsed = Number.parseInt(raw, 10);
+    if (Number.isFinite(parsed) && parsed >= 60 * 6e4 && parsed <= 30 * 24 * 60 * 6e4) return parsed;
+  }
+  return DEFAULT_AUTO_PRUNE_MIN_AGE_MS;
+}
+function resolvePendingHeldDrainEscalateMs() {
+  return resolveTunedReconcileMs("MESH_PENDING_HELD_DRAIN_ESCALATE_MS", DEFAULT_PENDING_HELD_DRAIN_ESCALATE_MS, 4e3, 5 * 6e4);
+}
+function resolveReconcileIntervalMs() {
+  const raw = readNonEmptyString2(process.env.MESH_RECONCILE_INTERVAL_MS);
+  if (raw) {
+    const parsed = Number.parseInt(raw, 10);
+    if (Number.isFinite(parsed) && parsed >= 1e3 && parsed <= 6e4) return parsed;
+  }
+  return DEFAULT_RECONCILE_INTERVAL_MS;
+}
+var DEFAULT_RECONCILE_INTERVAL_MS, DEFAULT_AUTO_PRUNE_MIN_AGE_MS, DEFAULT_PENDING_HELD_DRAIN_ESCALATE_MS;
+var init_mesh_reconcile_config = __esm({
+  "src/mesh/mesh-reconcile-config.ts"() {
+    "use strict";
+    init_mesh_events_utils();
+    init_mesh_reconcile_acked_hold();
+    DEFAULT_RECONCILE_INTERVAL_MS = 4e3;
+    DEFAULT_AUTO_PRUNE_MIN_AGE_MS = 24 * 60 * 6e4;
+    DEFAULT_PENDING_HELD_DRAIN_ESCALATE_MS = 12e3;
+  }
+});
+
+// src/mesh/mesh-remote-event-pull.ts
+async function pullRemoteNodeQueues(components, mesh, localDaemonId, candidateDaemonIds) {
+  const dispatchMeshCommand = components.dispatchMeshCommand;
+  if (!dispatchMeshCommand) return;
+  const meshId = mesh.id;
+  const pulls = candidateDaemonIds.length > 0 ? candidateDaemonIds.map((id) => ({ meshId, coordinatorDaemonId: id })) : [{ meshId }];
+  await Promise.allSettled(mesh.nodes.map(async (node) => {
+    const nodeDaemonId = readNonEmptyString2(node.daemonId);
+    if (!nodeDaemonId) return;
+    if (daemonIdsEquivalent(nodeDaemonId, localDaemonId)) return;
+    if (daemonIdListIncludes(candidateDaemonIds, nodeDaemonId)) return;
+    const peerSnapshot = components.getMeshPeerConnectionStatus?.(nodeDaemonId);
+    if (peerSnapshot && String(peerSnapshot.state) !== "connected") return;
+    for (const pendingEventArgs of pulls) {
+      let events;
+      try {
+        events = await dispatchMeshCommand(nodeDaemonId, "get_pending_mesh_events", pendingEventArgs);
+      } catch {
+        break;
+      }
+      const list = extractPendingEvents(events).filter((e) => readNonEmptyString2(e?.meshId) === meshId);
+      for (const event of list) {
+        const payload = buildForwardPayloadFromPending(event);
+        if (!payload.event || !payload.meshId) continue;
+        try {
+          handleMeshForwardEvent(components, payload);
+        } catch {
+        }
+      }
+    }
+  }));
+}
+function unwrapReadChatPayload(raw) {
+  let cursor = raw;
+  for (let depth = 0; depth < 4 && cursor && typeof cursor === "object"; depth++) {
+    const record = cursor;
+    if (Array.isArray(record.messages)) return record;
+    if (record.payload && typeof record.payload === "object") {
+      cursor = record.payload;
+      continue;
+    }
+    if (record.result && typeof record.result === "object") {
+      cursor = record.result;
+      continue;
+    }
+    if (record.data && typeof record.data === "object") {
+      cursor = record.data;
+      continue;
+    }
+    break;
+  }
+  return cursor && typeof cursor === "object" ? cursor : null;
+}
+function readChatPayloadStatus(payload) {
+  return readNonEmptyString2(payload?.status).toLowerCase();
+}
+function realTerminalEmitPendingForTask(meshId, taskId) {
+  let pending;
+  try {
+    pending = getPendingMeshCoordinatorEvents(meshId);
+  } catch {
+    return false;
+  }
+  return pending.some((e) => readNonEmptyString2(e.metadataEvent?.taskId) === taskId && (e.event === "agent:generating_completed" || e.event === "agent:stopped"));
+}
+async function reprobeWorkerStatus(components, args) {
+  try {
+    if (args.isLocalNode) {
+      const r = await components.commandHandler.handle("read_chat", args.readArgs);
+      if (r && r.success === false) return null;
+      return readChatPayloadStatus(unwrapReadChatPayload(r));
+    }
+    if (components.dispatchMeshCommand) {
+      const r = await components.dispatchMeshCommand(args.nodeDaemonId, "read_chat", args.readArgs);
+      const p = unwrapReadChatPayload(r);
+      if (p && p.success === false) return null;
+      return readChatPayloadStatus(p);
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+async function collectLiveNodesWithSessions(components, mesh, selfIds, localDaemonId) {
+  const dispatchMeshCommand = components.dispatchMeshCommand;
+  return Promise.all(mesh.nodes.map(async (node) => {
+    const nodeDaemonId = readNonEmptyString2(node.daemonId);
+    const isLocalNode = !nodeDaemonId || daemonIdListIncludes(selfIds, nodeDaemonId) || daemonIdsEquivalent(nodeDaemonId, localDaemonId);
+    if (!isLocalNode) {
+      const peerSnapshot = components.getMeshPeerConnectionStatus?.(nodeDaemonId);
+      if (peerSnapshot && String(peerSnapshot.state) !== "connected") return node;
+    }
+    let statusResult;
+    try {
+      if (isLocalNode) {
+        statusResult = await components.commandHandler.handle("get_status_metadata", {});
+      } else if (dispatchMeshCommand) {
+        statusResult = await dispatchMeshCommand(nodeDaemonId, "get_status_metadata", {});
+      } else {
+        return node;
+      }
+    } catch {
+      return node;
+    }
+    const sessions = extractStatusMetadataSessions(statusResult);
+    return sessions.length > 0 ? { ...node, sessions } : node;
+  }));
+}
+function extractStatusMetadataSessions(raw) {
+  let cursor = raw;
+  for (let depth = 0; depth < 4 && cursor && typeof cursor === "object"; depth++) {
+    const record = cursor;
+    const status = record.status && typeof record.status === "object" ? record.status : void 0;
+    if (status && Array.isArray(status.sessions)) return status.sessions;
+    if (Array.isArray(record.sessions)) return record.sessions;
+    if (record.payload && typeof record.payload === "object") {
+      cursor = record.payload;
+      continue;
+    }
+    if (record.result && typeof record.result === "object") {
+      cursor = record.result;
+      continue;
+    }
+    if (record.data && typeof record.data === "object") {
+      cursor = record.data;
+      continue;
+    }
+    break;
+  }
+  return [];
+}
+function extractPendingEvents(raw) {
+  if (Array.isArray(raw)) return raw;
+  if (raw && typeof raw === "object") {
+    const events = raw.events;
+    if (Array.isArray(events)) return events;
+  }
+  return [];
+}
+function buildForwardPayloadFromPending(event) {
+  const metadata = event?.metadataEvent && typeof event.metadataEvent === "object" ? event.metadataEvent : {};
+  return {
+    event: readNonEmptyString2(event?.event),
+    meshId: readNonEmptyString2(event?.meshId),
+    nodeId: readNonEmptyString2(event?.nodeId) || readNonEmptyString2(metadata.meshNodeId),
+    workspace: readNonEmptyString2(event?.workspace) || readNonEmptyString2(metadata.workspace),
+    // Preserve the originating coordinator session id across the relay. It is normally
+    // carried inside metadataEvent.meshCoordinatorSessionId (spread below), but pass the
+    // top-level field through explicitly too so the handleMeshForwardEvent whitelist
+    // recovers it regardless of which carrier the producing daemon used.
+    ...readNonEmptyString2(event?.targetCoordinatorSessionId) ? { targetCoordinatorSessionId: readNonEmptyString2(event.targetCoordinatorSessionId) } : {},
+    ...metadata,
+    // NOTIF-MISS (FIX 3): surface the dispatch task id at the TOP LEVEL so the relay's
+    // received-stage trace (and buildRelayMetadataEvent) recovers it regardless of which
+    // carrier the producing daemon used. The metadata spread above may carry the id only as
+    // `meshActiveTaskId` (a worker provider event), leaving top-level `taskId` unset and the
+    // received stage rendering `task=-`. Resolve both carriers into an explicit `taskId` so
+    // dedup stays task-scoped end-to-end. Only set when a non-empty id exists (no clobber to
+    // undefined when neither is present).
+    ...(() => {
+      const tid = readNonEmptyString2(metadata.taskId) || readNonEmptyString2(metadata.meshActiveTaskId);
+      return tid ? { taskId: tid } : {};
+    })(),
+    // T4 (B3b): carry the v2 envelope (protocolVersion/eventId/scope/dispatchedBy/
+    // intendedFor) across the P2P relay boundary at the TOP LEVEL. These live on the
+    // pending event itself, not inside metadataEvent, so without this the remote pull
+    // re-queue would re-stamp a fresh eventId — breaking cross-machine idempotency and
+    // downgrading the relayed completion to v1 broadcast routing. Spread LAST so the
+    // authoritative envelope always wins over any stale key the metadata spread carried.
+    ...serializeV2EnvelopeToWire(event)
+  };
+}
+var init_mesh_remote_event_pull = __esm({
+  "src/mesh/mesh-remote-event-pull.ts"() {
+    "use strict";
+    init_mesh_events_pending();
+    init_mesh_events_coordinator();
+    init_mesh_events_utils();
+    init_dist();
+    init_mesh_reconcile_identity();
+  }
+});
+
 // src/mesh/mesh-reconcile-v2-backstop.ts
 function getMeshV2BackstopCounters() {
   return { ...meshV2BackstopCounters };
@@ -18480,152 +18974,205 @@ var init_mesh_reconcile_v2_backstop = __esm({
   }
 });
 
-// src/mesh/mesh-reconcile-acked-hold.ts
-function resolveTunedReconcileMs(envName, def, min, max) {
-  const raw = readNonEmptyString2(process.env[envName]);
-  if (raw) {
-    const parsed = Number.parseInt(raw, 10);
-    if (Number.isFinite(parsed) && parsed >= min && parsed <= max) return parsed;
-  }
-  return def;
-}
-function resolveAckedDeathDeadlineMs() {
-  return resolveTunedReconcileMs("MESH_INFLIGHT_ACKED_DEATH_DEADLINE_MS", 8 * 6e4, 0, 60 * 6e4);
-}
-function resolveAckedTranscriptFastTrackGraceMs() {
-  return resolveTunedReconcileMs("MESH_INFLIGHT_ACKED_TRANSCRIPT_FASTTRACK_GRACE_MS", 4e4, 0, 5 * 6e4);
-}
-function inFlightSynthKey(meshId, taskId) {
-  return `${meshId}::${taskId}`;
-}
-function taskIdFromSynthKey(meshId, synthKey) {
-  const prefix = `${meshId}::`;
-  return synthKey.startsWith(prefix) ? synthKey.slice(prefix.length) : synthKey;
-}
-function holdStore() {
-  try {
-    return MeshRuntimeStore.getInstance();
-  } catch {
-    return void 0;
-  }
-}
-function getHoldState(synthKey, meshId) {
-  const cached3 = inFlightAckedHoldState.get(synthKey);
-  if (cached3) return cached3;
-  const store = holdStore();
-  if (!store) return void 0;
-  let row;
-  try {
-    row = store.getInflightHold(taskIdFromSynthKey(meshId, synthKey));
-  } catch {
-    return void 0;
-  }
-  if (!row) return void 0;
-  const state = {
-    liveConfirmedSinceAck: row.holdReason === "live",
-    consecutiveReadFailures: row.readFailureCount ?? 0,
-    ...row.firstIdleSinceAck !== null && row.firstIdleSinceAck !== void 0 ? { transcriptIdleSinceMs: row.firstIdleSinceAck } : {}
-  };
-  inFlightAckedHoldState.set(synthKey, state);
-  return state;
-}
-function setHoldState(synthKey, meshId, state) {
-  inFlightAckedHoldState.set(synthKey, state);
-  const store = holdStore();
-  if (!store) return;
-  try {
-    store.upsertInflightHold({
-      taskId: taskIdFromSynthKey(meshId, synthKey),
-      meshId,
-      holdReason: state.liveConfirmedSinceAck ? "live" : "unconfirmed",
-      firstIdleSinceAck: state.transcriptIdleSinceMs ?? null,
-      readFailureCount: state.consecutiveReadFailures
-    });
-  } catch {
-  }
-}
-function deleteHoldState(synthKey, meshId) {
-  inFlightAckedHoldState.delete(synthKey);
-  const store = holdStore();
-  if (!store) return;
-  try {
-    store.deleteInflightHold(taskIdFromSynthKey(meshId, synthKey));
-  } catch {
-  }
-}
-function rehydrateAckedHoldsForMesh(meshId) {
-  if (rehydratedHoldMeshes.has(meshId)) return;
-  rehydratedHoldMeshes.add(meshId);
-  const store = holdStore();
-  if (!store) return;
-  let rows;
-  try {
-    rows = store.listInflightHoldsByMesh(meshId);
-  } catch {
-    return;
-  }
-  for (const row of rows) {
-    const synthKey = inFlightSynthKey(meshId, row.taskId);
-    if (inFlightAckedHoldState.has(synthKey)) continue;
-    inFlightAckedHoldState.set(synthKey, {
-      liveConfirmedSinceAck: row.holdReason === "live",
-      consecutiveReadFailures: row.readFailureCount ?? 0,
-      ...row.firstIdleSinceAck !== null && row.firstIdleSinceAck !== void 0 ? { transcriptIdleSinceMs: row.firstIdleSinceAck } : {}
-    });
-  }
-  if (rows.length > 0) {
-    LOG.info("MeshReconcile", `Rehydrated ${rows.length} persisted acked-hold row(s) for mesh ${meshId} after (re)start`);
-  }
-}
-function collectHeldSynthKeysForMesh(meshId) {
-  const heldKeys = /* @__PURE__ */ new Set();
-  for (const key2 of inFlightAckedHoldState.keys()) {
-    if (key2.startsWith(`${meshId}::`)) heldKeys.add(key2);
+// src/mesh/mesh-completion-synthesis.ts
+async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds, localDaemonId) {
+  const dispatches = getActiveDirectDispatches(mesh.id);
+  rehydrateAckedHoldsForMesh(mesh.id);
+  const activeTaskKeys = new Set(
+    dispatches.map((d) => readNonEmptyString2(d.taskId)).filter(Boolean).map((taskId) => inFlightSynthKey(mesh.id, taskId))
+  );
+  const heldKeys = collectHeldSynthKeysForMesh(mesh.id);
+  for (const key2 of heldKeys) {
+    if (!activeTaskKeys.has(key2)) deleteHoldState(key2, mesh.id);
   }
-  const store = holdStore();
-  if (store) {
+  if (dispatches.length === 0) return;
+  const dispatchMeshCommand = components.dispatchMeshCommand;
+  const nodeById = new Map(mesh.nodes.map((n) => [n.id, n]));
+  for (const dispatch of dispatches) {
+    const sessionId = readNonEmptyString2(dispatch.sessionId);
+    const nodeId = readNonEmptyString2(dispatch.nodeId);
+    const taskId = readNonEmptyString2(dispatch.taskId);
+    if (!sessionId || !nodeId || !taskId) continue;
+    const node = nodeById.get(nodeId);
+    const nodeDaemonId = readNonEmptyString2(node?.daemonId);
+    const isLocalNode = !nodeDaemonId || daemonIdListIncludes(selfIds, nodeDaemonId) || daemonIdsEquivalent(nodeDaemonId, localDaemonId) || !!components.instanceManager.getInstance(sessionId);
+    const providerType = readNonEmptyString2(dispatch.providerType);
+    const readArgs = {
+      sessionId,
+      targetSessionId: sessionId,
+      tailLimit: 10,
+      ...node?.workspace ? { workspace: node.workspace } : {},
+      ...providerType ? { agentType: providerType, providerType } : {}
+    };
+    const synthKey = inFlightSynthKey(mesh.id, taskId);
+    const isAcked = dispatch.status === "acked";
+    let backstopKind;
+    let payload = null;
+    let readFailed = false;
     try {
-      for (const row of store.listInflightHoldsByMesh(meshId)) {
-        heldKeys.add(inFlightSynthKey(meshId, row.taskId));
+      if (isLocalNode) {
+        const result = await components.commandHandler.handle("read_chat", readArgs);
+        if (result && result.success === false) {
+          readFailed = true;
+        } else {
+          payload = unwrapReadChatPayload(result);
+        }
+      } else if (dispatchMeshCommand) {
+        const result = await dispatchMeshCommand(nodeDaemonId, "read_chat", readArgs);
+        payload = unwrapReadChatPayload(result);
+        if (payload && payload.success === false) {
+          payload = null;
+          readFailed = true;
+        }
+      } else {
+        continue;
       }
     } catch {
+      readFailed = true;
+    }
+    if (!payload && !readFailed) continue;
+    if (readFailed || !payload) {
+      if (isAcked) {
+        const prior = getHoldState(synthKey, mesh.id);
+        const failures = (prior?.consecutiveReadFailures ?? 0) + 1;
+        const liveConfirmedSinceAck = prior?.liveConfirmedSinceAck ?? false;
+        setHoldState(synthKey, mesh.id, { liveConfirmedSinceAck, consecutiveReadFailures: failures });
+        if (liveConfirmedSinceAck && failures >= ACKED_DEATH_CONSECUTIVE_READ_FAILURES) {
+          LOG.warn("MeshReconcile", `Acked-hold death signal: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) read_chat failed ${failures}x consecutively after a live-confirmed ack \u2014 worker session presumed gone mid-turn; releasing the indefinite synth hold to the stranded-reclaim / orphan-prune nets`);
+        }
+      }
+      continue;
+    }
+    const priorHoldState = getHoldState(synthKey, mesh.id);
+    setHoldState(synthKey, mesh.id, {
+      liveConfirmedSinceAck: true,
+      consecutiveReadFailures: 0,
+      ...priorHoldState?.transcriptIdleSinceMs !== void 0 ? { transcriptIdleSinceMs: priorHoldState.transcriptIdleSinceMs } : {}
+    });
+    const nowMs = Date.now();
+    if (readChatPayloadStatus(payload) !== "idle") {
+      setHoldState(synthKey, mesh.id, { liveConfirmedSinceAck: true, consecutiveReadFailures: 0 });
+      continue;
+    }
+    const messages = Array.isArray(payload.messages) ? payload.messages : [];
+    const evidence = extractFinalAssistantSummaryEvidence(messages);
+    if (isAcked) {
+      const ackedAtMs = Date.parse(readNonEmptyString2(dispatch.updatedAt));
+      const sinceAckMs = Number.isFinite(ackedAtMs) ? nowMs - ackedAtMs : Number.POSITIVE_INFINITY;
+      const deathDeadlineMs = resolveAckedDeathDeadlineMs();
+      const holdState = getHoldState(synthKey, mesh.id);
+      let fastTrackReady = false;
+      if (evidence.finalSummary) {
+        const idleSinceMs = holdState?.transcriptIdleSinceMs ?? nowMs;
+        if (holdState && holdState.transcriptIdleSinceMs === void 0) {
+          setHoldState(synthKey, mesh.id, { ...holdState, transcriptIdleSinceMs: idleSinceMs });
+        }
+        const fastTrackGraceMs = resolveAckedTranscriptFastTrackGraceMs();
+        const idleHeldMs = nowMs - idleSinceMs;
+        if (idleHeldMs >= fastTrackGraceMs) {
+          fastTrackReady = true;
+          backstopKind = "ackedHoldFastTrackFired";
+          LOG.info("MeshReconcile", `Acked-hold transcript fast-track: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) read idle WITH a final assistant message for ${Math.round(idleHeldMs / 1e3)}s continuous (grace ${Math.round(fastTrackGraceMs / 1e3)}s) \u2014 promoting the synth ahead of the ${Math.round(deathDeadlineMs / 1e3)}s death backstop; the worker's real emit was lost/late and a later one no-ops idempotently.`);
+        }
+      } else if (holdState?.transcriptIdleSinceMs !== void 0) {
+        setHoldState(synthKey, mesh.id, { ...holdState, transcriptIdleSinceMs: void 0 });
+      }
+      if (!fastTrackReady && sinceAckMs < deathDeadlineMs) {
+        LOG.info("MeshReconcile", `Acked-hold: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) read idle ${Number.isFinite(sinceAckMs) ? Math.round(sinceAckMs / 1e3) + "s" : "\u221E"} since the generating_started ack \u2014 HOLDING synth (worker presumed alive; a later real emit is idempotent). Transcript fast-track promotes at ${Math.round(resolveAckedTranscriptFastTrackGraceMs() / 1e3)}s continuous idle-with-final-assistant; death backstop at ${Math.round(deathDeadlineMs / 1e3)}s or on consecutive read failures.`);
+        continue;
+      }
+      if (!fastTrackReady) {
+        backstopKind = "ackedHoldDeathDeadlineFired";
+        LOG.warn("MeshReconcile", `Acked-hold death deadline reached: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) still idle ${Math.round(sinceAckMs / 1e3)}s after the ack (deadline ${Math.round(deathDeadlineMs / 1e3)}s) \u2014 synthesizing the missing completion as a notification-loss net (a real emit, if it ever lands, no-ops idempotently).`);
+      }
+    }
+    if (realTerminalEmitPendingForTask(mesh.id, taskId)) {
+      deleteHoldState(synthKey, mesh.id);
+      LOG.info("MeshReconcile", `Worker-emit priority: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) has a real terminal completion already queued \u2014 yielding synth to the worker's own emit`);
+      continue;
+    }
+    if (!evidence.finalSummary) continue;
+    const dispatchedAtMs = Date.parse(readNonEmptyString2(dispatch.dispatchedAt));
+    const transcriptAtMs = Date.parse(evidence.transcriptMessageAt ?? "");
+    if (Number.isFinite(dispatchedAtMs) && Number.isFinite(transcriptAtMs) && transcriptAtMs < dispatchedAtMs) {
+      LOG.info("MeshReconcile", `Stale-summary guard: skipping transcript reconcile for task ${taskId} on node ${nodeId} (mesh ${mesh.id}) \u2014 final assistant message (${evidence.transcriptMessageAt}) predates this task's dispatch (${dispatch.dispatchedAt}); it is a prior task's summary`);
+      traceMeshEventDrop("reconcile_stale_summary_before_dispatch", {
+        taskId,
+        sessionId,
+        nodeId,
+        meshId: mesh.id,
+        event: "agent:generating_completed"
+      }, `transcriptAt=${evidence.transcriptMessageAt} < dispatchedAt=${dispatch.dispatchedAt}`);
+      continue;
+    }
+    const reprobeStatus = await reprobeWorkerStatus(components, { isLocalNode, nodeDaemonId, readArgs });
+    if (reprobeStatus && reprobeStatus !== "idle") {
+      deleteHoldState(synthKey, mesh.id);
+      LOG.info("MeshReconcile", `Live re-probe defer: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) read '${reprobeStatus}' at synth-commit time \u2014 worker resumed generating; deferring synth to a later tick`);
+      continue;
+    }
+    const providerSessionId = readNonEmptyString2(payload.providerSessionId);
+    const coordinatorDaemonId = selfIds.find((id) => !!id);
+    try {
+      const result = reconcileDirectDispatchCompletionFromTranscript({
+        meshId: mesh.id,
+        nodeId,
+        sessionId,
+        providerType: providerType || void 0,
+        providerSessionId: providerSessionId || void 0,
+        taskId,
+        finalSummary: evidence.finalSummary,
+        ...evidence.transcriptMessageAt ? { transcriptMessageAt: evidence.transcriptMessageAt } : {},
+        ...coordinatorDaemonId ? { targetCoordinatorDaemonId: coordinatorDaemonId } : {},
+        source: "daemon_reconcile_transcript_completion"
+      });
+      if (result.reconciled) {
+        recordBackstopFire(backstopKind ?? "phase4SynthesisFired", `task ${taskId} on node ${nodeId} (mesh ${mesh.id}), kind=${result.kind}`);
+        LOG.info("MeshReconcile", `Synthesized missing completion (${result.kind}) for task ${taskId} on node ${nodeId} (mesh ${mesh.id})`);
+      }
+    } catch (e) {
+      LOG.warn("MeshReconcile", `Transcript completion reconcile threw for task ${taskId}: ${e?.message || e}`);
     }
   }
-  return heldKeys;
 }
-var ACKED_DEATH_CONSECUTIVE_READ_FAILURES, inFlightAckedHoldState, rehydratedHoldMeshes;
-var init_mesh_reconcile_acked_hold = __esm({
-  "src/mesh/mesh-reconcile-acked-hold.ts"() {
+async function autoPruneStaleDirectDispatches(components, mesh, selfIds, localDaemonId, minAgeMs) {
+  const directDispatches = getActiveDirectDispatches(mesh.id);
+  if (directDispatches.length === 0) return;
+  const liveNodes = await collectLiveNodesWithSessions(components, mesh, selfIds, localDaemonId);
+  const result = pruneStaleDirectDispatches({
+    meshId: mesh.id,
+    queue: getQueue(mesh.id),
+    ledgerEntries: readLedgerEntries(mesh.id, { tail: 500 }),
+    directDispatches,
+    nodes: liveNodes,
+    execute: true,
+    minAgeMs,
+    source: "daemon_reconcile_auto_prune"
+  });
+  if (result.prunedCount > 0) {
+    LOG.info("MeshReconcile", `Auto-pruned ${result.prunedCount} orphaned direct dispatch record(s) for mesh ${mesh.id}`);
+  }
+}
+var init_mesh_completion_synthesis = __esm({
+  "src/mesh/mesh-completion-synthesis.ts"() {
     "use strict";
     init_logger();
-    init_mesh_runtime_store();
     init_mesh_events_utils();
-    ACKED_DEATH_CONSECUTIVE_READ_FAILURES = 3;
-    inFlightAckedHoldState = /* @__PURE__ */ new Map();
-    rehydratedHoldMeshes = /* @__PURE__ */ new Set();
+    init_mesh_event_trace();
+    init_dist();
+    init_mesh_reconcile_identity();
+    init_mesh_work_queue();
+    init_mesh_ledger();
+    init_mesh_active_work();
+    init_mesh_events_stale();
+    init_chat_message_normalization();
+    init_mesh_reconcile_v2_backstop();
+    init_mesh_reconcile_acked_hold();
+    init_mesh_remote_event_pull();
   }
 });
 
 // src/mesh/mesh-reconcile-loop.ts
-function resolveAutoPruneMinAgeMs() {
-  const raw = readNonEmptyString2(process.env.MESH_AUTO_PRUNE_MIN_AGE_MS);
-  if (raw) {
-    const parsed = Number.parseInt(raw, 10);
-    if (Number.isFinite(parsed) && parsed >= 60 * 6e4 && parsed <= 30 * 24 * 60 * 6e4) return parsed;
-  }
-  return DEFAULT_AUTO_PRUNE_MIN_AGE_MS;
-}
-function resolvePendingHeldDrainEscalateMs() {
-  return resolveTunedReconcileMs("MESH_PENDING_HELD_DRAIN_ESCALATE_MS", DEFAULT_PENDING_HELD_DRAIN_ESCALATE_MS, 4e3, 5 * 6e4);
-}
-function resolveReconcileIntervalMs() {
-  const raw = readNonEmptyString2(process.env.MESH_RECONCILE_INTERVAL_MS);
-  if (raw) {
-    const parsed = Number.parseInt(raw, 10);
-    if (Number.isFinite(parsed) && parsed >= 1e3 && parsed <= 6e4) return parsed;
-  }
-  return DEFAULT_RECONCILE_INTERVAL_MS;
-}
 function findLiveCoordinators(components) {
   const out = [];
   for (const inst of components.instanceManager.getByCategory("cli")) {
@@ -19304,349 +19851,6 @@ async function retryUnresolvedDelegateForwards(components) {
     LOG.info("MeshReconcile", `Retried+delivered unresolved-delegate ${readNonEmptyString2(entry.payload.event)} to coordinator ${entry.coordinatorDaemonId}`);
   }
 }
-async function pullRemoteNodeQueues(components, mesh, localDaemonId, candidateDaemonIds) {
-  const dispatchMeshCommand = components.dispatchMeshCommand;
-  if (!dispatchMeshCommand) return;
-  const meshId = mesh.id;
-  const pulls = candidateDaemonIds.length > 0 ? candidateDaemonIds.map((id) => ({ meshId, coordinatorDaemonId: id })) : [{ meshId }];
-  for (const node of mesh.nodes) {
-    const nodeDaemonId = readNonEmptyString2(node.daemonId);
-    if (!nodeDaemonId) continue;
-    if (daemonIdsEquivalent(nodeDaemonId, localDaemonId)) continue;
-    if (daemonIdListIncludes(candidateDaemonIds, nodeDaemonId)) continue;
-    for (const pendingEventArgs of pulls) {
-      let events;
-      try {
-        events = await dispatchMeshCommand(nodeDaemonId, "get_pending_mesh_events", pendingEventArgs);
-      } catch {
-        break;
-      }
-      const list = extractPendingEvents(events).filter((e) => readNonEmptyString2(e?.meshId) === meshId);
-      for (const event of list) {
-        const payload = buildForwardPayloadFromPending(event);
-        if (!payload.event || !payload.meshId) continue;
-        try {
-          handleMeshForwardEvent(components, payload);
-        } catch {
-        }
-      }
-    }
-  }
-}
-function unwrapReadChatPayload(raw) {
-  let cursor = raw;
-  for (let depth = 0; depth < 4 && cursor && typeof cursor === "object"; depth++) {
-    const record = cursor;
-    if (Array.isArray(record.messages)) return record;
-    if (record.payload && typeof record.payload === "object") {
-      cursor = record.payload;
-      continue;
-    }
-    if (record.result && typeof record.result === "object") {
-      cursor = record.result;
-      continue;
-    }
-    if (record.data && typeof record.data === "object") {
-      cursor = record.data;
-      continue;
-    }
-    break;
-  }
-  return cursor && typeof cursor === "object" ? cursor : null;
-}
-function readChatPayloadStatus(payload) {
-  return readNonEmptyString2(payload?.status).toLowerCase();
-}
-function realTerminalEmitPendingForTask(meshId, taskId) {
-  let pending;
-  try {
-    pending = getPendingMeshCoordinatorEvents(meshId);
-  } catch {
-    return false;
-  }
-  return pending.some((e) => readNonEmptyString2(e.metadataEvent?.taskId) === taskId && (e.event === "agent:generating_completed" || e.event === "agent:stopped"));
-}
-async function reprobeWorkerStatus(components, args) {
-  try {
-    if (args.isLocalNode) {
-      const r = await components.commandHandler.handle("read_chat", args.readArgs);
-      if (r && r.success === false) return null;
-      return readChatPayloadStatus(unwrapReadChatPayload(r));
-    }
-    if (components.dispatchMeshCommand) {
-      const r = await components.dispatchMeshCommand(args.nodeDaemonId, "read_chat", args.readArgs);
-      const p = unwrapReadChatPayload(r);
-      if (p && p.success === false) return null;
-      return readChatPayloadStatus(p);
-    }
-  } catch {
-    return null;
-  }
-  return null;
-}
-async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds, localDaemonId) {
-  const dispatches = getActiveDirectDispatches(mesh.id);
-  rehydrateAckedHoldsForMesh(mesh.id);
-  const activeTaskKeys = new Set(
-    dispatches.map((d) => readNonEmptyString2(d.taskId)).filter(Boolean).map((taskId) => inFlightSynthKey(mesh.id, taskId))
-  );
-  const heldKeys = collectHeldSynthKeysForMesh(mesh.id);
-  for (const key2 of heldKeys) {
-    if (!activeTaskKeys.has(key2)) deleteHoldState(key2, mesh.id);
-  }
-  if (dispatches.length === 0) return;
-  const dispatchMeshCommand = components.dispatchMeshCommand;
-  const nodeById = new Map(mesh.nodes.map((n) => [n.id, n]));
-  for (const dispatch of dispatches) {
-    const sessionId = readNonEmptyString2(dispatch.sessionId);
-    const nodeId = readNonEmptyString2(dispatch.nodeId);
-    const taskId = readNonEmptyString2(dispatch.taskId);
-    if (!sessionId || !nodeId || !taskId) continue;
-    const node = nodeById.get(nodeId);
-    const nodeDaemonId = readNonEmptyString2(node?.daemonId);
-    const isLocalNode = !nodeDaemonId || daemonIdListIncludes(selfIds, nodeDaemonId) || daemonIdsEquivalent(nodeDaemonId, localDaemonId) || !!components.instanceManager.getInstance(sessionId);
-    const providerType = readNonEmptyString2(dispatch.providerType);
-    const readArgs = {
-      sessionId,
-      targetSessionId: sessionId,
-      tailLimit: 10,
-      ...node?.workspace ? { workspace: node.workspace } : {},
-      ...providerType ? { agentType: providerType, providerType } : {}
-    };
-    const synthKey = inFlightSynthKey(mesh.id, taskId);
-    const isAcked = dispatch.status === "acked";
-    let backstopKind;
-    let payload = null;
-    let readFailed = false;
-    try {
-      if (isLocalNode) {
-        const result = await components.commandHandler.handle("read_chat", readArgs);
-        if (result && result.success === false) {
-          readFailed = true;
-        } else {
-          payload = unwrapReadChatPayload(result);
-        }
-      } else if (dispatchMeshCommand) {
-        const result = await dispatchMeshCommand(nodeDaemonId, "read_chat", readArgs);
-        payload = unwrapReadChatPayload(result);
-        if (payload && payload.success === false) {
-          payload = null;
-          readFailed = true;
-        }
-      } else {
-        continue;
-      }
-    } catch {
-      readFailed = true;
-    }
-    if (!payload && !readFailed) continue;
-    if (readFailed || !payload) {
-      if (isAcked) {
-        const prior = getHoldState(synthKey, mesh.id);
-        const failures = (prior?.consecutiveReadFailures ?? 0) + 1;
-        const liveConfirmedSinceAck = prior?.liveConfirmedSinceAck ?? false;
-        setHoldState(synthKey, mesh.id, { liveConfirmedSinceAck, consecutiveReadFailures: failures });
-        if (liveConfirmedSinceAck && failures >= ACKED_DEATH_CONSECUTIVE_READ_FAILURES) {
-          LOG.warn("MeshReconcile", `Acked-hold death signal: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) read_chat failed ${failures}x consecutively after a live-confirmed ack \u2014 worker session presumed gone mid-turn; releasing the indefinite synth hold to the stranded-reclaim / orphan-prune nets`);
-        }
-      }
-      continue;
-    }
-    const priorHoldState = getHoldState(synthKey, mesh.id);
-    setHoldState(synthKey, mesh.id, {
-      liveConfirmedSinceAck: true,
-      consecutiveReadFailures: 0,
-      ...priorHoldState?.transcriptIdleSinceMs !== void 0 ? { transcriptIdleSinceMs: priorHoldState.transcriptIdleSinceMs } : {}
-    });
-    const nowMs = Date.now();
-    if (readChatPayloadStatus(payload) !== "idle") {
-      setHoldState(synthKey, mesh.id, { liveConfirmedSinceAck: true, consecutiveReadFailures: 0 });
-      continue;
-    }
-    const messages = Array.isArray(payload.messages) ? payload.messages : [];
-    const evidence = extractFinalAssistantSummaryEvidence(messages);
-    if (isAcked) {
-      const ackedAtMs = Date.parse(readNonEmptyString2(dispatch.updatedAt));
-      const sinceAckMs = Number.isFinite(ackedAtMs) ? nowMs - ackedAtMs : Number.POSITIVE_INFINITY;
-      const deathDeadlineMs = resolveAckedDeathDeadlineMs();
-      const holdState = getHoldState(synthKey, mesh.id);
-      let fastTrackReady = false;
-      if (evidence.finalSummary) {
-        const idleSinceMs = holdState?.transcriptIdleSinceMs ?? nowMs;
-        if (holdState && holdState.transcriptIdleSinceMs === void 0) {
-          setHoldState(synthKey, mesh.id, { ...holdState, transcriptIdleSinceMs: idleSinceMs });
-        }
-        const fastTrackGraceMs = resolveAckedTranscriptFastTrackGraceMs();
-        const idleHeldMs = nowMs - idleSinceMs;
-        if (idleHeldMs >= fastTrackGraceMs) {
-          fastTrackReady = true;
-          backstopKind = "ackedHoldFastTrackFired";
-          LOG.info("MeshReconcile", `Acked-hold transcript fast-track: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) read idle WITH a final assistant message for ${Math.round(idleHeldMs / 1e3)}s continuous (grace ${Math.round(fastTrackGraceMs / 1e3)}s) \u2014 promoting the synth ahead of the ${Math.round(deathDeadlineMs / 1e3)}s death backstop; the worker's real emit was lost/late and a later one no-ops idempotently.`);
-        }
-      } else if (holdState?.transcriptIdleSinceMs !== void 0) {
-        setHoldState(synthKey, mesh.id, { ...holdState, transcriptIdleSinceMs: void 0 });
-      }
-      if (!fastTrackReady && sinceAckMs < deathDeadlineMs) {
-        LOG.info("MeshReconcile", `Acked-hold: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) read idle ${Number.isFinite(sinceAckMs) ? Math.round(sinceAckMs / 1e3) + "s" : "\u221E"} since the generating_started ack \u2014 HOLDING synth (worker presumed alive; a later real emit is idempotent). Transcript fast-track promotes at ${Math.round(resolveAckedTranscriptFastTrackGraceMs() / 1e3)}s continuous idle-with-final-assistant; death backstop at ${Math.round(deathDeadlineMs / 1e3)}s or on consecutive read failures.`);
-        continue;
-      }
-      if (!fastTrackReady) {
-        backstopKind = "ackedHoldDeathDeadlineFired";
-        LOG.warn("MeshReconcile", `Acked-hold death deadline reached: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) still idle ${Math.round(sinceAckMs / 1e3)}s after the ack (deadline ${Math.round(deathDeadlineMs / 1e3)}s) \u2014 synthesizing the missing completion as a notification-loss net (a real emit, if it ever lands, no-ops idempotently).`);
-      }
-    }
-    if (realTerminalEmitPendingForTask(mesh.id, taskId)) {
-      deleteHoldState(synthKey, mesh.id);
-      LOG.info("MeshReconcile", `Worker-emit priority: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) has a real terminal completion already queued \u2014 yielding synth to the worker's own emit`);
-      continue;
-    }
-    if (!evidence.finalSummary) continue;
-    const dispatchedAtMs = Date.parse(readNonEmptyString2(dispatch.dispatchedAt));
-    const transcriptAtMs = Date.parse(evidence.transcriptMessageAt ?? "");
-    if (Number.isFinite(dispatchedAtMs) && Number.isFinite(transcriptAtMs) && transcriptAtMs < dispatchedAtMs) {
-      LOG.info("MeshReconcile", `Stale-summary guard: skipping transcript reconcile for task ${taskId} on node ${nodeId} (mesh ${mesh.id}) \u2014 final assistant message (${evidence.transcriptMessageAt}) predates this task's dispatch (${dispatch.dispatchedAt}); it is a prior task's summary`);
-      traceMeshEventDrop("reconcile_stale_summary_before_dispatch", {
-        taskId,
-        sessionId,
-        nodeId,
-        meshId: mesh.id,
-        event: "agent:generating_completed"
-      }, `transcriptAt=${evidence.transcriptMessageAt} < dispatchedAt=${dispatch.dispatchedAt}`);
-      continue;
-    }
-    const reprobeStatus = await reprobeWorkerStatus(components, { isLocalNode, nodeDaemonId, readArgs });
-    if (reprobeStatus && reprobeStatus !== "idle") {
-      deleteHoldState(synthKey, mesh.id);
-      LOG.info("MeshReconcile", `Live re-probe defer: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) read '${reprobeStatus}' at synth-commit time \u2014 worker resumed generating; deferring synth to a later tick`);
-      continue;
-    }
-    const providerSessionId = readNonEmptyString2(payload.providerSessionId);
-    const coordinatorDaemonId = selfIds.find((id) => !!id);
-    try {
-      const result = reconcileDirectDispatchCompletionFromTranscript({
-        meshId: mesh.id,
-        nodeId,
-        sessionId,
-        providerType: providerType || void 0,
-        providerSessionId: providerSessionId || void 0,
-        taskId,
-        finalSummary: evidence.finalSummary,
-        ...evidence.transcriptMessageAt ? { transcriptMessageAt: evidence.transcriptMessageAt } : {},
-        ...coordinatorDaemonId ? { targetCoordinatorDaemonId: coordinatorDaemonId } : {},
-        source: "daemon_reconcile_transcript_completion"
-      });
-      if (result.reconciled) {
-        recordBackstopFire(backstopKind ?? "phase4SynthesisFired", `task ${taskId} on node ${nodeId} (mesh ${mesh.id}), kind=${result.kind}`);
-        LOG.info("MeshReconcile", `Synthesized missing completion (${result.kind}) for task ${taskId} on node ${nodeId} (mesh ${mesh.id})`);
-      }
-    } catch (e) {
-      LOG.warn("MeshReconcile", `Transcript completion reconcile threw for task ${taskId}: ${e?.message || e}`);
-    }
-  }
-}
-async function autoPruneStaleDirectDispatches(components, mesh, selfIds, localDaemonId, minAgeMs) {
-  const directDispatches = getActiveDirectDispatches(mesh.id);
-  if (directDispatches.length === 0) return;
-  const liveNodes = await collectLiveNodesWithSessions(components, mesh, selfIds, localDaemonId);
-  const result = pruneStaleDirectDispatches({
-    meshId: mesh.id,
-    queue: getQueue(mesh.id),
-    ledgerEntries: readLedgerEntries(mesh.id, { tail: 500 }),
-    directDispatches,
-    nodes: liveNodes,
-    execute: true,
-    minAgeMs,
-    source: "daemon_reconcile_auto_prune"
-  });
-  if (result.prunedCount > 0) {
-    LOG.info("MeshReconcile", `Auto-pruned ${result.prunedCount} orphaned direct dispatch record(s) for mesh ${mesh.id}`);
-  }
-}
-async function collectLiveNodesWithSessions(components, mesh, selfIds, localDaemonId) {
-  const dispatchMeshCommand = components.dispatchMeshCommand;
-  return Promise.all(mesh.nodes.map(async (node) => {
-    const nodeDaemonId = readNonEmptyString2(node.daemonId);
-    const isLocalNode = !nodeDaemonId || daemonIdListIncludes(selfIds, nodeDaemonId) || daemonIdsEquivalent(nodeDaemonId, localDaemonId);
-    let statusResult;
-    try {
-      if (isLocalNode) {
-        statusResult = await components.commandHandler.handle("get_status_metadata", {});
-      } else if (dispatchMeshCommand) {
-        statusResult = await dispatchMeshCommand(nodeDaemonId, "get_status_metadata", {});
-      } else {
-        return node;
-      }
-    } catch {
-      return node;
-    }
-    const sessions = extractStatusMetadataSessions(statusResult);
-    return sessions.length > 0 ? { ...node, sessions } : node;
-  }));
-}
-function extractStatusMetadataSessions(raw) {
-  let cursor = raw;
-  for (let depth = 0; depth < 4 && cursor && typeof cursor === "object"; depth++) {
-    const record = cursor;
-    const status = record.status && typeof record.status === "object" ? record.status : void 0;
-    if (status && Array.isArray(status.sessions)) return status.sessions;
-    if (Array.isArray(record.sessions)) return record.sessions;
-    if (record.payload && typeof record.payload === "object") {
-      cursor = record.payload;
-      continue;
-    }
-    if (record.result && typeof record.result === "object") {
-      cursor = record.result;
-      continue;
-    }
-    if (record.data && typeof record.data === "object") {
-      cursor = record.data;
-      continue;
-    }
-    break;
-  }
-  return [];
-}
-function extractPendingEvents(raw) {
-  if (Array.isArray(raw)) return raw;
-  if (raw && typeof raw === "object") {
-    const events = raw.events;
-    if (Array.isArray(events)) return events;
-  }
-  return [];
-}
-function buildForwardPayloadFromPending(event) {
-  const metadata = event?.metadataEvent && typeof event.metadataEvent === "object" ? event.metadataEvent : {};
-  return {
-    event: readNonEmptyString2(event?.event),
-    meshId: readNonEmptyString2(event?.meshId),
-    nodeId: readNonEmptyString2(event?.nodeId) || readNonEmptyString2(metadata.meshNodeId),
-    workspace: readNonEmptyString2(event?.workspace) || readNonEmptyString2(metadata.workspace),
-    // Preserve the originating coordinator session id across the relay. It is normally
-    // carried inside metadataEvent.meshCoordinatorSessionId (spread below), but pass the
-    // top-level field through explicitly too so the handleMeshForwardEvent whitelist
-    // recovers it regardless of which carrier the producing daemon used.
-    ...readNonEmptyString2(event?.targetCoordinatorSessionId) ? { targetCoordinatorSessionId: readNonEmptyString2(event.targetCoordinatorSessionId) } : {},
-    ...metadata,
-    // NOTIF-MISS (FIX 3): surface the dispatch task id at the TOP LEVEL so the relay's
-    // received-stage trace (and buildRelayMetadataEvent) recovers it regardless of which
-    // carrier the producing daemon used. The metadata spread above may carry the id only as
-    // `meshActiveTaskId` (a worker provider event), leaving top-level `taskId` unset and the
-    // received stage rendering `task=-`. Resolve both carriers into an explicit `taskId` so
-    // dedup stays task-scoped end-to-end. Only set when a non-empty id exists (no clobber to
-    // undefined when neither is present).
-    ...(() => {
-      const tid = readNonEmptyString2(metadata.taskId) || readNonEmptyString2(metadata.meshActiveTaskId);
-      return tid ? { taskId: tid } : {};
-    })(),
-    // T4 (B3b): carry the v2 envelope (protocolVersion/eventId/scope/dispatchedBy/
-    // intendedFor) across the P2P relay boundary at the TOP LEVEL. These live on the
-    // pending event itself, not inside metadataEvent, so without this the remote pull
-    // re-queue would re-stamp a fresh eventId — breaking cross-machine idempotency and
-    // downgrading the relayed completion to v1 broadcast routing. Spread LAST so the
-    // authoritative envelope always wins over any stale key the metadata spread carried.
-    ...serializeV2EnvelopeToWire(event)
-  };
-}
 function setupMeshReconcileLoop(components) {
   const intervalMs = resolveReconcileIntervalMs();
   let running = false;
@@ -19666,7 +19870,7 @@ function setupMeshReconcileLoop(components) {
     }
   };
 }
-var DEFAULT_RECONCILE_INTERVAL_MS, DEFAULT_AUTO_PRUNE_MIN_AGE_MS, DEFAULT_PENDING_HELD_DRAIN_ESCALATE_MS, coordinatorModalParkState, heldEventLedgerRecorded, ASSIGNED_STRANDED_DEADLINE_MS, DELIVERED_NO_TURN_DEADLINE_MS, RECLAIM_UNKNOWN_GRACE_TICKS, deliveredNoTurnUnknownStreak, STRICT_SESSION_MATCH_TTL_MS, unresolvedForwardRejectionCounts, MAX_FORWARD_REJECTIONS;
+var coordinatorModalParkState, heldEventLedgerRecorded, ASSIGNED_STRANDED_DEADLINE_MS, DELIVERED_NO_TURN_DEADLINE_MS, RECLAIM_UNKNOWN_GRACE_TICKS, deliveredNoTurnUnknownStreak, STRICT_SESSION_MATCH_TTL_MS, unresolvedForwardRejectionCounts, MAX_FORWARD_REJECTIONS;
 var init_mesh_reconcile_loop = __esm({
   "src/mesh/mesh-reconcile-loop.ts"() {
     "use strict";
@@ -19685,17 +19889,13 @@ var init_mesh_reconcile_loop = __esm({
     init_mesh_work_queue();
     init_mesh_queue_assignment();
     init_mesh_ledger();
-    init_mesh_active_work();
     init_mesh_events_stale();
-    init_chat_message_normalization();
     init_mesh_reconcile_identity();
+    init_mesh_reconcile_config();
+    init_mesh_remote_event_pull();
+    init_mesh_completion_synthesis();
     init_mesh_reconcile_v2_backstop();
     init_mesh_reconcile_acked_hold();
-    init_mesh_reconcile_v2_backstop();
-    init_mesh_reconcile_acked_hold();
-    DEFAULT_RECONCILE_INTERVAL_MS = 4e3;
-    DEFAULT_AUTO_PRUNE_MIN_AGE_MS = 24 * 60 * 6e4;
-    DEFAULT_PENDING_HELD_DRAIN_ESCALATE_MS = 12e3;
     coordinatorModalParkState = /* @__PURE__ */ new Map();
     heldEventLedgerRecorded = /* @__PURE__ */ new Set();
     ASSIGNED_STRANDED_DEADLINE_MS = 5 * 6e4;
@@ -19725,6 +19925,7 @@ __export(mesh_events_exports, {
   queuePendingMeshCoordinatorEvent: () => queuePendingMeshCoordinatorEvent,
   readV2EnvelopeFromWire: () => readV2EnvelopeFromWire,
   reconcileDirectDispatchCompletionFromTranscript: () => reconcileDirectDispatchCompletionFromTranscript,
+  requeueHeldMeshCoordinatorEvents: () => requeueHeldMeshCoordinatorEvents,
   resolveCoordinatorDrainDeliverability: () => resolveCoordinatorDrainDeliverability,
   runMeshReconcileTick: () => runMeshReconcileTick,
   serializeV2EnvelopeToWire: () => serializeV2EnvelopeToWire,
@@ -26611,6 +26812,7 @@ init_mesh_config();
 init_dist();
 init_dist();
 init_dist();
+init_dist();
 init_coordinator_prompt();
 init_mesh_missions();
 init_mesh_task_stats();
@@ -42306,7 +42508,7 @@ async function waitForCliAdapterReady(adapter, options) {
   throw new Error(`CLI runtime did not become ready within ${timeoutMs}ms`);
 }
 
-// src/providers/cli-provider-instance.ts
+// src/providers/cli-provider-instance-types.ts
 var STATUS_HYDRATION_TAIL_LIMIT = 200;
 var COMPLETED_FINALIZATION_RETRY_MS = 1e3;
 var COMPLETED_FINALIZATION_MAX_WAIT_MS = 3e4;
@@ -42318,6 +42520,123 @@ var TERMINAL_MESH_EVENTS = /* @__PURE__ */ new Set([
   "agent:stopped",
   "agent:ready"
 ]);
+
+// src/providers/cli-provider-transcript-merge.ts
+init_contracts2();
+init_chat_message_normalization();
+function mergeConversationMessages(runtimeMessages, parsedMessages) {
+  if (runtimeMessages.length === 0) return normalizeChatMessages(parsedMessages);
+  const parsedEntries = parsedMessages.map((message, index) => ({
+    message,
+    index,
+    source: "parsed"
+  }));
+  const getRole = (message) => typeof message.role === "string" ? message.role.trim().toLowerCase() : "";
+  const runtimeEntries = runtimeMessages.map((entry, index) => ({
+    message: entry.message,
+    index: parsedMessages.length + index,
+    source: "runtime",
+    runtimeKey: entry.key
+  })).filter((entry) => {
+    const meta = entry.message.meta && typeof entry.message.meta === "object" && !Array.isArray(entry.message.meta) ? entry.message.meta : {};
+    if (meta.runtimeInputAck !== true) return true;
+    const runtimeText = flattenContent(entry.message.content).replace(/\s+/g, " ").trim();
+    if (!runtimeText) return false;
+    return !parsedEntries.some((parsedEntry) => {
+      const parsedRole = getRole(parsedEntry.message);
+      if (parsedRole !== "user" && parsedRole !== "human") return false;
+      const parsedText = flattenContent(parsedEntry.message.content).replace(/\s+/g, " ").trim();
+      return parsedText === runtimeText;
+    });
+  });
+  const getTime = (message) => {
+    const value = typeof message.receivedAt === "number" ? message.receivedAt : typeof message.timestamp === "number" ? message.timestamp : 0;
+    return Number.isFinite(value) && value > 0 ? value : 0;
+  };
+  const isRuntimeOverlay = (entry) => {
+    if (entry.source !== "runtime") return false;
+    const key2 = typeof entry.runtimeKey === "string" ? entry.runtimeKey.trim().toLowerCase() : "";
+    if (key2.startsWith("auto_approval:")) return true;
+    return !isUserFacingChatMessage(entry.message);
+  };
+  const shouldKeepParsedBeforeUntimedRuntime = (message) => {
+    const role = getRole(message);
+    return role === "user" || role === "human";
+  };
+  const shouldKeepParsedAfterUntimedRuntime = (message) => {
+    const role = getRole(message);
+    if (role !== "assistant") return false;
+    const kind = resolveChatMessageKind(message);
+    return kind === "standard" || kind === "terminal";
+  };
+  return normalizeChatMessages([...parsedEntries, ...runtimeEntries].sort((a, b) => {
+    const aTime = getTime(a.message);
+    const bTime = getTime(b.message);
+    if (aTime && bTime && aTime !== bTime) return aTime - bTime;
+    if (a.source !== b.source && aTime !== bTime) {
+      const parsedEntry = a.source === "parsed" ? a : b.source === "parsed" ? b : null;
+      const runtimeEntry = a.source === "runtime" ? a : b.source === "runtime" ? b : null;
+      if (parsedEntry && runtimeEntry && isRuntimeOverlay(runtimeEntry) && getTime(parsedEntry.message) === 0 && getTime(runtimeEntry.message) > 0) {
+        if (shouldKeepParsedBeforeUntimedRuntime(parsedEntry.message)) {
+          return a.source === "parsed" ? -1 : 1;
+        }
+        if (shouldKeepParsedAfterUntimedRuntime(parsedEntry.message)) {
+          return a.source === "parsed" ? 1 : -1;
+        }
+      }
+    }
+    return a.index - b.index;
+  }).map((entry) => entry.message));
+}
+function buildExternalTranscriptProbe(messages, sourcePath, sourceMtimeMs) {
+  const visibleMessages = messages.filter((message) => isUserFacingChatMessage(message));
+  const lastVisible = visibleMessages[visibleMessages.length - 1];
+  const readAt = Date.now();
+  const mtimeMs = Number(sourceMtimeMs) || 0;
+  return {
+    readAt,
+    msgCount: messages.length,
+    lastRole: typeof lastVisible?.role === "string" ? lastVisible.role.trim().toLowerCase() : null,
+    lastKind: typeof lastVisible?.kind === "string" ? lastVisible.kind : null,
+    contentLen: lastVisible ? flattenContent(lastVisible.content).trim().length : 0,
+    sourcePath: typeof sourcePath === "string" && sourcePath ? sourcePath : null,
+    sourceMtimeMs: mtimeMs || null,
+    mtimeAgeMs: mtimeMs ? Math.max(0, readAt - mtimeMs) : null
+  };
+}
+
+// src/providers/cli-provider-effect-format.ts
+function getEffectDedupKey(effect) {
+  if (effect.id) return `provider_effect:${effect.id}`;
+  if (effect.type === "message") {
+    const content = typeof effect.message?.content === "string" ? effect.message.content : JSON.stringify(effect.message?.content || "");
+    return `provider_effect:message:${content}`;
+  }
+  if (effect.type === "notification") {
+    return `provider_effect:notification:${effect.notification?.title || ""}:${effect.notification?.body || ""}`;
+  }
+  return `provider_effect:toast:${effect.toast?.message || ""}`;
+}
+function formatApprovalRequestMessage(modalMessage, buttons) {
+  const lines = ["Approval requested"];
+  const cleanMessage = String(modalMessage || "").trim();
+  if (cleanMessage) lines.push(cleanMessage);
+  const labels = (buttons || []).map((button) => String(button || "").trim()).filter(Boolean);
+  if (labels.length > 0) {
+    lines.push(labels.map((label) => `[${label}]`).join(" "));
+  }
+  return lines.join("\n");
+}
+function formatMarkerTimestamp(timestamp) {
+  const date = new Date(timestamp);
+  const pad = (value) => String(value).padStart(2, "0");
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+
+// src/providers/cli-provider-instance.ts
+function approvalModalSignature(message, affirmativeAnchor) {
+  return [typeof message === "string" ? message.trim() : "", affirmativeAnchor].join("::");
+}
 var CliProviderInstance = class _CliProviderInstance {
   constructor(provider, workingDir, cliArgs = [], instanceId, transportFactory, options) {
     this.provider = provider;
@@ -42565,7 +42884,7 @@ var CliProviderInstance = class _CliProviderInstance {
       const resumedAt = Date.now();
       this.historyWriter.appendSystemMarker(
         this.type,
-        `Resumed saved session at ${this.formatMarkerTimestamp(resumedAt)}`,
+        `Resumed saved session at ${formatMarkerTimestamp(resumedAt)}`,
         {
           instanceId: this.instanceId,
           historySessionId: this.providerSessionId,
@@ -42677,7 +42996,7 @@ var CliProviderInstance = class _CliProviderInstance {
     if (historyMessageCount !== null) {
       parsedMessages = historyMessageCount > 0 ? parsedMessages.slice(-historyMessageCount) : [];
     }
-    const mergedMessages = this.mergeConversationMessages(parsedMessages);
+    const mergedMessages = mergeConversationMessages(this.runtimeMessages, parsedMessages);
     const canonicalBackedHistory = this.shouldHydrateExistingProviderHistory() ? this.syncCanonicalSavedHistoryIfNeeded() : false;
     const statusMessages = canonicalBackedHistory && this.lastPersistedHistoryMessages.length > 0 ? this.lastPersistedHistoryMessages.map((message) => ({
       role: message.role,
@@ -43142,22 +43461,6 @@ var CliProviderInstance = class _CliProviderInstance {
     }
     return true;
   }
-  buildExternalTranscriptProbe(messages, sourcePath, sourceMtimeMs) {
-    const visibleMessages = messages.filter((message) => isUserFacingChatMessage(message));
-    const lastVisible = visibleMessages[visibleMessages.length - 1];
-    const readAt = Date.now();
-    const mtimeMs = Number(sourceMtimeMs) || 0;
-    return {
-      readAt,
-      msgCount: messages.length,
-      lastRole: typeof lastVisible?.role === "string" ? lastVisible.role.trim().toLowerCase() : null,
-      lastKind: typeof lastVisible?.kind === "string" ? lastVisible.kind : null,
-      contentLen: lastVisible ? flattenContent(lastVisible.content).trim().length : 0,
-      sourcePath: typeof sourcePath === "string" && sourcePath ? sourcePath : null,
-      sourceMtimeMs: mtimeMs || null,
-      mtimeAgeMs: mtimeMs ? Math.max(0, readAt - mtimeMs) : null
-    };
-  }
   recordPendingTranscriptProbe(pending) {
     const probe = this.lastExternalCompletionProbe;
     if (!probe) return null;
@@ -43209,7 +43512,7 @@ var CliProviderInstance = class _CliProviderInstance {
       this.lastExternalCompletionProbe = null;
       return null;
     }
-    this.lastExternalCompletionProbe = this.buildExternalTranscriptProbe(
+    this.lastExternalCompletionProbe = buildExternalTranscriptProbe(
       restoredHistory.messages,
       restoredHistory.sourcePath,
       restoredHistory.sourceMtimeMs
@@ -43457,6 +43760,27 @@ var CliProviderInstance = class _CliProviderInstance {
   autoApproveContinuityWindowMs() {
     return this.autoApproveMaskSince > 0 && this.isMeshWorkerSession() ? _CliProviderInstance.AUTO_APPROVE_FLAP_CONTINUITY_MS : _CliProviderInstance.AUTO_APPROVE_GATE_HYSTERESIS_MS;
   }
+  /**
+   * The settle-gate identity signature for a raw activeModal, or null when the
+   * modal is NOT a concrete auto-approvable consent prompt (no captured buttons,
+   * a picker/confirm kind, or no reliable affirmative+decline anchor). Mirrors the
+   * gates the auto-approve fire path applies before computing modalSignature, so
+   * the mask-stall nudge can ask the SAME question the settle gate is tracking —
+   * "is THIS frame's modal the identity the settle clock is accruing against?" —
+   * without duplicating the button-pick logic. The signature is message +
+   * normalized affirmative label only (no volatile counters/button set), matching
+   * the fire path exactly (AUTOAPPROVE-SETTLE-FLAP).
+   */
+  approvableModalSignature(modal) {
+    const buttons = Array.isArray(modal?.buttons) ? modal.buttons.map((b) => String(b || "").trim()).filter(Boolean) : [];
+    if (!modal || buttons.length === 0) return null;
+    const modalKind = typeof modal?.kind === "string" ? modal.kind : "approval";
+    if (modalKind !== "approval") return null;
+    const { index: buttonIndex, label: buttonLabel } = pickApprovalButton(buttons, this.provider);
+    const hasReliableConsentAnchor = hasNegativeApprovalOption(buttons) || hasReliableApprovalAffirmative(buttons);
+    if (buttonIndex < 0 || !hasReliableConsentAnchor) return null;
+    return approvalModalSignature(modal?.message, normalizeApprovalLabel(buttonLabel));
+  }
   // FALSE-IDLE (self-coordinator settle): an autonomously-progressing mesh session
   // is either a delegated worker (isMeshWorkerSession) OR the coordinator's OWN
   // claude-cli session (meshCoordinatorFor). Both run auto-approved tool turns whose
@@ -43760,10 +44084,7 @@ var CliProviderInstance = class _CliProviderInstance {
       return autoApproveActive;
     }
     const affirmativeAnchor = normalizeApprovalLabel(buttonLabel);
-    const modalSignature = [
-      typeof modal?.message === "string" ? modal.message.trim() : "",
-      affirmativeAnchor
-    ].join("::");
+    const modalSignature = approvalModalSignature(modal?.message, affirmativeAnchor);
     const approvalEntrySeq = typeof adapterStatus?.approvalEntrySeq === "number" ? adapterStatus.approvalEntrySeq : 0;
     const busySignature = `${approvalEntrySeq}::${modalSignature}`;
     if (this.autoApproveBusy && busySignature === this.lastAutoApprovalSignature) {
@@ -43996,7 +44317,7 @@ var CliProviderInstance = class _CliProviderInstance {
         if (approvalFingerprint !== this.lastApprovalEventFingerprint) {
           this.lastApprovalEventFingerprint = approvalFingerprint;
           this.appendRuntimeSystemMessage(
-            this.formatApprovalRequestMessage(modal?.message, modal?.buttons),
+            formatApprovalRequestMessage(modal?.message, modal?.buttons),
             `approval_request:${now}`,
             now
           );
@@ -44297,7 +44618,7 @@ var CliProviderInstance = class _CliProviderInstance {
       const effectWhen = effect.when || "immediate";
       if (effectWhen === "turn_completed" && options.phase !== "turn_completed") continue;
       if (effectWhen === "immediate" && options.phase === "turn_completed") continue;
-      const effectKey = this.getEffectDedupKey(effect);
+      const effectKey = getEffectDedupKey(effect);
       if (this.appliedEffectKeys.has(effectKey)) continue;
       this.appliedEffectKeys.add(effectKey);
       if (effect.persist !== false) {
@@ -44340,34 +44661,6 @@ var CliProviderInstance = class _CliProviderInstance {
       this.appliedEffectKeys = new Set(Array.from(this.appliedEffectKeys).slice(-100));
     }
   }
-  getEffectDedupKey(effect) {
-    if (effect.id) return `provider_effect:${effect.id}`;
-    if (effect.type === "message") {
-      const content = typeof effect.message?.content === "string" ? effect.message.content : JSON.stringify(effect.message?.content || "");
-      return `provider_effect:message:${content}`;
-    }
-    if (effect.type === "notification") {
-      return `provider_effect:notification:${effect.notification?.title || ""}:${effect.notification?.body || ""}`;
-    }
-    return `provider_effect:toast:${effect.toast?.message || ""}`;
-  }
-  getPersistedEffectContent(effect) {
-    if (effect.type === "message") {
-      return typeof effect.message?.content === "string" ? effect.message.content : JSON.stringify(effect.message?.content || "");
-    }
-    if (effect.type === "toast") {
-      return effect.toast?.message || null;
-    }
-    if (effect.type === "notification") {
-      if (typeof effect.notification?.bubbleContent === "string") return effect.notification.bubbleContent;
-      if (typeof effect.notification?.title === "string" && effect.notification.title.trim()) {
-        return `${effect.notification.title}
-${effect.notification.body || ""}`.trim();
-      }
-      return effect.notification?.body || null;
-    }
-    return null;
-  }
   // ─── Adapter access (backward compat) ──────────────────
   getAdapter() {
     return this.adapter;
@@ -44439,15 +44732,16 @@ ${effect.notification.body || ""}`.trim();
     if (!this.isMeshWorkerSession()) return;
     if (adapterStatus?.status !== "waiting_approval") return;
     if (!this.autoApproveMaskStalled(now)) return;
-    const modalButtons = Array.isArray(adapterStatus.activeModal?.buttons) ? adapterStatus.activeModal.buttons.map((b) => String(b || "").trim()).filter(Boolean) : [];
-    if (this.pendingAutoApprovalSince && modalButtons.length > 0) return;
+    const currentSignature = this.approvableModalSignature(adapterStatus.activeModal);
+    const settleProgressing = !!currentSignature && this.pendingAutoApprovalSince > 0 && currentSignature === this.pendingAutoApprovalSignature;
+    if (settleProgressing) return;
     if (this.stalledApprovalNudgeEpisode === this.autoApproveMaskSince) return;
     this.stalledApprovalNudgeEpisode = this.autoApproveMaskSince;
     const modal = adapterStatus.activeModal;
     const dirName = workingDirBasename(this.workingDir);
     const chatTitle = `${this.provider.name} \xB7 ${dirName}`;
     this.appendRuntimeSystemMessage(
-      this.formatApprovalRequestMessage(modal?.message, modal?.buttons),
+      formatApprovalRequestMessage(modal?.message, modal?.buttons),
       `approval_request:${now}`,
       now
     );
@@ -44477,11 +44771,6 @@ ${effect.notification.body || ""}`.trim();
       now
     );
   }
-  formatMarkerTimestamp(timestamp) {
-    const date = new Date(timestamp);
-    const pad = (value) => String(value).padStart(2, "0");
-    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
-  }
   maybeAppendRuntimeRecoveryMessage(runtime) {
     if (!runtime?.restoredFromStorage || !runtime.runtimeId) return;
     const recoveryState = String(runtime.recoveryState || "").trim();
@@ -44542,81 +44831,7 @@ ${effect.notification.body || ""}`.trim();
     }
   }
   mergeRuntimeChatMessages(parsedMessages) {
-    return this.mergeConversationMessages(parsedMessages);
-  }
-  mergeConversationMessages(parsedMessages) {
-    if (this.runtimeMessages.length === 0) return normalizeChatMessages(parsedMessages);
-    const parsedEntries = parsedMessages.map((message, index) => ({
-      message,
-      index,
-      source: "parsed"
-    }));
-    const getRole = (message) => typeof message.role === "string" ? message.role.trim().toLowerCase() : "";
-    const runtimeEntries = this.runtimeMessages.map((entry, index) => ({
-      message: entry.message,
-      index: parsedMessages.length + index,
-      source: "runtime",
-      runtimeKey: entry.key
-    })).filter((entry) => {
-      const meta = entry.message.meta && typeof entry.message.meta === "object" && !Array.isArray(entry.message.meta) ? entry.message.meta : {};
-      if (meta.runtimeInputAck !== true) return true;
-      const runtimeText = flattenContent(entry.message.content).replace(/\s+/g, " ").trim();
-      if (!runtimeText) return false;
-      return !parsedEntries.some((parsedEntry) => {
-        const parsedRole = getRole(parsedEntry.message);
-        if (parsedRole !== "user" && parsedRole !== "human") return false;
-        const parsedText = flattenContent(parsedEntry.message.content).replace(/\s+/g, " ").trim();
-        return parsedText === runtimeText;
-      });
-    });
-    const getTime = (message) => {
-      const value = typeof message.receivedAt === "number" ? message.receivedAt : typeof message.timestamp === "number" ? message.timestamp : 0;
-      return Number.isFinite(value) && value > 0 ? value : 0;
-    };
-    const isRuntimeOverlay = (entry) => {
-      if (entry.source !== "runtime") return false;
-      const key2 = typeof entry.runtimeKey === "string" ? entry.runtimeKey.trim().toLowerCase() : "";
-      if (key2.startsWith("auto_approval:")) return true;
-      return !isUserFacingChatMessage(entry.message);
-    };
-    const shouldKeepParsedBeforeUntimedRuntime = (message) => {
-      const role = getRole(message);
-      return role === "user" || role === "human";
-    };
-    const shouldKeepParsedAfterUntimedRuntime = (message) => {
-      const role = getRole(message);
-      if (role !== "assistant") return false;
-      const kind = resolveChatMessageKind(message);
-      return kind === "standard" || kind === "terminal";
-    };
-    return normalizeChatMessages([...parsedEntries, ...runtimeEntries].sort((a, b) => {
-      const aTime = getTime(a.message);
-      const bTime = getTime(b.message);
-      if (aTime && bTime && aTime !== bTime) return aTime - bTime;
-      if (a.source !== b.source && aTime !== bTime) {
-        const parsedEntry = a.source === "parsed" ? a : b.source === "parsed" ? b : null;
-        const runtimeEntry = a.source === "runtime" ? a : b.source === "runtime" ? b : null;
-        if (parsedEntry && runtimeEntry && isRuntimeOverlay(runtimeEntry) && getTime(parsedEntry.message) === 0 && getTime(runtimeEntry.message) > 0) {
-          if (shouldKeepParsedBeforeUntimedRuntime(parsedEntry.message)) {
-            return a.source === "parsed" ? -1 : 1;
-          }
-          if (shouldKeepParsedAfterUntimedRuntime(parsedEntry.message)) {
-            return a.source === "parsed" ? 1 : -1;
-          }
-        }
-      }
-      return a.index - b.index;
-    }).map((entry) => entry.message));
-  }
-  formatApprovalRequestMessage(modalMessage, buttons) {
-    const lines = ["Approval requested"];
-    const cleanMessage = String(modalMessage || "").trim();
-    if (cleanMessage) lines.push(cleanMessage);
-    const labels = (buttons || []).map((button) => String(button || "").trim()).filter(Boolean);
-    if (labels.length > 0) {
-      lines.push(labels.map((label) => `[${label}]`).join(" "));
-    }
-    return lines.join("\n");
+    return mergeConversationMessages(this.runtimeMessages, parsedMessages);
   }
   promoteProviderSessionId(sessionId, opts = {}) {
     const nextSessionId = String(sessionId || "").trim();
@@ -68322,6 +68537,8 @@ export {
   AcpProviderInstance,
   AgentStreamPoller,
   BUILTIN_CHAT_MESSAGE_KINDS,
+  CANONICAL_MESH_TOOL_COUNT,
+  CANONICAL_MESH_TOOL_NAMES,
   CHANGE_IMPACT_CONFIG_LOCATIONS,
   CHANGE_IMPACT_CONFIG_SCHEMA,
   CHAT_MESSAGE_ACTIVITY_SOURCES,
@@ -68379,11 +68596,13 @@ export {
   MESH_REFINE_CONFIG_LOCATIONS,
   MESH_REFINE_CONFIG_SCHEMA,
   MESH_SCHEDULING_STRATEGIES,
+  MESH_TASK_PRIORITIES,
   MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS,
   MESH_WORKTREE_BOOTSTRAP_CONFIG_SCHEMA,
   MIN_GIT_WORKSPACE_POLL_INTERVAL_MS,
   MIN_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS,
   MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS,
+  NOT_BEFORE_RELATIVE_THRESHOLD_MS,
   NodePtyTransportFactory,
   OPERATING_NOTE_DEDUPE_WINDOW,
   OPERATING_NOTE_KEEP_LATEST,
@@ -68531,7 +68750,6 @@ export {
   getQueue,
   getRecentActivity,
   getRecentCommands,
-  getRecentCompletionConflicts,
   getRecentDebugTrace,
   getRecentLogs,
   getSavedProviderSessions,
@@ -68595,6 +68813,8 @@ export {
   maybeRunDaemonUpgradeHelperFromEnv,
   mergeAndNormalizePolicy,
   meshNodeIdMatches,
+  meshTaskNotBeforeReady,
+  meshTaskPriorityRank,
   namedKeyToAnsi,
   namedKeysToAnsi,
   nodeSatisfiesRequiredTags,
@@ -68617,6 +68837,7 @@ export {
   normalizeMeshNodeId,
   normalizeMeshSchedulingStrategy,
   normalizeMeshTaskMode,
+  normalizeMeshTaskPriority,
   normalizeMeshWorkerResult,
   normalizeMessageParts,
   normalizeRepoIdentity,
@@ -68645,7 +68866,6 @@ export {
   readOperatingNotes,
   readV2EnvelopeFromWire,
   reconcileDirectDispatchCompletionFromTranscript,
-  recordCompletionConflict,
   recordDebugTrace,
   recordDirectDispatchTask,
   recordMeshToolCall,
@@ -68655,6 +68875,7 @@ export {
   removeMagiPanel,
   removeNode,
   removeWorktree,
+  requeueHeldMeshCoordinatorEvents,
   requeueTask,
   requireMeshHostQueueOwner,
   resetConfig,
@@ -68675,6 +68896,7 @@ export {
   resolveMeshRefineValidationPlan,
   resolveMeshSurfacedSessionPreview,
   resolveNodeSchedulingPriority,
+  resolveNotBefore,
   resolveProviderMaxParallel,
   resolveSessionHostAppName,
   resolveSessionHostAppNameResolution,