@adhdev/daemon-core 0.9.82-rc.400 → 0.9.82-rc.402

package/dist/index.js

@@ -399,10 +399,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "2350563490670c1c560cc5cf6f863a9e61ef3f89" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "23505634" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.400" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-27T13:15:45.410Z" : void 0);
+  const commit = readInjected(true ? "93b00efeec1fccd6550c1faf5fa838106caef4bb" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "93b00efe" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.402" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-27T16:41:05.513Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -1441,16 +1441,103 @@ function resolveWorktreePath(repoRoot, meshName, branch) {
   const parentDir = path4.dirname(repoRoot);
   return path4.join(parentDir, WORKTREE_DIR_NAME, safeMeshName, safeBranch);
 }
+async function tryGit(cwd, args) {
+  try {
+    const { stdout, stderr } = await execFileAsync2("git", args, {
+      cwd,
+      encoding: "utf8",
+      timeout: GIT_TIMEOUT_MS,
+      maxBuffer: GIT_MAX_BUFFER,
+      windowsHide: true
+    });
+    return { ok: true, stdout: (stdout || "").trim(), stderr: (stderr || "").trim() };
+  } catch (error) {
+    return {
+      ok: false,
+      stdout: typeof error?.stdout === "string" ? error.stdout.trim() : "",
+      stderr: typeof error?.stderr === "string" ? error.stderr.trim() : error?.message || ""
+    };
+  }
+}
+async function resolveWorktreeBaseStartPoint(repoRoot, baseBranch, remote) {
+  const fetchResult = await tryGit(repoRoot, ["fetch", remote, baseBranch]);
+  const fetched = fetchResult.ok;
+  const localRev = await tryGit(repoRoot, ["rev-parse", "--verify", "--quiet", `refs/heads/${baseBranch}`]);
+  const remoteRev = await tryGit(repoRoot, ["rev-parse", "--verify", "--quiet", `refs/remotes/${remote}/${baseBranch}`]);
+  const localSha = localRev.ok && localRev.stdout ? localRev.stdout : void 0;
+  const remoteSha = remoteRev.ok && remoteRev.stdout ? remoteRev.stdout : void 0;
+  const remoteRef = `${remote}/${baseBranch}`;
+  const base = {
+    branch: baseBranch,
+    remote,
+    startRef: baseBranch,
+    fetched,
+    localSha,
+    remoteSha,
+    behindBy: 0,
+    aheadBy: 0,
+    action: "up_to_date"
+  };
+  const fetchWarn = fetched ? "" : ` (warning: git fetch ${remote} ${baseBranch} failed: ${fetchResult.stderr || "unknown error"})`;
+  if (!remoteSha) {
+    return {
+      ...base,
+      action: "no_remote_ref_used_local",
+      ...fetched ? {} : { warning: `Could not fetch ${remoteRef}${fetchWarn}; worktree branched from local ${baseBranch}.` }
+    };
+  }
+  if (!localSha) {
+    return {
+      ...base,
+      startRef: remoteRef,
+      action: "no_local_ref_used_remote"
+    };
+  }
+  if (localSha === remoteSha) {
+    return base;
+  }
+  const localIsAncestor = (await tryGit(repoRoot, ["merge-base", "--is-ancestor", localSha, remoteSha])).ok;
+  const remoteIsAncestor = (await tryGit(repoRoot, ["merge-base", "--is-ancestor", remoteSha, localSha])).ok;
+  const behindBy = Number((await tryGit(repoRoot, ["rev-list", "--count", `${localSha}..${remoteSha}`])).stdout) || 0;
+  const aheadBy = Number((await tryGit(repoRoot, ["rev-list", "--count", `${remoteSha}..${localSha}`])).stdout) || 0;
+  if (localIsAncestor && !remoteIsAncestor) {
+    return {
+      ...base,
+      startRef: remoteRef,
+      behindBy,
+      aheadBy,
+      action: "local_behind_used_remote",
+      warning: `Base node local ${baseBranch} was behind ${remoteRef} by ${behindBy} commit(s); worktree branched from ${remoteRef} (${remoteSha.slice(0, 8)}) instead of stale local ${localSha.slice(0, 8)}.${fetchWarn}`
+    };
+  }
+  if (remoteIsAncestor) {
+    return { ...base, behindBy, aheadBy, action: "local_ahead_used_local" };
+  }
+  return {
+    ...base,
+    behindBy,
+    aheadBy,
+    action: "diverged_used_local",
+    warning: `Base node local ${baseBranch} (${localSha.slice(0, 8)}) has DIVERGED from ${remoteRef} (${remoteSha.slice(0, 8)}): behind ${behindBy}, ahead ${aheadBy}. Worktree branched from local; a rebase onto ${remoteRef} will be required before its push can fast-forward.${fetchWarn}`
+  };
+}
 async function createWorktree(opts) {
   const { repoRoot, branch, baseBranch, meshName } = opts;
+  const remote = (opts.remote || "origin").trim() || "origin";
   const targetDir = opts.targetDir || resolveWorktreePath(repoRoot, meshName, branch);
   if ((0, import_node_fs2.existsSync)(targetDir)) {
     throw new Error(`Worktree target directory already exists: ${targetDir}`);
   }
   await (0, import_promises3.mkdir)(path4.dirname(targetDir), { recursive: true });
+  let baseSync;
+  let startRef = baseBranch;
+  if (baseBranch && opts.syncBaseFromRemote !== false) {
+    baseSync = await resolveWorktreeBaseStartPoint(repoRoot, baseBranch, remote);
+    startRef = baseSync.startRef;
+  }
   const args = ["worktree", "add", targetDir, "-b", branch];
-  if (baseBranch) {
-    args.push(baseBranch);
+  if (startRef) {
+    args.push(startRef);
   }
   try {
     await execFileAsync2("git", args, {
@@ -1473,7 +1560,8 @@ async function createWorktree(opts) {
   return {
     success: true,
     worktreePath: targetDir,
-    branch
+    branch,
+    ...baseSync ? { baseSync } : {}
   };
 }
 async function removeWorktree(repoRoot, worktreePath, opts = {}) {
@@ -4403,6 +4491,176 @@ var init_mesh_ledger = __esm({
   }
 });
 
+// src/mesh/mesh-delivery-policy.ts
+function resolveDeliveryDecision(sessionStatus, opts) {
+  const status = (sessionStatus || "").trim().toLowerCase();
+  if (!status) {
+    return {
+      decision: "rejected",
+      reason: "unknown_session_status",
+      message: "Session status is unknown. Delivery rejected (fail-closed). Use mesh_launch_session to start a fresh session."
+    };
+  }
+  if (IMMEDIATE_DELIVERY_STATUSES.has(status)) {
+    return {
+      decision: "immediate",
+      reason: `session_${status}`,
+      message: `Session is ${status} \u2014 delivery allowed immediately.`
+    };
+  }
+  if (BUSY_DELIVERY_STATUSES.has(status)) {
+    if (opts?.allowBusyInjection) {
+      return {
+        decision: "immediate",
+        reason: `session_${status}_busy_injection_allowed`,
+        message: `Session is ${status} but provider supports busy injection. Delivered immediately.`
+      };
+    }
+    if (status === "waiting_approval" && opts?.kind === "approval") {
+      return {
+        decision: "immediate",
+        reason: "session_waiting_approval_approval_message",
+        message: "Session is waiting for approval \u2014 approval message delivered immediately."
+      };
+    }
+    return {
+      decision: "queued",
+      reason: `session_${status}_busy`,
+      message: `Session is ${status}. Task queued for delivery when session becomes idle. Do not inject directly into a busy session.`
+    };
+  }
+  if (TERMINAL_DELIVERY_STATUSES.has(status)) {
+    return {
+      decision: "rejected",
+      reason: `session_${status}_terminal`,
+      message: `Session is ${status} (terminal). Delivery rejected. Launch a new session before dispatching tasks.`
+    };
+  }
+  return {
+    decision: "rejected",
+    reason: "unrecognized_session_status",
+    message: `Session status '${sessionStatus}' is not recognized. Delivery rejected (fail-closed). Inspect session state before retrying.`
+  };
+}
+function createSessionDelivery(opts) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const id = (0, import_crypto5.randomUUID)();
+  const record = {
+    id,
+    meshId: opts.meshId,
+    nodeId: opts.nodeId,
+    sessionId: opts.sessionId,
+    providerType: opts.providerType,
+    taskId: opts.taskId,
+    kind: opts.kind,
+    priority: opts.priority ?? 0,
+    message: opts.message,
+    status: opts.status,
+    deliverAfter: opts.deliverAfter,
+    expiresAt: opts.expiresAt,
+    attemptCount: 0,
+    sourceCoordinatorSessionId: opts.sourceCoordinatorSessionId,
+    sourceCoordinatorDaemonId: opts.sourceCoordinatorDaemonId,
+    createdAt: now,
+    updatedAt: now
+  };
+  MeshRuntimeStore.getInstance().insertSessionDelivery({
+    id,
+    meshId: opts.meshId,
+    nodeId: opts.nodeId,
+    sessionId: opts.sessionId,
+    providerType: opts.providerType,
+    taskId: opts.taskId,
+    kind: opts.kind,
+    priority: opts.priority ?? 0,
+    message: opts.message,
+    status: opts.status,
+    deliverAfter: opts.deliverAfter,
+    expiresAt: opts.expiresAt,
+    sourceCoordinatorSessionId: opts.sourceCoordinatorSessionId,
+    sourceCoordinatorDaemonId: opts.sourceCoordinatorDaemonId,
+    createdAt: now,
+    updatedAt: now
+  });
+  return record;
+}
+function updateSessionDeliveryStatus(id, status, opts) {
+  try {
+    MeshRuntimeStore.getInstance().updateSessionDeliveryStatus(id, status, opts);
+  } catch {
+  }
+}
+function getActiveSessionDeliveries(meshId, sessionId) {
+  try {
+    return MeshRuntimeStore.getInstance().getActiveSessionDeliveries(meshId, sessionId);
+  } catch {
+    return [];
+  }
+}
+function recordCompletionConflict(opts) {
+  try {
+    MeshRuntimeStore.getInstance().recordCompletionConflict({
+      id: (0, import_crypto5.randomUUID)(),
+      meshId: opts.meshId,
+      fingerprint: opts.fingerprint,
+      conflictingTaskId: opts.conflictingTaskId,
+      conflictingSessionId: opts.conflictingSessionId,
+      originalTaskId: opts.originalTaskId,
+      originalSessionId: opts.originalSessionId,
+      event: opts.event,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  } catch {
+  }
+}
+function getRecentCompletionConflicts(meshId, limitMs) {
+  try {
+    return MeshRuntimeStore.getInstance().getRecentCompletionConflicts(meshId, limitMs);
+  } catch {
+    return [];
+  }
+}
+function markSessionDeliveriesTerminal(meshId, sessionId, terminalStatus) {
+  try {
+    const active = MeshRuntimeStore.getInstance().getActiveSessionDeliveries(meshId, sessionId);
+    for (const delivery of active) {
+      MeshRuntimeStore.getInstance().updateSessionDeliveryStatus(delivery.id, terminalStatus);
+    }
+  } catch {
+  }
+}
+var import_crypto5, IMMEDIATE_DELIVERY_STATUSES, BUSY_DELIVERY_STATUSES, TERMINAL_DELIVERY_STATUSES;
+var init_mesh_delivery_policy = __esm({
+  "src/mesh/mesh-delivery-policy.ts"() {
+    "use strict";
+    import_crypto5 = require("crypto");
+    init_mesh_runtime_store();
+    IMMEDIATE_DELIVERY_STATUSES = /* @__PURE__ */ new Set([
+      "idle",
+      "waiting_input",
+      "ready"
+    ]);
+    BUSY_DELIVERY_STATUSES = /* @__PURE__ */ new Set([
+      "generating",
+      "running",
+      "streaming",
+      "busy",
+      "starting",
+      "initializing",
+      "waiting_approval"
+    ]);
+    TERMINAL_DELIVERY_STATUSES = /* @__PURE__ */ new Set([
+      "stopped",
+      "failed",
+      "terminated",
+      "exited",
+      "closed",
+      "deleted",
+      "error"
+    ]);
+  }
+});
+
 // src/mesh/mesh-work-queue.ts
 var mesh_work_queue_exports = {};
 __export(mesh_work_queue_exports, {
@@ -4764,7 +5022,7 @@ function enqueueTask(meshId, message, opts) {
   if (!modeValidation.valid) {
     throw new Error(`live_debug_readonly_guardrail_violation: forbidden operations (${modeValidation.violations.join(", ")})`);
   }
-  const id = typeof opts?.id === "string" && opts.id.trim() ? opts.id.trim() : (0, import_crypto5.randomUUID)();
+  const id = typeof opts?.id === "string" && opts.id.trim() ? opts.id.trim() : (0, import_crypto6.randomUUID)();
   const dependsOn = normalizeDependsOn(opts?.dependsOn);
   return withQueueLock(meshId, () => {
     if (MeshRuntimeStore.getInstance().findQueueEntryById(meshId, id)) {
@@ -4825,6 +5083,18 @@ function recordDirectDispatchTask(meshId, message, opts) {
       updatedAt: now
     };
     MeshRuntimeStore.getInstance().insertQueueEntry(entry);
+    try {
+      createSessionDelivery({
+        meshId,
+        ...opts.assignedNodeId ? { nodeId: opts.assignedNodeId } : {},
+        ...opts.assignedSessionId ? { sessionId: opts.assignedSessionId } : {},
+        taskId,
+        kind: "task",
+        message,
+        status: "delivered"
+      });
+    } catch {
+    }
     return entry;
   });
 }
@@ -5098,17 +5368,18 @@ function recordMeshToolCall(opts) {
     return { rateLimitExceeded: false, callsInWindow: 0, advisory: null };
   }
 }
-var import_crypto5, 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 import_crypto6, 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 init_mesh_work_queue = __esm({
   "src/mesh/mesh-work-queue.ts"() {
     "use strict";
-    import_crypto5 = require("crypto");
+    import_crypto6 = require("crypto");
     init_mesh_host_ownership();
     init_repo_mesh_types();
     init_mesh_runtime_store();
     init_mesh_config();
     init_logger();
     init_mesh_ledger();
+    init_mesh_delivery_policy();
     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"];
@@ -5654,11 +5925,14 @@ var init_mesh_runtime_store = __esm({
       }
       /** A node may only execute one write task at a time (worktree isolation). */
       hasActiveNodeAssignment(meshId, nodeId) {
+        const nodeIdForms = expandDaemonIdForms(nodeId);
+        if (nodeIdForms.length === 0) return false;
+        const placeholders = nodeIdForms.map(() => "?").join(", ");
         const row = this.db.prepare(`
             SELECT 1 FROM mesh_queue
-            WHERE mesh_id = ? AND status = 'assigned' AND assigned_node_id = ?
+            WHERE mesh_id = ? AND status = 'assigned' AND assigned_node_id IN (${placeholders})
             LIMIT 1
-        `).get(meshId, nodeId);
+        `).get(meshId, ...nodeIdForms);
         return row !== void 0;
       }
       /**
@@ -6759,7 +7033,7 @@ function upsertMeshMission(meshId, input) {
   if (input.status !== void 0 && !MESH_MISSION_STATUSES.includes(input.status)) {
     throw new Error(`invalid_mission_status: '${input.status}' (valid: ${MESH_MISSION_STATUSES.join(", ")})`);
   }
-  const id = typeof input.id === "string" && input.id.trim() ? input.id.trim() : (0, import_crypto6.randomUUID)();
+  const id = typeof input.id === "string" && input.id.trim() ? input.id.trim() : (0, import_crypto7.randomUUID)();
   const store = MeshRuntimeStore.getInstance();
   const existing = store.getMission(meshId, id);
   const record = {
@@ -6875,11 +7149,11 @@ function buildMissionPromptSection(meshId) {
   );
   return lines.join("\n");
 }
-var import_crypto6, MESH_MISSION_STATUSES, GOAL_PREVIEW_MAX, COMPACT_STATUS_GOAL_PREVIEW_MAX;
+var import_crypto7, MESH_MISSION_STATUSES, GOAL_PREVIEW_MAX, COMPACT_STATUS_GOAL_PREVIEW_MAX;
 var init_mesh_missions = __esm({
   "src/mesh/mesh-missions.ts"() {
     "use strict";
-    import_crypto6 = require("crypto");
+    import_crypto7 = require("crypto");
     init_mesh_runtime_store();
     init_mesh_work_queue();
     init_mesh_task_stats();
@@ -9946,7 +10220,7 @@ function queuePendingMeshCoordinatorEvent(event) {
     let sqliteOk = false;
     try {
       MeshRuntimeStore.getInstance().insertPendingEvent({
-        id: (0, import_crypto7.randomUUID)(),
+        id: (0, import_crypto8.randomUUID)(),
         meshId: event.meshId,
         coordinatorDaemonId: event.targetCoordinatorDaemonId ?? null,
         event: event.event,
@@ -10134,13 +10408,13 @@ function clearPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
     }
   }
 }
-var import_fs10, import_path9, import_crypto7, REFINE_TERMINAL_EVENTS, TERMINAL_COMPLETION_EVENTS, MAX_PENDING_EVENTS_BYTES, MAX_PENDING_EVENTS_KEEP;
+var import_fs10, import_path9, import_crypto8, REFINE_TERMINAL_EVENTS, TERMINAL_COMPLETION_EVENTS, MAX_PENDING_EVENTS_BYTES, MAX_PENDING_EVENTS_KEEP;
 var init_mesh_events_pending = __esm({
   "src/mesh/mesh-events-pending.ts"() {
     "use strict";
     import_fs10 = require("fs");
     import_path9 = require("path");
-    import_crypto7 = require("crypto");
+    import_crypto8 = require("crypto");
     init_logger();
     init_mesh_ledger();
     init_mesh_runtime_store();
@@ -10153,176 +10427,6 @@ var init_mesh_events_pending = __esm({
   }
 });
 
-// src/mesh/mesh-delivery-policy.ts
-function resolveDeliveryDecision(sessionStatus, opts) {
-  const status = (sessionStatus || "").trim().toLowerCase();
-  if (!status) {
-    return {
-      decision: "rejected",
-      reason: "unknown_session_status",
-      message: "Session status is unknown. Delivery rejected (fail-closed). Use mesh_launch_session to start a fresh session."
-    };
-  }
-  if (IMMEDIATE_DELIVERY_STATUSES.has(status)) {
-    return {
-      decision: "immediate",
-      reason: `session_${status}`,
-      message: `Session is ${status} \u2014 delivery allowed immediately.`
-    };
-  }
-  if (BUSY_DELIVERY_STATUSES.has(status)) {
-    if (opts?.allowBusyInjection) {
-      return {
-        decision: "immediate",
-        reason: `session_${status}_busy_injection_allowed`,
-        message: `Session is ${status} but provider supports busy injection. Delivered immediately.`
-      };
-    }
-    if (status === "waiting_approval" && opts?.kind === "approval") {
-      return {
-        decision: "immediate",
-        reason: "session_waiting_approval_approval_message",
-        message: "Session is waiting for approval \u2014 approval message delivered immediately."
-      };
-    }
-    return {
-      decision: "queued",
-      reason: `session_${status}_busy`,
-      message: `Session is ${status}. Task queued for delivery when session becomes idle. Do not inject directly into a busy session.`
-    };
-  }
-  if (TERMINAL_DELIVERY_STATUSES.has(status)) {
-    return {
-      decision: "rejected",
-      reason: `session_${status}_terminal`,
-      message: `Session is ${status} (terminal). Delivery rejected. Launch a new session before dispatching tasks.`
-    };
-  }
-  return {
-    decision: "rejected",
-    reason: "unrecognized_session_status",
-    message: `Session status '${sessionStatus}' is not recognized. Delivery rejected (fail-closed). Inspect session state before retrying.`
-  };
-}
-function createSessionDelivery(opts) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const id = (0, import_crypto8.randomUUID)();
-  const record = {
-    id,
-    meshId: opts.meshId,
-    nodeId: opts.nodeId,
-    sessionId: opts.sessionId,
-    providerType: opts.providerType,
-    taskId: opts.taskId,
-    kind: opts.kind,
-    priority: opts.priority ?? 0,
-    message: opts.message,
-    status: opts.status,
-    deliverAfter: opts.deliverAfter,
-    expiresAt: opts.expiresAt,
-    attemptCount: 0,
-    sourceCoordinatorSessionId: opts.sourceCoordinatorSessionId,
-    sourceCoordinatorDaemonId: opts.sourceCoordinatorDaemonId,
-    createdAt: now,
-    updatedAt: now
-  };
-  MeshRuntimeStore.getInstance().insertSessionDelivery({
-    id,
-    meshId: opts.meshId,
-    nodeId: opts.nodeId,
-    sessionId: opts.sessionId,
-    providerType: opts.providerType,
-    taskId: opts.taskId,
-    kind: opts.kind,
-    priority: opts.priority ?? 0,
-    message: opts.message,
-    status: opts.status,
-    deliverAfter: opts.deliverAfter,
-    expiresAt: opts.expiresAt,
-    sourceCoordinatorSessionId: opts.sourceCoordinatorSessionId,
-    sourceCoordinatorDaemonId: opts.sourceCoordinatorDaemonId,
-    createdAt: now,
-    updatedAt: now
-  });
-  return record;
-}
-function updateSessionDeliveryStatus(id, status, opts) {
-  try {
-    MeshRuntimeStore.getInstance().updateSessionDeliveryStatus(id, status, opts);
-  } catch {
-  }
-}
-function getActiveSessionDeliveries(meshId, sessionId) {
-  try {
-    return MeshRuntimeStore.getInstance().getActiveSessionDeliveries(meshId, sessionId);
-  } catch {
-    return [];
-  }
-}
-function recordCompletionConflict(opts) {
-  try {
-    MeshRuntimeStore.getInstance().recordCompletionConflict({
-      id: (0, import_crypto8.randomUUID)(),
-      meshId: opts.meshId,
-      fingerprint: opts.fingerprint,
-      conflictingTaskId: opts.conflictingTaskId,
-      conflictingSessionId: opts.conflictingSessionId,
-      originalTaskId: opts.originalTaskId,
-      originalSessionId: opts.originalSessionId,
-      event: opts.event,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    });
-  } catch {
-  }
-}
-function getRecentCompletionConflicts(meshId, limitMs) {
-  try {
-    return MeshRuntimeStore.getInstance().getRecentCompletionConflicts(meshId, limitMs);
-  } catch {
-    return [];
-  }
-}
-function markSessionDeliveriesTerminal(meshId, sessionId, terminalStatus) {
-  try {
-    const active = MeshRuntimeStore.getInstance().getActiveSessionDeliveries(meshId, sessionId);
-    for (const delivery of active) {
-      MeshRuntimeStore.getInstance().updateSessionDeliveryStatus(delivery.id, terminalStatus);
-    }
-  } catch {
-  }
-}
-var import_crypto8, IMMEDIATE_DELIVERY_STATUSES, BUSY_DELIVERY_STATUSES, TERMINAL_DELIVERY_STATUSES;
-var init_mesh_delivery_policy = __esm({
-  "src/mesh/mesh-delivery-policy.ts"() {
-    "use strict";
-    import_crypto8 = require("crypto");
-    init_mesh_runtime_store();
-    IMMEDIATE_DELIVERY_STATUSES = /* @__PURE__ */ new Set([
-      "idle",
-      "waiting_input",
-      "ready"
-    ]);
-    BUSY_DELIVERY_STATUSES = /* @__PURE__ */ new Set([
-      "generating",
-      "running",
-      "streaming",
-      "busy",
-      "starting",
-      "initializing",
-      "waiting_approval"
-    ]);
-    TERMINAL_DELIVERY_STATUSES = /* @__PURE__ */ new Set([
-      "stopped",
-      "failed",
-      "terminated",
-      "exited",
-      "closed",
-      "deleted",
-      "error"
-    ]);
-  }
-});
-
 // src/mesh/mesh-events-stale.ts
 function findRecentTerminalLedgerEvidence(args) {
   if (!args.sessionId && !args.nodeId) return null;
@@ -11874,7 +11978,14 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
       targetSessionId: sessionId,
       cliType: providerType,
       action: "send_chat",
-      message: task.message
+      message: task.message,
+      meshContext: {
+        meshId,
+        nodeId,
+        taskId: task.id,
+        ...readNonEmptyString2(loadConfig().machineId) ? { coordinatorDaemonId: readNonEmptyString2(loadConfig().machineId) } : {},
+        ...readNonEmptyString2(task.sourceCoordinatorSessionId) ? { coordinatorSessionId: readNonEmptyString2(task.sourceCoordinatorSessionId) } : {}
+      }
     }),
     {
       meshId,
@@ -19544,6 +19655,15 @@ var init_cli_state_engine = __esm({
       currentStatus = "starting";
       isWaitingForResponse = false;
       currentTurnScope = null;
+      // ARCH-REFACTOR R1 (per-turn task identity): the mesh taskId bound to the most
+      // recently STARTED turn. Unlike currentTurnScope (nulled the moment the turn
+      // settles, before the completion event is even built), this persists past
+      // completion and is only overwritten when the NEXT turn starts. That window is
+      // exactly what the completion path needs: when a turn settles to idle, this still
+      // holds THAT turn's taskId (the next task's turn cannot have started yet — it is
+      // queued in pendingOutbound and only flushed asynchronously after idle), so the
+      // completion event carries the correct id instead of the racy session scalar.
+      currentTurnTaskId = null;
       activeModal = null;
       // ── Approval ─────────────────────────────────────
       lastApprovalResolvedAt = 0;
@@ -19653,6 +19773,7 @@ var init_cli_state_engine = __esm({
         this.finishRetryCount = 0;
         this.clearIdleFinishCandidate("send_message");
         this.currentTurnScope = turnScope;
+        this.currentTurnTaskId = typeof turnScope.taskId === "string" && turnScope.taskId.trim() ? turnScope.taskId : null;
         this.responseEpoch += 1;
       }
       /** Called when PTY exits */
@@ -21605,15 +21726,18 @@ ${lastSnapshot}`;
       }
       async sendMessage(text, options = {}) {
         if (options.force === true) {
-          await this.forceSendMessage(text);
+          await this.forceSendMessage(text, options.meshTaskId);
           return;
         }
-        await this.sendMessageNow(text, true);
+        await this.sendMessageNow(text, true, options.meshTaskId);
       }
-      async forceSendMessage(text) {
+      async forceSendMessage(text, meshTaskId) {
         if (!this.ptyProcess) throw new Error(`${this.cliName} is not running`);
         const content = String(text || "");
         if (!content.trim()) return;
+        if (typeof meshTaskId === "string" && meshTaskId.trim()) {
+          this.engine.currentTurnTaskId = meshTaskId;
+        }
         if (this.engine.currentStatus === "waiting_approval" || this.engine.hasActionableApproval()) {
           LOG.info("CLI", `[${this.cliType}] force-send held \u2014 session parked on approval modal (status=${this.engine.currentStatus})`);
           return;
@@ -21626,7 +21750,7 @@ ${lastSnapshot}`;
       async waitForForceSubmitSettle() {
         await new Promise((resolve24) => setTimeout(resolve24, FORCE_SUBMIT_SETTLE_MS));
       }
-      enqueuePendingOutboundMessage(text, reason) {
+      enqueuePendingOutboundMessage(text, reason, meshTaskId) {
         const content = String(text || "");
         const duplicate = this.pendingOutboundQueue.some((message2) => message2.content === content);
         if (duplicate) {
@@ -21638,7 +21762,8 @@ ${lastSnapshot}`;
           role: "user",
           content,
           queuedAt,
-          source: "sendMessage"
+          source: "sendMessage",
+          ...typeof meshTaskId === "string" && meshTaskId.trim() ? { meshTaskId } : {}
         };
         this.pendingOutboundQueue.push(message);
         LOG.info("CLI", `[${this.cliType}] queued outbound message while busy (${reason}); queue=${this.pendingOutboundQueue.length}`);
@@ -21681,7 +21806,7 @@ ${lastSnapshot}`;
             if (this.engine.currentStatus !== "idle" || this.engine.isWaitingForResponse || this.engine.hasActionableApproval()) break;
             const next = this.pendingOutboundQueue[0];
             try {
-              await this.sendMessageNow(next.content, false);
+              await this.sendMessageNow(next.content, false, next.meshTaskId);
               this.pendingOutboundQueue.shift();
               this.onStatusChange?.();
             } catch (error) {
@@ -21694,7 +21819,7 @@ ${lastSnapshot}`;
           this.pendingOutboundFlushInFlight = false;
         }
       }
-      async sendMessageNow(text, allowQueue) {
+      async sendMessageNow(text, allowQueue, meshTaskId) {
         if (!this.ptyProcess) throw new Error(`${this.cliName} is not running`);
         const allowInputDuringGeneration = this.provider.allowInputDuringGeneration === true;
         const allowInterventionPrompt = allowInputDuringGeneration && this.engine.isWaitingForResponse && !this.engine.hasActionableApproval();
@@ -21714,7 +21839,7 @@ ${lastSnapshot}`;
         })() : null;
         const queueReason = this.shouldQueuePendingOutboundMessage(parsedStatusBeforeSend);
         if (allowQueue && queueReason) {
-          this.enqueuePendingOutboundMessage(text, queueReason);
+          this.enqueuePendingOutboundMessage(text, queueReason, meshTaskId);
           return;
         }
         if (!allowInterventionPrompt) {
@@ -21731,7 +21856,7 @@ ${lastSnapshot}`;
         }
         if (!this.ready) {
           if (allowQueue) {
-            this.enqueuePendingOutboundMessage(text, "not_ready_pending_prompt");
+            this.enqueuePendingOutboundMessage(text, "not_ready_pending_prompt", meshTaskId);
             return;
           }
           throw new Error(`${this.cliName} not ready (status: ${this.engine.currentStatus})`);
@@ -21745,7 +21870,7 @@ ${lastSnapshot}`;
           const terminalLooksIdle = this.engine.currentStatus === "idle" && this.runDetectStatus(this.recentOutputBuffer) === "idle" && !this.engine.isWaitingForResponse && !this.engine.currentTurnScope && !this.engine.hasActionableApproval() && !parsedHasActionableModal;
           if (!terminalLooksIdle) {
             if (allowQueue) {
-              this.enqueuePendingOutboundMessage(text, `parsed_status_${parsedSessionStatus}`);
+              this.enqueuePendingOutboundMessage(text, `parsed_status_${parsedSessionStatus}`, meshTaskId);
               return;
             }
             throw new Error(`${this.cliName} is still processing the previous prompt`);
@@ -21755,7 +21880,7 @@ ${lastSnapshot}`;
           const snap = this.getSnapshot();
           if (!this.engine.clearStaleIdleResponseGuard("send_message_guard", snap) && !this.engine.clearParsedIdleResponseGuard("send_message_parsed_idle_guard", parsedStatusBeforeSend, snap)) {
             if (allowQueue) {
-              this.enqueuePendingOutboundMessage(text, "waiting_for_response");
+              this.enqueuePendingOutboundMessage(text, "waiting_for_response", meshTaskId);
               return;
             }
             throw new Error(`${this.cliName} is still processing the previous prompt`);
@@ -21766,7 +21891,11 @@ ${lastSnapshot}`;
           prompt: text,
           startedAt: Date.now(),
           bufferStart: this.accumulatedBuffer.length,
-          rawBufferStart: this.accumulatedRawBuffer.length
+          rawBufferStart: this.accumulatedRawBuffer.length,
+          // ARCH-REFACTOR R1: bind this turn to its mesh task. engine.onTurnStarted
+          // copies this into currentTurnTaskId so the turn's completion event carries
+          // the right id even if a later task overwrites the session scalar meanwhile.
+          ...typeof meshTaskId === "string" && meshTaskId.trim() ? { taskId: meshTaskId } : {}
         };
         LOG.info("CLI", `[${this.cliType}] sendMessage turn scope buffer=${turnScope.bufferStart} raw=${turnScope.rawBufferStart} prompt=${JSON.stringify(text).slice(0, 120)}`);
         if (this.submitRetryTimer) {
@@ -22116,6 +22245,13 @@ ${lastSnapshot}`;
       set currentTurnScope(v) {
         this.engine.currentTurnScope = v;
       }
+      // ARCH-REFACTOR R1: the mesh taskId bound to the most recently started turn,
+      // surviving past turn settle until the next turn starts. The provider instance
+      // reads this when stamping completion events so they carry the completing turn's
+      // task rather than the racy last-write-wins session scalar.
+      get currentTurnTaskId() {
+        return this.engine.currentTurnTaskId;
+      }
       get responseEpoch() {
         return this.engine.responseEpoch;
       }
@@ -40705,11 +40841,28 @@ var CliProviderInstance = class _CliProviderInstance {
   isMeshWorkerSession() {
     return !!(this.settings.meshNodeFor || this.settings.meshActiveTaskId || this.settings.meshNodeId || this.settings.launchedByCoordinator);
   }
+  /**
+   * ARCH-REFACTOR R1: the taskId to attribute the CURRENTLY-completing turn to.
+   * Prefers the per-turn binding (engine.currentTurnTaskId, set when the turn was
+   * submitted and surviving until the next turn starts) over the last-write-wins
+   * session scalar (settings.meshActiveTaskId). The scalar is retained only as a
+   * backward-compat alias for the "current/last assignment" and is the source of the
+   * NOTIF-MISDELIVER / TASK-MSG-MISROUTE race: a second task attaching before this
+   * turn completes overwrites it. Returns undefined for a non-task ad-hoc turn.
+   */
+  completingTurnTaskId() {
+    const turnTaskId = this.adapter?.currentTurnTaskId;
+    if (typeof turnTaskId === "string" && turnTaskId.trim()) return turnTaskId;
+    const scalar = this.settings.meshActiveTaskId;
+    return typeof scalar === "string" && scalar.trim() ? scalar : void 0;
+  }
   // EVTTRACE correlation context for this session's completion lifecycle. taskId is
   // the primary grep anchor; instanceId is the session fallback.
   meshTraceCtx(event = "agent:generating_completed") {
     return {
-      taskId: this.settings.meshActiveTaskId,
+      // ARCH-REFACTOR R1: trace the per-turn taskId (falling back to the scalar) so
+      // EvtTrace anchors on the same id the completion event actually carries.
+      taskId: this.completingTurnTaskId(),
       sessionId: this.instanceId,
       nodeId: this.settings.meshNodeId,
       meshId: this.settings.meshNodeFor,
@@ -40768,6 +40921,8 @@ var CliProviderInstance = class _CliProviderInstance {
         chatTitle: pending.chatTitle,
         duration: pending.duration,
         timestamp: pending.timestamp,
+        // ARCH-REFACTOR R1: attribute to the turn captured at idle-transition.
+        ...pending.taskId ? { taskId: pending.taskId } : {},
         // When finalization is forced past the timeout on a `parsed_status:` block
         // (the parser never confirmed a final assistant turn) we previously rode an
         // empty `finalSummary` unconditionally. That empty value propagates to the
@@ -40793,6 +40948,8 @@ var CliProviderInstance = class _CliProviderInstance {
       chatTitle: pending.chatTitle,
       duration: pending.duration,
       timestamp: pending.timestamp,
+      // ARCH-REFACTOR R1: attribute to the turn captured at idle-transition.
+      ...pending.taskId ? { taskId: pending.taskId } : {},
       finalSummary: this.completionFinalSummary(this.adapter?.getScriptParsedStatus()?.messages)
     });
     this.completedDebouncePending = null;
@@ -41069,7 +41226,11 @@ var CliProviderInstance = class _CliProviderInstance {
             duration,
             timestamp: now,
             firstObservedAt: now,
-            previousStatus: this.lastStatus
+            previousStatus: this.lastStatus,
+            // ARCH-REFACTOR R1: snapshot the completing turn's taskId NOW (sync),
+            // before any follow-up task's flush can start a new turn and move
+            // engine.currentTurnTaskId.
+            ...this.completingTurnTaskId() ? { taskId: this.completingTurnTaskId() } : {}
           };
           const ownsExternalHistory = !!this.adapter?.chatMessagesOwnedExternally;
           const meshWorkerSession = this.isMeshWorkerSession();
@@ -41172,10 +41333,11 @@ var CliProviderInstance = class _CliProviderInstance {
       workspace: typeof event.workspace === "string" && event.workspace.trim() ? event.workspace : this.workingDir,
       providerSessionId: typeof event.providerSessionId === "string" && event.providerSessionId.trim() ? event.providerSessionId : this.providerSessionId
     };
-    if (this.isMeshWorkerSession() && this.settings.meshActiveTaskId) {
+    if (this.isMeshWorkerSession()) {
       const existingTaskId = typeof enrichedEvent.taskId === "string" && enrichedEvent.taskId.trim() ? enrichedEvent.taskId : void 0;
       if (!existingTaskId) {
-        enrichedEvent.taskId = this.settings.meshActiveTaskId;
+        const resolved = this.completingTurnTaskId();
+        if (resolved) enrichedEvent.taskId = resolved;
       }
     }
     if (this.context?.emitProviderEvent) {
@@ -44055,11 +44217,15 @@ Run 'adhdev doctor' for detailed diagnostics.`
           }
           const message = input.textFallback;
           if (!message) throw new Error("message required for send_chat");
+          const meshTaskId = meshContext && typeof meshContext === "object" && typeof meshContext.taskId === "string" && meshContext.taskId.trim() ? meshContext.taskId : void 0;
           const forceSend = args?.force === true || args?.forceSend === true;
           if (forceSend && typeof adapter.forceSendMessage === "function") {
-            await adapter.forceSendMessage(message);
+            if (meshTaskId) await adapter.forceSendMessage(message, meshTaskId);
+            else await adapter.forceSendMessage(message);
           } else if (forceSend) {
-            await adapter.sendMessage(message, { force: true });
+            await adapter.sendMessage(message, meshTaskId ? { force: true, meshTaskId } : { force: true });
+          } else if (meshTaskId) {
+            await adapter.sendMessage(message, { meshTaskId });
           } else {
             await adapter.sendMessage(message);
           }
@@ -48587,6 +48753,11 @@ var meshCrudHandlers = {
         baseBranch,
         meshName: mesh.name
       });
+      if (result.baseSync?.warning) {
+        console.warn(`[mesh] clone_mesh_node base sync (${result.baseSync.action}): ${result.baseSync.warning}`);
+      } else if (result.baseSync && result.baseSync.action !== "up_to_date") {
+        console.log(`[mesh] clone_mesh_node base sync: ${result.baseSync.action} (startRef=${result.baseSync.startRef})`);
+      }
       let node;
       if (meshRecord.inline) {
         const { randomUUID: randomUUID15 } = await import("crypto");
@@ -48777,6 +48948,8 @@ var meshCrudHandlers = {
           node,
           worktreePath: result.worktreePath,
           branch: result.branch,
+          ...result.baseSync ? { baseSync: result.baseSync } : {},
+          ...result.baseSync?.warning ? { baseStaleWarning: result.baseSync.warning } : {},
           worktreeBootstrap: runningBootstrapState,
           worktreeSetup: {
             status: "running",
@@ -48792,6 +48965,8 @@ var meshCrudHandlers = {
         node,
         worktreePath: result.worktreePath,
         branch: result.branch,
+        ...result.baseSync ? { baseSync: result.baseSync } : {},
+        ...result.baseSync?.warning ? { baseStaleWarning: result.baseSync.warning } : {},
         submodulesInitialized,
         worktreeBootstrap: bootstrapState
       };