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

package/dist/index.js

@@ -24492,12 +24492,34 @@ Follow these recovery rules:
         if (session.expiresAt <= now) remoteIdleSessions.delete(key);
       }
     }
+    function readRefineJobId(event) {
+      const metadata = readRecord(event.metadataEvent) || event;
+      const result = readRecord(metadata.result);
+      const refineJob = readRecord(result?.refineJob);
+      return readNonEmptyString2(metadata.jobId) || readNonEmptyString2(refineJob?.jobId);
+    }
+    function buildRefineTerminalEventFingerprint(meshId, eventName, metadataEvent) {
+      const jobId = readRefineJobId({ metadataEvent });
+      return jobId && REFINE_TERMINAL_EVENTS.has(eventName) ? `${meshId}::${eventName}::${jobId}` : "";
+    }
+    function hasPendingRefineTerminalEventDuplicate(event) {
+      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) {
       const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
       return (0, import_path6.join)(getLedgerDir(), `${safe}.pending-events.jsonl`);
     }
     function queuePendingMeshCoordinatorEvent(event) {
       try {
+        if (hasPendingRefineTerminalEventDuplicate(event)) {
+          LOG2.info("MeshEvents", `Suppressed duplicate pending ${event.event} for refine job ${readRefineJobId(event)}`);
+          return true;
+        }
         (0, import_fs7.appendFileSync)(getPendingEventsPath(event.meshId), JSON.stringify(event) + "\n", "utf-8");
         return true;
       } catch (e) {
@@ -24635,6 +24657,17 @@ Follow these recovery rules:
       recentCompletionFingerprints.set(fingerprint, now);
       return false;
     }
+    function isDuplicateRefineTerminalEvent(meshId, eventName, metadataEvent) {
+      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;
+    }
     function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType) {
       const task = claimNextTask(meshId, nodeId, sessionId);
       if (!task) {
@@ -24977,6 +25010,32 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
       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 = readNonEmptyString2(validationSummary?.status);
+        const into = readNonEmptyString2(result?.into);
+        const branch = readNonEmptyString2(result?.branch);
+        const details = [
+          jobId ? `job_id=${jobId}` : "",
+          branch && into ? `${branch}\u2192${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 = readNonEmptyString2(result?.code);
+        const error48 = readNonEmptyString2(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})` : ""}${error48 ? `: ${error48}` : "."} Review the terminal refine event/ledger before retrying.`;
+      }
       return "";
     }
     function injectMeshSystemMessage(components, args) {
@@ -24996,6 +25055,10 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
         LOG2.info("MeshEvents", `Suppressed ${args.event} for intentionally cleanup-stopped session ${eventSessionId || "(unknown session)"}`);
         return { success: true, forwarded: 0, suppressed: true, intentionalCleanupStop: true };
       }
+      if (isDuplicateRefineTerminalEvent(args.meshId, args.event, args.metadataEvent)) {
+        LOG2.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({
@@ -25245,6 +25308,14 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
           providerType: readNonEmptyString2(payload.providerType),
           providerSessionId: readNonEmptyString2(payload.providerSessionId),
           finalSummary: readNonEmptyString2(payload.finalSummary) || readNonEmptyString2(payload.summary),
+          jobId: readNonEmptyString2(payload.jobId),
+          interactionId: readNonEmptyString2(payload.interactionId),
+          status: readNonEmptyString2(payload.status),
+          targetDaemonId: readNonEmptyString2(payload.targetDaemonId),
+          startedAt: readNonEmptyString2(payload.startedAt),
+          completedAt: readNonEmptyString2(payload.completedAt),
+          retryOfJobId: readNonEmptyString2(payload.retryOfJobId),
+          ...payload.result && typeof payload.result === "object" && !Array.isArray(payload.result) ? { result: payload.result } : {},
           ...payload.timestamp !== void 0 ? { timestamp: payload.timestamp } : {},
           intentional: payload.intentional === true,
           intentionalStop: payload.intentionalStop === true,
@@ -25292,6 +25363,7 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
     var import_path6;
     var REMOTE_IDLE_SESSION_TTL_MS;
     var remoteIdleSessions;
+    var REFINE_TERMINAL_EVENTS;
     var MESH_COORDINATOR_EVENTS;
     var EVENT_TO_LEDGER_KIND;
     var INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS;
@@ -25313,13 +25385,17 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
         init_mesh_work_queue();
         REMOTE_IDLE_SESSION_TTL_MS = 5 * 60 * 1e3;
         remoteIdleSessions = /* @__PURE__ */ new Map();
+        REFINE_TERMINAL_EVENTS = /* @__PURE__ */ new Set(["refine:completed", "refine:failed"]);
         MESH_COORDINATOR_EVENTS = /* @__PURE__ */ new Set([
           "agent:generating_started",
           "agent:generating_completed",
           "agent:waiting_approval",
           "agent:stopped",
           "agent:ready",
-          "monitor:long_generating"
+          "monitor:long_generating",
+          "refine:accepted",
+          "refine:completed",
+          "refine:failed"
         ]);
         EVENT_TO_LEDGER_KIND = {
           "agent:generating_completed": "task_completed",
@@ -48876,6 +48952,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
           workspace: readStringValue(args.node?.workspace),
           startedAt: args.startedAt || (/* @__PURE__ */ new Date()).toISOString(),
           ...args.completedAt ? { completedAt: args.completedAt } : {},
+          ...args.retryOfJobId ? { retryOfJobId: args.retryOfJobId } : {},
           eventDelivery: { pendingEvents: true, ledger: true },
           evidence: {
             pendingEventsCommand: "get_pending_mesh_events",
@@ -48902,6 +48979,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
             status: handle.status,
             startedAt: handle.startedAt,
             completedAt: handle.completedAt,
+            retryOfJobId: handle.retryOfJobId,
             ...result ? { result } : {}
           },
           queuedAt: Date.now()
@@ -48924,9 +49002,11 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                 targetDaemonId: handle.targetDaemonId,
                 workspace: handle.workspace,
                 startedAt: handle.startedAt,
-                completedAt: handle.completedAt
+                completedAt: handle.completedAt,
+                retryOfJobId: handle.retryOfJobId
               },
               async: true,
+              retryOfJobId: handle.retryOfJobId,
               ...result ? {
                 success: result.success === true,
                 result,
@@ -49164,6 +49244,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
           completedAt,
           jobId: handle.jobId,
           interactionId: handle.interactionId,
+          retryOfJobId: handle.retryOfJobId,
           node: { daemonId: handle.targetDaemonId, workspace: handle.workspace }
         });
         const terminal = { ...terminalHandle, result };
@@ -49178,13 +49259,12 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         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;
         const node = mesh?.nodes?.find((n) => n.id === nodeId || n.nodeId === nodeId);
         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);