@adhdev/daemon-core 0.9.82-rc.419 → 0.9.82-rc.420

package/dist/commands/med-family/types.d.ts

@@ -45,6 +45,20 @@ export type CleanupLocalWorktreeNodeResult = {
     recoveryHint: string;
     convergence?: Record<string, unknown>;
 };
+/**
+ * Result of the non-destructive local-worktree removability precheck. `ok:false`
+ * carries the same refusal `code`/`error`/`recoveryHint` that the destructive
+ * cleanup would have returned, so callers can refuse a removal BEFORE performing
+ * any irreversible step (e.g. stopping/deleting delegated sessions).
+ */
+export type WorktreeRemovalPrecheckResult = {
+    ok: true;
+} | {
+    ok: false;
+    code: string;
+    error: string;
+    recoveryHint: string;
+};
 /**
  * Router-private collaborators injected at dispatch. Each is a bound method or
  * field of DaemonCommandRouter; handlers that don't need a given collaborator
@@ -90,6 +104,17 @@ export interface MedFamilyContext {
         nodeId: string;
         force?: boolean;
     }) => Promise<CleanupLocalWorktreeNodeResult>;
+    /**
+     * Bound `DaemonCommandRouter.precheckLocalWorktreeRemovable` — purely
+     * non-destructive validation of whether a local worktree node can be removed.
+     * Called BEFORE session cleanup so a refusal does not orphan the session.
+     */
+    precheckLocalWorktreeRemovable: (args: {
+        mesh: any;
+        node: any;
+        nodeId: string;
+        force?: boolean;
+    }) => Promise<WorktreeRemovalPrecheckResult>;
     /** Bound `DaemonCommandRouter.startMeshRefineJob` (async execute path). */
     startMeshRefineJob: (meshId: string, nodeId: string, args: any) => Promise<CommandRouterResult>;
     /** Bound `DaemonCommandRouter.batchRefineMeshNodes` (dry-run batch plan). */

package/dist/commands/router.d.ts

@@ -248,6 +248,26 @@ export declare class DaemonCommandRouter {
      * to give handles time to release, and reports whether residue remains.
      */
     private bestEffortRemoveWorktreeDir;
+    /**
+     * Non-destructive precheck mirroring every REFUSAL condition in
+     * {@link cleanupLocalWorktreeNode} — missing workspace / source-repo / branch
+     * metadata, unexpected (non-managed) path, branch mismatch — PLUS the
+     * dirty-worktree guard that `removeWorktree(requireClean)` enforces
+     * (`git status --porcelain`). It performs ZERO destructive actions: no
+     * `git worktree remove`, no `git worktree prune`, no directory deletion.
+     *
+     * remove_mesh_node calls this BEFORE any session cleanup so that a refusal
+     * (the common one being a dirty worktree) does not first stop/delete the
+     * delegated session and orphan it — the original ordering bug. Success/skip
+     * cases that the real cleanup handles idempotently (worktree path already
+     * gone, git-de-registered residue) are NOT refusals and return `{ ok: true }`.
+     *
+     * `force:true` skips the dirty guard, preserving `removeWorktree`'s
+     * `requireClean: !force` semantics. This is a read-only superset check; the
+     * authoritative `requireClean` guard inside `removeWorktree` is intentionally
+     * kept as a second line of defense against a precheck→execute race.
+     */
+    private precheckLocalWorktreeRemovable;
     private cleanupLocalWorktreeNode;
     private getWorktreeForceCleanupConvergence;
     private isCompletedHostedSession;

package/dist/index.js

@@ -389,10 +389,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "00b0b1bba6930ac68b6c43e87795cbe63e59b323" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "00b0b1bb" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.419" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-28T18:13:37.481Z" : void 0);
+  const commit = readInjected(true ? "bd19cb0fbe1e16db1d8d2fcd8c2c871aae3ce33b" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "bd19cb0f" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.420" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-28T19:41:31.696Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -10913,6 +10913,35 @@ function drainPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId, opts) {
   if (merged.length === 0) return [];
   return reconcilePendingMeshCoordinatorEvents(meshId, merged);
 }
