@adhdev/daemon-standalone 0.9.82-rc.212 → 0.9.82-rc.214

package/dist/index.js

@@ -29749,6 +29749,7 @@ var require_dist3 = __commonJS({
           maxParallelTasks: 2,
           spawnedSessionVisibility: "visible",
           sessionCleanupOnNodeRemove: "preserve",
+          autoFastForward: { enabled: true },
           maxTaskRetries: 1
         };
       }
@@ -31074,7 +31075,17 @@ ${error48.message || ""}`;
       return identity;
     }
     function mergeMeshPolicy(base, patch) {
-      const policy = { ...DEFAULT_MESH_POLICY, ...base || {}, ...patch || {} };
+      const autoFastForward = normalizeAutoFastForwardPolicy({
+        ...DEFAULT_MESH_POLICY.autoFastForward,
+        ...base?.autoFastForward && typeof base.autoFastForward === "object" ? base.autoFastForward : {},
+        ...patch?.autoFastForward && typeof patch.autoFastForward === "object" ? patch.autoFastForward : {}
+      });
+      const policy = {
+        ...DEFAULT_MESH_POLICY,
+        ...base || {},
+        ...patch || {},
+        autoFastForward
+      };
       if (!["block", "warn", "checkpoint_then_continue"].includes(policy.dirtyWorkspaceBehavior)) {
         policy.dirtyWorkspaceBehavior = "warn";
       }
@@ -31089,6 +31100,15 @@ ${error48.message || ""}`;
       }
       return policy;
     }
+    function normalizeAutoFastForwardPolicy(value) {
+      const record2 = value && typeof value === "object" && !Array.isArray(value) ? value : {};
+      const maxBehind = Number(record2.maxBehind);
+      return {
+        enabled: record2.enabled !== false,
+        ...Number.isFinite(maxBehind) && maxBehind >= 0 ? { maxBehind: Math.floor(maxBehind) } : {},
+        requireCleanSubmodules: record2.requireCleanSubmodules !== false
+      };
+    }
     function listMeshes() {
       return loadMeshConfig().meshes;
     }
@@ -36482,6 +36502,34 @@ Next step: ${nextStep}`;
     function isDirtyNode(node) {
       return node?.health === "dirty" || node?.git?.dirty === true;
     }
+    function resolveAutoFastForwardPolicy(mesh) {
+      const record2 = mesh?.policy?.autoFastForward && typeof mesh.policy.autoFastForward === "object" && !Array.isArray(mesh.policy.autoFastForward) ? mesh.policy.autoFastForward : {};
+      const maxBehind = Number(record2.maxBehind);
+      return {
+        enabled: record2.enabled !== false,
+        ...Number.isFinite(maxBehind) && maxBehind >= 0 ? { maxBehind: Math.floor(maxBehind) } : {},
+        requireCleanSubmodules: record2.requireCleanSubmodules !== false
+      };
+    }
+    function sessionStateLooksActive(state) {
+      const status = readNonEmptyString2(state?.status).toLowerCase();
+      const chatStatus = readNonEmptyString2(state?.activeChat?.status).toLowerCase();
+      const active = /* @__PURE__ */ new Set(["generating", "streaming", "long_generating", "working", "starting", "waiting_approval"]);
+      return active.has(status) || active.has(chatStatus);
+    }
+    function nodeHasActiveMeshWork(components, meshId, nodeId, currentSessionId) {
+      if (nodeHasActiveAssignment(meshId, nodeId)) return true;
+      return components.instanceManager.getByCategory("cli").some((inst) => {
+        const state = inst.getState();
+        const settings = state.settings || {};
+        if (readNonEmptyString2(settings.meshNodeFor) !== meshId) return false;
+        const instNodeId = readNonEmptyString2(settings.meshNodeId) || readNonEmptyString2(settings.nodeId);
+        if (instNodeId !== nodeId) return false;
+        const sessionId = readNonEmptyString2(state.instanceId);
+        if (currentSessionId && sessionId === currentSessionId && isIdleSessionState(state)) return false;
+        return sessionStateLooksActive(state);
+      });
+    }
     function isLaunchableNode(node) {
       if (!node || node.status === "disabled" || node.status === "removed") return false;
       const health = readNonEmptyString2(node.health).toLowerCase();
@@ -36810,6 +36858,9 @@ Next step: ${nextStep}`;
       const workspace = readNonEmptyString2(node?.workspace);
       if (!workspace) return;
       if (!(0, import_fs10.existsSync)(workspace)) return;
