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

package/dist/index.js

@@ -29735,6 +29735,18 @@ var require_dist3 = __commonJS({
       mod
     ));
     var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    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;
@@ -29762,10 +29774,23 @@ var require_dist3 = __commonJS({
       if (!Number.isFinite(raw) || raw < 0) return void 0;
       return Math.floor(raw);
     }
+    var MESH_SCHEDULING_STRATEGIES;
+    var DEFAULT_MESH_SCHEDULING_STRATEGY;
+    var MESH_CONVERGE_REFINE_TAG;
+    var MESH_CONVERGE_FAST_FORWARD_TAG;
     var DEFAULT_MESH_POLICY;
     var init_repo_mesh_types = __esm2({
       "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,
@@ -30004,10 +30029,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "33fe83f72a43bccb1b4bec7744ee5c6d8c11a325" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "33fe83f7" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = 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:35:20.983Z" : 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 version2 = 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:49:21.710Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -31261,6 +31286,17 @@ ${error48.message || ""}`;
       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) {
@@ -31809,6 +31845,7 @@ ${rules.join("\n")}`;
 | \`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 |
@@ -32573,6 +32610,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       recordMeshToolCall: () => recordMeshToolCall,
       recordTaskAutoLaunch: () => recordTaskAutoLaunch,
       requeueTask: () => requeueTask,
+      resolveConvergeRequiredTags: () => resolveConvergeRequiredTags,
       updateDirectDispatchStatus: () => updateDirectDispatchStatus,
       updateSessionTaskStatus: () => updateSessionTaskStatus,
       updateTaskStatus: () => updateTaskStatus,
@@ -32646,6 +32684,21 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       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;
@@ -32657,7 +32710,25 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         // 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) {
@@ -32666,6 +32737,18 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       const available = new Set(normalizeMeshCapabilityTags(capabilityTags));
       return required2.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);
     }
@@ -32724,7 +32807,15 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
           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(),
@@ -32992,6 +33083,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         "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"];
@@ -33289,6 +33381,17 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
 
             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) {
@@ -33466,6 +33569,44 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         `).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.
@@ -35445,8 +35586,8 @@ ${rendered}`, "utf-8");
         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 {
@@ -38051,6 +38192,33 @@ Next step: ${nextStep}`;
     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;
     }
@@ -38187,7 +38355,14 @@ Next step: ${nextStep}`;
           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}`;
@@ -38314,6 +38489,8 @@ Next step: ${nextStep}`;
           noIdleMeshSessionAvailable: true
         };
       }
+      const strategy = resolveSchedulingStrategy(mesh);
+      const localCandidates = [];
       const cliInstances = components.instanceManager.getByCategory("cli");
       for (const inst of cliInstances) {
         const state = inst.getState();
@@ -38336,7 +38513,7 @@ Next step: ${nextStep}`;
         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,
@@ -38350,18 +38527,49 @@ Next step: ${nextStep}`;
         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);
@@ -40424,8 +40632,8 @@ Next step: ${nextStep}`;
             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();
@@ -40530,9 +40738,9 @@ Next step: ${nextStep}`;
         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;
               }
@@ -40546,12 +40754,12 @@ Next step: ${nextStep}`;
     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;
@@ -40562,12 +40770,12 @@ Next step: ${nextStep}`;
     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);
@@ -41743,7 +41951,7 @@ ${cont}` : cont;
           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
             );
@@ -41751,7 +41959,7 @@ ${cont}` : cont;
               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) {
@@ -45262,6 +45470,7 @@ ${lastSnapshot}`;
       DEFAULT_GIT_WORKSPACE_POLL_INTERVAL_MS: () => DEFAULT_GIT_WORKSPACE_POLL_INTERVAL_MS,
       DEFAULT_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS: () => DEFAULT_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS2,
       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_MS2,
       DEFAULT_SESSION_HOST_READY_TIMEOUT_MS: () => DEFAULT_SESSION_HOST_READY_TIMEOUT_MS2,
