@adhdev/daemon-core 0.9.82-rc.468 → 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 ? "f05125bad26f9ee974d8bd31a8b9ab66bca9d4cd" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "f05125ba" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.468" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-05T10:08:41.050Z" : 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 },
@@ -6377,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,
@@ -6572,6 +6650,7 @@ var init_mesh_runtime_store = __esm({
                     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;
@@ -6881,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) {
@@ -6913,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) => {
@@ -6922,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";
@@ -7282,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).
@@ -11559,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) {
@@ -11870,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)`);
@@ -12198,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 {
@@ -14233,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}::`;
@@ -14249,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) {
@@ -17384,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);
@@ -18470,38 +18601,6 @@ var init_mesh_reconcile_identity = __esm({
   }
 });
 
-// src/mesh/mesh-reconcile-v2-backstop.ts
-function getMeshV2BackstopCounters() {
-  return { ...meshV2BackstopCounters };
-}
-function meshProtocolV2EnforceOn() {
-  const raw = process.env.MESH_PROTOCOL_V2_ENFORCE;
-  if (typeof raw !== "string" || !raw.trim()) return true;
-  const v = raw.trim().toLowerCase();
-  return !(v === "0" || v === "false" || v === "off" || v === "no");
-}
-function recordBackstopFire(kind, detail) {
-  meshV2BackstopCounters[kind]++;
-  if (meshProtocolV2EnforceOn()) {
-    LOG.warn("MeshReconcileV2", `v2 ENFORCE last-resort backstop fired (${kind}): ${detail}. Under a healthy v2 completion contract this should be 0 \u2014 a worker's real terminal emit was lost/late.`);
-  }
-}
-var meshV2BackstopCounters;
-var init_mesh_reconcile_v2_backstop = __esm({
-  "src/mesh/mesh-reconcile-v2-backstop.ts"() {
-    "use strict";
-    init_logger();
-    meshV2BackstopCounters = {
-      /** PHASE-4 transcript synthesis actually reconciled a missing completion. */
-      phase4SynthesisFired: 0,
-      /** Acked-hold transcript fast-track promoted a synth ahead of the death deadline. */
-      ackedHoldFastTrackFired: 0,
-      /** Acked-hold death-deadline backstop released a held synth (the 8-min net). */
-      ackedHoldDeathDeadlineFired: 0
-    };
-  }
-});
-
 // src/mesh/mesh-reconcile-acked-hold.ts
 function resolveTunedReconcileMs(envName, def, min, max) {
   const raw = readNonEmptyString2(process.env[envName]);
@@ -18628,7 +18727,7 @@ var init_mesh_reconcile_acked_hold = __esm({
   }
 });
 
