@adhdev/daemon-standalone 1.0.44-rc.1 → 1.0.44-rc.2

package/dist/index.js

@@ -36556,10 +36556,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "c44c9ecb04316113166fd0c06a0a3584f072be76" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "c44c9ecb" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.44-rc.1" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-11T06:22:26.388Z" : void 0);
+      const commit = readInjected(true ? "648305378fc7e0a1970cfe964a80ce7a68172964" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "64830537" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.44-rc.2" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-11T08:23:49.936Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -45717,14 +45717,60 @@ Next step: ${nextStep}`;
       const reconciled = terminalJobIds.size === 0 ? events : events.filter((event) => !(event.event === "refine:accepted" && terminalJobIds.has(readRefineJobId2(event))));
       return backfilled.length === 0 ? reconciled : [...reconciled, ...backfilled];
     }
+    function getPendingRetentionCounters() {
+      return { ...pendingRetentionCounters };
+    }
+    function ledgerRecordExpiredUndrainedEvent(row) {
+      try {
+        const restored = row.payload && typeof row.payload === "object" ? row.payload : void 0;
+        const finalSummary = restored?.metadataEvent ? readMeshCompletionSummary(restored.metadataEvent) : void 0;
+        appendLedgerEntry(row.meshId, {
+          kind: "event_held",
+          ...restored?.nodeId ? { nodeId: restored.nodeId } : {},
+          payload: {
+            event: row.event,
+            reason: PENDING_RETENTION_EXPIRED_HOLD_REASON,
+            recoverable: true,
+            nodeLabel: restored?.nodeLabel ?? "",
+            ...restored?.workspace ? { workspace: restored.workspace } : {},
+            targetCoordinatorDaemonId: restored?.targetCoordinatorDaemonId ?? null,
+            ...readNonEmptyString(restored?.eventId) ? { eventId: restored.eventId } : {},
+            queuedAt: restored?.queuedAt ?? null,
+            ...finalSummary ? { finalSummary } : {},
+            // Full original event so mesh_requeue_held_events can restore it
+            // losslessly (event_held→pending), same as every other event_held feeder.
+            ...restored ? { heldEvent: restored } : {}
+          }
+        });
+      } catch (e) {
+        pendingRetentionCounters.undrainedExpiredMirrorFailed++;
+        LOG2.warn("MeshEvents", `Failed to ledger-record retention-expired pending event ${row.event} (row ${row.id}, mesh ${row.meshId}) \u2014 it is being deleted UNRECOVERABLY: ${e?.message || e}`);
+      }
+    }
     function prunePendingMeshCoordinatorEventsRetention() {
       try {
-        const removed = MeshRuntimeStore.getInstance().prunePendingEvents({
+        const { drainedExpired, undrainedExpired, undrainedRows } = MeshRuntimeStore.getInstance().prunePendingEvents({
           drainedOlderThanMs: PENDING_EVENTS_DRAINED_RETENTION_MS,
           undrainedOlderThanMs: PENDING_EVENTS_UNDRAINED_RETENTION_MS
         });
+        pendingRetentionCounters.drainedExpired += drainedExpired;
+        pendingRetentionCounters.undrainedExpired += undrainedExpired;
+        if (undrainedRows.length > 0) {
+          for (const row of undrainedRows) {
+            ledgerRecordExpiredUndrainedEvent(row);
+          }
+          const meshIds = [...new Set(undrainedRows.map((r) => r.meshId))];
+          const droppedAt = (/* @__PURE__ */ new Date()).toISOString();
+          LOG2.warn(
+            "MeshEvents",
+            `Pending-event retention DROPPED ${undrainedRows.length} never-delivered event(s) at ${droppedAt} (queued >30d, still undrained) across mesh(es) ${meshIds.join(", ")} \u2014 mirrored to the ledger as event_held (reason: ${PENDING_RETENTION_EXPIRED_HOLD_REASON}); recover with mesh_requeue_held_events.`
+          );
+        }
+        const removed = drainedExpired + undrainedExpired;
         if (removed > 0) {
           LOG2.info("MeshEvents", `Pruned ${removed} stale pending-event row(s) (drained >7d / undrained >30d)`);
+        } else {
+          pendingRetentionCounters.sweepsNoop++;
         }
         return removed;
       } catch (e) {
@@ -46053,6 +46099,8 @@ Next step: ${nextStep}`;
     var TERMINAL_COMPLETION_EVENTS;
     var PENDING_EVENTS_DRAINED_RETENTION_MS;
     var PENDING_EVENTS_UNDRAINED_RETENTION_MS;
+    var PENDING_RETENTION_EXPIRED_HOLD_REASON;
+    var pendingRetentionCounters;
     var init_mesh_events_pending = __esm2({
       "src/mesh/mesh-events-pending.ts"() {
         "use strict";
@@ -46101,6 +46149,22 @@ Next step: ${nextStep}`;
         TERMINAL_COMPLETION_EVENTS = /* @__PURE__ */ new Set(["agent:generating_completed", "agent:stopped"]);
         PENDING_EVENTS_DRAINED_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
         PENDING_EVENTS_UNDRAINED_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
+        PENDING_RETENTION_EXPIRED_HOLD_REASON = "pending_retention_expired";
+        pendingRetentionCounters = {
+          /** Already-drained rows deleted past the 7-day dedup-useful window. Not a drop. */
+          drainedExpired: 0,
+          /** Never-delivered rows deleted past the 30-day undrained window. A genuine
+           *  silent-drop risk — mirrored to event_held before deletion (see below). */
+          undrainedExpired: 0,
+          /** undrainedExpired rows that failed to mirror to the ledger (ledger write threw).
+           *  Non-zero here means those specific rows are NOT recoverable via
+           *  mesh_requeue_held_events — the delete still proceeds (retention must not wedge
+           *  on a ledger fault), but this count is the operator's signal of true loss. */
+          undrainedExpiredMirrorFailed: 0,
+          /** How many times the sweep has run and found nothing to prune (0 in both
+           *  windows). Purely diagnostic — confirms the sweep is actually firing. */
+          sweepsNoop: 0
+        };
       }
     });
     var mesh_missions_exports = {};
@@ -49838,21 +49902,43 @@ Next step: ${nextStep}`;
            *     receives its backlog; only genuinely unrecoverable orphans are swept.
            *
            * Both windows key off `queued_at` (always present) — `drained_at` can be NULL on
-           * legacy rows. Returns the number of rows deleted. Best-effort / idempotent:
-           * running it repeatedly with nothing to prune is a cheap no-op.
+           * legacy rows. Returns the number of rows deleted, split by which window matched:
+           * `drainedExpired` (already-delivered rows past the dedup-useful window — not a
+           * drop, the coordinator already got these) and `undrainedExpired` (rows that were
+           * NEVER delivered — a genuine silent drop, same shape as the retired JSONL trim's
+           * `pending_trim_dropped`). `undrainedRows` carries the id/meshId/event/payload of
+           * every undrained-expired row BEFORE deletion so the caller can mirror it to the
+           * mesh ledger as `event_held` (recoverable via mesh_requeue_held_events) instead of
+           * losing it silently — this is the observability gap the retired trim used to cover
+           * and the SQLite-only cutover left open. Best-effort / idempotent: running it
+           * repeatedly with nothing to prune is a cheap no-op.
            */
           prunePendingEvents(opts) {
             const now = Date.now();
             const drainedCutoff = now - Math.max(0, opts.drainedOlderThanMs);
             const undrainedCutoff = now - Math.max(0, opts.undrainedOlderThanMs);
-            let removed = 0;
-            removed += this.db.prepare(
+            const undrainedSelectRows = this.db.prepare(
+              "SELECT id, mesh_id, event, payload FROM mesh_pending_events WHERE drained = 0 AND queued_at < ?"
+            ).all(undrainedCutoff);
+            const undrainedRows = undrainedSelectRows.map((r) => ({
+              id: r.id,
+              meshId: r.mesh_id,
+              event: r.event,
+              payload: (() => {
+                try {
+                  return JSON.parse(r.payload);
+                } catch {
+                  return {};
+                }
+              })()
+            }));
+            const drainedExpired = this.db.prepare(
               "DELETE FROM mesh_pending_events WHERE drained = 1 AND queued_at < ?"
             ).run(drainedCutoff).changes;
-            removed += this.db.prepare(
+            const undrainedExpired = this.db.prepare(
               "DELETE FROM mesh_pending_events WHERE drained = 0 AND queued_at < ?"
             ).run(undrainedCutoff).changes;
-            return removed;
+            return { drainedExpired, undrainedExpired, undrainedRows };
           }
           // ── TURN-LEDGER (Stage 5): authoritative turn attempts ───────────────────
           /**
@@ -60371,7 +60457,17 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         LOG2.warn("MeshQueue", `Failed to retract stale dispatch-blocked event for task ${taskId} (mesh ${meshId}): ${e?.message || e}`);
       }
     }
-    function actionableSkipGuidance(reason) {
+    function resolveTaskDeliveryEvidence(meshId, taskId) {
+      try {
+        const store = MeshRuntimeStore.getInstance();
+        if (store.taskDeliveryConsumed(meshId, taskId)) return "consumed";
+        if (store.taskHasConfirmedDelivery(meshId, taskId)) return "delivered";
+      } catch {
+        return "delivered";
+      }
+      return "never_dispatched";
+    }
+    function actionableSkipGuidance(reason, evidence) {
       if (reason === "target_node_id_unmatched") return {
         summary: "it is pinned to a target node id that matches no node in the mesh (the node may have been removed, or its id form does not resolve)",
         nextAction: "Verify the target node still exists with mesh_status, then re-enqueue without the node pin or with a valid node id (or re-clone the node)."
@@ -60396,10 +60492,20 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         summary: "the node's workspace is dirty, so auto-launch is blocked to avoid clobbering uncommitted changes",
         nextAction: "Clean or commit the node's working tree (or fast-forward it); the task will then auto-assign."
       };
-      if (reason === "target_session_pin_expired") return {
-        summary: "it was pinned to a specific session (a follow-up/delta for work already in flight) that never claimed it within the pin TTL, so the pin was cleared and the message will NOT reach the session it was addressed to",
-        nextAction: "Assume the addressed session never received this delta and is still acting on its previous instructions. Re-send it to that session once it is idle (or re-target it), and re-check the work it produced in the meantime."
-      };
+      if (reason === "target_session_pin_expired") {
+        if (evidence === "consumed") return {
+          summary: "it was pinned to a specific session and the pin TTL expired before the queue row was claimed \u2014 but the delivery record shows this session DID receive and start acting on the message (a turn was started for it), so the queue row lagging is a bookkeeping gap, not a lost delta",
+          nextAction: "Do NOT re-send it \u2014 the session already has this message and re-sending would run the same instruction twice. Check its current output (mesh_read_chat / mesh_read_terminal) to confirm the work is under way."
+        };
+        if (evidence === "delivered") return {
+          summary: "it was pinned to a specific session and the pin TTL expired before the queue row was claimed; the message WAS handed to that session's transport, but the session never echoed a turn start, so whether it acted on it is unconfirmed",
+          nextAction: "Verify before re-sending: check the session with mesh_read_chat / mesh_read_terminal. Re-send only if its output shows no sign of this message \u2014 it may already be acting on it, and re-sending would duplicate the instruction."
+        };
+        return {
+          summary: "it was pinned to a specific session (a follow-up/delta for work already in flight) that never claimed it within the pin TTL, so the pin was cleared; no delivery to that session was ever recorded, so the message did not reach it",
+          nextAction: "The addressed session never received this delta and is still acting on its previous instructions. Re-send it to that session once it is idle (or re-target it), and re-check the work it produced in the meantime."
+        };
+      }
       if (reason === SLOT_MODEL_ABSENT_SKIP_REASON) return {
         summary: "no capability slot on the node declares the model this task resolved to (its difficulty\u2192brain preset picked a model the node was never configured to run)",
         nextAction: "Re-enqueue with a difficulty/model the node's slots declare, target a node that declares this model, or add a slot for it. The task is NOT run on a substitute model \u2014 an undeclared model is never launched."
@@ -60427,8 +60533,10 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       const targetCoordinatorDaemonId = readNonEmptyString(loadConfig2().machineId);
       const targetCoordinatorSessionId = readNonEmptyString(task?.sourceCoordinatorSessionId);
       const nodeLabel = readNonEmptyString(nodeId) || readNonEmptyString(task?.targetNodeId);
-      const { summary, nextAction } = actionableSkipGuidance(reason);
-      const coordinatorMessage = `[System] A queued mesh task${nodeLabel ? ` for node ${nodeLabel}` : ""} is not being dispatched because ${summary}. ${nextAction} This is an actionable blocker \u2014 it will NOT clear on its own; the task stays pending until you resolve it.`;
+      const evidence = reason === "target_session_pin_expired" ? resolveTaskDeliveryEvidence(meshId, taskId) : void 0;
+      const { summary, nextAction } = actionableSkipGuidance(reason, evidence);
+      const closing = reason === "target_session_pin_expired" ? "The stale pin has already been cleared, so the task is now claimable by any compatible session \u2014 the action above is about the session it was originally addressed to." : "This is an actionable blocker \u2014 it will NOT clear on its own; the task stays pending until you resolve it.";
+      const coordinatorMessage = `[System] A queued mesh task${nodeLabel ? ` for node ${nodeLabel}` : ""} is not being dispatched because ${summary}. ${nextAction} ${closing}`;
       try {
         queuePendingMeshCoordinatorEvent({
           event: "mesh:dispatch_blocked",
@@ -60461,6 +60569,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         "use strict";
         init_logger();
         init_mesh_work_queue();
+        init_mesh_runtime_store();
         init_dist();
         init_mesh_events_utils();
         init_mesh_events_pending();
@@ -60879,14 +60988,15 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         if (timer) clearTimeout(timer);
         const isQueued = res && typeof res === "object" && res.status === "queued";
         updateSessionDeliveryStatus(delivery.id, isQueued ? "queued" : "delivered");
-        if (!isQueued && ctx.task.attemptId) {
+        if (ctx.task.attemptId) {
           try {
             recordTurnAck({
               meshId: ctx.meshId,
               taskId: ctx.task.id,
-              kind: "delivered",
+              kind: isQueued ? "accepted" : "delivered",
               attemptId: ctx.task.attemptId,
-              sessionId: ctx.sessionId
+              sessionId: ctx.sessionId,
+              ...isQueued ? { evidence: { source: "transport_queued_in_adapter" } } : {}
             });
           } catch {
           }
@@ -60927,22 +61037,52 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         LOG2.error("MeshQueue", `Failed to dispatch task via ${ctx.transport} to node ${ctx.nodeId}: ${e?.message}`);
         updateSessionDeliveryStatus(delivery.id, "failed", { lastError: e?.message, incrementAttempt: true });
         endTaskDispatchInFlight(ctx.meshId, ctx.task.id);
-        updateTaskStatus(ctx.meshId, ctx.task.id, "pending");
         try {
           closeAttemptForReassignment({ meshId: ctx.meshId, taskId: ctx.task.id, reason: "dispatch_failed" });
         } catch {
         }
+        const retryable = isRetryableDispatchFailure(e);
+        if (!retryable) {
+          failTaskAsUndeliverable(ctx, `dispatch_unrecoverable: ${e?.message || "transport reported the failure as non-recoverable"}`);
+        } else {
+          const requeued = requeueTask(ctx.meshId, ctx.task.id, {
+            reason: "dispatch_failed",
+            clearTargetSession: false
+          });
+          if (requeued?.status === "failed") {
+            LOG2.error("MeshQueue", `Task ${ctx.task.id} (mesh ${ctx.meshId}) failed after repeated undeliverable dispatches to node ${ctx.nodeId}: ${requeued.cancelReason || "max_retries_exceeded"}. Dependents were unblocked.`);
+          }
+        }
         try {
           appendLedgerEntry(ctx.meshId, {
             kind: "dispatch_failed",
             nodeId: ctx.nodeId,
             sessionId: ctx.sessionId,
-            payload: { taskId: ctx.task.id, deliveryId: delivery.id, error: e?.message, retryable: isRetryableDispatchFailure(e), transport: ctx.transport }
+            payload: { taskId: ctx.task.id, deliveryId: delivery.id, error: e?.message, retryable, transport: ctx.transport }
           });
         } catch {
         }
       });
     }
+    function failTaskAsUndeliverable(ctx, reason) {
+      try {
+        const failed = requeueTask(ctx.meshId, ctx.task.id, { maxRetries: 0, reason, clearTargetSession: false });
+        if (!failed) return;
+      } catch (err) {
+        LOG2.warn("MeshQueue", `Failed to mark undeliverable task ${ctx.task.id} (mesh ${ctx.meshId}) terminal: ${err?.message || err}`);
+        return;
+      }
+      LOG2.error("MeshQueue", `Task ${ctx.task.id} (mesh ${ctx.meshId}) is undeliverable to node ${ctx.nodeId} (session ${ctx.sessionId ?? "?"}) and will NOT be retried: ${reason}`);
+      try {
+        appendLedgerEntry(ctx.meshId, {
+          kind: "task_failed",
+          nodeId: ctx.nodeId,
+          sessionId: ctx.sessionId,
+          payload: { taskId: ctx.task.id, reason, undeliverable: true }
+        });
+      } catch {
+      }
+    }
     function isRetryableDispatchFailure(e) {
       if (e && typeof e === "object") {
         if (e.retryRecommended === false) return false;
@@ -69010,6 +69150,7 @@ ${cleanBody}`;
     });
     var mesh_events_exports = {};
     __export2(mesh_events_exports, {
+      PENDING_RETENTION_EXPIRED_HOLD_REASON: () => PENDING_RETENTION_EXPIRED_HOLD_REASON,
       __resetIdleAutoFastForwardForTests: () => __resetIdleAutoFastForwardForTests,
       __resetMeshWorkspaceCacheForTests: () => __resetMeshWorkspaceCacheForTests,
       clearPendingMeshCoordinatorEvents: () => clearPendingMeshCoordinatorEvents,
@@ -69017,6 +69158,7 @@ ${cleanBody}`;
       getMeshV2BackstopCounters: () => getMeshV2BackstopCounters,
       getMeshV2DrainCounters: () => getMeshV2DrainCounters,
       getPendingMeshCoordinatorEvents: () => getPendingMeshCoordinatorEvents,
+      getPendingRetentionCounters: () => getPendingRetentionCounters,
       handleMeshForwardEvent: () => handleMeshForwardEvent,
       isMeshCoordinatorEvent: () => isMeshCoordinatorEvent,
       isMeshProtocolV2EnforceEnabled: () => isMeshProtocolV2EnforceEnabled,
@@ -110848,7 +110990,8 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
           drain: { ...getMeshV2DrainCounters() },
           backstop: { ...getMeshV2BackstopCounters() }
         };
-        return { success: true, events, hasLiveCliCoordinator, meshProtocolV2Counters, ...selfCoordinatorInboxRead ? { surfacedForSelfCoordinator: true } : {} };
+        const pendingRetentionCounters2 = { ...getPendingRetentionCounters() };
+        return { success: true, events, hasLiveCliCoordinator, meshProtocolV2Counters, pendingRetentionCounters: pendingRetentionCounters2, ...selfCoordinatorInboxRead ? { surfacedForSelfCoordinator: true } : {} };
       },
       interactive_prompt_response: async (ctx, args) => {
         const sessionId = typeof args?.targetSessionId === "string" && args.targetSessionId.trim() ? args.targetSessionId.trim() : typeof args?.sessionId === "string" && args.sessionId.trim() ? args.sessionId.trim() : "";
@@ -112005,6 +112148,7 @@ ${ptyResult.output.slice(-2e3)}`);
             drain: { ...getMeshV2DrainCounters() },
             backstop: { ...getMeshV2BackstopCounters() }
           };