@@ -45287,9 +45496,12 @@ ${lastSnapshot}`;
       InMemoryGitSnapshotStore: () => InMemoryGitSnapshotStore,
       LOG: () => LOG2,
       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,
@@ -45490,6 +45702,7 @@ ${lastSnapshot}`;
       normalizeManagedStatus: () => normalizeManagedStatus,
       normalizeMeshCapabilityTags: () => normalizeMeshCapabilityTags,
       normalizeMeshDaemonRole: () => normalizeMeshDaemonRole,
+      normalizeMeshSchedulingStrategy: () => normalizeMeshSchedulingStrategy,
       normalizeMeshTaskMode: () => normalizeMeshTaskMode,
       normalizeMeshWorkerResult: () => normalizeMeshWorkerResult,
       normalizeMessageParts: () => normalizeMessageParts,
@@ -45527,7 +45740,9 @@ ${lastSnapshot}`;
       resetConfig: () => resetConfig,
       resetDebugRuntimeConfig: () => resetDebugRuntimeConfig,
       resetState: () => resetState,
+      resolveAutoConvergeCodeChange: () => resolveAutoConvergeCodeChange,
       resolveChatMessageKind: () => resolveChatMessageKind,
+      resolveConvergeRequiredTags: () => resolveConvergeRequiredTags,
       resolveCurrentGlobalInstallSurface: () => resolveCurrentGlobalInstallSurface,
       resolveDebugRuntimeConfig: () => resolveDebugRuntimeConfig,
       resolveDelegatedWorkerAutoApprove: () => resolveDelegatedWorkerAutoApprove,
@@ -45535,6 +45750,7 @@ ${lastSnapshot}`;
       resolveGitRepository: () => resolveGitRepository,
       resolveMeshHostStatus: () => resolveMeshHostStatus,
       resolveMeshRefineValidationPlan: () => resolveMeshRefineValidationPlan,
+      resolveNodeSchedulingPriority: () => resolveNodeSchedulingPriority,
       resolveSessionHostAppName: () => resolveSessionHostAppName,
       resolveSessionHostAppNameResolution: () => resolveSessionHostAppNameResolution2,
       resolveWorktreePath: () => resolveWorktreePath,
@@ -47863,9 +48079,9 @@ ${lastSnapshot}`;
       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;
@@ -50937,6 +51153,11 @@ ${cleanBody}`;
           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);
@@ -56028,7 +56249,8 @@ ${effect.notification.body || ""}`.trim();
       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)));
@@ -58387,6 +58609,9 @@ ${effect.notification.body || ""}`.trim();
     }
     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)) {
@@ -59245,7 +59470,7 @@ ${effect.notification.body || ""}`.trim();
           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";
@@ -59289,7 +59514,7 @@ ${effect.notification.body || ""}`.trim();
           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);
@@ -59314,7 +59539,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,
@@ -59384,7 +59609,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(url2, timeoutMs) {
           return new Promise((resolve24, reject) => {
@@ -59468,8 +59693,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}`);
@@ -59507,8 +59732,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}`);
@@ -59536,7 +59761,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();
@@ -59545,10 +59770,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();
@@ -59564,28 +59789,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,
@@ -59696,7 +59921,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 file2 = ext.loadExternalSources();
@@ -59707,8 +59932,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 clone2 = spawnSync2("git", ["clone", "--depth=1", "--branch", ref, "--", url2, sourceDir], {
@@ -59718,7 +59943,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         });
         if (clone2.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: ${(clone2.stderr || clone2.stdout || "").trim() || "unknown error"}` };
@@ -59762,15 +59987,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(), __toCommonJS2(external_sources_exports));
-        const fs30 = require("fs");
+        const fs31 = require("fs");
         const path41 = require("path");
         const file2 = ext.loadExternalSources();
         const match = file2.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}` };
           }
