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

package/dist/index.js

@@ -30127,10 +30127,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "2350563490670c1c560cc5cf6f863a9e61ef3f89" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "23505634" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = 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:16:19.563Z" : 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 version2 = 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:39.131Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -31173,16 +31173,103 @@ var require_dist3 = __commonJS({
       const parentDir = path42.dirname(repoRoot);
       return path42.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 (error48) {
+        return {
+          ok: false,
+          stdout: typeof error48?.stdout === "string" ? error48.stdout.trim() : "",
+          stderr: typeof error48?.stderr === "string" ? error48.stderr.trim() : error48?.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)(path42.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, {
@@ -31205,7 +31292,8 @@ var require_dist3 = __commonJS({
       return {
         success: true,
         worktreePath: targetDir,
-        branch
+        branch,
+        ...baseSync ? { baseSync } : {}
       };
     }
     async function removeWorktree(repoRoot, worktreePath, opts = {}) {
@@ -34175,6 +34263,177 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         ledgerImportDone = /* @__PURE__ */ new Set();
       }
     });
+    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 record2 = {
+        id,
+        meshId: opts.meshId,
+        nodeId: opts.nodeId,
+        sessionId: opts.sessionId,
+        providerType: opts.providerType,
+        taskId: opts.taskId,
+        kind: opts.kind,
+        priority: opts.priority ?? 0,
+        message: opts.message,
+        status: opts.status,
+        deliverAfter: opts.deliverAfter,
+        expiresAt: opts.expiresAt,
+        attemptCount: 0,
+        sourceCoordinatorSessionId: opts.sourceCoordinatorSessionId,
+        sourceCoordinatorDaemonId: opts.sourceCoordinatorDaemonId,
+        createdAt: now,
+        updatedAt: now
+      };
+      MeshRuntimeStore.getInstance().insertSessionDelivery({
+        id,
+        meshId: opts.meshId,
+        nodeId: opts.nodeId,
+        sessionId: opts.sessionId,
+        providerType: opts.providerType,
+        taskId: opts.taskId,
+        kind: opts.kind,
+        priority: opts.priority ?? 0,
+        message: opts.message,
+        status: opts.status,
+        deliverAfter: opts.deliverAfter,
+        expiresAt: opts.expiresAt,
+        sourceCoordinatorSessionId: opts.sourceCoordinatorSessionId,
+        sourceCoordinatorDaemonId: opts.sourceCoordinatorDaemonId,
+        createdAt: now,
+        updatedAt: now
+      });
+      return record2;
+    }
+    function updateSessionDeliveryStatus(id, status, opts) {
+      try {
+        MeshRuntimeStore.getInstance().updateSessionDeliveryStatus(id, status, opts);
+      } catch {
+      }
+    }
+    function getActiveSessionDeliveries(meshId, sessionId) {
+      try {
+        return MeshRuntimeStore.getInstance().getActiveSessionDeliveries(meshId, sessionId);
+      } catch {
+        return [];
+      }
+    }
+    function recordCompletionConflict(opts) {
+      try {
+        MeshRuntimeStore.getInstance().recordCompletionConflict({
+          id: (0, import_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;
+    var IMMEDIATE_DELIVERY_STATUSES;
+    var BUSY_DELIVERY_STATUSES;
+    var TERMINAL_DELIVERY_STATUSES;
+    var init_mesh_delivery_policy = __esm2({
+      "src/mesh/mesh-delivery-policy.ts"() {
+        "use strict";
+        import_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"
+        ]);
+      }
+    });
     var mesh_work_queue_exports = {};
     __export2(mesh_work_queue_exports, {
       ACTIVE_MESH_QUEUE_STATUSES: () => ACTIVE_MESH_QUEUE_STATUSES,
@@ -34535,7 +34794,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       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)) {
@@ -34596,6 +34855,18 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
           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;
       });
     }
@@ -34869,7 +35140,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         return { rateLimitExceeded: false, callsInWindow: 0, advisory: null };
       }
     }
