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

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 ? "6ee0e52b0b7347870577ebe598054d87127078fe" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "6ee0e52b" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "0.9.82-rc.294" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-06-16T12:16:10.838Z" : 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,8 +31723,9 @@ ${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.
+- **Sequence shared-base-moving merges.** Parallel dispatch is encouraged, but merging one worktree can advance another in-flight worktree's base \u2014 especially the oss submodule pointer \u2014 turning a clean fast-forward into a diverged rebase (patch-equivalence correctly blocks this). Before merging an in-flight worktree while siblings are also in flight, land in an intentional order, re-clone long-running worktrees from the advanced base, or expect to manually rebase + ff-only the laggards; merging an independent fix mid-flight can strand siblings into a rebase.
 - **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.
 - **Submodule reachability = publish-needed.** \`submodule_reachability_failed\` \u2192 classify as \`blocked_review\`, request user approval to push to submodule main, then rerun \`mesh_refine_node\`.
@@ -31772,7 +31783,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 +34149,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 +34254,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 +34292,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 +34300,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 +37416,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 +38654,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 +38767,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 +38881,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 +38941,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 +39039,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;
       }
@@ -51396,22 +51598,160 @@ ${cleanBody}`;
       if (!Number.isFinite(numericOffset) || !Number.isFinite(numericExclude)) return false;
       return true;
     }
