@adhdev/daemon-core 0.9.82-rc.292 → 0.9.82-rc.293

package/dist/index.js

@@ -275,10 +275,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "7b5b620e2df42c7c3beb8a2983e3cc076c25f832" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "7b5b620e" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.292" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-16T09:16:23.646Z" : void 0);
+  const commit = readInjected(true ? "88f97abcc85d83fe5d5313b229d32a7d76b1208a" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "88f97abc" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.293" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-16T11:13:51.625Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -349,6 +349,15 @@ async function getGitRepoStatus(workspace, options = {}) {
     );
   }
 }
+function isNonRuntimeRootFile(file) {
+  const base = file.slice(file.lastIndexOf("/") + 1);
+  if (/^\.(?:verify|marker|converge|ff-verify|patch-equiv|live-verify)\b/i.test(base)) return true;
+  if (/(?:^|\/)docs\//i.test(file)) return true;
+  if (/^(?:README|CHANGELOG|LICENSE|NOTICE|AUTHORS|CONTRIBUTING|CODEOWNERS)(?:\.[A-Za-z0-9]+)?$/i.test(base)) {
+    return true;
+  }
+  return false;
+}
 async function classifyDaemonBuildChange(repoPath, buildCommit, options) {
   try {
     const diff = await runGit(repoPath, ["diff", "--name-only", `${buildCommit}..HEAD`], options);
@@ -357,18 +366,18 @@ async function classifyDaemonBuildChange(repoPath, buildCommit, options) {
       return { isDaemonAffecting: true, affectedPackages: [] };
     }
     const pkgs = /* @__PURE__ */ new Set();
-    let sawNonPackageOrUnknown = false;
+    let sawRuntimeAmbiguousNonPackage = false;
     for (const file of files) {
       const match = file.match(/(?:^|\/)packages\/([^/]+)\//);
       if (!match) {
-        sawNonPackageOrUnknown = true;
+        if (!isNonRuntimeRootFile(file)) sawRuntimeAmbiguousNonPackage = true;
         continue;
       }
       pkgs.add(match[1]);
     }
     const affectedPackages = [...pkgs].sort();
-    const allWebOnly = !sawNonPackageOrUnknown && affectedPackages.length > 0 && affectedPackages.every((p) => WEB_ONLY_PACKAGES.has(p) && !DAEMON_RUNTIME_PACKAGES.has(p));
-    return { isDaemonAffecting: !allWebOnly, affectedPackages };
+    const allBenign = !sawRuntimeAmbiguousNonPackage && affectedPackages.every((p) => WEB_ONLY_PACKAGES.has(p) && !DAEMON_RUNTIME_PACKAGES.has(p));
+    return { isDaemonAffecting: !allBenign, affectedPackages };
   } catch {
     return { isDaemonAffecting: true, affectedPackages: [] };
   }
@@ -395,7 +404,8 @@ async function detectDaemonBuildBehind(repo, submodules, options) {
         options
       );
       const scopeLabel = scope === "root" ? "workspace" : scope;
-      const warning = isDaemonAffecting ? `Live daemon was built from ${build.commitShort} which is behind ${scopeLabel} HEAD ${head.slice(0, 7)}. Merged code is NOT live until the daemon is rebuilt/redeployed and restarted \u2014 a local dist rebuild alone does not update a cloud daemon.` : `Live daemon was built from ${build.commitShort} which is behind ${scopeLabel} HEAD ${head.slice(0, 7)}, but only web packages changed (${(affectedPackages || []).join(", ") || "web"}). Daemon restart NOT required \u2014 redeploy the web app to reflect the change.`;
+      const benignDetail = affectedPackages.length > 0 ? `only web packages changed (${affectedPackages.join(", ")})` : "only non-runtime files changed (markers/docs)";
+      const warning = isDaemonAffecting ? `Live daemon was built from ${build.commitShort} which is behind ${scopeLabel} HEAD ${head.slice(0, 7)}. Merged code is NOT live until the daemon is rebuilt/redeployed and restarted \u2014 a local dist rebuild alone does not update a cloud daemon.` : `Live daemon was built from ${build.commitShort} which is behind ${scopeLabel} HEAD ${head.slice(0, 7)}, but ${benignDetail}. Daemon restart NOT required \u2014 redeploy the web app to reflect the change.`;
       return {
         buildCommit: build.commit,
         buildCommitShort: build.commitShort,
@@ -1997,7 +2007,7 @@ function buildRulesSection(coordinatorCliType) {
 - **Reuse idle sessions.** For follow-up, retry, commit/push, or cleanup on the same issue, send only the delta to the existing idle session. Start fresh only for independent work, provider mismatch, transcript contamination, or required worktree isolation.
 - **Respect explicit provider requests.** Map: Hermes \u2192 \`hermes-cli\`, Claude/Claude Code \u2192 \`claude-cli\`, Codex \u2192 \`codex-cli\`, Gemini \u2192 \`gemini-cli\`, Antigravity \u2192 \`antigravity-cli\`. Never substitute the coordinator's own runtime.
 - **Verify via git, not source.** Use \`mesh_git_status\` to confirm side effects. Treat agent summaries as self-reports, not verification.
-- **Limit parallelism.** Start with 1\u20132 tasks; scale only on success. Never duplicate a session because \`mesh_read_chat\` shows no final message while tool/terminal activity is ongoing.
+- **Limit parallelism.** Start with 1\u20132 tasks; scale only on success. Never duplicate a session because \`mesh_read_chat\` shows no final message while tool/terminal activity is ongoing. This caps *concurrent* load \u2014 it does not mean serialize independent work: when a new, independent request arrives and there is headroom under \`maxParallelTasks\`, dispatch it right away rather than waiting for an in-flight task or a user nudge (read-only diagnosis especially, since it has no merge cost).
 - **Check history first.** Call \`mesh_task_history\` at session start to avoid duplicate work and inform recovery. On failure, read task history before retrying.
 - **Converge branches.** After worktree tasks: refine/fast-forward, or classify as \`pushed_feature_branch_needs_merge\` / \`blocked_review\` / \`cleanup_candidate\` / \`not_mergeable\`. Clean up with \`mesh_remove_node\`.
 - **Refinery is config-driven.** \`mesh_refine_node\` must run validation from \`.adhdev/refine.{json,yaml,yml}\` or \`repo-mesh.refine.*\`. Heuristics are scaffolding only.
@@ -2051,7 +2061,7 @@ Before doing any coordinator work, confirm that the actual callable tool list in
    c. **Targeted Tasks**: Use \`mesh_send_task\` only when you need to bypass the queue and force a specific node to execute a task immediately.
    d. For the first dispatch of a new task, provide a **complete, self-contained** instruction that includes all context the agent needs (file paths, line numbers, what to change, why). Do not send partial instructions expecting future follow-up.
    e. For a continuation of the same issue in an existing session, send a concise **delta instruction**: current verified state, the exact failed/blocked step, the newly approved action, and final reporting requirements. Do not resend the full original task or open a new chat solely to continue the same work; that wastes coordinator and worker context.
-4. **Monitor** \u2014 Prefer event-driven completion/status notifications. Do **not** poll \`mesh_read_chat\` repeatedly. Do **not** repeatedly call \`mesh_status\` or \`mesh_view_queue\` just to wait for assigned/generating work. After dispatching a direct or queued task, send one progress update with the task/session handle, then stop. Wait for \`pendingCoordinatorEvents\` or another completion/approval/status signal, an explicit user status request, or a real timeout/stall signal before reading status/chat/queue again. Use at most one compact \`mesh_read_chat\` check after a terminal signal. Handle approvals via \`mesh_approve\`.
+4. **Monitor** \u2014 Prefer event-driven completion/status notifications. Do **not** poll \`mesh_read_chat\` repeatedly. Do **not** repeatedly call \`mesh_status\` or \`mesh_view_queue\` just to wait for assigned/generating work. After dispatching a direct or queued task, send one progress update with the task/session handle, then stop. Wait for \`pendingCoordinatorEvents\` or another completion/approval/status signal, an explicit user status request, or a real timeout/stall signal before reading status/chat/queue again. Use at most one compact \`mesh_read_chat\` check after a terminal signal. Handle approvals via \`mesh_approve\`. **Proactively parallelize new work.** When the user reports a new bug or asks for new work, start it immediately if it is independent of in-flight tasks and there is headroom under \`maxParallelTasks\` \u2014 do not wait for a current task to finish or for the user to prompt you to parallelize. Read-only diagnosis (\`live_debug_readonly\`) has no isolation or merge cost, so dispatch it in parallel right away. The no-polling / concurrency-limit rules constrain *re-checking or duplicating already-dispatched work*; they are **not** a reason to defer starting a new, independent task.
 5. **Verify** \u2014 When a task reports completion or git work is visible, call \`mesh_git_status\` to verify changes were made.
 6. **Checkpoint** \u2014 Call \`mesh_checkpoint\` to save the work.
 7. **Converge branches** \u2014 Before marking any task complete, classify every touched node/branch into exactly one final state: \`merged_to_main\`, \`pushed_feature_branch_needs_merge\`, \`blocked_review\`, \`cleanup_candidate\`, or \`not_mergeable\`. Use \`mesh_status\` branchConvergenceSummary. For obvious clean branch catch-up (ahead 0, behind > 0, upstream fresh, no dirty/stash/submodule issues), use \`mesh_fast_forward_node\` dry-run first and execute only when explicitly safe/approved; this avoids consuming an agent session. Use \`mesh_refine_node\` for clean worktree branches when safe. Before/refine merging root commits that contain submodule gitlink changes, require each submodule commit to be reachable from the configured submodule remote main branch, not merely present on a feature ref or local checkout. If \`mesh_refine_node\` returns \`submodule_reachability_failed\` or publish-required evidence, keep the public convergence bucket as \`blocked_review\`; unless \`allowAutoPublishSubmoduleMainCommits\` is explicitly enabled and Refinery reports successful non-force publish plus post-publish verification, ask the user for explicit approval to push/publish the unreachable submodule commit(s) to submodule main, then rerun \`mesh_refine_node\`. Do not merge the root branch until the submodule commit(s) are reachable from submodule origin/main. A task that remains on a non-main branch is not fully complete unless the final report names the follow-up state and next step.
@@ -4395,6 +4405,34 @@ var init_mesh_runtime_store = __esm({
         ).get(meshId);
         return row?.cnt ?? 0;
       }
+      /**
+       * Mark specific pending-event rows drained by id (ack). Used by the
+       * unresolved-delegate durable-forward outbox: an event is peeked (not drained)
+       * while its push to the coordinator is unconfirmed, then marked drained ONLY
+       * after the push is acked. A failed push leaves the row undrained so the next
+       * reconcile tick retries it. Returns the number of rows newly marked drained.
+       */
+      markPendingEventsDrainedById(ids) {
+        const idList = ids.filter((id) => typeof id === "string" && id.length > 0);
+        if (idList.length === 0) return 0;
+        const now = Date.now();
+        return this.db.prepare(
+          `UPDATE mesh_pending_events SET drained = 1, drained_at = ? WHERE drained = 0 AND id IN (${idList.map(() => "?").join(",")})`
+        ).run(now, ...idList).changes;
+      }
+      /**
+       * Hard-delete pending-event rows by id (including the dedup fingerprint history).
+       * Used to expire an unresolved-delegate outbox entry that has exhausted its retry
+       * budget — fully removing it frees the fingerprint so a genuinely new completion
+       * for the same task could be re-queued later. Returns the number of rows deleted.
+       */
+      deletePendingEventsById(ids) {
+        const idList = ids.filter((id) => typeof id === "string" && id.length > 0);
+        if (idList.length === 0) return 0;
+        return this.db.prepare(
+          `DELETE FROM mesh_pending_events WHERE id IN (${idList.map(() => "?").join(",")})`
+        ).run(...idList).changes;
+      }
     };
   }
 });
@@ -4402,6 +4440,7 @@ var init_mesh_runtime_store = __esm({
 // src/mesh/mesh-missions.ts
 var mesh_missions_exports = {};
 __export(mesh_missions_exports, {
+  GOAL_PREVIEW_MAX: () => GOAL_PREVIEW_MAX,
   MESH_MISSION_STATUSES: () => MESH_MISSION_STATUSES,
   buildMissionPromptSection: () => buildMissionPromptSection,
   getActiveMeshMissionSummaries: () => getActiveMeshMissionSummaries,
@@ -4473,12 +4512,23 @@ function summarizeMeshMission(meshId, mission) {
 function getActiveMeshMissionSummaries(meshId) {
   return getMeshMissions(meshId, ["active"]).map((mission) => summarizeMeshMission(meshId, mission));
 }
+function slimMissionSummary(summary) {
+  const goal = typeof summary.goal === "string" ? summary.goal : "";
+  const goalTruncated = goal.length > GOAL_PREVIEW_MAX;
+  const { goal: _omitGoal, ...rest } = summary;
+  return {
+    ...rest,
+    goalPreview: goalTruncated ? goal.slice(0, GOAL_PREVIEW_MAX) : goal,
+    goalTruncated
+  };
+}
 function getMeshStatusMissionSummaries(meshId, options) {
   const historyLimit = Math.max(0, options?.historyLimit ?? 10);
   const all = getMeshMissions(meshId);
   const live = all.filter((m) => m.status === "active" || m.status === "paused");
   const history = all.filter((m) => m.status === "completed" || m.status === "abandoned").sort((a, b) => (b.updatedAt || "").localeCompare(a.updatedAt || "")).slice(0, historyLimit);
-  return [...live, ...history].map((mission) => summarizeMeshMission(meshId, mission));
+  const full = [...live, ...history].map((mission) => summarizeMeshMission(meshId, mission));
+  return options?.verbose ? full : full.map(slimMissionSummary);
 }
 function buildMissionPromptSection(meshId) {
   const summaries = getActiveMeshMissionSummaries(meshId);
@@ -4498,7 +4548,7 @@ function buildMissionPromptSection(meshId) {
   );
   return lines.join("\n");
 }
-var import_crypto6, MESH_MISSION_STATUSES;
+var import_crypto6, MESH_MISSION_STATUSES, GOAL_PREVIEW_MAX;
 var init_mesh_missions = __esm({
   "src/mesh/mesh-missions.ts"() {
     "use strict";
@@ -4506,6 +4556,7 @@ var init_mesh_missions = __esm({
     init_mesh_runtime_store();
     init_mesh_work_queue();
     MESH_MISSION_STATUSES = ["active", "paused", "completed", "abandoned"];
+    GOAL_PREVIEW_MAX = 120;
   }
 });
 
@@ -7604,6 +7655,111 @@ var init_mesh_routing = __esm({
   }
 });
 
+// src/mesh/mesh-unresolved-forward-outbox.ts
+function getStore() {
+  try {
+    return MeshRuntimeStore.getInstance();
+  } catch {
+    return void 0;
+  }
+}
+function enqueueUnresolvedDelegateForward(coordinatorDaemonId, eventName, forwardPayload) {
+  const target = readNonEmptyString2(coordinatorDaemonId);
+  const event = readNonEmptyString2(eventName);
+  if (!target || !event) return false;
+  const store = getStore();
+  if (!store) return false;
+  const queuedAt = Date.now();
+  const fingerprintSource = {
+    event,
+    meshId: UNRESOLVED_FORWARD_OUTBOX_MESH_ID,
+    nodeLabel: readNonEmptyString2(forwardPayload.nodeId) || readNonEmptyString2(forwardPayload.workspace) || "unresolved-delegate",
+    nodeId: readNonEmptyString2(forwardPayload.nodeId) || void 0,
+    workspace: readNonEmptyString2(forwardPayload.workspace) || void 0,
+    metadataEvent: forwardPayload,
+    queuedAt,
+    targetCoordinatorDaemonId: target
+  };
+  const fingerprint = `${target}::${buildPendingEventFingerprint(fingerprintSource)}`;
+  try {
+    const inserted = store.insertPendingEvent({
+      id: (0, import_crypto9.randomUUID)(),
+      meshId: UNRESOLVED_FORWARD_OUTBOX_MESH_ID,
+      coordinatorDaemonId: target,
+      event,
+      // Store the flat forward payload + the queue timestamp so the retry tick can
+      // rebuild the push args and apply age-based expiry without a schema change.
+      payload: { forwardPayload, coordinatorDaemonId: target, queuedAt },
+      fingerprint,
+      queuedAt
+    });
+    if (inserted) {
+      LOG.info("MeshEvents", `Durably queued unresolved-delegate ${event} for coordinator ${target} (outbox)`);
+    }
+    return true;
+  } catch (e) {
+    LOG.warn("MeshEvents", `Failed to persist unresolved-delegate forward to outbox: ${e?.message || e}`);
+    return false;
+  }
+}
+function peekUnresolvedDelegateForwards() {
+  const store = getStore();
+  if (!store) return [];
+  let rows;
+  try {
+    rows = store.peekPendingEvents(UNRESOLVED_FORWARD_OUTBOX_MESH_ID);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const row of rows) {
+    const stored = row.payload && typeof row.payload === "object" ? row.payload : {};
+    const coordinatorDaemonId = readNonEmptyString2(stored.coordinatorDaemonId);
+    const forwardPayload = stored.forwardPayload && typeof stored.forwardPayload === "object" ? stored.forwardPayload : void 0;
+    if (!coordinatorDaemonId || !forwardPayload) continue;
+    const queuedAt = typeof stored.queuedAt === "number" ? stored.queuedAt : 0;
+    out.push({ id: row.id, coordinatorDaemonId, payload: forwardPayload, queuedAt });
+  }
+  return out;
+}
+function ackUnresolvedDelegateForward(id) {
+  const store = getStore();
+  if (!store) return;
+  try {
+    store.markPendingEventsDrainedById([id]);
+  } catch {
+  }
+}
+function expireStaleUnresolvedDelegateForwards(nowMs = Date.now()) {
+  const entries = peekUnresolvedDelegateForwards();
+  const staleIds = entries.filter((e) => e.queuedAt > 0 && nowMs - e.queuedAt >= UNRESOLVED_FORWARD_MAX_AGE_MS).map((e) => e.id);
+  if (staleIds.length === 0) return 0;
+  const store = getStore();
+  if (!store) return 0;
+  try {
+    const removed = store.deletePendingEventsById(staleIds);
+    if (removed > 0) {
+      LOG.warn("MeshEvents", `Expired ${removed} unresolved-delegate forward(s) after ${Math.round(UNRESOLVED_FORWARD_MAX_AGE_MS / 6e4)}m of failed retries \u2014 coordinator unreachable, completion dropped`);
+    }
+    return removed;
+  } catch {
+    return 0;
+  }
+}
+var import_crypto9, UNRESOLVED_FORWARD_OUTBOX_MESH_ID, UNRESOLVED_FORWARD_MAX_AGE_MS;
+var init_mesh_unresolved_forward_outbox = __esm({
+  "src/mesh/mesh-unresolved-forward-outbox.ts"() {
+    "use strict";
+    import_crypto9 = require("crypto");
+    init_logger();
+    init_mesh_runtime_store();
+    init_mesh_events_pending();
+    init_mesh_events_utils();
+    UNRESOLVED_FORWARD_OUTBOX_MESH_ID = "__unresolved_forward_outbox__";
+    UNRESOLVED_FORWARD_MAX_AGE_MS = 30 * 60 * 1e3;
+  }
+});
+
 // src/mesh/mesh-events-coordinator.ts
 function resolveCoordinatorDrainDaemonIds(components) {
   const ids = /* @__PURE__ */ new Set();
@@ -8738,12 +8894,25 @@ function forwardUnresolvedDelegateEvent(components, routing, event) {
     nodeId: readNonEmptyString2(routing.nodeId) || readNonEmptyString2(event.meshNodeId) || void 0,
     workspace: readNonEmptyString2(routing.workspace) || readNonEmptyString2(event.workspace) || void 0
   };
-  Promise.resolve(components.dispatchMeshCommand(coordinatorDaemonId, "mesh_forward_event", payload)).catch((e) => {
-    LOG.warn("MeshEvents", `Fallback forward of ${eventName} to coordinator ${coordinatorDaemonId} failed: ${e?.message || e}`);
+  const persisted = enqueueUnresolvedDelegateForward(coordinatorDaemonId, eventName, payload);
+  Promise.resolve(components.dispatchMeshCommand(coordinatorDaemonId, "mesh_forward_event", payload)).then((result) => {
+    if (result && result.success === false) {
+      LOG.warn("MeshEvents", `Immediate forward of ${eventName} to coordinator ${coordinatorDaemonId} rejected (${readNonEmptyString2(result.error) || "no reason"}) \u2014 left queued for retry`);
+      return;
+    }
+    if (persisted) ackUnresolvedDelegateForwardByFingerprint(coordinatorDaemonId, eventName, payload);
+  }).catch((e) => {
+    LOG.warn("MeshEvents", `Immediate forward of ${eventName} to coordinator ${coordinatorDaemonId} failed: ${e?.message || e} \u2014 left queued for retry`);
   });
-  LOG.info("MeshEvents", `Fallback-forwarded ${eventName} for unresolved-mesh worker at ${routing.workspace || "(no workspace)"} to coordinator daemon ${coordinatorDaemonId}`);
+  LOG.info("MeshEvents", `Durably forwarded ${eventName} for unresolved-mesh worker at ${routing.workspace || "(no workspace)"} to coordinator daemon ${coordinatorDaemonId}`);
   return true;
 }
+function ackUnresolvedDelegateForwardByFingerprint(coordinatorDaemonId, eventName, payload) {
+  const match = peekUnresolvedDelegateForwards().find(
+    (entry) => entry.coordinatorDaemonId === coordinatorDaemonId && readNonEmptyString2(entry.payload.event) === eventName && readNonEmptyString2(entry.payload.targetSessionId || entry.payload.sessionId || entry.payload.instanceId) === readNonEmptyString2(payload.targetSessionId || payload.sessionId || payload.instanceId) && readNonEmptyString2(entry.payload.workspace) === readNonEmptyString2(payload.workspace)
+  );
+  if (match) ackUnresolvedDelegateForward(match.id);
+}
 function setupMeshEventForwarding(components) {
   components.instanceManager.onEvent((event) => {
     if (event.event === "agent:ready" || event.event === "agent:generating_completed") {
@@ -8825,6 +8994,7 @@ var init_mesh_events_coordinator = __esm({
     init_mesh_runtime_store();
     init_mesh_events_pending();
     init_mesh_routing();
+    init_mesh_unresolved_forward_outbox();
     init_repo_mesh_types();
     init_dist();
     init_mesh_events_stale();
@@ -8940,6 +9110,13 @@ async function runMeshReconcileTick(components) {
       return void 0;
     }
   })();
+  if (dispatchMeshCommand) {
+    try {
+      await retryUnresolvedDelegateForwards(components);
+    } catch (e) {
+      LOG.warn("MeshReconcile", `Unresolved-delegate forward retry failed: ${e?.message || e}`);
+    }
+  }
   if (dispatchMeshCommand) {
     for (const mesh of listMeshes()) {
       const selfIds = resolveCoordinatorSelfIds(mesh, drainDaemonIds);
@@ -8993,6 +9170,28 @@ async function runMeshReconcileTick(components) {
     }
   }
 }
+async function retryUnresolvedDelegateForwards(components) {
+  const dispatchMeshCommand = components.dispatchMeshCommand;
+  if (!dispatchMeshCommand) return;
+  expireStaleUnresolvedDelegateForwards();
+  const entries = peekUnresolvedDelegateForwards();
+  if (entries.length === 0) return;
+  for (const entry of entries) {
+    let result;
+    try {
+      result = await dispatchMeshCommand(entry.coordinatorDaemonId, "mesh_forward_event", entry.payload);
+    } catch (e) {
+      LOG.warn("MeshReconcile", `Retry forward to coordinator ${entry.coordinatorDaemonId} failed: ${e?.message || e} \u2014 left queued`);
+      continue;
+    }
+    if (result && result.success === false) {
+      LOG.warn("MeshReconcile", `Retry forward to coordinator ${entry.coordinatorDaemonId} rejected (${readNonEmptyString2(result.error) || "no reason"}) \u2014 left queued`);
+      continue;
+    }
+    ackUnresolvedDelegateForward(entry.id);
+    LOG.info("MeshReconcile", `Retried+delivered unresolved-delegate ${readNonEmptyString2(entry.payload.event)} to coordinator ${entry.coordinatorDaemonId}`);
+  }
+}
 async function pullRemoteNodeQueues(components, mesh, localDaemonId, candidateDaemonIds) {
   const dispatchMeshCommand = components.dispatchMeshCommand;
   if (!dispatchMeshCommand) return;
@@ -9069,6 +9268,7 @@ var init_mesh_reconcile_loop = __esm({
     init_mesh_events_pending();
     init_mesh_runtime_store();
     init_mesh_events_coordinator();
+    init_mesh_unresolved_forward_outbox();
     init_mesh_events_utils();
     DEFAULT_RECONCILE_INTERVAL_MS = 4e3;
   }
@@ -22340,7 +22540,7 @@ var ExtensionProviderInstance = class {
     this.runtimeMessages = [];
   }
   updateSettings(newSettings) {
-    this.settings = { ...newSettings };
+    this.settings = { ...this.settings, ...newSettings };
     this.monitor.updateConfig({
       approvalAlert: this.settings.approvalAlert !== false,
       longGeneratingAlert: this.settings.longGeneratingAlert !== false,
@@ -23007,7 +23207,7 @@ var IdeProviderInstance = class {
     this.extensions.clear();
   }
   updateSettings(newSettings) {
-    this.settings = { ...newSettings };
+    this.settings = { ...this.settings, ...newSettings };
     this.monitor.updateConfig({
       approvalAlert: this.settings.approvalAlert !== false,
       longGeneratingAlert: this.settings.longGeneratingAlert !== false,
@@ -32555,22 +32755,7 @@ var CliProviderInstance = class _CliProviderInstance {
     };
   }
   updateSettings(newSettings) {
-    const runtimeMeshSettings = {};
-    for (const key of [
-      "meshNodeFor",
-      "meshNodeId",
-      "meshActiveTaskId",
-      "meshCoordinatorFor",
-      "meshCoordinatorDaemonId",
-      "meshCoordinatorNodeId",
-      "spawnedSessionVisibility",
-      "launchedByCoordinator"
-    ]) {
-      if (this.settings[key] !== void 0 && newSettings[key] === void 0) {
-        runtimeMeshSettings[key] = this.settings[key];
-      }
-    }
-    this.settings = { ...newSettings, ...runtimeMeshSettings };
+    this.settings = { ...this.settings, ...newSettings };
     this.adapter.updateRuntimeSettings?.(this.settings);
     this.monitor.updateConfig({
       approvalAlert: this.settings.approvalAlert !== false,
@@ -46628,9 +46813,9 @@ ${hintLines.join("\n")}` : "",
           });
           let node;
           if (meshRecord.inline) {
-            const { randomUUID: randomUUID14 } = await import("crypto");
+            const { randomUUID: randomUUID15 } = await import("crypto");
             node = {
-              id: `node_${randomUUID14().replace(/-/g, "")}`,
+              id: `node_${randomUUID15().replace(/-/g, "")}`,
               workspace: result.worktreePath,
               repoRoot: result.worktreePath,
               daemonId: sourceNode.daemonId,
@@ -47404,10 +47589,11 @@ ${ptyResult.output.slice(-2e3)}`);
           if (!mesh) return { success: false, error: "Mesh not found" };
           const meshHost = resolveMeshHostStatus(mesh);
           const refreshRequested = args?.refresh === true || args?.forceRefresh === true;
+          const verboseMissions = args?.verbose === true || args?.compact === false;
           const peekScope = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : this.deps.statusInstanceId || void 0;
           const pendingCoordinatorEventCount = getPendingMeshCoordinatorEvents(meshId, peekScope).length;
           const hadAggregateCache = this.aggregateMeshStatusCache.has(meshId);
-          if (!refreshRequested && pendingCoordinatorEventCount === 0) {
+          if (!refreshRequested && !verboseMissions && pendingCoordinatorEventCount === 0) {
             const cachedStatus = this.getCachedAggregateMeshStatus(meshId, mesh, { requireDirectPeerTruth: args?.requireDirectPeerTruth === true });
             if (cachedStatus) {
               logRepoMeshStatusDebug("return_cached", {
@@ -47710,7 +47896,7 @@ ${ptyResult.output.slice(-2e3)}`);
             liveSessionRecords: liveMeshSessions
           });
           const { getMeshStatusMissionSummaries: getMeshStatusMissionSummaries2 } = await Promise.resolve().then(() => (init_mesh_missions(), mesh_missions_exports));
-          const missions = getMeshStatusMissionSummaries2(meshId);
+          const missions = getMeshStatusMissionSummaries2(meshId, { verbose: verboseMissions });
           const statusResult = {
             success: true,
             meshId: mesh.id,
@@ -47764,7 +47950,7 @@ ${ptyResult.output.slice(-2e3)}`);
             }))
           };
           const { pendingCoordinatorEvents: _pendingCoordinatorEvents, unroutableDeliveries: _unroutableDeliveries, ...cacheableStatusResult } = statusResult;
-          const rememberedStatus = this.rememberAggregateMeshStatus(meshId, cacheableStatusResult, refreshReason);
+          const rememberedStatus = verboseMissions ? cacheableStatusResult : this.rememberAggregateMeshStatus(meshId, cacheableStatusResult, refreshReason);
           const returnedStatus = {
             ...rememberedStatus,
             ...pendingCoordinatorEvents.length > 0 ? { pendingCoordinatorEvents } : {},
@@ -55318,7 +55504,7 @@ var SessionHostPtyTransportFactory = class {
 };
 
 // src/cli-adapters/raw-terminal-io.ts
-var import_crypto9 = require("crypto");
+var import_crypto10 = require("crypto");
 var import_session_host_core10 = require("@adhdev/session-host-core");
 var BASE_KEY_SEQUENCES = {
   enter: "\r",
@@ -55416,7 +55602,7 @@ var RawTerminalAttachment = class _RawTerminalAttachment {
     const sessionId = String(options.sessionId || "").trim();
     if (!sessionId) throw new Error("sessionId is required");
     const mode = options.mode || "read";
-    const clientId = options.clientId || `raw-terminal-${process.pid}-${(0, import_crypto9.randomUUID)().slice(0, 8)}`;
+    const clientId = options.clientId || `raw-terminal-${process.pid}-${(0, import_crypto10.randomUUID)().slice(0, 8)}`;
     const client = options.client || new import_session_host_core10.SessionHostClient({ endpoint: options.endpoint });
     await client.connect();
     const attachResponse = await client.request({