-    var import_crypto5;
+    var import_crypto6;
     var ACTIVE_MESH_QUEUE_STATUSES;
     var HISTORICAL_MESH_QUEUE_STATUSES;
     var MESH_TASK_MODES;
@@ -34883,13 +35154,14 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     var init_mesh_work_queue = __esm2({
       "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"];
@@ -35437,11 +35709,14 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
           }
           /** 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;
           }
           /**
@@ -36538,7 +36813,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       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 record2 = {
@@ -36654,14 +36929,14 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       );
       return lines.join("\n");
     }
-    var import_crypto6;
+    var import_crypto7;
     var MESH_MISSION_STATUSES;
     var GOAL_PREVIEW_MAX;
     var COMPACT_STATUS_GOAL_PREVIEW_MAX;
     var init_mesh_missions = __esm2({
       "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();
@@ -39743,7 +40018,7 @@ Next step: ${nextStep}`;
         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,
@@ -39933,7 +40208,7 @@ Next step: ${nextStep}`;
     }
     var import_fs10;
     var import_path9;
-    var import_crypto7;
+    var import_crypto8;
     var REFINE_TERMINAL_EVENTS;
     var TERMINAL_COMPLETION_EVENTS;
     var MAX_PENDING_EVENTS_BYTES;
@@ -39943,7 +40218,7 @@ Next step: ${nextStep}`;
         "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();
@@ -39955,177 +40230,6 @@ Next step: ${nextStep}`;
         MAX_PENDING_EVENTS_KEEP = 50;
       }
     });
-    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 record2 = {
-        id,
-        meshId: opts.meshId,
-        nodeId: opts.nodeId,
-        sessionId: opts.sessionId,
-        providerType: opts.providerType,
-        taskId: opts.taskId,
-        kind: opts.kind,
-        priority: opts.priority ?? 0,
-        message: opts.message,
-        status: opts.status,
-        deliverAfter: opts.deliverAfter,
-        expiresAt: opts.expiresAt,
-        attemptCount: 0,
-        sourceCoordinatorSessionId: opts.sourceCoordinatorSessionId,
-        sourceCoordinatorDaemonId: opts.sourceCoordinatorDaemonId,
-        createdAt: now,
-        updatedAt: now
-      };
-      MeshRuntimeStore.getInstance().insertSessionDelivery({
-        id,
-        meshId: opts.meshId,
-        nodeId: opts.nodeId,
-        sessionId: opts.sessionId,
-        providerType: opts.providerType,
-        taskId: opts.taskId,
-        kind: opts.kind,
-        priority: opts.priority ?? 0,
-        message: opts.message,
-        status: opts.status,
-        deliverAfter: opts.deliverAfter,
-        expiresAt: opts.expiresAt,
-        sourceCoordinatorSessionId: opts.sourceCoordinatorSessionId,
-        sourceCoordinatorDaemonId: opts.sourceCoordinatorDaemonId,
-        createdAt: now,
-        updatedAt: now
-      });
-      return record2;
-    }
-    function updateSessionDeliveryStatus(id, status, opts) {
-      try {
-        MeshRuntimeStore.getInstance().updateSessionDeliveryStatus(id, status, opts);
-      } catch {
-      }
-    }
-    function getActiveSessionDeliveries(meshId, sessionId) {
-      try {
-        return MeshRuntimeStore.getInstance().getActiveSessionDeliveries(meshId, sessionId);
-      } catch {
-        return [];
-      }
-    }
-    function recordCompletionConflict(opts) {
-      try {
-        MeshRuntimeStore.getInstance().recordCompletionConflict({
-          id: (0, import_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;
-    var IMMEDIATE_DELIVERY_STATUSES;
-    var BUSY_DELIVERY_STATUSES;
-    var TERMINAL_DELIVERY_STATUSES;
-    var init_mesh_delivery_policy = __esm2({
-      "src/mesh/mesh-delivery-policy.ts"() {
-        "use strict";
-        import_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"
-        ]);
-      }
-    });
     function findRecentTerminalLedgerEvidence(args) {
       if (!args.sessionId && !args.nodeId) return null;
       const entries = readLedgerEntries(args.meshId, { tail: 200 });
@@ -41683,7 +41787,14 @@ Next step: ${nextStep}`;
           targetSessionId: sessionId,
           cliType: providerType,
           action: "send_chat",
-          message: task.message
+          message: task.message,
+          meshContext: {
+            meshId,
+            nodeId,
+            taskId: task.id,
+            ...readNonEmptyString2(loadConfig2().machineId) ? { coordinatorDaemonId: readNonEmptyString2(loadConfig2().machineId) } : {},
+            ...readNonEmptyString2(task.sourceCoordinatorSessionId) ? { coordinatorSessionId: readNonEmptyString2(task.sourceCoordinatorSessionId) } : {}
+          }
         }),
         {
           meshId,
@@ -49373,6 +49484,15 @@ ${cont}` : cont;
           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;
@@ -49482,6 +49602,7 @@ ${cont}` : cont;
             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 */