+    var REVERSE_TAIL_SMALL_FILE_BYTES = 64 * 1024;
+    var REVERSE_TAIL_CHUNK_BYTES = 64 * 1024;
+    var TAIL_LINES_RETAINED = BOUNDED_TAIL_MAX_LIMIT + 2 * BOUNDED_TAIL_SLACK;
+    var INCREMENTAL_TAIL_CACHE_MAX_ENTRIES = 64;
+    var incrementalTailCache = /* @__PURE__ */ new Map();
+    function evictIncrementalTailCache() {
+      while (incrementalTailCache.size > INCREMENTAL_TAIL_CACHE_MAX_ENTRIES) {
+        const oldest = incrementalTailCache.keys().next().value;
+        if (oldest === void 0) break;
+        incrementalTailCache.delete(oldest);
+      }
+    }
+    function splitBufferLines(buf) {
+      const lines = [];
+      let lineEnd = buf.length;
+      let firstNewline = -1;
+      for (let i = buf.length - 1; i >= 0; i--) {
+        if (buf[i] !== 10) continue;
+        if (i + 1 < lineEnd) {
+          lines.push(buf.toString("utf-8", i + 1, lineEnd));
+        }
+        lineEnd = i;
+        firstNewline = i;
+      }
+      lines.reverse();
+      const head = firstNewline >= 0 ? buf.subarray(0, firstNewline) : buf;
+      return { head, lines };
+    }
+    function readReverseTailLines(filePath, needed) {
+      const fd = fs52.openSync(filePath, "r");
+      try {
+        const stat2 = fs52.fstatSync(fd);
+        const size = stat2.size;
+        let position = size;
+        let carry = Buffer.alloc(0);
+        const collected = [];
+        while (position > 0 && collected.length < needed) {
+          const chunkSize = Math.min(REVERSE_TAIL_CHUNK_BYTES, position);
+          position -= chunkSize;
+          const chunk = Buffer.alloc(chunkSize);
+          fs52.readSync(fd, chunk, 0, chunkSize, position);
+          const combined = carry.length ? Buffer.concat([chunk, carry]) : chunk;
+          const { head, lines } = splitBufferLines(combined);
+          carry = head;
+          for (let i = lines.length - 1; i >= 0; i--) {
+            collected.push(lines[i]);
+          }
+        }
+        const reachedStart = position <= 0;
+        if (reachedStart && carry.length) {
+          collected.push(carry.toString("utf-8"));
+        }
+        collected.reverse();
+        return { lines: collected, coversWholeFile: reachedStart, size, mtimeMs: stat2.mtimeMs };
+      } finally {
+        fs52.closeSync(fd);
+      }
+    }
+    function readFileTailLines(filePath, needed) {
+      let stat2;
+      try {
+        stat2 = fs52.statSync(filePath);
+      } catch {
+        return { lines: [], coversWholeFile: true };
+      }
+      const size = stat2.size;
+      const mtimeMs = stat2.mtimeMs;
+      if (size === 0) {
+        incrementalTailCache.delete(filePath);
+        return { lines: [], coversWholeFile: true };
+      }
+      const cached22 = incrementalTailCache.get(filePath);
+      if (cached22) {
+        if (cached22.size === size && cached22.mtimeMs === mtimeMs) {
+          incrementalTailCache.delete(filePath);
+          incrementalTailCache.set(filePath, cached22);
+          if (cached22.coversWholeFile || cached22.lines.length >= needed) {
+            return { lines: cached22.lines, coversWholeFile: cached22.coversWholeFile };
+          }
+        } else if (size > cached22.size) {
+          const incremental = tryIncrementalTailGrowth(filePath, cached22, size, mtimeMs, needed);
+          if (incremental) return { lines: incremental.lines, coversWholeFile: incremental.coversWholeFile };
+        }
+        incrementalTailCache.delete(filePath);
+      }
+      if (size <= REVERSE_TAIL_SMALL_FILE_BYTES) {
+        let content;
+        try {
+          content = fs52.readFileSync(filePath, "utf-8");
+        } catch {
+          return { lines: [], coversWholeFile: true };
+        }
+        const lines = content.split("\n");
+        if (lines.length && lines[lines.length - 1] === "") lines.pop();
+        storeIncrementalTailCache(filePath, size, mtimeMs, lines, true);
+        return { lines, coversWholeFile: true };
+      }
+      let result;
+      try {
+        result = readReverseTailLines(filePath, needed);
+      } catch {
+        return { lines: [], coversWholeFile: true };
+      }
+      storeIncrementalTailCache(filePath, result.size, result.mtimeMs, result.lines, result.coversWholeFile);
+      return { lines: result.lines, coversWholeFile: result.coversWholeFile };
+    }
+    function tryIncrementalTailGrowth(filePath, cached22, size, mtimeMs, needed) {
+      const fd = fs52.openSync(filePath, "r");
+      try {
+        if (cached22.size > 0) {
+          const boundary = Buffer.alloc(1);
+          fs52.readSync(fd, boundary, 0, 1, cached22.size - 1);
+          if (boundary[0] !== 10) return null;
+        }
+        const appendedLength = size - cached22.size;
+        const appended = Buffer.alloc(appendedLength);
+        fs52.readSync(fd, appended, 0, appendedLength, cached22.size);
+        const newLines = appended.toString("utf-8").split("\n");
+        if (newLines.length && newLines[newLines.length - 1] === "") newLines.pop();
+        const merged = cached22.lines.concat(newLines);
+        const trimmed = merged.length > TAIL_LINES_RETAINED ? merged.slice(merged.length - TAIL_LINES_RETAINED) : merged;
+        const coversWholeFile = cached22.coversWholeFile && trimmed.length === merged.length;
+        storeIncrementalTailCache(filePath, size, mtimeMs, trimmed, coversWholeFile);
+        if (coversWholeFile || trimmed.length >= needed) {
+          return { lines: trimmed, coversWholeFile };
+        }
+        return { lines: trimmed, coversWholeFile };
+      } catch {
+        return null;
+      } finally {
+        fs52.closeSync(fd);
+      }
+    }
+    function storeIncrementalTailCache(filePath, size, mtimeMs, lines, coversWholeFile) {
+      const retained = lines.length > TAIL_LINES_RETAINED ? lines.slice(lines.length - TAIL_LINES_RETAINED) : lines;
+      const covers = coversWholeFile && retained.length === lines.length;
+      incrementalTailCache.delete(filePath);
+      incrementalTailCache.set(filePath, { size, mtimeMs, lines: retained, coversWholeFile: covers });
+      evictIncrementalTailCache();
+    }
     function readBoundedTailRecords(agentType, dir, files, needed) {
       const collected = [];
       const seen = /* @__PURE__ */ new Set();
       let readAllFiles = true;
       for (let f = 0; f < files.length; f++) {
         const filePath = path12.join(dir, files[f]);
-        let content;
-        try {
-          content = fs52.readFileSync(filePath, "utf-8");
-        } catch {
-          continue;
-        }
-        const lines = content.trim().split("\n").filter(Boolean);
+        const remaining = Math.max(0, needed - collected.length);
+        const perFileNeeded = Math.min(needed, remaining + BOUNDED_TAIL_SLACK);
+        const { lines, coversWholeFile } = readFileTailLines(filePath, perFileNeeded);
         for (let i = lines.length - 1; i >= 0; i--) {
+          const line = lines[i];
+          if (!line) continue;
           try {
-            const parsed = JSON.parse(lines[i]);
+            const parsed = JSON.parse(line);
             const sanitizedMessage = sanitizeHistoryMessage(agentType, parsed);
             if (!sanitizedMessage) continue;
             const hash2 = buildHistoryMessageHash(agentType, sanitizedMessage);
@@ -51421,6 +51761,10 @@ ${cleanBody}`;
           } catch {
           }
         }
+        if (!coversWholeFile) {
+          readAllFiles = false;
+          break;
+        }
         if (collected.length >= needed && f < files.length - 1) {
           readAllFiles = false;
           break;
@@ -52018,7 +52362,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 +53019,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,
@@ -61291,12 +61635,14 @@ ${formatManifestValidationIssues2(validation.issues)}`,
             }
             this.maybeClearResolvedClaudeTuiPrompt();
             this.maybeCaptureClaudeTuiPrompt();
+            this.maybeUpgradeClaudeTuiMultiSelect();
             this.statusCallback?.();
             return;
           case "pty_data":
             this.detectInteractivePromptFromPtyChunk(ev.chunk);
             this.maybeClearResolvedClaudeTuiPrompt();
             this.maybeCaptureClaudeTuiPrompt();
+            this.maybeUpgradeClaudeTuiMultiSelect();
             try {
               this.ptyDataCallback?.(ev.chunk);
             } catch {
@@ -61445,6 +61791,35 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           this.claudeTuiPromptCaptureInFlight = false;
         });
       }
+      /**
+       * The TUI prompt is captured on the FIRST frame that renders the
+       * "Enter to select" footer. At that instant the option rows' checkbox
+       * column may not have drawn yet, so `detectClaudeTuiMultiSelect` returns
+       * false and the prompt is frozen as single-select — the dashboard then
+       * renders radio buttons even though the picker is multi-select.
+       *
+       * While the same TUI prompt is still on screen, re-check the live snapshot:
+       * if checkbox glyphs have since appeared, promote any single-select
+       * question to multi-select and re-emit status. Promotion is one-way
+       * (false→true only) — once a question is known multi-select we never demote
+       * it, since the glyph column can scroll out of view on later frames.
+       */
+      maybeUpgradeClaudeTuiMultiSelect() {
+        if (this.cliType !== "claude-cli" || this.interactivePromptTransport !== "tui" || !this.activeInteractivePrompt) return;
+        const questions = this.activeInteractivePrompt.questions;
+        if (questions.length !== 1) return;
+        if (questions[0].multiSelect) return;
+        let screenText = "";
+        try {
+          screenText = this.driver.snapshot();
+        } catch {
+          return;
+        }
+        if (!screenText.includes("Enter to select")) return;
+        if (!detectClaudeTuiMultiSelect(screenText)) return;
+        questions[0].multiSelect = true;
+        this.statusCallback?.();
+      }
       readClaudeTuiHeaders(screenText) {
         const navLine = screenText.split(/\r?\n/).find((line) => line.includes("\u2714 Submit") && /[☐☒]/.test(line));
         if (!navLine) return [];
@@ -61586,6 +61961,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
       }
       return normalizedId;
     }
