@adhdev/daemon-core 0.9.82-rc.481 → 0.9.82-rc.483

package/dist/index.mjs

@@ -183,7 +183,7 @@ var init_repo_mesh_types = __esm({
       "checkpoint_then_continue"
     ]);
     MESH_MAX_PARALLEL_TASKS_MIN = 1;
-    MESH_MAX_PARALLEL_TASKS_MAX = 8;
+    MESH_MAX_PARALLEL_TASKS_MAX = 64;
     DEFAULT_MESH_READONLY_MULTIPLIER = 2;
   }
 });
@@ -404,10 +404,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "0d212674453127562e4c5827f5515163ea29f072" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "0d212674" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.481" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-07T20:14:39.096Z" : void 0);
+  const commit = readInjected(true ? "0862a3f10fa9de60a46591c0894a7209534db2e2" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "0862a3f1" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.483" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-08T04:27:00.139Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -2813,8 +2813,6 @@ var init_dist = __esm({
       "mesh_review_inbox",
       "mesh_magi_review",
       "mesh_magi_collect",
-      "mesh_magi_panel_set",
-      "mesh_magi_panel_list",
       "mesh_magi_kind_panel_set",
       "mesh_magi_kind_panel_list"
     ];
@@ -2914,24 +2912,19 @@ __export(mesh_config_exports, {
   createMeshHostPairingToken: () => createMeshHostPairingToken,
   deleteMesh: () => deleteMesh,
   getMagiKindPanel: () => getMagiKindPanel,
-  getMagiPanel: () => getMagiPanel,
   getMesh: () => getMesh,
   getMeshByRepo: () => getMeshByRepo,
   listMagiKindPanels: () => listMagiKindPanels,
-  listMagiPanels: () => listMagiPanels,
   listMeshes: () => listMeshes,
   markMeshHostPairingJoined: () => markMeshHostPairingJoined,
-  normalizeMagiPanel: () => normalizeMagiPanel,
   normalizeMagiSlots: () => normalizeMagiSlots,
   normalizeRepoIdentity: () => normalizeRepoIdentity,
   removeMagiKindPanel: () => removeMagiKindPanel,
-  removeMagiPanel: () => removeMagiPanel,
   removeNode: () => removeNode,
   setMagiKindPanel: () => setMagiKindPanel,
   tokenIdForManualPairing: () => tokenIdForManualPairing,
   updateMesh: () => updateMesh,
-  updateNode: () => updateNode,
-  upsertMagiPanel: () => upsertMagiPanel
+  updateNode: () => updateNode
 });
 import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
 import { join as join5 } from "path";
@@ -3313,6 +3306,11 @@ function updateNode(meshId, nodeId, opts) {
     node.reportedDaemonBuildVersion = opts.reportedDaemonBuildVersion.trim();
   }
   if (opts.policy) node.policy = { ...node.policy, ...opts.policy };