+function retractPendingDispatchBlockedEvent(meshId, taskId, coordinatorDaemonId) {
+  if (!meshId || !taskId) return 0;
+  let removed = 0;
+  const matchesTask = (event) => {
+    if (!event || event.event !== "mesh:dispatch_blocked") return false;
+    const rowTaskId = readNonEmptyString2(event.metadataEvent?.taskId);
+    return rowTaskId === taskId;
+  };
+  try {
+    const store = MeshRuntimeStore.getInstance();
+    const ids = [];
+    for (const row of store.peekPendingEvents(meshId)) {
+      if (row.event !== "mesh:dispatch_blocked") continue;
+      if (matchesTask(row.payload)) ids.push(row.id);
+    }
+    if (ids.length) removed += store.deletePendingEventsById(ids);
+  } catch {
+  }
+  const daemonIds = normalizeCoordinatorDaemonIds(coordinatorDaemonId);
+  const primaryDaemonId = daemonIds[0];
+  const paths = primaryDaemonId ? [getPendingEventsPath(meshId, primaryDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
+  for (const path43 of paths) {
+    try {
+      removed += selectiveDrainFile(path43, matchesTask).length;
+    } catch {
+    }
+  }
+  return removed;
+}
 function getPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
   if (!meshId) return [];
   const daemonIds = normalizeCoordinatorDaemonIds(coordinatorDaemonId);
@@ -11965,6 +11994,41 @@ var init_mesh_warmup_deadline = __esm({
   }
 });
 
+// src/mesh/mesh-clone-grace.ts
+function normalizeNodeIdKey(nodeId) {
+  return normalizeMeshNodeId({ id: nodeId ?? void 0 }) ?? "";
+}
+function noteRecentlyClonedNode(nodeId, nowMs = Date.now()) {
+  const key2 = normalizeNodeIdKey(nodeId);
+  if (!key2) return;
+  recentlyClonedNodeExpiry.set(key2, nowMs + CLONE_BOOTSTRAP_GRACE_MS);
+  if (recentlyClonedNodeExpiry.size > MAX_TRACKED_CLONED_NODES) {
+    const oldest = recentlyClonedNodeExpiry.keys().next().value;
+    if (oldest !== void 0) recentlyClonedNodeExpiry.delete(oldest);
+  }
+}
+function isWithinCloneBootstrapGrace(nodeId, nowMs = Date.now()) {
+  const key2 = normalizeNodeIdKey(nodeId);
+  if (!key2) return false;
+  const expiry = recentlyClonedNodeExpiry.get(key2);
+  if (expiry === void 0) return false;
+  if (nowMs >= expiry) {
+    recentlyClonedNodeExpiry.delete(key2);
+    return false;
+  }
+  return true;
+}
+var CLONE_BOOTSTRAP_GRACE_MS, recentlyClonedNodeExpiry, MAX_TRACKED_CLONED_NODES;
+var init_mesh_clone_grace = __esm({
+  "src/mesh/mesh-clone-grace.ts"() {
+    "use strict";
+    init_dist();
+    CLONE_BOOTSTRAP_GRACE_MS = 10 * 60 * 1e3;
+    recentlyClonedNodeExpiry = /* @__PURE__ */ new Map();
+    MAX_TRACKED_CLONED_NODES = 512;
+  }
+});
+
 // src/mesh/mesh-queue-assignment.ts
 function localCoordinatorDaemonId() {
   return canonicalDaemonId(readNonEmptyString2(loadConfig().machineId));
@@ -12128,6 +12192,7 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
     return false;
   }
   LOG.info("MeshQueue", `Node ${nodeId} (${sessionId}) pulled task ${task.id}`);
+  retractActionableSkipIfPreviouslyNotified(meshId, task.id);
   beginTaskDispatchInFlight(meshId, task.id);
   if (node?.daemonId && components.dispatchMeshCommand) {
     const isLocalNode = components.cliManager.adapters.has(sessionId);
@@ -12217,6 +12282,28 @@ function isActionableSkipReason(reason) {
   if (!reason) return false;
   return ACTIONABLE_SKIP_REASON_PREFIXES.some((prefix) => reason === prefix || reason.startsWith(prefix));
 }
+function isTargetNodeTransientlyUnresolved(mesh, task) {
+  const targetNodeId = readNonEmptyString2(task.targetNodeId);
+  if (!targetNodeId) return false;
+  const node = Array.isArray(mesh?.nodes) ? mesh.nodes.find((n) => meshNodeIdMatches(n, targetNodeId)) : void 0;
+  if (node && node.worktreeBootstrap?.status === "running" && !isWorktreeBootstrapStaleRunning(node)) {
+    return true;
+  }
+  return isWithinCloneBootstrapGrace(targetNodeId);
+}
+function retractActionableSkipIfPreviouslyNotified(meshId, taskId) {
+  const dedupKey = `${meshId}:${taskId}`;
+  if (!lastActionableSkipNotified.delete(dedupKey)) return;
+  try {
+    const coordinatorDaemonId = readNonEmptyString2(loadConfig().machineId) || void 0;
+    const removed = retractPendingDispatchBlockedEvent(meshId, taskId, coordinatorDaemonId);
+    if (removed > 0) {
+      LOG.info("MeshQueue", `Retracted ${removed} stale dispatch-blocked event(s) for task ${taskId} (mesh ${meshId}) \u2014 its blocker resolved`);
+    }
+  } catch (e) {
+    LOG.warn("MeshQueue", `Failed to retract stale dispatch-blocked event for task ${taskId} (mesh ${meshId}): ${e?.message || e}`);
+  }
+}
 function actionableSkipGuidance(reason) {
   if (reason === "target_node_id_unmatched") return {
     summary: "it is pinned to a target node id that matches no node in the mesh (the node may have been removed, or its id form does not resolve)",
@@ -12249,6 +12336,7 @@ function actionableSkipGuidance(reason) {
 }
 function notifyCoordinatorOfActionableSkip(meshId, taskId, reason, nodeId) {
   if (!isActionableSkipReason(reason)) return;
+  if (reason === "target_node_id_unmatched" && isWithinCloneBootstrapGrace(readNonEmptyString2(nodeId))) return;
   const dedupKey = `${meshId}:${taskId}`;
   if (lastActionableSkipNotified.get(dedupKey) === reason) return;
   lastActionableSkipNotified.set(dedupKey, reason);
@@ -12486,9 +12574,13 @@ function markAutoLaunch(meshId, taskId, args) {
     error: args.error
   });
   if (args.status === "skipped") {
-    notifyCoordinatorOfActionableSkip(meshId, taskId, args.reason, args.nodeId);
+    if (isActionableSkipReason(args.reason)) {
+      notifyCoordinatorOfActionableSkip(meshId, taskId, args.reason, args.nodeId);
+    } else if (args.reason === TRANSIENT_TARGET_NODE_BOOTSTRAP_PENDING_REASON) {
+      retractActionableSkipIfPreviouslyNotified(meshId, taskId);
+    }
   } else {
-    lastActionableSkipNotified.delete(`${meshId}:${taskId}`);
+    retractActionableSkipIfPreviouslyNotified(meshId, taskId);
   }
 }
 async function resolveUsableProvider(components, nodeId, node, requiredTags) {
@@ -12576,9 +12668,10 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
         const matched = mesh.nodes.filter((n) => !task.targetNodeId || meshNodeIdMatches(n, task.targetNodeId));
         return matched.length > 0 && matched.every((n) => n?.isLocalWorktree === true);
       })();
+      const targetTransientlyUnresolved = targetPinUnmatched && isTargetNodeTransientlyUnresolved(mesh, task);
       markAutoLaunch(meshId, task.id, {
         status: "skipped",
-        reason: convergenceOntoWorktree ? "mesh_convergence_target_is_worktree" : targetPinUnmatched ? "target_node_id_unmatched" : "no_node_satisfies_required_tags",
+        reason: convergenceOntoWorktree ? "mesh_convergence_target_is_worktree" : targetTransientlyUnresolved ? TRANSIENT_TARGET_NODE_BOOTSTRAP_PENDING_REASON : targetPinUnmatched ? "target_node_id_unmatched" : "no_node_satisfies_required_tags",
         nodeId: task.targetNodeId
       });
       continue;
@@ -12931,7 +13024,7 @@ function runIdleMaintenanceThenAssignQueue(components, args) {
     });
   });
 }
