@adhdev/daemon-standalone 0.9.82-rc.211 → 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;
     }
@@ -35316,12 +35336,14 @@ ${rendered}`, "utf-8");
       const completionDiagnostic = event.completionDiagnostic && typeof event.completionDiagnostic === "object" ? event.completionDiagnostic : null;
       const diagnosticReason = completionDiagnostic ? readNonEmptyString2(completionDiagnostic.blockReason) || "present" : "";
       const finalAssistantPresent = typeof completionDiagnostic?.finalAssistantPresent === "boolean" ? String(completionDiagnostic.finalAssistantPresent) : "";
+      const evidenceLevel = readNonEmptyString2(event.evidenceLevel);
       const parts = [
         readNonEmptyString2(event.targetSessionId) ? `session_id=${readNonEmptyString2(event.targetSessionId)}` : "",
         readNonEmptyString2(event.providerType) ? `provider=${readNonEmptyString2(event.providerType)}` : "",
         readNonEmptyString2(event.providerSessionId) ? `provider_session_id=${readNonEmptyString2(event.providerSessionId)}` : "",
         diagnosticReason ? `completion_diagnostic=${diagnosticReason}` : "",
-        finalAssistantPresent ? `final_assistant=${finalAssistantPresent}` : ""
+        finalAssistantPresent ? `final_assistant=${finalAssistantPresent}` : "",
+        evidenceLevel && evidenceLevel !== "sufficient" ? `evidence_level=${evidenceLevel}` : ""
       ].filter(Boolean);
       return parts.length > 0 ? ` (${parts.join("; ")})` : "";
     }
@@ -35331,7 +35353,8 @@ ${rendered}`, "utf-8");
         if (args.metadataEvent.source === "long_generating_reconciliation") {
           return `[System] ${args.nodeLabel} already has completion evidence${metadata}. The long-generating monitor reconciled the terminal handoff and marked the session complete; wait for the queued completion event/status refresh before doing any manual transcript check.`;
         }