+      const policy = resolveAutoFastForwardPolicy(mesh);
+      if (!policy.enabled) return;
+      if (nodeHasActiveMeshWork(components, args.meshId, args.nodeId, args.sessionId)) return;
       const throttleKey = `${args.meshId}:${args.nodeId}`;
       const now = Date.now();
       const lastAttempt = idleAutoFastForwardLastAttempt.get(throttleKey) || 0;
@@ -36828,6 +36879,12 @@ Next step: ${nextStep}`;
           trigger: "idle_auto"
         });
         if (!dryRun || dryRun.code !== "fast_forward_available" || dryRun.allowed !== true) return;
+        const behind = Number(dryRun.current?.behind);
+        if (policy.maxBehind !== void 0 && Number.isFinite(behind) && behind > policy.maxBehind) return;
+        if (policy.requireCleanSubmodules) {
+          const submodules = Array.isArray(dryRun.current?.submodules) ? dryRun.current.submodules : [];
+          if (submodules.some((submodule) => submodule?.dirty || submodule?.outOfSync || submodule?.error)) return;
+        }
         await fastForwardMeshNode({
           meshId: args.meshId,
           nodeId: args.nodeId,
@@ -40109,7 +40166,25 @@ ${cont}` : cont;
               "CLI",
               `[${this.provider.type}] settled diagnostics prompt=${JSON.stringify(this.currentTurnScope?.prompt || "").slice(0, 140)} status=${String(status || "")} parsedStatus=${String(parsedStatus || "")} parsedMsgCount=${parsedMessages.length} lastParsedAssistant=${JSON.stringify((lastParsedAssistant?.content || "").slice(0, 120)).slice(0, 160)} responseBuffer=${JSON.stringify((snap.responseBuffer || "").slice(0, 160)).slice(0, 220)} recentActivity=${recentInteractiveActivity}`
             );
-            const shouldHoldGenerating = status === "idle" && this.isWaitingForResponse && !!this.currentTurnScope && !modal && !(parsedStatus === "idle" && !!lastParsedAssistant);
+            const hasFinalCurrentTurnAssistant = (() => {
+              if (parsedStatus !== "idle") return false;
+              const msgs = Array.isArray(parsedMessages) ? parsedMessages : [];
+              let lastUserIdx = -1;
+              for (let i = msgs.length - 1; i >= 0; i--) {
+                if (msgs[i]?.role === "user") {
+                  lastUserIdx = i;
+                  break;
+                }
+              }
+              const searchSlice = lastUserIdx >= 0 ? msgs.slice(lastUserIdx + 1) : msgs;
+              return searchSlice.some((m) => {
+                if (!m || m.role !== "assistant") return false;
+                if (typeof m.content !== "string" || !m.content.trim()) return false;
+                const kind = typeof m.kind === "string" && m.kind.trim() ? m.kind.trim() : "standard";
+                return kind === "standard" && m.meta?.streaming !== true;
+              });
+            })();
+            const shouldHoldGenerating = status === "idle" && this.isWaitingForResponse && !!this.currentTurnScope && !modal && !hasFinalCurrentTurnAssistant;
             if (shouldHoldGenerating) {
               this.applyHoldGenerating(ctx);
               return;
@@ -65305,6 +65380,35 @@ Run 'adhdev doctor' for detailed diagnostics.`
       }
       return "";
     }
+    function hasAssistantStandardMessageSinceLastUser(records, content) {
+      const normalized = content.trim();
+      if (!normalized) return false;
+      for (let i = records.length - 1; i >= 0; i--) {
+        const record2 = records[i];
+        if (record2.kind === "session_start") continue;
+        if (record2.role === "user") return false;
+        if (record2.role === "assistant" && record2.kind === "standard" && record2.content.trim() === normalized) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function pushAssistantStandardMessage(records, sessionId, receivedAt, content, workspace) {
+      const text = content.trim();
+      if (!text) return;
+      if (hasAssistantStandardMessageSinceLastUser(records, text)) return;
+      const msg = {
+        ts: new Date(receivedAt).toISOString(),
+        receivedAt,
+        role: "assistant",
+        content: text,
+        kind: "standard",
+        agent: "codex-cli",
+        historySessionId: sessionId
+      };
+      if (workspace) msg.workspace = workspace;
+      records.push(msg);
+    }
     function readSessionMeta(filePath) {
       try {
         const firstLine = fs15.readFileSync(filePath, "utf-8").split("\n").find(Boolean);
@@ -65360,13 +65464,34 @@ Run 'adhdev doctor' for detailed diagnostics.`
           }
           continue;
         }
-        if (type !== "response_item") continue;
         const payloadType = String(payload.type ?? "").trim();
