@adhdev/daemon-core 0.9.82-rc.59 → 0.9.82-rc.60

package/dist/commands/router.d.ts

@@ -89,6 +89,10 @@ export declare class DaemonCommandRouter {
     private inlineMeshCache;
     /** Coordinator-owned whole-mesh aggregate status snapshots. Browser callers read this by default. */
     private aggregateMeshStatusCache;
+    /** In-memory async Refinery jobs keyed by meshId:nodeId to reject/return duplicate in-flight requests. */
+    private runningRefineJobs;
+    /** Terminal async Refinery jobs preserve a clear answer after the worktree node has been removed. */
+    private terminalRefineJobs;
     constructor(deps: CommandRouterDeps);
     private cloneJsonValue;
     private hydrateCachedAggregateMeshStatusFromInline;
@@ -121,6 +125,13 @@ export declare class DaemonCommandRouter {
      * @param source Log source ('ws' | 'p2p' | 'standalone' | etc.)
      */
     execute(cmd: string, args: any, source?: string): Promise<CommandRouterResult>;
+    private buildRefineJobKey;
+    private buildRefineJobHandle;
+    private queueRefineJobEvent;
+    private appendRefineJobLedger;
+    private executeMeshRefineNodeSynchronously;
+    private finishMeshRefineJob;
+    private startMeshRefineJob;
     /**
      * Daemon-level command execution (IDE start/stop/restart, CLI, detect, logs).
      * Returns null if not handled at this level → caller delegates to CommandHandler.

package/dist/index.js

@@ -26254,6 +26254,10 @@ var DaemonCommandRouter = class {
   inlineMeshCache = /* @__PURE__ */ new Map();
   /** Coordinator-owned whole-mesh aggregate status snapshots. Browser callers read this by default. */
   aggregateMeshStatusCache = /* @__PURE__ */ new Map();
+  /** In-memory async Refinery jobs keyed by meshId:nodeId to reject/return duplicate in-flight requests. */
+  runningRefineJobs = /* @__PURE__ */ new Map();
+  /** Terminal async Refinery jobs preserve a clear answer after the worktree node has been removed. */
+  terminalRefineJobs = /* @__PURE__ */ new Map();
   constructor(deps) {
     this.deps = deps;
   }
@@ -26883,6 +26887,340 @@ var DaemonCommandRouter = class {
       throw e;
     }
   }
+  buildRefineJobKey(meshId, nodeId) {
+    return `${meshId}:${nodeId}`;
+  }
+  buildRefineJobHandle(args) {
+    return {
+      success: true,
+      async: true,
+      status: args.status || "accepted",
+      jobId: args.jobId || `refine_${createInteractionId()}`,
+      interactionId: args.interactionId || createInteractionId(),
+      meshId: args.meshId,
+      nodeId: args.nodeId,
+      targetNodeId: args.nodeId,
+      targetDaemonId: readStringValue(args.node?.daemonId),
+      workspace: readStringValue(args.node?.workspace),
+      startedAt: args.startedAt || (/* @__PURE__ */ new Date()).toISOString(),
+      ...args.completedAt ? { completedAt: args.completedAt } : {},
+      eventDelivery: { pendingEvents: true, ledger: true },
+      evidence: {
+        pendingEventsCommand: "get_pending_mesh_events",
+        ledgerCommand: "get_mesh_ledger_slice",
+        taskHistoryKind: args.status === "completed" ? "task_completed" : args.status === "failed" ? "task_failed" : "task_dispatched"
+      }
+    };
+  }
+  queueRefineJobEvent(event, handle, result) {
+    queuePendingMeshCoordinatorEvent({
+      event,
+      meshId: handle.meshId,
+      nodeLabel: handle.targetNodeId,
+      nodeId: handle.targetNodeId,
+      workspace: handle.workspace,
+      metadataEvent: {
+        source: "refine_mesh_node_async_job",
+        jobId: handle.jobId,
+        interactionId: handle.interactionId,
+        meshId: handle.meshId,
+        nodeId: handle.targetNodeId,
+        targetDaemonId: handle.targetDaemonId,
+        workspace: handle.workspace,
+        status: handle.status,
+        startedAt: handle.startedAt,
+        completedAt: handle.completedAt,
+        ...result ? { result } : {}
+      },
+      queuedAt: Date.now()
+    });
+  }
+  async appendRefineJobLedger(kind, handle, result) {
+    try {
+      const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+      appendLedgerEntry2(handle.meshId, {
+        kind,
+        nodeId: handle.targetNodeId,
+        payload: {
+          source: "refine_mesh_node_async_job",
+          refineJob: {
+            jobId: handle.jobId,
+            interactionId: handle.interactionId,
+            status: handle.status,
+            meshId: handle.meshId,
+            nodeId: handle.targetNodeId,
+            targetDaemonId: handle.targetDaemonId,
+            workspace: handle.workspace,
+            startedAt: handle.startedAt,
+            completedAt: handle.completedAt
+          },
+          async: true,
+          ...result ? {
+            success: result.success === true,
+            result,
+            finalBranchConvergenceState: result.finalBranchConvergenceState
+          } : {}
+        }
+      });
+    } catch (e) {
+      LOG.warn("Mesh", `[Refinery] Failed to append async refine ledger entry: ${e?.message || e}`);
+    }
+  }
+  async executeMeshRefineNodeSynchronously(meshId, nodeId, args) {
+    const refineStages = [];
+    try {
+      const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh);
+      const mesh = meshRecord?.mesh;
+      const node = mesh?.nodes?.find((n) => n.id === nodeId || n.nodeId === nodeId);
+      if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh`, refineStages };
+      if (!node.isLocalWorktree || !node.workspace) {
+        return { success: false, error: `Refinery requires a local worktree node`, refineStages };
+      }
+      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) return { success: false, error: "Source node repoRoot not found", refineStages };
+      const { execFile: execFile3 } = await import("child_process");
+      const { promisify: promisify3 } = await import("util");
+      const execFileAsync3 = promisify3(execFile3);
+      const resolveStarted = Date.now();
+      const { stdout: branchStdout } = await execFileAsync3("git", ["branch", "--show-current"], { cwd: node.workspace, encoding: "utf8" });
+      const branch = branchStdout.trim();
+      if (!branch) return { success: false, error: "Could not determine branch of the worktree node", refineStages };
+      const { stdout: baseBranchStdout } = await execFileAsync3("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8" });
+      const baseBranch = baseBranchStdout.trim();
+      const { stdout: baseHeadStdout } = await execFileAsync3("git", ["rev-parse", "HEAD"], { cwd: repoRoot, encoding: "utf8" });
+      const { stdout: branchHeadStdout } = await execFileAsync3("git", ["rev-parse", branch], { cwd: node.workspace, encoding: "utf8" });
+      const baseHead = baseHeadStdout.trim();
+      const branchHead = branchHeadStdout.trim();
+      recordMeshRefineStage(refineStages, "resolve_refs", "passed", resolveStarted, { branch, baseBranch, baseHead, branchHead });
+      const validationStarted = Date.now();
+      const validationSummary = await runMeshRefineValidationGate(mesh, node.workspace);
+      recordMeshRefineStage(
+        refineStages,
+        "validation",
+        validationSummary.status === "passed" ? "passed" : validationSummary.status === "failed" ? "failed" : "skipped",
+        validationStarted,
+        { validationStatus: validationSummary.status, commandsRun: validationSummary.commandsRun.length }
+      );
+      if (validationSummary.status === "failed") {
+        return {
+          success: false,
+          code: "validation_failed",
+          convergenceStatus: "blocked_review",
+          error: "Refinery validation gate failed; merge/refine was not attempted.",
+          branch,
+          into: baseBranch,
+          validationSummary,
+          refineStages,
+          finalBranchConvergenceState: {
+            branch,
+            baseBranch,
+            merged: false,
+            removed: false,
+            validation: "failed",
+            status: "blocked_review"
+          }
+        };
+      }
+      if (validationSummary.status === "skipped") {
+        return {
+          success: false,
+          code: "validation_unavailable",
+          convergenceStatus: "blocked_review",
+          error: "Refinery validation gate is required but no allowlisted validation command was available; merge/refine was not attempted.",
+          branch,
+          into: baseBranch,
+          validationSummary,
+          refineStages,
+          finalBranchConvergenceState: {
+            branch,
+            baseBranch,
+            merged: false,
+            removed: false,
+            validation: "unavailable",
+            status: "blocked_review"
+          }
+        };
+      }
+      const patchEquivalenceStarted = Date.now();
+      const patchEquivalence = await runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead);
+      recordMeshRefineStage(refineStages, "patch_equivalence", patchEquivalence.status, patchEquivalenceStarted, {
+        equivalent: patchEquivalence.equivalent,
+        expectedPatchId: patchEquivalence.expectedPatchId,
+        actualPatchId: patchEquivalence.actualPatchId,
+        error: patchEquivalence.error
+      });
+      if (!patchEquivalence.equivalent) {
+        return {
+          success: false,
+          code: "patch_equivalence_failed",
+          convergenceStatus: "blocked_review",
+          error: "Refinery patch-equivalence preflight failed; merge/refine was not attempted.",
+          branch,
+          into: baseBranch,
+          validationSummary,
+          patchEquivalence,
+          refineStages,
+          finalBranchConvergenceState: {
+            branch,
+            baseBranch,
+            merged: false,
+            removed: false,
+            validation: "passed",
+            patchEquivalence: "failed",
+            status: "blocked_review"
+          }
+        };
+      }
+      let mergeResult;
+      const mergeStarted = Date.now();
+      try {
+        const result = await execFileAsync3("git", ["merge", "--no-ff", branch, "-m", `Auto-merge branch '${branch}' via Refinery`], { cwd: repoRoot, encoding: "utf8" });
+        mergeResult = {
+          stdout: truncateValidationOutput(result.stdout),
+          stderr: truncateValidationOutput(result.stderr),
+          durationMs: Date.now() - mergeStarted
+        };
+        recordMeshRefineStage(refineStages, "merge", "passed", mergeStarted, mergeResult);
+      } catch (e) {
+        recordMeshRefineStage(refineStages, "merge", "failed", mergeStarted, {
+          error: e?.message || String(e),
+          stdout: truncateValidationOutput(e?.stdout),
+          stderr: truncateValidationOutput(e?.stderr)
+        });
+        return {
+          success: false,
+          error: `Merge failed (conflicts?): ${e.message}`,
+          validationSummary,
+          patchEquivalence,
+          refineStages,
+          finalBranchConvergenceState: {
+            branch,
+            baseBranch,
+            merged: false,
+            removed: false,
+            validation: "passed",
+            patchEquivalence: "passed",
+            status: "not_mergeable"
+          }
+        };
+      }
+      const cleanupStarted = Date.now();
+      const removeResult = await this.execute("remove_mesh_node", {
+        meshId,
+        nodeId,
+        sessionCleanupMode: "preserve",
+        inlineMesh: args?.inlineMesh
+      });
+      recordMeshRefineStage(refineStages, "cleanup", removeResult?.success === false ? "failed" : "passed", cleanupStarted, {
+        removed: removeResult?.removed,
+        code: removeResult?.code,
+        error: removeResult?.error
+      });
+      let ledgerError;
+      const ledgerStarted = Date.now();
+      try {
+        const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+        appendLedgerEntry2(meshId, {
+          kind: "node_removed",
+          nodeId,
+          payload: { refined: true, mergedBranch: branch, into: baseBranch, validationSummary, patchEquivalence }
+        });
+        recordMeshRefineStage(refineStages, "ledger", "passed", ledgerStarted);
+      } catch (e) {
+        ledgerError = e?.message || String(e);
+        recordMeshRefineStage(refineStages, "ledger", "failed", ledgerStarted, { error: ledgerError });
+      }
+      const finalBranchConvergenceState = {
+        branch: baseBranch,
+        mergedBranch: branch,
+        baseBranch,
+        merged: true,
+        removed: removeResult?.success !== false,
+        validation: "passed",
+        patchEquivalence: "passed",
+        status: removeResult?.success === false ? "merged_cleanup_failed" : "merged"
+      };
+      if (removeResult?.success === false) {
+        return {
+          success: false,
+          code: "cleanup_failed",
+          error: "Refinery merge completed but worktree cleanup failed; manual cleanup/retry is required.",
+          merged: true,
+          branch,
+          into: baseBranch,
+          removeResult,
+          validationSummary,
+          patchEquivalence,
+          mergeResult,
+          refineStages,
+          ...ledgerError ? { ledgerError } : {},
+          finalBranchConvergenceState
+        };
+      }
+      return {
+        success: true,
+        merged: true,
+        branch,
+        into: baseBranch,
+        removeResult,
+        validationSummary,
+        patchEquivalence,
+        mergeResult,
+        refineStages,
+        ...ledgerError ? { ledgerError } : {},
+        finalBranchConvergenceState
+      };
+    } catch (e) {
+      return { success: false, error: e.message, refineStages };
+    }
+  }
+  async finishMeshRefineJob(handle, args) {
+    const key = this.buildRefineJobKey(handle.meshId, handle.targetNodeId);
+    let result;
+    try {
+      result = await this.executeMeshRefineNodeSynchronously(handle.meshId, handle.targetNodeId, args);
+    } catch (e) {
+      result = { success: false, error: e?.message || String(e) };
+    }
+    const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const terminalHandle = this.buildRefineJobHandle({
+      meshId: handle.meshId,
+      nodeId: handle.targetNodeId,
+      status: result.success === true ? "completed" : "failed",
+      startedAt: handle.startedAt,
+      completedAt,
+      jobId: handle.jobId,
+      interactionId: handle.interactionId,
+      node: { daemonId: handle.targetDaemonId, workspace: handle.workspace }
+    });
+    const terminal = { ...terminalHandle, result };
+    this.terminalRefineJobs.set(key, terminal);
+    this.runningRefineJobs.delete(key);
+    this.invalidateAggregateMeshStatus(handle.meshId);
+    await this.appendRefineJobLedger(result.success === true ? "task_completed" : "task_failed", terminalHandle, result);
+    this.queueRefineJobEvent(result.success === true ? "refine:completed" : "refine:failed", terminalHandle, result);
+  }
+  async startMeshRefineJob(meshId, nodeId, args) {
+    const key = this.buildRefineJobKey(meshId, nodeId);
+    const running = this.runningRefineJobs.get(key);
+    if (running) return { ...running, duplicate: true };
+    const terminal = this.terminalRefineJobs.get(key);
+    if (terminal) return { ...terminal, duplicate: true };
+    const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh);
+    const mesh = meshRecord?.mesh;
+    const node = mesh?.nodes?.find((n) => n.id === nodeId || n.nodeId === nodeId);
+    if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh` };
+    if (!node.isLocalWorktree || !node.workspace) return { success: false, error: `Refinery requires a local worktree node` };
+    const handle = this.buildRefineJobHandle({ meshId, nodeId, node });
+    this.runningRefineJobs.set(key, handle);
+    await this.appendRefineJobLedger("task_dispatched", handle);
+    this.queueRefineJobEvent("refine:accepted", handle);
+    setImmediate(() => {
+      void this.finishMeshRefineJob(handle, args);
+    });
+    return handle;
+  }
   // ─── Daemon-level command core ───────────────────
   /**
    * Daemon-level command execution (IDE start/stop/restart, CLI, detect, logs).
@@ -27968,213 +28306,7 @@ var DaemonCommandRouter = class {
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
         if (!meshId || !nodeId) return { success: false, error: "meshId and nodeId required" };
-        const refineStages = [];
-        try {
-          const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh);
-          const mesh = meshRecord?.mesh;
-          const node = mesh?.nodes?.find((n) => n.id === nodeId || n.nodeId === nodeId);
-          if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh`, refineStages };
-          if (!node.isLocalWorktree || !node.workspace) {
-            return { success: false, error: `Refinery requires a local worktree node`, refineStages };
-          }
-          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) return { success: false, error: "Source node repoRoot not found", refineStages };
-          const { execFile: execFile3 } = await import("child_process");
-          const { promisify: promisify3 } = await import("util");
-          const execFileAsync3 = promisify3(execFile3);
-          const resolveStarted = Date.now();
-          const { stdout: branchStdout } = await execFileAsync3("git", ["branch", "--show-current"], { cwd: node.workspace, encoding: "utf8" });
-          const branch = branchStdout.trim();
-          if (!branch) return { success: false, error: "Could not determine branch of the worktree node", refineStages };
-          const { stdout: baseBranchStdout } = await execFileAsync3("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8" });
-          const baseBranch = baseBranchStdout.trim();
-          const { stdout: baseHeadStdout } = await execFileAsync3("git", ["rev-parse", "HEAD"], { cwd: repoRoot, encoding: "utf8" });
-          const { stdout: branchHeadStdout } = await execFileAsync3("git", ["rev-parse", branch], { cwd: node.workspace, encoding: "utf8" });
-          const baseHead = baseHeadStdout.trim();
-          const branchHead = branchHeadStdout.trim();
-          recordMeshRefineStage(refineStages, "resolve_refs", "passed", resolveStarted, { branch, baseBranch, baseHead, branchHead });
-          const validationStarted = Date.now();
-          const validationSummary = await runMeshRefineValidationGate(mesh, node.workspace);
-          recordMeshRefineStage(
-            refineStages,
-            "validation",
-            validationSummary.status === "passed" ? "passed" : validationSummary.status === "failed" ? "failed" : "skipped",
-            validationStarted,
-            { validationStatus: validationSummary.status, commandsRun: validationSummary.commandsRun.length }
-          );
-          if (validationSummary.status === "failed") {
-            return {
-              success: false,
-              code: "validation_failed",
-              convergenceStatus: "blocked_review",
-              error: "Refinery validation gate failed; merge/refine was not attempted.",
-              branch,
-              into: baseBranch,
-              validationSummary,
-              refineStages,
-              finalBranchConvergenceState: {
-                branch,
-                baseBranch,
-                merged: false,
-                removed: false,
-                validation: "failed",
-                status: "blocked_review"
-              }
-            };
-          }
-          if (validationSummary.status === "skipped") {
-            return {
-              success: false,
-              code: "validation_unavailable",
-              convergenceStatus: "blocked_review",
-              error: "Refinery validation gate is required but no allowlisted validation command was available; merge/refine was not attempted.",
-              branch,
-              into: baseBranch,
-              validationSummary,
-              refineStages,
-              finalBranchConvergenceState: {
-                branch,
-                baseBranch,
-                merged: false,
-                removed: false,
-                validation: "unavailable",
-                status: "blocked_review"
-              }
-            };
-          }
-          const patchEquivalenceStarted = Date.now();
-          const patchEquivalence = await runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead);
-          recordMeshRefineStage(refineStages, "patch_equivalence", patchEquivalence.status, patchEquivalenceStarted, {
-            equivalent: patchEquivalence.equivalent,
-            expectedPatchId: patchEquivalence.expectedPatchId,
-            actualPatchId: patchEquivalence.actualPatchId,
-            error: patchEquivalence.error
-          });
-          if (!patchEquivalence.equivalent) {
-            return {
-              success: false,
-              code: "patch_equivalence_failed",
-              convergenceStatus: "blocked_review",
-              error: "Refinery patch-equivalence preflight failed; merge/refine was not attempted.",
-              branch,
-              into: baseBranch,
-              validationSummary,
-              patchEquivalence,
-              refineStages,
-              finalBranchConvergenceState: {
-                branch,
-                baseBranch,
-                merged: false,
-                removed: false,
-                validation: "passed",
-                patchEquivalence: "failed",
-                status: "blocked_review"
-              }
-            };
-          }
-          let mergeResult;
-          const mergeStarted = Date.now();
-          try {
-            const result = await execFileAsync3("git", ["merge", "--no-ff", branch, "-m", `Auto-merge branch '${branch}' via Refinery`], { cwd: repoRoot, encoding: "utf8" });
-            mergeResult = {
-              stdout: truncateValidationOutput(result.stdout),
-              stderr: truncateValidationOutput(result.stderr),
-              durationMs: Date.now() - mergeStarted
-            };
-            recordMeshRefineStage(refineStages, "merge", "passed", mergeStarted, mergeResult);
-          } catch (e) {
-            recordMeshRefineStage(refineStages, "merge", "failed", mergeStarted, {
-              error: e?.message || String(e),
-              stdout: truncateValidationOutput(e?.stdout),
-              stderr: truncateValidationOutput(e?.stderr)
-            });
-            return {
-              success: false,
-              error: `Merge failed (conflicts?): ${e.message}`,
-              validationSummary,
-              patchEquivalence,
-              refineStages,
-              finalBranchConvergenceState: {
-                branch,
-                baseBranch,
-                merged: false,
-                removed: false,
-                validation: "passed",
-                patchEquivalence: "passed",
-                status: "not_mergeable"
-              }
-            };
-          }
-          const cleanupStarted = Date.now();
-          const removeResult = await this.execute("remove_mesh_node", {
-            meshId,
-            nodeId,
-            sessionCleanupMode: "preserve",
-            inlineMesh: args?.inlineMesh
-          });
-          recordMeshRefineStage(refineStages, "cleanup", removeResult?.success === false ? "failed" : "passed", cleanupStarted, {
-            removed: removeResult?.removed,
-            code: removeResult?.code,
-            error: removeResult?.error
-          });
-          let ledgerError;
-          const ledgerStarted = Date.now();
-          try {
-            const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
-            appendLedgerEntry2(meshId, {
-              kind: "node_removed",
-              nodeId,
-              payload: { refined: true, mergedBranch: branch, into: baseBranch, validationSummary, patchEquivalence }
-            });
-            recordMeshRefineStage(refineStages, "ledger", "passed", ledgerStarted);
-          } catch (e) {
-            ledgerError = e?.message || String(e);
-            recordMeshRefineStage(refineStages, "ledger", "failed", ledgerStarted, { error: ledgerError });
-          }
-          const finalBranchConvergenceState = {
-            branch: baseBranch,
-            mergedBranch: branch,
-            baseBranch,
-            merged: true,
-            removed: removeResult?.success !== false,
-            validation: "passed",
-            patchEquivalence: "passed",
-            status: removeResult?.success === false ? "merged_cleanup_failed" : "merged"
-          };
-          if (removeResult?.success === false) {
-            return {
-              success: false,
-              code: "cleanup_failed",
-              error: "Refinery merge completed but worktree cleanup failed; manual cleanup/retry is required.",
-              merged: true,
-              branch,
-              into: baseBranch,
-              removeResult,
-              validationSummary,
-              patchEquivalence,
-              mergeResult,
-              refineStages,
-              ...ledgerError ? { ledgerError } : {},
-              finalBranchConvergenceState
-            };
-          }
-          return {
-            success: true,
-            merged: true,
-            branch,
-            into: baseBranch,
-            removeResult,
-            validationSummary,
-            patchEquivalence,
-            mergeResult,
-            refineStages,
-            ...ledgerError ? { ledgerError } : {},
-            finalBranchConvergenceState
-          };
-        } catch (e) {
-          return { success: false, error: e.message, refineStages };
-        }
+        return this.startMeshRefineJob(meshId, nodeId, args);
       }
       case "remove_mesh_node": {
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";