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

package/dist/providers/cli-provider-instance.d.ts

@@ -228,6 +228,16 @@ export declare class CliProviderInstance implements ProviderInstance {
     private approvalResolutionFinalizationBlock;
     private scheduleCompletedDebounceFlush;
     private isMeshWorkerSession;
+    /**
+     * 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.
+     */
+    private completingTurnTaskId;
     private meshTraceCtx;
     private flushCompletedDebounceIfFinalized;
     private maybeAutoApproveStatus;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.400",
+  "version": "0.9.82-rc.402",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.400",
+    "@adhdev/mesh-shared": "0.9.82-rc.402",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

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

@@ -36,7 +36,8 @@ export interface CliAdapter {
     workingDir: string;
     _acpInstance?: AcpAdapterHandle;
     spawn(): Promise<void>;
-    sendMessage(text: string): Promise<void>;
+    sendMessage(text: string, options?: { force?: boolean; meshTaskId?: string }): Promise<void>;
+    forceSendMessage?(text: string, meshTaskId?: string): Promise<void>;
     getStatus(): CliAdapterStatus;
     getScriptParsedStatus?(): unknown;
     invokeScript?(scriptName: string, args?: Record<string, unknown>): Promise<unknown>;

package/src/cli-adapter-types.ts

@@ -88,8 +88,8 @@ export interface CliAdapter {
     workingDir: string;
     _acpInstance?: AcpAdapterHandle;
     spawn(): Promise<void>;
-    sendMessage(text: string, options?: { force?: boolean }): Promise<void>;
-    forceSendMessage?(text: string): Promise<void>;
+    sendMessage(text: string, options?: { force?: boolean; meshTaskId?: string }): Promise<void>;
+    forceSendMessage?(text: string, meshTaskId?: string): Promise<void>;
     getStatus(options?: { allowParse?: boolean }): CliAdapterStatus;
     getScriptParsedStatus?(): unknown;
     getDebugSnapshot?(): unknown;

package/src/cli-adapters/cli-state-engine.ts

@@ -102,6 +102,15 @@ export class CliStateEngine {
     currentStatus: CliSessionStatus['status'] = 'starting';
     isWaitingForResponse = false;
     currentTurnScope: TurnParseScope | null = 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: string | null = null;
     activeModal: { message: string; buttons: string[] } | null = null;
 
     // ── Approval ─────────────────────────────────────
@@ -232,6 +241,12 @@ export class CliStateEngine {
         this.finishRetryCount = 0;
         this.clearIdleFinishCandidate('send_message');
         this.currentTurnScope = turnScope;
+        // ARCH-REFACTOR R1: bind this turn's mesh taskId. A task-less (ad-hoc dashboard)
+        // turn carries no taskId → null here, which correctly clears any prior task's id
+        // so an ad-hoc turn's completion is never stamped with a stale taskId.
+        this.currentTurnTaskId = typeof turnScope.taskId === 'string' && turnScope.taskId.trim()
+            ? turnScope.taskId
+            : null;
         this.responseEpoch += 1;
     }
 

package/src/cli-adapters/provider-cli-adapter.ts

@@ -117,6 +117,10 @@ interface PendingOutboundMessage {
     content: string;
     queuedAt: number;
     source: 'sendMessage';
+    // ARCH-REFACTOR R1: the mesh taskId this queued message belongs to. Carried so that
+    // when the queue is flushed (once the prior turn settles) the new turn is bound to
+    // its OWN task, not whatever scalar the session happens to hold at flush time.
+    meshTaskId?: string;
 }
 
 export function appendBoundedText(current: string, chunk: string, maxChars: number): string {
@@ -1383,18 +1387,25 @@ export class ProviderCliAdapter implements CliAdapter {
         ), 50);
     }
 
-    async sendMessage(text: string, options: { force?: boolean } = {}): Promise<void> {
+    async sendMessage(text: string, options: { force?: boolean; meshTaskId?: string } = {}): Promise<void> {
         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: string): Promise<void> {
+    async forceSendMessage(text: string, meshTaskId?: string): Promise<void> {
         if (!this.ptyProcess) throw new Error(`${this.cliName} is not running`);
         const content = String(text || '');
         if (!content.trim()) return;
+        // ARCH-REFACTOR R1: a force-send (mesh coordinator dispatch / reconcile
+        // redelivery) bypasses the normal turnScope pipeline (raw PTY write), so there is
+        // no turnScope to carry the taskId. Bind it directly on the engine so the
+        // resulting turn's completion is still attributed to the right task.
+        if (typeof meshTaskId === 'string' && meshTaskId.trim()) {
+            this.engine.currentTurnTaskId = meshTaskId;
+        }
         // Modal-park guard (defense-in-depth — the primary guard is at the
         // cli-provider-instance force-forward chokepoint). A force-write writes raw
         // keystrokes into the PTY, bypassing the busy send-guard. If the session is
@@ -1435,7 +1446,7 @@ export class ProviderCliAdapter implements CliAdapter {
         await new Promise<void>(resolve => setTimeout(resolve, FORCE_SUBMIT_SETTLE_MS));
     }
 
-    private enqueuePendingOutboundMessage(text: string, reason: string): void {
+    private enqueuePendingOutboundMessage(text: string, reason: string, meshTaskId?: string): void {
         const content = String(text || '');
         const duplicate = this.pendingOutboundQueue.some((message) => message.content === content);
         if (duplicate) {
@@ -1448,6 +1459,7 @@ export class ProviderCliAdapter implements CliAdapter {
             content,
             queuedAt,
             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}`);
@@ -1502,7 +1514,7 @@ export class ProviderCliAdapter implements CliAdapter {
                 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: any) {
@@ -1516,7 +1528,7 @@ export class ProviderCliAdapter implements CliAdapter {
         }
     }
 
-    private async sendMessageNow(text: string, allowQueue: boolean): Promise<void> {
+    private async sendMessageNow(text: string, allowQueue: boolean, meshTaskId?: string): Promise<void> {
         if (!this.ptyProcess) throw new Error(`${this.cliName} is not running`);
         const allowInputDuringGeneration = this.provider.allowInputDuringGeneration === true;
         const allowInterventionPrompt = allowInputDuringGeneration
@@ -1540,7 +1552,7 @@ export class ProviderCliAdapter implements CliAdapter {
             : null;
         const queueReason = this.shouldQueuePendingOutboundMessage(parsedStatusBeforeSend);
         if (allowQueue && queueReason) {
-            this.enqueuePendingOutboundMessage(text, queueReason);
+            this.enqueuePendingOutboundMessage(text, queueReason, meshTaskId);
             return;
         }
         if (!allowInterventionPrompt) {
@@ -1568,7 +1580,7 @@ export class ProviderCliAdapter implements CliAdapter {
             // so the message is delivered late rather than dropped. A non-queueable caller
             // (e.g. an internal flush) still throws so it isn't silently swallowed.
             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})`);
@@ -1591,7 +1603,7 @@ export class ProviderCliAdapter implements CliAdapter {
                 && !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`);
@@ -1604,7 +1616,7 @@ export class ProviderCliAdapter implements CliAdapter {
                 && !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`);
@@ -1616,6 +1628,10 @@ export class ProviderCliAdapter implements CliAdapter {
             startedAt: Date.now(),
             bufferStart: this.accumulatedBuffer.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) {
@@ -1967,6 +1983,11 @@ export class ProviderCliAdapter implements CliAdapter {
 
     get currentTurnScope(): TurnParseScope | null { return this.engine.currentTurnScope; }
     set currentTurnScope(v: TurnParseScope | null) { 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(): string | null { return this.engine.currentTurnTaskId; }
 
     get responseEpoch(): number { return this.engine.responseEpoch; }
     set responseEpoch(v: number) { this.engine.responseEpoch = v; }

package/src/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/src/cli-adapters/provider-cli-parse.ts

@@ -10,6 +10,12 @@ export interface TurnParseScope {
     startedAt: number;
     bufferStart: number;
     rawBufferStart: number;
+    // ARCH-REFACTOR R1 (per-turn task identity): the mesh task this turn was started
+    // for, bound to the turn at submit time. The completion event for this turn reads
+    // its taskId from here (via engine.currentTurnTaskId) instead of the last-write-wins
+    // session scalar (settings.meshActiveTaskId), so a second task that attaches before
+    // this turn completes can no longer make this turn's completion carry the wrong id.
+    taskId?: string;
 }
 
 function sliceFromOffset(text: string, start: number): string {

package/src/commands/cli-manager.ts

@@ -1553,11 +1553,25 @@ export class DaemonCliManager {
                     }
                     const message = input.textFallback;
                     if (!message) throw new Error('message required for send_chat');
+                    // ARCH-REFACTOR R1: thread the dispatched task's id into the turn so the
+                    // worker's completion event is bound to THIS task (per-turn identity),
+                    // not the last-write-wins session scalar. Carried for both local and
+                    // remote (P2P-echoed meshContext) dispatch; absent for plain ad-hoc chat.
+                    const meshTaskId = (meshContext && typeof meshContext === 'object'
+                        && typeof (meshContext as any).taskId === 'string' && (meshContext as any).taskId.trim())
+                        ? (meshContext as any).taskId as string
+                        : undefined;
                     const forceSend = args?.force === true || args?.forceSend === true;
+                    // Preserve the exact prior call shape when there is no taskId (plain
+                    // ad-hoc chat / non-mesh dispatch); only thread the per-turn taskId when
+                    // present, so existing non-mesh callers and their contracts are unchanged.
                     if (forceSend && typeof (adapter as any).forceSendMessage === 'function') {
-                        await (adapter as any).forceSendMessage(message);
+                        if (meshTaskId) await (adapter as any).forceSendMessage(message, meshTaskId);
+                        else await (adapter as any).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);
                     }

package/src/commands/med-family/mesh-crud.ts

@@ -553,6 +553,11 @@ export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
                 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: any;
             if (meshRecord.inline) {
@@ -767,6 +772,8 @@ export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
                     node,
                     worktreePath: result.worktreePath,
                     branch: result.branch,
+                    ...(result.baseSync ? { baseSync: result.baseSync } : {}),
+                    ...(result.baseSync?.warning ? { baseStaleWarning: result.baseSync.warning } : {}),
                     worktreeBootstrap: runningBootstrapState,
                     worktreeSetup: {
                         status: 'running',
@@ -783,6 +790,8 @@ export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
                 node,
                 worktreePath: result.worktreePath,
                 branch: result.branch,
+                ...(result.baseSync ? { baseSync: result.baseSync } : {}),
+                ...(result.baseSync?.warning ? { baseStaleWarning: result.baseSync.warning } : {}),
                 submodulesInitialized,
                 worktreeBootstrap: bootstrapState,
             };

package/src/git/git-worktree.ts

@@ -35,12 +35,62 @@ 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 {
@@ -83,15 +133,139 @@ export function resolveWorktreePath(repoRoot: string, meshName: string, branch:
     return path.join(parentDir, WORKTREE_DIR_NAME, safeMeshName, safeBranch);
 }
 
+// ─── Base sync (anti-stale-base) ─────────────────
+
+/** Run a git command, returning ok/stdout/stderr instead of throwing. */
+async function tryGit(cwd: string, args: string[]): Promise<{ ok: boolean; stdout: string; stderr: string }> {
+    try {
+        const { stdout, stderr } = await execFileAsync('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: any) {
+        return {
+            ok: false,
+            stdout: typeof error?.stdout === 'string' ? error.stdout.trim() : '',
+            stderr: typeof error?.stderr === 'string' ? error.stderr.trim() : (error?.message || ''),
+        };
+    }
+}
+
+/**
+ * Fetch the base branch from the remote and decide what to branch the new
+ * worktree from. Without this, `git worktree add -b <branch> main` always uses
+ * the local `refs/heads/main`, so a base node whose local main is behind a
+ * cross-machine-pushed origin/main produces a worktree on a STALE base —
+ * unaware of already-converged work, forcing a rebase before its push can
+ * fast-forward.
+ *
+ * Resolution (no history rewrite, never mutates the checked-out local branch):
+ *   - local strictly behind remote → branch from the remote-tracking ref.
+ *   - local ahead / up-to-date / no remote ref → branch from the local ref.
+ *   - diverged → branch from local + emit a warning for the coordinator.
+ */
+async function resolveWorktreeBaseStartPoint(
+    repoRoot: string,
+    baseBranch: string,
+    remote: string,
+): Promise<WorktreeBaseSync> {
+    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 : undefined;
+    const remoteSha = remoteRev.ok && remoteRev.stdout ? remoteRev.stdout : undefined;
+    const remoteRef = `${remote}/${baseBranch}`;
+
+    const base: WorktreeBaseSync = {
+        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'})`;
+
+    // No remote-tracking ref → nothing to compare; keep legacy local behavior.
+    if (!remoteSha) {
+        return {
+            ...base,
+            action: 'no_remote_ref_used_local',
+            ...(fetched ? {} : { warning: `Could not fetch ${remoteRef}${fetchWarn}; worktree branched from local ${baseBranch}.` }),
+        };
+    }
+
+    // Base branch only exists on the remote → branch from the remote ref.
+    if (!localSha) {
+        return {
+            ...base,
+            startRef: remoteRef,
+            action: 'no_local_ref_used_remote',
+        };
+    }
+
+    if (localSha === remoteSha) {
+        return base; // up_to_date
+    }
+
+    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) {
+        // Local strictly behind — THE stale-base fix: branch from the remote tip.
+        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) {
+        // Local ahead of remote (or remote is an ancestor) — local has the newer work.
+        return { ...base, behindBy, aheadBy, action: 'local_ahead_used_local' };
+    }
+
+    // Diverged: neither is an ancestor of the other. Don't silently pick a side —
+    // keep local (preserve local-only commits) and warn so the coordinator rebases.
+    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}`,
+    };
+}
+
 // ─── Create ─────────────────────────────────────
 
 /**
  * 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 async function createWorktree(opts: WorktreeCreateOptions): Promise<WorktreeCreateResult> {
     const { repoRoot, branch, baseBranch, meshName } = opts;
+    const remote = (opts.remote || 'origin').trim() || 'origin';
     const targetDir = opts.targetDir || resolveWorktreePath(repoRoot, meshName, branch);
 
     if (existsSync(targetDir)) {
@@ -101,9 +275,16 @@ export async function createWorktree(opts: WorktreeCreateOptions): Promise<Workt
     // Ensure parent directory exists
     await mkdir(path.dirname(targetDir), { recursive: true });
 
+    let baseSync: WorktreeBaseSync | undefined;
+    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 {
@@ -130,6 +311,7 @@ export async function createWorktree(opts: WorktreeCreateOptions): Promise<Workt
         success: true,
         worktreePath: targetDir,
         branch,
+        ...(baseSync ? { baseSync } : {}),
     };
 }
 

package/src/git/index.ts

@@ -98,6 +98,7 @@ export {
   resolveWorktreePath,
 } from './git-worktree.js';
 export type {
+  WorktreeBaseSync,
   WorktreeCreateOptions,
   WorktreeCreateResult,
   WorktreeEntry,

package/src/mesh/mesh-event-forwarding.ts

@@ -203,6 +203,9 @@ function hasRecentIntentionalCleanupStop(meshId: string, sessionId?: string, nod
         const timestamp = new Date(entry.timestamp).getTime();
         if (!Number.isNaN(timestamp) && timestamp < cutoff) break;
         if (!isIntentionalCleanupStopEntry(entry)) continue;
+        // SESSION-ID IS SINGLE-FORM: a session id is one canonical UUID (crypto.randomUUID
+        // in the provider instance), carried verbatim across daemons — no serialization
+        // variants like node/daemon ids. Exact `===` is correct; no equivalence helper.
         if (sessionId && entry.sessionId === sessionId) return true;
         // Normalized node-id match (P4): the cleanup-stop entry's node id may be stored as
         // `nodeId` or `node_id` and the `nodeId` arg can be in either form — a raw `===`
@@ -435,6 +438,8 @@ function supersedesTruncatedTerminalSummary(args: {
 // task surfaces as status='unknown' / terminalKind=null in computeMeshTaskStats.
 function resolveActiveDirectDispatchTaskId(meshId: string, sessionId: string): string | undefined {
     try {
+        // SESSION-ID IS SINGLE-FORM (canonical crypto.randomUUID, carried verbatim across
+        // daemons) — exact `===` filter is correct; no node-id-style form normalization.
         const matches = getActiveDirectDispatches(meshId).filter(d => d.sessionId === sessionId);
         if (!matches.length) return undefined;
         // getActiveDirectDispatches returns rows ordered by dispatched_at ASC; the last is
@@ -830,8 +835,14 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         const providerType = readNonEmptyString(args.metadataEvent.providerType);
 
         if (sessionId) {
-            // CANON-B: trust the taskId the completion echoed; only fall back to the
-            // most-recent-by-session heuristic when the worker carried none.
+            // CANON-B / ARCH-REFACTOR R1: trust the taskId the completion echoed. With R1's
+            // per-turn identity binding the worker stamps the COMPLETING turn's own taskId
+            // (not the racy session scalar), so the echoed id is authoritative and this is
+            // the path that should always be taken for an R1+ worker. The most-recent-by-
+            // session heuristic (resolveActiveDirectDispatchTaskId) is retained ONLY as a
+            // backward-compat fallback for legacy / version-skewed workers that carry no
+            // taskId — it is the very re-derive R1 exists to make unnecessary, and must not
+            // override a present echoed id, hence the `||` short-circuit order.
             directDispatchTaskIdForLedger = readNonEmptyString(args.metadataEvent.taskId)
                 || resolveActiveDirectDispatchTaskId(args.meshId, sessionId);
             // A false-idle completion of a direct dispatch is recorded but kept tentative (the

package/src/mesh/mesh-queue-assignment.ts

@@ -495,12 +495,24 @@ export function tryAssignQueueTask(
 
     // CONS3: same shared dispatch lifecycle as the remote branch — only the transport
     // (cliManager.handleCliCommand) differs.
+    // ARCH-REFACTOR R1: carry meshContext (incl. taskId) on the LOCAL dispatch too, so
+    // handleCliCommand's send_chat path binds this task to its turn (per-turn identity).
+    // Previously only the remote branch shipped meshContext.taskId; the local path relied
+    // on the last-write-wins session scalar, which races a follow-up task and made the
+    // completion echo the wrong taskId (the standalone NOTIF-MISDELIVER repro).
     deliverTaskToSession(
         () => components.cliManager.handleCliCommand('agent_command', {
             targetSessionId: sessionId,
             cliType: providerType,
             action: 'send_chat',
             message: task.message,
+            meshContext: {
+                meshId,
+                nodeId,
+                taskId: task.id,
+                ...(readNonEmptyString(loadConfig().machineId) ? { coordinatorDaemonId: readNonEmptyString(loadConfig().machineId) } : {}),
+                ...(readNonEmptyString(task.sourceCoordinatorSessionId) ? { coordinatorSessionId: readNonEmptyString(task.sourceCoordinatorSessionId) } : {}),
+            },
         }),
         {
             meshId,

package/src/mesh/mesh-reconcile-loop.ts

@@ -920,6 +920,10 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
             // (unchanged behaviour — regression-0 for the common case).
             const wantSession = readNonEmptyString(pending.targetCoordinatorSessionId);
             if (wantSession) {
+                // SESSION-ID IS SINGLE-FORM: a coordinator session id is one canonical
+                // UUID (crypto.randomUUID), carried verbatim end-to-end — no node/daemon-id
+                // style serialization variants. Exact `===` is the correct match; unlike
+                // the daemon-level set below it needs no equivalence helper.
                 const matched = targetCoordinators.filter(c => c.sessionId === wantSession);
                 if (matched.length === 0) {
                     // The originating coordinator session is not deliverable on this daemon