+          const pendingRetentionCounters2 = { ...getPendingRetentionCounters() };
           const turnPresentationCounters = getTurnPresentationMetrics();
           const previewFreshness = (() => {
             const localRepoRoot = nodeStatuses.map((node) => readStringValue(node?.git?.repoRoot, node?.repoRoot, node?.workspace)).find((candidate) => !!candidate && fs43.existsSync(candidate));
@@ -112096,6 +112240,7 @@ ${ptyResult.output.slice(-2e3)}`);
             ...pendingCoordinatorEvents.length > 0 ? { pendingCoordinatorEvents } : {},
             ...unroutableDeliveries.length > 0 ? { unroutableDeliveries } : {},
             meshProtocolV2Counters,
+            pendingRetentionCounters: pendingRetentionCounters2,
             turnPresentationCounters,
             activeRefineJobs: Array.from(ctx.runningRefineJobs.values()).filter((job) => job.meshId === meshId).map((job) => ({
               jobId: job.jobId,
@@ -112106,13 +112251,14 @@ ${ptyResult.output.slice(-2e3)}`);
               targetCoordinatorDaemonId: job.targetCoordinatorDaemonId
             }))
           };
-          const { pendingCoordinatorEvents: _pendingCoordinatorEvents, unroutableDeliveries: _unroutableDeliveries, meshProtocolV2Counters: _meshProtocolV2Counters, turnPresentationCounters: _turnPresentationCounters, ...cacheableStatusResult } = statusResult;
+          const { pendingCoordinatorEvents: _pendingCoordinatorEvents, unroutableDeliveries: _unroutableDeliveries, meshProtocolV2Counters: _meshProtocolV2Counters, pendingRetentionCounters: _pendingRetentionCounters, turnPresentationCounters: _turnPresentationCounters, ...cacheableStatusResult } = statusResult;
           const rememberedStatus = verboseMissions ? cacheableStatusResult : ctx.rememberAggregateMeshStatus(meshId, cacheableStatusResult, refreshReason);
           const returnedStatus = {
             ...rememberedStatus,
             ...pendingCoordinatorEvents.length > 0 ? { pendingCoordinatorEvents } : {},
             ...unroutableDeliveries.length > 0 ? { unroutableDeliveries } : {},
             meshProtocolV2Counters,
+            pendingRetentionCounters: pendingRetentionCounters2,
             turnPresentationCounters
           };
           logRepoMeshStatusDebug("return_live", {
@@ -115977,17 +116123,27 @@ ${e?.stderr || ""}`;
     }
     async function startMeshRefineJob(self, meshId, nodeId, args) {
       const key2 = buildRefineJobKey(self, meshId, nodeId);
-      const running = self.runningRefineJobs.get(key2);
-      if (running) return { ...running, duplicate: true };
       const terminal = self.terminalRefineJobs.get(key2);
+      const alreadyRunning = self.runningRefineJobs.get(key2);
+      if (alreadyRunning) return { ...alreadyRunning, duplicate: true };
+      const jobId = `refine_${createInteractionId()}`;
+      const interactionId = createInteractionId();
+      const placeholder = buildRefineJobHandle(self, { meshId, nodeId, jobId, interactionId, retryOfJobId: terminal?.jobId });
+      self.runningRefineJobs.set(key2, placeholder);
       const meshRecord = await self.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
       const mesh = meshRecord?.mesh;
       const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, 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` };
+      if (!node) {
+        self.runningRefineJobs.delete(key2);
+        return { success: false, error: `Node '${nodeId}' not found in mesh` };
+      }
+      if (!node.isLocalWorktree || !node.workspace) {
+        self.runningRefineJobs.delete(key2);
+        return { success: false, error: `Refinery requires a local worktree node` };
+      }
       const coordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : self.deps.statusInstanceId || void 0;
       const coordinatorSessionId = typeof args?.coordinatorSessionId === "string" && args.coordinatorSessionId.trim() ? args.coordinatorSessionId.trim() : void 0;
-      const handle = buildRefineJobHandle(self, { meshId, nodeId, node, retryOfJobId: terminal?.jobId, coordinatorDaemonId, coordinatorSessionId });
+      const handle = buildRefineJobHandle(self, { meshId, nodeId, node, jobId, interactionId, retryOfJobId: terminal?.jobId, coordinatorDaemonId, coordinatorSessionId });
       self.runningRefineJobs.set(key2, handle);
       await appendRefineJobLedger(self, "task_dispatched", handle);
       queueRefineJobEvent(self, "refine:accepted", handle);