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

package/dist/cli-adapter-types.d.ts

@@ -85,8 +85,9 @@ export interface CliAdapter {
     spawn(): Promise<void>;
     sendMessage(text: string, options?: {
         force?: boolean;
+        meshTaskId?: string;
     }): Promise<void>;
-    forceSendMessage?(text: string): Promise<void>;
+    forceSendMessage?(text: string, meshTaskId?: string): Promise<void>;
     getStatus(options?: {
         allowParse?: boolean;
     }): CliAdapterStatus;

package/dist/cli-adapters/cli-state-engine.d.ts

@@ -58,6 +58,7 @@ export declare class CliStateEngine {
     currentStatus: CliSessionStatus['status'];
     isWaitingForResponse: boolean;
     currentTurnScope: TurnParseScope | null;
+    currentTurnTaskId: string | null;
     activeModal: {
         message: string;
         buttons: string[];

package/dist/cli-adapters/provider-cli-adapter.d.ts

@@ -187,8 +187,9 @@ export declare class ProviderCliAdapter implements CliAdapter {
     private waitForEchoAndSubmit;
     sendMessage(text: string, options?: {
         force?: boolean;
+        meshTaskId?: string;
     }): Promise<void>;
-    forceSendMessage(text: string): Promise<void>;
+    forceSendMessage(text: string, meshTaskId?: string): Promise<void>;
     private waitForForceSubmitSettle;
     private enqueuePendingOutboundMessage;
     private shouldQueuePendingOutboundMessage;
@@ -229,6 +230,7 @@ export declare class ProviderCliAdapter implements CliAdapter {
     } | null);
     get currentTurnScope(): TurnParseScope | null;
     set currentTurnScope(v: TurnParseScope | null);
+    get currentTurnTaskId(): string | null;
     get responseEpoch(): number;
     set responseEpoch(v: number);
     get submitRetryUsed(): boolean;

package/dist/cli-adapters/provider-cli-parse.d.ts

@@ -4,6 +4,7 @@ export interface TurnParseScope {
     startedAt: number;
     bufferStart: number;
     rawBufferStart: number;
+    taskId?: string;
 }
 export declare function normalizeCliParsedMessages(parsedMessages: any[], _options: {
     scope?: TurnParseScope | null;

package/dist/git/git-worktree.d.ts

@@ -19,11 +19,54 @@ export interface WorktreeCreateOptions {
     meshName: string;
     /** Override the auto-resolved target directory */
     targetDir?: string;
+    /**
+     * Remote to fetch+compare the base branch against before branching.
+     * Default: 'origin'.
+     */
+    remote?: string;
+    /**
+     * When true (default) and `baseBranch` is given, fetch the base branch from
+     * `remote` and, if the local base branch is strictly behind the remote
+     * (no divergence), branch the worktree from the remote-tracking ref instead
+     * of the stale local ref. The decision is always surfaced via `baseSync`.
+     * Set false to preserve the legacy "branch from local ref, never fetch"
+     * behavior.
+     */
+    syncBaseFromRemote?: boolean;
+}
+/**
+ * How the worktree's start point was resolved relative to the remote base.
+ * Surfaced so the coordinator can detect a stale base node before dispatching
+ * work onto a worktree built on a behind/diverged base.
+ */
+export interface WorktreeBaseSync {
+    /** The base branch name requested (e.g. 'main'). */
+    branch: string;
+    /** The remote compared against (e.g. 'origin'). */
+    remote: string;
+    /** The actual ref/commit-ish used as the worktree branch start point. */
+    startRef: string;
+    /** Whether `git fetch <remote> <branch>` succeeded. */
+    fetched: boolean;
+    /** Local base-branch SHA before clone, if the local ref exists. */
+    localSha?: string;
+    /** Remote-tracking base-branch SHA after fetch, if it exists. */
+    remoteSha?: string;
+    /** Commits the local base ref is behind the remote (0 when up-to-date/ahead). */
+    behindBy: number;
+    /** Commits the local base ref is ahead of the remote. */
+    aheadBy: number;
+    /** What was done with the base ref. */
+    action: 'up_to_date' | 'local_behind_used_remote' | 'local_ahead_used_local' | 'diverged_used_local' | 'no_remote_ref_used_local' | 'no_local_ref_used_remote';
+    /** Human-readable warning when the base was stale/diverged. */
+    warning?: string;
 }
 export interface WorktreeCreateResult {
     success: true;
     worktreePath: string;
     branch: string;
+    /** Present when `baseBranch` was given and base sync resolution ran. */
+    baseSync?: WorktreeBaseSync;
 }
 export interface WorktreeEntry {
     path: string;
@@ -56,7 +99,12 @@ export declare function resolveWorktreePath(repoRoot: string, meshName: string,
 /**
  * Create a new git worktree with a fresh branch.
  *
- * Runs: git worktree add <targetDir> -b <branch> [baseBranch]
+ * Runs: git worktree add <targetDir> -b <branch> [startRef]
+ *
+ * When `baseBranch` is given and `syncBaseFromRemote` is not disabled, the
+ * start point is resolved against the remote first (see
+ * resolveWorktreeBaseStartPoint) so a stale local base does not produce a stale
+ * worktree. The resolution is returned as `baseSync`.
  */
 export declare function createWorktree(opts: WorktreeCreateOptions): Promise<WorktreeCreateResult>;
 /**

package/dist/git/index.d.ts

@@ -17,4 +17,4 @@ export type { GitCommandResult, GitCommandServices, GitFileDiff, GitLogEntry, Gi
 export { TurnSnapshotTracker } from './turn-snapshot-tracker.js';
 export type { TurnCompletedCallback } from './turn-snapshot-tracker.js';
 export { createWorktree, listWorktrees, parseWorktreeListOutput, removeWorktree, resolveWorktreePath, } from './git-worktree.js';
-export type { WorktreeCreateOptions, WorktreeCreateResult, WorktreeEntry, WorktreeRemoveResult, } from './git-worktree.js';
+export type { WorktreeBaseSync, WorktreeCreateOptions, WorktreeCreateResult, WorktreeEntry, WorktreeRemoveResult, } from './git-worktree.js';

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 ? "c31eb449e8febc28e378bd25394830a96a67594e" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "c31eb449" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.401" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-27T16:14:32.200Z" : 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 = {}) {
@@ -5654,11 +5742,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;
       }
       /**
@@ -11874,7 +11965,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 +19642,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 +19760,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 +21713,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 +21737,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 +21749,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 +21793,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 +21806,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 +21826,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 +21843,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 +21857,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 +21867,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 +21878,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 +22232,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 +40828,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 +40908,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 +40935,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 +41213,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 +41320,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 +44204,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 +48740,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 +48935,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 +48952,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
       };