@@ -60217,12 +60442,12 @@ ${formatManifestValidationIssues2(validation.issues)}`,
       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) {
@@ -60588,11 +60813,11 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           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));
@@ -60646,7 +60871,15 @@ ${formatManifestValidationIssues2(validation.issues)}`,
             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": {
@@ -60829,8 +61062,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
       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);
         }
@@ -60910,8 +61142,9 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         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 {
@@ -61309,11 +61542,42 @@ ${formatManifestValidationIssues2(validation.issues)}`,
       }
       return cur;
     }
-    function projectMessage(record2, map2, index, total, sourceMtimeMs) {
+    function projectMessages(record2, map2, index, total, sourceMtimeMs) {
       const roleRaw = jsonPathGet(record2, map2.role);
-      const contentRaw = jsonPathGet(record2, map2.content);
       const role = normalizeRole(roleRaw);
-      let content = stringifyContent(contentRaw);
+      let receivedAt = sourceMtimeMs - (total - 1 - index) * 1e3;
+      if (map2.timestamp_ms) {
+        const tsRaw = jsonPathGet(record2, map2.timestamp_ms);
+        const parsed = parseTimestamp(tsRaw);
+        if (parsed != null) receivedAt = parsed;
+      }
+      const kindRaw = map2.kind ? jsonPathGet(record2, map2.kind) : void 0;
+      const kind = typeof kindRaw === "string" && kindRaw ? kindRaw : "standard";
+      const out = [];
+      if (map2.tools) {
+        const recordTool = projectToolBlock(record2, role, map2.tools);
+        if (recordTool) {
+          out.push({ ...recordTool, receivedAt });
+          return out;
+        }
+      }
+      const contentRaw = jsonPathGet(record2, map2.content);
+      const content = cleanContent(stringifyContent(contentRaw), map2);
+      if (content) out.push({ role, content, receivedAt, kind });
+      if (map2.tools && Array.isArray(contentRaw)) {
+        let nudge = 1;
+        for (const block2 of contentRaw) {
+          const tool = projectToolBlock(block2, role, map2.tools);
+          if (tool) {
+            out.push({ ...tool, receivedAt: receivedAt + nudge });
+            nudge += 1;
+          }
+        }
+      }
+      return out;
+    }
+    function cleanContent(input, map2) {
+      let content = input;
       if (content && map2.content_strip) {
         for (const tag of map2.content_strip) {
           const safeTag = tag.replace(/[.+^${}()|[\]\\]/g, "\\$&");
@@ -61329,17 +61593,33 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           content = content.replace(open, "").replace(close, "");
         }
       }
-      if (content) content = content.trim();
-      if (!content) return null;
-      let receivedAt = sourceMtimeMs - (total - 1 - index) * 1e3;
-      if (map2.timestamp_ms) {
-        const tsRaw = jsonPathGet(record2, map2.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 = map2.kind ? jsonPathGet(record2, map2.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;
@@ -61478,6 +61758,9 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     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;
@@ -61699,9 +61982,15 @@ ${formatManifestValidationIssues2(validation.issues)}`,
        * 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
        *
@@ -61726,11 +62015,128 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           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 = "";
@@ -68643,7 +69049,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         }
         if (providerDir) {
           try {
-            const fs30 = require("fs");
+            const fs31 = require("fs");
             const path41 = require("path");
             const candidates = [];
             if (Array.isArray(base.compatibility)) {
@@ -68655,13 +69061,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
             }
             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 {
@@ -68686,7 +69092,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
                   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)];
@@ -69867,7 +70273,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         }
       } else if (plat === "win32") {
         try {
-          const fs30 = require("fs");
+          const fs31 = require("fs");
           const appNameMap = getMacAppIdentifiers();
           const appName = appNameMap[ideId];
           if (appName) {
@@ -69876,8 +70282,8 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
               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];
@@ -70203,6 +70609,204 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     cleanOldFiles();
     var yaml3 = __toESM2(require_js_yaml());
     init_logger();
+    var fs23 = __toESM2(require("fs"));
+    init_logger();
+    var DEFAULT_TAIL_BYTES = 64 * 1024;
+    var MAX_TAIL_BYTES = 128 * 1024;
+    var READ_CHUNK_BYTES = 64 * 1024;
+    function resolveLogPath(date5) {
+      if (date5 instanceof Date) return getCurrentDaemonLogPath(date5);
+      if (typeof date5 === "string" && date5.trim()) {
+        const parsed = /* @__PURE__ */ new Date(`${date5.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 } : {}
+      };
+    }
+    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);
     init_mesh_coordinator();
     init_mesh_events();
     init_mesh_routing();
@@ -70833,21 +71437,21 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     init_build_info();
     var import_child_process8 = require("child_process");
     var import_child_process9 = require("child_process");
-    var fs23 = __toESM2(require("fs"));
+    var fs24 = __toESM2(require("fs"));
     var os27 = __toESM2(require("os"));
     var path35 = __toESM2(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 {
       }
     }
@@ -70855,12 +71459,12 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       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) };
           }
         }
@@ -70868,7 +71472,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       }
       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) };
         }
       }
@@ -70878,12 +71482,12 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       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 {
@@ -70892,8 +71496,8 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       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;
@@ -71042,8 +71646,8 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     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)) {
             killPid2(pid);
           }
@@ -71051,7 +71655,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       } catch {
       } finally {
         try {
-          fs23.unlinkSync(pidFile);
+          fs24.unlinkSync(pidFile);
         } catch {
         }
       }
@@ -71059,7 +71663,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     function removeDaemonPidFile() {
       const pidFile = path35.join(os27.homedir(), ".adhdev", "daemon.pid");
       try {
-        fs23.unlinkSync(pidFile);
+        fs24.unlinkSync(pidFile);
       } catch {
       }
     }
@@ -71077,23 +71681,23 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       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)}`);
         }
       }
@@ -71182,7 +71786,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     init_repo_mesh_types();
     var import_os3 = require("os");
     var import_path11 = require("path");
-    var fs24 = __toESM2(require("fs"));
+    var fs25 = __toESM2(require("fs"));
     var import_node_child_process6 = require("child_process");
     var CHANNEL_NPM_TAG = { stable: "latest", preview: "next" };
     var CHANNEL_SERVER_URL = {
@@ -71508,6 +72112,12 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     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);
@@ -71754,7 +72364,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       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);
@@ -71882,6 +72492,43 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     }
     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 cached22 = this.recent.get(key);
