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

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,
@@ -69763,6 +69820,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 +69966,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) => {