@adhdev/daemon-standalone 0.9.77-rc.41 → 0.9.77-rc.43

package/dist/index.js

@@ -22183,13 +22183,25 @@ var require_dist2 = __commonJS({
         branch
       };
     }
-    async function removeWorktree(repoRoot, worktreePath) {
+    async function removeWorktree(repoRoot, worktreePath, opts = {}) {
       if (!(0, import_node_fs2.existsSync)(worktreePath)) {
         await pruneWorktrees(repoRoot);
         return { success: true, removedPath: worktreePath };
       }
+      if (opts.requireClean) {
+        const { stdout } = await execFileAsync2("git", ["status", "--porcelain"], {
+          cwd: worktreePath,
+          encoding: "utf8",
+          timeout: GIT_TIMEOUT_MS,
+          maxBuffer: GIT_MAX_BUFFER,
+          windowsHide: true
+        });
+        if (stdout.trim()) {
+          throw new Error(`Refusing to remove dirty worktree: ${worktreePath}`);
+        }
+      }
       try {
-        await execFileAsync2("git", ["worktree", "remove", worktreePath, "--force"], {
+        await execFileAsync2("git", ["worktree", "remove", worktreePath], {
           cwd: repoRoot,
           encoding: "utf8",
           timeout: GIT_TIMEOUT_MS,
@@ -22642,6 +22654,7 @@ var require_dist2 = __commonJS({
         workspace: opts.workspace.trim(),
         repoRoot: opts.repoRoot,
         daemonId: opts.daemonId,
+        machineId: opts.machineId,
         userOverrides: opts.userOverrides || {},
         policy: opts.policy || {},
         isLocalWorktree: opts.isLocalWorktree,
@@ -22783,6 +22796,7 @@ ${rules.join("\n")}`;
 - **Respect node capabilities.** Don't send build tasks to read-only nodes. Don't push from nodes that aren't allowed to.
 - **Never fabricate tool results.** Always call the actual tool; never pretend you did.
 - **Clean up worktree nodes.** After a worktree task completes and its changes are merged or checkpointed, call \`mesh_remove_node\` to free resources.
+- **Do not strand completed branches.** A checkpointed or clean feature/worktree branch is not done by itself. Merge/refine it to the mesh default branch, or explicitly report one of \`pushed_feature_branch_needs_merge\`, \`blocked_review\`, \`cleanup_candidate\`, or \`not_mergeable\` with the next action.
 - **Name worktree branches meaningfully.** Use descriptive names like \`feat/auth-refactor\` or \`fix/build-123\`.${coordinatorNote}`;
     }
     var TOOLS_SECTION;
@@ -22806,6 +22820,7 @@ ${rules.join("\n")}`;
 | \`mesh_checkpoint\` | Create a git checkpoint on a node |
 | \`mesh_approve\` | Approve/reject a pending agent action |
 | \`mesh_clone_node\` | Create a worktree node for isolated parallel branch work |
+| \`mesh_refine_node\` | Validate and merge a completed worktree node back into its base branch |
 | \`mesh_remove_node\` | Remove a node (cleans up worktree if applicable) |`;
         TOOL_EXPOSURE_PREFLIGHT_SECTION = `## Tool Exposure Preflight
 
@@ -22822,8 +22837,9 @@ Before doing any coordinator work, confirm that the actual callable tool list in
 4. **Monitor** \u2014 Prefer event-driven completion/status notifications. Do **not** poll \`mesh_read_chat\` repeatedly. Use \`mesh_view_queue\` to see the status of all pending, assigned, completed, and failed tasks. Do not call \`mesh_read_chat\` again within a few seconds for the same generating session. Use at most one compact \`mesh_read_chat\` check after a completion/approval signal. Handle approvals via \`mesh_approve\`.
 5. **Verify** \u2014 When a task reports completion or git work is visible, call \`mesh_git_status\` to verify changes were made.
 6. **Checkpoint** \u2014 Call \`mesh_checkpoint\` to save the work.
-7. **Clean up** \u2014 Remove worktree nodes via \`mesh_remove_node\` after their work is merged or no longer needed.
-8. **Report** \u2014 Summarize what was done, what changed, and any issues.
+7. **Converge branches** \u2014 Before marking any task complete, classify every touched node/branch into exactly one final state: \`merged_to_main\`, \`pushed_feature_branch_needs_merge\`, \`blocked_review\`, \`cleanup_candidate\`, or \`not_mergeable\`. Use \`mesh_status\` branchConvergenceSummary and \`mesh_refine_node\` for clean worktree branches when safe. A task that remains on a non-main branch is not fully complete unless the final report names the follow-up state and next step.
+8. **Clean up** \u2014 Remove worktree nodes via \`mesh_remove_node\` after their work is merged or no longer needed.
+9. **Report** \u2014 Summarize what was done, what changed, any issues, and the branch convergence state.
 
 ## Failure Recovery
 
@@ -24891,6 +24907,7 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
             this.requirePromptEchoBeforeSubmit = resolvedConfig.requirePromptEchoBeforeSubmit;
             this.providerResolutionMeta = resolvedConfig.providerResolutionMeta;
             this.cliScripts = provider.scripts || {};
+            this.scriptState = typeof this.cliScripts.createState === "function" ? this.cliScripts.createState() ?? null : null;
             const scriptNames = listCliScriptNames(this.cliScripts);
             if (scriptNames.length > 0) {
               LOG2.info("CLI", `[${this.cliType}] CLI scripts: [${scriptNames.join(", ")}]`);
@@ -25160,7 +25177,7 @@ ${lastSnapshot}`;
             this.cliScripts = scripts;
             this.parsedStatusCache = null;
             this.parseErrorMessage = null;
-            this.scriptState = typeof scripts.createState === "function" ? scripts.createState() : null;
+            this.scriptState = typeof scripts.createState === "function" ? scripts.createState() ?? null : null;
             const scriptNames = listCliScriptNames(scripts);
             LOG2.info("CLI", `[${this.cliType}] CLI scripts injected: [${scriptNames.join(", ")}]`);
           }
@@ -26203,7 +26220,7 @@ ${lastSnapshot}`;
               scope: this.currentTurnScope,
               runtimeSettings: this.runtimeSettings
             });
-            return await Promise.resolve(fn(this.scriptState, {
+            return await Promise.resolve(this.invokeCliScript(fn, {
               ...input,
               args: args && typeof args === "object" ? { ...args } : {}
             }));
@@ -38359,6 +38376,8 @@ ${effect.notification.body || ""}`.trim();
       }
       return normalizedId;
     }
+    var COMPLETED_FINALIZATION_RETRY_MS = 1e3;
+    var COMPLETED_FINALIZATION_MAX_WAIT_MS = 3e4;
     var IMAGE_MIME_EXTENSIONS = {
       "image/png": ".png",
       "image/jpeg": ".jpg",
@@ -38422,6 +38441,13 @@ ${effect.notification.body || ""}`.trim();
       } catch {
       }
     }
+    function hasNonEmptyCliModalButtons(activeModal) {
+      const buttons = activeModal?.buttons;
+      return Array.isArray(buttons) && buttons.some((button) => String(button || "").trim().length > 0);
+    }
+    function isCliGeneratingLikeStatus(status) {
+      return status === "generating" || status === "streaming" || status === "long_generating" || status === "starting";
+    }
     function buildCliStructuredInputPrompt(input, options = {}) {
       const promptParts = [];
       const imageRefs = [];
@@ -38706,10 +38732,12 @@ ${effect.notification.body || ""}`.trim();
         const mergedMessages = this.mergeConversationMessages(parsedMessages);
         const canonicalBackedHistory = this.syncCanonicalSavedHistoryIfNeeded();
         const dirName = this.workingDir.split("/").filter(Boolean).pop() || "session";
+        const parsedChatStatus = typeof parsedStatus?.status === "string" && parsedStatus.status.trim() ? parsedStatus.status.trim() : void 0;
+        const suppressStaleParsedBusyStatus = this.shouldSuppressStaleParsedBusyStatus(parsedStatus, adapterStatus);
         if (parsedMessages.length > 0) {
           const shouldSkipReplayPersist = this.suppressIdleHistoryReplay && adapterStatus.status === "idle" && parsedStatus?.status === "idle";
           let messagesToSave = parsedMessages;
-          if (parsedStatus?.status === "generating" || parsedStatus?.status === "long_generating") {
+          if (!suppressStaleParsedBusyStatus && (parsedChatStatus === "generating" || parsedChatStatus === "long_generating")) {
             const lastIdx = messagesToSave.length - 1;
             if (lastIdx >= 0 && messagesToSave[lastIdx]?.role === "assistant") {
               messagesToSave = messagesToSave.slice(0, lastIdx);
@@ -38743,6 +38771,7 @@ ${effect.notification.body || ""}`.trim();
           summaryMetadata: this.summaryMetadata,
           controlValues: this.controlValues
         });
+        const activeChatStatus = parseErrorMessage ? "error" : autoApproveActive && parsedStatus?.status === "waiting_approval" ? "generating" : adapterStatus.status !== "idle" ? visibleStatus : suppressStaleParsedBusyStatus ? visibleStatus : parsedChatStatus || visibleStatus;
         return {
           type: this.type,
           name: this.provider.name,
@@ -38752,7 +38781,7 @@ ${effect.notification.body || ""}`.trim();
           activeChat: {
             id: `${this.type}_${this.workingDir}`,
             title: parsedStatus?.title || dirName,
-            status: parseErrorMessage ? "error" : autoApproveActive && parsedStatus?.status === "waiting_approval" ? "generating" : adapterStatus.status !== "idle" ? visibleStatus : parsedStatus?.status || visibleStatus,
+            status: activeChatStatus,
             messages: mergedMessages,
             activeModal: autoApproveActive ? null : parsedStatus?.activeModal ?? adapterStatus.activeModal,
             inputContent: ""
@@ -38882,6 +38911,102 @@ ${effect.notification.body || ""}`.trim();
         }
         this.applyProviderResponse(parsed.payload, { phase: "immediate" });
       }
+      completionHasFinalAssistantMessage(messages) {
+        const visibleMessages = (Array.isArray(messages) ? messages : []).filter((message) => isUserFacingChatMessage(message));
+        const lastVisible = visibleMessages[visibleMessages.length - 1];
+        const role = typeof lastVisible?.role === "string" ? lastVisible.role.trim().toLowerCase() : "";
+        const content = lastVisible ? flattenContent(lastVisible.content).trim() : "";
+        return role === "assistant" && !!content;
+      }
+      hasAdapterPendingResponse() {
+        const adapterAny = this.adapter;
+        if (adapterAny?.isWaitingForResponse === true) return true;
+        if (adapterAny?.currentTurnScope) return true;
+        try {
+          if (typeof this.adapter.isProcessing === "function" && this.adapter.isProcessing()) return true;
+        } catch {
+        }
+        try {
+          const partial2 = typeof this.adapter.getPartialResponse === "function" ? this.adapter.getPartialResponse() : "";
+          if (typeof partial2 === "string" && partial2.trim()) return true;
+        } catch {
+        }
+        return false;
+      }
+      shouldSuppressStaleParsedBusyStatus(parsedStatus, adapterStatus) {
+        const parsedRawStatus = typeof parsedStatus?.status === "string" ? parsedStatus.status.trim() : "";
+        const adapterRawStatus = typeof adapterStatus?.status === "string" ? adapterStatus.status.trim() : "";
+        if (!isCliGeneratingLikeStatus(parsedRawStatus)) return false;
+        if (adapterRawStatus !== "idle") return false;
+        if (hasNonEmptyCliModalButtons(parsedStatus?.activeModal ?? parsedStatus?.modal)) return false;
+        return !this.hasAdapterPendingResponse();
+      }
+      getCompletedFinalizationBlockReason(latestVisibleStatus) {
+        if (latestVisibleStatus !== "idle") return `status:${latestVisibleStatus}`;
+        const adapterAny = this.adapter;
+        if (adapterAny?.isWaitingForResponse === true) return "adapter_waiting_for_response";
+        if (adapterAny?.currentTurnScope) return "adapter_turn_scope_active";
+        const partial2 = typeof this.adapter.getPartialResponse === "function" ? this.adapter.getPartialResponse() : "";
+        if (typeof partial2 === "string" && partial2.trim()) return "partial_response_pending";
+        let parsed;
+        try {
+          parsed = this.adapter.getScriptParsedStatus();
+        } catch (error48) {
+          return `parse_error:${error48?.message || String(error48)}`;
+        }
+        const parsedStatus = typeof parsed?.status === "string" ? parsed.status : "unknown";
+        if (parsedStatus !== "idle") return `parsed_status:${parsedStatus}`;
+        if (parsed?.activeModal || parsed?.modal) return "parsed_modal_active";
+        if (!this.completionHasFinalAssistantMessage(parsed?.messages)) return "missing_final_assistant";
+        return null;
+      }
+      scheduleCompletedDebounceFlush(delayMs) {
+        if (this.completedDebounceTimer) clearTimeout(this.completedDebounceTimer);
+        this.completedDebounceTimer = setTimeout(() => this.flushCompletedDebounceIfFinalized(), delayMs);
+      }
+      flushCompletedDebounceIfFinalized() {
+        const pending = this.completedDebouncePending;
+        if (!pending) {
+          this.completedDebounceTimer = null;
+          return;
+        }
+        const latestStatus = this.adapter.getStatus({ allowParse: false });
+        const latestAutoApproveActive = latestStatus.status === "waiting_approval" && this.shouldAutoApprove();
+        const latestVisibleStatus = latestAutoApproveActive ? "generating" : latestStatus.status;
+        if (latestVisibleStatus !== "idle") {
+          LOG2.info("CLI", `[${this.type}] cancelled pending completed (resumed ${latestVisibleStatus})`);
+          this.completedDebouncePending = null;
+          this.completedDebounceTimer = null;
+          return;
+        }
+        const blockReason = this.getCompletedFinalizationBlockReason(latestVisibleStatus);
+        if (blockReason) {
+          const waitedMs = Date.now() - pending.firstObservedAt;
+          if (waitedMs < COMPLETED_FINALIZATION_MAX_WAIT_MS) {
+            if (pending.loggedBlockReason !== blockReason) {
+              LOG2.info("CLI", `[${this.type}] waiting to emit completed until transcript finalizes (${blockReason})`);
+              pending.loggedBlockReason = blockReason;
+            }
+            this.scheduleCompletedDebounceFlush(COMPLETED_FINALIZATION_RETRY_MS);
+            return;
+          }
+          LOG2.warn("CLI", `[${this.type}] suppressed completed event after ${waitedMs}ms without finalized assistant turn (${blockReason})`);
+          this.completedDebouncePending = null;
+          this.completedDebounceTimer = null;
+          this.generatingStartedAt = 0;
+          return;
+        }
+        LOG2.info("CLI", `[${this.type}] completed in ${pending.duration}s`);
+        this.pushEvent({
+          event: "agent:generating_completed",
+          chatTitle: pending.chatTitle,
+          duration: pending.duration,
+          timestamp: pending.timestamp
+        });
+        this.completedDebouncePending = null;
+        this.completedDebounceTimer = null;
+        this.generatingStartedAt = 0;
+      }
       maybeAutoApproveStatus(adapterStatus, now = Date.now()) {
         const autoApproveActive = adapterStatus?.status === "waiting_approval" && this.shouldAutoApprove();
         if (autoApproveActive && !this.autoApproveBusy) {
@@ -38979,26 +39104,8 @@ ${effect.notification.body || ""}`.trim();
               this.generatingDebouncePending = null;
               this.generatingStartedAt = 0;
             } else {
-              if (this.completedDebounceTimer) clearTimeout(this.completedDebounceTimer);
-              this.completedDebouncePending = { chatTitle, duration: duration3, timestamp: now };
-              this.completedDebounceTimer = setTimeout(() => {
-                if (this.completedDebouncePending) {
-                  const latestStatus = this.adapter.getStatus({ allowParse: false });
-                  const latestAutoApproveActive = latestStatus.status === "waiting_approval" && this.shouldAutoApprove();
-                  const latestVisibleStatus = latestAutoApproveActive ? "generating" : latestStatus.status;
-                  if (latestVisibleStatus !== "idle") {
-                    LOG2.info("CLI", `[${this.type}] cancelled pending completed (resumed ${latestVisibleStatus})`);
-                    this.completedDebouncePending = null;
-                    this.completedDebounceTimer = null;
-                    return;
-                  }
-                  LOG2.info("CLI", `[${this.type}] completed in ${this.completedDebouncePending.duration}s`);
-                  this.pushEvent({ event: "agent:generating_completed", ...this.completedDebouncePending });
-                  this.completedDebouncePending = null;
-                  this.generatingStartedAt = 0;
-                }
-                this.completedDebounceTimer = null;
-              }, 3e3);
+              this.completedDebouncePending = { chatTitle, duration: duration3, timestamp: now, firstObservedAt: now };
+              this.scheduleCompletedDebounceFlush(3e3);
             }
           } else if (newStatus === "idle" && this.lastStatus === "starting") {
             this.pushEvent({ event: "agent:ready", chatTitle, timestamp: now });
@@ -45145,6 +45252,89 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         if (record2?.meta?.meshNodeId === nodeId) return true;
         return false;
       }
+      async cleanupLocalWorktreeNode(args) {
+        const workspace = typeof args.node?.workspace === "string" ? args.node.workspace.trim() : "";
+        if (!workspace) {
+          return {
+            success: false,
+            code: "mesh_worktree_cleanup_missing_workspace",
+            error: `Worktree node '${args.nodeId}' is missing workspace metadata`,
+            recoveryHint: "Inspect the mesh node record before removing it, or remove stale metadata manually only after confirming no managed worktree remains."
+          };
+        }
+        const worktreeExists = fs10.existsSync(workspace);
+        const sourceNode = args.node?.clonedFromNodeId ? args.mesh?.nodes?.find((n) => n.id === args.node.clonedFromNodeId || n.nodeId === args.node.clonedFromNodeId) : args.mesh?.nodes?.find((n) => !n.isLocalWorktree);
+        const repoRoot = typeof sourceNode?.repoRoot === "string" && sourceNode.repoRoot.trim() ? sourceNode.repoRoot.trim() : typeof sourceNode?.workspace === "string" && sourceNode.workspace.trim() ? sourceNode.workspace.trim() : "";
+        if (!worktreeExists) {
+          return { success: true, skipped: true, removedPath: workspace, repoRoot: repoRoot || void 0, reason: "worktree_path_missing" };
+        }
+        if (!repoRoot || !fs10.existsSync(repoRoot)) {
+          return {
+            success: false,
+            code: "mesh_worktree_cleanup_missing_source_repo",
+            error: `Refusing to remove worktree '${workspace}' because the source repo root is unavailable`,
+            recoveryHint: "Run mesh_remove_node from the machine that owns the source repo, or verify the source node metadata before retrying."
+          };
+        }
+        if (typeof args.node?.worktreeBranch !== "string" || !args.node.worktreeBranch.trim()) {
+          return {
+            success: false,
+            code: "mesh_worktree_cleanup_missing_branch",
+            error: `Refusing to remove worktree '${workspace}' because worktreeBranch metadata is missing`,
+            recoveryHint: "Confirm this is an ADHDev-managed worktree before removing it manually; managed worktree nodes include worktreeBranch metadata."
+          };
+        }
+        const { resolveWorktreePath: resolveWorktreePath2, listWorktrees: listWorktrees2, removeWorktree: removeWorktree2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
+        const normalizePath = (value) => {
+          const resolved = (0, import_path6.resolve)(value);
+          try {
+            return fs10.realpathSync(resolved);
+          } catch {
+            return resolved;
+          }
+        };
+        const expectedPath = normalizePath(resolveWorktreePath2(repoRoot, String(args.mesh?.name || args.mesh?.id || "mesh"), args.node.worktreeBranch));
+        const actualPath = normalizePath(workspace);
+        if (actualPath !== expectedPath) {
+          return {
+            success: false,
+            code: "mesh_worktree_cleanup_unexpected_path",
+            error: `Refusing to remove worktree '${workspace}' because it is not at the expected managed path '${expectedPath}'`,
+            recoveryHint: "Use git worktree list/status to inspect the path. Retry only after confirming the mesh node metadata points to an ADHDev-managed worktree."
+          };
+        }
+        const entries = await listWorktrees2(repoRoot);
+        const managedEntry = entries.find((entry) => normalizePath(entry.path) === actualPath);
+        if (!managedEntry) {
+          return {
+            success: false,
+            code: "mesh_worktree_cleanup_not_registered",
+            error: `Refusing to remove '${workspace}' because it is not registered in git worktree list for '${repoRoot}'`,
+            recoveryHint: "Inspect git worktree list --porcelain from the source repo. If the path was already removed, prune git worktrees before retrying."
+          };
+        }
+        if (managedEntry.branch && managedEntry.branch !== args.node.worktreeBranch) {
+          return {
+            success: false,
+            code: "mesh_worktree_cleanup_branch_mismatch",
+            error: `Refusing to remove '${workspace}' because git reports branch '${managedEntry.branch}', expected '${args.node.worktreeBranch}'`,
+            recoveryHint: "Inspect the worktree branch and mesh metadata before retrying cleanup."
+          };
+        }
+        try {
+          const result = await removeWorktree2(repoRoot, workspace, { requireClean: true });
+          return { success: true, removedPath: result.removedPath, repoRoot };
+        } catch (e) {
+          const message = String(e?.message || e || "worktree cleanup failed");
+          const dirty = message.includes("dirty worktree") || message.includes("local changes");
+          return {
+            success: false,
+            code: dirty ? "mesh_worktree_cleanup_dirty" : "mesh_worktree_cleanup_failed",
+            error: message,
+            recoveryHint: dirty ? "Commit, stash, or intentionally discard the worktree changes before retrying mesh_remove_node. The mesh registry entry is preserved until cleanup is safe." : "Inspect git worktree status/list from the source repo and retry after resolving the reported cleanup failure."
+          };
+        }
+      }
       isCompletedHostedSession(record2) {
         return record2?.lifecycle === "stopped" || record2?.lifecycle === "failed" || record2?.lifecycle === "interrupted";
       }
@@ -46145,17 +46335,21 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                 sessionCleanup = await this.cleanupMeshSessions({ meshId, nodeId, node, mode: sessionCleanupMode });
                 if (sessionCleanup.success === false) return { success: false, removed: false, sessionCleanup };
               }
-              if (node?.isLocalWorktree && node.workspace) {
-                try {
-                  const sourceNode = node.clonedFromNodeId ? mesh?.nodes.find((n) => n.id === node.clonedFromNodeId || n.nodeId === node.clonedFromNodeId) : mesh?.nodes.find((n) => !n.isLocalWorktree);
-                  const repoRoot = sourceNode?.repoRoot || sourceNode?.workspace;
-                  if (repoRoot) {
-                    const { removeWorktree: removeWorktree2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
-                    await removeWorktree2(repoRoot, node.workspace);
-                  }
-                } catch (e) {
-                  LOG2.warn("MeshNode", `Worktree cleanup failed for ${nodeId}: ${e.message}`);
+              let worktreeCleanup;
+              if (node?.isLocalWorktree) {
+                const cleanupResult = await this.cleanupLocalWorktreeNode({ mesh, node, nodeId });
+                if (cleanupResult.success === false) {
+                  return {
+                    success: false,
+                    removed: false,
+                    code: cleanupResult.code,
+                    error: cleanupResult.error,
+                    recoveryHint: cleanupResult.recoveryHint,
+                    ...sessionCleanup ? { sessionCleanup } : {},
+                    worktreeCleanup: cleanupResult
+                  };
                 }
+                worktreeCleanup = cleanupResult;
               }
               let removed = false;
               if (meshRecord?.inline) {
@@ -46181,7 +46375,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                 } catch {
                 }
               }
-              return { success: true, removed, ...sessionCleanup ? { sessionCleanup } : {} };
+              return { success: true, removed, ...sessionCleanup ? { sessionCleanup } : {}, ...worktreeCleanup ? { worktreeCleanup } : {} };
             } catch (e) {
               return { success: false, error: e.message };
             }
@@ -46216,6 +46410,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                   workspace: result.worktreePath,
                   repoRoot: result.worktreePath,
                   daemonId: sourceNode.daemonId,
+                  machineId: sourceNode.machineId ?? sourceNode.machine_id,
                   userOverrides: { ...sourceNode.userOverrides || {} },
                   policy: { ...sourceNode.policy || {} },
                   isLocalWorktree: true,
@@ -46229,6 +46424,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                   workspace: result.worktreePath,
                   repoRoot: result.worktreePath,
                   daemonId: sourceNode.daemonId,
+                  machineId: sourceNode.machineId ?? sourceNode.machine_id,
                   userOverrides: { ...sourceNode.userOverrides || {} },
                   isLocalWorktree: true,
                   worktreeBranch: result.branch,