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

package/dist/index.js

@@ -30036,10 +30036,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "fe24f3fb158efc949e806b79bca2479b1c29d753" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "fe24f3fb" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = 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:48:25.762Z" : 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 version2 = 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:23:02.144Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -37002,8 +37002,8 @@ ${rendered}`, "utf-8");
         const remaining = (existing.slice(0, openIdx) + existing.slice(closeIdx + CLOSE.length)).replace(/^\s*\n+/, "").replace(/\n+\s*$/, "");
         if (!remaining.trim()) {
           try {
-            const fs33 = require("fs");
-            fs33.unlinkSync(filePath);
+            const fs35 = require("fs");
+            fs35.unlinkSync(filePath);
           } catch {
           }
         } else {
@@ -39448,9 +39448,9 @@ Next step: ${nextStep}`;
         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;
               }
@@ -39464,12 +39464,12 @@ Next step: ${nextStep}`;
     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;
@@ -39480,12 +39480,12 @@ Next step: ${nextStep}`;
     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);
@@ -43282,6 +43282,13 @@ ${cleanBody}`;
         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,
@@ -43295,7 +43302,11 @@ ${cleanBody}`;
         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) {
@@ -46274,8 +46285,8 @@ ${cleanBody}`;
             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();
@@ -62051,7 +62062,7 @@ ${effect.notification.body || ""}`.trim();
           return { success: false, error: "invalid type" };
         }
         const https = require("https");
-        const fs33 = require("fs");
+        const fs35 = require("fs");
         const path422 = require("path");
         const crypto6 = require("crypto");
         const REGISTRY = "https://api.adhf.dev/api/v1/registry";
@@ -62095,7 +62106,7 @@ ${effect.notification.body || ""}`.trim();
           if (!targetDir.startsWith(installRootResolved + path422.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);
@@ -62120,7 +62131,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           }
           const targetFile = isV1 ? "provider.v1.json" : "provider.json";
           const targetPath = path422.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,
@@ -62190,7 +62201,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 path422 = require("path");
         function fetchJson(url2, timeoutMs) {
           return new Promise((resolve24, reject) => {
@@ -62274,8 +62285,8 @@ ${formatManifestValidationIssues2(validation.issues)}`,
                 const relInside = entry.path.startsWith(sharedDirRel + "/") ? entry.path.slice(sharedDirRel.length + 1) : entry.path;
                 const outPath = path422.resolve(path422.join(sharedTargetDir, relInside));
                 if (!outPath.startsWith(path422.resolve(sharedTargetDir) + path422.sep)) continue;
-                fs33.mkdirSync(path422.dirname(outPath), { recursive: true });
-                fs33.writeFileSync(outPath, body);
+                fs35.mkdirSync(path422.dirname(outPath), { recursive: true });
+                fs35.writeFileSync(outPath, body);
                 fetchedCount++;
               } catch (e) {
                 errors.push(`fetch shared ${entry.path}: ${e?.message ?? e}`);
@@ -62313,8 +62324,8 @@ ${formatManifestValidationIssues2(validation.issues)}`,
                   errors.push(`refusing to write outside targetDir: ${entry.path}`);
                   continue;
                 }
-                fs33.mkdirSync(path422.dirname(outPath), { recursive: true });
-                fs33.writeFileSync(outPath, body);
+                fs35.mkdirSync(path422.dirname(outPath), { recursive: true });
+                fs35.writeFileSync(outPath, body);
                 fetchedCount++;
               } catch (e) {
                 errors.push(`fetch ${entry.path}: ${e?.message ?? e}`);
@@ -62342,7 +62353,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 path422 = require("path");
         try {
           const installRoot = this.getUpstreamInstallRoot();
@@ -62351,10 +62362,10 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           if (!targetDir.startsWith(installRootResolved + path422.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();
@@ -62370,28 +62381,28 @@ ${formatManifestValidationIssues2(validation.issues)}`,
        * the UI and by the update checker.
        */
       handleListInstalledProviders(_args) {
-        const fs33 = require("fs");
+        const fs35 = require("fs");
         const path422 = 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 = path422.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 = path422.join(categoryDir, type, "provider.v1.json");
             const v0Path = path422.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,
@@ -62502,7 +62513,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 path422 = require("path");
         const { spawnSync: spawnSync2 } = require("child_process");
         const file2 = ext.loadExternalSources();
@@ -62513,8 +62524,8 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           return { success: false, error: `source url+ref already registered (use a different name to track another ref)` };
         }
         const sourceDir = path422.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 clone2 = spawnSync2("git", ["clone", "--depth=1", "--branch", ref, "--", url2, sourceDir], {
@@ -62524,7 +62535,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         });
         if (clone2.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: ${(clone2.stderr || clone2.stdout || "").trim() || "unknown error"}` };
@@ -62568,15 +62579,15 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         const name = typeof args?.name === "string" ? args.name.trim() : "";
         if (!name) return { success: false, error: "name is required" };
         const ext = (init_external_sources(), __toCommonJS2(external_sources_exports));
-        const fs33 = require("fs");
+        const fs35 = require("fs");
         const path422 = require("path");
         const file2 = ext.loadExternalSources();
         const match = file2.sources.find((s2) => s2.name === name);
         if (!match) return { success: false, error: `source "${name}" not registered` };
         const sourceDir = path422.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}` };
           }
@@ -63345,14 +63356,14 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     };
     var coordinatorPromptHandlers = {
       list_coordinator_prompts: async (_ctx, _args) => {
-        const fs33 = await import("fs");
+        const fs35 = await import("fs");
         const path422 = await import("path");
         const os30 = await import("os");
         const dir = path422.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;
@@ -63362,7 +63373,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
               const full = path422.join(dir, name);
               let content = "";
               try {
-                content = fs33.readFileSync(full, "utf8");
+                content = fs35.readFileSync(full, "utf8");
               } catch {
               }
               if (!entries[key]) entries[key] = { override: "", append: "" };
@@ -63376,7 +63387,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         return { success: true, dir, entries };
       },
       write_coordinator_prompt: async (_ctx, args) => {
-        const fs33 = await import("fs");
+        const fs35 = await import("fs");
         const path422 = await import("path");
         const os30 = await import("os");
         const key = typeof args?.key === "string" ? args.key.trim() : "";
@@ -63389,11 +63400,11 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         const filename = kind === "append" ? `${key}.append.md` : `${key}.md`;
         const full = path422.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 (error48) {
@@ -71349,7 +71360,17 @@ Run 'adhdev doctor' for detailed diagnostics.`
             continue;
           }
           const restoredSettings = { ...this.providerLoader.getSettings(normalizedType) };
-          const coordinatorEntry = getCoordinatorForSession(record2.runtimeId);
+          let coordinatorEntry = getCoordinatorForSession(record2.runtimeId);
+          if (!coordinatorEntry?.meshId && record2.workspace) {
+            const workspaceCoordinators = listCoordinatorsForWorkspace(record2.workspace).filter((e) => e.meshId && (!e.cliType || e.cliType === record2.cliType));
+            if (workspaceCoordinators.length === 1) {
+              coordinatorEntry = workspaceCoordinators[0];
+              LOG2.info(
+                "CLI",
+                `\u21BB Rebound coordinator mark by workspace for ${record2.runtimeKey || record2.runtimeId} (mesh ${coordinatorEntry.meshId} @ ${record2.workspace}); registry key did not match runtimeId`
+              );
+            }
+          }
           if (coordinatorEntry?.meshId) {
             restoredSettings.meshCoordinatorFor = coordinatorEntry.meshId;
           }
@@ -74236,7 +74257,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         }
         if (providerDir) {
           try {
-            const fs33 = require("fs");
+            const fs35 = require("fs");
             const path422 = require("path");
             const candidates = [];
             if (Array.isArray(base.compatibility)) {
@@ -74248,13 +74269,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
             }
             candidates.push(path422.join(providerDir, "specs", "default.json"));
             candidates.push(path422.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 {
@@ -74286,7 +74307,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
                   reader = (input) => executeNativeHistory(nh, input);
                 } else if (nh.override_path) {
                   const overrideFile = path422.resolve(providerDir, nh.override_path);
-                  if (fs33.existsSync(overrideFile)) {
+                  if (fs35.existsSync(overrideFile)) {
                     try {
                       registerProviderScriptRootSafely(path422.dirname(path422.dirname(providerDir)));
                       delete require.cache[require.resolve(overrideFile)];
@@ -74833,8 +74854,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
         }
       }
       writeConfig(config2) {
-        const { saveConfig: saveConfig3 } = (init_config(), __toCommonJS2(config_exports));
-        saveConfig3(config2);
+        const { saveConfig: saveConfig2 } = (init_config(), __toCommonJS2(config_exports));
+        saveConfig2(config2);
       }
       getPlatformVersionCommand(versionCommand) {
         if (!versionCommand) return void 0;
@@ -75467,7 +75488,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         }
       } else if (plat === "win32") {
         try {
-          const fs33 = require("fs");
+          const fs35 = require("fs");
           const appNameMap = getMacAppIdentifiers();
           const appName = appNameMap[ideId];
           if (appName) {
@@ -75476,8 +75497,8 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
               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];
@@ -76971,12 +76992,1039 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         ...fastForwardHandlers
       })
     );
+    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 = normalizeInteractivePromptResponse2(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 };
+      }
+    };
+    var import_path12 = require("path");
+    var fs26 = __toESM2(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 (error48) {
+              const message = error48?.message || String(error48);
+              LOG2.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(" ");
+                LOG2.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;
+                }
+                LOG2.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 (error48) {
+              LOG2.warn("MeshCoordinator", `MCP registration command failed: ${error48?.message || error48}`);
+              mcpRegistrationFailure = {
+                command: coordinatorSetup.command,
+                output: error48?.message || String(error48),
+                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");
+                    LOG2.info("MeshCoordinator", `Refreshed repo-local ${repoMcpConfigPath} entry for ${coordinatorSetup.serverName}`);
+                  }
+                } catch (error48) {
+                  return {
+                    success: false,
+                    code: "mesh_coordinator_config_write_failed",
+                    error: `Could not refresh repo-local MCP config: ${error48?.message || error48}`,
+                    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);
+                  LOG2.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" };
+            }
+            LOG2.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 (error48) {
+            const message = error48?.message || String(error48);
+            LOG2.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 (error48) {
+              const message = `Failed to parse Hermes base config for automatic coordinator setup: ${error48?.message || error48}`;
+              LOG2.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 (error48) {
+            const message = `Could not prepare MCP config path for automatic setup: ${error48?.message || error48}`;
+            LOG2.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 (error48) {
+              LOG2.error("MeshCoordinator", `Failed to parse existing MCP config ${mcpConfigPath}: ${error48?.message || error48}`);
+              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 (error48) {
+            const message = `Could not write MCP config for automatic setup: ${error48?.message || error48}`;
+            LOG2.error("MeshCoordinator", message);
+            if (hermesManualFallback) return returnManualFallback(message);
+            return { success: false, code: "mesh_coordinator_config_write_failed", error: message, meshId, cliType, workspace };
+          }
+          LOG2.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);
+                LOG2.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" };
+          }
+          LOG2.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) {
+          LOG2.error("MeshCoordinator", `Failed: ${e.message}`);
+          return { success: false, error: e.message };
+        }
+      }
+    };
+    var fs27 = __toESM2(require("fs"));
+    var import_os3 = require("os");
     init_config();
+    init_git_status();
+    init_dist();
+    init_mesh_events();
+    init_mesh_routing();
+    init_mesh_host_ownership();
+    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 path422 = (0, import_node_path2.resolve)(repoRoot, PREVIEW_DEPLOY_RECORD);
+      if (!(0, import_node_fs4.existsSync)(path422)) return null;
+      try {
+        const parsed = JSON.parse((0, import_node_fs4.readFileSync)(path422, "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(record2, currentCommit) {
+      const targets = record2?.targets && typeof record2.targets === "object" && !Array.isArray(record2.targets) ? record2.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 record2 = readRecord5(repoRoot);
+      const lastPreviewCommit = normalizeCommit(record2?.lastPreviewCommit);
+      const targets = readTargetFreshness(record2, 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 record2?.updatedAt === "string" ? record2.updatedAt : void 0,
+        lastTarget: typeof record2?.target === "string" ? record2.target : void 0,
+        previewVersion: typeof record2?.previewVersion === "string" ? record2.previewVersion : void 0,
+        targets,
+        nextAction
+      };
+    }
+    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 = loadConfig2().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((record2) => typeof record2?.sessionId === "string" ? record2.sessionId : "").filter(Boolean);
+              const providerTypes = matchedLiveSessionRecords.map((record2) => readStringValue(record2?.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 };
+        }
+      }
+    };
+    var highFamilyRegistry = new Map(
+      Object.entries({
+        ...meshEventsHandlers,
+        ...meshCoordinatorLaunchHandlers,
+        ...meshStatusHandlers
+      })
+    );
     init_cli_detector();
     init_git_status();
     init_dist();
     init_logger();
-    var fs26 = __toESM2(require("fs"));
+    var fs28 = __toESM2(require("fs"));
     var path36 = __toESM2(require("path"));
     var os27 = __toESM2(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");
@@ -76984,7 +78032,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     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([
@@ -77030,7 +78078,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     }
     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);
@@ -77038,7 +78086,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
           const dateMatch = file2.match(/commands-(\d{4}-\d{2}-\d{2})/);
           if (dateMatch && dateMatch[1] < cutoffStr) {
             try {
-              fs26.unlinkSync(path36.join(LOG_DIR2, file2));
+              fs28.unlinkSync(path36.join(LOG_DIR2, file2));
             } catch {
             }
           }
@@ -77048,14 +78096,14 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     }
     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 {
       }
@@ -77088,14 +78136,14 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
           ...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 {
@@ -77120,14 +78168,11 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     }
     cleanOldFiles();
     var yaml4 = __toESM2(require_js_yaml());
-    init_mesh_coordinator();
-    init_coordinator_registry();
     init_mesh_events();
-    init_mesh_routing();
     init_mesh_host_ownership();
-    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(path422) {
       const slash = path422.indexOf("/");
@@ -77210,92 +78255,11 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       }
       return { order: ranked.map((a) => a.nodeId), changeAreas: areaById, rationale };
     }
-    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 path422 = (0, import_node_path2.resolve)(repoRoot, PREVIEW_DEPLOY_RECORD);
-      if (!(0, import_node_fs4.existsSync)(path422)) return null;
-      try {
-        const parsed = JSON.parse((0, import_node_fs4.readFileSync)(path422, "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(record2, currentCommit) {
-      const targets = record2?.targets && typeof record2.targets === "object" && !Array.isArray(record2.targets) ? record2.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 record2 = readRecord5(repoRoot);
-      const lastPreviewCommit = normalizeCommit(record2?.lastPreviewCommit);
-      const targets = readTargetFreshness(record2, 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 record2?.updatedAt === "string" ? record2.updatedAt : void 0,
-        lastTarget: typeof record2?.target === "string" ? record2.target : void 0,
-        previewVersion: typeof record2?.previewVersion === "string" ? record2.previewVersion : void 0,
-        targets,
-        nextAction
-      };
-    }
-    init_mesh_refine_status();
     init_mesh_work_queue();
     init_repo_mesh_types();
-    var import_os3 = require("os");
-    var import_path12 = require("path");
-    var fs27 = __toESM2(require("fs"));
+    var import_os4 = require("os");
+    var import_path13 = require("path");
+    var fs29 = __toESM2(require("fs"));
     var import_node_child_process6 = require("child_process");
     init_resolve_executable();
     function readProviderPriorityFromPolicy(policy) {
@@ -77643,7 +78607,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       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;
@@ -77891,7 +78855,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       const followUps = nodes.filter((node) => {
         if (readObjectRecord(node.branchConvergence).needsConvergence !== true) return false;
         const workspace = typeof node.workspace === "string" ? node.workspace : "";
-        if (workspace && !fs27.existsSync(workspace)) return false;
+        if (workspace && !fs29.existsSync(workspace)) return false;
         return true;
       }).map((node) => {
         const convergence = readObjectRecord(node.branchConvergence);
@@ -78199,7 +79163,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
           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) {
@@ -78307,7 +79271,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     }
     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((record2) => {
         const recordNodeId = readStringValue(record2?.meta?.meshNodeId);
         if (recordNodeId && recordNodeId !== args.nodeId) return false;
@@ -78334,7 +79298,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         const workspace = readStringValue(node?.workspace);
         if (nodeId) liveNodeIds.add(nodeId);
         if (workspace) liveWorkspaces.add(workspace);
-        if (nodeId && node?.isLocalWorktree === true && workspace && !fs27.existsSync(workspace)) {
+        if (nodeId && node?.isLocalWorktree === true && workspace && !fs29.existsSync(workspace)) {
           missingLocalWorktreeNodeIds.add(nodeId);
         }
       }
@@ -78770,7 +79734,7 @@ ${mergeTreeErr?.stderr || ""}`;
       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" });
@@ -78809,14 +79773,14 @@ ${mergeTreeErr?.stderr || ""}`;
         const baseCommit = readTreeObject(repoRoot, baseHead, path422);
         const branchCommit = readTreeObject(repoRoot, branchHead, path422);
         if (!baseCommit || !branchCommit) return false;
-        return isSubmoduleFastForward((0, import_path12.resolve)(repoRoot, path422), baseCommit, branchCommit);
+        return isSubmoduleFastForward((0, import_path13.resolve)(repoRoot, path422), baseCommit, branchCommit);
       });
     }
     function evaluateGitlinkTrivialFastForward(repoRoot, baseHead, branchHead) {
       const changedGitlinks = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path422) => {
         const baseCommit = readTreeObject(repoRoot, baseHead, path422);
         const branchCommit = readTreeObject(repoRoot, branchHead, path422);
-        const submoduleRepoPath = (0, import_path12.resolve)(repoRoot, path422);
+        const submoduleRepoPath = (0, import_path13.resolve)(repoRoot, path422);
         const fastForward = !!baseCommit && !!branchCommit && isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit);
         return { path: path422, baseCommit, branchCommit, fastForward };
       });
@@ -78871,7 +79835,7 @@ ${mergeTreeErr?.stderr || ""}`;
         if (!tree) return void 0;
         const updates = paths.map((path422) => `160000 commit ${placeholderCommit}	${path422}`).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 env2 = { ...process.env, GIT_INDEX_FILE: tmpIndex };
         try {
           (0, import_node_child_process6.execFileSync)("git", ["read-tree", tree], { cwd: repoRoot, env: env2, stdio: "ignore" });
@@ -78887,7 +79851,7 @@ ${mergeTreeErr?.stderr || ""}`;
           return newTree || void 0;
         } finally {
           try {
-            fs27.rmSync(tmpIndex, { force: true });
+            fs29.rmSync(tmpIndex, { force: true });
           } catch {
           }
         }
@@ -78946,7 +79910,7 @@ ${mergeTreeErr?.stderr || ""}`;
         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 env2 = { ...process.env, GIT_INDEX_FILE: tmpIndex };
         try {
           (0, import_node_child_process6.execFileSync)("git", ["read-tree", contentTree], { cwd: repoRoot, env: env2, stdio: "ignore" });
@@ -78962,7 +79926,7 @@ ${mergeTreeErr?.stderr || ""}`;
           return newTree || void 0;
         } finally {
           try {
-            fs27.rmSync(tmpIndex, { force: true });
+            fs29.rmSync(tmpIndex, { force: true });
           } catch {
           }
         }
@@ -79068,7 +80032,7 @@ ${mergeTreeErr?.stderr || ""}`;
           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 {
@@ -79084,14 +80048,14 @@ ${mergeTreeErr?.stderr || ""}`;
           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) {
@@ -79112,7 +80076,7 @@ ${mergeTreeErr?.stderr || ""}`;
                 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) {
@@ -79324,19 +80288,19 @@ ${mergeTreeErr?.stderr || ""}`;
         ...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 {
@@ -79366,7 +80330,7 @@ ${mergeTreeErr?.stderr || ""}`;
       }
       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)) {
@@ -79435,14 +80399,14 @@ ${mergeTreeErr?.stderr || ""}`;
     }
     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 };
     }
