@adhdev/daemon-core 0.9.82-rc.369 → 0.9.82-rc.370

package/src/mesh/mesh-events-coordinator.ts

@@ -1754,98 +1754,35 @@ export function shouldForceInjectMeshEvent(eventName: unknown): boolean {
     return typeof eventName === 'string' && MESH_FORCE_INJECT_EVENTS.has(eventName);
 }
 
-function injectMeshSystemMessage(components: DaemonComponents, args: {
-    meshId: string;
-    sourceInstanceId?: string;
-    nodeId?: string;
-    nodeLabel: string;
-    event: string;
-    metadataEvent: Record<string, unknown>;
-}) {
-    const eventSessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
-    const eventNodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
-
-    // EVTTRACE correlation context for this event's coordinator-side lifecycle (queue /
-    // dedup / suppress). Observation only — never read by any decision below.
-    const traceCtx = {
-        taskId: args.metadataEvent.taskId,
-        sessionId: eventSessionId,
-        nodeId: eventNodeId,
-        meshId: args.meshId,
-        event: args.event,
-    };
-
-    const sourceSession = args.sourceInstanceId
-        ? components.instanceManager.getInstance(args.sourceInstanceId)
-        : undefined;
-    const workerCoordinatorDaemonId = readNonEmptyString(
-        (sourceSession?.getState()?.settings as Record<string, unknown>)?.meshCoordinatorDaemonId,
-    );
-    // Session-level routing anchor (multi-coordinator). Prefer the LIVE worker session's
-    // stamp; fall back to a relayed value carried in metadataEvent.meshCoordinatorSessionId
-    // (a remote worker's completion arrives via handleMeshForwardEvent with no local
-    // sourceSession, so the stamp can only ride in the relayed metadata). Empty on legacy /
-    // version-skewed dispatches → the event stays daemon-broadcast (no regression).
-    const workerCoordinatorSessionId = readNonEmptyString(
-        (sourceSession?.getState()?.settings as Record<string, unknown>)?.meshCoordinatorSessionId,
-    ) || readNonEmptyString(args.metadataEvent.meshCoordinatorSessionId);
-
-    // T2: a summary-less completion (and any non-completion status-sync event) carries no
-    // assistant text on the event, so resolveMeshSurfacedSessionPreview had nothing to surface
-    // and the coordinator's inbox mirror stayed stuck on the first dispatched user task. When
-    // THIS daemon hosts the live worker instance (sourceSession present), derive the worker's
-    // latest display message straight from its transcript and attach it to the event as
-    // lastMessagePreview/lastMessageRole/lastMessageAt. resolveMeshSurfacedSessionPreview reads
-    // these as an assistant-only fallback; they also ride the pending-queue + P2P relay
-    // (handleMeshForwardEvent whitelist) so a remote coordinator can surface them. A remote
-    // coordinator has no local instance and keeps relying on the relayed fields — unchanged.
-    const enrichedMetadataEvent = ((): Record<string, unknown> => {
-        const last = sourceSession ? getLastDisplayMessage(sourceSession.getState()) : null;
-        if (!last || !last.preview) return args.metadataEvent;
-        return {
-            ...args.metadataEvent,
-            lastMessagePreview: last.preview,
-            lastMessageRole: last.role,
-            ...(last.receivedAt > 0 ? { lastMessageAt: last.receivedAt } : {}),
-        };
-    })();
-
-    // R2: cloud P2P dashboard metadata sync. The cloud daemon used to do this from its own
-    // relay listener; now the single core forwarder invokes the injected hook (no-op on
-    // standalone) so the event path stays single-listener and the local code path is identical
-    // across standalone and cloud.
-    if (components.onMeshCoordinatorEventForwarded) {
-        try {
-            // T: the coordinator surfaces a remote worker's session but holds no local
-            // instance for it, so the status snapshot can't derive a preview and the
-            // mirror would stay stuck on the first dispatched user task. Resolve the
-            // worker's latest assistant reply (carried on the completion event's
-            // finalSummary / workerResult) into a preview the mirror can stamp, so the
-            // mobile inbox reflects the assistant response. Completion events carry assistant
-            // text as finalSummary; a summary-less completion / status sync falls back to the
-            // worker's latest assistant display message (enrichedMetadataEvent.lastMessage*).
-            // For a mid-turn user-only event this is undefined and the prior surfaced preview
-            // is preserved downstream (no clobber).
-            const surfacedPreview = resolveMeshSurfacedSessionPreview(enrichedMetadataEvent);
-            components.onMeshCoordinatorEventForwarded({
-                event: args.event,
-                meshId: args.meshId,
-                nodeId: eventNodeId || undefined,
-                ...enrichedMetadataEvent,
-                // Ensure a `workspace` field reaches updateMeshOwnedSession even when the
-                // worker provider event only carried `workspaceName`. The merge spread of
-                // metadataEvent above wins when it already has a non-empty `workspace`.
-                workspace: readNonEmptyString(args.metadataEvent.workspace)
-                    || readNonEmptyString(args.metadataEvent.workspaceName)
-                    || undefined,
-                ...(surfacedPreview ? {
-                    meshSessionLastMessagePreview: surfacedPreview.preview,
-                    meshSessionLastMessageRole: surfacedPreview.role,
-                    meshSessionLastMessageAt: surfacedPreview.receivedAt || undefined,
-                } : {}),
-            });
-        } catch { /* dashboard metadata sync is best-effort */ }
-    }
+// Coordinator-side suppression/reconcile gate for an incoming mesh event. Each clause is a
+// closed dedup/suppression concern that only inspects the event + already-resolved context and
+// either (a) returns a `suppress` result the caller forwards verbatim, (b) returns a `reconcile`
+// signal carrying the rewritten metadataEvent for the caller to re-inject as
+// agent:generating_completed, or (c) returns null to let the event fall through to the
+// terminal/ledger machinery. Extracted verbatim from injectMeshSystemMessage — no behavior
+// change; the only side effects (best-effort remote-idle cleanup, LOG, trace) fire on the same
+// paths as before.
+function evaluateMeshEventSuppression(
+    args: {
+        meshId: string;
+        sourceInstanceId?: string;
+        nodeId?: string;
+        nodeLabel: string;
+        event: string;
+        metadataEvent: Record<string, unknown>;
+    },
+    ctx: {
+        traceCtx: Parameters<typeof traceMeshEventDrop>[1];
+        eventSessionId: string;
+        eventNodeId: string;
+        eventTimestamp: number | null;
+        workerCoordinatorDaemonId: string | undefined;
+    },
+):
+    | { kind: 'suppress'; result: { success: true; forwarded: 0; suppressed: true; [extra: string]: unknown } }
+    | { kind: 'reconcile'; metadataEvent: Record<string, unknown> }
+    | null {
+    const { traceCtx, eventSessionId, eventNodeId, eventTimestamp, workerCoordinatorDaemonId } = ctx;
 
     const intentionalCleanupStop = shouldSuppressIntentionalCleanupStop({
         event: args.event,
@@ -1862,7 +1799,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         }
         LOG.info('MeshEvents', `Suppressed ${args.event} for intentionally cleanup-stopped session ${eventSessionId || '(unknown session)'}`);
         traceMeshEventDrop('intentional_cleanup_stop', traceCtx);
-        return { success: true, forwarded: 0, suppressed: true, intentionalCleanupStop: true };
+        return { kind: 'suppress', result: { success: true, forwarded: 0, suppressed: true, intentionalCleanupStop: true } };
     }
 
     if (args.event === 'monitor:no_progress') {
@@ -1875,21 +1812,20 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         });
         if (reconciledCompletion?.source === 'no_progress_reconciliation') {
             LOG.info('MeshEvents', `Reconciled no-progress monitor to completion for session ${eventSessionId || '(unknown session)'}`);
-            return injectMeshSystemMessage(components, {
-                ...args,
-                event: 'agent:generating_completed',
-                metadataEvent: reconciledCompletion,
-            });
+            return { kind: 'reconcile', metadataEvent: reconciledCompletion };
         }
         if (reconciledCompletion?.source === 'no_progress_terminal_ledger_suppression') {
             LOG.info('MeshEvents', `Suppressed no-progress monitor because terminal ledger evidence already exists for session ${eventSessionId || '(unknown session)'}`);
             traceMeshEventDrop('no_progress_terminal_ledger_suppression', traceCtx, `terminalKind=${reconciledCompletion.terminalLedgerKind}`);
             return {
-                success: true,
-                forwarded: 0,
-                suppressed: true,
-                terminalLedgerEvidence: true,
-                terminalLedgerKind: reconciledCompletion.terminalLedgerKind,
+                kind: 'suppress',
+                result: {
+                    success: true,
+                    forwarded: 0,
+                    suppressed: true,
+                    terminalLedgerEvidence: true,
+                    terminalLedgerKind: reconciledCompletion.terminalLedgerKind,
+                },
             };
         }
     }
