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

package/dist/index.js

@@ -29983,10 +29983,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "7b5b620e2df42c7c3beb8a2983e3cc076c25f832" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "7b5b620e" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = 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:52.266Z" : 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 version2 = 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:14:20.929Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -30055,6 +30055,15 @@ var require_dist3 = __commonJS({
         );
       }
     }
+    function isNonRuntimeRootFile(file2) {
+      const base = file2.slice(file2.lastIndexOf("/") + 1);
+      if (/^\.(?:verify|marker|converge|ff-verify|patch-equiv|live-verify)\b/i.test(base)) return true;
+      if (/(?:^|\/)docs\//i.test(file2)) 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);
@@ -30063,18 +30072,18 @@ var require_dist3 = __commonJS({
           return { isDaemonAffecting: true, affectedPackages: [] };
         }
         const pkgs = /* @__PURE__ */ new Set();
-        let sawNonPackageOrUnknown = false;
+        let sawRuntimeAmbiguousNonPackage = false;
         for (const file2 of files) {
           const match = file2.match(/(?:^|\/)packages\/([^/]+)\//);
           if (!match) {
-            sawNonPackageOrUnknown = true;
+            if (!isNonRuntimeRootFile(file2)) 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: [] };
       }
@@ -30101,7 +30110,8 @@ var require_dist3 = __commonJS({
             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,
@@ -31713,7 +31723,7 @@ ${rules.join("\n")}`;
 - **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.
@@ -31772,7 +31782,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.
@@ -34138,11 +34148,40 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
             ).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;
+          }
         };
       }
     });
     var mesh_missions_exports = {};
     __export2(mesh_missions_exports, {
+      GOAL_PREVIEW_MAX: () => GOAL_PREVIEW_MAX,
       MESH_MISSION_STATUSES: () => MESH_MISSION_STATUSES,
       buildMissionPromptSection: () => buildMissionPromptSection,
       getActiveMeshMissionSummaries: () => getActiveMeshMissionSummaries,
@@ -34214,12 +34253,23 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     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);
@@ -34241,6 +34291,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     }
     var import_crypto6;
     var MESH_MISSION_STATUSES;
+    var GOAL_PREVIEW_MAX;
     var init_mesh_missions = __esm2({
       "src/mesh/mesh-missions.ts"() {
         "use strict";
@@ -34248,6 +34299,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         init_mesh_runtime_store();
         init_mesh_work_queue();
         MESH_MISSION_STATUSES = ["active", "paused", "completed", "abandoned"];
+        GOAL_PREVIEW_MAX = 120;
       }
     });
     function readString3(value) {
@@ -37363,6 +37415,111 @@ Next step: ${nextStep}`;
         recentUnroutableDiagnostics = /* @__PURE__ */ new Map();
       }
     });
+    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) {
+          LOG2.info("MeshEvents", `Durably queued unresolved-delegate ${event} for coordinator ${target} (outbox)`);
+        }
+        return true;
+      } catch (e) {
+        LOG2.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) {
+          LOG2.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;
+    var UNRESOLVED_FORWARD_OUTBOX_MESH_ID;
+    var UNRESOLVED_FORWARD_MAX_AGE_MS;
+    var init_mesh_unresolved_forward_outbox = __esm2({
+      "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;
+      }
+    });
     function resolveCoordinatorDrainDaemonIds(components) {
       const ids = /* @__PURE__ */ new Set();
       const statusInstanceId = readNonEmptyString2(components.statusInstanceId);
@@ -38496,12 +38653,25 @@ Next step: ${nextStep}`;
         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) => {
-        LOG2.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) {
+          LOG2.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) => {
+        LOG2.warn("MeshEvents", `Immediate forward of ${eventName} to coordinator ${coordinatorDaemonId} failed: ${e?.message || e} \u2014 left queued for retry`);
       });
-      LOG2.info("MeshEvents", `Fallback-forwarded ${eventName} for unresolved-mesh worker at ${routing.workspace || "(no workspace)"} to coordinator daemon ${coordinatorDaemonId}`);
+      LOG2.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") {
@@ -38596,6 +38766,7 @@ Next step: ${nextStep}`;
         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();
@@ -38709,6 +38880,13 @@ Next step: ${nextStep}`;
           return void 0;
         }
       })();
+      if (dispatchMeshCommand) {
+        try {
+          await retryUnresolvedDelegateForwards(components);
+        } catch (e) {
+          LOG2.warn("MeshReconcile", `Unresolved-delegate forward retry failed: ${e?.message || e}`);
+        }
+      }
       if (dispatchMeshCommand) {
         for (const mesh of listMeshes()) {
           const selfIds = resolveCoordinatorSelfIds(mesh, drainDaemonIds);
@@ -38762,6 +38940,28 @@ Next step: ${nextStep}`;
         }
       }
     }
+    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) {
+          LOG2.warn("MeshReconcile", `Retry forward to coordinator ${entry.coordinatorDaemonId} failed: ${e?.message || e} \u2014 left queued`);
+          continue;
+        }
+        if (result && result.success === false) {
+          LOG2.warn("MeshReconcile", `Retry forward to coordinator ${entry.coordinatorDaemonId} rejected (${readNonEmptyString2(result.error) || "no reason"}) \u2014 left queued`);
+          continue;
+        }
+        ackUnresolvedDelegateForward(entry.id);
+        LOG2.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;
@@ -38838,6 +39038,7 @@ Next step: ${nextStep}`;
         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;
       }
@@ -52018,7 +52219,7 @@ ${cleanBody}`;
         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,
@@ -52675,7 +52876,7 @@ ${effect.notification.body || ""}`.trim();
         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,
@@ -62145,22 +62346,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         };
       }
       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,
@@ -76164,9 +76350,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,
@@ -76940,10 +77126,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", {
@@ -77246,7 +77433,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,
@@ -77300,7 +77487,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 } : {},
@@ -84812,7 +84999,7 @@ data: ${JSON.stringify(msg.data)}
         });
       }
     };
-    var import_crypto9 = require("crypto");
+    var import_crypto10 = require("crypto");
     var import_session_host_core10 = require_dist();
     var BASE_KEY_SEQUENCES = {
       enter: "\r",
@@ -84910,7 +85097,7 @@ data: ${JSON.stringify(msg.data)}
         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({