@@ -79475,13 +80439,13 @@ ${mergeTreeErr?.stderr || ""}`;
       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 (error48) {
           LOG2.warn("MeshCoordinator", `Could not copy Hermes ${fileName} into isolated coordinator home: ${error48?.message || error48}`);
         }
@@ -79873,6 +80837,29 @@ ${mergeTreeErr?.stderr || ""}`;
         };
         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;
@@ -79930,7 +80917,7 @@ ${mergeTreeErr?.stderr || ""}`;
           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;
           }
@@ -79965,14 +80952,14 @@ ${mergeTreeErr?.stderr || ""}`;
        * 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;
@@ -79983,7 +80970,7 @@ ${mergeTreeErr?.stderr || ""}`;
           }
           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() : "";
@@ -79995,13 +80982,13 @@ ${mergeTreeErr?.stderr || ""}`;
             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",
@@ -80019,9 +81006,9 @@ ${mergeTreeErr?.stderr || ""}`;
         }
         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;
           }
@@ -80616,196 +81603,242 @@ ${mergeTreeErr?.stderr || ""}`;
           LOG2.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 merge2 = await this.refineMergeAndFinalizeStage(ctx);
+          return merge2.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,
@@ -80816,16 +81849,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,
@@ -80840,146 +81878,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 {
+          const alreadyMergedViaOtherPath = !patchEquivalence.actualPatchId && !!patchEquivalence.expectedPatchId;
+          if (!didAutoRebase && !alreadyMergedViaOtherPath) {
+            return { kind: "terminal", result: {
               success: false,
-              code: "submodule_reachability_failed",
+              code: "patch_equivalence_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
-              })),
+              error: "Refinery patch-equivalence preflight failed; merge/refine was not attempted.",
               branch,
               into: baseBranch,
               validationSummary,
               patchEquivalence,
-              submoduleReachability,
               refineStages,
               finalBranchConvergenceState: {
                 branch,
@@ -80987,232 +81899,378 @@ ${tail}` : ""
                 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 {
-              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 } : {}
+                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((record2) => {
-                const sid = typeof record2?.sessionId === "string" ? record2.sessionId : "";
-                if (!sid) return false;
-                if (readStringValue(record2?.meta?.meshCoordinatorFor) === meshId) return false;
-                const boundToNode = readStringValue(record2?.meta?.meshNodeId) === nodeId;
-                const matchedByWorkspace = !!workspace && record2?.workspace === workspace;
-                return boundToNode || matchedByWorkspace;
-              }).map((record2) => String(record2.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((record2) => {
+              const sid = typeof record2?.sessionId === "string" ? record2.sessionId : "";
+              if (!sid) return false;
+              if (readStringValue(record2?.meta?.meshCoordinatorFor) === meshId) return false;
+              const boundToNode = readStringValue(record2?.meta?.meshNodeId) === nodeId;
+              const matchedByWorkspace = !!workspace && record2?.workspace === workspace;
+              return boundToNode || matchedByWorkspace;
+            }).map((record2) => String(record2.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,
@@ -81224,17 +82282,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
@@ -81792,929 +82884,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 = normalizeInteractivePromptResponse2(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 (error48) {
-                  const message = error48?.message || String(error48);
-                  LOG2.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(" ");
-                    LOG2.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;
-                    }
-                    LOG2.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 (error48) {
-                  LOG2.warn("MeshCoordinator", `MCP registration command failed: ${error48?.message || error48}`);
-                  mcpRegistrationFailure = {
-                    command: coordinatorSetup.command,
-                    output: error48?.message || String(error48),
-                    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");
-                        LOG2.info("MeshCoordinator", `Refreshed repo-local ${repoMcpConfigPath} entry for ${coordinatorSetup.serverName}`);
-                      }
-                    } catch (error48) {
-                      return {
-                        success: false,
-                        code: "mesh_coordinator_config_write_failed",
-                        error: `Could not refresh repo-local MCP config: ${error48?.message || error48}`,
-                        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);
-                      LOG2.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" };
-                }
-                LOG2.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 (error48) {
-                const message = error48?.message || String(error48);
-                LOG2.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 (error48) {
-                  const message = `Failed to parse Hermes base config for automatic coordinator setup: ${error48?.message || error48}`;
-                  LOG2.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 (error48) {
-                const message = `Could not prepare MCP config path for automatic setup: ${error48?.message || error48}`;
-                LOG2.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 (error48) {
-                  LOG2.error("MeshCoordinator", `Failed to parse existing MCP config ${mcpConfigPath}: ${error48?.message || error48}`);
-                  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 (error48) {
-                const message = `Could not write MCP config for automatic setup: ${error48?.message || error48}`;
-                LOG2.error("MeshCoordinator", message);
-                if (hermesManualFallback) return returnManualFallback(message);
-                return { success: false, code: "mesh_coordinator_config_write_failed", error: message, meshId, cliType, workspace };
-              }
-              LOG2.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);
-                    LOG2.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" };
-              }
-              LOG2.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) {
-              LOG2.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 = loadConfig2().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((record2) => typeof record2?.sessionId === "string" ? record2.sessionId : "").filter(Boolean);
-                  const providerTypes = matchedLiveSessionRecords.map((record2) => readStringValue(record2?.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;
       }
@@ -84416,10 +84588,10 @@ ${ptyResult.output.slice(-2e3)}`);
     };
     init_io_contracts();
     init_chat_message_normalization();
