@adhdev/daemon-standalone 0.9.77-rc.49 → 0.9.77-rc.50

package/dist/index.js

@@ -22897,13 +22897,20 @@ Follow these recovery rules:
       MAX_LEDGER_SLICE_LIMIT: () => MAX_LEDGER_SLICE_LIMIT,
       appendLedgerEntry: () => appendLedgerEntry,
       appendRemoteLedgerEntries: () => appendRemoteLedgerEntries,
+      buildTaskCompletionEvidence: () => buildTaskCompletionEvidence,
       getLedgerDir: () => getLedgerDir,
       getLedgerSummary: () => getLedgerSummary,
       getSessionRecoveryContext: () => getSessionRecoveryContext,
+      isIntentionalCleanupStopEntry: () => isIntentionalCleanupStopEntry,
       meshLedgerEvents: () => meshLedgerEvents,
       readLedgerEntries: () => readLedgerEntries,
       readLedgerSlice: () => readLedgerSlice
     });
+    function isIntentionalCleanupStopEntry(entry) {
+      if (entry.kind !== "session_stopped" && entry.kind !== "task_failed" && entry.kind !== "task_stalled") return false;
+      const payload = entry.payload && typeof entry.payload === "object" && !Array.isArray(entry.payload) ? entry.payload : {};
+      return payload.intentional === true && (payload.reason === "operator_cleanup" || payload.intentionalStopReason === "operator_cleanup" || payload.source === "mesh_cleanup_sessions" || payload.source === "mesh_remove_node");
+    }
     function getLedgerDir() {
       const dir = (0, import_path3.join)(getConfigDir(), LEDGER_DIR_NAME);
       if (!(0, import_fs3.existsSync)(dir)) {
@@ -22919,6 +22926,37 @@ Follow these recovery rules:
       const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
       return (0, import_path3.join)(getLedgerDir(), `${safe}.${index}.jsonl`);
     }
+    function buildTaskCompletionEvidence(opts) {
+      const providerSessionId = opts.providerSessionId?.trim() || void 0;
+      const providerType = opts.providerType?.trim() || void 0;
+      return {
+        source: "agent_status_event",
+        event: opts.event,
+        nodeId: opts.nodeId,
+        sessionId: opts.sessionId,
+        providerType,
+        completedAt: opts.completedAt || (/* @__PURE__ */ new Date()).toISOString(),
+        transcriptHandle: {
+          kind: providerSessionId ? "provider_session" : "runtime_session",
+          sessionId: opts.sessionId,
+          providerSessionId,
+          finalSummaryAvailable: typeof opts.finalSummary === "string" && opts.finalSummary.trim().length > 0
+        },
+        git: {
+          status: "deferred",
+          reason: "ordinary_completion_git_status_not_checked"
+        },
+        validation: {
+          status: "deferred",
+          commandsRun: [],
+          reason: "ordinary_completion_validation_not_run"
+        },
+        checkpoint: {
+          attempted: false,
+          reason: "not_attempted_for_ordinary_completion"
+        }
+      };
+    }
     function appendLedgerEntry(meshId, partial2) {
       const entry = {
         id: (0, import_crypto4.randomUUID)(),
@@ -23079,15 +23117,17 @@ Follow these recovery rules:
             summary.taskCompleted++;
             break;
           case "task_failed": {
+            if (isIntentionalCleanupStopEntry(entry)) break;
             summary.taskFailed++;
             if (new Date(entry.timestamp).getTime() >= recentFailureCutoff) {
               summary.recentFailures++;
             }
             break;
           }
-          case "task_stalled":
-            summary.taskStalled++;
+          case "task_stalled": {
+            if (!isIntentionalCleanupStopEntry(entry)) summary.taskStalled++;
             break;
+          }
           case "session_launched":
             summary.sessionLaunched++;
             break;
@@ -23126,6 +23166,7 @@ Follow these recovery rules:
         if (new Date(e.timestamp).getTime() < recentWindow) break;
         if (opts.nodeId && e.nodeId !== opts.nodeId) continue;
         if (e.kind === "task_failed") {
+          if (isIntentionalCleanupStopEntry(e)) continue;
           consecutiveNodeFailures++;
         } else if (e.kind === "task_completed" || e.kind === "task_dispatched") {
           break;
@@ -23795,6 +23836,28 @@ Follow these recovery rules:
       if (localMesh) return localMesh;
       return components.router?.getCachedInlineMesh(meshId);
     }
+    function isIntentionalCleanupStopMetadata(event) {
+      return event.intentional === true || event.intentionalStop === true || event.operatorCleanup === true || event.reason === "operator_cleanup" || event.stopReason === "operator_cleanup" || event.cleanupReason === "operator_cleanup" || event.source === "mesh_cleanup_sessions" || event.source === "mesh_remove_node";
+    }
+    function hasRecentIntentionalCleanupStop(meshId, sessionId, nodeId) {
+      if (!sessionId && !nodeId) return false;
+      const cutoff = Date.now() - INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS;
+      const entries = readLedgerEntries(meshId);
+      for (let i = entries.length - 1; i >= 0; i--) {
+        const entry = entries[i];
+        const timestamp = new Date(entry.timestamp).getTime();
+        if (!Number.isNaN(timestamp) && timestamp < cutoff) break;
+        if (!isIntentionalCleanupStopEntry(entry)) continue;
+        if (sessionId && entry.sessionId === sessionId) return true;
+        if (!sessionId && nodeId && entry.nodeId === nodeId) return true;
+      }
+      return false;
+    }
+    function shouldSuppressIntentionalCleanupStop(args) {
+      if (args.event !== "agent:stopped" && args.event !== "monitor:long_generating") return false;
+      if (isIntentionalCleanupStopMetadata(args.metadataEvent)) return true;
+      return hasRecentIntentionalCleanupStop(args.meshId, args.sessionId, args.nodeId);
+    }
     function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType) {
       const task = claimNextTask(meshId, nodeId, sessionId);
       if (!task) {
@@ -24131,6 +24194,22 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
       return "";
     }
     function injectMeshSystemMessage(components, args) {
+      const eventSessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
+      const eventNodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
+      const intentionalCleanupStop = shouldSuppressIntentionalCleanupStop({
+        event: args.event,
+        meshId: args.meshId,
+        metadataEvent: args.metadataEvent,
+        sessionId: eventSessionId || void 0,
+        nodeId: eventNodeId || void 0
+      });
+      if (intentionalCleanupStop) {
+        if (eventSessionId && eventNodeId) {
+          remoteIdleSessions.delete(`${eventNodeId}:${eventSessionId}`);
+        }
+        LOG2.info("MeshEvents", `Suppressed ${args.event} for intentionally cleanup-stopped session ${eventSessionId || "(unknown session)"}`);
+        return { success: true, forwarded: 0, suppressed: true, intentionalCleanupStop: true };
+      }
       let completedTaskForLedger = null;
       if (args.event === "agent:generating_completed") {
         const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
@@ -24164,7 +24243,15 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
                 taskId: completedTask.id,
                 completedViaReady: true,
                 providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || void 0,
-                finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || void 0
+                finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || void 0,
+                evidence: buildTaskCompletionEvidence({
+                  event: "agent:ready",
+                  nodeId,
+                  sessionId,
+                  providerType: providerType || void 0,
+                  providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || void 0,
+                  finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || void 0
+                })
               }
             });
           } catch (e) {
@@ -24199,17 +24286,29 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
       const ledgerKind = EVENT_TO_LEDGER_KIND[args.event];
       if (ledgerKind) {
         try {
+          const ledgerNodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || void 0;
+          const ledgerSessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId) || void 0;
+          const ledgerProviderType = readNonEmptyString(args.metadataEvent.providerType) || void 0;
+          const completionEvidence = ledgerKind === "task_completed" && ledgerNodeId && ledgerSessionId ? buildTaskCompletionEvidence({
+            event: "agent:generating_completed",
+            nodeId: ledgerNodeId,
+            sessionId: ledgerSessionId,
+            providerType: ledgerProviderType,
+            providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || void 0,
+            finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || void 0
+          }) : void 0;
           appendLedgerEntry(args.meshId, {
             kind: ledgerKind,
-            nodeId: readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || void 0,
-            sessionId: resolveEventSessionId(args.metadataEvent, args.sourceInstanceId) || void 0,
-            providerType: readNonEmptyString(args.metadataEvent.providerType) || void 0,
+            nodeId: ledgerNodeId,
+            sessionId: ledgerSessionId,
+            providerType: ledgerProviderType,
             payload: {
               event: args.event,
               nodeLabel: args.nodeLabel,
               taskId: completedTaskForLedger?.id || void 0,
               providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || void 0,
-              finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || void 0
+              finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || void 0,
+              evidence: completionEvidence
             }
           });
         } catch (e) {
@@ -24325,7 +24424,14 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
           targetSessionId: readNonEmptyString(payload.targetSessionId) || readNonEmptyString(payload.sessionId) || readNonEmptyString(payload.instanceId),
           providerType: readNonEmptyString(payload.providerType),
           providerSessionId: readNonEmptyString(payload.providerSessionId),
-          finalSummary: readNonEmptyString(payload.finalSummary) || readNonEmptyString(payload.summary)
+          finalSummary: readNonEmptyString(payload.finalSummary) || readNonEmptyString(payload.summary),
+          intentional: payload.intentional === true,
+          intentionalStop: payload.intentionalStop === true,
+          operatorCleanup: payload.operatorCleanup === true,
+          reason: readNonEmptyString(payload.reason),
+          stopReason: readNonEmptyString(payload.stopReason),
+          cleanupReason: readNonEmptyString(payload.cleanupReason),
+          source: readNonEmptyString(payload.source)
         }
       });
     }
