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

package/dist/commands/router.d.ts

@@ -93,6 +93,7 @@ export declare class DaemonCommandRouter {
     private cleanupLocalWorktreeNode;
     private getWorktreeForceCleanupConvergence;
     private isCompletedHostedSession;
+    private recordIntentionalMeshSessionStop;
     private cleanupMeshSessions;
     private traceSessionHostAction;
     /**

package/dist/index.js

@@ -798,13 +798,20 @@ __export(mesh_ledger_exports, {
   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)) {
@@ -820,6 +827,37 @@ function getRotatedPath(meshId, index) {
   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, partial) {
   const entry = {
     id: (0, import_crypto4.randomUUID)(),
@@ -980,15 +1018,17 @@ function getLedgerSummary(meshId) {
         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;
@@ -1027,6 +1067,7 @@ function getSessionRecoveryContext(meshId, opts) {
     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;
@@ -1669,6 +1710,28 @@ function getMeshWithCache(components, meshId) {
   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) {
@@ -2005,6 +2068,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}`);
+    }
+    LOG.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);
@@ -2038,7 +2117,15 @@ function injectMeshSystemMessage(components, args) {
             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) {
@@ -2073,17 +2160,29 @@ function injectMeshSystemMessage(components, args) {
   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) {
@@ -2199,7 +2298,14 @@ function handleMeshForwardEvent(components, payload) {
       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)
     }
   });
 }
@@ -2235,7 +2341,7 @@ function setupMeshEventForwarding(components) {
     });
   });
 }
-var remoteIdleSessions, MAX_PENDING_EVENTS, pendingMeshCoordinatorEvents, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS;
+var remoteIdleSessions, MAX_PENDING_EVENTS, pendingMeshCoordinatorEvents, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS;
 var init_mesh_events = __esm({
   "src/mesh/mesh-events.ts"() {
     "use strict";
@@ -2262,6 +2368,7 @@ var init_mesh_events = __esm({
       "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;
@@ -24211,6 +24318,27 @@ var DaemonCommandRouter = class {
   isCompletedHostedSession(record) {
     return record?.lifecycle === "stopped" || record?.lifecycle === "failed" || record?.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) {
+      LOG.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: [] };
@@ -24227,6 +24355,21 @@ var DaemonCommandRouter = class {
     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,
@@ -24249,7 +24392,10 @@ var DaemonCommandRouter = class {
       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);
@@ -24266,6 +24412,7 @@ var DaemonCommandRouter = class {
           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;
@@ -24277,6 +24424,7 @@ var DaemonCommandRouter = class {
           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) {
@@ -25177,7 +25325,8 @@ var DaemonCommandRouter = class {
             node,
             mode,
             sessionIds,
-            dryRun: args?.dryRun === true
+            dryRun: args?.dryRun === true,
+            source: "mesh_cleanup_sessions"
           });
           return result;
         } catch (e) {
@@ -25312,7 +25461,7 @@ var DaemonCommandRouter = class {
           );
           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;