+        if (type === "event_msg") {
+          if (payloadType === "task_complete") {
+            pushAssistantStandardMessage(
+              records,
+              sessionId,
+              receivedAt,
+              flattenCodexContent(payload.last_agent_message),
+              detectedWorkspace
+            );
+          } else if (payloadType === "agent_message" && String(payload.phase ?? "").trim() === "final_answer") {
+            pushAssistantStandardMessage(
+              records,
+              sessionId,
+              receivedAt,
+              flattenCodexContent(payload.message),
+              detectedWorkspace
+            );
+          }
+          continue;
+        }
+        if (type !== "response_item") continue;
         if (payloadType === "message") {
           const role = String(payload.role ?? "").trim();
           if (role !== "user" && role !== "assistant") continue;
           const content = flattenCodexContent(payload.content);
           if (!content) continue;
+          if (role === "assistant" && hasAssistantStandardMessageSinceLastUser(records, content)) continue;
           const msg = {
             ts: new Date(receivedAt).toISOString(),
             receivedAt,
@@ -69271,6 +69396,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       }
     }
     init_mesh_work_queue();
+    init_repo_mesh_types();
     var import_os3 = require("os");
     var import_path10 = require("path");
     var fs222 = __toESM2(require("fs"));
@@ -69763,6 +69889,23 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       }
       return { dirty, outOfSync };
     }
