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

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 ? "c31eb449e8febc28e378bd25394830a96a67594e" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "c31eb449" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = 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:15:03.175Z" : 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 = {}) {
@@ -35437,11 +35525,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;
           }
           /**
@@ -41683,7 +41774,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 +49471,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 +49589,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 +51541,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 +51565,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 +51577,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 +51621,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 +51634,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 +51654,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 +51671,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 +51685,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 +51695,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 +51706,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 +52060,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 +70473,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 +70553,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 +70580,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 +70858,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 +70965,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 +73841,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 +78345,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 +78540,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 +78557,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
           };