@adhdev/daemon-standalone 0.9.82-rc.374 → 0.9.82-rc.376

package/dist/index.js

@@ -30036,10 +30036,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "47e042dcb10c9ca07c30ac4bf8e0d5a4153a63c6" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "47e042dc" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "0.9.82-rc.374" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-06-25T00:33:32.738Z" : void 0);
+      const commit = readInjected(true ? "5f02f35175e6b8b9d8c70d2232438b332cd18d84" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "5f02f351" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "0.9.82-rc.376" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-06-25T03:48:42.404Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -32771,6 +32771,10 @@ Default branch: \`${mesh.defaultBranch}\`` : ""}`);
       if (ctx.missionSection?.trim()) {
         sections.push(ctx.missionSection.trim());
       }
+      const recentActivity = buildRecentActivitySection(ctx.recentActivity);
+      if (recentActivity) sections.push(recentActivity);
+      const operatingNotes = buildOperatingNotesSection(ctx.operatingNotes);
+      if (operatingNotes) sections.push(operatingNotes);
       sections.push(buildPolicySection({ ...DEFAULT_MESH_POLICY, ...mesh.policy || {} }));
       sections.push(TOOLS_SECTION);
       sections.push(TOOL_EXPOSURE_PREFLIGHT_SECTION);
@@ -32802,6 +32806,8 @@ Default branch: \`${mesh.defaultBranch}\`` : ""}`);
         cliType: coordinatorCliType || "",
         nodes: nodesSection,
         mission: ctx.missionSection?.trim() || "",
+        recentActivity: buildRecentActivitySection(ctx.recentActivity) || "",
+        operatingNotes: buildOperatingNotesSection(ctx.operatingNotes) || "",
         policy: buildPolicySection({ ...DEFAULT_MESH_POLICY, ...mesh.policy || {} }),
         tools: TOOLS_SECTION,
         workflow: WORKFLOW_SECTION,
@@ -32873,6 +32879,56 @@ Default branch: \`${mesh.defaultBranch}\`` : ""}`);
       if (lines.length === 1) return lines[0];
       return [lines[0], ...lines.slice(1).map((l) => pad + l)].join("\n");
     }
+    function buildRecentActivitySection(activity) {
+      if (!activity) return "";
+      const failures = Array.isArray(activity.recentFailures) ? activity.recentFailures : [];
+      const pending = Number.isFinite(activity.pendingTasks) ? Number(activity.pendingTasks) : 0;
+      const assigned = Number.isFinite(activity.assignedTasks) ? Number(activity.assignedTasks) : 0;
+      const stalled = Number.isFinite(activity.stalledTasks) ? Number(activity.stalledTasks) : 0;
+      const recentFailureCount = Number.isFinite(activity.recentFailureCount) ? Number(activity.recentFailureCount) : failures.length;
+      if (failures.length === 0 && pending === 0 && assigned === 0 && stalled === 0 && recentFailureCount === 0) {
+        return "";
+      }
+      const lines = ["## Recent Activity", ""];
+      lines.push("A snapshot of this mesh's recent ledger/queue state at launch. Use it to decide what needs attention first; call `mesh_task_history` / `mesh_view_queue` for full detail.");
+      lines.push("");
+      const counts = [];
+      if (pending > 0) counts.push(`**${pending}** pending`);
+      if (assigned > 0) counts.push(`**${assigned}** assigned`);
+      if (stalled > 0) counts.push(`**${stalled}** stalled`);
+      if (recentFailureCount > 0) counts.push(`**${recentFailureCount}** failed in the last 30 min`);
+      if (counts.length) lines.push(`- Queue/ledger: ${counts.join(", ")}.`);
+      if (activity.lastActivityAt) lines.push(`- Last ledger activity: ${activity.lastActivityAt}.`);
+      if (failures.length > 0) {
+        const recent = failures.slice(-5).reverse();
+        lines.push("", "Recent failures (newest first):");
+        for (const f of recent) {
+          const when = f.timestamp ? `${f.timestamp} ` : "";
+          const node = f.nodeId ? `node \`${f.nodeId}\`` : "unknown node";
+          const summary = (f.summary || "").trim();
+          lines.push(`- ${when}${node}${summary ? ` \u2014 ${summary}` : ""}`);
+        }
+        lines.push("", "_Check `mesh_task_history` before retrying; repeated failures on the same node mean reassign or escalate, not retry._");
+      }
+      return lines.join("\n");
+    }
+    function buildOperatingNotesSection(notes) {
+      const valid = Array.isArray(notes) ? notes.filter((n) => n && typeof n.text === "string" && n.text.trim()) : [];
+      if (valid.length === 0) return "";
+      const categoryLabel = {
+        provider_quirk: "provider quirk",
+        pattern_to_avoid: "pattern to avoid",
+        recovery_lesson: "recovery lesson"
+      };
+      const lines = ["## Operating Notes", ""];
+      lines.push("Lessons earlier coordinators on this mesh recorded via `mesh_record_note`. Treat them as accumulated operating knowledge \u2014 apply them. When you learn a durable lesson (a provider quirk, a pattern to avoid, a recovery lesson), record it with `mesh_record_note` so future coordinators inherit it.");
+      lines.push("");
+      for (const n of valid) {
+        const cat = n.category && categoryLabel[n.category] ? `[${categoryLabel[n.category]}] ` : "";
+        lines.push(`- ${cat}${n.text.trim()}`);
+      }
+      return lines.join("\n");
+    }
     function buildPolicySection(policy) {
       const rules = [];
       if (policy.requirePreTaskCheckpoint) rules.push("- Create a git checkpoint **before** starting each task");
@@ -32941,6 +32997,7 @@ ${rules.join("\n")}`;
 | \`mesh_read_chat\` | Read recent chat messages from a delegated agent session |
 | \`mesh_read_debug\` | Collect a daemon-side chat/parser debug bundle for a session |
 | \`mesh_task_history\` | Read the task ledger \u2014 dispatches, completions, failures. Use to understand what has been done before deciding next steps |
+| \`mesh_record_note\` | Record a durable, provider-neutral operating note (provider quirk / pattern to avoid / recovery lesson). Future coordinators see it under "## Operating Notes" at launch |
 | \`mesh_git_status\` | Check git status on a specific node |
 | \`mesh_read_node_logs\` | Fetch a remote node's daemon log tail directly over P2P (grep/since/byte-bounded, secrets redacted) \u2014 no session/PowerShell needed to debug a node's daemon |
 | \`mesh_fast_forward_node\` | Safely dry-run or explicitly execute an obvious clean fast-forward without launching an agent session |
@@ -42724,6 +42781,18 @@ ${cleanBody}`;
       const diag = readRecord4(payload.completionDiagnostic);
       return diag?.finalAssistantPresent === false || diag?.blockReason === "missing_final_assistant";
     }
