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

package/dist/index.mjs

@@ -2338,12 +2338,34 @@ function sweepExpiredRemoteIdleSessions() {
     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 join10(getLedgerDir(), `${safe}.pending-events.jsonl`);
 }
 function queuePendingMeshCoordinatorEvent(event) {
   try {
+    if (hasPendingRefineTerminalEventDuplicate(event)) {
+      LOG.info("MeshEvents", `Suppressed duplicate pending ${event.event} for refine job ${readRefineJobId(event)}`);
+      return true;
+    }
     appendFileSync3(getPendingEventsPath(event.meshId), JSON.stringify(event) + "\n", "utf-8");
     return true;
   } catch (e) {
@@ -2481,6 +2503,17 @@ function isDuplicateMeshCompletionEvent(args) {
   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) {
@@ -2823,6 +2856,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 error = 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})` : ""}${error ? `: ${error}` : "."} Review the terminal refine event/ledger before retrying.`;
+  }
   return "";
 }
 function injectMeshSystemMessage(components, args) {
@@ -2842,6 +2901,10 @@ function injectMeshSystemMessage(components, args) {
     LOG.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)) {
+    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({
@@ -3091,6 +3154,14 @@ function handleMeshForwardEvent(components, payload) {
       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,
@@ -3134,7 +3205,7 @@ function setupMeshEventForwarding(components) {
     });
   });
 }
-var REMOTE_IDLE_SESSION_TTL_MS, remoteIdleSessions, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, recentCompletionFingerprints, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS;
+var REMOTE_IDLE_SESSION_TTL_MS, remoteIdleSessions, REFINE_TERMINAL_EVENTS, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, recentCompletionFingerprints, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS;
 var init_mesh_events = __esm({
   "src/mesh/mesh-events.ts"() {
     "use strict";
@@ -3146,13 +3217,17 @@ var init_mesh_events = __esm({
     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",
@@ -26652,6 +26727,7 @@ var DaemonCommandRouter = class {
       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",
@@ -26678,6 +26754,7 @@ var DaemonCommandRouter = class {
         status: handle.status,
         startedAt: handle.startedAt,
         completedAt: handle.completedAt,
+        retryOfJobId: handle.retryOfJobId,
         ...result ? { result } : {}
       },
       queuedAt: Date.now()
@@ -26700,9 +26777,11 @@ var DaemonCommandRouter = class {
             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,
@@ -26940,6 +27019,7 @@ var DaemonCommandRouter = class {
       completedAt,
       jobId: handle.jobId,
       interactionId: handle.interactionId,
+      retryOfJobId: handle.retryOfJobId,
       node: { daemonId: handle.targetDaemonId, workspace: handle.workspace }
     });
     const terminal = { ...terminalHandle, result };
@@ -26954,13 +27034,12 @@ var DaemonCommandRouter = class {
     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);