@@ -51433,15 +51554,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()) {
               LOG2.info("CLI", `[${this.cliType}] force-send held \u2014 session parked on approval modal (status=${this.engine.currentStatus})`);
               return;
@@ -51454,7 +51578,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) {
@@ -51466,7 +51590,8 @@ ${lastSnapshot}`;
               role: "user",
               content,
               queuedAt,
-              source: "sendMessage"
+              source: "sendMessage",
+              ...typeof meshTaskId === "string" && meshTaskId.trim() ? { meshTaskId } : {}
             };
             this.pendingOutboundQueue.push(message);
             LOG2.info("CLI", `[${this.cliType}] queued outbound message while busy (${reason}); queue=${this.pendingOutboundQueue.length}`);
@@ -51509,7 +51634,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 (error48) {
@@ -51522,7 +51647,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();
@@ -51542,7 +51667,7 @@ ${lastSnapshot}`;
             })() : null;
             const queueReason = this.shouldQueuePendingOutboundMessage(parsedStatusBeforeSend);
             if (allowQueue && queueReason) {
-              this.enqueuePendingOutboundMessage(text, queueReason);
+              this.enqueuePendingOutboundMessage(text, queueReason, meshTaskId);
               return;
             }
             if (!allowInterventionPrompt) {
@@ -51559,7 +51684,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})`);
@@ -51573,7 +51698,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`);
@@ -51583,7 +51708,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`);
@@ -51594,7 +51719,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 } : {}
             };
             LOG2.info("CLI", `[${this.cliType}] sendMessage turn scope buffer=${turnScope.bufferStart} raw=${turnScope.rawBufferStart} prompt=${JSON.stringify(text).slice(0, 120)}`);
             if (this.submitRetryTimer) {
@@ -51944,6 +52073,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;
           }
@@ -70350,11 +70486,28 @@ ${body}
       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,
@@ -70413,6 +70566,8 @@ ${body}
             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
@@ -70438,6 +70593,8 @@ ${body}
           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;
@@ -70714,7 +70871,11 @@ ${body}
                 duration: duration3,
                 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();
@@ -70817,10 +70978,11 @@ ${body}
           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) {
@@ -73692,11 +73854,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);
               }
@@ -78192,6 +78358,11 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
             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");
@@ -78382,6 +78553,8 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
               node,
               worktreePath: result.worktreePath,
               branch: result.branch,
+              ...result.baseSync ? { baseSync: result.baseSync } : {},
+              ...result.baseSync?.warning ? { baseStaleWarning: result.baseSync.warning } : {},
               worktreeBootstrap: runningBootstrapState,
               worktreeSetup: {
                 status: "running",
@@ -78397,6 +78570,8 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
             node,
             worktreePath: result.worktreePath,
             branch: result.branch,
+            ...result.baseSync ? { baseSync: result.baseSync } : {},
+            ...result.baseSync?.warning ? { baseStaleWarning: result.baseSync.warning } : {},
             submodulesInitialized,
             worktreeBootstrap: bootstrapState
           };