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

package/dist/index.js

@@ -48226,6 +48226,10 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       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;
       }
@@ -48855,6 +48859,340 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
           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) {
+          LOG2.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).
@@ -49940,213 +50278,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
             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() : "";