-// src/mesh/mesh-reconcile-loop.ts
+// src/mesh/mesh-reconcile-config.ts
 function resolveAutoPruneMinAgeMs() {
   const raw = readNonEmptyString2(process.env.MESH_AUTO_PRUNE_MIN_AGE_MS);
   if (raw) {
@@ -18648,6 +18747,432 @@ function resolveReconcileIntervalMs() {
   }
   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 };
+}
+function meshProtocolV2EnforceOn() {
+  const raw = process.env.MESH_PROTOCOL_V2_ENFORCE;
+  if (typeof raw !== "string" || !raw.trim()) return true;
+  const v = raw.trim().toLowerCase();
+  return !(v === "0" || v === "false" || v === "off" || v === "no");
+}
+function recordBackstopFire(kind, detail) {
+  meshV2BackstopCounters[kind]++;
+  if (meshProtocolV2EnforceOn()) {
+    LOG.warn("MeshReconcileV2", `v2 ENFORCE last-resort backstop fired (${kind}): ${detail}. Under a healthy v2 completion contract this should be 0 \u2014 a worker's real terminal emit was lost/late.`);
+  }
+}
+var meshV2BackstopCounters;
+var init_mesh_reconcile_v2_backstop = __esm({
+  "src/mesh/mesh-reconcile-v2-backstop.ts"() {
+    "use strict";
+    init_logger();
+    meshV2BackstopCounters = {
+      /** PHASE-4 transcript synthesis actually reconciled a missing completion. */
+      phase4SynthesisFired: 0,
+      /** Acked-hold transcript fast-track promoted a synth ahead of the death deadline. */
+      ackedHoldFastTrackFired: 0,
+      /** Acked-hold death-deadline backstop released a held synth (the 8-min net). */
+      ackedHoldDeathDeadlineFired: 0
+    };
+  }
+});
+
+// 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);
+  }
+  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}`);
+  }
+}
+var init_mesh_completion_synthesis = __esm({
+  "src/mesh/mesh-completion-synthesis.ts"() {
+    "use strict";
+    init_logger();
+    init_mesh_events_utils();
+    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 findLiveCoordinators(components) {
   const out = [];
   for (const inst of components.instanceManager.getByCategory("cli")) {
@@ -19326,355 +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 }];
-  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 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);
-    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)
-  };
-}
 function setupMeshReconcileLoop(components) {
   const intervalMs = resolveReconcileIntervalMs();
   let running = false;
@@ -19694,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";
@@ -19713,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;
@@ -19753,6 +19925,7 @@ __export(mesh_events_exports, {
   queuePendingMeshCoordinatorEvent: () => queuePendingMeshCoordinatorEvent,
   readV2EnvelopeFromWire: () => readV2EnvelopeFromWire,
   reconcileDirectDispatchCompletionFromTranscript: () => reconcileDirectDispatchCompletionFromTranscript,
+  requeueHeldMeshCoordinatorEvents: () => requeueHeldMeshCoordinatorEvents,
   resolveCoordinatorDrainDeliverability: () => resolveCoordinatorDrainDeliverability,
   runMeshReconcileTick: () => runMeshReconcileTick,
   serializeV2EnvelopeToWire: () => serializeV2EnvelopeToWire,
@@ -26639,6 +26812,7 @@ init_mesh_config();
 init_dist();
 init_dist();
 init_dist();
+init_dist();
 init_coordinator_prompt();
 init_mesh_missions();
 init_mesh_task_stats();
@@ -68363,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,
@@ -68420,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,
@@ -68572,7 +68750,6 @@ export {
   getQueue,
   getRecentActivity,
   getRecentCommands,
-  getRecentCompletionConflicts,
   getRecentDebugTrace,
   getRecentLogs,
   getSavedProviderSessions,
@@ -68636,6 +68813,8 @@ export {
   maybeRunDaemonUpgradeHelperFromEnv,
   mergeAndNormalizePolicy,
   meshNodeIdMatches,
+  meshTaskNotBeforeReady,
+  meshTaskPriorityRank,
   namedKeyToAnsi,
   namedKeysToAnsi,
   nodeSatisfiesRequiredTags,
@@ -68658,6 +68837,7 @@ export {
   normalizeMeshNodeId,
   normalizeMeshSchedulingStrategy,
   normalizeMeshTaskMode,
+  normalizeMeshTaskPriority,
   normalizeMeshWorkerResult,
   normalizeMessageParts,
   normalizeRepoIdentity,
@@ -68686,7 +68866,6 @@ export {
   readOperatingNotes,
   readV2EnvelopeFromWire,
   reconcileDirectDispatchCompletionFromTranscript,
-  recordCompletionConflict,
   recordDebugTrace,
   recordDirectDispatchTask,
   recordMeshToolCall,
@@ -68696,6 +68875,7 @@ export {
   removeMagiPanel,
   removeNode,
   removeWorktree,
+  requeueHeldMeshCoordinatorEvents,
   requeueTask,
   requireMeshHostQueueOwner,
   resetConfig,
@@ -68716,6 +68896,7 @@ export {
   resolveMeshRefineValidationPlan,
   resolveMeshSurfacedSessionPreview,
   resolveNodeSchedulingPriority,
+  resolveNotBefore,
   resolveProviderMaxParallel,
   resolveSessionHostAppName,
   resolveSessionHostAppNameResolution,