@@ -1897,10 +1833,9 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
     if (isDuplicateRefineTerminalEvent(args.meshId, args.event, args.metadataEvent)) {
         LOG.info('MeshEvents', `Suppressed duplicate ${args.event} for refine job ${readRefineJobId({ metadataEvent: args.metadataEvent })}`);
         traceMeshEventDrop('duplicate_refine_terminal', traceCtx);
-        return { success: true, forwarded: 0, suppressed: true, duplicateRefineTerminalEvent: true };
+        return { kind: 'suppress', result: { success: true, forwarded: 0, suppressed: true, duplicateRefineTerminalEvent: true } };
     }
 
-    const eventTimestamp = readEventTimestamp(args.metadataEvent.timestamp);
     if (args.event === 'agent:waiting_approval' && eventSessionId) {
         const duplicateApproval = isDuplicateMeshApprovalEvent({
             meshId: args.meshId,
@@ -1913,7 +1848,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         if (duplicateApproval) {
             LOG.info('MeshEvents', `Suppressed duplicate approval event for mesh ${args.meshId} session ${eventSessionId}`);
             traceMeshEventDrop('duplicate_approval', traceCtx);
-            return { success: true, forwarded: 0, suppressed: true, duplicateApproval: true };
+            return { kind: 'suppress', result: { success: true, forwarded: 0, suppressed: true, duplicateApproval: true } };
         }
     }
     if (args.event === 'agent:generating_completed' && eventSessionId) {
@@ -1965,7 +1900,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
                 ) {
                     LOG.info('MeshEvents', `Suppressed duplicate completion with existing terminal ledger evidence for mesh ${args.meshId} session ${eventSessionId}`);
                     traceMeshEventDrop('duplicate_completion_terminal_ledger', traceCtx);
-                    return { success: true, forwarded: 0, suppressed: true, duplicateCompletion: true, terminalLedgerEvidence: true };
+                    return { kind: 'suppress', result: { success: true, forwarded: 0, suppressed: true, duplicateCompletion: true, terminalLedgerEvidence: true } };
                 }
             }
         }
