@adhdev/daemon-core 0.9.82-rc.310 → 0.9.82-rc.312

package/dist/index.js

@@ -31,6 +31,18 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/repo-mesh-types.ts
+function normalizeMeshSchedulingStrategy(value) {
+  if (typeof value !== "string") return DEFAULT_MESH_SCHEDULING_STRATEGY;
+  const trimmed = value.trim();
+  return MESH_SCHEDULING_STRATEGIES.includes(trimmed) ? trimmed : DEFAULT_MESH_SCHEDULING_STRATEGY;
+}
+function resolveNodeSchedulingPriority(nodePolicy) {
+  const raw = Number(nodePolicy?.schedulingPriority);
+  return Number.isFinite(raw) ? raw : 0;
+}
+function resolveAutoConvergeCodeChange(policy) {
+  return policy?.autoConvergeCodeChange === true;
+}
 function resolveDelegatedWorkerAutoApprove(meshPolicy, nodePolicy) {
   if (typeof nodePolicy?.delegatedWorkerAutoApprove === "boolean") {
     return nodePolicy.delegatedWorkerAutoApprove;
@@ -58,10 +70,19 @@ function resolveProviderMaxParallel(nodePolicy, providerType) {
   if (!Number.isFinite(raw) || raw < 0) return void 0;
   return Math.floor(raw);
 }
-var DEFAULT_MESH_POLICY;
+var MESH_SCHEDULING_STRATEGIES, DEFAULT_MESH_SCHEDULING_STRATEGY, MESH_CONVERGE_REFINE_TAG, MESH_CONVERGE_FAST_FORWARD_TAG, DEFAULT_MESH_POLICY;
 var init_repo_mesh_types = __esm({
   "src/repo-mesh-types.ts"() {
     "use strict";
+    MESH_SCHEDULING_STRATEGIES = [
+      "first_eligible",
+      "least_loaded",
+      "round_robin",
+      "priority_only"
+    ];
+    DEFAULT_MESH_SCHEDULING_STRATEGY = "first_eligible";
+    MESH_CONVERGE_REFINE_TAG = "converge=refine";
+    MESH_CONVERGE_FAST_FORWARD_TAG = "converge=fast_forward";
     DEFAULT_MESH_POLICY = {
       requirePreTaskCheckpoint: false,
       requirePostTaskCheckpoint: true,
@@ -295,10 +316,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "33fe83f72a43bccb1b4bec7744ee5c6d8c11a325" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "33fe83f7" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.310" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-17T09:34:54.806Z" : void 0);
+  const commit = readInjected(true ? "35facf0367dbbe37f25a3b5589287dc757ee6213" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "35facf03" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.312" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-17T22:48:50.124Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -1545,6 +1566,17 @@ function mergeMeshPolicy(base, patch) {
   if (!SPAWNED_SESSION_VISIBILITY_MODES.has(String(policy.spawnedSessionVisibility))) {
     policy.spawnedSessionVisibility = "visible";
   }
+  const normalizedStrategy = normalizeMeshSchedulingStrategy(policy.schedulingStrategy);
+  if (normalizedStrategy === "first_eligible") {
+    delete policy.schedulingStrategy;
+  } else {
+    policy.schedulingStrategy = normalizedStrategy;
+  }
+  if (policy.autoConvergeCodeChange === true) {
+    policy.autoConvergeCodeChange = true;
+  } else {
+    delete policy.autoConvergeCodeChange;
+  }
   return policy;
 }
 function normalizeAutoFastForwardPolicy(value) {
@@ -2086,6 +2118,7 @@ var init_coordinator_prompt = __esm({
 | \`mesh_read_debug\` | Collect a daemon-side chat/parser debug bundle for a session |
 | \`mesh_task_history\` | Read the task ledger \u2014 dispatches, completions, failures. Use to understand what has been done before deciding next steps |
 | \`mesh_git_status\` | Check git status on a specific node |
+| \`mesh_read_node_logs\` | Fetch a remote node's daemon log tail directly over P2P (grep/since/byte-bounded, secrets redacted) \u2014 no session/PowerShell needed to debug a node's daemon |
 | \`mesh_fast_forward_node\` | Safely dry-run or explicitly execute an obvious clean fast-forward without launching an agent session |
 | \`mesh_checkpoint\` | Create a git checkpoint on a node |
 | \`mesh_approve\` | Approve/reject a pending agent action |
@@ -2838,6 +2871,7 @@ __export(mesh_work_queue_exports, {
   recordMeshToolCall: () => recordMeshToolCall,
   recordTaskAutoLaunch: () => recordTaskAutoLaunch,
   requeueTask: () => requeueTask,
+  resolveConvergeRequiredTags: () => resolveConvergeRequiredTags,
   updateDirectDispatchStatus: () => updateDirectDispatchStatus,
   updateSessionTaskStatus: () => updateSessionTaskStatus,
   updateTaskStatus: () => updateTaskStatus,
@@ -2911,6 +2945,21 @@ function firstProviderPriority(policy) {
   if (!Array.isArray(raw)) return void 0;
   return raw.find((type) => typeof type === "string" && type.trim())?.trim();
 }
+function roleCapabilityTags(policy, providerType) {
+  const roles = policy && typeof policy === "object" && !Array.isArray(policy) ? policy.providerRoles : void 0;
+  if (!Array.isArray(roles)) return [];
+  const wantedProvider = typeof providerType === "string" && providerType.trim() ? providerType.trim().toLowerCase() : "";
+  const out = [];
+  for (const entry of roles) {
+    if (!entry || typeof entry !== "object") continue;
+    const type = typeof entry.providerType === "string" ? entry.providerType.trim().toLowerCase() : "";
+    const role = typeof entry.role === "string" ? entry.role.trim().toLowerCase() : "";
+    if (!role) continue;
+    if (wantedProvider && type && type !== wantedProvider) continue;
+    out.push(`role=${role}`);
+  }
+  return out;
+}
 function buildMeshNodeCapabilityTags(node, providerType) {
   const provider = typeof providerType === "string" && providerType.trim() ? providerType.trim() : firstProviderPriority(node?.policy);
   const worktreeBranch = typeof node?.worktreeBranch === "string" && node.worktreeBranch.trim() ? node.worktreeBranch.trim() : null;
@@ -2922,7 +2971,25 @@ function buildMeshNodeCapabilityTags(node, providerType) {
     // Worktree nodes automatically expose a "worktree=<branch>" tag so that
     // mesh_enqueue_task with required_tags: ["worktree=<branch>"] routes
     // only to the matching worktree node.
-    ...node?.isLocalWorktree === true && worktreeBranch ? [`worktree=${worktreeBranch}`] : []
+    ...node?.isLocalWorktree === true && worktreeBranch ? [`worktree=${worktreeBranch}`] : [],
+    // Convergence routing: advertise how this node can land its work onto base.
+    //   - converge=refine: local worktree nodes (on ANY machine — refine_mesh_node
+    //     now forwards to the owning daemon) can run the Refinery merge → push →
+    //     cleanup against their own checkout, so they accept code_change tasks.
+    //   - converge=fast_forward: non-worktree nodes (the machine itself) can only
+    //     ff/push an already-converged branch; they are NOT a destination for
+    //     code_change work (a worktree is created first, and that worktree node
+    //     receives the task instead). Reuses the ordinary required-tags filter —
+    //     the load-balancing scheduler auto-injects converge=refine for code_change
+    //     so such work is hard-filtered onto refine-capable nodes.
+    ...node?.isLocalWorktree === true ? ["converge=refine"] : ["converge=fast_forward"],
+    // Role-based routing: advertise role=<x> for each (node, provider) role
+    // declared in policy.providerRoles. Narrowed to the selected provider when
+    // one is given so the chosen provider must match a task's required role;
+    // when no provider is selected, all declared roles are advertised for the
+    // node-level eligibility scan. Reuses the ordinary required-tags filter —
+    // no separate role field/gate.
+    ...roleCapabilityTags(node?.policy, providerType)
   ]);
 }
 function nodeSatisfiesRequiredTags(requiredTags, capabilityTags) {
@@ -2931,6 +2998,18 @@ function nodeSatisfiesRequiredTags(requiredTags, capabilityTags) {
   const available = new Set(normalizeMeshCapabilityTags(capabilityTags));
   return required.every((tag) => available.has(tag));
 }
+function resolveConvergeRequiredTags(meshId, taskMode, explicitRequiredTags, opts) {
+  if (taskMode !== "code_change") return explicitRequiredTags;
+  if (typeof opts?.targetNodeId === "string" && opts.targetNodeId.trim()) return explicitRequiredTags;
+  let optedIn = false;
+  try {
+    optedIn = resolveAutoConvergeCodeChange(getMesh(meshId)?.policy);
+  } catch {
+    optedIn = false;
+  }
+  if (!optedIn) return explicitRequiredTags;
+  return normalizeMeshCapabilityTags([...explicitRequiredTags, MESH_CONVERGE_REFINE_TAG]);
+}
 function withQueueLock(_meshId, fn) {
   return MeshRuntimeStore.getInstance().transaction(fn);
 }
@@ -2989,7 +3068,15 @@ function enqueueTask(meshId, message, opts) {
       taskMode: modeValidation.taskMode,
       targetNodeId: opts?.targetNodeId,
       targetSessionId: opts?.targetSessionId,
-      requiredTags: normalizeMeshCapabilityTags(opts?.requiredTags),
+      // Convergence routing (opt-in): auto-inject converge=refine for code_change
+      // tasks so they hard-filter onto refine-capable worktree nodes. No-op unless
+      // the mesh opts in; explicit target_node_id / required_tags are preserved.
+      requiredTags: resolveConvergeRequiredTags(
+        meshId,
+        modeValidation.taskMode,
+        normalizeMeshCapabilityTags(opts?.requiredTags),
+        { targetNodeId: opts?.targetNodeId }
+      ),
       ...dependsOn.length > 0 ? { dependsOn } : {},
       ...typeof opts?.missionId === "string" && opts.missionId.trim() ? { missionId: opts.missionId.trim() } : {},
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -3250,6 +3337,7 @@ var init_mesh_work_queue = __esm({
     "use strict";
     import_crypto5 = require("crypto");
     init_mesh_host_ownership();
+    init_repo_mesh_types();
     init_mesh_runtime_store();
     init_mesh_config();
     ACTIVE_MESH_QUEUE_STATUSES = ["pending", "assigned"];
@@ -3544,6 +3632,17 @@ var init_mesh_runtime_store = __esm({
 
             CREATE INDEX IF NOT EXISTS idx_mesh_missions_mesh_status
                 ON mesh_missions(mesh_id, status, updated_at);
+
+            -- Load-balancing scheduler: per-mesh round-robin rotation cursor. When
+            -- the schedulingStrategy is 'round_robin', several eligible nodes tied at
+            -- the least load are rotated by this cursor so the tie-break winner cycles
+            -- across scheduling passes instead of always favouring the same array-order
+            -- node. Persisted (not a module Map) so rotation survives daemon restarts
+            -- and stays a single source of truth across scheduling entry points.
+            CREATE TABLE IF NOT EXISTS mesh_scheduler_cursor (
+                mesh_id TEXT PRIMARY KEY,
+                cursor INTEGER NOT NULL DEFAULT 0
+            );
         `);
       }
       hasCompletionFingerprint(fingerprint) {
@@ -3721,6 +3820,44 @@ var init_mesh_runtime_store = __esm({
         `).get(meshId, nodeId);
         return row !== void 0;
       }
+      /**
+       * Count active (status='assigned') tasks on a node, regardless of provider or
+       * task mode. This is the load metric for least-loaded / round-robin ranking:
+       * the scheduler prefers the node with the fewest active assignments so
+       * untargeted work spreads instead of piling onto whichever node asks first.
+       */
+      nodeActiveAssignmentCount(meshId, nodeId) {
+        const row = this.db.prepare(`
+            SELECT COUNT(*) as count FROM mesh_queue
+            WHERE mesh_id = ? AND status = 'assigned' AND assigned_node_id = ?
+        `).get(meshId, nodeId);
+        return row?.count ?? 0;
+      }
+      /**
+       * Read the current per-mesh round-robin cursor (0 when unset). Used to rotate
+       * the tie-break winner among nodes tied at the least load.
+       */
+      getSchedulerCursor(meshId) {
+        const row = this.db.prepare(
+          "SELECT cursor FROM mesh_scheduler_cursor WHERE mesh_id = ?"
+        ).get(meshId);
+        return row?.cursor ?? 0;
+      }
+      /**
+       * Atomically advance the per-mesh round-robin cursor by one and return the
+       * value that was current BEFORE the bump (the value the caller should rotate
+       * by for this pass). UPSERT keeps it lock-free across concurrent passes.
+       */
+      bumpSchedulerCursor(meshId) {
+        return this.transaction(() => {
+          const current = this.getSchedulerCursor(meshId);
+          this.db.prepare(`
+                INSERT INTO mesh_scheduler_cursor (mesh_id, cursor) VALUES (?, ?)
+                ON CONFLICT(mesh_id) DO UPDATE SET cursor = excluded.cursor
+            `).run(meshId, current + 1);
+          return current;
+        });
+      }
       /**
        * Count active (status='assigned') tasks on a (node, provider) combination,
        * matched by the assignedProviderType stamped on the payload at claim time.
@@ -5689,8 +5826,8 @@ function stripCoordinatorWrapperFile(filePath) {
     const remaining = (existing.slice(0, openIdx) + existing.slice(closeIdx + CLOSE.length)).replace(/^\s*\n+/, "").replace(/\n+\s*$/, "");
     if (!remaining.trim()) {
       try {
-        const fs30 = require("fs");
-        fs30.unlinkSync(filePath);
+        const fs31 = require("fs");
+        fs31.unlinkSync(filePath);
       } catch {
       }
     } else {
@@ -8292,6 +8429,33 @@ function activeReadonlyAssignedCount(meshId) {
 function nodeHasActiveAssignment(meshId, nodeId) {
   return getQueue(meshId, { status: ["assigned"] }).some((task) => task.assignedNodeId === nodeId);
 }
+function nodeActiveLoad(meshId, nodeId) {
+  return MeshRuntimeStore.getInstance().nodeActiveAssignmentCount(meshId, nodeId);
+}
+function resolveSchedulingStrategy(mesh) {
+  return normalizeMeshSchedulingStrategy(mesh?.policy?.schedulingStrategy);
+}
+function orderEligibleNodes(meshId, strategy, nodes, opts) {
+  if (strategy === "first_eligible" || nodes.length <= 1) {
+    return nodes;
+  }
+  const priorityOf = (n) => resolveNodeSchedulingPriority(n.node?.policy);
+  let rotation = 0;
+  if (strategy === "round_robin") {
+    const cursor = opts?.bumpCursor ? MeshRuntimeStore.getInstance().bumpSchedulerCursor(meshId) : MeshRuntimeStore.getInstance().getSchedulerCursor(meshId);
+    rotation = (cursor % nodes.length + nodes.length) % nodes.length;
+  }
+  const rotationRank = (index) => (index - rotation + nodes.length) % nodes.length;
+  return [...nodes].sort((a, b) => {
+    const prioDelta = priorityOf(b) - priorityOf(a);
+    if (prioDelta !== 0) return prioDelta;
+    if (strategy === "least_loaded" || strategy === "round_robin") {
+      const loadDelta = nodeActiveLoad(meshId, a.nodeId) - nodeActiveLoad(meshId, b.nodeId);
+      if (loadDelta !== 0) return loadDelta;
+    }
+    return rotationRank(a.index) - rotationRank(b.index);
+  });
+}
 function activeProviderAssignedCount(meshId, nodeId, providerType) {
   return getQueue(meshId, { status: ["assigned"] }).filter((task) => task.assignedNodeId === nodeId && task.assignedProviderType === providerType).length;
 }
@@ -8428,7 +8592,14 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
       markAutoLaunch(meshId, task.id, { status: "skipped", reason: "no_node_satisfies_required_tags", nodeId: task.targetNodeId });
       continue;
     }
-    for (const node of candidateNodes) {
+    const strategy = resolveSchedulingStrategy(mesh);
+    const orderedCandidateNodes = strategy === "first_eligible" ? candidateNodes : orderEligibleNodes(
+      meshId,
+      strategy,
+      candidateNodes.map((node, index) => ({ nodeId: readMeshNodeId(node), node, index })).filter((c) => c.nodeId),
+      { bumpCursor: true }
+    ).map((c) => c.node);
+    for (const node of orderedCandidateNodes) {
       const nodeId = readMeshNodeId(node);
       if (!nodeId) continue;
       const launchKey = `${meshId}:${nodeId}`;
@@ -8555,6 +8726,8 @@ async function triggerMeshQueue(components, meshId) {
       noIdleMeshSessionAvailable: true
     };
   }
+  const strategy = resolveSchedulingStrategy(mesh);
+  const localCandidates = [];
   const cliInstances = components.instanceManager.getByCategory("cli");
   for (const inst of cliInstances) {
     const state = inst.getState();
@@ -8577,7 +8750,7 @@ async function triggerMeshQueue(components, meshId) {
     const providerType = state.type || readNonEmptyString2(settings.providerType);
     if (providerType) {
       localIdleSessionsChecked += 1;
-      tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType);
+      localCandidates.push({ nodeId, sessionId, providerType, origin: "local", node: mesh.nodes.find((n) => readMeshNodeId(n) === nodeId) });
     } else {
       skippedSessions.push({
         nodeId,
@@ -8591,18 +8764,49 @@ async function triggerMeshQueue(components, meshId) {
     remoteSessions = MeshRuntimeStore.getInstance().getRemoteIdleSessions();
   } catch {
   }
+  const remoteCandidates = [];
   for (const idle of remoteSessions) {
     const node = mesh.nodes.find((n) => n.id === idle.nodeId);
     if (node) {
       remoteIdleSessionsChecked += 1;
-      const assigned = tryAssignQueueTask(components, meshId, idle.nodeId, idle.sessionId, idle.providerType);
-      if (assigned) {
-        try {
-          MeshRuntimeStore.getInstance().deleteRemoteIdleSession(idle.nodeId, idle.sessionId);
-        } catch {
-        }
+      remoteCandidates.push({ nodeId: idle.nodeId, sessionId: idle.sessionId, providerType: idle.providerType, origin: "remote", node });
+    }
+  }
+  const assignIdleCandidate = (candidate) => {
+    const assigned = tryAssignQueueTask(components, meshId, candidate.nodeId, candidate.sessionId, candidate.providerType);
+    if (assigned && candidate.origin === "remote") {
+      try {
+        MeshRuntimeStore.getInstance().deleteRemoteIdleSession(candidate.nodeId, candidate.sessionId);
+      } catch {
       }
     }
+  };
+  if (strategy === "first_eligible") {
+    for (const candidate of localCandidates) assignIdleCandidate(candidate);
+    for (const candidate of remoteCandidates) assignIdleCandidate(candidate);
+  } else {
+    const pool = [...localCandidates, ...remoteCandidates];
+    const baseIndex = /* @__PURE__ */ new Map();
+    pool.forEach((c, i) => {
+      if (!baseIndex.has(c.nodeId)) baseIndex.set(c.nodeId, i);
+    });
+    const uniqueNodes = [...new Set(pool.map((c) => c.nodeId))].map((nodeId, index) => ({ nodeId, node: pool.find((c) => c.nodeId === nodeId)?.node, index }));
+    const ranked = orderEligibleNodes(meshId, strategy, uniqueNodes, { bumpCursor: true });
+    const rankIndex = new Map(ranked.map((r, i) => [r.nodeId, i]));
+    const remaining = [...pool];
+    while (remaining.length > 0) {
+      remaining.sort((a, b) => {
+        const aPrio = resolveNodeSchedulingPriority(a.node?.policy);
+        const bPrio = resolveNodeSchedulingPriority(b.node?.policy);
+        if (aPrio !== bPrio) return bPrio - aPrio;
+        if (strategy === "least_loaded" || strategy === "round_robin") {
+          const loadDelta = nodeActiveLoad(meshId, a.nodeId) - nodeActiveLoad(meshId, b.nodeId);
+          if (loadDelta !== 0) return loadDelta;
+        }
+        return (rankIndex.get(a.nodeId) ?? 0) - (rankIndex.get(b.nodeId) ?? 0);
+      });
+      assignIdleCandidate(remaining.shift());
+    }
   }
   autoLaunchStarted = await maybeAutoLaunchOneQueueSession(components, meshId, mesh);
   const afterQueue = getQueue(meshId);
@@ -10655,8 +10859,8 @@ var init_pty_transport = __esm({
         let cwd = options.cwd;
         if (cwd) {
           try {
-            const fs30 = require("fs");
-            const stat2 = fs30.statSync(cwd);
+            const fs31 = require("fs");
+            const stat2 = fs31.statSync(cwd);
             if (!stat2.isDirectory()) cwd = os11.homedir();
           } catch {
             cwd = os11.homedir();
@@ -10763,9 +10967,9 @@ function findBinary(name) {
     for (const ext of exes) {
       const fullPath = path17.join(p, trimmed + ext);
       try {
-        const fs30 = require("fs");
-        if (fs30.existsSync(fullPath)) {
-          const stat2 = fs30.statSync(fullPath);
+        const fs31 = require("fs");
+        if (fs31.existsSync(fullPath)) {
+          const stat2 = fs31.statSync(fullPath);
           if (stat2.isFile() && (isWin || stat2.mode & 73)) {
             return fullPath;
           }
@@ -10779,12 +10983,12 @@ function findBinary(name) {
 function isScriptBinary(binaryPath) {
   if (!path17.isAbsolute(binaryPath)) return false;
   try {
-    const fs30 = require("fs");
-    const resolved = fs30.realpathSync(binaryPath);
+    const fs31 = require("fs");
+    const resolved = fs31.realpathSync(binaryPath);
     const head = Buffer.alloc(8);
-    const fd = fs30.openSync(resolved, "r");
-    fs30.readSync(fd, head, 0, 8, 0);
-    fs30.closeSync(fd);
+    const fd = fs31.openSync(resolved, "r");
+    fs31.readSync(fd, head, 0, 8, 0);
+    fs31.closeSync(fd);
     let i = 0;
     if (head[0] === 239 && head[1] === 187 && head[2] === 191) i = 3;
     return head[i] === 35 && head[i + 1] === 33;
@@ -10795,12 +10999,12 @@ function isScriptBinary(binaryPath) {
 function looksLikeMachOOrElf(filePath) {
   if (!path17.isAbsolute(filePath)) return false;
   try {
-    const fs30 = require("fs");
-    const resolved = fs30.realpathSync(filePath);
+    const fs31 = require("fs");
+    const resolved = fs31.realpathSync(filePath);
     const buf = Buffer.alloc(8);
-    const fd = fs30.openSync(resolved, "r");
-    fs30.readSync(fd, buf, 0, 8, 0);
-    fs30.closeSync(fd);
+    const fd = fs31.openSync(resolved, "r");
+    fs31.readSync(fd, buf, 0, 8, 0);
+    fs31.closeSync(fd);
     let i = 0;
     if (buf[0] === 239 && buf[1] === 187 && buf[2] === 191) i = 3;
     const b = buf.subarray(i);
@@ -11976,7 +12180,7 @@ var init_cli_state_engine = __esm({
       scheduleSettle() {
         if (this.settleTimer) clearTimeout(this.settleTimer);
         const epoch = this.responseEpoch;
-        const delay = Math.max(
+        const delay2 = Math.max(
           this.timeouts.outputSettle,
           this.submitPendingUntil > Date.now() ? this.submitPendingUntil - Date.now() + this.timeouts.outputSettle : 0
         );
@@ -11984,7 +12188,7 @@ var init_cli_state_engine = __esm({
           this.settleTimer = null;
           if (epoch !== this.responseEpoch) return;
           this.evaluateSettled(this.transport.getSnapshot());
-        }, delay);
+        }, delay2);
       }
       /** Called from sendMessage in transport once a turn scope is established. */
       onTurnStarted(turnScope) {
@@ -15492,6 +15696,7 @@ __export(index_exports, {
   DEFAULT_GIT_WORKSPACE_POLL_INTERVAL_MS: () => DEFAULT_GIT_WORKSPACE_POLL_INTERVAL_MS,
   DEFAULT_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS: () => DEFAULT_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS,
   DEFAULT_MESH_POLICY: () => DEFAULT_MESH_POLICY,
+  DEFAULT_MESH_SCHEDULING_STRATEGY: () => DEFAULT_MESH_SCHEDULING_STRATEGY,
   DEFAULT_SESSION_HOST_APP_NAME: () => DEFAULT_SESSION_HOST_APP_NAME,
   DEFAULT_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS: () => DEFAULT_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS,
   DEFAULT_SESSION_HOST_READY_TIMEOUT_MS: () => DEFAULT_SESSION_HOST_READY_TIMEOUT_MS,
@@ -15517,9 +15722,12 @@ __export(index_exports, {
   InMemoryGitSnapshotStore: () => InMemoryGitSnapshotStore,
   LOG: () => LOG,
   MAX_LEDGER_SLICE_LIMIT: () => MAX_LEDGER_SLICE_LIMIT,
+  MESH_CONVERGE_FAST_FORWARD_TAG: () => MESH_CONVERGE_FAST_FORWARD_TAG,
+  MESH_CONVERGE_REFINE_TAG: () => MESH_CONVERGE_REFINE_TAG,
   MESH_MISSION_STATUSES: () => MESH_MISSION_STATUSES,
   MESH_REFINE_CONFIG_LOCATIONS: () => MESH_REFINE_CONFIG_LOCATIONS,
   MESH_REFINE_CONFIG_SCHEMA: () => MESH_REFINE_CONFIG_SCHEMA,
+  MESH_SCHEDULING_STRATEGIES: () => MESH_SCHEDULING_STRATEGIES,
   MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS: () => MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS,
   MESH_WORKTREE_BOOTSTRAP_CONFIG_SCHEMA: () => MESH_WORKTREE_BOOTSTRAP_CONFIG_SCHEMA,
   MIN_GIT_WORKSPACE_POLL_INTERVAL_MS: () => MIN_GIT_WORKSPACE_POLL_INTERVAL_MS,
@@ -15720,6 +15928,7 @@ __export(index_exports, {
   normalizeManagedStatus: () => normalizeManagedStatus,
   normalizeMeshCapabilityTags: () => normalizeMeshCapabilityTags,
   normalizeMeshDaemonRole: () => normalizeMeshDaemonRole,
+  normalizeMeshSchedulingStrategy: () => normalizeMeshSchedulingStrategy,
   normalizeMeshTaskMode: () => normalizeMeshTaskMode,
   normalizeMeshWorkerResult: () => normalizeMeshWorkerResult,
   normalizeMessageParts: () => normalizeMessageParts,
@@ -15757,7 +15966,9 @@ __export(index_exports, {
   resetConfig: () => resetConfig,
   resetDebugRuntimeConfig: () => resetDebugRuntimeConfig,
   resetState: () => resetState,
+  resolveAutoConvergeCodeChange: () => resolveAutoConvergeCodeChange,
   resolveChatMessageKind: () => resolveChatMessageKind,
+  resolveConvergeRequiredTags: () => resolveConvergeRequiredTags,
   resolveCurrentGlobalInstallSurface: () => resolveCurrentGlobalInstallSurface,
   resolveDebugRuntimeConfig: () => resolveDebugRuntimeConfig,
   resolveDelegatedWorkerAutoApprove: () => resolveDelegatedWorkerAutoApprove,
@@ -15765,6 +15976,7 @@ __export(index_exports, {
   resolveGitRepository: () => resolveGitRepository,
   resolveMeshHostStatus: () => resolveMeshHostStatus,
   resolveMeshRefineValidationPlan: () => resolveMeshRefineValidationPlan,
+  resolveNodeSchedulingPriority: () => resolveNodeSchedulingPriority,
   resolveSessionHostAppName: () => resolveSessionHostAppName,
   resolveSessionHostAppNameResolution: () => resolveSessionHostAppNameResolution,
   resolveWorktreePath: () => resolveWorktreePath,
@@ -18139,9 +18351,9 @@ function readString6(value) {
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
 function summarizeMessage(message) {
-  const oneLine = message.replace(/\s+/g, " ").trim();
-  const title = oneLine.length > 96 ? `${oneLine.slice(0, 93)}...` : oneLine;
-  return { title: title || "(untitled task)", summary: oneLine };
+  const oneLine2 = message.replace(/\s+/g, " ").trim();
+  const title = oneLine2.length > 96 ? `${oneLine2.slice(0, 93)}...` : oneLine2;
+  return { title: title || "(untitled task)", summary: oneLine2 };
 }
 function elapsedSince(value, now) {
   const started = value ? new Date(value).getTime() : Number.NaN;
@@ -21247,6 +21459,11 @@ function collapseReplayAssistantTurns(messages, historyBehavior) {
       continue;
     }
     if (message.role === "assistant") {
+      const isActivity = message.kind === "tool" || message.kind === "terminal" || message.kind === "thought";
+      if (isActivity) {
+        collapsed.push(message);
+        continue;
+      }
       if (sawAssistantSinceLastUser) continue;
       sawAssistantSinceLastUser = true;
       collapsed.push(message);
@@ -26390,7 +26607,8 @@ function buildReadChatCommandResult(payload, args, h) {
   const sessionIdHint = typeof args?.targetSessionId === "string" ? args.targetSessionId : typeof args?.sessionId === "string" ? args.sessionId : "";
   const providerHint = typeof args?.cliType === "string" ? args.cliType : typeof args?.providerType === "string" ? args.providerType : typeof args?.agentType === "string" ? args.agentType : "";
   const filteredMessages = h ? maybeHideCoordinatorPromptMessage(h, providerHint, sessionIdHint, messages) : messages;
-  const visibleMessages = filterUserFacingChatMessages(filteredMessages);
+  const includeActivity = args?.includeActivity === true || args?.includeActivity === "true";
+  const visibleMessages = includeActivity ? filteredMessages.filter((m) => isUserFacingChatMessage(m) || isActivityChatMessage(m)) : filterUserFacingChatMessages(filteredMessages);
   const sync = buildFullTail(visibleMessages, normalizeReadChatTailLimit(args));
   const hiddenMsgCount = Math.max(0, messages.length - visibleMessages.length);
   const preservedPayloadFields = Object.fromEntries(Object.entries(payload).filter(([key]) => shouldPreserveReadChatPayloadField(key)));
@@ -28759,6 +28977,9 @@ function normalizeProviderScriptArgs(args, scriptName) {
 }
 function buildControlScriptResult(scriptName, payload) {
   if (!payload || typeof payload !== "object") return {};
+  if (payload.controlResult && typeof payload.controlResult === "object") {
+    return { controlResult: payload.controlResult };
+  }
   const legacyListPayload = (() => {
     if (Array.isArray(payload.options)) return payload;
     if (/^listmodels$/i.test(scriptName) && Array.isArray(payload.models)) {
@@ -29621,7 +29842,7 @@ var DaemonCommandHandler = class {
       return { success: false, error: "invalid type" };
     }
     const https = require("https");
-    const fs30 = require("fs");
+    const fs31 = require("fs");
     const path41 = require("path");
     const crypto6 = require("crypto");
     const REGISTRY = "https://api.adhf.dev/api/v1/registry";
@@ -29665,7 +29886,7 @@ var DaemonCommandHandler = class {
       if (!targetDir.startsWith(installRootResolved + path41.sep)) {
         return { success: false, error: "install path escaped upstream root" };
       }
-      fs30.mkdirSync(targetDir, { recursive: true });
+      fs31.mkdirSync(targetDir, { recursive: true });
       let manifestProbe = {};
       try {
         manifestProbe = JSON.parse(manifestBody);
@@ -29690,7 +29911,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
       }
       const targetFile = isV1 ? "provider.v1.json" : "provider.json";
       const targetPath = path41.join(targetDir, targetFile);
-      fs30.writeFileSync(targetPath, manifestBody, "utf-8");
+      fs31.writeFileSync(targetPath, manifestBody, "utf-8");
       const manifestJson = JSON.parse(manifestBody);
       const scriptFetch = await this.fetchProviderSources(
         manifestJson,
@@ -29760,7 +29981,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     const repo = source.repo;
     const ref = source.ref;
     const https = require("https");
-    const fs30 = require("fs");
+    const fs31 = require("fs");
     const path41 = require("path");
     function fetchJson(url, timeoutMs) {
       return new Promise((resolve24, reject) => {
@@ -29844,8 +30065,8 @@ ${formatManifestValidationIssues2(validation.issues)}`,
             const relInside = entry.path.startsWith(sharedDirRel + "/") ? entry.path.slice(sharedDirRel.length + 1) : entry.path;
             const outPath = path41.resolve(path41.join(sharedTargetDir, relInside));
             if (!outPath.startsWith(path41.resolve(sharedTargetDir) + path41.sep)) continue;
-            fs30.mkdirSync(path41.dirname(outPath), { recursive: true });
-            fs30.writeFileSync(outPath, body);
+            fs31.mkdirSync(path41.dirname(outPath), { recursive: true });
+            fs31.writeFileSync(outPath, body);
             fetchedCount++;
           } catch (e) {
             errors.push(`fetch shared ${entry.path}: ${e?.message ?? e}`);
@@ -29883,8 +30104,8 @@ ${formatManifestValidationIssues2(validation.issues)}`,
               errors.push(`refusing to write outside targetDir: ${entry.path}`);
               continue;
             }
-            fs30.mkdirSync(path41.dirname(outPath), { recursive: true });
-            fs30.writeFileSync(outPath, body);
+            fs31.mkdirSync(path41.dirname(outPath), { recursive: true });
+            fs31.writeFileSync(outPath, body);
             fetchedCount++;
           } catch (e) {
             errors.push(`fetch ${entry.path}: ${e?.message ?? e}`);
@@ -29912,7 +30133,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     if (!["cli", "ide", "extension", "acp"].includes(category)) {
       return { success: false, error: `unknown category: ${category}` };
     }
-    const fs30 = require("fs");
+    const fs31 = require("fs");
     const path41 = require("path");
     try {
       const installRoot = this.getUpstreamInstallRoot();
@@ -29921,10 +30142,10 @@ ${formatManifestValidationIssues2(validation.issues)}`,
       if (!targetDir.startsWith(installRootResolved + path41.sep)) {
         return { success: false, error: "refusing to delete outside upstream root" };
       }
-      if (!fs30.existsSync(targetDir)) {
+      if (!fs31.existsSync(targetDir)) {
         return { success: false, error: "not installed" };
       }
-      fs30.rmSync(targetDir, { recursive: true, force: true });
+      fs31.rmSync(targetDir, { recursive: true, force: true });
       if (this._ctx.providerLoader) {
         this._ctx.providerLoader.reload();
         this._ctx.providerLoader.registerToDetector();
@@ -29940,28 +30161,28 @@ ${formatManifestValidationIssues2(validation.issues)}`,
    * the UI and by the update checker.
    */
   handleListInstalledProviders(_args) {
-    const fs30 = require("fs");
+    const fs31 = require("fs");
     const path41 = require("path");
     const installRoot = this.getUpstreamInstallRoot();
-    if (!fs30.existsSync(installRoot)) return { success: true, providers: [] };
+    if (!fs31.existsSync(installRoot)) return { success: true, providers: [] };
     const CATEGORIES = ["cli", "ide", "extension", "acp"];
     const items = [];
     for (const category of CATEGORIES) {
       const categoryDir = path41.join(installRoot, category);
-      if (!fs30.existsSync(categoryDir)) continue;
+      if (!fs31.existsSync(categoryDir)) continue;
       let entries;
       try {
-        entries = fs30.readdirSync(categoryDir);
+        entries = fs31.readdirSync(categoryDir);
       } catch {
         continue;
       }
       for (const type of entries) {
         const v1Path = path41.join(categoryDir, type, "provider.v1.json");
         const v0Path = path41.join(categoryDir, type, "provider.json");
-        const manifestPath = fs30.existsSync(v1Path) ? v1Path : fs30.existsSync(v0Path) ? v0Path : null;
+        const manifestPath = fs31.existsSync(v1Path) ? v1Path : fs31.existsSync(v0Path) ? v0Path : null;
         if (!manifestPath) continue;
         try {
-          const m = JSON.parse(fs30.readFileSync(manifestPath, "utf-8"));
+          const m = JSON.parse(fs31.readFileSync(manifestPath, "utf-8"));
           items.push({
             type,
             category,
@@ -30072,7 +30293,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     if (!/^@[a-z0-9_-]+$/i.test(requestedName)) {
       return { success: false, error: "name must match @[a-z0-9_-]+" };
     }
-    const fs30 = require("fs");
+    const fs31 = require("fs");
     const path41 = require("path");
     const { spawnSync: spawnSync2 } = require("child_process");
     const file = ext.loadExternalSources();
@@ -30083,8 +30304,8 @@ ${formatManifestValidationIssues2(validation.issues)}`,
       return { success: false, error: `source url+ref already registered (use a different name to track another ref)` };
     }
     const sourceDir = path41.join(ext.externalRoot(), requestedName);
-    if (!fs30.existsSync(ext.externalRoot())) fs30.mkdirSync(ext.externalRoot(), { recursive: true });
-    if (fs30.existsSync(sourceDir)) {
+    if (!fs31.existsSync(ext.externalRoot())) fs31.mkdirSync(ext.externalRoot(), { recursive: true });
+    if (fs31.existsSync(sourceDir)) {
       return { success: false, error: `directory already exists: ${sourceDir} (rename or remove first)` };
     }
     const clone = spawnSync2("git", ["clone", "--depth=1", "--branch", ref, "--", url, sourceDir], {
@@ -30094,7 +30315,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     });
     if (clone.status !== 0) {
       try {
-        fs30.rmSync(sourceDir, { recursive: true, force: true });
+        fs31.rmSync(sourceDir, { recursive: true, force: true });
       } catch {
       }
       return { success: false, error: `git clone failed: ${(clone.stderr || clone.stdout || "").trim() || "unknown error"}` };
@@ -30138,15 +30359,15 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     const name = typeof args?.name === "string" ? args.name.trim() : "";
     if (!name) return { success: false, error: "name is required" };
     const ext = (init_external_sources(), __toCommonJS(external_sources_exports));
-    const fs30 = require("fs");
+    const fs31 = require("fs");
     const path41 = require("path");
     const file = ext.loadExternalSources();
     const match = file.sources.find((s) => s.name === name);
     if (!match) return { success: false, error: `source "${name}" not registered` };
     const sourceDir = path41.join(ext.externalRoot(), name);
-    if (fs30.existsSync(sourceDir)) {
+    if (fs31.existsSync(sourceDir)) {
       try {
-        fs30.rmSync(sourceDir, { recursive: true, force: true });
+        fs31.rmSync(sourceDir, { recursive: true, force: true });
       } catch (e) {
         return { success: false, error: `failed to delete ${sourceDir}: ${e?.message || e}` };
       }
@@ -30609,12 +30830,12 @@ var FsmDriver = class {
   scheduleSpawnPrime() {
     const seqs = this.spec.send_on_spawn;
     if (!Array.isArray(seqs) || seqs.length === 0) return;
-    const delay = Math.max(0, this.spec.send_on_spawn_delay_ms ?? 250);
+    const delay2 = Math.max(0, this.spec.send_on_spawn_delay_ms ?? 250);
     setTimeout(() => {
       for (const seq of seqs) {
         if (typeof seq === "string" && seq.length > 0) this.adapter.send_keys(seq);
       }
-    }, delay);
+    }, delay2);
   }
   dispatch(cmd) {
     switch (cmd.kind) {
@@ -30980,11 +31201,11 @@ var FsmDriver = class {
       const armed = this.delegateTimers.has(d.id);
       const shouldFire = d.when_state === currentStateId;
       if (shouldFire && !armed) {
-        const delay = d.after_duration_ms ?? 0;
+        const delay2 = d.after_duration_ms ?? 0;
         const t = setTimeout(() => {
           this.fireDelegate(d);
           this.delegateTimers.delete(d.id);
-        }, delay);
+        }, delay2);
         this.delegateTimers.set(d.id, t);
       } else if (!shouldFire && armed) {
         clearTimeout(this.delegateTimers.get(d.id));
@@ -31038,7 +31259,15 @@ var FsmDriver = class {
         this.adapter.send_keys(a.keys);
         return;
       case "open_picker":
-        this.adapter.send_keys(a.trigger_keys);
+        {
+          const m = /^([\s\S]*?)([\r\n]+)$/.exec(a.trigger_keys);
+          if (m && m[1]) {
+            this.adapter.send_keys(m[1]);
+            setTimeout(() => this.adapter.send_keys(m[2]), 200);
+          } else {
+            this.adapter.send_keys(a.trigger_keys);
+          }
+        }
         this.pickerInProgress = { control_id: ctl.id, spec: ctl };
         return;
       case "attach_image": {
@@ -31223,8 +31452,7 @@ function executeJsonl(src, input) {
   for (let i = 0; i < lines.length; i += 1) {
     const rec = lines[i];
     if (filter && !filter(rec)) continue;
-    const msg = projectMessage(rec, src.message_map, i, lines.length, mtime);
-    if (msg) {
+    for (const msg of projectMessages(rec, src.message_map, i, lines.length, mtime)) {
       if (transcriptWorkspace) msg.workspace = transcriptWorkspace;
       messages.push(msg);
     }
@@ -31304,8 +31532,9 @@ function executeSqlite(src, input) {
     const mtime = safeMtimeMs(resolved);
     const messages = [];
     for (let i = 0; i < messageRows.length; i += 1) {
-      const msg = projectMessage(messageRows[i], src.message_map, i, messageRows.length, mtime);
-      if (msg) messages.push(msg);
+      for (const msg of projectMessages(messageRows[i], src.message_map, i, messageRows.length, mtime)) {
+        messages.push(msg);
+      }
     }
     if (messages.length === 0) return null;
     return {
@@ -31703,11 +31932,42 @@ function jsonPathGet(record, expr) {
   }
   return cur;
 }
-function projectMessage(record, map, index, total, sourceMtimeMs) {
+function projectMessages(record, map, index, total, sourceMtimeMs) {
   const roleRaw = jsonPathGet(record, map.role);
-  const contentRaw = jsonPathGet(record, map.content);
   const role = normalizeRole(roleRaw);
-  let content = stringifyContent(contentRaw);
+  let receivedAt = sourceMtimeMs - (total - 1 - index) * 1e3;
+  if (map.timestamp_ms) {
+    const tsRaw = jsonPathGet(record, map.timestamp_ms);
+    const parsed = parseTimestamp(tsRaw);
+    if (parsed != null) receivedAt = parsed;
+  }
+  const kindRaw = map.kind ? jsonPathGet(record, map.kind) : void 0;
+  const kind = typeof kindRaw === "string" && kindRaw ? kindRaw : "standard";
+  const out = [];
+  if (map.tools) {
+    const recordTool = projectToolBlock(record, role, map.tools);
+    if (recordTool) {
+      out.push({ ...recordTool, receivedAt });
+      return out;
+    }
+  }
+  const contentRaw = jsonPathGet(record, map.content);
+  const content = cleanContent(stringifyContent(contentRaw), map);
+  if (content) out.push({ role, content, receivedAt, kind });
+  if (map.tools && Array.isArray(contentRaw)) {
+    let nudge = 1;
+    for (const block2 of contentRaw) {
+      const tool = projectToolBlock(block2, role, map.tools);
+      if (tool) {
+        out.push({ ...tool, receivedAt: receivedAt + nudge });
+        nudge += 1;
+      }
+    }
+  }
+  return out;
+}
+function cleanContent(input, map) {
+  let content = input;
   if (content && map.content_strip) {
     for (const tag of map.content_strip) {
       const safeTag = tag.replace(/[.+^${}()|[\]\\]/g, "\\$&");
@@ -31723,17 +31983,33 @@ function projectMessage(record, map, index, total, sourceMtimeMs) {
       content = content.replace(open, "").replace(close, "");
     }
   }
-  if (content) content = content.trim();
-  if (!content) return null;
-  let receivedAt = sourceMtimeMs - (total - 1 - index) * 1e3;
-  if (map.timestamp_ms) {
-    const tsRaw = jsonPathGet(record, map.timestamp_ms);
-    const parsed = parseTimestamp(tsRaw);
-    if (parsed != null) receivedAt = parsed;
+  return content ? content.trim() : "";
+}
+var DEFAULT_TOOL_CALL_TYPES = ["tool_use", "function_call", "custom_tool_call"];
+var DEFAULT_TOOL_RESULT_TYPES = ["tool_result", "function_call_output", "custom_tool_call_output"];
+function projectToolBlock(block2, role, tmap) {
+  void role;
+  if (block2 == null || typeof block2 !== "object") return null;
+  const typeVal = String(jsonPathGet(block2, tmap.block_type || "$.type") ?? "");
+  if (!typeVal) return null;
+  const callTypes = tmap.call_types ?? DEFAULT_TOOL_CALL_TYPES;
+  const resultTypes = tmap.result_types ?? DEFAULT_TOOL_RESULT_TYPES;
+  if (callTypes.includes(typeVal)) {
+    const name = String(jsonPathGet(block2, tmap.call_name || "$.name") ?? "tool").trim() || "tool";
+    const args = oneLine(stringifyContent(jsonPathGet(block2, tmap.call_args || "$.input")), 240);
+    const content = args ? `\u2197 ${name}: ${args}` : `\u2197 ${name}`;
+    return { role: "assistant", content, receivedAt: 0, kind: "tool" };
+  }
+  if (resultTypes.includes(typeVal)) {
+    const result = oneLine(stringifyContent(jsonPathGet(block2, tmap.result_content || "$.content")), 600);
+    if (!result) return null;
+    return { role: "assistant", content: `\u2198 ${result}`, receivedAt: 0, kind: "tool" };
   }
-  const kindRaw = map.kind ? jsonPathGet(record, map.kind) : void 0;
-  const kind = typeof kindRaw === "string" && kindRaw ? kindRaw : "standard";
-  return { role, content, receivedAt, kind };
+  return null;
+}
+function oneLine(s, max) {
+  const flat = s.replace(/\s+/g, " ").trim();
+  return flat.length > max ? flat.slice(0, max - 1) + "\u2026" : flat;
 }
 function parseTimestamp(v) {
   if (v == null) return null;
@@ -31874,6 +32150,9 @@ init_logger();
 function stripAnsi3(text) {
   return String(text || "").replace(/\x1B\][^\x07]*(?:\x07|\x1B\\)/g, "").replace(/\x1B[P^_X][\s\S]*?(?:\x07|\x1B\\)/g, "").replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "");
 }
+function delay(ms) {
+  return new Promise((resolve24) => setTimeout(resolve24, ms));
+}
 var SpecCliAdapter = class _SpecCliAdapter {
   cliType;
   cliName;
@@ -32095,9 +32374,15 @@ var SpecCliAdapter = class _SpecCliAdapter {
    * drives the dispatch:
    *
    *   send_keys     → click_control                   (e.g. stop)
-   *   open_picker   → click_control then resolve when extract_choices
-   *                   surface; choice index comes from args.choiceIndex
-   *                   or args.choice (string label match), defaulting to 0
+   *   open_picker   → two roles, driven by the screen, not a hardcoded list:
+   *                   - LIST  (no choice arg): open the picker, wait for it
+   *                     to render, parse the on-screen options via
+   *                     `extract_choices`, and return them as
+   *                     `controlResult.options` (+ `currentValue`). This is
+   *                     how the dashboard's Model/Mode controls learn what is
+   *                     actually selectable in this CLI right now.
+   *                   - SELECT (args.choiceIndex / args.choiceLabel): drive
+   *                     the picker to that option using `submit_key`.
    *   attach_image  → attach_image dispatch; expects args.blob (data url
    *                   or base64) and args.mime
    *
@@ -32122,11 +32407,128 @@ var SpecCliAdapter = class _SpecCliAdapter {
       this.driver.dispatch({ kind: "attach_image", blob, mime });
       return Promise.resolve({ ok: true, effects: [{ type: "attached_image", controlId: ctl.id }] });
     }
+    if (action.type === "open_picker") {
+      const choiceIndex = typeof flat.choiceIndex === "number" ? flat.choiceIndex : typeof flat.choiceIndex === "string" && flat.choiceIndex.trim() ? Number(flat.choiceIndex) : void 0;
+      const choiceLabel = typeof flat.choiceLabel === "string" ? flat.choiceLabel : typeof flat.choice === "string" ? flat.choice : void 0;
+      if (typeof choiceIndex === "number" && Number.isFinite(choiceIndex) || choiceLabel && choiceLabel.trim()) {
+        return this.selectPickerChoice(ctl, action, choiceIndex, choiceLabel);
+      }
+      return this.openPickerAndListChoices(ctl, action);
+    }
     this.driver.dispatch({ kind: "click_control", control_id: ctl.id, payload: flat });
-    const effects = [];
-    if (action.type === "open_picker") effects.push({ type: "opened_picker", controlId: ctl.id });
-    else if (action.type === "send_keys") effects.push({ type: "sent_keys", controlId: ctl.id });
-    return Promise.resolve({ ok: true, effects });
+    return Promise.resolve({ ok: true, effects: [{ type: "sent_keys", controlId: ctl.id }] });
+  }
+  /**
+   * Open an `open_picker` control and return the options the CLI is showing,
+   * parsed live from the screen via `extract_choices`. Nothing is selected —
+   * the picker is left open so a follow-up SELECT invoke can commit a choice.
+   */
+  async openPickerAndListChoices(ctl, action) {
+    this.driver.dispatch({ kind: "click_control", control_id: ctl.id });
+    const ready = await this.waitForPickerRendered(action);
+    const options = this.extractPickerChoices(action);
+    const currentValue = options.find((o) => o.current)?.label;
+    return {
+      ok: true,
+      effects: [{ type: "opened_picker", controlId: ctl.id }],
+      controlResult: {
+        options: options.map((o) => ({ value: o.label, label: o.label, current: o.current })),
+        ...currentValue ? { currentValue } : {},
+        source: "screen-parse",
+        ...ready ? {} : { warning: "picker_render_timeout" }
+      }
+    };
+  }
+  /**
+   * Drive an already-listable picker to a specific option. The option can be
+   * named (choiceLabel — matched against the parsed on-screen labels) or
+   * positional (choiceIndex — the on-screen number). The actual keystrokes
+   * come from the spec's `submit_key` with `{index}` substituted, so the spec
+   * — not this code — decides how a selection is keyed for each CLI.
+   */
+  async selectPickerChoice(ctl, action, choiceIndex, choiceLabel) {
+    this.driver.dispatch({ kind: "click_control", control_id: ctl.id });
+    await this.waitForPickerRendered(action);
+    const options = this.extractPickerChoices(action);
+    let index = choiceIndex;
+    if ((index == null || !Number.isFinite(index)) && choiceLabel) {
+      const needle = choiceLabel.trim().toLowerCase();
+      const match = options.find((o) => o.label.toLowerCase().includes(needle));
+      if (!match) {
+        return { ok: false, error: `choice not found on screen: ${choiceLabel}`, controlResult: { options: options.map((o) => ({ value: o.label, label: o.label })) } };
+      }
+      index = match.index;
+    }
+    if (index == null || !Number.isFinite(index)) {
+      return { ok: false, error: "choiceIndex or choiceLabel required to select" };
+    }
+    const keys = (action.submit_key || "{index}\r").replace(/\{index\}/g, String(index));
+    this.driver.dispatch({ kind: "pty_write", data: keys });
+    const selected = options.find((o) => o.index === index);
+    return {
+      ok: true,
+      effects: [{ type: "selected_choice", controlId: ctl.id }],
+      controlResult: {
+        ok: true,
+        ...selected ? { currentValue: selected.label } : {},
+        selectedIndex: index
+      }
+    };
+  }
+  /** Poll the live screen until the picker's `wait_for` condition matches,
+   *  up to a short budget. Returns true if it rendered, false on timeout. */
+  async waitForPickerRendered(action) {
+    const wf = action.wait_for;
+    if (!wf?.regex) {
+      await delay(250);
+      return true;
+    }
+    const re = new RegExp(wf.regex, wf.flags ?? "i");
+    const deadline = Date.now() + 2500;
+    while (Date.now() < deadline) {
+      await delay(120);
+      const hay = this.readScreenSectionText(wf.section);
+      if (re.test(hay)) return true;
+    }
+    return false;
+  }
+  /** Parse the picker's `extract_choices` pattern against the live screen.
+   *  Each match yields { index, label, current }. `current` is true for the
+   *  line the CLI marks with its cursor glyph (❯ ›). Purely screen-driven —
+   *  no model/mode names are baked in. */
+  extractPickerChoices(action) {
+    const ec = action.extract_choices;
+    if (!ec?.pattern) return [];
+    const text = this.readScreenSectionText(ec.section);
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const rawLine of text.split("\n")) {
+      const line = rawLine.replace(/\r$/, "");
+      const m = new RegExp(ec.pattern, ec.flags ?? "").exec(line);
+      if (!m) continue;
+      const idx = Number(m[1]);
+      if (!Number.isFinite(idx) || seen.has(idx)) continue;
+      const label = (m[2] ?? "").replace(/\s+/g, " ").trim();
+      if (!label) continue;
+      const current = /^\s*[❯›>]/.test(line) || /[✔✓●]\s*$/.test(label);
+      seen.add(idx);
+      out.push({ index: idx, label, current });
+    }
+    return out;
+  }
+  /** Live text of a named screen section (or the whole screen when no
+   *  section is named), resolved from the driver's current sections. */
+  readScreenSectionText(sectionId) {
+    try {
+      const sections = this.driver.getSections();
+      if (sectionId && sections) {
+        const hit = sections.find((s) => s.id === sectionId);
+        if (hit) return hit.text;
+      }
+      return this.driver.getScreen();
+    } catch {
+      return "";
+    }
   }
   getDebugSnapshot() {
     let screen = "";
@@ -39077,7 +39479,7 @@ var ProviderLoader = class _ProviderLoader {
     }
     if (providerDir) {
       try {
-        const fs30 = require("fs");
+        const fs31 = require("fs");
         const path41 = require("path");
         const candidates = [];
         if (Array.isArray(base.compatibility)) {
@@ -39089,13 +39491,13 @@ var ProviderLoader = class _ProviderLoader {
         }
         candidates.push(path41.join(providerDir, "specs", "default.json"));
         candidates.push(path41.join(providerDir, "spec.json"));
-        const specPath = candidates.find((p) => fs30.existsSync(p));
+        const specPath = candidates.find((p) => fs31.existsSync(p));
         if (specPath) {
           resolved._resolvedSpecPath = specPath;
           let specControls;
           let nh;
           try {
-            const rawSpec = JSON.parse(fs30.readFileSync(specPath, "utf8"));
+            const rawSpec = JSON.parse(fs31.readFileSync(specPath, "utf8"));
             specControls = rawSpec.control_bar;
             nh = rawSpec.native_history;
           } catch {
@@ -39120,7 +39522,7 @@ var ProviderLoader = class _ProviderLoader {
               reader = (input) => executeNativeHistory(nh, input);
             } else if (nh.override_path) {
               const overrideFile = path41.resolve(providerDir, nh.override_path);
-              if (fs30.existsSync(overrideFile)) {
+              if (fs31.existsSync(overrideFile)) {
                 try {
                   registerProviderScriptRootSafely(path41.dirname(path41.dirname(providerDir)));
                   delete require.cache[require.resolve(overrideFile)];
@@ -40305,7 +40707,7 @@ async function detectCurrentWorkspace(ideId) {
     }
   } else if (plat === "win32") {
     try {
-      const fs30 = require("fs");
+      const fs31 = require("fs");
       const appNameMap = getMacAppIdentifiers();
       const appName = appNameMap[ideId];
       if (appName) {
@@ -40314,8 +40716,8 @@ async function detectCurrentWorkspace(ideId) {
           appName,
           "storage.json"
         );
-        if (fs30.existsSync(storagePath)) {
-          const data = JSON.parse(fs30.readFileSync(storagePath, "utf-8"));
+        if (fs31.existsSync(storagePath)) {
+          const data = JSON.parse(fs31.readFileSync(storagePath, "utf-8"));
           const workspaces = data?.openedPathsList?.workspaces3 || data?.openedPathsList?.entries || [];
           if (workspaces.length > 0) {
             const recent = workspaces[0];
@@ -40647,6 +41049,210 @@ cleanOldFiles();
 // src/commands/router.ts
 var yaml3 = __toESM(require("js-yaml"));
 init_logger();
+
+// src/logging/log-tail-reader.ts
+var fs23 = __toESM(require("fs"));
+init_logger();
+var DEFAULT_TAIL_BYTES = 64 * 1024;
+var MAX_TAIL_BYTES = 128 * 1024;
+var READ_CHUNK_BYTES = 64 * 1024;
+function resolveLogPath(date) {
+  if (date instanceof Date) return getCurrentDaemonLogPath(date);
+  if (typeof date === "string" && date.trim()) {
+    const parsed = /* @__PURE__ */ new Date(`${date.trim()}T00:00:00.000Z`);
+    if (!Number.isNaN(parsed.getTime())) return getCurrentDaemonLogPath(parsed);
+  }
+  return getCurrentDaemonLogPath();
+}
+function clampTailBytes(tailBytes) {
+  if (!Number.isFinite(tailBytes) || tailBytes <= 0) return DEFAULT_TAIL_BYTES;
+  return Math.min(Math.floor(tailBytes), MAX_TAIL_BYTES);
+}
+function readByteBoundedTail(filePath, limitBytes) {
+  const fd = fs23.openSync(filePath, "r");
+  try {
+    const stat2 = fs23.fstatSync(fd);
+    const size = stat2.size;
+    if (size === 0) return { text: "", truncated: false, bytesReturned: 0 };
+    const want = Math.min(limitBytes, size);
+    let start = size - want;
+    const truncated = start > 0;
+    const buffers = [];
+    let position = start;
+    while (position < size) {
+      const chunkSize = Math.min(READ_CHUNK_BYTES, size - position);
+      const chunk = Buffer.alloc(chunkSize);
+      fs23.readSync(fd, chunk, 0, chunkSize, position);
+      buffers.push(chunk);
+      position += chunkSize;
+    }
+    let buf = Buffer.concat(buffers);
+    if (truncated) {
+      const firstNewline = buf.indexOf(10);
+      if (firstNewline >= 0) {
+        buf = buf.subarray(firstNewline + 1);
+      }
+    }
+    return { text: buf.toString("utf-8"), truncated, bytesReturned: buf.length };
+  } finally {
+    fs23.closeSync(fd);
+  }
+}
+function parseLineEpochMs(line, fileDate) {
+  const m = line.match(/^\[(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,3}))?\]/);
+  if (!m) {
+    const iso = line.match(/\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?/);
+    if (iso) {
+      const t = Date.parse(iso[0].replace(" ", "T"));
+      return Number.isNaN(t) ? null : t;
+    }
+    return null;
+  }
+  const d = new Date(fileDate);
+  d.setHours(Number(m[1]), Number(m[2]), Number(m[3]), m[4] ? Number(m[4].padEnd(3, "0")) : 0);
+  return d.getTime();
+}
+function readDaemonLogTail(args = {}) {
+  const platform10 = process.platform;
+  const limitBytes = clampTailBytes(args.tailBytes);
+  let logPath = resolveLogPath(args.date);
+  if (!fs23.existsSync(logPath)) {
+    const backup = logPath.replace(/\.log$/, ".1.log");
+    if (fs23.existsSync(backup)) {
+      logPath = backup;
+    } else {
+      return {
+        success: false,
+        error: `No daemon log file at ${logPath} (dir: ${getDaemonLogDir()})`,
+        lines: [],
+        truncated: false,
+        logPath,
+        platform: platform10,
+        bytesReturned: 0,
+        filtered: false
+      };
+    }
+  }
+  let raw;
+  try {
+    raw = readByteBoundedTail(logPath, limitBytes);
+  } catch (e) {
+    return {
+      success: false,
+      error: `Failed to read ${logPath}: ${e?.message ?? String(e)}`,
+      lines: [],
+      truncated: false,
+      logPath,
+      platform: platform10,
+      bytesReturned: 0,
+      filtered: false
+    };
+  }
+  let lines = raw.text.split("\n");
+  if (lines.length && lines[lines.length - 1] === "") lines.pop();
+  const rawCount = lines.length;
+  if (Number.isFinite(args.sinceMs)) {
+    const fileDate = args.date instanceof Date ? args.date : typeof args.date === "string" && args.date.trim() ? /* @__PURE__ */ new Date(`${args.date.trim()}T00:00:00.000Z`) : /* @__PURE__ */ new Date();
+    const floor = args.sinceMs;
+    lines = lines.filter((line) => {
+      const ts2 = parseLineEpochMs(line, fileDate);
+      return ts2 === null || ts2 >= floor;
+    });
+  }
+  let appliedGrep;
+  if (typeof args.grep === "string" && args.grep.trim()) {
+    appliedGrep = args.grep.trim();
+    let re = null;
+    try {
+      re = new RegExp(appliedGrep, "i");
+    } catch {
+      re = null;
+    }
+    if (re) {
+      const compiled = re;
+      lines = lines.filter((line) => compiled.test(line));
+    } else {
+      const needle = appliedGrep.toLowerCase();
+      lines = lines.filter((line) => line.toLowerCase().includes(needle));
+    }
+  }
+  return {
+    success: true,
+    lines,
+    truncated: raw.truncated,
+    logPath,
+    platform: platform10,
+    bytesReturned: raw.bytesReturned,
+    filtered: lines.length !== rawCount,
+    ...appliedGrep ? { grep: appliedGrep } : {}
+  };
+}
+
+// src/logging/log-redactor.ts
+var MASK = "\u2022\u2022\u2022\u2022redacted";
+function maskKeepTail(token) {
+  if (token.length <= 8) return MASK;
+  return `${MASK}${token.slice(-4)}`;
+}
+var RULES = [
+  // `JWT_SECRET=...`, `TOKEN=...`, `API_KEY=...`, `password: ...` env/config dumps.
+  // Captures the key + delimiter and masks only the value.
+  {
+    name: "key_value_secret",
+    pattern: /\b([A-Z0-9_]*(?:SECRET|TOKEN|API[_-]?KEY|PASSWORD|PASSWD|PRIVATE[_-]?KEY|CREDENTIAL|CLIENT[_-]?SECRET)[A-Z0-9_]*)(\s*[:=]\s*)(["']?)([^\s"',;]+)\3/gi,
+    replace: (_m, key, delim, quote) => `${key}${delim}${quote}${MASK}${quote}`
+  },
+  // Authorization: Bearer <token>
+  {
+    name: "bearer_token",
+    pattern: /\b(Bearer\s+)([A-Za-z0-9._\-+/=]{8,})/g,
+    replace: (_m, prefix, token) => `${prefix}${maskKeepTail(token)}`
+  },
+  // ADHDev credential prefixes: API key (adk_), machine secret (adm_), provider key (adp_).
+  {
+    name: "adhdev_prefixed_secret",
+    pattern: /\b(ad[kmp]_)([A-Za-z0-9]{6,})/g,
+    replace: (_m, prefix, token) => `${prefix}${maskKeepTail(prefix + token)}`
+  },
+  // JWT: three base64url segments separated by dots, header starts with eyJ.
+  {
+    name: "jwt",
+    pattern: /\beyJ[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]{4,}/g,
+    replace: () => MASK
+  },
+  // TURN credential: a long credential value following a `credential` key in
+  // any common shape — `credential: x`, `credential=x`, or `credential "x"`.
+  // Mask the credential value only, preserving the key + delimiter/quote.
+  {
+    name: "turn_credential",
+    pattern: /\b(credential["']?\s*(?:[:=]\s*)?["']?)([^\s"',;]{6,})/gi,
+    replace: (_m, prefix) => `${prefix}${MASK}`
+  },
+  // TURN REST username:credential of the form `<expiry-ts>:<base64hmac>`,
+  // where the hmac part is long base64. Mask the hmac.
+  {
+    name: "turn_rest_pair",
+    pattern: /\b(\d{10,}:)([A-Za-z0-9+/]{20,}={0,2})\b/g,
+    replace: (_m, prefix) => `${prefix}${MASK}`
+  }
+];
+function redactLogLine(line) {
+  if (!line) return line;
+  let out = line;
+  for (const rule of RULES) {
+    try {
+      out = out.replace(rule.pattern, rule.replace);
+    } catch {
+    }
+  }
+  return out;
+}
+function redactLogLines(lines) {
+  return lines.map((line) => redactLogLine(line));
+}
+var LOG_REDACTION_RULE_NAMES = RULES.map((r) => r.name);
+
+// src/commands/router.ts
 init_mesh_coordinator();
 init_mesh_events();
 init_mesh_routing();
@@ -41291,21 +41897,21 @@ init_build_info();
 // src/commands/upgrade-helper.ts
 var import_child_process8 = require("child_process");
 var import_child_process9 = require("child_process");
-var fs23 = __toESM(require("fs"));
+var fs24 = __toESM(require("fs"));
 var os27 = __toESM(require("os"));
 var path35 = __toESM(require("path"));
 var UPGRADE_HELPER_ENV = "ADHDEV_DAEMON_UPGRADE_HELPER";
 function getUpgradeLogPath() {
   const home = os27.homedir();
   const dir = path35.join(home, ".adhdev");
-  fs23.mkdirSync(dir, { recursive: true });
+  fs24.mkdirSync(dir, { recursive: true });
   return path35.join(dir, "daemon-upgrade.log");
 }
 function appendUpgradeLog(message) {
   const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${message}
 `;
   try {
-    fs23.appendFileSync(getUpgradeLogPath(), line, "utf8");
+    fs24.appendFileSync(getUpgradeLogPath(), line, "utf8");
   } catch {
   }
 }
@@ -41313,12 +41919,12 @@ function resolveSiblingNpmInvocation(nodeExecutable, platform10 = process.platfo
   const binDir = path35.dirname(nodeExecutable);
   if (platform10 === "win32") {
     const npmCliPath = path35.join(binDir, "node_modules", "npm", "bin", "npm-cli.js");
-    if (fs23.existsSync(npmCliPath)) {
+    if (fs24.existsSync(npmCliPath)) {
       return { executable: nodeExecutable, argsPrefix: [npmCliPath], execOptions: getNpmExecOptions(platform10) };
     }
     for (const candidate of ["npm.exe", "npm"]) {
       const candidatePath = path35.join(binDir, candidate);
-      if (fs23.existsSync(candidatePath)) {
+      if (fs24.existsSync(candidatePath)) {
         return { executable: candidatePath, argsPrefix: [], execOptions: getNpmExecOptions(platform10) };
       }
     }
@@ -41326,7 +41932,7 @@ function resolveSiblingNpmInvocation(nodeExecutable, platform10 = process.platfo
   }
   for (const candidate of ["npm"]) {
     const candidatePath = path35.join(binDir, candidate);
-    if (fs23.existsSync(candidatePath)) {
+    if (fs24.existsSync(candidatePath)) {
       return { executable: candidatePath, argsPrefix: [], execOptions: getNpmExecOptions(platform10) };
     }
   }
@@ -41336,12 +41942,12 @@ function findCurrentPackageRoot(currentCliPath, packageName) {
   if (!currentCliPath) return null;
   let resolvedPath = currentCliPath;
   try {
-    resolvedPath = fs23.realpathSync.native(currentCliPath);
+    resolvedPath = fs24.realpathSync.native(currentCliPath);
   } catch {
   }
   let currentDir = resolvedPath;
   try {
-    if (fs23.statSync(resolvedPath).isFile()) {
+    if (fs24.statSync(resolvedPath).isFile()) {
       currentDir = path35.dirname(resolvedPath);
     }
   } catch {
@@ -41350,8 +41956,8 @@ function findCurrentPackageRoot(currentCliPath, packageName) {
   while (true) {
     const packageJsonPath = path35.join(currentDir, "package.json");
     try {
-      if (fs23.existsSync(packageJsonPath)) {
-        const parsed = JSON.parse(fs23.readFileSync(packageJsonPath, "utf8"));
+      if (fs24.existsSync(packageJsonPath)) {
+        const parsed = JSON.parse(fs24.readFileSync(packageJsonPath, "utf8"));
         if (parsed?.name === packageName) {
           const normalized = currentDir.replace(/\\/g, "/");
           return normalized.includes("/node_modules/") ? currentDir : null;
@@ -41500,8 +42106,8 @@ async function waitForPidExit(pid, timeoutMs) {
 function stopSessionHostProcesses(appName) {
   const pidFile = path35.join(os27.homedir(), ".adhdev", `${appName}-session-host.pid`);
   try {
-    if (fs23.existsSync(pidFile)) {
-      const pid = Number.parseInt(fs23.readFileSync(pidFile, "utf8").trim(), 10);
+    if (fs24.existsSync(pidFile)) {
+      const pid = Number.parseInt(fs24.readFileSync(pidFile, "utf8").trim(), 10);
       if (Number.isFinite(pid) && pid !== process.pid && isManagedSessionHostPid(pid)) {
         killPid(pid);
       }
@@ -41509,7 +42115,7 @@ function stopSessionHostProcesses(appName) {
   } catch {
   } finally {
     try {
-      fs23.unlinkSync(pidFile);
+      fs24.unlinkSync(pidFile);
     } catch {
     }
   }
@@ -41517,7 +42123,7 @@ function stopSessionHostProcesses(appName) {
 function removeDaemonPidFile() {
   const pidFile = path35.join(os27.homedir(), ".adhdev", "daemon.pid");
   try {
-    fs23.unlinkSync(pidFile);
+    fs24.unlinkSync(pidFile);
   } catch {
   }
 }
@@ -41535,23 +42141,23 @@ function cleanupStaleGlobalInstallDirs(pkgName, surface) {
   if (pkgName.startsWith("@")) {
     const [scope, name] = pkgName.split("/");
     const scopeDir = path35.join(npmRoot, scope);
-    if (!fs23.existsSync(scopeDir)) return;
-    for (const entry of fs23.readdirSync(scopeDir)) {
+    if (!fs24.existsSync(scopeDir)) return;
+    for (const entry of fs24.readdirSync(scopeDir)) {
       if (!entry.startsWith(`.${name}-`)) continue;
-      fs23.rmSync(path35.join(scopeDir, entry), { recursive: true, force: true });
+      fs24.rmSync(path35.join(scopeDir, entry), { recursive: true, force: true });
       appendUpgradeLog(`Removed stale scoped staging dir: ${path35.join(scopeDir, entry)}`);
     }
   } else {
-    for (const entry of fs23.readdirSync(npmRoot)) {
+    for (const entry of fs24.readdirSync(npmRoot)) {
       if (!entry.startsWith(`.${pkgName}-`)) continue;
-      fs23.rmSync(path35.join(npmRoot, entry), { recursive: true, force: true });
+      fs24.rmSync(path35.join(npmRoot, entry), { recursive: true, force: true });
       appendUpgradeLog(`Removed stale staging dir: ${path35.join(npmRoot, entry)}`);
     }
   }
-  if (fs23.existsSync(binDir)) {
-    for (const entry of fs23.readdirSync(binDir)) {
+  if (fs24.existsSync(binDir)) {
+    for (const entry of fs24.readdirSync(binDir)) {
       if (!Array.from(binNames).some((name) => entry.startsWith(`.${name}-`))) continue;
-      fs23.rmSync(path35.join(binDir, entry), { recursive: true, force: true });
+      fs24.rmSync(path35.join(binDir, entry), { recursive: true, force: true });
       appendUpgradeLog(`Removed stale bin staging entry: ${path35.join(binDir, entry)}`);
     }
   }
@@ -41642,7 +42248,7 @@ init_mesh_work_queue();
 init_repo_mesh_types();
 var import_os3 = require("os");
 var import_path11 = require("path");
-var fs24 = __toESM(require("fs"));
+var fs25 = __toESM(require("fs"));
 var import_node_child_process6 = require("child_process");
 var CHANNEL_NPM_TAG = { stable: "latest", preview: "next" };
 var CHANNEL_SERVER_URL = {
@@ -41968,6 +42574,12 @@ function inlineMeshCarriesTransientNodeTruth(inlineMesh) {
 function readInlineMeshNodeId(node) {
   return normalizeMeshNodeId(node) ?? "";
 }
+function isDeadLocalWorktreeNode(node) {
+  if (node?.isLocalWorktree !== true) return false;
+  const workspace = readStringValue(node?.workspace);
+  if (!workspace) return false;
+  return !fs25.existsSync(workspace);
+}
 function foldMeshNodeIdentityToCanonical(node) {
   if (!node || typeof node !== "object" || Array.isArray(node)) return node;
   const canonical = normalizeMeshNodeId(node);
@@ -42214,7 +42826,7 @@ function summarizeInlineMeshBranchConvergence(nodes) {
   const followUps = nodes.filter((node) => {
     if (readObjectRecord(node.branchConvergence).needsConvergence !== true) return false;
     const workspace = typeof node.workspace === "string" ? node.workspace : "";
-    if (workspace && !fs24.existsSync(workspace)) return false;
+    if (workspace && !fs25.existsSync(workspace)) return false;
     return true;
   }).map((node) => {
     const convergence = readObjectRecord(node.branchConvergence);
@@ -42342,6 +42954,43 @@ function readMeshTimeoutEnvMs(name, defaultMs) {
 }
 var MESH_DIRECT_PROBE_TIMEOUT_MS = readMeshTimeoutEnvMs("MESH_DIRECT_PROBE_TIMEOUT_MS", 25e3);
 var MESH_DIRECT_PROBE_RETRY_TIMEOUT_MS = readMeshTimeoutEnvMs("MESH_DIRECT_PROBE_RETRY_TIMEOUT_MS", 25e3);
+var MESH_DIRECT_PROBE_REUSE_MS = readMeshTimeoutEnvMs("MESH_DIRECT_PROBE_REUSE_MS", 12e3);
+var MeshGitProbeCache = class {
+  constructor(reuseMs, now = Date.now) {
+    this.reuseMs = reuseMs;
+    this.now = now;
+  }
+  inflight = /* @__PURE__ */ new Map();
+  recent = /* @__PURE__ */ new Map();
+  key(daemonId, workspace) {
+    return `${daemonId}::${workspace}`;
+  }
+  /**
+   * Run `probe` for this peer, but reuse a fresh recent result or an in-flight
+   * probe for the same key when one is available. `probe` is only invoked when
+   * neither gate is satisfied.
+   */
+  async probe(daemonId, workspace, probe) {
+    const key = this.key(daemonId, workspace);
+    const cached2 = this.recent.get(key);
+    if (cached2 && this.now() - cached2.at < this.reuseMs) {
+      return cached2.value;
+    }
+    const existing = this.inflight.get(key);
+    if (existing) return existing;
+    const pending = (async () => {
+      const result = await probe();
+      if (result) this.recent.set(key, { at: this.now(), value: result });
+      return result;
+    })();
+    this.inflight.set(key, pending);
+    try {
+      return await pending;
+    } finally {
+      if (this.inflight.get(key) === pending) this.inflight.delete(key);
+    }
+  }
+};
 async function probeRemoteMeshGitStatus(args) {
   if (!args.dispatchMeshCommand) return null;
   const remoteResult = await Promise.race([
@@ -42385,7 +43034,8 @@ async function hydrateInlineMeshDirectTruth(args) {
       peerAttemptedCount: 0,
       peerConfirmedCount: 0,
       standingEvidenceCount: 0,
-      unavailableNodeIds: []
+      unavailableNodeIds: [],
+      deadNodeIds: []
     };
   }
   const selectedCoordinatorNodeId = readStringValue(
@@ -42398,6 +43048,7 @@ async function hydrateInlineMeshDirectTruth(args) {
   let peerConfirmedCount = 0;
   let standingEvidenceCount = 0;
   const unavailableNodeIds = [];
+  const deadNodeIds = [];
   for (const [nodeIndex, node] of nodes.entries()) {
     const nodeId = normalizeMeshNodeId(node) || `node_${nodeIndex}`;
     const workspace = readStringValue(node?.workspace);
@@ -42407,11 +43058,18 @@ async function hydrateInlineMeshDirectTruth(args) {
     ) || Boolean(
       daemonId && (daemonId === args.localMachineId || daemonId === args.statusInstanceId)
     ) || Boolean(args.meshSource !== "local_config" && nodeIndex === 0);
+    const isSelfDaemonNode = Boolean(
+      daemonId && (daemonId === args.localMachineId || daemonId === args.statusInstanceId)
+    );
+    if ((isSelfNode || isSelfDaemonNode) && isDeadLocalWorktreeNode(node)) {
+      deadNodeIds.push(nodeId);
+      continue;
+    }
     if (!workspace) {
       if (!isSelfNode && daemonId) unavailableNodeIds.push(nodeId);
       continue;
     }
-    if (fs24.existsSync(workspace)) {
+    if (fs25.existsSync(workspace)) {
       try {
         const localGit = await getGitRepoStatus(workspace, { timeoutMs: 1e4, refreshUpstream: true });
         if (localGit?.isGitRepo) {
@@ -42435,7 +43093,7 @@ async function hydrateInlineMeshDirectTruth(args) {
       continue;
     }
     peerAttemptedCount += 1;
-    const remoteGit = await probeRemoteMeshGitStatusWithRetry({
+    const runProbe = () => probeRemoteMeshGitStatusWithRetry({
       dispatchMeshCommand: args.dispatchMeshCommand,
       daemonId,
       workspace,
@@ -42443,6 +43101,7 @@ async function hydrateInlineMeshDirectTruth(args) {
       retryTimeoutMs: MESH_DIRECT_PROBE_RETRY_TIMEOUT_MS,
       getConnection: args.getMeshPeerConnectionStatus
     });
+    const remoteGit = args.probeCache ? await args.probeCache.probe(daemonId, workspace, runProbe) : await runProbe();
     if (remoteGit) {
       recordInlineMeshDirectGitTruth(node, remoteGit, "selected_coordinator_mesh_p2p_git");
       peerConfirmedCount += 1;
@@ -42456,7 +43115,8 @@ async function hydrateInlineMeshDirectTruth(args) {
     peerAttemptedCount,
     peerConfirmedCount,
     standingEvidenceCount,
-    unavailableNodeIds
+    unavailableNodeIds,
+    deadNodeIds
   };
 }
 function summarizeMeshSessionRecord(record) {
@@ -42515,7 +43175,7 @@ function readLiveMeshNodeWorkspace(args) {
 }
 function collectLiveMeshSessionRecords(args) {
   const nodeWorkspace = readStringValue(args.node?.workspace);
-  const nodeIsMissingLocalWorktree = args.node?.isLocalWorktree === true && !!nodeWorkspace && !fs24.existsSync(nodeWorkspace);
+  const nodeIsMissingLocalWorktree = args.node?.isLocalWorktree === true && !!nodeWorkspace && !fs25.existsSync(nodeWorkspace);
   const matches = args.liveSessionRecords.filter((record) => {
     const recordNodeId = readStringValue(record?.meta?.meshNodeId);
     if (recordNodeId && recordNodeId !== args.nodeId) return false;
@@ -42542,7 +43202,7 @@ function buildHistoricalMeshSessions(args) {
     const workspace = readStringValue(node?.workspace);
     if (nodeId) liveNodeIds.add(nodeId);
     if (workspace) liveWorkspaces.add(workspace);
-    if (nodeId && node?.isLocalWorktree === true && workspace && !fs24.existsSync(workspace)) {
+    if (nodeId && node?.isLocalWorktree === true && workspace && !fs25.existsSync(workspace)) {
       missingLocalWorktreeNodeIds.add(nodeId);
     }
   }
@@ -42902,7 +43562,7 @@ function isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit) {
   if (!baseCommit || !branchCommit) return false;
   if (baseCommit === branchCommit) return true;
   try {
-    if (!fs24.existsSync(submoduleRepoPath)) return false;
+    if (!fs25.existsSync(submoduleRepoPath)) return false;
     (0, import_node_child_process6.execFileSync)("git", ["cat-file", "-e", `${baseCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
     (0, import_node_child_process6.execFileSync)("git", ["cat-file", "-e", `${branchCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
     (0, import_node_child_process6.execFileSync)("git", ["merge-base", "--is-ancestor", baseCommit, branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
@@ -43019,7 +43679,7 @@ function buildTreeWithGitlinksEqualized(repoRoot, commitish, paths, placeholderC
       return newTree || void 0;
     } finally {
       try {
-        fs24.rmSync(tmpIndex, { force: true });
+        fs25.rmSync(tmpIndex, { force: true });
       } catch {
       }
     }
@@ -43094,7 +43754,7 @@ function synthesizeTrivialFastForwardMergeTree(repoRoot, baseHead, branchHead, g
       return newTree || void 0;
     } finally {
       try {
-        fs24.rmSync(tmpIndex, { force: true });
+        fs25.rmSync(tmpIndex, { force: true });
       } catch {
       }
     }
@@ -43200,7 +43860,7 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
       return { stdout: String(stdout || ""), stderr: String(stderr || ""), refspec };
     };
     const importCommitFromWorktreeSubmodule = async (submodulePath, worktreeSubmodulePath, commit) => {
-      if (!fs24.existsSync(worktreeSubmodulePath)) return false;
+      if (!fs25.existsSync(worktreeSubmodulePath)) return false;
       try {
         await runGit3(worktreeSubmodulePath, ["cat-file", "-e", `${commit}^{commit}`]);
       } catch {
@@ -43223,7 +43883,7 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
         reachable: false
       };
       try {
-        if (!fs24.existsSync(submodulePath)) {
+        if (!fs25.existsSync(submodulePath)) {
           entry.error = `Submodule checkout missing at ${gitlink.path}`;
           entry.publishRequired = true;
           if (options.allowAutoPublishSubmoduleMainCommits === true) {
@@ -43460,9 +44120,9 @@ async function runMeshRefineValidationGate(mesh, workspace, opts) {
     return ["npm", "pnpm", "yarn", "bun"].includes(command) && candidate.args.some((arg) => arg === "run" || arg === "test" || arg === "exec");
   };
   const dependenciesLikelyMissing = (cwd) => {
-    if (!fs24.existsSync((0, import_path11.join)(cwd, "package.json"))) return false;
-    if (fs24.existsSync((0, import_path11.join)(cwd, "node_modules"))) return false;
-    return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs24.existsSync((0, import_path11.join)(cwd, lock)));
+    if (!fs25.existsSync((0, import_path11.join)(cwd, "package.json"))) return false;
+    if (fs25.existsSync((0, import_path11.join)(cwd, "node_modules"))) return false;
+    return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs25.existsSync((0, import_path11.join)(cwd, lock)));
   };
   if (runLegacyBootstrapCommands) {
     summary.bootstrap = { stage: "legacy" };
@@ -43564,9 +44224,9 @@ function resolveHermesUserHome() {
 function loadHermesCoordinatorBaseConfig(targetConfigPath) {
   const sourceHome = resolveHermesUserHome();
   const sourceConfigPath = (0, import_path11.join)(sourceHome, "config.yaml");
-  if (!fs24.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+  if (!fs25.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
   if ((0, import_path11.resolve)(sourceConfigPath) === (0, import_path11.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
-  const parsed = parseMeshCoordinatorMcpConfig(fs24.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
+  const parsed = parseMeshCoordinatorMcpConfig(fs25.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
   const { mcp_servers: _mcpServers, ...baseConfig } = parsed;
   return { config: baseConfig, sourceHome, sourceConfigPath };
 }
@@ -43603,9 +44263,9 @@ function copyHermesCoordinatorCredentialFiles(sourceHome, targetHome) {
   for (const fileName of [".env", "auth.json"]) {
     const sourcePath = (0, import_path11.join)(sourceHome, fileName);
     const targetPath = (0, import_path11.join)(targetHome, fileName);
-    if (!fs24.existsSync(sourcePath)) continue;
+    if (!fs25.existsSync(sourcePath)) continue;
     try {
-      fs24.copyFileSync(sourcePath, targetPath);
+      fs25.copyFileSync(sourcePath, targetPath);
     } catch (error) {
       LOG.warn("MeshCoordinator", `Could not copy Hermes ${fileName} into isolated coordinator home: ${error?.message || error}`);
     }
@@ -43763,8 +44423,21 @@ var DaemonCommandRouter = class {
    *  Allows the MCP server to query mesh data via get_mesh even when
    *  the mesh doesn't exist in the local meshes.json file. */
   inlineMeshCache = /* @__PURE__ */ new Map();
+  /** Tombstones for inline mesh nodes removed via remove_mesh_node, keyed by
+   *  meshId → set of removed nodeIds. The dashboard keeps echoing the removed
+   *  node in the inlineMesh it attaches to every command; without a tombstone,
+   *  reconcileInlineMeshCache MERGEs it straight back (resurrection). A
+   *  tombstoned node is skipped during reconcile only while its workspace is
+   *  absent from disk — a genuine re-registration (same nodeId, workspace back
+   *  on disk) clears the tombstone and merges normally, preserving clone
+   *  worktree visibility and legitimate node re-creation. */
+  removedInlineMeshNodeIds = /* @__PURE__ */ new Map();
   /** Coordinator-owned whole-mesh aggregate status snapshots. Browser callers read this by default. */
   aggregateMeshStatusCache = /* @__PURE__ */ new Map();
+  /** Shared per-peer git_status probe dedup + recently-probed reuse gate.
+   *  Spans separate mesh_status/get_mesh calls so the dashboard auto-retry
+   *  loop cannot storm a slow peer with back-to-back refreshUpstream probes. */
+  meshGitProbeCache = new MeshGitProbeCache(MESH_DIRECT_PROBE_REUSE_MS);
   /** In-memory async Refinery jobs keyed by meshId:nodeId to reject/return duplicate in-flight requests. */
   runningRefineJobs = /* @__PURE__ */ new Map();
   /** Terminal async Refinery jobs preserve a clear answer after the worktree node has been removed. */
@@ -43792,10 +44465,23 @@ var DaemonCommandRouter = class {
     const unavailableNodeIds = /* @__PURE__ */ new Set();
     const sourceOfTruth = readObjectRecord(snapshot.sourceOfTruth);
     const directPeerTruth = readObjectRecord(sourceOfTruth.directPeerTruth);
+    const deadNodeIds = /* @__PURE__ */ new Set();
+    for (const node of mesh.nodes) {
+      if (!isDeadLocalWorktreeNode(node)) continue;
+      const deadId = readInlineMeshNodeId(node);
+      if (deadId) deadNodeIds.add(deadId);
+    }
+    let droppedDeadUnavailable = false;
     for (const entry of Array.isArray(directPeerTruth.unavailableNodeIds) ? directPeerTruth.unavailableNodeIds : []) {
       const nodeId = readStringValue(entry);
-      if (nodeId) unavailableNodeIds.add(nodeId);
+      if (!nodeId) continue;
+      if (deadNodeIds.has(nodeId)) {
+        droppedDeadUnavailable = true;
+        continue;
+      }
+      unavailableNodeIds.add(nodeId);
     }
+    if (droppedDeadUnavailable) changed = true;
     const nodes = snapshot.nodes.map((statusNode) => {
       const nodeId = normalizeMeshNodeId(statusNode);
       const inlineNode = nodeId ? inlineNodesById.get(nodeId) : void 0;
@@ -43910,7 +44596,10 @@ var DaemonCommandRouter = class {
   }
   warmInlineMeshCache(meshId, inlineMesh) {
     if (!inlineMesh || typeof inlineMesh !== "object") return void 0;
-    const sanitizedInlineMesh = sanitizeInlineMesh(normalizeInlineMeshNodeIdentity(inlineMesh));
+    const sanitizedInlineMesh = this.applyInlineMeshNodeTombstones(
+      meshId,
+      sanitizeInlineMesh(normalizeInlineMeshNodeIdentity(inlineMesh))
+    );
     const cached2 = this.inlineMeshCache.get(meshId);
     if (cached2) {
       const merged = reconcileInlineMeshCache(cached2, sanitizedInlineMesh);
@@ -43926,7 +44615,10 @@ var DaemonCommandRouter = class {
       const cached3 = this.getCachedInlineMesh(meshId);
       if (cached3) {
         if (inlineMeshCarriesTransientNodeTruth(inlineMesh)) {
-          const merged = reconcileInlineMeshCache(cached3, inlineMesh);
+          const merged = reconcileInlineMeshCache(
+            cached3,
+            this.applyInlineMeshNodeTombstones(meshId, inlineMesh)
+          );
           this.inlineMeshCache.set(meshId, sanitizeInlineMesh(normalizeInlineMeshNodeIdentity(merged)));
           return { mesh: merged, inline: true, source: "inline_cache" };
         }
@@ -43977,12 +44669,49 @@ var DaemonCommandRouter = class {
     if (!mesh || !Array.isArray(mesh.nodes)) return false;
     const idx = mesh.nodes.findIndex((entry) => meshNodeIdMatches(entry, nodeId));
     if (idx === -1) return false;
+    const canonicalNodeId = readInlineMeshNodeId(mesh.nodes[idx]) || nodeId;
     mesh.nodes.splice(idx, 1);
     mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     this.inlineMeshCache.set(meshId, mesh);
+    this.tombstoneRemovedInlineMeshNode(meshId, canonicalNodeId);
+    if (canonicalNodeId !== nodeId) this.tombstoneRemovedInlineMeshNode(meshId, nodeId);
     this.invalidateAggregateMeshStatus(meshId);
     return true;
   }
+  tombstoneRemovedInlineMeshNode(meshId, nodeId) {
+    if (!nodeId) return;
+    let set = this.removedInlineMeshNodeIds.get(meshId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.removedInlineMeshNodeIds.set(meshId, set);
+    }
+    set.add(nodeId);
+  }
+  /** Filter an incoming inline mesh against this mesh's tombstones before it is
+   *  reconciled into the cache. A tombstoned node is dropped only while its
+   *  workspace is still absent from disk; if the workspace is back (genuine
+   *  re-registration), the tombstone is cleared and the node merges normally. */
+  applyInlineMeshNodeTombstones(meshId, incoming) {
+    const tombstones = this.removedInlineMeshNodeIds.get(meshId);
+    if (!tombstones?.size || !incoming || typeof incoming !== "object" || !Array.isArray(incoming.nodes)) {
+      return incoming;
+    }
+    let dropped = false;
+    const nodes = incoming.nodes.filter((node) => {
+      const nodeId = readInlineMeshNodeId(node);
+      if (!nodeId || !tombstones.has(nodeId)) return true;
+      const workspace = readStringValue(node?.workspace);
+      if (workspace && fs25.existsSync(workspace)) {
+        tombstones.delete(nodeId);
+        return true;
+      }
+      dropped = true;
+      return false;
+    });
+    if (tombstones.size === 0) this.removedInlineMeshNodeIds.delete(meshId);
+    if (!dropped) return incoming;
+    return { ...incoming, nodes };
+  }
   normalizeMeshSessionCleanupMode(value) {
     return value === "stop" || value === "delete_stopped" || value === "stop_and_delete" || value === "preserve" ? value : "preserve";
   }
@@ -44005,13 +44734,13 @@ var DaemonCommandRouter = class {
         recoveryHint: "Inspect the mesh node record before removing it, or remove stale metadata manually only after confirming no managed worktree remains."
       };
     }
-    const worktreeExists = fs24.existsSync(workspace);
+    const worktreeExists = fs25.existsSync(workspace);
     const sourceNode = args.node?.clonedFromNodeId ? args.mesh?.nodes?.find((n) => meshNodeIdMatches(n, args.node.clonedFromNodeId)) : args.mesh?.nodes?.find((n) => !n.isLocalWorktree);
     const repoRoot = typeof sourceNode?.repoRoot === "string" && sourceNode.repoRoot.trim() ? sourceNode.repoRoot.trim() : typeof sourceNode?.workspace === "string" && sourceNode.workspace.trim() ? sourceNode.workspace.trim() : "";
     if (!worktreeExists) {
       return { success: true, skipped: true, removedPath: workspace, repoRoot: repoRoot || void 0, reason: "worktree_path_missing" };
     }
-    if (!repoRoot || !fs24.existsSync(repoRoot)) {
+    if (!repoRoot || !fs25.existsSync(repoRoot)) {
       return {
         success: false,
         code: "mesh_worktree_cleanup_missing_source_repo",
@@ -44031,7 +44760,7 @@ var DaemonCommandRouter = class {
     const normalizePath = (value) => {
       const resolved = (0, import_path11.resolve)(value);
       try {
-        return fs24.realpathSync(resolved);
+        return fs25.realpathSync(resolved);
       } catch {
         return resolved;
       }
@@ -44117,7 +44846,7 @@ var DaemonCommandRouter = class {
           };
         } catch (deinitError) {
           try {
-            fs24.rmSync(workspace, { recursive: true, force: true });
+            fs25.rmSync(workspace, { recursive: true, force: true });
             await execFileAsync4("git", ["worktree", "prune"], {
               cwd: repoRoot,
               encoding: "utf8",
@@ -45896,8 +46625,8 @@ ${hintLines.join("\n")}` : "",
           if (sinceTs > 0) {
             return { success: true, logs: [], totalBuffered: 0 };
           }
-          if (fs24.existsSync(LOG_PATH)) {
-            const content = fs24.readFileSync(LOG_PATH, "utf-8");
+          if (fs25.existsSync(LOG_PATH)) {
+            const content = fs25.readFileSync(LOG_PATH, "utf-8");
             const allLines = content.split("\n");
             const recent = allLines.slice(-count).join("\n");
             return { success: true, logs: recent, totalLines: allLines.length };
@@ -46442,14 +47171,14 @@ ${hintLines.join("\n")}` : "",
       //    Settings page in the dashboard reads/writes via these two
       //    commands instead of going through fs from the browser.
       case "list_coordinator_prompts": {
-        const fs30 = await import("fs");
+        const fs31 = await import("fs");
         const path41 = await import("path");
         const os30 = await import("os");
         const dir = path41.join(os30.homedir(), ".adhdev", "coordinator-prompts");
         const entries = {};
         try {
-          if (fs30.existsSync(dir)) {
-            for (const name of fs30.readdirSync(dir)) {
+          if (fs31.existsSync(dir)) {
+            for (const name of fs31.readdirSync(dir)) {
               const matchOverride = name.match(/^([a-zA-Z0-9_.-]+)\.md$/);
               const matchAppend = name.match(/^([a-zA-Z0-9_.-]+)\.append\.md$/);
               const m = matchAppend || matchOverride;
@@ -46459,7 +47188,7 @@ ${hintLines.join("\n")}` : "",
               const full = path41.join(dir, name);
               let content = "";
               try {
-                content = fs30.readFileSync(full, "utf8");
+                content = fs31.readFileSync(full, "utf8");
               } catch {
               }
               if (!entries[key]) entries[key] = { override: "", append: "" };
@@ -46473,7 +47202,7 @@ ${hintLines.join("\n")}` : "",
         return { success: true, dir, entries };
       }
       case "write_coordinator_prompt": {
-        const fs30 = await import("fs");
+        const fs31 = await import("fs");
         const path41 = await import("path");
         const os30 = await import("os");
         const key = typeof args?.key === "string" ? args.key.trim() : "";
@@ -46486,11 +47215,11 @@ ${hintLines.join("\n")}` : "",
         const filename = kind === "append" ? `${key}.append.md` : `${key}.md`;
         const full = path41.join(dir, filename);
         try {
-          fs30.mkdirSync(dir, { recursive: true });
+          fs31.mkdirSync(dir, { recursive: true });
           if (content.trim()) {
-            fs30.writeFileSync(full, content, { encoding: "utf8", mode: 384 });
-          } else if (fs30.existsSync(full)) {
-            fs30.unlinkSync(full);
+            fs31.writeFileSync(full, content, { encoding: "utf8", mode: 384 });
+          } else if (fs31.existsSync(full)) {
+            fs31.unlinkSync(full);
           }
           return { success: true, path: full, kind, key };
         } catch (error) {
@@ -46667,7 +47396,8 @@ ${hintLines.join("\n")}` : "",
           getMeshPeerConnectionStatus: this.deps.getMeshPeerConnectionStatus,
           statusInstanceId: this.deps.statusInstanceId,
           localMachineId: loadConfig().machineId || "",
-          probeRemotePeers
+          probeRemotePeers,
+          probeCache: this.meshGitProbeCache
         });
         const directTruthSatisfied = meshRecord.source !== "inline_bootstrap" || directTruth.directEvidenceCount > 0;
         const sourceOfTruth = {
@@ -47267,10 +47997,75 @@ ${hintLines.join("\n")}` : "",
         });
         return result;
       }
+      case "get_mesh_node_logs": {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
+        let nodeDaemonId;
+        if (meshId && nodeId) {
+          const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+          const node = meshRecord?.mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
+          nodeDaemonId = typeof node?.daemonId === "string" ? node.daemonId.trim() : void 0;
+        }
+        const selfDaemonId = this.deps.statusInstanceId;
+        const isRemote = nodeDaemonId && selfDaemonId && nodeDaemonId !== selfDaemonId;
+        if (isRemote && this.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
+          const forwarded = await this.deps.dispatchMeshCommand(nodeDaemonId, "get_mesh_node_logs", {
+            ...typeof args === "object" && args !== null ? args : {},
+            _meshDirectDispatch: true
+          });
+          return forwarded ?? { success: false, error: "no response from remote node" };
+        }
+        const rawTailBytes = Number(args?.tailBytes);
+        const tail = readDaemonLogTail({
+          date: typeof args?.date === "string" ? args.date : void 0,
+          tailBytes: Number.isFinite(rawTailBytes) ? Math.min(rawTailBytes, MAX_TAIL_BYTES) : void 0,
+          grep: typeof args?.grep === "string" ? args.grep : void 0,
+          sinceMs: Number.isFinite(Number(args?.sinceMs)) ? Number(args?.sinceMs) : void 0
+        });
+        if (!tail.success) {
+          return {
+            success: false,
+            error: tail.error || "failed to read daemon log tail",
+            nodeId,
+            logPath: tail.logPath,
+            platform: tail.platform
+          };
+        }
+        const redactedLines = redactLogLines(tail.lines);
+        return {
+          success: true,
+          nodeId,
+          daemonId: selfDaemonId,
+          logPath: tail.logPath,
+          platform: tail.platform,
+          lines: redactedLines,
+          lineCount: redactedLines.length,
+          truncated: tail.truncated,
+          filtered: tail.filtered,
+          bytesReturned: tail.bytesReturned,
+          ...tail.grep ? { grep: tail.grep } : {}
+        };
+      }
       case "refine_mesh_node": {
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
         if (!meshId || !nodeId) return { success: false, error: "meshId and nodeId required" };
+        {
+          const meshRecordForForward = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+          const forwardNode = meshRecordForForward?.mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
+          const nodeDaemonId = typeof forwardNode?.daemonId === "string" ? forwardNode.daemonId.trim() : void 0;
+          const selfDaemonId = this.deps.statusInstanceId;
+          const isRemote = nodeDaemonId && selfDaemonId && nodeDaemonId !== selfDaemonId;
+          if (isRemote && this.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
+            const callerCoordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : void 0;
+            const forwarded = await this.deps.dispatchMeshCommand(nodeDaemonId, "refine_mesh_node", {
+              ...typeof args === "object" && args !== null ? args : {},
+              coordinatorDaemonId: callerCoordinatorDaemonId || selfDaemonId,
+              _meshDirectDispatch: true
+            });
+            return forwarded ?? { success: false, error: "no response from remote node" };
+          }
+        }
         const isDryRun = args?.dryRun !== false && args?.execute !== true;
         if (isDryRun) {
           const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
@@ -47918,15 +48713,15 @@ ${ptyResult.output.slice(-2e3)}`);
             }
             if (cliType === "codex-cli") {
               const repoMcpConfigPath = (0, import_path11.join)(workspace, ".mcp.json");
-              if (fs24.existsSync(repoMcpConfigPath)) {
+              if (fs25.existsSync(repoMcpConfigPath)) {
                 try {
                   const repoMcpConfig = parseMeshCoordinatorMcpConfig(
-                    fs24.readFileSync(repoMcpConfigPath, "utf-8"),
+                    fs25.readFileSync(repoMcpConfigPath, "utf-8"),
                     "claude_mcp_json"
                   );
                   const existingServers2 = repoMcpConfig.mcpServers;
                   if (existingServers2 && typeof existingServers2 === "object" && !Array.isArray(existingServers2) && existingServers2[coordinatorSetup.serverName]) {
-                    fs24.writeFileSync(repoMcpConfigPath, serializeMeshCoordinatorMcpConfig({
+                    fs25.writeFileSync(repoMcpConfigPath, serializeMeshCoordinatorMcpConfig({
                       ...repoMcpConfig,
                       mcpServers: {
                         ...existingServers2,
@@ -48042,7 +48837,7 @@ ${ptyResult.output.slice(-2e3)}`);
               workspace
             };
           }
-          const { existsSync: existsSync43, readFileSync: readFileSync35, writeFileSync: writeFileSync23, copyFileSync: copyFileSync4, mkdirSync: mkdirSync21 } = await import("fs");
+          const { existsSync: existsSync44, readFileSync: readFileSync35, writeFileSync: writeFileSync23, copyFileSync: copyFileSync4, mkdirSync: mkdirSync21 } = await import("fs");
           const { dirname: dirname14 } = await import("path");
           const mcpConfigPath = coordinatorSetup.configPath;
           const hermesManualFallback = cliType === "hermes-cli" && configFormat === "hermes_config_yaml" ? createHermesManualMeshCoordinatorSetup(meshId, workspace) : null;
@@ -48085,7 +48880,7 @@ ${ptyResult.output.slice(-2e3)}`);
             if (hermesManualFallback) return returnManualFallback(message);
             return { success: false, code: "mesh_coordinator_config_write_failed", error: message, meshId, cliType, workspace };
           }
-          const hadExistingMcpConfig = existsSync43(mcpConfigPath);
+          const hadExistingMcpConfig = existsSync44(mcpConfigPath);
           let existingMcpConfig = hermesBaseConfig?.config || {};
           if (hermesBaseConfig) {
             copyHermesCoordinatorCredentialFiles(hermesBaseConfig.sourceHome, dirname14(mcpConfigPath));
@@ -48243,6 +49038,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const liveMeshSessions = partitionSessionHostRecords(Array.isArray(sessionHostRecords) ? sessionHostRecords : []).liveRuntimes;
           const localMachineId = loadConfig().machineId || "";
           const requireDirectPeerTruth = args?.requireDirectPeerTruth === true;
+          const meshGitProbeCache = this.meshGitProbeCache;
           const directTruth = requireDirectPeerTruth ? await hydrateInlineMeshDirectTruth({
             mesh,
             meshSource: meshRecord.source,
@@ -48253,14 +49049,16 @@ ${ptyResult.output.slice(-2e3)}`);
             // Standing-state model: only an explicit refresh fans
             // out a blocking peer git probe. Default loads return
             // held truth so one slow peer can't block the graph.
-            probeRemotePeers: refreshRequested
+            probeRemotePeers: refreshRequested,
+            probeCache: meshGitProbeCache
           }) : {
             directEvidenceCount: 0,
             localConfirmedCount: 0,
             peerAttemptedCount: 0,
             peerConfirmedCount: 0,
             standingEvidenceCount: 0,
-            unavailableNodeIds: []
+            unavailableNodeIds: [],
+            deadNodeIds: []
           };
           const passivePeerTruthNotAttempted = requireDirectPeerTruth && !refreshRequested && directTruth.directEvidenceCount > 0 && directTruth.peerAttemptedCount === 0;
           const effectiveDirectTruth = passivePeerTruthNotAttempted ? { ...directTruth, unavailableNodeIds: [] } : directTruth;
@@ -48400,7 +49198,7 @@ ${ptyResult.output.slice(-2e3)}`);
               }
             }
             if (workspace) {
-              if (!fs24.existsSync(workspace)) {
+              if (!fs25.existsSync(workspace)) {
                 const inlineTransitGit = buildInlineMeshTransitGitStatus(node);
                 let remoteProbeApplied = false;
                 if (inlineTransitGit) {
@@ -48414,7 +49212,7 @@ ${ptyResult.output.slice(-2e3)}`);
                   }
                   remoteProbeApplied = true;
                 } else if (refreshRequested && !isSelfNode && daemonId && this.deps.dispatchMeshCommand && !directTruthUnavailableNodeIds.has(nodeId)) {
-                  const remoteGit = await probeRemoteMeshGitStatusWithRetry({
+                  const runNodeProbe = () => probeRemoteMeshGitStatusWithRetry({
                     dispatchMeshCommand: this.deps.dispatchMeshCommand,
                     daemonId,
                     workspace,
@@ -48425,6 +49223,7 @@ ${ptyResult.output.slice(-2e3)}`);
                       status.connection = connection;
                     }
                   });
+                  const remoteGit = await meshGitProbeCache.probe(daemonId, workspace, runNodeProbe);
                   if (remoteGit) {
                     status.git = remoteGit;
                     status.health = remoteGit.isGitRepo ? deriveMeshNodeHealthFromGit(remoteGit) : "degraded";
@@ -48490,7 +49289,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const pendingCoordinatorEvents = getPendingMeshCoordinatorEvents(meshId, callerCoordinatorDaemonId);
           const unroutableDeliveries = getRecentUnroutableDeliveries();
           const previewFreshness = (() => {
-            const localRepoRoot = nodeStatuses.map((node) => readStringValue(node?.git?.repoRoot, node?.repoRoot, node?.workspace)).find((candidate) => !!candidate && fs24.existsSync(candidate));
+            const localRepoRoot = nodeStatuses.map((node) => readStringValue(node?.git?.repoRoot, node?.repoRoot, node?.workspace)).find((candidate) => !!candidate && fs25.existsSync(candidate));
             return localRepoRoot ? buildPreviewFreshness(localRepoRoot) : void 0;
           })();
           const asyncRefineJobs = buildMeshAsyncRefineJobs({
@@ -48585,7 +49384,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const { deriveMeshReviewInboxItems: deriveMeshReviewInboxItems2 } = await Promise.resolve().then(() => (init_mesh_review_inbox(), mesh_review_inbox_exports));
           const { readLedgerEntries: readLedgerEntries2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
           const { getGitDiffSummary: getGitDiffSummary2 } = await Promise.resolve().then(() => (init_git_diff(), git_diff_exports));
-          const { existsSync: existsSync43 } = await import("fs");
+          const { existsSync: existsSync44 } = await import("fs");
           const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
           const mesh = meshRecord?.mesh;
           if (!mesh) return { success: false, error: "Mesh not found" };
@@ -48604,7 +49403,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const derivation = deriveMeshReviewInboxItems2({ nodes: nodeStatuses, ledgerEntries });
           for (const item of derivation.items) {
             const workspace = item.workspace;
-            if (!workspace || !existsSync43(workspace)) continue;
+            if (!workspace || !existsSync44(workspace)) continue;
             const baseRef = item.defaultBranch ? `origin/${item.defaultBranch}` : "origin/main";
             try {
               const diffResult = await getGitDiffSummary2(workspace, { baseRef, maxFiles: 100 });
@@ -50350,7 +51149,7 @@ var ProviderInstanceManager = class {
 };
 
 // src/providers/version-archive.ts
-var fs25 = __toESM(require("fs"));
+var fs26 = __toESM(require("fs"));
 var path36 = __toESM(require("path"));
 var os28 = __toESM(require("os"));
 var import_os4 = require("os");
@@ -50364,8 +51163,8 @@ var VersionArchive = class {
   }
   load() {
     try {
-      if (fs25.existsSync(ARCHIVE_PATH)) {
-        this.history = JSON.parse(fs25.readFileSync(ARCHIVE_PATH, "utf-8"));
+      if (fs26.existsSync(ARCHIVE_PATH)) {
+        this.history = JSON.parse(fs26.readFileSync(ARCHIVE_PATH, "utf-8"));
       }
     } catch {
       this.history = {};
@@ -50402,8 +51201,8 @@ var VersionArchive = class {
   }
   save() {
     try {
-      fs25.mkdirSync(path36.dirname(ARCHIVE_PATH), { recursive: true });
-      fs25.writeFileSync(ARCHIVE_PATH, JSON.stringify(this.history, null, 2));
+      fs26.mkdirSync(path36.dirname(ARCHIVE_PATH), { recursive: true });
+      fs26.writeFileSync(ARCHIVE_PATH, JSON.stringify(this.history, null, 2));
     } catch {
     }
   }
@@ -50428,8 +51227,8 @@ function findBinary2(name) {
     for (const ext of exes) {
       const fullPath = path36.join(p, name + ext);
       try {
-        if (fs25.existsSync(fullPath)) {
-          const stat2 = fs25.statSync(fullPath);
+        if (fs26.existsSync(fullPath)) {
+          const stat2 = fs26.statSync(fullPath);
           if (stat2.isFile() && (isWin || stat2.mode & 73)) {
             return fullPath;
           }
@@ -50476,9 +51275,9 @@ function checkPathExists2(paths) {
     if (p.includes("*")) {
       const home = os28.homedir();
       const resolved = p.replace(/\*/g, home.split(path36.sep).pop() || "");
-      if (fs25.existsSync(resolved)) return resolved;
+      if (fs26.existsSync(resolved)) return resolved;
     } else {
-      if (fs25.existsSync(p)) return p;
+      if (fs26.existsSync(p)) return p;
     }
   }
   return null;
@@ -50486,7 +51285,7 @@ function checkPathExists2(paths) {
 async function getMacAppVersion(appPath) {
   if ((0, import_os4.platform)() !== "darwin" || !appPath.endsWith(".app")) return null;
   const plistPath = path36.join(appPath, "Contents", "Info.plist");
-  if (!fs25.existsSync(plistPath)) return null;
+  if (!fs26.existsSync(plistPath)) return null;
   const raw = await runCommand(`/usr/libexec/PlistBuddy -c "Print CFBundleShortVersionString" "${plistPath}"`);
   return raw || null;
 }
@@ -50512,7 +51311,7 @@ async function detectAllVersions(loader, archive) {
       let resolvedBin = cliBin;
       if (!resolvedBin && appPath && currentOs === "darwin") {
         const bundled = path36.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
-        if (provider.cli && fs25.existsSync(bundled)) resolvedBin = bundled;
+        if (provider.cli && fs26.existsSync(bundled)) resolvedBin = bundled;
       }
       info.installed = !!(appPath || resolvedBin);
       info.path = appPath || null;
@@ -50551,7 +51350,7 @@ async function detectAllVersions(loader, archive) {
 
 // src/daemon/dev-server.ts
 var http2 = __toESM(require("http"));
-var fs29 = __toESM(require("fs"));
+var fs30 = __toESM(require("fs"));
 var path40 = __toESM(require("path"));
 init_config();
 
@@ -50902,7 +51701,7 @@ async (params) => {
 init_logger();
 
 // src/daemon/dev-cdp-handlers.ts
-var fs26 = __toESM(require("fs"));
+var fs27 = __toESM(require("fs"));
 var path37 = __toESM(require("path"));
 init_logger();
 async function handleCdpEvaluate(ctx, req, res) {
@@ -51083,17 +51882,17 @@ async function handleScriptHints(ctx, type, _req, res) {
   }
   let scriptsPath = "";
   const directScripts = path37.join(dir, "scripts.js");
-  if (fs26.existsSync(directScripts)) {
+  if (fs27.existsSync(directScripts)) {
     scriptsPath = directScripts;
   } else {
     const scriptsDir = path37.join(dir, "scripts");
-    if (fs26.existsSync(scriptsDir)) {
-      const versions = fs26.readdirSync(scriptsDir).filter((d) => {
-        return fs26.statSync(path37.join(scriptsDir, d)).isDirectory();
+    if (fs27.existsSync(scriptsDir)) {
+      const versions = fs27.readdirSync(scriptsDir).filter((d) => {
+        return fs27.statSync(path37.join(scriptsDir, d)).isDirectory();
       }).sort().reverse();
       for (const ver of versions) {
         const p = path37.join(scriptsDir, ver, "scripts.js");
-        if (fs26.existsSync(p)) {
+        if (fs27.existsSync(p)) {
           scriptsPath = p;
           break;
         }
@@ -51105,7 +51904,7 @@ async function handleScriptHints(ctx, type, _req, res) {
     return;
   }
   try {
-    const source = fs26.readFileSync(scriptsPath, "utf-8");
+    const source = fs27.readFileSync(scriptsPath, "utf-8");
     const hints = {};
     const funcRegex = /module\.exports\.(\w+)\s*=\s*function\s+\w+\s*\(params\)/g;
     let match;
@@ -51920,7 +52719,7 @@ async function handleDomContext(ctx, type, req, res) {
 }
 
 // src/daemon/dev-cli-debug.ts
-var fs27 = __toESM(require("fs"));
+var fs28 = __toESM(require("fs"));
 var path38 = __toESM(require("path"));
 function slugifyFixtureName(value) {
   const normalized = String(value || "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
@@ -51936,10 +52735,10 @@ function getCliFixtureDir(ctx, type) {
 function readCliFixture(ctx, type, name) {
   const fixtureDir = getCliFixtureDir(ctx, type);
   const filePath = path38.join(fixtureDir, `${name}.json`);
-  if (!fs27.existsSync(filePath)) {
+  if (!fs28.existsSync(filePath)) {
     throw new Error(`Fixture not found: ${filePath}`);
   }
-  return JSON.parse(fs27.readFileSync(filePath, "utf-8"));
+  return JSON.parse(fs28.readFileSync(filePath, "utf-8"));
 }
 function getExerciseTranscriptText(result) {
   const parts = [];
@@ -52684,7 +53483,7 @@ async function handleCliFixtureCapture(ctx, req, res) {
       return;
     }
     const fixtureDir = getCliFixtureDir(ctx, type);
-    fs27.mkdirSync(fixtureDir, { recursive: true });
+    fs28.mkdirSync(fixtureDir, { recursive: true });
     const name = slugifyFixtureName(String(body?.name || `${type}-${Date.now()}`));
     const result = await runCliExerciseInternal(ctx, { ...request, type });
     const fixture = {
@@ -52712,7 +53511,7 @@ async function handleCliFixtureCapture(ctx, req, res) {
       notes: typeof body?.notes === "string" ? body.notes : void 0
     };
     const filePath = path38.join(fixtureDir, `${name}.json`);
-    fs27.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
+    fs28.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
     ctx.json(res, 200, {
       saved: true,
       name,
@@ -52730,14 +53529,14 @@ async function handleCliFixtureCapture(ctx, req, res) {
 async function handleCliFixtureList(ctx, type, _req, res) {
   try {
     const fixtureDir = getCliFixtureDir(ctx, type);
-    if (!fs27.existsSync(fixtureDir)) {
+    if (!fs28.existsSync(fixtureDir)) {
       ctx.json(res, 200, { fixtures: [], count: 0 });
       return;
     }
-    const fixtures = fs27.readdirSync(fixtureDir).filter((file) => file.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file) => {
+    const fixtures = fs28.readdirSync(fixtureDir).filter((file) => file.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file) => {
       const fullPath = path38.join(fixtureDir, file);
       try {
-        const raw = JSON.parse(fs27.readFileSync(fullPath, "utf-8"));
+        const raw = JSON.parse(fs28.readFileSync(fullPath, "utf-8"));
         return {
           name: raw.name || file.replace(/\.json$/i, ""),
           path: fullPath,
@@ -52870,7 +53669,7 @@ async function handleCliRaw(ctx, req, res) {
 }
 
 // src/daemon/dev-auto-implement.ts
-var fs28 = __toESM(require("fs"));
+var fs29 = __toESM(require("fs"));
 var path39 = __toESM(require("path"));
 var os29 = __toESM(require("os"));
 var import_session_host_core8 = require("@adhdev/session-host-core");
@@ -52919,10 +53718,10 @@ function resolveAutoImplReference(ctx, category, requestedReference, targetType)
   return fallback?.type || null;
 }
 function getLatestScriptVersionDir(scriptsDir) {
-  if (!fs28.existsSync(scriptsDir)) return null;
-  const versions = fs28.readdirSync(scriptsDir).filter((d) => {
+  if (!fs29.existsSync(scriptsDir)) return null;
+  const versions = fs29.readdirSync(scriptsDir).filter((d) => {
     try {
-      return fs28.statSync(path39.join(scriptsDir, d)).isDirectory();
+      return fs29.statSync(path39.join(scriptsDir, d)).isDirectory();
     } catch {
       return false;
     }
@@ -52944,13 +53743,13 @@ function resolveAutoImplWritableProviderDir(ctx, category, type, requestedDir) {
   if (!sourceDir) {
     return { dir: null, reason: `Provider source directory not found for '${type}'` };
   }
-  if (!fs28.existsSync(desiredDir)) {
-    fs28.mkdirSync(path39.dirname(desiredDir), { recursive: true });
-    fs28.cpSync(sourceDir, desiredDir, { recursive: true });
+  if (!fs29.existsSync(desiredDir)) {
+    fs29.mkdirSync(path39.dirname(desiredDir), { recursive: true });
+    fs29.cpSync(sourceDir, desiredDir, { recursive: true });
     ctx.log(`Auto-implement writable copy created: ${desiredDir}`);
   }
   const providerJson = path39.join(desiredDir, "provider.json");
-  if (!fs28.existsSync(providerJson)) {
+  if (!fs29.existsSync(providerJson)) {
     return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
   }
   return { dir: desiredDir };
@@ -52958,15 +53757,15 @@ function resolveAutoImplWritableProviderDir(ctx, category, type, requestedDir) {
 function loadAutoImplReferenceScripts(ctx, referenceType) {
   if (!referenceType) return {};
   const refDir = ctx.findProviderDir(referenceType);
-  if (!refDir || !fs28.existsSync(refDir)) return {};
+  if (!refDir || !fs29.existsSync(refDir)) return {};
   const referenceScripts = {};
   const scriptsDir = path39.join(refDir, "scripts");
   const latestDir = getLatestScriptVersionDir(scriptsDir);
   if (!latestDir) return referenceScripts;
-  for (const file of fs28.readdirSync(latestDir)) {
+  for (const file of fs29.readdirSync(latestDir)) {
     if (!file.endsWith(".js")) continue;
     try {
-      referenceScripts[file] = fs28.readFileSync(path39.join(latestDir, file), "utf-8");
+      referenceScripts[file] = fs29.readFileSync(path39.join(latestDir, file), "utf-8");
     } catch {
     }
   }
@@ -53075,15 +53874,15 @@ async function handleAutoImplement(ctx, type, req, res) {
     const referenceScripts = loadAutoImplReferenceScripts(ctx, resolvedReference);
     const prompt = buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domContext, referenceScripts, comment, resolvedReference, verification);
     const tmpDir = path39.join(os29.tmpdir(), "adhdev-autoimpl");
-    if (!fs28.existsSync(tmpDir)) fs28.mkdirSync(tmpDir, { recursive: true });
+    if (!fs29.existsSync(tmpDir)) fs29.mkdirSync(tmpDir, { recursive: true });
     const promptFile = path39.join(tmpDir, `prompt-${type}-${Date.now()}.md`);
-    fs28.writeFileSync(promptFile, prompt, "utf-8");
+    fs29.writeFileSync(promptFile, prompt, "utf-8");
     ctx.log(`Auto-implement prompt written to ${promptFile} (${prompt.length} chars)`);
     const agentProvider = ctx.providerLoader.resolve(agent) || ctx.providerLoader.getMeta(agent);
     const spawn4 = agentProvider?.spawn;
     if (!spawn4?.command) {
       try {
-        fs28.unlinkSync(promptFile);
+        fs29.unlinkSync(promptFile);
       } catch {
       }
       ctx.json(res, 400, { error: `Agent '${agent}' has no spawn config. Select a CLI provider with a spawn configuration.` });
@@ -53185,7 +53984,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         } catch {
         }
         try {
-          fs28.unlinkSync(promptFile);
+          fs29.unlinkSync(promptFile);
         } catch {
         }
         ctx.log(`Auto-implement (ACP) ${success ? "completed" : "failed"}: ${type} (exit: ${code})`);
@@ -53411,7 +54210,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         }
       });
       try {
-        fs28.unlinkSync(promptFile);
+        fs29.unlinkSync(promptFile);
       } catch {
       }
       ctx.log(`Auto-implement ${success ? "completed" : "failed"}: ${type} (exit: ${code})${verificationSummary ? ` verify=${verificationSummary.pass ? "pass" : "fail"}` : ""}`);
@@ -53516,10 +54315,10 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
     lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
     lines.push("These are the ONLY files you are allowed to modify. Replace the TODO stubs with working implementations.");
     lines.push("");
-    for (const file of fs28.readdirSync(latestScriptsDir)) {
+    for (const file of fs29.readdirSync(latestScriptsDir)) {
       if (file.endsWith(".js") && targetFileNames.has(file)) {
         try {
-          const content = fs28.readFileSync(path39.join(latestScriptsDir, file), "utf-8");
+          const content = fs29.readFileSync(path39.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
           lines.push("```javascript");
           lines.push(content);
@@ -53529,14 +54328,14 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
         }
       }
     }
-    const refFiles = fs28.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+    const refFiles = fs29.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
     if (refFiles.length > 0) {
       lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
       lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
       lines.push("");
       for (const file of refFiles) {
         try {
-          const content = fs28.readFileSync(path39.join(latestScriptsDir, file), "utf-8");
+          const content = fs29.readFileSync(path39.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u{1F512}`);
           lines.push("```javascript");
           lines.push(content);
@@ -53581,7 +54380,7 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
   const loadGuide = (name) => {
     try {
       const p = path39.join(docsDir, name);
-      if (fs28.existsSync(p)) return fs28.readFileSync(p, "utf-8");
+      if (fs29.existsSync(p)) return fs29.readFileSync(p, "utf-8");
     } catch {
     }
     return null;
@@ -53825,11 +54624,11 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
     lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
     lines.push("These are the ONLY files you are allowed to modify. Replace TODO or heuristic-only logic with working PTY-aware implementations.");
     lines.push("");
-    for (const file of fs28.readdirSync(latestScriptsDir)) {
+    for (const file of fs29.readdirSync(latestScriptsDir)) {
       if (!file.endsWith(".js")) continue;
       if (!targetFileNames.has(file)) continue;
       try {
-        const content = fs28.readFileSync(path39.join(latestScriptsDir, file), "utf-8");
+        const content = fs29.readFileSync(path39.join(latestScriptsDir, file), "utf-8");
         lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
         lines.push("```javascript");
         lines.push(content);
@@ -53838,14 +54637,14 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
       } catch {
       }
     }
-    const refFiles = fs28.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+    const refFiles = fs29.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
     if (refFiles.length > 0) {
       lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
       lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
       lines.push("");
       for (const file of refFiles) {
         try {
-          const content = fs28.readFileSync(path39.join(latestScriptsDir, file), "utf-8");
+          const content = fs29.readFileSync(path39.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u{1F512}`);
           lines.push("```javascript");
           lines.push(content);
@@ -53882,7 +54681,7 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
   const loadGuide = (name) => {
     try {
       const p = path39.join(docsDir, name);
-      if (fs28.existsSync(p)) return fs28.readFileSync(p, "utf-8");
+      if (fs29.existsSync(p)) return fs29.readFileSync(p, "utf-8");
     } catch {
     }
     return null;
@@ -54622,7 +55421,7 @@ var DevServer = class _DevServer {
       path40.join(process.cwd(), "packages/web-devconsole/dist")
     ];
     for (const dir of candidates) {
-      if (fs29.existsSync(path40.join(dir, "index.html"))) return dir;
+      if (fs30.existsSync(path40.join(dir, "index.html"))) return dir;
     }
     return null;
   }
@@ -54634,7 +55433,7 @@ var DevServer = class _DevServer {
     }
     const htmlPath = path40.join(distDir, "index.html");
     try {
-      const html = fs29.readFileSync(htmlPath, "utf-8");
+      const html = fs30.readFileSync(htmlPath, "utf-8");
       res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
       res.end(html);
     } catch (e) {
@@ -54664,7 +55463,7 @@ var DevServer = class _DevServer {
       return;
     }
     try {
-      const content = fs29.readFileSync(filePath);
+      const content = fs30.readFileSync(filePath);
       const ext = path40.extname(filePath);
       const contentType = _DevServer.MIME_MAP[ext] || "application/octet-stream";
       res.writeHead(200, { "Content-Type": contentType, "Cache-Control": "public, max-age=31536000, immutable" });
@@ -54773,14 +55572,14 @@ var DevServer = class _DevServer {
     const files = [];
     const scan = (d, prefix) => {
       try {
-        for (const entry of fs29.readdirSync(d, { withFileTypes: true })) {
+        for (const entry of fs30.readdirSync(d, { withFileTypes: true })) {
           if (entry.name.startsWith(".") || entry.name.endsWith(".bak")) continue;
           const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
           if (entry.isDirectory()) {
             files.push({ path: rel, size: 0, type: "dir" });
             scan(path40.join(d, entry.name), rel);
           } else {
-            const stat2 = fs29.statSync(path40.join(d, entry.name));
+            const stat2 = fs30.statSync(path40.join(d, entry.name));
             files.push({ path: rel, size: stat2.size, type: "file" });
           }
         }
@@ -54808,11 +55607,11 @@ var DevServer = class _DevServer {
       this.json(res, 403, { error: "Forbidden" });
       return;
     }
-    if (!fs29.existsSync(fullPath) || fs29.statSync(fullPath).isDirectory()) {
+    if (!fs30.existsSync(fullPath) || fs30.statSync(fullPath).isDirectory()) {
       this.json(res, 404, { error: `File not found: ${filePath}` });
       return;
     }
-    const content = fs29.readFileSync(fullPath, "utf-8");
+    const content = fs30.readFileSync(fullPath, "utf-8");
     this.json(res, 200, { type, path: filePath, content, lines: content.split("\n").length });
   }
   /** POST /api/providers/:type/file — write a file { path, content } */
@@ -54834,9 +55633,9 @@ var DevServer = class _DevServer {
       return;
     }
     try {
-      if (fs29.existsSync(fullPath)) fs29.copyFileSync(fullPath, fullPath + ".bak");
-      fs29.mkdirSync(path40.dirname(fullPath), { recursive: true });
-      fs29.writeFileSync(fullPath, content, "utf-8");
+      if (fs30.existsSync(fullPath)) fs30.copyFileSync(fullPath, fullPath + ".bak");
+      fs30.mkdirSync(path40.dirname(fullPath), { recursive: true });
+      fs30.writeFileSync(fullPath, content, "utf-8");
       this.log(`File saved: ${fullPath} (${content.length} chars)`);
       this.providerLoader.reload();
       this.json(res, 200, { saved: true, path: filePath, chars: content.length });
@@ -54853,8 +55652,8 @@ var DevServer = class _DevServer {
     }
     for (const name of ["scripts.js", "provider.json"]) {
       const p = path40.join(dir, name);
-      if (fs29.existsSync(p)) {
-        const source = fs29.readFileSync(p, "utf-8");
+      if (fs30.existsSync(p)) {
+        const source = fs30.readFileSync(p, "utf-8");
         this.json(res, 200, { type, path: p, source, lines: source.split("\n").length });
         return;
       }
@@ -54873,11 +55672,11 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: `Provider not found: ${type}` });
       return;
     }
-    const target = fs29.existsSync(path40.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
+    const target = fs30.existsSync(path40.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
     const targetPath = path40.join(dir, target);
     try {
-      if (fs29.existsSync(targetPath)) fs29.copyFileSync(targetPath, targetPath + ".bak");
-      fs29.writeFileSync(targetPath, source, "utf-8");
+      if (fs30.existsSync(targetPath)) fs30.copyFileSync(targetPath, targetPath + ".bak");
+      fs30.writeFileSync(targetPath, source, "utf-8");
       this.log(`Saved provider: ${targetPath} (${source.length} chars)`);
       this.providerLoader.reload();
       this.json(res, 200, { saved: true, path: targetPath, chars: source.length });
@@ -55022,20 +55821,20 @@ var DevServer = class _DevServer {
     let targetDir;
     targetDir = this.providerLoader.getUserProviderDir(category, type);
     const jsonPath = path40.join(targetDir, "provider.json");
-    if (fs29.existsSync(jsonPath)) {
+    if (fs30.existsSync(jsonPath)) {
       this.json(res, 409, { error: `Provider already exists at ${targetDir}`, path: targetDir });
       return;
     }
     try {
       const result = generateFiles(type, name, category, { cdpPorts, cli, processName, installPath, binary, extensionId, version, osPaths, processNames });
-      fs29.mkdirSync(targetDir, { recursive: true });
-      fs29.writeFileSync(jsonPath, result["provider.json"], "utf-8");
+      fs30.mkdirSync(targetDir, { recursive: true });
+      fs30.writeFileSync(jsonPath, result["provider.json"], "utf-8");
       const createdFiles = ["provider.json"];
       if (result.files) {
         for (const [relPath, content] of Object.entries(result.files)) {
           const fullPath = path40.join(targetDir, relPath);
-          fs29.mkdirSync(path40.dirname(fullPath), { recursive: true });
-          fs29.writeFileSync(fullPath, content, "utf-8");
+          fs30.mkdirSync(path40.dirname(fullPath), { recursive: true });
+          fs30.writeFileSync(fullPath, content, "utf-8");
           createdFiles.push(relPath);
         }
       }
@@ -55084,10 +55883,10 @@ var DevServer = class _DevServer {
   }
   // ─── Phase 2: Auto-Implement Backend ───
   getLatestScriptVersionDir(scriptsDir) {
-    if (!fs29.existsSync(scriptsDir)) return null;
-    const versions = fs29.readdirSync(scriptsDir).filter((d) => {
+    if (!fs30.existsSync(scriptsDir)) return null;
+    const versions = fs30.readdirSync(scriptsDir).filter((d) => {
       try {
-        return fs29.statSync(path40.join(scriptsDir, d)).isDirectory();
+        return fs30.statSync(path40.join(scriptsDir, d)).isDirectory();
       } catch {
         return false;
       }
@@ -55109,13 +55908,13 @@ var DevServer = class _DevServer {
     if (!sourceDir) {
       return { dir: null, reason: `Provider source directory not found for '${type}'` };
     }
-    if (!fs29.existsSync(desiredDir)) {
-      fs29.mkdirSync(path40.dirname(desiredDir), { recursive: true });
-      fs29.cpSync(sourceDir, desiredDir, { recursive: true });
+    if (!fs30.existsSync(desiredDir)) {
+      fs30.mkdirSync(path40.dirname(desiredDir), { recursive: true });
+      fs30.cpSync(sourceDir, desiredDir, { recursive: true });
       this.log(`Auto-implement writable copy created: ${desiredDir}`);
     }
     const providerJson = path40.join(desiredDir, "provider.json");
-    if (!fs29.existsSync(providerJson)) {
+    if (!fs30.existsSync(providerJson)) {
       return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
     }
     return { dir: desiredDir };
@@ -55158,10 +55957,10 @@ var DevServer = class _DevServer {
       lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
       lines.push("These are the ONLY files you are allowed to modify. Replace the TODO stubs with working implementations.");
       lines.push("");
-      for (const file of fs29.readdirSync(latestScriptsDir)) {
+      for (const file of fs30.readdirSync(latestScriptsDir)) {
         if (file.endsWith(".js") && targetFileNames.has(file)) {
           try {
-            const content = fs29.readFileSync(path40.join(latestScriptsDir, file), "utf-8");
+            const content = fs30.readFileSync(path40.join(latestScriptsDir, file), "utf-8");
             lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
             lines.push("```javascript");
             lines.push(content);
@@ -55171,14 +55970,14 @@ var DevServer = class _DevServer {
           }
         }
       }
-      const refFiles = fs29.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+      const refFiles = fs30.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
       if (refFiles.length > 0) {
         lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
         lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
         lines.push("");
         for (const file of refFiles) {
           try {
-            const content = fs29.readFileSync(path40.join(latestScriptsDir, file), "utf-8");
+            const content = fs30.readFileSync(path40.join(latestScriptsDir, file), "utf-8");
             lines.push(`### \`${file}\` \u{1F512}`);
             lines.push("```javascript");
             lines.push(content);
@@ -55223,7 +56022,7 @@ var DevServer = class _DevServer {
     const loadGuide = (name) => {
       try {
         const p = path40.join(docsDir, name);
-        if (fs29.existsSync(p)) return fs29.readFileSync(p, "utf-8");
+        if (fs30.existsSync(p)) return fs30.readFileSync(p, "utf-8");
       } catch {
       }
       return null;
@@ -55404,11 +56203,11 @@ var DevServer = class _DevServer {
       lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
       lines.push("These are the ONLY files you are allowed to modify. Replace TODO or heuristic-only logic with working PTY-aware implementations.");
       lines.push("");
-      for (const file of fs29.readdirSync(latestScriptsDir)) {
+      for (const file of fs30.readdirSync(latestScriptsDir)) {
         if (!file.endsWith(".js")) continue;
         if (!targetFileNames.has(file)) continue;
         try {
-          const content = fs29.readFileSync(path40.join(latestScriptsDir, file), "utf-8");
+          const content = fs30.readFileSync(path40.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
           lines.push("```javascript");
           lines.push(content);
@@ -55417,14 +56216,14 @@ var DevServer = class _DevServer {
         } catch {
         }
       }
-      const refFiles = fs29.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+      const refFiles = fs30.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
       if (refFiles.length > 0) {
         lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
         lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
         lines.push("");
         for (const file of refFiles) {
           try {
-            const content = fs29.readFileSync(path40.join(latestScriptsDir, file), "utf-8");
+            const content = fs30.readFileSync(path40.join(latestScriptsDir, file), "utf-8");
             lines.push(`### \`${file}\` \u{1F512}`);
             lines.push("```javascript");
             lines.push(content);
@@ -55461,7 +56260,7 @@ var DevServer = class _DevServer {
     const loadGuide = (name) => {
       try {
         const p = path40.join(docsDir, name);
-        if (fs29.existsSync(p)) return fs29.readFileSync(p, "utf-8");
+        if (fs30.existsSync(p)) return fs30.readFileSync(p, "utf-8");
       } catch {
       }
       return null;
@@ -56562,8 +57361,8 @@ async function installExtension(ide, extension) {
       const res = await fetch(extension.vsixUrl);
       if (res.ok) {
         const buffer = Buffer.from(await res.arrayBuffer());
-        const fs30 = await import("fs");
-        fs30.writeFileSync(vsixPath, buffer);
+        const fs31 = await import("fs");
+        fs31.writeFileSync(vsixPath, buffer);
         return new Promise((resolve24) => {
           const cmd = `"${ide.cliCommand}" --install-extension "${vsixPath}" --force`;
           (0, import_child_process11.exec)(cmd, { timeout: 6e4 }, (error, _stdout, stderr) => {
@@ -57242,6 +58041,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   DEFAULT_GIT_WORKSPACE_POLL_INTERVAL_MS,
   DEFAULT_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS,
   DEFAULT_MESH_POLICY,
+  DEFAULT_MESH_SCHEDULING_STRATEGY,
   DEFAULT_SESSION_HOST_APP_NAME,
   DEFAULT_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS,
   DEFAULT_SESSION_HOST_READY_TIMEOUT_MS,
@@ -57267,9 +58067,12 @@ var V1_CONTRACT_VERSION = "1.0.0";
   InMemoryGitSnapshotStore,
   LOG,
   MAX_LEDGER_SLICE_LIMIT,
+  MESH_CONVERGE_FAST_FORWARD_TAG,
+  MESH_CONVERGE_REFINE_TAG,
   MESH_MISSION_STATUSES,
   MESH_REFINE_CONFIG_LOCATIONS,
   MESH_REFINE_CONFIG_SCHEMA,
+  MESH_SCHEDULING_STRATEGIES,
   MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS,
   MESH_WORKTREE_BOOTSTRAP_CONFIG_SCHEMA,
   MIN_GIT_WORKSPACE_POLL_INTERVAL_MS,
@@ -57470,6 +58273,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   normalizeManagedStatus,
   normalizeMeshCapabilityTags,
   normalizeMeshDaemonRole,
+  normalizeMeshSchedulingStrategy,
   normalizeMeshTaskMode,
   normalizeMeshWorkerResult,
   normalizeMessageParts,
@@ -57507,7 +58311,9 @@ var V1_CONTRACT_VERSION = "1.0.0";
   resetConfig,
   resetDebugRuntimeConfig,
   resetState,
+  resolveAutoConvergeCodeChange,
   resolveChatMessageKind,
+  resolveConvergeRequiredTags,
   resolveCurrentGlobalInstallSurface,
   resolveDebugRuntimeConfig,
   resolveDelegatedWorkerAutoApprove,
@@ -57515,6 +58321,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   resolveGitRepository,
   resolveMeshHostStatus,
   resolveMeshRefineValidationPlan,
+  resolveNodeSchedulingPriority,
   resolveSessionHostAppName,
   resolveSessionHostAppNameResolution,
   resolveWorktreePath,