@adhdev/daemon-core 0.9.82-rc.89 → 0.9.82-rc.90

package/dist/index.mjs

@@ -8454,6 +8454,23 @@ var MESH_REFINE_CONFIG_SCHEMA = {
               env: { type: "object", additionalProperties: { type: "string" } }
             }
           }
+        },
+        bootstrapCommands: {
+          type: "array",
+          maxItems: 4,
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["command"],
+            properties: {
+              command: { type: "string", minLength: 1 },
+              args: { type: "array", items: { type: "string" } },
+              category: { enum: [...MESH_REFINE_VALIDATION_CATEGORIES, "custom"] },
+              cwd: { type: "string" },
+              timeoutMs: { type: "number", minimum: 1e3, maximum: 6e5 },
+              env: { type: "object", additionalProperties: { type: "string" } }
+            }
+          }
         }
       }
     }
@@ -8520,9 +8537,10 @@ function normalizeCommandConfig(entry, source) {
 }
 function validateMeshRefineConfig(config, source = "inline") {
   const errors = [];
+  const bootstrapCommands = [];
   const commands = [];
   const rejectedCommands = [];
-  if (!isRecord(config)) return { valid: false, errors: ["config must be an object"], commands, rejectedCommands };
+  if (!isRecord(config)) return { valid: false, errors: ["config must be an object"], bootstrapCommands, commands, rejectedCommands };
   if (config.version !== 1) errors.push("version must be 1");
   if (config.allowAutoPublishSubmoduleMainCommits !== void 0 && typeof config.allowAutoPublishSubmoduleMainCommits !== "boolean") {
     errors.push("allowAutoPublishSubmoduleMainCommits must be a boolean when provided");
@@ -8530,7 +8548,16 @@ function validateMeshRefineConfig(config, source = "inline") {
   const validation = config.validation;
   if (validation !== void 0 && !isRecord(validation)) errors.push("validation must be an object");
   const rawCommands = isRecord(validation) ? validation.commands : void 0;
+  const rawBootstrapCommands = isRecord(validation) ? validation.bootstrapCommands : void 0;
   if (rawCommands !== void 0 && !Array.isArray(rawCommands)) errors.push("validation.commands must be an array");
+  if (rawBootstrapCommands !== void 0 && !Array.isArray(rawBootstrapCommands)) errors.push("validation.bootstrapCommands must be an array");
+  if (Array.isArray(rawBootstrapCommands)) {
+    rawBootstrapCommands.forEach((entry, index) => {
+      const normalized = normalizeCommandConfig(entry, `${source}:validation.bootstrapCommands[${index}]`);
+      if (normalized.command) bootstrapCommands.push(normalized.command);
+      if (normalized.rejected) rejectedCommands.push(normalized.rejected);
+    });
+  }
   if (Array.isArray(rawCommands)) {
     rawCommands.forEach((entry, index) => {
       const normalized = normalizeCommandConfig(entry, `${source}:validation.commands[${index}]`);
@@ -8539,7 +8566,7 @@ function validateMeshRefineConfig(config, source = "inline") {
     });
   }
   if (rejectedCommands.length) errors.push("one or more validation commands are invalid");
-  return { valid: errors.length === 0, errors, commands, rejectedCommands };
+  return { valid: errors.length === 0, errors, bootstrapCommands, commands, rejectedCommands };
 }
 function parseConfigText(path28, text) {
   if (/\.json$/i.test(path28)) return JSON.parse(text);
@@ -8624,6 +8651,7 @@ function resolveMeshRefineValidationPlan(mesh, workspace) {
     return {
       source: loaded.source,
       sourceType: loaded.sourceType,
+      bootstrapCommands: [],
       commands: [],
       rejectedCommands: loaded.error ? [{ source: loaded.source, reason: loaded.error }] : [],
       suggestions: suggestion.suggestions,
@@ -8635,6 +8663,7 @@ function resolveMeshRefineValidationPlan(mesh, workspace) {
   return {
     source: loaded.path || loaded.source,
     sourceType: loaded.sourceType,
+    bootstrapCommands: validation.bootstrapCommands,
     commands: validation.commands,
     rejectedCommands: validation.rejectedCommands,
     suggestions: suggestion.suggestions,
@@ -26787,6 +26816,17 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
       });
       return { stdout: String(stdout || ""), stderr: String(stderr || ""), refspec };
     };
+    const importCommitFromWorktreeSubmodule = async (submodulePath, worktreeSubmodulePath, commit) => {
+      if (!fs11.existsSync(worktreeSubmodulePath)) return false;
+      try {
+        await runGit2(worktreeSubmodulePath, ["cat-file", "-e", `${commit}^{commit}`]);
+      } catch {
+        return false;
+      }
+      await runGit2(submodulePath, ["-c", "protocol.file.allow=always", "fetch", worktreeSubmodulePath, commit]);
+      await runGit2(submodulePath, ["cat-file", "-e", `${commit}^{commit}`]);
+      return true;
+    };
     const treeOutput = await runGit2(repoRoot, ["ls-tree", "-r", "-z", mergedTree]);
     const gitlinks = treeOutput.split("\0").filter(Boolean).map((record) => {
       const match = /^160000\s+commit\s+([0-9a-f]{40})\t(.+)$/.exec(record);
@@ -26803,6 +26843,11 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
         if (!fs11.existsSync(submodulePath)) {
           entry.error = `Submodule checkout missing at ${gitlink.path}`;
           entry.publishRequired = true;
+          if (options.allowAutoPublishSubmoduleMainCommits === true) {
+            entry.autoPublishAllowed = true;
+            entry.autoPublishAttempted = false;
+            entry.autoPublishSkippedReason = `submodule checkout missing at ${gitlink.path}; cannot perform non-force push to origin/main`;
+          }
           entries.push(entry);
           continue;
         }
@@ -26812,6 +26857,21 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
           entry.localReachable = true;
         } catch {
           entry.localReachable = false;
+          if (options.allowAutoPublishSubmoduleMainCommits === true && options.worktreeRoot) {
+            try {
+              const imported = await importCommitFromWorktreeSubmodule(
+                submodulePath,
+                pathResolve(options.worktreeRoot, gitlink.path),
+                gitlink.commit
+              );
+              if (imported) {
+                entry.localReachable = true;
+                entry.importedFromWorktree = true;
+              }
+            } catch (importError) {
+              entry.autoPublishSkippedReason = `candidate commit was not present in the source checkout and could not be imported from worktree submodule: ${truncateValidationOutput(importError?.stderr || importError?.message || String(importError))}`;
+            }
+          }
         }
         try {
           entry.remote = "origin";
@@ -26823,6 +26883,11 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
           } catch {
             entry.error = "Submodule remote reachability check failed: no configured origin remote";
             entry.publishRequired = true;
+            if (options.allowAutoPublishSubmoduleMainCommits === true) {
+              entry.autoPublishAllowed = true;
+              entry.autoPublishAttempted = false;
+              entry.autoPublishSkippedReason = "submodule origin remote is not configured; cannot perform non-force push to origin/main";
+            }
             entries.push(entry);
             continue;
           }
@@ -26862,6 +26927,10 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
                 const publishDetails = truncateValidationOutput(publishError?.stderr || publishError?.message || String(publishError));
                 entry.error = `Submodule auto-publish to origin/main failed or could not be verified: ${publishDetails}`;
               }
+            } else if (options.allowAutoPublishSubmoduleMainCommits === true) {
+              entry.autoPublishAllowed = true;
+              entry.autoPublishAttempted = false;
+              entry.autoPublishSkippedReason = entry.autoPublishSkippedReason || "candidate commit is not reachable in the source checkout or worktree submodule, so Refinery cannot push it to origin/main";
             }
           }
         } catch (e) {
@@ -26903,16 +26972,18 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
 }
 function buildMeshRefineValidationPlan(mesh, workspace) {
   const plan = resolveMeshRefineValidationPlan(mesh, workspace);
+  const mapCommand = (command) => ({
+    displayCommand: command.displayCommand,
+    category: command.category,
+    source: command.source,
+    cwd: command.cwd,
+    timeoutMs: command.timeoutMs
+  });
   return {
     source: plan.source,
     sourceType: plan.sourceType,
-    commands: plan.commands.map((command) => ({
-      displayCommand: command.displayCommand,
-      category: command.category,
-      source: command.source,
-      cwd: command.cwd,
-      timeoutMs: command.timeoutMs
-    })),
+    bootstrapCommands: plan.bootstrapCommands.map(mapCommand),
+    commands: plan.commands.map(mapCommand),
     unavailableReason: plan.unavailableReason,
     rejectedCommands: plan.rejectedCommands,
     suggestions: plan.suggestions,
@@ -26929,6 +27000,7 @@ async function runMeshRefineValidationGate(mesh, workspace) {
     status: "skipped",
     required: true,
     commandsRun: [],
+    bootstrapCommandsRun: [],
     rejectedCommands: selection.rejectedCommands,
     skippedReason: void 0,
     timeoutMs: REFINE_VALIDATION_TIMEOUT_MS,
@@ -26942,7 +27014,29 @@ async function runMeshRefineValidationGate(mesh, workspace) {
     summary.skippedReason = selection.unavailableReason || "validation_unavailable: repo mesh/refine config did not provide executable validation.commands";
     return summary;
   }
-  for (const candidate of selection.commands) {
+  const commandRecord = (candidate, cwd, startedAt, result, passed, extras = {}) => ({
+    command: candidate.command,
+    args: candidate.args,
+    displayCommand: candidate.displayCommand,
+    category: candidate.category,
+    source: candidate.source,
+    cwd,
+    passed,
+    durationMs: Date.now() - startedAt,
+    stdout: truncateValidationOutput(result?.stdout),
+    stderr: truncateValidationOutput(result?.stderr || result?.message),
+    ...extras
+  });
+  const isPackageManagerValidation = (candidate) => {
+    const command = pathBasename(candidate.command).replace(/\.(?:cmd|exe)$/i, "");
+    return ["npm", "pnpm", "yarn", "bun"].includes(command) && candidate.args.some((arg) => arg === "run" || arg === "test" || arg === "exec");
+  };
+  const dependenciesLikelyMissing = (cwd) => {
+    if (!fs11.existsSync(pathJoin(cwd, "package.json"))) return false;
+    if (fs11.existsSync(pathJoin(cwd, "node_modules"))) return false;
+    return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs11.existsSync(pathJoin(cwd, lock)));
+  };
+  for (const candidate of selection.bootstrapCommands) {
     const startedAt = Date.now();
     const cwd = candidate.cwd ? pathResolve(workspace, candidate.cwd) : workspace;
     const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
@@ -26954,36 +27048,60 @@ async function runMeshRefineValidationGate(mesh, workspace) {
         maxBuffer: REFINE_VALIDATION_OUTPUT_LIMIT_BYTES,
         env: { ...process.env, CI: process.env.CI || "1", ...candidate.env || {} }
       });
-      summary.commandsRun.push({
-        command: candidate.command,
-        args: candidate.args,
-        displayCommand: candidate.displayCommand,
-        category: candidate.category,
-        source: candidate.source,
+      summary.bootstrapCommandsRun.push(commandRecord(candidate, cwd, startedAt, result, true, { exitCode: 0 }));
+    } catch (error) {
+      summary.bootstrapCommandsRun.push(commandRecord(candidate, cwd, startedAt, error, false, {
+        exitCode: typeof error?.code === "number" ? error.code : null,
+        signal: typeof error?.signal === "string" ? error.signal : null,
+        timedOut: error?.killed === true || /timed out/i.test(String(error?.message || "")),
+        failureKind: "dependency_bootstrap_failed"
+      }));
+      summary.status = "failed";
+      summary.failureKind = "dependency_bootstrap_failed";
+      summary.failureCode = "dependency_bootstrap_failed";
+      return summary;
+    }
+  }
+  for (const candidate of selection.commands) {
+    const startedAt = Date.now();
+    const cwd = candidate.cwd ? pathResolve(workspace, candidate.cwd) : workspace;
+    const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
+    if (selection.bootstrapCommands.length === 0 && isPackageManagerValidation(candidate) && dependenciesLikelyMissing(cwd)) {
+      summary.commandsRun.push(commandRecord(candidate, cwd, startedAt, {
+        stderr: "Dependencies appear to be missing: package.json and a lockfile are present, but node_modules is absent. Configure validation.bootstrapCommands in repo mesh/refine config if Refinery should install/bootstrap before validation."
+      }, false, {
+        exitCode: null,
+        skipped: true,
+        failureKind: "missing_dependencies"
+      }));
+      summary.status = "failed";
+      summary.failureKind = "missing_dependencies";
+      summary.failureCode = "missing_dependencies";
+      return summary;
+    }
+    try {
+      const result = await execFileAsync3(candidate.command, candidate.args, {
         cwd,
-        passed: true,
-        exitCode: 0,
-        durationMs: Date.now() - startedAt,
-        stdout: truncateValidationOutput(result.stdout),
-        stderr: truncateValidationOutput(result.stderr)
+        encoding: "utf8",
+        timeout,
+        maxBuffer: REFINE_VALIDATION_OUTPUT_LIMIT_BYTES,
+        env: { ...process.env, CI: process.env.CI || "1", ...candidate.env || {} }
       });
+      summary.commandsRun.push(commandRecord(candidate, cwd, startedAt, result, true, { exitCode: 0 }));
     } catch (error) {
-      summary.commandsRun.push({
-        command: candidate.command,
-        args: candidate.args,
-        displayCommand: candidate.displayCommand,
-        category: candidate.category,
-        source: candidate.source,
-        cwd,
-        passed: false,
+      const stderr = truncateValidationOutput(error?.stderr || error?.message);
+      const missingDependencyFailure = /Cannot find module|MODULE_NOT_FOUND|node_modules|command not found|not found/i.test(stderr);
+      summary.commandsRun.push(commandRecord(candidate, cwd, startedAt, error, false, {
         exitCode: typeof error?.code === "number" ? error.code : null,
         signal: typeof error?.signal === "string" ? error.signal : null,
         timedOut: error?.killed === true || /timed out/i.test(String(error?.message || "")),
-        durationMs: Date.now() - startedAt,
-        stdout: truncateValidationOutput(error?.stdout),
-        stderr: truncateValidationOutput(error?.stderr || error?.message)
-      });
+        ...missingDependencyFailure ? { failureKind: "missing_dependencies" } : {}
+      }));
       summary.status = "failed";
+      if (missingDependencyFailure) {
+        summary.failureKind = "missing_dependencies";
+        summary.failureCode = "missing_dependencies";
+      }
       return summary;
     }
   }
@@ -27967,9 +28085,9 @@ var DaemonCommandRouter = class {
       if (validationSummary.status === "failed") {
         return {
           success: false,
-          code: "validation_failed",
+          code: validationSummary.failureCode || "validation_failed",
           convergenceStatus: "blocked_review",
-          error: "Refinery validation gate failed; merge/refine was not attempted.",
+          error: validationSummary.failureCode === "missing_dependencies" ? "Refinery validation dependencies are missing; merge/refine was not attempted. Configure validation.bootstrapCommands if Refinery should bootstrap dependencies before validation." : validationSummary.failureCode === "dependency_bootstrap_failed" ? "Refinery dependency/bootstrap command failed; merge/refine was not attempted." : "Refinery validation gate failed; merge/refine was not attempted.",
           branch,
           into: baseBranch,
           validationSummary,
@@ -28038,7 +28156,8 @@ var DaemonCommandRouter = class {
       const autoPublishSubmoduleMainCommits = resolveRefineryAutoPublishSubmoduleMainCommits(mesh, node.workspace);
       const submoduleReachability = await runMeshRefineSubmoduleReachabilityGate(repoRoot, patchEquivalence.mergedTree || branchHead, {
         allowAutoPublishSubmoduleMainCommits: autoPublishSubmoduleMainCommits.enabled,
-        autoPublishPolicySource: autoPublishSubmoduleMainCommits.source
+        autoPublishPolicySource: autoPublishSubmoduleMainCommits.source,
+        worktreeRoot: node.workspace
       });
       recordMeshRefineStage(refineStages, "submodule_reachability", submoduleReachability.status, submoduleReachabilityStarted, {
         checked: submoduleReachability.checked,
@@ -28056,6 +28175,14 @@ var DaemonCommandRouter = class {
           remoteMainReachable: entry.remoteMainReachable,
           error: entry.error
         })),
+        autoPublishSkipped: submoduleReachability.entries.filter((entry) => entry.autoPublishAllowed === true && entry.autoPublishAttempted !== true).map((entry) => ({
+          path: entry.path,
+          commit: entry.commit,
+          remote: entry.remote,
+          remoteUrl: entry.remoteUrl,
+          remoteMainBranch: entry.remoteMainBranch,
+          reason: entry.autoPublishSkippedReason || entry.error || "auto-publish was allowed but no publish attempt was possible"
+        })),
         unreachable: submoduleReachability.unreachable.map((entry) => ({
           path: entry.path,
           commit: entry.commit,
@@ -28065,6 +28192,7 @@ var DaemonCommandRouter = class {
           autoPublishSucceeded: entry.autoPublishSucceeded,
           autoPublishVerified: entry.autoPublishVerified,
           autoPublishRefspec: entry.autoPublishRefspec,
+          autoPublishSkippedReason: entry.autoPublishSkippedReason,
           remote: entry.remote,
           remoteUrl: entry.remoteUrl,
           remoteReachable: entry.remoteReachable,
@@ -28103,6 +28231,7 @@ var DaemonCommandRouter = class {
             autoPublishSucceeded: entry.autoPublishSucceeded,
             autoPublishVerified: entry.autoPublishVerified,
             autoPublishRefspec: entry.autoPublishRefspec,
+            autoPublishSkippedReason: entry.autoPublishSkippedReason,
             error: entry.error
           })),
           branch,
@@ -29890,8 +30019,9 @@ ${block2}`);
           if (!mesh) return { success: false, error: "Mesh not found" };
           const meshHost = resolveMeshHostStatus(mesh);
           const refreshRequested = args?.refresh === true || args?.forceRefresh === true;
+          const pendingCoordinatorEventCount = getPendingMeshCoordinatorEvents(meshId).length;
           const hadAggregateCache = this.aggregateMeshStatusCache.has(meshId);
-          if (!refreshRequested) {
+          if (!refreshRequested && pendingCoordinatorEventCount === 0) {
             const cachedStatus = this.getCachedAggregateMeshStatus(meshId, mesh, { requireDirectPeerTruth: args?.requireDirectPeerTruth === true });
             if (cachedStatus) {
               logRepoMeshStatusDebug("return_cached", {
@@ -29903,7 +30033,7 @@ ${block2}`);
               return cachedStatus;
             }
           }
-          const refreshReason = refreshRequested ? "explicit_refresh" : hadAggregateCache ? "stale_pending_cache_refresh" : "cold_cache_miss";
+          const refreshReason = refreshRequested ? "explicit_refresh" : pendingCoordinatorEventCount > 0 ? "pending_coordinator_events" : hadAggregateCache ? "stale_pending_cache_refresh" : "cold_cache_miss";
           const { getMeshQueueStats: getMeshQueueStats2, getQueue: getQueue2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
           const queue = getQueue2(meshId);
           const queueSummary = getMeshQueueStats2(meshId);
@@ -29929,7 +30059,9 @@ ${block2}`);
           };
           const passivePeerTruthNotAttempted = requireDirectPeerTruth && !refreshRequested && directTruth.directEvidenceCount > 0 && directTruth.peerAttemptedCount === 0;
           const effectiveDirectTruth = passivePeerTruthNotAttempted ? { ...directTruth, unavailableNodeIds: [] } : directTruth;
-          const directTruthSatisfied = !requireDirectPeerTruth || effectiveDirectTruth.directEvidenceCount > 0;
+          const unavailableDirectTruthNodeIds = new Set(effectiveDirectTruth.unavailableNodeIds);
+          const unavailableNodesAreOnlyRemovedWorktrees = unavailableDirectTruthNodeIds.size > 0 && Array.isArray(mesh.nodes) && mesh.nodes.filter((node) => unavailableDirectTruthNodeIds.has(String(node.id || node.nodeId || ""))).every((node) => node?.isLocalWorktree === true);
+          const directTruthSatisfied = !requireDirectPeerTruth || effectiveDirectTruth.directEvidenceCount > 0 && (effectiveDirectTruth.unavailableNodeIds.length === 0 || unavailableNodesAreOnlyRemovedWorktrees);
           if (requireDirectPeerTruth && !directTruthSatisfied) {
             const failureResult = {
               success: false,
@@ -30160,6 +30292,7 @@ ${block2}`);
             finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode });
             nodeStatuses.push(status);
           }
+          const pendingCoordinatorEvents = drainPendingMeshCoordinatorEvents(meshId);
           const statusResult = {
             success: true,
             meshId: mesh.id,
@@ -30196,9 +30329,12 @@ ${block2}`);
             branchConvergenceSummary: summarizeInlineMeshBranchConvergence(nodeStatuses),
             nodes: nodeStatuses,
             queue: { tasks: queue, summary: queueSummary },
-            ledger: { entries: ledgerEntries, summary: ledgerSummary }
+            ledger: { entries: ledgerEntries, summary: ledgerSummary },
+            ...pendingCoordinatorEvents.length > 0 ? { pendingCoordinatorEvents } : {}
           };
-          const rememberedStatus = this.rememberAggregateMeshStatus(meshId, statusResult, refreshReason);
+          const { pendingCoordinatorEvents: _pendingCoordinatorEvents, ...cacheableStatusResult } = statusResult;
+          const rememberedStatus = this.rememberAggregateMeshStatus(meshId, cacheableStatusResult, refreshReason);
+          const returnedStatus = pendingCoordinatorEvents.length > 0 ? { ...rememberedStatus, pendingCoordinatorEvents } : rememberedStatus;
           logRepoMeshStatusDebug("return_live", {
             meshId,
             command: "mesh_status",
@@ -30206,9 +30342,9 @@ ${block2}`);
             refreshReason,
             meshSource: meshRecord.source,
             directTruth,
-            summary: summarizeRepoMeshStatusDebug(rememberedStatus)
+            summary: summarizeRepoMeshStatusDebug(returnedStatus)
           });
-          return rememberedStatus;
+          return returnedStatus;
         } catch (e) {
           return { success: false, error: e.message };
         }