-    var fs28 = __toESM2(require("fs"));
+    var fs30 = __toESM2(require("fs"));
     var path37 = __toESM2(require("path"));
     var os28 = __toESM2(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;
@@ -84430,8 +84602,8 @@ ${ptyResult.output.slice(-2e3)}`);
       }
       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 = {};
@@ -84446,7 +84618,7 @@ ${ptyResult.output.slice(-2e3)}`);
         entries.push({
           version: version2,
           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);
@@ -84468,8 +84640,8 @@ ${ptyResult.output.slice(-2e3)}`);
       }
       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 {
         }
       }
@@ -84486,7 +84658,7 @@ ${ptyResult.output.slice(-2e3)}`);
       });
     }
     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) {
@@ -84494,8 +84666,8 @@ ${ptyResult.output.slice(-2e3)}`);
         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;
               }
@@ -84542,23 +84714,23 @@ ${ptyResult.output.slice(-2e3)}`);
         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 = {
@@ -84579,7 +84751,7 @@ ${ptyResult.output.slice(-2e3)}`);
           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;
@@ -84625,7 +84797,7 @@ ${ptyResult.output.slice(-2e3)}`);
       return results;
     }
     var http2 = __toESM2(require("http"));
-    var fs322 = __toESM2(require("fs"));
+    var fs34 = __toESM2(require("fs"));
     var path41 = __toESM2(require("path"));
     init_config();
     function generateFiles(type, name, category, opts = {}) {
@@ -84971,7 +85143,7 @@ async (params) => {
     }
     init_logger();
     init_builders();
-    var fs29 = __toESM2(require("fs"));
+    var fs31 = __toESM2(require("fs"));
     var path38 = __toESM2(require("path"));
     init_logger();
     async function handleCdpEvaluate(ctx, req, res) {
@@ -85152,17 +85324,17 @@ async (params) => {
       }
       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;
             }
@@ -85174,7 +85346,7 @@ async (params) => {
         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;
@@ -85987,7 +86159,7 @@ async (params) => {
         ctx.json(res, 500, { error: `DOM context collection failed: ${e.message}` });
       }
     }
-    var fs30 = __toESM2(require("fs"));
+    var fs322 = __toESM2(require("fs"));
     var path39 = __toESM2(require("path"));
     function slugifyFixtureName(value) {
       const normalized = String(value || "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
@@ -86003,10 +86175,10 @@ async (params) => {
     function readCliFixture(ctx, type, name) {
       const fixtureDir = getCliFixtureDir(ctx, type);
       const filePath = path39.join(fixtureDir, `${name}.json`);
-      if (!fs30.existsSync(filePath)) {
+      if (!fs322.existsSync(filePath)) {
         throw new Error(`Fixture not found: ${filePath}`);
       }
-      return JSON.parse(fs30.readFileSync(filePath, "utf-8"));
+      return JSON.parse(fs322.readFileSync(filePath, "utf-8"));
     }
     function getExerciseTranscriptText(result) {
       const parts = [];
@@ -86751,7 +86923,7 @@ async (params) => {
           return;
         }
         const fixtureDir = getCliFixtureDir(ctx, type);
-        fs30.mkdirSync(fixtureDir, { recursive: true });
+        fs322.mkdirSync(fixtureDir, { recursive: true });
         const name = slugifyFixtureName(String(body?.name || `${type}-${Date.now()}`));
         const result = await runCliExerciseInternal(ctx, { ...request, type });
         const fixture = {
@@ -86779,7 +86951,7 @@ async (params) => {
           notes: typeof body?.notes === "string" ? body.notes : void 0
         };
         const filePath = path39.join(fixtureDir, `${name}.json`);
-        fs30.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
+        fs322.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
         ctx.json(res, 200, {
           saved: true,
           name,
@@ -86797,14 +86969,14 @@ async (params) => {
     async function handleCliFixtureList(ctx, type, _req, res) {
       try {
         const fixtureDir = getCliFixtureDir(ctx, type);
-        if (!fs30.existsSync(fixtureDir)) {
+        if (!fs322.existsSync(fixtureDir)) {
           ctx.json(res, 200, { fixtures: [], count: 0 });
           return;
         }
-        const fixtures = fs30.readdirSync(fixtureDir).filter((file2) => file2.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file2) => {
+        const fixtures = fs322.readdirSync(fixtureDir).filter((file2) => file2.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file2) => {
           const fullPath = path39.join(fixtureDir, file2);
           try {
-            const raw = JSON.parse(fs30.readFileSync(fullPath, "utf-8"));
+            const raw = JSON.parse(fs322.readFileSync(fullPath, "utf-8"));
             return {
               name: raw.name || file2.replace(/\.json$/i, ""),
               path: fullPath,
@@ -86935,7 +87107,7 @@ async (params) => {
         ctx.json(res, 500, { error: `Raw send failed: ${e.message}` });
       }
     }
-    var fs31 = __toESM2(require("fs"));
+    var fs33 = __toESM2(require("fs"));
     var path40 = __toESM2(require("path"));
     var os29 = __toESM2(require("os"));
     var import_session_host_core8 = require_dist();
@@ -86984,10 +87156,10 @@ async (params) => {
       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;
         }
@@ -87009,13 +87181,13 @@ async (params) => {
       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 };
@@ -87023,15 +87195,15 @@ async (params) => {
     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 file2 of fs31.readdirSync(latestDir)) {
+      for (const file2 of fs33.readdirSync(latestDir)) {
         if (!file2.endsWith(".js")) continue;
         try {
-          referenceScripts[file2] = fs31.readFileSync(path40.join(latestDir, file2), "utf-8");
+          referenceScripts[file2] = fs33.readFileSync(path40.join(latestDir, file2), "utf-8");
         } catch {
         }
       }
@@ -87140,15 +87312,15 @@ async (params) => {
         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.` });
@@ -87250,7 +87422,7 @@ async (params) => {
             } catch {
             }
             try {
-              fs31.unlinkSync(promptFile);
+              fs33.unlinkSync(promptFile);
             } catch {
             }
             ctx.log(`Auto-implement (ACP) ${success2 ? "completed" : "failed"}: ${type} (exit: ${code})`);
@@ -87476,7 +87648,7 @@ async (params) => {
             }
           });
           try {
-            fs31.unlinkSync(promptFile);
+            fs33.unlinkSync(promptFile);
           } catch {
           }
           ctx.log(`Auto-implement ${success2 ? "completed" : "failed"}: ${type} (exit: ${code})${verificationSummary ? ` verify=${verificationSummary.pass ? "pass" : "fail"}` : ""}`);
@@ -87581,10 +87753,10 @@ async (params) => {
         lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
         lines.push("These are the ONLY files you are allowed to modify. Replace the TODO stubs with working implementations.");
         lines.push("");
-        for (const file2 of fs31.readdirSync(latestScriptsDir)) {
+        for (const file2 of fs33.readdirSync(latestScriptsDir)) {
           if (file2.endsWith(".js") && targetFileNames.has(file2)) {
             try {
-              const content = fs31.readFileSync(path40.join(latestScriptsDir, file2), "utf-8");
+              const content = fs33.readFileSync(path40.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
               lines.push("```javascript");
               lines.push(content);
@@ -87594,14 +87766,14 @@ async (params) => {
             }
           }
         }
-        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 file2 of refFiles) {
             try {
-              const content = fs31.readFileSync(path40.join(latestScriptsDir, file2), "utf-8");
+              const content = fs33.readFileSync(path40.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u{1F512}`);
               lines.push("```javascript");
               lines.push(content);
@@ -87646,7 +87818,7 @@ async (params) => {
       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;
@@ -87890,11 +88062,11 @@ async (params) => {
         lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
         lines.push("These are the ONLY files you are allowed to modify. Replace TODO or heuristic-only logic with working PTY-aware implementations.");
         lines.push("");
-        for (const file2 of fs31.readdirSync(latestScriptsDir)) {
+        for (const file2 of fs33.readdirSync(latestScriptsDir)) {
           if (!file2.endsWith(".js")) continue;
           if (!targetFileNames.has(file2)) continue;
           try {
-            const content = fs31.readFileSync(path40.join(latestScriptsDir, file2), "utf-8");
+            const content = fs33.readFileSync(path40.join(latestScriptsDir, file2), "utf-8");
             lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
             lines.push("```javascript");
             lines.push(content);
@@ -87903,14 +88075,14 @@ async (params) => {
           } 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 file2 of refFiles) {
             try {
-              const content = fs31.readFileSync(path40.join(latestScriptsDir, file2), "utf-8");
+              const content = fs33.readFileSync(path40.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u{1F512}`);
               lines.push("```javascript");
               lines.push(content);
@@ -87947,7 +88119,7 @@ async (params) => {
       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;
@@ -88685,7 +88857,7 @@ data: ${JSON.stringify(msg.data)}
           path41.join(process.cwd(), "packages/web-devconsole/dist")
         ];
         for (const dir of candidates) {
-          if (fs322.existsSync(path41.join(dir, "index.html"))) return dir;
+          if (fs34.existsSync(path41.join(dir, "index.html"))) return dir;
         }
         return null;
       }
@@ -88697,7 +88869,7 @@ data: ${JSON.stringify(msg.data)}
         }
         const htmlPath = path41.join(distDir, "index.html");
         try {
-          const html = fs322.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) {
@@ -88727,7 +88899,7 @@ data: ${JSON.stringify(msg.data)}
           return;
         }
         try {
-          const content = fs322.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" });
@@ -88836,14 +89008,14 @@ data: ${JSON.stringify(msg.data)}
         const files = [];
         const scan = (d, prefix) => {
           try {
-            for (const entry of fs322.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 = fs322.statSync(path41.join(d, entry.name));
+                const stat2 = fs34.statSync(path41.join(d, entry.name));
                 files.push({ path: rel, size: stat2.size, type: "file" });
               }
             }
@@ -88871,11 +89043,11 @@ data: ${JSON.stringify(msg.data)}
           this.json(res, 403, { error: "Forbidden" });
           return;
         }
-        if (!fs322.existsSync(fullPath) || fs322.statSync(fullPath).isDirectory()) {
+        if (!fs34.existsSync(fullPath) || fs34.statSync(fullPath).isDirectory()) {
           this.json(res, 404, { error: `File not found: ${filePath}` });
           return;
         }
-        const content = fs322.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 } */
@@ -88897,9 +89069,9 @@ data: ${JSON.stringify(msg.data)}
           return;
         }
         try {
-          if (fs322.existsSync(fullPath)) fs322.copyFileSync(fullPath, fullPath + ".bak");
-          fs322.mkdirSync(path41.dirname(fullPath), { recursive: true });
-          fs322.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 });
@@ -88916,8 +89088,8 @@ data: ${JSON.stringify(msg.data)}
         }
         for (const name of ["scripts.js", "provider.json"]) {
           const p = path41.join(dir, name);
-          if (fs322.existsSync(p)) {
-            const source = fs322.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;
           }
@@ -88936,11 +89108,11 @@ data: ${JSON.stringify(msg.data)}
           this.json(res, 404, { error: `Provider not found: ${type}` });
           return;
         }
-        const target = fs322.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 (fs322.existsSync(targetPath)) fs322.copyFileSync(targetPath, targetPath + ".bak");
-          fs322.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 });
@@ -89085,20 +89257,20 @@ data: ${JSON.stringify(msg.data)}
         let targetDir;
         targetDir = this.providerLoader.getUserProviderDir(category, type);
         const jsonPath = path41.join(targetDir, "provider.json");
-        if (fs322.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: version2, osPaths, processNames });
-          fs322.mkdirSync(targetDir, { recursive: true });
-          fs322.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);
-              fs322.mkdirSync(path41.dirname(fullPath), { recursive: true });
-              fs322.writeFileSync(fullPath, content, "utf-8");
+              fs34.mkdirSync(path41.dirname(fullPath), { recursive: true });
+              fs34.writeFileSync(fullPath, content, "utf-8");
               createdFiles.push(relPath);
             }
           }
@@ -89147,10 +89319,10 @@ data: ${JSON.stringify(msg.data)}
       }
       // ─── Phase 2: Auto-Implement Backend ───
       getLatestScriptVersionDir(scriptsDir) {
-        if (!fs322.existsSync(scriptsDir)) return null;
-        const versions = fs322.readdirSync(scriptsDir).filter((d) => {
+        if (!fs34.existsSync(scriptsDir)) return null;
+        const versions = fs34.readdirSync(scriptsDir).filter((d) => {
           try {
-            return fs322.statSync(path41.join(scriptsDir, d)).isDirectory();
+            return fs34.statSync(path41.join(scriptsDir, d)).isDirectory();
           } catch {
             return false;
           }
@@ -89172,13 +89344,13 @@ data: ${JSON.stringify(msg.data)}
         if (!sourceDir) {
           return { dir: null, reason: `Provider source directory not found for '${type}'` };
         }
-        if (!fs322.existsSync(desiredDir)) {
-          fs322.mkdirSync(path41.dirname(desiredDir), { recursive: true });
-          fs322.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 (!fs322.existsSync(providerJson)) {
+        if (!fs34.existsSync(providerJson)) {
           return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
         }
         return { dir: desiredDir };
@@ -89221,10 +89393,10 @@ data: ${JSON.stringify(msg.data)}
           lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
           lines.push("These are the ONLY files you are allowed to modify. Replace the TODO stubs with working implementations.");
           lines.push("");
-          for (const file2 of fs322.readdirSync(latestScriptsDir)) {
+          for (const file2 of fs34.readdirSync(latestScriptsDir)) {
             if (file2.endsWith(".js") && targetFileNames.has(file2)) {
               try {
-                const content = fs322.readFileSync(path41.join(latestScriptsDir, file2), "utf-8");
+                const content = fs34.readFileSync(path41.join(latestScriptsDir, file2), "utf-8");
                 lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
                 lines.push("```javascript");
                 lines.push(content);
@@ -89234,14 +89406,14 @@ data: ${JSON.stringify(msg.data)}
               }
             }
           }
-          const refFiles = fs322.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 file2 of refFiles) {
               try {
-                const content = fs322.readFileSync(path41.join(latestScriptsDir, file2), "utf-8");
+                const content = fs34.readFileSync(path41.join(latestScriptsDir, file2), "utf-8");
                 lines.push(`### \`${file2}\` \u{1F512}`);
                 lines.push("```javascript");
                 lines.push(content);
@@ -89286,7 +89458,7 @@ data: ${JSON.stringify(msg.data)}
         const loadGuide = (name) => {
           try {
             const p = path41.join(docsDir, name);
-            if (fs322.existsSync(p)) return fs322.readFileSync(p, "utf-8");
+            if (fs34.existsSync(p)) return fs34.readFileSync(p, "utf-8");
           } catch {
           }
           return null;
@@ -89467,11 +89639,11 @@ data: ${JSON.stringify(msg.data)}
           lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
           lines.push("These are the ONLY files you are allowed to modify. Replace TODO or heuristic-only logic with working PTY-aware implementations.");
           lines.push("");
-          for (const file2 of fs322.readdirSync(latestScriptsDir)) {
+          for (const file2 of fs34.readdirSync(latestScriptsDir)) {
             if (!file2.endsWith(".js")) continue;
             if (!targetFileNames.has(file2)) continue;
             try {
-              const content = fs322.readFileSync(path41.join(latestScriptsDir, file2), "utf-8");
+              const content = fs34.readFileSync(path41.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
               lines.push("```javascript");
               lines.push(content);
@@ -89480,14 +89652,14 @@ data: ${JSON.stringify(msg.data)}
             } catch {
             }
           }
-          const refFiles = fs322.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 file2 of refFiles) {
               try {
-                const content = fs322.readFileSync(path41.join(latestScriptsDir, file2), "utf-8");
+                const content = fs34.readFileSync(path41.join(latestScriptsDir, file2), "utf-8");
                 lines.push(`### \`${file2}\` \u{1F512}`);
                 lines.push("```javascript");
                 lines.push(content);
@@ -89524,7 +89696,7 @@ data: ${JSON.stringify(msg.data)}
         const loadGuide = (name) => {
           try {
             const p = path41.join(docsDir, name);
-            if (fs322.existsSync(p)) return fs322.readFileSync(p, "utf-8");
+            if (fs34.existsSync(p)) return fs34.readFileSync(p, "utf-8");
           } catch {
           }
           return null;
@@ -90611,8 +90783,8 @@ data: ${JSON.stringify(msg.data)}
           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 }, (error48, _stdout, stderr) => {