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

package/dist/index.js

@@ -22146,6 +22146,7 @@ var require_dist2 = __commonJS({
           requirePreTaskCheckpoint: false,
           requirePostTaskCheckpoint: true,
           requireApprovalForPush: true,
+          allowAutoPublishSubmoduleMainCommits: false,
           requireApprovalForDestructiveGit: true,
           dirtyWorkspaceBehavior: "warn",
           maxParallelTasks: 2,
@@ -22908,6 +22909,7 @@ ${error48.message || ""}`;
       }
       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";
       }
@@ -23299,6 +23301,9 @@ ${userInstruction}`);
       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",
@@ -23330,7 +23335,7 @@ ${rules.join("\n")}`;
 - **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;
@@ -23379,7 +23384,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.
 
@@ -25356,7 +25361,8 @@ Next step: ${nextStep}`;
         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 {
@@ -30802,6 +30808,11 @@ ${lastSnapshot}`;
       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,
@@ -30894,6 +30905,9 @@ ${lastSnapshot}`;
       const rejectedCommands = [];
       if (!isRecord(config2)) return { valid: false, errors: ["config must be an object"], 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");
+      }
       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;
@@ -38761,7 +38775,7 @@ ${effect.notification.body || ""}`.trim();
             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(
@@ -38920,6 +38934,17 @@ ${effect.notification.body || ""}`.trim();
             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",
@@ -43788,6 +43813,14 @@ ${rawInput}` : rawInput;
     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() : {};
@@ -43799,6 +43832,17 @@ ${rawInput}` : rawInput;
       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;
@@ -43808,6 +43852,7 @@ ${rawInput}` : rawInput;
     }
     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;
@@ -48758,6 +48803,16 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       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], {
@@ -48826,7 +48881,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         };
       }
     }
-    async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree) {
+    async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, options = {}) {
       const startedAt = Date.now();
       const entries = [];
       try {
@@ -48847,6 +48902,17 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
           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((record2) => {
           const match = /^160000\s+commit\s+([0-9a-f]{40})\t(.+)$/.exec(record2);
@@ -48887,11 +48953,43 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                 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;
@@ -48911,7 +49009,9 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
           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 }));
@@ -48921,6 +49021,8 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
           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))
         };
       }
@@ -50059,13 +50161,36 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
             };
           }
           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,
@@ -50099,6 +50224,11 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                 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,
@@ -50173,7 +50303,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
             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) {
@@ -50201,6 +50331,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
               removeResult,
               validationSummary,
               patchEquivalence,
+              submoduleReachability,
               mergeResult,
               refineStages,
               ...ledgerError ? { ledgerError } : {},
@@ -50215,6 +50346,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
             removeResult,
             validationSummary,
             patchEquivalence,
+            submoduleReachability,
             mergeResult,
             refineStages,
             ...ledgerError ? { ledgerError } : {},