@adhdev/daemon-core 0.9.82-rc.373 → 0.9.82-rc.375

package/dist/index.js

@@ -316,10 +316,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "f16b5e6cdf653b4258f8f44cb11fb6ad8c13329f" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "f16b5e6c" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.373" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-24T16:28:52.547Z" : void 0);
+  const commit = readInjected(true ? "b17fb9165bd52c9e2ab8cccf2ce80734e2165680" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "b17fb916" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.375" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-25T02:21:59.111Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -3042,6 +3042,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);
@@ -3073,6 +3077,8 @@ function expandPromptPlaceholders(template, ctx) {
     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,
@@ -3144,6 +3150,56 @@ function indentFollowing(text, pad) {
   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");
@@ -3207,6 +3263,7 @@ var init_coordinator_prompt = __esm({
 | \`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 |
@@ -8749,7 +8806,7 @@ var init_mesh_events_utils = __esm({
   "src/mesh/mesh-events-utils.ts"() {
     "use strict";
     MESH_SURFACED_PREVIEW_MAX_CHARS = 512;
-    MESH_COMPLETION_SURFACE_MAX_CHARS = 4e3;
+    MESH_COMPLETION_SURFACE_MAX_CHARS = 16e3;
   }
 });
 
@@ -9389,6 +9446,22 @@ function isWeakCompletionLedgerPayload(payload) {
   const diag = readRecord4(payload.completionDiagnostic);
   return diag?.finalAssistantPresent === false || diag?.blockReason === "missing_final_assistant";
 }
+function findTerminalLedgerEvidenceForTask(args) {
+  const taskId = readNonEmptyString2(args.taskId);
+  if (!taskId) return null;
+  const entries = readLedgerEntries(args.meshId, { tail: args.tail ?? 500 });
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entry = entries[i];
+    if (entry.kind !== "task_completed" && entry.kind !== "task_failed" && entry.kind !== "task_stalled") continue;
+    const terminalTaskId = readNonEmptyString2(entry.payload?.taskId);
+    if (terminalTaskId !== taskId) continue;
+    if (entry.kind === "task_completed" && isWeakCompletionLedgerPayload(entry.payload)) continue;
+    if (args.sessionId && entry.sessionId && entry.sessionId !== args.sessionId) continue;
+    if (!args.sessionId && args.nodeId && entry.nodeId && !meshNodeIdMatches(entry, args.nodeId)) continue;
+    return { id: entry.id, kind: entry.kind, payload: entry.payload || {}, timestamp: entry.timestamp };
+  }
+  return null;
+}
 function findDirectDispatchLedgerEntry(args) {
   const entries = readLedgerEntries(args.meshId, { tail: 500 });
   for (let i = entries.length - 1; i >= 0; i--) {
@@ -11517,7 +11590,7 @@ var init_chat_message_normalization = __esm({
   "src/providers/chat-message-normalization.ts"() {
     "use strict";
     init_contracts();
-    DEFAULT_FINAL_SUMMARY_MAX_CHARS = 4e3;
+    DEFAULT_FINAL_SUMMARY_MAX_CHARS = 16e3;
     BUILTIN_CHAT_MESSAGE_KINDS = ["standard", "thought", "tool", "terminal", "system"];
     CHAT_MESSAGE_VISIBILITIES = ["user", "debug", "internal", "hidden"];
     CHAT_MESSAGE_TRANSCRIPT_VISIBILITIES = ["visible", "chat", "user", "debug", "internal", "hidden"];
@@ -12924,6 +12997,18 @@ function isWeakTerminalLedgerPayload(payload) {
   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);
@@ -13033,6 +13118,23 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
   if (!task) {
     return false;
   }
+  const terminal = findTerminalLedgerEvidenceForTask({
+    meshId,
+    taskId: task.id
+  });
+  if (terminal) {
+    const status = terminal.kind === "task_completed" ? "completed" : "failed";
+    updateTaskStatus(meshId, task.id, status);
+    LOG.info("MeshQueue", `Skipped dispatch for terminal task ${task.id} on mesh ${meshId}; ${terminal.kind} ledger evidence already exists`);
+    traceMeshEventDrop("dispatch_terminal_ledger", {
+      taskId: task.id,
+      sessionId,
+      nodeId,
+      meshId,
+      event: "agent_command"
+    }, terminal.kind);
+    return false;
+  }
   LOG.info("MeshQueue", `Node ${nodeId} (${sessionId}) pulled task ${task.id}`);
   if (node?.daemonId && components.dispatchMeshCommand) {
     const isLocalNode = components.cliManager.adapters.has(sessionId);
@@ -13823,7 +13925,13 @@ function evaluateMeshEventSuppression(args, ctx) {
       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);
@@ -14570,20 +14678,24 @@ function daemonHostsMesh(mesh, daemonIds) {
   if (host.role && host.role !== "host") return false;
   const hostDaemonId = readNonEmptyString2(host.hostDaemonId);
   if (!hostDaemonId) return true;
-  return daemonIds.includes(hostDaemonId);
+  return daemonIdListIncludes(daemonIds, hostDaemonId);
+}
+function daemonIdListIncludes(ids, id) {
+  if (!id) return false;
+  return ids.some((candidate) => candidate === id || daemonIdsEquivalent(candidate, id));
 }
 function resolveCoordinatorSelfIds(mesh, drainDaemonIds) {
   const ids = new Set(drainDaemonIds);
   for (const node of mesh.nodes) {
     const nodeDaemonId = readNonEmptyString2(node.daemonId);
     const nodeMachineId = readNonEmptyString2(node.machineId);
-    const isSelf = nodeDaemonId && drainDaemonIds.includes(nodeDaemonId) || nodeMachineId && drainDaemonIds.includes(nodeMachineId);
+    const isSelf = nodeDaemonId && daemonIdListIncludes(drainDaemonIds, nodeDaemonId) || nodeMachineId && daemonIdListIncludes(drainDaemonIds, nodeMachineId);
     if (!isSelf) continue;
     if (nodeDaemonId) ids.add(nodeDaemonId);
     if (nodeMachineId) ids.add(nodeMachineId);
   }
   const hostDaemonId = readNonEmptyString2(mesh.meshHost?.hostDaemonId);
-  if (hostDaemonId && ids.has(hostDaemonId)) ids.add(hostDaemonId);
+  if (hostDaemonId && daemonIdListIncludes([...ids], hostDaemonId)) ids.add(hostDaemonId);
   return [...ids];
 }
 function findLiveCoordinators(components) {
@@ -14596,6 +14708,16 @@ function findLiveCoordinators(components) {
     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) {
+        LOG.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) {
+        LOG.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;
@@ -14661,6 +14783,23 @@ function recoverStrandedAssignedDispatches(meshId, store) {
     const dispatchedAtMs = Date.parse(row.dispatchTimestamp ?? "");
     if (!Number.isFinite(dispatchedAtMs)) continue;
     if (nowMs - dispatchedAtMs < ASSIGNED_STRANDED_DEADLINE_MS) continue;
+    const terminal = findTerminalLedgerEvidenceForTask({
+      meshId,
+      taskId: row.id
+    });
+    if (terminal) {
+      const status = terminal.kind === "task_completed" ? "completed" : "failed";
+      updateTaskStatus(meshId, row.id, status);
+      LOG.warn("MeshReconcile", `Skipped stranded reclaim redispatch for terminal task ${row.id} on mesh ${meshId}; ${terminal.kind} ledger evidence already exists`);
+      traceMeshEventDrop("assigned_stranded_terminal_ledger", {
+        taskId: row.id,
+        sessionId: row.assignedSessionId,
+        nodeId: row.assignedNodeId,
+        meshId,
+        event: "agent:generating_completed"
+      }, terminal.kind);
+      continue;
+    }
     if (store.taskHasConfirmedDelivery(meshId, row.id)) continue;
     const reclaimed = reclaimStrandedAssignedTask(meshId, row.id, {
       reason: "assigned_stranded_dispatch_unconfirmed",
@@ -14772,7 +14911,55 @@ async function runMeshReconcileTick(components) {
     const forceOnly = idleCoordinators.length === 0;
     if (targetCoordinators.length === 0) {
       if (modalParkedCoordinators.length > 0) {
-        LOG.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) {
+              LOG.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 {
+                }
+              }
+            }
+          }
+        }
+        LOG.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 {
@@ -14957,7 +15144,7 @@ async function pullRemoteNodeQueues(components, mesh, localDaemonId, candidateDa
     const nodeDaemonId = readNonEmptyString2(node.daemonId);
     if (!nodeDaemonId) continue;
     if (daemonIdsEquivalent(nodeDaemonId, localDaemonId)) continue;
-    if (candidateDaemonIds.includes(nodeDaemonId)) continue;
+    if (daemonIdListIncludes(candidateDaemonIds, nodeDaemonId)) continue;
     for (const pendingEventArgs of pulls) {
       let events;
       try {
@@ -15013,7 +15200,7 @@ async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds,
     if (!sessionId || !nodeId || !taskId) continue;
     const node = nodeById.get(nodeId);
     const nodeDaemonId = readNonEmptyString2(node?.daemonId);
-    const isLocalNode = !nodeDaemonId || selfIds.includes(nodeDaemonId) || daemonIdsEquivalent(nodeDaemonId, localDaemonId) || !!components.instanceManager.getInstance(sessionId);
+    const isLocalNode = !nodeDaemonId || daemonIdListIncludes(selfIds, nodeDaemonId) || daemonIdsEquivalent(nodeDaemonId, localDaemonId) || !!components.instanceManager.getInstance(sessionId);
     const providerType = readNonEmptyString2(dispatch.providerType);
     const readArgs = {
       sessionId,
@@ -15043,6 +15230,19 @@ async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds,
     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) {
+      LOG.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 {
@@ -15088,7 +15288,7 @@ async function collectLiveNodesWithSessions(components, mesh, selfIds, localDaem
   const dispatchMeshCommand = components.dispatchMeshCommand;
   return Promise.all(mesh.nodes.map(async (node) => {
     const nodeDaemonId = readNonEmptyString2(node.daemonId);
-    const isLocalNode = !nodeDaemonId || selfIds.includes(nodeDaemonId) || daemonIdsEquivalent(nodeDaemonId, localDaemonId);
+    const isLocalNode = !nodeDaemonId || daemonIdListIncludes(selfIds, nodeDaemonId) || daemonIdsEquivalent(nodeDaemonId, localDaemonId);
     let statusResult;
     try {
       if (isLocalNode) {
@@ -15170,7 +15370,7 @@ function setupMeshReconcileLoop(components) {
     }
   };
 }
-var DEFAULT_RECONCILE_INTERVAL_MS, DEFAULT_AUTO_PRUNE_MIN_AGE_MS, heldEventLedgerRecorded, ASSIGNED_STRANDED_DEADLINE_MS, STRICT_SESSION_MATCH_TTL_MS, unresolvedForwardRejectionCounts, MAX_FORWARD_REJECTIONS;
+var DEFAULT_RECONCILE_INTERVAL_MS, DEFAULT_AUTO_PRUNE_MIN_AGE_MS, coordinatorModalParkState, heldEventLedgerRecorded, ASSIGNED_STRANDED_DEADLINE_MS, STRICT_SESSION_MATCH_TTL_MS, unresolvedForwardRejectionCounts, MAX_FORWARD_REJECTIONS;
 var init_mesh_reconcile_loop = __esm({
   "src/mesh/mesh-reconcile-loop.ts"() {
     "use strict";
@@ -15192,6 +15392,7 @@ var init_mesh_reconcile_loop = __esm({
     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;
@@ -38130,6 +38331,8 @@ function getMessageTime(message) {
 }
 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",
@@ -38401,6 +38604,14 @@ var CliProviderInstance = class _CliProviderInstance {
   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;
@@ -38835,6 +39046,15 @@ var CliProviderInstance = class _CliProviderInstance {
     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({
@@ -38852,6 +39072,13 @@ var CliProviderInstance = class _CliProviderInstance {
       }
     }), 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();
@@ -39541,8 +39768,9 @@ var CliProviderInstance = class _CliProviderInstance {
             previousStatus: this.lastStatus
           };
           const ownsExternalHistory = !!this.adapter?.chatMessagesOwnedExternally;
-          const flushDelay = ownsExternalHistory ? 0 : 3e3;
-          LOG.debug("CLI", `[${this.type}] set completedDebouncePending duration=${duration}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;
+          LOG.debug("CLI", `[${this.type}] set completedDebouncePending duration=${duration}s ownsExternalHistory=${ownsExternalHistory} meshWorker=${meshWorkerSession} flushDelay=${flushDelay}ms generatingStartedAt=${this.generatingStartedAt}`);
           this.scheduleCompletedDebounceFlush(flushDelay);
         }
       } else if (newStatus === "idle" && this.lastStatus === "starting") {
@@ -42597,11 +42825,11 @@ var cliAgentHandlers = {
         }
       }
     }
-    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);
@@ -42609,17 +42837,22 @@ var cliAgentHandlers = {
         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) => {
@@ -46871,7 +47104,7 @@ var meshCrudHandlers = {
             return "";
           }
         })();
