@adhdev/daemon-core 0.9.82-rc.82 → 0.9.82-rc.83

package/dist/index.mjs

@@ -34,6 +34,7 @@ var init_repo_mesh_types = __esm({
       requirePreTaskCheckpoint: false,
       requirePostTaskCheckpoint: true,
       requireApprovalForPush: true,
+      allowAutoPublishSubmoduleMainCommits: false,
       requireApprovalForDestructiveGit: true,
       dirtyWorkspaceBehavior: "warn",
       maxParallelTasks: 2,
@@ -787,6 +788,7 @@ function mergeMeshPolicy(base, patch) {
   }
   const maxParallelTasks = Number(policy.maxParallelTasks);
   policy.maxParallelTasks = Number.isFinite(maxParallelTasks) ? Math.max(1, Math.min(8, Math.floor(maxParallelTasks))) : 2;
+  policy.allowAutoPublishSubmoduleMainCommits = policy.allowAutoPublishSubmoduleMainCommits === true;
   if (!SESSION_CLEANUP_MODES.has(String(policy.sessionCleanupOnNodeRemove))) {
     policy.sessionCleanupOnNodeRemove = "preserve";
   }
@@ -1173,6 +1175,9 @@ function buildPolicySection(policy) {
   if (policy.requirePreTaskCheckpoint) rules.push("- Create a git checkpoint **before** starting each task");
   if (policy.requirePostTaskCheckpoint) rules.push("- Create a git checkpoint **after** each task completes");
   if (policy.requireApprovalForPush) rules.push("- **Ask for user approval** before pushing to remote");
+  if (policy.allowAutoPublishSubmoduleMainCommits) {
+    rules.push("- Refinery may auto-publish unreachable submodule gitlink commits to submodule origin/main with non-force pushes after validation and patch-equivalence pass");
+  }
   if (policy.requireApprovalForDestructiveGit) rules.push("- **Ask for user approval** before destructive git operations (force push, reset, etc.)");
   const dirtyBehavior = {
     block: "- **Do not** send tasks to nodes with dirty workspaces",
@@ -1204,7 +1209,7 @@ function buildRulesSection(coordinatorCliType) {
 - **Clean up worktree nodes.** After a worktree task completes and its changes are merged or checkpointed, call \`mesh_remove_node\` to free resources.
 - **Do not strand completed branches.** A checkpointed or clean feature/worktree branch is not done by itself. Merge/refine it to the mesh default branch, fast-forward obvious clean behind-only branches with \`mesh_fast_forward_node\`, or explicitly report one of \`pushed_feature_branch_needs_merge\`, \`blocked_review\`, \`cleanup_candidate\`, or \`not_mergeable\` with the next action.
 - **Keep Refinery validation project-configurable.** \`mesh_refine_node\` must execute validation from repo mesh/refine config (for example \`.adhdev/refine.{json,yaml,yml}\`, \`.adhdev/repo-mesh-refine.*\`, or \`repo-mesh.refine.*\`). Heuristics are suggestions/scaffolding only, not the execution path.
-- **Treat submodule main reachability as publish-needed.** A \`submodule_reachability_failed\` refine result means the root gitlink points at a submodule commit that is not reachable from the configured submodule remote main branch. Do not treat feature-branch reachability as complete, retry validation blindly, or start code review first. Classify it as \`blocked_review\`, request user approval to push/publish the submodule commit to submodule main, then rerun \`mesh_refine_node\`.
+- **Treat submodule main reachability as publish-needed.** A \`submodule_reachability_failed\` refine result means the root gitlink points at a submodule commit that is not reachable from the configured submodule remote main branch. Do not treat feature-branch reachability as complete, retry validation blindly, or start code review first. Classify it as \`blocked_review\`, request user approval to push/publish the submodule commit to submodule main, then rerun \`mesh_refine_node\`, unless the mesh or repo refine config explicitly enabled \`allowAutoPublishSubmoduleMainCommits\` and Refinery reports exact path/commit/remote/branch evidence with post-publish verification.
 - **Name worktree branches meaningfully.** Use descriptive names like \`feat/auth-refactor\` or \`fix/build-123\`.${coordinatorNote}`;
 }
 var TOOLS_SECTION, TOOL_EXPOSURE_PREFLIGHT_SECTION, WORKFLOW_SECTION;
@@ -1251,7 +1256,7 @@ Before doing any coordinator work, confirm that the actual callable tool list in
 4. **Monitor** \u2014 Prefer event-driven completion/status notifications. Do **not** poll \`mesh_read_chat\` repeatedly. Use \`mesh_view_queue\` to see the status of all pending, assigned, completed, and failed tasks. Do not call \`mesh_read_chat\` again within a few seconds for the same generating session. Use at most one compact \`mesh_read_chat\` check after a completion/approval signal. Handle approvals via \`mesh_approve\`.
 5. **Verify** \u2014 When a task reports completion or git work is visible, call \`mesh_git_status\` to verify changes were made.
 6. **Checkpoint** \u2014 Call \`mesh_checkpoint\` to save the work.
-7. **Converge branches** \u2014 Before marking any task complete, classify every touched node/branch into exactly one final state: \`merged_to_main\`, \`pushed_feature_branch_needs_merge\`, \`blocked_review\`, \`cleanup_candidate\`, or \`not_mergeable\`. Use \`mesh_status\` branchConvergenceSummary. For obvious clean branch catch-up (ahead 0, behind > 0, upstream fresh, no dirty/stash/submodule issues), use \`mesh_fast_forward_node\` dry-run first and execute only when explicitly safe/approved; this avoids consuming an agent session. Use \`mesh_refine_node\` for clean worktree branches when safe. Before/refine merging root commits that contain submodule gitlink changes, require each submodule commit to be reachable from the configured submodule remote main branch, not merely present on a feature ref or local checkout. If \`mesh_refine_node\` returns \`submodule_reachability_failed\` or publish-required evidence, keep the public convergence bucket as \`blocked_review\`, ask the user for explicit approval to push/publish the unreachable submodule commit(s) to submodule main, then rerun \`mesh_refine_node\`; do not merge the root branch until the submodule commit(s) are reachable from submodule origin/main. A task that remains on a non-main branch is not fully complete unless the final report names the follow-up state and next step.
+7. **Converge branches** \u2014 Before marking any task complete, classify every touched node/branch into exactly one final state: \`merged_to_main\`, \`pushed_feature_branch_needs_merge\`, \`blocked_review\`, \`cleanup_candidate\`, or \`not_mergeable\`. Use \`mesh_status\` branchConvergenceSummary. For obvious clean branch catch-up (ahead 0, behind > 0, upstream fresh, no dirty/stash/submodule issues), use \`mesh_fast_forward_node\` dry-run first and execute only when explicitly safe/approved; this avoids consuming an agent session. Use \`mesh_refine_node\` for clean worktree branches when safe. Before/refine merging root commits that contain submodule gitlink changes, require each submodule commit to be reachable from the configured submodule remote main branch, not merely present on a feature ref or local checkout. If \`mesh_refine_node\` returns \`submodule_reachability_failed\` or publish-required evidence, keep the public convergence bucket as \`blocked_review\`; unless \`allowAutoPublishSubmoduleMainCommits\` is explicitly enabled and Refinery reports successful non-force publish plus post-publish verification, ask the user for explicit approval to push/publish the unreachable submodule commit(s) to submodule main, then rerun \`mesh_refine_node\`. Do not merge the root branch until the submodule commit(s) are reachable from submodule origin/main. A task that remains on a non-main branch is not fully complete unless the final report names the follow-up state and next step.
 8. **Clean up** \u2014 Remove worktree nodes via \`mesh_remove_node\` after their work is merged or no longer needed.
 9. **Report** \u2014 Summarize what was done, what changed, any issues, and the branch convergence state.
 
@@ -3201,7 +3206,8 @@ function injectMeshSystemMessage(components, args) {
     const providerSessionId = readNonEmptyString2(args.metadataEvent.providerSessionId) || void 0;
     const finalSummary = readNonEmptyString2(args.metadataEvent.finalSummary) || void 0;
     const workerResult = readWorkerResultMetadata(args.metadataEvent);
-    const completedTask = sessionId ? updateSessionTaskStatus(args.meshId, sessionId, "completed") : null;
+    const hasCompletionEvidence = !!finalSummary || !!workerResult;
+    const completedTask = sessionId && hasCompletionEvidence ? updateSessionTaskStatus(args.meshId, sessionId, "completed") : null;
     if (completedTask) {
       completedTaskForLedger = { id: completedTask.id };
       try {
@@ -8421,6 +8427,11 @@ var MESH_REFINE_CONFIG_SCHEMA = {
   required: ["version"],
   properties: {
     version: { const: 1 },
+    allowAutoPublishSubmoduleMainCommits: {
+      type: "boolean",
+      default: false,
+      description: "When true, Refinery may non-force publish submodule gitlink commits referenced by the refined root tree to each submodule origin/main after validation and patch-equivalence pass, then verify reachability."
+    },
     validation: {
       type: "object",
       additionalProperties: false,
@@ -8513,6 +8524,9 @@ function validateMeshRefineConfig(config, source = "inline") {
   const rejectedCommands = [];
   if (!isRecord(config)) return { valid: false, errors: ["config must be an object"], 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");
+  }
   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;
@@ -16472,7 +16486,7 @@ async function handleReadChat(h, args) {
         returnedMessages,
         ptyStatusApprovalOnly: false
       });
-      if (supportsCliNativeTranscript(providerType)) {
+      if (supportsCliNativeTranscript(providerType) && provider?.canonicalHistory?.mode === "native-source") {
         const agentStr = provider?.type || args?.agentType || getCurrentProviderType(h, adapter.cliType);
         const workspace = typeof args?.workspace === "string" ? args.workspace : typeof h.currentSession?.workspace === "string" ? h.currentSession.workspace : typeof adapter.workingDir === "string" ? adapter.workingDir : void 0;
         const nativeHistoryLimit = Math.max(
@@ -16631,6 +16645,17 @@ async function handleReadChat(h, args) {
         freshEnough: true,
         ptyStatusApprovalOnly: false
       });
+      const requiresNativeSource = supportsCliNativeTranscript(agentStr) && provider?.canonicalHistory?.mode === "native-source";
+      if (requiresNativeSource && !nativeSelected) {
+        return {
+          success: false,
+          code: "native_history_not_safely_available",
+          error: "Provider-native history was not safely available for the requested CLI session.",
+          providerSessionId: historyProviderSessionId,
+          messageSource,
+          transcriptProvenance: messageSource
+        };
+      }
       return buildReadChatCommandResult({
         messages: historyMessages,
         status: "idle",
@@ -21534,6 +21559,14 @@ function hasAdapterPendingResponse(adapter) {
 function countMessages(value) {
   return Array.isArray(value) ? value.length : 0;
 }
+function hasFinalAssistantMessage(value) {
+  const messages = Array.isArray(value) ? value : [];
+  const last = messages[messages.length - 1];
+  if (!last || last.role !== "assistant") return false;
+  if (last.bubbleState === "streaming") return false;
+  if (last.meta?.streaming === true) return false;
+  return typeof last.content === "string" && last.content.trim().length > 0;
+}
 function hasZeroMessageStartingLaunch(adapter) {
   const adapterStatus = adapter?.getStatus?.({ allowParse: false }) ?? adapter?.getStatus?.() ?? {};
   const parsedStatus = typeof adapter?.getScriptParsedStatus === "function" ? adapter.getScriptParsedStatus() : {};
@@ -21545,6 +21578,17 @@ function hasZeroMessageStartingLaunch(adapter) {
   if (countMessages(adapterStatus?.messages) > 0 || countMessages(parsedStatus?.messages) > 0) return false;
   return !hasAdapterPendingResponse(adapter);
 }
+function hasCompletedStartingLaunch(adapter) {
+  const adapterStatus = adapter?.getStatus?.({ allowParse: false }) ?? adapter?.getStatus?.() ?? {};
+  const adapterRawStatus = normalizeAgentStatus(adapterStatus?.status);
+  if (adapterRawStatus !== "starting") return false;
+  if (hasAdapterPendingResponse(adapter)) return false;
+  const parsedStatus = typeof adapter?.getScriptParsedStatus === "function" ? adapter.getScriptParsedStatus() : {};
+  const parsedRawStatus = normalizeAgentStatus(parsedStatus?.status);
+  if (parsedRawStatus !== "idle") return false;
+  if (hasNonEmptyModalButtons2(adapterStatus?.activeModal ?? adapterStatus?.modal ?? parsedStatus?.activeModal ?? parsedStatus?.modal)) return false;
+  return hasFinalAssistantMessage(parsedStatus?.messages);
+}
 function shouldSuppressStaleParsedBusyStatus(adapterStatus, parsedStatus, adapter) {
   const parsedRawStatus = normalizeAgentStatus(parsedStatus?.status);
   if (!BUSY_AGENT_STATUSES.has(parsedRawStatus)) return false;
@@ -21554,6 +21598,7 @@ function shouldSuppressStaleParsedBusyStatus(adapterStatus, parsedStatus, adapte
 }
 function getEffectiveAgentSendStatus(adapter) {
   const adapterStatus = normalizeAgentStatus(adapter?.getStatus?.({ allowParse: false })?.status ?? adapter?.getStatus?.()?.status);
+  if (adapterStatus === "starting" && hasCompletedStartingLaunch(adapter)) return "idle";
   if (adapterStatus && adapterStatus !== "idle") return adapterStatus;
   if (adapterStatus !== "idle") return adapterStatus;
   if (typeof adapter?.getScriptParsedStatus !== "function") return adapterStatus;
@@ -26532,6 +26577,16 @@ function buildSubmodulePublishRequiredNextStep(entries) {
   const refs = entries.map((entry) => `${entry.path}@${entry.commit}`).join(", ");
   return `Ask the user for explicit approval to push/publish the unreachable submodule commit(s) (${refs}) to the configured submodule remote main branch, then rerun mesh_refine_node. Do not merge the root branch until every submodule gitlink commit is reachable from submodule origin/main.`;
 }
+function resolveRefineryAutoPublishSubmoduleMainCommits(mesh, workspace) {
+  if (mesh?.policy?.allowAutoPublishSubmoduleMainCommits === true) {
+    return { enabled: true, source: "mesh.policy.allowAutoPublishSubmoduleMainCommits" };
+  }
+  const loaded = loadMeshRefineConfig(mesh, workspace);
+  if (loaded.config?.allowAutoPublishSubmoduleMainCommits === true) {
+    return { enabled: true, source: loaded.path || loaded.source };
+  }
+  return { enabled: false };
+}
 async function computeGitPatchId(cwd, fromRef, toRef) {
   const { execFileSync: execFileSync3 } = await import("child_process");
   const diff = execFileSync3("git", ["diff", "--patch", "--full-index", fromRef, toRef], {
@@ -26600,7 +26655,7 @@ async function runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead)
     };
   }
 }
-async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree) {
+async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, options = {}) {
   const startedAt = Date.now();
   const entries = [];
   try {
@@ -26621,6 +26676,17 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree) {
       await runGit2(submodulePath, ["-c", "protocol.file.allow=always", "fetch", "origin", `refs/heads/${branch}:refs/remotes/origin/${branch}`]);
       await runGit2(submodulePath, ["merge-base", "--is-ancestor", commit, `refs/remotes/origin/${branch}`]);
     };
+    const publishCommitToRemoteMain = async (submodulePath, commit, branch = "main") => {
+      const refspec = `${commit}:refs/heads/${branch}`;
+      const { stdout, stderr } = await execFileAsync3("git", ["push", "origin", refspec], {
+        cwd: submodulePath,
+        encoding: "utf8",
+        timeout: 3e4,
+        maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES,
+        windowsHide: true
+      });
+      return { stdout: String(stdout || ""), stderr: String(stderr || ""), refspec };
+    };
     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);
@@ -26661,11 +26727,43 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree) {
             continue;
           }
           entry.remoteMainBranch = "main";
-          await verifyRemoteMainContainsCommit(submodulePath, gitlink.commit, "main");
-          entry.fetchedFromOrigin = true;
-          entry.remoteReachable = true;
-          entry.remoteMainReachable = true;
-          entry.reachable = true;
+          try {
+            await verifyRemoteMainContainsCommit(submodulePath, gitlink.commit, "main");
+            entry.fetchedFromOrigin = true;
+            entry.remoteReachable = true;
+            entry.remoteMainReachable = true;
+            entry.reachable = true;
+          } catch (e) {
+            entry.remoteReachable = false;
+            entry.remoteMainReachable = false;
+            entry.publishRequired = true;
+            const details = truncateValidationOutput(e?.stderr || e?.message || String(e));
+            entry.error = `Submodule remote main reachability check failed for origin/main: ${details}`;
+            if (options.allowAutoPublishSubmoduleMainCommits === true && entry.localReachable === true) {
+              entry.autoPublishAllowed = true;
+              entry.autoPublishAttempted = true;
+              try {
+                const publish = await publishCommitToRemoteMain(submodulePath, gitlink.commit, "main");
+                entry.autoPublishRefspec = publish.refspec;
+                entry.publishStdout = truncateValidationOutput(publish.stdout);
+                entry.publishStderr = truncateValidationOutput(publish.stderr);
+                entry.autoPublishSucceeded = true;
+                await verifyRemoteMainContainsCommit(submodulePath, gitlink.commit, "main");
+                entry.fetchedFromOrigin = true;
+                entry.remoteReachable = true;
+                entry.remoteMainReachable = true;
+                entry.autoPublishVerified = true;
+                entry.publishRequired = false;
+                entry.reachable = true;
+                entry.error = void 0;
+              } catch (publishError) {
+                entry.autoPublishSucceeded = false;
+                entry.autoPublishVerified = false;
+                const publishDetails = truncateValidationOutput(publishError?.stderr || publishError?.message || String(publishError));
+                entry.error = `Submodule auto-publish to origin/main failed or could not be verified: ${publishDetails}`;
+              }
+            }
+          }
         } catch (e) {
           entry.remoteReachable = false;
           entry.remoteMainReachable = false;
@@ -26685,7 +26783,9 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree) {
       checked: entries.length,
       unreachable: unreachable.map((entry) => ({ ...entry, publishRequired: entry.publishRequired !== false })),
       entries: entries.map((entry) => entry.reachable ? entry : { ...entry, publishRequired: entry.publishRequired !== false }),
-      durationMs: Date.now() - startedAt
+      durationMs: Date.now() - startedAt,
+      autoPublishAllowed: options.allowAutoPublishSubmoduleMainCommits === true,
+      autoPublishPolicySource: options.autoPublishPolicySource
     };
   } catch (e) {
     const unreachable = entries.filter((entry) => !entry.reachable).map((entry) => ({ ...entry, publishRequired: true }));
@@ -26695,6 +26795,8 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree) {
       unreachable,
       entries: entries.map((entry) => entry.reachable ? entry : { ...entry, publishRequired: true }),
       durationMs: Date.now() - startedAt,
+      autoPublishAllowed: options.allowAutoPublishSubmoduleMainCommits === true,
+      autoPublishPolicySource: options.autoPublishPolicySource,
       error: truncateValidationOutput(e?.message || String(e))
     };
   }
@@ -27833,13 +27935,36 @@ var DaemonCommandRouter = class {
         };
       }
       const submoduleReachabilityStarted = Date.now();
-      const submoduleReachability = await runMeshRefineSubmoduleReachabilityGate(repoRoot, patchEquivalence.mergedTree || branchHead);
+      const autoPublishSubmoduleMainCommits = resolveRefineryAutoPublishSubmoduleMainCommits(mesh, node.workspace);
+      const submoduleReachability = await runMeshRefineSubmoduleReachabilityGate(repoRoot, patchEquivalence.mergedTree || branchHead, {
+        allowAutoPublishSubmoduleMainCommits: autoPublishSubmoduleMainCommits.enabled,
+        autoPublishPolicySource: autoPublishSubmoduleMainCommits.source
+      });
       recordMeshRefineStage(refineStages, "submodule_reachability", submoduleReachability.status, submoduleReachabilityStarted, {
         checked: submoduleReachability.checked,
+        autoPublishAllowed: submoduleReachability.autoPublishAllowed,
+        autoPublishPolicySource: submoduleReachability.autoPublishPolicySource,
+        autoPublished: submoduleReachability.entries.filter((entry) => entry.autoPublishAttempted).map((entry) => ({
+          path: entry.path,
+          commit: entry.commit,
+          remote: entry.remote,
+          remoteUrl: entry.remoteUrl,
+          remoteMainBranch: entry.remoteMainBranch,
+          refspec: entry.autoPublishRefspec,
+          succeeded: entry.autoPublishSucceeded,
+          verified: entry.autoPublishVerified,
+          remoteMainReachable: entry.remoteMainReachable,
+          error: entry.error
+        })),
         unreachable: submoduleReachability.unreachable.map((entry) => ({
           path: entry.path,
           commit: entry.commit,
           publishRequired: entry.publishRequired === true,
+          autoPublishAllowed: entry.autoPublishAllowed,
+          autoPublishAttempted: entry.autoPublishAttempted,
+          autoPublishSucceeded: entry.autoPublishSucceeded,
+          autoPublishVerified: entry.autoPublishVerified,
+          autoPublishRefspec: entry.autoPublishRefspec,
           remote: entry.remote,
           remoteUrl: entry.remoteUrl,
           remoteReachable: entry.remoteReachable,
@@ -27873,6 +27998,11 @@ var DaemonCommandRouter = class {
             remoteReachable: entry.remoteReachable,
             remoteMainBranch: entry.remoteMainBranch,
             remoteMainReachable: entry.remoteMainReachable,
+            autoPublishAllowed: entry.autoPublishAllowed,
+            autoPublishAttempted: entry.autoPublishAttempted,
+            autoPublishSucceeded: entry.autoPublishSucceeded,
+            autoPublishVerified: entry.autoPublishVerified,
+            autoPublishRefspec: entry.autoPublishRefspec,
             error: entry.error
           })),
           branch,
@@ -27947,7 +28077,7 @@ var DaemonCommandRouter = class {
         appendLedgerEntry2(meshId, {
           kind: "node_removed",
           nodeId,
-          payload: { refined: true, mergedBranch: branch, into: baseBranch, validationSummary, patchEquivalence }
+          payload: { refined: true, mergedBranch: branch, into: baseBranch, validationSummary, patchEquivalence, submoduleReachability }
         });
         recordMeshRefineStage(refineStages, "ledger", "passed", ledgerStarted);
       } catch (e) {
@@ -27975,6 +28105,7 @@ var DaemonCommandRouter = class {
           removeResult,
           validationSummary,
           patchEquivalence,
+          submoduleReachability,
           mergeResult,
           refineStages,
           ...ledgerError ? { ledgerError } : {},
@@ -27989,6 +28120,7 @@ var DaemonCommandRouter = class {
         removeResult,
         validationSummary,
         patchEquivalence,
+        submoduleReachability,
         mergeResult,
         refineStages,
         ...ledgerError ? { ledgerError } : {},