@@ -24366,6 +24472,7 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
     var pendingMeshCoordinatorEvents;
     var MESH_COORDINATOR_EVENTS;
     var EVENT_TO_LEDGER_KIND;
+    var INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS;
     var autoLaunchInProgress;
     var autoLaunchCooldownUntil;
     var AUTO_LAUNCH_COOLDOWN_MS;
@@ -24395,6 +24502,7 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
           "agent:stopped": "task_failed",
           "monitor:long_generating": "task_stalled"
         };
+        INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS = 30 * 60 * 1e3;
         autoLaunchInProgress = /* @__PURE__ */ new Set();
         autoLaunchCooldownUntil = /* @__PURE__ */ new Map();
         AUTO_LAUNCH_COOLDOWN_MS = 5e3;
@@ -46163,6 +46271,27 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       isCompletedHostedSession(record2) {
         return record2?.lifecycle === "stopped" || record2?.lifecycle === "failed" || record2?.lifecycle === "interrupted";
       }
+      async recordIntentionalMeshSessionStop(args) {
+        try {
+          const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+          appendLedgerEntry2(args.meshId, {
+            kind: "session_stopped",
+            nodeId: args.nodeId,
+            sessionId: args.sessionId,
+            payload: {
+              intentional: true,
+              reason: "operator_cleanup",
+              intentionalStopReason: "operator_cleanup",
+              source: args.source,
+              cleanupMode: args.mode,
+              action: args.action,
+              workspace: typeof args.node?.workspace === "string" ? args.node.workspace : void 0
+            }
+          });
+        } catch (e) {
+          LOG2.warn("MeshCleanup", `Failed to record intentional cleanup stop for ${args.sessionId}: ${e?.message || e}`);
+        }
+      }
       async cleanupMeshSessions(args) {
         if (args.mode === "preserve") {
           return { success: true, mode: "preserve", matchedCount: 0, stoppedSessionIds: [], deletedSessionIds: [], skippedSessionIds: [] };
@@ -46179,6 +46308,21 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         const deleteUnsupportedSessionIds = [];
         const recordsRemainSessionIds = [];
         const errors = [];
+        const cleanupSource = args.source || "mesh_cleanup_sessions";
+        const markedIntentionalStopSessionIds = /* @__PURE__ */ new Set();
+        const markIntentionalStop = async (sessionId, action) => {
+          if (args.dryRun || markedIntentionalStopSessionIds.has(sessionId)) return;
+          markedIntentionalStopSessionIds.add(sessionId);
+          await this.recordIntentionalMeshSessionStop({
+            meshId: args.meshId,
+            nodeId: args.nodeId,
+            node: args.node,
+            sessionId,
+            mode: args.mode,
+            source: cleanupSource,
+            action
+          });
+        };
         const matchedBySurfaceKind = {
           live_runtime: 0,
           recovery_snapshot: 0,
@@ -46201,7 +46345,10 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
           try {
             if (args.mode === "stop") {
               if (!completed) {
-                if (!args.dryRun) await this.deps.sessionHostControl.stopSession(sessionId);
+                if (!args.dryRun) {
+                  await markIntentionalStop(sessionId, "stop_session");
+                  await this.deps.sessionHostControl.stopSession(sessionId);
+                }
                 stoppedSessionIds.push(sessionId);
               } else {
                 skippedSessionIds.push(sessionId);
@@ -46218,6 +46365,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
               continue;
             }
             if (args.mode === "stop_and_delete") {
+              if (!completed) await markIntentionalStop(sessionId, "delete_session_force");
               if (!args.dryRun) await this.deps.sessionHostControl.deleteSession(sessionId, { force: true });
               deletedSessionIds.push(sessionId);
               continue;
@@ -46229,6 +46377,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
               recordsRemainSessionIds.push(sessionId);
               if (args.mode === "stop_and_delete" && !completed) {
                 try {
+                  await markIntentionalStop(sessionId, "stop_session");
                   await this.deps.sessionHostControl.stopSession(sessionId);
                   stoppedSessionIds.push(sessionId);
                 } catch (stopError) {
@@ -47129,7 +47278,8 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                 node,
                 mode,
                 sessionIds,
-                dryRun: args?.dryRun === true
+                dryRun: args?.dryRun === true,
+                source: "mesh_cleanup_sessions"
               });
               return result;
             } catch (e) {
@@ -47264,7 +47414,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
               );
               let sessionCleanup;
               if (node && sessionCleanupMode !== "preserve") {
-                sessionCleanup = await this.cleanupMeshSessions({ meshId, nodeId, node, mode: sessionCleanupMode });
+                sessionCleanup = await this.cleanupMeshSessions({ meshId, nodeId, node, mode: sessionCleanupMode, source: "mesh_remove_node" });
                 if (sessionCleanup.success === false) return { success: false, removed: false, sessionCleanup };
               }
               let worktreeCleanup;