+    function supersedesTruncatedTerminalSummary(args) {
+      if (!args.terminalTaskId || !args.eventTaskId || args.terminalTaskId !== args.eventTaskId) return false;
+      if (!isGenuineCompletionEvidence(args.metadataEvent)) return false;
+      const terminalSummary = readNonEmptyString2(args.terminalPayload.finalSummary);
+      const eventSummary = readNonEmptyString2(args.metadataEvent.finalSummary);
+      if (!eventSummary) return false;
+      if (terminalSummary === eventSummary) return false;
+      if (isWeakTerminalLedgerPayload(args.terminalPayload)) return false;
+      if (!terminalSummary) return true;
+      if (eventSummary.startsWith(terminalSummary)) return true;
+      return eventSummary.length > terminalSummary.length + 32;
+    }
     function resolveActiveDirectDispatchTaskId(meshId, sessionId) {
       try {
         const matches = getActiveDirectDispatches(meshId).filter((d) => d.sessionId === sessionId);
@@ -43640,7 +43709,13 @@ ${cleanBody}`;
           const terminalTaskId = readNonEmptyString2(terminal.payload.taskId);
           const eventTaskId = readNonEmptyString2(args.metadataEvent.taskId);
           const distinctTaskCompletion = !!eventTaskId && !!terminalTaskId && eventTaskId !== terminalTaskId;
-          if (!newDispatchAfterTerminal && !supersedesWeakTerminal && !distinctTaskCompletion) {
+          const supersedesTruncatedTerminal = supersedesTruncatedTerminalSummary({
+            terminalPayload: terminal.payload,
+            metadataEvent: args.metadataEvent,
+            terminalTaskId,
+            eventTaskId
+          });
+          if (!newDispatchAfterTerminal && !supersedesWeakTerminal && !distinctTaskCompletion && !supersedesTruncatedTerminal) {
             const terminalProviderSessionId = readNonEmptyString2(terminal.payload.providerSessionId);
             const terminalFinalSummary = readNonEmptyString2(terminal.payload.finalSummary);
             const eventProviderSessionId = readNonEmptyString2(args.metadataEvent.providerSessionId);
@@ -44435,6 +44510,16 @@ ${cleanBody}`;
         const status = readNonEmptyString2(state.status).toLowerCase();
         const modalParked = status === "waiting_choice" || status === "waiting_approval";
         const sessionId = readNonEmptyString2(state.instanceId);
+        const stateKey = `${meshId}::${sessionId || "?"}`;
+        const prevParked = coordinatorModalParkState.get(stateKey);
+        if (prevParked !== modalParked) {
+          coordinatorModalParkState.set(stateKey, modalParked);
+          if (modalParked) {
+            LOG2.info("MeshReconcile", `Coordinator ${sessionId || "?"} (mesh ${meshId}) entered modal-park (status=${status}) \u2014 terminal events for it will be held until the modal is answered`);
+          } else if (prevParked === true) {
+            LOG2.info("MeshReconcile", `Coordinator ${sessionId || "?"} (mesh ${meshId}) left modal-park (status=${status}) \u2014 held events will drain on this/next tick`);
+          }
+        }
         out.push({ meshId, instance: inst, sessionId, idle: status === "idle", modalParked });
       }
       return out;
@@ -44628,7 +44713,55 @@ ${cleanBody}`;
         const forceOnly = idleCoordinators.length === 0;
         if (targetCoordinators.length === 0) {
           if (modalParkedCoordinators.length > 0) {
-            LOG2.info("MeshReconcile", `Reconcile skip \u2192 modal-parked: holding pending event(s) for mesh ${meshId} (${modalParkedCoordinators.length} coordinator(s) awaiting a modal answer; events left queued)`);
+            const liveSessionIds = new Set(
+              meshCoordinators.map((c) => readNonEmptyString2(c.sessionId)).filter(Boolean)
+            );
+            let orphanEscaped = 0;
+            const hasPendingForOrphanPeek = !store || (() => {
+              try {
+                return store.pendingEventCount(meshId) > 0;
+              } catch {
+                return true;
+              }
+            })();
+            if (hasPendingForOrphanPeek) {
+              let peeked = [];
+              try {
+                peeked = getPendingMeshCoordinatorEvents(meshId, drainDaemonIds.length > 0 ? drainDaemonIds : void 0);
+              } catch {
+                peeked = [];
+              }
+              const isOrphan = (e) => {
+                const want = readNonEmptyString2(e.targetCoordinatorSessionId);
+                return !!want && !liveSessionIds.has(want);
+              };
+              const orphanEventNames = new Set(peeked.filter(isOrphan).map((e) => e.event));
+              if (orphanEventNames.size > 0) {
+                let drained = [];
+                try {
+                  drained = drainPendingMeshCoordinatorEvents(
+                    meshId,
+                    drainDaemonIds.length > 0 ? drainDaemonIds : localDaemonId,
+                    { onlyEvents: orphanEventNames }
+                  );
+                } catch (e) {
+                  LOG2.warn("MeshReconcile", `Orphan-escape drain failed for mesh ${meshId}: ${e?.message || e}`);
+                  drained = [];
+                }
+                for (const pending of drained) {
+                  if (isOrphan(pending)) {
+                    holdOrExpireStrictUnmatchedEvent(pending, readNonEmptyString2(pending.targetCoordinatorSessionId), meshId);
+                    orphanEscaped++;
+                  } else {
+                    try {
+                      queuePendingMeshCoordinatorEvent(pending);
+                    } catch {
+                    }
+                  }
+                }
+              }
+            }
+            LOG2.info("MeshReconcile", `Reconcile skip \u2192 modal-parked: holding pending event(s) for mesh ${meshId} (${modalParkedCoordinators.length} coordinator(s) awaiting a modal answer; events left queued${orphanEscaped > 0 ? `; ${orphanEscaped} orphan-targeted event(s) routed to strict-route TTL` : ""})`);
             let hasPending = true;
             if (store) {
               try {
@@ -44899,6 +45032,19 @@ ${cleanBody}`;
         const messages = Array.isArray(payload.messages) ? payload.messages : [];
         const evidence = extractFinalAssistantSummaryEvidence(messages);
         if (!evidence.finalSummary) continue;
+        const dispatchedAtMs = Date.parse(readNonEmptyString2(dispatch.dispatchedAt));
+        const transcriptAtMs = Date.parse(evidence.transcriptMessageAt ?? "");
+        if (Number.isFinite(dispatchedAtMs) && Number.isFinite(transcriptAtMs) && transcriptAtMs < dispatchedAtMs) {
+          LOG2.info("MeshReconcile", `Stale-summary guard: skipping transcript reconcile for task ${taskId} on node ${nodeId} (mesh ${mesh.id}) \u2014 final assistant message (${evidence.transcriptMessageAt}) predates this task's dispatch (${dispatch.dispatchedAt}); it is a prior task's summary`);
+          traceMeshEventDrop("reconcile_stale_summary_before_dispatch", {
+            taskId,
+            sessionId,
+            nodeId,
+            meshId: mesh.id,
+            event: "agent:generating_completed"
+          }, `transcriptAt=${evidence.transcriptMessageAt} < dispatchedAt=${dispatch.dispatchedAt}`);
+          continue;
+        }
         const providerSessionId = readNonEmptyString2(payload.providerSessionId);
         const coordinatorDaemonId = selfIds.find((id) => !!id);
         try {
@@ -45028,6 +45174,7 @@ ${cleanBody}`;
     }
     var DEFAULT_RECONCILE_INTERVAL_MS;
     var DEFAULT_AUTO_PRUNE_MIN_AGE_MS;
+    var coordinatorModalParkState;
     var heldEventLedgerRecorded;
     var ASSIGNED_STRANDED_DEADLINE_MS;
     var STRICT_SESSION_MATCH_TTL_MS;
@@ -45054,6 +45201,7 @@ ${cleanBody}`;
         init_chat_message_normalization();
         DEFAULT_RECONCILE_INTERVAL_MS = 4e3;
         DEFAULT_AUTO_PRUNE_MIN_AGE_MS = 24 * 60 * 6e4;
+        coordinatorModalParkState = /* @__PURE__ */ new Map();
         heldEventLedgerRecorded = /* @__PURE__ */ new Set();
         ASSIGNED_STRANDED_DEADLINE_MS = 5 * 6e4;
         STRICT_SESSION_MATCH_TTL_MS = 6e4;
@@ -67800,6 +67948,8 @@ ${body}
     }
     var COMPLETED_FINALIZATION_RETRY_MS = 1e3;
     var COMPLETED_FINALIZATION_MAX_WAIT_MS = 3e4;
+    var NATIVE_HISTORY_MESH_IDLE_SETTLE_MS = 1500;
+    var USER_INPUT_ACK_DEDUP_WINDOW_MS = 6e4;
     var TERMINAL_MESH_EVENTS = /* @__PURE__ */ new Set([
       "agent:generating_completed",
       "agent:stopped",
@@ -68071,6 +68221,14 @@ ${body}
       runtimeMessages = [];
       lastPersistedHistoryMessages = [];
       lastAcknowledgedUserInputAt = 0;
+      // TASKBUBBLE-DUP: per-content last-ack timestamps so the same dispatched
+      // prompt acked twice in quick succession (the worker buffers the first
+      // send during bootstrap/busy, then a redelivery — dispatch-confirm-timeout
+      // requeue or a reconcile re-dispatch — fires a SECOND send_chat before the
+      // outbound queue drains) collapses to ONE user bubble. Keyed on the trimmed
+      // content; an entry older than USER_INPUT_ACK_DEDUP_WINDOW_MS is treated as
+      // a fresh, intentional resend and is NOT suppressed.
+      recentUserInputAcks = /* @__PURE__ */ new Map();
       lastNativeSourceCanonicalCheckAt = 0;
       lastNativeSourceCanonicalCacheKey = void 0;
       cachedSqliteDb = null;
@@ -68505,6 +68663,15 @@ ${body}
         const content = typeof input === "string" ? input.trim() : buildCliStructuredInputPrompt(input).trim();
         if (!content) return;
         const receivedAt = Date.now();
+        const ackContentKey = shortHash(`${this.instanceId}:${content}`, 24);
+        const lastAckAt = this.recentUserInputAcks.get(ackContentKey);
+        if (lastAckAt !== void 0 && receivedAt - lastAckAt <= USER_INPUT_ACK_DEDUP_WINDOW_MS) {
+          this.recentUserInputAcks.set(ackContentKey, receivedAt);
+          this.pruneRecentUserInputAcks(receivedAt);
+          return;
+        }
+        this.recentUserInputAcks.set(ackContentKey, receivedAt);
+        this.pruneRecentUserInputAcks(receivedAt);
         this.lastAcknowledgedUserInputAt = receivedAt;
         const dedupKey = `user_input_ack:${shortHash(`${this.instanceId}:${content}:${receivedAt}`, 24)}`;
         this.appendRuntimeMessage(buildChatMessage({
@@ -68522,6 +68689,13 @@ ${body}
           }
         }), dedupKey);
       }
+      /** Drop user-input ack entries older than the dedup window so the map can't grow unbounded. */
+      pruneRecentUserInputAcks(now) {
+        if (this.recentUserInputAcks.size <= 1) return;
+        for (const [key, at] of this.recentUserInputAcks) {
+          if (now - at > USER_INPUT_ACK_DEDUP_WINDOW_MS) this.recentUserInputAcks.delete(key);
+        }
+      }
       dispose() {
         this.adapter.shutdown();
         this.monitor.reset();
@@ -69211,8 +69385,9 @@ ${body}
                 previousStatus: this.lastStatus
               };
               const ownsExternalHistory = !!this.adapter?.chatMessagesOwnedExternally;
-              const flushDelay = ownsExternalHistory ? 0 : 3e3;
-              LOG2.debug("CLI", `[${this.type}] set completedDebouncePending duration=${duration3}s ownsExternalHistory=${ownsExternalHistory} flushDelay=${flushDelay}ms generatingStartedAt=${this.generatingStartedAt}`);
+              const meshWorkerSession = this.isMeshWorkerSession();
+              const flushDelay = ownsExternalHistory ? meshWorkerSession ? NATIVE_HISTORY_MESH_IDLE_SETTLE_MS : 0 : 3e3;
+              LOG2.debug("CLI", `[${this.type}] set completedDebouncePending duration=${duration3}s ownsExternalHistory=${ownsExternalHistory} meshWorker=${meshWorkerSession} flushDelay=${flushDelay}ms generatingStartedAt=${this.generatingStartedAt}`);
               this.scheduleCompletedDebounceFlush(flushDelay);
             }
           } else if (newStatus === "idle" && this.lastStatus === "starting") {
@@ -72257,11 +72432,11 @@ Run 'adhdev doctor' for detailed diagnostics.`
             }
           }
         }
-        const agentResult = await ctx.deps.cliManager.handleCliCommand("agent_command", args);
         const meshCtx = args?.meshContext;
         const dispatchNodeId = readStringValue(meshCtx?.nodeId);
         const dispatchMeshId = readStringValue(meshCtx?.meshId);
-        if (dispatchNodeId && dispatchMeshId && agentResult?.success !== false) {
+        const isSendChat = args?.action === "send_chat";
+        if (isSendChat && dispatchNodeId && dispatchMeshId) {
           try {
             const { getMesh: getMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
             const meshObj = getMesh2(dispatchMeshId) ?? ctx.getCachedInlineMesh(dispatchMeshId);
@@ -72269,17 +72444,22 @@ Run 'adhdev doctor' for detailed diagnostics.`
             const bootstrapStatus = readStringValue(nodeObj?.worktreeBootstrap?.status);
             if (bootstrapStatus === "running") {
               return {
-                success: true,
-                ...agentResult,
-                dispatchAcknowledgementRisk: true,
-                dispatchAcknowledgementRiskReason: "bootstrap_still_running",
-                nextAction: "Wait for worktree_bootstrap_complete event before dispatching work to this node."
+                success: false,
+                recoverable: true,
+                dispatched: false,
+                code: "mesh_node_bootstrap_pending",
+                reason: "bootstrap_still_running",
+                nodeId: dispatchNodeId,
+                meshId: dispatchMeshId,
+                ...readStringValue(meshCtx?.taskId) ? { taskId: readStringValue(meshCtx?.taskId) } : {},
+                error: `Node '${dispatchNodeId}' worktree bootstrap is still running; a task injected now would land in the session input buffer before the provider is ready to consume it and be silently lost. Dispatch deferred.`,
+                nextAction: "Wait for the worktree_bootstrap_complete event (or poll mesh_status until the node session is ready), then re-send the task with mesh_send_task. Alternatively use mesh_enqueue_task so the queue auto-assigns it once a ready session is available."
               };
             }
           } catch {
           }
         }