+        if (cached22 && this.now() - cached22.at < this.reuseMs) {
+          return cached22.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([
@@ -71925,7 +72572,8 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
           peerAttemptedCount: 0,
           peerConfirmedCount: 0,
           standingEvidenceCount: 0,
-          unavailableNodeIds: []
+          unavailableNodeIds: [],
+          deadNodeIds: []
         };
       }
       const selectedCoordinatorNodeId = readStringValue(
@@ -71938,6 +72586,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       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);
@@ -71947,11 +72596,18 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         ) || 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) {
@@ -71975,7 +72631,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
           continue;
         }
         peerAttemptedCount += 1;
-        const remoteGit = await probeRemoteMeshGitStatusWithRetry({
+        const runProbe = () => probeRemoteMeshGitStatusWithRetry({
           dispatchMeshCommand: args.dispatchMeshCommand,
           daemonId,
           workspace,
@@ -71983,6 +72639,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
           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;
@@ -71996,7 +72653,8 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         peerAttemptedCount,
         peerConfirmedCount,
         standingEvidenceCount,
-        unavailableNodeIds
+        unavailableNodeIds,
+        deadNodeIds
       };
     }
     function summarizeMeshSessionRecord(record2) {
@@ -72055,7 +72713,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     }
     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((record2) => {
         const recordNodeId = readStringValue(record2?.meta?.meshNodeId);
         if (recordNodeId && recordNodeId !== args.nodeId) return false;
@@ -72082,7 +72740,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         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);
         }
       }
@@ -72442,7 +73100,7 @@ ${e?.stderr || ""}`
       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" });
@@ -72559,7 +73217,7 @@ ${e?.stderr || ""}`
           return newTree || void 0;
         } finally {
           try {
-            fs24.rmSync(tmpIndex, { force: true });
+            fs25.rmSync(tmpIndex, { force: true });
           } catch {
           }
         }