+    var STATUS_HYDRATION_TAIL_LIMIT = 200;
     function isIdleStatus(value) {
       const status = typeof value === "string" ? value.trim().toLowerCase() : "";
       return !status || status === "idle" || status === "ready";
@@ -62145,22 +62521,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,
@@ -63263,12 +63624,14 @@ ${effect.notification.body || ""}`.trim();
         const newestMessageAt = parsedMessages.reduce((newest, message) => Math.max(newest, getMessageTime(message)), 0);
         return newestMessageAt === 0;
       }
-      syncCanonicalSavedHistoryIfNeeded() {
+      syncCanonicalSavedHistoryIfNeeded(options = {}) {
         if (!this.providerSessionId) return false;
         const canonicalHistory = this.provider.nativeHistory;
         if (!canonicalHistory) return false;
+        const limit = options.full ? Number.MAX_SAFE_INTEGER : STATUS_HYDRATION_TAIL_LIMIT;
+        const windowTag = options.full ? "full" : `tail:${STATUS_HYDRATION_TAIL_LIMIT}`;
         if (isNativeSourceCanonicalHistory(canonicalHistory)) {
-          const cacheKey = [this.type, this.providerSessionId, this.workingDir].join("\0");
+          const cacheKey = [this.type, this.providerSessionId, this.workingDir, windowTag].join("\0");
           const now = Date.now();
           if (cacheKey === this.lastNativeSourceCanonicalCacheKey && now - this.lastNativeSourceCanonicalCheckAt < 2e3) {
             return true;
@@ -63280,7 +63643,7 @@ ${effect.notification.body || ""}`.trim();
             historySessionId: this.providerSessionId,
             workspace: this.workingDir,
             offset: 0,
-            limit: Number.MAX_SAFE_INTEGER,
+            limit,
             historyBehavior: this.provider.historyBehavior,
             scripts: this.provider.scripts
           });
