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

package/dist/index.js

@@ -30835,6 +30835,23 @@ ${lastSnapshot}`;
                   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" } }
+                }
+              }
             }
           }
         }
@@ -30901,9 +30918,10 @@ ${lastSnapshot}`;
     }
     function validateMeshRefineConfig(config2, source = "inline") {
       const errors = [];
+      const bootstrapCommands = [];
       const commands = [];
       const rejectedCommands = [];
-      if (!isRecord(config2)) return { valid: false, errors: ["config must be an object"], commands, rejectedCommands };
+      if (!isRecord(config2)) return { valid: false, errors: ["config must be an object"], bootstrapCommands, commands, rejectedCommands };
       if (config2.version !== 1) errors.push("version must be 1");
       if (config2.allowAutoPublishSubmoduleMainCommits !== void 0 && typeof config2.allowAutoPublishSubmoduleMainCommits !== "boolean") {
         errors.push("allowAutoPublishSubmoduleMainCommits must be a boolean when provided");
@@ -30911,7 +30929,16 @@ ${lastSnapshot}`;
       const validation = config2.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}]`);
@@ -30920,7 +30947,7 @@ ${lastSnapshot}`;
         });
       }
       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);
@@ -31005,6 +31032,7 @@ ${lastSnapshot}`;
         return {
           source: loaded.source,
           sourceType: loaded.sourceType,
+          bootstrapCommands: [],
           commands: [],
           rejectedCommands: loaded.error ? [{ source: loaded.source, reason: loaded.error }] : [],
           suggestions: suggestion.suggestions,
@@ -31016,6 +31044,7 @@ ${lastSnapshot}`;
       return {
         source: loaded.path || loaded.source,
         sourceType: loaded.sourceType,
+        bootstrapCommands: validation.bootstrapCommands,
         commands: validation.commands,
         rejectedCommands: validation.rejectedCommands,
         suggestions: suggestion.suggestions,
@@ -49013,6 +49042,17 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
           });
           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((record2) => {
           const match = /^160000\s+commit\s+([0-9a-f]{40})\t(.+)$/.exec(record2);
@@ -49029,6 +49069,11 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
             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;
             }
@@ -49038,6 +49083,21 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
               entry.localReachable = true;
             } catch {
               entry.localReachable = false;
+              if (options.allowAutoPublishSubmoduleMainCommits === true && options.worktreeRoot) {
+                try {
+                  const imported = await importCommitFromWorktreeSubmodule(
+                    submodulePath,
+                    (0, import_path8.resolve)(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";
@@ -49049,6 +49109,11 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
               } 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;
               }
@@ -49088,6 +49153,10 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                     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) {
@@ -49129,16 +49198,18 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
     }
     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,
@@ -49155,6 +49226,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         status: "skipped",
         required: true,
         commandsRun: [],
+        bootstrapCommandsRun: [],
         rejectedCommands: selection.rejectedCommands,
         skippedReason: void 0,
         timeoutMs: REFINE_VALIDATION_TIMEOUT_MS,
@@ -49168,7 +49240,29 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         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 = (0, import_path8.basename)(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((0, import_path8.join)(cwd, "package.json"))) return false;
+        if (fs11.existsSync((0, import_path8.join)(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((0, import_path8.join)(cwd, lock)));
+      };
+      for (const candidate of selection.bootstrapCommands) {
         const startedAt = Date.now();
         const cwd = candidate.cwd ? (0, import_path8.resolve)(workspace, candidate.cwd) : workspace;
         const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
@@ -49180,36 +49274,60 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
             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 (error48) {
+          summary.bootstrapCommandsRun.push(commandRecord(candidate, cwd, startedAt, error48, false, {
+            exitCode: typeof error48?.code === "number" ? error48.code : null,
+            signal: typeof error48?.signal === "string" ? error48.signal : null,
+            timedOut: error48?.killed === true || /timed out/i.test(String(error48?.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 ? (0, import_path8.resolve)(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 (error48) {
-          summary.commandsRun.push({
-            command: candidate.command,
-            args: candidate.args,
-            displayCommand: candidate.displayCommand,
-            category: candidate.category,
-            source: candidate.source,
-            cwd,
-            passed: false,
+          const stderr = truncateValidationOutput(error48?.stderr || error48?.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, error48, false, {
             exitCode: typeof error48?.code === "number" ? error48.code : null,
             signal: typeof error48?.signal === "string" ? error48.signal : null,
             timedOut: error48?.killed === true || /timed out/i.test(String(error48?.message || "")),
-            durationMs: Date.now() - startedAt,
-            stdout: truncateValidationOutput(error48?.stdout),
-            stderr: truncateValidationOutput(error48?.stderr || error48?.message)
-          });
+            ...missingDependencyFailure ? { failureKind: "missing_dependencies" } : {}
+          }));
           summary.status = "failed";
+          if (missingDependencyFailure) {
+            summary.failureKind = "missing_dependencies";
+            summary.failureCode = "missing_dependencies";
+          }
           return summary;
         }
       }
@@ -50193,9 +50311,9 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
           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,
@@ -50264,7 +50382,8 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
           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,
@@ -50282,6 +50401,14 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
               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,
@@ -50291,6 +50418,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
               autoPublishSucceeded: entry.autoPublishSucceeded,
               autoPublishVerified: entry.autoPublishVerified,
               autoPublishRefspec: entry.autoPublishRefspec,
+              autoPublishSkippedReason: entry.autoPublishSkippedReason,
               remote: entry.remote,
               remoteUrl: entry.remoteUrl,
               remoteReachable: entry.remoteReachable,
@@ -50329,6 +50457,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                 autoPublishSucceeded: entry.autoPublishSucceeded,
                 autoPublishVerified: entry.autoPublishVerified,
                 autoPublishRefspec: entry.autoPublishRefspec,
+                autoPublishSkippedReason: entry.autoPublishSkippedReason,
                 error: entry.error
               })),
               branch,
@@ -52116,8 +52245,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", {
@@ -52129,7 +52259,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);
@@ -52155,7 +52285,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,
@@ -52386,6 +52518,7 @@ ${block2}`);
                 finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode });
                 nodeStatuses.push(status);
               }
+              const pendingCoordinatorEvents = drainPendingMeshCoordinatorEvents(meshId);
               const statusResult = {
                 success: true,
                 meshId: mesh.id,
@@ -52422,9 +52555,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",
@@ -52432,9 +52568,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 };
             }