@adhdev/daemon-core 0.9.82-rc.60 → 0.9.82-rc.62

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

@@ -26,6 +26,15 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     forwarded: number;
     suppressed: boolean;
     intentionalCleanupStop: boolean;
+    duplicateRefineTerminalEvent?: undefined;
+    duplicateCompletion?: undefined;
+    error?: undefined;
+} | {
+    success: boolean;
+    forwarded: number;
+    suppressed: boolean;
+    duplicateRefineTerminalEvent: boolean;
+    intentionalCleanupStop?: undefined;
     duplicateCompletion?: undefined;
     error?: undefined;
 } | {
@@ -34,12 +43,14 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     suppressed: boolean;
     duplicateCompletion: boolean;
     intentionalCleanupStop?: undefined;
+    duplicateRefineTerminalEvent?: undefined;
     error?: undefined;
 } | {
     success: boolean;
     forwarded: number;
     suppressed?: undefined;
     intentionalCleanupStop?: undefined;
+    duplicateRefineTerminalEvent?: undefined;
     duplicateCompletion?: undefined;
     error?: undefined;
 } | {

package/package.json

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

package/src/commands/router.ts

@@ -925,6 +925,7 @@ type MeshRefineJobHandle = {
     startedAt: string;
     completedAt?: string;
     duplicate?: boolean;
+    retryOfJobId?: string;
     eventDelivery: {
         pendingEvents: true;
         ledger: true;
@@ -2188,6 +2189,7 @@ export class DaemonCommandRouter {
         completedAt?: string;
         jobId?: string;
         interactionId?: string;
+        retryOfJobId?: string;
     }): MeshRefineJobHandle {
         return {
             success: true,
@@ -2202,6 +2204,7 @@ export class DaemonCommandRouter {
             workspace: readStringValue(args.node?.workspace),
             startedAt: args.startedAt || new Date().toISOString(),
             ...(args.completedAt ? { completedAt: args.completedAt } : {}),
+            ...(args.retryOfJobId ? { retryOfJobId: args.retryOfJobId } : {}),
             eventDelivery: { pendingEvents: true, ledger: true },
             evidence: {
                 pendingEventsCommand: 'get_pending_mesh_events',
@@ -2229,6 +2232,7 @@ export class DaemonCommandRouter {
                 status: handle.status,
                 startedAt: handle.startedAt,
                 completedAt: handle.completedAt,
+                retryOfJobId: handle.retryOfJobId,
                 ...(result ? { result } : {}),
             },
             queuedAt: Date.now(),
@@ -2253,8 +2257,10 @@ export class DaemonCommandRouter {
                         workspace: handle.workspace,
                         startedAt: handle.startedAt,
                         completedAt: handle.completedAt,
+                        retryOfJobId: handle.retryOfJobId,
                     },
                     async: true,
+                    retryOfJobId: handle.retryOfJobId,
                     ...(result ? {
                         success: result.success === true,
                         result,
@@ -2509,6 +2515,7 @@ export class DaemonCommandRouter {
             completedAt,
             jobId: handle.jobId,
             interactionId: handle.interactionId,
+            retryOfJobId: handle.retryOfJobId,
             node: { daemonId: handle.targetDaemonId, workspace: handle.workspace },
         });
         const terminal: MeshRefineTerminalJob = { ...terminalHandle, result };
@@ -2524,7 +2531,6 @@ export class DaemonCommandRouter {
         const running = this.runningRefineJobs.get(key);
         if (running) return { ...running, duplicate: true };
         const terminal = this.terminalRefineJobs.get(key);
-        if (terminal) return { ...terminal, duplicate: true };
 
         const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh);
         const mesh = meshRecord?.mesh;
@@ -2532,7 +2538,7 @@ export class DaemonCommandRouter {
         if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh` };
         if (!node.isLocalWorktree || !node.workspace) return { success: false, error: `Refinery requires a local worktree node` };
 
-        const handle = this.buildRefineJobHandle({ meshId, nodeId, node });
+        const handle = this.buildRefineJobHandle({ meshId, nodeId, node, retryOfJobId: terminal?.jobId });
         this.runningRefineJobs.set(key, handle);
         await this.appendRefineJobLedger('task_dispatched', handle);
         this.queueRefineJobEvent('refine:accepted', handle);

package/src/mesh/mesh-events.ts

@@ -58,6 +58,29 @@ export interface PendingMeshCoordinatorEvent {
     queuedAt: number;
 }
 
+const REFINE_TERMINAL_EVENTS = new Set(['refine:completed', 'refine:failed']);
+
+function readRefineJobId(event: { metadataEvent?: Record<string, unknown> } | Record<string, unknown>): string {
+    const metadata = readRecord((event as any).metadataEvent) || event as Record<string, unknown>;
+    const result = readRecord(metadata.result);
+    const refineJob = readRecord(result?.refineJob);
+    return readNonEmptyString(metadata.jobId) || readNonEmptyString(refineJob?.jobId);
+}
+
+function buildRefineTerminalEventFingerprint(meshId: string, eventName: string, metadataEvent: Record<string, unknown>): string {
+    const jobId = readRefineJobId({ metadataEvent });
+    return jobId && REFINE_TERMINAL_EVENTS.has(eventName) ? `${meshId}::${eventName}::${jobId}` : '';
+}
+
+function hasPendingRefineTerminalEventDuplicate(event: PendingMeshCoordinatorEvent): boolean {
+    if (!REFINE_TERMINAL_EVENTS.has(event.event)) return false;
+    const jobId = readRefineJobId(event);
+    if (!jobId) return false;
+    return getPendingMeshCoordinatorEvents(event.meshId).some((pending) =>
+        pending.event === event.event && readRefineJobId(pending) === jobId,
+    );
+}
+
 function getPendingEventsPath(meshId: string): string {
     const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, '_');
     return join(getLedgerDir(), `${safe}.pending-events.jsonl`);
@@ -65,6 +88,10 @@ function getPendingEventsPath(meshId: string): string {
 
 export function queuePendingMeshCoordinatorEvent(event: PendingMeshCoordinatorEvent): boolean {
     try {
+        if (hasPendingRefineTerminalEventDuplicate(event)) {
+            LOG.info('MeshEvents', `Suppressed duplicate pending ${event.event} for refine job ${readRefineJobId(event)}`);
+            return true;
+        }
         appendFileSync(getPendingEventsPath(event.meshId), JSON.stringify(event) + '\n', 'utf-8');
         return true;
     } catch (e: any) {
@@ -131,6 +158,9 @@ const MESH_COORDINATOR_EVENTS = new Set([
     'agent:stopped',
     'agent:ready',
     'monitor:long_generating',
+    'refine:accepted',
+    'refine:completed',
+    'refine:failed',
 ]);
 
 const EVENT_TO_LEDGER_KIND: Record<string, MeshLedgerKind> = {
@@ -266,6 +296,18 @@ function isDuplicateMeshCompletionEvent(args: {
     return false;
 }
 
+function isDuplicateRefineTerminalEvent(meshId: string, eventName: string, metadataEvent: Record<string, unknown>): boolean {
+    const fingerprint = buildRefineTerminalEventFingerprint(meshId, eventName, metadataEvent);
+    if (!fingerprint) return false;
+    const now = Date.now();
+    for (const [key, seenAt] of recentCompletionFingerprints.entries()) {
+        if (now - seenAt > RECENT_COMPLETION_FINGERPRINT_TTL_MS) recentCompletionFingerprints.delete(key);
+    }
+    if (recentCompletionFingerprints.has(fingerprint)) return true;
+    recentCompletionFingerprints.set(fingerprint, now);
+    return false;
+}
+
 
 export function tryAssignQueueTask(
     components: DaemonComponents,
@@ -700,6 +742,32 @@ function buildMeshSystemMessage(args: {
     if (args.event === 'monitor:long_generating') {
         return `[System] ${args.nodeLabel} has been generating for a long time${metadata}. Use mesh_read_chat once for a status check, but do not poll repeatedly.`;
     }
+    if (args.event === 'refine:accepted') {
+        const jobId = readRefineJobId({ metadataEvent: args.metadataEvent });
+        return `[System] Refinery accepted async job${jobId ? ` ${jobId}` : ''} for ${args.nodeLabel}. Completion/failure will be delivered as a terminal refine event; do not poll repeatedly.`;
+    }
+    if (args.event === 'refine:completed') {
+        const jobId = readRefineJobId({ metadataEvent: args.metadataEvent });
+        const result = readRecord(args.metadataEvent.result);
+        const validationSummary = readRecord(result?.validationSummary);
+        const validationStatus = readNonEmptyString(validationSummary?.status);
+        const into = readNonEmptyString(result?.into);
+        const branch = readNonEmptyString(result?.branch);
+        const details = [
+            jobId ? `job_id=${jobId}` : '',
+            branch && into ? `${branch}→${into}` : '',
+            validationStatus ? `validation=${validationStatus}` : '',
+        ].filter(Boolean).join('; ');
+        return `[System] Refinery async job for ${args.nodeLabel} completed successfully${details ? ` (${details})` : ''}. The worktree was merged and cleanup completed; continue from the updated mesh state.`;
+    }
+    if (args.event === 'refine:failed') {
+        const jobId = readRefineJobId({ metadataEvent: args.metadataEvent });
+        const result = readRecord(args.metadataEvent.result);
+        const code = readNonEmptyString(result?.code);
+        const error = readNonEmptyString(result?.error);
+        const details = [jobId ? `job_id=${jobId}` : '', code ? `code=${code}` : ''].filter(Boolean).join('; ');
+        return `[System] Refinery async job for ${args.nodeLabel} failed${details ? ` (${details})` : ''}${error ? `: ${error}` : '.'} Review the terminal refine event/ledger before retrying.`;
+    }
     return '';
 }
 
@@ -728,6 +796,11 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         return { success: true, forwarded: 0, suppressed: true, intentionalCleanupStop: true };
     }
 
+    if (isDuplicateRefineTerminalEvent(args.meshId, args.event, args.metadataEvent)) {
+        LOG.info('MeshEvents', `Suppressed duplicate ${args.event} for refine job ${readRefineJobId({ metadataEvent: args.metadataEvent })}`);
+        return { success: true, forwarded: 0, suppressed: true, duplicateRefineTerminalEvent: true };
+    }
+
     const eventTimestamp = readEventTimestamp(args.metadataEvent.timestamp);
     if (args.event === 'agent:generating_completed' && eventSessionId) {
         const duplicateCompletion = isDuplicateMeshCompletionEvent({
@@ -1005,6 +1078,14 @@ export function handleMeshForwardEvent(components: DaemonComponents, payload: Re
             providerType: readNonEmptyString(payload.providerType),
             providerSessionId: readNonEmptyString(payload.providerSessionId),
             finalSummary: readNonEmptyString(payload.finalSummary) || readNonEmptyString(payload.summary),
+            jobId: readNonEmptyString(payload.jobId),
+            interactionId: readNonEmptyString(payload.interactionId),
+            status: readNonEmptyString(payload.status),
+            targetDaemonId: readNonEmptyString(payload.targetDaemonId),
+            startedAt: readNonEmptyString(payload.startedAt),
+            completedAt: readNonEmptyString(payload.completedAt),
+            retryOfJobId: readNonEmptyString(payload.retryOfJobId),
+            ...(payload.result && typeof payload.result === 'object' && !Array.isArray(payload.result) ? { result: payload.result } : {}),
             ...(payload.timestamp !== undefined ? { timestamp: payload.timestamp } : {}),
             intentional: payload.intentional === true,
             intentionalStop: payload.intentionalStop === true,