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

package/dist/mesh/mesh-events.d.ts

@@ -17,6 +17,14 @@ export declare function triggerMeshQueue(components: DaemonComponents, meshId: s
 export declare function handleMeshForwardEvent(components: DaemonComponents, payload: Record<string, unknown>): {
     success: boolean;
     forwarded: number;
+    suppressed: boolean;
+    intentionalCleanupStop: boolean;
+    error?: undefined;
+} | {
+    success: boolean;
+    forwarded: number;
+    suppressed?: undefined;
+    intentionalCleanupStop?: undefined;
     error?: undefined;
 } | {
     success: boolean;

package/dist/mesh/mesh-ledger.d.ts

@@ -24,6 +24,43 @@ export interface MeshLedgerEntry {
     providerType?: string;
     payload: Record<string, unknown>;
 }
+export declare function isIntentionalCleanupStopEntry(entry: Pick<MeshLedgerEntry, 'kind' | 'payload'>): boolean;
+export interface MeshTaskCompletionEvidence {
+    source: 'agent_status_event';
+    event: 'agent:generating_completed' | 'agent:ready';
+    nodeId: string;
+    sessionId: string;
+    providerType?: string;
+    completedAt: string;
+    transcriptHandle: {
+        kind: 'provider_session' | 'runtime_session';
+        sessionId: string;
+        providerSessionId?: string;
+        finalSummaryAvailable: boolean;
+    };
+    git: {
+        status: 'deferred';
+        reason: string;
+    };
+    validation: {
+        status: 'deferred';
+        commandsRun: string[];
+        reason: string;
+    };
+    checkpoint: {
+        attempted: false;
+        reason: 'not_attempted_for_ordinary_completion';
+    };
+}
+export interface BuildTaskCompletionEvidenceOptions {
+    event: MeshTaskCompletionEvidence['event'];
+    nodeId: string;
+    sessionId: string;
+    providerType?: string;
+    providerSessionId?: string;
+    finalSummary?: string;
+    completedAt?: string;
+}
 export interface MeshLedgerSummary {
     meshId: string;
     totalEntries: number;
@@ -78,6 +115,7 @@ export interface AppendRemoteLedgerResult {
 }
 export declare const MAX_LEDGER_SLICE_LIMIT = 500;
 export declare function getLedgerDir(): string;
+export declare function buildTaskCompletionEvidence(opts: BuildTaskCompletionEvidenceOptions): MeshTaskCompletionEvidence;
 /**
  * Append a new entry to the mesh ledger.
  * Handles file creation, rotation on size overflow, and atomic writes.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.77-rc.49",
+  "version": "0.9.77-rc.50",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/commands/router.ts

@@ -882,6 +882,36 @@ export class DaemonCommandRouter {
         return record?.lifecycle === 'stopped' || record?.lifecycle === 'failed' || record?.lifecycle === 'interrupted';
     }
 
+    private async recordIntentionalMeshSessionStop(args: {
+        meshId: string;
+        nodeId: string;
+        node: any;
+        sessionId: string;
+        mode: RepoMeshSessionCleanupMode;
+        source: 'mesh_cleanup_sessions' | 'mesh_remove_node';
+        action: 'stop_session' | 'delete_session_force';
+    }): Promise<void> {
+        try {
+            const { appendLedgerEntry } = await import('../mesh/mesh-ledger.js');
+            appendLedgerEntry(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 : undefined,
+                },
+            });
+        } catch (e: any) {
+            LOG.warn('MeshCleanup', `Failed to record intentional cleanup stop for ${args.sessionId}: ${e?.message || e}`);
+        }
+    }
+
     private async cleanupMeshSessions(args: {
         meshId: string;
         nodeId: string;
@@ -889,6 +919,7 @@ export class DaemonCommandRouter {
         mode: RepoMeshSessionCleanupMode;
         sessionIds?: string[];
         dryRun?: boolean;
+        source?: 'mesh_cleanup_sessions' | 'mesh_remove_node';
     }): Promise<{ success: boolean; [key: string]: unknown }> {
         if (args.mode === 'preserve') {
             return { success: true, mode: 'preserve', matchedCount: 0, stoppedSessionIds: [], deletedSessionIds: [], skippedSessionIds: [] };
@@ -908,6 +939,21 @@ export class DaemonCommandRouter {
         const deleteUnsupportedSessionIds: string[] = [];
         const recordsRemainSessionIds: string[] = [];
         const errors: Array<{ sessionId: string; error: string }> = [];
+        const cleanupSource = args.source || 'mesh_cleanup_sessions';
+        const markedIntentionalStopSessionIds = new Set<string>();
+        const markIntentionalStop = async (sessionId: string, action: 'stop_session' | 'delete_session_force') => {
+            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,
@@ -932,7 +978,10 @@ export class DaemonCommandRouter {
             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);
@@ -951,6 +1000,7 @@ export class DaemonCommandRouter {
                 }
 
                 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;
@@ -963,6 +1013,7 @@ export class DaemonCommandRouter {
                     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: any) {
@@ -1989,6 +2040,7 @@ export class DaemonCommandRouter {
                         mode,
                         sessionIds,
                         dryRun: args?.dryRun === true,
+                        source: 'mesh_cleanup_sessions',
                     });
                     return result;
                 } catch (e: any) {
@@ -2137,7 +2189,7 @@ export class DaemonCommandRouter {
                     );
                     let sessionCleanup: Record<string, unknown> | undefined;
                     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 };
                     }
 

package/src/mesh/mesh-events.ts

@@ -3,7 +3,7 @@ import { loadConfig } from '../config/config.js';
 import { getMesh, getMeshByRepo } from '../config/mesh-config.js';
 import { detectCLI } from '../detection/cli-detector.js';
 import { LOG } from '../logging/logger.js';
-import { appendLedgerEntry, getSessionRecoveryContext } from './mesh-ledger.js';
+import { appendLedgerEntry, buildTaskCompletionEvidence, getSessionRecoveryContext, isIntentionalCleanupStopEntry, readLedgerEntries } from './mesh-ledger.js';
 import type { MeshLedgerKind, SessionRecoveryContext } from './mesh-ledger.js';
 import { claimNextTask, updateSessionTaskStatus, enqueueTask, updateTaskStatus, getQueue, recordTaskAutoLaunch } from './mesh-work-queue.js';
 
@@ -90,6 +90,46 @@ function getMeshWithCache(components: DaemonComponents, meshId: string): any | u
     return components.router?.getCachedInlineMesh(meshId);
 }
 
+const INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS = 30 * 60 * 1000;
+
+function isIntentionalCleanupStopMetadata(event: Record<string, unknown>): boolean {
+    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: string, sessionId?: string, nodeId?: string): boolean {
+    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: {
+    event: string;
+    meshId: string;
+    metadataEvent: Record<string, unknown>;
+    sessionId?: string;
+    nodeId?: string;
+}): boolean {
+    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);
+}
+
 
 export function tryAssignQueueTask(
     components: DaemonComponents,
@@ -526,6 +566,23 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
     event: string;
     metadataEvent: Record<string, unknown>;
 }) {
+    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 || undefined,
+        nodeId: eventNodeId || undefined,
+    });
+    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 };
+    }
+
     // ── Task Queue & Ledger ──
     let completedTaskForLedger: { id?: string } | null = null;
     if (args.event === 'agent:generating_completed') {
@@ -565,6 +622,14 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
                         completedViaReady: true,
                         providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || undefined,
                         finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || undefined,
+                        evidence: buildTaskCompletionEvidence({
+                            event: 'agent:ready',
+                            nodeId,
+                            sessionId,
+                            providerType: providerType || undefined,
+                            providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || undefined,
+                            finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || undefined,
+                        }),
                     },
                 });
             } catch (e: any) {
@@ -601,17 +666,31 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
     const ledgerKind = EVENT_TO_LEDGER_KIND[args.event];
     if (ledgerKind) {
         try {
+            const ledgerNodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || undefined;
+            const ledgerSessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId) || undefined;
+            const ledgerProviderType = readNonEmptyString(args.metadataEvent.providerType) || undefined;
+            const completionEvidence = ledgerKind === 'task_completed' && ledgerNodeId && ledgerSessionId
+                ? buildTaskCompletionEvidence({
+                    event: 'agent:generating_completed',
+                    nodeId: ledgerNodeId,
+                    sessionId: ledgerSessionId,
+                    providerType: ledgerProviderType,
+                    providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || undefined,
+                    finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || undefined,
+                })
+                : undefined;
             appendLedgerEntry(args.meshId, {
                 kind: ledgerKind,
-                nodeId: readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || undefined,
-                sessionId: resolveEventSessionId(args.metadataEvent, args.sourceInstanceId) || undefined,
-                providerType: readNonEmptyString(args.metadataEvent.providerType) || undefined,
+                nodeId: ledgerNodeId,
+                sessionId: ledgerSessionId,
+                providerType: ledgerProviderType,
                 payload: {
                     event: args.event,
                     nodeLabel: args.nodeLabel,
                     taskId: completedTaskForLedger?.id || undefined,
                     providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || undefined,
                     finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || undefined,
+                    evidence: completionEvidence,
                 },
             });
         } catch (e: any) {
@@ -745,6 +824,13 @@ export function handleMeshForwardEvent(components: DaemonComponents, payload: Re
             providerType: readNonEmptyString(payload.providerType),
             providerSessionId: readNonEmptyString(payload.providerSessionId),
             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),
         },
     });
 }

package/src/mesh/mesh-ledger.ts

@@ -49,6 +49,56 @@ export interface MeshLedgerEntry {
     payload: Record<string, unknown>;
 }
 
+export function isIntentionalCleanupStopEntry(entry: Pick<MeshLedgerEntry, 'kind' | 'payload'>): boolean {
+    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 as Record<string, unknown>
+        : {};
+    return payload.intentional === true
+        && (payload.reason === 'operator_cleanup'
+            || payload.intentionalStopReason === 'operator_cleanup'
+            || payload.source === 'mesh_cleanup_sessions'
+            || payload.source === 'mesh_remove_node');
+}
+
+export interface MeshTaskCompletionEvidence {
+    source: 'agent_status_event';
+    event: 'agent:generating_completed' | 'agent:ready';
+    nodeId: string;
+    sessionId: string;
+    providerType?: string;
+    completedAt: string;
+    transcriptHandle: {
+        kind: 'provider_session' | 'runtime_session';
+        sessionId: string;
+        providerSessionId?: string;
+        finalSummaryAvailable: boolean;
+    };
+    git: {
+        status: 'deferred';
+        reason: string;
+    };
+    validation: {
+        status: 'deferred';
+        commandsRun: string[];
+        reason: string;
+    };
+    checkpoint: {
+        attempted: false;
+        reason: 'not_attempted_for_ordinary_completion';
+    };
+}
+
+export interface BuildTaskCompletionEvidenceOptions {
+    event: MeshTaskCompletionEvidence['event'];
+    nodeId: string;
+    sessionId: string;
+    providerType?: string;
+    providerSessionId?: string;
+    finalSummary?: string;
+    completedAt?: string;
+}
+
 export interface MeshLedgerSummary {
     meshId: string;
     totalEntries: number;
@@ -138,6 +188,38 @@ function getRotatedPath(meshId: string, index: number): string {
 
 // ─── Core API ───────────────────────────────────
 
+export function buildTaskCompletionEvidence(opts: BuildTaskCompletionEvidenceOptions): MeshTaskCompletionEvidence {
+    const providerSessionId = opts.providerSessionId?.trim() || undefined;
+    const providerType = opts.providerType?.trim() || undefined;
+    return {
+        source: 'agent_status_event',
+        event: opts.event,
+        nodeId: opts.nodeId,
+        sessionId: opts.sessionId,
+        providerType,
+        completedAt: opts.completedAt || 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',
+        },
+    };
+}
+
 /**
  * Append a new entry to the mesh ledger.
  * Handles file creation, rotation on size overflow, and atomic writes.
@@ -345,13 +427,17 @@ export function getLedgerSummary(meshId: string): MeshLedgerSummary {
             case 'task_dispatched': summary.taskDispatched++; break;
             case 'task_completed': 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++; break;
+            case 'task_stalled': {
+                if (!isIntentionalCleanupStopEntry(entry)) summary.taskStalled++;
+                break;
+            }
             case 'session_launched': summary.sessionLaunched++; break;
             case 'checkpoint_created': summary.checkpointCreated++; break;
         }
@@ -422,6 +508,7 @@ export function getSessionRecoveryContext(
         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') {
             // A completion or new dispatch breaks the consecutive failure chain