+  if (Object.prototype.hasOwnProperty.call(opts, "capabilities")) {
+    const tags = normalizeCapabilityTags(opts.capabilities);
+    if (tags && tags.length) node.capabilities = tags;
+    else delete node.capabilities;
+  }
   if (opts.worktreeBootstrap) node.worktreeBootstrap = opts.worktreeBootstrap;
   if (Object.prototype.hasOwnProperty.call(opts, "systemPrompt")) {
     if (opts.systemPrompt && opts.systemPrompt.trim()) {
@@ -3330,99 +3328,6 @@ function normalizeReplicaCount(value) {
   const n = Math.floor(value);
   return n >= 1 ? n : void 0;
 }
-function normalizeMagiPanelDefaultKind(raw) {
-  if (raw == null) return void 0;
-  const s2 = typeof raw === "string" ? raw.trim().toLowerCase() : "";
-  if (s2 === "claim_audit" || s2 === "rca" || s2 === "design") return s2;
-  if (s2 === "freeform") {
-    console.warn(
-      "[magi] panel defaultKind='freeform' rejected \u2014 freeform contributes no structured claims to cross-verification; dropping (use claim_audit / rca / design, or omit)."
-    );
-    return void 0;
-  }
-  return void 0;
-}
-function normalizeMagiPanel(config) {
-  if (!config || typeof config !== "object" || Array.isArray(config)) {
-    throw new Error("invalid_magi_panel: config must be an object");
-  }
-  const raw = config;
-  const rawMembers = raw.members;
-  if (!Array.isArray(rawMembers) || rawMembers.length === 0) {
-    throw new Error("invalid_magi_panel: members must be a non-empty array");
-  }
-  if (rawMembers.length > MAX_MAGI_PANEL_MEMBERS) {
-    throw new Error(`invalid_magi_panel: too many members (max ${MAX_MAGI_PANEL_MEMBERS})`);
-  }
-  const members = rawMembers.map((entry, idx) => {
-    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
-      throw new Error(`invalid_magi_panel: member[${idx}] must be an object`);
-    }
-    const m = entry;
-    const provider = typeof m.provider === "string" ? m.provider.trim() : "";
-    if (!provider) {
-      throw new Error(`invalid_magi_panel: member[${idx}].provider is required`);
-    }
-    const nodeId = typeof m.nodeId === "string" && m.nodeId.trim() ? m.nodeId.trim() : void 0;
-    const model = typeof m.model === "string" && m.model.trim() ? m.model.trim() : void 0;
-    const capabilityTags = normalizeCapabilityTags(m.capabilityTags);
-    const n = normalizeReplicaCount(m.n);
-    return {
-      provider,
-      ...nodeId ? { nodeId } : {},
-      ...model ? { model } : {},
-      ...capabilityTags ? { capabilityTags } : {},
-      ...n !== void 0 ? { n } : {}
-    };
-  });
-  const description = typeof raw.description === "string" && raw.description.trim() ? raw.description.trim().slice(0, 200) : void 0;
-  const defaultN = normalizeReplicaCount(raw.defaultN);
-  const defaultKind = normalizeMagiPanelDefaultKind(raw.defaultKind);
-  return {
-    ...description ? { description } : {},
-    members,
-    ...defaultN !== void 0 ? { defaultN } : {},
-    ...defaultKind !== void 0 ? { defaultKind } : {},
-    // dedupExempt is always meaningful for a MAGI panel (intentional same-prompt
-    // fan-out). Persist it true unless the caller explicitly disables it.
-    dedupExempt: raw.dedupExempt === false ? false : true
-  };
-}
-function normalizePanelName(name) {
-  const trimmed = typeof name === "string" ? name.trim() : "";
-  if (!trimmed) throw new Error("invalid_magi_panel: panel name is required");
-  return trimmed.slice(0, 100);
-}
-function listMagiPanels() {
-  return loadMeshConfig().magiPanels ?? {};
-}
-function getMagiPanel(name) {
-  const key2 = typeof name === "string" ? name.trim() : "";
-  if (!key2) return void 0;
-  return loadMeshConfig().magiPanels?.[key2];
-}
-function upsertMagiPanel(name, config, opts = {}) {
-  const key2 = normalizePanelName(name);
-  const panel = normalizeMagiPanel(config);
-  const stored = loadMeshConfig();
-  const panels = stored.magiPanels ?? {};
-  if (panels[key2] && opts.overwrite !== true) {
-    throw new Error(`magi_panel_exists: panel '${key2}' already exists \u2014 pass overwrite=true to replace it`);
-  }
-  panels[key2] = panel;
-  stored.magiPanels = panels;
-  saveMeshConfig(stored);
-  return panel;
-}
-function removeMagiPanel(name) {
-  const key2 = typeof name === "string" ? name.trim() : "";
-  if (!key2) return false;
-  const stored = loadMeshConfig();
-  if (!stored.magiPanels || !stored.magiPanels[key2]) return false;
-  delete stored.magiPanels[key2];
-  saveMeshConfig(stored);
-  return true;
-}
 function normalizeMagiTaskKindKey(raw) {
   const s2 = typeof raw === "string" ? raw.trim().toLowerCase() : "";
   if (!MAGI_KIND_PANEL_KINDS.includes(s2)) {
@@ -3494,7 +3399,7 @@ function removeMagiKindPanel(kind) {
   saveMeshConfig(stored);
   return true;
 }
-var mergeMeshPolicy, MAX_MAGI_PANEL_MEMBERS, MAGI_KIND_PANEL_KINDS, MAX_MAGI_KIND_SLOTS;
+var mergeMeshPolicy, MAGI_KIND_PANEL_KINDS, MAX_MAGI_KIND_SLOTS;
 var init_mesh_config = __esm({
   "src/config/mesh-config.ts"() {
     "use strict";
@@ -3503,7 +3408,6 @@ var init_mesh_config = __esm({
     init_repo_mesh_types();
     init_mesh_host_ownership();
     mergeMeshPolicy = mergeAndNormalizePolicy;
-    MAX_MAGI_PANEL_MEMBERS = 24;
     MAGI_KIND_PANEL_KINDS = ["claim_audit", "rca", "design", "freeform"];
     MAX_MAGI_KIND_SLOTS = 24;
   }
@@ -3699,6 +3603,21 @@ function buildNodeConfigSection(mesh) {
     }).filter(Boolean) : [];
     const providerRolesSuffix = providerRoles.length ? ` | caps: ${providerRoles.join(", ")}` : "";
     lines.push(`- ${explicitLabel} nodeId: \`${n.id}\` | workspace: \`${n.workspace}\`${n.daemonId ? ` | daemon: \`${n.daemonId}\`` : ""}${providerPriority}${providerRolesSuffix}${suffix}`);
+    const routingTags = [];
+    const custom = Array.isArray(n.capabilities) ? n.capabilities : [];
+    for (const t of custom) {
+      const s2 = typeof t === "string" ? t.trim() : "";
+      if (s2) routingTags.push(s2);
+    }
+    const tagOs = (n.userOverrides?.platform || n.reportedPlatform || "").toString().trim();
+    const tagArch = (n.userOverrides?.arch || n.reportedArch || "").toString().trim();
+    if (tagOs) routingTags.push(`os=${tagOs}`);
+    if (tagArch) routingTags.push(`arch=${tagArch}`);
+    const wtBranch = typeof n.worktreeBranch === "string" ? n.worktreeBranch.trim() : "";
+    if (n.isLocalWorktree && wtBranch) routingTags.push(`worktree=${wtBranch}`);
+    if (routingTags.length) {
+      lines.push(`  \u{1F3F7}\uFE0F routing tags: ${routingTags.map((t) => `\`${t}\``).join(", ")}`);
+    }
     const nodePrompt = typeof n.systemPrompt === "string" ? n.systemPrompt.trim() : "";
     if (nodePrompt) {
       lines.push(`  \u{1F4CC} Node instruction: ${indentFollowing(nodePrompt, "     ")}`);
@@ -3800,6 +3719,7 @@ function buildRulesSection(coordinatorCliType) {
 - **Route, don't implement.** Delegate all code reading, analysis, and execution to node agents. Never read source files or run commands in the coordinator \u2014 keep context lean.
 - **Front-load task messages.** Include everything the agent needs (files, problem, expected fix) in \`mesh_enqueue_task\` / \`mesh_send_task\`. Append a structured result request at the end: ask the worker to conclude with a JSON block containing \`status\`, \`changedFiles\`, \`gitStatus\`, \`validationResults\`, \`errors\`, \`nextAction\`. The daemon parses this automatically; you can read it from \`mesh_task_history\`.
 - **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.
+- **Worktree affinity.** A worktree is a durable per-branch workspace; keep all of a branch's code_change/fix/review work on its worktree node by targeting \`required_tags: ["worktree=<branch>"]\` or \`target_node_id\`. Get the id/branch from the \`mesh_clone_node\` result or a live \`mesh_status\` \u2014 the Configured Nodes snapshot won't list a worktree cloned after launch. Untargeted same-branch follow-ups drift to the base node. Only \`convergence\` (merge/push) runs on the base, never pinned to the worktree.
 - **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. 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).
@@ -3874,9 +3794,7 @@ var init_coordinator_prompt = __esm({
 | \`mesh_write_mesh_json_config\` | Gated write of \`.adhdev/mesh.json\` (repo coordinator-prompt config) from the mesh entry \u2014 dry-run/overwrite like mesh_init |
 | \`mesh_magi_review\` | Cross-verify a read-only investigation across a standing panel of independent mesh agents (different machines/providers) instead of a single worker |
 | \`mesh_magi_collect\` | Collect + synthesize a previously dispatched MAGI fan-out by its consensus group id (async companion to mesh_magi_review wait:false) |
-| \`mesh_magi_panel_set\` | Upsert a named MAGI panel (standing set of independent node\xD7provider members) into machine-local config |
-| \`mesh_magi_panel_list\` | List configured MAGI panels and resolve each member's availability against the current mesh (read-only) |
-| \`mesh_magi_kind_panel_set\` | Bind a task_kind \u2192 MAGI kind-panel slots (machine-local, wholesale replacement \u2014 approve current-vs-new first) |
+| \`mesh_magi_kind_panel_set\` | Bind a task_kind \u2192 MAGI kind-panel slots (the SOLE MAGI panel-resolution surface; machine-local, wholesale replacement \u2014 approve current-vs-new first) |
 | \`mesh_magi_kind_panel_list\` | List configured task_kind \u2192 MAGI kind-panel slot bindings (machine-local, read-only) |`;
     TOOL_EXPOSURE_PREFLIGHT_SECTION = `## Tool Exposure Preflight
 
@@ -3888,6 +3806,7 @@ Before doing any coordinator work, confirm that the actual callable tool list in
 3. **Queue / Delegate** \u2014 The Mesh uses an autonomous pull-based Work Queue:
    a. **General Tasks**: Enqueue tasks using \`mesh_enqueue_task\`. Idle node agents will automatically pull tasks from the queue and begin working.
    b. **Node Preparation**: Reuse an existing idle session on the correct node/provider before launching a new chat/session. Call \`mesh_launch_session\` only when no suitable session exists, when the user explicitly asks for a fresh provider/session, or when branch/worktree isolation requires it. If you need branch isolation for parallel work, call \`mesh_clone_node\` to create a worktree node first.
+   b1. **Keep a branch's work on its worktree (worktree affinity).** A worktree node is a durable per-branch workspace, not a one-task throwaway \u2014 implement, review, and fix for the same branch all belong on the SAME worktree, and it lives until its work is converged (merged/pushed) and it is cleaned up. So once you clone a worktree for a branch, route every subsequent \`code_change\`/\`validation\`/fix task for that branch back to that same node: pass \`required_tags: ["worktree=<branch>"]\` or \`target_node_id: <that worktree node's id>\`. **Where to get the node id / tag:** the \`mesh_clone_node\` result returns the new node's \`id\` and \`worktreeBranch\` directly \u2014 use them immediately. The Configured Nodes list in this prompt is a launch-time snapshot and will NOT list a worktree you cloned after this session started, so do not rely on it for freshly-cloned worktrees; take the id/branch from the \`mesh_clone_node\` result, or call \`mesh_status\` to re-list the live nodes (each worktree there advertises its \`worktree=<branch>\` tag). Do NOT leave same-branch follow-ups untargeted \u2014 an untargeted task is claimed by whichever node polls first (usually the base machine node), which strands the work off the branch's worktree. The ONE exception is a \`convergence\` task (merge/push): that is base-only and must NOT be pinned to the worktree.
    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.
@@ -3916,7 +3835,7 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
 
 **Save scopes \u2014 label every draft with its scope before asking for approval:**
 - **repo-file (commit target)** \u2014 \`.adhdev/refine.json\`, \`.adhdev/worktree_bootstrap.json\`, \`.adhdev/change-impact.json\`, \`.adhdev/mesh.json\`. These are committed to the repository and shared with every machine/contributor.
-- **machine-local** \u2014 MAGI kind\u2192panel bindings and named MAGI panels, node providerPriority (\`~/.adhdev/meshes.json\`). These stay on this machine and are NOT committed.
+- **machine-local** \u2014 MAGI kind\u2192panel bindings, node providerPriority (\`~/.adhdev/meshes.json\`). These stay on this machine and are NOT committed.
 
 **Guided sequence:**
 1. **Scan (dry-run)** \u2014 Call \`mesh_init\` (write=false, the default). It returns per-domain suggested configs for refine / worktree_bootstrap / change-impact, a recommended providerPriority, AND \`currentConfig\` \u2014 the currently-saved config per domain (repo files + machine-local \`magiKindPanels\`). Nothing is written.
@@ -3924,8 +3843,7 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
 3. **Approve \u2192 gated write** \u2014 Only after the user approves, call the matching gated-write tool:
    - repo \`.adhdev/*\` config files \u2192 \`mesh_init\` with \`write=true\` (and \`overwrite=true\` ONLY for domains the user approved replacing).
    - \`.adhdev/mesh.json\` (coordinator prompt / operating notes) \u2192 \`mesh_write_mesh_json_config\` (write=true, overwrite only if approved).
-   - machine-local MAGI kind\u2192panel slots \u2192 \`mesh_magi_kind_panel_set\` (write=true). NOTE: a kind binding is a **wholesale replacement** of that kind's slot list \u2014 present the current-vs-new slots first.
-   - machine-local named MAGI panels \u2192 \`mesh_magi_panel_set\`. providerPriority \u2192 apply via node policy update.
+   - machine-local MAGI kind\u2192panel slots \u2192 \`mesh_magi_kind_panel_set\` (write=true). NOTE: a kind binding is a **wholesale replacement** of that kind's slot list \u2014 present the current-vs-new slots first. providerPriority \u2192 apply via node policy update.
 
 **init vs reinit:**
 - **\`mesh_init\`** \u2014 for a fresh, never-onboarded repo. Existing config files are kept (existing-wins) unless the user explicitly approves overwrite. Use for first-time setup.
@@ -4338,9 +4256,11 @@ function shouldDeliverPendingEventToCoordinator(event, drainer) {
   if (!event.intendedFor) return false;
   return coordinatorIdentityEquals(event.intendedFor, drainer);
 }
+function isTerminalTaskEvent(eventName) {
+  return TERMINAL_TASK_EVENTS.has(eventName);
+}
 function defaultScopeForEvent(eventName) {
-  if (SYSTEM_EVENTS.has(eventName)) return "system";
-  if (TERMINAL_TASK_EVENTS.has(eventName)) return "unicast";
+  if (TERMINAL_TASK_EVENTS.has(eventName) || COORDINATOR_ALERT_EVENTS.has(eventName)) return "unicast";
   return "broadcast";
 }
 function coordinatorIdentityFromEmitFields(fields) {
@@ -4355,7 +4275,11 @@ function buildPendingEventEmitStamp(opts) {
   let scope = opts.scope ?? defaultScopeForEvent(opts.eventName);
   let intendedFor = opts.intendedFor;
   if (scope === "unicast" && !intendedFor) {
-    scope = "broadcast";
+    if (isTerminalTaskEvent(opts.eventName)) {
+      intendedFor = opts.dispatchedBy;
+    } else {
+      scope = "broadcast";
+    }
   }
   if (scope !== "unicast") intendedFor = void 0;
   return {
@@ -4366,7 +4290,7 @@ function buildPendingEventEmitStamp(opts) {
     ...intendedFor ? { intendedFor } : {}
   };
 }
-var MESH_PROTOCOL_VERSION_V1, MESH_PROTOCOL_VERSION_V2, SUPPORTED_MESH_PROTOCOL_VERSIONS, MESH_EVENT_SCOPES, MeshContractViolationError, TERMINAL_TASK_EVENTS, SYSTEM_EVENTS;
+var MESH_PROTOCOL_VERSION_V1, MESH_PROTOCOL_VERSION_V2, SUPPORTED_MESH_PROTOCOL_VERSIONS, MESH_EVENT_SCOPES, MeshContractViolationError, TERMINAL_TASK_EVENTS, COORDINATOR_ALERT_EVENTS;
 var init_contracts = __esm({
   "src/mesh/contracts.ts"() {
     "use strict";
@@ -4395,7 +4319,7 @@ var init_contracts = __esm({
       "refine:failed",
       "refine:accepted"
     ]);
-    SYSTEM_EVENTS = /* @__PURE__ */ new Set([
+    COORDINATOR_ALERT_EVENTS = /* @__PURE__ */ new Set([
       "mesh:dispatch_blocked"
     ]);
   }
@@ -6349,7 +6273,22 @@ function meshRuntimeStorePath() {
   }
   return nextPath;
 }
-var DatabaseCtor, loggedMigrationFailure, loggedStrayCleanup, MeshRuntimeStore;
+function pruneMeshRuntimeRetention() {
+  try {
+    const store = MeshRuntimeStore.getInstance();
+    const ledger = store.pruneEventLedger(MESH_EVENT_LEDGER_RETENTION_MS);
+    const toolCalls = store.pruneToolCallLog(MESH_TOOL_CALL_LOG_RETENTION_MS);
+    const terminalQueue = store.pruneTerminalQueueEntries(MESH_TERMINAL_QUEUE_RETENTION_MS);
+    if (ledger + toolCalls + terminalQueue > 0) {
+      LOG.info("MeshRuntimeStore", `Retention prune removed ${ledger} ledger / ${toolCalls} tool-call / ${terminalQueue} terminal-queue row(s)`);
+    }
+    return { ledger, toolCalls, terminalQueue };
+  } catch (e) {
+    LOG.warn("MeshRuntimeStore", `Runtime retention prune failed: ${e?.message || e}`);
+    return { ledger: 0, toolCalls: 0, terminalQueue: 0 };
+  }
+}
+var DatabaseCtor, loggedMigrationFailure, loggedStrayCleanup, MeshRuntimeStore, MESH_EVENT_LEDGER_RETENTION_MS, MESH_TOOL_CALL_LOG_RETENTION_MS, MESH_TERMINAL_QUEUE_RETENTION_MS;
 var init_mesh_runtime_store = __esm({
   "src/mesh/mesh-runtime-store.ts"() {
     "use strict";
@@ -7459,10 +7398,79 @@ var init_mesh_runtime_store = __esm({
       }
       /**
        * Prune tool call log entries older than the given age in ms.
-       * Exposed for testing.
+       * Returns the number of rows deleted. Also used by the periodic retention
+       * sweep (pruneMeshRuntimeRetention) — the in-write sweep in recordMeshToolCall
+       * only fires every 200 calls and only covers the rate-limit window, so a
+       * quiet mesh otherwise accumulates rows indefinitely.
        */
       pruneToolCallLog(olderThanMs) {
-        this.db.prepare("DELETE FROM mesh_tool_call_log WHERE called_at < ?").run(Date.now() - olderThanMs);
+        return this.db.prepare("DELETE FROM mesh_tool_call_log WHERE called_at < ?").run(Date.now() - olderThanMs).changes;
+      }
+      /**
+       * Retention prune for mesh_event_ledger (SoT 1-11 (b)). The ledger is append-only
+       * with NO lifecycle GC of its own, so lifecycle events accumulate without bound
+       * (the dominant mesh-runtime.db growth). Every production reader is bounded to a
+       * recent window (readLedgerEntries tail/limit ≤ a few hundred; task-stats /
+       * terminal-evidence scans look at recent tasks), so rows past a generous age only
+       * cost space. Excluded from deletion — retained forever:
+       *   - coordinator_operating_note / _tombstone: runtime-accumulated lessons whose
+       *     whole point is surviving restarts; a tombstone must also outlive the notes
+       *     it retracts.
+       * Timestamps are ISO-8601 TEXT, so the lexicographic `<` cutoff is a correct time
+       * comparison; a malformed timestamp compares greater than any ISO date and is
+       * conservatively retained. Returns rows deleted.
+       */
+      pruneEventLedger(olderThanMs) {
+        const cutoffIso = new Date(Date.now() - Math.max(0, olderThanMs)).toISOString();
+        return this.db.prepare(
+          `DELETE FROM mesh_event_ledger
+             WHERE timestamp < ?
+               AND kind NOT IN ('coordinator_operating_note', 'coordinator_operating_note_tombstone')`
+        ).run(cutoffIso).changes;
+      }
+      /**
+       * Retention prune for TERMINAL (completed/cancelled/failed) mesh_queue rows
+       * (SoT 1-11 (b)). Terminal rows are kept as recent history (mesh_task_history,
+       * completion-dedup taskId lookups) but nothing ever deletes them, so the queue
+       * table grows monotonically. Rows past the retention window serve no reader —
+       * every dedup/attribution path operates on recent tasks — EXCEPT as a dependency
+       * anchor: taskDependenciesSatisfied resolves dependsOn by id and treats a MISSING
+       * row as not-completed, so deleting a completed row that a still-live
+       * (pending/assigned) row depends on would permanently strand the dependent.
+       * Those ids are collected first and excluded. Returns rows deleted.
+       */
+      pruneTerminalQueueEntries(olderThanMs) {
+        const cutoffIso = new Date(Date.now() - Math.max(0, olderThanMs)).toISOString();
+        return this.transaction(() => {
+          const liveRows = this.db.prepare(
+            `SELECT payload FROM mesh_queue WHERE status IN ('pending', 'assigned')`
+          ).all();
+          const protectedIds = /* @__PURE__ */ new Set();
+          for (const row of liveRows) {
+            try {
+              const entry = JSON.parse(row.payload);
+              if (Array.isArray(entry.dependsOn)) {
+                for (const dep of entry.dependsOn) {
+                  if (typeof dep === "string" && dep) protectedIds.add(dep);
+                }
+              }
+            } catch {
+            }
+          }
+          const candidates = this.db.prepare(
+            `SELECT id FROM mesh_queue
+                 WHERE status IN ('completed', 'cancelled', 'failed') AND updated_at < ?`
+          ).all(cutoffIso);
+          const deletable = candidates.map((r) => r.id).filter((id) => !protectedIds.has(id));
+          let removed = 0;
+          for (let i = 0; i < deletable.length; i += 500) {
+            const chunk = deletable.slice(i, i + 500);
+            removed += this.db.prepare(
+              `DELETE FROM mesh_queue WHERE id IN (${chunk.map(() => "?").join(",")})`
+            ).run(...chunk).changes;
+          }
+          return removed;
+        });
       }
       // ── G2: Event Ledger ────────────────────────────────────────────────────
       appendLedgerEntry(entry) {
@@ -7948,6 +7956,9 @@ var init_mesh_runtime_store = __esm({
         return removed;
       }
     };
+    MESH_EVENT_LEDGER_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
+    MESH_TOOL_CALL_LOG_RETENTION_MS = 14 * 24 * 60 * 60 * 1e3;
+    MESH_TERMINAL_QUEUE_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
   }
 });
 
@@ -8426,6 +8437,16 @@ function routeV2EventsForDrainer(events, drainer, ctx) {
       continue;
     }
     if (validated.scope !== "unicast") {
+      if (validated.scope === "broadcast" && isTerminalTaskEvent(validated.event)) {
+        if (identityDeliversTo(validated.dispatchedBy, drainer)) {
+          ctx.batchSeen.add(eventId);
+          bump("v2Delivered");
+          kept.push(event);
+        } else {
+          bump("v2RoutedAway");
+        }
+        continue;
+      }
       if (shouldDeliverPendingEventToCoordinator(validated, drainer)) {
         ctx.batchSeen.add(eventId);
         bump("v2Delivered");
@@ -16570,6 +16591,15 @@ function getStore() {
     return void 0;
   }
 }
+function registerUnresolvedForwardRetryNudge(handler) {
+  retryNudgeHandler = handler;
+}
+function nudgeUnresolvedForwardRetry() {
+  try {
+    retryNudgeHandler?.();
+  } catch {
+  }
+}
 function enqueueUnresolvedDelegateForward(coordinatorDaemonId, eventName, forwardPayload) {
   const target = readNonEmptyString2(coordinatorDaemonId);
   const event = readNonEmptyString2(eventName);
@@ -16653,7 +16683,7 @@ function expireStaleUnresolvedDelegateForwards(nowMs = Date.now()) {
     return 0;
   }
 }
-var UNRESOLVED_FORWARD_OUTBOX_MESH_ID, UNRESOLVED_FORWARD_MAX_AGE_MS;
+var UNRESOLVED_FORWARD_OUTBOX_MESH_ID, UNRESOLVED_FORWARD_MAX_AGE_MS, retryNudgeHandler;
 var init_mesh_unresolved_forward_outbox = __esm({
   "src/mesh/mesh-unresolved-forward-outbox.ts"() {
     "use strict";
@@ -19044,6 +19074,7 @@ function sweepExpiredRemoteIdleSessions() {
   if (now - lastPendingEventsPruneAt >= PENDING_EVENTS_PRUNE_INTERVAL_MS) {
     lastPendingEventsPruneAt = now;
     prunePendingMeshCoordinatorEventsRetention();
+    pruneMeshRuntimeRetention();
   }
 }
 function isIntentionalCleanupStopMetadata(event) {
@@ -19900,25 +19931,6 @@ function handleMeshForwardEvent(components, payload) {
     v2Envelope: readV2EnvelopeFromWire(payload)
   });
 }
-function enqueueCoordinatorForwardPush(coordinatorDaemonId, run) {
-  let lane = coordinatorForwardLanes.get(coordinatorDaemonId);
-  if (!lane) {
-    lane = { tail: Promise.resolve(), depth: 0 };
-    coordinatorForwardLanes.set(coordinatorDaemonId, lane);
-  }
-  const wasIdle = lane.depth === 0;
-  lane.depth += 1;
-  const dec = () => {
-    lane.depth -= 1;
-  };
-  if (wasIdle) {
-    lane.tail = Promise.resolve(run()).catch(() => {
-    }).then(dec, dec);
-  } else {
-    lane.tail = lane.tail.then(() => run()).catch(() => {
-    }).then(dec, dec);
-  }
-}
 function forwardUnresolvedDelegateEvent(components, routing, event) {
   const coordinatorDaemonId = readNonEmptyString2(routing.coordinatorDaemonId);
   if (!coordinatorDaemonId) return false;
@@ -19955,28 +19967,15 @@ function forwardUnresolvedDelegateEvent(components, routing, event) {
     nodeId: readNonEmptyString2(routing.nodeId) || readNonEmptyString2(event.meshNodeId),
     event: eventName
   };
-  traceMeshEventStage("outbox_enqueue", fwdTraceCtx, `coordinatorDaemon=${coordinatorDaemonId} meshId=absent`);
-  traceMeshEventStage("forward_send", fwdTraceCtx, "immediate push");
-  const dispatchMeshCommand = components.dispatchMeshCommand;
-  enqueueCoordinatorForwardPush(coordinatorDaemonId, () => Promise.resolve(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`);
-      traceMeshEventDrop("immediate_forward_rejected", fwdTraceCtx, readNonEmptyString2(result.error) || "no reason");
-      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", `Durably forwarded ${eventName} for unresolved-mesh worker at ${routing.workspace || "(no workspace)"} to coordinator daemon ${coordinatorDaemonId}`);
+  if (!persisted) {
+    traceMeshEventDrop("outbox_enqueue_failed", fwdTraceCtx, `coordinatorDaemon=${coordinatorDaemonId}`);
+    return false;
+  }
+  traceMeshEventStage("outbox_enqueue", fwdTraceCtx, `coordinatorDaemon=${coordinatorDaemonId} meshId=${readNonEmptyString2(payload.meshId) || "absent"}`);
+  nudgeUnresolvedForwardRetry();
+  LOG.info("MeshEvents", `Durably queued ${eventName} for unresolved-mesh worker at ${routing.workspace || "(no workspace)"} to coordinator daemon ${coordinatorDaemonId} (reconcile PHASE 0 delivers)`);
   return true;
 }
-function ackUnresolvedDelegateForwardByFingerprint(coordinatorDaemonId, eventName, payload) {
-  const match = peekUnresolvedDelegateForwards().find(
-    (entry) => daemonIdsEquivalent(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 flushPendingForMeshIdleCoordinators(components, meshId) {
   try {
     const store = MeshRuntimeStore.getInstance();
@@ -20109,7 +20108,7 @@ function setupMeshEventForwarding(components) {
     flushPendingForMeshIdleCoordinators(components, routing.meshId);
   });
 }
-var REMOTE_IDLE_SESSION_TTL_MS, meshByWorkspaceCache, MESH_WORKSPACE_CACHE_TTL_MS, lastPendingEventsPruneAt, PENDING_EVENTS_PRUNE_INTERVAL_MS, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, RECONCILED_COMPLETION_SOURCES, coordinatorForwardLanes;
+var REMOTE_IDLE_SESSION_TTL_MS, meshByWorkspaceCache, MESH_WORKSPACE_CACHE_TTL_MS, lastPendingEventsPruneAt, PENDING_EVENTS_PRUNE_INTERVAL_MS, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, RECONCILED_COMPLETION_SOURCES;
 var init_mesh_event_forwarding = __esm({
   "src/mesh/mesh-event-forwarding.ts"() {
     "use strict";
@@ -20146,7 +20145,6 @@ var init_mesh_event_forwarding = __esm({
       "mcp_mesh_status_transcript_reconciliation",
       "no_progress_reconciliation"
     ]);
-    coordinatorForwardLanes = /* @__PURE__ */ new Map();
   }
 });
 
@@ -21125,6 +21123,65 @@ function recoverStrandedAssignedDispatches(components, meshId, store) {
     }
   }
 }
+function reconcileZombieAssignedTasks(components, mesh, selfIds) {
+  const meshId = mesh.id;
+  const assigned = getQueue(meshId, { status: ["assigned"] });
+  if (!assigned.length) return;
+  const nowMs = Date.now();
+  const assignedNodeIsLocal = (assignedNodeId) => {
+    if (!assignedNodeId) return true;
+    if (selfIds.some((id) => daemonIdsEquivalent(id, assignedNodeId))) return true;
+    const nodes = Array.isArray(mesh.nodes) ? mesh.nodes : [];
+    const node = nodes.find((n) => meshNodeIdMatches(n, assignedNodeId));
+    const nodeDaemonId = readNonEmptyString2(node?.daemonId);
+    return !!nodeDaemonId && selfIds.some((id) => daemonIdsEquivalent(id, nodeDaemonId));
+  };
+  for (const row of assigned) {
+    if (Number.isFinite(Date.parse(row.dispatchTimestamp ?? ""))) continue;
+    const updatedMs = Date.parse(row.updatedAt ?? "");
+    const createdMs = Date.parse(row.createdAt ?? "");
+    const anchorMs = Number.isFinite(updatedMs) ? updatedMs : createdMs;
+    if (!Number.isFinite(anchorMs)) continue;
+    if (nowMs - anchorMs < ZOMBIE_ASSIGNED_MIN_AGE_MS) continue;
+    const terminal = findTerminalLedgerEvidenceForTask({ meshId, taskId: row.id });
+    if (terminal) {
+      const status = terminal.kind === "task_completed" ? "completed" : "failed";
+      updateTaskStatus(meshId, row.id, status);
+      LOG.warn("MeshReconcile", `Zombie assigned task ${row.id} on mesh ${meshId} had ${terminal.kind} ledger evidence \u2014 flipped to ${status}`);
+      continue;
+    }
+    if (!assignedNodeIsLocal(row.assignedNodeId)) continue;
+    if (row.assignedSessionId) {
+      const verdict = resolveSessionBusyVerdict(components, row.assignedSessionId);
+      if (verdict !== "UNKNOWN") continue;
+    }
+    const reason = row.assignedSessionId ? "assigned_zombie_session_missing" : "assigned_zombie_no_session_bound";
+    const failed = updateTaskStatus(meshId, row.id, "failed");
+    if (!failed) continue;
+    try {
+      appendLedgerEntry(meshId, {
+        kind: "task_failed",
+        nodeId: row.assignedNodeId,
+        sessionId: row.assignedSessionId,
+        payload: {
+          taskId: row.id,
+          reason,
+          source: "reconcile_zombie_assigned_sweep",
+          ageMs: nowMs - anchorMs
+        }
+      });
+    } catch {
+    }
+    LOG.warn("MeshReconcile", `Failed zombie assigned task ${row.id} on mesh ${meshId} (node=${row.assignedNodeId ?? "?"} session=${row.assignedSessionId ?? "?"}, no dispatchTimestamp, stale ${Math.round((nowMs - anchorMs) / 6e4)}m, ${reason})`);
+    traceMeshEventDrop("assigned_zombie_failed", {
+      taskId: row.id,
+      sessionId: row.assignedSessionId,
+      nodeId: row.assignedNodeId,
+      meshId,
+      event: "agent:generating_completed"
+    }, `${reason} stale=${Math.round((nowMs - anchorMs) / 6e4)}m`);
+  }
+}
 async function runMeshReconcileTick(components) {
   const localDaemonId = readNonEmptyString2(loadConfig().machineId) || void 0;
   const drainDaemonIds = resolveCoordinatorDaemonIds(components);
@@ -21163,6 +21220,11 @@ async function runMeshReconcileTick(components) {
       } catch (e) {
         LOG.warn("MeshReconcile", `Assigned-stranded watchdog failed for mesh ${mesh.id}: ${e?.message || e}`);
       }
+      try {
+        reconcileZombieAssignedTasks(components, mesh, selfIds);
+      } catch (e) {
+        LOG.warn("MeshReconcile", `Assigned-zombie sweep failed for mesh ${mesh.id}: ${e?.message || e}`);
+      }
     }
   }
   for (const mesh of listMeshes()) {
@@ -21384,6 +21446,25 @@ function holdOrExpireStrictUnmatchedEvent(pending, wantSession, meshId) {
     LOG.warn("MeshReconcile", `Failed to ledger-expire strict-unmatched ${pending.event} for mesh ${meshId}: ${e?.message || e}`);
   }
 }
+function scheduleUnresolvedForwardNudge(components) {
+  if (!components.dispatchMeshCommand) return;
+  if (unresolvedForwardNudgeTimer) return;
+  unresolvedForwardNudgeTimer = setTimeout(() => {
+    unresolvedForwardNudgeTimer = void 0;
+    if (unresolvedForwardNudgeRunning) return;
+    unresolvedForwardNudgeRunning = true;
+    void retryUnresolvedDelegateForwards(components).catch((e) => LOG.warn("MeshReconcile", `Nudged unresolved-forward retry failed: ${e?.message || e}`)).finally(() => {
+      unresolvedForwardNudgeRunning = false;
+    });
+  }, UNRESOLVED_FORWARD_NUDGE_DELAY_MS);
+  if (typeof unresolvedForwardNudgeTimer.unref === "function") unresolvedForwardNudgeTimer.unref();
+}
+function clearUnresolvedForwardNudge() {
+  if (unresolvedForwardNudgeTimer) {
+    clearTimeout(unresolvedForwardNudgeTimer);
+    unresolvedForwardNudgeTimer = void 0;
+  }
+}
 async function retryUnresolvedDelegateForwards(components) {
   const dispatchMeshCommand = components.dispatchMeshCommand;
   if (!dispatchMeshCommand) return;
@@ -21468,15 +21549,18 @@ function setupMeshReconcileLoop(components) {
     });
   }, intervalMs);
   if (typeof timer.unref === "function") timer.unref();
+  registerUnresolvedForwardRetryNudge(() => scheduleUnresolvedForwardNudge(components));
   LOG.info("MeshReconcile", `Mesh reconcile loop started (interval ${intervalMs}ms)`);
   return {
     stop() {
       clearInterval(timer);
+      registerUnresolvedForwardRetryNudge(void 0);
+      clearUnresolvedForwardNudge();
       LOG.info("MeshReconcile", "Mesh reconcile loop stopped");
     }
   };
 }
-var coordinatorModalParkState, heldEventLedgerRecorded, ASSIGNED_STRANDED_DEADLINE_MS, DELIVERED_NO_TURN_DEADLINE_MS, RECLAIM_UNKNOWN_GRACE_TICKS, deliveredNoTurnUnknownStreak, STRICT_SESSION_MATCH_TTL_MS, unresolvedForwardRejectionCounts, MAX_FORWARD_REJECTIONS;
+var coordinatorModalParkState, heldEventLedgerRecorded, ASSIGNED_STRANDED_DEADLINE_MS, DELIVERED_NO_TURN_DEADLINE_MS, RECLAIM_UNKNOWN_GRACE_TICKS, deliveredNoTurnUnknownStreak, ZOMBIE_ASSIGNED_MIN_AGE_MS, STRICT_SESSION_MATCH_TTL_MS, unresolvedForwardRejectionCounts, MAX_FORWARD_REJECTIONS, UNRESOLVED_FORWARD_NUDGE_DELAY_MS, unresolvedForwardNudgeTimer, unresolvedForwardNudgeRunning;
 var init_mesh_reconcile_loop = __esm({
   "src/mesh/mesh-reconcile-loop.ts"() {
     "use strict";
@@ -21508,9 +21592,12 @@ var init_mesh_reconcile_loop = __esm({
     DELIVERED_NO_TURN_DEADLINE_MS = 15 * 6e4;
     RECLAIM_UNKNOWN_GRACE_TICKS = 3;
     deliveredNoTurnUnknownStreak = /* @__PURE__ */ new Map();
+    ZOMBIE_ASSIGNED_MIN_AGE_MS = 30 * 60 * 1e3;
     STRICT_SESSION_MATCH_TTL_MS = 6e4;
     unresolvedForwardRejectionCounts = /* @__PURE__ */ new Map();
     MAX_FORWARD_REJECTIONS = 5;
+    UNRESOLVED_FORWARD_NUDGE_DELAY_MS = 250;
+    unresolvedForwardNudgeRunning = false;
   }
 });
 
@@ -34195,6 +34282,16 @@ function isRuntimeFallbackHistorySessionId(candidateHistorySessionId, targetSess
   const candidate = typeof candidateHistorySessionId === "string" ? candidateHistorySessionId.trim() : "";
   return candidate === target;
 }
+function resolveNativeHistoryReadSession(args, candidateHistorySessionId) {
+  const targetSid = typeof args?.targetSessionId === "string" ? args.targetSessionId.trim() : "";
+  const explicitHistorySessionId = getExplicitHistorySessionId(args);
+  const isRuntimeFallback = Boolean(
+    targetSid && isRuntimeFallbackHistorySessionId(candidateHistorySessionId, targetSid) && (!explicitHistorySessionId || isRuntimeFallbackHistorySessionId(explicitHistorySessionId, targetSid))
+  );
+  const pinnedProviderSessionId = getBoundProviderSessionIdPin(args?.targetSessionId);
+  const effectiveHistorySessionId = isRuntimeFallback ? pinnedProviderSessionId || void 0 : candidateHistorySessionId;
+  return { isRuntimeFallback, pinnedProviderSessionId, effectiveHistorySessionId };
+}
 function getHistorySessionId(h, args) {
   const explicit = getExplicitHistorySessionId(args);
   if (explicit) return explicit;
@@ -35029,13 +35126,11 @@ async function handleChatHistory(h, args) {
       if (visibleCount > excludeRecentCount) excludeRecentCount = visibleCount;
     }
     const workspace = typeof args?.workspace === "string" ? args.workspace : typeof h.currentSession?.workspace === "string" ? h.currentSession.workspace : void 0;
-    const targetSidForHistory = typeof args?.targetSessionId === "string" ? args.targetSessionId.trim() : "";
-    const explicitHistorySessionIdForHistory = getExplicitHistorySessionId(args);
-    const historySessionIdIsRuntimeFallback = Boolean(
-      targetSidForHistory && isRuntimeFallbackHistorySessionId(historySessionId, targetSidForHistory) && (!explicitHistorySessionIdForHistory || isRuntimeFallbackHistorySessionId(explicitHistorySessionIdForHistory, targetSidForHistory))
-    );
-    const pinnedProviderSessionIdForHistory = getBoundProviderSessionIdPin(args?.targetSessionId);
-    const effectiveHistorySessionId = historySessionIdIsRuntimeFallback ? pinnedProviderSessionIdForHistory || void 0 : historySessionId;
+    const {
+      isRuntimeFallback: historySessionIdIsRuntimeFallback,
+      pinnedProviderSessionId: pinnedProviderSessionIdForHistory,
+      effectiveHistorySessionId
+    } = resolveNativeHistoryReadSession(args, historySessionId);
     const exactNativeHistoryScope = Boolean(
       typeof args?.targetSessionId === "string" && args.targetSessionId.trim() || typeof args?.historySessionId === "string" && args.historySessionId.trim() && !historySessionIdIsRuntimeFallback || typeof args?.providerSessionId === "string" && args.providerSessionId.trim()
     );
@@ -35196,12 +35291,10 @@ async function handleReadChat(h, args) {
       let nativeHistory = null;
       let nativeHistoryError;
       if (supportsNative) {
-        const pinnedProviderSessionIdForRead = getBoundProviderSessionIdPin(targetSessionId);
-        const explicitHistorySessionIdForRead = getExplicitHistorySessionId(args);
-        const nativeReadSessionIdIsRuntimeFallback = Boolean(
-          targetSessionId && isRuntimeFallbackHistorySessionId(nativeHistoryReadSessionId, targetSessionId) && (!explicitHistorySessionIdForRead || isRuntimeFallbackHistorySessionId(explicitHistorySessionIdForRead, targetSessionId))
-        );
-        const effectiveNativeReadSessionId = nativeReadSessionIdIsRuntimeFallback ? pinnedProviderSessionIdForRead || void 0 : nativeHistoryReadSessionId;
+        const {
+          pinnedProviderSessionId: pinnedProviderSessionIdForRead,
+          effectiveHistorySessionId: effectiveNativeReadSessionId
+        } = resolveNativeHistoryReadSession(args, nativeHistoryReadSessionId);
         try {
           nativeHistory = readCliProviderNativeHistory(agentStr, {
             canonicalHistory: provider?.nativeHistory,
@@ -35478,12 +35571,11 @@ async function handleReadChat(h, args) {
       const workspace = targetSid ? typeof registrySessionWorkspace === "string" ? registrySessionWorkspace : argsWorkspace ?? currentSessionWorkspace : typeof currentSessionWorkspace === "string" ? currentSessionWorkspace : void 0;
       const intendedWorkspace = argsWorkspace;
       const supportsNative = supportsCliNativeTranscript(agentStr, provider) && isNativeSourceCanonicalHistory(provider?.nativeHistory);
-      const pinnedProviderSessionIdForHistory = getBoundProviderSessionIdPin(targetSid);
-      const explicitHistorySessionId = getExplicitHistorySessionId(args);
-      const historySessionIdIsRuntimeFallback = Boolean(
-        targetSid && isRuntimeFallbackHistorySessionId(historySessionId, targetSid) && (!explicitHistorySessionId || isRuntimeFallbackHistorySessionId(explicitHistorySessionId, targetSid))
-      );
-      const effectiveHistorySessionIdForRead = historySessionIdIsRuntimeFallback ? pinnedProviderSessionIdForHistory || void 0 : historySessionId;
+      const {
+        isRuntimeFallback: historySessionIdIsRuntimeFallback,
+        pinnedProviderSessionId: pinnedProviderSessionIdForHistory,
+        effectiveHistorySessionId: effectiveHistorySessionIdForRead
+      } = resolveNativeHistoryReadSession(args, historySessionId);
       const history = supportsNative ? readCliProviderNativeHistory(agentStr, {
         canonicalHistory: provider?.nativeHistory,
         historySessionId: effectiveHistorySessionIdForRead,
@@ -39707,6 +39799,53 @@ var statusMetaHandlers = {
 
 // src/commands/low-family/coordinator-prompt.ts
 var coordinatorPromptHandlers = {
+  /**
+   * Render the coordinator system prompt for a mesh + CLI type, so the
+   * dashboard can show the operator exactly what a coordinator session
+   * receives by default. This resolves the mesh, applies its repo-mesh
+   * config, and runs the SAME buildCoordinatorSystemPrompt the launch path
+   * uses — minus the runtime-only best-effort sections (mission / recent
+   * activity / operating notes), which are launch-scope and not part of the
+   * static "default base" an operator is trying to preview here.
+   *
+   * It respects mesh-level and user-file override/append layering, so the
+   * preview reflects the effective prompt: with no overrides configured it
+   * shows the pure daemon default; with an override set it shows that.
+   */
+  coordinator_prompt_preview: async (ctx, args) => {
+    const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+    const cliType = typeof args?.cliType === "string" && args.cliType.trim() ? args.cliType.trim() : "claude-cli";
+    if (!meshId) return { success: false, error: "meshId required" };
+    try {
+      let mesh = null;
+      if (ctx.getMeshForCommand) {
+        const resolved = await ctx.getMeshForCommand(meshId);
+        mesh = resolved?.mesh ?? null;
+      }
+      if (!mesh) {
+        const { getMesh: getMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+        mesh = getMesh2(meshId);
+      }
+      if (!mesh) return { success: false, error: `mesh not found: ${meshId}` };
+      let effectiveMesh = mesh;
+      try {
+        const { loadRepoMeshJsonConfig: loadRepoMeshJsonConfig2, applyRepoMeshConfig: applyRepoMeshConfig2 } = await Promise.resolve().then(() => (init_mesh_json_config(), mesh_json_config_exports));
+        const workspace = typeof mesh?.workspace === "string" ? mesh.workspace : void 0;
+        if (workspace) {
+          const loaded = loadRepoMeshJsonConfig2(workspace);
+          if (loaded?.sourceType !== "invalid") {
+            effectiveMesh = applyRepoMeshConfig2(mesh, loaded?.config);
+          }
+        }
+      } catch {
+      }
+      const { buildCoordinatorSystemPrompt: buildCoordinatorSystemPrompt2 } = await Promise.resolve().then(() => (init_coordinator_prompt(), coordinator_prompt_exports));
+      const prompt = buildCoordinatorSystemPrompt2({ mesh: effectiveMesh, coordinatorCliType: cliType });
+      return { success: true, prompt, cliType, meshId, bytes: Buffer.byteLength(prompt, "utf8") };
+    } catch (error) {
+      return { success: false, error: error?.message || String(error) };
+    }
+  },
   list_coordinator_prompts: async (_ctx, _args) => {
     const fs41 = await import("fs");
     const path45 = await import("path");
@@ -54288,61 +54427,15 @@ var meshCrudHandlers = {
       return { success: false, error: e.message };
     }
   },
-  // ─── MAGI panels (machine-local config, sibling to meshes) ───────────────
-  // Panels live in ~/.adhdev/meshes.json `magiPanels` and are pure local config
-  // (no mesh ownership). These three handlers mirror list_meshes/create_mesh/
-  // update_mesh: dynamic-import the already-exported mesh-config accessors and
-  // surface normalizeMagiPanel's structured error codes (invalid_magi_panel,
-  // magi_panel_exists) verbatim so the dashboard can render them.
-  //
-  // Permission: magi_panel_set / magi_panel_remove are WRITE commands. They are
-  // intentionally NOT listed in canPeerUsePrivilegedShareCommand (daemon-cloud
-  // data-channel-router), so a peer holding ANY share permission hits its
-  // `default → false` branch — identical owner-only gating to create_mesh /
-  // update_mesh / list_meshes (none of which are listed there either). A trusted
-  // peer (no permission = the owner) passes the top `!permission → true` guard.
-  // Mirror, don't invent: do not add a new policy tier here.
-  //
-  // Resolvability (coupling / stale / available) is deliberately NOT computed
-  // here: buildMagiFanoutPlan lives in mcp-server, unreachable from daemon-core.
-  // magi_panel_list returns the raw definitions only; the dashboard derives
-  // member resolvability client-side (web-core MagiPanelManager, reusing the
-  // MagiGroupRow coupling logic) against live mesh_status.
-  magi_panel_list: async (_ctx, _args) => {
-    try {
-      const { listMagiPanels: listMagiPanels2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-      return { success: true, panels: listMagiPanels2() };
-    } catch (e) {
-      return { success: false, error: e.message };
-    }
-  },
-  magi_panel_set: async (_ctx, args) => {
-    const name = typeof args?.name === "string" ? args.name.trim() : "";
-    if (!name) return { success: false, error: "invalid_magi_panel: panel name is required" };
-    try {
-      const { upsertMagiPanel: upsertMagiPanel2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-      const panel = upsertMagiPanel2(name, args?.panel, { overwrite: args?.overwrite === true });
-      return { success: true, name, panel };
-    } catch (e) {
-      return { success: false, error: e.message };
-    }
-  },
-  magi_panel_remove: async (_ctx, args) => {
-    const name = typeof args?.name === "string" ? args.name.trim() : "";
-    if (!name) return { success: false, error: "invalid_magi_panel: panel name is required" };
-    try {
-      const { removeMagiPanel: removeMagiPanel2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-      const removed = removeMagiPanel2(name);
-      return { success: true, removed };
-    } catch (e) {
-      return { success: false, error: e.message };
-    }
-  },
   // ─── MAGI kind → panel bindings (MAGI-KIND-PANEL, machine-local config) ───
-  // Per-task_kind slot lists in ~/.adhdev/meshes.json `magiKindPanels`. Same
-  // owner-only gating and structured-error precedent as the magi_panel_* handlers
-  // above (not listed in canPeerUsePrivilegedShareCommand → owner-only). set/remove
-  // are WRITE commands; list is read-only. normalizeMagiSlots (inside setMagiKindPanel)
+  // Per-task_kind slot lists in ~/.adhdev/meshes.json `magiKindPanels` — the SOLE
+  // MAGI panel-resolution surface (the former named-panel magi_panel_* handlers were
+  // removed). Owner-only gating: intentionally NOT listed in
+  // canPeerUsePrivilegedShareCommand (daemon-cloud data-channel-router), so a peer
+  // holding ANY share permission hits its `default → false` branch — identical
+  // owner-only gating to create_mesh / update_mesh / list_meshes. A trusted peer (no
+  // permission = the owner) passes the top `!permission → true` guard. set/remove are
+  // WRITE commands; list is read-only. normalizeMagiSlots (inside setMagiKindPanel)
   // surfaces invalid_magi_kind_panel: … messages verbatim for the editor.
   magi_kind_panel_list: async (_ctx, _args) => {
     try {
@@ -54395,13 +54488,15 @@ var meshCrudHandlers = {
       const daemonId = typeof args?.daemonId === "string" && args.daemonId.trim() ? args.daemonId.trim() : void 0;
       const machineId = typeof args?.machineId === "string" && args.machineId.trim() ? args.machineId.trim() : void 0;
       const repoRoot = typeof args?.repoRoot === "string" && args.repoRoot.trim() ? args.repoRoot.trim() : void 0;
+      const capabilities = Array.isArray(args?.capabilities) ? args.capabilities.map((t) => typeof t === "string" ? t.trim() : "").filter(Boolean) : void 0;
       const node = addNode2(meshId, {
         workspace,
         ...repoRoot ? { repoRoot } : {},
         ...daemonId ? { daemonId } : {},
         ...machineId ? { machineId } : {},
         ...policy ? { policy } : {},
-        ...role ? { role } : {}
+        ...role ? { role } : {},
+        ...capabilities && capabilities.length ? { capabilities } : {}
       });
       if (!node) return { success: false, error: "Mesh not found" };
       ctx.invalidateAggregateMeshStatus(meshId);
@@ -54443,6 +54538,9 @@ var meshCrudHandlers = {
       } else if (args?.systemPrompt === null) {
         patch.systemPrompt = void 0;
       }
+      if (Array.isArray(args?.capabilities)) {
+        patch.capabilities = args.capabilities.map((t) => typeof t === "string" ? t.trim() : "").filter(Boolean);
+      }
       const node = updateNode2(meshId, nodeId, patch);
       if (!node) return { success: false, error: "Mesh node not found" };
       ctx.invalidateAggregateMeshStatus(meshId);
@@ -69481,7 +69579,6 @@ export {
   getLedgerSummary,
   getLogLevel,
   getMagiKindPanel,
-  getMagiPanel,
   getMesh,
   getMeshByRepo,
   getMeshMagiActivityByGroup,
@@ -69539,7 +69636,6 @@ export {
   listCoordinatorsForWorkspace,
   listHostedCliRuntimes,
   listMagiKindPanels,
-  listMagiPanels,
   listMeshMissionSummaries,
   listMeshMissionsForTool,
   listMeshes,
@@ -69576,7 +69672,6 @@ export {
   normalizeInputEnvelope,
   normalizeInteractivePrompt,
   normalizeInteractivePromptResponse,
-  normalizeMagiPanel,
   normalizeMagiSlots,
   normalizeManagedStatus,
   normalizeMeshCapabilityTags,
@@ -69619,7 +69714,6 @@ export {
   registerExtensionProviders,
   registerMeshCoordinator,
   removeMagiKindPanel,
-  removeMagiPanel,
   removeNode,
   removeWorktree,
   requeueHeldMeshCoordinatorEvents,
@@ -69682,7 +69776,6 @@ export {
   updateSessionDeliveryStatus,
   updateSessionTaskStatus,
   updateTaskStatus,
-  upsertMagiPanel,
   upsertMeshMission,
   upsertSavedProviderSession,
   validateChangeImpactConfig,