@@ -63296,7 +63659,7 @@ ${effect.notification.body || ""}`.trim();
           return true;
         }
         try {
-          const cacheKey = [this.type, this.providerSessionId, this.workingDir, canonicalHistory.mode || "materialized-mirror"].join("\0");
+          const cacheKey = [this.type, this.providerSessionId, this.workingDir, canonicalHistory.mode || "materialized-mirror", windowTag].join("\0");
           const now = Date.now();
           if (cacheKey === this.lastNativeSourceCanonicalCacheKey && now - this.lastNativeSourceCanonicalCheckAt < 2e3) {
             return true;
@@ -63306,7 +63669,7 @@ ${effect.notification.body || ""}`.trim();
           if (!materializeProviderNativeHistory(this.type, canonicalHistory, this.providerSessionId, this.workingDir, this.provider.scripts)) {
             return false;
           }
-          const restoredHistory = readChatHistory(this.type, 0, Number.MAX_SAFE_INTEGER, this.providerSessionId, 0, this.provider.historyBehavior);
+          const restoredHistory = readChatHistory(this.type, 0, limit, this.providerSessionId, 0, this.provider.historyBehavior);
           this.lastPersistedHistoryMessages = restoredHistory.messages.map((message) => ({
             role: message.role,
             content: message.content,
@@ -63321,7 +63684,7 @@ ${effect.notification.body || ""}`.trim();
       }
       restorePersistedHistoryFromCurrentSession() {
         if (!this.providerSessionId) return;
-        this.syncCanonicalSavedHistoryIfNeeded();
+        this.syncCanonicalSavedHistoryIfNeeded({ full: true });
         const restoredHistory = isNativeSourceCanonicalHistory(this.provider.nativeHistory) ? readProviderChatHistory(this.type, {
           canonicalHistory: this.provider.nativeHistory,
           historySessionId: this.providerSessionId,
@@ -76164,9 +76527,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 +77303,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 +77610,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 +77664,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 +85176,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 +85274,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({