@@ -72634,7 +73292,7 @@ ${e?.stderr || ""}`
           return newTree || void 0;
         } finally {
           try {
-            fs24.rmSync(tmpIndex, { force: true });
+            fs25.rmSync(tmpIndex, { force: true });
           } catch {
           }
         }
@@ -72740,7 +73398,7 @@ ${e?.stderr || ""}`
           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 {
@@ -72763,7 +73421,7 @@ ${e?.stderr || ""}`
             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) {
@@ -73000,9 +73658,9 @@ ${e?.stderr || ""}`
         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" };
@@ -73104,9 +73762,9 @@ ${e?.stderr || ""}`
     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 };
     }
@@ -73143,9 +73801,9 @@ ${e?.stderr || ""}`
       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 (error48) {
           LOG2.warn("MeshCoordinator", `Could not copy Hermes ${fileName} into isolated coordinator home: ${error48?.message || error48}`);
         }
@@ -73303,8 +73961,21 @@ ${e?.stderr || ""}`
        *  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. */
@@ -73332,10 +74003,23 @@ ${e?.stderr || ""}`
         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;
@@ -73450,7 +74134,10 @@ ${e?.stderr || ""}`
       }
       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 cached22 = this.inlineMeshCache.get(meshId);
         if (cached22) {
           const merged = reconcileInlineMeshCache(cached22, sanitizedInlineMesh);
@@ -73466,7 +74153,10 @@ ${e?.stderr || ""}`
           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" };
             }
@@ -73517,12 +74207,49 @@ ${e?.stderr || ""}`
         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 set2 = this.removedInlineMeshNodeIds.get(meshId);
+        if (!set2) {
+          set2 = /* @__PURE__ */ new Set();
+          this.removedInlineMeshNodeIds.set(meshId, set2);
+        }
+        set2.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";
       }
@@ -73545,13 +74272,13 @@ ${e?.stderr || ""}`
             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",
@@ -73571,7 +74298,7 @@ ${e?.stderr || ""}`
         const normalizePath = (value) => {
           const resolved = (0, import_path11.resolve)(value);
           try {
-            return fs24.realpathSync(resolved);
+            return fs25.realpathSync(resolved);
           } catch {
             return resolved;
           }
@@ -73657,7 +74384,7 @@ ${e?.stderr || ""}`
               };
             } 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",
@@ -75436,8 +76163,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 };
@@ -75982,14 +76709,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;
@@ -75999,7 +76726,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: "" };
@@ -76013,7 +76740,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() : "";
@@ -76026,11 +76753,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 (error48) {
@@ -76207,7 +76934,8 @@ ${hintLines.join("\n")}` : "",
               getMeshPeerConnectionStatus: this.deps.getMeshPeerConnectionStatus,
               statusInstanceId: this.deps.statusInstanceId,
               localMachineId: loadConfig2().machineId || "",
-              probeRemotePeers
+              probeRemotePeers,
+              probeCache: this.meshGitProbeCache
             });
             const directTruthSatisfied = meshRecord.source !== "inline_bootstrap" || directTruth.directEvidenceCount > 0;
             const sourceOfTruth = {
@@ -76807,10 +77535,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 });
@@ -77458,15 +78251,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,
@@ -77582,7 +78375,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;
@@ -77625,7 +78418,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));
@@ -77783,6 +78576,7 @@ ${ptyResult.output.slice(-2e3)}`);
               const liveMeshSessions = partitionSessionHostRecords(Array.isArray(sessionHostRecords) ? sessionHostRecords : []).liveRuntimes;
               const localMachineId = loadConfig2().machineId || "";
               const requireDirectPeerTruth = args?.requireDirectPeerTruth === true;
