@adhdev/daemon-core 0.9.82-rc.365 → 0.9.82-rc.366

package/dist/index.js

@@ -316,10 +316,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "fe24f3fb158efc949e806b79bca2479b1c29d753" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "fe24f3fb" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.365" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-24T00:47:57.092Z" : void 0);
+  const commit = readInjected(true ? "c2224ab0c9d05e85b4cbf88e4fc696f3733ec397" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "c2224ab0" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.366" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-24T02:22:36.214Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -7231,8 +7231,8 @@ function stripCoordinatorWrapperFile(filePath) {
     const remaining = (existing.slice(0, openIdx) + existing.slice(closeIdx + CLOSE.length)).replace(/^\s*\n+/, "").replace(/\n+\s*$/, "");
     if (!remaining.trim()) {
       try {
-        const fs33 = require("fs");
-        fs33.unlinkSync(filePath);
+        const fs35 = require("fs");
+        fs35.unlinkSync(filePath);
       } catch {
       }
     } else {
@@ -9671,9 +9671,9 @@ function findBinary(name) {
     for (const ext of exes) {
       const fullPath = path11.join(p, trimmed + ext);
       try {
-        const fs33 = require("fs");
-        if (fs33.existsSync(fullPath)) {
-          const stat2 = fs33.statSync(fullPath);
+        const fs35 = require("fs");
+        if (fs35.existsSync(fullPath)) {
+          const stat2 = fs35.statSync(fullPath);
           if (stat2.isFile() && (isWin || stat2.mode & 73)) {
             return fullPath;
           }
@@ -9687,12 +9687,12 @@ function findBinary(name) {
 function isScriptBinary(binaryPath) {
   if (!path11.isAbsolute(binaryPath)) return false;
   try {
-    const fs33 = require("fs");
-    const resolved = fs33.realpathSync(binaryPath);
+    const fs35 = require("fs");
+    const resolved = fs35.realpathSync(binaryPath);
     const head = Buffer.alloc(8);
-    const fd = fs33.openSync(resolved, "r");
-    fs33.readSync(fd, head, 0, 8, 0);
-    fs33.closeSync(fd);
+    const fd = fs35.openSync(resolved, "r");
+    fs35.readSync(fd, head, 0, 8, 0);
+    fs35.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;
@@ -9703,12 +9703,12 @@ function isScriptBinary(binaryPath) {
 function looksLikeMachOOrElf(filePath) {
   if (!path11.isAbsolute(filePath)) return false;
   try {
-    const fs33 = require("fs");
-    const resolved = fs33.realpathSync(filePath);
+    const fs35 = require("fs");
+    const resolved = fs35.realpathSync(filePath);
     const buf = Buffer.alloc(8);
-    const fd = fs33.openSync(resolved, "r");
-    fs33.readSync(fd, buf, 0, 8, 0);
-    fs33.closeSync(fd);
+    const fd = fs35.openSync(resolved, "r");
+    fs35.readSync(fd, buf, 0, 8, 0);
+    fs35.closeSync(fd);
     let i = 0;
     if (buf[0] === 239 && buf[1] === 187 && buf[2] === 191) i = 3;
     const b = buf.subarray(i);
@@ -13496,6 +13496,13 @@ async function triggerMeshQueue(components, meshId) {
     nodeId: task.assignedNodeId,
     sessionId: task.assignedSessionId
   }));
+  const autoLaunchPending = autoLaunchStarted || afterQueue.some((task) => {
+    if (task.status !== "pending") return false;
+    const al = task.autoLaunch;
+    if (!al || al.status !== "started" && al.status !== "completed") return false;
+    const launchedAtMs = Date.parse(al.updatedAt);
+    return Number.isFinite(launchedAtMs) && Date.now() - launchedAtMs < AUTO_LAUNCH_AWAIT_CLAIM_MS;
+  });
   return {
     success: true,
     meshId,
@@ -13509,7 +13516,11 @@ async function triggerMeshQueue(components, meshId) {
     remoteIdleSessionsChecked,
     skippedSessions,
     autoLaunchStarted,
-    ...pendingAfter > 0 && newlyAssignedTasks.length === 0 && localIdleSessionsChecked === 0 && remoteIdleSessionsChecked === 0 && !autoLaunchStarted ? { noIdleMeshSessionAvailable: true } : {}
+    ...autoLaunchPending ? { autoLaunchPending: true } : {},
+    // Only report "no idle session, go launch one" when nothing is already on its way.
+    // A pending auto-launch (this tick or a prior still-converging one) means a session
+    // WILL claim shortly, so it is not a no-session-available situation.
+    ...pendingAfter > 0 && newlyAssignedTasks.length === 0 && localIdleSessionsChecked === 0 && remoteIdleSessionsChecked === 0 && !autoLaunchPending ? { noIdleMeshSessionAvailable: true } : {}
   };
 }
 async function maybeAutoFastForwardIdleNode(components, args) {
@@ -16478,8 +16489,8 @@ var init_pty_transport = __esm({
         let cwd = options.cwd;
         if (cwd) {
           try {
-            const fs33 = require("fs");
-            const stat2 = fs33.statSync(cwd);
+            const fs35 = require("fs");
+            const stat2 = fs35.statSync(cwd);
             if (!stat2.isDirectory()) cwd = os14.homedir();
           } catch {
             cwd = os14.homedir();
@@ -32368,7 +32379,7 @@ var DaemonCommandHandler = class {
       return { success: false, error: "invalid type" };
     }
     const https = require("https");
-    const fs33 = require("fs");
+    const fs35 = require("fs");
     const path42 = require("path");
     const crypto6 = require("crypto");
     const REGISTRY = "https://api.adhf.dev/api/v1/registry";
@@ -32412,7 +32423,7 @@ var DaemonCommandHandler = class {
       if (!targetDir.startsWith(installRootResolved + path42.sep)) {
         return { success: false, error: "install path escaped upstream root" };
       }
-      fs33.mkdirSync(targetDir, { recursive: true });
+      fs35.mkdirSync(targetDir, { recursive: true });
       let manifestProbe = {};
       try {
         manifestProbe = JSON.parse(manifestBody);
@@ -32437,7 +32448,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
       }
       const targetFile = isV1 ? "provider.v1.json" : "provider.json";
       const targetPath = path42.join(targetDir, targetFile);
-      fs33.writeFileSync(targetPath, manifestBody, "utf-8");
+      fs35.writeFileSync(targetPath, manifestBody, "utf-8");
       const manifestJson = JSON.parse(manifestBody);
       const scriptFetch = await this.fetchProviderSources(
         manifestJson,
@@ -32507,7 +32518,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     const repo = source.repo;
     const ref = source.ref;
     const https = require("https");
-    const fs33 = require("fs");
+    const fs35 = require("fs");
     const path42 = require("path");
     function fetchJson(url, timeoutMs) {
       return new Promise((resolve24, reject) => {
@@ -32591,8 +32602,8 @@ ${formatManifestValidationIssues2(validation.issues)}`,
             const relInside = entry.path.startsWith(sharedDirRel + "/") ? entry.path.slice(sharedDirRel.length + 1) : entry.path;
             const outPath = path42.resolve(path42.join(sharedTargetDir, relInside));
             if (!outPath.startsWith(path42.resolve(sharedTargetDir) + path42.sep)) continue;
-            fs33.mkdirSync(path42.dirname(outPath), { recursive: true });
-            fs33.writeFileSync(outPath, body);
+            fs35.mkdirSync(path42.dirname(outPath), { recursive: true });
+            fs35.writeFileSync(outPath, body);
             fetchedCount++;
           } catch (e) {
             errors.push(`fetch shared ${entry.path}: ${e?.message ?? e}`);
@@ -32630,8 +32641,8 @@ ${formatManifestValidationIssues2(validation.issues)}`,
               errors.push(`refusing to write outside targetDir: ${entry.path}`);
               continue;
             }
-            fs33.mkdirSync(path42.dirname(outPath), { recursive: true });
-            fs33.writeFileSync(outPath, body);
+            fs35.mkdirSync(path42.dirname(outPath), { recursive: true });
+            fs35.writeFileSync(outPath, body);
             fetchedCount++;
           } catch (e) {
             errors.push(`fetch ${entry.path}: ${e?.message ?? e}`);
@@ -32659,7 +32670,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     if (!["cli", "ide", "extension", "acp"].includes(category)) {
       return { success: false, error: `unknown category: ${category}` };
     }
-    const fs33 = require("fs");
+    const fs35 = require("fs");
     const path42 = require("path");
     try {
       const installRoot = this.getUpstreamInstallRoot();
@@ -32668,10 +32679,10 @@ ${formatManifestValidationIssues2(validation.issues)}`,
       if (!targetDir.startsWith(installRootResolved + path42.sep)) {
         return { success: false, error: "refusing to delete outside upstream root" };
       }
-      if (!fs33.existsSync(targetDir)) {
+      if (!fs35.existsSync(targetDir)) {
         return { success: false, error: "not installed" };
       }
-      fs33.rmSync(targetDir, { recursive: true, force: true });
+      fs35.rmSync(targetDir, { recursive: true, force: true });
       if (this._ctx.providerLoader) {
         this._ctx.providerLoader.reload();
         this._ctx.providerLoader.registerToDetector();
@@ -32687,28 +32698,28 @@ ${formatManifestValidationIssues2(validation.issues)}`,
    * the UI and by the update checker.
    */
   handleListInstalledProviders(_args) {
-    const fs33 = require("fs");
+    const fs35 = require("fs");
     const path42 = require("path");
     const installRoot = this.getUpstreamInstallRoot();
-    if (!fs33.existsSync(installRoot)) return { success: true, providers: [] };
+    if (!fs35.existsSync(installRoot)) return { success: true, providers: [] };
     const CATEGORIES = ["cli", "ide", "extension", "acp"];
     const items = [];
     for (const category of CATEGORIES) {
       const categoryDir = path42.join(installRoot, category);
-      if (!fs33.existsSync(categoryDir)) continue;
+      if (!fs35.existsSync(categoryDir)) continue;
       let entries;
       try {
-        entries = fs33.readdirSync(categoryDir);
+        entries = fs35.readdirSync(categoryDir);
       } catch {
         continue;
       }
       for (const type of entries) {
         const v1Path = path42.join(categoryDir, type, "provider.v1.json");
         const v0Path = path42.join(categoryDir, type, "provider.json");
-        const manifestPath = fs33.existsSync(v1Path) ? v1Path : fs33.existsSync(v0Path) ? v0Path : null;
+        const manifestPath = fs35.existsSync(v1Path) ? v1Path : fs35.existsSync(v0Path) ? v0Path : null;
         if (!manifestPath) continue;
         try {
-          const m = JSON.parse(fs33.readFileSync(manifestPath, "utf-8"));
+          const m = JSON.parse(fs35.readFileSync(manifestPath, "utf-8"));
           items.push({
             type,
             category,
@@ -32819,7 +32830,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     if (!/^@[a-z0-9_-]+$/i.test(requestedName)) {
       return { success: false, error: "name must match @[a-z0-9_-]+" };
     }
-    const fs33 = require("fs");
+    const fs35 = require("fs");
     const path42 = require("path");
     const { spawnSync: spawnSync2 } = require("child_process");
     const file = ext.loadExternalSources();
@@ -32830,8 +32841,8 @@ ${formatManifestValidationIssues2(validation.issues)}`,
       return { success: false, error: `source url+ref already registered (use a different name to track another ref)` };
     }
     const sourceDir = path42.join(ext.externalRoot(), requestedName);
-    if (!fs33.existsSync(ext.externalRoot())) fs33.mkdirSync(ext.externalRoot(), { recursive: true });
-    if (fs33.existsSync(sourceDir)) {
+    if (!fs35.existsSync(ext.externalRoot())) fs35.mkdirSync(ext.externalRoot(), { recursive: true });
+    if (fs35.existsSync(sourceDir)) {
       return { success: false, error: `directory already exists: ${sourceDir} (rename or remove first)` };
     }
     const clone = spawnSync2("git", ["clone", "--depth=1", "--branch", ref, "--", url, sourceDir], {
@@ -32841,7 +32852,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     });
     if (clone.status !== 0) {
       try {
-        fs33.rmSync(sourceDir, { recursive: true, force: true });
+        fs35.rmSync(sourceDir, { recursive: true, force: true });
       } catch {
       }
       return { success: false, error: `git clone failed: ${(clone.stderr || clone.stdout || "").trim() || "unknown error"}` };
@@ -32885,15 +32896,15 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     const name = typeof args?.name === "string" ? args.name.trim() : "";
     if (!name) return { success: false, error: "name is required" };
     const ext = (init_external_sources(), __toCommonJS(external_sources_exports));
-    const fs33 = require("fs");
+    const fs35 = require("fs");
     const path42 = require("path");
     const file = ext.loadExternalSources();
     const match = file.sources.find((s2) => s2.name === name);
     if (!match) return { success: false, error: `source "${name}" not registered` };
     const sourceDir = path42.join(ext.externalRoot(), name);
-    if (fs33.existsSync(sourceDir)) {
+    if (fs35.existsSync(sourceDir)) {
       try {
-        fs33.rmSync(sourceDir, { recursive: true, force: true });
+        fs35.rmSync(sourceDir, { recursive: true, force: true });
       } catch (e) {
         return { success: false, error: `failed to delete ${sourceDir}: ${e?.message || e}` };
       }
@@ -33674,14 +33685,14 @@ var statusMetaHandlers = {
 // src/commands/low-family/coordinator-prompt.ts
 var coordinatorPromptHandlers = {
   list_coordinator_prompts: async (_ctx, _args) => {
-    const fs33 = await import("fs");
+    const fs35 = await import("fs");
     const path42 = await import("path");
     const os30 = await import("os");
     const dir = path42.join(os30.homedir(), ".adhdev", "coordinator-prompts");
     const entries = {};
     try {
-      if (fs33.existsSync(dir)) {
-        for (const name of fs33.readdirSync(dir)) {
+      if (fs35.existsSync(dir)) {
+        for (const name of fs35.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;
@@ -33691,7 +33702,7 @@ var coordinatorPromptHandlers = {
           const full = path42.join(dir, name);
           let content = "";
           try {
-            content = fs33.readFileSync(full, "utf8");
+            content = fs35.readFileSync(full, "utf8");
           } catch {
           }
           if (!entries[key]) entries[key] = { override: "", append: "" };
@@ -33705,7 +33716,7 @@ var coordinatorPromptHandlers = {
     return { success: true, dir, entries };
   },
   write_coordinator_prompt: async (_ctx, args) => {
-    const fs33 = await import("fs");
+    const fs35 = await import("fs");
     const path42 = await import("path");
     const os30 = await import("os");
     const key = typeof args?.key === "string" ? args.key.trim() : "";
@@ -33718,11 +33729,11 @@ var coordinatorPromptHandlers = {
     const filename = kind === "append" ? `${key}.append.md` : `${key}.md`;
     const full = path42.join(dir, filename);
     try {
-      fs33.mkdirSync(dir, { recursive: true });
+      fs35.mkdirSync(dir, { recursive: true });
       if (content.trim()) {
-        fs33.writeFileSync(full, content, { encoding: "utf8", mode: 384 });
-      } else if (fs33.existsSync(full)) {
-        fs33.unlinkSync(full);
+        fs35.writeFileSync(full, content, { encoding: "utf8", mode: 384 });
+      } else if (fs35.existsSync(full)) {
+        fs35.unlinkSync(full);
       }
       return { success: true, path: full, kind, key };
     } catch (error) {
@@ -41742,7 +41753,17 @@ Run 'adhdev doctor' for detailed diagnostics.`
         continue;
       }
       const restoredSettings = { ...this.providerLoader.getSettings(normalizedType) };
-      const coordinatorEntry = getCoordinatorForSession(record.runtimeId);
+      let coordinatorEntry = getCoordinatorForSession(record.runtimeId);
+      if (!coordinatorEntry?.meshId && record.workspace) {
+        const workspaceCoordinators = listCoordinatorsForWorkspace(record.workspace).filter((e) => e.meshId && (!e.cliType || e.cliType === record.cliType));
+        if (workspaceCoordinators.length === 1) {
+          coordinatorEntry = workspaceCoordinators[0];
+          LOG.info(
+            "CLI",
+            `\u21BB Rebound coordinator mark by workspace for ${record.runtimeKey || record.runtimeId} (mesh ${coordinatorEntry.meshId} @ ${record.workspace}); registry key did not match runtimeId`
+          );
+        }
+      }
       if (coordinatorEntry?.meshId) {
         restoredSettings.meshCoordinatorFor = coordinatorEntry.meshId;
       }
@@ -44653,7 +44674,7 @@ var ProviderLoader = class _ProviderLoader {
     }
     if (providerDir) {
       try {
-        const fs33 = require("fs");
+        const fs35 = require("fs");
         const path42 = require("path");
         const candidates = [];
         if (Array.isArray(base.compatibility)) {
@@ -44665,13 +44686,13 @@ var ProviderLoader = class _ProviderLoader {
         }
         candidates.push(path42.join(providerDir, "specs", "default.json"));
         candidates.push(path42.join(providerDir, "spec.json"));
-        const specPath = candidates.find((p) => fs33.existsSync(p));
+        const specPath = candidates.find((p) => fs35.existsSync(p));
         if (specPath) {
           resolved._resolvedSpecPath = specPath;
           let specControls;
           let nh;
           try {
-            const rawSpec = JSON.parse(fs33.readFileSync(specPath, "utf8"));
+            const rawSpec = JSON.parse(fs35.readFileSync(specPath, "utf8"));
             specControls = rawSpec.control_bar;
             nh = rawSpec.native_history;
           } catch {
@@ -44703,7 +44724,7 @@ var ProviderLoader = class _ProviderLoader {
               reader = (input) => executeNativeHistory(nh, input);
             } else if (nh.override_path) {
               const overrideFile = path42.resolve(providerDir, nh.override_path);
-              if (fs33.existsSync(overrideFile)) {
+              if (fs35.existsSync(overrideFile)) {
                 try {
                   registerProviderScriptRootSafely(path42.dirname(path42.dirname(providerDir)));
                   delete require.cache[require.resolve(overrideFile)];
@@ -45250,8 +45271,8 @@ var ProviderLoader = class _ProviderLoader {
     }
   }
   writeConfig(config) {
-    const { saveConfig: saveConfig3 } = (init_config(), __toCommonJS(config_exports));
-    saveConfig3(config);
+    const { saveConfig: saveConfig2 } = (init_config(), __toCommonJS(config_exports));
+    saveConfig2(config);
   }
   getPlatformVersionCommand(versionCommand) {
     if (!versionCommand) return void 0;
@@ -45888,7 +45909,7 @@ async function detectCurrentWorkspace(ideId) {
     }
   } else if (plat === "win32") {
     try {
-      const fs33 = require("fs");
+      const fs35 = require("fs");
       const appNameMap = getMacAppIdentifiers();
       const appName = appNameMap[ideId];
       if (appName) {
@@ -45897,8 +45918,8 @@ async function detectCurrentWorkspace(ideId) {
           appName,
           "storage.json"
         );
-        if (fs33.existsSync(storagePath)) {
-          const data = JSON.parse(fs33.readFileSync(storagePath, "utf-8"));
+        if (fs35.existsSync(storagePath)) {
+          const data = JSON.parse(fs35.readFileSync(storagePath, "utf-8"));
           const workspaces = data?.openedPathsList?.workspaces3 || data?.openedPathsList?.entries || [];
           if (workspaces.length > 0) {
             const recent = workspaces[0];
@@ -47409,15 +47430,1054 @@ var medFamilyRegistry = new Map(
   })
 );
 
-// src/commands/router.ts
+// src/commands/high-family/mesh-events.ts
+init_mesh_events();
+var meshEventsHandlers = {
+  mesh_forward_event: async (ctx, args) => {
+    return handleMeshForwardEvent({ instanceManager: ctx.deps.instanceManager }, args);
+  },
+  get_pending_mesh_events: async (_ctx, args) => {
+    const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+    const coordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : void 0;
+    const events = drainPendingMeshCoordinatorEvents(meshId || void 0, coordinatorDaemonId);
+    return { success: true, events };
+  },
+  interactive_prompt_response: async (ctx, args) => {
+    const sessionId = typeof args?.targetSessionId === "string" && args.targetSessionId.trim() ? args.targetSessionId.trim() : typeof args?.sessionId === "string" && args.sessionId.trim() ? args.sessionId.trim() : "";
+    if (!sessionId) return { success: false, error: "targetSessionId required" };
+    const response = normalizeInteractivePromptResponse(args?.response ?? args);
+    const instance = ctx.deps.instanceManager.getInstance(sessionId);
+    if (!instance) return { success: false, error: `No running instance for session ${sessionId}` };
+    ctx.deps.instanceManager.sendEvent(sessionId, "interactive_prompt_response", response);
+    return { success: true };
+  }
+};
+
+// src/commands/high-family/mesh-coordinator-launch.ts
+var import_path12 = require("path");
+var fs26 = __toESM(require("fs"));
+init_logger();
+init_mesh_host_ownership();
+init_coordinator_registry();
+init_mesh_coordinator();
+init_dist();
+var meshCoordinatorLaunchHandlers = {
+  launch_mesh_coordinator: async (ctx, args) => {
+    const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+    let cliType = typeof args?.cliType === "string" ? args.cliType.trim() : "";
+    const extraSystemPrompt = typeof args?.extraSystemPrompt === "string" ? args.extraSystemPrompt.trim() : "";
+    if (!meshId) return { success: false, error: "meshId required" };
+    try {
+      const { buildCoordinatorSystemPrompt: buildCoordinatorSystemPrompt2 } = await Promise.resolve().then(() => (init_coordinator_prompt(), coordinator_prompt_exports));
+      const { buildMissionPromptSection: buildMissionPromptSection2 } = await Promise.resolve().then(() => (init_mesh_missions(), mesh_missions_exports));
+      const buildMissionSectionBestEffort = (id) => {
+        try {
+          return buildMissionPromptSection2(id);
+        } catch {
+          return "";
+        }
+      };
+      let mesh;
+      if (args?.inlineMesh && typeof args.inlineMesh === "object") {
+        mesh = args.inlineMesh;
+        ctx.inlineMeshCache.set(meshId, mesh);
+      } else {
+        const { getMesh: getMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+        mesh = getMesh2(meshId);
+      }
+      if (!mesh) return { success: false, error: "Mesh not found" };
+      const meshHost = resolveMeshHostStatus(mesh);
+      if (!meshHost.canOwnCoordinator) {
+        return {
+          success: false,
+          ...buildMeshHostRequiredFailure(mesh, "coordinator launch"),
+          meshId,
+          cliType
+        };
+      }
+      if (!Array.isArray(mesh.nodes) || mesh.nodes.length === 0) return { success: false, error: "No nodes in mesh" };
+      const requestedCoordinatorNodeId = typeof args?.coordinatorNodeId === "string" ? args.coordinatorNodeId.trim() : "";
+      const preferredCoordinatorNodeId = requestedCoordinatorNodeId || (typeof mesh.coordinator?.preferredNodeId === "string" ? mesh.coordinator.preferredNodeId.trim() : "");
+      const coordinatorNode = preferredCoordinatorNodeId ? mesh.nodes.find((node) => node?.id === preferredCoordinatorNodeId || node?.nodeId === preferredCoordinatorNodeId) : mesh.nodes[0];
+      if (!coordinatorNode) {
+        return {
+          success: false,
+          code: "mesh_coordinator_node_not_found",
+          error: `Coordinator node ${preferredCoordinatorNodeId} was not found in mesh`,
+          meshId,
+          cliType
+        };
+      }
+      const sessionHostRecords = ctx.deps.sessionHostControl?.listSessions ? await ctx.deps.sessionHostControl.listSessions().catch(() => []) : [];
+      const liveMeshSessions = partitionSessionHostRecords(Array.isArray(sessionHostRecords) ? sessionHostRecords : []).liveRuntimes;
+      const workspace = readLiveMeshNodeWorkspace({
+        meshId,
+        nodeId: String(normalizeMeshNodeId(coordinatorNode) || preferredCoordinatorNodeId || ""),
+        liveSessionRecords: liveMeshSessions,
+        allowCoordinatorSession: true
+      }) || (typeof coordinatorNode.workspace === "string" ? coordinatorNode.workspace.trim() : "");
+      if (!workspace) return { success: false, error: "Coordinator node workspace required", meshId, cliType };
+      if (!cliType) {
+        const resolved = await resolveProviderTypeFromPriority({
+          nodeId: String(normalizeMeshNodeId(coordinatorNode) || preferredCoordinatorNodeId || "coordinator"),
+          providerPriority: readProviderPriorityFromPolicy(coordinatorNode.policy),
+          providerLoader: ctx.deps.providerLoader,
+          onStatusChange: ctx.deps.onStatusChange
+        });
+        if (!resolved.providerType) {
+          return {
+            success: false,
+            code: "mesh_coordinator_provider_priority_unusable",
+            error: resolved.error || "No usable provider found from node providerPriority",
+            meshId,
+            cliType,
+            workspace
+          };
+        }
+        cliType = resolved.providerType;
+      }
+      const providerMeta = ctx.deps.providerLoader.resolve?.(cliType) || ctx.deps.providerLoader.getMeta(cliType);
+      const coordinatorSetup = resolveMeshCoordinatorSetup({
+        provider: providerMeta,
+        cliType,
+        meshId,
+        workspace
+      });
+      if (coordinatorSetup.kind === "unsupported") {
+        return {
+          success: false,
+          code: "mesh_coordinator_unsupported",
+          error: coordinatorSetup.reason,
+          meshId,
+          cliType,
+          workspace
+        };
+      }
+      if (coordinatorSetup.kind === "manual") {
+        return {
+          success: false,
+          code: "mesh_coordinator_manual_mcp_setup_required",
+          error: coordinatorSetup.instructions,
+          meshId,
+          cliType,
+          workspace,
+          meshCoordinatorSetup: coordinatorSetup
+        };
+      }
+      if (coordinatorSetup.kind === "cli_command") {
+        let cliCmdSystemPrompt = "";
+        try {
+          cliCmdSystemPrompt = buildCoordinatorSystemPrompt2({ mesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || void 0, missionSection: buildMissionSectionBestEffort(mesh.id) });
+        } catch (error) {
+          const message = error?.message || String(error);
+          LOG.error("MeshCoordinator", `Failed to build coordinator prompt: ${message}`);
+          return {
+            success: false,
+            code: "mesh_coordinator_prompt_failed",
+            error: `Failed to build Repo Mesh coordinator prompt: ${message}`,
+            meshId,
+            cliType,
+            workspace
+          };
+        }
+        let mcpRegistrationOk = false;
+        let mcpRegistrationFailure = null;
+        try {
+          const { buildMeshCoordinatorRegistrationPlan: buildMeshCoordinatorRegistrationPlan2, execUnderPty: execUnderPty2 } = await Promise.resolve().then(() => (init_mesh_coordinator(), mesh_coordinator_exports));
+          const registrationPlan = buildMeshCoordinatorRegistrationPlan2(
+            cliType,
+            coordinatorSetup.serverName,
+            coordinatorSetup.command
+          );
+          for (const step of registrationPlan) {
+            const renderedCommand = [step.command, ...step.args].join(" ");
+            LOG.info("MeshCoordinator", `Running MCP ${step.label} (pty): ${renderedCommand}`);
+            const ptyResult = await execUnderPty2(step.command, step.args, { cwd: workspace, timeoutMs: 2e4 });
+            if (ptyResult.exitCode === 0 && !ptyResult.timedOut) {
+              if (step.required) mcpRegistrationOk = true;
+              continue;
+            }
+            LOG.warn("MeshCoordinator", `MCP ${step.label} failed exit=${ptyResult.exitCode} signal=${ptyResult.signal} timedOut=${ptyResult.timedOut} \u2014 output:
+${ptyResult.output.slice(-2e3)}`);
+            if (step.required) {
+              mcpRegistrationFailure = {
+                command: renderedCommand,
+                output: ptyResult.output.slice(-2e3),
+                exitCode: ptyResult.exitCode,
+                signal: ptyResult.signal,
+                timedOut: ptyResult.timedOut
+              };
+              break;
+            }
+          }
+        } catch (error) {
+          LOG.warn("MeshCoordinator", `MCP registration command failed: ${error?.message || error}`);
+          mcpRegistrationFailure = {
+            command: coordinatorSetup.command,
+            output: error?.message || String(error),
+            exitCode: null,
+            signal: null,
+            timedOut: false
+          };
+        }
+        if (!mcpRegistrationOk) {
+          return {
+            success: false,
+            code: "mesh_coordinator_mcp_registration_failed",
+            error: `Could not register ${coordinatorSetup.serverName}; coordinator session was not launched`,
+            meshId,
+            cliType,
+            workspace,
+            registration: mcpRegistrationFailure
+          };
+        }
+        if (cliType === "codex-cli") {
+          const repoMcpConfigPath = (0, import_path12.join)(workspace, ".mcp.json");
+          if (fs26.existsSync(repoMcpConfigPath)) {
+            try {
+              const repoMcpConfig = parseMeshCoordinatorMcpConfig(
+                fs26.readFileSync(repoMcpConfigPath, "utf-8"),
+                "claude_mcp_json"
+              );
+              const existingServers2 = repoMcpConfig.mcpServers;
+              if (existingServers2 && typeof existingServers2 === "object" && !Array.isArray(existingServers2) && existingServers2[coordinatorSetup.serverName]) {
+                fs26.writeFileSync(repoMcpConfigPath, serializeMeshCoordinatorMcpConfig({
+                  ...repoMcpConfig,
+                  mcpServers: {
+                    ...existingServers2,
+                    [coordinatorSetup.serverName]: coordinatorSetup.mcpServer
+                  }
+                }, "claude_mcp_json"), "utf-8");
+                LOG.info("MeshCoordinator", `Refreshed repo-local ${repoMcpConfigPath} entry for ${coordinatorSetup.serverName}`);
+              }
+            } catch (error) {
+              return {
+                success: false,
+                code: "mesh_coordinator_config_write_failed",
+                error: `Could not refresh repo-local MCP config: ${error?.message || error}`,
+                meshId,
+                cliType,
+                workspace
+              };
+            }
+          }
+        }
+        const cliCmdArgs = [];
+        const cliCmdEnv = {};
+        let cliCmdContextFilePath;
+        if (cliCmdSystemPrompt) {
+          const { applyMeshCoordinatorSystemPromptInjection: applyMeshCoordinatorSystemPromptInjection2 } = await Promise.resolve().then(() => (init_mesh_coordinator(), mesh_coordinator_exports));
+          const effect = applyMeshCoordinatorSystemPromptInjection2(
+            cliCmdSystemPrompt,
+            providerMeta?.meshCoordinator?.systemPromptInjection,
+            { cliArgs: cliCmdArgs, launchEnv: cliCmdEnv, workspace, cliType }
+          );
+          cliCmdContextFilePath = effect.contextFilePath;
+        }
+        const cliCmdLaunch = await ctx.deps.cliManager.handleCliCommand("launch_cli", {
+          cliType,
+          dir: workspace,
+          cliArgs: cliCmdArgs.length > 0 ? cliCmdArgs : void 0,
+          env: Object.keys(cliCmdEnv).length > 0 ? cliCmdEnv : void 0,
+          settings: { meshCoordinatorFor: meshId }
+        });
+        if (cliCmdLaunch?.success && cliCmdContextFilePath) {
+          const stripPath = cliCmdContextFilePath;
+          setTimeout(() => {
+            void Promise.resolve().then(() => (init_mesh_coordinator(), mesh_coordinator_exports)).then(({ stripCoordinatorWrapperFile: stripCoordinatorWrapperFile2 }) => {
+              stripCoordinatorWrapperFile2(stripPath);
+              LOG.info("MeshCoordinator", `Stripped wrapper from ${stripPath} after launch settle (cli_command)`);
+            }).catch(() => {
+            });
+          }, 5e3);
+        }
+        if (!cliCmdLaunch?.success) {
+          return { success: false, error: cliCmdLaunch?.error || "Failed to launch CLI session" };
+        }
+        LOG.info("MeshCoordinator", `Launched ${cliType} coordinator (cli_command) for mesh ${meshId}`);
+        const cliCmdSessionId = cliCmdLaunch.sessionId || cliCmdLaunch.id;
+        if (cliCmdSessionId) {
+          const cliCmdInjectionDecl = providerMeta?.meshCoordinator?.systemPromptInjection;
+          registerMeshCoordinator({
+            meshId,
+            sessionId: cliCmdSessionId,
+            workspace,
+            startedAt: Date.now(),
+            cliType,
+            systemPrompt: cliCmdSystemPrompt || void 0,
+            extraSystemPrompt: extraSystemPrompt || void 0,
+            injection: cliCmdInjectionDecl ? {
+              mode: cliCmdInjectionDecl.mode,
+              target: "flag" in cliCmdInjectionDecl ? cliCmdInjectionDecl.flag : "name" in cliCmdInjectionDecl ? cliCmdInjectionDecl.name : "path" in cliCmdInjectionDecl ? cliCmdInjectionDecl.path : void 0
+            } : void 0
+          });
+        }
+        try {
+          const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+          appendLedgerEntry2(meshId, {
+            kind: "coordinator_started",
+            sessionId: cliCmdSessionId,
+            providerType: cliType,
+            payload: { workspace }
+          });
+        } catch {
+        }
+        return {
+          success: true,
+          meshId,
+          cliType,
+          workspace,
+          sessionId: cliCmdSessionId,
+          mcpRegistered: mcpRegistrationOk
+        };
+      }
+      const configFormat = coordinatorSetup.configFormat;
+      if (configFormat !== "claude_mcp_json" && configFormat !== "hermes_config_yaml") {
+        return {
+          success: false,
+          code: "mesh_coordinator_unsupported",
+          error: `Unsupported auto-import MCP config format: ${String(coordinatorSetup.configFormat)}`,
+          meshId,
+          cliType,
+          workspace
+        };
+      }
+      let systemPrompt = "";
+      try {
+        systemPrompt = buildCoordinatorSystemPrompt2({ mesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || void 0, missionSection: buildMissionSectionBestEffort(mesh.id) });
+      } catch (error) {
+        const message = error?.message || String(error);
+        LOG.error("MeshCoordinator", `Failed to build coordinator prompt: ${message}`);
+        return {
+          success: false,
+          code: "mesh_coordinator_prompt_failed",
+          error: `Failed to build Repo Mesh coordinator prompt: ${message}`,
+          meshId,
+          cliType,
+          workspace
+        };
+      }
+      const { existsSync: existsSync49, readFileSync: readFileSync39, writeFileSync: writeFileSync24, copyFileSync: copyFileSync4, mkdirSync: mkdirSync21 } = await import("fs");
+      const { dirname: dirname17 } = await import("path");
+      const mcpConfigPath = coordinatorSetup.configPath;
+      const hermesManualFallback = cliType === "hermes-cli" && configFormat === "hermes_config_yaml" ? createHermesManualMeshCoordinatorSetup(meshId, workspace) : null;
+      let hermesBaseConfig = null;
+      if (hermesManualFallback) {
+        try {
+          hermesBaseConfig = loadHermesCoordinatorBaseConfig(mcpConfigPath);
+        } catch (error) {
+          const message = `Failed to parse Hermes base config for automatic coordinator setup: ${error?.message || error}`;
+          LOG.error("MeshCoordinator", message);
+          return { success: false, code: "mesh_coordinator_config_parse_failed", error: message, meshId, cliType, workspace };
+        }
+      }
+      const returnManualFallback = (message) => ({
+        success: false,
+        code: "mesh_coordinator_manual_mcp_setup_required",
+        error: message,
+        meshId,
+        cliType,
+        workspace,
+        meshCoordinatorSetup: hermesManualFallback
+      });
+      const mcpServerEntry = {
+        command: coordinatorSetup.mcpServer.command,
+        args: coordinatorSetup.mcpServer.args
+      };
+      if (args?.inlineMesh) {
+        const modeArgIndex = coordinatorSetup.mcpServer.args.findIndex((value) => value === "--mode");
+        const mcpTransport = modeArgIndex >= 0 ? coordinatorSetup.mcpServer.args[modeArgIndex + 1] : "ipc";
+        mcpServerEntry.env = {
+          ADHDEV_INLINE_MESH: JSON.stringify(mesh),
+          ADHDEV_MCP_TRANSPORT: mcpTransport === "local" ? "local" : "ipc"
+        };
+      }
+      try {
+        mkdirSync21(dirname17(mcpConfigPath), { recursive: true });
+      } catch (error) {
+        const message = `Could not prepare MCP config path for automatic setup: ${error?.message || error}`;
+        LOG.error("MeshCoordinator", message);
+        if (hermesManualFallback) return returnManualFallback(message);
+        return { success: false, code: "mesh_coordinator_config_write_failed", error: message, meshId, cliType, workspace };
+      }
+      const hadExistingMcpConfig = existsSync49(mcpConfigPath);
+      let existingMcpConfig = hermesBaseConfig?.config || {};
+      if (hermesBaseConfig) {
+        copyHermesCoordinatorCredentialFiles(hermesBaseConfig.sourceHome, dirname17(mcpConfigPath));
+      }
+      if (hadExistingMcpConfig) {
+        try {
+          const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync39(mcpConfigPath, "utf-8"), configFormat);
+          const existingCoordinatorConfig = hermesManualFallback ? stripHermesCoordinatorTempModelProviderOverrides(parsedExistingMcpConfig) : parsedExistingMcpConfig;
+          existingMcpConfig = { ...existingMcpConfig, ...existingCoordinatorConfig };
+          copyFileSync4(mcpConfigPath, mcpConfigPath + ".backup");
+        } catch (error) {
+          LOG.error("MeshCoordinator", `Failed to parse existing MCP config ${mcpConfigPath}: ${error?.message || error}`);
+          return {
+            success: false,
+            code: "mesh_coordinator_config_parse_failed",
+            error: `Failed to parse existing MCP config at ${mcpConfigPath}`
+          };
+        }
+      }
+      const mcpServersKey = getMcpServersKey(configFormat);
+      const existingServers = existingMcpConfig[mcpServersKey];
+      const mcpConfig = {
+        ...existingMcpConfig,
+        [mcpServersKey]: {
+          ...existingServers && typeof existingServers === "object" && !Array.isArray(existingServers) ? existingServers : {},
+          [coordinatorSetup.serverName]: mcpServerEntry
+        }
+      };
+      try {
+        writeFileSync24(mcpConfigPath, serializeMeshCoordinatorMcpConfig(mcpConfig, configFormat), "utf-8");
+      } catch (error) {
+        const message = `Could not write MCP config for automatic setup: ${error?.message || error}`;
+        LOG.error("MeshCoordinator", message);
+        if (hermesManualFallback) return returnManualFallback(message);
+        return { success: false, code: "mesh_coordinator_config_write_failed", error: message, meshId, cliType, workspace };
+      }
+      LOG.info("MeshCoordinator", `Wrote ${mcpConfigPath} with ${coordinatorSetup.serverName} server`);
+      const cliArgs = [];
+      const launchEnv = {};
+      if (configFormat === "hermes_config_yaml") {
+        launchEnv.HERMES_HOME = dirname17(mcpConfigPath);
+        launchEnv.HERMES_IGNORE_USER_CONFIG = "";
+      }
+      let autoImportContextFilePath;
+      if (systemPrompt) {
+        const { applyMeshCoordinatorSystemPromptInjection: applyMeshCoordinatorSystemPromptInjection2 } = await Promise.resolve().then(() => (init_mesh_coordinator(), mesh_coordinator_exports));
+        const effect = applyMeshCoordinatorSystemPromptInjection2(
+          systemPrompt,
+          providerMeta?.meshCoordinator?.systemPromptInjection,
+          { cliArgs, launchEnv, workspace, cliType }
+        );
+        autoImportContextFilePath = effect.contextFilePath;
+      }
+      if (cliType === "claude-cli") {
+        cliArgs.push("--mcp-config", coordinatorSetup.configPath);
+      }
+      const launchResult = await ctx.deps.cliManager.handleCliCommand("launch_cli", {
+        cliType,
+        dir: workspace,
+        cliArgs: cliArgs.length > 0 ? cliArgs : void 0,
+        env: Object.keys(launchEnv).length > 0 ? launchEnv : void 0,
+        settings: {
+          meshCoordinatorFor: meshId
+        }
+      });
+      if (launchResult?.success && autoImportContextFilePath) {
+        const stripPath = autoImportContextFilePath;
+        setTimeout(() => {
+          void Promise.resolve().then(() => (init_mesh_coordinator(), mesh_coordinator_exports)).then(({ stripCoordinatorWrapperFile: stripCoordinatorWrapperFile2 }) => {
+            stripCoordinatorWrapperFile2(stripPath);
+            LOG.info("MeshCoordinator", `Stripped wrapper from ${stripPath} after launch settle (auto_import)`);
+          }).catch(() => {
+          });
+        }, 5e3);
+      }
+      if (!launchResult?.success) {
+        return { success: false, error: launchResult?.error || "Failed to launch CLI session" };
+      }
+      LOG.info("MeshCoordinator", `Launched ${cliType} coordinator for mesh ${meshId} in ${workspace}`);
+      const launchSessionId = launchResult.sessionId || launchResult.id;
+      if (launchSessionId) {
+        const autoImportInjectionDecl = providerMeta?.meshCoordinator?.systemPromptInjection;
+        registerMeshCoordinator({
+          meshId,
+          sessionId: launchSessionId,
+          workspace,
+          startedAt: Date.now(),
+          cliType,
+          systemPrompt: systemPrompt || void 0,
+          extraSystemPrompt: extraSystemPrompt || void 0,
+          mcpConfigPath,
+          injection: autoImportInjectionDecl ? {
+            mode: autoImportInjectionDecl.mode,
+            target: "flag" in autoImportInjectionDecl ? autoImportInjectionDecl.flag : "name" in autoImportInjectionDecl ? autoImportInjectionDecl.name : "path" in autoImportInjectionDecl ? autoImportInjectionDecl.path : void 0
+          } : void 0
+        });
+      }
+      try {
+        const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+        appendLedgerEntry2(meshId, {
+          kind: "coordinator_started",
+          sessionId: launchSessionId,
+          providerType: cliType,
+          payload: { workspace }
+        });
+      } catch {
+      }
+      return {
+        success: true,
+        meshId,
+        cliType,
+        workspace,
+        sessionId: launchSessionId,
+        mcpConfigWritten: true
+      };
+    } catch (e) {
+      LOG.error("MeshCoordinator", `Failed: ${e.message}`);
+      return { success: false, error: e.message };
+    }
+  }
+};
+
+// src/commands/high-family/mesh-status.ts
+var fs27 = __toESM(require("fs"));
+var import_os3 = require("os");
 init_config();
+init_git_status();
+init_dist();
+init_mesh_events();
+init_mesh_routing();
+init_mesh_host_ownership();
+
+// src/mesh/preview-freshness.ts
+var import_node_child_process4 = require("child_process");
+var import_node_fs4 = require("fs");
+var import_node_path2 = require("path");
+var PREVIEW_DEPLOY_RECORD = ".adhdev/preview-deploy.json";
+function runGit2(repoRoot, args) {
+  try {
+    return (0, import_node_child_process4.execFileSync)("git", args, {
+      cwd: repoRoot,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 5e3
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+function readRecord5(repoRoot) {
+  const path42 = (0, import_node_path2.resolve)(repoRoot, PREVIEW_DEPLOY_RECORD);
+  if (!(0, import_node_fs4.existsSync)(path42)) return null;
+  try {
+    const parsed = JSON.parse((0, import_node_fs4.readFileSync)(path42, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function normalizeCommit(value) {
+  return typeof value === "string" && /^[0-9a-f]{7,40}$/i.test(value.trim()) ? value.trim() : null;
+}
+function readTargetFreshness(record, currentCommit) {
+  const targets = record?.targets && typeof record.targets === "object" && !Array.isArray(record.targets) ? record.targets : {};
+  const result = {};
+  for (const targetName of ["npm", "server", "web"]) {
+    const targetRecord = targets[targetName] && typeof targets[targetName] === "object" && !Array.isArray(targets[targetName]) ? targets[targetName] : {};
+    const commit = normalizeCommit(targetRecord.commit);
+    result[targetName] = {
+      commit,
+      deployedAt: typeof targetRecord.deployedAt === "string" ? targetRecord.deployedAt : void 0,
+      status: commit && currentCommit ? commit === currentCommit ? "fresh" : "stale" : "unknown"
+    };
+  }
+  return result;
+}
+function readCurrentMainCommit(repoRoot) {
+  const originMain = runGit2(repoRoot, ["rev-parse", "--verify", "origin/main^{commit}"]);
+  if (originMain) {
+    return { currentMainCommit: originMain, currentMainCommitSource: "origin/main" };
+  }
+  const head = runGit2(repoRoot, ["rev-parse", "--verify", "HEAD"]);
+  if (head) {
+    return { currentMainCommit: head, currentMainCommitSource: "HEAD" };
+  }
+  return { currentMainCommit: null, currentMainCommitSource: "unknown" };
+}
+function buildPreviewFreshness(repoRoot) {
+  const current = readCurrentMainCommit(repoRoot);
+  const record = readRecord5(repoRoot);
+  const lastPreviewCommit = normalizeCommit(record?.lastPreviewCommit);
+  const targets = readTargetFreshness(record, current.currentMainCommit);
+  let status = "unknown";
+  let nextAction = "Run npm run deploy:preview from the current main commit, then smoke preview.";
+  if (lastPreviewCommit && current.currentMainCommit) {
+    status = lastPreviewCommit === current.currentMainCommit ? "fresh" : "stale";
+    nextAction = status === "fresh" ? "No preview deploy action needed." : "Run npm run deploy:preview from origin/main, then smoke preview.";
+  } else if (!current.currentMainCommit) {
+    nextAction = "Resolve the current main commit before judging preview freshness.";
+  }
+  return {
+    status,
+    lastPreviewCommit,
+    currentMainCommit: current.currentMainCommit,
+    currentMainCommitSource: current.currentMainCommitSource,
+    recordPath: PREVIEW_DEPLOY_RECORD,
+    lastDeployedAt: typeof record?.updatedAt === "string" ? record.updatedAt : void 0,
+    lastTarget: typeof record?.target === "string" ? record.target : void 0,
+    previewVersion: typeof record?.previewVersion === "string" ? record.previewVersion : void 0,
+    targets,
+    nextAction
+  };
+}
+
+// src/commands/high-family/mesh-status.ts
+init_mesh_refine_status();
+var meshStatusHandlers = {
+  mesh_status: async (ctx, args) => {
+    const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+    if (!meshId) return { success: false, error: "meshId required" };
+    try {
+      const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+      const mesh = meshRecord?.mesh;
+      if (!mesh) return { success: false, error: "Mesh not found" };
+      const meshHost = resolveMeshHostStatus(mesh);
+      const refreshRequested = args?.refresh === true || args?.forceRefresh === true;
+      const verboseMissions = args?.verbose === true || args?.compact === false;
+      const peekScope = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : ctx.deps.statusInstanceId || void 0;
+      const pendingCoordinatorEventCount = getPendingMeshCoordinatorEvents(meshId, peekScope).length;
+      const hadAggregateCache = ctx.aggregateMeshStatusCache.has(meshId);
+      if (!refreshRequested && !verboseMissions && pendingCoordinatorEventCount === 0) {
+        const cachedStatus = ctx.getCachedAggregateMeshStatus(meshId, mesh, { requireDirectPeerTruth: args?.requireDirectPeerTruth === true });
+        if (cachedStatus) {
+          logRepoMeshStatusDebug("return_cached", {
+            meshId,
+            command: "mesh_status",
+            refreshRequested,
+            summary: summarizeRepoMeshStatusDebug(cachedStatus)
+          });
+          return cachedStatus;
+        }
+      }
+      const refreshReason = refreshRequested ? "explicit_refresh" : pendingCoordinatorEventCount > 0 ? "pending_coordinator_events" : hadAggregateCache ? "stale_pending_cache_refresh" : "cold_cache_miss";
+      const { getMeshQueueStats: getMeshQueueStats2, getQueue: getQueue2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
+      const queue = getQueue2(meshId);
+      const queueSummary = getMeshQueueStats2(meshId);
+      const { readLedgerEntries: readLedgerEntries2, getLedgerSummary: getLedgerSummary2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+      const ledgerEntries = readLedgerEntries2(meshId, { tail: 20 });
+      const asyncRefineLedgerEntries = readLedgerEntries2(meshId, { tail: 100 });
+      const ledgerSummary = getLedgerSummary2(meshId);
+      const sessionHostRecords = ctx.deps.sessionHostControl?.listSessions ? await ctx.deps.sessionHostControl.listSessions().catch(() => []) : [];
+      const liveMeshSessions = partitionSessionHostRecords(Array.isArray(sessionHostRecords) ? sessionHostRecords : []).liveRuntimes;
+      const localMachineId = loadConfig().machineId || "";
+      const requireDirectPeerTruth = args?.requireDirectPeerTruth === true;
+      const meshGitProbeCache = ctx.meshGitProbeCache;
+      const directTruth = requireDirectPeerTruth ? await hydrateInlineMeshDirectTruth({
+        mesh,
+        meshSource: meshRecord.source,
+        dispatchMeshCommand: ctx.deps.dispatchMeshCommand,
+        getMeshPeerConnectionStatus: ctx.deps.getMeshPeerConnectionStatus,
+        statusInstanceId: ctx.deps.statusInstanceId,
+        localMachineId,
+        // 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,
+        probeCache: meshGitProbeCache
+      }) : {
+        directEvidenceCount: 0,
+        localConfirmedCount: 0,
+        peerAttemptedCount: 0,
+        peerConfirmedCount: 0,
+        standingEvidenceCount: 0,
+        unavailableNodeIds: [],
+        deadNodeIds: []
+      };
+      const passivePeerTruthNotAttempted = requireDirectPeerTruth && !refreshRequested && directTruth.directEvidenceCount > 0 && directTruth.peerAttemptedCount === 0;
+      const effectiveDirectTruth = passivePeerTruthNotAttempted ? { ...directTruth, unavailableNodeIds: [] } : directTruth;
+      const unavailableDirectTruthNodeIds = new Set(effectiveDirectTruth.unavailableNodeIds);
+      const unavailableNodesAreOnlyRemovedWorktrees = unavailableDirectTruthNodeIds.size > 0 && Array.isArray(mesh.nodes) && mesh.nodes.filter((node) => unavailableDirectTruthNodeIds.has(normalizeMeshNodeId(node) ?? "")).every((node) => node?.isLocalWorktree === true);
+      const directTruthSatisfied = !requireDirectPeerTruth || !refreshRequested || effectiveDirectTruth.directEvidenceCount > 0 && (effectiveDirectTruth.unavailableNodeIds.length === 0 || unavailableNodesAreOnlyRemovedWorktrees);
+      if (requireDirectPeerTruth && refreshRequested && !directTruthSatisfied) {
+        const failureResult = {
+          success: false,
+          code: "mesh_direct_peer_truth_unavailable",
+          error: "Selected coordinator could not confirm direct mesh truth yet. Bootstrap inventory stays unavailable until direct mesh_status probes succeed.",
+          sourceOfTruth: {
+            membership: meshRecord.source === "inline_cache" ? "coordinator_inline_mesh_cache" : meshRecord.source === "local_config" ? "local_mesh_config" : "inline_bootstrap_snapshot",
+            coordinatorOwnsLiveTruth: false,
+            currentStatus: "direct_peer_truth_unavailable",
+            directPeerTruth: {
+              required: true,
+              satisfied: false,
+              directEvidenceCount: directTruth.directEvidenceCount,
+              localConfirmedCount: directTruth.localConfirmedCount,
+              peerAttemptedCount: directTruth.peerAttemptedCount,
+              peerConfirmedCount: directTruth.peerConfirmedCount,
+              unavailableNodeIds: directTruth.unavailableNodeIds
+            }
+          }
+        };
+        logRepoMeshStatusDebug("direct_truth_unavailable", {
+          meshId,
+          command: "mesh_status",
+          refreshRequested,
+          meshSource: meshRecord.source,
+          directTruth
+        });
+        return failureResult;
+      }
+      const directTruthUnavailableNodeIds = new Set(effectiveDirectTruth.unavailableNodeIds);
+      const coordinatorHostname = (0, import_os3.hostname)();
+      const selectedCoordinatorNodeId = readStringValue(
+        mesh.coordinator?.preferredNodeId,
+        normalizeMeshNodeId(mesh.nodes?.[0])
+      );
+      const inlineCoordinatorNodeId = meshRecord?.inline && Array.isArray(mesh.nodes) ? selectedCoordinatorNodeId : void 0;
+      const refreshedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const nodeStatuses = [];
+      for (const [nodeIndex, node] of (mesh.nodes || []).entries()) {
+        const nodeId = normalizeMeshNodeId(node) ?? "";
+        const daemonId = readStringValue(node.daemonId);
+        const nodeMachineId = readMeshNodeMachineId(node);
+        const nodeHostname = readMeshNodeHostname(node);
+        const providerPriority = readProviderPriorityFromPolicy(node.policy);
+        const configuredCoordinatorNode = Boolean(
+          nodeId && selectedCoordinatorNodeId && nodeId === selectedCoordinatorNodeId
+        );
+        const sparseConfiguredCoordinatorNode = configuredCoordinatorNode && !daemonId && !nodeMachineId && !nodeHostname;
+        const isSelfNode = Boolean(
+          nodeId && inlineCoordinatorNodeId && nodeId === inlineCoordinatorNodeId
+        ) || Boolean(
+          daemonId && (daemonIdsEquivalent(daemonId, localMachineId) || daemonIdsEquivalent(daemonId, ctx.deps.statusInstanceId))
+        ) || Boolean(meshRecord?.inline && nodeIndex === 0) || sparseConfiguredCoordinatorNode;
+        const machineIdentity = buildMeshNodeMachineIdentity(node, {
+          localMachineId,
+          localDaemonId: ctx.deps.statusInstanceId,
+          coordinatorHostname,
+          isSelfNode
+        });
+        const status = {
+          nodeId,
+          machineLabel: buildMeshNodeDisplayLabel(node, nodeId, providerPriority),
+          labelSource: readStringValue(node.machineLabel, node.machine_label, node.machineNickname, node.machine_nickname, node.alias) ? "explicit_metadata" : "workspace_host_provider_context",
+          workspace: node.workspace,
+          repoRoot: node.repoRoot,
+          isLocalWorktree: node.isLocalWorktree,
+          worktreeBranch: node.worktreeBranch,
+          role: normalizeMeshDaemonRole(node.role) || (meshHost.hostNodeId && nodeId === meshHost.hostNodeId ? "host" : void 0),
+          daemonId,
+          machineId: nodeMachineId || node.machineId,
+          machine: machineIdentity,
+          machineStatus: node.machineStatus,
+          health: "unknown",
+          providers: node.providers || [],
+          providerPriority,
+          activeSessions: [],
+          activeSessionDetails: [],
+          launchReady: false
+        };
+        if (isSelfNode) {
+          status.connection = {
+            perspective: "selected_coordinator",
+            source: "mesh_peer_status",
+            state: "self",
+            transport: "local",
+            reported: true,
+            reason: "Selected coordinator daemon",
+            lastStateChangeAt: refreshedAt
+          };
+        } else if (daemonId) {
+          const connection = ctx.deps.getMeshPeerConnectionStatus?.(daemonId);
+          status.connection = connection ?? {
+            perspective: "selected_coordinator",
+            source: "not_reported",
+            state: "unknown",
+            transport: "unknown",
+            reported: false,
+            reason: "No live mesh peer telemetry reported by the selected coordinator yet."
+          };
+        } else {
+          status.connection = {
+            perspective: "selected_coordinator",
+            source: "not_reported",
+            state: "unknown",
+            transport: "unknown",
+            reported: false,
+            reason: "Node has no daemon id, so mesh transport cannot be reported from the selected coordinator."
+          };
+        }
+        const matchedLiveSessionRecords = collectLiveMeshSessionRecords({
+          meshId,
+          node,
+          nodeId,
+          liveSessionRecords: liveMeshSessions,
+          allowCoordinatorSession: nodeId === selectedCoordinatorNodeId
+        });
+        const workspace = readLiveMeshNodeWorkspace({
+          meshId,
+          nodeId,
+          liveSessionRecords: matchedLiveSessionRecords,
+          allowCoordinatorSession: nodeId === selectedCoordinatorNodeId
+        }) || (typeof node.workspace === "string" ? node.workspace : "");
+        status.workspace = workspace || node.workspace;
+        if (matchedLiveSessionRecords.length > 0) {
+          const sessionIds = matchedLiveSessionRecords.map((record) => typeof record?.sessionId === "string" ? record.sessionId : "").filter(Boolean);
+          const providerTypes = matchedLiveSessionRecords.map((record) => readStringValue(record?.providerType)).filter(Boolean);
+          status.activeSessions = sessionIds;
+          status.activeSessionDetails = matchedLiveSessionRecords.map(summarizeMeshSessionRecord);
+          if (providerTypes.length > 0) {
+            status.providers = Array.from(/* @__PURE__ */ new Set([...Array.isArray(status.providers) ? status.providers : [], ...providerTypes]));
+          }
+        }
+        if (workspace) {
+          if (!fs27.existsSync(workspace)) {
+            const inlineTransitGit = buildInlineMeshTransitGitStatus(node);
+            let remoteProbeApplied = false;
+            if (inlineTransitGit) {
+              status.git = inlineTransitGit;
+              status.health = inlineTransitGit.isGitRepo ? deriveMeshNodeHealthFromGit(inlineTransitGit) : "degraded";
+              const connection = readObjectRecord(status.connection);
+              const connectionState = readStringValue(connection.state);
+              const connectionReported = readBooleanValue(connection.reported) ?? false;
+              if (!connectionReported || connectionState === "unknown") {
+                status.connection = buildLivePeerGitConnection(connection, refreshedAt);
+              }
+              remoteProbeApplied = true;
+            } else if (refreshRequested && !isSelfNode && daemonId && ctx.deps.dispatchMeshCommand && !directTruthUnavailableNodeIds.has(nodeId)) {
+              const runNodeProbe = () => probeRemoteMeshGitStatusWithRetry({
+                dispatchMeshCommand: ctx.deps.dispatchMeshCommand,
+                daemonId,
+                workspace,
+                timeoutMs: MESH_DIRECT_PROBE_TIMEOUT_MS,
+                retryTimeoutMs: MESH_DIRECT_PROBE_RETRY_TIMEOUT_MS,
+                getConnection: ctx.deps.getMeshPeerConnectionStatus,
+                onConnection: (connection) => {
+                  status.connection = connection;
+                }
+              });
+              const remoteGit = await meshGitProbeCache.probe(daemonId, workspace, runNodeProbe);
+              if (remoteGit) {
+                status.git = remoteGit;
+                status.health = remoteGit.isGitRepo ? deriveMeshNodeHealthFromGit(remoteGit) : "degraded";
+                const connection = readObjectRecord(status.connection);
+                const connectionState = readStringValue(connection.state);
+                const connectionReported = readBooleanValue(connection.reported) ?? false;
+                if (!connectionReported || connectionState === "unknown") {
+                  status.connection = buildLivePeerGitConnection(connection, refreshedAt);
+                }
+                const reporter = recordInlineMeshDirectGitTruth(node, remoteGit, "selected_coordinator_mesh_p2p_git");
+                persistNodeReporterPlatform(meshRecord.source, mesh, nodeId, reporter);
+                remoteProbeApplied = true;
+              }
+            }
+            if (!remoteProbeApplied) {
+              const connectionState = readStringValue(status.connection?.state);
+              const pendingPeerGitProbe = !inlineTransitGit && !isSelfNode && !!daemonId && (readStringValue(status.machineStatus) === "online" || readStringValue(status.health) === "online" || connectionState === "connecting" || connectionState === "connected" || connectionState === "unknown");
+              if (pendingPeerGitProbe) {
+                status.gitProbePending = true;
+                status.health = "unknown";
+              }
+              if (applyCachedInlineMeshNodeStatus(
+                status,
+                node,
+                pendingPeerGitProbe ? { skipGit: true, skipError: true, skipHealth: true } : void 0
+              )) {
+                applyInlineMeshBranchConvergence(mesh, node, status);
+                finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode });
+                nodeStatuses.push(status);
+                continue;
+              }
+              if (meshRecord?.source === "inline_cache" && !isSelfNode) {
+                applyInlineMeshBranchConvergence(mesh, node, status);
+                finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode });
+                nodeStatuses.push(status);
+                continue;
+              }
+            }
+          } else {
+            try {
+              const gitStatus = await getGitRepoStatus(workspace, { timeoutMs: 1e4, refreshUpstream: true });
+              status.git = gitStatus;
+              const reporter = recordInlineMeshDirectGitTruth(node, gitStatus, "selected_coordinator_local_git");
+              persistNodeReporterPlatform(meshRecord.source, mesh, nodeId, reporter);
+              if (gitStatus.isGitRepo) {
+                status.health = deriveMeshNodeHealthFromGit(gitStatus);
+              } else {
+                status.health = "degraded";
+                if (gitStatus.error && !status.error) status.error = gitStatus.error;
+              }
+            } catch {
+              if (!applyCachedInlineMeshNodeStatus(status, node)) {
+                status.health = "degraded";
+              }
+            }
+          }
+        } else {
+          applyCachedInlineMeshNodeStatus(status, node);
+        }
+        applyInlineMeshBranchConvergence(mesh, node, status);
+        finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode });
+        nodeStatuses.push(status);
+      }
+      const callerCoordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : ctx.deps.statusInstanceId || void 0;
+      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 && fs27.existsSync(candidate));
+        return localRepoRoot ? buildPreviewFreshness(localRepoRoot) : void 0;
+      })();
+      const asyncRefineJobs = buildMeshAsyncRefineJobs({
+        meshId,
+        ledgerEntries: asyncRefineLedgerEntries,
+        pendingEvents: [...pendingCoordinatorEvents]
+      });
+      const historicalSessions = buildHistoricalMeshSessions({
+        meshId,
+        nodes: mesh.nodes || [],
+        liveSessionRecords: liveMeshSessions
+      });
+      const { getMeshStatusMissionSummaries: getMeshStatusMissionSummaries2 } = await Promise.resolve().then(() => (init_mesh_missions(), mesh_missions_exports));
+      const missions = getMeshStatusMissionSummaries2(meshId, { verbose: verboseMissions, withStats: true });
+      const statusResult = {
+        success: true,
+        meshId: mesh.id,
+        meshName: mesh.name,
+        repoIdentity: mesh.repoIdentity,
+        defaultBranch: mesh.defaultBranch,
+        refreshedAt,
+        meshHost,
+        sourceOfTruth: {
+          membership: meshRecord?.source === "inline_cache" ? "coordinator_inline_mesh_cache" : meshRecord?.source === "local_config" ? "local_mesh_config" : "inline_bootstrap_snapshot",
+          coordinatorOwnsLiveTruth: directTruthSatisfied,
+          meshHost: {
+            owner: "mesh_host_daemon",
+            localRole: meshHost.role,
+            hostDaemonId: meshHost.hostDaemonId,
+            hostNodeId: meshHost.hostNodeId,
+            hostAddress: meshHost.hostAddress
+          },
+          ...requireDirectPeerTruth ? {
+            currentStatus: directTruthSatisfied ? "live_git_and_session_probes" : "direct_peer_truth_unavailable",
+            directPeerTruth: {
+              required: true,
+              satisfied: directTruthSatisfied,
+              directEvidenceCount: effectiveDirectTruth.directEvidenceCount,
+              localConfirmedCount: effectiveDirectTruth.localConfirmedCount,
+              peerAttemptedCount: effectiveDirectTruth.peerAttemptedCount,
+              peerConfirmedCount: effectiveDirectTruth.peerConfirmedCount,
+              unavailableNodeIds: effectiveDirectTruth.unavailableNodeIds,
+              partialNodeFailures: effectiveDirectTruth.unavailableNodeIds
+            }
+          } : {},
+          historicalEvidenceOnly: ["recoveryHints", "ledger.summary", "queue.summary", "historicalSessions"]
+        },
+        branchConvergenceSummary: summarizeInlineMeshBranchConvergence(nodeStatuses),
+        ...previewFreshness ? { previewFreshness, deployFreshness: previewFreshness } : {},
+        nodes: nodeStatuses,
+        queue: { tasks: queue, summary: queueSummary },
+        ledger: { entries: ledgerEntries, summary: ledgerSummary },
+        ...missions.length > 0 ? { missions } : {},
+        ...asyncRefineJobs.length > 0 ? { asyncRefineJobs } : {},
+        ...historicalSessions ? { historicalSessions } : {},
+        ...pendingCoordinatorEvents.length > 0 ? { pendingCoordinatorEvents } : {},
+        ...unroutableDeliveries.length > 0 ? { unroutableDeliveries } : {},
+        activeRefineJobs: Array.from(ctx.runningRefineJobs.values()).filter((job) => job.meshId === meshId).map((job) => ({
+          jobId: job.jobId,
+          nodeId: job.targetNodeId,
+          workspace: job.workspace,
+          startedAt: job.startedAt,
+          status: job.status,
+          targetCoordinatorDaemonId: job.targetCoordinatorDaemonId
+        }))
+      };
+      const { pendingCoordinatorEvents: _pendingCoordinatorEvents, unroutableDeliveries: _unroutableDeliveries, ...cacheableStatusResult } = statusResult;
+      const rememberedStatus = verboseMissions ? cacheableStatusResult : ctx.rememberAggregateMeshStatus(meshId, cacheableStatusResult, refreshReason);
+      const returnedStatus = {
+        ...rememberedStatus,
+        ...pendingCoordinatorEvents.length > 0 ? { pendingCoordinatorEvents } : {},
+        ...unroutableDeliveries.length > 0 ? { unroutableDeliveries } : {}
+      };
+      logRepoMeshStatusDebug("return_live", {
+        meshId,
+        command: "mesh_status",
+        refreshRequested,
+        refreshReason,
+        meshSource: meshRecord.source,
+        directTruth,
+        summary: summarizeRepoMeshStatusDebug(returnedStatus)
+      });
+      return returnedStatus;
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  },
+  get_mesh_review_inbox: async (ctx, args) => {
+    const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+    if (!meshId) return { success: false, error: "meshId required" };
+    try {
+      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: existsSync49 } = await import("fs");
+      const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+      const mesh = meshRecord?.mesh;
+      if (!mesh) return { success: false, error: "Mesh not found" };
+      const inlineNodes = args?.inlineMesh && Array.isArray(args.inlineMesh?.nodes) ? args.inlineMesh.nodes : null;
+      let cachedStatus = !inlineNodes ? ctx.getCachedAggregateMeshStatus(meshId, mesh, {}) : null;
+      if (!cachedStatus && !inlineNodes) {
+        const freshStatus = await ctx.execute("mesh_status", {
+          meshId,
+          inlineMesh: args?.inlineMesh,
+          refresh: true
+        }, "get_mesh_review_inbox");
+        cachedStatus = freshStatus?.success !== false ? freshStatus : null;
+      }
+      const nodeStatuses = inlineNodes ? inlineNodes : Array.isArray(cachedStatus?.nodes) ? cachedStatus.nodes : Array.isArray(mesh.nodes) ? mesh.nodes : [];
+      const ledgerEntries = readLedgerEntries2(meshId, { tail: 300 });
+      const derivation = deriveMeshReviewInboxItems2({ nodes: nodeStatuses, ledgerEntries });
+      for (const item of derivation.items) {
+        const workspace = item.workspace;
+        if (!workspace || !existsSync49(workspace)) continue;
+        const baseRef = item.defaultBranch ? `origin/${item.defaultBranch}` : "origin/main";
+        try {
+          const diffResult = await getGitDiffSummary2(workspace, { baseRef, maxFiles: 100 });
+          if (diffResult.isGitRepo) {
+            item.diffSummary = {
+              baseRef,
+              files: diffResult.files.map((f) => ({
+                path: f.path,
+                status: f.status,
+                insertions: f.insertions,
+                deletions: f.deletions,
+                binary: f.binary,
+                oldPath: f.oldPath
+              })),
+              totalFiles: diffResult.files.length,
+              totalInsertions: diffResult.totalInsertions,
+              totalDeletions: diffResult.totalDeletions,
+              truncated: diffResult.truncated,
+              ...diffResult.error ? { error: diffResult.error } : {}
+            };
+          }
+        } catch {
+          item.diffSummary = null;
+        }
+      }
+      return {
+        success: true,
+        meshId,
+        inbox: derivation.items,
+        remoteNodesExcluded: derivation.remoteNodesExcluded,
+        excludedRemoteNodeIds: derivation.excludedRemoteNodeIds
+      };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+};
+
+// src/commands/high-family/index.ts
+var highFamilyRegistry = new Map(
+  Object.entries({
+    ...meshEventsHandlers,
+    ...meshCoordinatorLaunchHandlers,
+    ...meshStatusHandlers
+  })
+);
+
+// src/commands/router.ts
 init_cli_detector();
 init_git_status();
 init_dist();
 init_logger();
 
 // src/logging/command-log.ts
-var fs26 = __toESM(require("fs"));
+var fs28 = __toESM(require("fs"));
 var path36 = __toESM(require("path"));
 var os27 = __toESM(require("os"));
 var ADHDEV_HOME2 = process.env.ADHDEV_CONFIG_DIR && process.env.ADHDEV_CONFIG_DIR.trim() ? process.env.ADHDEV_CONFIG_DIR.trim() : path36.join(os27.homedir(), ".adhdev");
@@ -47425,7 +48485,7 @@ var LOG_DIR2 = path36.join(ADHDEV_HOME2, "logs");
 var MAX_FILE_SIZE = 5 * 1024 * 1024;
 var MAX_DAYS = 7;
 try {
-  fs26.mkdirSync(LOG_DIR2, { recursive: true });
+  fs28.mkdirSync(LOG_DIR2, { recursive: true });
 } catch {
 }
 var SENSITIVE_KEYS = /* @__PURE__ */ new Set([
@@ -47471,7 +48531,7 @@ function checkRotation() {
 }
 function cleanOldFiles() {
   try {
-    const files = fs26.readdirSync(LOG_DIR2).filter((f) => f.startsWith("commands-") && f.endsWith(".jsonl"));
+    const files = fs28.readdirSync(LOG_DIR2).filter((f) => f.startsWith("commands-") && f.endsWith(".jsonl"));
     const cutoff = /* @__PURE__ */ new Date();
     cutoff.setDate(cutoff.getDate() - MAX_DAYS);
     const cutoffStr = cutoff.toISOString().slice(0, 10);
@@ -47479,7 +48539,7 @@ function cleanOldFiles() {
       const dateMatch = file.match(/commands-(\d{4}-\d{2}-\d{2})/);
       if (dateMatch && dateMatch[1] < cutoffStr) {
         try {
-          fs26.unlinkSync(path36.join(LOG_DIR2, file));
+          fs28.unlinkSync(path36.join(LOG_DIR2, file));
         } catch {
         }
       }
@@ -47489,14 +48549,14 @@ function cleanOldFiles() {
 }
 function checkSize() {
   try {
-    const stat2 = fs26.statSync(currentFile);
+    const stat2 = fs28.statSync(currentFile);
     if (stat2.size > MAX_FILE_SIZE) {
       const backup = currentFile.replace(".jsonl", ".1.jsonl");
       try {
-        fs26.unlinkSync(backup);
+        fs28.unlinkSync(backup);
       } catch {
       }
-      fs26.renameSync(currentFile, backup);
+      fs28.renameSync(currentFile, backup);
     }
   } catch {
   }
@@ -47529,14 +48589,14 @@ function logCommand(entry) {
       ...entry.error ? { err: entry.error } : {},
       ...entry.durationMs !== void 0 ? { ms: entry.durationMs } : {}
     });
-    fs26.appendFileSync(currentFile, line + "\n");
+    fs28.appendFileSync(currentFile, line + "\n");
   } catch {
   }
 }
 function getRecentCommands(count = 50) {
   try {
-    if (!fs26.existsSync(currentFile)) return [];
-    const content = fs26.readFileSync(currentFile, "utf-8");
+    if (!fs28.existsSync(currentFile)) return [];
+    const content = fs28.readFileSync(currentFile, "utf-8");
     const lines = content.trim().split("\n").filter(Boolean);
     return lines.slice(-count).map((line) => {
       try {
@@ -47563,16 +48623,13 @@ cleanOldFiles();
 
 // src/commands/router.ts
 var yaml4 = __toESM(require("js-yaml"));
-init_mesh_coordinator();
-init_coordinator_registry();
 init_mesh_events();
-init_mesh_routing();
 init_mesh_host_ownership();
 
 // src/mesh/mesh-refine-batch.ts
-var import_node_child_process4 = require("child_process");
+var import_node_child_process5 = require("child_process");
 var import_node_util4 = require("util");
-var execFileAsync3 = (0, import_node_util4.promisify)(import_node_child_process4.execFile);
+var execFileAsync3 = (0, import_node_util4.promisify)(import_node_child_process5.execFile);
 var MAX_CHANGED_FILES2 = 500;
 function topLevel(path42) {
   const slash = path42.indexOf("/");
@@ -47656,95 +48713,12 @@ function orderMeshRefineBatchNodes(changeAreas) {
   return { order: ranked.map((a) => a.nodeId), changeAreas: areaById, rationale };
 }
 
-// src/mesh/preview-freshness.ts
-var import_node_child_process5 = require("child_process");
-var import_node_fs4 = require("fs");
-var import_node_path2 = require("path");
-var PREVIEW_DEPLOY_RECORD = ".adhdev/preview-deploy.json";
-function runGit2(repoRoot, args) {
-  try {
-    return (0, import_node_child_process5.execFileSync)("git", args, {
-      cwd: repoRoot,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-      timeout: 5e3
-    }).trim();
-  } catch {
-    return "";
-  }
-}
-function readRecord5(repoRoot) {
-  const path42 = (0, import_node_path2.resolve)(repoRoot, PREVIEW_DEPLOY_RECORD);
-  if (!(0, import_node_fs4.existsSync)(path42)) return null;
-  try {
-    const parsed = JSON.parse((0, import_node_fs4.readFileSync)(path42, "utf8"));
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-function normalizeCommit(value) {
-  return typeof value === "string" && /^[0-9a-f]{7,40}$/i.test(value.trim()) ? value.trim() : null;
-}
-function readTargetFreshness(record, currentCommit) {
-  const targets = record?.targets && typeof record.targets === "object" && !Array.isArray(record.targets) ? record.targets : {};
-  const result = {};
-  for (const targetName of ["npm", "server", "web"]) {
-    const targetRecord = targets[targetName] && typeof targets[targetName] === "object" && !Array.isArray(targets[targetName]) ? targets[targetName] : {};
-    const commit = normalizeCommit(targetRecord.commit);
-    result[targetName] = {
-      commit,
-      deployedAt: typeof targetRecord.deployedAt === "string" ? targetRecord.deployedAt : void 0,
-      status: commit && currentCommit ? commit === currentCommit ? "fresh" : "stale" : "unknown"
-    };
-  }
-  return result;
-}
-function readCurrentMainCommit(repoRoot) {
-  const originMain = runGit2(repoRoot, ["rev-parse", "--verify", "origin/main^{commit}"]);
-  if (originMain) {
-    return { currentMainCommit: originMain, currentMainCommitSource: "origin/main" };
-  }
-  const head = runGit2(repoRoot, ["rev-parse", "--verify", "HEAD"]);
-  if (head) {
-    return { currentMainCommit: head, currentMainCommitSource: "HEAD" };
-  }
-  return { currentMainCommit: null, currentMainCommitSource: "unknown" };
-}
-function buildPreviewFreshness(repoRoot) {
-  const current = readCurrentMainCommit(repoRoot);
-  const record = readRecord5(repoRoot);
-  const lastPreviewCommit = normalizeCommit(record?.lastPreviewCommit);
-  const targets = readTargetFreshness(record, current.currentMainCommit);
-  let status = "unknown";
-  let nextAction = "Run npm run deploy:preview from the current main commit, then smoke preview.";
-  if (lastPreviewCommit && current.currentMainCommit) {
-    status = lastPreviewCommit === current.currentMainCommit ? "fresh" : "stale";
-    nextAction = status === "fresh" ? "No preview deploy action needed." : "Run npm run deploy:preview from origin/main, then smoke preview.";
-  } else if (!current.currentMainCommit) {
-    nextAction = "Resolve the current main commit before judging preview freshness.";
-  }
-  return {
-    status,
-    lastPreviewCommit,
-    currentMainCommit: current.currentMainCommit,
-    currentMainCommitSource: current.currentMainCommitSource,
-    recordPath: PREVIEW_DEPLOY_RECORD,
-    lastDeployedAt: typeof record?.updatedAt === "string" ? record.updatedAt : void 0,
-    lastTarget: typeof record?.target === "string" ? record.target : void 0,
-    previewVersion: typeof record?.previewVersion === "string" ? record.previewVersion : void 0,
-    targets,
-    nextAction
-  };
-}
-
 // src/commands/router.ts
-init_mesh_refine_status();
 init_mesh_work_queue();
 init_repo_mesh_types();
-var import_os3 = require("os");
-var import_path12 = require("path");
-var fs27 = __toESM(require("fs"));
+var import_os4 = require("os");
+var import_path13 = require("path");
+var fs29 = __toESM(require("fs"));
 var import_node_child_process6 = require("child_process");
 init_resolve_executable();
 function readProviderPriorityFromPolicy(policy) {
@@ -48092,7 +49066,7 @@ function isDeadLocalWorktreeNode(node) {
   if (node?.isLocalWorktree !== true) return false;
   const workspace = readStringValue(node?.workspace);
   if (!workspace) return false;
-  return !fs27.existsSync(workspace);
+  return !fs29.existsSync(workspace);
 }
 function foldMeshNodeIdentityToCanonical(node) {
   if (!node || typeof node !== "object" || Array.isArray(node)) return node;
@@ -48340,7 +49314,7 @@ function summarizeInlineMeshBranchConvergence(nodes) {
   const followUps = nodes.filter((node) => {
     if (readObjectRecord(node.branchConvergence).needsConvergence !== true) return false;
     const workspace = typeof node.workspace === "string" ? node.workspace : "";
-    if (workspace && !fs27.existsSync(workspace)) return false;
+    if (workspace && !fs29.existsSync(workspace)) return false;
     return true;
   }).map((node) => {
     const convergence = readObjectRecord(node.branchConvergence);
@@ -48648,7 +49622,7 @@ async function hydrateInlineMeshDirectTruth(args) {
       if (!isSelfNode && daemonId) unavailableNodeIds.push(nodeId);
       continue;
     }
-    if (fs27.existsSync(workspace)) {
+    if (fs29.existsSync(workspace)) {
       try {
         const localGit = await getGitRepoStatus(workspace, { timeoutMs: 1e4, refreshUpstream: true });
         if (localGit?.isGitRepo) {
@@ -48756,7 +49730,7 @@ function readLiveMeshNodeWorkspace(args) {
 }
 function collectLiveMeshSessionRecords(args) {
   const nodeWorkspace = readStringValue(args.node?.workspace);
-  const nodeIsMissingLocalWorktree = args.node?.isLocalWorktree === true && !!nodeWorkspace && !fs27.existsSync(nodeWorkspace);
+  const nodeIsMissingLocalWorktree = args.node?.isLocalWorktree === true && !!nodeWorkspace && !fs29.existsSync(nodeWorkspace);
   const matches = args.liveSessionRecords.filter((record) => {
     const recordNodeId = readStringValue(record?.meta?.meshNodeId);
     if (recordNodeId && recordNodeId !== args.nodeId) return false;
@@ -48783,7 +49757,7 @@ function buildHistoricalMeshSessions(args) {
     const workspace = readStringValue(node?.workspace);
     if (nodeId) liveNodeIds.add(nodeId);
     if (workspace) liveWorkspaces.add(workspace);
-    if (nodeId && node?.isLocalWorktree === true && workspace && !fs27.existsSync(workspace)) {
+    if (nodeId && node?.isLocalWorktree === true && workspace && !fs29.existsSync(workspace)) {
       missingLocalWorktreeNodeIds.add(nodeId);
     }
   }
@@ -49219,7 +50193,7 @@ function isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit) {
   if (!baseCommit || !branchCommit) return false;
   if (baseCommit === branchCommit) return true;
   try {
-    if (!fs27.existsSync(submoduleRepoPath)) return false;
+    if (!fs29.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" });
@@ -49258,14 +50232,14 @@ function collectFastForwardGitlinkPaths(repoRoot, baseHead, branchHead) {
     const baseCommit = readTreeObject(repoRoot, baseHead, path42);
     const branchCommit = readTreeObject(repoRoot, branchHead, path42);
     if (!baseCommit || !branchCommit) return false;
-    return isSubmoduleFastForward((0, import_path12.resolve)(repoRoot, path42), baseCommit, branchCommit);
+    return isSubmoduleFastForward((0, import_path13.resolve)(repoRoot, path42), baseCommit, branchCommit);
   });
 }
 function evaluateGitlinkTrivialFastForward(repoRoot, baseHead, branchHead) {
   const changedGitlinks = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path42) => {
     const baseCommit = readTreeObject(repoRoot, baseHead, path42);
     const branchCommit = readTreeObject(repoRoot, branchHead, path42);
-    const submoduleRepoPath = (0, import_path12.resolve)(repoRoot, path42);
+    const submoduleRepoPath = (0, import_path13.resolve)(repoRoot, path42);
     const fastForward = !!baseCommit && !!branchCommit && isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit);
     return { path: path42, baseCommit, branchCommit, fastForward };
   });
@@ -49320,7 +50294,7 @@ function buildTreeWithGitlinksEqualized(repoRoot, commitish, paths, placeholderC
     if (!tree) return void 0;
     const updates = paths.map((path42) => `160000 commit ${placeholderCommit}	${path42}`).join("\n");
     if (!updates) return tree;
-    const tmpIndex = (0, import_path12.join)(resolveGitDir(repoRoot), `adhdev-refine-eq-${commitish.slice(0, 12)}.index`);
+    const tmpIndex = (0, import_path13.join)(resolveGitDir(repoRoot), `adhdev-refine-eq-${commitish.slice(0, 12)}.index`);
     const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
     try {
       (0, import_node_child_process6.execFileSync)("git", ["read-tree", tree], { cwd: repoRoot, env, stdio: "ignore" });
@@ -49336,7 +50310,7 @@ function buildTreeWithGitlinksEqualized(repoRoot, commitish, paths, placeholderC
       return newTree || void 0;
     } finally {
       try {
-        fs27.rmSync(tmpIndex, { force: true });
+        fs29.rmSync(tmpIndex, { force: true });
       } catch {
       }
     }
@@ -49395,7 +50369,7 @@ function synthesizeTrivialFastForwardMergeTree(repoRoot, baseHead, branchHead, g
     if (!contentTree) return void 0;
     const updates = branchGitlinks.map((entry) => `160000 commit ${entry.branchCommit}	${entry.path}`).join("\n");
     if (!updates) return contentTree;
-    const tmpIndex = (0, import_path12.join)(resolveGitDir(repoRoot), `adhdev-refine-ff-${baseHead.slice(0, 12)}-${branchHead.slice(0, 12)}.index`);
+    const tmpIndex = (0, import_path13.join)(resolveGitDir(repoRoot), `adhdev-refine-ff-${baseHead.slice(0, 12)}-${branchHead.slice(0, 12)}.index`);
     const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
     try {
       (0, import_node_child_process6.execFileSync)("git", ["read-tree", contentTree], { cwd: repoRoot, env, stdio: "ignore" });
@@ -49411,7 +50385,7 @@ function synthesizeTrivialFastForwardMergeTree(repoRoot, baseHead, branchHead, g
       return newTree || void 0;
     } finally {
       try {
-        fs27.rmSync(tmpIndex, { force: true });
+        fs29.rmSync(tmpIndex, { force: true });
       } catch {
       }
     }
@@ -49517,7 +50491,7 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
       return { stdout: String(stdout || ""), stderr: String(stderr || ""), refspec };
     };
     const importCommitFromWorktreeSubmodule = async (submodulePath, worktreeSubmodulePath, commit) => {
-      if (!fs27.existsSync(worktreeSubmodulePath)) return false;
+      if (!fs29.existsSync(worktreeSubmodulePath)) return false;
       try {
         await runGit3(worktreeSubmodulePath, ["cat-file", "-e", `${commit}^{commit}`]);
       } catch {
@@ -49533,14 +50507,14 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
       return match ? { commit: match[1], path: match[2] } : null;
     }).filter((entry) => !!entry);
     for (const gitlink of gitlinks) {
-      const submodulePath = (0, import_path12.resolve)(repoRoot, gitlink.path);
+      const submodulePath = (0, import_path13.resolve)(repoRoot, gitlink.path);
       const entry = {
         path: gitlink.path,
         commit: gitlink.commit,
         reachable: false
       };
       try {
-        if (!fs27.existsSync(submodulePath)) {
+        if (!fs29.existsSync(submodulePath)) {
           entry.error = `Submodule checkout missing at ${gitlink.path}`;
           entry.publishRequired = true;
           if (options.allowAutoPublishSubmoduleMainCommits === true) {
@@ -49561,7 +50535,7 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
             try {
               const imported = await importCommitFromWorktreeSubmodule(
                 submodulePath,
-                (0, import_path12.resolve)(options.worktreeRoot, gitlink.path),
+                (0, import_path13.resolve)(options.worktreeRoot, gitlink.path),
                 gitlink.commit
               );
               if (imported) {
@@ -49773,19 +50747,19 @@ async function runMeshRefineValidationGate(mesh, workspace, opts) {
     ...extras
   });
   const isPackageManagerValidation = (candidate) => {
-    const command = (0, import_path12.basename)(candidate.command).replace(/\.(?:cmd|exe)$/i, "");
+    const command = (0, import_path13.basename)(candidate.command).replace(/\.(?:cmd|exe)$/i, "");
     return ["npm", "pnpm", "yarn", "bun"].includes(command) && candidate.args.some((arg) => arg === "run" || arg === "test" || arg === "exec");
   };
   const dependenciesLikelyMissing = (cwd) => {
-    if (!fs27.existsSync((0, import_path12.join)(cwd, "package.json"))) return false;
-    if (fs27.existsSync((0, import_path12.join)(cwd, "node_modules"))) return false;
-    return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs27.existsSync((0, import_path12.join)(cwd, lock)));
+    if (!fs29.existsSync((0, import_path13.join)(cwd, "package.json"))) return false;
+    if (fs29.existsSync((0, import_path13.join)(cwd, "node_modules"))) return false;
+    return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs29.existsSync((0, import_path13.join)(cwd, lock)));
   };
   if (runLegacyBootstrapCommands) {
     summary.bootstrap = { stage: "legacy" };
     for (const candidate of selection.bootstrapCommands) {
       const startedAt = Date.now();
-      const cwd = candidate.cwd ? (0, import_path12.resolve)(workspace, candidate.cwd) : workspace;
+      const cwd = candidate.cwd ? (0, import_path13.resolve)(workspace, candidate.cwd) : workspace;
       const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
       const resolvedCommand = resolveWin32Executable(candidate.command);
       try {
@@ -49815,7 +50789,7 @@ async function runMeshRefineValidationGate(mesh, workspace, opts) {
   }
   for (const candidate of selection.commands) {
     const startedAt = Date.now();
-    const cwd = candidate.cwd ? (0, import_path12.resolve)(workspace, candidate.cwd) : workspace;
+    const cwd = candidate.cwd ? (0, import_path13.resolve)(workspace, candidate.cwd) : workspace;
     const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
     const bootstrapProvidedDependencies = summary.bootstrap?.stage === "cached" || summary.bootstrap?.stage === "ran" || summary.bootstrap?.stage === "legacy";
     if (!bootstrapProvidedDependencies && isPackageManagerValidation(candidate) && dependenciesLikelyMissing(cwd)) {
@@ -49884,14 +50858,14 @@ function serializeMeshCoordinatorMcpConfig(config, format) {
 }
 function resolveHermesUserHome() {
   const explicitHome = process.env.HERMES_HOME?.trim();
-  return explicitHome || (0, import_path12.join)((0, import_os3.homedir)(), ".hermes");
+  return explicitHome || (0, import_path13.join)((0, import_os4.homedir)(), ".hermes");
 }
 function loadHermesCoordinatorBaseConfig(targetConfigPath) {
   const sourceHome = resolveHermesUserHome();
-  const sourceConfigPath = (0, import_path12.join)(sourceHome, "config.yaml");
-  if (!fs27.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
-  if ((0, import_path12.resolve)(sourceConfigPath) === (0, import_path12.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
-  const parsed = parseMeshCoordinatorMcpConfig(fs27.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
+  const sourceConfigPath = (0, import_path13.join)(sourceHome, "config.yaml");
+  if (!fs29.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+  if ((0, import_path13.resolve)(sourceConfigPath) === (0, import_path13.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+  const parsed = parseMeshCoordinatorMcpConfig(fs29.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
   const { mcp_servers: _mcpServers, ...baseConfig } = parsed;
   return { config: baseConfig, sourceHome, sourceConfigPath };
 }
@@ -49924,13 +50898,13 @@ function stripHermesCoordinatorTempModelProviderOverrides(config) {
   return sanitized;
 }
 function copyHermesCoordinatorCredentialFiles(sourceHome, targetHome) {
-  if ((0, import_path12.resolve)(sourceHome) === (0, import_path12.resolve)(targetHome)) return;
+  if ((0, import_path13.resolve)(sourceHome) === (0, import_path13.resolve)(targetHome)) return;
   for (const fileName of [".env", "auth.json"]) {
-    const sourcePath = (0, import_path12.join)(sourceHome, fileName);
-    const targetPath = (0, import_path12.join)(targetHome, fileName);
-    if (!fs27.existsSync(sourcePath)) continue;
+    const sourcePath = (0, import_path13.join)(sourceHome, fileName);
+    const targetPath = (0, import_path13.join)(targetHome, fileName);
+    if (!fs29.existsSync(sourcePath)) continue;
     try {
-      fs27.copyFileSync(sourcePath, targetPath);
+      fs29.copyFileSync(sourcePath, targetPath);
     } catch (error) {
       LOG.warn("MeshCoordinator", `Could not copy Hermes ${fileName} into isolated coordinator home: ${error?.message || error}`);
     }
@@ -50322,6 +51296,29 @@ var DaemonCommandRouter = class {
     };
     return ctx;
   }
+  /**
+   * Build the HighFamilyContext handed to RF-ROUTER HIGH family handlers. Binds
+   * the router-private collaborators those handlers need (mesh resolution, the
+   * aggregate-status memory cache + its bound read/write helpers, the
+   * running-refine-job table, inline-mesh + git-probe caches, and the router's
+   * own `execute` for the get_mesh_review_inbox mesh_status re-entry). HIGH
+   * handlers reach more router-owned state than MED, but the binding shape is
+   * the same: bound methods + direct field references, none reachable from
+   * `deps`.
+   */
+  buildHighFamilyContext() {
+    return {
+      deps: this.deps,
+      getMeshForCommand: this.getMeshForCommand.bind(this),
+      getCachedAggregateMeshStatus: this.getCachedAggregateMeshStatus.bind(this),
+      rememberAggregateMeshStatus: this.rememberAggregateMeshStatus.bind(this),
+      execute: this.execute.bind(this),
+      aggregateMeshStatusCache: this.aggregateMeshStatusCache,
+      runningRefineJobs: this.runningRefineJobs,
+      inlineMeshCache: this.inlineMeshCache,
+      meshGitProbeCache: this.meshGitProbeCache
+    };
+  }
   async requireMeshHostMutationOwner(meshId, inlineMesh, operation) {
     const meshRecord = await this.getMeshForCommand(meshId, inlineMesh, { preferInline: true });
     const mesh = meshRecord?.mesh;
@@ -50379,7 +51376,7 @@ var DaemonCommandRouter = class {
       const nodeId = readInlineMeshNodeId(node);
       if (!nodeId || !tombstones.has(nodeId)) return true;
       const workspace = readStringValue(node?.workspace);
-      if (workspace && fs27.existsSync(workspace)) {
+      if (workspace && fs29.existsSync(workspace)) {
         tombstones.delete(nodeId);
         return true;
       }
@@ -50414,14 +51411,14 @@ var DaemonCommandRouter = class {
    * to give handles time to release, and reports whether residue remains.
    */
   async bestEffortRemoveWorktreeDir(dir) {
-    if (!dir || !fs27.existsSync(dir)) return { removed: true, residue: false };
+    if (!dir || !fs29.existsSync(dir)) return { removed: true, residue: false };
     const sleep3 = (ms) => new Promise((resolve24) => setTimeout(resolve24, ms));
     const ABSORB = /* @__PURE__ */ new Set(["EINVAL", "EPERM", "EBUSY", "ENOTEMPTY", "EACCES", "EMFILE", "ENFILE"]);
     let lastErr;
     for (let attempt = 0; attempt < 4; attempt++) {
       try {
-        fs27.rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
-        if (!fs27.existsSync(dir)) return { removed: true, residue: false };
+        fs29.rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+        if (!fs29.existsSync(dir)) return { removed: true, residue: false };
         lastErr = new Error("directory still present after rmSync");
       } catch (e) {
         lastErr = e;
@@ -50432,7 +51429,7 @@ var DaemonCommandRouter = class {
       }
       await sleep3(150 * (attempt + 1));
     }
-    return fs27.existsSync(dir) ? { removed: false, residue: true, error: String(lastErr?.message || lastErr || "unknown rm error") } : { removed: true, residue: false };
+    return fs29.existsSync(dir) ? { removed: false, residue: true, error: String(lastErr?.message || lastErr || "unknown rm error") } : { removed: true, residue: false };
   }
   async cleanupLocalWorktreeNode(args) {
     const workspace = typeof args.node?.workspace === "string" ? args.node.workspace.trim() : "";
@@ -50444,13 +51441,13 @@ var DaemonCommandRouter = class {
         recoveryHint: "Inspect the mesh node record before removing it, or remove stale metadata manually only after confirming no managed worktree remains."
       };
     }
-    const worktreeExists = fs27.existsSync(workspace);
+    const worktreeExists = fs29.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 || !fs27.existsSync(repoRoot)) {
+    if (!repoRoot || !fs29.existsSync(repoRoot)) {
       return {
         success: false,
         code: "mesh_worktree_cleanup_missing_source_repo",
@@ -50468,9 +51465,9 @@ var DaemonCommandRouter = class {
     }
     const { resolveWorktreePath: resolveWorktreePath2, listWorktrees: listWorktrees2, removeWorktree: removeWorktree2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
     const normalizePath = (value) => {
-      const resolved = (0, import_path12.resolve)(value);
+      const resolved = (0, import_path13.resolve)(value);
       try {
-        return fs27.realpathSync(resolved);
+        return fs29.realpathSync(resolved);
       } catch {
         return resolved;
       }
@@ -51065,196 +52062,242 @@ var DaemonCommandRouter = class {
       LOG.warn("Mesh", `[Refinery] resumePendingRefineJobsOnStartup failed: ${e?.message || e}`);
     }
   }
+  /**
+   * Synchronous refinery for a single worktree node — the gate pipeline that
+   * validates, preflights (patch-equivalence / submodule-reachability /
+   * no-op), merges, aligns submodules, cleans up the worktree node and
+   * (optionally) pushes. The body is a flat sequence of stage methods; each
+   * stage either returns a terminal CommandRouterResult (gate failure or a
+   * successful already-merged short-circuit) or `continue` with the extended
+   * context. Behavior — stage order, every early-exit, and every result shape —
+   * is identical to the previous single inlined body.
+   */
   async executeMeshRefineNodeSynchronously(meshId, nodeId, args) {
     const refineStages = [];
     try {
-      const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-      const mesh = meshRecord?.mesh;
-      const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
-      if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh`, refineStages };
-      if (!node.isLocalWorktree || !node.workspace) {
-        return { success: false, error: `Refinery requires a local worktree node`, refineStages };
-      }
-      const sourceNode = node.clonedFromNodeId ? mesh?.nodes.find((n) => meshNodeIdMatches(n, node.clonedFromNodeId)) : mesh?.nodes.find((n) => !n.isLocalWorktree);
-      const repoRoot = sourceNode?.repoRoot || sourceNode?.workspace;
-      if (!repoRoot) return { success: false, error: "Source node repoRoot not found", refineStages };
-      const { execFile: execFile5 } = await import("child_process");
-      const { promisify: promisify8 } = await import("util");
-      const execFileAsync4 = promisify8(execFile5);
-      const resolveStarted = Date.now();
-      const { stdout: branchStdout } = await execFileAsync4("git", ["branch", "--show-current"], { cwd: node.workspace, encoding: "utf8" });
-      const branch = branchStdout.trim();
-      if (!branch) return { success: false, error: "Could not determine branch of the worktree node", refineStages };
-      const { stdout: baseBranchStdout } = await execFileAsync4("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8" });
-      const baseBranch = baseBranchStdout.trim();
-      let fetchWarning;
-      try {
-        await execFileAsync4("git", ["fetch", "origin", baseBranch], { cwd: repoRoot, encoding: "utf8" });
-      } catch (e) {
-        fetchWarning = `git fetch origin ${baseBranch} failed (proceeding with local HEAD): ${e?.message}`;
-      }
-      let baseHeadRaw;
-      try {
-        const { stdout } = await execFileAsync4("git", ["rev-parse", `origin/${baseBranch}`], { cwd: repoRoot, encoding: "utf8" });
-        baseHeadRaw = stdout.trim();
-      } catch {
-        const { stdout: localHead } = await execFileAsync4("git", ["rev-parse", "HEAD"], { cwd: repoRoot, encoding: "utf8" });
-        baseHeadRaw = localHead.trim();
-      }
-      const { stdout: branchHeadStdout } = await execFileAsync4("git", ["rev-parse", branch], { cwd: node.workspace, encoding: "utf8" });
-      const baseHead = baseHeadRaw;
-      let branchHead = branchHeadStdout.trim();
-      recordMeshRefineStage(refineStages, "resolve_refs", "passed", resolveStarted, { branch, baseBranch, baseHead, branchHead, ...fetchWarning ? { fetchWarning } : {} });
-      const validationStarted = Date.now();
-      const validationSummary = await runMeshRefineValidationGate(mesh, node.workspace, {
-        // M2-2: consume the node's persisted bootstrap state; persist re-runs.
-        persistedBootstrapState: node.worktreeBootstrap,
-        onBootstrapStateChange: (state) => {
-          node.worktreeBootstrap = state;
-          void Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports)).then(({ updateNode: updateNode2 }) => updateNode2(mesh.id, node.id, { worktreeBootstrap: state })).catch(() => {
-          });
-        }
-      });
-      recordMeshRefineStage(
+      const resolved = await this.refineResolveRefsStage(meshId, nodeId, args, refineStages);
+      if (resolved.kind === "terminal") return resolved.result;
+      const ctx = resolved.ctx;
+      const validation = await this.refineValidationStage(ctx);
+      if (validation.kind === "terminal") return validation.result;
+      const patchEquivalence = await this.refinePatchEquivalenceStage(ctx);
+      if (patchEquivalence.kind === "terminal") return patchEquivalence.result;
+      const submoduleReachability = await this.refineSubmoduleReachabilityStage(ctx);
+      if (submoduleReachability.kind === "terminal") return submoduleReachability.result;
+      const effectiveDiff = await this.refineEffectiveDiffStage(ctx);
+      if (effectiveDiff.kind === "terminal") return effectiveDiff.result;
+      const merge = await this.refineMergeAndFinalizeStage(ctx);
+      return merge.result;
+    } catch (e) {
+      return { success: false, error: e.message, refineStages };
+    }
+  }
+  /**
+   * resolve_refs stage: resolve the mesh / worktree node / source node /
+   * repoRoot, then the worktree branch, base branch, fetched base head and
+   * branch head. Seeds the RefineContext consumed by every later stage.
+   */
+  async refineResolveRefsStage(meshId, nodeId, args, refineStages) {
+    const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+    const mesh = meshRecord?.mesh;
+    const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
+    if (!node) return { kind: "terminal", result: { success: false, error: `Node '${nodeId}' not found in mesh`, refineStages } };
+    if (!node.isLocalWorktree || !node.workspace) {
+      return { kind: "terminal", result: { success: false, error: `Refinery requires a local worktree node`, refineStages } };
+    }
+    const sourceNode = node.clonedFromNodeId ? mesh?.nodes.find((n) => meshNodeIdMatches(n, node.clonedFromNodeId)) : mesh?.nodes.find((n) => !n.isLocalWorktree);
+    const repoRoot = sourceNode?.repoRoot || sourceNode?.workspace;
+    if (!repoRoot) return { kind: "terminal", result: { success: false, error: "Source node repoRoot not found", refineStages } };
+    const { execFile: execFile5 } = await import("child_process");
+    const { promisify: promisify8 } = await import("util");
+    const execFileAsync4 = promisify8(execFile5);
+    const resolveStarted = Date.now();
+    const { stdout: branchStdout } = await execFileAsync4("git", ["branch", "--show-current"], { cwd: node.workspace, encoding: "utf8" });
+    const branch = branchStdout.trim();
+    if (!branch) return { kind: "terminal", result: { success: false, error: "Could not determine branch of the worktree node", refineStages } };
+    const { stdout: baseBranchStdout } = await execFileAsync4("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8" });
+    const baseBranch = baseBranchStdout.trim();
+    let fetchWarning;
+    try {
+      await execFileAsync4("git", ["fetch", "origin", baseBranch], { cwd: repoRoot, encoding: "utf8" });
+    } catch (e) {
+      fetchWarning = `git fetch origin ${baseBranch} failed (proceeding with local HEAD): ${e?.message}`;
+    }
+    let baseHeadRaw;
+    try {
+      const { stdout } = await execFileAsync4("git", ["rev-parse", `origin/${baseBranch}`], { cwd: repoRoot, encoding: "utf8" });
+      baseHeadRaw = stdout.trim();
+    } catch {
+      const { stdout: localHead } = await execFileAsync4("git", ["rev-parse", "HEAD"], { cwd: repoRoot, encoding: "utf8" });
+      baseHeadRaw = localHead.trim();
+    }
+    const { stdout: branchHeadStdout } = await execFileAsync4("git", ["rev-parse", branch], { cwd: node.workspace, encoding: "utf8" });
+    const baseHead = baseHeadRaw;
+    const branchHead = branchHeadStdout.trim();
+    recordMeshRefineStage(refineStages, "resolve_refs", "passed", resolveStarted, { branch, baseBranch, baseHead, branchHead, ...fetchWarning ? { fetchWarning } : {} });
+    return {
+      kind: "continue",
+      ctx: {
+        meshId,
+        nodeId,
+        args,
         refineStages,
-        "validation",
-        validationSummary.status === "passed" ? "passed" : validationSummary.status === "failed" ? "failed" : "skipped",
-        validationStarted,
-        { validationStatus: validationSummary.status, commandsRun: validationSummary.commandsRun.length }
-      );
-      if (validationSummary.status === "failed") {
-        const firstFailedCmd = Array.isArray(validationSummary.commandsRun) ? validationSummary.commandsRun.find((c) => c.success === false) : void 0;
-        const buildValidationFailedError = () => {
-          const base = validationSummary.failureCode === "missing_dependencies" ? "Refinery validation dependencies are missing; merge/refine was not attempted. Configure validation.bootstrapCommands if Refinery should bootstrap dependencies before validation." : validationSummary.failureCode === "dependency_bootstrap_failed" ? "Refinery dependency/bootstrap command failed; merge/refine was not attempted." : validationSummary.failureCode === "spawn_resolution_failed" ? validationSummary.spawnResolutionError || "Refinery validation command could not be spawned (executable not found); merge/refine was not attempted." : "Refinery validation gate failed; merge/refine was not attempted.";
-          if (!firstFailedCmd) return base;
-          const cmdName = typeof firstFailedCmd.displayCommand === "string" ? firstFailedCmd.displayCommand : typeof firstFailedCmd.command === "string" ? [firstFailedCmd.command, ...Array.isArray(firstFailedCmd.args) ? firstFailedCmd.args : []].join(" ").trim() : typeof firstFailedCmd.cmd === "string" ? firstFailedCmd.cmd : "";
-          const rawOutput = [firstFailedCmd.stdout, firstFailedCmd.stderr, firstFailedCmd.output].filter((s2) => typeof s2 === "string" && s2.length > 0).join("\n");
-          const tail = rawOutput.length > 800 ? rawOutput.slice(-800) : rawOutput;
-          return [
-            base,
-            cmdName ? `First failing command: ${cmdName}` : "",
-            tail ? `Output (tail):
+        execFileAsync: execFileAsync4,
+        mesh,
+        node,
+        sourceNode,
+        repoRoot,
+        branch,
+        baseBranch,
+        baseHead,
+        branchHead,
+        validationSummary: void 0,
+        patchEquivalence: void 0,
+        submoduleReachability: void 0
+      }
+    };
+  }
+  /**
+   * validation stage: run the refinery validation gate (typecheck / test /
+   * lint / build per node config) and block on failure or when no allowlisted
+   * command was available. On pass, stores the summary on the context.
+   */
+  async refineValidationStage(ctx) {
+    const { mesh, node, branch, baseBranch, refineStages } = ctx;
+    const validationStarted = Date.now();
+    const validationSummary = await runMeshRefineValidationGate(mesh, node.workspace, {
+      // M2-2: consume the node's persisted bootstrap state; persist re-runs.
+      persistedBootstrapState: node.worktreeBootstrap,
+      onBootstrapStateChange: (state) => {
+        node.worktreeBootstrap = state;
+        void Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports)).then(({ updateNode: updateNode2 }) => updateNode2(mesh.id, node.id, { worktreeBootstrap: state })).catch(() => {
+        });
+      }
+    });
+    ctx.validationSummary = validationSummary;
+    recordMeshRefineStage(
+      refineStages,
+      "validation",
+      validationSummary.status === "passed" ? "passed" : validationSummary.status === "failed" ? "failed" : "skipped",
+      validationStarted,
+      { validationStatus: validationSummary.status, commandsRun: validationSummary.commandsRun.length }
+    );
+    if (validationSummary.status === "failed") {
+      const firstFailedCmd = Array.isArray(validationSummary.commandsRun) ? validationSummary.commandsRun.find((c) => c.success === false) : void 0;
+      const buildValidationFailedError = () => {
+        const base = validationSummary.failureCode === "missing_dependencies" ? "Refinery validation dependencies are missing; merge/refine was not attempted. Configure validation.bootstrapCommands if Refinery should bootstrap dependencies before validation." : validationSummary.failureCode === "dependency_bootstrap_failed" ? "Refinery dependency/bootstrap command failed; merge/refine was not attempted." : validationSummary.failureCode === "spawn_resolution_failed" ? validationSummary.spawnResolutionError || "Refinery validation command could not be spawned (executable not found); merge/refine was not attempted." : "Refinery validation gate failed; merge/refine was not attempted.";
+        if (!firstFailedCmd) return base;
+        const cmdName = typeof firstFailedCmd.displayCommand === "string" ? firstFailedCmd.displayCommand : typeof firstFailedCmd.command === "string" ? [firstFailedCmd.command, ...Array.isArray(firstFailedCmd.args) ? firstFailedCmd.args : []].join(" ").trim() : typeof firstFailedCmd.cmd === "string" ? firstFailedCmd.cmd : "";
+        const rawOutput = [firstFailedCmd.stdout, firstFailedCmd.stderr, firstFailedCmd.output].filter((s2) => typeof s2 === "string" && s2.length > 0).join("\n");
+        const tail = rawOutput.length > 800 ? rawOutput.slice(-800) : rawOutput;
+        return [
+          base,
+          cmdName ? `First failing command: ${cmdName}` : "",
+          tail ? `Output (tail):
 ${tail}` : ""
-          ].filter(Boolean).join("\n");
-        };
-        return {
-          success: false,
-          code: validationSummary.failureCode || "validation_failed",
-          convergenceStatus: "blocked_review",
-          error: buildValidationFailedError(),
+        ].filter(Boolean).join("\n");
+      };
+      return { kind: "terminal", result: {
+        success: false,
+        code: validationSummary.failureCode || "validation_failed",
+        convergenceStatus: "blocked_review",
+        error: buildValidationFailedError(),
+        branch,
+        into: baseBranch,
+        validationSummary,
+        refineStages,
+        finalBranchConvergenceState: {
           branch,
-          into: baseBranch,
-          validationSummary,
-          refineStages,
-          finalBranchConvergenceState: {
-            branch,
-            baseBranch,
-            merged: false,
-            removed: false,
-            validation: "failed",
-            status: "blocked_review"
-          }
-        };
-      }
-      if (validationSummary.status === "skipped") {
-        return {
-          success: false,
-          code: "validation_unavailable",
-          convergenceStatus: "blocked_review",
-          error: "Refinery validation gate is required but no allowlisted validation command was available; merge/refine was not attempted.",
+          baseBranch,
+          merged: false,
+          removed: false,
+          validation: "failed",
+          status: "blocked_review"
+        }
+      } };
+    }
+    if (validationSummary.status === "skipped") {
+      return { kind: "terminal", result: {
+        success: false,
+        code: "validation_unavailable",
+        convergenceStatus: "blocked_review",
+        error: "Refinery validation gate is required but no allowlisted validation command was available; merge/refine was not attempted.",
+        branch,
+        into: baseBranch,
+        validationSummary,
+        refineStages,
+        finalBranchConvergenceState: {
           branch,
-          into: baseBranch,
-          validationSummary,
-          refineStages,
-          finalBranchConvergenceState: {
-            branch,
-            baseBranch,
-            merged: false,
-            removed: false,
-            validation: "unavailable",
-            status: "blocked_review"
-          }
-        };
+          baseBranch,
+          merged: false,
+          removed: false,
+          validation: "unavailable",
+          status: "blocked_review"
+        }
+      } };
+    }
+    return { kind: "continue", ctx };
+  }
+  /**
+   * patch_equivalence stage: preflight that the worktree branch's cumulative
+   * patch is equivalent to base+branch. On a "behind base" branch, auto-rebase
+   * once and re-check; on an empty merge-tree with real branch changes, treat as
+   * already-merged-via-another-path and short-circuit to cleanup. Mutates the
+   * context's branchHead (after rebase) and patchEquivalence (rebased gate).
+   */
+  async refinePatchEquivalenceStage(ctx) {
+    const { meshId, nodeId, args, repoRoot, baseHead, node, branch, baseBranch, validationSummary, refineStages, execFileAsync: execFileAsync4 } = ctx;
+    let branchHead = ctx.branchHead;
+    const patchEquivalenceStarted = Date.now();
+    let patchEquivalence = await runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead);
+    recordMeshRefineStage(refineStages, "patch_equivalence", patchEquivalence.status, patchEquivalenceStarted, {
+      equivalent: patchEquivalence.equivalent,
+      expectedPatchId: patchEquivalence.expectedPatchId,
+      actualPatchId: patchEquivalence.actualPatchId,
+      error: patchEquivalence.error,
+      actionableHint: patchEquivalence.actionableHint
+    });
+    if (!patchEquivalence.equivalent) {
+      let didAutoRebase = false;
+      let isBehindBase = false;
+      try {
+        (0, import_node_child_process6.execFileSync)("git", ["merge-base", "--is-ancestor", branchHead, baseHead], {
+          cwd: node.workspace,
+          stdio: "ignore"
+        });
+        isBehindBase = true;
+      } catch {
       }
-      const patchEquivalenceStarted = Date.now();
-      let patchEquivalence = await runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead);
-      recordMeshRefineStage(refineStages, "patch_equivalence", patchEquivalence.status, patchEquivalenceStarted, {
-        equivalent: patchEquivalence.equivalent,
-        expectedPatchId: patchEquivalence.expectedPatchId,
-        actualPatchId: patchEquivalence.actualPatchId,
-        error: patchEquivalence.error,
-        actionableHint: patchEquivalence.actionableHint
-      });
-      if (!patchEquivalence.equivalent) {
-        let didAutoRebase = false;
-        let isBehindBase = false;
+      if (isBehindBase) {
+        const autoRebaseStarted = Date.now();
         try {
-          (0, import_node_child_process6.execFileSync)("git", ["merge-base", "--is-ancestor", branchHead, baseHead], {
+          (0, import_node_child_process6.execFileSync)("git", ["rebase", baseHead], {
             cwd: node.workspace,
-            stdio: "ignore"
+            stdio: ["ignore", "pipe", "pipe"]
           });
-          isBehindBase = true;
-        } catch {
-        }
-        if (isBehindBase) {
-          const autoRebaseStarted = Date.now();
-          try {
-            (0, import_node_child_process6.execFileSync)("git", ["rebase", baseHead], {
-              cwd: node.workspace,
-              stdio: ["ignore", "pipe", "pipe"]
-            });
-            const { stdout: rebasedHeadStdout } = await execFileAsync4("git", ["rev-parse", "HEAD"], { cwd: node.workspace, encoding: "utf8" });
-            branchHead = rebasedHeadStdout.trim();
-            const rebasedPatchEquivalence = await runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead);
-            recordMeshRefineStage(refineStages, "patch_equivalence_after_auto_rebase", rebasedPatchEquivalence.status, autoRebaseStarted, {
-              equivalent: rebasedPatchEquivalence.equivalent,
-              expectedPatchId: rebasedPatchEquivalence.expectedPatchId,
-              actualPatchId: rebasedPatchEquivalence.actualPatchId,
-              error: rebasedPatchEquivalence.error,
-              rebasedBranchHead: branchHead
-            });
-            if (rebasedPatchEquivalence.equivalent) {
-              patchEquivalence = rebasedPatchEquivalence;
-              didAutoRebase = true;
-            } else {
-              return {
-                success: false,
-                code: "needs_rebase",
-                convergenceStatus: "blocked_review",
-                error: "Branch was rebased onto base but patch equivalence still failed; manual intervention required.",
-                branch,
-                into: baseBranch,
-                validationSummary,
-                patchEquivalence: rebasedPatchEquivalence,
-                refineStages,
-                finalBranchConvergenceState: {
-                  branch,
-                  baseBranch,
-                  merged: false,
-                  removed: false,
-                  validation: "passed",
-                  patchEquivalence: "failed",
-                  status: "blocked_review"
-                }
-              };
-            }
-          } catch (rebaseErr) {
-            try {
-              (0, import_node_child_process6.execFileSync)("git", ["rebase", "--abort"], { cwd: node.workspace, stdio: "ignore" });
-            } catch {
-            }
-            recordMeshRefineStage(refineStages, "patch_equivalence_after_auto_rebase", "failed", autoRebaseStarted, {
-              error: rebaseErr?.message || String(rebaseErr)
-            });
-            return {
+          const { stdout: rebasedHeadStdout } = await execFileAsync4("git", ["rev-parse", "HEAD"], { cwd: node.workspace, encoding: "utf8" });
+          branchHead = rebasedHeadStdout.trim();
+          const rebasedPatchEquivalence = await runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead);
+          recordMeshRefineStage(refineStages, "patch_equivalence_after_auto_rebase", rebasedPatchEquivalence.status, autoRebaseStarted, {
+            equivalent: rebasedPatchEquivalence.equivalent,
+            expectedPatchId: rebasedPatchEquivalence.expectedPatchId,
+            actualPatchId: rebasedPatchEquivalence.actualPatchId,
+            error: rebasedPatchEquivalence.error,
+            rebasedBranchHead: branchHead
+          });
+          if (rebasedPatchEquivalence.equivalent) {
+            patchEquivalence = rebasedPatchEquivalence;
+            didAutoRebase = true;
+          } else {
+            return { kind: "terminal", result: {
               success: false,
-              code: "needs_rebase_with_conflicts",
+              code: "needs_rebase",
               convergenceStatus: "blocked_review",
-              error: "Branch is behind base and auto-rebase failed due to conflicts; resolve conflicts manually and retry.",
+              error: "Branch was rebased onto base but patch equivalence still failed; manual intervention required.",
               branch,
               into: baseBranch,
               validationSummary,
-              patchEquivalence,
+              patchEquivalence: rebasedPatchEquivalence,
               refineStages,
               finalBranchConvergenceState: {
                 branch,
@@ -51265,16 +52308,21 @@ ${tail}` : ""
                 patchEquivalence: "failed",
                 status: "blocked_review"
               }
-            };
+            } };
           }
-        }
-        const alreadyMergedViaOtherPath = !patchEquivalence.actualPatchId && !!patchEquivalence.expectedPatchId;
-        if (!didAutoRebase && !alreadyMergedViaOtherPath) {
-          return {
+        } catch (rebaseErr) {
+          try {
+            (0, import_node_child_process6.execFileSync)("git", ["rebase", "--abort"], { cwd: node.workspace, stdio: "ignore" });
+          } catch {
+          }
+          recordMeshRefineStage(refineStages, "patch_equivalence_after_auto_rebase", "failed", autoRebaseStarted, {
+            error: rebaseErr?.message || String(rebaseErr)
+          });
+          return { kind: "terminal", result: {
             success: false,
-            code: "patch_equivalence_failed",
+            code: "needs_rebase_with_conflicts",
             convergenceStatus: "blocked_review",
-            error: "Refinery patch-equivalence preflight failed; merge/refine was not attempted.",
+            error: "Branch is behind base and auto-rebase failed due to conflicts; resolve conflicts manually and retry.",
             branch,
             into: baseBranch,
             validationSummary,
@@ -51289,188 +52337,20 @@ ${tail}` : ""
               patchEquivalence: "failed",
               status: "blocked_review"
             }
-          };
-        }
-        if (!didAutoRebase && alreadyMergedViaOtherPath) {
-          recordMeshRefineStage(refineStages, "merge", "skipped", Date.now(), {
-            reason: "already_merged_via_other_path",
-            note: "actualPatchId is empty; branch content is already present in base via a different commit path"
-          });
-          const cleanupStarted2 = Date.now();
-          const removeResult2 = await this.execute("remove_mesh_node", {
-            meshId,
-            nodeId,
-            sessionCleanupMode: "preserve",
-            inlineMesh: args?.inlineMesh
-          });
-          recordMeshRefineStage(refineStages, "cleanup", removeResult2?.success === false ? "failed" : "passed", cleanupStarted2, {
-            removed: removeResult2?.removed,
-            code: removeResult2?.code,
-            error: removeResult2?.error
-          });
-          try {
-            const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
-            appendLedgerEntry2(meshId, {
-              kind: "node_removed",
-              nodeId,
-              payload: { alreadyMergedViaOtherPath: true, branch, into: baseBranch, validationSummary, patchEquivalence }
-            });
-          } catch {
-          }
-          return {
-            success: removeResult2?.success !== false,
-            code: "already_merged",
-            merged: false,
-            alreadyMergedViaOtherPath: true,
-            branch,
-            into: baseBranch,
-            removeResult: removeResult2,
-            validationSummary,
-            patchEquivalence,
-            refineStages,
-            finalBranchConvergenceState: {
-              branch: baseBranch,
-              mergedBranch: branch,
-              baseBranch,
-              merged: false,
-              alreadyMergedViaOtherPath: true,
-              removed: removeResult2?.success !== false,
-              validation: "passed",
-              patchEquivalence: "already_merged",
-              status: removeResult2?.success === false ? "merged_cleanup_failed" : "merged_to_main"
-            }
-          };
+          } };
         }
       }
-      const submoduleReachabilityStarted = Date.now();
-      const autoPublishSubmoduleMainCommits = resolveRefineryAutoPublishSubmoduleMainCommits(mesh, node.workspace);
-      const submoduleReachability = await runMeshRefineSubmoduleReachabilityGate(repoRoot, patchEquivalence.mergedTree || branchHead, {
-        allowAutoPublishSubmoduleMainCommits: autoPublishSubmoduleMainCommits.enabled,
-        autoPublishPolicySource: autoPublishSubmoduleMainCommits.source,
-        worktreeRoot: node.workspace
-      });
-      recordMeshRefineStage(refineStages, "submodule_reachability", submoduleReachability.status, submoduleReachabilityStarted, {
-        checked: submoduleReachability.checked,
-        autoPublishAllowed: submoduleReachability.autoPublishAllowed,
-        autoPublishPolicySource: submoduleReachability.autoPublishPolicySource,
-        autoPublished: submoduleReachability.entries.filter((entry) => entry.autoPublishAttempted).map((entry) => ({
-          path: entry.path,
-          commit: entry.commit,
-          remote: entry.remote,
-          remoteUrl: entry.remoteUrl,
-          remoteMainBranch: entry.remoteMainBranch,
-          refspec: entry.autoPublishRefspec,
-          succeeded: entry.autoPublishSucceeded,
-          verified: entry.autoPublishVerified,
-          remoteMainReachable: entry.remoteMainReachable,
-          error: entry.error
-        })),
-        autoPublishSkipped: submoduleReachability.entries.filter((entry) => entry.autoPublishAllowed === true && entry.autoPublishAttempted !== true).map((entry) => ({
-          path: entry.path,
-          commit: entry.commit,
-          remote: entry.remote,
-          remoteUrl: entry.remoteUrl,
-          remoteMainBranch: entry.remoteMainBranch,
-          reason: entry.autoPublishSkippedReason || entry.error || "auto-publish was allowed but no publish attempt was possible"
-        })),
-        unreachable: submoduleReachability.unreachable.map((entry) => ({
-          path: entry.path,
-          commit: entry.commit,
-          publishRequired: entry.publishRequired === true,
-          autoPublishAllowed: entry.autoPublishAllowed,
-          autoPublishAttempted: entry.autoPublishAttempted,
-          autoPublishSucceeded: entry.autoPublishSucceeded,
-          autoPublishVerified: entry.autoPublishVerified,
-          autoPublishRefspec: entry.autoPublishRefspec,
-          autoPublishSkippedReason: entry.autoPublishSkippedReason,
-          remote: entry.remote,
-          remoteUrl: entry.remoteUrl,
-          remoteReachable: entry.remoteReachable,
-          remoteMainBranch: entry.remoteMainBranch,
-          remoteMainReachable: entry.remoteMainReachable,
-          error: entry.error
-        })),
-        error: submoduleReachability.error
-      });
-      if (submoduleReachability.status === "failed") {
-        const nextStep = buildSubmodulePublishRequiredNextStep(submoduleReachability.unreachable);
-        return {
-          success: false,
-          code: "submodule_reachability_failed",
-          convergenceStatus: "blocked_review",
-          publishRequired: true,
-          blockedReason: "submodule_publish_required",
-          error: "Refinery submodule reachability preflight failed because one or more submodule gitlink commits are not reachable from their configured remote main branch; merge/refine cleanup was not attempted.",
-          nextStep,
-          nextSteps: [
-            "Ask the user for explicit approval before pushing or publishing any submodule commit.",
-            "Push/publish each unreachable submodule commit to the configured submodule remote main branch shown in the evidence.",
-            "Rerun mesh_refine_node after remote reachability is confirmed.",
-            "Do not merge the root branch until every submodule gitlink commit is reachable from submodule origin/main."
-          ],
-          unreachableSubmoduleCommits: submoduleReachability.unreachable.map((entry) => ({
-            path: entry.path,
-            commit: entry.commit,
-            remote: entry.remote,
-            remoteUrl: entry.remoteUrl,
-            remoteReachable: entry.remoteReachable,
-            remoteMainBranch: entry.remoteMainBranch,
-            remoteMainReachable: entry.remoteMainReachable,
-            autoPublishAllowed: entry.autoPublishAllowed,
-            autoPublishAttempted: entry.autoPublishAttempted,
-            autoPublishSucceeded: entry.autoPublishSucceeded,
-            autoPublishVerified: entry.autoPublishVerified,
-            autoPublishRefspec: entry.autoPublishRefspec,
-            autoPublishSkippedReason: entry.autoPublishSkippedReason,
-            error: entry.error
-          })),
-          branch,
-          into: baseBranch,
-          validationSummary,
-          patchEquivalence,
-          submoduleReachability,
-          refineStages,
-          finalBranchConvergenceState: {
-            branch,
-            baseBranch,
-            merged: false,
-            removed: false,
-            validation: "passed",
-            patchEquivalence: "passed",
-            submoduleReachability: "failed",
-            status: "blocked_review",
-            reason: "submodule_publish_required",
-            nextStep
-          }
-        };
-      }
-      const effectiveDiffStarted = Date.now();
-      const effectiveDiff = await runMeshRefineEffectiveDiffGate(repoRoot, baseHead, branchHead);
-      recordMeshRefineStage(refineStages, "effective_diff", effectiveDiff.status, effectiveDiffStarted, {
-        hasEffectiveDiff: effectiveDiff.hasEffectiveDiff,
-        changedPaths: effectiveDiff.changedPaths,
-        submoduleHints: effectiveDiff.submoduleHints,
-        ...effectiveDiff.error ? { error: effectiveDiff.error } : {}
-      });
-      if (effectiveDiff.status === "failed" && !effectiveDiff.hasEffectiveDiff) {
-        const hintLines = (effectiveDiff.submoduleHints || []).map((h) => `  - ${h.path}: ${h.reason}`);
-        const message = [
-          `Refinery no-op guard: branch '${branch}' has no effective root-tree diff against '${baseBranch}' (${baseHead.slice(0, 12)}); nothing would merge.`,
-          "This usually means a submodule (e.g. oss) has commits but the root branch never committed the gitlink (pointer) bump, so the merge would be a silent no-op while the real change never reaches main.",
-          hintLines.length ? `Submodules with uncommitted pointer bumps:
-${hintLines.join("\n")}` : "",
-          `Fix: commit the submodule pointer bump on '${branch}' (git add <submodule-path> && git commit), then re-run refine.`
-        ].filter(Boolean).join("\n");
-        return {
+      const alreadyMergedViaOtherPath = !patchEquivalence.actualPatchId && !!patchEquivalence.expectedPatchId;
+      if (!didAutoRebase && !alreadyMergedViaOtherPath) {
+        return { kind: "terminal", result: {
           success: false,
-          code: "no_effective_diff",
+          code: "patch_equivalence_failed",
           convergenceStatus: "blocked_review",
-          error: message,
+          error: "Refinery patch-equivalence preflight failed; merge/refine was not attempted.",
           branch,
           into: baseBranch,
           validationSummary,
           patchEquivalence,
-          effectiveDiff,
           refineStages,
           finalBranchConvergenceState: {
             branch,
@@ -51478,190 +52358,378 @@ ${hintLines.join("\n")}` : "",
             merged: false,
             removed: false,
             validation: "passed",
-            patchEquivalence: "passed",
-            effectiveDiff: "no_effective_diff",
-            status: "blocked_review",
-            reason: "no_effective_diff",
-            ...effectiveDiff.submoduleHints?.length ? { submoduleHints: effectiveDiff.submoduleHints } : {}
+            patchEquivalence: "failed",
+            status: "blocked_review"
           }
-        };
+        } };
       }
-      let mergeResult;
-      const mergeStarted = Date.now();
-      try {
-        const result = await execFileAsync4("git", ["merge", "--no-ff", branch, "-m", `Auto-merge branch '${branch}' via Refinery`], { cwd: repoRoot, encoding: "utf8" });
-        mergeResult = {
-          stdout: truncateValidationOutput(result.stdout),
-          stderr: truncateValidationOutput(result.stderr),
-          durationMs: Date.now() - mergeStarted
-        };
-        recordMeshRefineStage(refineStages, "merge", "passed", mergeStarted, mergeResult);
-      } catch (e) {
-        recordMeshRefineStage(refineStages, "merge", "failed", mergeStarted, {
-          error: e?.message || String(e),
-          stdout: truncateValidationOutput(e?.stdout),
-          stderr: truncateValidationOutput(e?.stderr)
+      if (!didAutoRebase && alreadyMergedViaOtherPath) {
+        recordMeshRefineStage(refineStages, "merge", "skipped", Date.now(), {
+          reason: "already_merged_via_other_path",
+          note: "actualPatchId is empty; branch content is already present in base via a different commit path"
         });
-        return {
-          success: false,
-          error: `Merge failed (conflicts?): ${e.message}`,
-          validationSummary,
-          patchEquivalence,
-          refineStages,
-          finalBranchConvergenceState: {
-            branch,
-            baseBranch,
-            merged: false,
-            removed: false,
-            validation: "passed",
-            patchEquivalence: "passed",
-            status: "not_mergeable"
-          }
-        };
-      }
-      const submoduleAlignmentStarted = Date.now();
-      const submoduleAlignment = await alignRefinerySubmodulesAfterMerge(repoRoot, baseHead, "HEAD", {
-        submoduleIgnorePaths: Array.isArray(sourceNode?.policy?.submoduleIgnorePaths) ? sourceNode.policy.submoduleIgnorePaths.filter((value) => typeof value === "string") : void 0
-      });
-      if (submoduleAlignment.status !== "skipped") {
-        recordMeshRefineStage(refineStages, "submodule_alignment", submoduleAlignment.status, submoduleAlignmentStarted, {
-          changedGitlinkPaths: submoduleAlignment.changedGitlinkPaths,
-          outOfSyncPaths: submoduleAlignment.outOfSyncPaths,
-          updatedPaths: submoduleAlignment.updatedPaths,
-          verifiedPaths: submoduleAlignment.verifiedPaths,
-          command: submoduleAlignment.command,
-          error: submoduleAlignment.error
+        const cleanupStarted = Date.now();
+        const removeResult = await this.execute("remove_mesh_node", {
+          meshId,
+          nodeId,
+          sessionCleanupMode: "preserve",
+          inlineMesh: args?.inlineMesh
         });
-      }
-      if (submoduleAlignment.status === "failed") {
-        return {
-          success: false,
-          code: "post_merge_submodule_alignment_failed",
-          error: "Refinery merge completed but post-merge submodule checkout alignment failed; run the reported git submodule update command and re-check base workspace status.",
-          merged: true,
+        recordMeshRefineStage(refineStages, "cleanup", removeResult?.success === false ? "failed" : "passed", cleanupStarted, {
+          removed: removeResult?.removed,
+          code: removeResult?.code,
+          error: removeResult?.error
+        });
+        try {
+          const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+          appendLedgerEntry2(meshId, {
+            kind: "node_removed",
+            nodeId,
+            payload: { alreadyMergedViaOtherPath: true, branch, into: baseBranch, validationSummary, patchEquivalence }
+          });
+        } catch {
+        }
+        return { kind: "terminal", result: {
+          success: removeResult?.success !== false,
+          code: "already_merged",
+          merged: false,
+          alreadyMergedViaOtherPath: true,
           branch,
           into: baseBranch,
+          removeResult,
           validationSummary,
           patchEquivalence,
-          submoduleReachability,
-          submoduleAlignment,
-          mergeResult,
           refineStages,
           finalBranchConvergenceState: {
             branch: baseBranch,
             mergedBranch: branch,
             baseBranch,
-            merged: true,
-            removed: false,
+            merged: false,
+            alreadyMergedViaOtherPath: true,
+            removed: removeResult?.success !== false,
             validation: "passed",
-            patchEquivalence: "passed",
-            submoduleReachability: "passed",
-            submoduleAlignment: "failed",
-            status: "post_merge_alignment_failed",
-            nextStep: submoduleAlignment.command || "Run git submodule update --init --recursive for the reported path(s), then re-check base workspace status."
+            patchEquivalence: "already_merged",
+            status: removeResult?.success === false ? "merged_cleanup_failed" : "merged_to_main"
           }
-        };
+        } };
       }
-      const cleanupStarted = Date.now();
-      const refineSessionCleanupMode = this.normalizeMeshSessionCleanupMode(
-        mesh?.policy?.sessionCleanupOnNodeRemove
-      );
-      let refineSessionIds;
-      if (refineSessionCleanupMode !== "preserve" && this.deps.sessionHostControl) {
-        try {
-          const liveSessions = await this.deps.sessionHostControl.listSessions();
-          const workspace = typeof node.workspace === "string" ? node.workspace : "";
-          refineSessionIds = liveSessions.filter((record) => {
-            const sid = typeof record?.sessionId === "string" ? record.sessionId : "";
-            if (!sid) return false;
-            if (readStringValue(record?.meta?.meshCoordinatorFor) === meshId) return false;
-            const boundToNode = readStringValue(record?.meta?.meshNodeId) === nodeId;
-            const matchedByWorkspace = !!workspace && record?.workspace === workspace;
-            return boundToNode || matchedByWorkspace;
-          }).map((record) => String(record.sessionId));
-        } catch {
-          refineSessionIds = void 0;
+    }
+    ctx.branchHead = branchHead;
+    ctx.patchEquivalence = patchEquivalence;
+    return { kind: "continue", ctx };
+  }
+  /**
+   * submodule_reachability stage: verify every submodule gitlink commit that
+   * would land via the merge is reachable from its configured remote main
+   * branch (optionally auto-publishing when policy allows). Blocks the merge
+   * when any commit is unreachable. Stores the result on the context.
+   */
+  async refineSubmoduleReachabilityStage(ctx) {
+    const { mesh, node, repoRoot, branch, baseBranch, branchHead, validationSummary, patchEquivalence, refineStages } = ctx;
+    const submoduleReachabilityStarted = Date.now();
+    const autoPublishSubmoduleMainCommits = resolveRefineryAutoPublishSubmoduleMainCommits(mesh, node.workspace);
+    const submoduleReachability = await runMeshRefineSubmoduleReachabilityGate(repoRoot, patchEquivalence.mergedTree || branchHead, {
+      allowAutoPublishSubmoduleMainCommits: autoPublishSubmoduleMainCommits.enabled,
+      autoPublishPolicySource: autoPublishSubmoduleMainCommits.source,
+      worktreeRoot: node.workspace
+    });
+    recordMeshRefineStage(refineStages, "submodule_reachability", submoduleReachability.status, submoduleReachabilityStarted, {
+      checked: submoduleReachability.checked,
+      autoPublishAllowed: submoduleReachability.autoPublishAllowed,
+      autoPublishPolicySource: submoduleReachability.autoPublishPolicySource,
+      autoPublished: submoduleReachability.entries.filter((entry) => entry.autoPublishAttempted).map((entry) => ({
+        path: entry.path,
+        commit: entry.commit,
+        remote: entry.remote,
+        remoteUrl: entry.remoteUrl,
+        remoteMainBranch: entry.remoteMainBranch,
+        refspec: entry.autoPublishRefspec,
+        succeeded: entry.autoPublishSucceeded,
+        verified: entry.autoPublishVerified,
+        remoteMainReachable: entry.remoteMainReachable,
+        error: entry.error
+      })),
+      autoPublishSkipped: submoduleReachability.entries.filter((entry) => entry.autoPublishAllowed === true && entry.autoPublishAttempted !== true).map((entry) => ({
+        path: entry.path,
+        commit: entry.commit,
+        remote: entry.remote,
+        remoteUrl: entry.remoteUrl,
+        remoteMainBranch: entry.remoteMainBranch,
+        reason: entry.autoPublishSkippedReason || entry.error || "auto-publish was allowed but no publish attempt was possible"
+      })),
+      unreachable: submoduleReachability.unreachable.map((entry) => ({
+        path: entry.path,
+        commit: entry.commit,
+        publishRequired: entry.publishRequired === true,
+        autoPublishAllowed: entry.autoPublishAllowed,
+        autoPublishAttempted: entry.autoPublishAttempted,
+        autoPublishSucceeded: entry.autoPublishSucceeded,
+        autoPublishVerified: entry.autoPublishVerified,
+        autoPublishRefspec: entry.autoPublishRefspec,
+        autoPublishSkippedReason: entry.autoPublishSkippedReason,
+        remote: entry.remote,
+        remoteUrl: entry.remoteUrl,
+        remoteReachable: entry.remoteReachable,
+        remoteMainBranch: entry.remoteMainBranch,
+        remoteMainReachable: entry.remoteMainReachable,
+        error: entry.error
+      })),
+      error: submoduleReachability.error
+    });
+    if (submoduleReachability.status === "failed") {
+      const nextStep = buildSubmodulePublishRequiredNextStep(submoduleReachability.unreachable);
+      return { kind: "terminal", result: {
+        success: false,
+        code: "submodule_reachability_failed",
+        convergenceStatus: "blocked_review",
+        publishRequired: true,
+        blockedReason: "submodule_publish_required",
+        error: "Refinery submodule reachability preflight failed because one or more submodule gitlink commits are not reachable from their configured remote main branch; merge/refine cleanup was not attempted.",
+        nextStep,
+        nextSteps: [
+          "Ask the user for explicit approval before pushing or publishing any submodule commit.",
+          "Push/publish each unreachable submodule commit to the configured submodule remote main branch shown in the evidence.",
+          "Rerun mesh_refine_node after remote reachability is confirmed.",
+          "Do not merge the root branch until every submodule gitlink commit is reachable from submodule origin/main."
+        ],
+        unreachableSubmoduleCommits: submoduleReachability.unreachable.map((entry) => ({
+          path: entry.path,
+          commit: entry.commit,
+          remote: entry.remote,
+          remoteUrl: entry.remoteUrl,
+          remoteReachable: entry.remoteReachable,
+          remoteMainBranch: entry.remoteMainBranch,
+          remoteMainReachable: entry.remoteMainReachable,
+          autoPublishAllowed: entry.autoPublishAllowed,
+          autoPublishAttempted: entry.autoPublishAttempted,
+          autoPublishSucceeded: entry.autoPublishSucceeded,
+          autoPublishVerified: entry.autoPublishVerified,
+          autoPublishRefspec: entry.autoPublishRefspec,
+          autoPublishSkippedReason: entry.autoPublishSkippedReason,
+          error: entry.error
+        })),
+        branch,
+        into: baseBranch,
+        validationSummary,
+        patchEquivalence,
+        submoduleReachability,
+        refineStages,
+        finalBranchConvergenceState: {
+          branch,
+          baseBranch,
+          merged: false,
+          removed: false,
+          validation: "passed",
+          patchEquivalence: "passed",
+          submoduleReachability: "failed",
+          status: "blocked_review",
+          reason: "submodule_publish_required",
+          nextStep
         }
-      }
-      const removeResult = await this.execute("remove_mesh_node", {
-        meshId,
-        nodeId,
-        sessionCleanupMode: refineSessionCleanupMode,
-        ...refineSessionIds && refineSessionIds.length > 0 ? { sessionIds: refineSessionIds } : {},
-        inlineMesh: args?.inlineMesh
+      } };
+    }
+    ctx.submoduleReachability = submoduleReachability;
+    return { kind: "continue", ctx };
+  }
+  /**
+   * effective_diff stage (no-op guard): block a silent no-op merge where the
+   * branch produces no effective root-tree diff against base — typically a
+   * submodule that has commits but whose root-level gitlink (pointer) bump was
+   * never committed, so the merge would land nothing real on main.
+   */
+  async refineEffectiveDiffStage(ctx) {
+    const { repoRoot, baseHead, branchHead, branch, baseBranch, validationSummary, patchEquivalence, refineStages } = ctx;
+    const effectiveDiffStarted = Date.now();
+    const effectiveDiff = await runMeshRefineEffectiveDiffGate(repoRoot, baseHead, branchHead);
+    recordMeshRefineStage(refineStages, "effective_diff", effectiveDiff.status, effectiveDiffStarted, {
+      hasEffectiveDiff: effectiveDiff.hasEffectiveDiff,
+      changedPaths: effectiveDiff.changedPaths,
+      submoduleHints: effectiveDiff.submoduleHints,
+      ...effectiveDiff.error ? { error: effectiveDiff.error } : {}
+    });
+    if (effectiveDiff.status === "failed" && !effectiveDiff.hasEffectiveDiff) {
+      const hintLines = (effectiveDiff.submoduleHints || []).map((h) => `  - ${h.path}: ${h.reason}`);
+      const message = [
+        `Refinery no-op guard: branch '${branch}' has no effective root-tree diff against '${baseBranch}' (${baseHead.slice(0, 12)}); nothing would merge.`,
+        "This usually means a submodule (e.g. oss) has commits but the root branch never committed the gitlink (pointer) bump, so the merge would be a silent no-op while the real change never reaches main.",
+        hintLines.length ? `Submodules with uncommitted pointer bumps:
+${hintLines.join("\n")}` : "",
+        `Fix: commit the submodule pointer bump on '${branch}' (git add <submodule-path> && git commit), then re-run refine.`
+      ].filter(Boolean).join("\n");
+      return { kind: "terminal", result: {
+        success: false,
+        code: "no_effective_diff",
+        convergenceStatus: "blocked_review",
+        error: message,
+        branch,
+        into: baseBranch,
+        validationSummary,
+        patchEquivalence,
+        effectiveDiff,
+        refineStages,
+        finalBranchConvergenceState: {
+          branch,
+          baseBranch,
+          merged: false,
+          removed: false,
+          validation: "passed",
+          patchEquivalence: "passed",
+          effectiveDiff: "no_effective_diff",
+          status: "blocked_review",
+          reason: "no_effective_diff",
+          ...effectiveDiff.submoduleHints?.length ? { submoduleHints: effectiveDiff.submoduleHints } : {}
+        }
+      } };
+    }
+    return { kind: "continue", ctx };
+  }
+  /**
+   * merge + finalize stage: perform the --no-ff merge, align submodule
+   * checkouts after merge, clean up (remove) the worktree node per policy,
+   * append the refinery ledger entry, and (unless approval is required) push the
+   * base branch. Always terminal — produces the final CommandRouterResult.
+   */
+  async refineMergeAndFinalizeStage(ctx) {
+    const { meshId, nodeId, args, repoRoot, baseHead, node, branch, baseBranch, sourceNode, validationSummary, patchEquivalence, submoduleReachability, mesh, refineStages, execFileAsync: execFileAsync4 } = ctx;
+    let mergeResult;
+    const mergeStarted = Date.now();
+    try {
+      const result = await execFileAsync4("git", ["merge", "--no-ff", branch, "-m", `Auto-merge branch '${branch}' via Refinery`], { cwd: repoRoot, encoding: "utf8" });
+      mergeResult = {
+        stdout: truncateValidationOutput(result.stdout),
+        stderr: truncateValidationOutput(result.stderr),
+        durationMs: Date.now() - mergeStarted
+      };
+      recordMeshRefineStage(refineStages, "merge", "passed", mergeStarted, mergeResult);
+    } catch (e) {
+      recordMeshRefineStage(refineStages, "merge", "failed", mergeStarted, {
+        error: e?.message || String(e),
+        stdout: truncateValidationOutput(e?.stdout),
+        stderr: truncateValidationOutput(e?.stderr)
       });
-      recordMeshRefineStage(refineStages, "cleanup", removeResult?.success === false ? "failed" : "passed", cleanupStarted, {
-        removed: removeResult?.removed,
-        code: removeResult?.code,
-        error: removeResult?.error
+      return { kind: "terminal", result: {
+        success: false,
+        error: `Merge failed (conflicts?): ${e.message}`,
+        validationSummary,
+        patchEquivalence,
+        refineStages,
+        finalBranchConvergenceState: {
+          branch,
+          baseBranch,
+          merged: false,
+          removed: false,
+          validation: "passed",
+          patchEquivalence: "passed",
+          status: "not_mergeable"
+        }
+      } };
+    }
+    const submoduleAlignmentStarted = Date.now();
+    const submoduleAlignment = await alignRefinerySubmodulesAfterMerge(repoRoot, baseHead, "HEAD", {
+      submoduleIgnorePaths: Array.isArray(sourceNode?.policy?.submoduleIgnorePaths) ? sourceNode.policy.submoduleIgnorePaths.filter((value) => typeof value === "string") : void 0
+    });
+    if (submoduleAlignment.status !== "skipped") {
+      recordMeshRefineStage(refineStages, "submodule_alignment", submoduleAlignment.status, submoduleAlignmentStarted, {
+        changedGitlinkPaths: submoduleAlignment.changedGitlinkPaths,
+        outOfSyncPaths: submoduleAlignment.outOfSyncPaths,
+        updatedPaths: submoduleAlignment.updatedPaths,
+        verifiedPaths: submoduleAlignment.verifiedPaths,
+        command: submoduleAlignment.command,
+        error: submoduleAlignment.error
       });
-      let ledgerError;
-      const ledgerStarted = Date.now();
-      try {
-        const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
-        appendLedgerEntry2(meshId, {
-          kind: "node_removed",
-          nodeId,
-          payload: { refined: true, mergedBranch: branch, into: baseBranch, validationSummary, patchEquivalence, submoduleReachability, submoduleAlignment }
-        });
-        recordMeshRefineStage(refineStages, "ledger", "passed", ledgerStarted);
-      } catch (e) {
-        ledgerError = e?.message || String(e);
-        recordMeshRefineStage(refineStages, "ledger", "failed", ledgerStarted, { error: ledgerError });
-      }
-      const finalBranchConvergenceState = {
-        branch: baseBranch,
-        mergedBranch: branch,
-        baseBranch,
+    }
+    if (submoduleAlignment.status === "failed") {
+      return { kind: "terminal", result: {
+        success: false,
+        code: "post_merge_submodule_alignment_failed",
+        error: "Refinery merge completed but post-merge submodule checkout alignment failed; run the reported git submodule update command and re-check base workspace status.",
         merged: true,
-        removed: removeResult?.success !== false,
-        validation: "passed",
-        patchEquivalence: "passed",
-        submoduleAlignment: submoduleAlignment.status,
-        status: removeResult?.success === false ? "merged_cleanup_failed" : "merged"
-      };
-      if (removeResult?.success === false) {
-        return {
-          success: false,
-          code: "cleanup_failed",
-          error: "Refinery merge completed but worktree cleanup failed; manual cleanup/retry is required.",
+        branch,
+        into: baseBranch,
+        validationSummary,
+        patchEquivalence,
+        submoduleReachability,
+        submoduleAlignment,
+        mergeResult,
+        refineStages,
+        finalBranchConvergenceState: {
+          branch: baseBranch,
+          mergedBranch: branch,
+          baseBranch,
           merged: true,
-          branch,
-          into: baseBranch,
-          removeResult,
-          validationSummary,
-          patchEquivalence,
-          submoduleReachability,
-          submoduleAlignment,
-          mergeResult,
-          refineStages,
-          ...ledgerError ? { ledgerError } : {},
-          finalBranchConvergenceState
-        };
-      }
-      const requireApprovalForPush = mesh?.policy?.requireApprovalForPush ?? DEFAULT_MESH_POLICY.requireApprovalForPush;
-      let pushResult;
-      if (!requireApprovalForPush) {
-        const pushStarted = Date.now();
-        try {
-          await execFileAsync4("git", ["push", "origin", baseBranch], { cwd: repoRoot, encoding: "utf8" });
-          pushResult = { pushed: true, remote: "origin", branch: baseBranch, durationMs: Date.now() - pushStarted };
-          recordMeshRefineStage(refineStages, "push", "passed", pushStarted, pushResult);
-          finalBranchConvergenceState.status = "merged_pushed";
-        } catch (e) {
-          pushResult = {
-            pushed: false,
-            remote: "origin",
-            branch: baseBranch,
-            error: e?.message || String(e),
-            stderr: e?.stderr,
-            durationMs: Date.now() - pushStarted
-          };
-          recordMeshRefineStage(refineStages, "push", "failed", pushStarted, pushResult);
-        }
+          removed: false,
+          validation: "passed",
+          patchEquivalence: "passed",
+          submoduleReachability: "passed",
+          submoduleAlignment: "failed",
+          status: "post_merge_alignment_failed",
+          nextStep: submoduleAlignment.command || "Run git submodule update --init --recursive for the reported path(s), then re-check base workspace status."
+        }
+      } };
+    }
+    const cleanupStarted = Date.now();
+    const refineSessionCleanupMode = this.normalizeMeshSessionCleanupMode(
+      mesh?.policy?.sessionCleanupOnNodeRemove
+    );
+    let refineSessionIds;
+    if (refineSessionCleanupMode !== "preserve" && this.deps.sessionHostControl) {
+      try {
+        const liveSessions = await this.deps.sessionHostControl.listSessions();
+        const workspace = typeof node.workspace === "string" ? node.workspace : "";
+        refineSessionIds = liveSessions.filter((record) => {
+          const sid = typeof record?.sessionId === "string" ? record.sessionId : "";
+          if (!sid) return false;
+          if (readStringValue(record?.meta?.meshCoordinatorFor) === meshId) return false;
+          const boundToNode = readStringValue(record?.meta?.meshNodeId) === nodeId;
+          const matchedByWorkspace = !!workspace && record?.workspace === workspace;
+          return boundToNode || matchedByWorkspace;
+        }).map((record) => String(record.sessionId));
+      } catch {
+        refineSessionIds = void 0;
       }
-      return {
-        success: true,
+    }
+    const removeResult = await this.execute("remove_mesh_node", {
+      meshId,
+      nodeId,
+      sessionCleanupMode: refineSessionCleanupMode,
+      ...refineSessionIds && refineSessionIds.length > 0 ? { sessionIds: refineSessionIds } : {},
+      inlineMesh: args?.inlineMesh
+    });
+    recordMeshRefineStage(refineStages, "cleanup", removeResult?.success === false ? "failed" : "passed", cleanupStarted, {
+      removed: removeResult?.removed,
+      code: removeResult?.code,
+      error: removeResult?.error
+    });
+    let ledgerError;
+    const ledgerStarted = Date.now();
+    try {
+      const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+      appendLedgerEntry2(meshId, {
+        kind: "node_removed",
+        nodeId,
+        payload: { refined: true, mergedBranch: branch, into: baseBranch, validationSummary, patchEquivalence, submoduleReachability, submoduleAlignment }
+      });
+      recordMeshRefineStage(refineStages, "ledger", "passed", ledgerStarted);
+    } catch (e) {
+      ledgerError = e?.message || String(e);
+      recordMeshRefineStage(refineStages, "ledger", "failed", ledgerStarted, { error: ledgerError });
+    }
+    const finalBranchConvergenceState = {
+      branch: baseBranch,
+      mergedBranch: branch,
+      baseBranch,
+      merged: true,
+      removed: removeResult?.success !== false,
+      validation: "passed",
+      patchEquivalence: "passed",
+      submoduleAlignment: submoduleAlignment.status,
+      status: removeResult?.success === false ? "merged_cleanup_failed" : "merged"
+    };
+    if (removeResult?.success === false) {
+      return { kind: "terminal", result: {
+        success: false,
+        code: "cleanup_failed",
+        error: "Refinery merge completed but worktree cleanup failed; manual cleanup/retry is required.",
         merged: true,
         branch,
         into: baseBranch,
@@ -51673,17 +52741,51 @@ ${hintLines.join("\n")}` : "",
         mergeResult,
         refineStages,
         ...ledgerError ? { ledgerError } : {},
-        finalBranchConvergenceState,
-        // Push outcome or readiness info for coordinator.
-        ...pushResult ? { pushResult } : {
-          pushReady: true,
-          pushCommand: `git push origin ${baseBranch}`,
-          pushNote: "requireApprovalForPush is enabled \u2014 run the push command or obtain user approval before pushing."
-        }
-      };
-    } catch (e) {
-      return { success: false, error: e.message, refineStages };
+        finalBranchConvergenceState
+      } };
     }
+    const requireApprovalForPush = mesh?.policy?.requireApprovalForPush ?? DEFAULT_MESH_POLICY.requireApprovalForPush;
+    let pushResult;
+    if (!requireApprovalForPush) {
+      const pushStarted = Date.now();
+      try {
+        await execFileAsync4("git", ["push", "origin", baseBranch], { cwd: repoRoot, encoding: "utf8" });
+        pushResult = { pushed: true, remote: "origin", branch: baseBranch, durationMs: Date.now() - pushStarted };
+        recordMeshRefineStage(refineStages, "push", "passed", pushStarted, pushResult);
+        finalBranchConvergenceState.status = "merged_pushed";
+      } catch (e) {
+        pushResult = {
+          pushed: false,
+          remote: "origin",
+          branch: baseBranch,
+          error: e?.message || String(e),
+          stderr: e?.stderr,
+          durationMs: Date.now() - pushStarted
+        };
+        recordMeshRefineStage(refineStages, "push", "failed", pushStarted, pushResult);
+      }
+    }
+    return { kind: "terminal", result: {
+      success: true,
+      merged: true,
+      branch,
+      into: baseBranch,
+      removeResult,
+      validationSummary,
+      patchEquivalence,
+      submoduleReachability,
+      submoduleAlignment,
+      mergeResult,
+      refineStages,
+      ...ledgerError ? { ledgerError } : {},
+      finalBranchConvergenceState,
+      // Push outcome or readiness info for coordinator.
+      ...pushResult ? { pushResult } : {
+        pushReady: true,
+        pushCommand: `git push origin ${baseBranch}`,
+        pushNote: "requireApprovalForPush is enabled \u2014 run the push command or obtain user approval before pushing."
+      }
+    } };
   }
   /**
    * Batch refinery: converge multiple sibling worktree nodes onto the base branch
@@ -52241,929 +53343,9 @@ ${hintLines.join("\n")}` : "",
     if (medFamilyHandler) {
       return await medFamilyHandler(this.buildMedFamilyContext(), args);
     }
-    switch (cmd) {
-      // ─── CLI / ACP commands ───
-      case "mesh_forward_event": {
-        return handleMeshForwardEvent({ instanceManager: this.deps.instanceManager }, args);
-      }
-      case "get_pending_mesh_events": {
-        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-        const coordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : void 0;
-        const events = drainPendingMeshCoordinatorEvents(meshId || void 0, coordinatorDaemonId);
-        return { success: true, events };
-      }
-      case "interactive_prompt_response": {
-        const sessionId = typeof args?.targetSessionId === "string" && args.targetSessionId.trim() ? args.targetSessionId.trim() : typeof args?.sessionId === "string" && args.sessionId.trim() ? args.sessionId.trim() : "";
-        if (!sessionId) return { success: false, error: "targetSessionId required" };
-        const response = normalizeInteractivePromptResponse(args?.response ?? args);
-        const instance = this.deps.instanceManager.getInstance(sessionId);
-        if (!instance) return { success: false, error: `No running instance for session ${sessionId}` };
-        this.deps.instanceManager.sendEvent(sessionId, "interactive_prompt_response", response);
-        return { success: true };
-      }
-      // ─── Mesh Coordinator Launch ───
-      case "launch_mesh_coordinator": {
-        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-        let cliType = typeof args?.cliType === "string" ? args.cliType.trim() : "";
-        const extraSystemPrompt = typeof args?.extraSystemPrompt === "string" ? args.extraSystemPrompt.trim() : "";
-        if (!meshId) return { success: false, error: "meshId required" };
-        try {
-          const { buildCoordinatorSystemPrompt: buildCoordinatorSystemPrompt2 } = await Promise.resolve().then(() => (init_coordinator_prompt(), coordinator_prompt_exports));
-          const { buildMissionPromptSection: buildMissionPromptSection2 } = await Promise.resolve().then(() => (init_mesh_missions(), mesh_missions_exports));
-          const buildMissionSectionBestEffort = (id) => {
-            try {
-              return buildMissionPromptSection2(id);
-            } catch {
-              return "";
-            }
-          };
-          let mesh;
-          if (args?.inlineMesh && typeof args.inlineMesh === "object") {
-            mesh = args.inlineMesh;
-            this.inlineMeshCache.set(meshId, mesh);
-          } else {
-            const { getMesh: getMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-            mesh = getMesh2(meshId);
-          }
-          if (!mesh) return { success: false, error: "Mesh not found" };
-          const meshHost = resolveMeshHostStatus(mesh);
-          if (!meshHost.canOwnCoordinator) {
-            return {
-              success: false,
-              ...buildMeshHostRequiredFailure(mesh, "coordinator launch"),
-              meshId,
-              cliType
-            };
-          }
-          if (!Array.isArray(mesh.nodes) || mesh.nodes.length === 0) return { success: false, error: "No nodes in mesh" };
-          const requestedCoordinatorNodeId = typeof args?.coordinatorNodeId === "string" ? args.coordinatorNodeId.trim() : "";
-          const preferredCoordinatorNodeId = requestedCoordinatorNodeId || (typeof mesh.coordinator?.preferredNodeId === "string" ? mesh.coordinator.preferredNodeId.trim() : "");
-          const coordinatorNode = preferredCoordinatorNodeId ? mesh.nodes.find((node) => node?.id === preferredCoordinatorNodeId || node?.nodeId === preferredCoordinatorNodeId) : mesh.nodes[0];
-          if (!coordinatorNode) {
-            return {
-              success: false,
-              code: "mesh_coordinator_node_not_found",
-              error: `Coordinator node ${preferredCoordinatorNodeId} was not found in mesh`,
-              meshId,
-              cliType
-            };
-          }
-          const sessionHostRecords = this.deps.sessionHostControl?.listSessions ? await this.deps.sessionHostControl.listSessions().catch(() => []) : [];
-          const liveMeshSessions = partitionSessionHostRecords(Array.isArray(sessionHostRecords) ? sessionHostRecords : []).liveRuntimes;
-          const workspace = readLiveMeshNodeWorkspace({
-            meshId,
-            nodeId: String(normalizeMeshNodeId(coordinatorNode) || preferredCoordinatorNodeId || ""),
-            liveSessionRecords: liveMeshSessions,
-            allowCoordinatorSession: true
-          }) || (typeof coordinatorNode.workspace === "string" ? coordinatorNode.workspace.trim() : "");
-          if (!workspace) return { success: false, error: "Coordinator node workspace required", meshId, cliType };
-          if (!cliType) {
-            const resolved = await resolveProviderTypeFromPriority({
-              nodeId: String(normalizeMeshNodeId(coordinatorNode) || preferredCoordinatorNodeId || "coordinator"),
-              providerPriority: readProviderPriorityFromPolicy(coordinatorNode.policy),
-              providerLoader: this.deps.providerLoader,
-              onStatusChange: this.deps.onStatusChange
-            });
-            if (!resolved.providerType) {
-              return {
-                success: false,
-                code: "mesh_coordinator_provider_priority_unusable",
-                error: resolved.error || "No usable provider found from node providerPriority",
-                meshId,
-                cliType,
-                workspace
-              };
-            }
-            cliType = resolved.providerType;
-          }
-          const providerMeta = this.deps.providerLoader.resolve?.(cliType) || this.deps.providerLoader.getMeta(cliType);
-          const coordinatorSetup = resolveMeshCoordinatorSetup({
-            provider: providerMeta,
-            cliType,
-            meshId,
-            workspace
-          });
-          if (coordinatorSetup.kind === "unsupported") {
-            return {
-              success: false,
-              code: "mesh_coordinator_unsupported",
-              error: coordinatorSetup.reason,
-              meshId,
-              cliType,
-              workspace
-            };
-          }
-          if (coordinatorSetup.kind === "manual") {
-            return {
-              success: false,
-              code: "mesh_coordinator_manual_mcp_setup_required",
-              error: coordinatorSetup.instructions,
-              meshId,
-              cliType,
-              workspace,
-              meshCoordinatorSetup: coordinatorSetup
-            };
-          }
-          if (coordinatorSetup.kind === "cli_command") {
-            let cliCmdSystemPrompt = "";
-            try {
-              cliCmdSystemPrompt = buildCoordinatorSystemPrompt2({ mesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || void 0, missionSection: buildMissionSectionBestEffort(mesh.id) });
-            } catch (error) {
-              const message = error?.message || String(error);
-              LOG.error("MeshCoordinator", `Failed to build coordinator prompt: ${message}`);
-              return {
-                success: false,
-                code: "mesh_coordinator_prompt_failed",
-                error: `Failed to build Repo Mesh coordinator prompt: ${message}`,
-                meshId,
-                cliType,
-                workspace
-              };
-            }
-            let mcpRegistrationOk = false;
-            let mcpRegistrationFailure = null;
-            try {
-              const { buildMeshCoordinatorRegistrationPlan: buildMeshCoordinatorRegistrationPlan2, execUnderPty: execUnderPty2 } = await Promise.resolve().then(() => (init_mesh_coordinator(), mesh_coordinator_exports));
-              const registrationPlan = buildMeshCoordinatorRegistrationPlan2(
-                cliType,
-                coordinatorSetup.serverName,
-                coordinatorSetup.command
-              );
-              for (const step of registrationPlan) {
-                const renderedCommand = [step.command, ...step.args].join(" ");
-                LOG.info("MeshCoordinator", `Running MCP ${step.label} (pty): ${renderedCommand}`);
-                const ptyResult = await execUnderPty2(step.command, step.args, { cwd: workspace, timeoutMs: 2e4 });
-                if (ptyResult.exitCode === 0 && !ptyResult.timedOut) {
-                  if (step.required) mcpRegistrationOk = true;
-                  continue;
-                }
-                LOG.warn("MeshCoordinator", `MCP ${step.label} failed exit=${ptyResult.exitCode} signal=${ptyResult.signal} timedOut=${ptyResult.timedOut} \u2014 output:
-${ptyResult.output.slice(-2e3)}`);
-                if (step.required) {
-                  mcpRegistrationFailure = {
-                    command: renderedCommand,
-                    output: ptyResult.output.slice(-2e3),
-                    exitCode: ptyResult.exitCode,
-                    signal: ptyResult.signal,
-                    timedOut: ptyResult.timedOut
-                  };
-                  break;
-                }
-              }
-            } catch (error) {
-              LOG.warn("MeshCoordinator", `MCP registration command failed: ${error?.message || error}`);
-              mcpRegistrationFailure = {
-                command: coordinatorSetup.command,
-                output: error?.message || String(error),
-                exitCode: null,
-                signal: null,
-                timedOut: false
-              };
-            }
-            if (!mcpRegistrationOk) {
-              return {
-                success: false,
-                code: "mesh_coordinator_mcp_registration_failed",
-                error: `Could not register ${coordinatorSetup.serverName}; coordinator session was not launched`,
-                meshId,
-                cliType,
-                workspace,
-                registration: mcpRegistrationFailure
-              };
-            }
-            if (cliType === "codex-cli") {
-              const repoMcpConfigPath = (0, import_path12.join)(workspace, ".mcp.json");
-              if (fs27.existsSync(repoMcpConfigPath)) {
-                try {
-                  const repoMcpConfig = parseMeshCoordinatorMcpConfig(
-                    fs27.readFileSync(repoMcpConfigPath, "utf-8"),
-                    "claude_mcp_json"
-                  );
-                  const existingServers2 = repoMcpConfig.mcpServers;
-                  if (existingServers2 && typeof existingServers2 === "object" && !Array.isArray(existingServers2) && existingServers2[coordinatorSetup.serverName]) {
-                    fs27.writeFileSync(repoMcpConfigPath, serializeMeshCoordinatorMcpConfig({
-                      ...repoMcpConfig,
-                      mcpServers: {
-                        ...existingServers2,
-                        [coordinatorSetup.serverName]: coordinatorSetup.mcpServer
-                      }
-                    }, "claude_mcp_json"), "utf-8");
-                    LOG.info("MeshCoordinator", `Refreshed repo-local ${repoMcpConfigPath} entry for ${coordinatorSetup.serverName}`);
-                  }
-                } catch (error) {
-                  return {
-                    success: false,
-                    code: "mesh_coordinator_config_write_failed",
-                    error: `Could not refresh repo-local MCP config: ${error?.message || error}`,
-                    meshId,
-                    cliType,
-                    workspace
-                  };
-                }
-              }
-            }
-            const cliCmdArgs = [];
-            const cliCmdEnv = {};
-            let cliCmdContextFilePath;
-            if (cliCmdSystemPrompt) {
-              const { applyMeshCoordinatorSystemPromptInjection: applyMeshCoordinatorSystemPromptInjection2 } = await Promise.resolve().then(() => (init_mesh_coordinator(), mesh_coordinator_exports));
-              const effect = applyMeshCoordinatorSystemPromptInjection2(
-                cliCmdSystemPrompt,
-                providerMeta?.meshCoordinator?.systemPromptInjection,
-                { cliArgs: cliCmdArgs, launchEnv: cliCmdEnv, workspace, cliType }
-              );
-              cliCmdContextFilePath = effect.contextFilePath;
-            }
-            const cliCmdLaunch = await this.deps.cliManager.handleCliCommand("launch_cli", {
-              cliType,
-              dir: workspace,
-              cliArgs: cliCmdArgs.length > 0 ? cliCmdArgs : void 0,
-              env: Object.keys(cliCmdEnv).length > 0 ? cliCmdEnv : void 0,
-              settings: { meshCoordinatorFor: meshId }
-            });
-            if (cliCmdLaunch?.success && cliCmdContextFilePath) {
-              const stripPath = cliCmdContextFilePath;
-              setTimeout(() => {
-                void Promise.resolve().then(() => (init_mesh_coordinator(), mesh_coordinator_exports)).then(({ stripCoordinatorWrapperFile: stripCoordinatorWrapperFile2 }) => {
-                  stripCoordinatorWrapperFile2(stripPath);
-                  LOG.info("MeshCoordinator", `Stripped wrapper from ${stripPath} after launch settle (cli_command)`);
-                }).catch(() => {
-                });
-              }, 5e3);
-            }
-            if (!cliCmdLaunch?.success) {
-              return { success: false, error: cliCmdLaunch?.error || "Failed to launch CLI session" };
-            }
-            LOG.info("MeshCoordinator", `Launched ${cliType} coordinator (cli_command) for mesh ${meshId}`);
-            const cliCmdSessionId = cliCmdLaunch.sessionId || cliCmdLaunch.id;
-            if (cliCmdSessionId) {
-              const cliCmdInjectionDecl = providerMeta?.meshCoordinator?.systemPromptInjection;
-              registerMeshCoordinator({
-                meshId,
-                sessionId: cliCmdSessionId,
-                workspace,
-                startedAt: Date.now(),
-                cliType,
-                systemPrompt: cliCmdSystemPrompt || void 0,
-                extraSystemPrompt: extraSystemPrompt || void 0,
-                injection: cliCmdInjectionDecl ? {
-                  mode: cliCmdInjectionDecl.mode,
-                  target: "flag" in cliCmdInjectionDecl ? cliCmdInjectionDecl.flag : "name" in cliCmdInjectionDecl ? cliCmdInjectionDecl.name : "path" in cliCmdInjectionDecl ? cliCmdInjectionDecl.path : void 0
-                } : void 0
-              });
-            }
-            try {
-              const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
-              appendLedgerEntry2(meshId, {
-                kind: "coordinator_started",
-                sessionId: cliCmdSessionId,
-                providerType: cliType,
-                payload: { workspace }
-              });
-            } catch {
-            }
-            return {
-              success: true,
-              meshId,
-              cliType,
-              workspace,
-              sessionId: cliCmdSessionId,
-              mcpRegistered: mcpRegistrationOk
-            };
-          }
-          const configFormat = coordinatorSetup.configFormat;
-          if (configFormat !== "claude_mcp_json" && configFormat !== "hermes_config_yaml") {
-            return {
-              success: false,
-              code: "mesh_coordinator_unsupported",
-              error: `Unsupported auto-import MCP config format: ${String(coordinatorSetup.configFormat)}`,
-              meshId,
-              cliType,
-              workspace
-            };
-          }
-          let systemPrompt = "";
-          try {
-            systemPrompt = buildCoordinatorSystemPrompt2({ mesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || void 0, missionSection: buildMissionSectionBestEffort(mesh.id) });
-          } catch (error) {
-            const message = error?.message || String(error);
-            LOG.error("MeshCoordinator", `Failed to build coordinator prompt: ${message}`);
-            return {
-              success: false,
-              code: "mesh_coordinator_prompt_failed",
-              error: `Failed to build Repo Mesh coordinator prompt: ${message}`,
-              meshId,
-              cliType,
-              workspace
-            };
-          }
-          const { existsSync: existsSync47, readFileSync: readFileSync38, writeFileSync: writeFileSync24, copyFileSync: copyFileSync4, mkdirSync: mkdirSync21 } = await import("fs");
-          const { dirname: dirname17 } = await import("path");
-          const mcpConfigPath = coordinatorSetup.configPath;
-          const hermesManualFallback = cliType === "hermes-cli" && configFormat === "hermes_config_yaml" ? createHermesManualMeshCoordinatorSetup(meshId, workspace) : null;
-          let hermesBaseConfig = null;
-          if (hermesManualFallback) {
-            try {
-              hermesBaseConfig = loadHermesCoordinatorBaseConfig(mcpConfigPath);
-            } catch (error) {
-              const message = `Failed to parse Hermes base config for automatic coordinator setup: ${error?.message || error}`;
-              LOG.error("MeshCoordinator", message);
-              return { success: false, code: "mesh_coordinator_config_parse_failed", error: message, meshId, cliType, workspace };
-            }
-          }
-          const returnManualFallback = (message) => ({
-            success: false,
-            code: "mesh_coordinator_manual_mcp_setup_required",
-            error: message,
-            meshId,
-            cliType,
-            workspace,
-            meshCoordinatorSetup: hermesManualFallback
-          });
-          const mcpServerEntry = {
-            command: coordinatorSetup.mcpServer.command,
-            args: coordinatorSetup.mcpServer.args
-          };
-          if (args?.inlineMesh) {
-            const modeArgIndex = coordinatorSetup.mcpServer.args.findIndex((value) => value === "--mode");
-            const mcpTransport = modeArgIndex >= 0 ? coordinatorSetup.mcpServer.args[modeArgIndex + 1] : "ipc";
-            mcpServerEntry.env = {
-              ADHDEV_INLINE_MESH: JSON.stringify(mesh),
-              ADHDEV_MCP_TRANSPORT: mcpTransport === "local" ? "local" : "ipc"
-            };
-          }
-          try {
-            mkdirSync21(dirname17(mcpConfigPath), { recursive: true });
-          } catch (error) {
-            const message = `Could not prepare MCP config path for automatic setup: ${error?.message || error}`;
-            LOG.error("MeshCoordinator", message);
-            if (hermesManualFallback) return returnManualFallback(message);
-            return { success: false, code: "mesh_coordinator_config_write_failed", error: message, meshId, cliType, workspace };
-          }
-          const hadExistingMcpConfig = existsSync47(mcpConfigPath);
-          let existingMcpConfig = hermesBaseConfig?.config || {};
-          if (hermesBaseConfig) {
-            copyHermesCoordinatorCredentialFiles(hermesBaseConfig.sourceHome, dirname17(mcpConfigPath));
-          }
-          if (hadExistingMcpConfig) {
-            try {
-              const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync38(mcpConfigPath, "utf-8"), configFormat);
-              const existingCoordinatorConfig = hermesManualFallback ? stripHermesCoordinatorTempModelProviderOverrides(parsedExistingMcpConfig) : parsedExistingMcpConfig;
-              existingMcpConfig = { ...existingMcpConfig, ...existingCoordinatorConfig };
-              copyFileSync4(mcpConfigPath, mcpConfigPath + ".backup");
-            } catch (error) {
-              LOG.error("MeshCoordinator", `Failed to parse existing MCP config ${mcpConfigPath}: ${error?.message || error}`);
-              return {
-                success: false,
-                code: "mesh_coordinator_config_parse_failed",
-                error: `Failed to parse existing MCP config at ${mcpConfigPath}`
-              };
-            }
-          }
-          const mcpServersKey = getMcpServersKey(configFormat);
-          const existingServers = existingMcpConfig[mcpServersKey];
-          const mcpConfig = {
-            ...existingMcpConfig,
-            [mcpServersKey]: {
-              ...existingServers && typeof existingServers === "object" && !Array.isArray(existingServers) ? existingServers : {},
-              [coordinatorSetup.serverName]: mcpServerEntry
-            }
-          };
-          try {
-            writeFileSync24(mcpConfigPath, serializeMeshCoordinatorMcpConfig(mcpConfig, configFormat), "utf-8");
-          } catch (error) {
-            const message = `Could not write MCP config for automatic setup: ${error?.message || error}`;
-            LOG.error("MeshCoordinator", message);
-            if (hermesManualFallback) return returnManualFallback(message);
-            return { success: false, code: "mesh_coordinator_config_write_failed", error: message, meshId, cliType, workspace };
-          }
-          LOG.info("MeshCoordinator", `Wrote ${mcpConfigPath} with ${coordinatorSetup.serverName} server`);
-          const cliArgs = [];
-          const launchEnv = {};
-          if (configFormat === "hermes_config_yaml") {
-            launchEnv.HERMES_HOME = dirname17(mcpConfigPath);
-            launchEnv.HERMES_IGNORE_USER_CONFIG = "";
-          }
-          let autoImportContextFilePath;
-          if (systemPrompt) {
-            const { applyMeshCoordinatorSystemPromptInjection: applyMeshCoordinatorSystemPromptInjection2 } = await Promise.resolve().then(() => (init_mesh_coordinator(), mesh_coordinator_exports));
-            const effect = applyMeshCoordinatorSystemPromptInjection2(
-              systemPrompt,
-              providerMeta?.meshCoordinator?.systemPromptInjection,
-              { cliArgs, launchEnv, workspace, cliType }
-            );
-            autoImportContextFilePath = effect.contextFilePath;
-          }
-          if (cliType === "claude-cli") {
-            cliArgs.push("--mcp-config", coordinatorSetup.configPath);
-          }
-          const launchResult = await this.deps.cliManager.handleCliCommand("launch_cli", {
-            cliType,
-            dir: workspace,
-            cliArgs: cliArgs.length > 0 ? cliArgs : void 0,
-            env: Object.keys(launchEnv).length > 0 ? launchEnv : void 0,
-            settings: {
-              meshCoordinatorFor: meshId
-            }
-          });
-          if (launchResult?.success && autoImportContextFilePath) {
-            const stripPath = autoImportContextFilePath;
-            setTimeout(() => {
-              void Promise.resolve().then(() => (init_mesh_coordinator(), mesh_coordinator_exports)).then(({ stripCoordinatorWrapperFile: stripCoordinatorWrapperFile2 }) => {
-                stripCoordinatorWrapperFile2(stripPath);
-                LOG.info("MeshCoordinator", `Stripped wrapper from ${stripPath} after launch settle (auto_import)`);
-              }).catch(() => {
-              });
-            }, 5e3);
-          }
-          if (!launchResult?.success) {
-            return { success: false, error: launchResult?.error || "Failed to launch CLI session" };
-          }
-          LOG.info("MeshCoordinator", `Launched ${cliType} coordinator for mesh ${meshId} in ${workspace}`);
-          const launchSessionId = launchResult.sessionId || launchResult.id;
-          if (launchSessionId) {
-            const autoImportInjectionDecl = providerMeta?.meshCoordinator?.systemPromptInjection;
-            registerMeshCoordinator({
-              meshId,
-              sessionId: launchSessionId,
-              workspace,
-              startedAt: Date.now(),
-              cliType,
-              systemPrompt: systemPrompt || void 0,
-              extraSystemPrompt: extraSystemPrompt || void 0,
-              mcpConfigPath,
-              injection: autoImportInjectionDecl ? {
-                mode: autoImportInjectionDecl.mode,
-                target: "flag" in autoImportInjectionDecl ? autoImportInjectionDecl.flag : "name" in autoImportInjectionDecl ? autoImportInjectionDecl.name : "path" in autoImportInjectionDecl ? autoImportInjectionDecl.path : void 0
-              } : void 0
-            });
-          }
-          try {
-            const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
-            appendLedgerEntry2(meshId, {
-              kind: "coordinator_started",
-              sessionId: launchSessionId,
-              providerType: cliType,
-              payload: { workspace }
-            });
-          } catch {
-          }
-          return {
-            success: true,
-            meshId,
-            cliType,
-            workspace,
-            sessionId: launchSessionId,
-            mcpConfigWritten: true
-          };
-        } catch (e) {
-          LOG.error("MeshCoordinator", `Failed: ${e.message}`);
-          return { success: false, error: e.message };
-        }
-      }
-      case "mesh_status": {
-        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-        if (!meshId) return { success: false, error: "meshId required" };
-        try {
-          const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
-          const mesh = meshRecord?.mesh;
-          if (!mesh) return { success: false, error: "Mesh not found" };
-          const meshHost = resolveMeshHostStatus(mesh);
-          const refreshRequested = args?.refresh === true || args?.forceRefresh === true;
-          const verboseMissions = args?.verbose === true || args?.compact === false;
-          const peekScope = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : this.deps.statusInstanceId || void 0;
-          const pendingCoordinatorEventCount = getPendingMeshCoordinatorEvents(meshId, peekScope).length;
-          const hadAggregateCache = this.aggregateMeshStatusCache.has(meshId);
-          if (!refreshRequested && !verboseMissions && pendingCoordinatorEventCount === 0) {
-            const cachedStatus = this.getCachedAggregateMeshStatus(meshId, mesh, { requireDirectPeerTruth: args?.requireDirectPeerTruth === true });
-            if (cachedStatus) {
-              logRepoMeshStatusDebug("return_cached", {
-                meshId,
-                command: "mesh_status",
-                refreshRequested,
-                summary: summarizeRepoMeshStatusDebug(cachedStatus)
-              });
-              return cachedStatus;
-            }
-          }
-          const refreshReason = refreshRequested ? "explicit_refresh" : pendingCoordinatorEventCount > 0 ? "pending_coordinator_events" : hadAggregateCache ? "stale_pending_cache_refresh" : "cold_cache_miss";
-          const { getMeshQueueStats: getMeshQueueStats2, getQueue: getQueue2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
-          const queue = getQueue2(meshId);
-          const queueSummary = getMeshQueueStats2(meshId);
-          const { readLedgerEntries: readLedgerEntries2, getLedgerSummary: getLedgerSummary2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
-          const ledgerEntries = readLedgerEntries2(meshId, { tail: 20 });
-          const asyncRefineLedgerEntries = readLedgerEntries2(meshId, { tail: 100 });
-          const ledgerSummary = getLedgerSummary2(meshId);
-          const sessionHostRecords = this.deps.sessionHostControl?.listSessions ? await this.deps.sessionHostControl.listSessions().catch(() => []) : [];
-          const liveMeshSessions = partitionSessionHostRecords(Array.isArray(sessionHostRecords) ? sessionHostRecords : []).liveRuntimes;
-          const localMachineId = loadConfig().machineId || "";
-          const requireDirectPeerTruth = args?.requireDirectPeerTruth === true;
-          const meshGitProbeCache = this.meshGitProbeCache;
-          const directTruth = requireDirectPeerTruth ? await hydrateInlineMeshDirectTruth({
-            mesh,
-            meshSource: meshRecord.source,
-            dispatchMeshCommand: this.deps.dispatchMeshCommand,
-            getMeshPeerConnectionStatus: this.deps.getMeshPeerConnectionStatus,
-            statusInstanceId: this.deps.statusInstanceId,
-            localMachineId,
-            // 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,
-            probeCache: meshGitProbeCache
-          }) : {
-            directEvidenceCount: 0,
-            localConfirmedCount: 0,
-            peerAttemptedCount: 0,
-            peerConfirmedCount: 0,
-            standingEvidenceCount: 0,
-            unavailableNodeIds: [],
-            deadNodeIds: []
-          };
-          const passivePeerTruthNotAttempted = requireDirectPeerTruth && !refreshRequested && directTruth.directEvidenceCount > 0 && directTruth.peerAttemptedCount === 0;
-          const effectiveDirectTruth = passivePeerTruthNotAttempted ? { ...directTruth, unavailableNodeIds: [] } : directTruth;
-          const unavailableDirectTruthNodeIds = new Set(effectiveDirectTruth.unavailableNodeIds);
-          const unavailableNodesAreOnlyRemovedWorktrees = unavailableDirectTruthNodeIds.size > 0 && Array.isArray(mesh.nodes) && mesh.nodes.filter((node) => unavailableDirectTruthNodeIds.has(normalizeMeshNodeId(node) ?? "")).every((node) => node?.isLocalWorktree === true);
-          const directTruthSatisfied = !requireDirectPeerTruth || !refreshRequested || effectiveDirectTruth.directEvidenceCount > 0 && (effectiveDirectTruth.unavailableNodeIds.length === 0 || unavailableNodesAreOnlyRemovedWorktrees);
-          if (requireDirectPeerTruth && refreshRequested && !directTruthSatisfied) {
-            const failureResult = {
-              success: false,
-              code: "mesh_direct_peer_truth_unavailable",
-              error: "Selected coordinator could not confirm direct mesh truth yet. Bootstrap inventory stays unavailable until direct mesh_status probes succeed.",
-              sourceOfTruth: {
-                membership: meshRecord.source === "inline_cache" ? "coordinator_inline_mesh_cache" : meshRecord.source === "local_config" ? "local_mesh_config" : "inline_bootstrap_snapshot",
-                coordinatorOwnsLiveTruth: false,
-                currentStatus: "direct_peer_truth_unavailable",
-                directPeerTruth: {
-                  required: true,
-                  satisfied: false,
-                  directEvidenceCount: directTruth.directEvidenceCount,
-                  localConfirmedCount: directTruth.localConfirmedCount,
-                  peerAttemptedCount: directTruth.peerAttemptedCount,
-                  peerConfirmedCount: directTruth.peerConfirmedCount,
-                  unavailableNodeIds: directTruth.unavailableNodeIds
-                }
-              }
-            };
-            logRepoMeshStatusDebug("direct_truth_unavailable", {
-              meshId,
-              command: "mesh_status",
-              refreshRequested,
-              meshSource: meshRecord.source,
-              directTruth
-            });
-            return failureResult;
-          }
-          const directTruthUnavailableNodeIds = new Set(effectiveDirectTruth.unavailableNodeIds);
-          const coordinatorHostname = (0, import_os3.hostname)();
-          const selectedCoordinatorNodeId = readStringValue(
-            mesh.coordinator?.preferredNodeId,
-            normalizeMeshNodeId(mesh.nodes?.[0])
-          );
-          const inlineCoordinatorNodeId = meshRecord?.inline && Array.isArray(mesh.nodes) ? selectedCoordinatorNodeId : void 0;
-          const refreshedAt = (/* @__PURE__ */ new Date()).toISOString();
-          const nodeStatuses = [];
-          for (const [nodeIndex, node] of (mesh.nodes || []).entries()) {
-            const nodeId = normalizeMeshNodeId(node) ?? "";
-            const daemonId = readStringValue(node.daemonId);
-            const nodeMachineId = readMeshNodeMachineId(node);
-            const nodeHostname = readMeshNodeHostname(node);
-            const providerPriority = readProviderPriorityFromPolicy(node.policy);
-            const configuredCoordinatorNode = Boolean(
-              nodeId && selectedCoordinatorNodeId && nodeId === selectedCoordinatorNodeId
-            );
-            const sparseConfiguredCoordinatorNode = configuredCoordinatorNode && !daemonId && !nodeMachineId && !nodeHostname;
-            const isSelfNode = Boolean(
-              nodeId && inlineCoordinatorNodeId && nodeId === inlineCoordinatorNodeId
-            ) || Boolean(
-              daemonId && (daemonIdsEquivalent(daemonId, localMachineId) || daemonIdsEquivalent(daemonId, this.deps.statusInstanceId))
-            ) || Boolean(meshRecord?.inline && nodeIndex === 0) || sparseConfiguredCoordinatorNode;
-            const machineIdentity = buildMeshNodeMachineIdentity(node, {
-              localMachineId,
-              localDaemonId: this.deps.statusInstanceId,
-              coordinatorHostname,
-              isSelfNode
-            });
-            const status = {
-              nodeId,
-              machineLabel: buildMeshNodeDisplayLabel(node, nodeId, providerPriority),
-              labelSource: readStringValue(node.machineLabel, node.machine_label, node.machineNickname, node.machine_nickname, node.alias) ? "explicit_metadata" : "workspace_host_provider_context",
-              workspace: node.workspace,
-              repoRoot: node.repoRoot,
-              isLocalWorktree: node.isLocalWorktree,
-              worktreeBranch: node.worktreeBranch,
-              role: normalizeMeshDaemonRole(node.role) || (meshHost.hostNodeId && nodeId === meshHost.hostNodeId ? "host" : void 0),
-              daemonId,
-              machineId: nodeMachineId || node.machineId,
-              machine: machineIdentity,
-              machineStatus: node.machineStatus,
-              health: "unknown",
-              providers: node.providers || [],
-              providerPriority,
-              activeSessions: [],
-              activeSessionDetails: [],
-              launchReady: false
-            };
-            if (isSelfNode) {
-              status.connection = {
-                perspective: "selected_coordinator",
-                source: "mesh_peer_status",
-                state: "self",
-                transport: "local",
-                reported: true,
-                reason: "Selected coordinator daemon",
-                lastStateChangeAt: refreshedAt
-              };
-            } else if (daemonId) {
-              const connection = this.deps.getMeshPeerConnectionStatus?.(daemonId);
-              status.connection = connection ?? {
-                perspective: "selected_coordinator",
-                source: "not_reported",
-                state: "unknown",
-                transport: "unknown",
-                reported: false,
-                reason: "No live mesh peer telemetry reported by the selected coordinator yet."
-              };
-            } else {
-              status.connection = {
-                perspective: "selected_coordinator",
-                source: "not_reported",
-                state: "unknown",
-                transport: "unknown",
-                reported: false,
-                reason: "Node has no daemon id, so mesh transport cannot be reported from the selected coordinator."
-              };
-            }
-            const matchedLiveSessionRecords = collectLiveMeshSessionRecords({
-              meshId,
-              node,
-              nodeId,
-              liveSessionRecords: liveMeshSessions,
-              allowCoordinatorSession: nodeId === selectedCoordinatorNodeId
-            });
-            const workspace = readLiveMeshNodeWorkspace({
-              meshId,
-              nodeId,
-              liveSessionRecords: matchedLiveSessionRecords,
-              allowCoordinatorSession: nodeId === selectedCoordinatorNodeId
-            }) || (typeof node.workspace === "string" ? node.workspace : "");
-            status.workspace = workspace || node.workspace;
-            if (matchedLiveSessionRecords.length > 0) {
-              const sessionIds = matchedLiveSessionRecords.map((record) => typeof record?.sessionId === "string" ? record.sessionId : "").filter(Boolean);
-              const providerTypes = matchedLiveSessionRecords.map((record) => readStringValue(record?.providerType)).filter(Boolean);
-              status.activeSessions = sessionIds;
-              status.activeSessionDetails = matchedLiveSessionRecords.map(summarizeMeshSessionRecord);
-              if (providerTypes.length > 0) {
-                status.providers = Array.from(/* @__PURE__ */ new Set([...Array.isArray(status.providers) ? status.providers : [], ...providerTypes]));
-              }
-            }
-            if (workspace) {
-              if (!fs27.existsSync(workspace)) {
-                const inlineTransitGit = buildInlineMeshTransitGitStatus(node);
-                let remoteProbeApplied = false;
-                if (inlineTransitGit) {
-                  status.git = inlineTransitGit;
-                  status.health = inlineTransitGit.isGitRepo ? deriveMeshNodeHealthFromGit(inlineTransitGit) : "degraded";
-                  const connection = readObjectRecord(status.connection);
-                  const connectionState = readStringValue(connection.state);
-                  const connectionReported = readBooleanValue(connection.reported) ?? false;
-                  if (!connectionReported || connectionState === "unknown") {
-                    status.connection = buildLivePeerGitConnection(connection, refreshedAt);
-                  }
-                  remoteProbeApplied = true;
-                } else if (refreshRequested && !isSelfNode && daemonId && this.deps.dispatchMeshCommand && !directTruthUnavailableNodeIds.has(nodeId)) {
-                  const runNodeProbe = () => probeRemoteMeshGitStatusWithRetry({
-                    dispatchMeshCommand: this.deps.dispatchMeshCommand,
-                    daemonId,
-                    workspace,
-                    timeoutMs: MESH_DIRECT_PROBE_TIMEOUT_MS,
-                    retryTimeoutMs: MESH_DIRECT_PROBE_RETRY_TIMEOUT_MS,
-                    getConnection: this.deps.getMeshPeerConnectionStatus,
-                    onConnection: (connection) => {
-                      status.connection = connection;
-                    }
-                  });
-                  const remoteGit = await meshGitProbeCache.probe(daemonId, workspace, runNodeProbe);
-                  if (remoteGit) {
-                    status.git = remoteGit;
-                    status.health = remoteGit.isGitRepo ? deriveMeshNodeHealthFromGit(remoteGit) : "degraded";
-                    const connection = readObjectRecord(status.connection);
-                    const connectionState = readStringValue(connection.state);
-                    const connectionReported = readBooleanValue(connection.reported) ?? false;
-                    if (!connectionReported || connectionState === "unknown") {
-                      status.connection = buildLivePeerGitConnection(connection, refreshedAt);
-                    }
-                    const reporter = recordInlineMeshDirectGitTruth(node, remoteGit, "selected_coordinator_mesh_p2p_git");
-                    persistNodeReporterPlatform(meshRecord.source, mesh, nodeId, reporter);
-                    remoteProbeApplied = true;
-                  }
-                }
-                if (!remoteProbeApplied) {
-                  const connectionState = readStringValue(status.connection?.state);
-                  const pendingPeerGitProbe = !inlineTransitGit && !isSelfNode && !!daemonId && (readStringValue(status.machineStatus) === "online" || readStringValue(status.health) === "online" || connectionState === "connecting" || connectionState === "connected" || connectionState === "unknown");
-                  if (pendingPeerGitProbe) {
-                    status.gitProbePending = true;
-                    status.health = "unknown";
-                  }
-                  if (applyCachedInlineMeshNodeStatus(
-                    status,
-                    node,
-                    pendingPeerGitProbe ? { skipGit: true, skipError: true, skipHealth: true } : void 0
-                  )) {
-                    applyInlineMeshBranchConvergence(mesh, node, status);
-                    finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode });
-                    nodeStatuses.push(status);
-                    continue;
-                  }
-                  if (meshRecord?.source === "inline_cache" && !isSelfNode) {
-                    applyInlineMeshBranchConvergence(mesh, node, status);
-                    finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode });
-                    nodeStatuses.push(status);
-                    continue;
-                  }
-                }
-              } else {
-                try {
-                  const gitStatus = await getGitRepoStatus(workspace, { timeoutMs: 1e4, refreshUpstream: true });
-                  status.git = gitStatus;
-                  const reporter = recordInlineMeshDirectGitTruth(node, gitStatus, "selected_coordinator_local_git");
-                  persistNodeReporterPlatform(meshRecord.source, mesh, nodeId, reporter);
-                  if (gitStatus.isGitRepo) {
-                    status.health = deriveMeshNodeHealthFromGit(gitStatus);
-                  } else {
-                    status.health = "degraded";
-                    if (gitStatus.error && !status.error) status.error = gitStatus.error;
-                  }
-                } catch {
-                  if (!applyCachedInlineMeshNodeStatus(status, node)) {
-                    status.health = "degraded";
-                  }
-                }
-              }
-            } else {
-              applyCachedInlineMeshNodeStatus(status, node);
-            }
-            applyInlineMeshBranchConvergence(mesh, node, status);
-            finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode });
-            nodeStatuses.push(status);
-          }
-          const callerCoordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : this.deps.statusInstanceId || void 0;
-          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 && fs27.existsSync(candidate));
-            return localRepoRoot ? buildPreviewFreshness(localRepoRoot) : void 0;
-          })();
-          const asyncRefineJobs = buildMeshAsyncRefineJobs({
-            meshId,
-            ledgerEntries: asyncRefineLedgerEntries,
-            pendingEvents: [...pendingCoordinatorEvents]
-          });
-          const historicalSessions = buildHistoricalMeshSessions({
-            meshId,
-            nodes: mesh.nodes || [],
-            liveSessionRecords: liveMeshSessions
-          });
-          const { getMeshStatusMissionSummaries: getMeshStatusMissionSummaries2 } = await Promise.resolve().then(() => (init_mesh_missions(), mesh_missions_exports));
-          const missions = getMeshStatusMissionSummaries2(meshId, { verbose: verboseMissions, withStats: true });
-          const statusResult = {
-            success: true,
-            meshId: mesh.id,
-            meshName: mesh.name,
-            repoIdentity: mesh.repoIdentity,
-            defaultBranch: mesh.defaultBranch,
-            refreshedAt,
-            meshHost,
-            sourceOfTruth: {
-              membership: meshRecord?.source === "inline_cache" ? "coordinator_inline_mesh_cache" : meshRecord?.source === "local_config" ? "local_mesh_config" : "inline_bootstrap_snapshot",
-              coordinatorOwnsLiveTruth: directTruthSatisfied,
-              meshHost: {
-                owner: "mesh_host_daemon",
-                localRole: meshHost.role,
-                hostDaemonId: meshHost.hostDaemonId,
-                hostNodeId: meshHost.hostNodeId,
-                hostAddress: meshHost.hostAddress
-              },
-              ...requireDirectPeerTruth ? {
-                currentStatus: directTruthSatisfied ? "live_git_and_session_probes" : "direct_peer_truth_unavailable",
-                directPeerTruth: {
-                  required: true,
-                  satisfied: directTruthSatisfied,
-                  directEvidenceCount: effectiveDirectTruth.directEvidenceCount,
-                  localConfirmedCount: effectiveDirectTruth.localConfirmedCount,
-                  peerAttemptedCount: effectiveDirectTruth.peerAttemptedCount,
-                  peerConfirmedCount: effectiveDirectTruth.peerConfirmedCount,
-                  unavailableNodeIds: effectiveDirectTruth.unavailableNodeIds,
-                  partialNodeFailures: effectiveDirectTruth.unavailableNodeIds
-                }
-              } : {},
-              historicalEvidenceOnly: ["recoveryHints", "ledger.summary", "queue.summary", "historicalSessions"]
-            },
-            branchConvergenceSummary: summarizeInlineMeshBranchConvergence(nodeStatuses),
-            ...previewFreshness ? { previewFreshness, deployFreshness: previewFreshness } : {},
-            nodes: nodeStatuses,
-            queue: { tasks: queue, summary: queueSummary },
-            ledger: { entries: ledgerEntries, summary: ledgerSummary },
-            ...missions.length > 0 ? { missions } : {},
-            ...asyncRefineJobs.length > 0 ? { asyncRefineJobs } : {},
-            ...historicalSessions ? { historicalSessions } : {},
-            ...pendingCoordinatorEvents.length > 0 ? { pendingCoordinatorEvents } : {},
-            ...unroutableDeliveries.length > 0 ? { unroutableDeliveries } : {},
-            activeRefineJobs: Array.from(this.runningRefineJobs.values()).filter((job) => job.meshId === meshId).map((job) => ({
-              jobId: job.jobId,
-              nodeId: job.targetNodeId,
-              workspace: job.workspace,
-              startedAt: job.startedAt,
-              status: job.status,
-              targetCoordinatorDaemonId: job.targetCoordinatorDaemonId
-            }))
-          };
-          const { pendingCoordinatorEvents: _pendingCoordinatorEvents, unroutableDeliveries: _unroutableDeliveries, ...cacheableStatusResult } = statusResult;
-          const rememberedStatus = verboseMissions ? cacheableStatusResult : this.rememberAggregateMeshStatus(meshId, cacheableStatusResult, refreshReason);
-          const returnedStatus = {
-            ...rememberedStatus,
-            ...pendingCoordinatorEvents.length > 0 ? { pendingCoordinatorEvents } : {},
-            ...unroutableDeliveries.length > 0 ? { unroutableDeliveries } : {}
-          };
-          logRepoMeshStatusDebug("return_live", {
-            meshId,
-            command: "mesh_status",
-            refreshRequested,
-            refreshReason,
-            meshSource: meshRecord.source,
-            directTruth,
-            summary: summarizeRepoMeshStatusDebug(returnedStatus)
-          });
-          return returnedStatus;
-        } catch (e) {
-          return { success: false, error: e.message };
-        }
-      }
-      case "get_mesh_review_inbox": {
-        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
-        if (!meshId) return { success: false, error: "meshId required" };
-        try {
-          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: existsSync47 } = 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" };
-          const inlineNodes = args?.inlineMesh && Array.isArray(args.inlineMesh?.nodes) ? args.inlineMesh.nodes : null;
-          let cachedStatus = !inlineNodes ? this.getCachedAggregateMeshStatus(meshId, mesh, {}) : null;
-          if (!cachedStatus && !inlineNodes) {
-            const freshStatus = await this.execute("mesh_status", {
-              meshId,
-              inlineMesh: args?.inlineMesh,
-              refresh: true
-            }, "get_mesh_review_inbox");
-            cachedStatus = freshStatus?.success !== false ? freshStatus : null;
-          }
-          const nodeStatuses = inlineNodes ? inlineNodes : Array.isArray(cachedStatus?.nodes) ? cachedStatus.nodes : Array.isArray(mesh.nodes) ? mesh.nodes : [];
-          const ledgerEntries = readLedgerEntries2(meshId, { tail: 300 });
-          const derivation = deriveMeshReviewInboxItems2({ nodes: nodeStatuses, ledgerEntries });
-          for (const item of derivation.items) {
-            const workspace = item.workspace;
-            if (!workspace || !existsSync47(workspace)) continue;
-            const baseRef = item.defaultBranch ? `origin/${item.defaultBranch}` : "origin/main";
-            try {
-              const diffResult = await getGitDiffSummary2(workspace, { baseRef, maxFiles: 100 });
-              if (diffResult.isGitRepo) {
-                item.diffSummary = {
-                  baseRef,
-                  files: diffResult.files.map((f) => ({
-                    path: f.path,
-                    status: f.status,
-                    insertions: f.insertions,
-                    deletions: f.deletions,
-                    binary: f.binary,
-                    oldPath: f.oldPath
-                  })),
-                  totalFiles: diffResult.files.length,
-                  totalInsertions: diffResult.totalInsertions,
-                  totalDeletions: diffResult.totalDeletions,
-                  truncated: diffResult.truncated,
-                  ...diffResult.error ? { error: diffResult.error } : {}
-                };
-              }
-            } catch {
-              item.diffSummary = null;
-            }
-          }
-          return {
-            success: true,
-            meshId,
-            inbox: derivation.items,
-            remoteNodesExcluded: derivation.remoteNodesExcluded,
-            excludedRemoteNodeIds: derivation.excludedRemoteNodeIds
-          };
-        } catch (e) {
-          return { success: false, error: e.message };
-        }
-      }
-      default:
-        break;
+    const highFamilyHandler = highFamilyRegistry.get(cmd);
+    if (highFamilyHandler) {
+      return await highFamilyHandler(this.buildHighFamilyContext(), args);
     }
     return null;
   }
@@ -54889,10 +55071,10 @@ init_io_contracts();
 init_chat_message_normalization();
 
 // src/providers/version-archive.ts
-var fs28 = __toESM(require("fs"));
+var fs30 = __toESM(require("fs"));
 var path37 = __toESM(require("path"));
 var os28 = __toESM(require("os"));
-var import_os4 = require("os");
+var import_os5 = require("os");
 var import_child_process10 = require("child_process");
 var ARCHIVE_PATH = path37.join(os28.homedir(), ".adhdev", "version-history.json");
 var MAX_ENTRIES_PER_PROVIDER = 20;
@@ -54903,8 +55085,8 @@ var VersionArchive = class {
   }
   load() {
     try {
-      if (fs28.existsSync(ARCHIVE_PATH)) {
-        this.history = JSON.parse(fs28.readFileSync(ARCHIVE_PATH, "utf-8"));
+      if (fs30.existsSync(ARCHIVE_PATH)) {
+        this.history = JSON.parse(fs30.readFileSync(ARCHIVE_PATH, "utf-8"));
       }
     } catch {
       this.history = {};
@@ -54919,7 +55101,7 @@ var VersionArchive = class {
     entries.push({
       version,
       detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      os: (0, import_os4.platform)()
+      os: (0, import_os5.platform)()
     });
     if (entries.length > MAX_ENTRIES_PER_PROVIDER) {
       this.history[type] = entries.slice(-MAX_ENTRIES_PER_PROVIDER);
@@ -54941,8 +55123,8 @@ var VersionArchive = class {
   }
   save() {
     try {
-      fs28.mkdirSync(path37.dirname(ARCHIVE_PATH), { recursive: true });
-      fs28.writeFileSync(ARCHIVE_PATH, JSON.stringify(this.history, null, 2));
+      fs30.mkdirSync(path37.dirname(ARCHIVE_PATH), { recursive: true });
+      fs30.writeFileSync(ARCHIVE_PATH, JSON.stringify(this.history, null, 2));
     } catch {
     }
   }
@@ -54959,7 +55141,7 @@ async function runCommand(cmd, timeout = 1e4) {
   });
 }
 function findBinary2(name) {
-  const isWin = (0, import_os4.platform)() === "win32";
+  const isWin = (0, import_os5.platform)() === "win32";
   const paths = (process.env.PATH || "").split(isWin ? ";" : ":");
   const exes = isWin ? [".exe", ".cmd", ".bat", ""] : [""];
   for (const p of paths) {
@@ -54967,8 +55149,8 @@ function findBinary2(name) {
     for (const ext of exes) {
       const fullPath = path37.join(p, name + ext);
       try {
-        if (fs28.existsSync(fullPath)) {
-          const stat2 = fs28.statSync(fullPath);
+        if (fs30.existsSync(fullPath)) {
+          const stat2 = fs30.statSync(fullPath);
           if (stat2.isFile() && (isWin || stat2.mode & 73)) {
             return fullPath;
           }
@@ -55015,23 +55197,23 @@ function checkPathExists2(paths) {
     if (p.includes("*")) {
       const home = os28.homedir();
       const resolved = p.replace(/\*/g, home.split(path37.sep).pop() || "");
-      if (fs28.existsSync(resolved)) return resolved;
+      if (fs30.existsSync(resolved)) return resolved;
     } else {
-      if (fs28.existsSync(p)) return p;
+      if (fs30.existsSync(p)) return p;
     }
   }
   return null;
 }
 async function getMacAppVersion(appPath) {
-  if ((0, import_os4.platform)() !== "darwin" || !appPath.endsWith(".app")) return null;
+  if ((0, import_os5.platform)() !== "darwin" || !appPath.endsWith(".app")) return null;
   const plistPath = path37.join(appPath, "Contents", "Info.plist");
-  if (!fs28.existsSync(plistPath)) return null;
+  if (!fs30.existsSync(plistPath)) return null;
   const raw = await runCommand(`/usr/libexec/PlistBuddy -c "Print CFBundleShortVersionString" "${plistPath}"`);
   return raw || null;
 }
 async function detectAllVersions(loader, archive) {
   const results = [];
-  const currentOs = (0, import_os4.platform)();
+  const currentOs = (0, import_os5.platform)();
   const win32ProcessNames = typeof loader.getWinProcessNames === "function" ? loader.getWinProcessNames() : {};
   for (const provider of loader.getAll()) {
     const info = {
@@ -55052,7 +55234,7 @@ async function detectAllVersions(loader, archive) {
       let resolvedBin = cliBin;
       if (!resolvedBin && appPath && currentOs === "darwin") {
         const bundled = path37.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
-        if (provider.cli && fs28.existsSync(bundled)) resolvedBin = bundled;
+        if (provider.cli && fs30.existsSync(bundled)) resolvedBin = bundled;
       }
       info.installed = !!(appPath || resolvedBin);
       info.path = appPath || null;
@@ -55100,7 +55282,7 @@ async function detectAllVersions(loader, archive) {
 
 // src/daemon/dev-server.ts
 var http2 = __toESM(require("http"));
-var fs32 = __toESM(require("fs"));
+var fs34 = __toESM(require("fs"));
 var path41 = __toESM(require("path"));
 init_config();
 
@@ -55452,7 +55634,7 @@ init_logger();
 init_builders();
 
 // src/daemon/dev-cdp-handlers.ts
-var fs29 = __toESM(require("fs"));
+var fs31 = __toESM(require("fs"));
 var path38 = __toESM(require("path"));
 init_logger();
 async function handleCdpEvaluate(ctx, req, res) {
@@ -55633,17 +55815,17 @@ async function handleScriptHints(ctx, type, _req, res) {
   }
   let scriptsPath = "";
   const directScripts = path38.join(dir, "scripts.js");
-  if (fs29.existsSync(directScripts)) {
+  if (fs31.existsSync(directScripts)) {
     scriptsPath = directScripts;
   } else {
     const scriptsDir = path38.join(dir, "scripts");
-    if (fs29.existsSync(scriptsDir)) {
-      const versions = fs29.readdirSync(scriptsDir).filter((d) => {
-        return fs29.statSync(path38.join(scriptsDir, d)).isDirectory();
+    if (fs31.existsSync(scriptsDir)) {
+      const versions = fs31.readdirSync(scriptsDir).filter((d) => {
+        return fs31.statSync(path38.join(scriptsDir, d)).isDirectory();
       }).sort().reverse();
       for (const ver of versions) {
         const p = path38.join(scriptsDir, ver, "scripts.js");
-        if (fs29.existsSync(p)) {
+        if (fs31.existsSync(p)) {
           scriptsPath = p;
           break;
         }
@@ -55655,7 +55837,7 @@ async function handleScriptHints(ctx, type, _req, res) {
     return;
   }
   try {
-    const source = fs29.readFileSync(scriptsPath, "utf-8");
+    const source = fs31.readFileSync(scriptsPath, "utf-8");
     const hints = {};
     const funcRegex = /module\.exports\.(\w+)\s*=\s*function\s+\w+\s*\(params\)/g;
     let match;
@@ -56470,7 +56652,7 @@ async function handleDomContext(ctx, type, req, res) {
 }
 
 // src/daemon/dev-cli-debug.ts
-var fs30 = __toESM(require("fs"));
+var fs32 = __toESM(require("fs"));
 var path39 = __toESM(require("path"));
 function slugifyFixtureName(value) {
   const normalized = String(value || "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
@@ -56486,10 +56668,10 @@ function getCliFixtureDir(ctx, type) {
 function readCliFixture(ctx, type, name) {
   const fixtureDir = getCliFixtureDir(ctx, type);
   const filePath = path39.join(fixtureDir, `${name}.json`);
-  if (!fs30.existsSync(filePath)) {
+  if (!fs32.existsSync(filePath)) {
     throw new Error(`Fixture not found: ${filePath}`);
   }
-  return JSON.parse(fs30.readFileSync(filePath, "utf-8"));
+  return JSON.parse(fs32.readFileSync(filePath, "utf-8"));
 }
 function getExerciseTranscriptText(result) {
   const parts = [];
@@ -57234,7 +57416,7 @@ async function handleCliFixtureCapture(ctx, req, res) {
       return;
     }
     const fixtureDir = getCliFixtureDir(ctx, type);
-    fs30.mkdirSync(fixtureDir, { recursive: true });
+    fs32.mkdirSync(fixtureDir, { recursive: true });
     const name = slugifyFixtureName(String(body?.name || `${type}-${Date.now()}`));
     const result = await runCliExerciseInternal(ctx, { ...request, type });
     const fixture = {
@@ -57262,7 +57444,7 @@ async function handleCliFixtureCapture(ctx, req, res) {
       notes: typeof body?.notes === "string" ? body.notes : void 0
     };
     const filePath = path39.join(fixtureDir, `${name}.json`);
-    fs30.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
+    fs32.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
     ctx.json(res, 200, {
       saved: true,
       name,
@@ -57280,14 +57462,14 @@ async function handleCliFixtureCapture(ctx, req, res) {
 async function handleCliFixtureList(ctx, type, _req, res) {
   try {
     const fixtureDir = getCliFixtureDir(ctx, type);
-    if (!fs30.existsSync(fixtureDir)) {
+    if (!fs32.existsSync(fixtureDir)) {
       ctx.json(res, 200, { fixtures: [], count: 0 });
       return;
     }
-    const fixtures = fs30.readdirSync(fixtureDir).filter((file) => file.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file) => {
+    const fixtures = fs32.readdirSync(fixtureDir).filter((file) => file.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file) => {
       const fullPath = path39.join(fixtureDir, file);
       try {
-        const raw = JSON.parse(fs30.readFileSync(fullPath, "utf-8"));
+        const raw = JSON.parse(fs32.readFileSync(fullPath, "utf-8"));
         return {
           name: raw.name || file.replace(/\.json$/i, ""),
           path: fullPath,
@@ -57420,7 +57602,7 @@ async function handleCliRaw(ctx, req, res) {
 }
 
 // src/daemon/dev-auto-implement.ts
-var fs31 = __toESM(require("fs"));
+var fs33 = __toESM(require("fs"));
 var path40 = __toESM(require("path"));
 var os29 = __toESM(require("os"));
 var import_session_host_core8 = require("@adhdev/session-host-core");
@@ -57469,10 +57651,10 @@ function resolveAutoImplReference(ctx, category, requestedReference, targetType)
   return fallback?.type || null;
 }
 function getLatestScriptVersionDir(scriptsDir) {
-  if (!fs31.existsSync(scriptsDir)) return null;
-  const versions = fs31.readdirSync(scriptsDir).filter((d) => {
+  if (!fs33.existsSync(scriptsDir)) return null;
+  const versions = fs33.readdirSync(scriptsDir).filter((d) => {
     try {
-      return fs31.statSync(path40.join(scriptsDir, d)).isDirectory();
+      return fs33.statSync(path40.join(scriptsDir, d)).isDirectory();
     } catch {
       return false;
     }
@@ -57494,13 +57676,13 @@ function resolveAutoImplWritableProviderDir(ctx, category, type, requestedDir) {
   if (!sourceDir) {
     return { dir: null, reason: `Provider source directory not found for '${type}'` };
   }
-  if (!fs31.existsSync(desiredDir)) {
-    fs31.mkdirSync(path40.dirname(desiredDir), { recursive: true });
-    fs31.cpSync(sourceDir, desiredDir, { recursive: true });
+  if (!fs33.existsSync(desiredDir)) {
+    fs33.mkdirSync(path40.dirname(desiredDir), { recursive: true });
+    fs33.cpSync(sourceDir, desiredDir, { recursive: true });
     ctx.log(`Auto-implement writable copy created: ${desiredDir}`);
   }
   const providerJson = path40.join(desiredDir, "provider.json");
-  if (!fs31.existsSync(providerJson)) {
+  if (!fs33.existsSync(providerJson)) {
     return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
   }
   return { dir: desiredDir };
@@ -57508,15 +57690,15 @@ function resolveAutoImplWritableProviderDir(ctx, category, type, requestedDir) {
 function loadAutoImplReferenceScripts(ctx, referenceType) {
   if (!referenceType) return {};
   const refDir = ctx.findProviderDir(referenceType);
-  if (!refDir || !fs31.existsSync(refDir)) return {};
+  if (!refDir || !fs33.existsSync(refDir)) return {};
   const referenceScripts = {};
   const scriptsDir = path40.join(refDir, "scripts");
   const latestDir = getLatestScriptVersionDir(scriptsDir);
   if (!latestDir) return referenceScripts;
-  for (const file of fs31.readdirSync(latestDir)) {
+  for (const file of fs33.readdirSync(latestDir)) {
     if (!file.endsWith(".js")) continue;
     try {
-      referenceScripts[file] = fs31.readFileSync(path40.join(latestDir, file), "utf-8");
+      referenceScripts[file] = fs33.readFileSync(path40.join(latestDir, file), "utf-8");
     } catch {
     }
   }
@@ -57625,15 +57807,15 @@ async function handleAutoImplement(ctx, type, req, res) {
     const referenceScripts = loadAutoImplReferenceScripts(ctx, resolvedReference);
     const prompt = buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domContext, referenceScripts, comment, resolvedReference, verification);
     const tmpDir = path40.join(os29.tmpdir(), "adhdev-autoimpl");
-    if (!fs31.existsSync(tmpDir)) fs31.mkdirSync(tmpDir, { recursive: true });
+    if (!fs33.existsSync(tmpDir)) fs33.mkdirSync(tmpDir, { recursive: true });
     const promptFile = path40.join(tmpDir, `prompt-${type}-${Date.now()}.md`);
-    fs31.writeFileSync(promptFile, prompt, "utf-8");
+    fs33.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 {
-        fs31.unlinkSync(promptFile);
+        fs33.unlinkSync(promptFile);
       } catch {
       }
       ctx.json(res, 400, { error: `Agent '${agent}' has no spawn config. Select a CLI provider with a spawn configuration.` });
@@ -57735,7 +57917,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         } catch {
         }
         try {
-          fs31.unlinkSync(promptFile);
+          fs33.unlinkSync(promptFile);
         } catch {
         }
         ctx.log(`Auto-implement (ACP) ${success ? "completed" : "failed"}: ${type} (exit: ${code})`);
@@ -57961,7 +58143,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         }
       });
       try {
-        fs31.unlinkSync(promptFile);
+        fs33.unlinkSync(promptFile);
       } catch {
       }
       ctx.log(`Auto-implement ${success ? "completed" : "failed"}: ${type} (exit: ${code})${verificationSummary ? ` verify=${verificationSummary.pass ? "pass" : "fail"}` : ""}`);
@@ -58066,10 +58248,10 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
     lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
     lines.push("These are the ONLY files you are allowed to modify. Replace the TODO stubs with working implementations.");
     lines.push("");
-    for (const file of fs31.readdirSync(latestScriptsDir)) {
+    for (const file of fs33.readdirSync(latestScriptsDir)) {
       if (file.endsWith(".js") && targetFileNames.has(file)) {
         try {
-          const content = fs31.readFileSync(path40.join(latestScriptsDir, file), "utf-8");
+          const content = fs33.readFileSync(path40.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
           lines.push("```javascript");
           lines.push(content);
@@ -58079,14 +58261,14 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
         }
       }
     }
-    const refFiles = fs31.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+    const refFiles = fs33.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
     if (refFiles.length > 0) {
       lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
       lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
       lines.push("");
       for (const file of refFiles) {
         try {
-          const content = fs31.readFileSync(path40.join(latestScriptsDir, file), "utf-8");
+          const content = fs33.readFileSync(path40.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u{1F512}`);
           lines.push("```javascript");
           lines.push(content);
@@ -58131,7 +58313,7 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
   const loadGuide = (name) => {
     try {
       const p = path40.join(docsDir, name);
-      if (fs31.existsSync(p)) return fs31.readFileSync(p, "utf-8");
+      if (fs33.existsSync(p)) return fs33.readFileSync(p, "utf-8");
     } catch {
     }
     return null;
@@ -58375,11 +58557,11 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
     lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
     lines.push("These are the ONLY files you are allowed to modify. Replace TODO or heuristic-only logic with working PTY-aware implementations.");
     lines.push("");
-    for (const file of fs31.readdirSync(latestScriptsDir)) {
+    for (const file of fs33.readdirSync(latestScriptsDir)) {
       if (!file.endsWith(".js")) continue;
       if (!targetFileNames.has(file)) continue;
       try {
-        const content = fs31.readFileSync(path40.join(latestScriptsDir, file), "utf-8");
+        const content = fs33.readFileSync(path40.join(latestScriptsDir, file), "utf-8");
         lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
         lines.push("```javascript");
         lines.push(content);
@@ -58388,14 +58570,14 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
       } catch {
       }
     }
-    const refFiles = fs31.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+    const refFiles = fs33.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
     if (refFiles.length > 0) {
       lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
       lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
       lines.push("");
       for (const file of refFiles) {
         try {
-          const content = fs31.readFileSync(path40.join(latestScriptsDir, file), "utf-8");
+          const content = fs33.readFileSync(path40.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u{1F512}`);
           lines.push("```javascript");
           lines.push(content);
@@ -58432,7 +58614,7 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
   const loadGuide = (name) => {
     try {
       const p = path40.join(docsDir, name);
-      if (fs31.existsSync(p)) return fs31.readFileSync(p, "utf-8");
+      if (fs33.existsSync(p)) return fs33.readFileSync(p, "utf-8");
     } catch {
     }
     return null;
@@ -59172,7 +59354,7 @@ var DevServer = class _DevServer {
       path41.join(process.cwd(), "packages/web-devconsole/dist")
     ];
     for (const dir of candidates) {
-      if (fs32.existsSync(path41.join(dir, "index.html"))) return dir;
+      if (fs34.existsSync(path41.join(dir, "index.html"))) return dir;
     }
     return null;
   }
@@ -59184,7 +59366,7 @@ var DevServer = class _DevServer {
     }
     const htmlPath = path41.join(distDir, "index.html");
     try {
-      const html = fs32.readFileSync(htmlPath, "utf-8");
+      const html = fs34.readFileSync(htmlPath, "utf-8");
       res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
       res.end(html);
     } catch (e) {
@@ -59214,7 +59396,7 @@ var DevServer = class _DevServer {
       return;
     }
     try {
-      const content = fs32.readFileSync(filePath);
+      const content = fs34.readFileSync(filePath);
       const ext = path41.extname(filePath);
       const contentType = _DevServer.MIME_MAP[ext] || "application/octet-stream";
       res.writeHead(200, { "Content-Type": contentType, "Cache-Control": "public, max-age=31536000, immutable" });
@@ -59323,14 +59505,14 @@ var DevServer = class _DevServer {
     const files = [];
     const scan = (d, prefix) => {
       try {
-        for (const entry of fs32.readdirSync(d, { withFileTypes: true })) {
+        for (const entry of fs34.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(path41.join(d, entry.name), rel);
           } else {
-            const stat2 = fs32.statSync(path41.join(d, entry.name));
+            const stat2 = fs34.statSync(path41.join(d, entry.name));
             files.push({ path: rel, size: stat2.size, type: "file" });
           }
         }
@@ -59358,11 +59540,11 @@ var DevServer = class _DevServer {
       this.json(res, 403, { error: "Forbidden" });
       return;
     }
-    if (!fs32.existsSync(fullPath) || fs32.statSync(fullPath).isDirectory()) {
+    if (!fs34.existsSync(fullPath) || fs34.statSync(fullPath).isDirectory()) {
       this.json(res, 404, { error: `File not found: ${filePath}` });
       return;
     }
-    const content = fs32.readFileSync(fullPath, "utf-8");
+    const content = fs34.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 } */
@@ -59384,9 +59566,9 @@ var DevServer = class _DevServer {
       return;
     }
     try {
-      if (fs32.existsSync(fullPath)) fs32.copyFileSync(fullPath, fullPath + ".bak");
-      fs32.mkdirSync(path41.dirname(fullPath), { recursive: true });
-      fs32.writeFileSync(fullPath, content, "utf-8");
+      if (fs34.existsSync(fullPath)) fs34.copyFileSync(fullPath, fullPath + ".bak");
+      fs34.mkdirSync(path41.dirname(fullPath), { recursive: true });
+      fs34.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 });
@@ -59403,8 +59585,8 @@ var DevServer = class _DevServer {
     }
     for (const name of ["scripts.js", "provider.json"]) {
       const p = path41.join(dir, name);
-      if (fs32.existsSync(p)) {
-        const source = fs32.readFileSync(p, "utf-8");
+      if (fs34.existsSync(p)) {
+        const source = fs34.readFileSync(p, "utf-8");
         this.json(res, 200, { type, path: p, source, lines: source.split("\n").length });
         return;
       }
@@ -59423,11 +59605,11 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: `Provider not found: ${type}` });
       return;
     }
-    const target = fs32.existsSync(path41.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
+    const target = fs34.existsSync(path41.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
     const targetPath = path41.join(dir, target);
     try {
-      if (fs32.existsSync(targetPath)) fs32.copyFileSync(targetPath, targetPath + ".bak");
-      fs32.writeFileSync(targetPath, source, "utf-8");
+      if (fs34.existsSync(targetPath)) fs34.copyFileSync(targetPath, targetPath + ".bak");
+      fs34.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 });
@@ -59572,20 +59754,20 @@ var DevServer = class _DevServer {
     let targetDir;
     targetDir = this.providerLoader.getUserProviderDir(category, type);
     const jsonPath = path41.join(targetDir, "provider.json");
-    if (fs32.existsSync(jsonPath)) {
+    if (fs34.existsSync(jsonPath)) {
       this.json(res, 409, { error: `Provider already exists at ${targetDir}`, path: targetDir });
       return;
     }
     try {
       const result = generateFiles(type, name, category, { cdpPorts, cli, processName, installPath, binary, extensionId, version, osPaths, processNames });
-      fs32.mkdirSync(targetDir, { recursive: true });
-      fs32.writeFileSync(jsonPath, result["provider.json"], "utf-8");
+      fs34.mkdirSync(targetDir, { recursive: true });
+      fs34.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 = path41.join(targetDir, relPath);
-          fs32.mkdirSync(path41.dirname(fullPath), { recursive: true });
-          fs32.writeFileSync(fullPath, content, "utf-8");
+          fs34.mkdirSync(path41.dirname(fullPath), { recursive: true });
+          fs34.writeFileSync(fullPath, content, "utf-8");
           createdFiles.push(relPath);
         }
       }
@@ -59634,10 +59816,10 @@ var DevServer = class _DevServer {
   }
   // ─── Phase 2: Auto-Implement Backend ───
   getLatestScriptVersionDir(scriptsDir) {
-    if (!fs32.existsSync(scriptsDir)) return null;
-    const versions = fs32.readdirSync(scriptsDir).filter((d) => {
+    if (!fs34.existsSync(scriptsDir)) return null;
+    const versions = fs34.readdirSync(scriptsDir).filter((d) => {
       try {
-        return fs32.statSync(path41.join(scriptsDir, d)).isDirectory();
+        return fs34.statSync(path41.join(scriptsDir, d)).isDirectory();
       } catch {
         return false;
       }
@@ -59659,13 +59841,13 @@ var DevServer = class _DevServer {
     if (!sourceDir) {
       return { dir: null, reason: `Provider source directory not found for '${type}'` };
     }
-    if (!fs32.existsSync(desiredDir)) {
-      fs32.mkdirSync(path41.dirname(desiredDir), { recursive: true });
-      fs32.cpSync(sourceDir, desiredDir, { recursive: true });
+    if (!fs34.existsSync(desiredDir)) {
+      fs34.mkdirSync(path41.dirname(desiredDir), { recursive: true });
+      fs34.cpSync(sourceDir, desiredDir, { recursive: true });
       this.log(`Auto-implement writable copy created: ${desiredDir}`);
     }
     const providerJson = path41.join(desiredDir, "provider.json");
-    if (!fs32.existsSync(providerJson)) {
+    if (!fs34.existsSync(providerJson)) {
       return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
     }
     return { dir: desiredDir };
@@ -59708,10 +59890,10 @@ var DevServer = class _DevServer {
       lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
       lines.push("These are the ONLY files you are allowed to modify. Replace the TODO stubs with working implementations.");
       lines.push("");
-      for (const file of fs32.readdirSync(latestScriptsDir)) {
+      for (const file of fs34.readdirSync(latestScriptsDir)) {
         if (file.endsWith(".js") && targetFileNames.has(file)) {
           try {
-            const content = fs32.readFileSync(path41.join(latestScriptsDir, file), "utf-8");
+            const content = fs34.readFileSync(path41.join(latestScriptsDir, file), "utf-8");
             lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
             lines.push("```javascript");
             lines.push(content);
@@ -59721,14 +59903,14 @@ var DevServer = class _DevServer {
           }
         }
       }
-      const refFiles = fs32.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+      const refFiles = fs34.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
       if (refFiles.length > 0) {
         lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
         lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
         lines.push("");
         for (const file of refFiles) {
           try {
-            const content = fs32.readFileSync(path41.join(latestScriptsDir, file), "utf-8");
+            const content = fs34.readFileSync(path41.join(latestScriptsDir, file), "utf-8");
             lines.push(`### \`${file}\` \u{1F512}`);
             lines.push("```javascript");
             lines.push(content);
@@ -59773,7 +59955,7 @@ var DevServer = class _DevServer {
     const loadGuide = (name) => {
       try {
         const p = path41.join(docsDir, name);
-        if (fs32.existsSync(p)) return fs32.readFileSync(p, "utf-8");
+        if (fs34.existsSync(p)) return fs34.readFileSync(p, "utf-8");
       } catch {
       }
       return null;
@@ -59954,11 +60136,11 @@ var DevServer = class _DevServer {
       lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
       lines.push("These are the ONLY files you are allowed to modify. Replace TODO or heuristic-only logic with working PTY-aware implementations.");
       lines.push("");
-      for (const file of fs32.readdirSync(latestScriptsDir)) {
+      for (const file of fs34.readdirSync(latestScriptsDir)) {
         if (!file.endsWith(".js")) continue;
         if (!targetFileNames.has(file)) continue;
         try {
-          const content = fs32.readFileSync(path41.join(latestScriptsDir, file), "utf-8");
+          const content = fs34.readFileSync(path41.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
           lines.push("```javascript");
           lines.push(content);
@@ -59967,14 +60149,14 @@ var DevServer = class _DevServer {
         } catch {
         }
       }
-      const refFiles = fs32.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+      const refFiles = fs34.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
       if (refFiles.length > 0) {
         lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
         lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
         lines.push("");
         for (const file of refFiles) {
           try {
-            const content = fs32.readFileSync(path41.join(latestScriptsDir, file), "utf-8");
+            const content = fs34.readFileSync(path41.join(latestScriptsDir, file), "utf-8");
             lines.push(`### \`${file}\` \u{1F512}`);
             lines.push("```javascript");
             lines.push(content);
@@ -60011,7 +60193,7 @@ var DevServer = class _DevServer {
     const loadGuide = (name) => {
       try {
         const p = path41.join(docsDir, name);
-        if (fs32.existsSync(p)) return fs32.readFileSync(p, "utf-8");
+        if (fs34.existsSync(p)) return fs34.readFileSync(p, "utf-8");
       } catch {
       }
       return null;
@@ -61112,8 +61294,8 @@ async function installExtension(ide, extension) {
       const res = await fetch(extension.vsixUrl);
       if (res.ok) {
         const buffer = Buffer.from(await res.arrayBuffer());
-        const fs33 = await import("fs");
-        fs33.writeFileSync(vsixPath, buffer);
+        const fs35 = await import("fs");
+        fs35.writeFileSync(vsixPath, buffer);
         return new Promise((resolve24) => {
           const cmd = `"${ide.cliCommand}" --install-extension "${vsixPath}" --force`;
           (0, import_child_process11.exec)(cmd, { timeout: 6e4 }, (error, _stdout, stderr) => {