@@ -1984,7 +1919,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         if (duplicateCompletion) {
             LOG.info('MeshEvents', `Suppressed duplicate completion for mesh ${args.meshId} session ${eventSessionId}`);
             traceMeshEventDrop('duplicate_completion', traceCtx);
-            return { success: true, forwarded: 0, suppressed: true, duplicateCompletion: true };
+            return { kind: 'suppress', result: { success: true, forwarded: 0, suppressed: true, duplicateCompletion: true } };
         }
     }
     if (args.event === 'agent:stopped' && eventSessionId) {
@@ -2003,8 +1938,126 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         if (duplicateStopped) {
             LOG.info('MeshEvents', `Suppressed duplicate stopped event for mesh ${args.meshId} session ${eventSessionId}`);
             traceMeshEventDrop('duplicate_stopped', traceCtx);
-            return { success: true, forwarded: 0, suppressed: true, duplicateStopped: true };
+            return { kind: 'suppress', result: { success: true, forwarded: 0, suppressed: true, duplicateStopped: true } };
+        }
+    }
+
+    return null;
+}
+
+function injectMeshSystemMessage(components: DaemonComponents, args: {
+    meshId: string;
+    sourceInstanceId?: string;
+    nodeId?: string;
+    nodeLabel: string;
+    event: string;
+    metadataEvent: Record<string, unknown>;
+}) {
+    const eventSessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
+    const eventNodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
+
+    // EVTTRACE correlation context for this event's coordinator-side lifecycle (queue /
+    // dedup / suppress). Observation only — never read by any decision below.
+    const traceCtx = {
+        taskId: args.metadataEvent.taskId,
+        sessionId: eventSessionId,
+        nodeId: eventNodeId,
+        meshId: args.meshId,
+        event: args.event,
+    };
+
+    const sourceSession = args.sourceInstanceId
+        ? components.instanceManager.getInstance(args.sourceInstanceId)
+        : undefined;
+    const workerCoordinatorDaemonId = readNonEmptyString(
+        (sourceSession?.getState()?.settings as Record<string, unknown>)?.meshCoordinatorDaemonId,
+    );
+    // Session-level routing anchor (multi-coordinator). Prefer the LIVE worker session's
+    // stamp; fall back to a relayed value carried in metadataEvent.meshCoordinatorSessionId
+    // (a remote worker's completion arrives via handleMeshForwardEvent with no local
+    // sourceSession, so the stamp can only ride in the relayed metadata). Empty on legacy /
+    // version-skewed dispatches → the event stays daemon-broadcast (no regression).
+    const workerCoordinatorSessionId = readNonEmptyString(
+        (sourceSession?.getState()?.settings as Record<string, unknown>)?.meshCoordinatorSessionId,
+    ) || readNonEmptyString(args.metadataEvent.meshCoordinatorSessionId);
+
+    // T2: a summary-less completion (and any non-completion status-sync event) carries no
+    // assistant text on the event, so resolveMeshSurfacedSessionPreview had nothing to surface
+    // and the coordinator's inbox mirror stayed stuck on the first dispatched user task. When
+    // THIS daemon hosts the live worker instance (sourceSession present), derive the worker's
+    // latest display message straight from its transcript and attach it to the event as
+    // lastMessagePreview/lastMessageRole/lastMessageAt. resolveMeshSurfacedSessionPreview reads
+    // these as an assistant-only fallback; they also ride the pending-queue + P2P relay
+    // (handleMeshForwardEvent whitelist) so a remote coordinator can surface them. A remote
+    // coordinator has no local instance and keeps relying on the relayed fields — unchanged.
+    const enrichedMetadataEvent = ((): Record<string, unknown> => {
+        const last = sourceSession ? getLastDisplayMessage(sourceSession.getState()) : null;
+        if (!last || !last.preview) return args.metadataEvent;
+        return {
+            ...args.metadataEvent,
+            lastMessagePreview: last.preview,
+            lastMessageRole: last.role,
+            ...(last.receivedAt > 0 ? { lastMessageAt: last.receivedAt } : {}),
+        };
+    })();
+
+    // R2: cloud P2P dashboard metadata sync. The cloud daemon used to do this from its own
+    // relay listener; now the single core forwarder invokes the injected hook (no-op on
+    // standalone) so the event path stays single-listener and the local code path is identical
+    // across standalone and cloud.
+    if (components.onMeshCoordinatorEventForwarded) {
+        try {
+            // T: the coordinator surfaces a remote worker's session but holds no local
+            // instance for it, so the status snapshot can't derive a preview and the
+            // mirror would stay stuck on the first dispatched user task. Resolve the
+            // worker's latest assistant reply (carried on the completion event's
+            // finalSummary / workerResult) into a preview the mirror can stamp, so the
+            // mobile inbox reflects the assistant response. Completion events carry assistant
+            // text as finalSummary; a summary-less completion / status sync falls back to the
+            // worker's latest assistant display message (enrichedMetadataEvent.lastMessage*).
+            // For a mid-turn user-only event this is undefined and the prior surfaced preview
+            // is preserved downstream (no clobber).
+            const surfacedPreview = resolveMeshSurfacedSessionPreview(enrichedMetadataEvent);
+            components.onMeshCoordinatorEventForwarded({
+                event: args.event,
+                meshId: args.meshId,
+                nodeId: eventNodeId || undefined,
+                ...enrichedMetadataEvent,
+                // Ensure a `workspace` field reaches updateMeshOwnedSession even when the
+                // worker provider event only carried `workspaceName`. The merge spread of
+                // metadataEvent above wins when it already has a non-empty `workspace`.
+                workspace: readNonEmptyString(args.metadataEvent.workspace)
+                    || readNonEmptyString(args.metadataEvent.workspaceName)
+                    || undefined,
+                ...(surfacedPreview ? {
+                    meshSessionLastMessagePreview: surfacedPreview.preview,
+                    meshSessionLastMessageRole: surfacedPreview.role,
+                    meshSessionLastMessageAt: surfacedPreview.receivedAt || undefined,
+                } : {}),
+            });
+        } catch { /* dashboard metadata sync is best-effort */ }
+    }
+
+    const eventTimestamp = readEventTimestamp(args.metadataEvent.timestamp);
+    // Coordinator-side dedup/suppression gate (extracted, behavior-preserving). A non-null
+    // outcome either short-circuits with a forwarded result or signals a no-progress→completion
+    // reconciliation that we re-inject; null lets the event fall through to the ledger machinery.
+    const suppression = evaluateMeshEventSuppression(args, {
+        traceCtx,
+        eventSessionId,
+        eventNodeId,
+        eventTimestamp,
+        workerCoordinatorDaemonId,
+    });
+    if (suppression) {
+        if (suppression.kind === 'reconcile') {
+            return injectMeshSystemMessage(components, {
+                ...args,
+                event: 'agent:generating_completed',
+                metadataEvent: suppression.metadataEvent,
+            });
         }
+        return suppression.result;
     }
 
     function markSessionTerminal(sessionId: string, outcome: 'completed' | 'failed', occurredAtMs?: number | null, opts?: { tentativeIfDirect?: boolean }): { id?: string } | null {

package/src/providers/cli-provider-instance.ts

@@ -15,6 +15,7 @@ import { assertProviderSupportsDeclaredInput, getEffectiveMessageInputSupport }
 import type { ProviderInstance, ProviderState, ProviderEvent, InstanceContext, ProviderErrorReason, HotChatSessionState, SessionModalState } from './provider-instance.js';
 import { normalizeInteractivePrompt, normalizeInteractivePromptResponse, type InteractivePrompt } from './types/interactive-prompt.js';
 import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
+import { shortHash } from '../system/hash.js';
 import type { CliProviderModule } from '../cli-adapters/provider-cli-adapter.js';
 import { createCliAdapter } from './spec/route.js';
 import type { PtyRuntimeMetadata, PtyTransportFactory } from '../cli-adapters/pty-transport.js';
@@ -1056,11 +1057,7 @@ export class CliProviderInstance implements ProviderInstance {
 
         const receivedAt = Date.now();
         this.lastAcknowledgedUserInputAt = receivedAt;
-        const dedupKey = `user_input_ack:${crypto
-            .createHash('sha256')
-            .update(`${this.instanceId}:${content}:${receivedAt}`)
-            .digest('hex')
-            .slice(0, 24)}`;
+        const dedupKey = `user_input_ack:${shortHash(`${this.instanceId}:${content}:${receivedAt}`, 24)}`;
         this.appendRuntimeMessage(buildChatMessage({
             role: 'user',
             senderName: 'User',

package/src/providers/provider-loader.ts

@@ -18,6 +18,7 @@ import * as path from 'path';
 import * as os from 'os';
 import * as chokidar from 'chokidar';
 import { registerIDEDefinition } from '../detection/ide-detector.js';
+import { sha256Hex } from '../system/hash.js';
 import { LOG } from '../logging/logger.js';
 import { VersionArchive } from './version-archive.js';
 import type {
@@ -1604,10 +1605,7 @@ export class ProviderLoader {
         });
 
         // Verify checksum
-        const actualChecksum = await new Promise<string>((resolve) => {
-          const crypto = require('crypto') as typeof import('crypto');
-          resolve(crypto.createHash('sha256').update(manifestBody, 'utf-8').digest('hex'));
-        });
+        const actualChecksum = sha256Hex(manifestBody);
         if (actualChecksum !== checksum) {
           this.log(`⚠ Registry checksum mismatch for ${type}@${version} — skipping`);
           continue;