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

package/dist/index.mjs

@@ -96,13 +96,25 @@ async function createWorktree(opts) {
     branch
   };
 }
-async function removeWorktree(repoRoot, worktreePath) {
+async function removeWorktree(repoRoot, worktreePath, opts = {}) {
   if (!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,
@@ -544,6 +556,7 @@ function addNode(meshId, opts) {
     workspace: opts.workspace.trim(),
     repoRoot: opts.repoRoot,
     daemonId: opts.daemonId,
+    machineId: opts.machineId,
     userOverrides: opts.userOverrides || {},
     policy: opts.policy || {},
     isLocalWorktree: opts.isLocalWorktree,
@@ -680,6 +693,7 @@ function buildRulesSection(coordinatorCliType) {
 - **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, TOOL_EXPOSURE_PREFLIGHT_SECTION, WORKFLOW_SECTION;
@@ -701,6 +715,7 @@ var init_coordinator_prompt = __esm({
 | \`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
 
@@ -717,8 +732,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
 
@@ -2766,6 +2782,7 @@ var init_provider_cli_adapter = __esm({
         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) {
           LOG.info("CLI", `[${this.cliType}] CLI scripts: [${scriptNames.join(", ")}]`);
@@ -3035,7 +3052,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);
         LOG.info("CLI", `[${this.cliType}] CLI scripts injected: [${scriptNames.join(", ")}]`);
       }
@@ -4078,7 +4095,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 } : {}
         }));
@@ -16149,6 +16166,8 @@ function normalizeProviderSessionId(provider, providerSessionId) {
 }
 
 // src/providers/cli-provider-instance.ts
+var COMPLETED_FINALIZATION_RETRY_MS = 1e3;
+var COMPLETED_FINALIZATION_MAX_WAIT_MS = 3e4;
 var IMAGE_MIME_EXTENSIONS = {
   "image/png": ".png",
   "image/jpeg": ".jpg",
@@ -16212,6 +16231,13 @@ function cleanupStaleMaterializedImages(dir) {
   } 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 = [];
@@ -16496,10 +16522,12 @@ var CliProviderInstance = class {
     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);
@@ -16533,6 +16561,7 @@ var CliProviderInstance = class {
       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,
@@ -16542,7 +16571,7 @@ var CliProviderInstance = class {
       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: ""
@@ -16672,6 +16701,102 @@ var CliProviderInstance = class {
     }
     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 partial = typeof this.adapter.getPartialResponse === "function" ? this.adapter.getPartialResponse() : "";
+      if (typeof partial === "string" && partial.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 partial = typeof this.adapter.getPartialResponse === "function" ? this.adapter.getPartialResponse() : "";
+    if (typeof partial === "string" && partial.trim()) return "partial_response_pending";
+    let parsed;
+    try {
+      parsed = this.adapter.getScriptParsedStatus();
+    } catch (error) {
+      return `parse_error:${error?.message || String(error)}`;
+    }
+    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") {
+      LOG.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) {
+          LOG.info("CLI", `[${this.type}] waiting to emit completed until transcript finalizes (${blockReason})`);
+          pending.loggedBlockReason = blockReason;
+        }
+        this.scheduleCompletedDebounceFlush(COMPLETED_FINALIZATION_RETRY_MS);
+        return;
+      }
+      LOG.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;
+    }
+    LOG.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) {
@@ -16769,26 +16894,8 @@ var CliProviderInstance = class {
           this.generatingDebouncePending = null;
           this.generatingStartedAt = 0;
         } else {
-          if (this.completedDebounceTimer) clearTimeout(this.completedDebounceTimer);
-          this.completedDebouncePending = { chatTitle, duration, 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") {
-                LOG.info("CLI", `[${this.type}] cancelled pending completed (resumed ${latestVisibleStatus})`);
-                this.completedDebouncePending = null;
-                this.completedDebounceTimer = null;
-                return;
-              }
-              LOG.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, timestamp: now, firstObservedAt: now };
+          this.scheduleCompletedDebounceFlush(3e3);
         }
       } else if (newStatus === "idle" && this.lastStatus === "starting") {
         this.pushEvent({ event: "agent:ready", chatTitle, timestamp: now });
@@ -22976,6 +23083,89 @@ var DaemonCommandRouter = class {
     if (record?.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 = pathResolve(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(record) {
     return record?.lifecycle === "stopped" || record?.lifecycle === "failed" || record?.lifecycle === "interrupted";
   }
@@ -23976,17 +24166,21 @@ var DaemonCommandRouter = class {
             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) {
-              LOG.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) {
@@ -24012,7 +24206,7 @@ var DaemonCommandRouter = class {
             } catch {
             }
           }
-          return { success: true, removed, ...sessionCleanup ? { sessionCleanup } : {} };
+          return { success: true, removed, ...sessionCleanup ? { sessionCleanup } : {}, ...worktreeCleanup ? { worktreeCleanup } : {} };
         } catch (e) {
           return { success: false, error: e.message };
         }
@@ -24047,6 +24241,7 @@ var DaemonCommandRouter = class {
               workspace: result.worktreePath,
               repoRoot: result.worktreePath,
               daemonId: sourceNode.daemonId,
+              machineId: sourceNode.machineId ?? sourceNode.machine_id,
               userOverrides: { ...sourceNode.userOverrides || {} },
               policy: { ...sourceNode.policy || {} },
               isLocalWorktree: true,
@@ -24060,6 +24255,7 @@ var DaemonCommandRouter = class {
               workspace: result.worktreePath,
               repoRoot: result.worktreePath,
               daemonId: sourceNode.daemonId,
+              machineId: sourceNode.machineId ?? sourceNode.machine_id,
               userOverrides: { ...sourceNode.userOverrides || {} },
               isLocalWorktree: true,
               worktreeBranch: result.branch,