+    function isInlineMeshAutoFastForwardEligible(git) {
+      if (!git) return false;
+      if (readBooleanValue(git.isGitRepo) !== true) return false;
+      if (!readStringValue(git.branch)) return false;
+      if (!readStringValue(git.upstream)) return false;
+      const upstreamStatus = readStringValue(git.upstreamStatus, git.upstream_status);
+      if (upstreamStatus !== "fresh") return false;
+      if ((readNumberValue(git.ahead) ?? 0) !== 0) return false;
+      if ((readNumberValue(git.behind) ?? 0) <= 0) return false;
+      const hasConflicts = readBooleanValue(git.hasConflicts) ?? (Array.isArray(git.conflictFiles) && git.conflictFiles.length > 0);
+      if (hasConflicts) return false;
+      if ((readNumberValue(git.stashCount, git.stash_count) ?? 0) > 0) return false;
+      const submoduleDrift = getGitSubmoduleDriftState(git);
+      if (submoduleDrift.dirty || submoduleDrift.outOfSync) return false;
+      const dirty = readBooleanValue(git.dirty) ?? countGitWorktreeChanges(git) > 0;
+      return dirty !== true && countGitWorktreeChanges(git) === 0;
+    }
     function deriveMeshNodeHealthFromGit(git) {
       if (!git || readBooleanValue(git.isGitRepo) === false) return "degraded";
       const branch = readStringValue(git.branch);
@@ -69892,6 +70035,12 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       status.isDirty = uncommittedChanges > 0;
       status.uncommittedChanges = uncommittedChanges;
       status.branchConvergence = buildInlineMeshBranchConvergence({ mesh, node, status });
+      status.autoFastForwardEligible = isInlineMeshAutoFastForwardEligible(git);
+      if (status.autoFastForwardEligible) {
+        status.suggestedAction = "auto_fast_forward";
+      } else {
+        delete status.suggestedAction;
+      }
     }
     function summarizeInlineMeshBranchConvergence(nodes) {
       const followUps = nodes.filter((node) => readObjectRecord(node.branchConvergence).needsConvergence === true).map((node) => {
@@ -71807,7 +71956,8 @@ ${e?.stderr || ""}`
               ...result ? {
                 success: result.success === true,
                 result,
-                finalBranchConvergenceState: result.finalBranchConvergenceState
+                finalBranchConvergenceState: result.finalBranchConvergenceState,
+                ...result.blockerContext ? { blockerContext: result.blockerContext } : {}
               } : {}
             }
           });
@@ -72337,6 +72487,27 @@ ${e?.stderr || ""}`
               finalBranchConvergenceState
             };
           }
+          const requireApprovalForPush = mesh?.policy?.requireApprovalForPush ?? DEFAULT_MESH_POLICY.requireApprovalForPush;
+          let pushResult;
+          if (!requireApprovalForPush) {
+            const pushStarted = Date.now();
+            try {
+              await execFileAsync3("git", ["push", "origin", baseBranch], { cwd: repoRoot, encoding: "utf8" });
+              pushResult = { pushed: true, remote: "origin", branch: baseBranch, durationMs: Date.now() - pushStarted };
+              recordMeshRefineStage(refineStages, "push", "passed", pushStarted, pushResult);
+              finalBranchConvergenceState.status = "merged_pushed";
+            } catch (e) {
+              pushResult = {
+                pushed: false,
+                remote: "origin",
+                branch: baseBranch,
+                error: e?.message || String(e),
+                stderr: e?.stderr,
+                durationMs: Date.now() - pushStarted
+              };
+              recordMeshRefineStage(refineStages, "push", "failed", pushStarted, pushResult);
+            }
+          }
           return {
             success: true,
             merged: true,
@@ -72350,7 +72521,13 @@ ${e?.stderr || ""}`
             mergeResult,
             refineStages,
             ...ledgerError ? { ledgerError } : {},
-            finalBranchConvergenceState
+            finalBranchConvergenceState,
+            // Push outcome or readiness info for coordinator.
+            ...pushResult ? { pushResult } : {
+              pushReady: true,
+              pushCommand: `git push origin ${baseBranch}`,
+              pushNote: "requireApprovalForPush is enabled \u2014 run the push command or obtain user approval before pushing."
+            }
           };
         } catch (e) {
           return { success: false, error: e.message, refineStages };
@@ -72368,9 +72545,46 @@ ${e?.stderr || ""}`
         const refineCode = typeof result.code === "string" ? result.code : "";
         const refineTerminalKind = result.success === true ? "completed" : refineCode === "blocked_review" ? "blocked_review" : refineCode === "validation_failed" || refineCode === "validation_dependencies_missing" ? "validation_failed" : refineCode === "submodule_reachability_failed" ? "submodule_reachability_failed" : refineCode === "merge_failed" || refineCode === "patch_equivalence_failed" || refineCode === "needs_rebase" || refineCode === "needs_rebase_with_conflicts" ? "merge_failed" : refineCode === "cleanup_failed" ? "cleanup_failed" : "merge_failed";
         const isTerminalSuccess = refineTerminalKind === "completed";
+        const blockerContext = isTerminalSuccess ? void 0 : (() => {
+          const code = typeof result.code === "string" ? result.code : refineTerminalKind;
+          const stage = refineTerminalKind === "validation_failed" ? "validation" : refineTerminalKind === "submodule_reachability_failed" ? "submodule_reachability" : refineCode === "patch_equivalence_failed" ? "patch_equivalence" : refineCode === "needs_rebase" || refineCode === "needs_rebase_with_conflicts" ? "patch_equivalence" : refineTerminalKind === "merge_failed" ? "merge" : refineTerminalKind === "cleanup_failed" ? "cleanup" : "unknown";
+          const ctx = {
+            stage,
+            reason: code,
+            terminalKind: refineTerminalKind
+          };
+          if (typeof result.error === "string") ctx.error = result.error;
+          if (typeof result.blockedReason === "string") ctx.blockedReason = result.blockedReason;
+          if (stage === "patch_equivalence" && result.patchEquivalence) {
+            const pe = result.patchEquivalence;
+            ctx.details = {
+              expectedPatchId: pe.expectedPatchId,
+              actualPatchId: pe.actualPatchId,
+              status: pe.status,
+              actionableHint: pe.actionableHint,
+              error: pe.error
+            };
+          }
+          if (stage === "submodule_reachability" && Array.isArray(result.unreachableSubmoduleCommits)) {
+            ctx.details = {
+              unreachableCount: result.unreachableSubmoduleCommits.length,
+              paths: result.unreachableSubmoduleCommits.map((e) => e.path),
+              autoPublishAllowed: result.unreachableSubmoduleCommits[0]?.autoPublishAllowed
+            };
+          }
+          if (stage === "validation" && result.validationSummary) {
+            const vs = result.validationSummary;
+            ctx.details = {
+              failureCode: vs.failureCode,
+              commandsRun: Array.isArray(vs.commandsRun) ? vs.commandsRun.length : void 0
+            };
+          }
+          return ctx;
+        })();
         const normalizedResult = {
           ...result,
           terminalKind: refineTerminalKind,
+          ...blockerContext ? { blockerContext } : {},
           ...result.nextStep === void 0 && !isTerminalSuccess ? {
             nextStep: refineTerminalKind === "blocked_review" ? "Request user review/approval before attempting to merge again." : refineTerminalKind === "validation_failed" ? "Fix failing tests or configure validation.bootstrapCommands and retry mesh_refine_node." : refineTerminalKind === "submodule_reachability_failed" ? "Push unreachable submodule commits to origin/main, then retry mesh_refine_node." : refineTerminalKind === "merge_failed" ? "Resolve merge conflicts or patch equivalence issues, then retry mesh_refine_node." : refineTerminalKind === "cleanup_failed" ? "Manually remove the worktree and retry or use mesh_remove_node." : "Inspect refineStages for the failing stage and retry."
           } : {}