+              const meshGitProbeCache = this.meshGitProbeCache;
               const directTruth = requireDirectPeerTruth ? await hydrateInlineMeshDirectTruth({
                 mesh,
                 meshSource: meshRecord.source,
@@ -77793,14 +78587,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;
@@ -77940,7 +78736,7 @@ ${ptyResult.output.slice(-2e3)}`);
                   }
                 }
                 if (workspace) {
-                  if (!fs24.existsSync(workspace)) {
+                  if (!fs25.existsSync(workspace)) {
                     const inlineTransitGit = buildInlineMeshTransitGitStatus(node);
                     let remoteProbeApplied = false;
                     if (inlineTransitGit) {
@@ -77954,7 +78750,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,
@@ -77965,6 +78761,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";
@@ -78030,7 +78827,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({
@@ -78125,7 +78922,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" };
@@ -78144,7 +78941,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 });
@@ -79868,7 +80665,7 @@ ${ptyResult.output.slice(-2e3)}`);
         this.eventListeners = [];
       }
     };
-    var fs25 = __toESM2(require("fs"));
+    var fs26 = __toESM2(require("fs"));
     var path36 = __toESM2(require("path"));
     var os28 = __toESM2(require("os"));
     var import_os4 = require("os");
@@ -79882,8 +80679,8 @@ ${ptyResult.output.slice(-2e3)}`);
       }
       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 = {};
@@ -79920,8 +80717,8 @@ ${ptyResult.output.slice(-2e3)}`);
       }
       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 {
         }
       }
@@ -79946,8 +80743,8 @@ ${ptyResult.output.slice(-2e3)}`);
         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;
               }
@@ -79994,9 +80791,9 @@ ${ptyResult.output.slice(-2e3)}`);
         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;
@@ -80004,7 +80801,7 @@ ${ptyResult.output.slice(-2e3)}`);
     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;
     }
@@ -80030,7 +80827,7 @@ ${ptyResult.output.slice(-2e3)}`);
           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;
@@ -80067,7 +80864,7 @@ ${ptyResult.output.slice(-2e3)}`);
       return results;
     }
     var http2 = __toESM2(require("http"));
-    var fs29 = __toESM2(require("fs"));
+    var fs30 = __toESM2(require("fs"));
     var path40 = __toESM2(require("path"));
     init_config();
     function generateFiles(type, name, category, opts = {}) {
@@ -80412,7 +81209,7 @@ async (params) => {
       };
     }
     init_logger();
-    var fs26 = __toESM2(require("fs"));
+    var fs27 = __toESM2(require("fs"));
     var path37 = __toESM2(require("path"));
     init_logger();
     async function handleCdpEvaluate(ctx, req, res) {
@@ -80593,17 +81390,17 @@ async (params) => {
       }
       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;
             }
@@ -80615,7 +81412,7 @@ async (params) => {
         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;
@@ -81428,7 +82225,7 @@ async (params) => {
         ctx.json(res, 500, { error: `DOM context collection failed: ${e.message}` });
       }
     }
-    var fs27 = __toESM2(require("fs"));
+    var fs28 = __toESM2(require("fs"));
     var path38 = __toESM2(require("path"));
     function slugifyFixtureName(value) {
       const normalized = String(value || "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
@@ -81444,10 +82241,10 @@ async (params) => {
     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 = [];
@@ -82192,7 +82989,7 @@ async (params) => {
           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 = {
@@ -82220,7 +83017,7 @@ async (params) => {
           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,
@@ -82238,14 +83035,14 @@ async (params) => {
     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((file2) => file2.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file2) => {
+        const fixtures = fs28.readdirSync(fixtureDir).filter((file2) => file2.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file2) => {
           const fullPath = path38.join(fixtureDir, file2);
           try {
-            const raw = JSON.parse(fs27.readFileSync(fullPath, "utf-8"));
+            const raw = JSON.parse(fs28.readFileSync(fullPath, "utf-8"));
             return {
               name: raw.name || file2.replace(/\.json$/i, ""),
               path: fullPath,
@@ -82376,7 +83173,7 @@ async (params) => {
         ctx.json(res, 500, { error: `Raw send failed: ${e.message}` });
       }
     }
-    var fs28 = __toESM2(require("fs"));
+    var fs29 = __toESM2(require("fs"));
     var path39 = __toESM2(require("path"));
     var os29 = __toESM2(require("os"));
     var import_session_host_core8 = require_dist();
@@ -82425,10 +83222,10 @@ async (params) => {
       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;
         }
@@ -82450,13 +83247,13 @@ async (params) => {
       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 };
@@ -82464,15 +83261,15 @@ async (params) => {
     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 file2 of fs28.readdirSync(latestDir)) {
+      for (const file2 of fs29.readdirSync(latestDir)) {
         if (!file2.endsWith(".js")) continue;
         try {
-          referenceScripts[file2] = fs28.readFileSync(path39.join(latestDir, file2), "utf-8");
+          referenceScripts[file2] = fs29.readFileSync(path39.join(latestDir, file2), "utf-8");
         } catch {
         }
       }
@@ -82581,15 +83378,15 @@ async (params) => {
         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.` });
