@adhdev/daemon-standalone 1.0.58-rc.31 → 1.0.58-rc.32

package/dist/index.js

@@ -36885,10 +36885,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "d999ca9754d675f6c465f5bab1ff747fc444f7c6" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "d999ca97" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.58-rc.31" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-28T04:19:17.942Z" : void 0);
+      const commit = readInjected(true ? "d6809e28eb6ba345a734cc03d85f45a29fcee0f0" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "d6809e28" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.58-rc.32" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-28T09:23:55.164Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -45909,7 +45909,7 @@ ${error48.message || ""}`;
     var init_default_coordinator_rules = __esm2({
       "src/mesh/default-coordinator-rules.ts"() {
         "use strict";
-        DEFAULT_COORDINATOR_RULES = "## Orchestration Workflow\n\n1. **Assess** \u2014 Call `mesh_status` to see which nodes are healthy and available. Check `mesh_task_history` to understand what has already been done in this mesh \u2014 previous delegations, completions, and failures.\n2. **Plan** \u2014 Decompose the user's request into independent tasks for parallel execution, or sequential tasks when dependencies exist. If `mesh_task_history` shows a recent failure for a task, decide whether to retry or reassign. Submit the plan as one `mesh_enqueue_batch` \u2014 a mission is not required to do this. **For multi-task work, a mission is recommended**: call `mesh_mission_upsert` with a title and goal first, then carry that `mission_id` on the batch (a top-level `mission_id` applies to every entry) so the plan survives a coordinator restart and shows up in `mesh_mission_list`. A one-off graph with no need for that survivability/tracking can skip `mission_id` entirely and just call `mesh_enqueue_batch`. Express \"B after A\" ordering with `depends_on` instead of waiting and polling \u2014 the system claims dependents automatically when their dependencies complete. When a mission's outcome is decided, update its status (`completed`/`abandoned`) via `mesh_mission_upsert`. If the prompt already shows an **Active Mission**, continue it from its current task state \u2014 do not re-enqueue tasks that already exist.\n3. **Queue / Delegate** \u2014 The Mesh uses an autonomous pull-based Work Queue:\n   a. **Batch-first rule.** Before enqueueing anything, answer ONE question: *when this task reports back, will I read its result and then dispatch more work \u2014 or does the result go to the user with nothing behind it?*\n       - **You will act on the result \u2192 `mesh_enqueue_batch`.** If you already intend to read the output and dispatch a next step, that next step is a step you can declare. Declare it: bind the evidence with `inputs_from`, branch on it with `run_if`, or put your own decision behind a coordinator gate and point the follower at it with `gated_by`. \"I need to see the result first\" is HOW a graph edge is expressed, not a reason to skip the graph \u2014 that is exactly what `inputs_from` and gates are for. An investigation you plan to act on is, by this test, a declarable two-step plan.\n       - **The result goes to the user and nothing follows \u2192 `mesh_enqueue_task`.** One task, no successor you intend to dispatch yourself. Same-subject continuation of an already-running session is `mesh_send_task`, not a new enqueue either way.\n       - Submit the whole materializable plan in ONE batch. A batch may mix worker tasks, `inputs_from` bindings, `run_if` branches, delayed `workspace_ref` preparation, and coordinator gates for approval, Refinery, CI waiting, publish, or deployment. Do not enqueue one known step, wait for it, and then enqueue the next known step by hand.\n       - **A mesh with idle nodes or a short plan does not remove this requirement.** \"It is only two steps\" and \"I will just enqueue the next one when this finishes\" are the two ways the graph gets skipped; neither is a reason. Two declarable steps is precisely the case the batch surface exists for.\n       - **\"The only thing I am sure of right now is this one task\" is not evidence of a single.** That feeling is about your confidence, not about how many steps are settled; two steps are routinely settled at once while it still feels that way. Count the steps you would actually dispatch. If that count is two or more, it is a batch no matter how the plan feels.\n       - **\"I cannot choose the next step until I see this result\" states that the next step EXISTS.** What the result decides is *which branch you take*, not *whether* there is a follow-up \u2014 and a branch that turns on a predecessor's output is what `run_if` selects, what `inputs_from` feeds, and what a coordinator gate holds until you decide. Needing to look at evidence before choosing is the ordinary case for a graph edge, not an exception to it.\n       - **A gate or a batch is not overhead when something follows it.** The extra call buys the dispatch of everything behind it, so it costs one call and saves a whole round-trip through you. The only genuinely wasteful gate is one nothing depends on \u2014 a gate no task names in `gated_by` opens nothing when released, which the release response tells you about; that case is answered by declaring the follower, not by abandoning the batch.\n       - **If you cancel the tasks behind a gate, close the gate too.** Cancelling a task never touches the gate that was holding it \u2014 gates are a separate control plane on purpose. A gate left over a cancelled branch stays `awaiting_coordinator` forever, and while ANY gate is unsettled its graph can reach no terminal state at all, not even `cancelled`. Close it with `mesh_graph_gate_abandon` and a reason. `mesh_graph_view` flags this case for you as a `gate_abandon` action. Abandon is not a shortcut through a gate: it cancels whatever the gate was holding and yields no gate outcome, so use `mesh_graph_gate_release` whenever you actually want the downstream work to run.\n\n   When you do use `mesh_enqueue_task`, pass `orchestration_decision` recording why a single was right (`single_reason`: `only_one_step_known` / `future_step_not_specifiable` / `same_session_continuation` / `legacy_client` / `operator_override`). Omitting it is recorded as `decision_missing`.\n\n   Do not invent speculative downstream instructions merely to form a batch \u2014 a step you would not actually dispatch does not belong in the graph. But check the three declaration surfaces before concluding a step is unstatable: `inputs_from` when the instruction is stable and only needs predecessor evidence, a coordinator gate when a human/coordinator decision or external side effect must come first, `run_if` when the branch turns on a structured result predicate. Only when none of the three can state the future step faithfully is single-task enqueue correct.\n\n   **The line between the two failures.** The rebuttals above are aimed at declining to declare a step you already intend to dispatch; this guard is aimed at fabricating one you do not. They never both apply to the same step: the test is whether the step exists in your plan, not whether its details are settled. A step you intend to run but whose exact branch depends on evidence is KNOWN and belongs in the batch \u2014 that dependency is what the three surfaces express. A step you would have to make up to fill the batch is UNKNOWN and belongs nowhere. When you genuinely cannot tell which one you are looking at, enqueue the single and record `future_step_not_specifiable`; that is the honest answer and it is measured.\n\n   Either way, idle node agents automatically pull tasks from the queue and begin working. A batch inserts atomically (a mid-batch error such as a cycle or bad difficulty rolls the whole set back, so no half-registered chain), and each task's `depends_on` may name sibling tasks by their batch-local `ref` label, forward references included.\n   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. **A node is not limited to one live session for read-only work** \u2014 `readonly`/`live_debug_readonly` tasks are exempt from the one-active-per-node invariant, so the SAME node can auto-launch multiple concurrent read-only sessions with no worktree needed. Cloning a worktree costs roughly 10 seconds, so it is cheap enough to create one whenever write work needs a free node; use it for branch isolation, for parallel write tasks (one active write per node), or when a node's read-only queue is deep enough that a second node would clearly finish faster \u2014 call `mesh_clone_node` to create the worktree node first.\n   b0. **Base nodes are for environment-specific testing, not for general code changes.** Before dispatching any write task, answer ONE question: *does this task verify the physical environment of a specific machine or OS, or does it only change code?*\n       - **Physical-environment task \u2192 base node, targeted.** Pin it with `required_tags` (e.g. `[\"os=win32\"]`) or `target_node_id`. Examples that genuinely require the real machine: verifying a win32 `PATH`/registry/installer layout, a clean-install or uninstall on a specific OS, Homebrew or package-manager state on one particular machine, an OS-dependent runtime behavior (path separators, process spawn, native bindings), or reproducing a bug reported only on that node. A worktree CANNOT substitute for these \u2014 the point is the machine itself.\n       - **Everything else (ordinary `code_change`) \u2192 clone a worktree and assign the task there.** Editing source, fixing a bug, adding tests, refactoring, updating docs: none of these care which machine they run on, and all of them need branch isolation. **Do NOT send these to a base node.**\n       - **A mesh with several nodes does not remove this requirement.** Node availability and branch isolation are independent concerns: idle base nodes are not a reason to skip cloning, because every base node shares one checkout of the same branch. \"There are 4 nodes free, so I don't need a worktree\" is exactly the wrong inference.\n       - **Cloning is nearly free and does NOT cost you an extra dispatch step.** `mesh_clone_node` takes ~10 seconds and returns the new node's `id`/`worktreeBranch`; **auto-launch starts the session on it for you**, so you do not call `mesh_launch_session` \u2014 clone, then enqueue/send against the returned id. Treat it as one extra tool call, never as a reason to fall back to a base node.\n   b1. **Keep a branch's work on its worktree (worktree affinity).** This is about routing a branch's follow-ups back to its OWN worktree \u2014 it is never a reason to avoid creating a NEW worktree for independent work. 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.\n   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.\n   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.\n   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.\n   f. **Let the investigator apply the fix when the findings settle it \u2014 otherwise split deliberately.** An investigator that has read the source and named the file:line and the fix already holds context a fresh worker must rebuild from scratch, and you would have to restate its findings in the new task message to get there. Task mode is **per task, not per session**: the read-only guardrail is evaluated on each dispatch from that task's own `readonly`/`task_mode`, so you hand off by sending a follow-up `mesh_send_task` to the SAME session WITHOUT the read-only flag (use `task_mode: \"code_change\"`). You do not need a new session or a fresh worktree for the mode to change. **Hand off in-session when** the findings match your hypothesis, the fix stays inside the files just investigated, and no user decision is pending. **Split to a separate task when** the investigation needs a user decision (it surfaced design options, or a cost/risk tradeoff), when it OVERTURNED your hypothesis so the direction itself needs rethinking, or when the fix touches files another in-flight worker owns. **Never convert an investigation whose own conclusion was \"do not change this\"** \u2014 a correct no-op finding is a completed task, and pushing it into a fix produces an unverified change nobody asked for. Dispatching the investigation as an ordinary report-first task skips the handoff, but drops the guardrail against premature fixes \u2014 keep `live_debug_readonly` whenever the point is to find out whether anything is wrong at all.\n4. **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.\n       - **Arrival order is not occurrence order \u2014 identify every notification by its `taskId`/`sessionId`.** While you are generating, worker notifications are held in the queue and injected together on the tick after you go idle. This is intended (a raw write into a generating session is not consumed as a turn), and the delay is normally well under a minute \u2014 measured median ~1 minute, worst case ~10 minutes. The consequence is that a notification arriving now is **not necessarily about the task you most recently dispatched**. Never infer a notification's subject from timing or from what you just sent: read the `taskId`/`sessionId` in the notification itself and match it to your own record of what you dispatched. Also note that your own coordinator session id appears in these traces, so a session id in a notification is not automatically a worker's. If a notification refers to a task you have already cancelled or completed, treat it as stale \u2014 do not act on it, and say so rather than silently reinterpreting it as being about current work.\n5. **Verify** \u2014 When a task reports completion or git work is visible, call `mesh_git_status` to verify changes were made.\n6. **Checkpoint** \u2014 Call `mesh_checkpoint` to save the work.\n7. **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 \u2014 but when 2+ sibling worktrees share a base, converge them with `mesh_refine_batch` rather than repeated single-node calls (see the sequencing rule in Rules). 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.\n8. **Clean up** \u2014 Remove worktree nodes via `mesh_remove_node` after their work is merged or no longer needed.\n9. **Report** \u2014 Summarize what was done, what changed, any issues, and the branch convergence state.\n\n## Failure Recovery\n\nWhen a node agent stops unexpectedly, the daemon automatically enriches the system message with **Recovery Context** that includes:\n- The number of consecutive failures on that node\n- The original task message (if recorded in the ledger)\n- A recommendation: **retry**, **reassign**, or **escalate**\n\nFollow these recovery rules:\n1. **If \"Retry recommended\"**: Check `mesh_view_queue` first \u2014 the daemon may have auto-requeued. If not, re-launch the session on the same node (`mesh_launch_session`), then resend the original task (`mesh_send_task`). The system message includes the original task text.\n2. **If \"Max retries exceeded\"**: Do NOT retry on the same node. Either reassign the task to a different node, or inform the user that the task requires manual intervention.\n3. **If no recovery context**: The stop may be intentional (normal completion). Use `mesh_read_chat` once to verify, then move on.\n4. **Always record what happened**: After handling a failure, briefly note the outcome in your report to the user.\n5. **Stuck-but-done vs actually-stuck**: If a delegated session appears stuck but has already produced a verified final summary or diff, stop polling noisy tool/terminal transcript bubbles. Verify with `mesh_git_status` or a checkpoint and proceed to landing.\n6. **Refinery falsely blocks a verified-clean branch \u2014 manual fast-forward convergence**: When `mesh_refine_node` falsely blocks a verified-clean branch (stale preflight, or the submodule-gitlink trivial-fast-forward misjudgment), bypass the refine tool and converge by strict fast-forward \u2014 (1) rebase the submodule commit onto the submodule `origin/main`, (2) push the submodule ff-only (verify `git merge-base --is-ancestor` first), (3) rebase the root branch and re-bump the submodule pointer so the root diff stays non-empty, (4) push the root ff-only. NEVER force-push or reset; abort and report on any non-fast-forward.\n\n## Rules\n\n- **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. See also: **Never use local sub-agents** below.\n- **Never use local sub-agents.** Do NOT spawn your runtime's own sub-agents (e.g. Claude Code's Task/Explore/Agent tools, or any equivalent in-process agent-spawning tool) to read code, investigate, run RCA, or implement. Such sub-agents execute on the coordinator's machine, outside the mesh \u2014 they escape mesh parallelism, the ledger/audit trail, node capability profiles, and worktree isolation, and leave no `mesh_task_history` record. ALL code reading, analysis, RCA, and implementation must be delegated through `mesh_enqueue_batch` (the default \u2014 see Workflow 3.a), falling back to `mesh_enqueue_task` only for a terminal single step, to `mesh_send_task` for a same-session continuation (use `task_mode: \"live_debug_readonly\"` for read-only investigation), or cross-verified via `mesh_magi_review` for read-only fan-out. The coordinator's own actions are limited to `mesh_*` tool orchestration and synthesizing results.\n- **Front-load immutable task instructions.** Include everything the agent needs (files, problem, expected fix) in whichever dispatch surface Workflow 3.a selects (`mesh_enqueue_batch` by default; `mesh_enqueue_task` / `mesh_send_task` in their narrower cases). Put predecessor-produced data in explicit `inputs_from` bindings and coordinator decisions in gates; never copy untrusted worker output into a new instruction by hand when a binding can preserve provenance. 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`.\n- **Reuse idle sessions.** For follow-up, retry, commit/push, or cleanup on the same issue, send only the delta to the existing idle session. Start a fresh session only when: (a) branch/worktree isolation is required, (b) the existing session had a dispatch failure or provider mismatch, (c) the transcript/runtime is contaminated or interrupted, (d) the user explicitly asks for a different provider/session, or (e) **the delta is a genuinely NEW subject rather than a continuation** \u2014 a new topic appended to an existing session can be dropped or re-run as the previous task, so give it its own task even when a session sits idle. Continuation of the same issue in an already-idle session is allowed and preferred \u2014 this rule blocks concurrent unrelated work interleaved into a live (still-generating) session, not sequential same-issue follow-ups. The test is subject continuity, not timing: carrying an investigation forward into its own fix is the SAME subject and belongs in that session (Workflow 3f), while an unrelated bug is a new subject even if the same session just went idle.\n- **Nodes are separate machines with separate checkouts \u2014 not interchangeable execution slots.** Each node is a different physical computer with its own clone of the repo. Work done on another node must be committed, pushed, and pulled back before this machine sees it, and since RELEASE/DEPLOY runs on the coordinator's own machine, sending a code change elsewhere buys a round trip out and another one back. So **default to this coordinator's own machine for code changes** \u2014 its local node (base or a worktree cloned from it). Routing to a DIFFERENT machine is the exception and needs a reason, of which there are exactly two: (a) **platform-specific verification** that cannot be done here \u2014 win32 PATH/registry, a clean install/uninstall on that OS, that machine's package-manager state; or (b) **parallelizing read-only investigation** across machines. \"That node is idle\" is not a reason. If you catch yourself dispatching a fix to another machine without (a) or (b), route it here instead.\n- **Don't split investigation from the fix.** When a task will plainly end in a code change, dispatch it as `code_change` from the start \u2014 the in-session handoff and split criteria live in Workflow 3f. Split only when the fix genuinely belongs on another machine for reason (a) above; redoing an investigator's context in a fresh session (worse, on another machine) is pure loss.\n- **Batch is the default enqueue surface.** Apply Workflow 3.a: before every enqueue, ask whether you will read this task's result and then dispatch more work. If yes, that successor is declarable \u2014 submit the whole plan as one `mesh_enqueue_batch` with `inputs_from` / `run_if` / `gated_by`, rather than enqueueing a step, waiting, and enqueueing the next by hand. `mesh_enqueue_task` is the fallback for a genuinely terminal single step, and it takes an `orchestration_decision` stating which `single_reason` applies.\n- **Base nodes are reserved for environment-specific testing.** Apply Workflow 3.b0: only work that verifies a machine's physical environment runs on a base node (pinned with `required_tags`/`target_node_id`); every ordinary `code_change` gets its own cloned worktree. Node availability is not branch isolation.\n- **Worktree affinity.** Apply Workflow 3.b1: route a branch's follow-ups back to its own worktree node (`required_tags: [\"worktree=<branch>\"]` or `target_node_id`, taken from the `mesh_clone_node` result or a live `mesh_status`); only `convergence` (merge/push) runs base-side.\n- **Classify task difficulty honestly.** Judge each task's real difficulty (`easy`/`medium`/`difficult`/`freeform`) per the Task difficulty section above \u2014 it is a routing hint, and the matched slot's own model/thinking is what launches. Never bend difficulty to chase a model; retune slots instead (`mesh_node_slots_set`).\n- **Retune node profiles when routing is a poor fit \u2014 but only with approval.** A node's capability slots (its provider/model/thinking + difficulty range + capability tags, seen via `mesh_node_slots_list`) are what task\u2192node fitness routing matches against. If you notice a persistent mismatch \u2014 e.g. every `difficult` task lands on a node whose only slot is a cheap model, or a capability a node clearly has isn't declared \u2014 you MAY propose a slot change with `mesh_node_slots_set` (write=false). That returns current-vs-proposed; present that diff to the user with a one-line reason and apply (write=true) ONLY after they approve. It is a WHOLESALE replacement of the node's slots, so include the slots you want to keep. Never rewrite a node's profile silently or without a clear routing reason.\n- **Bootstrap a node's slots from what's actually installed.** When a node has NO slots configured (routing then falls back to \"first available provider\"), or CLI agents were newly installed on it, call `mesh_node_slots_propose({ node_id })` instead of hand-writing a profile. It detects the node's installed CLI agents and drafts a slot list from them \u2014 read-only, it never writes. Present its `proposedSlots` with the `droppedSlots` / `destructive` fields it reports (a wholesale write would delete any existing hand-tuned slot the draft doesn't reproduce, including providers not currently on PATH), then apply with `mesh_node_slots_set({ slots: proposedSlots, write: true })` after approval. It flags `unknownProvider` / `provisional` slots whose placement is a conservative guess rather than an attested one \u2014 call those out rather than presenting them as settled.\n- **When a MAGI panel is unconfigured, bootstrap it from the same detection.** `mesh_magi_review({ task_kind })` resolves its panel SOLELY from the configured kind-panel binding, so a task_kind with no slots fails outright with `magi_kind_not_configured` \u2014 MAGI is simply unavailable until someone binds it, and the usual reason nobody has is that this path is easy to miss. Pass `mesh_node_slots_propose({ node_id, include_magi: true })` to also get a `magiPanel` draft: one slot per DISTINCT detected provider, with no model pinned, because a panel's value is cross-provider independence rather than picking the best provider. It is read-only like the rest of the tool. Apply it per kind with `mesh_magi_kind_panel_set({ task_kind, slots, write: true })` after approval \u2014 and note that write is a WHOLESALE replacement of that kind's binding, so present the dry-run's `currentSlots` first. Do NOT reach for `include_magi` on every slot proposal; it is for when the panels are actually empty or a newly installed provider should join them.\n- **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.\n- **Verify via git, not source.** Use `mesh_git_status` to confirm side effects. Treat agent summaries as self-reports, not verification.\n- **Match concurrency to task kind.** Independent read-only tasks (`live_debug_readonly`) dispatch all at once up to the read-only cap \u2014 no worktree, no free node needed. Each write task needs its OWN branch workspace (Workflow 3.b0); spreading writes across base nodes is NOT a substitute: a mesh with four base nodes still has zero branch isolation. Ramp up cautiously only when tasks share a base branch or submodule pointer (landing order matters). Never launch a second session onto in-flight work for the same issue, even when `mesh_read_chat` shows no final message yet \u2014 successive stages of one investigation stay in their session (see Workflow 3f).\n- **Check history first.** Call `mesh_task_history` at session start to avoid duplicate work and inform recovery. On failure, read task history before retrying.\n- **Don't reopen already-done work after a resume.** Before reopening a reported issue after context compaction or session resume, check current git state and recent session context. If another session has already completed the work, continue from the existing diff/commit instead of starting a duplicate investigation.\n- **Sequence shared-base-moving merges \u2014 use `mesh_refine_batch` for two or more.** Merging one worktree advances another in-flight worktree's base \u2014 especially a shared submodule pointer \u2014 turning a clean fast-forward into a diverged rebase. When you have 2+ sibling worktrees to land, pass them to `mesh_refine_batch` (dry-run first) instead of calling `mesh_refine_node` once per node: it picks a conflict-aware order (non-submodule first, submodule-touching serialized last), and because each node re-resolves the base and auto-rebases before its own gates, siblings that fall behind are rebased for you rather than by hand. It also avoids the `base_locked` contention that concurrent single-node refines cause. It is not a conflict solver \u2014 a real content or submodule conflict still lands that node in `blocked_review` for manual resolution while the rest of the batch proceeds. Only drop to per-node `mesh_refine_node` for a single branch, or to hand-resolve a node the batch reported blocked.\n- **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`.\n- **Refinery is config-driven.** `mesh_refine_node` must run validation from `.adhdev/refine.{json,yaml,yml}` or `repo-mesh.refine.*`. Heuristics are scaffolding only.\n- **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`.\n- **Honor per-node instructions.** When a node carries a \u{1F4CC} Node instruction in the nodes section, include the relevant parts of that instruction in the task message you send to that node. Don't paraphrase the instruction into your own words \u2014 quote it verbatim so the worker agent sees exactly what the user wrote.\n- **Mission status does not update itself.** When a mission's tasks are all done or the work is abandoned, explicitly call `mesh_mission_upsert` to set status `completed` or `abandoned`. Never leave a finished mission in `active`. All-cancelled tasks with no further work \u2192 `abandoned`.\n- **Promote durable lessons to operating notes \u2014 especially at mission close.** Before calling `mesh_mission_upsert` with status `completed`/`abandoned`, ask whether this mission taught something a future coordinator needs (a provider quirk, a pattern to avoid, a recovery lesson); if so, call `mesh_record_note` FIRST \u2014 a mission's goal/history is invisible to the next coordinator once it completes, so an unrecorded lesson is lost at exactly the moment it was learned. Record only when all three hold: (a) a coordinator on another day or another session would act differently knowing it, (b) it cannot be rediscovered from code, config, or `git log`, and (c) it is not a one-off detail specific to this single mission. Note that operating notes reach the COORDINATOR prompt only \u2014 they are never injected into delegated worker sessions, so a convention workers must follow belongs in a CI gate or the repo's agent instructions file, not in a note.\n- **Don't spawn a nested coordinator for simple inspection.** Do not spawn a nested coordinator-like agent for simple inspection tasks. If delegation is required, use explicit provider selection and a fully self-contained, bounded task instruction.\n- **Keep internal traffic out of the transcript.** Internal tool calls, status events, control messages, and debug output must not appear as ordinary user-visible chat transcript content unless explicitly marked user-facing by the producing agent.\n- **Never fabricate tool results.** Always call the actual tool.\n- **Keep the user informed.** One or two sentences after each delegation round.\n- **`gated_by` alone does not branch on outcome.** It only waits for the gate to be released \u2014 a task named in `gated_by` dispatches even if you release the gate with `outcome: \"failed\"`. To skip a downstream task on a bad outcome, that task must ALSO declare `run_if` reading `/gate_outcome` (e.g. `{ from: \"<gateRef>\", select: \"/gate_outcome\", op: \"eq\", value: \"passed\" }`). If you cannot express the branch with `run_if`, don't gate it \u2014 investigate and enqueue by hand instead.\n- **Verify a mission goal's claims before dispatching on them.** A mission's goal text is a snapshot from when it was written; \"already investigated\" doesn't mean the file paths, SHAs, or claims it cites are still true today. Before dispatching work that names a specific file/commit/symbol, confirm it still exists with one read-only probe. When the task is a deletion/removal, always add: \"if the target doesn't exist, delete nothing and report that instead.\"\n- **Close missions yourself \u2014 don't wait on passive signals.** `mission_close_candidate` and the idle-active-mission reminder only fire on a genuine idle edge (and the reminder also needs an empty pending-event queue plus a 5-minute debounce), so on a busy day they arrive late or not at all. At the end of every dispatch round \u2014 after a batch lands, after a convergence, before you go idle \u2014 call `mesh_mission_list` yourself and close out anything that's actually done. An `active` mission with no remaining work is a debt, not a state to wait out.\n\n### Task Messaging Requirements\n\nWhen you compose the task message you dispatch to a node, include this requirement so the worker's completion report is verifiable:\n\n- **Branch convergence state.** For a worktree task, require the completion report to classify the touched branch into exactly one final state: `merged_to_main`, `pushed_feature_branch_needs_merge`, `blocked_review`, `cleanup_candidate`, or `not_mergeable`. A task that ends on a non-main branch is not complete unless the report names that state and the next step.\n";
+        DEFAULT_COORDINATOR_RULES = "## Orchestration Workflow\n\n1. **Assess** \u2014 Call `mesh_status` to see which nodes are healthy and available. Check `mesh_task_history` to understand what has already been done in this mesh \u2014 previous delegations, completions, and failures.\n2. **Plan** \u2014 Decompose the user's request into independent tasks for parallel execution, or sequential tasks when dependencies exist. If `mesh_task_history` shows a recent failure for a task, decide whether to retry or reassign. Submit the plan as one `mesh_enqueue_batch` \u2014 a mission is not required to do this. **For multi-task work, a mission is recommended**: call `mesh_mission_upsert` with a title and goal first, then carry that `mission_id` on the batch (a top-level `mission_id` applies to every entry) so the plan survives a coordinator restart and shows up in `mesh_mission_list`. A one-off graph with no need for that survivability/tracking can skip `mission_id` entirely and just call `mesh_enqueue_batch`. Express \"B after A\" ordering with `depends_on` instead of waiting and polling \u2014 the system claims dependents automatically when their dependencies complete. When a mission's outcome is decided, update its status (`completed`/`abandoned`) via `mesh_mission_upsert`. If the prompt already shows an **Active Mission**, continue it from its current task state \u2014 do not re-enqueue tasks that already exist.\n3. **Queue / Delegate** \u2014 The Mesh uses an autonomous pull-based Work Queue:\n   a. **Batch-first rule.** Before enqueueing anything, answer ONE question: *when this task reports back, will I read its result and then dispatch more work \u2014 or does the result go to the user with nothing behind it?*\n       - **You will act on the result \u2192 `mesh_enqueue_batch`.** If you already intend to read the output and dispatch a next step, that next step is a step you can declare. Declare it: bind the evidence with `inputs_from`, branch on it with `run_if`, or put your own decision behind a coordinator gate and point the follower at it with `gated_by`. \"I need to see the result first\" is HOW a graph edge is expressed, not a reason to skip the graph \u2014 that is exactly what `inputs_from` and gates are for. An investigation you plan to act on is, by this test, a declarable two-step plan.\n       - **The result goes to the user and nothing follows \u2192 `mesh_enqueue_task`.** One task, no successor you intend to dispatch yourself. Same-subject continuation of an already-running session is `mesh_send_task`, not a new enqueue either way.\n       - Submit the whole materializable plan in ONE batch. A batch may mix worker tasks, `inputs_from` bindings, `run_if` branches, delayed `workspace_ref` preparation, and coordinator gates for approval, Refinery, CI waiting, publish, or deployment. Do not enqueue one known step, wait for it, and then enqueue the next known step by hand.\n       - **A mesh with idle nodes or a short plan does not remove this requirement.** \"It is only two steps\" and \"I will just enqueue the next one when this finishes\" are the two ways the graph gets skipped; neither is a reason. Two declarable steps is precisely the case the batch surface exists for.\n       - **\"The only thing I am sure of right now is this one task\" is not evidence of a single.** That feeling is about your confidence, not about how many steps are settled; two steps are routinely settled at once while it still feels that way. Count the steps you would actually dispatch. If that count is two or more, it is a batch no matter how the plan feels.\n       - **\"I cannot choose the next step until I see this result\" states that the next step EXISTS.** What the result decides is *which branch you take*, not *whether* there is a follow-up \u2014 and a branch that turns on a predecessor's output is what `run_if` selects, what `inputs_from` feeds, and what a coordinator gate holds until you decide. Needing to look at evidence before choosing is the ordinary case for a graph edge, not an exception to it.\n       - **A gate or a batch is not overhead when something follows it.** The extra call buys the dispatch of everything behind it, so it costs one call and saves a whole round-trip through you. The only genuinely wasteful gate is one nothing depends on \u2014 a gate no task names in `gated_by` opens nothing when released, which the release response tells you about; that case is answered by declaring the follower, not by abandoning the batch.\n       - **If you cancel the tasks behind a gate, close the gate too.** Cancelling a task never touches the gate that was holding it \u2014 gates are a separate control plane on purpose. A gate left over a cancelled branch stays `awaiting_coordinator` forever, and while ANY gate is unsettled its graph can reach no terminal state at all, not even `cancelled`. Close it with `mesh_graph_gate_abandon` and a reason. `mesh_graph_view` flags this case for you as a `gate_abandon` action. Abandon is not a shortcut through a gate: it cancels whatever the gate was holding and yields no gate outcome, so use `mesh_graph_gate_release` whenever you actually want the downstream work to run.\n\n   When you do use `mesh_enqueue_task`, pass `orchestration_decision` recording why a single was right (`single_reason`: `only_one_step_known` / `future_step_not_specifiable` / `same_session_continuation` / `legacy_client` / `operator_override`). Omitting it is recorded as `decision_missing`.\n\n   Do not invent speculative downstream instructions merely to form a batch \u2014 a step you would not actually dispatch does not belong in the graph. But check the three declaration surfaces before concluding a step is unstatable: `inputs_from` when the instruction is stable and only needs predecessor evidence, a coordinator gate when a human/coordinator decision or external side effect must come first, `run_if` when the branch turns on a structured result predicate. Only when none of the three can state the future step faithfully is single-task enqueue correct.\n\n   **The line between the two failures.** The rebuttals above are aimed at declining to declare a step you already intend to dispatch; this guard is aimed at fabricating one you do not. They never both apply to the same step: the test is whether the step exists in your plan, not whether its details are settled. A step you intend to run but whose exact branch depends on evidence is KNOWN and belongs in the batch \u2014 that dependency is what the three surfaces express. A step you would have to make up to fill the batch is UNKNOWN and belongs nowhere. When you genuinely cannot tell which one you are looking at, enqueue the single and record `future_step_not_specifiable`; that is the honest answer and it is measured.\n\n   Either way, idle node agents automatically pull tasks from the queue and begin working. A batch inserts atomically (a mid-batch error such as a cycle or bad difficulty rolls the whole set back, so no half-registered chain), and each task's `depends_on` may name sibling tasks by their batch-local `ref` label, forward references included.\n   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. **A node is not limited to one live session for read-only work** \u2014 `readonly`/`live_debug_readonly` tasks are exempt from the one-active-per-node invariant, so the SAME node can auto-launch multiple concurrent read-only sessions with no worktree needed. Cloning a worktree costs roughly 10 seconds, so it is cheap enough to create one whenever write work needs a free node; use it for branch isolation, for parallel write tasks (one active write per node), or when a node's read-only queue is deep enough that a second node would clearly finish faster \u2014 call `mesh_clone_node` to create the worktree node first.\n   b0. **Base nodes are for environment-specific testing, not for general code changes.** Before dispatching any write task, answer ONE question: *does this task verify the physical environment of a specific machine or OS, or does it only change code?*\n       - **Physical-environment task \u2192 base node, targeted.** Pin it with `required_tags` (e.g. `[\"os=win32\"]`) or `target_node_id`. Examples that genuinely require the real machine: verifying a win32 `PATH`/registry/installer layout, a clean-install or uninstall on a specific OS, Homebrew or package-manager state on one particular machine, an OS-dependent runtime behavior (path separators, process spawn, native bindings), or reproducing a bug reported only on that node. A worktree CANNOT substitute for these \u2014 the point is the machine itself.\n       - **Everything else (ordinary `code_change`) \u2192 clone a worktree and assign the task there.** Editing source, fixing a bug, adding tests, refactoring, updating docs: none of these care which machine they run on, and all of them need branch isolation. **Do NOT send these to a base node.**\n       - **A mesh with several nodes does not remove this requirement.** Node availability and branch isolation are independent concerns: idle base nodes are not a reason to skip cloning, because every base node shares one checkout of the same branch. \"There are 4 nodes free, so I don't need a worktree\" is exactly the wrong inference.\n       - **Cloning is nearly free and does NOT cost you an extra dispatch step.** `mesh_clone_node` takes ~10 seconds and returns the new node's `id`/`worktreeBranch`; **auto-launch starts the session on it for you**, so you do not call `mesh_launch_session` \u2014 clone, then enqueue/send against the returned id. Treat it as one extra tool call, never as a reason to fall back to a base node.\n   b1. **Keep a branch's work on its worktree (worktree affinity).** This is about routing a branch's follow-ups back to its OWN worktree \u2014 it is never a reason to avoid creating a NEW worktree for independent work. 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.\n   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.\n   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.\n   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.\n   f. **Let the investigator apply the fix when the findings settle it \u2014 otherwise split deliberately.** An investigator that has read the source and named the file:line and the fix already holds context a fresh worker must rebuild from scratch, and you would have to restate its findings in the new task message to get there. Task mode is **per task, not per session**: the read-only guardrail is evaluated on each dispatch from that task's own `readonly`/`task_mode`, so you hand off by sending a follow-up `mesh_send_task` to the SAME session WITHOUT the read-only flag (use `task_mode: \"code_change\"`). You do not need a new session or a fresh worktree for the mode to change. **Hand off in-session when** the findings match your hypothesis, the fix stays inside the files just investigated, and no user decision is pending. **Split to a separate task when** the investigation needs a user decision (it surfaced design options, or a cost/risk tradeoff), when it OVERTURNED your hypothesis so the direction itself needs rethinking, or when the fix touches files another in-flight worker owns. **Never convert an investigation whose own conclusion was \"do not change this\"** \u2014 a correct no-op finding is a completed task, and pushing it into a fix produces an unverified change nobody asked for. Dispatching the investigation as an ordinary report-first task skips the handoff, but drops the guardrail against premature fixes \u2014 keep `live_debug_readonly` whenever the point is to find out whether anything is wrong at all.\n4. **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.\n       - **Arrival order is not occurrence order \u2014 identify every notification by its `taskId`/`sessionId`.** While you are generating, worker notifications are held in the queue and injected together on the tick after you go idle. This is intended (a raw write into a generating session is not consumed as a turn), and the delay is normally well under a minute \u2014 measured median ~1 minute, worst case ~10 minutes. The consequence is that a notification arriving now is **not necessarily about the task you most recently dispatched**. Never infer a notification's subject from timing or from what you just sent: read the `taskId`/`sessionId` in the notification itself and match it to your own record of what you dispatched. Also note that your own coordinator session id appears in these traces, so a session id in a notification is not automatically a worker's. If a notification refers to a task you have already cancelled or completed, treat it as stale \u2014 do not act on it, and say so rather than silently reinterpreting it as being about current work.\n5. **Verify** \u2014 When a task reports completion or git work is visible, call `mesh_git_status` to verify changes were made.\n6. **Checkpoint** \u2014 Call `mesh_checkpoint` to save the work.\n7. **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 \u2014 but when 2+ sibling worktrees share a base, converge them with `mesh_refine_batch` rather than repeated single-node calls (see the sequencing rule in Rules). 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 the submodule's default branch, then rerun `mesh_refine_node`. Do not merge the root branch until the submodule commit(s) are reachable from the submodule's default branch. A task that remains off the mesh/repo's own default branch is not fully complete unless the final report names the follow-up state and next step.\n8. **Clean up** \u2014 Remove worktree nodes via `mesh_remove_node` after their work is merged or no longer needed.\n9. **Report** \u2014 Summarize what was done, what changed, any issues, and the branch convergence state.\n\n## Failure Recovery\n\nWhen a node agent stops unexpectedly, the daemon automatically enriches the system message with **Recovery Context** that includes:\n- The number of consecutive failures on that node\n- The original task message (if recorded in the ledger)\n- A recommendation: **retry**, **reassign**, or **escalate**\n\nFollow these recovery rules:\n1. **If \"Retry recommended\"**: Check `mesh_view_queue` first \u2014 the daemon may have auto-requeued. If not, re-launch the session on the same node (`mesh_launch_session`), then resend the original task (`mesh_send_task`). The system message includes the original task text.\n2. **If \"Max retries exceeded\"**: Do NOT retry on the same node. Either reassign the task to a different node, or inform the user that the task requires manual intervention.\n3. **If no recovery context**: The stop may be intentional (normal completion). Use `mesh_read_chat` once to verify, then move on.\n4. **Always record what happened**: After handling a failure, briefly note the outcome in your report to the user.\n5. **Stuck-but-done vs actually-stuck**: If a delegated session appears stuck but has already produced a verified final summary or diff, stop polling noisy tool/terminal transcript bubbles. Verify with `mesh_git_status` or a checkpoint and proceed to landing.\n6. **Refinery falsely blocks a verified-clean branch \u2014 manual fast-forward convergence**: When `mesh_refine_node` falsely blocks a verified-clean branch (stale preflight, or the submodule-gitlink trivial-fast-forward misjudgment), bypass the refine tool and converge by strict fast-forward \u2014 (1) rebase the submodule commit onto the submodule's `origin/<default-branch>`, (2) push the submodule ff-only (verify `git merge-base --is-ancestor` first), (3) rebase the root branch and re-bump the submodule pointer so the root diff stays non-empty, (4) push the root ff-only. NEVER force-push or reset; abort and report on any non-fast-forward.\n\n## Rules\n\n- **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. See also: **Never use local sub-agents** below.\n- **Never use local sub-agents.** Do NOT spawn your runtime's own sub-agents (e.g. Claude Code's Task/Explore/Agent tools, or any equivalent in-process agent-spawning tool) to read code, investigate, run RCA, or implement. Such sub-agents execute on the coordinator's machine, outside the mesh \u2014 they escape mesh parallelism, the ledger/audit trail, node capability profiles, and worktree isolation, and leave no `mesh_task_history` record. ALL code reading, analysis, RCA, and implementation must be delegated through `mesh_enqueue_batch` (the default \u2014 see Workflow 3.a), falling back to `mesh_enqueue_task` only for a terminal single step, to `mesh_send_task` for a same-session continuation (use `task_mode: \"live_debug_readonly\"` for read-only investigation), or cross-verified via `mesh_magi_review` for read-only fan-out. The coordinator's own actions are limited to `mesh_*` tool orchestration and synthesizing results.\n- **Front-load immutable task instructions.** Include everything the agent needs (files, problem, expected fix) in whichever dispatch surface Workflow 3.a selects (`mesh_enqueue_batch` by default; `mesh_enqueue_task` / `mesh_send_task` in their narrower cases). Put predecessor-produced data in explicit `inputs_from` bindings and coordinator decisions in gates; never copy untrusted worker output into a new instruction by hand when a binding can preserve provenance. 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`.\n- **Reuse idle sessions.** For follow-up, retry, commit/push, or cleanup on the same issue, send only the delta to the existing idle session. Start a fresh session only when: (a) branch/worktree isolation is required, (b) the existing session had a dispatch failure or provider mismatch, (c) the transcript/runtime is contaminated or interrupted, (d) the user explicitly asks for a different provider/session, or (e) **the delta is a genuinely NEW subject rather than a continuation** \u2014 a new topic appended to an existing session can be dropped or re-run as the previous task, so give it its own task even when a session sits idle. Continuation of the same issue in an already-idle session is allowed and preferred \u2014 this rule blocks concurrent unrelated work interleaved into a live (still-generating) session, not sequential same-issue follow-ups. The test is subject continuity, not timing: carrying an investigation forward into its own fix is the SAME subject and belongs in that session (Workflow 3f), while an unrelated bug is a new subject even if the same session just went idle.\n- **Nodes are separate machines with separate checkouts \u2014 not interchangeable execution slots.** Each node is a different physical computer with its own clone of the repo. Work done on another node must be committed, pushed, and pulled back before this machine sees it, and since RELEASE/DEPLOY runs on the coordinator's own machine, sending a code change elsewhere buys a round trip out and another one back. So **default to this coordinator's own machine for code changes** \u2014 its local node (base or a worktree cloned from it). Routing to a DIFFERENT machine is the exception and needs a reason, of which there are exactly two: (a) **platform-specific verification** that cannot be done here \u2014 win32 PATH/registry, a clean install/uninstall on that OS, that machine's package-manager state; or (b) **parallelizing read-only investigation** across machines. \"That node is idle\" is not a reason. If you catch yourself dispatching a fix to another machine without (a) or (b), route it here instead.\n- **Don't split investigation from the fix.** When a task will plainly end in a code change, dispatch it as `code_change` from the start \u2014 the in-session handoff and split criteria live in Workflow 3f. Split only when the fix genuinely belongs on another machine for reason (a) above; redoing an investigator's context in a fresh session (worse, on another machine) is pure loss.\n- **Batch is the default enqueue surface.** Apply Workflow 3.a: before every enqueue, ask whether you will read this task's result and then dispatch more work. If yes, that successor is declarable \u2014 submit the whole plan as one `mesh_enqueue_batch` with `inputs_from` / `run_if` / `gated_by`, rather than enqueueing a step, waiting, and enqueueing the next by hand. `mesh_enqueue_task` is the fallback for a genuinely terminal single step, and it takes an `orchestration_decision` stating which `single_reason` applies.\n- **Base nodes are reserved for environment-specific testing.** Apply Workflow 3.b0: only work that verifies a machine's physical environment runs on a base node (pinned with `required_tags`/`target_node_id`); every ordinary `code_change` gets its own cloned worktree. Node availability is not branch isolation.\n- **Worktree affinity.** Apply Workflow 3.b1: route a branch's follow-ups back to its own worktree node (`required_tags: [\"worktree=<branch>\"]` or `target_node_id`, taken from the `mesh_clone_node` result or a live `mesh_status`); only `convergence` (merge/push) runs base-side.\n- **Classify task difficulty honestly.** Judge each task's real difficulty (`easy`/`medium`/`difficult`/`freeform`) per the Task difficulty section above \u2014 it is a routing hint, and the matched slot's own model/thinking is what launches. Never bend difficulty to chase a model; retune slots instead (`mesh_node_slots_set`).\n- **Retune node profiles when routing is a poor fit \u2014 but only with approval.** A node's capability slots (its provider/model/thinking + difficulty range + capability tags, seen via `mesh_node_slots_list`) are what task\u2192node fitness routing matches against. If you notice a persistent mismatch \u2014 e.g. every `difficult` task lands on a node whose only slot is a cheap model, or a capability a node clearly has isn't declared \u2014 you MAY propose a slot change with `mesh_node_slots_set` (write=false). That returns current-vs-proposed; present that diff to the user with a one-line reason and apply (write=true) ONLY after they approve. It is a WHOLESALE replacement of the node's slots, so include the slots you want to keep. Never rewrite a node's profile silently or without a clear routing reason.\n- **Bootstrap a node's slots from what's actually installed.** When a node has NO slots configured (routing then falls back to \"first available provider\"), or CLI agents were newly installed on it, call `mesh_node_slots_propose({ node_id })` instead of hand-writing a profile. It detects the node's installed CLI agents and drafts a slot list from them \u2014 read-only, it never writes. Present its `proposedSlots` with the `droppedSlots` / `destructive` fields it reports (a wholesale write would delete any existing hand-tuned slot the draft doesn't reproduce, including providers not currently on PATH), then apply with `mesh_node_slots_set({ slots: proposedSlots, write: true })` after approval. It flags `unknownProvider` / `provisional` slots whose placement is a conservative guess rather than an attested one \u2014 call those out rather than presenting them as settled.\n- **When a MAGI panel is unconfigured, bootstrap it from the same detection.** `mesh_magi_review({ task_kind })` resolves its panel SOLELY from the configured kind-panel binding, so a task_kind with no slots fails outright with `magi_kind_not_configured` \u2014 MAGI is simply unavailable until someone binds it, and the usual reason nobody has is that this path is easy to miss. Pass `mesh_node_slots_propose({ node_id, include_magi: true })` to also get a `magiPanel` draft: one slot per DISTINCT detected provider, with no model pinned, because a panel's value is cross-provider independence rather than picking the best provider. It is read-only like the rest of the tool. Apply it per kind with `mesh_magi_kind_panel_set({ task_kind, slots, write: true })` after approval \u2014 and note that write is a WHOLESALE replacement of that kind's binding, so present the dry-run's `currentSlots` first. Do NOT reach for `include_magi` on every slot proposal; it is for when the panels are actually empty or a newly installed provider should join them.\n- **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.\n- **Verify via git, not source.** Use `mesh_git_status` to confirm side effects. Treat agent summaries as self-reports, not verification.\n- **Match concurrency to task kind.** Independent read-only tasks (`live_debug_readonly`) dispatch all at once up to the read-only cap \u2014 no worktree, no free node needed. Each write task needs its OWN branch workspace (Workflow 3.b0); spreading writes across base nodes is NOT a substitute: a mesh with four base nodes still has zero branch isolation. Ramp up cautiously only when tasks share a base branch or submodule pointer (landing order matters). Never launch a second session onto in-flight work for the same issue, even when `mesh_read_chat` shows no final message yet \u2014 successive stages of one investigation stay in their session (see Workflow 3f).\n- **Check history first.** Call `mesh_task_history` at session start to avoid duplicate work and inform recovery. On failure, read task history before retrying.\n- **Don't reopen already-done work after a resume.** Before reopening a reported issue after context compaction or session resume, check current git state and recent session context. If another session has already completed the work, continue from the existing diff/commit instead of starting a duplicate investigation.\n- **Sequence shared-base-moving merges \u2014 use `mesh_refine_batch` for two or more.** Merging one worktree advances another in-flight worktree's base \u2014 especially a shared submodule pointer \u2014 turning a clean fast-forward into a diverged rebase. When you have 2+ sibling worktrees to land, pass them to `mesh_refine_batch` (dry-run first) instead of calling `mesh_refine_node` once per node: it picks a conflict-aware order (non-submodule first, submodule-touching serialized last), and because each node re-resolves the base and auto-rebases before its own gates, siblings that fall behind are rebased for you rather than by hand. It also avoids the `base_locked` contention that concurrent single-node refines cause. It is not a conflict solver \u2014 a real content or submodule conflict still lands that node in `blocked_review` for manual resolution while the rest of the batch proceeds. Only drop to per-node `mesh_refine_node` for a single branch, or to hand-resolve a node the batch reported blocked.\n- **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`.\n- **Refinery is config-driven.** `mesh_refine_node` must run validation from `.adhdev/refine.{json,yaml,yml}` or `repo-mesh.refine.*`. Heuristics are scaffolding only.\n- **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`.\n- **Honor per-node instructions.** When a node carries a \u{1F4CC} Node instruction in the nodes section, include the relevant parts of that instruction in the task message you send to that node. Don't paraphrase the instruction into your own words \u2014 quote it verbatim so the worker agent sees exactly what the user wrote.\n- **Mission status does not update itself.** When a mission's tasks are all done or the work is abandoned, explicitly call `mesh_mission_upsert` to set status `completed` or `abandoned`. Never leave a finished mission in `active`. All-cancelled tasks with no further work \u2192 `abandoned`.\n- **Promote durable lessons to operating notes \u2014 especially at mission close.** Before calling `mesh_mission_upsert` with status `completed`/`abandoned`, ask whether this mission taught something a future coordinator needs (a provider quirk, a pattern to avoid, a recovery lesson); if so, call `mesh_record_note` FIRST \u2014 a mission's goal/history is invisible to the next coordinator once it completes, so an unrecorded lesson is lost at exactly the moment it was learned. Record only when all three hold: (a) a coordinator on another day or another session would act differently knowing it, (b) it cannot be rediscovered from code, config, or `git log`, and (c) it is not a one-off detail specific to this single mission. Note that operating notes reach the COORDINATOR prompt only \u2014 they are never injected into delegated worker sessions, so a convention workers must follow belongs in a CI gate or the repo's agent instructions file, not in a note.\n- **Don't spawn a nested coordinator for simple inspection.** Do not spawn a nested coordinator-like agent for simple inspection tasks. If delegation is required, use explicit provider selection and a fully self-contained, bounded task instruction.\n- **Keep internal traffic out of the transcript.** Internal tool calls, status events, control messages, and debug output must not appear as ordinary user-visible chat transcript content unless explicitly marked user-facing by the producing agent.\n- **Never fabricate tool results.** Always call the actual tool.\n- **Keep the user informed.** One or two sentences after each delegation round.\n- **`gated_by` alone does not branch on outcome.** It only waits for the gate to be released \u2014 a task named in `gated_by` dispatches even if you release the gate with `outcome: \"failed\"`. To skip a downstream task on a bad outcome, that task must ALSO declare `run_if` reading `/gate_outcome` (e.g. `{ from: \"<gateRef>\", select: \"/gate_outcome\", op: \"eq\", value: \"passed\" }`). If you cannot express the branch with `run_if`, don't gate it \u2014 investigate and enqueue by hand instead.\n- **Verify a mission goal's claims before dispatching on them.** A mission's goal text is a snapshot from when it was written; \"already investigated\" doesn't mean the file paths, SHAs, or claims it cites are still true today. Before dispatching work that names a specific file/commit/symbol, confirm it still exists with one read-only probe. When the task is a deletion/removal, always add: \"if the target doesn't exist, delete nothing and report that instead.\"\n- **Close missions yourself \u2014 don't wait on passive signals.** `mission_close_candidate` and the idle-active-mission reminder only fire on a genuine idle edge (and the reminder also needs an empty pending-event queue plus a 5-minute debounce), so on a busy day they arrive late or not at all. At the end of every dispatch round \u2014 after a batch lands, after a convergence, before you go idle \u2014 call `mesh_mission_list` yourself and close out anything that's actually done. An `active` mission with no remaining work is a debt, not a state to wait out.\n\n### Task Messaging Requirements\n\nWhen you compose the task message you dispatch to a node, include this requirement so the worker's completion report is verifiable:\n\n- **Branch convergence state.** For a worktree task, require the completion report to classify the touched branch into exactly one final state: `merged_to_main`, `pushed_feature_branch_needs_merge`, `blocked_review`, `cleanup_candidate`, or `not_mergeable`. A task that ends on a non-main branch is not complete unless the report names that state and the next step.\n";
       }
     });
     function resolveCoordinatorRules(meshBaseWorkspace) {
@@ -51628,11 +51628,11 @@ The instruction it carried was never delivered to anyone. If it still matters, r
       }
     });
     function assertTopic(topic) {
-      if (typeof topic !== "string" || !TOPIC_RE.test(topic))
+      if (typeof topic !== "string" || !TOPIC_RE.test(topic) || topic === RESERVED_NAME)
         throw new SeqscribeError("ERR_ENTRY_ENCODING", `invalid topic: ${String(topic)}`);
     }
     function assertWriter(writer) {
-      if (typeof writer !== "string" || !WRITER_RE.test(writer))
+      if (typeof writer !== "string" || !WRITER_RE.test(writer) || writer === RESERVED_NAME)
         throw new SeqscribeError("ERR_ENTRY_ENCODING", `invalid writer: ${String(writer)}`);
     }
     function assertNonNegSafeInt(n, name) {
@@ -51722,6 +51722,7 @@ The instruction it carried was never delivered to anyone. If it still matters, r
     var WRITER_RE;
     var MAX_KEY_BYTES;
     var CHAIN_RE;
+    var RESERVED_NAME;
     var MAX_NUMERIC_FIELD;
     var init_codec = __esm2({
       "../../vendor/seqscribe/dist/codec.js"() {
@@ -51733,6 +51734,7 @@ The instruction it carried was never delivered to anyone. If it still matters, r
         WRITER_RE = /^[A-Za-z0-9_.:-]{1,128}$/;
         MAX_KEY_BYTES = 512;
         CHAIN_RE = /^[0-9a-f]{64}$/;
+        RESERVED_NAME = "__proto__";
         MAX_NUMERIC_FIELD = Number.MAX_SAFE_INTEGER;
       }
     });
@@ -57927,6 +57929,9 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         retention: { mode: "full" },
         replication: "full-sync",
         access: "content",
+        // P27 derives pre-write hints directly from the register fold. Hash
+        // mode keeps authored setting keys off the Beacon board.
+        hintKeys: "hash",
         finalityAuthority: ADHDEV_AUTHORITY_ID,
         conflict: {
           default: "lww",
@@ -58108,6 +58113,22 @@ CREATE TABLE IF NOT EXISTS sq_archive (
       counters.extraInShadow += extra;
       counters.fieldMismatch += field2;
       counters.mismatches += result.mismatches.length;
+      counters.persistentMismatches += extra + field2;
+      const previouslyMissing = pendingMissing.get(meshId) ?? /* @__PURE__ */ new Set();
+      const stillMissing = /* @__PURE__ */ new Set();
+      for (const m of result.mismatches) {
+        if (m.kind !== "missing_in_shadow") continue;
+        stillMissing.add(m.id);
+        if (previouslyMissing.has(m.id)) {
+          counters.persistentMismatches++;
+          LOG2.warn(
+            "Seqscribe",
+            `parity mismatch PERSISTED across sweeps mesh=${meshId} entry=${shortId(m.id)} ledgerKind=${m.ledgerKind ?? "unknown"} \u2014 the backfill did not repair it; the mesh read cutover stays on the ledger`
+          );
+        }
+      }
+      if (stillMissing.size > 0) pendingMissing.set(meshId, stillMissing);
+      else pendingMissing.delete(meshId);
       if (result.mismatches.length > 0) {
         for (const m of result.mismatches.slice(0, MISMATCH_LOG_CAP)) {
           LOG2.info(
@@ -58133,10 +58154,13 @@ CREATE TABLE IF NOT EXISTS sq_archive (
       counters.extraInShadow = 0;
       counters.fieldMismatch = 0;
       counters.mismatches = 0;
+      counters.persistentMismatches = 0;
       counters.runs = 0;
+      pendingMissing.clear();
     }
     var PARITY_CONSUMER;
     var counters;
+    var pendingMissing;
     var SHADOW_SCAN_PAGE;
     var SHADOW_SCAN_MAX_PAGES;
     var MISMATCH_LOG_CAP;
@@ -58153,8 +58177,10 @@ CREATE TABLE IF NOT EXISTS sq_archive (
           extraInShadow: 0,
           fieldMismatch: 0,
           mismatches: 0,
+          persistentMismatches: 0,
           runs: 0
         };
+        pendingMissing = /* @__PURE__ */ new Map();
         SHADOW_SCAN_PAGE = 500;
         SHADOW_SCAN_MAX_PAGES = 200;
         MISMATCH_LOG_CAP = 20;
@@ -58462,12 +58488,12 @@ CREATE TABLE IF NOT EXISTS sq_archive (
     });
     function resolveMeshDualWriteMode(env2 = process.env) {
       const raw = env2[MESH_DUAL_WRITE_ENV]?.trim().toLowerCase();
-      if (!raw) return "shadow";
+      if (!raw) return "primary";
       if (raw === "off") return "off";
       if (raw === "shadow") return "shadow";
       if (raw === "primary") return "primary";
       warnOnce2(
-        `unrecognized ${MESH_DUAL_WRITE_ENV}=${raw}; treating as 'shadow' (reads stay on the ledger). Valid values are 'shadow' (default), 'primary' and 'off'.`
+        `unrecognized ${MESH_DUAL_WRITE_ENV}=${raw}; treating as 'shadow' (reads stay on the ledger). Valid values are 'primary' (the default when unset), 'shadow' and 'off'.`
       );
       return "shadow";
     }
@@ -58759,7 +58785,9 @@ CREATE TABLE IF NOT EXISTS sq_archive (
       if (!isConsumerCaughtUp(node, topic, meshId, consumerName)) {
         return { ready: false, reason: "consumer_lag" };
       }
-      if (meshParityCounters().mismatches > 0) return { ready: false, reason: "parity_mismatch" };
+      if (meshParityCounters().persistentMismatches > 0) {
+        return { ready: false, reason: "parity_mismatch" };
+      }
       return { ready: true, reason: null };
     }
     function isMeshReadModelReady(meshId) {
@@ -68560,7 +68588,7 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
             allowAutoPublishSubmoduleMainCommits: {
               type: "boolean",
               default: false,
-              description: "When true, Refinery may non-force publish submodule gitlink commits referenced by the refined root tree to each submodule origin/main after validation and patch-equivalence pass, then verify reachability."
+              description: "When true, Refinery may non-force publish submodule gitlink commits referenced by the refined root tree to each submodule's configured default branch after validation and patch-equivalence pass, then verify reachability."
             },
             validation: {
               type: "object",
@@ -69149,261 +69177,945 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
         OUTPUT_SUMMARY_CHARS = 2e3;
       }
     });
-    var mesh_coordinator_exports = {};
-    __export2(mesh_coordinator_exports, {
-      applyMeshCoordinatorSystemPromptInjection: () => applyMeshCoordinatorSystemPromptInjection,
-      buildMeshCoordinatorRegistrationPlan: () => buildMeshCoordinatorRegistrationPlan,
-      cleanupCoordinatorAgentFile: () => cleanupCoordinatorAgentFile,
-      createHermesManualMeshCoordinatorSetup: () => createHermesManualMeshCoordinatorSetup,
-      execUnderPty: () => execUnderPty,
-      inspectMeshCoordinatorMcpServerPaths: () => inspectMeshCoordinatorMcpServerPaths,
-      resolveMeshCoordinatorSetup: () => resolveMeshCoordinatorSetup,
-      stripCoordinatorWrapperFile: () => stripCoordinatorWrapperFile
-    });
-    function isHermesProvider(provider, cliType) {
-      const type2 = cliType?.trim() || provider?.type?.trim() || "";
-      return type2 === HERMES_CLI_TYPE;
+    function writeConfigFile(workspace, relativePath, config2) {
+      const target = (0, import_path11.join)(workspace, relativePath);
+      (0, import_fs13.mkdirSync)((0, import_path11.dirname)(target), { recursive: true });
+      (0, import_fs13.writeFileSync)(target, `${JSON.stringify(config2, null, 2)}
+`, "utf-8");
+      return target;
     }
-    function resolveHermesMeshCoordinatorSetup(options) {
-      const mcpServer = resolveAdhdevMcpServerLaunch({
-        meshId: options.meshId,
-        adhdevMcpCommand: options.adhdevMcpCommand,
-        adhdevMcpEntryPath: options.adhdevMcpEntryPath,
-        nodeExecutable: options.nodeExecutable,
-        adhdevMcpTransport: options.adhdevMcpTransport,
-        adhdevMcpPort: options.adhdevMcpPort
-      });
-      if (!mcpServer) {
-        return {
-          kind: "unsupported",
-          reason: "Could not resolve the ADHDev MCP server entrypoint and a Node runtime with WebSocket support for daemon IPC mode"
-        };
+    function suggestMeshWorktreeBootstrapConfig(workspace) {
+      const commands = [];
+      const hasPackageJson = (0, import_fs13.existsSync)((0, import_path11.join)(workspace, "package.json"));
+      const hasNpmLock = (0, import_fs13.existsSync)((0, import_path11.join)(workspace, "package-lock.json"));
+      if (hasPackageJson) {
+        commands.push(
+          hasNpmLock ? { command: "npm", args: ["ci"] } : { command: "npm", args: ["install"] }
+        );
       }
-      const configPath = (0, import_node_path3.join)(resolveHermesCoordinatorHome(options.meshId, options.workspace), "config.yaml");
-      if (!configPath.trim()) {
-        return createHermesManualMeshCoordinatorSetup(options.meshId, options.workspace);
+      const staleInputs = CANDIDATE_STALE_INPUTS.filter((relative8) => (0, import_fs13.existsSync)((0, import_path11.join)(workspace, relative8)));
+      if (!commands.length) {
+        return { commands, staleInputs };
       }
       return {
-        kind: "auto_import",
-        serverName: DEFAULT_SERVER_NAME,
-        configPath,
-        configFormat: "hermes_config_yaml",
-        mcpServer
+        commands,
+        staleInputs,
+        suggestedConfig: {
+          version: 1,
+          enabled: true,
+          runOnClone: true,
+          required: false,
+          commands,
+          ...staleInputs.length ? { staleInputs } : {}
+        }
       };
     }
-    function createHermesManualMeshCoordinatorSetup(meshId, workspace) {
+    function suggestNodeProviderPriority(detected) {
+      const installed = detected.filter((cli) => cli.installed);
+      const installedIds = installed.map((cli) => cli.id);
+      const preferred = PROVIDER_PRIORITY_PREFERENCE.filter((id) => installedIds.includes(id));
+      const rest = installedIds.filter((id) => !preferred.includes(id));
+      const providerPriority = [...preferred, ...rest];
       return {
-        kind: "manual",
-        serverName: DEFAULT_SERVER_NAME,
-        configFormat: "hermes_config_yaml",
-        configPathCommand: HERMES_MCP_CONFIG_PATH,
-        requiresRestart: true,
-        instructions: "Hermes CLI does not auto-import repo-local .mcp.json. Add this MCP server to Hermes config under mcp_servers, then start a fresh Hermes session.",
-        template: renderMeshCoordinatorTemplate(
-          "mcp_servers:\n  {{serverName}}:\n    command: {{adhdevMcpCommand}}\n    args:\n      - mcp\n      - --mode\n      - ipc\n      - --repo-mesh\n      - {{meshId}}\n    enabled: true\n",
-          {
-            meshId,
-            workspace,
-            serverName: DEFAULT_SERVER_NAME,
-            adhdevMcpCommand: DEFAULT_ADHDEV_MCP_COMMAND
-          }
-        )
+        providerPriority,
+        installedProviders: installed.map((cli) => ({
+          id: cli.id,
+          displayName: cli.displayName,
+          ...cli.version ? { version: cli.version } : {}
+        }))
       };
     }
-    function resolveMeshCoordinatorSetup(options) {
-      const { provider, meshId, workspace } = options;
-      const config2 = provider?.meshCoordinator;
-      if (!config2?.supported) {
-        return {
-          kind: "unsupported",
-          reason: config2?.reason || "Provider does not declare Repo Mesh coordinator support"
-        };
+    function runMeshInit(mesh, workspace, detected, options = {}) {
+      const write = options.write === true;
+      const overwrite = options.overwrite === true;
+      const refine2 = applyConfigSuggestion({
+        workspace,
+        relativePath: MESH_INIT_REFINE_CONFIG_PATH,
+        existing: loadMeshRefineConfig(mesh, workspace).config,
+        suggestedConfig: suggestMeshRefineConfig(mesh, workspace).suggestedConfig,
+        validate: (config2) => validateMeshRefineConfig(config2, MESH_INIT_REFINE_CONFIG_PATH).valid,
+        write,
+        overwrite
+      });
+      const bootstrapSuggestion = suggestMeshWorktreeBootstrapConfig(workspace);
+      const worktreeBootstrap = applyConfigSuggestion({
+        workspace,
+        relativePath: MESH_INIT_WORKTREE_BOOTSTRAP_CONFIG_PATH,
+        existing: loadMeshWorktreeBootstrapConfig(mesh, workspace).config,
+        suggestedConfig: bootstrapSuggestion.suggestedConfig,
+        validate: (config2) => validateMeshWorktreeBootstrapConfig(config2, MESH_INIT_WORKTREE_BOOTSTRAP_CONFIG_PATH).valid,
+        write,
+        overwrite
+      });
+      const changeImpactLoaded = loadChangeImpactConfig(workspace);
+      const changeImpact = applyConfigSuggestion({
+        workspace,
+        relativePath: MESH_INIT_CHANGE_IMPACT_CONFIG_PATH,
+        existing: changeImpactLoaded.sourceType === "repo_file" ? changeImpactLoaded.config : void 0,
+        suggestedConfig: suggestChangeImpactConfig(workspace).suggestedConfig,
+        validate: (config2) => validateChangeImpactConfig(config2, MESH_INIT_CHANGE_IMPACT_CONFIG_PATH).valid,
+        write,
+        overwrite
+      });
+      const providers = suggestNodeProviderPriority(detected);
+      const refineLoaded = loadMeshRefineConfig(mesh, workspace);
+      const bootstrapLoaded = loadMeshWorktreeBootstrapConfig(mesh, workspace);
+      let magiKindPanels = {};
+      try {
+        magiKindPanels = listMagiKindPanelsReadOnly(typeof mesh?.id === "string" ? mesh.id : void 0);
+      } catch {
+        magiKindPanels = {};
       }
-      if (isHermesProvider(provider, options.cliType)) {
-        return resolveHermesMeshCoordinatorSetup(options);
+      const currentConfig2 = {
+        refine: refineLoaded.config,
+        worktreeBootstrap: bootstrapLoaded.config,
+        changeImpact: changeImpactLoaded.sourceType === "repo_file" ? changeImpactLoaded.config : void 0,
+        sourceTypes: {
+          refine: refineLoaded.sourceType,
+          worktreeBootstrap: bootstrapLoaded.sourceType,
+          changeImpact: changeImpactLoaded.sourceType
+        },
+        magiKindPanels
+      };
+      return {
+        success: true,
+        workspace,
+        dryRun: !write,
+        refine: refine2,
+        worktreeBootstrap,
+        changeImpact,
+        providers,
+        currentConfig: currentConfig2,
+        note: write ? "Configs written to disk are the execution source of truth; suggestions are scaffold and only take effect once saved. providerPriority is a recommendation \u2014 apply it to node policy via clone/policy update. currentConfig echoes what was on disk before this run." : "Dry-run: no files written. Re-run with write=true to persist the suggested configs. Heuristic suggestions never execute until saved as repo config. Use currentConfig to diff current-vs-suggested before overwriting."
+      };
+    }
+    function applyConfigSuggestion(input) {
+      const { workspace, relativePath, existing, suggestedConfig, validate, write, overwrite } = input;
+      const absolute = (0, import_path11.join)(workspace, relativePath);
+      if (existing !== void 0 && !overwrite) {
+        return { path: absolute, relativePath, written: false, skippedReason: "already_exists", config: existing };
       }
-      const mcpConfig = config2.mcpConfig;
-      if (!mcpConfig || mcpConfig.mode === "none") {
-        return {
-          kind: "unsupported",
-          reason: config2.reason || "Provider does not declare a usable Repo Mesh MCP configuration mode"
-        };
+      if (!suggestedConfig || !validate(suggestedConfig)) {
+        return { path: absolute, relativePath, written: false, skippedReason: "no_suggestion" };
       }
-      const serverName = mcpConfig.serverName?.trim() || DEFAULT_SERVER_NAME;
-      if (mcpConfig.mode === "auto_import") {
-        const path63 = mcpConfig.path?.trim();
-        if (!path63) {
-          return { kind: "unsupported", reason: "Provider auto-import MCP config is missing a config path" };
-        }
-        const mcpServer = resolveAdhdevMcpServerLaunch({
-          meshId,
-          adhdevMcpCommand: options.adhdevMcpCommand,
-          adhdevMcpEntryPath: options.adhdevMcpEntryPath,
-          nodeExecutable: options.nodeExecutable,
-          adhdevMcpTransport: options.adhdevMcpTransport,
-          adhdevMcpPort: options.adhdevMcpPort
-        });
-        if (!mcpServer) {
-          return {
-            kind: "unsupported",
-            reason: "Could not resolve the ADHDev MCP server entrypoint and a Node runtime with WebSocket support for daemon IPC mode"
-          };
-        }
-        return {
-          kind: "auto_import",
-          serverName,
-          configPath: resolveMcpConfigPath(path63, workspace),
-          configFormat: mcpConfig.format,
-          mcpServer
-        };
+      if (!write) {
+        return { path: absolute, relativePath, written: false, config: suggestedConfig };
       }
-      if (mcpConfig.mode === "manual") {
-        const instructions = mcpConfig.instructions?.trim();
-        const template = mcpConfig.template;
-        if (!instructions || !template?.trim()) {
-          return { kind: "unsupported", reason: "Provider manual MCP setup is missing instructions or template" };
-        }
-        const mcpServer = resolveAdhdevMcpServerLaunch({
-          meshId,
-          adhdevMcpCommand: options.adhdevMcpCommand,
-          adhdevMcpEntryPath: options.adhdevMcpEntryPath,
-          nodeExecutable: options.nodeExecutable,
-          adhdevMcpTransport: options.adhdevMcpTransport,
-          adhdevMcpPort: options.adhdevMcpPort
+      const writtenPath = writeConfigFile(workspace, relativePath, suggestedConfig);
+      return { path: writtenPath, relativePath, written: true, config: suggestedConfig };
+    }
+    var import_fs13;
+    var import_path11;
+    var MESH_INIT_REFINE_CONFIG_PATH;
+    var MESH_INIT_WORKTREE_BOOTSTRAP_CONFIG_PATH;
+    var MESH_INIT_CHANGE_IMPACT_CONFIG_PATH;
+    var CANDIDATE_STALE_INPUTS;
+    var PROVIDER_PRIORITY_PREFERENCE;
+    var init_mesh_init = __esm2({
+      "src/mesh/mesh-init.ts"() {
+        "use strict";
+        import_fs13 = require("fs");
+        import_path11 = require("path");
+        init_refine_config();
+        init_worktree_bootstrap_config();
+        init_change_impact_config();
+        init_mesh_config();
+        MESH_INIT_REFINE_CONFIG_PATH = MESH_REFINE_CONFIG_LOCATIONS[0];
+        MESH_INIT_WORKTREE_BOOTSTRAP_CONFIG_PATH = MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS[0];
+        MESH_INIT_CHANGE_IMPACT_CONFIG_PATH = CHANGE_IMPACT_CONFIG_LOCATIONS[0];
+        CANDIDATE_STALE_INPUTS = [
+          "package-lock.json",
+          "pnpm-lock.yaml",
+          "yarn.lock",
+          "bun.lockb",
+          "Cargo.lock",
+          "go.sum",
+          "poetry.lock",
+          "requirements.txt"
+        ];
+        PROVIDER_PRIORITY_PREFERENCE = ["claude-cli", "codex-cli", "gemini-cli"];
+      }
+    });
+    var mesh_onboarding_plan_exports = {};
+    __export2(mesh_onboarding_plan_exports, {
+      planMeshOnboarding: () => planMeshOnboarding,
+      resolveRootDefaultBranch: () => resolveRootDefaultBranch
+    });
+    async function git(cwd, args, allowFailure = false) {
+      try {
+        const { stdout } = await execFileAsync3("git", args, {
+          cwd,
+          encoding: "utf8",
+          timeout: GIT_TIMEOUT_MS2,
+          maxBuffer: 4 * 1024 * 1024,
+          windowsHide: true,
+          env: gitChildEnv()
         });
-        if (!mcpServer) {
-          return {
-            kind: "unsupported",
-            reason: "Could not resolve the ADHDev MCP server entrypoint and transport arguments"
-          };
+        return (stdout || "").trim();
+      } catch (error48) {
+        if (allowFailure) return "";
+        const stderr = typeof error48?.stderr === "string" ? error48.stderr.trim() : "";
+        throw new Error(stderr || error48?.message || `git ${args[0]} failed`);
+      }
+    }
+    async function canonicalPath(path63) {
+      const absolute = (0, import_node_path2.resolve)(path63);
+      try {
+        return await (0, import_promises5.realpath)(absolute);
+      } catch {
+        return absolute;
+      }
+    }
+    function pathInside(child, parent) {
+      const rel = (0, import_node_path2.relative)(parent, child);
+      return rel !== "" && rel !== ".." && !rel.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) && !(0, import_node_path2.isAbsolute)(rel);
+    }
+    function failure2(code, error48, action, extra = {}) {
+      return { success: false, dryRun: true, code, error: error48, action, ...extra };
+    }
+    function isPlanFailure(value) {
+      return value.success === false;
+    }
+    function parseStatus(raw) {
+      const lines = raw.split(/\r?\n/).filter((line) => line && !line.startsWith("# "));
+      const conflictFiles = [];
+      for (const line of lines) {
+        if (line.startsWith("u ")) {
+          const fields = line.split(" ");
+          conflictFiles.push(fields.slice(10).join(" ") || fields.at(-1) || "(unknown)");
+          continue;
         }
-        let renderedTemplate = renderMeshCoordinatorTemplate(template, {
-          meshId,
-          workspace,
-          serverName,
-          adhdevMcpCommand: mcpServer.command,
-          adhdevMcpArgs: mcpServer.args.join(" ")
-        });
-        const isCliCommand = !renderedTemplate.trim().includes("\n") && !renderedTemplate.trim().startsWith("{");
-        if (isCliCommand) {
-          if (!/\{\{\s*adhdevMcpArgs\s*\}\}/.test(template)) {
-            renderedTemplate = replaceLegacyCliCommandMcpArgs(renderedTemplate, mcpServer.args);
+        if (line.startsWith("1 ") || line.startsWith("2 ")) {
+          const xy = line.slice(2, 4);
+          if (["DD", "AU", "UD", "UA", "DU", "AA", "UU"].includes(xy)) {
+            conflictFiles.push(line.split(" ").at(-1) || "(unknown)");
           }
-          return {
-            kind: "cli_command",
-            serverName,
-            command: renderedTemplate.trim(),
-            requiresRestart: mcpConfig.requiresRestart === true,
-            instructions,
-            mcpServer
-          };
         }
-        return {
-          kind: "manual",
-          serverName,
-          configFormat: mcpConfig.format,
-          configPathCommand: mcpConfig.configPathCommand,
-          requiresRestart: mcpConfig.requiresRestart === true,
-          instructions,
-          template: renderedTemplate
-        };
       }
       return {
-        kind: "unsupported",
-        reason: `Unsupported Repo Mesh MCP configuration mode: ${String(mcpConfig.mode)}`
+        dirty: lines.length > 0,
+        changedFileCount: lines.length,
+        hasConflicts: conflictFiles.length > 0,
+        conflictFiles
       };
     }
-    function renderMeshCoordinatorTemplate(template, values) {
-      return template.replace(/\{\{\s*(meshId|workspace|serverName|adhdevMcpCommand|adhdevMcpArgs)\s*\}\}/g, (_, key2) => values[key2] || "");
+    async function discoverRemotes(repoRoot, currentBranch) {
+      const names = (await git(repoRoot, ["remote"], true)).split(/\r?\n/).map((v) => v.trim()).filter(Boolean);
+      const remotes = [];
+      for (const name of names) {
+        const urls = (await git(repoRoot, ["remote", "get-url", "--all", name], true)).split(/\r?\n/).map((v) => v.trim()).filter(Boolean);
+        const identities2 = [...new Set(urls.map(normalizeRepoIdentity).filter(Boolean))];
+        remotes.push({ name, urls, identities: identities2 });
+      }
+      const origin = remotes.find((remote) => remote.name === "origin");
+      const trackingRemoteName = await git(repoRoot, ["config", "--get", `branch.${currentBranch}.remote`], true);
+      const upstream = remotes.find((remote) => remote.name === trackingRemoteName) || remotes.find((remote) => remote.name === "upstream");
+      const identities = [...new Set(remotes.flatMap((remote) => remote.identities))];
+      const selectedRemote = origin || upstream || (remotes.length === 1 ? remotes[0] : void 0);
+      return {
+        remotes,
+        origin,
+        upstream,
+        selectedRemote,
+        ambiguous: identities.length > 1 || !!remotes.find((remote) => remote.identities.length > 1)
+      };
     }
-    function replaceLegacyCliCommandMcpArgs(command, args) {
-      return command.replace(
-        /\bmcp\s+--mode\s+(?:ipc|local)\s+--repo-mesh\s+\S+(?:\s+--port\s+\d+)?\s*$/,
-        args.join(" ")
-      );
+    async function deriveLocalRepoIdentity(repoRoot) {
+      const raw = await git(repoRoot, ["rev-list", "--max-parents=0", "HEAD"], true);
+      const roots = raw.split(/\r?\n/).map((line) => line.trim()).filter((line) => /^[0-9a-f]{40}$/i.test(line)).sort();
+      const root = roots[0];
+      return root ? `local/${root.toLowerCase()}` : "";
     }
-    function resolveHermesCoordinatorHome(meshId, workspace) {
-      const key2 = `${meshId || "mesh"}
-${(0, import_node_path3.resolve)(workspace || os13.tmpdir())}`;
-      const hash2 = shortHash(key2);
-      return (0, import_node_path3.join)(os13.tmpdir(), `adhdev-hermes-mesh-coordinator-${hash2}`);
+    async function resolveDefaultBranch(repoRoot, remoteName, currentBranch) {
+      const symbolic = await git(repoRoot, ["symbolic-ref", "--quiet", "--short", `refs/remotes/${remoteName}/HEAD`], true);
+      if (symbolic.startsWith(`${remoteName}/`)) return symbolic.slice(remoteName.length + 1);
+      for (const candidate of ["main", "master"]) {
+        const exists = await git(repoRoot, ["rev-parse", "--verify", "--quiet", `refs/remotes/${remoteName}/${candidate}`], true) || await git(repoRoot, ["rev-parse", "--verify", "--quiet", `refs/heads/${candidate}`], true);
+        if (exists) return candidate;
+      }
+      return currentBranch;
     }
-    function resolveMcpConfigPath(configPath, workspace) {
-      const trimmed = configPath.trim();
-      if (trimmed === "~") return os13.homedir();
-      if (trimmed.startsWith("~/")) return (0, import_node_path3.join)(os13.homedir(), trimmed.slice(2));
-      if ((0, import_node_path3.isAbsolute)(trimmed)) return trimmed;
-      return (0, import_node_path3.join)(workspace, trimmed);
+    async function resolveRootDefaultBranch(repoRoot, mesh, opts = {}) {
+      const meshDefault = typeof mesh?.defaultBranch === "string" ? mesh.defaultBranch.trim() : "";
+      if (meshDefault) return meshDefault;
+      const remote = opts.remote?.trim() || "origin";
+      const symbolic = await git(repoRoot, ["symbolic-ref", "--quiet", "--short", `refs/remotes/${remote}/HEAD`], true);
+      if (symbolic.startsWith(`${remote}/`)) return symbolic.slice(remote.length + 1);
+      const currentBranch = await git(repoRoot, ["symbolic-ref", "--quiet", "--short", "HEAD"], true);
+      return currentBranch || "main";
     }
-    function resolveAdhdevMcpServerLaunch(options) {
-      const directEntryPath = resolveAdhdevMcpEntryPath(options.adhdevMcpEntryPath);
-      if (directEntryPath) {
-        const transport2 = resolveMcpTransport(options.adhdevMcpTransport);
-        const args2 = [directEntryPath, "--mode", transport2, "--repo-mesh", options.meshId];
-        const port2 = resolveMcpPort(options.adhdevMcpPort);
-        if (port2 !== void 0) args2.push("--port", String(port2));
-        return {
-          command: resolveNodeExecutable(options.nodeExecutable),
-          args: args2
-        };
+    async function discoverGit(workspaceInput) {
+      const workspace = await canonicalPath(workspaceInput || process.cwd());
+      const repoRootRaw = await git(workspace, ["rev-parse", "--show-toplevel"], true);
+      if (!repoRootRaw) {
+        return failure2(
+          "not_git_repository",
+          `Not a Git repository: ${workspace}`,
+          "Choose a directory inside a Git checkout, or initialize/clone the repository before planning Repo Mesh onboarding."
+        );
       }
-      const command = resolveAdhdevCommand(options.adhdevMcpCommand);
-      const transport = resolveMcpTransport(options.adhdevMcpTransport);
-      const directMcpEntrypoint = (0, import_node_path3.basename)(command).startsWith("adhdev-mcp") || command.includes("/vendor/mcp-server/") || command.includes("\\vendor\\mcp-server\\");
-      const args = [...directMcpEntrypoint ? [] : ["mcp"], "--mode", transport, "--repo-mesh", options.meshId];
-      const port = resolveMcpPort(options.adhdevMcpPort);
-      if (port !== void 0) args.push("--port", String(port));
-      return {
-        command,
-        args
+      const repoRoot = await canonicalPath(repoRootRaw);
+      const gitDirRaw = await git(repoRoot, ["rev-parse", "--git-dir"]);
+      const commonDirRaw = await git(repoRoot, ["rev-parse", "--git-common-dir"]);
+      const gitDir = await canonicalPath((0, import_node_path2.isAbsolute)(gitDirRaw) ? gitDirRaw : (0, import_node_path2.resolve)(repoRoot, gitDirRaw));
+      const commonDir = await canonicalPath((0, import_node_path2.isAbsolute)(commonDirRaw) ? commonDirRaw : (0, import_node_path2.resolve)(repoRoot, commonDirRaw));
+      const currentBranch = await git(repoRoot, ["symbolic-ref", "--quiet", "--short", "HEAD"], true);
+      const headCommit = await git(repoRoot, ["rev-parse", "HEAD"], true);
+      const worktrees = await listWorktrees(repoRoot);
+      const canonicalWorktrees = await Promise.all(worktrees.map(async (entry) => ({
+        ...entry,
+        path: await canonicalPath(entry.path)
+      })));
+      const mainWorktreeRoot = canonicalWorktrees[0]?.path || repoRoot;
+      const isMainCheckout = repoRoot === mainWorktreeRoot;
+      const isLinkedWorktree = gitDir !== commonDir;
+      const parentRepoRootRaw = await git((0, import_node_path2.dirname)(repoRoot), ["rev-parse", "--show-toplevel"], true);
+      const parentRepoRoot = parentRepoRootRaw ? await canonicalPath(parentRepoRootRaw) : "";
+      const isNestedWorktree = !!parentRepoRoot && parentRepoRoot !== repoRoot && pathInside(repoRoot, parentRepoRoot);
+      const status = parseStatus(await git(repoRoot, ["status", "--porcelain=v2", "--branch", "--untracked-files=normal"]));
+      const partial2 = {
+        inputPath: workspaceInput,
+        workspace,
+        repoRoot,
+        gitDir,
+        commonDir,
+        mainWorktreeRoot,
+        isMainCheckout,
+        isLinkedWorktree,
+        isNestedWorktree,
+        worktrees: canonicalWorktrees,
+        currentBranch,
+        headCommit,
+        ...status
       };
-    }
-    function resolveAdhdevCommand(explicitCommand) {
-      return explicitCommand?.trim() || process.env.ADHDEV_COORDINATOR_MCP_COMMAND?.trim() || DEFAULT_ADHDEV_MCP_COMMAND;
-    }
-    function inspectMeshCoordinatorMcpServerPaths(mcpServer, options = {}) {
-      const embeddedPaths = [mcpServer.command, ...mcpServer.args].filter((value) => (0, import_node_path3.isAbsolute)(value));
-      if (embeddedPaths.length === 0) {
-        return { state: "absent", referencedPath: null, volatile: false, volatileReason: null, warning: null };
+      if (!currentBranch) {
+        return failure2(
+          "detached_head",
+          `Detached HEAD at ${headCommit.slice(0, 12) || "(unknown commit)"}.`,
+          "Check out a named, safe branch before adding or cloning a Repo Mesh node.",
+          { discovery: partial2 }
+        );
       }
-      let firstMissing = null;
-      let firstVolatile = null;
-      for (const embeddedPath of embeddedPaths) {
-        const health = inspectEmbeddedPath(embeddedPath, options.env ?? process.env);
-        if (health.state === "missing" && !firstMissing) firstMissing = health;
-        if (health.volatile && !firstVolatile) firstVolatile = health;
+      const branchValid = await git(repoRoot, ["check-ref-format", "--branch", currentBranch], true);
+      if (!branchValid) {
+        return failure2(
+          "unsafe_branch",
+          `Current branch is not a safe Git branch name: ${currentBranch}`,
+          "Check out or create a valid named branch, then re-run the onboarding plan.",
+          { discovery: partial2 }
+        );
       }
-      const serverName = options.serverName?.trim() || "adhdev-mesh";
-      const target = options.target?.trim() || `MCP setup for ${serverName}`;
-      const propagationNote = options.repoLocal ? " The config file lives inside the workspace and may be committed \u2014 this machine-specific absolute path would propagate to teammates' machines, where it matches nothing." : "";
-      if (firstMissing) {
-        return {
-          state: "missing",
-          referencedPath: firstMissing.referencedPath,
-          volatile: firstMissing.volatile || Boolean(firstVolatile),
-          volatileReason: firstMissing.volatileReason || firstVolatile?.volatileReason || null,
-          warning: `${target} embeds ${firstMissing.referencedPath}, which does not exist on this machine \u2014 the ${serverName} MCP server will fail to start (dangling reference, the statusline failure class).${propagationNote}`
-        };
+      if (isNestedWorktree) {
+        return failure2(
+          "nested_worktree",
+          `Repository ${repoRoot} is nested inside Git checkout ${parentRepoRoot}.`,
+          "Choose the intended outer checkout or move the nested checkout outside it before Repo Mesh onboarding.",
+          { discovery: partial2 }
+        );
       }
-      if (firstVolatile) {
-        return {
-          state: "ok",
-          referencedPath: firstVolatile.referencedPath,
-          volatile: true,
-          volatileReason: firstVolatile.volatileReason,
-          warning: `${target} embeds ${firstVolatile.referencedPath}, which is ${firstVolatile.volatileReason}. It works today, but the ${serverName} entry will dangle once that location is cleaned up \u2014 the same failure class as the 2026-08-20 statusline incident.${propagationNote}`
-        };
+      if (status.hasConflicts) {
+        return failure2(
+          "conflicted_workspace",
+          `Workspace has unresolved conflicts (${status.conflictFiles.join(", ")}).`,
+          "Resolve or abort the in-progress Git operation before adding this workspace to Repo Mesh.",
+          { discovery: partial2 }
+        );
       }
-      return { state: "ok", referencedPath: embeddedPaths[0], volatile: false, volatileReason: null, warning: null };
-    }
-    function resolveAdhdevMcpEntryPath(explicitEntryPath) {
-      const entryPath = explicitEntryPath?.trim() || process.env.ADHDEV_COORDINATOR_MCP_ENTRY_PATH?.trim();
-      return entryPath || null;
-    }
-    function resolveNodeExecutable(explicitNodeExecutable) {
-      return explicitNodeExecutable?.trim() || process.env.ADHDEV_COORDINATOR_NODE_EXECUTABLE?.trim() || process.execPath;
-    }
-    function resolveMcpTransport(explicitTransport) {
+      const remoteDiscovery = await discoverRemotes(repoRoot, currentBranch);
+      if (!remoteDiscovery.remotes.length) {
+        const localIdentity = await deriveLocalRepoIdentity(repoRoot);
+        if (!localIdentity) {
+          return failure2(
+            "no_commits_for_local_identity",
+            "This repository has no remote and no commits, so a stable repository identity cannot be derived.",
+            "Create at least one commit (the root commit becomes the local identity), or pass an explicit repo identity when creating the mesh.",
+            { discovery: partial2 }
+          );
+        }
+        const localDefaultBranch = await resolveDefaultBranch(repoRoot, "", currentBranch);
+        return {
+          ...partial2,
+          remotes: [],
+          origin: void 0,
+          upstream: void 0,
+          selectedRemote: "",
+          repoIdentity: localIdentity,
+          defaultBranch: localDefaultBranch
+        };
+      }
+      if (!remoteDiscovery.selectedRemote) {
+        const detail = remoteDiscovery.remotes.map((remote) => remote.name).join(", ");
+        return failure2(
+          "remote_not_selected",
+          `No canonical remote could be selected among multiple remotes (${detail}).`,
+          "Name one of them origin or upstream, set the current branch to track one of them, or pass an explicit repo identity when creating the mesh.",
+          { discovery: { ...partial2, remotes: remoteDiscovery.remotes, origin: remoteDiscovery.origin, upstream: remoteDiscovery.upstream } }
+        );
+      }
+      if (remoteDiscovery.ambiguous) {
+        const detail = remoteDiscovery.remotes.map((remote) => `${remote.name}=${remote.identities.join("|") || "(no URL)"}`).join(", ");
+        return failure2(
+          "ambiguous_remotes",
+          `Multiple unrelated remote identities were found: ${detail}`,
+          "Remove the ambiguity or explicitly choose/reconcile the canonical remote before onboarding.",
+          { discovery: { ...partial2, remotes: remoteDiscovery.remotes, origin: remoteDiscovery.origin, upstream: remoteDiscovery.upstream } }
+        );
+      }
+      const repoIdentity = remoteDiscovery.selectedRemote.identities[0];
+      if (!repoIdentity) {
+        return failure2(
+          "remote_not_found",
+          `Remote '${remoteDiscovery.selectedRemote.name}' has no usable URL.`,
+          "Configure a valid fetch URL for the selected remote before onboarding.",
+          { discovery: partial2 }
+        );
+      }
+      const defaultBranch = await resolveDefaultBranch(repoRoot, remoteDiscovery.selectedRemote.name, currentBranch);
+      return {
+        ...partial2,
+        remotes: remoteDiscovery.remotes,
+        origin: remoteDiscovery.origin,
+        upstream: remoteDiscovery.upstream,
+        selectedRemote: remoteDiscovery.selectedRemote.name,
+        repoIdentity,
+        defaultBranch
+      };
+    }
+    async function membershipsFor(discovery, meshes) {
+      const matches = [];
+      for (const mesh of meshes) {
+        const compatible = normalizeRepoIdentity(mesh.repoIdentity) === discovery.repoIdentity;
+        let emittedMesh = false;
+        for (const node of mesh.nodes || []) {
+          const rawWorkspace = (0, import_node_path2.resolve)(node.workspace || "");
+          const canonicalWorkspace = await canonicalPath(rawWorkspace);
+          const canonicalRepoRoot = node.repoRoot ? await canonicalPath(node.repoRoot) : canonicalWorkspace;
+          const exactWorkspace = canonicalWorkspace === discovery.workspace;
+          if (exactWorkspace || canonicalRepoRoot === discovery.repoRoot) {
+            matches.push({
+              meshId: mesh.id,
+              meshName: mesh.name,
+              repoIdentity: normalizeRepoIdentity(mesh.repoIdentity),
+              compatible,
+              nodeId: node.id,
+              nodeWorkspace: node.workspace,
+              exactWorkspace
+            });
+            emittedMesh = true;
+          }
+        }
+        if (compatible && !emittedMesh) {
+          matches.push({
+            meshId: mesh.id,
+            meshName: mesh.name,
+            repoIdentity: normalizeRepoIdentity(mesh.repoIdentity),
+            compatible: true
+          });
+        }
+      }
+      return matches;
+    }
+    function meshSummary(mesh) {
+      return {
+        id: mesh.id,
+        name: mesh.name,
+        repoIdentity: normalizeRepoIdentity(mesh.repoIdentity),
+        defaultBranch: mesh.defaultBranch,
+        nodeCount: mesh.nodes?.length || 0
+      };
+    }
+    function addStep(mesh, discovery) {
+      return {
+        command: "add_mesh_node",
+        description: "Explicitly register this existing checkout as a mesh node.",
+        writes: true,
+        approvalRequired: true,
+        args: {
+          meshId: mesh.id,
+          workspace: discovery.repoRoot,
+          repoRoot: discovery.repoRoot,
+          isLocalWorktree: discovery.isLinkedWorktree
+        }
+      };
+    }
+    function initStep(discovery) {
+      return {
+        command: "mesh_init",
+        description: "Preview suggested .adhdev configuration; persist only in a separate approved write call.",
+        writes: false,
+        approvalRequired: false,
+        args: { workspace: discovery.repoRoot, write: false, overwrite: false }
+      };
+    }
+    async function planMeshOnboarding(options) {
+      const discoveryResult = await discoverGit(options.workspace);
+      if (isPlanFailure(discoveryResult)) return discoveryResult;
+      const discovery = discoveryResult;
+      const operation = options.operation || "auto";
+      const meshes = options.meshes || listMeshesReadOnly();
+      const membership = await membershipsFor(discovery, meshes);
+      const requestedMesh = options.meshId ? meshes.find((mesh) => mesh.id === options.meshId) : void 0;
+      if (options.meshId && !requestedMesh) {
+        return failure2("mesh_not_found", `Mesh not found: ${options.meshId}`, "List meshes and choose an existing mesh id.", { discovery, membership });
+      }
+      if (requestedMesh && normalizeRepoIdentity(requestedMesh.repoIdentity) !== discovery.repoIdentity) {
+        return failure2(
+          "unrelated_repo_identity",
+          `Workspace identity '${discovery.repoIdentity}' does not match mesh '${requestedMesh.name}' identity '${normalizeRepoIdentity(requestedMesh.repoIdentity)}'.`,
+          "Choose a mesh for the same repository, or create a separate mesh for this repository.",
+          { discovery, membership }
+        );
+      }
+      const compatibleMeshes = requestedMesh ? [requestedMesh] : meshes.filter((mesh) => normalizeRepoIdentity(mesh.repoIdentity) === discovery.repoIdentity);
+      if (compatibleMeshes.length > 1) {
+        return failure2(
+          "ambiguous_mesh",
+          `More than one compatible mesh exists for '${discovery.repoIdentity}': ${compatibleMeshes.map((mesh) => `${mesh.name} (${mesh.id})`).join(", ")}`,
+          "Pass an explicit mesh id to select the intended mesh.",
+          { discovery, membership }
+        );
+      }
+      const compatibleMesh = compatibleMeshes[0];
+      const duplicate = membership.find((match) => match.compatible && match.nodeId && (!compatibleMesh || match.meshId === compatibleMesh.id));
+      if (operation !== "clone_worktree" && duplicate) {
+        return failure2(
+          duplicate.exactWorkspace ? "duplicate_workspace" : "duplicate_node",
+          `Workspace is already registered as node '${duplicate.nodeId}' in mesh '${duplicate.meshName}'.`,
+          "Use the existing node, or choose clone_worktree with a new branch for isolated work.",
+          { discovery, membership }
+        );
+      }
+      if (operation === "add_existing" && !compatibleMesh) {
+        return failure2(
+          "mesh_not_found",
+          `No compatible mesh exists for '${discovery.repoIdentity}'.`,
+          "Run the auto/create onboarding plan first, explicitly create the mesh, then add this workspace.",
+          { discovery, membership }
+        );
+      }
+      if (operation === "clone_worktree") {
+        const planWarnings = [];
+        if (!compatibleMesh) {
+          return failure2(
+            "mesh_not_found",
+            `No compatible mesh exists for '${discovery.repoIdentity}'.`,
+            "Create and add the base workspace first, then plan a cloned worktree node.",
+            { discovery, membership }
+          );
+        }
+        const dirtyBehavior = mergeAndNormalizePolicy(compatibleMesh.policy, void 0).dirtyWorkspaceBehavior;
+        if (discovery.dirty && dirtyBehavior === "block") {
+          return failure2(
+            "dirty_workspace",
+            `Workspace has ${discovery.changedFileCount} uncommitted change(s); a cloned worktree would not include them.`,
+            "Commit or stash the changes, then re-run the clone plan. (This mesh's dirtyWorkspaceBehavior is 'block'; set it to 'warn' to allow cloning from a dirty workspace.)",
+            { discovery, membership }
+          );
+        }
+        if (discovery.dirty) {
+          planWarnings.push(
+            `Source workspace has ${discovery.changedFileCount} uncommitted change(s). The new worktree is created from HEAD, so uncommitted changes are NOT included in it \u2014 commit them first if the cloned branch needs them.`
+          );
+        }
+        const branch = (options.branch || "").trim();
+        if (!branch || !await git(discovery.repoRoot, ["check-ref-format", "--branch", branch], true)) {
+          return failure2(
+            "unsafe_branch",
+            branch ? `Requested worktree branch is unsafe: ${branch}` : "A named branch is required to clone a new worktree node.",
+            "Provide a new valid branch name such as feat/my-task.",
+            { discovery, membership }
+          );
+        }
+        const sourceNode = duplicate?.nodeId ? compatibleMesh.nodes.find((node) => node.id === duplicate.nodeId) : compatibleMesh.nodes.find((node) => !!node.workspace);
+        if (!sourceNode) {
+          return failure2(
+            "mesh_not_found",
+            `Mesh '${compatibleMesh.name}' has no source node to clone.`,
+            "Explicitly add this existing workspace as the first node, then clone a worktree.",
+            { discovery, membership }
+          );
+        }
+        const suggestedConfig2 = runMeshInit(compatibleMesh, discovery.repoRoot, options.detectedProviders || []);
+        return {
+          success: true,
+          dryRun: true,
+          discovery,
+          membership,
+          compatibleMesh: meshSummary(compatibleMesh),
+          plan: {
+            kind: "clone_new_worktree",
+            summary: `Create an isolated worktree node from '${sourceNode.id}' on branch '${branch}'.`,
+            // Only a 'block' mesh actually requires a clean source; under the
+            // default 'warn' a dirty workspace is advisory, so reporting true here
+            // would misdescribe the plan the caller is approving.
+            requiresClean: dirtyBehavior === "block",
+            approvalRequired: true,
+            steps: [{
+              command: "clone_mesh_node",
+              description: "Explicitly create the branch/worktree and register the resulting node.",
+              writes: true,
+              approvalRequired: true,
+              args: {
+                meshId: compatibleMesh.id,
+                sourceNodeId: sourceNode.id,
+                branch,
+                baseBranch: compatibleMesh.defaultBranch || discovery.defaultBranch
+              }
+            }, initStep(discovery)],
+            alternatives: [{ kind: "add_existing_workspace", summary: "Register the supplied checkout without creating a worktree.", requiresClean: false }]
+          },
+          suggestedConfig: suggestedConfig2,
+          note: "Read-only plan only. No mesh, config, branch, remote or worktree state was changed.",
+          ...planWarnings.length ? { warnings: planWarnings } : {}
+        };
+      }
+      const suggestedConfig = runMeshInit(compatibleMesh || {}, discovery.repoRoot, options.detectedProviders || []);
+      if (compatibleMesh && operation !== "create_mesh") {
+        return {
+          success: true,
+          dryRun: true,
+          discovery,
+          membership,
+          compatibleMesh: meshSummary(compatibleMesh),
+          plan: {
+            kind: "add_existing_workspace",
+            summary: discovery.isLinkedWorktree ? `Register the existing linked worktree on '${discovery.currentBranch}' in '${compatibleMesh.name}'.` : `Register the main checkout as a base node in '${compatibleMesh.name}'.`,
+            requiresClean: false,
+            approvalRequired: true,
+            steps: [addStep(compatibleMesh, discovery), initStep(discovery)],
+            alternatives: [{
+              kind: "clone_new_worktree",
+              summary: `After a base node exists, create a clean isolated worktree from '${compatibleMesh.defaultBranch || discovery.defaultBranch}'.`,
+              requiresClean: true
+            }]
+          },
+          suggestedConfig,
+          note: "Read-only plan only. Adding the node and writing suggested configs require separate explicit approved calls."
+        };
+      }
+      const identityRepoName = discovery.repoIdentity.split("/").filter(Boolean).at(-1);
+      const suggestedName = `${identityRepoName || (0, import_node_path2.basename)(discovery.mainWorktreeRoot || discovery.repoRoot)}-mesh`;
+      const createArgs = {
+        name: suggestedName,
+        repoIdentity: discovery.repoIdentity,
+        repoRemoteUrl: discovery.origin?.urls[0] || discovery.upstream?.urls[0] || discovery.remotes[0]?.urls[0],
+        defaultBranch: discovery.defaultBranch
+      };
+      return {
+        success: true,
+        dryRun: true,
+        discovery,
+        membership,
+        plan: {
+          kind: "create_mesh_and_onboard",
+          summary: `Create '${suggestedName}', add this ${discovery.isLinkedWorktree ? "linked worktree" : "checkout"} as its first node, then review suggested .adhdev configs.`,
+          requiresClean: false,
+          approvalRequired: true,
+          steps: [
+            {
+              command: "create_mesh",
+              description: "Explicitly create a machine-local mesh record.",
+              writes: true,
+              approvalRequired: true,
+              args: createArgs
+            },
+            {
+              command: "add_mesh_node",
+              description: "After creation, explicitly register this existing workspace as the first node.",
+              writes: true,
+              approvalRequired: true,
+              args: {
+                meshId: "<created mesh id>",
+                workspace: discovery.repoRoot,
+                repoRoot: discovery.repoRoot,
+                isLocalWorktree: discovery.isLinkedWorktree
+              }
+            },
+            initStep(discovery)
+          ],
+          alternatives: []
+        },
+        suggestedConfig,
+        note: "Read-only plan only. No mesh/config/worktree writes occurred; execute each write step separately after approval."
+      };
+    }
+    var import_node_child_process5;
+    var import_promises5;
+    var import_node_path2;
+    var import_node_util4;
+    var execFileAsync3;
+    var GIT_TIMEOUT_MS2;
+    var init_mesh_onboarding_plan = __esm2({
+      "src/mesh/mesh-onboarding-plan.ts"() {
+        "use strict";
+        import_node_child_process5 = require("child_process");
+        import_promises5 = require("fs/promises");
+        import_node_path2 = require("path");
+        import_node_util4 = require("util");
+        init_git_locale();
+        init_repo_mesh_types();
+        init_mesh_config();
+        init_mesh_init();
+        init_git_worktree();
+        execFileAsync3 = (0, import_node_util4.promisify)(import_node_child_process5.execFile);
+        GIT_TIMEOUT_MS2 = 15e3;
+      }
+    });
+    var mesh_coordinator_exports = {};
+    __export2(mesh_coordinator_exports, {
+      applyMeshCoordinatorSystemPromptInjection: () => applyMeshCoordinatorSystemPromptInjection,
+      buildMeshCoordinatorRegistrationPlan: () => buildMeshCoordinatorRegistrationPlan,
+      cleanupCoordinatorAgentFile: () => cleanupCoordinatorAgentFile,
+      createHermesManualMeshCoordinatorSetup: () => createHermesManualMeshCoordinatorSetup,
+      execUnderPty: () => execUnderPty,
+      inspectMeshCoordinatorMcpServerPaths: () => inspectMeshCoordinatorMcpServerPaths,
+      resolveMeshCoordinatorSetup: () => resolveMeshCoordinatorSetup,
+      stripCoordinatorWrapperFile: () => stripCoordinatorWrapperFile
+    });
+    function isHermesProvider(provider, cliType) {
+      const type2 = cliType?.trim() || provider?.type?.trim() || "";
+      return type2 === HERMES_CLI_TYPE;
+    }
+    function resolveHermesMeshCoordinatorSetup(options) {
+      const mcpServer = resolveAdhdevMcpServerLaunch({
+        meshId: options.meshId,
+        adhdevMcpCommand: options.adhdevMcpCommand,
+        adhdevMcpEntryPath: options.adhdevMcpEntryPath,
+        nodeExecutable: options.nodeExecutable,
+        adhdevMcpTransport: options.adhdevMcpTransport,
+        adhdevMcpPort: options.adhdevMcpPort
+      });
+      if (!mcpServer) {
+        return {
+          kind: "unsupported",
+          reason: "Could not resolve the ADHDev MCP server entrypoint and a Node runtime with WebSocket support for daemon IPC mode"
+        };
+      }
+      const configPath = (0, import_node_path3.join)(resolveHermesCoordinatorHome(options.meshId, options.workspace), "config.yaml");
+      if (!configPath.trim()) {
+        return createHermesManualMeshCoordinatorSetup(options.meshId, options.workspace);
+      }
+      return {
+        kind: "auto_import",
+        serverName: DEFAULT_SERVER_NAME,
+        configPath,
+        configFormat: "hermes_config_yaml",
+        mcpServer
+      };
+    }
+    function createHermesManualMeshCoordinatorSetup(meshId, workspace) {
+      return {
+        kind: "manual",
+        serverName: DEFAULT_SERVER_NAME,
+        configFormat: "hermes_config_yaml",
+        configPathCommand: HERMES_MCP_CONFIG_PATH,
+        requiresRestart: true,
+        instructions: "Hermes CLI does not auto-import repo-local .mcp.json. Add this MCP server to Hermes config under mcp_servers, then start a fresh Hermes session.",
+        template: renderMeshCoordinatorTemplate(
+          "mcp_servers:\n  {{serverName}}:\n    command: {{adhdevMcpCommand}}\n    args:\n      - mcp\n      - --mode\n      - ipc\n      - --repo-mesh\n      - {{meshId}}\n    enabled: true\n",
+          {
+            meshId,
+            workspace,
+            serverName: DEFAULT_SERVER_NAME,
+            adhdevMcpCommand: DEFAULT_ADHDEV_MCP_COMMAND
+          }
+        )
+      };
+    }
+    function resolveMeshCoordinatorSetup(options) {
+      const { provider, meshId, workspace } = options;
+      const config2 = provider?.meshCoordinator;
+      if (!config2?.supported) {
+        return {
+          kind: "unsupported",
+          reason: config2?.reason || "Provider does not declare Repo Mesh coordinator support"
+        };
+      }
+      if (isHermesProvider(provider, options.cliType)) {
+        return resolveHermesMeshCoordinatorSetup(options);
+      }
+      const mcpConfig = config2.mcpConfig;
+      if (!mcpConfig || mcpConfig.mode === "none") {
+        return {
+          kind: "unsupported",
+          reason: config2.reason || "Provider does not declare a usable Repo Mesh MCP configuration mode"
+        };
+      }
+      const serverName = mcpConfig.serverName?.trim() || DEFAULT_SERVER_NAME;
+      if (mcpConfig.mode === "auto_import") {
+        const path63 = mcpConfig.path?.trim();
+        if (!path63) {
+          return { kind: "unsupported", reason: "Provider auto-import MCP config is missing a config path" };
+        }
+        const mcpServer = resolveAdhdevMcpServerLaunch({
+          meshId,
+          adhdevMcpCommand: options.adhdevMcpCommand,
+          adhdevMcpEntryPath: options.adhdevMcpEntryPath,
+          nodeExecutable: options.nodeExecutable,
+          adhdevMcpTransport: options.adhdevMcpTransport,
+          adhdevMcpPort: options.adhdevMcpPort
+        });
+        if (!mcpServer) {
+          return {
+            kind: "unsupported",
+            reason: "Could not resolve the ADHDev MCP server entrypoint and a Node runtime with WebSocket support for daemon IPC mode"
+          };
+        }
+        return {
+          kind: "auto_import",
+          serverName,
+          configPath: resolveMcpConfigPath(path63, workspace),
+          configFormat: mcpConfig.format,
+          mcpServer
+        };
+      }
+      if (mcpConfig.mode === "manual") {
+        const instructions = mcpConfig.instructions?.trim();
+        const template = mcpConfig.template;
+        if (!instructions || !template?.trim()) {
+          return { kind: "unsupported", reason: "Provider manual MCP setup is missing instructions or template" };
+        }
+        const mcpServer = resolveAdhdevMcpServerLaunch({
+          meshId,
+          adhdevMcpCommand: options.adhdevMcpCommand,
+          adhdevMcpEntryPath: options.adhdevMcpEntryPath,
+          nodeExecutable: options.nodeExecutable,
+          adhdevMcpTransport: options.adhdevMcpTransport,
+          adhdevMcpPort: options.adhdevMcpPort
+        });
+        if (!mcpServer) {
+          return {
+            kind: "unsupported",
+            reason: "Could not resolve the ADHDev MCP server entrypoint and transport arguments"
+          };
+        }
+        let renderedTemplate = renderMeshCoordinatorTemplate(template, {
+          meshId,
+          workspace,
+          serverName,
+          adhdevMcpCommand: mcpServer.command,
+          adhdevMcpArgs: mcpServer.args.join(" ")
+        });
+        const isCliCommand = !renderedTemplate.trim().includes("\n") && !renderedTemplate.trim().startsWith("{");
+        if (isCliCommand) {
+          if (!/\{\{\s*adhdevMcpArgs\s*\}\}/.test(template)) {
+            renderedTemplate = replaceLegacyCliCommandMcpArgs(renderedTemplate, mcpServer.args);
+          }
+          return {
+            kind: "cli_command",
+            serverName,
+            command: renderedTemplate.trim(),
+            requiresRestart: mcpConfig.requiresRestart === true,
+            instructions,
+            mcpServer
+          };
+        }
+        return {
+          kind: "manual",
+          serverName,
+          configFormat: mcpConfig.format,
+          configPathCommand: mcpConfig.configPathCommand,
+          requiresRestart: mcpConfig.requiresRestart === true,
+          instructions,
+          template: renderedTemplate
+        };
+      }
+      return {
+        kind: "unsupported",
+        reason: `Unsupported Repo Mesh MCP configuration mode: ${String(mcpConfig.mode)}`
+      };
+    }
+    function renderMeshCoordinatorTemplate(template, values) {
+      return template.replace(/\{\{\s*(meshId|workspace|serverName|adhdevMcpCommand|adhdevMcpArgs)\s*\}\}/g, (_, key2) => values[key2] || "");
+    }
+    function replaceLegacyCliCommandMcpArgs(command, args) {
+      return command.replace(
+        /\bmcp\s+--mode\s+(?:ipc|local)\s+--repo-mesh\s+\S+(?:\s+--port\s+\d+)?\s*$/,
+        args.join(" ")
+      );
+    }
+    function resolveHermesCoordinatorHome(meshId, workspace) {
+      const key2 = `${meshId || "mesh"}
+${(0, import_node_path3.resolve)(workspace || os13.tmpdir())}`;
+      const hash2 = shortHash(key2);
+      return (0, import_node_path3.join)(os13.tmpdir(), `adhdev-hermes-mesh-coordinator-${hash2}`);
+    }
+    function resolveMcpConfigPath(configPath, workspace) {
+      const trimmed = configPath.trim();
+      if (trimmed === "~") return os13.homedir();
+      if (trimmed.startsWith("~/")) return (0, import_node_path3.join)(os13.homedir(), trimmed.slice(2));
+      if ((0, import_node_path3.isAbsolute)(trimmed)) return trimmed;
+      return (0, import_node_path3.join)(workspace, trimmed);
+    }
+    function resolveAdhdevMcpServerLaunch(options) {
+      const directEntryPath = resolveAdhdevMcpEntryPath(options.adhdevMcpEntryPath);
+      if (directEntryPath) {
+        const transport2 = resolveMcpTransport(options.adhdevMcpTransport);
+        const args2 = [directEntryPath, "--mode", transport2, "--repo-mesh", options.meshId];
+        const port2 = resolveMcpPort(options.adhdevMcpPort);
+        if (port2 !== void 0) args2.push("--port", String(port2));
+        return {
+          command: resolveNodeExecutable(options.nodeExecutable),
+          args: args2
+        };
+      }
+      const command = resolveAdhdevCommand(options.adhdevMcpCommand);
+      const transport = resolveMcpTransport(options.adhdevMcpTransport);
+      const directMcpEntrypoint = (0, import_node_path3.basename)(command).startsWith("adhdev-mcp") || command.includes("/vendor/mcp-server/") || command.includes("\\vendor\\mcp-server\\");
+      const args = [...directMcpEntrypoint ? [] : ["mcp"], "--mode", transport, "--repo-mesh", options.meshId];
+      const port = resolveMcpPort(options.adhdevMcpPort);
+      if (port !== void 0) args.push("--port", String(port));
+      return {
+        command,
+        args
+      };
+    }
+    function resolveAdhdevCommand(explicitCommand) {
+      return explicitCommand?.trim() || process.env.ADHDEV_COORDINATOR_MCP_COMMAND?.trim() || DEFAULT_ADHDEV_MCP_COMMAND;
+    }
+    function inspectMeshCoordinatorMcpServerPaths(mcpServer, options = {}) {
+      const embeddedPaths = [mcpServer.command, ...mcpServer.args].filter((value) => (0, import_node_path3.isAbsolute)(value));
+      if (embeddedPaths.length === 0) {
+        return { state: "absent", referencedPath: null, volatile: false, volatileReason: null, warning: null };
+      }
+      let firstMissing = null;
+      let firstVolatile = null;
+      for (const embeddedPath of embeddedPaths) {
+        const health = inspectEmbeddedPath(embeddedPath, options.env ?? process.env);
+        if (health.state === "missing" && !firstMissing) firstMissing = health;
+        if (health.volatile && !firstVolatile) firstVolatile = health;
+      }
+      const serverName = options.serverName?.trim() || "adhdev-mesh";
+      const target = options.target?.trim() || `MCP setup for ${serverName}`;
+      const propagationNote = options.repoLocal ? " The config file lives inside the workspace and may be committed \u2014 this machine-specific absolute path would propagate to teammates' machines, where it matches nothing." : "";
+      if (firstMissing) {
+        return {
+          state: "missing",
+          referencedPath: firstMissing.referencedPath,
+          volatile: firstMissing.volatile || Boolean(firstVolatile),
+          volatileReason: firstMissing.volatileReason || firstVolatile?.volatileReason || null,
+          warning: `${target} embeds ${firstMissing.referencedPath}, which does not exist on this machine \u2014 the ${serverName} MCP server will fail to start (dangling reference, the statusline failure class).${propagationNote}`
+        };
+      }
+      if (firstVolatile) {
+        return {
+          state: "ok",
+          referencedPath: firstVolatile.referencedPath,
+          volatile: true,
+          volatileReason: firstVolatile.volatileReason,
+          warning: `${target} embeds ${firstVolatile.referencedPath}, which is ${firstVolatile.volatileReason}. It works today, but the ${serverName} entry will dangle once that location is cleaned up \u2014 the same failure class as the 2026-08-20 statusline incident.${propagationNote}`
+        };
+      }
+      return { state: "ok", referencedPath: embeddedPaths[0], volatile: false, volatileReason: null, warning: null };
+    }
+    function resolveAdhdevMcpEntryPath(explicitEntryPath) {
+      const entryPath = explicitEntryPath?.trim() || process.env.ADHDEV_COORDINATOR_MCP_ENTRY_PATH?.trim();
+      return entryPath || null;
+    }
+    function resolveNodeExecutable(explicitNodeExecutable) {
+      return explicitNodeExecutable?.trim() || process.env.ADHDEV_COORDINATOR_NODE_EXECUTABLE?.trim() || process.execPath;
+    }
+    function resolveMcpTransport(explicitTransport) {
       if (explicitTransport === "local" || explicitTransport === "ipc") return explicitTransport;
       const envTransport = process.env.ADHDEV_COORDINATOR_MCP_TRANSPORT?.trim();
       return envTransport === "local" ? "local" : "ipc";
@@ -73288,33 +74000,24 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       }
       return null;
     }
-    function isStructurallyUnmeasurable(quota) {
-      const kind = quota.metadata?.failureKind;
-      return typeof kind === "string" && STRUCTURALLY_UNMEASURABLE_FAILURE_KINDS.has(kind);
-    }
     function expiryRiskForRanking(node, providerType, axis, policy, now = Date.now(), context) {
       const entry = quotaEntryFor(node, providerType, context, now);
       if (!entry) return void 0;
       const { facts, quota } = entry;
-      const fresh = isQuotaSnapshotFresh(facts, quota, policy, now);
-      const confidence = quota.status === "ok" && fresh ? CONFIDENCE_CURRENT : isStructurallyUnmeasurable(quota) ? CONFIDENCE_RETAINED_STRUCTURAL : CONFIDENCE_RETAINED_AGED;
       const window = axis === "session" ? quota.session : quota.weekly;
       if (!isWindowTrustworthy(window, facts, quota, policy, now)) return void 0;
       const remaining = remainingPercent(window);
       if (remaining === void 0) return void 0;
       const resetsAt = Number(window?.resetsAt);
-      if (!Number.isFinite(resetsAt) || resetsAt <= 0) return { remainingPercent: remaining, risk: 0, confidence };
+      if (!Number.isFinite(resetsAt) || resetsAt <= 0) return { remainingPercent: remaining, risk: 0 };
       const ageMs2 = quotaSnapshotAgeMs(facts, quota, now);
-      if (!Number.isFinite(ageMs2)) return { remainingPercent: remaining, risk: 0, confidence };
+      if (!Number.isFinite(ageMs2)) return { remainingPercent: remaining, risk: 0 };
       const reporterNowMs = Number(quota.updatedAt) + ageMs2;
       const windowMinutes3 = Number(window?.windowMinutes);
       const fallbackMinutes = axis === "session" ? DEFAULT_SESSION_WINDOW_MINUTES : DEFAULT_WEEKLY_WINDOW_MINUTES;
       const windowMs = (Number.isFinite(windowMinutes3) && windowMinutes3 > 0 ? windowMinutes3 : fallbackMinutes) * 60 * 1e3;
       const elapsedFraction = Math.min(1, Math.max(0, 1 - (resetsAt - reporterNowMs) / windowMs));
-      return { remainingPercent: remaining, risk: remaining * elapsedFraction, confidence };
-    }
-    function rankedRisk(reading) {
-      return reading.risk * reading.confidence;
+      return { remainingPercent: remaining, risk: remaining * elapsedFraction };
     }
     function rankProvidersByQuotaGate(node, orderedProviderTypes, policy, now = Date.now(), context) {
       const clear = [];
@@ -73339,19 +74042,14 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           const sa = sessionByProvider.get(a);
           const sb = sessionByProvider.get(b);
           if (sa !== void 0 && sb !== void 0) {
-            const ra2 = rankedRisk(sa);
-            const rb2 = rankedRisk(sb);
-            if (rb2 !== ra2) return rb2 - ra2;
+            if (sb.risk !== sa.risk) return sb.risk - sa.risk;
             if (sb.remainingPercent !== sa.remainingPercent) {
               return sb.remainingPercent - sa.remainingPercent;
             }
           } else if (sa !== void 0) return -1;
           else if (sb !== void 0) return 1;
         }
-        const ra = rankedRisk(wa);
-        const rb = rankedRisk(wb);
-        if (rb !== ra) return rb - ra;
-        if (wb.confidence !== wa.confidence) return wb.confidence - wa.confidence;
+        if (wb.risk !== wa.risk) return wb.risk - wa.risk;
         return wb.remainingPercent - wa.remainingPercent;
       });
       const rankingEvidence = clear.map((providerType) => {
@@ -73363,8 +74061,6 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           axis,
           ...reading ? {
             risk: reading.risk,
-            confidence: reading.confidence,
-            rankedRisk: rankedRisk(reading),
             remainingPercent: reading.remainingPercent
           } : {}
         };
@@ -73406,8 +74102,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           axis,
           ...w ? {
             remainingPercent: w.remainingPercent,
-            risk: w.risk,
-            ...w.confidence !== CONFIDENCE_CURRENT ? { confidence: w.confidence, rankedRisk: rankedRisk(w) } : {}
+            risk: w.risk
           } : {}
         };
       });
@@ -73507,10 +74202,6 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
     var absentFailOpenLoggedAt;
     var DEFAULT_WEEKLY_WINDOW_MINUTES;
     var DEFAULT_SESSION_WINDOW_MINUTES;
-    var CONFIDENCE_CURRENT;
-    var CONFIDENCE_RETAINED_STRUCTURAL;
-    var CONFIDENCE_RETAINED_AGED;
-    var STRUCTURALLY_UNMEASURABLE_FAILURE_KINDS;
     var RATIONALE_LOSERS_MAX;
     var lastQuotaRankingByNode;
     var init_mesh_quota_routing = __esm2({
@@ -73528,10 +74219,6 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         absentFailOpenLoggedAt = /* @__PURE__ */ new Map();
         DEFAULT_WEEKLY_WINDOW_MINUTES = 7 * 24 * 60;
         DEFAULT_SESSION_WINDOW_MINUTES = 5 * 60;
-        CONFIDENCE_CURRENT = 1;
-        CONFIDENCE_RETAINED_STRUCTURAL = 0.7;
-        CONFIDENCE_RETAINED_AGED = 0.4;
-        STRUCTURALLY_UNMEASURABLE_FAILURE_KINDS = /* @__PURE__ */ new Set(["no-data"]);
         RATIONALE_LOSERS_MAX = 4;
         lastQuotaRankingByNode = /* @__PURE__ */ new Map();
       }
@@ -91836,6 +92523,16 @@ ${cleanBody}`;
         _acpValidator = null;
       }
     });
+    function truncateValidationOutput(value) {
+      const text = typeof value === "string" ? value : value == null ? "" : String(value);
+      if (text.length <= REFINE_VALIDATION_SUMMARY_CHARS) return text;
+      const head = text.slice(0, REFINE_VALIDATION_SUMMARY_HEAD_CHARS);
+      const tail = text.slice(text.length - REFINE_VALIDATION_SUMMARY_TAIL_CHARS);
+      const omitted = text.length - REFINE_VALIDATION_SUMMARY_HEAD_CHARS - REFINE_VALIDATION_SUMMARY_TAIL_CHARS;
+      return `${head}
+[... ${omitted} chars omitted ...]
+${tail}`;
+    }
     function readChangedGitlinkPaths(repoRoot, fromRef, toRef) {
       try {
         const output = (0, import_node_child_process9.execFileSync)(GIT2, ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
@@ -91899,7 +92596,7 @@ ${cleanBody}`;
       }
     }
     function probeSubmoduleGitlinkReachability(input) {
-      const { path: path63, baseCommit, branchCommit, probeRoot, baseRepoRoot } = input;
+      const { path: path63, baseCommit, branchCommit, probeRoot, baseRepoRoot, defaultBranch } = input;
       const submoduleRepo = (0, import_path17.resolve)(probeRoot, path63);
       const baseSubmoduleRepo = (0, import_path17.resolve)(baseRepoRoot, path63);
       if (baseCommit) ensureSubmoduleCommitLocal(submoduleRepo, baseSubmoduleRepo, baseCommit);
@@ -91913,7 +92610,7 @@ ${cleanBody}`;
           if (ff === "undeterminable") undeterminable.push("fastForward");
           else fastForward = ff;
         }
-        const reach = probeGitAncestry(submoduleRepo, branchCommit, "refs/remotes/origin/main");
+        const reach = probeGitAncestry(submoduleRepo, branchCommit, `refs/remotes/origin/${defaultBranch || "main"}`);
         if (reach === "undeterminable") undeterminable.push("reachableFromOriginMain");
         else reachableFromOriginMain = reach;
       }
@@ -92069,11 +92766,251 @@ ${cleanBody}`;
       parts.push("Do not merge the root branch until every submodule gitlink commit is reachable from submodule origin/main.");
       return parts.join(" ");
     }
+    async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, options = {}) {
+      const startedAt = Date.now();
+      const entries = [];
+      try {
+        const { execFile: execFile9 } = await import("child_process");
+        const { promisify: promisify12 } = await import("util");
+        const execFileAsync8 = promisify12(execFile9);
+        const runGit4 = async (cwd, args) => {
+          const { stdout } = await execFileAsync8(GIT2, args, {
+            cwd,
+            encoding: "utf8",
+            timeout: 3e4,
+            maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES,
+            windowsHide: true
+          });
+          return String(stdout || "");
+        };
+        const verifyRemoteMainContainsCommit = (submodulePath, commit, branch = "main") => verifyRemoteBranchContainsCommit(runGit4, submodulePath, commit, branch);
+        const publishCommitToRemoteMain = async (submodulePath, commit, branch = "main") => {
+          const refspec = `${commit}:refs/heads/${branch}`;
+          const { stdout, stderr } = await execFileAsync8(GIT2, ["push", "origin", refspec], {
+            cwd: submodulePath,
+            encoding: "utf8",
+            timeout: 3e4,
+            maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES,
+            windowsHide: true
+          });
+          return { stdout: String(stdout || ""), stderr: String(stderr || ""), refspec };
+        };
+        const importCommitFromWorktreeSubmodule = async (submodulePath, worktreeSubmodulePath, commit) => {
+          if (!fs50.existsSync(worktreeSubmodulePath)) return false;
+          try {
+            await runGit4(worktreeSubmodulePath, ["cat-file", "-e", `${commit}^{commit}`]);
+          } catch {
+            return false;
+          }
+          await runGit4(submodulePath, ["-c", "protocol.file.allow=always", "fetch", worktreeSubmodulePath, commit]);
+          await runGit4(submodulePath, ["cat-file", "-e", `${commit}^{commit}`]);
+          return true;
+        };
+        const findEquivalentPublishedCommit = async (submodulePath, commit, remoteRef) => {
+          try {
+            const targetTree = (await runGit4(submodulePath, ["rev-parse", `${commit}^{tree}`])).trim();
+            if (!targetTree) return void 0;
+            const candidates = (await runGit4(submodulePath, ["rev-list", "--max-count=100", remoteRef])).split("\n").map((s2) => s2.trim()).filter(Boolean);
+            for (const candidate of candidates) {
+              let tree = "";
+              try {
+                tree = (await runGit4(submodulePath, ["rev-parse", `${candidate}^{tree}`])).trim();
+              } catch {
+                continue;
+              }
+              if (tree && tree === targetTree) return candidate;
+            }
+          } catch {
+          }
+          return void 0;
+        };
+        const treeOutput = await runGit4(repoRoot, ["ls-tree", "-r", "-z", mergedTree]);
+        const gitlinks = treeOutput.split("\0").filter(Boolean).map((record2) => {
+          const match = /^160000\s+commit\s+([0-9a-f]{40})\t(.+)$/.exec(record2);
+          return match ? { commit: match[1], path: match[2] } : null;
+        }).filter((entry) => !!entry);
+        for (const gitlink of gitlinks) {
+          const submodulePath = (0, import_path17.resolve)(repoRoot, gitlink.path);
+          const entry = {
+            path: gitlink.path,
+            commit: gitlink.commit,
+            reachable: false
+          };
+          let submoduleDefaultBranch = "main";
+          try {
+            if (!fs50.existsSync(submodulePath)) {
+              entry.error = `Submodule checkout missing at ${gitlink.path}`;
+              entry.publishRequired = true;
+              if (options.allowAutoPublishSubmoduleMainCommits === true) {
+                entry.autoPublishAllowed = true;
+                entry.autoPublishAttempted = false;
+                entry.autoPublishSkippedReason = `submodule checkout missing at ${gitlink.path}; cannot perform non-force push to origin/main`;
+              }
+              entries.push(entry);
+              continue;
+            }
+            entry.checkedLocal = true;
+            try {
+              await runGit4(submodulePath, ["cat-file", "-e", `${gitlink.commit}^{commit}`]);
+              entry.localReachable = true;
+            } catch {
+              entry.localReachable = false;
+              if (options.allowAutoPublishSubmoduleMainCommits === true && options.worktreeRoot) {
+                try {
+                  const imported = await importCommitFromWorktreeSubmodule(submodulePath, (0, import_path17.resolve)(options.worktreeRoot, gitlink.path), gitlink.commit);
+                  if (imported) {
+                    entry.localReachable = true;
+                    entry.importedFromWorktree = true;
+                  }
+                } catch (importError) {
+                  entry.autoPublishSkippedReason = `candidate commit was not present in the source checkout and could not be imported from worktree submodule: ${truncateValidationOutput(importError?.stderr || importError?.message || String(importError))}`;
+                }
+              }
+            }
+            try {
+              entry.remote = "origin";
+              let remoteUrl = "";
+              try {
+                remoteUrl = (await runGit4(submodulePath, ["remote", "get-url", "origin"])).trim();
+                if (!remoteUrl) throw new Error("origin remote has no URL");
+                entry.remoteUrl = remoteUrl;
+              } catch {
+                entry.error = "Submodule remote reachability check failed: no configured origin remote";
+                entry.publishRequired = true;
+                if (options.allowAutoPublishSubmoduleMainCommits === true) {
+                  entry.autoPublishAllowed = true;
+                  entry.autoPublishAttempted = false;
+                  entry.autoPublishSkippedReason = "submodule origin remote is not configured; cannot perform non-force push to origin/main";
+                }
+                entries.push(entry);
+                continue;
+              }
+              submoduleDefaultBranch = await resolveSubmoduleDefaultBranch({
+                submoduleRepoPath: submodulePath,
+                superprojectWorkspace: repoRoot,
+                submodulePath: gitlink.path
+              });
+              entry.remoteMainBranch = submoduleDefaultBranch;
+              const verdict = await verifyRemoteMainContainsCommit(submodulePath, gitlink.commit, submoduleDefaultBranch);
+              if (verdict.state === "contained") {
+                entry.fetchedFromOrigin = true;
+                entry.remoteReachable = true;
+                entry.remoteMainReachable = true;
+                entry.reachable = true;
+              } else if (verdict.state === "undeterminable") {
+                const e = verdict.error;
+                entry.remoteMainUndeterminable = true;
+                entry.publishRequired = false;
+                const details = truncateValidationOutput(e?.stderr || e?.message || String(e));
+                entry.error = `Submodule remote main reachability for origin/${submoduleDefaultBranch} could not be determined (the remote was not successfully consulted): ${details}. This is not evidence that ${gitlink.commit} is unpublished \u2014 resolve the remote access problem and re-run; Refinery will not publish on an undetermined verdict.`;
+                if (options.allowAutoPublishSubmoduleMainCommits === true) {
+                  entry.autoPublishAllowed = true;
+                  entry.autoPublishAttempted = false;
+                  entry.autoPublishSkippedReason = `remote main containment for origin/${submoduleDefaultBranch} could not be determined, so Refinery will not push \u2014 a failed fetch is not proof the commit is unpublished`;
+                }
+              } else {
+                const e = verdict.error;
+                entry.remoteReachable = false;
+                entry.remoteMainReachable = false;
+                const equivalentPublished = await findEquivalentPublishedCommit(submodulePath, gitlink.commit, `refs/remotes/origin/${submoduleDefaultBranch}`);
+                if (equivalentPublished) {
+                  entry.equivalentPublishedCommit = equivalentPublished;
+                  entry.publishRequired = false;
+                  entry.error = `Submodule commit ${gitlink.commit} is not reachable from origin/${submoduleDefaultBranch}, but an equivalent commit ${equivalentPublished} (identical tree) is already published there; converge the gitlink to the published commit instead of publishing a same-content twin.`;
+                  if (options.allowAutoPublishSubmoduleMainCommits === true) {
+                    entry.autoPublishAllowed = true;
+                    entry.autoPublishAttempted = false;
+                    entry.autoPublishSkippedReason = `an equivalent commit (${equivalentPublished}) is already published on origin/${submoduleDefaultBranch}; publishing a same-content twin is wrong \u2014 converge the gitlink to the published commit instead`;
+                  }
+                } else {
+                  entry.publishRequired = true;
+                  const details = truncateValidationOutput(e?.stderr || e?.message || String(e));
+                  entry.error = `Submodule remote main reachability check failed for origin/${submoduleDefaultBranch}: ${details}`;
+                  if (options.allowAutoPublishSubmoduleMainCommits === true && entry.localReachable === true) {
+                    entry.autoPublishAllowed = true;
+                    entry.autoPublishAttempted = true;
+                    try {
+                      const publish = await publishCommitToRemoteMain(submodulePath, gitlink.commit, submoduleDefaultBranch);
+                      entry.autoPublishRefspec = publish.refspec;
+                      entry.publishStdout = truncateValidationOutput(publish.stdout);
+                      entry.publishStderr = truncateValidationOutput(publish.stderr);
+                      entry.autoPublishSucceeded = true;
+                      const postPublish = await verifyRemoteMainContainsCommit(submodulePath, gitlink.commit, submoduleDefaultBranch);
+                      if (postPublish.state !== "contained") {
+                        entry.autoPublishVerified = false;
+                        const postDetails = truncateValidationOutput(
+                          postPublish.error?.stderr || postPublish.error?.message || String(postPublish.error)
+                        );
+                        if (postPublish.state === "undeterminable") entry.remoteMainUndeterminable = true;
+                        else entry.remoteMainReachable = false;
+                        entry.error = `Submodule auto-publish to origin/${submoduleDefaultBranch} reported success but post-publish verification did not confirm containment (${postPublish.state}): ${postDetails}`;
+                      } else {
+                        entry.fetchedFromOrigin = true;
+                        entry.remoteReachable = true;
+                        entry.remoteMainReachable = true;
+                        entry.autoPublishVerified = true;
+                        entry.publishRequired = false;
+                        entry.reachable = true;
+                        entry.error = void 0;
+                      }
+                    } catch (publishError) {
+                      entry.autoPublishSucceeded = false;
+                      entry.autoPublishVerified = false;
+                      const publishDetails = truncateValidationOutput(publishError?.stderr || publishError?.message || String(publishError));
+                      entry.error = `Submodule auto-publish to origin/${submoduleDefaultBranch} failed or could not be verified: ${publishDetails}`;
+                    }
+                  } else if (options.allowAutoPublishSubmoduleMainCommits === true) {
+                    entry.autoPublishAllowed = true;
+                    entry.autoPublishAttempted = false;
+                    entry.autoPublishSkippedReason = entry.autoPublishSkippedReason || `candidate commit is not reachable in the source checkout or worktree submodule, so Refinery cannot push it to origin/${submoduleDefaultBranch}`;
+                  }
+                }
+              }
+            } catch (e) {
+              entry.remoteReachable = false;
+              entry.remoteMainReachable = false;
+              entry.publishRequired = true;
+              const details = truncateValidationOutput(e?.stderr || e?.message || String(e));
+              entry.error = `Submodule remote main reachability check failed for origin/${submoduleDefaultBranch}: ${details}`;
+            }
+          } catch (e) {
+            entry.error = truncateValidationOutput(e?.message || String(e));
+            entry.publishRequired = true;
+          }
+          entries.push(entry);
+        }
+        const unreachable = entries.filter((entry) => !entry.reachable);
+        return {
+          status: unreachable.length ? "failed" : "passed",
+          checked: entries.length,
+          unreachable: unreachable.map((entry) => ({ ...entry, publishRequired: entry.publishRequired !== false })),
+          entries: entries.map((entry) => entry.reachable ? entry : { ...entry, publishRequired: entry.publishRequired !== false }),
+          durationMs: Date.now() - startedAt,
+          autoPublishAllowed: options.allowAutoPublishSubmoduleMainCommits === true,
+          autoPublishPolicySource: options.autoPublishPolicySource
+        };
+      } catch (e) {
+        const unreachable = entries.filter((entry) => !entry.reachable).map((entry) => ({ ...entry, publishRequired: entry.publishRequired !== false }));
+        return {
+          status: "failed",
+          checked: entries.length,
+          unreachable,
+          entries: entries.map((entry) => entry.reachable ? entry : { ...entry, publishRequired: entry.publishRequired !== false }),
+          durationMs: Date.now() - startedAt,
+          autoPublishAllowed: options.allowAutoPublishSubmoduleMainCommits === true,
+          autoPublishPolicySource: options.autoPublishPolicySource,
+          error: truncateValidationOutput(e?.message || String(e))
+        };
+      }
+    }
     var fs50;
     var import_node_child_process9;
     var import_path17;
     var GIT2;
     var REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES;
+    var REFINE_VALIDATION_SUMMARY_HEAD_CHARS;
+    var REFINE_VALIDATION_SUMMARY_TAIL_CHARS;
+    var REFINE_VALIDATION_SUMMARY_CHARS;
     var init_mesh_refine_gitlink_utils = __esm2({
       "src/mesh/mesh-refine-gitlink-utils.ts"() {
         "use strict";
@@ -92082,8 +93019,12 @@ ${cleanBody}`;
         import_path17 = require("path");
         init_logger();
         init_resolve_executable();
+        init_worktree_bootstrap_config();
         GIT2 = process.platform === "win32" ? resolveWin32Executable("git") : "git";
         REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES = 4 * 1024 * 1024;
+        REFINE_VALIDATION_SUMMARY_HEAD_CHARS = 2e3;
+        REFINE_VALIDATION_SUMMARY_TAIL_CHARS = 6e3;
+        REFINE_VALIDATION_SUMMARY_CHARS = REFINE_VALIDATION_SUMMARY_HEAD_CHARS + REFINE_VALIDATION_SUMMARY_TAIL_CHARS;
       }
     });
     function resolveRefineVitestMaxWorkers(env2 = process.env) {
@@ -92464,16 +93405,6 @@ ${cleanBody}`;
         SUBMODULE_PUBLICATION_UNDETERMINABLE_RECOMMENDED_ACTION = "Restore access to the submodule remote (the publication check could not be run), then rerun mesh_refine_node. Do NOT publish and do NOT retry the rebase on this evidence: it is unknown whether the branch-side commit is already on origin, so minting or pushing here can synthesize a redundant twin of a published commit.";
       }
     });
-    function truncateValidationOutput(value) {
-      const text = typeof value === "string" ? value : value == null ? "" : String(value);
-      if (text.length <= REFINE_VALIDATION_SUMMARY_CHARS) return text;
-      const head = text.slice(0, REFINE_VALIDATION_SUMMARY_HEAD_CHARS);
-      const tail = text.slice(text.length - REFINE_VALIDATION_SUMMARY_TAIL_CHARS);
-      const omitted = text.length - REFINE_VALIDATION_SUMMARY_HEAD_CHARS - REFINE_VALIDATION_SUMMARY_TAIL_CHARS;
-      return `${head}
-[... ${omitted} chars omitted ...]
-${tail}`;
-    }
     function classifyValidationFailure(error48, stderr, spawnResolutionFailed) {
       const outputLimitExceeded = error48?.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" || /maxBuffer length exceeded/i.test(String(error48?.message || ""));
       const missingDependencyFailure = !spawnResolutionFailed && !outputLimitExceeded && /Cannot find module|MODULE_NOT_FOUND|node_modules|command not found|not found/i.test(stderr);
@@ -92728,12 +93659,22 @@ ${e?.stderr || ""}`
             } catch {
               continue;
             }
+            let gitlinkDefaultBranch;
+            try {
+              gitlinkDefaultBranch = await resolveSubmoduleDefaultBranch({
+                submoduleRepoPath: (0, import_path19.resolve)(submoduleProbeRoot, p),
+                superprojectWorkspace: repoRoot,
+                submodulePath: p
+              });
+            } catch {
+            }
             submoduleGitlinks.push(probeSubmoduleGitlinkReachability({
               path: p,
               baseCommit,
               branchCommit,
               probeRoot: submoduleProbeRoot,
-              baseRepoRoot: repoRoot
+              baseRepoRoot: repoRoot,
+              defaultBranch: gitlinkDefaultBranch
             }));
           }
         } catch {
@@ -93228,243 +94169,6 @@ ${mergeTreeErr?.stderr || ""}`;
         };
       }
     }
-    async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, options = {}) {
-      const startedAt = Date.now();
-      const entries = [];
-      try {
-        const { execFile: execFile9 } = await import("child_process");
-        const { promisify: promisify12 } = await import("util");
-        const execFileAsync8 = promisify12(execFile9);
-        const runGit4 = async (cwd, args) => {
-          const { stdout } = await execFileAsync8(GIT2, args, {
-            cwd,
-            encoding: "utf8",
-            timeout: 3e4,
-            maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES,
-            windowsHide: true
-          });
-          return String(stdout || "");
-        };
-        const verifyRemoteMainContainsCommit = (submodulePath, commit, branch = "main") => verifyRemoteBranchContainsCommit(runGit4, submodulePath, commit, branch);
-        const publishCommitToRemoteMain = async (submodulePath, commit, branch = "main") => {
-          const refspec = `${commit}:refs/heads/${branch}`;
-          const { stdout, stderr } = await execFileAsync8(GIT2, ["push", "origin", refspec], {
-            cwd: submodulePath,
-            encoding: "utf8",
-            timeout: 3e4,
-            maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES,
-            windowsHide: true
-          });
-          return { stdout: String(stdout || ""), stderr: String(stderr || ""), refspec };
-        };
-        const importCommitFromWorktreeSubmodule = async (submodulePath, worktreeSubmodulePath, commit) => {
-          if (!fs52.existsSync(worktreeSubmodulePath)) return false;
-          try {
-            await runGit4(worktreeSubmodulePath, ["cat-file", "-e", `${commit}^{commit}`]);
-          } catch {
-            return false;
-          }
-          await runGit4(submodulePath, ["-c", "protocol.file.allow=always", "fetch", worktreeSubmodulePath, commit]);
-          await runGit4(submodulePath, ["cat-file", "-e", `${commit}^{commit}`]);
-          return true;
-        };
-        const findEquivalentPublishedCommit = async (submodulePath, commit, remoteRef) => {
-          try {
-            const targetTree = (await runGit4(submodulePath, ["rev-parse", `${commit}^{tree}`])).trim();
-            if (!targetTree) return void 0;
-            const candidates = (await runGit4(submodulePath, ["rev-list", "--max-count=100", remoteRef])).split("\n").map((s2) => s2.trim()).filter(Boolean);
-            for (const candidate of candidates) {
-              let tree = "";
-              try {
-                tree = (await runGit4(submodulePath, ["rev-parse", `${candidate}^{tree}`])).trim();
-              } catch {
-                continue;
-              }
-              if (tree && tree === targetTree) return candidate;
-            }
-          } catch {
-          }
-          return void 0;
-        };
-        const treeOutput = await runGit4(repoRoot, ["ls-tree", "-r", "-z", mergedTree]);
-        const gitlinks = treeOutput.split("\0").filter(Boolean).map((record2) => {
-          const match = /^160000\s+commit\s+([0-9a-f]{40})\t(.+)$/.exec(record2);
-          return match ? { commit: match[1], path: match[2] } : null;
-        }).filter((entry) => !!entry);
-        for (const gitlink of gitlinks) {
-          const submodulePath = (0, import_path19.resolve)(repoRoot, gitlink.path);
-          const entry = {
-            path: gitlink.path,
-            commit: gitlink.commit,
-            reachable: false
-          };
-          let submoduleDefaultBranch = "main";
-          try {
-            if (!fs52.existsSync(submodulePath)) {
-              entry.error = `Submodule checkout missing at ${gitlink.path}`;
-              entry.publishRequired = true;
-              if (options.allowAutoPublishSubmoduleMainCommits === true) {
-                entry.autoPublishAllowed = true;
-                entry.autoPublishAttempted = false;
-                entry.autoPublishSkippedReason = `submodule checkout missing at ${gitlink.path}; cannot perform non-force push to origin/main`;
-              }
-              entries.push(entry);
-              continue;
-            }
-            entry.checkedLocal = true;
-            try {
-              await runGit4(submodulePath, ["cat-file", "-e", `${gitlink.commit}^{commit}`]);
-              entry.localReachable = true;
-            } catch {
-              entry.localReachable = false;
-              if (options.allowAutoPublishSubmoduleMainCommits === true && options.worktreeRoot) {
-                try {
-                  const imported = await importCommitFromWorktreeSubmodule(submodulePath, (0, import_path19.resolve)(options.worktreeRoot, gitlink.path), gitlink.commit);
-                  if (imported) {
-                    entry.localReachable = true;
-                    entry.importedFromWorktree = true;
-                  }
-                } catch (importError) {
-                  entry.autoPublishSkippedReason = `candidate commit was not present in the source checkout and could not be imported from worktree submodule: ${truncateValidationOutput(importError?.stderr || importError?.message || String(importError))}`;
-                }
-              }
-            }
-            try {
-              entry.remote = "origin";
-              let remoteUrl = "";
-              try {
-                remoteUrl = (await runGit4(submodulePath, ["remote", "get-url", "origin"])).trim();
-                if (!remoteUrl) throw new Error("origin remote has no URL");
-                entry.remoteUrl = remoteUrl;
-              } catch {
-                entry.error = "Submodule remote reachability check failed: no configured origin remote";
-                entry.publishRequired = true;
-                if (options.allowAutoPublishSubmoduleMainCommits === true) {
-                  entry.autoPublishAllowed = true;
-                  entry.autoPublishAttempted = false;
-                  entry.autoPublishSkippedReason = "submodule origin remote is not configured; cannot perform non-force push to origin/main";
-                }
-                entries.push(entry);
-                continue;
-              }
-              submoduleDefaultBranch = await resolveSubmoduleDefaultBranch({
-                submoduleRepoPath: submodulePath,
-                superprojectWorkspace: repoRoot,
-                submodulePath: gitlink.path
-              });
-              entry.remoteMainBranch = submoduleDefaultBranch;
-              const verdict = await verifyRemoteMainContainsCommit(submodulePath, gitlink.commit, submoduleDefaultBranch);
-              if (verdict.state === "contained") {
-                entry.fetchedFromOrigin = true;
-                entry.remoteReachable = true;
-                entry.remoteMainReachable = true;
-                entry.reachable = true;
-              } else if (verdict.state === "undeterminable") {
-                const e = verdict.error;
-                entry.remoteMainUndeterminable = true;
-                entry.publishRequired = false;
-                const details = truncateValidationOutput(e?.stderr || e?.message || String(e));
-                entry.error = `Submodule remote main reachability for origin/${submoduleDefaultBranch} could not be determined (the remote was not successfully consulted): ${details}. This is not evidence that ${gitlink.commit} is unpublished \u2014 resolve the remote access problem and re-run; Refinery will not publish on an undetermined verdict.`;
-                if (options.allowAutoPublishSubmoduleMainCommits === true) {
-                  entry.autoPublishAllowed = true;
-                  entry.autoPublishAttempted = false;
-                  entry.autoPublishSkippedReason = `remote main containment for origin/${submoduleDefaultBranch} could not be determined, so Refinery will not push \u2014 a failed fetch is not proof the commit is unpublished`;
-                }
-              } else {
-                const e = verdict.error;
-                entry.remoteReachable = false;
-                entry.remoteMainReachable = false;
-                const equivalentPublished = await findEquivalentPublishedCommit(submodulePath, gitlink.commit, `refs/remotes/origin/${submoduleDefaultBranch}`);
-                if (equivalentPublished) {
-                  entry.equivalentPublishedCommit = equivalentPublished;
-                  entry.publishRequired = false;
-                  entry.error = `Submodule commit ${gitlink.commit} is not reachable from origin/${submoduleDefaultBranch}, but an equivalent commit ${equivalentPublished} (identical tree) is already published there; converge the gitlink to the published commit instead of publishing a same-content twin.`;
-                  if (options.allowAutoPublishSubmoduleMainCommits === true) {
-                    entry.autoPublishAllowed = true;
-                    entry.autoPublishAttempted = false;
-                    entry.autoPublishSkippedReason = `an equivalent commit (${equivalentPublished}) is already published on origin/${submoduleDefaultBranch}; publishing a same-content twin is wrong \u2014 converge the gitlink to the published commit instead`;
-                  }
-                } else {
-                  entry.publishRequired = true;
-                  const details = truncateValidationOutput(e?.stderr || e?.message || String(e));
-                  entry.error = `Submodule remote main reachability check failed for origin/${submoduleDefaultBranch}: ${details}`;
-                  if (options.allowAutoPublishSubmoduleMainCommits === true && entry.localReachable === true) {
-                    entry.autoPublishAllowed = true;
-                    entry.autoPublishAttempted = true;
-                    try {
-                      const publish = await publishCommitToRemoteMain(submodulePath, gitlink.commit, submoduleDefaultBranch);
-                      entry.autoPublishRefspec = publish.refspec;
-                      entry.publishStdout = truncateValidationOutput(publish.stdout);
-                      entry.publishStderr = truncateValidationOutput(publish.stderr);
-                      entry.autoPublishSucceeded = true;
-                      const postPublish = await verifyRemoteMainContainsCommit(submodulePath, gitlink.commit, submoduleDefaultBranch);
-                      if (postPublish.state !== "contained") {
-                        entry.autoPublishVerified = false;
-                        const postDetails = truncateValidationOutput(
-                          postPublish.error?.stderr || postPublish.error?.message || String(postPublish.error)
-                        );
-                        if (postPublish.state === "undeterminable") entry.remoteMainUndeterminable = true;
-                        else entry.remoteMainReachable = false;
-                        entry.error = `Submodule auto-publish to origin/${submoduleDefaultBranch} reported success but post-publish verification did not confirm containment (${postPublish.state}): ${postDetails}`;
-                      } else {
-                        entry.fetchedFromOrigin = true;
-                        entry.remoteReachable = true;
-                        entry.remoteMainReachable = true;
-                        entry.autoPublishVerified = true;
-                        entry.publishRequired = false;
-                        entry.reachable = true;
-                        entry.error = void 0;
-                      }
-                    } catch (publishError) {
-                      entry.autoPublishSucceeded = false;
-                      entry.autoPublishVerified = false;
-                      const publishDetails = truncateValidationOutput(publishError?.stderr || publishError?.message || String(publishError));
-                      entry.error = `Submodule auto-publish to origin/${submoduleDefaultBranch} failed or could not be verified: ${publishDetails}`;
-                    }
-                  } else if (options.allowAutoPublishSubmoduleMainCommits === true) {
-                    entry.autoPublishAllowed = true;
-                    entry.autoPublishAttempted = false;
-                    entry.autoPublishSkippedReason = entry.autoPublishSkippedReason || `candidate commit is not reachable in the source checkout or worktree submodule, so Refinery cannot push it to origin/${submoduleDefaultBranch}`;
-                  }
-                }
-              }
-            } catch (e) {
-              entry.remoteReachable = false;
-              entry.remoteMainReachable = false;
-              entry.publishRequired = true;
-              const details = truncateValidationOutput(e?.stderr || e?.message || String(e));
-              entry.error = `Submodule remote main reachability check failed for origin/${submoduleDefaultBranch}: ${details}`;
-            }
-          } catch (e) {
-            entry.error = truncateValidationOutput(e?.message || String(e));
-            entry.publishRequired = true;
-          }
-          entries.push(entry);
-        }
-        const unreachable = entries.filter((entry) => !entry.reachable);
-        return {
-          status: unreachable.length ? "failed" : "passed",
-          checked: entries.length,
-          unreachable: unreachable.map((entry) => ({ ...entry, publishRequired: entry.publishRequired !== false })),
-          entries: entries.map((entry) => entry.reachable ? entry : { ...entry, publishRequired: entry.publishRequired !== false }),
-          durationMs: Date.now() - startedAt,
-          autoPublishAllowed: options.allowAutoPublishSubmoduleMainCommits === true,
-          autoPublishPolicySource: options.autoPublishPolicySource
-        };
-      } catch (e) {
-        const unreachable = entries.filter((entry) => !entry.reachable).map((entry) => ({ ...entry, publishRequired: entry.publishRequired !== false }));
-        return {
-          status: "failed",
-          checked: entries.length,
-          unreachable,
-          entries: entries.map((entry) => entry.reachable ? entry : { ...entry, publishRequired: entry.publishRequired !== false }),
-          durationMs: Date.now() - startedAt,
-          autoPublishAllowed: options.allowAutoPublishSubmoduleMainCommits === true,
-          autoPublishPolicySource: options.autoPublishPolicySource,
-          error: truncateValidationOutput(e?.message || String(e))
-        };
-      }
-    }
     function buildMeshRefineValidationPlan(mesh, workspace) {
       const plan = resolveMeshRefineValidationPlan(mesh, workspace);
       const mapCommand = (command) => ({
@@ -93749,9 +94453,6 @@ ${mergeTreeErr?.stderr || ""}`;
     var import_node_child_process11;
     var REFINE_VALIDATION_TIMEOUT_MS;
     var REFINE_VALIDATION_OUTPUT_LIMIT_BYTES;
-    var REFINE_VALIDATION_SUMMARY_HEAD_CHARS;
-    var REFINE_VALIDATION_SUMMARY_TAIL_CHARS;
-    var REFINE_VALIDATION_SUMMARY_CHARS;
     var REFINE_VALIDATION_LOG_DIR;
     var init_mesh_refine_gates = __esm2({
       "src/mesh/mesh-refine-gates.ts"() {
@@ -93769,9 +94470,6 @@ ${mergeTreeErr?.stderr || ""}`;
         init_mesh_refine_gitlink_utils();
         REFINE_VALIDATION_TIMEOUT_MS = 12e4;
         REFINE_VALIDATION_OUTPUT_LIMIT_BYTES = 128 * 1024;
-        REFINE_VALIDATION_SUMMARY_HEAD_CHARS = 2e3;
-        REFINE_VALIDATION_SUMMARY_TAIL_CHARS = 6e3;
-        REFINE_VALIDATION_SUMMARY_CHARS = REFINE_VALIDATION_SUMMARY_HEAD_CHARS + REFINE_VALIDATION_SUMMARY_TAIL_CHARS;
         REFINE_VALIDATION_LOG_DIR = (0, import_path19.join)(".adhdev", "logs");
       }
     });
@@ -97028,6 +97726,7 @@ ${e?.stderr || ""}`;
       ASSISTANT_JOURNAL_TOPIC: () => ASSISTANT_JOURNAL_TOPIC,
       AcpProviderInstance: () => AcpProviderInstance,
       AgentStreamPoller: () => AgentStreamPoller,
+      BEACON_BOARD_TTL_MS: () => BEACON_BOARD_TTL_MS,
       BEACON_ENV: () => BEACON_ENV,
       BUILD_CHANNEL_ENV_VAR: () => BUILD_CHANNEL_ENV_VAR,
       BUILTIN_CHAT_MESSAGE_KINDS: () => BUILTIN_CHAT_MESSAGE_KINDS,
@@ -97093,6 +97792,7 @@ ${e?.stderr || ""}`;
       FLEET_STATUS_PARITY_INTERVAL_MS: () => FLEET_STATUS_PARITY_INTERVAL_MS,
       FLEET_STATUS_PARITY_SUMMARY_INTERVAL_MS: () => FLEET_STATUS_PARITY_SUMMARY_INTERVAL_MS,
       FLEET_STATUS_RING: () => FLEET_STATUS_RING,
+      FLEET_STATUS_SUB_VIEW: () => FLEET_STATUS_SUB_VIEW,
       FLEET_STATUS_TOPIC: () => FLEET_STATUS_TOPIC,
       FsmDriver: () => FsmDriver,
       GOAL_PREVIEW_MAX: () => GOAL_PREVIEW_MAX,
@@ -97299,6 +97999,7 @@ ${e?.stderr || ""}`;
       commitMeshGraphPlan: () => commitMeshGraphPlan,
       compareGitSnapshots: () => compareGitSnapshots,
       compensateWorkspaceIntent: () => compensateWorkspaceIntent,
+      computeBeaconDiagnostics: () => computeBeaconDiagnostics,
       computeMeshGraphPlanDigest: () => computeMeshGraphPlanDigest,
       computeMeshMissionStats: () => computeMeshMissionStats,
       computeMeshTaskStats: () => computeMeshTaskStats,
@@ -97320,6 +98021,7 @@ ${e?.stderr || ""}`;
       createDefaultMeshHostMetadata: () => createDefaultMeshHostMetadata,
       createFleetAuthority: () => createFleetAuthority,
       createFleetAuthorityIfConfigured: () => createFleetAuthorityIfConfigured,
+      createFleetStatusPeerViewConsumer: () => createFleetStatusPeerViewConsumer,
       createGitCompactSummary: () => createGitCompactSummary,
       createGitSnapshotStore: () => createGitSnapshotStore,
       createGitWorkspaceMonitor: () => createGitWorkspaceMonitor2,
@@ -97598,6 +98300,7 @@ ${e?.stderr || ""}`;
       printQuotaRefreshOutcome: () => printQuotaRefreshOutcome2,
       probeCdpPort: () => probeCdpPort,
       projectBeaconReport: () => projectBeaconReport,
+      projectFleetStatusEntry: () => projectFleetStatusEntry,
       projectGraphPublicPolicy: () => projectGraphPublicPolicy,
       projectMeshLedgerEntry: () => projectMeshLedgerEntry,
       pruneOperatingNotes: () => pruneOperatingNotes,
@@ -97615,6 +98318,7 @@ ${e?.stderr || ""}`;
       readCodexCliSession: () => readSession2,
       readDiskSpace: () => readDiskSpace,
       readHermesCliSession: () => readSession4,
+      readKeyStaleAdvisory: () => readKeyStaleAdvisory,
       readLatestCodexRateLimits: () => readLatestCodexRateLimits,
       readLedgerEntries: () => readLedgerEntries,
       readLedgerSlice: () => readLedgerSlice,
@@ -97746,11 +98450,13 @@ ${e?.stderr || ""}`;
       summarizeMeshUsage: () => summarizeMeshUsage,
       summarizeMissionTasks: () => summarizeMissionTasks,
       summarizeSeqscribeStats: () => summarizeSeqscribeStats,
+      summarizeSoleCopy: () => summarizeSoleCopy,
       supportsUnicodeSymbols: () => supportsUnicodeSymbols,
       sweepMeshGraphGateTimeouts: () => sweepMeshGraphGateTimeouts,
       taskDependenciesSatisfied: () => taskDependenciesSatisfied,
       taskIsParked: () => taskIsParked,
       terminalizeSiblingDispatch: () => terminalizeSiblingDispatch,
+      toBeaconDiagnosticsSummary: () => toBeaconDiagnosticsSummary,
       toJsonValue: () => toJsonValue,
       tombstoneOperatingNote: () => tombstoneOperatingNote,
       totalTokens: () => totalTokens,
@@ -98826,1066 +99532,421 @@ ${e?.stderr || ""}`;
           if (popResult !== void 0 && "success" in popResult) return popResult;
           return { success: true, stashPopped: true };
         }
-        case "git_checkout_files": {
-          if (!services.checkoutFiles) return serviceNotImplemented(command);
-          const paths = args?.paths;
-          if (!Array.isArray(paths) || paths.length === 0) {
-            return failure("invalid_args", "paths must be a non-empty array");
-          }
-          if (paths.length > 50) {
-            return failure("invalid_args", "paths array exceeds maximum of 50 entries");
-          }
-          const checkoutResult = await runService(() => services.checkoutFiles({ workspace, paths }));
-          return "success" in checkoutResult ? checkoutResult : { success: true, checkedOut: checkoutResult.checkedOut };
-        }
-        case "git_remote_url": {
-          if (!services.getRemoteUrl) return serviceNotImplemented(command);
-          const remote = typeof args?.remote === "string" && args.remote.trim() ? args.remote.trim() : "origin";
-          const remoteResult = await runService(() => services.getRemoteUrl({ workspace, remote }));
-          if ("success" in remoteResult) return remoteResult;
-          return { success: true, remoteUrl: remoteResult.remoteUrl, remote: remoteResult.remote };
-        }
-        case "git_push": {
-          if (!services.push) return serviceNotImplemented(command);
-          const remote = typeof args?.remote === "string" && args.remote.trim() ? args.remote.trim() : "origin";
-          const branch = typeof args?.branch === "string" && args.branch.trim() ? args.branch.trim() : void 0;
-          const setUpstream = Boolean(args?.setUpstream);
-          if (!/^[a-zA-Z0-9_.\-]+$/.test(remote)) {
-            return failure("invalid_args", "remote must contain only alphanumeric characters, dots, hyphens, and underscores");
-          }
-          if (branch !== void 0 && !/^[a-zA-Z0-9/_.\-]+$/.test(branch)) {
-            return failure("invalid_args", "branch must contain only alphanumeric characters, slashes, dots, hyphens, and underscores");
-          }
-          const pushResult = await runService(() => services.push({ workspace, remote, branch, setUpstream }));
-          return "success" in pushResult ? pushResult : { success: true, push: pushResult };
-        }
-        default:
-          return failure("invalid_args", `Unknown Git command: ${command}`);
-      }
-    }
-    function validateMutatingMessage(value) {
-      if (typeof value !== "string" || !value.trim()) {
-        return failure("invalid_args", "message must be a non-empty string");
-      }
-      const msg = value.trim();
-      if (msg.length > 200) {
-        return failure("invalid_args", "message must be 200 characters or fewer");
-      }
-      return msg;
-    }
-    async function gitCheckpoint(workspace, message, includeUntracked) {
-      const repo = await resolveGitRepository(workspace);
-      const repoRoot = repo.repoRoot;
-      const statusResult = await getGitRepoStatus(workspace, { forceFresh: true });
-      if (statusResult.hasConflicts) {
-        throw new GitCommandError("conflict", "Repository has conflicts \u2014 resolve before checkpointing");
-      }
-      const dirtySubmodules = (statusResult.submodules || []).filter((submodule) => submodule.dirty);
-      if (dirtySubmodules.length > 0) {
-        const paths = dirtySubmodules.map((submodule) => submodule.path).join(", ");
-        throw new GitCommandError(
-          "dirty_index_required",
-          `Repository has dirty submodules that must be checkpointed first: ${paths}. Checkpoint or commit each dirty submodule, then checkpoint this repository to record gitlink changes.`
-        );
-      }
-      const addArgs = includeUntracked ? ["-A"] : ["-u"];
-      await runGit(repo, ["add", ...addArgs], { cwd: repoRoot });
-      const fullMsg = `adhdev: checkpoint ${message}`;
-      let commitSha;
-      try {
-        await runGit(repo, ["commit", "-m", fullMsg], { cwd: repoRoot });
-        const revResult = await runGit(repo, ["rev-parse", "HEAD"], { cwd: repoRoot });
-        commitSha = revResult.stdout.trim();
-      } catch (err) {
-        const output = (err?.stdout || "") + (err?.stderr || "");
-        if (/nothing to commit/i.test(output)) {
-          return {
-            workspace: repo.workspace,
-            repoRoot,
-            isGitRepo: true,
-            message: fullMsg,
-            status: "skipped",
-            skipped: true,
-            noop: true,
-            reason: "nothing_to_commit",
-            lastCheckedAt: Date.now()
-          };
-        }
-        throw err;
-      }
-      return {
-        workspace: repo.workspace,
-        repoRoot,
-        isGitRepo: true,
-        commit: commitSha,
-        message: fullMsg,
-        status: "created",
-        lastCheckedAt: Date.now()
-      };
-    }
-    async function gitStashPush(workspace, message, includeUntracked) {
-      const repo = await resolveGitRepository(workspace);
-      const repoRoot = repo.repoRoot;
-      const stashArgs = ["stash", "push", "-m", message];
-      if (includeUntracked) stashArgs.push("--include-untracked");
-      const result = await runGit(repo, stashArgs, { cwd: repoRoot });
-      if (/No local changes to save/i.test(result.stdout + result.stderr)) {
-        throw new GitCommandError("git_command_failed", "Nothing to stash");
-      }
-      return {
-        workspace: repo.workspace,
-        repoRoot,
-        isGitRepo: true,
-        stashRef: "stash@{0}",
-        message,
-        lastCheckedAt: Date.now()
-      };
-    }
-    async function gitStashPop(workspace, stashRef) {
-      const repo = await resolveGitRepository(workspace);
-      const repoRoot = repo.repoRoot;
-      const popArgs = stashRef ? ["stash", "pop", stashRef] : ["stash", "pop"];
-      await runGit(repo, popArgs, { cwd: repoRoot });
-    }
-    async function gitCheckoutFiles(workspace, paths) {
-      const repo = await resolveGitRepository(workspace);
-      const repoRoot = repo.repoRoot;
-      const normalizedPaths = [];
-      for (const p of paths) {
-        if (typeof p !== "string" || !p.trim() || p.includes("\0")) {
-          throw new GitCommandError("invalid_args", `Invalid path: ${String(p)}`);
-        }
-        if (path15.isAbsolute(p)) {
-          throw new GitCommandError("invalid_args", `Path must be repository-relative, not absolute: ${p}`);
-        }
-        const normalized = path15.normalize(p.trim()).split(path15.sep).join("/");
-        if (normalized.startsWith("../") || normalized === "..") {
-          throw new GitCommandError("path_outside_repo", `Path is outside repository root: ${p}`);
-        }
-        const absolutePath = path15.resolve(repoRoot, normalized);
-        if (!isPathInside(repoRoot, absolutePath)) {
-          throw new GitCommandError("path_outside_repo", `Path is outside repository root: ${p}`);
-        }
-        normalizedPaths.push(normalized);
-      }
-      await runGit(repo, ["checkout", "--", ...normalizedPaths], { cwd: repoRoot });
-      return { checkedOut: normalizedPaths };
-    }
-    async function gitGetRemoteUrl(workspace, remote) {
-      const repo = await resolveGitRepository(workspace);
-      const result = await runGit(repo, ["remote", "get-url", remote], { cwd: repo.repoRoot });
-      const remoteUrl = result.stdout.trim();
-      if (!remoteUrl) {
-        throw new GitCommandError("git_command_failed", `Remote '${remote}' has no URL`);
-      }
-      return { remoteUrl, remote };
-    }
-    async function gitPush(workspace, remote, branch, setUpstream) {
-      const lastCheckedAt = Date.now();
-      const repo = await resolveGitRepository(workspace);
-      const repoRoot = repo.repoRoot;
-      let resolvedBranch = branch;
-      if (!resolvedBranch) {
-        const branchResult = await runGit(repo, ["symbolic-ref", "--short", "HEAD"], { cwd: repoRoot });
-        resolvedBranch = branchResult.stdout.trim();
-        if (!resolvedBranch) {
-          throw new GitCommandError("git_command_failed", "Cannot push: not on a branch (detached HEAD)");
-        }
-      }
-      const pushArgs = ["push"];
-      if (setUpstream) pushArgs.push("--set-upstream");
-      pushArgs.push(remote, resolvedBranch);
-      let output = "";
-      let newBranch = false;
-      try {
-        const result = await runGit(repo, pushArgs, { cwd: repoRoot });
-        output = (result.stdout + result.stderr).trim();
-        newBranch = /\[new branch\]/i.test(output);
-      } catch (err) {
-        const errOutput = (err?.stdout ?? "") + (err?.stderr ?? "");
-        if (!setUpstream && /no upstream branch|set-upstream/i.test(errOutput)) {
-          const retryArgs = ["push", "--set-upstream", remote, resolvedBranch];
-          const retryResult = await runGit(repo, retryArgs, { cwd: repoRoot });
-          output = (retryResult.stdout + retryResult.stderr).trim();
-          newBranch = /\[new branch\]/i.test(output);
-        } else {
-          throw new GitCommandError("git_command_failed", errOutput || err?.message || "git push failed");
-        }
-      }
-      return {
-        workspace: repo.workspace,
-        repoRoot,
-        isGitRepo: true,
-        remote,
-        branch: resolvedBranch,
-        output,
-        newBranch,
-        lastCheckedAt
-      };
-    }
-    function formatOptionalGitLogRangeArg(flag, value) {
-      return value ? [`${flag}=${value}`] : [];
-    }
-    async function getGitLog(workspace, options) {
-      const lastCheckedAt = Date.now();
-      const repo = await resolveGitRepository(workspace);
-      const repoRoot = repo.repoRoot;
-      const boundedLimit = Math.max(1, Math.min(200, Math.floor(options.limit || 50)));
-      const selectedPath = options.path ? validateGitLogPath(repoRoot, options.path) : void 0;
-      const result = await runGit(
-        repo,
-        [
-          "log",
-          `--max-count=${boundedLimit}`,
-          "--format=%H%x00%an%x00%ae%x00%at%x00%ct%x00%s",
-          ...formatOptionalGitLogRangeArg("--since", options.since),
-          ...formatOptionalGitLogRangeArg("--until", options.until),
-          "--",
-          ...selectedPath ? [selectedPath] : []
-        ],
-        { cwd: repoRoot }
-      );
-      const entries = result.stdout.split("\n").filter((line) => line.trim().length > 0).map((line) => {
-        const [commit = "", authorName, authorEmail, authoredAt, committedAt, ...messageParts] = line.split("\0");
-        return {
-          commit,
-          message: messageParts.join("\0"),
-          authorName: authorName || void 0,
-          authorEmail: authorEmail || void 0,
-          authoredAt: authoredAt ? Number.parseInt(authoredAt, 10) * 1e3 : void 0,
-          committedAt: committedAt ? Number.parseInt(committedAt, 10) * 1e3 : void 0
-        };
-      }).filter((entry) => entry.commit.length > 0);
-      return {
-        workspace: repo.workspace,
-        repoRoot,
-        isGitRepo: true,
-        entries,
-        limit: boundedLimit,
-        truncated: entries.length >= boundedLimit,
-        lastCheckedAt
-      };
-    }
-    function validateGitLogPath(repoRoot, filePath) {
-      if (!filePath.trim() || filePath.includes("\0")) {
-        throw new GitCommandError("invalid_args", "path must be a non-empty repository-relative path");
-      }
-      if (path15.isAbsolute(filePath)) {
-        throw new GitCommandError("invalid_args", "path must be repository-relative");
-      }
-      const normalized = path15.normalize(filePath).split(path15.sep).join("/");
-      const absolutePath = path15.resolve(repoRoot, normalized);
-      if (!isPathInside(repoRoot, absolutePath) || normalized.startsWith("../") || normalized === "..") {
-        throw new GitCommandError("path_outside_repo", "Git log path is outside the repository root");
-      }
-      return normalized;
-    }
-    var BUSY_STATUSES = /* @__PURE__ */ new Set(["streaming", "waiting_approval"]);
-    var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["idle", "error"]);
-    var TurnSnapshotTracker = class {
-      lastStatus = /* @__PURE__ */ new Map();
-      onTurnCompleted;
-      constructor(onTurnCompleted) {
-        this.onTurnCompleted = onTurnCompleted;
-      }
-      record(sessionId, status, workspace) {
-        const prev = this.lastStatus.get(sessionId);
-        this.lastStatus.set(sessionId, status);
-        if (workspace && prev && BUSY_STATUSES.has(prev) && TERMINAL_STATUSES.has(status)) {
-          this.onTurnCompleted({ sessionId, workspace });
-        }
-      }
-      forget(sessionId) {
-        this.lastStatus.delete(sessionId);
-      }
-    };
-    init_git_worktree();
-    init_config();
-    init_config_dir();
-    init_embedded_path_health();
-    var os11 = __toESM2(require("os"));
-    var path17 = __toESM2(require("path"));
-    var import_session_host_core22 = require_dist();
-    init_config_dir();
-    init_track_identity();
-    var DEFAULT_SESSION_HOST_APP_NAME = IDENTITY.sessionHostName;
-    var RESERVED_GLOBAL_SESSION_HOST_APP_NAME = IDENTITY.sessionHostName;
-    var DEFAULT_STANDALONE_SESSION_HOST_APP_NAME = "adhdev-standalone";
-    function getReservedStandaloneNamespaceWarning() {
-      return `Standalone session-host namespace '${RESERVED_GLOBAL_SESSION_HOST_APP_NAME}' is reserved for the global daemon. Falling back to '${DEFAULT_STANDALONE_SESSION_HOST_APP_NAME}' for this standalone run.`;
-    }
-    function resolveSessionHostAppNameResolution2(options = {}) {
-      const env2 = options.env || process.env;
-      const explicit = typeof env2.ADHDEV_SESSION_HOST_NAME === "string" ? env2.ADHDEV_SESSION_HOST_NAME.trim() : "";
-      if (explicit) {
-        if (options.standalone && explicit === RESERVED_GLOBAL_SESSION_HOST_APP_NAME) {
-          return {
-            appName: DEFAULT_STANDALONE_SESSION_HOST_APP_NAME,
-            warning: getReservedStandaloneNamespaceWarning(),
-            source: "reserved-standalone-fallback"
-          };
-        }
-        return {
-          appName: explicit,
-          source: "explicit"
-        };
-      }
-      return {
-        appName: options.standalone ? DEFAULT_STANDALONE_SESSION_HOST_APP_NAME : DEFAULT_SESSION_HOST_APP_NAME,
-        source: "default"
-      };
-    }
-    function resolveSessionHostAppName(options = {}) {
-      return resolveSessionHostAppNameResolution2(options).appName;
-    }
-    var InstanceContextConflictError = class extends Error {
-      constructor(message) {
-        super(message);
-        this.name = "InstanceContextConflictError";
-      }
-    };
-    var cached22 = null;
-    function resolveInstanceContext(options = {}) {
-      const env2 = options.env ?? process.env;
-      const homeDir2 = options.homeDir ?? os11.homedir();
-      const envDir = typeof env2.ADHDEV_CONFIG_DIR === "string" ? env2.ADHDEV_CONFIG_DIR.trim() : "";
-      const explicitDir = typeof options.configDir === "string" ? options.configDir.trim() : "";
-      if (explicitDir && envDir && (0, import_session_host_core22.canonicalizeInstancePath)(explicitDir) !== (0, import_session_host_core22.canonicalizeInstancePath)(envDir)) {
-        throw new InstanceContextConflictError(
-          `Conflicting instance identity: explicit configDir "${explicitDir}" vs ADHDEV_CONFIG_DIR "${envDir}". Refusing to merge mutable namespaces \u2014 fix the caller or unset one of the two.`
-        );
-      }
-      const configDir = explicitDir || resolveConfigDir(env2, homeDir2);
-      const trimmed = configDir.replace(/[\\/]+$/, "");
-      return {
-        configDir,
-        canonicalConfigDir: (0, import_session_host_core22.canonicalizeInstancePath)(configDir),
-        instanceDir: path17.basename(trimmed) || ".adhdev",
-        isDefault: (0, import_session_host_core22.isDefaultInstanceConfigDir)(configDir, homeDir2),
-        ipcKey: (0, import_session_host_core22.resolveSessionHostIpcKey)(configDir, homeDir2),
-        sessionHostAppName: resolveSessionHostAppName({ standalone: options.standalone, env: env2 })
-      };
-    }
-    function getProcessInstanceContext(options = {}) {
-      const envDir = typeof process.env.ADHDEV_CONFIG_DIR === "string" ? process.env.ADHDEV_CONFIG_DIR.trim() : "";
-      const key2 = `${envDir}|${os11.homedir()}|${options.standalone ? "standalone" : "daemon"}`;
-      if (!cached22 || cached22.key !== key2) {
-        cached22 = { key: key2, context: resolveInstanceContext({ standalone: options.standalone }) };
-      }
-      return cached22.context;
-    }
-    function resetProcessInstanceContextForTests() {
-      cached22 = null;
-    }
-    init_workspaces();
-    init_recent_activity();
-    var path20 = __toESM2(require("path"));
-    init_workspaces();
-    init_summary_metadata();
-    var MAX_SAVED_SESSIONS = 500;
-    function normalizeWorkspace2(workspace) {
-      if (!workspace) return "";
-      try {
-        return path20.resolve(expandPath(workspace));
-      } catch {
-        return path20.resolve(workspace);
-      }
-    }
-    function buildSavedProviderSessionKey(providerSessionId) {
-      return `saved:${providerSessionId.trim()}`;
-    }
-    function upsertSavedProviderSession(state, entry) {
-      const providerSessionId = typeof entry.providerSessionId === "string" ? entry.providerSessionId.trim() : "";
-      if (!providerSessionId) return state;
-      const id = buildSavedProviderSessionKey(providerSessionId);
-      const existing = (state.savedProviderSessions || []).find((item) => item.id === id);
-      const nextEntry = {
-        id,
-        kind: entry.kind,
-        providerType: entry.providerType,
-        providerName: entry.providerName,
-        providerSessionId,
-        workspace: entry.workspace ? normalizeWorkspace2(entry.workspace) : void 0,
-        summaryMetadata: normalizePersistedSummaryMetadata({
-          summaryMetadata: entry.summaryMetadata
-        }),
-        title: entry.title,
-        createdAt: existing?.createdAt || entry.createdAt || Date.now(),
-        lastUsedAt: entry.lastUsedAt || Date.now()
-      };
-      const filtered = (state.savedProviderSessions || []).filter((item) => item.id !== id);
-      return {
-        ...state,
-        savedProviderSessions: [nextEntry, ...filtered].slice(0, MAX_SAVED_SESSIONS)
-      };
-    }
-    function getSavedProviderSessions(state, filters) {
-      return [...state.savedProviderSessions || []].filter((entry) => {
-        if (filters?.providerType && entry.providerType !== filters.providerType) return false;
-        if (filters?.kind && entry.kind !== filters.kind) return false;
-        return true;
-      }).map((entry) => ({
-        ...entry,
-        summaryMetadata: normalizePersistedSummaryMetadata({
-          summaryMetadata: entry.summaryMetadata
-        })
-      })).sort((a, b) => b.lastUsedAt - a.lastUsedAt);
-    }
-    init_mesh_config();
-    init_dist();
-    init_dist();
-    init_dist();
-    init_dist();
-    init_coordinator_prompt();
-    init_mesh_missions();
-    init_mesh_task_stats();
-    init_mesh_review_inbox();
-    var import_node_child_process5 = require("child_process");
-    var import_promises5 = require("fs/promises");
-    var import_node_path2 = require("path");
-    var import_node_util4 = require("util");
-    init_git_locale();
-    init_repo_mesh_types();
-    init_mesh_config();
-    var import_fs13 = require("fs");
-    var import_path11 = require("path");
-    init_refine_config();
-    init_worktree_bootstrap_config();
-    init_change_impact_config();
-    init_mesh_config();
-    var MESH_INIT_REFINE_CONFIG_PATH = MESH_REFINE_CONFIG_LOCATIONS[0];
-    var MESH_INIT_WORKTREE_BOOTSTRAP_CONFIG_PATH = MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS[0];
-    var MESH_INIT_CHANGE_IMPACT_CONFIG_PATH = CHANGE_IMPACT_CONFIG_LOCATIONS[0];
-    var CANDIDATE_STALE_INPUTS = [
-      "package-lock.json",
-      "pnpm-lock.yaml",
-      "yarn.lock",
-      "bun.lockb",
-      "Cargo.lock",
-      "go.sum",
-      "poetry.lock",
-      "requirements.txt"
-    ];
-    function writeConfigFile(workspace, relativePath, config2) {
-      const target = (0, import_path11.join)(workspace, relativePath);
-      (0, import_fs13.mkdirSync)((0, import_path11.dirname)(target), { recursive: true });
-      (0, import_fs13.writeFileSync)(target, `${JSON.stringify(config2, null, 2)}
-`, "utf-8");
-      return target;
-    }
-    function suggestMeshWorktreeBootstrapConfig(workspace) {
-      const commands = [];
-      const hasPackageJson = (0, import_fs13.existsSync)((0, import_path11.join)(workspace, "package.json"));
-      const hasNpmLock = (0, import_fs13.existsSync)((0, import_path11.join)(workspace, "package-lock.json"));
-      if (hasPackageJson) {
-        commands.push(
-          hasNpmLock ? { command: "npm", args: ["ci"] } : { command: "npm", args: ["install"] }
-        );
-      }
-      const staleInputs = CANDIDATE_STALE_INPUTS.filter((relative8) => (0, import_fs13.existsSync)((0, import_path11.join)(workspace, relative8)));
-      if (!commands.length) {
-        return { commands, staleInputs };
-      }
-      return {
-        commands,
-        staleInputs,
-        suggestedConfig: {
-          version: 1,
-          enabled: true,
-          runOnClone: true,
-          required: false,
-          commands,
-          ...staleInputs.length ? { staleInputs } : {}
-        }
-      };
-    }
-    var PROVIDER_PRIORITY_PREFERENCE = ["claude-cli", "codex-cli", "gemini-cli"];
-    function suggestNodeProviderPriority(detected) {
-      const installed = detected.filter((cli) => cli.installed);
-      const installedIds = installed.map((cli) => cli.id);
-      const preferred = PROVIDER_PRIORITY_PREFERENCE.filter((id) => installedIds.includes(id));
-      const rest = installedIds.filter((id) => !preferred.includes(id));
-      const providerPriority = [...preferred, ...rest];
-      return {
-        providerPriority,
-        installedProviders: installed.map((cli) => ({
-          id: cli.id,
-          displayName: cli.displayName,
-          ...cli.version ? { version: cli.version } : {}
-        }))
-      };
-    }
-    function runMeshInit(mesh, workspace, detected, options = {}) {
-      const write = options.write === true;
-      const overwrite = options.overwrite === true;
-      const refine2 = applyConfigSuggestion({
-        workspace,
-        relativePath: MESH_INIT_REFINE_CONFIG_PATH,
-        existing: loadMeshRefineConfig(mesh, workspace).config,
-        suggestedConfig: suggestMeshRefineConfig(mesh, workspace).suggestedConfig,
-        validate: (config2) => validateMeshRefineConfig(config2, MESH_INIT_REFINE_CONFIG_PATH).valid,
-        write,
-        overwrite
-      });
-      const bootstrapSuggestion = suggestMeshWorktreeBootstrapConfig(workspace);
-      const worktreeBootstrap = applyConfigSuggestion({
-        workspace,
-        relativePath: MESH_INIT_WORKTREE_BOOTSTRAP_CONFIG_PATH,
-        existing: loadMeshWorktreeBootstrapConfig(mesh, workspace).config,
-        suggestedConfig: bootstrapSuggestion.suggestedConfig,
-        validate: (config2) => validateMeshWorktreeBootstrapConfig(config2, MESH_INIT_WORKTREE_BOOTSTRAP_CONFIG_PATH).valid,
-        write,
-        overwrite
-      });
-      const changeImpactLoaded = loadChangeImpactConfig(workspace);
-      const changeImpact = applyConfigSuggestion({
-        workspace,
-        relativePath: MESH_INIT_CHANGE_IMPACT_CONFIG_PATH,
-        existing: changeImpactLoaded.sourceType === "repo_file" ? changeImpactLoaded.config : void 0,
-        suggestedConfig: suggestChangeImpactConfig(workspace).suggestedConfig,
-        validate: (config2) => validateChangeImpactConfig(config2, MESH_INIT_CHANGE_IMPACT_CONFIG_PATH).valid,
-        write,
-        overwrite
-      });
-      const providers = suggestNodeProviderPriority(detected);
-      const refineLoaded = loadMeshRefineConfig(mesh, workspace);
-      const bootstrapLoaded = loadMeshWorktreeBootstrapConfig(mesh, workspace);
-      let magiKindPanels = {};
-      try {
-        magiKindPanels = listMagiKindPanelsReadOnly(typeof mesh?.id === "string" ? mesh.id : void 0);
-      } catch {
-        magiKindPanels = {};
+        case "git_checkout_files": {
+          if (!services.checkoutFiles) return serviceNotImplemented(command);
+          const paths = args?.paths;
+          if (!Array.isArray(paths) || paths.length === 0) {
+            return failure("invalid_args", "paths must be a non-empty array");
+          }
+          if (paths.length > 50) {
+            return failure("invalid_args", "paths array exceeds maximum of 50 entries");
+          }
+          const checkoutResult = await runService(() => services.checkoutFiles({ workspace, paths }));
+          return "success" in checkoutResult ? checkoutResult : { success: true, checkedOut: checkoutResult.checkedOut };
+        }
+        case "git_remote_url": {
+          if (!services.getRemoteUrl) return serviceNotImplemented(command);
+          const remote = typeof args?.remote === "string" && args.remote.trim() ? args.remote.trim() : "origin";
+          const remoteResult = await runService(() => services.getRemoteUrl({ workspace, remote }));
+          if ("success" in remoteResult) return remoteResult;
+          return { success: true, remoteUrl: remoteResult.remoteUrl, remote: remoteResult.remote };
+        }
+        case "git_push": {
+          if (!services.push) return serviceNotImplemented(command);
+          const remote = typeof args?.remote === "string" && args.remote.trim() ? args.remote.trim() : "origin";
+          const branch = typeof args?.branch === "string" && args.branch.trim() ? args.branch.trim() : void 0;
+          const setUpstream = Boolean(args?.setUpstream);
+          if (!/^[a-zA-Z0-9_.\-]+$/.test(remote)) {
+            return failure("invalid_args", "remote must contain only alphanumeric characters, dots, hyphens, and underscores");
+          }
+          if (branch !== void 0 && !/^[a-zA-Z0-9/_.\-]+$/.test(branch)) {
+            return failure("invalid_args", "branch must contain only alphanumeric characters, slashes, dots, hyphens, and underscores");
+          }
+          const pushResult = await runService(() => services.push({ workspace, remote, branch, setUpstream }));
+          return "success" in pushResult ? pushResult : { success: true, push: pushResult };
+        }
+        default:
+          return failure("invalid_args", `Unknown Git command: ${command}`);
       }
-      const currentConfig2 = {
-        refine: refineLoaded.config,
-        worktreeBootstrap: bootstrapLoaded.config,
-        changeImpact: changeImpactLoaded.sourceType === "repo_file" ? changeImpactLoaded.config : void 0,
-        sourceTypes: {
-          refine: refineLoaded.sourceType,
-          worktreeBootstrap: bootstrapLoaded.sourceType,
-          changeImpact: changeImpactLoaded.sourceType
-        },
-        magiKindPanels
-      };
-      return {
-        success: true,
-        workspace,
-        dryRun: !write,
-        refine: refine2,
-        worktreeBootstrap,
-        changeImpact,
-        providers,
-        currentConfig: currentConfig2,
-        note: write ? "Configs written to disk are the execution source of truth; suggestions are scaffold and only take effect once saved. providerPriority is a recommendation \u2014 apply it to node policy via clone/policy update. currentConfig echoes what was on disk before this run." : "Dry-run: no files written. Re-run with write=true to persist the suggested configs. Heuristic suggestions never execute until saved as repo config. Use currentConfig to diff current-vs-suggested before overwriting."
-      };
     }
-    function applyConfigSuggestion(input) {
-      const { workspace, relativePath, existing, suggestedConfig, validate, write, overwrite } = input;
-      const absolute = (0, import_path11.join)(workspace, relativePath);
-      if (existing !== void 0 && !overwrite) {
-        return { path: absolute, relativePath, written: false, skippedReason: "already_exists", config: existing };
-      }
-      if (!suggestedConfig || !validate(suggestedConfig)) {
-        return { path: absolute, relativePath, written: false, skippedReason: "no_suggestion" };
+    function validateMutatingMessage(value) {
+      if (typeof value !== "string" || !value.trim()) {
+        return failure("invalid_args", "message must be a non-empty string");
       }
-      if (!write) {
-        return { path: absolute, relativePath, written: false, config: suggestedConfig };
+      const msg = value.trim();
+      if (msg.length > 200) {
+        return failure("invalid_args", "message must be 200 characters or fewer");
       }
-      const writtenPath = writeConfigFile(workspace, relativePath, suggestedConfig);
-      return { path: writtenPath, relativePath, written: true, config: suggestedConfig };
+      return msg;
     }
-    init_git_worktree();
-    var execFileAsync3 = (0, import_node_util4.promisify)(import_node_child_process5.execFile);
-    var GIT_TIMEOUT_MS2 = 15e3;
-    async function git(cwd, args, allowFailure = false) {
-      try {
-        const { stdout } = await execFileAsync3("git", args, {
-          cwd,
-          encoding: "utf8",
-          timeout: GIT_TIMEOUT_MS2,
-          maxBuffer: 4 * 1024 * 1024,
-          windowsHide: true,
-          env: gitChildEnv()
-        });
-        return (stdout || "").trim();
-      } catch (error48) {
-        if (allowFailure) return "";
-        const stderr = typeof error48?.stderr === "string" ? error48.stderr.trim() : "";
-        throw new Error(stderr || error48?.message || `git ${args[0]} failed`);
+    async function gitCheckpoint(workspace, message, includeUntracked) {
+      const repo = await resolveGitRepository(workspace);
+      const repoRoot = repo.repoRoot;
+      const statusResult = await getGitRepoStatus(workspace, { forceFresh: true });
+      if (statusResult.hasConflicts) {
+        throw new GitCommandError("conflict", "Repository has conflicts \u2014 resolve before checkpointing");
       }
-    }
-    async function canonicalPath(path63) {
-      const absolute = (0, import_node_path2.resolve)(path63);
-      try {
-        return await (0, import_promises5.realpath)(absolute);
-      } catch {
-        return absolute;
+      const dirtySubmodules = (statusResult.submodules || []).filter((submodule) => submodule.dirty);
+      if (dirtySubmodules.length > 0) {
+        const paths = dirtySubmodules.map((submodule) => submodule.path).join(", ");
+        throw new GitCommandError(
+          "dirty_index_required",
+          `Repository has dirty submodules that must be checkpointed first: ${paths}. Checkpoint or commit each dirty submodule, then checkpoint this repository to record gitlink changes.`
+        );
       }
-    }
-    function pathInside(child, parent) {
-      const rel = (0, import_node_path2.relative)(parent, child);
-      return rel !== "" && rel !== ".." && !rel.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) && !(0, import_node_path2.isAbsolute)(rel);
-    }
-    function failure2(code, error48, action, extra = {}) {
-      return { success: false, dryRun: true, code, error: error48, action, ...extra };
-    }
-    function isPlanFailure(value) {
-      return value.success === false;
-    }
-    function parseStatus(raw) {
-      const lines = raw.split(/\r?\n/).filter((line) => line && !line.startsWith("# "));
-      const conflictFiles = [];
-      for (const line of lines) {
-        if (line.startsWith("u ")) {
-          const fields = line.split(" ");
-          conflictFiles.push(fields.slice(10).join(" ") || fields.at(-1) || "(unknown)");
-          continue;
-        }
-        if (line.startsWith("1 ") || line.startsWith("2 ")) {
-          const xy = line.slice(2, 4);
-          if (["DD", "AU", "UD", "UA", "DU", "AA", "UU"].includes(xy)) {
-            conflictFiles.push(line.split(" ").at(-1) || "(unknown)");
-          }
+      const addArgs = includeUntracked ? ["-A"] : ["-u"];
+      await runGit(repo, ["add", ...addArgs], { cwd: repoRoot });
+      const fullMsg = `adhdev: checkpoint ${message}`;
+      let commitSha;
+      try {
+        await runGit(repo, ["commit", "-m", fullMsg], { cwd: repoRoot });
+        const revResult = await runGit(repo, ["rev-parse", "HEAD"], { cwd: repoRoot });
+        commitSha = revResult.stdout.trim();
+      } catch (err) {
+        const output = (err?.stdout || "") + (err?.stderr || "");
+        if (/nothing to commit/i.test(output)) {
+          return {
+            workspace: repo.workspace,
+            repoRoot,
+            isGitRepo: true,
+            message: fullMsg,
+            status: "skipped",
+            skipped: true,
+            noop: true,
+            reason: "nothing_to_commit",
+            lastCheckedAt: Date.now()
+          };
         }
+        throw err;
       }
       return {
-        dirty: lines.length > 0,
-        changedFileCount: lines.length,
-        hasConflicts: conflictFiles.length > 0,
-        conflictFiles
+        workspace: repo.workspace,
+        repoRoot,
+        isGitRepo: true,
+        commit: commitSha,
+        message: fullMsg,
+        status: "created",
+        lastCheckedAt: Date.now()
       };
     }
-    async function discoverRemotes(repoRoot, currentBranch) {
-      const names = (await git(repoRoot, ["remote"], true)).split(/\r?\n/).map((v) => v.trim()).filter(Boolean);
-      const remotes = [];
-      for (const name of names) {
-        const urls = (await git(repoRoot, ["remote", "get-url", "--all", name], true)).split(/\r?\n/).map((v) => v.trim()).filter(Boolean);
-        const identities2 = [...new Set(urls.map(normalizeRepoIdentity).filter(Boolean))];
-        remotes.push({ name, urls, identities: identities2 });
+    async function gitStashPush(workspace, message, includeUntracked) {
+      const repo = await resolveGitRepository(workspace);
+      const repoRoot = repo.repoRoot;
+      const stashArgs = ["stash", "push", "-m", message];
+      if (includeUntracked) stashArgs.push("--include-untracked");
+      const result = await runGit(repo, stashArgs, { cwd: repoRoot });
+      if (/No local changes to save/i.test(result.stdout + result.stderr)) {
+        throw new GitCommandError("git_command_failed", "Nothing to stash");
       }
-      const origin = remotes.find((remote) => remote.name === "origin");
-      const trackingRemoteName = await git(repoRoot, ["config", "--get", `branch.${currentBranch}.remote`], true);
-      const upstream = remotes.find((remote) => remote.name === trackingRemoteName) || remotes.find((remote) => remote.name === "upstream");
-      const identities = [...new Set(remotes.flatMap((remote) => remote.identities))];
-      const selectedRemote = origin || upstream || (remotes.length === 1 ? remotes[0] : void 0);
       return {
-        remotes,
-        origin,
-        upstream,
-        selectedRemote,
-        ambiguous: identities.length > 1 || !!remotes.find((remote) => remote.identities.length > 1)
+        workspace: repo.workspace,
+        repoRoot,
+        isGitRepo: true,
+        stashRef: "stash@{0}",
+        message,
+        lastCheckedAt: Date.now()
       };
     }
-    async function deriveLocalRepoIdentity(repoRoot) {
-      const raw = await git(repoRoot, ["rev-list", "--max-parents=0", "HEAD"], true);
-      const roots = raw.split(/\r?\n/).map((line) => line.trim()).filter((line) => /^[0-9a-f]{40}$/i.test(line)).sort();
-      const root = roots[0];
-      return root ? `local/${root.toLowerCase()}` : "";
-    }
-    async function resolveDefaultBranch(repoRoot, remoteName, currentBranch) {
-      const symbolic = await git(repoRoot, ["symbolic-ref", "--quiet", "--short", `refs/remotes/${remoteName}/HEAD`], true);
-      if (symbolic.startsWith(`${remoteName}/`)) return symbolic.slice(remoteName.length + 1);
-      for (const candidate of ["main", "master"]) {
-        const exists = await git(repoRoot, ["rev-parse", "--verify", "--quiet", `refs/remotes/${remoteName}/${candidate}`], true) || await git(repoRoot, ["rev-parse", "--verify", "--quiet", `refs/heads/${candidate}`], true);
-        if (exists) return candidate;
-      }
-      return currentBranch;
+    async function gitStashPop(workspace, stashRef) {
+      const repo = await resolveGitRepository(workspace);
+      const repoRoot = repo.repoRoot;
+      const popArgs = stashRef ? ["stash", "pop", stashRef] : ["stash", "pop"];
+      await runGit(repo, popArgs, { cwd: repoRoot });
     }
-    async function discoverGit(workspaceInput) {
-      const workspace = await canonicalPath(workspaceInput || process.cwd());
-      const repoRootRaw = await git(workspace, ["rev-parse", "--show-toplevel"], true);
-      if (!repoRootRaw) {
-        return failure2(
-          "not_git_repository",
-          `Not a Git repository: ${workspace}`,
-          "Choose a directory inside a Git checkout, or initialize/clone the repository before planning Repo Mesh onboarding."
-        );
-      }
-      const repoRoot = await canonicalPath(repoRootRaw);
-      const gitDirRaw = await git(repoRoot, ["rev-parse", "--git-dir"]);
-      const commonDirRaw = await git(repoRoot, ["rev-parse", "--git-common-dir"]);
-      const gitDir = await canonicalPath((0, import_node_path2.isAbsolute)(gitDirRaw) ? gitDirRaw : (0, import_node_path2.resolve)(repoRoot, gitDirRaw));
-      const commonDir = await canonicalPath((0, import_node_path2.isAbsolute)(commonDirRaw) ? commonDirRaw : (0, import_node_path2.resolve)(repoRoot, commonDirRaw));
-      const currentBranch = await git(repoRoot, ["symbolic-ref", "--quiet", "--short", "HEAD"], true);
-      const headCommit = await git(repoRoot, ["rev-parse", "HEAD"], true);
-      const worktrees = await listWorktrees(repoRoot);
-      const canonicalWorktrees = await Promise.all(worktrees.map(async (entry) => ({
-        ...entry,
-        path: await canonicalPath(entry.path)
-      })));
-      const mainWorktreeRoot = canonicalWorktrees[0]?.path || repoRoot;
-      const isMainCheckout = repoRoot === mainWorktreeRoot;
-      const isLinkedWorktree = gitDir !== commonDir;
-      const parentRepoRootRaw = await git((0, import_node_path2.dirname)(repoRoot), ["rev-parse", "--show-toplevel"], true);
-      const parentRepoRoot = parentRepoRootRaw ? await canonicalPath(parentRepoRootRaw) : "";
-      const isNestedWorktree = !!parentRepoRoot && parentRepoRoot !== repoRoot && pathInside(repoRoot, parentRepoRoot);
-      const status = parseStatus(await git(repoRoot, ["status", "--porcelain=v2", "--branch", "--untracked-files=normal"]));
-      const partial2 = {
-        inputPath: workspaceInput,
-        workspace,
-        repoRoot,
-        gitDir,
-        commonDir,
-        mainWorktreeRoot,
-        isMainCheckout,
-        isLinkedWorktree,
-        isNestedWorktree,
-        worktrees: canonicalWorktrees,
-        currentBranch,
-        headCommit,
-        ...status
-      };
-      if (!currentBranch) {
-        return failure2(
-          "detached_head",
-          `Detached HEAD at ${headCommit.slice(0, 12) || "(unknown commit)"}.`,
-          "Check out a named, safe branch before adding or cloning a Repo Mesh node.",
-          { discovery: partial2 }
-        );
-      }
-      const branchValid = await git(repoRoot, ["check-ref-format", "--branch", currentBranch], true);
-      if (!branchValid) {
-        return failure2(
-          "unsafe_branch",
-          `Current branch is not a safe Git branch name: ${currentBranch}`,
-          "Check out or create a valid named branch, then re-run the onboarding plan.",
-          { discovery: partial2 }
-        );
-      }
-      if (isNestedWorktree) {
-        return failure2(
-          "nested_worktree",
-          `Repository ${repoRoot} is nested inside Git checkout ${parentRepoRoot}.`,
-          "Choose the intended outer checkout or move the nested checkout outside it before Repo Mesh onboarding.",
-          { discovery: partial2 }
-        );
-      }
-      if (status.hasConflicts) {
-        return failure2(
-          "conflicted_workspace",
-          `Workspace has unresolved conflicts (${status.conflictFiles.join(", ")}).`,
-          "Resolve or abort the in-progress Git operation before adding this workspace to Repo Mesh.",
-          { discovery: partial2 }
-        );
-      }
-      const remoteDiscovery = await discoverRemotes(repoRoot, currentBranch);
-      if (!remoteDiscovery.remotes.length) {
-        const localIdentity = await deriveLocalRepoIdentity(repoRoot);
-        if (!localIdentity) {
-          return failure2(
-            "no_commits_for_local_identity",
-            "This repository has no remote and no commits, so a stable repository identity cannot be derived.",
-            "Create at least one commit (the root commit becomes the local identity), or pass an explicit repo identity when creating the mesh.",
-            { discovery: partial2 }
-          );
+    async function gitCheckoutFiles(workspace, paths) {
+      const repo = await resolveGitRepository(workspace);
+      const repoRoot = repo.repoRoot;
+      const normalizedPaths = [];
+      for (const p of paths) {
+        if (typeof p !== "string" || !p.trim() || p.includes("\0")) {
+          throw new GitCommandError("invalid_args", `Invalid path: ${String(p)}`);
         }
-        const localDefaultBranch = await resolveDefaultBranch(repoRoot, "", currentBranch);
-        return {
-          ...partial2,
-          remotes: [],
-          origin: void 0,
-          upstream: void 0,
-          selectedRemote: "",
-          repoIdentity: localIdentity,
-          defaultBranch: localDefaultBranch
-        };
-      }
-      if (!remoteDiscovery.selectedRemote) {
-        const detail = remoteDiscovery.remotes.map((remote) => remote.name).join(", ");
-        return failure2(
-          "remote_not_selected",
-          `No canonical remote could be selected among multiple remotes (${detail}).`,
-          "Name one of them origin or upstream, set the current branch to track one of them, or pass an explicit repo identity when creating the mesh.",
-          { discovery: { ...partial2, remotes: remoteDiscovery.remotes, origin: remoteDiscovery.origin, upstream: remoteDiscovery.upstream } }
-        );
-      }
-      if (remoteDiscovery.ambiguous) {
-        const detail = remoteDiscovery.remotes.map((remote) => `${remote.name}=${remote.identities.join("|") || "(no URL)"}`).join(", ");
-        return failure2(
-          "ambiguous_remotes",
-          `Multiple unrelated remote identities were found: ${detail}`,
-          "Remove the ambiguity or explicitly choose/reconcile the canonical remote before onboarding.",
-          { discovery: { ...partial2, remotes: remoteDiscovery.remotes, origin: remoteDiscovery.origin, upstream: remoteDiscovery.upstream } }
-        );
+        if (path15.isAbsolute(p)) {
+          throw new GitCommandError("invalid_args", `Path must be repository-relative, not absolute: ${p}`);
+        }
+        const normalized = path15.normalize(p.trim()).split(path15.sep).join("/");
+        if (normalized.startsWith("../") || normalized === "..") {
+          throw new GitCommandError("path_outside_repo", `Path is outside repository root: ${p}`);
+        }
+        const absolutePath = path15.resolve(repoRoot, normalized);
+        if (!isPathInside(repoRoot, absolutePath)) {
+          throw new GitCommandError("path_outside_repo", `Path is outside repository root: ${p}`);
+        }
+        normalizedPaths.push(normalized);
       }
-      const repoIdentity = remoteDiscovery.selectedRemote.identities[0];
-      if (!repoIdentity) {
-        return failure2(
-          "remote_not_found",
-          `Remote '${remoteDiscovery.selectedRemote.name}' has no usable URL.`,
-          "Configure a valid fetch URL for the selected remote before onboarding.",
-          { discovery: partial2 }
-        );
+      await runGit(repo, ["checkout", "--", ...normalizedPaths], { cwd: repoRoot });
+      return { checkedOut: normalizedPaths };
+    }
+    async function gitGetRemoteUrl(workspace, remote) {
+      const repo = await resolveGitRepository(workspace);
+      const result = await runGit(repo, ["remote", "get-url", remote], { cwd: repo.repoRoot });
+      const remoteUrl = result.stdout.trim();
+      if (!remoteUrl) {
+        throw new GitCommandError("git_command_failed", `Remote '${remote}' has no URL`);
       }
-      const defaultBranch = await resolveDefaultBranch(repoRoot, remoteDiscovery.selectedRemote.name, currentBranch);
-      return {
-        ...partial2,
-        remotes: remoteDiscovery.remotes,
-        origin: remoteDiscovery.origin,
-        upstream: remoteDiscovery.upstream,
-        selectedRemote: remoteDiscovery.selectedRemote.name,
-        repoIdentity,
-        defaultBranch
-      };
+      return { remoteUrl, remote };
     }
-    async function membershipsFor(discovery, meshes) {
-      const matches = [];
-      for (const mesh of meshes) {
-        const compatible = normalizeRepoIdentity(mesh.repoIdentity) === discovery.repoIdentity;
-        let emittedMesh = false;
-        for (const node of mesh.nodes || []) {
-          const rawWorkspace = (0, import_node_path2.resolve)(node.workspace || "");
-          const canonicalWorkspace = await canonicalPath(rawWorkspace);
-          const canonicalRepoRoot = node.repoRoot ? await canonicalPath(node.repoRoot) : canonicalWorkspace;
-          const exactWorkspace = canonicalWorkspace === discovery.workspace;
-          if (exactWorkspace || canonicalRepoRoot === discovery.repoRoot) {
-            matches.push({
-              meshId: mesh.id,
-              meshName: mesh.name,
-              repoIdentity: normalizeRepoIdentity(mesh.repoIdentity),
-              compatible,
-              nodeId: node.id,
-              nodeWorkspace: node.workspace,
-              exactWorkspace
-            });
-            emittedMesh = true;
-          }
+    async function gitPush(workspace, remote, branch, setUpstream) {
+      const lastCheckedAt = Date.now();
+      const repo = await resolveGitRepository(workspace);
+      const repoRoot = repo.repoRoot;
+      let resolvedBranch = branch;
+      if (!resolvedBranch) {
+        const branchResult = await runGit(repo, ["symbolic-ref", "--short", "HEAD"], { cwd: repoRoot });
+        resolvedBranch = branchResult.stdout.trim();
+        if (!resolvedBranch) {
+          throw new GitCommandError("git_command_failed", "Cannot push: not on a branch (detached HEAD)");
         }
-        if (compatible && !emittedMesh) {
-          matches.push({
-            meshId: mesh.id,
-            meshName: mesh.name,
-            repoIdentity: normalizeRepoIdentity(mesh.repoIdentity),
-            compatible: true
-          });
+      }
+      const pushArgs = ["push"];
+      if (setUpstream) pushArgs.push("--set-upstream");
+      pushArgs.push(remote, resolvedBranch);
+      let output = "";
+      let newBranch = false;
+      try {
+        const result = await runGit(repo, pushArgs, { cwd: repoRoot });
+        output = (result.stdout + result.stderr).trim();
+        newBranch = /\[new branch\]/i.test(output);
+      } catch (err) {
+        const errOutput = (err?.stdout ?? "") + (err?.stderr ?? "");
+        if (!setUpstream && /no upstream branch|set-upstream/i.test(errOutput)) {
+          const retryArgs = ["push", "--set-upstream", remote, resolvedBranch];
+          const retryResult = await runGit(repo, retryArgs, { cwd: repoRoot });
+          output = (retryResult.stdout + retryResult.stderr).trim();
+          newBranch = /\[new branch\]/i.test(output);
+        } else {
+          throw new GitCommandError("git_command_failed", errOutput || err?.message || "git push failed");
         }
       }
-      return matches;
-    }
-    function meshSummary(mesh) {
       return {
-        id: mesh.id,
-        name: mesh.name,
-        repoIdentity: normalizeRepoIdentity(mesh.repoIdentity),
-        defaultBranch: mesh.defaultBranch,
-        nodeCount: mesh.nodes?.length || 0
+        workspace: repo.workspace,
+        repoRoot,
+        isGitRepo: true,
+        remote,
+        branch: resolvedBranch,
+        output,
+        newBranch,
+        lastCheckedAt
       };
     }
-    function addStep(mesh, discovery) {
-      return {
-        command: "add_mesh_node",
-        description: "Explicitly register this existing checkout as a mesh node.",
-        writes: true,
-        approvalRequired: true,
-        args: {
-          meshId: mesh.id,
-          workspace: discovery.repoRoot,
-          repoRoot: discovery.repoRoot,
-          isLocalWorktree: discovery.isLinkedWorktree
-        }
-      };
+    function formatOptionalGitLogRangeArg(flag, value) {
+      return value ? [`${flag}=${value}`] : [];
     }
-    function initStep(discovery) {
+    async function getGitLog(workspace, options) {
+      const lastCheckedAt = Date.now();
+      const repo = await resolveGitRepository(workspace);
+      const repoRoot = repo.repoRoot;
+      const boundedLimit = Math.max(1, Math.min(200, Math.floor(options.limit || 50)));
+      const selectedPath = options.path ? validateGitLogPath(repoRoot, options.path) : void 0;
+      const result = await runGit(
+        repo,
+        [
+          "log",
+          `--max-count=${boundedLimit}`,
+          "--format=%H%x00%an%x00%ae%x00%at%x00%ct%x00%s",
+          ...formatOptionalGitLogRangeArg("--since", options.since),
+          ...formatOptionalGitLogRangeArg("--until", options.until),
+          "--",
+          ...selectedPath ? [selectedPath] : []
+        ],
+        { cwd: repoRoot }
+      );
+      const entries = result.stdout.split("\n").filter((line) => line.trim().length > 0).map((line) => {
+        const [commit = "", authorName, authorEmail, authoredAt, committedAt, ...messageParts] = line.split("\0");
+        return {
+          commit,
+          message: messageParts.join("\0"),
+          authorName: authorName || void 0,
+          authorEmail: authorEmail || void 0,
+          authoredAt: authoredAt ? Number.parseInt(authoredAt, 10) * 1e3 : void 0,
+          committedAt: committedAt ? Number.parseInt(committedAt, 10) * 1e3 : void 0
+        };
+      }).filter((entry) => entry.commit.length > 0);
       return {
-        command: "mesh_init",
-        description: "Preview suggested .adhdev configuration; persist only in a separate approved write call.",
-        writes: false,
-        approvalRequired: false,
-        args: { workspace: discovery.repoRoot, write: false, overwrite: false }
+        workspace: repo.workspace,
+        repoRoot,
+        isGitRepo: true,
+        entries,
+        limit: boundedLimit,
+        truncated: entries.length >= boundedLimit,
+        lastCheckedAt
       };
     }
-    async function planMeshOnboarding(options) {
-      const discoveryResult = await discoverGit(options.workspace);
-      if (isPlanFailure(discoveryResult)) return discoveryResult;
-      const discovery = discoveryResult;
-      const operation = options.operation || "auto";
-      const meshes = options.meshes || listMeshesReadOnly();
-      const membership = await membershipsFor(discovery, meshes);
-      const requestedMesh = options.meshId ? meshes.find((mesh) => mesh.id === options.meshId) : void 0;
-      if (options.meshId && !requestedMesh) {
-        return failure2("mesh_not_found", `Mesh not found: ${options.meshId}`, "List meshes and choose an existing mesh id.", { discovery, membership });
-      }
-      if (requestedMesh && normalizeRepoIdentity(requestedMesh.repoIdentity) !== discovery.repoIdentity) {
-        return failure2(
-          "unrelated_repo_identity",
-          `Workspace identity '${discovery.repoIdentity}' does not match mesh '${requestedMesh.name}' identity '${normalizeRepoIdentity(requestedMesh.repoIdentity)}'.`,
-          "Choose a mesh for the same repository, or create a separate mesh for this repository.",
-          { discovery, membership }
-        );
+    function validateGitLogPath(repoRoot, filePath) {
+      if (!filePath.trim() || filePath.includes("\0")) {
+        throw new GitCommandError("invalid_args", "path must be a non-empty repository-relative path");
       }
-      const compatibleMeshes = requestedMesh ? [requestedMesh] : meshes.filter((mesh) => normalizeRepoIdentity(mesh.repoIdentity) === discovery.repoIdentity);
-      if (compatibleMeshes.length > 1) {
-        return failure2(
-          "ambiguous_mesh",
-          `More than one compatible mesh exists for '${discovery.repoIdentity}': ${compatibleMeshes.map((mesh) => `${mesh.name} (${mesh.id})`).join(", ")}`,
-          "Pass an explicit mesh id to select the intended mesh.",
-          { discovery, membership }
-        );
+      if (path15.isAbsolute(filePath)) {
+        throw new GitCommandError("invalid_args", "path must be repository-relative");
       }
-      const compatibleMesh = compatibleMeshes[0];
-      const duplicate = membership.find((match) => match.compatible && match.nodeId && (!compatibleMesh || match.meshId === compatibleMesh.id));
-      if (operation !== "clone_worktree" && duplicate) {
-        return failure2(
-          duplicate.exactWorkspace ? "duplicate_workspace" : "duplicate_node",
-          `Workspace is already registered as node '${duplicate.nodeId}' in mesh '${duplicate.meshName}'.`,
-          "Use the existing node, or choose clone_worktree with a new branch for isolated work.",
-          { discovery, membership }
-        );
+      const normalized = path15.normalize(filePath).split(path15.sep).join("/");
+      const absolutePath = path15.resolve(repoRoot, normalized);
+      if (!isPathInside(repoRoot, absolutePath) || normalized.startsWith("../") || normalized === "..") {
+        throw new GitCommandError("path_outside_repo", "Git log path is outside the repository root");
       }
-      if (operation === "add_existing" && !compatibleMesh) {
-        return failure2(
-          "mesh_not_found",
-          `No compatible mesh exists for '${discovery.repoIdentity}'.`,
-          "Run the auto/create onboarding plan first, explicitly create the mesh, then add this workspace.",
-          { discovery, membership }
-        );
+      return normalized;
+    }
+    var BUSY_STATUSES = /* @__PURE__ */ new Set(["streaming", "waiting_approval"]);
+    var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["idle", "error"]);
+    var TurnSnapshotTracker = class {
+      lastStatus = /* @__PURE__ */ new Map();
+      onTurnCompleted;
+      constructor(onTurnCompleted) {
+        this.onTurnCompleted = onTurnCompleted;
       }
-      if (operation === "clone_worktree") {
-        const planWarnings = [];
-        if (!compatibleMesh) {
-          return failure2(
-            "mesh_not_found",
-            `No compatible mesh exists for '${discovery.repoIdentity}'.`,
-            "Create and add the base workspace first, then plan a cloned worktree node.",
-            { discovery, membership }
-          );
-        }
-        const dirtyBehavior = mergeAndNormalizePolicy(compatibleMesh.policy, void 0).dirtyWorkspaceBehavior;
-        if (discovery.dirty && dirtyBehavior === "block") {
-          return failure2(
-            "dirty_workspace",
-            `Workspace has ${discovery.changedFileCount} uncommitted change(s); a cloned worktree would not include them.`,
-            "Commit or stash the changes, then re-run the clone plan. (This mesh's dirtyWorkspaceBehavior is 'block'; set it to 'warn' to allow cloning from a dirty workspace.)",
-            { discovery, membership }
-          );
-        }
-        if (discovery.dirty) {
-          planWarnings.push(
-            `Source workspace has ${discovery.changedFileCount} uncommitted change(s). The new worktree is created from HEAD, so uncommitted changes are NOT included in it \u2014 commit them first if the cloned branch needs them.`
-          );
-        }
-        const branch = (options.branch || "").trim();
-        if (!branch || !await git(discovery.repoRoot, ["check-ref-format", "--branch", branch], true)) {
-          return failure2(
-            "unsafe_branch",
-            branch ? `Requested worktree branch is unsafe: ${branch}` : "A named branch is required to clone a new worktree node.",
-            "Provide a new valid branch name such as feat/my-task.",
-            { discovery, membership }
-          );
+      record(sessionId, status, workspace) {
+        const prev = this.lastStatus.get(sessionId);
+        this.lastStatus.set(sessionId, status);
+        if (workspace && prev && BUSY_STATUSES.has(prev) && TERMINAL_STATUSES.has(status)) {
+          this.onTurnCompleted({ sessionId, workspace });
         }
-        const sourceNode = duplicate?.nodeId ? compatibleMesh.nodes.find((node) => node.id === duplicate.nodeId) : compatibleMesh.nodes.find((node) => !!node.workspace);
-        if (!sourceNode) {
-          return failure2(
-            "mesh_not_found",
-            `Mesh '${compatibleMesh.name}' has no source node to clone.`,
-            "Explicitly add this existing workspace as the first node, then clone a worktree.",
-            { discovery, membership }
-          );
+      }
+      forget(sessionId) {
+        this.lastStatus.delete(sessionId);
+      }
+    };
+    init_git_worktree();
+    init_config();
+    init_config_dir();
+    init_embedded_path_health();
+    var os11 = __toESM2(require("os"));
+    var path17 = __toESM2(require("path"));
+    var import_session_host_core22 = require_dist();
+    init_config_dir();
+    init_track_identity();
+    var DEFAULT_SESSION_HOST_APP_NAME = IDENTITY.sessionHostName;
+    var RESERVED_GLOBAL_SESSION_HOST_APP_NAME = IDENTITY.sessionHostName;
+    var DEFAULT_STANDALONE_SESSION_HOST_APP_NAME = "adhdev-standalone";
+    function getReservedStandaloneNamespaceWarning() {
+      return `Standalone session-host namespace '${RESERVED_GLOBAL_SESSION_HOST_APP_NAME}' is reserved for the global daemon. Falling back to '${DEFAULT_STANDALONE_SESSION_HOST_APP_NAME}' for this standalone run.`;
+    }
+    function resolveSessionHostAppNameResolution2(options = {}) {
+      const env2 = options.env || process.env;
+      const explicit = typeof env2.ADHDEV_SESSION_HOST_NAME === "string" ? env2.ADHDEV_SESSION_HOST_NAME.trim() : "";
+      if (explicit) {
+        if (options.standalone && explicit === RESERVED_GLOBAL_SESSION_HOST_APP_NAME) {
+          return {
+            appName: DEFAULT_STANDALONE_SESSION_HOST_APP_NAME,
+            warning: getReservedStandaloneNamespaceWarning(),
+            source: "reserved-standalone-fallback"
+          };
         }
-        const suggestedConfig2 = runMeshInit(compatibleMesh, discovery.repoRoot, options.detectedProviders || []);
         return {
-          success: true,
-          dryRun: true,
-          discovery,
-          membership,
-          compatibleMesh: meshSummary(compatibleMesh),
-          plan: {
-            kind: "clone_new_worktree",
-            summary: `Create an isolated worktree node from '${sourceNode.id}' on branch '${branch}'.`,
-            // Only a 'block' mesh actually requires a clean source; under the
-            // default 'warn' a dirty workspace is advisory, so reporting true here
-            // would misdescribe the plan the caller is approving.
-            requiresClean: dirtyBehavior === "block",
-            approvalRequired: true,
-            steps: [{
-              command: "clone_mesh_node",
-              description: "Explicitly create the branch/worktree and register the resulting node.",
-              writes: true,
-              approvalRequired: true,
-              args: {
-                meshId: compatibleMesh.id,
-                sourceNodeId: sourceNode.id,
-                branch,
-                baseBranch: compatibleMesh.defaultBranch || discovery.defaultBranch
-              }
-            }, initStep(discovery)],
-            alternatives: [{ kind: "add_existing_workspace", summary: "Register the supplied checkout without creating a worktree.", requiresClean: false }]
-          },
-          suggestedConfig: suggestedConfig2,
-          note: "Read-only plan only. No mesh, config, branch, remote or worktree state was changed.",
-          ...planWarnings.length ? { warnings: planWarnings } : {}
+          appName: explicit,
+          source: "explicit"
         };
       }
-      const suggestedConfig = runMeshInit(compatibleMesh || {}, discovery.repoRoot, options.detectedProviders || []);
-      if (compatibleMesh && operation !== "create_mesh") {
-        return {
-          success: true,
-          dryRun: true,
-          discovery,
-          membership,
-          compatibleMesh: meshSummary(compatibleMesh),
-          plan: {
-            kind: "add_existing_workspace",
-            summary: discovery.isLinkedWorktree ? `Register the existing linked worktree on '${discovery.currentBranch}' in '${compatibleMesh.name}'.` : `Register the main checkout as a base node in '${compatibleMesh.name}'.`,
-            requiresClean: false,
-            approvalRequired: true,
-            steps: [addStep(compatibleMesh, discovery), initStep(discovery)],
-            alternatives: [{
-              kind: "clone_new_worktree",
-              summary: `After a base node exists, create a clean isolated worktree from '${compatibleMesh.defaultBranch || discovery.defaultBranch}'.`,
-              requiresClean: true
-            }]
-          },
-          suggestedConfig,
-          note: "Read-only plan only. Adding the node and writing suggested configs require separate explicit approved calls."
-        };
+      return {
+        appName: options.standalone ? DEFAULT_STANDALONE_SESSION_HOST_APP_NAME : DEFAULT_SESSION_HOST_APP_NAME,
+        source: "default"
+      };
+    }
+    function resolveSessionHostAppName(options = {}) {
+      return resolveSessionHostAppNameResolution2(options).appName;
+    }
+    var InstanceContextConflictError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "InstanceContextConflictError";
       }
-      const identityRepoName = discovery.repoIdentity.split("/").filter(Boolean).at(-1);
-      const suggestedName = `${identityRepoName || (0, import_node_path2.basename)(discovery.mainWorktreeRoot || discovery.repoRoot)}-mesh`;
-      const createArgs = {
-        name: suggestedName,
-        repoIdentity: discovery.repoIdentity,
-        repoRemoteUrl: discovery.origin?.urls[0] || discovery.upstream?.urls[0] || discovery.remotes[0]?.urls[0],
-        defaultBranch: discovery.defaultBranch
+    };
+    var cached22 = null;
+    function resolveInstanceContext(options = {}) {
+      const env2 = options.env ?? process.env;
+      const homeDir2 = options.homeDir ?? os11.homedir();
+      const envDir = typeof env2.ADHDEV_CONFIG_DIR === "string" ? env2.ADHDEV_CONFIG_DIR.trim() : "";
+      const explicitDir = typeof options.configDir === "string" ? options.configDir.trim() : "";
+      if (explicitDir && envDir && (0, import_session_host_core22.canonicalizeInstancePath)(explicitDir) !== (0, import_session_host_core22.canonicalizeInstancePath)(envDir)) {
+        throw new InstanceContextConflictError(
+          `Conflicting instance identity: explicit configDir "${explicitDir}" vs ADHDEV_CONFIG_DIR "${envDir}". Refusing to merge mutable namespaces \u2014 fix the caller or unset one of the two.`
+        );
+      }
+      const configDir = explicitDir || resolveConfigDir(env2, homeDir2);
+      const trimmed = configDir.replace(/[\\/]+$/, "");
+      return {
+        configDir,
+        canonicalConfigDir: (0, import_session_host_core22.canonicalizeInstancePath)(configDir),
+        instanceDir: path17.basename(trimmed) || ".adhdev",
+        isDefault: (0, import_session_host_core22.isDefaultInstanceConfigDir)(configDir, homeDir2),
+        ipcKey: (0, import_session_host_core22.resolveSessionHostIpcKey)(configDir, homeDir2),
+        sessionHostAppName: resolveSessionHostAppName({ standalone: options.standalone, env: env2 })
+      };
+    }
+    function getProcessInstanceContext(options = {}) {
+      const envDir = typeof process.env.ADHDEV_CONFIG_DIR === "string" ? process.env.ADHDEV_CONFIG_DIR.trim() : "";
+      const key2 = `${envDir}|${os11.homedir()}|${options.standalone ? "standalone" : "daemon"}`;
+      if (!cached22 || cached22.key !== key2) {
+        cached22 = { key: key2, context: resolveInstanceContext({ standalone: options.standalone }) };
+      }
+      return cached22.context;
+    }
+    function resetProcessInstanceContextForTests() {
+      cached22 = null;
+    }
+    init_workspaces();
+    init_recent_activity();
+    var path20 = __toESM2(require("path"));
+    init_workspaces();
+    init_summary_metadata();
+    var MAX_SAVED_SESSIONS = 500;
+    function normalizeWorkspace2(workspace) {
+      if (!workspace) return "";
+      try {
+        return path20.resolve(expandPath(workspace));
+      } catch {
+        return path20.resolve(workspace);
+      }
+    }
+    function buildSavedProviderSessionKey(providerSessionId) {
+      return `saved:${providerSessionId.trim()}`;
+    }
+    function upsertSavedProviderSession(state, entry) {
+      const providerSessionId = typeof entry.providerSessionId === "string" ? entry.providerSessionId.trim() : "";
+      if (!providerSessionId) return state;
+      const id = buildSavedProviderSessionKey(providerSessionId);
+      const existing = (state.savedProviderSessions || []).find((item) => item.id === id);
+      const nextEntry = {
+        id,
+        kind: entry.kind,
+        providerType: entry.providerType,
+        providerName: entry.providerName,
+        providerSessionId,
+        workspace: entry.workspace ? normalizeWorkspace2(entry.workspace) : void 0,
+        summaryMetadata: normalizePersistedSummaryMetadata({
+          summaryMetadata: entry.summaryMetadata
+        }),
+        title: entry.title,
+        createdAt: existing?.createdAt || entry.createdAt || Date.now(),
+        lastUsedAt: entry.lastUsedAt || Date.now()
       };
+      const filtered = (state.savedProviderSessions || []).filter((item) => item.id !== id);
       return {
-        success: true,
-        dryRun: true,
-        discovery,
-        membership,
-        plan: {
-          kind: "create_mesh_and_onboard",
-          summary: `Create '${suggestedName}', add this ${discovery.isLinkedWorktree ? "linked worktree" : "checkout"} as its first node, then review suggested .adhdev configs.`,
-          requiresClean: false,
-          approvalRequired: true,
-          steps: [
-            {
-              command: "create_mesh",
-              description: "Explicitly create a machine-local mesh record.",
-              writes: true,
-              approvalRequired: true,
-              args: createArgs
-            },
-            {
-              command: "add_mesh_node",
-              description: "After creation, explicitly register this existing workspace as the first node.",
-              writes: true,
-              approvalRequired: true,
-              args: {
-                meshId: "<created mesh id>",
-                workspace: discovery.repoRoot,
-                repoRoot: discovery.repoRoot,
-                isLocalWorktree: discovery.isLinkedWorktree
-              }
-            },
-            initStep(discovery)
-          ],
-          alternatives: []
-        },
-        suggestedConfig,
-        note: "Read-only plan only. No mesh/config/worktree writes occurred; execute each write step separately after approval."
+        ...state,
+        savedProviderSessions: [nextEntry, ...filtered].slice(0, MAX_SAVED_SESSIONS)
       };
     }
+    function getSavedProviderSessions(state, filters) {
+      return [...state.savedProviderSessions || []].filter((entry) => {
+        if (filters?.providerType && entry.providerType !== filters.providerType) return false;
+        if (filters?.kind && entry.kind !== filters.kind) return false;
+        return true;
+      }).map((entry) => ({
+        ...entry,
+        summaryMetadata: normalizePersistedSummaryMetadata({
+          summaryMetadata: entry.summaryMetadata
+        })
+      })).sort((a, b) => b.lastUsedAt - a.lastUsedAt);
+    }
+    init_mesh_config();
+    init_dist();
+    init_dist();
+    init_dist();
+    init_dist();
+    init_coordinator_prompt();
+    init_mesh_missions();
+    init_mesh_task_stats();
+    init_mesh_review_inbox();
+    init_mesh_onboarding_plan();
     init_coordinator_registry();
     init_refine_config();
     init_worktree_bootstrap_config();
@@ -100291,12 +100352,13 @@ ${e?.stderr || ""}`;
     var import_node_child_process7 = require("child_process");
     init_mesh_runtime_store();
     init_mesh_config();
+    init_mesh_onboarding_plan();
     var GIT_PROBE_TIMEOUT_MS = 3e3;
     var MAX_PROBE_COMMITS = 12;
     var SHA_PATTERN = /^[0-9a-f]{7,40}$/i;
-    function isCommitReachable(workspace, sha) {
+    function isCommitReachable(workspace, sha, defaultBranch) {
       try {
-        (0, import_node_child_process7.execFileSync)("git", ["merge-base", "--is-ancestor", sha, "origin/main"], {
+        (0, import_node_child_process7.execFileSync)("git", ["merge-base", "--is-ancestor", sha, `origin/${defaultBranch}`], {
           cwd: workspace,
           timeout: GIT_PROBE_TIMEOUT_MS,
           stdio: ["ignore", "ignore", "ignore"]
@@ -100353,7 +100415,7 @@ ${e?.stderr || ""}`;
       }
       return commits;
     }
-    function collectGateConvergenceEvidence(meshId, gateId) {
+    async function collectGateConvergenceEvidence(meshId, gateId) {
       try {
         const graphStore = MeshRuntimeStore.getInstance().graphStore();
         const gate = graphStore.getGate(gateId);
@@ -100362,19 +100424,21 @@ ${e?.stderr || ""}`;
         if (!workspace) return null;
         const upstream = collectUpstreamCommits(gate);
         if (upstream.length === 0) return null;
+        const mesh = getMesh(meshId);
+        const defaultBranch = await resolveRootDefaultBranch(workspace, mesh);
         const commits = upstream.map((ref) => ({
           ...ref,
-          reachedMain: isCommitReachable(workspace, ref.sha)
+          reachedMain: isCommitReachable(workspace, ref.sha, defaultBranch)
         }));
         const allReachedMain = commits.every((c) => c.reachedMain === true);
         return {
           workspace,
           probedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          probedAgainst: "local origin/main (no fetch)",
+          probedAgainst: `local origin/${defaultBranch} (no fetch)`,
           commits,
           allReachedMain,
           ...allReachedMain ? {
-            hint: "Every upstream commit is already reachable from origin/main \u2014 the guarded work appears to have landed. Verify, then RELEASE this gate with these commits as evidence instead of re-running the action. (Evidence never auto-releases a gate; the decision is yours.)"
+            hint: `Every upstream commit is already reachable from origin/${defaultBranch} \u2014 the guarded work appears to have landed. Verify, then RELEASE this gate with these commits as evidence instead of re-running the action. (Evidence never auto-releases a gate; the decision is yours.)`
           } : {}
         };
       } catch {
@@ -112671,7 +112735,26 @@ ${marker}`,
           // null = replication unavailable (node failed to open, or stats
           // threw); the key is always present so a caller can tell "no node"
           // from an older daemon that never reported the field at all.
-          seqscribe: ctx.deps.getSeqscribeStats?.() ?? null
+          seqscribe: ctx.deps.getSeqscribeStats?.() ?? null,
+          // Beacon staleness / sole-copy (design §7.1, mission b60d70b8).
+          //
+          // ★Unlike `seqscribe` above, this DOES carry topic names and peer
+          // writer ids — that is the feature ("which topic is how far
+          // ahead"), and it is why it appears on THIS local surface and on
+          // the P2P payload, but never on `status_report` to the server. The
+          // approved Beacon content exception (CLAUDE.md) covers the beacon
+          // BOARD path; it does not widen the status path's allow-list.
+          //
+          // null = no beacon armed (standalone never arms one) or none yet on
+          // this daemon, so it stays distinguishable from an older daemon
+          // that never reported the field.
+          beacon: ctx.deps.getBeaconDiagnostics?.() ?? null,
+          // Phase 4 Stage 2 receive-side fleet view. This is a pure local
+          // snapshot of fixed-key entries delivered by connection-scoped
+          // seqscribe SUBs; it neither polls nor touches the server status
+          // path. Raw numeric receive/comparison counters live alongside the
+          // entries because no content or dynamic-key map is present.
+          fleetStatusPeerView: ctx.deps.getFleetStatusPeerView?.() ?? null
         };
       },
       /**
@@ -132962,8 +133045,17 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         const name = typeof args?.name === "string" ? args.name.trim() : "";
         const repoIdentity = typeof args?.repoIdentity === "string" ? args.repoIdentity.trim() : "";
         const repoRemoteUrl = typeof args?.repoRemoteUrl === "string" ? args.repoRemoteUrl.trim() : void 0;
-        const defaultBranch = typeof args?.defaultBranch === "string" ? args.defaultBranch.trim() : void 0;
+        let defaultBranch = typeof args?.defaultBranch === "string" ? args.defaultBranch.trim() : void 0;
         if (!name) return { success: false, error: "name required" };
+        if (!defaultBranch) {
+          try {
+            const { resolveRootDefaultBranch: resolveRootDefaultBranch2 } = await Promise.resolve().then(() => (init_mesh_onboarding_plan(), mesh_onboarding_plan_exports));
+            const workspace = typeof args?.workspace === "string" && args.workspace.trim() ? args.workspace.trim() : process.cwd();
+            const detected = await resolveRootDefaultBranch2(workspace, void 0);
+            if (detected) defaultBranch = detected;
+          } catch {
+          }
+        }
         try {
           const { createMesh: createMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
           const meshHost = args?.meshHost && typeof args.meshHost === "object" && !Array.isArray(args.meshHost) ? args.meshHost : void 0;
@@ -134529,6 +134621,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     };
     init_dist();
     init_mesh_fast_forward();
+    init_mesh_init();
     init_cli_detector();
     init_mesh_refine_submodule_preflight();
     var fastForwardHandlers = {
@@ -134955,6 +135048,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       }
     };
     init_cli_detector();
+    init_mesh_onboarding_plan();
     var meshOnboardingHandlers = {
       plan_mesh_onboarding: async (ctx, args) => {
         const workspace = typeof args?.workspace === "string" && args.workspace.trim() ? args.workspace.trim() : process.cwd();
@@ -135108,7 +135202,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
           }
           let convergenceEvidence = null;
           try {
-            convergenceEvidence = collectGateConvergenceEvidence(meshId, gateId);
+            convergenceEvidence = await collectGateConvergenceEvidence(meshId, gateId);
           } catch {
           }
           return {
@@ -139833,6 +139927,49 @@ ${ptyResult.output.slice(-2e3)}`);
         ...seqscribeSummary ? { seqscribe: seqscribeSummary } : {}
       };
     }
+    var FLEET_DAEMON_ID_RE = /^[A-Za-z0-9._:-]{1,160}$/;
+    function fleetCount(value) {
+      return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+    }
+    function projectFleetStatusEntry(raw) {
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+      const value = raw;
+      if (typeof value.daemonId !== "string" || !FLEET_DAEMON_ID_RE.test(value.daemonId)) return null;
+      if (typeof value.at !== "string" || Number.isNaN(Date.parse(value.at))) return null;
+      if (!["online", "reconnecting", "offline"].includes(String(value.onlineState))) return null;
+      if (typeof value.p2pActive !== "boolean") return null;
+      if (!value.sessionCounts || typeof value.sessionCounts !== "object" || Array.isArray(value.sessionCounts)) {
+        return null;
+      }
+      const rawCounts = value.sessionCounts;
+      const ideCount = fleetCount(rawCounts.ideCount);
+      const cliCount = fleetCount(rawCounts.cliCount);
+      const acpCount = fleetCount(rawCounts.acpCount);
+      const idleCount = fleetCount(rawCounts.idleCount);
+      const generatingCount = fleetCount(rawCounts.generatingCount);
+      const waitingApprovalCount = fleetCount(rawCounts.waitingApprovalCount);
+      const erroredCount = fleetCount(rawCounts.erroredCount);
+      if (ideCount === null || cliCount === null || acpCount === null || idleCount === null || generatingCount === null || waitingApprovalCount === null || erroredCount === null) {
+        return null;
+      }
+      const seqscribe = value.seqscribe && typeof value.seqscribe === "object" && !Array.isArray(value.seqscribe) ? buildCloudSeqscribeSummary(value.seqscribe) : void 0;
+      return {
+        daemonId: value.daemonId,
+        at: new Date(value.at).toISOString(),
+        onlineState: value.onlineState,
+        p2pActive: value.p2pActive,
+        sessionCounts: {
+          ideCount,
+          cliCount,
+          acpCount,
+          idleCount,
+          generatingCount,
+          waitingApprovalCount,
+          erroredCount
+        },
+        ...seqscribe ? { seqscribe } : {}
+      };
+    }
     var SERVER_DEDUP_KEEPALIVE_REPORTS = 10;
     var DaemonStatusReporter = class {
       deps;
@@ -140062,6 +140199,18 @@ ${ptyResult.output.slice(-2e3)}`);
             LOG2.info("StatusReport", `\u2192${target} ${baseSummary}`);
           }
         }
+        let beaconDiagnostics = null;
+        try {
+          beaconDiagnostics = this.deps.getBeaconDiagnostics?.() ?? null;
+        } catch {
+          beaconDiagnostics = null;
+        }
+        let fleetStatusPeerView = null;
+        try {
+          fleetStatusPeerView = this.deps.getFleetStatusPeerView?.() ?? null;
+        } catch {
+          fleetStatusPeerView = null;
+        }
         const payload = {
           ...buildStatusSnapshot2({
             allStates,
@@ -140083,7 +140232,20 @@ ${ptyResult.output.slice(-2e3)}`);
             },
             profile: "live"
           }),
-          screenshotUsage: this.deps.getScreenshotUsage?.() || null
+          screenshotUsage: this.deps.getScreenshotUsage?.() || null,
+          // ★ Beacon staleness/sole-copy rides the P2P payload ONLY (mission
+          // b60d70b8). It carries topic names and peer writer ids, which the
+          // server status path forbids — and it cannot leak there, because the
+          // server frame is built separately by
+          // `buildCloudStatusReportPayload` from `allStates`, never from this
+          // object. Omitted entirely when no beacon is armed, so "absent"
+          // stays distinguishable from "armed but empty".
+          ...beaconDiagnostics ? { beacon: beaconDiagnostics } : {},
+          // Phase 4 Stage 2: latest fixed-key status received from each
+          // seqscribe SUB peer. This is a cross-check beside the WS routing
+          // view, not a replacement. The server frame below has no field for
+          // it and continues to be built from its existing allow-list.
+          ...fleetStatusPeerView ? { fleetStatusPeerView } : {}
         };
         const p2pSent = this.sendP2PPayload(payload);
         if (p2pSent) {
@@ -148003,6 +148165,155 @@ data: ${JSON.stringify(msg.data)}
       }
       LOG2.info("Seqscribe", `fleet secret stored (v${version2})`);
     }
+    var BEACON_BOARD_TTL_MS = 3e4;
+    function summarizeSoleCopy(args) {
+      if (!args.haveBoard) return { verdict: "unknown", unknownReason: "no-board" };
+      if (args.truncated > 0) return { verdict: "unknown", unknownReason: "truncated" };
+      if (args.bestPeerSeq === null) {
+        return { verdict: args.localSeq > 0 ? "sole-copy" : "replicated" };
+      }
+      return { verdict: args.bestPeerSeq < args.localSeq ? "sole-copy" : "replicated" };
+    }
+    function writerSeq(entry) {
+      if (!entry || typeof entry !== "object") return null;
+      const w = entry;
+      const raw = w.retired === true ? w.finalSeq : w.contig;
+      return typeof raw === "number" && Number.isFinite(raw) && raw >= 0 ? raw : null;
+    }
+    function computeBeaconDiagnostics(args) {
+      const now = args.now ?? Date.now();
+      const board = args.board;
+      const reports = board?.reports ?? [];
+      const truncated = board?.truncated ?? 0;
+      const haveBoard = board !== null;
+      const peers = [];
+      for (const report of reports) {
+        if (report.node === args.node) continue;
+        const topics = [];
+        let worst = 0;
+        for (const [topic, vec] of Object.entries(report.vectors ?? {})) {
+          let topicBehind = 0;
+          for (const [writer, entry] of Object.entries(vec?.writers ?? {})) {
+            const theirs = writerSeq(entry);
+            if (theirs === null) continue;
+            const mine = writerSeq(args.localVectors[topic]?.writers?.[writer]) ?? 0;
+            const lag = theirs - mine;
+            if (lag > 0) topicBehind += lag;
+          }
+          if (topicBehind > 0) {
+            topics.push({ node: report.node, topic, behind: topicBehind });
+            if (topicBehind > worst) worst = topicBehind;
+          }
+        }
+        const seenAt = Date.parse(report.at);
+        const lastSeenAgeMs = Number.isNaN(seenAt) ? 0 : Math.max(0, now - seenAt);
+        peers.push({
+          node: report.node,
+          behind: worst,
+          topics: topics.sort((a, b) => b.behind - a.behind),
+          lastSeen: report.at,
+          lastSeenAgeMs
+        });
+      }
+      peers.sort((a, b) => b.behind - a.behind || a.node.localeCompare(b.node));
+      const soleCopy = [];
+      for (const [topic, vec] of Object.entries(args.localVectors)) {
+        for (const [writer, entry] of Object.entries(vec?.writers ?? {})) {
+          const localSeq = writerSeq(entry);
+          if (localSeq === null || localSeq <= 0) continue;
+          let bestPeerSeq = null;
+          for (const report of reports) {
+            if (report.node === args.node) continue;
+            const theirs = writerSeq(report.vectors?.[topic]?.writers?.[writer]);
+            if (theirs === null) continue;
+            if (bestPeerSeq === null || theirs > bestPeerSeq) bestPeerSeq = theirs;
+          }
+          const { verdict, unknownReason } = summarizeSoleCopy({
+            localSeq,
+            bestPeerSeq,
+            truncated,
+            haveBoard
+          });
+          if (verdict === "replicated") continue;
+          soleCopy.push({
+            topic,
+            writer,
+            localSeq,
+            bestPeerSeq,
+            unreplicated: verdict === "sole-copy" ? localSeq - (bestPeerSeq ?? 0) : 0,
+            verdict,
+            ...unknownReason ? { unknownReason } : {}
+          });
+        }
+      }
+      soleCopy.sort((a, b) => b.unreplicated - a.unreplicated || a.topic.localeCompare(b.topic));
+      const boardAgeMs = board ? Math.max(0, now - board.capturedAt) : null;
+      return {
+        node: args.node,
+        peers,
+        maxBehind: peers.reduce((max, p) => p.behind > max ? p.behind : max, 0),
+        soleCopy,
+        truncated,
+        soleCopyDeferred: truncated > 0,
+        topicScope: board?.topicScope ?? [],
+        boardAt: board ? new Date(board.capturedAt).toISOString() : null,
+        boardAgeMs,
+        stale: boardAgeMs === null || boardAgeMs > BEACON_BOARD_TTL_MS,
+        // ★ Advisory only — see BeaconKeyStaleAdvisory.
+        keyStaleAdvisory: args.keyStaleAdvisory ?? []
+      };
+    }
+    function readKeyStaleAdvisory(handle, pairs2) {
+      const out = [];
+      for (const { topic, key: key2 } of pairs2) {
+        try {
+          const stale = handle.node.staleness(topic, key2);
+          if (!stale?.keyStale) continue;
+          out.push({
+            topic,
+            key: key2,
+            latestKnown: stale.keyStale.latestKnown,
+            haveLocally: stale.keyStale.haveLocally === true
+          });
+        } catch {
+        }
+      }
+      return out;
+    }
+    function toBeaconDiagnosticsSummary(d) {
+      return {
+        node: d.node,
+        peers: d.peers.map((p) => ({
+          node: p.node,
+          behind: p.behind,
+          topics: p.topics.map((t) => ({ node: t.node, topic: t.topic, behind: t.behind })),
+          lastSeen: p.lastSeen
+          // `lastSeenAgeMs` intentionally dropped — see the header.
+        })),
+        maxBehind: d.maxBehind,
+        soleCopy: d.soleCopy.map((s2) => ({
+          topic: s2.topic,
+          writer: s2.writer,
+          localSeq: s2.localSeq,
+          bestPeerSeq: s2.bestPeerSeq,
+          unreplicated: s2.unreplicated,
+          verdict: s2.verdict,
+          ...s2.unknownReason ? { unknownReason: s2.unknownReason } : {}
+        })),
+        truncated: d.truncated,
+        soleCopyDeferred: d.soleCopyDeferred,
+        topicScope: [...d.topicScope],
+        boardAt: d.boardAt,
+        // `boardAgeMs` and `stale` intentionally dropped — both are derived
+        // from Date.now() and would tick on every report.
+        keyStaleAdvisory: d.keyStaleAdvisory.map((k) => ({
+          topic: k.topic,
+          key: k.key,
+          latestKnown: k.latestKnown,
+          haveLocally: k.haveLocally
+        }))
+      };
+    }
     var import_fs24 = require("fs");
     var import_path26 = require("path");
     init_dist2();
@@ -148352,6 +148663,10 @@ data: ${JSON.stringify(msg.data)}
         dualWriteDroppedBucket: bucket(opts.dualWrite?.dropped ?? 0, BACKLOG_BUCKETS),
         dualWriteBackfilledBucket: bucket(opts.dualWrite?.backfilled ?? 0, BACKLOG_BUCKETS),
         parityMismatchBucket: bucket(opts.parity?.mismatches ?? 0, BACKLOG_BUCKETS),
+        parityPersistentMismatchBucket: bucket(
+          opts.parity?.persistentMismatches ?? 0,
+          BACKLOG_BUCKETS
+        ),
         parityRan: (opts.parity?.runs ?? 0) > 0,
         parityMissingInShadowBucket: bucket(opts.parity?.missingInShadow ?? 0, BACKLOG_BUCKETS),
         parityExtraInShadowBucket: bucket(opts.parity?.extraInShadow ?? 0, BACKLOG_BUCKETS),
@@ -148469,6 +148784,177 @@ data: ${JSON.stringify(msg.data)}
     }
     init_mesh_read_readiness();
     init_mesh_dual_write();
+    init_dist();
+    init_topics2();
+    var FLEET_STATUS_SUB_VIEW = "tail";
+    function emptyDiagnostics() {
+      return {
+        receivedEntries: 0,
+        comparedEntries: 0,
+        matchedEntries: 0,
+        mismatchedEntries: 0,
+        invalidEntries: 0,
+        viewReplacements: 0
+      };
+    }
+    function finiteInteger(value) {
+      return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+    }
+    function compareOrder(a, b) {
+      if (a.hlcL !== b.hlcL) return a.hlcL - b.hlcL;
+      if (a.hlcC !== b.hlcC) return a.hlcC - b.hlcC;
+      if (a.writer !== b.writer) return a.writer < b.writer ? -1 : 1;
+      return a.seq - b.seq;
+    }
+    function cloneEntry(entry) {
+      return {
+        daemonId: entry.daemonId,
+        at: entry.at,
+        onlineState: entry.onlineState,
+        p2pActive: entry.p2pActive,
+        sessionCounts: { ...entry.sessionCounts },
+        ...entry.seqscribe ? { seqscribe: { ...entry.seqscribe } } : {}
+      };
+    }
+    function parseTailRow(row) {
+      if (row.kind !== FLEET_STATUS_ENTRY_KIND || typeof row.payload !== "string") return null;
+      const hlcL = finiteInteger(row.hlc_l);
+      const hlcC = finiteInteger(row.hlc_c);
+      const seq2 = finiteInteger(row.seq);
+      if (hlcL === null || hlcC === null || seq2 === null || typeof row.writer !== "string") return null;
+      let raw;
+      try {
+        raw = JSON.parse(row.payload);
+      } catch {
+        return null;
+      }
+      const entry = projectFleetStatusEntry(raw);
+      if (!entry) return null;
+      return { entry, order: { hlcL, hlcC, writer: row.writer, seq: seq2 } };
+    }
+    function createFleetStatusPeerViewConsumer(handle) {
+      const active = /* @__PURE__ */ new Map();
+      const latest = /* @__PURE__ */ new Map();
+      const diagnostics = emptyDiagnostics();
+      let nextGeneration2 = 1;
+      let stopped = false;
+      const closeSubscription = (peerId, removeView) => {
+        const current = active.get(peerId);
+        if (current) {
+          active.delete(peerId);
+          try {
+            current.unsubscribeSnapshot();
+          } catch {
+          }
+          try {
+            current.unsubscribeDelta();
+          } catch {
+          }
+          try {
+            current.subscription.close();
+          } catch {
+          }
+        }
+        if (removeView) latest.delete(peerId);
+      };
+      const acceptRows = (peerId, generation, rows, replaceSnapshot) => {
+        if (stopped || active.get(peerId)?.generation !== generation) return;
+        let newest = null;
+        for (const row of rows) {
+          diagnostics.receivedEntries++;
+          const parsed = parseTailRow(row);
+          if (!parsed) {
+            diagnostics.invalidEntries++;
+            continue;
+          }
+          diagnostics.comparedEntries++;
+          if (!daemonIdsEquivalent(parsed.entry.daemonId, peerId)) {
+            diagnostics.mismatchedEntries++;
+            continue;
+          }
+          diagnostics.matchedEntries++;
+          if (!newest || compareOrder(parsed.order, newest.order) > 0) newest = parsed;
+        }
+        if (replaceSnapshot) {
+          if (!newest) {
+            latest.delete(peerId);
+            return;
+          }
+          latest.set(peerId, newest);
+          diagnostics.viewReplacements++;
+          return;
+        }
+        if (!newest) return;
+        const current = latest.get(peerId);
+        if (!current || compareOrder(newest.order, current.order) > 0) {
+          latest.set(peerId, newest);
+          diagnostics.viewReplacements++;
+        }
+      };
+      return {
+        attachPeer(peerId, peer) {
+          if (stopped || !peerId || peer.state() !== "ready") return false;
+          closeSubscription(peerId, true);
+          const generation = nextGeneration2++;
+          let subscription = null;
+          let unsubscribeSnapshot = null;
+          let unsubscribeDelta = null;
+          try {
+            subscription = handle.node.subscribe(peer, {
+              view: FLEET_STATUS_SUB_VIEW,
+              params: { topic: FLEET_STATUS_TOPIC }
+            });
+            unsubscribeSnapshot = subscription.onSnapshot((rows) => {
+              acceptRows(peerId, generation, rows, true);
+            });
+            unsubscribeDelta = subscription.onDelta((changes) => {
+              acceptRows(peerId, generation, changes.upserts, false);
+            });
+            active.set(peerId, {
+              generation,
+              subscription,
+              unsubscribeSnapshot,
+              unsubscribeDelta
+            });
+            return true;
+          } catch {
+            try {
+              unsubscribeSnapshot?.();
+            } catch {
+            }
+            try {
+              unsubscribeDelta?.();
+            } catch {
+            }
+            try {
+              subscription?.close();
+            } catch {
+            }
+            latest.delete(peerId);
+            return false;
+          }
+        },
+        detachPeer(peerId) {
+          closeSubscription(peerId, true);
+        },
+        snapshot() {
+          const peers = Array.from(latest.values()).map(({ entry }) => cloneEntry(entry)).sort((a, b) => a.daemonId.localeCompare(b.daemonId));
+          return {
+            peers,
+            diagnostics: {
+              subscribedPeers: active.size,
+              ...diagnostics
+            }
+          };
+        },
+        stop() {
+          if (stopped) return;
+          stopped = true;
+          for (const peerId of Array.from(active.keys())) closeSubscription(peerId, true);
+          latest.clear();
+        }
+      };
+    }
     init_mesh_parity();
     init_mesh_config();
     init_logger();
@@ -148839,6 +149325,7 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
       commandHandler.setAgentStreamManager(agentStreamManager);
       let seqscribeNodeRef;
       let seqscribeCollector;
+      let componentsRef;
       const router = new DaemonCommandRouter({
         commandHandler,
         cliManager,
@@ -148892,6 +149379,7 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
               parity: {
                 runs: parity.runs,
                 mismatches: parity.mismatches,
+                persistentMismatches: parity.persistentMismatches,
                 missingInShadow: parity.missingInShadow,
                 extraInShadow: parity.extraInShadow,
                 fieldMismatch: parity.fieldMismatch
@@ -148904,7 +149392,39 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
             );
             return null;
           }
-        }
+        },
+        // Beacon staleness / sole-copy for `get_status_metadata` (§7.1, mission
+        // b60d70b8). A getter for the same reason as getSeqscribeStats — but
+        // one level more so: the beacon is armed by the HOST on its first
+        // authenticated epoch, long after this router is constructed, so the
+        // closure reads `components.seqscribeBeacon` at call time.
+        //
+        // ★Unlike getSeqscribeStats above, the value here DOES carry topic
+        // names and peer writer ids. That is the feature, and it is why it is
+        // exposed on this LOCAL surface (and the P2P payload) only — never on
+        // status_report. `buildCloudSeqscribeSummary` is a fixed-key allow-list
+        // that could not forward it even by accident.
+        //
+        // `diagnostics()` performs no I/O: it reads the last board the beacon
+        // captured, so an on-demand `get_status_metadata` cannot turn into a
+        // Beacon traffic source (§7.1.2's idle-silence property).
+        getBeaconDiagnostics: () => {
+          const beacon = componentsRef?.seqscribeBeacon;
+          if (!beacon) return null;
+          try {
+            return toBeaconDiagnosticsSummary(beacon.diagnostics());
+          } catch (error48) {
+            LOG2.info(
+              "Seqscribe",
+              `beacon diagnostics unavailable for get_status_metadata: ${error48 instanceof Error ? error48.message : String(error48)}`
+            );
+            return null;
+          }
+        },
+        // Phase 4 Stage 2: pure local snapshot of statuses received through
+        // per-peer SUB tail subscriptions. The cloud host supplies PeerHandles
+        // after this core assembly returns; the slot is read at call time.
+        getFleetStatusPeerView: () => componentsRef?.seqscribeFleetStatusPeerView?.snapshot() ?? null
       });
       poller = new AgentStreamPoller({
         agentStreamManager,
@@ -148934,8 +149454,19 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
         onMeshCoordinatorEventForwarded: config2.onMeshCoordinatorEventForwarded,
         statusInstanceId: config2.statusInstanceId
       };
+      componentsRef = components;
       components.seqscribeNode = tryOpenDaemonSeqscribeNode({ daemonId: config2.statusInstanceId });
       seqscribeNodeRef = components.seqscribeNode;
+      if (components.seqscribeNode) {
+        try {
+          components.seqscribeFleetStatusPeerView = createFleetStatusPeerViewConsumer(components.seqscribeNode);
+        } catch (error48) {
+          LOG2.warn(
+            "Seqscribe",
+            `fleet.status SUB consumer unavailable: ${error48 instanceof Error ? error48.message : String(error48)}`
+          );
+        }
+      }
       if (components.seqscribeNode) {
         try {
           const node = components.seqscribeNode;
@@ -149033,7 +149564,8 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
         seqscribeNode,
         seqscribeProbe,
         seqscribeParityLoop,
-        seqscribeCollector
+        seqscribeCollector,
+        seqscribeFleetStatusPeerView
       } = components;
       poller.stop();
       cdpInitializer.stop();
@@ -149085,6 +149617,10 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
         configureFleetStatusShadow(null);
       } catch {
       }
+      try {
+        seqscribeFleetStatusPeerView?.stop();
+      } catch {
+      }
       try {
         configureMeshReadModel(null);
       } catch {
@@ -149588,6 +150124,7 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
     var TOPIC_RE2 = /^[A-Za-z0-9._*-]{1,160}$/;
     var MAX_TOPICS_PER_REPORT = 512;
     var MAX_WRITERS_PER_TOPIC = 512;
+    var MAX_HINTS_PER_TOPIC = 512;
     function finiteCount(v) {
       return typeof v === "number" && Number.isFinite(v) && v >= 0 ? Math.floor(v) : void 0;
     }
@@ -149609,6 +150146,31 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
       if (contig === void 0 || chain === void 0) return null;
       return rgen === void 0 ? { contig, chain } : { contig, chain, rgen };
     }
+    function projectHints(raw) {
+      if (!raw || typeof raw !== "object") return void 0;
+      const hints = {};
+      let topicCount = 0;
+      for (const [topic, rawTopicHints] of Object.entries(raw)) {
+        if (topicCount >= MAX_TOPICS_PER_REPORT) break;
+        if (!TOPIC_RE2.test(topic) || !rawTopicHints || typeof rawTopicHints !== "object") continue;
+        const topicHints = {};
+        let hintCount = 0;
+        for (const [keyHash, rawPosition] of Object.entries(rawTopicHints)) {
+          if (hintCount >= MAX_HINTS_PER_TOPIC) break;
+          if (!CHAIN_RE2.test(keyHash)) continue;
+          if (!Array.isArray(rawPosition) || rawPosition.length !== 2) continue;
+          const writer = typeof rawPosition[0] === "string" && WRITER_ID_RE.test(rawPosition[0]) ? rawPosition[0] : void 0;
+          const seq2 = finiteCount(rawPosition[1]);
+          if (writer === void 0 || seq2 === void 0) continue;
+          topicHints[keyHash] = [writer, seq2];
+          hintCount++;
+        }
+        if (hintCount === 0) continue;
+        hints[topic] = topicHints;
+        topicCount++;
+      }
+      return topicCount > 0 ? hints : void 0;
+    }
     function projectBeaconReport(raw) {
       if (!raw || typeof raw !== "object") return null;
       const v = raw;
@@ -149641,7 +150203,8 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
           topicCount++;
         }
       }
-      return { node, at, vectors };
+      const hints = projectHints(v.hints);
+      return hints ? { node, at, vectors, hints } : { node, at, vectors };
     }
     function assertNoPlaintextHintTopics(defs) {
       const offenders = defs.filter((d) => d.policy.hintKeys === "plain").map((d) => d.topic);
@@ -149701,9 +150264,16 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
       }
       assertNoPlaintextHintTopics(handle.topics);
       const counters5 = emptyCounters();
-      const scopeOf = opts.topicScope ?? defaultBeaconTopicScope;
+      const scopeOf = opts.topicScope ?? ((vectors) => [
+        .../* @__PURE__ */ new Set([
+          ...defaultBeaconTopicScope(vectors),
+          ...handle.topics.filter((definition) => definition.policy.hintKeys === "hash").map((definition) => definition.topic)
+        ])
+      ]);
       let stopped = false;
       let lastScope = [];
+      let lastLocalHints;
+      let lastBoard = null;
       const doPut = async (rawReport) => {
         const projected = projectBeaconReport(rawReport);
         if (!projected) {
@@ -149711,6 +150281,7 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
           LOG2.warn("Seqscribe", "beacon report failed the content projection; not sent");
           return;
         }
+        lastLocalHints = projected.hints;
         lastScope = scopeOf(projected.vectors);
         try {
           await transport.put(projected);
@@ -149789,6 +150360,12 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
           );
         }
         const clean2 = reports.map((r) => projectBeaconReport(r)).filter((r) => r !== null);
+        lastBoard = {
+          reports: clean2,
+          truncated,
+          topicScope: [...lastScope],
+          capturedAt: Date.now()
+        };
         LOG2.info(
           "Seqscribe",
           `beacon get writer=${handle.writerId} peers=${clean2.length} topics=${lastScope.length}`
@@ -149820,18 +150397,75 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
           );
         },
         counters: () => ({ ...counters5 }),
+        seedKnownBoard(seed) {
+          if (stopped || !Array.isArray(seed?.reports)) return;
+          const clean2 = seed.reports.map((report) => projectBeaconReport(report)).filter((report) => report !== null);
+          const truncated = typeof seed.truncated === "number" && Number.isFinite(seed.truncated) && seed.truncated >= 0 ? Math.floor(seed.truncated) : 0;
+          const topicScope = [...new Set(clean2.flatMap((report) => [
+            ...Object.keys(report.vectors),
+            ...Object.keys(report.hints ?? {})
+          ]))];
+          try {
+            handle.node.setKnownVectors(clean2);
+            lastBoard = {
+              reports: clean2,
+              truncated,
+              topicScope,
+              capturedAt: Date.now()
+            };
+            if (truncated > 0) counters5.truncated += truncated;
+            LOG2.info(
+              "Seqscribe",
+              `beacon auth seed writer=${handle.writerId} peers=${clean2.length} topics=${topicScope.length} truncated=${truncated}`
+            );
+          } catch (err) {
+            LOG2.info(
+              "Seqscribe",
+              `beacon auth seed rejected (advisory, ignored): ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        },
         async pushNow() {
           if (stopped) return;
           try {
             await doPut({
               node: handle.writerId,
               at: (/* @__PURE__ */ new Date()).toISOString(),
-              vectors: handle.node.vectors()
+              vectors: handle.node.vectors(),
+              ...lastLocalHints ? { hints: lastLocalHints } : {}
             });
             const board = await doGet();
             if (!stopped) handle.node.setKnownVectors(board);
           } catch {
           }
+        },
+        diagnostics() {
+          let localVectors = {};
+          try {
+            localVectors = handle.node.vectors();
+          } catch {
+          }
+          return computeBeaconDiagnostics({
+            node: handle.writerId,
+            localVectors,
+            board: lastBoard,
+            // ★ Advisory only (§5.7a). Query the hash keys peers actually
+            // advertised; the upstream reader chooses the raw max seq
+            // across writers, so this must never become a correctness gate.
+            keyStaleAdvisory: readKeyStaleAdvisory(
+              handle,
+              [...new Map(
+                (lastBoard?.reports ?? []).filter((report) => report.node !== handle.writerId).flatMap(
+                  (report) => Object.entries(report.hints ?? {}).flatMap(
+                    ([topic, topicHints]) => Object.keys(topicHints).map((key2) => [
+                      `${topic}\0${key2}`,
+                      { topic, key: key2 }
+                    ])
+                  )
+                )
+              ).values()]
+            )
+          });
         }
       };
       handle.onClose(() => beaconHandle.stop());