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

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 ? "6ee0e52b0b7347870577ebe598054d87127078fe" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "6ee0e52b" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = 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:15:42.290Z" : 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,8 +2007,9 @@ 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.
+- **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\`.
@@ -2051,7 +2062,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 +4406,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 +4441,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 +4513,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 +4549,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 +4557,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 +7656,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 +8895,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 +8995,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 +9111,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 +9171,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 +9269,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;
   }
@@ -21712,22 +21913,160 @@ function isBoundedTailRequest(limit, offset, excludeRecentCount) {
   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 = fs5.openSync(filePath, "r");
+  try {
+    const stat2 = fs5.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);
+      fs5.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 {
+    fs5.closeSync(fd);
+  }
+}
+function readFileTailLines(filePath, needed) {
+  let stat2;
+  try {
+    stat2 = fs5.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 cached2 = incrementalTailCache.get(filePath);
+  if (cached2) {
+    if (cached2.size === size && cached2.mtimeMs === mtimeMs) {
+      incrementalTailCache.delete(filePath);
+      incrementalTailCache.set(filePath, cached2);
+      if (cached2.coversWholeFile || cached2.lines.length >= needed) {
+        return { lines: cached2.lines, coversWholeFile: cached2.coversWholeFile };
+      }
+    } else if (size > cached2.size) {
+      const incremental = tryIncrementalTailGrowth(filePath, cached2, 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 = fs5.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, cached2, size, mtimeMs, needed) {
+  const fd = fs5.openSync(filePath, "r");
+  try {
+    if (cached2.size > 0) {
+      const boundary = Buffer.alloc(1);
+      fs5.readSync(fd, boundary, 0, 1, cached2.size - 1);
+      if (boundary[0] !== 10) return null;
+    }
+    const appendedLength = size - cached2.size;
+    const appended = Buffer.alloc(appendedLength);
+    fs5.readSync(fd, appended, 0, appendedLength, cached2.size);
+    const newLines = appended.toString("utf-8").split("\n");
+    if (newLines.length && newLines[newLines.length - 1] === "") newLines.pop();
+    const merged = cached2.lines.concat(newLines);
+    const trimmed = merged.length > TAIL_LINES_RETAINED ? merged.slice(merged.length - TAIL_LINES_RETAINED) : merged;
+    const coversWholeFile = cached2.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 {
+    fs5.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 = fs5.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 hash = buildHistoryMessageHash(agentType, sanitizedMessage);
@@ -21737,6 +22076,10 @@ function readBoundedTailRecords(agentType, dir, files, needed) {
       } catch {
       }
     }
+    if (!coversWholeFile) {
+      readAllFiles = false;
+      break;
+    }
     if (collected.length >= needed && f < files.length - 1) {
       readAllFiles = false;
       break;
@@ -22340,7 +22683,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 +23350,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,
@@ -31693,12 +32036,14 @@ var SpecCliAdapter = class _SpecCliAdapter {
         }
         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 {
@@ -31847,6 +32192,35 @@ var SpecCliAdapter = class _SpecCliAdapter {
       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 [];
@@ -31996,6 +32370,7 @@ function normalizeProviderSessionId(provider, providerSessionId) {
 }
 
 // src/providers/cli-provider-instance.ts
+var STATUS_HYDRATION_TAIL_LIMIT = 200;
 function isIdleStatus(value) {
   const status = typeof value === "string" ? value.trim().toLowerCase() : "";
   return !status || status === "idle" || status === "ready";
@@ -32555,22 +32930,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,
@@ -33673,12 +34033,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;
@@ -33690,7 +34052,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
       });
@@ -33706,7 +34068,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;
@@ -33716,7 +34078,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,
@@ -33731,7 +34093,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,
@@ -46628,9 +46990,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 +47766,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 +48073,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 +48127,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 +55681,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 +55779,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({