-        return agentResult;
+        return ctx.deps.cliManager.handleCliCommand("agent_command", args);
       },
       // ─── Logs ───
       list_saved_sessions: async (ctx, args) => {
@@ -77361,49 +77541,72 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         };
       },
       fast_forward_mesh_node: async (ctx, args) => {
-        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-        const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
-        let workspace = typeof args?.workspace === "string" ? args.workspace.trim() : "";
-        let submoduleIgnorePaths = Array.isArray(args?.submoduleIgnorePaths) ? args.submoduleIgnorePaths.filter((value) => typeof value === "string") : void 0;
-        let nodeDaemonId;
-        let allowAutoPublishSubmoduleMainCommits = false;
-        if (meshId && nodeId) {
-          const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-          const mesh = meshRecord?.mesh;
-          const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
-          if (!workspace) {
-            workspace = typeof node?.workspace === "string" ? node.workspace.trim() : "";
+        const workspaceForError = typeof args?.workspace === "string" ? args.workspace.trim() : "";
+        const meshIdForError = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        const nodeIdForError = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
+        try {
+          const meshId = meshIdForError;
+          const nodeId = nodeIdForError;
+          let workspace = workspaceForError;
+          let submoduleIgnorePaths = Array.isArray(args?.submoduleIgnorePaths) ? args.submoduleIgnorePaths.filter((value) => typeof value === "string") : void 0;
+          let nodeDaemonId;
+          let allowAutoPublishSubmoduleMainCommits = false;
+          if (meshId && nodeId) {
+            const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+            const mesh = meshRecord?.mesh;
+            const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
+            if (!workspace) {
+              workspace = typeof node?.workspace === "string" ? node.workspace.trim() : "";
+            }
+            if (!submoduleIgnorePaths && Array.isArray(node?.policy?.submoduleIgnorePaths)) {
+              submoduleIgnorePaths = node.policy.submoduleIgnorePaths.filter((value) => typeof value === "string");
+            }
+            allowAutoPublishSubmoduleMainCommits = mesh?.policy?.allowAutoPublishSubmoduleMainCommits === true;
+            nodeDaemonId = typeof node?.daemonId === "string" ? node.daemonId.trim() : void 0;
           }
-          if (!submoduleIgnorePaths && Array.isArray(node?.policy?.submoduleIgnorePaths)) {
-            submoduleIgnorePaths = node.policy.submoduleIgnorePaths.filter((value) => typeof value === "string");
+          const selfDaemonId = ctx.deps.statusInstanceId;
+          const isRemote = nodeDaemonId && selfDaemonId && !daemonIdsEquivalent(nodeDaemonId, selfDaemonId);
+          if (isRemote && ctx.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
+            const forwarded = await ctx.deps.dispatchMeshCommand(nodeDaemonId, "fast_forward_mesh_node", {
+              ...typeof args === "object" && args !== null ? args : {},
+              workspace,
+              _meshDirectDispatch: true
+            });
+            return forwarded ?? { success: false, error: "no response from remote node" };
           }
-          allowAutoPublishSubmoduleMainCommits = mesh?.policy?.allowAutoPublishSubmoduleMainCommits === true;
-          nodeDaemonId = typeof node?.daemonId === "string" ? node.daemonId.trim() : void 0;
-        }
-        const selfDaemonId = ctx.deps.statusInstanceId;
-        const isRemote = nodeDaemonId && selfDaemonId && !daemonIdsEquivalent(nodeDaemonId, selfDaemonId);
-        if (isRemote && ctx.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
-          const forwarded = await ctx.deps.dispatchMeshCommand(nodeDaemonId, "fast_forward_mesh_node", {
-            ...typeof args === "object" && args !== null ? args : {},
+          const result = await fastForwardMeshNode({
+            meshId: meshId || void 0,
+            nodeId: nodeId || void 0,
             workspace,
-            _meshDirectDispatch: true
+            branch: typeof args?.branch === "string" ? args.branch : void 0,
+            execute: args?.execute === true,
+            dryRun: args?.dryRun === true,
+            updateSubmodules: args?.updateSubmodules === true,
+            submoduleIgnorePaths,
+            mode: args?.mode === "push" ? "push" : "merge",
+            pushSubmodules: args?.pushSubmodules === true,
+            allowAutoPublishSubmoduleMainCommits
           });
-          return forwarded ?? { success: false, error: "no response from remote node" };
+          return result;
+        } catch (e) {
+          const errorMessage = e?.message || String(e);
+          return {
+            success: false,
+            code: "fast_forward_safety_gate_error",
+            ...meshIdForError ? { meshId: meshIdForError } : {},
+            ...nodeIdForError ? { nodeId: nodeIdForError } : {},
+            workspace: workspaceForError,
+            mode: args?.mode === "push" ? "push" : "merge",
+            allowed: false,
+            willRun: false,
+            executed: false,
+            // Surface the throw as a blocking reason instead of an opaque IPC crash
+            // so the coordinator gets the same structured shape a clean node returns.
+            blockingReasons: ["fast_forward_safety_gate_error"],
+            operationError: errorMessage,
+            error: errorMessage
+          };
         }
-        const result = await fastForwardMeshNode({
-          meshId: meshId || void 0,
-          nodeId: nodeId || void 0,
-          workspace,
-          branch: typeof args?.branch === "string" ? args.branch : void 0,
-          execute: args?.execute === true,
-          dryRun: args?.dryRun === true,
-          updateSubmodules: args?.updateSubmodules === true,
-          submoduleIgnorePaths,
-          mode: args?.mode === "push" ? "push" : "merge",
-          pushSubmodules: args?.pushSubmodules === true,
-          allowAutoPublishSubmoduleMainCommits
-        });
-        return result;
       },
       refine_mesh_node: async (ctx, args) => {
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
@@ -77552,6 +77755,56 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
               return "";
             }
           };
+          const buildRecentActivityBestEffort = async (id) => {
+            try {
+              const { getLedgerSummary: getLedgerSummary2, readLedgerEntries: readLedgerEntries2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+              const { getMeshQueueStats: getMeshQueueStats2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
+              const summary = getLedgerSummary2(id);
+              const queue = getMeshQueueStats2(id);
+              const failureEntries = readLedgerEntries2(id, { kind: ["task_failed"], tail: 5 });
+              const recentFailures = failureEntries.map((e) => {
+                const p = e.payload || {};
+                const raw = typeof p.taskSummary === "string" ? p.taskSummary : typeof p.message === "string" ? p.message : typeof p.error === "string" ? p.error : "";
+                const summaryText = raw.length > 160 ? `${raw.slice(0, 160)}\u2026` : raw;
+                return {
+                  timestamp: e.timestamp,
+                  nodeId: e.nodeId,
+                  summary: summaryText
+                };
+              });
+              return {
+                recentFailures,
+                recentFailureCount: summary.recentFailures,
+                pendingTasks: queue.pending,
+                assignedTasks: queue.assigned,
+                stalledTasks: summary.taskStalled,
+                lastActivityAt: summary.lastActivityAt
+              };
+            } catch {
+              return void 0;
+            }
+          };
+          const buildOperatingNotesBestEffort = async (id) => {
+            try {
+              const { readLedgerEntries: readLedgerEntries2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+              const noteEntries = readLedgerEntries2(id, { kind: ["coordinator_operating_note"], tail: 20 });
+              const notes = noteEntries.map((e) => {
+                const p = e.payload || {};
+                const text = typeof p.text === "string" ? p.text.trim() : "";
+                if (!text) return null;
+                const category = p.category === "provider_quirk" || p.category === "pattern_to_avoid" || p.category === "recovery_lesson" ? p.category : void 0;
+                return {
+                  text,
+                  category,
+                  createdAt: typeof p.createdAt === "string" ? p.createdAt : e.timestamp,
+                  sourceCoordinator: typeof p.sourceCoordinator === "string" ? p.sourceCoordinator : void 0
+                };
+              }).filter((n) => n !== null);
+              return notes.length ? notes : void 0;
+            } catch {
+              return void 0;
+            }
+          };
           let mesh;
           if (args?.inlineMesh && typeof args.inlineMesh === "object") {
             mesh = args.inlineMesh;
@@ -77642,7 +77895,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
           if (coordinatorSetup.kind === "cli_command") {
             let cliCmdSystemPrompt = "";
             try {
-              cliCmdSystemPrompt = buildCoordinatorSystemPrompt2({ mesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || void 0, missionSection: buildMissionSectionBestEffort(mesh.id) });
+              cliCmdSystemPrompt = buildCoordinatorSystemPrompt2({ mesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || void 0, missionSection: buildMissionSectionBestEffort(mesh.id), recentActivity: await buildRecentActivityBestEffort(mesh.id), operatingNotes: await buildOperatingNotesBestEffort(mesh.id) });
             } catch (error48) {
               const message = error48?.message || String(error48);
               LOG2.error("MeshCoordinator", `Failed to build coordinator prompt: ${message}`);
@@ -77819,7 +78072,7 @@ ${ptyResult.output.slice(-2e3)}`);
           }
           let systemPrompt = "";
           try {
-            systemPrompt = buildCoordinatorSystemPrompt2({ mesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || void 0, missionSection: buildMissionSectionBestEffort(mesh.id) });
+            systemPrompt = buildCoordinatorSystemPrompt2({ mesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || void 0, missionSection: buildMissionSectionBestEffort(mesh.id), recentActivity: await buildRecentActivityBestEffort(mesh.id), operatingNotes: await buildOperatingNotesBestEffort(mesh.id) });
           } catch (error48) {
             const message = error48?.message || String(error48);
             LOG2.error("MeshCoordinator", `Failed to build coordinator prompt: ${message}`);