-        const isCoordinatorBaseNode = !!selfDaemonId && (nodeDaemonId === selfDaemonId || nodeMachineId === selfDaemonId) || !!selfMachineId && (nodeDaemonId === selfMachineId || nodeMachineId === selfMachineId);
+        const isCoordinatorBaseNode = !!selfDaemonId && (daemonIdsEquivalent(nodeDaemonId, selfDaemonId) || daemonIdsEquivalent(nodeMachineId, selfDaemonId)) || !!selfMachineId && (daemonIdsEquivalent(nodeDaemonId, selfMachineId) || daemonIdsEquivalent(nodeMachineId, selfMachineId));
         if (isCoordinatorBaseNode) {
           return {
             success: false,
@@ -47741,49 +47974,72 @@ var fastForwardHandlers = {
     };
   },
   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() : "";
@@ -47940,6 +48196,56 @@ var meshCoordinatorLaunchHandlers = {
           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;
@@ -48030,7 +48336,7 @@ var meshCoordinatorLaunchHandlers = {
       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 (error) {
           const message = error?.message || String(error);
           LOG.error("MeshCoordinator", `Failed to build coordinator prompt: ${message}`);
@@ -48207,7 +48513,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 (error) {
         const message = error?.message || String(error);
         LOG.error("MeshCoordinator", `Failed to build coordinator prompt: ${message}`);