@@ -82691,7 +83488,7 @@ async (params) => {
             } catch {
             }
             try {
-              fs28.unlinkSync(promptFile);
+              fs29.unlinkSync(promptFile);
             } catch {
             }
             ctx.log(`Auto-implement (ACP) ${success2 ? "completed" : "failed"}: ${type} (exit: ${code})`);
@@ -82917,7 +83714,7 @@ async (params) => {
             }
           });
           try {
-            fs28.unlinkSync(promptFile);
+            fs29.unlinkSync(promptFile);
           } catch {
           }
           ctx.log(`Auto-implement ${success2 ? "completed" : "failed"}: ${type} (exit: ${code})${verificationSummary ? ` verify=${verificationSummary.pass ? "pass" : "fail"}` : ""}`);
@@ -83022,10 +83819,10 @@ async (params) => {
         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 file2 of fs28.readdirSync(latestScriptsDir)) {
+        for (const file2 of fs29.readdirSync(latestScriptsDir)) {
           if (file2.endsWith(".js") && targetFileNames.has(file2)) {
             try {
-              const content = fs28.readFileSync(path39.join(latestScriptsDir, file2), "utf-8");
+              const content = fs29.readFileSync(path39.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
               lines.push("```javascript");
               lines.push(content);
@@ -83035,14 +83832,14 @@ async (params) => {
             }
           }
         }
-        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 file2 of refFiles) {
             try {
-              const content = fs28.readFileSync(path39.join(latestScriptsDir, file2), "utf-8");
+              const content = fs29.readFileSync(path39.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u{1F512}`);
               lines.push("```javascript");
               lines.push(content);
@@ -83087,7 +83884,7 @@ async (params) => {
       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;
@@ -83331,11 +84128,11 @@ async (params) => {
         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 file2 of fs28.readdirSync(latestScriptsDir)) {
+        for (const file2 of fs29.readdirSync(latestScriptsDir)) {
           if (!file2.endsWith(".js")) continue;
           if (!targetFileNames.has(file2)) continue;
           try {
-            const content = fs28.readFileSync(path39.join(latestScriptsDir, file2), "utf-8");
+            const content = fs29.readFileSync(path39.join(latestScriptsDir, file2), "utf-8");
             lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
             lines.push("```javascript");
             lines.push(content);
@@ -83344,14 +84141,14 @@ async (params) => {
           } 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 file2 of refFiles) {
             try {
-              const content = fs28.readFileSync(path39.join(latestScriptsDir, file2), "utf-8");
+              const content = fs29.readFileSync(path39.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u{1F512}`);
               lines.push("```javascript");
               lines.push(content);
@@ -83388,7 +84185,7 @@ async (params) => {
       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;
@@ -84126,7 +84923,7 @@ data: ${JSON.stringify(msg.data)}
           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;
       }
@@ -84138,7 +84935,7 @@ data: ${JSON.stringify(msg.data)}
         }
         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) {
@@ -84168,7 +84965,7 @@ data: ${JSON.stringify(msg.data)}
           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" });
@@ -84277,14 +85074,14 @@ data: ${JSON.stringify(msg.data)}
         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" });
               }
             }
@@ -84312,11 +85109,11 @@ data: ${JSON.stringify(msg.data)}
           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 } */
@@ -84338,9 +85135,9 @@ data: ${JSON.stringify(msg.data)}
           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 });
@@ -84357,8 +85154,8 @@ data: ${JSON.stringify(msg.data)}
         }
         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;
           }
@@ -84377,11 +85174,11 @@ data: ${JSON.stringify(msg.data)}
           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 });
@@ -84526,20 +85323,20 @@ data: ${JSON.stringify(msg.data)}
         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: version2, 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);
             }
           }