-        return `[System] ${args.nodeLabel} has completed its task and is now idle${metadata}. This completion came from the agent status event path; use mesh_read_chat once to review its final progress, but do not poll repeatedly.`;
+        const reviewNote = args.metadataEvent.reviewRecommended === true ? " Completion evidence is insufficient \u2014 verify via git status or provider_session_id before assuming the task is done. Use mesh_read_chat once if needed, but do not poll repeatedly." : " Use mesh_read_chat once to review its final progress, but do not poll repeatedly.";
+        return `[System] ${args.nodeLabel} has completed its task and is now idle${metadata}. This completion came from the agent status event path;${reviewNote}`;
       }
       if (args.event === "agent:waiting_approval") {
         return `[System] ${args.nodeLabel} is waiting for approval to proceed${metadata}. You may use mesh_read_chat and mesh_approve to handle it.`;
@@ -36479,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();
@@ -36807,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;
@@ -36825,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,
@@ -58126,6 +58186,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
             "busy_hold_ms": { "type": "integer", "minimum": 0 },
             "idle_hold_ms": { "type": "integer", "minimum": 0 },
             "startup_grace_ms": { "type": "integer", "minimum": 0 },
+            "screen_active_hold_ms": { "type": "integer", "minimum": 0 },
             "completion_marker": {
               "type": "object",
               "additionalProperties": false,
@@ -58466,6 +58527,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         ...t.busy_hold_ms !== void 0 ? { busy_hold_ms: t.busy_hold_ms } : {},
         ...t.idle_hold_ms !== void 0 ? { idle_hold_ms: t.idle_hold_ms } : {},
         ...t.startup_grace_ms !== void 0 ? { startup_grace_ms: t.startup_grace_ms } : {},
+        ...t.screen_active_hold_ms !== void 0 ? { screen_active_hold_ms: t.screen_active_hold_ms } : {},
         ...cm ? {
           completion_idle_after: {
             ...cm.section ? { section: cm.section } : {},
@@ -58767,6 +58829,10 @@ ${formatManifestValidationIssues2(validation.issues)}`,
       completionIdleKey = "";
       /** Previous screen lines — passed to evaluate() for `changed` condition detection. */
       prevScreenLines = [];
+      /** Timestamp of the last PTY frame that changed the screen content.
+       *  Used by screen_active_hold_ms to suppress idle downshifts while
+       *  the terminal is still actively updating. */
+      lastScreenChangedAt = 0;
       /** Timer that re-runs evaluate() once the hold window expires. Needed
        *  because the PTY stops emitting once the agent finishes; without an
        *  explicit wake-up there's nothing to trigger the busy → idle
@@ -58968,8 +59034,12 @@ ${formatManifestValidationIssues2(validation.issues)}`,
       reevaluate(forceEmit = false) {
         const screen = this.adapter.snapshot();
         const cursor = this.adapter.getCursorPosition();
+        const currentLines = screen.split("\n").map((l) => l.endsWith("\r") ? l.slice(0, -1) : l);
         const ev = evaluate(this.spec, screen, cursor, this.prevScreenLines.length > 0 ? this.prevScreenLines : void 0);
-        this.prevScreenLines = screen.split("\n").map((l) => l.endsWith("\r") ? l.slice(0, -1) : l);
+        if (this.prevScreenLines.length > 0 && currentLines.join("\n") !== this.prevScreenLines.join("\n")) {
+          this.lastScreenChangedAt = Date.now();
+        }
+        this.prevScreenLines = currentLines;
         let evState = ev.state;
         const busyHoldMs = this.spec.debounce?.busy_hold_ms ?? BUSY_HOLD_MS;
         if (this.currentStateId === "busy" && evState.id === "idle") {
@@ -58987,12 +59057,19 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           }
         }
         const completionIdleRule = this.spec.debounce?.completion_idle_after;
+        const screenActiveHoldMs = this.spec.debounce?.screen_active_hold_ms;
         let busyWakeMs = busyHoldMs;
         const postModalGraceMs = busyHoldMs;
         const now = Date.now();
         const recentlyInModal = isModalState(this.currentStateId) || this.lastModalAt > 0 && now - this.lastModalAt < postModalGraceMs;
         const recentlyLeftModal = !recentlyInModal && this.lastModalExitAt > 0 && now - this.lastModalExitAt < postModalGraceMs;
-        if (evState.id === "busy" && completionIdleRule && !recentlyInModal && !recentlyLeftModal) {
+        const screenActiveMs = screenActiveHoldMs ?? 0;
+        const screenStableMs = this.lastScreenChangedAt > 0 ? now - this.lastScreenChangedAt : Infinity;
+        const screenIsActive = screenActiveMs > 0 && screenStableMs < screenActiveMs;
+        if (screenIsActive) {
+          busyWakeMs = Math.min(busyWakeMs, screenActiveMs - screenStableMs + 50);
+        }
+        if (evState.id === "busy" && completionIdleRule && !recentlyInModal && !recentlyLeftModal && !screenIsActive) {
           const completionKey = matchesCompletionIdleRule(this.spec, ev, screen);
           if (completionKey) {
             const now2 = Date.now();
@@ -59022,8 +59099,13 @@ ${formatManifestValidationIssues2(validation.issues)}`,
             this.completionIdleFirstSeenAt = 0;
           }
         } else if (evState.id !== "busy") {
-          this.completionIdleKey = "";
-          this.completionIdleFirstSeenAt = 0;
+          if (!screenIsActive) {
+            this.completionIdleKey = "";
+            this.completionIdleFirstSeenAt = 0;
+          }
+        }
+        if (screenIsActive && this.currentStateId === "busy" && evState.id === (this.spec.default_state ?? "idle")) {
+          evState = this.lastBusyState ?? evState;
         }
         if (evState.id === "busy") {
           this.lastBusyAt = Date.now();
@@ -61718,7 +61800,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
               message: typeof modal?.message === "string" ? modal.message.trim() : "",
               buttons: Array.isArray(modal?.buttons) ? modal.buttons.map((button) => String(button).trim()) : []
             });
-            if (this.lastStatus !== "waiting_approval" && approvalFingerprint !== this.lastApprovalEventFingerprint) {
+            if (approvalFingerprint !== this.lastApprovalEventFingerprint) {
               this.lastApprovalEventFingerprint = approvalFingerprint;
               this.appendRuntimeSystemMessage(
                 this.formatApprovalRequestMessage(modal?.message, modal?.buttons),
@@ -69738,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);
@@ -69867,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) => {