-var import_fs13, IDLE_AUTO_FAST_FORWARD_THROTTLE_MS, idleAutoFastForwardLastAttempt, DISPATCH_CONFIRM_TIMEOUT_MS, DISPATCH_CONNECT_TIMEOUT_MS, dispatchWarmupGetterMissingWarned, LOCAL_LAUNCH_READY_TIMEOUT_MS, LOCAL_LAUNCH_READY_POLL_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS, AUTO_LAUNCH_AWAIT_CLAIM_MS, lastAutoLaunchLedgerKey, AUTO_LAUNCH_LEDGER_DEDUP_MAX, ACTIONABLE_SKIP_REASON_PREFIXES, lastActionableSkipNotified;
+var import_fs13, IDLE_AUTO_FAST_FORWARD_THROTTLE_MS, idleAutoFastForwardLastAttempt, DISPATCH_CONFIRM_TIMEOUT_MS, DISPATCH_CONNECT_TIMEOUT_MS, dispatchWarmupGetterMissingWarned, LOCAL_LAUNCH_READY_TIMEOUT_MS, LOCAL_LAUNCH_READY_POLL_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS, AUTO_LAUNCH_AWAIT_CLAIM_MS, lastAutoLaunchLedgerKey, AUTO_LAUNCH_LEDGER_DEDUP_MAX, ACTIONABLE_SKIP_REASON_PREFIXES, TRANSIENT_TARGET_NODE_BOOTSTRAP_PENDING_REASON, lastActionableSkipNotified;
 var init_mesh_queue_assignment = __esm({
   "src/mesh/mesh-queue-assignment.ts"() {
     "use strict";
@@ -12954,6 +13047,7 @@ var init_mesh_queue_assignment = __esm({
     init_mesh_events_utils();
     init_mesh_events_pending();
     init_worktree_bootstrap_config();
+    init_mesh_clone_grace();
     init_mesh_task_inflight();
     IDLE_AUTO_FAST_FORWARD_THROTTLE_MS = 30 * 60 * 1e3;
     idleAutoFastForwardLastAttempt = /* @__PURE__ */ new Map();
@@ -12980,6 +13074,7 @@ var init_mesh_queue_assignment = __esm({
       "provider_unusable",
       "dirty_workspace"
     ];
+    TRANSIENT_TARGET_NODE_BOOTSTRAP_PENDING_REASON = "target_node_bootstrap_pending";
     lastActionableSkipNotified = /* @__PURE__ */ new Map();
   }
 });
@@ -48986,6 +49081,7 @@ init_dist();
 init_mesh_host_ownership();
 init_worktree_bootstrap_config();
 init_mesh_events();
+init_mesh_clone_grace();
 init_config();
 async function decideOssCloneSync(ossCtx, worktreeOssSha, sourceSha, rg) {
   if (!worktreeOssSha || !sourceSha || worktreeOssSha === sourceSha) return "noop";
@@ -49267,6 +49363,26 @@ var meshCrudHandlers = {
         explicitCleanupMode ?? (node?.isLocalWorktree === true ? "stop_and_delete" : void 0) ?? mesh?.policy?.sessionCleanupOnNodeRemove
       );
       const explicitSessionIds = Array.isArray(args?.sessionIds) ? args.sessionIds.filter((v) => typeof v === "string" && v.trim().length > 0).map((v) => v.trim()) : void 0;
+      if (node?.isLocalWorktree) {
+        const nodeDaemonId = typeof node.daemonId === "string" ? node.daemonId.trim() : void 0;
+        const isRemoteWorktree = nodeDaemonId && !daemonIdsEquivalent(nodeDaemonId, ctx.deps.statusInstanceId) && ctx.deps.dispatchMeshCommand && !args?._meshDirectDispatch;
+        if (!isRemoteWorktree) {
+          const precheck = await ctx.precheckLocalWorktreeRemovable({ mesh, node, nodeId, force: args?.force === true });
+          if (precheck.ok === false) {
+            return {
+              success: false,
+              removed: false,
+              code: precheck.code,
+              error: precheck.error,
+              recoveryHint: precheck.recoveryHint,
+              // No sessionCleanup key: the session was deliberately NOT
+              // touched. worktreeCleanup mirrors the destructive path's
+              // refusal shape so existing callers see the same code.
+              worktreeCleanup: { success: false, code: precheck.code, error: precheck.error, recoveryHint: precheck.recoveryHint }
+            };
+          }
+        }
+      }
       let sessionCleanup;
       if (node && sessionCleanupMode !== "preserve") {
         sessionCleanup = await ctx.cleanupMeshSessions({
@@ -49377,6 +49493,8 @@ var meshCrudHandlers = {
           ...typeof args === "object" && args !== null ? args : {},
           _meshDirectDispatch: true
         });
+        const forwardedNodeId = forwarded?.node?.id;
+        if (typeof forwardedNodeId === "string" && forwardedNodeId) noteRecentlyClonedNode(forwardedNodeId);
         return forwarded ?? { success: false, error: "no response from remote node" };
       }
       const repoRoot = sourceNode.repoRoot || sourceNode.workspace;
@@ -49426,6 +49544,7 @@ var meshCrudHandlers = {
         if (inlineForReconcile) ctx.updateInlineMeshNode(meshId, inlineForReconcile, node);
         ctx.invalidateAggregateMeshStatus(meshId);
       }
+      if (typeof node?.id === "string" && node.id) noteRecentlyClonedNode(node.id);
       const persistWorktreeSetupState = async (bootstrapState2) => {
         node.worktreeBootstrap = bootstrapState2;
         if (meshRecord.inline) {
@@ -54451,6 +54570,7 @@ var DaemonCommandRouter = class {
       normalizeMeshSessionCleanupMode: this.normalizeMeshSessionCleanupMode.bind(this),
       cleanupMeshSessions: this.cleanupMeshSessions.bind(this),
       cleanupLocalWorktreeNode: this.cleanupLocalWorktreeNode.bind(this),
+      precheckLocalWorktreeRemovable: this.precheckLocalWorktreeRemovable.bind(this),
       startMeshRefineJob: this.startMeshRefineJob.bind(this),
       batchRefineMeshNodes: this.batchRefineMeshNodes.bind(this),
       startMeshRefineBatchJob: this.startMeshRefineBatchJob.bind(this),
@@ -54667,6 +54787,111 @@ var DaemonCommandRouter = class {
     }
     return fs32.existsSync(dir) ? { removed: false, residue: true, error: String(lastErr?.message || lastErr || "unknown rm error") } : { removed: true, residue: false };
   }
+  /**
+   * Non-destructive precheck mirroring every REFUSAL condition in
+   * {@link cleanupLocalWorktreeNode} — missing workspace / source-repo / branch
+   * metadata, unexpected (non-managed) path, branch mismatch — PLUS the
+   * dirty-worktree guard that `removeWorktree(requireClean)` enforces
+   * (`git status --porcelain`). It performs ZERO destructive actions: no
+   * `git worktree remove`, no `git worktree prune`, no directory deletion.
+   *
+   * remove_mesh_node calls this BEFORE any session cleanup so that a refusal
+   * (the common one being a dirty worktree) does not first stop/delete the
+   * delegated session and orphan it — the original ordering bug. Success/skip
+   * cases that the real cleanup handles idempotently (worktree path already
+   * gone, git-de-registered residue) are NOT refusals and return `{ ok: true }`.
+   *
+   * `force:true` skips the dirty guard, preserving `removeWorktree`'s
+   * `requireClean: !force` semantics. This is a read-only superset check; the
+   * authoritative `requireClean` guard inside `removeWorktree` is intentionally
+   * kept as a second line of defense against a precheck→execute race.
+   */
+  async precheckLocalWorktreeRemovable(args) {
+    const sessionPreservedNote = " The delegated session was left running (not stopped) \u2014 resolve the issue and retry mesh_remove_node.";
+    const workspace = typeof args.node?.workspace === "string" ? args.node.workspace.trim() : "";
+    if (!workspace) {
+      return {
+        ok: 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." + sessionPreservedNote
+      };
+    }
+    if (!fs32.existsSync(workspace)) return { ok: true };
+    const sourceNode = args.node?.clonedFromNodeId ? args.mesh?.nodes?.find((n) => meshNodeIdMatches(n, 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 (!repoRoot || !fs32.existsSync(repoRoot)) {
+      return {
+        ok: 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." + sessionPreservedNote
+      };
+    }
+    if (typeof args.node?.worktreeBranch !== "string" || !args.node.worktreeBranch.trim()) {
+      return {
+        ok: 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." + sessionPreservedNote
+      };
+    }
+    const { resolveWorktreePath: resolveWorktreePath2, listWorktrees: listWorktrees2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
+    const normalizePath = (value) => {
+      const resolved = (0, import_path16.resolve)(value);
+      try {
+        return fs32.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 {
+        ok: 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." + sessionPreservedNote
+      };
+    }
+    const entries = await listWorktrees2(repoRoot);
+    const managedEntry = entries.find((entry) => normalizePath(entry.path) === actualPath);
+    if (!managedEntry) return { ok: true };
+    if (managedEntry.branch && managedEntry.branch !== args.node.worktreeBranch) {
+      return {
+        ok: 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." + sessionPreservedNote
+      };
+    }
+    if (args.force !== true) {
+      const { execFile: execFile5 } = await import("child_process");
+      const { promisify: promisify8 } = await import("util");
+      const execFileAsync4 = promisify8(execFile5);
+      try {
+        const { stdout } = await execFileAsync4("git", ["status", "--porcelain"], {
+          cwd: workspace,
+          encoding: "utf8",
+          timeout: 3e4,
+          maxBuffer: 4 * 1024 * 1024,
+          windowsHide: true
+        });
+        if (stdout.trim()) {
+          return {
+            ok: false,
+            code: "mesh_worktree_cleanup_dirty",
+            error: `Refusing to remove dirty worktree: ${workspace}`,
+            recoveryHint: "Commit, stash, or intentionally discard the worktree changes before retrying mesh_remove_node. The mesh registry entry is preserved until cleanup is safe." + sessionPreservedNote
+          };
+        }
+      } catch {
+        return { ok: true };
+      }
+    }
+    return { ok: true };
+  }
   async cleanupLocalWorktreeNode(args) {
     const workspace = typeof args.node?.workspace === "string" ? args.node.workspace.trim() : "";
     if (!workspace) {