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

package/dist/index.mjs

@@ -40,6 +40,7 @@ var init_repo_mesh_types = __esm({
       maxParallelTasks: 2,
       spawnedSessionVisibility: "visible",
       sessionCleanupOnNodeRemove: "preserve",
+      autoFastForward: { enabled: true },
       maxTaskRetries: 1
     };
   }
@@ -1357,7 +1358,17 @@ function normalizeRepoIdentity(remoteUrl) {
   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";
   }
@@ -1372,6 +1383,15 @@ function mergeMeshPolicy(base, patch) {
   }
   return policy;
 }
+function normalizeAutoFastForwardPolicy(value) {
+  const record = value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  const maxBehind = Number(record.maxBehind);
+  return {
+    enabled: record.enabled !== false,
+    ...Number.isFinite(maxBehind) && maxBehind >= 0 ? { maxBehind: Math.floor(maxBehind) } : {},
+    requireCleanSubmodules: record.requireCleanSubmodules !== false
+  };
+}
 function listMeshes() {
   return loadMeshConfig().meshes;
 }
@@ -6719,6 +6739,34 @@ function isIdleSessionState(state) {
 function isDirtyNode(node) {
   return node?.health === "dirty" || node?.git?.dirty === true;
 }
+function resolveAutoFastForwardPolicy(mesh) {
+  const record = mesh?.policy?.autoFastForward && typeof mesh.policy.autoFastForward === "object" && !Array.isArray(mesh.policy.autoFastForward) ? mesh.policy.autoFastForward : {};
+  const maxBehind = Number(record.maxBehind);
+  return {
+    enabled: record.enabled !== false,
+    ...Number.isFinite(maxBehind) && maxBehind >= 0 ? { maxBehind: Math.floor(maxBehind) } : {},
+    requireCleanSubmodules: record.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();
@@ -7047,6 +7095,9 @@ async function maybeAutoFastForwardIdleNode(components, args) {
   const workspace = readNonEmptyString2(node?.workspace);
   if (!workspace) return;
   if (!existsSync14(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;
@@ -7065,6 +7116,12 @@ async function maybeAutoFastForwardIdleNode(components, args) {
       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,
@@ -10340,7 +10397,25 @@ var init_cli_state_engine = __esm({
           "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;
@@ -35407,6 +35482,35 @@ function extractToolOutputContent(payload) {
   }
   return "";
 }
+function hasAssistantStandardMessageSinceLastUser(records, content) {
+  const normalized = content.trim();
+  if (!normalized) return false;
+  for (let i = records.length - 1; i >= 0; i--) {
+    const record = records[i];
+    if (record.kind === "session_start") continue;
+    if (record.role === "user") return false;
+    if (record.role === "assistant" && record.kind === "standard" && record.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);
@@ -35462,13 +35566,34 @@ function parseSessionFile(filePath, sessionId, workspaceFallback) {
       }
       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,
@@ -39401,6 +39526,7 @@ async function maybeRunDaemonUpgradeHelperFromEnv() {
 
 // src/commands/router.ts
 init_mesh_work_queue();
+init_repo_mesh_types();
 import { homedir as homedir25, hostname as osHostname } from "os";
 import { basename as pathBasename, join as pathJoin, resolve as pathResolve2 } from "path";
 import * as fs22 from "fs";
@@ -39893,6 +40019,23 @@ function getGitSubmoduleDriftState(git) {
   }
   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);
@@ -40022,6 +40165,12 @@ function applyInlineMeshBranchConvergence(mesh, node, status) {
   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) => {
@@ -41937,7 +42086,8 @@ var DaemonCommandRouter = class {
           ...result ? {
             success: result.success === true,
             result,
-            finalBranchConvergenceState: result.finalBranchConvergenceState
+            finalBranchConvergenceState: result.finalBranchConvergenceState,
+            ...result.blockerContext ? { blockerContext: result.blockerContext } : {}
           } : {}
         }
       });
@@ -42467,6 +42617,27 @@ var DaemonCommandRouter = class {
           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,
@@ -42480,7 +42651,13 @@ var DaemonCommandRouter = class {
         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 };
@@ -42498,9 +42675,46 @@ var DaemonCommandRouter = class {
     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."
       } : {}