@@ -84588,10 +85385,10 @@ data: ${JSON.stringify(msg.data)}
       }
       // ─── 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;
           }
@@ -84613,13 +85410,13 @@ data: ${JSON.stringify(msg.data)}
         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 };
@@ -84662,10 +85459,10 @@ data: ${JSON.stringify(msg.data)}
           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 file2 of fs29.readdirSync(latestScriptsDir)) {
+          for (const file2 of fs30.readdirSync(latestScriptsDir)) {
             if (file2.endsWith(".js") && targetFileNames.has(file2)) {
               try {
-                const content = fs29.readFileSync(path40.join(latestScriptsDir, file2), "utf-8");
+                const content = fs30.readFileSync(path40.join(latestScriptsDir, file2), "utf-8");
                 lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
                 lines.push("```javascript");
                 lines.push(content);
@@ -84675,14 +85472,14 @@ data: ${JSON.stringify(msg.data)}
               }
             }
           }
-          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 file2 of refFiles) {
               try {
-                const content = fs29.readFileSync(path40.join(latestScriptsDir, file2), "utf-8");
+                const content = fs30.readFileSync(path40.join(latestScriptsDir, file2), "utf-8");
                 lines.push(`### \`${file2}\` \u{1F512}`);
                 lines.push("```javascript");
                 lines.push(content);
@@ -84727,7 +85524,7 @@ data: ${JSON.stringify(msg.data)}
         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;
@@ -84908,11 +85705,11 @@ data: ${JSON.stringify(msg.data)}
           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 file2 of fs29.readdirSync(latestScriptsDir)) {
+          for (const file2 of fs30.readdirSync(latestScriptsDir)) {
             if (!file2.endsWith(".js")) continue;
             if (!targetFileNames.has(file2)) continue;
             try {
-              const content = fs29.readFileSync(path40.join(latestScriptsDir, file2), "utf-8");
+              const content = fs30.readFileSync(path40.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
               lines.push("```javascript");
               lines.push(content);
@@ -84921,14 +85718,14 @@ data: ${JSON.stringify(msg.data)}
             } 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 file2 of refFiles) {
               try {
-                const content = fs29.readFileSync(path40.join(latestScriptsDir, file2), "utf-8");
+                const content = fs30.readFileSync(path40.join(latestScriptsDir, file2), "utf-8");
                 lines.push(`### \`${file2}\` \u{1F512}`);
                 lines.push("```javascript");
                 lines.push(content);
@@ -84965,7 +85762,7 @@ data: ${JSON.stringify(msg.data)}
         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;
@@ -86052,8 +86849,8 @@ data: ${JSON.stringify(msg.data)}
           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 }, (error48, _stdout, stderr) => {