@adhdev/daemon-core 0.9.82-rc.446 → 0.9.82-rc.448

package/dist/index.js

@@ -409,10 +409,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "c70a1cf556d27bbee6f81e64ea13699887f50ecc" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "c70a1cf5" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.446" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-01T15:09:11.778Z" : void 0);
+  const commit = readInjected(true ? "7636b9d4fc6c456ebfe178b9b0a7b81664b02257" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "7636b9d4" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.448" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-02T00:30:54.215Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -486,8 +486,8 @@ function validateChangeImpactConfig(raw, source = "inline") {
   }
   return { valid: errors.length === 0, errors, config: errors.length === 0 ? config : void 0 };
 }
-function parseConfigText(path43, text) {
-  if (/\.json$/i.test(path43)) return JSON.parse(text);
+function parseConfigText(path44, text) {
+  if (/\.json$/i.test(path44)) return JSON.parse(text);
   return yaml.load(text);
 }
 function loadChangeImpactConfig(repoRoot) {
@@ -1104,14 +1104,14 @@ async function deriveSubmoduleGitlinkStatuses(repo, options) {
   const lastCheckedAt = Date.now();
   const headOidByPath = /* @__PURE__ */ new Map();
   const entries = await Promise.all(
-    paths.filter((path43) => !ignoreSet.has(path43)).map(async (path43) => {
-      const repoPath = repo.repoRoot + "/" + path43;
-      const expected = await readGitlinkExpectedSha(repo, path43, options);
+    paths.filter((path44) => !ignoreSet.has(path44)).map(async (path44) => {
+      const repoPath = repo.repoRoot + "/" + path44;
+      const expected = await readGitlinkExpectedSha(repo, path44, options);
       const actual = await readSubmoduleHeadSha(repo, repoPath, options);
-      if (actual) headOidByPath.set(path43, actual);
+      if (actual) headOidByPath.set(path44, actual);
       const outOfSync = actual === null ? true : expected !== null && expected !== actual;
       return {
-        path: path43,
+        path: path44,
         // Prefer the recorded gitlink SHA (matches the legacy column); fall back
         // to the checked-out SHA so the field is never empty when both are known.
         commit: expected ?? actual ?? "",
@@ -1502,6 +1502,255 @@ var init_git_diff = __esm({
   }
 });
 
+// src/config/config.ts
+var config_exports = {};
+__export(config_exports, {
+  generateMachineId: () => generateMachineId,
+  getConfigDir: () => getConfigDir,
+  getDaemonDataDir: () => getDaemonDataDir,
+  isSetupComplete: () => isSetupComplete,
+  isStableMachineId: () => isStableMachineId,
+  loadConfig: () => loadConfig,
+  markSetupComplete: () => markSetupComplete,
+  resetConfig: () => resetConfig,
+  resolveProviderSourceMode: () => resolveProviderSourceMode,
+  saveConfig: () => saveConfig,
+  updateConfig: () => updateConfig
+});
+function resolveProviderSourceMode(providerSourceMode, legacyDisableUpstream) {
+  if (providerSourceMode === "normal" || providerSourceMode === "no-upstream") {
+    return providerSourceMode;
+  }
+  return legacyDisableUpstream === true ? "no-upstream" : "normal";
+}
+function isPlainObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function asStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => typeof item === "string");
+}
+function asNullableString(value) {
+  return typeof value === "string" ? value : null;
+}
+function asOptionalString(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function asBoolean(value, fallback) {
+  return typeof value === "boolean" ? value : fallback;
+}
+function normalizeMachineProviders(value) {
+  if (!isPlainObject(value)) return {};
+  const result = {};
+  for (const [providerType, raw] of Object.entries(value)) {
+    if (!isPlainObject(raw)) continue;
+    const entry = {};
+    if (raw.enabled === true) entry.enabled = true;
+    if (typeof raw.executable === "string" && raw.executable.trim()) {
+      entry.executable = raw.executable.trim();
+    }
+    if (Array.isArray(raw.args)) {
+      entry.args = raw.args.filter((arg) => typeof arg === "string");
+    }
+    if (isPlainObject(raw.lastDetection)) {
+      entry.lastDetection = raw.lastDetection;
+    }
+    if (isPlainObject(raw.lastVerification)) {
+      entry.lastVerification = raw.lastVerification;
+    }
+    result[providerType] = entry;
+  }
+  return result;
+}
+function normalizeConfig(raw) {
+  const parsed = isPlainObject(raw) ? raw : {};
+  return {
+    serverUrl: typeof parsed.serverUrl === "string" && parsed.serverUrl.trim() ? parsed.serverUrl : DEFAULT_CONFIG.serverUrl,
+    allowServerApiProxy: asBoolean(parsed.allowServerApiProxy, DEFAULT_CONFIG.allowServerApiProxy ?? false),
+    selectedIde: asNullableString(parsed.selectedIde),
+    configuredIdes: asStringArray(parsed.configuredIdes),
+    installedExtensions: asStringArray(parsed.installedExtensions),
+    userEmail: asNullableString(parsed.userEmail),
+    userName: asNullableString(parsed.userName),
+    setupCompleted: asBoolean(parsed.setupCompleted, DEFAULT_CONFIG.setupCompleted),
+    setupDate: asNullableString(parsed.setupDate),
+    enabledIdes: asStringArray(parsed.enabledIdes),
+    workspaces: Array.isArray(parsed.workspaces) ? parsed.workspaces : [],
+    defaultWorkspaceId: asNullableString(parsed.defaultWorkspaceId) ?? asNullableString(parsed.activeWorkspaceId),
+    machineNickname: asNullableString(parsed.machineNickname),
+    machineId: asOptionalString(parsed.machineId),
+    machineSecret: parsed.machineSecret === null ? null : asOptionalString(parsed.machineSecret),
+    registeredMachineId: asOptionalString(parsed.registeredMachineId),
+    providerSettings: isPlainObject(parsed.providerSettings) ? parsed.providerSettings : {},
+    machineProviders: normalizeMachineProviders(parsed.machineProviders),
+    ideSettings: isPlainObject(parsed.ideSettings) ? parsed.ideSettings : {},
+    providerSourceMode: resolveProviderSourceMode(parsed.providerSourceMode, parsed.disableUpstream),
+    providerDir: asOptionalString(parsed.providerDir),
+    updateChannel: parsed.updateChannel === "preview" ? "preview" : "stable",
+    terminalSizingMode: parsed.terminalSizingMode === "fit" ? "fit" : "measured"
+  };
+}
+function generateMachineId() {
+  return `${MACHINE_ID_PREFIX}${(0, import_crypto.randomUUID)().replace(/-/g, "")}`;
+}
+function isStableMachineId(machineId) {
+  return typeof machineId === "string" && machineId.startsWith(MACHINE_ID_PREFIX);
+}
+function ensureMachineId(config) {
+  if (isStableMachineId(config.machineId)) {
+    return { config, changed: false };
+  }
+  return {
+    config: {
+      ...config,
+      machineId: generateMachineId()
+    },
+    changed: true
+  };
+}
+function getConfigDir() {
+  const override = process.env.ADHDEV_CONFIG_DIR;
+  const dir = override && override.trim() ? override.trim() : (0, import_path2.join)((0, import_os.homedir)(), ".adhdev");
+  if (!(0, import_fs2.existsSync)(dir)) {
+    (0, import_fs2.mkdirSync)(dir, { recursive: true });
+  }
+  return dir;
+}
+function getDaemonDataDir() {
+  const dir = (0, import_path2.join)(getConfigDir(), "daemon");
+  if (!(0, import_fs2.existsSync)(dir)) {
+    (0, import_fs2.mkdirSync)(dir, { recursive: true });
+  }
+  return dir;
+}
+function getConfigPath() {
+  return (0, import_path2.join)(getConfigDir(), "config.json");
+}
+function migrateStateToStateFile(raw) {
+  const statePath = (0, import_path2.join)(getConfigDir(), "state.json");
+  if ((0, import_fs2.existsSync)(statePath)) return;
+  const recentActivity = Array.isArray(raw.recentActivity) ? raw.recentActivity : [];
+  const savedProviderSessions = Array.isArray(raw.savedProviderSessions) ? raw.savedProviderSessions : [];
+  const legacySessionReads = isPlainObject(raw.recentSessionReads) ? raw.recentSessionReads : {};
+  const sessionReads = isPlainObject(raw.sessionReads) ? raw.sessionReads : {};
+  const sessionReadMarkers = isPlainObject(raw.sessionReadMarkers) ? raw.sessionReadMarkers : {};
+  const hasData = recentActivity.length > 0 || savedProviderSessions.length > 0 || Object.keys(sessionReads).length > 0 || Object.keys(legacySessionReads).length > 0 || Object.keys(sessionReadMarkers).length > 0;
+  if (!hasData) return;
+  const mergedReads = Object.fromEntries(
+    Object.entries({ ...legacySessionReads, ...sessionReads }).filter(([, v]) => typeof v === "number" && Number.isFinite(v))
+  );
+  const cleanedMarkers = Object.fromEntries(
+    Object.entries(sessionReadMarkers).filter(([, v]) => typeof v === "string")
+  );
+  const state = {
+    recentActivity,
+    savedProviderSessions,
+    sessionReads: mergedReads,
+    sessionReadMarkers: cleanedMarkers
+  };
+  (0, import_fs2.writeFileSync)(statePath, JSON.stringify(state, null, 2), { encoding: "utf-8", mode: 384 });
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (!(0, import_fs2.existsSync)(configPath)) {
+    const initialized = ensureMachineId({ ...DEFAULT_CONFIG });
+    try {
+      saveConfig(initialized.config);
+    } catch {
+    }
+    return initialized.config;
+  }
+  try {
+    const raw = (0, import_fs2.readFileSync)(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    migrateStateToStateFile(parsed);
+    const normalizedInput = normalizeConfig(parsed);
+    const ensured = ensureMachineId(normalizedInput);
+    const normalized = ensured.config;
+    if (ensured.changed || JSON.stringify(parsed) !== JSON.stringify(normalized)) {
+      try {
+        saveConfig(normalized);
+      } catch {
+      }
+    }
+    return normalized;
+  } catch {
+    const initialized = ensureMachineId({ ...DEFAULT_CONFIG });
+    return initialized.config;
+  }
+}
+function saveConfig(config) {
+  const configPath = getConfigPath();
+  const dir = getConfigDir();
+  const normalized = normalizeConfig(config);
+  if (!(0, import_fs2.existsSync)(dir)) {
+    (0, import_fs2.mkdirSync)(dir, { recursive: true, mode: 448 });
+  }
+  (0, import_fs2.writeFileSync)(configPath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
+  try {
+    (0, import_fs2.chmodSync)(configPath, 384);
+  } catch {
+  }
+}
+function updateConfig(updates) {
+  const config = loadConfig();
+  const updated = { ...config, ...updates };
+  saveConfig(updated);
+  return updated;
+}
+function markSetupComplete(ideId, extensions) {
+  const ideIds = Array.isArray(ideId) ? ideId : [ideId];
+  return updateConfig({
+    selectedIde: ideIds[0],
+    configuredIdes: ideIds,
+    installedExtensions: extensions,
+    setupCompleted: true,
+    setupDate: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function isSetupComplete() {
+  const config = loadConfig();
+  return config.setupCompleted;
+}
+function resetConfig() {
+  saveConfig({ ...DEFAULT_CONFIG });
+}
+var import_os, import_path2, import_fs2, import_crypto, DEFAULT_CONFIG, MACHINE_ID_PREFIX;
+var init_config = __esm({
+  "src/config/config.ts"() {
+    "use strict";
+    import_os = require("os");
+    import_path2 = require("path");
+    import_fs2 = require("fs");
+    import_crypto = require("crypto");
+    DEFAULT_CONFIG = {
+      serverUrl: "https://api.adhf.dev",
+      allowServerApiProxy: false,
+      selectedIde: null,
+      configuredIdes: [],
+      installedExtensions: [],
+      userEmail: null,
+      userName: null,
+      setupCompleted: false,
+      setupDate: null,
+      enabledIdes: [],
+      workspaces: [],
+      defaultWorkspaceId: null,
+      machineNickname: null,
+      machineId: void 0,
+      machineSecret: null,
+      registeredMachineId: void 0,
+      providerSettings: {},
+      machineProviders: {},
+      ideSettings: {},
+      providerSourceMode: "normal",
+      updateChannel: "stable",
+      terminalSizingMode: "measured"
+    };
+    MACHINE_ID_PREFIX = "mach_";
+  }
+});
+
 // src/git/git-worktree.ts
 var git_worktree_exports = {};
 __export(git_worktree_exports, {
@@ -1812,255 +2061,6 @@ var init_git_worktree = __esm({
   }
 });
 
-// src/config/config.ts
-var config_exports = {};
-__export(config_exports, {
-  generateMachineId: () => generateMachineId,
-  getConfigDir: () => getConfigDir,
-  getDaemonDataDir: () => getDaemonDataDir,
-  isSetupComplete: () => isSetupComplete,
-  isStableMachineId: () => isStableMachineId,
-  loadConfig: () => loadConfig,
-  markSetupComplete: () => markSetupComplete,
-  resetConfig: () => resetConfig,
-  resolveProviderSourceMode: () => resolveProviderSourceMode,
-  saveConfig: () => saveConfig,
-  updateConfig: () => updateConfig
-});
-function resolveProviderSourceMode(providerSourceMode, legacyDisableUpstream) {
-  if (providerSourceMode === "normal" || providerSourceMode === "no-upstream") {
-    return providerSourceMode;
-  }
-  return legacyDisableUpstream === true ? "no-upstream" : "normal";
-}
-function isPlainObject(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function asStringArray(value) {
-  if (!Array.isArray(value)) return [];
-  return value.filter((item) => typeof item === "string");
-}
-function asNullableString(value) {
-  return typeof value === "string" ? value : null;
-}
-function asOptionalString(value) {
-  return typeof value === "string" && value.trim() ? value : void 0;
-}
-function asBoolean(value, fallback) {
-  return typeof value === "boolean" ? value : fallback;
-}
-function normalizeMachineProviders(value) {
-  if (!isPlainObject(value)) return {};
-  const result = {};
-  for (const [providerType, raw] of Object.entries(value)) {
-    if (!isPlainObject(raw)) continue;
-    const entry = {};
-    if (raw.enabled === true) entry.enabled = true;
-    if (typeof raw.executable === "string" && raw.executable.trim()) {
-      entry.executable = raw.executable.trim();
-    }
-    if (Array.isArray(raw.args)) {
-      entry.args = raw.args.filter((arg) => typeof arg === "string");
-    }
-    if (isPlainObject(raw.lastDetection)) {
-      entry.lastDetection = raw.lastDetection;
-    }
-    if (isPlainObject(raw.lastVerification)) {
-      entry.lastVerification = raw.lastVerification;
-    }
-    result[providerType] = entry;
-  }
-  return result;
-}
-function normalizeConfig(raw) {
-  const parsed = isPlainObject(raw) ? raw : {};
-  return {
-    serverUrl: typeof parsed.serverUrl === "string" && parsed.serverUrl.trim() ? parsed.serverUrl : DEFAULT_CONFIG.serverUrl,
-    allowServerApiProxy: asBoolean(parsed.allowServerApiProxy, DEFAULT_CONFIG.allowServerApiProxy ?? false),
-    selectedIde: asNullableString(parsed.selectedIde),
-    configuredIdes: asStringArray(parsed.configuredIdes),
-    installedExtensions: asStringArray(parsed.installedExtensions),
-    userEmail: asNullableString(parsed.userEmail),
-    userName: asNullableString(parsed.userName),
-    setupCompleted: asBoolean(parsed.setupCompleted, DEFAULT_CONFIG.setupCompleted),
-    setupDate: asNullableString(parsed.setupDate),
-    enabledIdes: asStringArray(parsed.enabledIdes),
-    workspaces: Array.isArray(parsed.workspaces) ? parsed.workspaces : [],
-    defaultWorkspaceId: asNullableString(parsed.defaultWorkspaceId) ?? asNullableString(parsed.activeWorkspaceId),
-    machineNickname: asNullableString(parsed.machineNickname),
-    machineId: asOptionalString(parsed.machineId),
-    machineSecret: parsed.machineSecret === null ? null : asOptionalString(parsed.machineSecret),
-    registeredMachineId: asOptionalString(parsed.registeredMachineId),
-    providerSettings: isPlainObject(parsed.providerSettings) ? parsed.providerSettings : {},
-    machineProviders: normalizeMachineProviders(parsed.machineProviders),
-    ideSettings: isPlainObject(parsed.ideSettings) ? parsed.ideSettings : {},
-    providerSourceMode: resolveProviderSourceMode(parsed.providerSourceMode, parsed.disableUpstream),
-    providerDir: asOptionalString(parsed.providerDir),
-    updateChannel: parsed.updateChannel === "preview" ? "preview" : "stable",
-    terminalSizingMode: parsed.terminalSizingMode === "fit" ? "fit" : "measured"
-  };
-}
-function generateMachineId() {
-  return `${MACHINE_ID_PREFIX}${(0, import_crypto.randomUUID)().replace(/-/g, "")}`;
-}
-function isStableMachineId(machineId) {
-  return typeof machineId === "string" && machineId.startsWith(MACHINE_ID_PREFIX);
-}
-function ensureMachineId(config) {
-  if (isStableMachineId(config.machineId)) {
-    return { config, changed: false };
-  }
-  return {
-    config: {
-      ...config,
-      machineId: generateMachineId()
-    },
-    changed: true
-  };
-}
-function getConfigDir() {
-  const override = process.env.ADHDEV_CONFIG_DIR;
-  const dir = override && override.trim() ? override.trim() : (0, import_path2.join)((0, import_os.homedir)(), ".adhdev");
-  if (!(0, import_fs2.existsSync)(dir)) {
-    (0, import_fs2.mkdirSync)(dir, { recursive: true });
-  }
-  return dir;
-}
-function getDaemonDataDir() {
-  const dir = (0, import_path2.join)(getConfigDir(), "daemon");
-  if (!(0, import_fs2.existsSync)(dir)) {
-    (0, import_fs2.mkdirSync)(dir, { recursive: true });
-  }
-  return dir;
-}
-function getConfigPath() {
-  return (0, import_path2.join)(getConfigDir(), "config.json");
-}
-function migrateStateToStateFile(raw) {
-  const statePath = (0, import_path2.join)(getConfigDir(), "state.json");
-  if ((0, import_fs2.existsSync)(statePath)) return;
-  const recentActivity = Array.isArray(raw.recentActivity) ? raw.recentActivity : [];
-  const savedProviderSessions = Array.isArray(raw.savedProviderSessions) ? raw.savedProviderSessions : [];
-  const legacySessionReads = isPlainObject(raw.recentSessionReads) ? raw.recentSessionReads : {};
-  const sessionReads = isPlainObject(raw.sessionReads) ? raw.sessionReads : {};
-  const sessionReadMarkers = isPlainObject(raw.sessionReadMarkers) ? raw.sessionReadMarkers : {};
-  const hasData = recentActivity.length > 0 || savedProviderSessions.length > 0 || Object.keys(sessionReads).length > 0 || Object.keys(legacySessionReads).length > 0 || Object.keys(sessionReadMarkers).length > 0;
-  if (!hasData) return;
-  const mergedReads = Object.fromEntries(
-    Object.entries({ ...legacySessionReads, ...sessionReads }).filter(([, v]) => typeof v === "number" && Number.isFinite(v))
-  );
-  const cleanedMarkers = Object.fromEntries(
-    Object.entries(sessionReadMarkers).filter(([, v]) => typeof v === "string")
-  );
-  const state = {
-    recentActivity,
-    savedProviderSessions,
-    sessionReads: mergedReads,
-    sessionReadMarkers: cleanedMarkers
-  };
-  (0, import_fs2.writeFileSync)(statePath, JSON.stringify(state, null, 2), { encoding: "utf-8", mode: 384 });
-}
-function loadConfig() {
-  const configPath = getConfigPath();
-  if (!(0, import_fs2.existsSync)(configPath)) {
-    const initialized = ensureMachineId({ ...DEFAULT_CONFIG });
-    try {
-      saveConfig(initialized.config);
-    } catch {
-    }
-    return initialized.config;
-  }
-  try {
-    const raw = (0, import_fs2.readFileSync)(configPath, "utf-8");
-    const parsed = JSON.parse(raw);
-    migrateStateToStateFile(parsed);
-    const normalizedInput = normalizeConfig(parsed);
-    const ensured = ensureMachineId(normalizedInput);
-    const normalized = ensured.config;
-    if (ensured.changed || JSON.stringify(parsed) !== JSON.stringify(normalized)) {
-      try {
-        saveConfig(normalized);
-      } catch {
-      }
-    }
-    return normalized;
-  } catch {
-    const initialized = ensureMachineId({ ...DEFAULT_CONFIG });
-    return initialized.config;
-  }
-}
-function saveConfig(config) {
-  const configPath = getConfigPath();
-  const dir = getConfigDir();
-  const normalized = normalizeConfig(config);
-  if (!(0, import_fs2.existsSync)(dir)) {
-    (0, import_fs2.mkdirSync)(dir, { recursive: true, mode: 448 });
-  }
-  (0, import_fs2.writeFileSync)(configPath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
-  try {
-    (0, import_fs2.chmodSync)(configPath, 384);
-  } catch {
-  }
-}
-function updateConfig(updates) {
-  const config = loadConfig();
-  const updated = { ...config, ...updates };
-  saveConfig(updated);
-  return updated;
-}
-function markSetupComplete(ideId, extensions) {
-  const ideIds = Array.isArray(ideId) ? ideId : [ideId];
-  return updateConfig({
-    selectedIde: ideIds[0],
-    configuredIdes: ideIds,
-    installedExtensions: extensions,
-    setupCompleted: true,
-    setupDate: (/* @__PURE__ */ new Date()).toISOString()
-  });
-}
-function isSetupComplete() {
-  const config = loadConfig();
-  return config.setupCompleted;
-}
-function resetConfig() {
-  saveConfig({ ...DEFAULT_CONFIG });
-}
-var import_os, import_path2, import_fs2, import_crypto, DEFAULT_CONFIG, MACHINE_ID_PREFIX;
-var init_config = __esm({
-  "src/config/config.ts"() {
-    "use strict";
-    import_os = require("os");
-    import_path2 = require("path");
-    import_fs2 = require("fs");
-    import_crypto = require("crypto");
-    DEFAULT_CONFIG = {
-      serverUrl: "https://api.adhf.dev",
-      allowServerApiProxy: false,
-      selectedIde: null,
-      configuredIdes: [],
-      installedExtensions: [],
-      userEmail: null,
-      userName: null,
-      setupCompleted: false,
-      setupDate: null,
-      enabledIdes: [],
-      workspaces: [],
-      defaultWorkspaceId: null,
-      machineNickname: null,
-      machineId: void 0,
-      machineSecret: null,
-      registeredMachineId: void 0,
-      providerSettings: {},
-      machineProviders: {},
-      ideSettings: {},
-      providerSourceMode: "normal",
-      updateChannel: "stable",
-      terminalSizingMode: "measured"
-    };
-    MACHINE_ID_PREFIX = "mach_";
-  }
-});
-
 // src/config/workspaces.ts
 function expandPath(p) {
   const t = (p || "").trim();
@@ -2557,12 +2557,12 @@ function readGitSubmodules(value, parentRepoRoot) {
   if (!Array.isArray(value)) return void 0;
   const submodules = value.map((entry) => {
     const submodule = readRecord(entry);
-    const path43 = readString2(submodule.path);
+    const path44 = readString2(submodule.path);
     const commit = readString2(submodule.commit);
-    const repoPath = readString2(submodule.repoPath, submodule.repo_root) ?? joinRepoPath(parentRepoRoot, path43);
-    if (!path43 || !commit) return null;
+    const repoPath = readString2(submodule.repoPath, submodule.repo_root) ?? joinRepoPath(parentRepoRoot, path44);
+    if (!path44 || !commit) return null;
     const result = {
-      path: path43,
+      path: path44,
       commit,
       dirty: readBoolean(submodule.dirty) ?? false,
       outOfSync: readBoolean(submodule.outOfSync, submodule.out_of_sync) ?? false,
@@ -2887,10 +2887,10 @@ function getMeshConfigPath() {
   return (0, import_path3.join)(getConfigDir(), "meshes.json");
 }
 function loadMeshConfig() {
-  const path43 = getMeshConfigPath();
-  if (!(0, import_fs3.existsSync)(path43)) return { meshes: [] };
+  const path44 = getMeshConfigPath();
+  if (!(0, import_fs3.existsSync)(path44)) return { meshes: [] };
   try {
-    const raw = JSON.parse((0, import_fs3.readFileSync)(path43, "utf-8"));
+    const raw = JSON.parse((0, import_fs3.readFileSync)(path44, "utf-8"));
     if (!raw || !Array.isArray(raw.meshes)) return { meshes: [] };
     const config = raw;
     const migrated = migrateLoadedMeshConfig(config);
@@ -2939,16 +2939,16 @@ function normalizeCapabilityTags(value) {
   return tags.length ? tags : void 0;
 }
 function saveMeshConfig(config) {
-  const path43 = getMeshConfigPath();
-  (0, import_fs3.writeFileSync)(path43, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
+  const path44 = getMeshConfigPath();
+  (0, import_fs3.writeFileSync)(path44, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
 }
 function normalizeRepoIdentity(remoteUrl) {
   let identity = remoteUrl.trim();
   if (identity.startsWith("http://") || identity.startsWith("https://")) {
     try {
       const url = new URL(identity);
-      const path43 = url.pathname.replace(/^\//, "").replace(/\.git$/, "");
-      return `${url.hostname}/${path43}`;
+      const path44 = url.pathname.replace(/^\//, "").replace(/\.git$/, "");
+      return `${url.hostname}/${path44}`;
     } catch {
     }
   }
@@ -3201,12 +3201,23 @@ function addNode(meshId, opts) {
   if (mesh.nodes.some((n) => n.workspace === opts.workspace)) {
     throw new Error("This workspace is already in the mesh");
   }
+  const machineNickname = (() => {
+    const explicit = typeof opts.machineNickname === "string" ? opts.machineNickname.trim() : "";
+    if (explicit) return explicit;
+    try {
+      const local = loadConfig().machineNickname;
+      return typeof local === "string" && local.trim() ? local.trim() : void 0;
+    } catch {
+      return void 0;
+    }
+  })();
   const node = {
     id: `node_${(0, import_crypto3.randomUUID)().replace(/-/g, "")}`,
     workspace: opts.workspace.trim(),
     repoRoot: opts.repoRoot,
     daemonId: opts.daemonId,
     machineId: opts.machineId,
+    ...machineNickname ? { machineNickname } : {},
     capabilities: normalizeCapabilityTags(opts.capabilities),
     userOverrides: opts.userOverrides || {},
     policy: opts.policy || {},
@@ -3241,6 +3252,7 @@ function updateNode(meshId, nodeId, opts) {
   if (opts.userOverrides) node.userOverrides = { ...node.userOverrides, ...opts.userOverrides };
   if (opts.reportedPlatform && opts.reportedPlatform.trim()) node.reportedPlatform = opts.reportedPlatform.trim();
   if (opts.reportedArch && opts.reportedArch.trim()) node.reportedArch = opts.reportedArch.trim();
+  if (opts.reportedMachineNickname && opts.reportedMachineNickname.trim()) node.machineNickname = opts.reportedMachineNickname.trim();
   if (opts.policy) node.policy = { ...node.policy, ...opts.policy };
   if (opts.worktreeBootstrap) node.worktreeBootstrap = opts.worktreeBootstrap;
   if (Object.prototype.hasOwnProperty.call(opts, "systemPrompt")) {
@@ -4175,10 +4187,10 @@ function rotateArchiveFile(meshId, archivePath) {
   }
 }
 function readArchivedCounts(meshId) {
-  const path43 = getArchivedCountsPath(meshId);
-  if (!(0, import_fs4.existsSync)(path43)) return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
+  const path44 = getArchivedCountsPath(meshId);
+  if (!(0, import_fs4.existsSync)(path44)) return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
   try {
-    return JSON.parse((0, import_fs4.readFileSync)(path43, "utf-8"));
+    return JSON.parse((0, import_fs4.readFileSync)(path44, "utf-8"));
   } catch {
     return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
   }
@@ -5388,11 +5400,11 @@ function readNodeReporter(node, key2) {
 function buildMeshNodeCapabilityTags(node, providerType) {
   const provider = typeof providerType === "string" && providerType.trim() ? providerType.trim() : firstProviderPriority(node?.policy);
   const worktreeBranch = typeof node?.worktreeBranch === "string" && node.worktreeBranch.trim() ? node.worktreeBranch.trim() : null;
-  const os30 = readNodeOverride(node, "platform") ?? readNodeReporter(node, "platform") ?? process.platform;
+  const os31 = readNodeOverride(node, "platform") ?? readNodeReporter(node, "platform") ?? process.platform;
   const arch2 = readNodeOverride(node, "arch") ?? readNodeReporter(node, "arch") ?? process.arch;
   return normalizeMeshCapabilityTags([
     ...Array.isArray(node?.capabilities) ? node.capabilities : [],
-    `os=${os30}`,
+    `os=${os31}`,
     `arch=${arch2}`,
     ...provider ? [`provider=${provider}`] : [],
     // Worktree nodes automatically expose a "worktree=<branch>" tag so that
@@ -6286,10 +6298,10 @@ var init_mesh_runtime_store = __esm({
         this.migratedMeshIds.add(meshId);
         const count = this.db.prepare("SELECT COUNT(*) AS count FROM mesh_queue WHERE mesh_id = ?").get(meshId);
         if (count.count > 0) return;
-        const path43 = legacyQueuePath(meshId);
-        if (!(0, import_fs5.existsSync)(path43)) return;
+        const path44 = legacyQueuePath(meshId);
+        if (!(0, import_fs5.existsSync)(path44)) return;
         try {
-          const entries = JSON.parse((0, import_fs5.readFileSync)(path43, "utf-8"));
+          const entries = JSON.parse((0, import_fs5.readFileSync)(path44, "utf-8"));
           if (!Array.isArray(entries)) return;
           const insert = this.db.prepare(`
                 INSERT OR REPLACE INTO mesh_queue (
@@ -8113,8 +8125,8 @@ function resolveMeshCoordinatorSetup(options) {
   }
   const serverName = mcpConfig.serverName?.trim() || DEFAULT_SERVER_NAME;
   if (mcpConfig.mode === "auto_import") {
-    const path43 = mcpConfig.path?.trim();
-    if (!path43) {
+    const path44 = mcpConfig.path?.trim();
+    if (!path44) {
       return { kind: "unsupported", reason: "Provider auto-import MCP config is missing a config path" };
     }
     const mcpServer = resolveAdhdevMcpServerLaunch({
@@ -8134,7 +8146,7 @@ function resolveMeshCoordinatorSetup(options) {
     return {
       kind: "auto_import",
       serverName,
-      configPath: resolveMcpConfigPath(path43, workspace),
+      configPath: resolveMcpConfigPath(path44, workspace),
       configFormat: mcpConfig.format,
       mcpServer
     };
@@ -8335,8 +8347,8 @@ function stripCoordinatorWrapperFile(filePath) {
     const remaining = (existing.slice(0, openIdx) + existing.slice(closeIdx + CLOSE.length)).replace(/^\s*\n+/, "").replace(/\n+\s*$/, "");
     if (!remaining.trim()) {
       try {
-        const fs38 = require("fs");
-        fs38.unlinkSync(filePath);
+        const fs39 = require("fs");
+        fs39.unlinkSync(filePath);
       } catch {
       }
     } else {
@@ -8438,10 +8450,10 @@ function getRegistryPath() {
   return (0, import_path6.join)(getDaemonDataDir(), "mesh-coordinators.json");
 }
 function loadMeshCoordinatorRegistry() {
-  const path43 = getRegistryPath();
-  if (!(0, import_fs6.existsSync)(path43)) return;
+  const path44 = getRegistryPath();
+  if (!(0, import_fs6.existsSync)(path44)) return;
   try {
-    const raw = JSON.parse((0, import_fs6.readFileSync)(path43, "utf-8"));
+    const raw = JSON.parse((0, import_fs6.readFileSync)(path44, "utf-8"));
     if (!Array.isArray(raw)) return;
     _registry.clear();
     for (const entry of raw) {
@@ -8612,8 +8624,8 @@ function validateMeshRefineConfig(config, source = "inline") {
   if (rejectedCommands.length) errors.push("one or more validation commands are invalid");
   return { valid: errors.length === 0, errors, bootstrapCommands, commands, rejectedCommands, bootstrapMode, deprecationWarnings };
 }
-function parseConfigText2(path43, text) {
-  if (/\.json$/i.test(path43)) return JSON.parse(text);
+function parseConfigText2(path44, text) {
+  if (/\.json$/i.test(path44)) return JSON.parse(text);
   return yaml2.load(text);
 }
 function loadMeshRefineConfig(mesh, workspace) {
@@ -8940,8 +8952,8 @@ function isCleanIgnoringSubmoduleGitlinks(porcelain, submodulePaths) {
   const lines = porcelain.split(/\r?\n/).filter((line) => line.length > 0);
   for (const line of lines) {
     const status = line.slice(0, 2);
-    const path43 = line.slice(3).trim().replace(/\\/g, "/").replace(/\/+$/, "");
-    const isGitlinkPointerMove = (status === " M" || status === "M ") && submodulePaths.has(path43);
+    const path44 = line.slice(3).trim().replace(/\\/g, "/").replace(/\/+$/, "");
+    const isGitlinkPointerMove = (status === " M" || status === "M ") && submodulePaths.has(path44);
     if (!isGitlinkPointerMove) return false;
   }
   return true;
@@ -8972,8 +8984,8 @@ function isWorktreeBootstrapStaleRunning(node, nowMs = Date.now()) {
     return false;
   }
 }
-function parseConfigText3(path43, text) {
-  if (/\.json$/i.test(path43)) return JSON.parse(text);
+function parseConfigText3(path44, text) {
+  if (/\.json$/i.test(path44)) return JSON.parse(text);
   return yaml3.load(text);
 }
 function truncateOutput(value) {
@@ -9118,16 +9130,16 @@ async function runMeshWorktreeBootstrap(mesh, workspace) {
     const startedAt = Date.now();
     state.lastCommand = command.displayCommand;
     const resolvedCommand = resolveWin32Executable(command.command);
-    const spawn4 = buildWin32ExecFileSpawn(resolvedCommand, command.args);
+    const spawn5 = buildWin32ExecFileSpawn(resolvedCommand, command.args);
     try {
-      const result = await execFileAsync4(spawn4.file, spawn4.args, {
+      const result = await execFileAsync4(spawn5.file, spawn5.args, {
         cwd,
         encoding: "utf8",
         timeout: command.timeoutMs || DEFAULT_TIMEOUT_MS2,
         maxBuffer: command.outputLimitBytes || DEFAULT_OUTPUT_LIMIT_BYTES,
         env: { ...process.env, CI: process.env.CI || "1", ...command.env || {} },
         windowsHide: true,
-        ...spawn4.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}
+        ...spawn5.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}
       });
       state.commandsRun?.push({
         command: command.command,
@@ -9250,8 +9262,8 @@ __export(mesh_json_config_exports, {
 function isRecord3(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
-function parseConfigText4(path43, text) {
-  if (/\.json$/i.test(path43)) return JSON.parse(text);
+function parseConfigText4(path44, text) {
+  if (/\.json$/i.test(path44)) return JSON.parse(text);
   return yaml4.load(text);
 }
 function normalizeOperatingNote(value) {
@@ -11057,10 +11069,10 @@ function readPendingMeshCoordinatorEventsFromDisk(meshId, coordinatorDaemonId) {
   const primaryDaemonId = daemonIds[0];
   const paths = primaryDaemonId ? [getPendingEventsPath(meshId, primaryDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
   const events = [];
-  for (const path43 of paths) {
-    if (!(0, import_fs11.existsSync)(path43)) continue;
+  for (const path44 of paths) {
+    if (!(0, import_fs11.existsSync)(path44)) continue;
     try {
-      const raw = (0, import_fs11.readFileSync)(path43, "utf-8");
+      const raw = (0, import_fs11.readFileSync)(path44, "utf-8");
       const parsed = raw.split("\n").filter(Boolean).flatMap((line) => {
         try {
           return [JSON.parse(line)];
@@ -11068,7 +11080,7 @@ function readPendingMeshCoordinatorEventsFromDisk(meshId, coordinatorDaemonId) {
           return [];
         }
       });
-      const filtered = primaryDaemonId && path43 === getPendingEventsPath(meshId) ? parsed.filter((e) => !e.targetCoordinatorDaemonId || daemonIds.includes(e.targetCoordinatorDaemonId)) : parsed;
+      const filtered = primaryDaemonId && path44 === getPendingEventsPath(meshId) ? parsed.filter((e) => !e.targetCoordinatorDaemonId || daemonIds.includes(e.targetCoordinatorDaemonId)) : parsed;
       events.push(...filtered);
     } catch {
     }
@@ -11133,11 +11145,11 @@ function reconcilePendingMeshCoordinatorEvents(meshId, events) {
   const reconciled = terminalJobIds.size === 0 ? events : events.filter((event) => !(event.event === "refine:accepted" && terminalJobIds.has(readRefineJobId2(event))));
   return backfilled.length === 0 ? reconciled : [...reconciled, ...backfilled];
 }
-function trimPendingEventsIfNeeded(path43) {
+function trimPendingEventsIfNeeded(path44) {
   try {
-    if (!(0, import_fs11.existsSync)(path43)) return;
-    if ((0, import_fs11.statSync)(path43).size <= MAX_PENDING_EVENTS_BYTES) return;
-    const lines = (0, import_fs11.readFileSync)(path43, "utf-8").split("\n").filter(Boolean);
+    if (!(0, import_fs11.existsSync)(path44)) return;
+    if ((0, import_fs11.statSync)(path44).size <= MAX_PENDING_EVENTS_BYTES) return;
+    const lines = (0, import_fs11.readFileSync)(path44, "utf-8").split("\n").filter(Boolean);
     if (lines.length <= MAX_PENDING_EVENTS_KEEP) return;
     const dropped = lines.slice(0, lines.length - MAX_PENDING_EVENTS_KEEP);
     for (const line of dropped) {
@@ -11170,7 +11182,7 @@ function trimPendingEventsIfNeeded(path43) {
         LOG.warn("MeshEvents", `Failed to ledger-record trim-dropped ${event.event} for mesh ${event.meshId}: ${e?.message || e}`);
       }
     }
-    (0, import_fs11.writeFileSync)(path43, lines.slice(-MAX_PENDING_EVENTS_KEEP).join("\n") + "\n", "utf-8");
+    (0, import_fs11.writeFileSync)(path44, lines.slice(-MAX_PENDING_EVENTS_KEEP).join("\n") + "\n", "utf-8");
   } catch {
   }
 }
@@ -11200,9 +11212,9 @@ function queuePendingMeshCoordinatorEvent(event) {
     } catch {
     }
     try {
-      const path43 = getPendingEventsPath(event.meshId, event.targetCoordinatorDaemonId);
-      trimPendingEventsIfNeeded(path43);
-      (0, import_fs11.appendFileSync)(path43, JSON.stringify(event) + "\n", "utf-8");
+      const path44 = getPendingEventsPath(event.meshId, event.targetCoordinatorDaemonId);
+      trimPendingEventsIfNeeded(path44);
+      (0, import_fs11.appendFileSync)(path44, JSON.stringify(event) + "\n", "utf-8");
     } catch (e) {
       if (!sqliteOk) throw e;
       LOG.warn("MeshEvents", `JSONL append failed for mesh ${event.meshId}; SQLite holds the event: ${e?.message || e}`);
@@ -11213,10 +11225,10 @@ function queuePendingMeshCoordinatorEvent(event) {
     return false;
   }
 }
-function atomicDrainFile(path43) {
-  const tmpPath = `${path43}.draining`;
+function atomicDrainFile(path44) {
+  const tmpPath = `${path44}.draining`;
   try {
-    (0, import_fs11.renameSync)(path43, tmpPath);
+    (0, import_fs11.renameSync)(path44, tmpPath);
   } catch {
     return null;
   }
@@ -11235,10 +11247,10 @@ function atomicDrainFile(path43) {
     return null;
   }
 }
-function selectiveDrainFile(path43, predicate) {
-  const tmpPath = `${path43}.draining`;
+function selectiveDrainFile(path44, predicate) {
+  const tmpPath = `${path44}.draining`;
   try {
-    (0, import_fs11.renameSync)(path43, tmpPath);
+    (0, import_fs11.renameSync)(path44, tmpPath);
   } catch {
     return [];
   }
@@ -11270,12 +11282,12 @@ function selectiveDrainFile(path43, predicate) {
   }
   try {
     if (keptLines.length > 0) {
-      (0, import_fs11.writeFileSync)(path43, keptLines.join("\n") + "\n", "utf-8");
+      (0, import_fs11.writeFileSync)(path44, keptLines.join("\n") + "\n", "utf-8");
     }
     (0, import_fs11.unlinkSync)(tmpPath);
   } catch {
     try {
-      if ((0, import_fs11.existsSync)(tmpPath) && !(0, import_fs11.existsSync)(path43)) (0, import_fs11.renameSync)(tmpPath, path43);
+      if ((0, import_fs11.existsSync)(tmpPath) && !(0, import_fs11.existsSync)(path44)) (0, import_fs11.renameSync)(tmpPath, path44);
     } catch {
     }
     return [];
@@ -11310,16 +11322,16 @@ function drainPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId, opts) {
     LOG.warn("MeshEvents", `SQLite pending-event drain failed for mesh ${meshId}; JSONL fallback only: ${e?.message || e}`);
   }
   const paths = primaryDaemonId ? [getPendingEventsPath(meshId, primaryDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
-  for (const path43 of paths) {
-    const isSharedFile = !!primaryDaemonId && path43 === getPendingEventsPath(meshId);
+  for (const path44 of paths) {
+    const isSharedFile = !!primaryDaemonId && path44 === getPendingEventsPath(meshId);
     const targets = (e) => !isSharedFile || !e.targetCoordinatorDaemonId || daemonIds.includes(e.targetCoordinatorDaemonId);
     if (onlyEvents) {
-      for (const event of selectiveDrainFile(path43, (e) => targets(e) && matchesFilter(e.event))) {
+      for (const event of selectiveDrainFile(path44, (e) => targets(e) && matchesFilter(e.event))) {
         pushUnique(event);
       }
       continue;
     }
-    const content = atomicDrainFile(path43);
+    const content = atomicDrainFile(path44);
     if (!content) continue;
     const parsed = content.split("\n").filter(Boolean).flatMap((line) => {
       try {
@@ -11355,9 +11367,9 @@ function retractPendingDispatchBlockedEvent(meshId, taskId, coordinatorDaemonId)
   const daemonIds = normalizeCoordinatorDaemonIds(coordinatorDaemonId);
   const primaryDaemonId = daemonIds[0];
   const paths = primaryDaemonId ? [getPendingEventsPath(meshId, primaryDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
-  for (const path43 of paths) {
+  for (const path44 of paths) {
     try {
-      removed += selectiveDrainFile(path43, matchesTask).length;
+      removed += selectiveDrainFile(path44, matchesTask).length;
     } catch {
     }
   }
@@ -11398,9 +11410,9 @@ function clearPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
   } catch {
   }
   const paths = coordinatorDaemonId ? [getPendingEventsPath(meshId, coordinatorDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
-  for (const path43 of paths) {
-    if ((0, import_fs11.existsSync)(path43)) try {
-      (0, import_fs11.unlinkSync)(path43);
+  for (const path44 of paths) {
+    if ((0, import_fs11.existsSync)(path44)) try {
+      (0, import_fs11.unlinkSync)(path44);
     } catch {
     }
   }
@@ -11872,9 +11884,9 @@ function findBinary(name) {
     for (const ext of exes) {
       const fullPath = path11.join(p, trimmed + ext);
       try {
-        const fs38 = require("fs");
-        if (fs38.existsSync(fullPath)) {
-          const stat2 = fs38.statSync(fullPath);
+        const fs39 = require("fs");
+        if (fs39.existsSync(fullPath)) {
+          const stat2 = fs39.statSync(fullPath);
           if (stat2.isFile() && (isWin || stat2.mode & 73)) {
             return fullPath;
           }
@@ -11888,12 +11900,12 @@ function findBinary(name) {
 function isScriptBinary(binaryPath) {
   if (!path11.isAbsolute(binaryPath)) return false;
   try {
-    const fs38 = require("fs");
-    const resolved = fs38.realpathSync(binaryPath);
+    const fs39 = require("fs");
+    const resolved = fs39.realpathSync(binaryPath);
     const head = Buffer.alloc(8);
-    const fd = fs38.openSync(resolved, "r");
-    fs38.readSync(fd, head, 0, 8, 0);
-    fs38.closeSync(fd);
+    const fd = fs39.openSync(resolved, "r");
+    fs39.readSync(fd, head, 0, 8, 0);
+    fs39.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;
@@ -11904,12 +11916,12 @@ function isScriptBinary(binaryPath) {
 function looksLikeMachOOrElf(filePath) {
   if (!path11.isAbsolute(filePath)) return false;
   try {
-    const fs38 = require("fs");
-    const resolved = fs38.realpathSync(filePath);
+    const fs39 = require("fs");
+    const resolved = fs39.realpathSync(filePath);
     const buf = Buffer.alloc(8);
-    const fd = fs38.openSync(resolved, "r");
-    fs38.readSync(fd, buf, 0, 8, 0);
-    fs38.closeSync(fd);
+    const fd = fs39.openSync(resolved, "r");
+    fs39.readSync(fd, buf, 0, 8, 0);
+    fs39.closeSync(fd);
     let i = 0;
     if (buf[0] === 239 && buf[1] === 187 && buf[2] === 191) i = 3;
     const b = buf.subarray(i);
@@ -12196,19 +12208,19 @@ async function resolveDetectionPath(command, whichCmd) {
   return null;
 }
 function execAsync(cmd, timeoutMs = 5e3) {
-  return new Promise((resolve24) => {
+  return new Promise((resolve25) => {
     const child = (0, import_child_process2.exec)(cmd, {
       encoding: "utf-8",
       timeout: timeoutMs,
       ...process.platform === "win32" ? { windowsHide: true } : {}
     }, (err, stdout) => {
       if (err || !stdout?.trim()) {
-        resolve24(null);
+        resolve25(null);
       } else {
-        resolve24(stdout.trim());
+        resolve25(stdout.trim());
       }
     });
-    child.on("error", () => resolve24(null));
+    child.on("error", () => resolve25(null));
   });
 }
 async function detectCLIs(providerLoader, options) {
@@ -12334,7 +12346,7 @@ var init_mesh_event_trace = __esm({
 // src/mesh/mesh-warmup-deadline.ts
 function awaitWithWarmupDeadline(work, opts) {
   const pollMs = Math.max(1, Math.min(opts.pollIntervalMs ?? 200, opts.connectTimeoutMs));
-  return new Promise((resolve24, reject) => {
+  return new Promise((resolve25, reject) => {
     let done = false;
     let poll;
     let responseTimer;
@@ -12384,7 +12396,7 @@ function awaitWithWarmupDeadline(work, opts) {
       if (typeof poll.unref === "function") poll.unref();
     }
     work.then(
-      (val) => settle(() => resolve24(val)),
+      (val) => settle(() => resolve25(val)),
       (err) => settle(() => reject(err))
     );
   });
@@ -12487,7 +12499,7 @@ async function waitForLocalSessionReady(components, sessionId) {
   const deadline = Date.now() + LOCAL_LAUNCH_READY_TIMEOUT_MS;
   while (Date.now() < deadline) {
     if (adapter.isReady() || adapter.currentStatus === "idle") return;
-    await new Promise((resolve24) => setTimeout(resolve24, LOCAL_LAUNCH_READY_POLL_MS));
+    await new Promise((resolve25) => setTimeout(resolve25, LOCAL_LAUNCH_READY_POLL_MS));
   }
   LOG.warn("MeshQueue", `Auto-launched session ${sessionId} not interactive after ${LOCAL_LAUNCH_READY_TIMEOUT_MS}ms; dispatching anyway (adapter queue-until-ready will buffer)`);
 }
@@ -18918,7 +18930,7 @@ function getCliValidator() {
   return _cliValidator;
 }
 function formatIssue(err) {
-  const path43 = err.instancePath || "";
+  const path44 = err.instancePath || "";
   const params = err.params;
   let message = err.message || "validation failed";
   let allowed;
@@ -18936,7 +18948,7 @@ function formatIssue(err) {
   } else if (err.keyword === "type") {
     message = `must be ${params.type}`;
   }
-  return { path: path43, keyword: err.keyword, message, ...allowed !== void 0 ? { allowed } : {} };
+  return { path: path44, keyword: err.keyword, message, ...allowed !== void 0 ? { allowed } : {} };
 }
 function validateCliProviderManifest(manifest) {
   const validator = getCliValidator();
@@ -19232,40 +19244,40 @@ function validateFsmSpec(raw) {
   }
   return errs;
 }
-function validateCondition(c, sectionIds, path43) {
+function validateCondition(c, sectionIds, path44) {
   const errs = [];
   const w = c;
   if ("all" in w) {
-    w.all.forEach((x, i) => errs.push(...validateCondition(x, sectionIds, `${path43}.all[${i}]`)));
+    w.all.forEach((x, i) => errs.push(...validateCondition(x, sectionIds, `${path44}.all[${i}]`)));
     return errs;
   }
   if ("any" in w) {
-    w.any.forEach((x, i) => errs.push(...validateCondition(x, sectionIds, `${path43}.any[${i}]`)));
+    w.any.forEach((x, i) => errs.push(...validateCondition(x, sectionIds, `${path44}.any[${i}]`)));
     return errs;
   }
   if ("not" in w) {
-    errs.push(...validateCondition(w.not, sectionIds, `${path43}.not`));
+    errs.push(...validateCondition(w.not, sectionIds, `${path44}.not`));
     return errs;
   }
   if ("matches" in w) {
-    if (w.section && !sectionIds.has(w.section)) errs.push(`${path43}.section "${w.section}" unknown`);
+    if (w.section && !sectionIds.has(w.section)) errs.push(`${path44}.section "${w.section}" unknown`);
     try {
       new RegExp(w.matches, w.flags ?? "i");
     } catch (e) {
-      errs.push(`${path43}.matches invalid regex: ${e.message}`);
+      errs.push(`${path44}.matches invalid regex: ${e.message}`);
     }
     return errs;
   }
   if ("cursor_above" in w && "changed" in w) return errs;
   if ("elapsed_ms" in w) {
-    if (typeof w.elapsed_ms !== "number") errs.push(`${path43}.elapsed_ms must be a number`);
+    if (typeof w.elapsed_ms !== "number") errs.push(`${path44}.elapsed_ms must be a number`);
     return errs;
   }
   if ("stable_ms" in w) {
-    if (typeof w.stable_ms !== "number") errs.push(`${path43}.stable_ms must be a number`);
+    if (typeof w.stable_ms !== "number") errs.push(`${path44}.stable_ms must be a number`);
     return errs;
   }
-  errs.push(`${path43} is not a recognized condition`);
+  errs.push(`${path44} is not a recognized condition`);
   return errs;
 }
 var fs10;
@@ -19760,8 +19772,8 @@ var init_pty_transport = __esm({
         let cwd = options.cwd;
         if (cwd) {
           try {
-            const fs38 = require("fs");
-            const stat2 = fs38.statSync(cwd);
+            const fs39 = require("fs");
+            const stat2 = fs39.statSync(cwd);
             if (!stat2.isDirectory()) cwd = os14.homedir();
           } catch {
             cwd = os14.homedir();
@@ -22309,7 +22321,7 @@ ${lastSnapshot}`;
               `[${this.cliType}] Waiting for interactive prompt: status=${status} stableMs=${stableMs} recentOutputMs=${recentlyOutput} screen=${JSON.stringify(summarizeCliTraceText(screenText, 220)).slice(0, 260)}`
             );
           }
-          await new Promise((resolve24) => setTimeout(resolve24, 50));
+          await new Promise((resolve25) => setTimeout(resolve25, 50));
         }
         const finalScreenText = this.terminalScreen.getText() || "";
         LOG.warn(
@@ -22604,7 +22616,7 @@ ${lastSnapshot}`;
           if (!this.ptyProcess) throw new Error(`${this.cliName} is not running`);
           await this.ptyProcess.write(chunks[i]);
           if (i + 1 < chunks.length) {
-            await new Promise((resolve24) => setTimeout(resolve24, WIN32_PTY_WRITE_CHUNK_GAP_MS));
+            await new Promise((resolve25) => setTimeout(resolve25, WIN32_PTY_WRITE_CHUNK_GAP_MS));
           }
         }
       }
@@ -22772,7 +22784,7 @@ ${lastSnapshot}`;
         this.onStatusChange?.();
       }
       async waitForForceSubmitSettle() {
-        await new Promise((resolve24) => setTimeout(resolve24, FORCE_SUBMIT_SETTLE_MS));
+        await new Promise((resolve25) => setTimeout(resolve25, FORCE_SUBMIT_SETTLE_MS));
       }
       enqueuePendingOutboundMessage(text, reason, meshTaskId) {
         const content = String(text || "");
@@ -22851,7 +22863,7 @@ ${lastSnapshot}`;
           const deadline = Date.now() + 1e4;
           while (this.startupParseGate && Date.now() < deadline) {
             this.resolveStartupState("send_wait");
-            await new Promise((resolve24) => setTimeout(resolve24, 50));
+            await new Promise((resolve25) => setTimeout(resolve25, 50));
           }
         }
         const parsedStatusBeforeSend = !allowInputDuringGeneration ? (() => {
@@ -22944,13 +22956,13 @@ ${lastSnapshot}`;
           isFirstTurn: !this.firstTurnSent
         };
         this.engine.responseSettleIgnoreUntil = Date.now() + submitDelayMs + this.timeouts.outputSettle + 250;
-        await new Promise((resolve24, reject) => {
+        await new Promise((resolve25, reject) => {
           let resolved = false;
           const completion = {
             resolveOnce: () => {
               if (resolved) return;
               resolved = true;
-              resolve24();
+              resolve25();
             },
             rejectOnce: (error) => {
               if (resolved) return;
@@ -23138,17 +23150,17 @@ ${lastSnapshot}`;
         }
       }
       waitForStopped(timeoutMs) {
-        return new Promise((resolve24) => {
+        return new Promise((resolve25) => {
           const startedAt = Date.now();
           const timer = setInterval(() => {
             if (!this.ptyProcess || this.engine.currentStatus === "stopped") {
               clearInterval(timer);
-              resolve24(true);
+              resolve25(true);
               return;
             }
             if (Date.now() - startedAt >= timeoutMs) {
               clearInterval(timer);
-              resolve24(false);
+              resolve25(false);
             }
           }, 100);
         });
@@ -24008,6 +24020,7 @@ __export(index_exports, {
   createGitSnapshotStore: () => createGitSnapshotStore,
   createGitWorkspaceMonitor: () => createGitWorkspaceMonitor,
   createInteractionId: () => createInteractionId,
+  createManagedSessionHost: () => createManagedSessionHost,
   createMesh: () => createMesh,
   createNativeHistoryDispatcher: () => createNativeHistoryDispatcher,
   createSessionDelivery: () => createSessionDelivery,
@@ -24946,6 +24959,7 @@ var path3 = __toESM(require("path"));
 init_git_diff();
 init_git_executor();
 init_git_status();
+init_config();
 var GIT_COMMAND_NAMES = /* @__PURE__ */ new Set([
   "git_status",
   "git_diff_summary",
@@ -25085,7 +25099,21 @@ async function handleGitCommand(command, args, services = defaultGitCommandServi
       if (submoduleIgnorePaths && submoduleIgnorePaths.length > 0) statusParams.submoduleIgnorePaths = submoduleIgnorePaths;
       const status = await runService(() => services.getStatus(statusParams));
       if ("success" in status) return status;
-      return { success: true, status, reporterPlatform: process.platform, reporterArch: process.arch };
+      const reporterMachineNickname = (() => {
+        try {
+          const nick = loadConfig().machineNickname;
+          return typeof nick === "string" && nick.trim() ? nick.trim() : void 0;
+        } catch {
+          return void 0;
+        }
+      })();
+      return {
+        success: true,
+        status,
+        reporterPlatform: process.platform,
+        reporterArch: process.arch,
+        ...reporterMachineNickname ? { reporterMachineNickname } : {}
+      };
     }
     case "git_diff_summary": {
       if (!services.getDiffSummary) return serviceNotImplemented(command);
@@ -25841,17 +25869,17 @@ function checkPathExists(paths) {
   return null;
 }
 async function detectIDEs(providerLoader) {
-  const os30 = (0, import_os2.platform)();
+  const os31 = (0, import_os2.platform)();
   const results = [];
   for (const def of getMergedDefinitions()) {
     const cliPath = findCliCommand(providerLoader?.getIdeCliCommand(def.id, def.cli) || def.cli);
-    const appPath = checkPathExists(providerLoader?.getIdePathCandidates(def.id, def.paths[os30] || []) || []);
+    const appPath = checkPathExists(providerLoader?.getIdePathCandidates(def.id, def.paths[os31] || []) || []);
     let resolvedCli = cliPath;
-    if (!resolvedCli && appPath && os30 === "darwin") {
+    if (!resolvedCli && appPath && os31 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
       if ((0, import_fs15.existsSync)(bundledCli)) resolvedCli = bundledCli;
     }
-    if (!resolvedCli && appPath && os30 === "win32") {
+    if (!resolvedCli && appPath && os31 === "win32") {
       const { dirname: dirname17 } = await import("path");
       const appDir = dirname17(appPath);
       const candidates = [
@@ -25868,7 +25896,7 @@ async function detectIDEs(providerLoader) {
         }
       }
     }
-    const installed = os30 === "darwin" ? !!(resolvedCli || appPath) : !!resolvedCli;
+    const installed = os31 === "darwin" ? !!(resolvedCli || appPath) : !!resolvedCli;
     const version = null;
     results.push({
       id: def.id,
@@ -26127,7 +26155,7 @@ var DaemonCdpManager = class {
   * Returns multiple entries if multiple IDE windows are open on same port
   */
   static listAllTargets(port) {
-    return new Promise((resolve24) => {
+    return new Promise((resolve25) => {
       const req = http.get(`http://127.0.0.1:${port}/json`, (res) => {
         let data = "";
         res.on("data", (chunk) => data += chunk.toString());
@@ -26143,16 +26171,16 @@ var DaemonCdpManager = class {
               (t) => !isNonMain(t.title || "") && t.url?.includes("workbench.html") && !t.url?.includes("agent")
             );
             const fallbackPages = pages.filter((t) => !isNonMain(t.title || ""));
-            resolve24(mainPages.length > 0 ? mainPages : fallbackPages);
+            resolve25(mainPages.length > 0 ? mainPages : fallbackPages);
           } catch {
-            resolve24([]);
+            resolve25([]);
           }
         });
       });
-      req.on("error", () => resolve24([]));
+      req.on("error", () => resolve25([]));
       req.setTimeout(2e3, () => {
         req.destroy();
-        resolve24([]);
+        resolve25([]);
       });
     });
   }
@@ -26192,7 +26220,7 @@ var DaemonCdpManager = class {
     }
   }
   findTargetOnPort(port) {
-    return new Promise((resolve24) => {
+    return new Promise((resolve25) => {
       const req = http.get(`http://127.0.0.1:${port}/json`, (res) => {
         let data = "";
         res.on("data", (chunk) => data += chunk.toString());
@@ -26203,7 +26231,7 @@ var DaemonCdpManager = class {
               (t) => (t.type === "page" || t.type === "browser" || t.type === "Page") && t.webSocketDebuggerUrl
             );
             if (pages.length === 0) {
-              resolve24(targets.find((t) => t.webSocketDebuggerUrl) || null);
+              resolve25(targets.find((t) => t.webSocketDebuggerUrl) || null);
               return;
             }
             const titleFilteredPages = pages.filter((t) => !this.isNonMainTitle(t.title || ""));
@@ -26222,25 +26250,25 @@ var DaemonCdpManager = class {
                 this._targetId = selected.target.id;
               }
               this._pageTitle = selected.target.title || "";
-              resolve24(selected.target);
+              resolve25(selected.target);
               return;
             }
             if (previousTargetId) {
               this.log(`[CDP] Target ${previousTargetId} not found in page list`);
-              resolve24(null);
+              resolve25(null);
               return;
             }
             this._pageTitle = list[0]?.title || "";
-            resolve24(list[0]);
+            resolve25(list[0]);
           } catch {
-            resolve24(null);
+            resolve25(null);
           }
         });
       });
-      req.on("error", () => resolve24(null));
+      req.on("error", () => resolve25(null));
       req.setTimeout(2e3, () => {
         req.destroy();
-        resolve24(null);
+        resolve25(null);
       });
     });
   }
@@ -26251,7 +26279,7 @@ var DaemonCdpManager = class {
     this.extensionProviders = providers;
   }
   connectToTarget(wsUrl) {
-    return new Promise((resolve24) => {
+    return new Promise((resolve25) => {
       this.ws = new import_ws.default(wsUrl);
       this.ws.on("open", async () => {
         this._connected = true;
@@ -26261,17 +26289,17 @@ var DaemonCdpManager = class {
         }
         this.connectBrowserWs().catch(() => {
         });
-        resolve24(true);
+        resolve25(true);
       });
       this.ws.on("message", (data) => {
         try {
           const msg = JSON.parse(data.toString());
           if (msg.id && this.pending.has(msg.id)) {
-            const { resolve: resolve25, reject } = this.pending.get(msg.id);
+            const { resolve: resolve26, reject } = this.pending.get(msg.id);
             this.pending.delete(msg.id);
             this.failureCount = 0;
             if (msg.error) reject(new Error(msg.error.message));
-            else resolve25(msg.result);
+            else resolve26(msg.result);
           } else if (msg.method === "Runtime.executionContextCreated") {
             this.contexts.add(msg.params.context.id);
           } else if (msg.method === "Runtime.executionContextDestroyed") {
@@ -26294,7 +26322,7 @@ var DaemonCdpManager = class {
       this.ws.on("error", (err) => {
         this.log(`[CDP] WebSocket error: ${err.message}`);
         this._connected = false;
-        resolve24(false);
+        resolve25(false);
       });
     });
   }
@@ -26308,7 +26336,7 @@ var DaemonCdpManager = class {
         return;
       }
       this.log(`[CDP] Connecting browser WS for target discovery...`);
-      await new Promise((resolve24, reject) => {
+      await new Promise((resolve25, reject) => {
         this.browserWs = new import_ws.default(browserWsUrl);
         this.browserWs.on("open", async () => {
           this._browserConnected = true;
@@ -26318,16 +26346,16 @@ var DaemonCdpManager = class {
           } catch (e) {
             this.log(`[CDP] setDiscoverTargets failed: ${e.message}`);
           }
-          resolve24();
+          resolve25();
         });
         this.browserWs.on("message", (data) => {
           try {
             const msg = JSON.parse(data.toString());
             if (msg.id && this.browserPending.has(msg.id)) {
-              const { resolve: resolve25, reject: reject2 } = this.browserPending.get(msg.id);
+              const { resolve: resolve26, reject: reject2 } = this.browserPending.get(msg.id);
               this.browserPending.delete(msg.id);
               if (msg.error) reject2(new Error(msg.error.message));
-              else resolve25(msg.result);
+              else resolve26(msg.result);
             }
           } catch {
           }
@@ -26347,31 +26375,31 @@ var DaemonCdpManager = class {
     }
   }
   getBrowserWsUrl() {
-    return new Promise((resolve24) => {
+    return new Promise((resolve25) => {
       const req = http.get(`http://127.0.0.1:${this.port}/json/version`, (res) => {
         let data = "";
         res.on("data", (chunk) => data += chunk.toString());
         res.on("end", () => {
           try {
             const info = JSON.parse(data);
-            resolve24(info.webSocketDebuggerUrl || null);
+            resolve25(info.webSocketDebuggerUrl || null);
           } catch {
-            resolve24(null);
+            resolve25(null);
           }
         });
       });
-      req.on("error", () => resolve24(null));
+      req.on("error", () => resolve25(null));
       req.setTimeout(3e3, () => {
         req.destroy();
-        resolve24(null);
+        resolve25(null);
       });
     });
   }
   sendBrowser(method, params = {}, timeoutMs = 15e3) {
-    return new Promise((resolve24, reject) => {
+    return new Promise((resolve25, reject) => {
       if (!this.browserWs || !this._browserConnected) return reject(new Error("Browser WS not connected"));
       const id = this.browserMsgId++;
-      this.browserPending.set(id, { resolve: resolve24, reject });
+      this.browserPending.set(id, { resolve: resolve25, reject });
       this.browserWs.send(JSON.stringify({ id, method, params }));
       setTimeout(() => {
         if (this.browserPending.has(id)) {
@@ -26411,11 +26439,11 @@ var DaemonCdpManager = class {
   }
   // ─── CDP Protocol ────────────────────────────────────────
   sendInternal(method, params = {}, timeoutMs = 15e3) {
-    return new Promise((resolve24, reject) => {
+    return new Promise((resolve25, reject) => {
       if (!this.ws || !this._connected) return reject(new Error("CDP not connected"));
       if (this.ws.readyState !== import_ws.default.OPEN) return reject(new Error("WebSocket not open"));
       const id = this.msgId++;
-      this.pending.set(id, { resolve: resolve24, reject });
+      this.pending.set(id, { resolve: resolve25, reject });
       this.ws.send(JSON.stringify({ id, method, params }));
       setTimeout(() => {
         if (this.pending.has(id)) {
@@ -26664,7 +26692,7 @@ var DaemonCdpManager = class {
     const browserWs = this.browserWs;
     let msgId = this.browserMsgId;
     const sendWs = (method, params = {}, sessionId) => {
-      return new Promise((resolve24, reject) => {
+      return new Promise((resolve25, reject) => {
         const mid = msgId++;
         this.browserMsgId = msgId;
         const handler = (raw) => {
@@ -26673,7 +26701,7 @@ var DaemonCdpManager = class {
             if (msg.id === mid) {
               browserWs.removeListener("message", handler);
               if (msg.error) reject(new Error(msg.error.message || JSON.stringify(msg.error)));
-              else resolve24(msg.result);
+              else resolve25(msg.result);
             }
           } catch {
           }
@@ -26874,14 +26902,14 @@ var DaemonCdpManager = class {
     if (!ws || ws.readyState !== import_ws.default.OPEN) {
       throw new Error("CDP not connected");
     }
-    return new Promise((resolve24, reject) => {
+    return new Promise((resolve25, reject) => {
       const id = getNextId();
       pendingMap.set(id, {
         resolve: (result) => {
           if (result?.result?.subtype === "error") {
             reject(new Error(result.result.description));
           } else {
-            resolve24(result?.result?.value);
+            resolve25(result?.result?.value);
           }
         },
         reject
@@ -26913,10 +26941,10 @@ var DaemonCdpManager = class {
       throw new Error("CDP not connected");
     }
     const sendViaSession = (method, params = {}) => {
-      return new Promise((resolve24, reject) => {
+      return new Promise((resolve25, reject) => {
         const pendingMap = this._browserConnected ? this.browserPending : this.pending;
         const id = this._browserConnected ? this.browserMsgId++ : this.msgId++;
-        pendingMap.set(id, { resolve: resolve24, reject });
+        pendingMap.set(id, { resolve: resolve25, reject });
         ws.send(JSON.stringify({ id, sessionId, method, params }));
         setTimeout(() => {
           if (pendingMap.has(id)) {
@@ -33146,7 +33174,7 @@ function getSendChatInputEnvelope(args) {
   return normalizeInputEnvelope(args?.input ? { input: args.input } : args);
 }
 function sleep(ms) {
-  return new Promise((resolve24) => setTimeout(resolve24, ms));
+  return new Promise((resolve25) => setTimeout(resolve25, ms));
 }
 async function waitOnceForFreshHermesCliStart(adapter, log) {
   if (adapter.cliType !== "hermes-cli") return;
@@ -33201,7 +33229,7 @@ function getStateLastSignature(state) {
 async function getStableExtensionBaseline(h) {
   const first = await readExtensionChatState(h);
   if (getStateMessageCount(first) > 0 || getStateLastSignature(first)) return first;
-  await new Promise((resolve24) => setTimeout(resolve24, 150));
+  await new Promise((resolve25) => setTimeout(resolve25, 150));
   const second = await readExtensionChatState(h);
   return getStateMessageCount(second) >= getStateMessageCount(first) ? second : first;
 }
@@ -33209,7 +33237,7 @@ async function verifyExtensionSendObserved(h, before) {
   const beforeCount = getStateMessageCount(before);
   const beforeSignature = getStateLastSignature(before);
   for (let attempt = 0; attempt < 12; attempt += 1) {
-    await new Promise((resolve24) => setTimeout(resolve24, 250));
+    await new Promise((resolve25) => setTimeout(resolve25, 250));
     const state = await readExtensionChatState(h);
     if (state?.status === "waiting_approval") return true;
     const afterCount = getStateMessageCount(state);
@@ -34611,7 +34639,7 @@ async function executeProviderScript(h, args, scriptName) {
         const enterCount = cliCommand.enterCount || 1;
         await adapter.writeRaw(cliCommand.text + "\r");
         for (let i = 1; i < enterCount; i += 1) {
-          await new Promise((resolve24) => setTimeout(resolve24, 50));
+          await new Promise((resolve25) => setTimeout(resolve25, 50));
           await adapter.writeRaw("\r");
         }
       }
@@ -35388,9 +35416,9 @@ var DaemonCommandHandler = class {
    * point at a sibling git checkout.
    */
   getUpstreamInstallRoot() {
-    const os30 = require("os");
-    const path43 = require("path");
-    return path43.join(os30.homedir(), ".adhdev", "providers", ".upstream");
+    const os31 = require("os");
+    const path44 = require("path");
+    return path44.join(os31.homedir(), ".adhdev", "providers", ".upstream");
   }
   /**
    * Download a single provider manifest from the registry and write it to
@@ -35414,11 +35442,11 @@ var DaemonCommandHandler = class {
       return { success: false, error: "invalid type" };
     }
     const https = require("https");
-    const fs38 = require("fs");
-    const path43 = require("path");
+    const fs39 = require("fs");
+    const path44 = require("path");
     const REGISTRY = "https://api.adhf.dev/api/v1/registry";
     function fetchText(url, timeoutMs) {
-      return new Promise((resolve24, reject) => {
+      return new Promise((resolve25, reject) => {
         const req = https.get(url, { headers: { "User-Agent": "adhdev-daemon", "Accept": "application/json" }, timeout: timeoutMs }, (res) => {
           if (res.statusCode !== 200) {
             reject(new Error(`HTTP ${res.statusCode}`));
@@ -35426,7 +35454,7 @@ var DaemonCommandHandler = class {
           }
           const chunks = [];
           res.on("data", (c) => chunks.push(c));
-          res.on("end", () => resolve24(Buffer.concat(chunks).toString("utf-8")));
+          res.on("end", () => resolve25(Buffer.concat(chunks).toString("utf-8")));
         });
         req.on("error", reject);
         req.on("timeout", () => {
@@ -35452,12 +35480,12 @@ var DaemonCommandHandler = class {
         return { success: false, error: `checksum mismatch: expected ${meta.checksum}, got ${actualChecksum}` };
       }
       const installRoot = this.getUpstreamInstallRoot();
-      const installRootResolved = path43.resolve(installRoot);
-      const targetDir = path43.resolve(path43.join(installRoot, category, type));
-      if (!targetDir.startsWith(installRootResolved + path43.sep)) {
+      const installRootResolved = path44.resolve(installRoot);
+      const targetDir = path44.resolve(path44.join(installRoot, category, type));
+      if (!targetDir.startsWith(installRootResolved + path44.sep)) {
         return { success: false, error: "install path escaped upstream root" };
       }
-      fs38.mkdirSync(targetDir, { recursive: true });
+      fs39.mkdirSync(targetDir, { recursive: true });
       let manifestProbe = {};
       try {
         manifestProbe = JSON.parse(manifestBody);
@@ -35481,8 +35509,8 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         }
       }
       const targetFile = isV1 ? "provider.v1.json" : "provider.json";
-      const targetPath = path43.join(targetDir, targetFile);
-      fs38.writeFileSync(targetPath, manifestBody, "utf-8");
+      const targetPath = path44.join(targetDir, targetFile);
+      fs39.writeFileSync(targetPath, manifestBody, "utf-8");
       const manifestJson = JSON.parse(manifestBody);
       const scriptFetch = await this.fetchProviderSources(
         manifestJson,
@@ -35552,10 +35580,10 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     const repo = source.repo;
     const ref = source.ref;
     const https = require("https");
-    const fs38 = require("fs");
-    const path43 = require("path");
+    const fs39 = require("fs");
+    const path44 = require("path");
     function fetchJson(url, timeoutMs) {
-      return new Promise((resolve24, reject) => {
+      return new Promise((resolve25, reject) => {
         const req = https.get(url, {
           headers: { "User-Agent": "adhdev-daemon", "Accept": "application/vnd.github+json" },
           timeout: timeoutMs
@@ -35568,7 +35596,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           res.on("data", (c) => chunks.push(c));
           res.on("end", () => {
             try {
-              resolve24(JSON.parse(Buffer.concat(chunks).toString("utf-8")));
+              resolve25(JSON.parse(Buffer.concat(chunks).toString("utf-8")));
             } catch (e) {
               reject(e);
             }
@@ -35582,14 +35610,14 @@ ${formatManifestValidationIssues2(validation.issues)}`,
       });
     }
     function fetchBinary(url, timeoutMs) {
-      return new Promise((resolve24, reject) => {
+      return new Promise((resolve25, reject) => {
         const req = https.get(url, {
           headers: { "User-Agent": "adhdev-daemon" },
           timeout: timeoutMs
         }, (res) => {
           if (res.statusCode === 301 || res.statusCode === 302) {
             if (res.headers.location) {
-              return fetchBinary(res.headers.location, timeoutMs).then(resolve24, reject);
+              return fetchBinary(res.headers.location, timeoutMs).then(resolve25, reject);
             }
           }
           if (res.statusCode !== 200) {
@@ -35598,7 +35626,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           }
           const chunks = [];
           res.on("data", (c) => chunks.push(c));
-          res.on("end", () => resolve24(Buffer.concat(chunks)));
+          res.on("end", () => resolve25(Buffer.concat(chunks)));
         });
         req.on("error", reject);
         req.on("timeout", () => {
@@ -35609,9 +35637,9 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     }
     let fetchedCount = 0;
     const sharedDirRel = `${category}/_shared`;
-    const sharedTargetDir = path43.resolve(path43.join(targetDir, "../_shared"));
-    const installRootResolved = path43.resolve(path43.join(targetDir, "../.."));
-    if (sharedTargetDir.startsWith(installRootResolved + path43.sep)) {
+    const sharedTargetDir = path44.resolve(path44.join(targetDir, "../_shared"));
+    const installRootResolved = path44.resolve(path44.join(targetDir, "../.."));
+    if (sharedTargetDir.startsWith(installRootResolved + path44.sep)) {
       const sharedStack = [sharedDirRel];
       while (sharedStack.length) {
         const relDir = sharedStack.pop();
@@ -35634,10 +35662,10 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           try {
             const body = await fetchBinary(entry.download_url, 3e4);
             const relInside = entry.path.startsWith(sharedDirRel + "/") ? entry.path.slice(sharedDirRel.length + 1) : entry.path;
-            const outPath = path43.resolve(path43.join(sharedTargetDir, relInside));
-            if (!outPath.startsWith(path43.resolve(sharedTargetDir) + path43.sep)) continue;
-            fs38.mkdirSync(path43.dirname(outPath), { recursive: true });
-            fs38.writeFileSync(outPath, body);
+            const outPath = path44.resolve(path44.join(sharedTargetDir, relInside));
+            if (!outPath.startsWith(path44.resolve(sharedTargetDir) + path44.sep)) continue;
+            fs39.mkdirSync(path44.dirname(outPath), { recursive: true });
+            fs39.writeFileSync(outPath, body);
             fetchedCount++;
           } catch (e) {
             errors.push(`fetch shared ${entry.path}: ${e?.message ?? e}`);
@@ -35670,13 +35698,13 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           try {
             const body = await fetchBinary(entry.download_url, 3e4);
             const relInsideProvider = entry.path.startsWith(subdir + "/") ? entry.path.slice(subdir.length + 1) : entry.path;
-            const outPath = path43.resolve(path43.join(targetDir, relInsideProvider));
-            if (!outPath.startsWith(path43.resolve(targetDir) + path43.sep)) {
+            const outPath = path44.resolve(path44.join(targetDir, relInsideProvider));
+            if (!outPath.startsWith(path44.resolve(targetDir) + path44.sep)) {
               errors.push(`refusing to write outside targetDir: ${entry.path}`);
               continue;
             }
-            fs38.mkdirSync(path43.dirname(outPath), { recursive: true });
-            fs38.writeFileSync(outPath, body);
+            fs39.mkdirSync(path44.dirname(outPath), { recursive: true });
+            fs39.writeFileSync(outPath, body);
             fetchedCount++;
           } catch (e) {
             errors.push(`fetch ${entry.path}: ${e?.message ?? e}`);
@@ -35704,19 +35732,19 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     if (!["cli", "ide", "extension", "acp"].includes(category)) {
       return { success: false, error: `unknown category: ${category}` };
     }
-    const fs38 = require("fs");
-    const path43 = require("path");
+    const fs39 = require("fs");
+    const path44 = require("path");
     try {
       const installRoot = this.getUpstreamInstallRoot();
-      const installRootResolved = path43.resolve(installRoot);
-      const targetDir = path43.resolve(path43.join(installRoot, category, type));
-      if (!targetDir.startsWith(installRootResolved + path43.sep)) {
+      const installRootResolved = path44.resolve(installRoot);
+      const targetDir = path44.resolve(path44.join(installRoot, category, type));
+      if (!targetDir.startsWith(installRootResolved + path44.sep)) {
         return { success: false, error: "refusing to delete outside upstream root" };
       }
-      if (!fs38.existsSync(targetDir)) {
+      if (!fs39.existsSync(targetDir)) {
         return { success: false, error: "not installed" };
       }
-      fs38.rmSync(targetDir, { recursive: true, force: true });
+      fs39.rmSync(targetDir, { recursive: true, force: true });
       if (this._ctx.providerLoader) {
         this._ctx.providerLoader.reload();
         this._ctx.providerLoader.registerToDetector();
@@ -35732,28 +35760,28 @@ ${formatManifestValidationIssues2(validation.issues)}`,
    * the UI and by the update checker.
    */
   handleListInstalledProviders(_args) {
-    const fs38 = require("fs");
-    const path43 = require("path");
+    const fs39 = require("fs");
+    const path44 = require("path");
     const installRoot = this.getUpstreamInstallRoot();
-    if (!fs38.existsSync(installRoot)) return { success: true, providers: [] };
+    if (!fs39.existsSync(installRoot)) return { success: true, providers: [] };
     const CATEGORIES = ["cli", "ide", "extension", "acp"];
     const items = [];
     for (const category of CATEGORIES) {
-      const categoryDir = path43.join(installRoot, category);
-      if (!fs38.existsSync(categoryDir)) continue;
+      const categoryDir = path44.join(installRoot, category);
+      if (!fs39.existsSync(categoryDir)) continue;
       let entries;
       try {
-        entries = fs38.readdirSync(categoryDir);
+        entries = fs39.readdirSync(categoryDir);
       } catch {
         continue;
       }
       for (const type of entries) {
-        const v1Path = path43.join(categoryDir, type, "provider.v1.json");
-        const v0Path = path43.join(categoryDir, type, "provider.json");
-        const manifestPath = fs38.existsSync(v1Path) ? v1Path : fs38.existsSync(v0Path) ? v0Path : null;
+        const v1Path = path44.join(categoryDir, type, "provider.v1.json");
+        const v0Path = path44.join(categoryDir, type, "provider.json");
+        const manifestPath = fs39.existsSync(v1Path) ? v1Path : fs39.existsSync(v0Path) ? v0Path : null;
         if (!manifestPath) continue;
         try {
-          const m = JSON.parse(fs38.readFileSync(manifestPath, "utf-8"));
+          const m = JSON.parse(fs39.readFileSync(manifestPath, "utf-8"));
           items.push({
             type,
             category,
@@ -35780,7 +35808,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     const https = require("https");
     const REGISTRY = "https://api.adhf.dev/api/v1/registry";
     function fetchJson(url) {
-      return new Promise((resolve24, reject) => {
+      return new Promise((resolve25, reject) => {
         const req = https.get(url, { headers: { "User-Agent": "adhdev-daemon", "Accept": "application/json" }, timeout: 1e4 }, (res) => {
           if (res.statusCode !== 200) {
             reject(new Error(`HTTP ${res.statusCode}`));
@@ -35790,7 +35818,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           res.on("data", (c) => chunks.push(c));
           res.on("end", () => {
             try {
-              resolve24(JSON.parse(Buffer.concat(chunks).toString("utf-8")));
+              resolve25(JSON.parse(Buffer.concat(chunks).toString("utf-8")));
             } catch (e) {
               reject(e);
             }
@@ -35864,8 +35892,8 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     if (!/^@[a-z0-9_-]+$/i.test(requestedName)) {
       return { success: false, error: "name must match @[a-z0-9_-]+" };
     }
-    const fs38 = require("fs");
-    const path43 = require("path");
+    const fs39 = require("fs");
+    const path44 = require("path");
     const { spawnSync: spawnSync2 } = require("child_process");
     const file = ext.loadExternalSources();
     if (file.sources.some((s2) => s2.name === requestedName)) {
@@ -35874,9 +35902,9 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     if (file.sources.some((s2) => s2.url === url && s2.ref === ref)) {
       return { success: false, error: `source url+ref already registered (use a different name to track another ref)` };
     }
-    const sourceDir = path43.join(ext.externalRoot(), requestedName);
-    if (!fs38.existsSync(ext.externalRoot())) fs38.mkdirSync(ext.externalRoot(), { recursive: true });
-    if (fs38.existsSync(sourceDir)) {
+    const sourceDir = path44.join(ext.externalRoot(), requestedName);
+    if (!fs39.existsSync(ext.externalRoot())) fs39.mkdirSync(ext.externalRoot(), { recursive: true });
+    if (fs39.existsSync(sourceDir)) {
       return { success: false, error: `directory already exists: ${sourceDir} (rename or remove first)` };
     }
     const clone = spawnSync2("git", ["clone", "--depth=1", "--branch", ref, "--", url, sourceDir], {
@@ -35886,7 +35914,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     });
     if (clone.status !== 0) {
       try {
-        fs38.rmSync(sourceDir, { recursive: true, force: true });
+        fs39.rmSync(sourceDir, { recursive: true, force: true });
       } catch {
       }
       return { success: false, error: `git clone failed: ${(clone.stderr || clone.stdout || "").trim() || "unknown error"}` };
@@ -35930,15 +35958,15 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     const name = typeof args?.name === "string" ? args.name.trim() : "";
     if (!name) return { success: false, error: "name is required" };
     const ext = (init_external_sources(), __toCommonJS(external_sources_exports));
-    const fs38 = require("fs");
-    const path43 = require("path");
+    const fs39 = require("fs");
+    const path44 = require("path");
     const file = ext.loadExternalSources();
     const match = file.sources.find((s2) => s2.name === name);
     if (!match) return { success: false, error: `source "${name}" not registered` };
-    const sourceDir = path43.join(ext.externalRoot(), name);
-    if (fs38.existsSync(sourceDir)) {
+    const sourceDir = path44.join(ext.externalRoot(), name);
+    if (fs39.existsSync(sourceDir)) {
       try {
-        fs38.rmSync(sourceDir, { recursive: true, force: true });
+        fs39.rmSync(sourceDir, { recursive: true, force: true });
       } catch (e) {
         return { success: false, error: `failed to delete ${sourceDir}: ${e?.message || e}` };
       }
@@ -36028,7 +36056,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     try {
       const http3 = await import("http");
       const postData = JSON.stringify(body);
-      const result = await new Promise((resolve24, reject) => {
+      const result = await new Promise((resolve25, reject) => {
         const req = http3.request({
           hostname: "127.0.0.1",
           port: 19280,
@@ -36040,9 +36068,9 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           res.on("data", (chunk) => data += chunk);
           res.on("end", () => {
             try {
-              resolve24(JSON.parse(data));
+              resolve25(JSON.parse(data));
             } catch {
-              resolve24({ raw: data });
+              resolve25({ raw: data });
             }
           });
         });
@@ -36060,15 +36088,15 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     if (!providerType) return { success: false, error: "providerType required" };
     try {
       const http3 = await import("http");
-      const result = await new Promise((resolve24, reject) => {
+      const result = await new Promise((resolve25, reject) => {
         http3.get(`http://127.0.0.1:19280/api/providers/${providerType}/${endpoint}`, (res) => {
           let data = "";
           res.on("data", (chunk) => data += chunk);
           res.on("end", () => {
             try {
-              resolve24(JSON.parse(data));
+              resolve25(JSON.parse(data));
             } catch {
-              resolve24({ raw: data });
+              resolve25({ raw: data });
             }
           });
         }).on("error", reject);
@@ -36082,7 +36110,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     try {
       const http3 = await import("http");
       const postData = JSON.stringify(args || {});
-      const result = await new Promise((resolve24, reject) => {
+      const result = await new Promise((resolve25, reject) => {
         const req = http3.request({
           hostname: "127.0.0.1",
           port: 19280,
@@ -36094,9 +36122,9 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           res.on("data", (chunk) => data += chunk);
           res.on("end", () => {
             try {
-              resolve24(JSON.parse(data));
+              resolve25(JSON.parse(data));
             } catch {
-              resolve24({ raw: data });
+              resolve25({ raw: data });
             }
           });
         });
@@ -36721,24 +36749,24 @@ var statusMetaHandlers = {
 // src/commands/low-family/coordinator-prompt.ts
 var coordinatorPromptHandlers = {
   list_coordinator_prompts: async (_ctx, _args) => {
-    const fs38 = await import("fs");
-    const path43 = await import("path");
-    const os30 = await import("os");
-    const dir = path43.join(os30.homedir(), ".adhdev", "coordinator-prompts");
+    const fs39 = await import("fs");
+    const path44 = await import("path");
+    const os31 = await import("os");
+    const dir = path44.join(os31.homedir(), ".adhdev", "coordinator-prompts");
     const entries = {};
     try {
-      if (fs38.existsSync(dir)) {
-        for (const name of fs38.readdirSync(dir)) {
+      if (fs39.existsSync(dir)) {
+        for (const name of fs39.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;
           if (!m) continue;
           const isAppend = !!matchAppend;
           const key2 = m[1];
-          const full = path43.join(dir, name);
+          const full = path44.join(dir, name);
           let content = "";
           try {
-            content = fs38.readFileSync(full, "utf8");
+            content = fs39.readFileSync(full, "utf8");
           } catch {
           }
           if (!entries[key2]) entries[key2] = { override: "", append: "" };
@@ -36752,24 +36780,24 @@ var coordinatorPromptHandlers = {
     return { success: true, dir, entries };
   },
   write_coordinator_prompt: async (_ctx, args) => {
-    const fs38 = await import("fs");
-    const path43 = await import("path");
-    const os30 = await import("os");
+    const fs39 = await import("fs");
+    const path44 = await import("path");
+    const os31 = await import("os");
     const key2 = typeof args?.key === "string" ? args.key.trim() : "";
     const kind = args?.kind === "append" ? "append" : "override";
     const content = typeof args?.content === "string" ? args.content : "";
     if (!key2 || !/^[a-zA-Z0-9_.-]+$/.test(key2)) {
       return { success: false, error: "key must match [a-zA-Z0-9_.-]+" };
     }
-    const dir = path43.join(os30.homedir(), ".adhdev", "coordinator-prompts");
+    const dir = path44.join(os31.homedir(), ".adhdev", "coordinator-prompts");
     const filename = kind === "append" ? `${key2}.append.md` : `${key2}.md`;
-    const full = path43.join(dir, filename);
+    const full = path44.join(dir, filename);
     try {
-      fs38.mkdirSync(dir, { recursive: true });
+      fs39.mkdirSync(dir, { recursive: true });
       if (content.trim()) {
-        fs38.writeFileSync(full, content, { encoding: "utf8", mode: 384 });
-      } else if (fs38.existsSync(full)) {
-        fs38.unlinkSync(full);
+        fs39.writeFileSync(full, content, { encoding: "utf8", mode: 384 });
+      } else if (fs39.existsSync(full)) {
+        fs39.unlinkSync(full);
       }
       return { success: true, path: full, kind, key: key2 };
     } catch (error) {
@@ -37086,7 +37114,7 @@ async function waitForPidExit(pid, timeoutMs) {
   while (Date.now() - start < timeoutMs) {
     try {
       process.kill(pid, 0);
-      await new Promise((resolve24) => setTimeout(resolve24, 250));
+      await new Promise((resolve25) => setTimeout(resolve25, 250));
     } catch {
       return;
     }
@@ -37312,7 +37340,7 @@ async function runDaemonUpgradeHelper(payload) {
         appendUpgradeLog(`Install attempt ${attempt} hit a file lock (${error?.code || "lock"}); clearing holders + staging and retrying after backoff`);
         await stopForeignNativeAddonHolders(installCommand.surface.packageRoot, { parentPid: payload.parentPid });
         cleanupStaleGlobalInstallDirs(payload.packageName, installCommand.surface);
-        await new Promise((resolve24) => setTimeout(resolve24, attempt * 1500));
+        await new Promise((resolve25) => setTimeout(resolve25, attempt * 1500));
         continue;
       }
       if (isRetriableInstallLockError(error)) {
@@ -37340,7 +37368,7 @@ async function runDaemonUpgradeHelper(payload) {
     appendUpgradeLog(installOutput.trim());
   }
   if (process.platform === "win32") {
-    await new Promise((resolve24) => setTimeout(resolve24, 500));
+    await new Promise((resolve25) => setTimeout(resolve25, 500));
     cleanupStaleGlobalInstallDirs(payload.packageName, installCommand.surface);
     appendUpgradeLog("Post-install staging cleanup complete");
   }
@@ -39988,7 +40016,7 @@ function stripAnsi3(text) {
   return String(text || "").replace(/\x1B\][^\x07]*(?:\x07|\x1B\\)/g, "").replace(/\x1B[P^_X][\s\S]*?(?:\x07|\x1B\\)/g, "").replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "");
 }
 function delay(ms) {
-  return new Promise((resolve24) => setTimeout(resolve24, ms));
+  return new Promise((resolve25) => setTimeout(resolve25, ms));
 }
 var SpecCliAdapter = class _SpecCliAdapter {
   cliType;
@@ -40187,7 +40215,7 @@ var SpecCliAdapter = class _SpecCliAdapter {
       const steps = buildClaudeInteractiveTuiAnswerSteps(prompt, response);
       for (const step of steps) {
         this.driver.dispatch({ kind: "pty_write", data: step });
-        await new Promise((resolve24) => setTimeout(resolve24, 180));
+        await new Promise((resolve25) => setTimeout(resolve25, 180));
       }
     } else {
       this.driver.dispatch({ kind: "pty_write", data: `${buildClaudeInteractiveToolResult(response)}
@@ -40738,7 +40766,7 @@ var SpecCliAdapter = class _SpecCliAdapter {
     let screenText = this.driver.snapshot();
     const deadline = Date.now() + _SpecCliAdapter.CLAUDE_TUI_PAGE_SETTLE_TIMEOUT_MS;
     while (!detectClaudeTuiMultiSelect(screenText) && Date.now() < deadline) {
-      await new Promise((resolve24) => setTimeout(resolve24, _SpecCliAdapter.CLAUDE_TUI_PAGE_POLL_INTERVAL_MS));
+      await new Promise((resolve25) => setTimeout(resolve25, _SpecCliAdapter.CLAUDE_TUI_PAGE_POLL_INTERVAL_MS));
       screenText = this.driver.snapshot();
     }
     return screenText;
@@ -40747,12 +40775,12 @@ var SpecCliAdapter = class _SpecCliAdapter {
     const pages = [{ screenText: firstScreen, header: headers[0] }];
     for (let index = 1; index < headers.length; index += 1) {
       this.driver.dispatch({ kind: "pty_write", data: "	" });
-      await new Promise((resolve24) => setTimeout(resolve24, _SpecCliAdapter.CLAUDE_TUI_PAGE_POLL_INTERVAL_MS));
+      await new Promise((resolve25) => setTimeout(resolve25, _SpecCliAdapter.CLAUDE_TUI_PAGE_POLL_INTERVAL_MS));
       pages.push({ screenText: await this.snapshotSettledClaudeTuiPage(), header: headers[index] });
     }
     for (let index = headers.length - 1; index > 0; index -= 1) {
       this.driver.dispatch({ kind: "pty_write", data: "\x1B[Z" });
-      await new Promise((resolve24) => setTimeout(resolve24, _SpecCliAdapter.CLAUDE_TUI_PAGE_POLL_INTERVAL_MS));
+      await new Promise((resolve25) => setTimeout(resolve25, _SpecCliAdapter.CLAUDE_TUI_PAGE_POLL_INTERVAL_MS));
       const reread = await this.snapshotSettledClaudeTuiPage();
       const landed = pages[index - 1];
       if (landed && !detectClaudeTuiMultiSelect(landed.screenText) && detectClaudeTuiMultiSelect(reread)) {
@@ -41107,7 +41135,7 @@ async function waitForCliAdapterReady(adapter, options) {
     if (status === "stopped") {
       throw new Error("CLI runtime stopped before it became ready");
     }
-    await new Promise((resolve24) => setTimeout(resolve24, pollMs));
+    await new Promise((resolve25) => setTimeout(resolve25, pollMs));
   }
   throw new Error(`CLI runtime did not become ready within ${timeoutMs}ms`);
 }
@@ -41856,7 +41884,7 @@ var CliProviderInstance = class _CliProviderInstance {
       const enterCount = cliCommand.enterCount || 1;
       await this.adapter.writeRaw(cliCommand.text + "\r");
       for (let i = 1; i < enterCount; i += 1) {
-        await new Promise((resolve24) => setTimeout(resolve24, 50));
+        await new Promise((resolve25) => setTimeout(resolve25, 50));
         await this.adapter.writeRaw("\r");
       }
     }
@@ -43930,13 +43958,13 @@ var AcpProviderInstance = class {
         }
         this.currentStatus = "waiting_approval";
         this.detectStatusTransition();
-        const approved = await new Promise((resolve24) => {
-          this.permissionResolvers.push(resolve24);
+        const approved = await new Promise((resolve25) => {
+          this.permissionResolvers.push(resolve25);
           setTimeout(() => {
-            const idx = this.permissionResolvers.indexOf(resolve24);
+            const idx = this.permissionResolvers.indexOf(resolve25);
             if (idx >= 0) {
               this.permissionResolvers.splice(idx, 1);
-              resolve24(false);
+              resolve25(false);
             }
           }, 3e5);
         });
@@ -44672,7 +44700,7 @@ async function waitForZeroMessageStartingLaunch(adapter) {
   } catch {
     return false;
   }
-  await new Promise((resolve24) => setTimeout(resolve24, ZERO_MESSAGE_STARTING_SEND_WAIT_MS));
+  await new Promise((resolve25) => setTimeout(resolve25, ZERO_MESSAGE_STARTING_SEND_WAIT_MS));
   try {
     return hasZeroMessageStartingLaunch(adapter);
   } catch {
@@ -46013,9 +46041,9 @@ function validateProviderDefinition(raw) {
   const typedProvider = provider;
   const controls = Array.isArray(provider.controls) ? provider.controls : [];
   if (category === "cli" || category === "acp") {
-    const spawn4 = provider.spawn;
-    const command = spawn4 && typeof spawn4 === "object" ? spawn4.command : void 0;
-    if (!spawn4 || typeof spawn4 !== "object") {
+    const spawn5 = provider.spawn;
+    const command = spawn5 && typeof spawn5 === "object" ? spawn5.command : void 0;
+    if (!spawn5 || typeof spawn5 !== "object") {
       errors.push(`${String(category).toUpperCase()}/CLI providers must have spawn config`);
     } else if (typeof command !== "string" || !command.trim()) {
       errors.push("spawn.command is required");
@@ -48536,25 +48564,25 @@ var ProviderLoader = class _ProviderLoader {
     }
     if (providerDir) {
       try {
-        const fs38 = require("fs");
-        const path43 = require("path");
+        const fs39 = require("fs");
+        const path44 = require("path");
         const candidates = [];
         if (Array.isArray(base.compatibility)) {
           for (const entry of base.compatibility) {
             if (typeof entry?.spec !== "string") continue;
             const matches = !entry.ideVersion || currentVersion && this.matchesVersion(currentVersion, entry.ideVersion) || !currentVersion;
-            if (matches) candidates.push(path43.join(providerDir, entry.spec));
+            if (matches) candidates.push(path44.join(providerDir, entry.spec));
           }
         }
-        candidates.push(path43.join(providerDir, "specs", "default.json"));
-        candidates.push(path43.join(providerDir, "spec.json"));
-        const specPath = candidates.find((p) => fs38.existsSync(p));
+        candidates.push(path44.join(providerDir, "specs", "default.json"));
+        candidates.push(path44.join(providerDir, "spec.json"));
+        const specPath = candidates.find((p) => fs39.existsSync(p));
         if (specPath) {
           resolved._resolvedSpecPath = specPath;
           let specControls;
           let nh;
           try {
-            const rawSpec = JSON.parse(fs38.readFileSync(specPath, "utf8"));
+            const rawSpec = JSON.parse(fs39.readFileSync(specPath, "utf8"));
             specControls = rawSpec.control_bar;
             nh = rawSpec.native_history;
           } catch {
@@ -48585,10 +48613,10 @@ var ProviderLoader = class _ProviderLoader {
               format = `spec-${nh.source.kind}`;
               reader = (input) => executeNativeHistory(nh, input);
             } else if (nh.override_path) {
-              const overrideFile = path43.resolve(providerDir, nh.override_path);
-              if (fs38.existsSync(overrideFile)) {
+              const overrideFile = path44.resolve(providerDir, nh.override_path);
+              if (fs39.existsSync(overrideFile)) {
                 try {
-                  registerProviderScriptRootSafely(path43.dirname(path43.dirname(providerDir)));
+                  registerProviderScriptRootSafely(path44.dirname(path44.dirname(providerDir)));
                   delete require.cache[require.resolve(overrideFile)];
                   const mod = require(overrideFile);
                   const fn = typeof mod === "function" ? mod : mod && typeof mod.default === "function" ? mod.default : null;
@@ -48762,7 +48790,7 @@ var ProviderLoader = class _ProviderLoader {
     }
     try {
       const listUrl = `${_ProviderLoader.REGISTRY_BASE_URL}/providers`;
-      const listBody = await new Promise((resolve24, reject) => {
+      const listBody = await new Promise((resolve25, reject) => {
         const req = https.get(listUrl, { headers: { "User-Agent": "adhdev-daemon", "Accept": "application/json" }, timeout: 1e4 }, (res) => {
           if (res.statusCode !== 200) {
             reject(new Error(`registry list HTTP ${res.statusCode}`));
@@ -48770,7 +48798,7 @@ var ProviderLoader = class _ProviderLoader {
           }
           const chunks = [];
           res.on("data", (c) => chunks.push(c));
-          res.on("end", () => resolve24(Buffer.concat(chunks).toString("utf-8")));
+          res.on("end", () => resolve25(Buffer.concat(chunks).toString("utf-8")));
         });
         req.on("error", reject);
         req.on("timeout", () => {
@@ -48786,7 +48814,7 @@ var ProviderLoader = class _ProviderLoader {
         const cacheKey = `${category}/${type}`;
         if (cachedChecksums[cacheKey] === checksum) continue;
         const dlUrl = `${_ProviderLoader.REGISTRY_BASE_URL}/providers/${type}/${version}/download`;
-        const manifestBody = await new Promise((resolve24, reject) => {
+        const manifestBody = await new Promise((resolve25, reject) => {
           const req = https.get(dlUrl, { headers: { "User-Agent": "adhdev-daemon", "Accept": "application/json" }, timeout: 3e4 }, (res) => {
             if (res.statusCode !== 200) {
               reject(new Error(`registry download HTTP ${res.statusCode} for ${type}@${version}`));
@@ -48794,7 +48822,7 @@ var ProviderLoader = class _ProviderLoader {
             }
             const chunks = [];
             res.on("data", (c) => chunks.push(c));
-            res.on("end", () => resolve24(Buffer.concat(chunks).toString("utf-8")));
+            res.on("end", () => resolve25(Buffer.concat(chunks).toString("utf-8")));
           });
           req.on("error", reject);
           req.on("timeout", () => {
@@ -48853,7 +48881,7 @@ var ProviderLoader = class _ProviderLoader {
       return { updated: false };
     }
     try {
-      const etag = await new Promise((resolve24, reject) => {
+      const etag = await new Promise((resolve25, reject) => {
         const options = {
           method: "HEAD",
           hostname: "github.com",
@@ -48871,7 +48899,7 @@ var ProviderLoader = class _ProviderLoader {
               headers: { "User-Agent": "adhdev-launcher" },
               timeout: 1e4
             }, (res2) => {
-              resolve24(res2.headers.etag || res2.headers["last-modified"] || "");
+              resolve25(res2.headers.etag || res2.headers["last-modified"] || "");
             });
             req2.on("error", reject);
             req2.on("timeout", () => {
@@ -48880,7 +48908,7 @@ var ProviderLoader = class _ProviderLoader {
             });
             req2.end();
           } else {
-            resolve24(res.headers.etag || res.headers["last-modified"] || "");
+            resolve25(res.headers.etag || res.headers["last-modified"] || "");
           }
         });
         req.on("error", reject);
@@ -48944,7 +48972,7 @@ var ProviderLoader = class _ProviderLoader {
   downloadFile(url, destPath) {
     const https = require("https");
     const http3 = require("http");
-    return new Promise((resolve24, reject) => {
+    return new Promise((resolve25, reject) => {
       const doRequest = (reqUrl, redirectCount = 0) => {
         if (redirectCount > 5) {
           reject(new Error("Too many redirects"));
@@ -48964,7 +48992,7 @@ var ProviderLoader = class _ProviderLoader {
           res.pipe(ws);
           ws.on("finish", () => {
             ws.close();
-            resolve24();
+            resolve25();
           });
           ws.on("error", reject);
         });
@@ -49520,10 +49548,10 @@ function findMacAppProcessPids(psOutput, appPaths) {
 
 // src/launch.ts
 async function execQuiet(command, options = {}) {
-  return new Promise((resolve24) => {
+  return new Promise((resolve25) => {
     (0, import_child_process9.exec)(command, options, (error, stdout) => {
-      if (error) return resolve24("");
-      resolve24(stdout.toString());
+      if (error) return resolve25("");
+      resolve25(stdout.toString());
     });
   });
 }
@@ -49604,17 +49632,17 @@ async function findFreePort(ports) {
   throw new Error("No free port found");
 }
 function checkPortFree(port) {
-  return new Promise((resolve24) => {
+  return new Promise((resolve25) => {
     const server = net.createServer();
     server.unref();
-    server.on("error", () => resolve24(false));
+    server.on("error", () => resolve25(false));
     server.listen(port, "127.0.0.1", () => {
-      server.close(() => resolve24(true));
+      server.close(() => resolve25(true));
     });
   });
 }
 async function isCdpActive(port) {
-  return new Promise((resolve24) => {
+  return new Promise((resolve25) => {
     const req = require("http").get(`http://127.0.0.1:${port}/json/version`, {
       timeout: 2e3
     }, (res) => {
@@ -49623,16 +49651,16 @@ async function isCdpActive(port) {
       res.on("end", () => {
         try {
           const info = JSON.parse(data);
-          resolve24(!!info["WebKit-Version"] || !!info["Browser"]);
+          resolve25(!!info["WebKit-Version"] || !!info["Browser"]);
         } catch {
-          resolve24(false);
+          resolve25(false);
         }
       });
     });
-    req.on("error", () => resolve24(false));
+    req.on("error", () => resolve25(false));
     req.on("timeout", () => {
       req.destroy();
-      resolve24(false);
+      resolve25(false);
     });
   });
 }
@@ -49768,7 +49796,7 @@ async function detectCurrentWorkspace(ideId) {
     }
   } else if (plat === "win32") {
     try {
-      const fs38 = require("fs");
+      const fs39 = require("fs");
       const appNameMap = getMacAppIdentifiers();
       const appName = appNameMap[ideId];
       if (appName) {
@@ -49777,8 +49805,8 @@ async function detectCurrentWorkspace(ideId) {
           appName,
           "storage.json"
         );
-        if (fs38.existsSync(storagePath)) {
-          const data = JSON.parse(fs38.readFileSync(storagePath, "utf-8"));
+        if (fs39.existsSync(storagePath)) {
+          const data = JSON.parse(fs39.readFileSync(storagePath, "utf-8"));
           const workspaces = data?.openedPathsList?.workspaces3 || data?.openedPathsList?.entries || [];
           if (workspaces.length > 0) {
             const recent = workspaces[0];
@@ -50256,12 +50284,12 @@ var meshCrudHandlers = {
         normalizeRepoMeshDeclarativeConfig: normalizeRepoMeshDeclarativeConfig2,
         MESH_JSON_CONFIG_LOCATIONS: MESH_JSON_CONFIG_LOCATIONS2
       } = await Promise.resolve().then(() => (init_mesh_json_config(), mesh_json_config_exports));
-      const { mkdirSync: mkdirSync21, writeFileSync: writeFileSync24 } = await import("fs");
-      const { dirname: dirname17, join: join49 } = await import("path");
+      const { mkdirSync: mkdirSync22, writeFileSync: writeFileSync24 } = await import("fs");
+      const { dirname: dirname17, join: join50 } = await import("path");
       const scaffold = buildMeshJsonConfigScaffold2(mesh);
       const scaffoldJson = serializeMeshJsonConfigScaffold2(scaffold);
       const relativePath = MESH_JSON_CONFIG_LOCATIONS2[0];
-      const absolutePath = join49(workspace, relativePath);
+      const absolutePath = join50(workspace, relativePath);
       const validation = normalizeRepoMeshDeclarativeConfig2(scaffold);
       if (!validation.valid) {
         return { success: false, meshId, error: `invalid mesh.json scaffold: ${validation.errors.join("; ")}` };
@@ -50297,7 +50325,7 @@ var meshCrudHandlers = {
           note: "Dry-run: nothing written. Re-run with write=true to persist to the repo (commit target). meshes.json is untouched."
         };
       }
-      mkdirSync21(dirname17(absolutePath), { recursive: true });
+      mkdirSync22(dirname17(absolutePath), { recursive: true });
       writeFileSync24(absolutePath, `${scaffoldJson}
 `, "utf-8");
       return {
@@ -50861,7 +50889,7 @@ var meshCrudHandlers = {
       const setupPromise = finishWorktreeSetup();
       const setupResult = await Promise.race([
         setupPromise.then((value) => ({ completed: true, value })),
-        new Promise((resolve24) => setTimeout(() => resolve24({ completed: false }), setupWaitMs))
+        new Promise((resolve25) => setTimeout(() => resolve25({ completed: false }), setupWaitMs))
       ]);
       const emitBootstrapEvent = (eventStatus2, bootstrapState2, startedAtMs, extraPayload) => {
         try {
@@ -52098,7 +52126,7 @@ ${ptyResult.output.slice(-2e3)}`);
           workspace
         };
       }
-      const { existsSync: existsSync53, readFileSync: readFileSync41, writeFileSync: writeFileSync24, copyFileSync: copyFileSync4, mkdirSync: mkdirSync21 } = await import("fs");
+      const { existsSync: existsSync54, readFileSync: readFileSync42, writeFileSync: writeFileSync24, copyFileSync: copyFileSync4, mkdirSync: mkdirSync22 } = 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;
@@ -52134,21 +52162,21 @@ ${ptyResult.output.slice(-2e3)}`);
         };
       }
       try {
-        mkdirSync21(dirname17(mcpConfigPath), { recursive: true });
+        mkdirSync22(dirname17(mcpConfigPath), { recursive: true });
       } catch (error) {
         const message = `Could not prepare MCP config path for automatic setup: ${error?.message || error}`;
         LOG.error("MeshCoordinator", message);
         if (hermesManualFallback) return returnManualFallback(message);
         return { success: false, code: "mesh_coordinator_config_write_failed", error: message, meshId, cliType, workspace };
       }
-      const hadExistingMcpConfig = existsSync53(mcpConfigPath);
+      const hadExistingMcpConfig = existsSync54(mcpConfigPath);
       let existingMcpConfig = hermesBaseConfig?.config || {};
       if (hermesBaseConfig) {
         copyHermesCoordinatorCredentialFiles(hermesBaseConfig.sourceHome, dirname17(mcpConfigPath));
       }
       if (hadExistingMcpConfig) {
         try {
-          const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync41(mcpConfigPath, "utf-8"), configFormat);
+          const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync42(mcpConfigPath, "utf-8"), configFormat);
           const existingCoordinatorConfig = hermesManualFallback ? stripHermesCoordinatorTempModelProviderOverrides(parsedExistingMcpConfig) : parsedExistingMcpConfig;
           existingMcpConfig = { ...existingMcpConfig, ...existingCoordinatorConfig };
           copyFileSync4(mcpConfigPath, mcpConfigPath + ".backup");
@@ -52292,10 +52320,10 @@ function runGit2(repoRoot, args) {
   }
 }
 function readRecord6(repoRoot) {
-  const path43 = (0, import_node_path2.resolve)(repoRoot, PREVIEW_DEPLOY_RECORD);
-  if (!(0, import_node_fs4.existsSync)(path43)) return null;
+  const path44 = (0, import_node_path2.resolve)(repoRoot, PREVIEW_DEPLOY_RECORD);
+  if (!(0, import_node_fs4.existsSync)(path44)) return null;
   try {
-    const parsed = JSON.parse((0, import_node_fs4.readFileSync)(path43, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs4.readFileSync)(path44, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
@@ -52427,6 +52455,10 @@ var meshStatusHandlers = {
       const sessionHostRecords = ctx.deps.sessionHostControl?.listSessions ? await ctx.deps.sessionHostControl.listSessions().catch(() => []) : [];
       const liveMeshSessions = partitionSessionHostRecords(Array.isArray(sessionHostRecords) ? sessionHostRecords : []).liveRuntimes;
       const localMachineId = loadConfig().machineId || "";
+      const localMachineNickname = (() => {
+        const nick = loadConfig().machineNickname;
+        return typeof nick === "string" && nick.trim() ? nick.trim() : "";
+      })();
       const requireDirectPeerTruth = args?.requireDirectPeerTruth === true;
       const meshGitProbeCache = ctx.meshGitProbeCache;
       const directTruth = requireDirectPeerTruth ? await hydrateInlineMeshDirectTruth({
@@ -52507,6 +52539,9 @@ var meshStatusHandlers = {
         ) || Boolean(
           daemonId && (daemonIdsEquivalent(daemonId, localMachineId) || daemonIdsEquivalent(daemonId, ctx.deps.statusInstanceId))
         ) || Boolean(meshRecord?.inline && nodeIndex === 0) || sparseConfiguredCoordinatorNode;
+        if (isSelfNode && localMachineNickname && !readStringValue(node.machineNickname, node.machine_nickname)) {
+          node.machineNickname = localMachineNickname;
+        }
         const machineIdentity = buildMeshNodeMachineIdentity(node, {
           localMachineId,
           localDaemonId: ctx.deps.statusInstanceId,
@@ -52843,7 +52878,7 @@ var meshStatusHandlers = {
       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: existsSync53 } = await import("fs");
+      const { existsSync: existsSync54 } = 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" };
@@ -52862,7 +52897,7 @@ var meshStatusHandlers = {
       const derivation = deriveMeshReviewInboxItems2({ nodes: nodeStatuses, ledgerEntries });
       for (const item of derivation.items) {
         const workspace = item.workspace;
-        if (!workspace || !existsSync53(workspace)) continue;
+        if (!workspace || !existsSync54(workspace)) continue;
         const baseRef = item.defaultBranch ? `origin/${item.defaultBranch}` : "origin/main";
         try {
           const diffResult = await getGitDiffSummary2(workspace, { baseRef, maxFiles: 100 });
@@ -53070,9 +53105,9 @@ init_resolve_executable();
 var execFileAsync3 = (0, import_node_util4.promisify)(import_node_child_process5.execFile);
 var GIT = process.platform === "win32" ? resolveWin32Executable("git") : "git";
 var MAX_CHANGED_FILES2 = 500;
-function topLevel(path43) {
-  const slash = path43.indexOf("/");
-  return slash === -1 ? path43 : path43.slice(0, slash);
+function topLevel(path44) {
+  const slash = path44.indexOf("/");
+  return slash === -1 ? path44 : path44.slice(0, slash);
 }
 async function analyzeMeshRefineNodeChangeArea(args) {
   const { nodeId, workspace, branch, baseRef, branchRef, diffCwd, submodulePaths } = args;
@@ -53395,7 +53430,7 @@ function buildLivePeerGitConnection(connection, timestamp = (/* @__PURE__ */ new
 }
 function recordInlineMeshDirectGitTruth(node, git, source) {
   if (!node || typeof node !== "object" || Array.isArray(node)) {
-    return { reporterPlatform: null, reporterArch: null };
+    return { reporterPlatform: null, reporterArch: null, reporterMachineNickname: null };
   }
   const checkedAt = readNumberValue(git.lastCheckedAt) ?? Date.now();
   const updatedAt = new Date(checkedAt).toISOString();
@@ -53420,7 +53455,9 @@ function recordInlineMeshDirectGitTruth(node, git, source) {
   stampNodeReporterPlatform(node, reporterPlatform, reporterArch);
   if (reporterPlatform) node.reportedPlatform = reporterPlatform;
   if (reporterArch) node.reportedArch = reporterArch;
-  return { reporterPlatform, reporterArch };
+  const reporterMachineNickname = readStringValue(git.reporterMachineNickname) ?? null;
+  if (reporterMachineNickname) node.machineNickname = reporterMachineNickname;
+  return { reporterPlatform, reporterArch, reporterMachineNickname };
 }
 function stampNodeReporterPlatform(node, platform10, arch2) {
   if (!node || typeof node !== "object" || Array.isArray(node)) return;
@@ -53443,8 +53480,9 @@ function persistNodeReporterPlatform(meshSource, mesh, nodeId, reporter) {
   if (!meshId || !nodeId) return;
   const reportedPlatform = reporter.reporterPlatform ?? void 0;
   const reportedArch = reporter.reporterArch ?? void 0;
-  if (!reportedPlatform && !reportedArch) return;
-  void Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports)).then(({ updateNode: updateNode2 }) => updateNode2(meshId, nodeId, { reportedPlatform, reportedArch })).catch(() => {
+  const reportedMachineNickname = reporter.reporterMachineNickname ?? void 0;
+  if (!reportedPlatform && !reportedArch && !reportedMachineNickname) return;
+  void Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports)).then(({ updateNode: updateNode2 }) => updateNode2(meshId, nodeId, { reportedPlatform, reportedArch, reportedMachineNickname })).catch(() => {
   });
 }
 function buildCachedInlineMeshGitStatus(node) {
@@ -54096,9 +54134,11 @@ async function probeRemoteMeshGitStatus(args) {
   if (!remoteGit || typeof remoteGit !== "object" || typeof remoteGit.isGitRepo !== "boolean") return null;
   const reporterPlatform = readStringValue(remoteResult?.reporterPlatform);
   const reporterArch = readStringValue(remoteResult?.reporterArch);
+  const reporterMachineNickname = readStringValue(remoteResult?.reporterMachineNickname);
   const git = remoteGit;
   if (reporterPlatform) git.reporterPlatform = reporterPlatform;
   if (reporterArch) git.reporterArch = reporterArch;
+  if (reporterMachineNickname) git.reporterMachineNickname = reporterMachineNickname;
   return git;
 }
 var MESH_DIRECT_PROBE_MAX_RETRIES = 2;
@@ -54125,7 +54165,7 @@ async function probeRemoteMeshGitStatusWithRetry(args) {
       const connection = args.getConnection?.(args.daemonId);
       if (args.getConnection && readMeshConnectionState(connection) !== "connected") break;
       if (connection) args.onConnection?.(connection);
-      await new Promise((resolve24) => setTimeout(resolve24, 250 * 2 ** (attempt - 1)));
+      await new Promise((resolve25) => setTimeout(resolve25, 250 * 2 ** (attempt - 1)));
     }
     try {
       const remoteGit = await probeRemoteMeshGitStatus({
@@ -54502,18 +54542,18 @@ function resolveRefineryAutoPublishSubmoduleMainCommits(mesh, workspace) {
   return { enabled: false };
 }
 async function computeGitPatchId(cwd, fromRef, toRef, excludePaths = []) {
-  const { execFileSync: execFileSync9 } = await import("child_process");
+  const { execFileSync: execFileSync10 } = await import("child_process");
   const diffArgs = ["diff", "--patch", "--full-index", fromRef, toRef];
   if (excludePaths.length > 0) {
-    diffArgs.push("--", ".", ...excludePaths.map((path43) => `:(exclude)${path43}`));
+    diffArgs.push("--", ".", ...excludePaths.map((path44) => `:(exclude)${path44}`));
   }
-  const diff = execFileSync9(GIT2, diffArgs, {
+  const diff = execFileSync10(GIT2, diffArgs, {
     cwd,
     encoding: "utf8",
     maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
   });
   if (!diff.trim()) return "";
-  const patchId = execFileSync9(GIT2, ["patch-id", "--stable"], {
+  const patchId = execFileSync10(GIT2, ["patch-id", "--stable"], {
     cwd,
     input: diff,
     encoding: "utf8",
@@ -54524,8 +54564,8 @@ async function computeGitPatchId(cwd, fromRef, toRef, excludePaths = []) {
 async function runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead) {
   const startedAt = Date.now();
   try {
-    const { execFileSync: execFileSync9 } = await import("child_process");
-    const git = (args) => execFileSync9(GIT2, args, {
+    const { execFileSync: execFileSync10 } = await import("child_process");
+    const git = (args) => execFileSync10(GIT2, args, {
       cwd: repoRoot,
       encoding: "utf8",
       maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -54616,8 +54656,8 @@ ${e?.stderr || ""}`
 async function checkWorktreeChangesPatchEquivalentInRef(repoRoot, ref, worktreeHead) {
   const startedAt = Date.now();
   try {
-    const { execFileSync: execFileSync9 } = await import("child_process");
-    const git = (gitArgs) => execFileSync9(GIT2, gitArgs, {
+    const { execFileSync: execFileSync10 } = await import("child_process");
+    const git = (gitArgs) => execFileSync10(GIT2, gitArgs, {
       cwd: repoRoot,
       encoding: "utf8",
       maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -54680,8 +54720,8 @@ ${mergeTreeErr?.stderr || ""}`;
 async function runMeshRefineEffectiveDiffGate(repoRoot, baseHead, branchHead) {
   const startedAt = Date.now();
   try {
-    const { execFileSync: execFileSync9 } = await import("child_process");
-    const git = (args, opts) => execFileSync9(GIT2, args, {
+    const { execFileSync: execFileSync10 } = await import("child_process");
+    const git = (args, opts) => execFileSync10(GIT2, args, {
       cwd: opts?.cwd || repoRoot,
       encoding: "utf8",
       maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -54706,9 +54746,9 @@ async function runMeshRefineEffectiveDiffGate(repoRoot, baseHead, branchHead) {
         if (!trimmed) continue;
         if (trimmed.startsWith("+")) {
           const parts = trimmed.slice(1).trim().split(/\s+/);
-          const path43 = parts[1] || parts[0] || "(unknown)";
+          const path44 = parts[1] || parts[0] || "(unknown)";
           submoduleHints.push({
-            path: path43,
+            path: path44,
             reason: "submodule checked-out commit differs from the committed gitlink (pointer bump not committed on the root branch)"
           });
         }
@@ -54738,10 +54778,10 @@ async function runMeshRefineEffectiveDiffGate(repoRoot, baseHead, branchHead) {
 }
 function buildPatchEquivalenceSubmoduleConflictHint(repoRoot, baseHead, branchHead, output) {
   if (!/(submodule|160000)/i.test(output) || !/(conflict|failed to merge)/i.test(output)) return void 0;
-  const conflicts = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path43) => ({
-    path: path43,
-    baseCommit: readTreeObject(repoRoot, baseHead, path43),
-    branchCommit: readTreeObject(repoRoot, branchHead, path43)
+  const conflicts = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path44) => ({
+    path: path44,
+    baseCommit: readTreeObject(repoRoot, baseHead, path44),
+    branchCommit: readTreeObject(repoRoot, branchHead, path44)
   }));
   if (conflicts.length === 0) return void 0;
   return {
@@ -54767,11 +54807,11 @@ function readChangedGitlinkPaths(repoRoot, fromRef, toRef) {
       if (!line.trim()) continue;
       const metaAndPath = line.split("	");
       const meta = metaAndPath[0] || "";
-      const path43 = metaAndPath[metaAndPath.length - 1]?.trim();
-      if (!path43) continue;
+      const path44 = metaAndPath[metaAndPath.length - 1]?.trim();
+      if (!path44) continue;
       const parts = meta.split(/\s+/);
       if (parts[0]?.includes("160000") || parts[1]?.includes("160000")) {
-        paths.add(path43);
+        paths.add(path44);
       }
     }
     return [...paths].sort();
@@ -54779,9 +54819,9 @@ function readChangedGitlinkPaths(repoRoot, fromRef, toRef) {
     return [];
   }
 }
-function readTreeObject(repoRoot, ref, path43) {
+function readTreeObject(repoRoot, ref, path44) {
   try {
-    const output = (0, import_node_child_process6.execFileSync)(GIT2, ["ls-tree", ref, "--", path43], {
+    const output = (0, import_node_child_process6.execFileSync)(GIT2, ["ls-tree", ref, "--", path44], {
       cwd: repoRoot,
       encoding: "utf8",
       maxBuffer: 1024 * 1024
@@ -54826,12 +54866,12 @@ function readChangedPathKinds(repoRoot, fromRef, toRef) {
       if (!line.trim()) continue;
       const metaAndPath = line.split("	");
       const meta = metaAndPath[0] || "";
-      const path43 = metaAndPath[metaAndPath.length - 1]?.trim();
-      if (!path43 || seen.has(path43)) continue;
-      seen.add(path43);
+      const path44 = metaAndPath[metaAndPath.length - 1]?.trim();
+      if (!path44 || seen.has(path44)) continue;
+      seen.add(path44);
       const parts = meta.split(/\s+/);
       const isGitlink = !!(parts[0]?.includes("160000") || parts[1]?.includes("160000"));
-      result.push({ path: path43, isGitlink });
+      result.push({ path: path44, isGitlink });
     }
     return result;
   } catch {
@@ -54839,20 +54879,20 @@ function readChangedPathKinds(repoRoot, fromRef, toRef) {
   }
 }
 function collectFastForwardGitlinkPaths(repoRoot, baseHead, branchHead) {
-  return readChangedGitlinkPaths(repoRoot, baseHead, branchHead).filter((path43) => {
-    const baseCommit = readTreeObject(repoRoot, baseHead, path43);
-    const branchCommit = readTreeObject(repoRoot, branchHead, path43);
+  return readChangedGitlinkPaths(repoRoot, baseHead, branchHead).filter((path44) => {
+    const baseCommit = readTreeObject(repoRoot, baseHead, path44);
+    const branchCommit = readTreeObject(repoRoot, branchHead, path44);
     if (!baseCommit || !branchCommit) return false;
-    return isSubmoduleFastForward((0, import_path14.resolve)(repoRoot, path43), baseCommit, branchCommit);
+    return isSubmoduleFastForward((0, import_path14.resolve)(repoRoot, path44), baseCommit, branchCommit);
   });
 }
 function evaluateGitlinkTrivialFastForward(repoRoot, baseHead, branchHead) {
-  const changedGitlinks = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path43) => {
-    const baseCommit = readTreeObject(repoRoot, baseHead, path43);
-    const branchCommit = readTreeObject(repoRoot, branchHead, path43);
-    const submoduleRepoPath = (0, import_path14.resolve)(repoRoot, path43);
+  const changedGitlinks = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path44) => {
+    const baseCommit = readTreeObject(repoRoot, baseHead, path44);
+    const branchCommit = readTreeObject(repoRoot, branchHead, path44);
+    const submoduleRepoPath = (0, import_path14.resolve)(repoRoot, path44);
     const fastForward = !!baseCommit && !!branchCommit && isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit);
-    return { path: path43, baseCommit, branchCommit, fastForward };
+    return { path: path44, baseCommit, branchCommit, fastForward };
   });
   if (changedGitlinks.length === 0) {
     return { trivial: false, reason: "no_changed_gitlinks", gitlinks: changedGitlinks };
@@ -54903,7 +54943,7 @@ function buildTreeWithGitlinksEqualized(repoRoot, commitish, paths, placeholderC
       maxBuffer: 1024 * 1024
     }).trim();
     if (!tree) return void 0;
-    const updates = paths.map((path43) => `160000 commit ${placeholderCommit}	${path43}`).join("\n");
+    const updates = paths.map((path44) => `160000 commit ${placeholderCommit}	${path44}`).join("\n");
     if (!updates) return tree;
     const tmpIndex = (0, import_path14.join)(resolveGitDir(repoRoot), `adhdev-refine-eq-${commitish.slice(0, 12)}.index`);
     const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
@@ -55006,7 +55046,7 @@ function synthesizeTrivialFastForwardMergeTree(repoRoot, baseHead, branchHead, g
 }
 async function alignRefinerySubmodulesAfterMerge(repoRoot, previousBaseHead, currentHead, options = {}) {
   const startedAt = Date.now();
-  const changedGitlinkPaths = readChangedGitlinkPaths(repoRoot, previousBaseHead, currentHead).filter((path43) => !(options.submoduleIgnorePaths || []).includes(path43));
+  const changedGitlinkPaths = readChangedGitlinkPaths(repoRoot, previousBaseHead, currentHead).filter((path44) => !(options.submoduleIgnorePaths || []).includes(path44));
   const preStatus = await getGitRepoStatus(repoRoot, {
     includeSubmodules: true,
     submoduleIgnorePaths: options.submoduleIgnorePaths,
@@ -55053,7 +55093,7 @@ async function alignRefinerySubmodulesAfterMerge(repoRoot, previousBaseHead, cur
       changedGitlinkPaths,
       outOfSyncPaths,
       updatedPaths: updatePaths,
-      verifiedPaths: updatePaths.filter((path43) => !remaining.some((submodule) => submodule.path === path43)),
+      verifiedPaths: updatePaths.filter((path44) => !remaining.some((submodule) => submodule.path === path44)),
       durationMs: Date.now() - startedAt,
       command: `git ${commandArgs.join(" ")}`,
       stdout: truncateValidationOutput(result.stdout),
@@ -55379,15 +55419,15 @@ async function runMeshRefineValidationGate(mesh, workspace, opts) {
       const cwd = candidate.cwd ? (0, import_path14.resolve)(workspace, candidate.cwd) : workspace;
       const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
       const resolvedCommand = resolveWin32Executable(candidate.command);
-      const spawn4 = buildWin32ExecFileSpawn(resolvedCommand, candidate.args);
+      const spawn5 = buildWin32ExecFileSpawn(resolvedCommand, candidate.args);
       try {
-        const result = await execFileAsync4(spawn4.file, spawn4.args, {
+        const result = await execFileAsync4(spawn5.file, spawn5.args, {
           cwd,
           encoding: "utf8",
           timeout,
           maxBuffer: candidate.outputLimitBytes || REFINE_VALIDATION_OUTPUT_LIMIT_BYTES,
           env: { ...process.env, CI: process.env.CI || "1", ...candidate.env || {} },
-          ...spawn4.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}
+          ...spawn5.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}
         });
         summary.bootstrapCommandsRun.push(commandRecord(candidate, cwd, startedAt, result, true, { exitCode: 0 }));
       } catch (error) {
@@ -55425,15 +55465,15 @@ async function runMeshRefineValidationGate(mesh, workspace, opts) {
       return summary;
     }
     const resolvedCommand = resolveWin32Executable(candidate.command);
-    const spawn4 = buildWin32ExecFileSpawn(resolvedCommand, candidate.args);
+    const spawn5 = buildWin32ExecFileSpawn(resolvedCommand, candidate.args);
     try {
-      const result = await execFileAsync4(spawn4.file, spawn4.args, {
+      const result = await execFileAsync4(spawn5.file, spawn5.args, {
         cwd,
         encoding: "utf8",
         timeout,
         maxBuffer: candidate.outputLimitBytes || REFINE_VALIDATION_OUTPUT_LIMIT_BYTES,
         env: { ...process.env, CI: process.env.CI || "1", ...candidate.env || {} },
-        ...spawn4.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}
+        ...spawn5.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}
       });
       summary.commandsRun.push(commandRecord(candidate, cwd, startedAt, result, true, { exitCode: 0 }));
     } catch (error) {
@@ -56142,7 +56182,7 @@ var DaemonCommandRouter = class {
    */
   async bestEffortRemoveWorktreeDir(dir) {
     if (!dir || !fs32.existsSync(dir)) return { removed: true, residue: false };
-    const sleep3 = (ms) => new Promise((resolve24) => setTimeout(resolve24, ms));
+    const sleep3 = (ms) => new Promise((resolve25) => setTimeout(resolve25, ms));
     const ABSORB = /* @__PURE__ */ new Set(["EINVAL", "EPERM", "EBUSY", "ENOTEMPTY", "EACCES", "EMFILE", "ENFILE"]);
     let lastErr;
     for (let attempt = 0; attempt < 4; attempt++) {
@@ -58900,7 +58940,7 @@ var ProviderStreamAdapter = class {
     const beforeCount = this.messageCount(before);
     const beforeSignature = this.lastMessageSignature(before);
     for (let attempt = 0; attempt < 12; attempt += 1) {
-      await new Promise((resolve24) => setTimeout(resolve24, 250));
+      await new Promise((resolve25) => setTimeout(resolve25, 250));
       let state;
       try {
         state = await this.readChat(evaluate);
@@ -58922,7 +58962,7 @@ var ProviderStreamAdapter = class {
     if (this.messageCount(first) > 0 || this.lastMessageSignature(first)) {
       return first;
     }
-    await new Promise((resolve24) => setTimeout(resolve24, 150));
+    await new Promise((resolve25) => setTimeout(resolve25, 150));
     const second = await this.readChat(evaluate);
     return this.messageCount(second) >= this.messageCount(first) ? second : first;
   }
@@ -59073,7 +59113,7 @@ var ProviderStreamAdapter = class {
       if (typeof data.error === "string" && data.error.trim()) return false;
     }
     for (let attempt = 0; attempt < 6; attempt += 1) {
-      await new Promise((resolve24) => setTimeout(resolve24, 250));
+      await new Promise((resolve25) => setTimeout(resolve25, 250));
       const state = await this.readChat(evaluate);
       const title = this.getStateTitle(state);
       if (this.titlesMatch(title, sessionId)) return true;
@@ -60065,13 +60105,13 @@ var VersionArchive = class {
   }
 };
 async function runCommand(cmd, timeout = 1e4) {
-  return new Promise((resolve24) => {
+  return new Promise((resolve25) => {
     (0, import_child_process10.exec)(cmd, {
       encoding: "utf-8",
       timeout
     }, (error, stdout) => {
-      if (error) return resolve24(null);
-      resolve24(stdout.trim());
+      if (error) return resolve25(null);
+      resolve25(stdout.trim());
     });
   });
 }
@@ -61771,7 +61811,7 @@ function getCliTargetBundle(ctx, type, instanceId) {
   return { target, instance, adapter };
 }
 function sleep2(ms) {
-  return new Promise((resolve24) => setTimeout(resolve24, ms));
+  return new Promise((resolve25) => setTimeout(resolve25, ms));
 }
 async function waitForCliReady(ctx, type, instanceId, timeoutMs) {
   const startedAt = Date.now();
@@ -62747,8 +62787,8 @@ async function handleAutoImplement(ctx, type, req, res) {
     fs36.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) {
+    const spawn5 = agentProvider?.spawn;
+    if (!spawn5?.command) {
       try {
         fs36.unlinkSync(promptFile);
       } catch {
@@ -62758,22 +62798,22 @@ async function handleAutoImplement(ctx, type, req, res) {
     }
     const agentCategory = agentProvider?.category;
     if (agentCategory === "acp") {
-      sendAutoImplSSE(ctx, { event: "progress", data: { function: "_init", status: "spawning", message: `Spawning ACP agent: ${spawn4.command} ${(spawn4.args || []).join(" ")}` } });
+      sendAutoImplSSE(ctx, { event: "progress", data: { function: "_init", status: "spawning", message: `Spawning ACP agent: ${spawn5.command} ${(spawn5.args || []).join(" ")}` } });
       ctx.autoImplStatus.running = true;
       ctx.autoImplStatus.type = type;
       const { ClientSideConnection: ClientSideConnection2, ndJsonStream: ndJsonStream2, PROTOCOL_VERSION: PROTOCOL_VERSION2 } = await import("@agentclientprotocol/sdk");
       const { Readable: Readable2, Writable: Writable2 } = await import("stream");
       const { spawn: spawnFn2 } = await import("child_process");
-      const acpArgs = [...spawn4.args || []];
+      const acpArgs = [...spawn5.args || []];
       if (model) {
         acpArgs.push("--model", model);
         ctx.log(`Auto-implement ACP using model: ${model}`);
       }
-      const child2 = spawnFn2(spawn4.command, acpArgs, {
+      const child2 = spawnFn2(spawn5.command, acpArgs, {
         cwd: providerDir,
         stdio: ["pipe", "pipe", "pipe"],
-        shell: spawn4.shell ?? false,
-        env: { ...process.env, ...spawn4.env || {} }
+        shell: spawn5.shell ?? false,
+        env: { ...process.env, ...spawn5.env || {} }
       });
       ctx.autoImplProcess = child2;
       child2.stderr?.on("data", (d) => {
@@ -62883,7 +62923,7 @@ async function handleAutoImplement(ctx, type, req, res) {
       ctx.json(res, 202, {
         started: true,
         type,
-        agent: spawn4.command,
+        agent: spawn5.command,
         functions,
         providerDir,
         message: "ACP Auto-implement started. Connect to SSE for progress.",
@@ -62891,10 +62931,10 @@ async function handleAutoImplement(ctx, type, req, res) {
       });
       return;
     }
-    const command = spawn4.command;
-    const autoImpl = spawn4.autoImpl;
+    const command = spawn5.command;
+    const autoImpl = spawn5.autoImpl;
     const interactiveFlags = ["--yolo", "--interactive", "-i"];
-    const baseArgs = [...spawn4.args || []].filter((a) => !interactiveFlags.includes(a));
+    const baseArgs = [...spawn5.args || []].filter((a) => !interactiveFlags.includes(a));
     let shellCmd;
     const isWin = os29.platform() === "win32";
     const escapeArg = (a) => isWin ? `"${a.replace(/"/g, '""')}"` : `'${a.replace(/'/g, "'\\''")}'`;
@@ -62941,7 +62981,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         cols: import_session_host_core8.DEFAULT_SESSION_HOST_COLS,
         rows: import_session_host_core8.DEFAULT_SESSION_HOST_ROWS,
         cwd: providerDir,
-        env: { ...process.env, ...spawn4.env || {} }
+        env: { ...process.env, ...spawn5.env || {} }
       });
       isPty = true;
     } catch (err) {
@@ -62953,7 +62993,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         stdio: ["pipe", "pipe", "pipe"],
         env: {
           ...process.env,
-          ...spawn4.env || {}
+          ...spawn5.env || {}
         }
       });
       child.on("error", (err2) => {
@@ -63995,8 +64035,8 @@ var DevServer = class _DevServer {
   }
   getEndpointList() {
     return this.routes.map((r) => {
-      const path43 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
-      return `${r.method.padEnd(5)} ${path43}`;
+      const path44 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
+      return `${r.method.padEnd(5)} ${path44}`;
     });
   }
   async start(port = DEV_SERVER_PORT) {
@@ -64027,15 +64067,15 @@ var DevServer = class _DevServer {
         this.json(res, 500, { error: e.message });
       }
     });
-    return new Promise((resolve24, reject) => {
+    return new Promise((resolve25, reject) => {
       this.server.listen(port, "127.0.0.1", () => {
         this.log(`Dev server listening on http://127.0.0.1:${port}`);
-        resolve24();
+        resolve25();
       });
       this.server.on("error", (e) => {
         if (e.code === "EADDRINUSE") {
           this.log(`Port ${port} in use, skipping dev server`);
-          resolve24();
+          resolve25();
         } else {
           reject(e);
         }
@@ -64096,16 +64136,16 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: `Provider not found: ${type}` });
       return;
     }
-    const spawn4 = provider.spawn;
-    if (!spawn4) {
+    const spawn5 = provider.spawn;
+    if (!spawn5) {
       this.json(res, 400, { error: `Provider ${type} has no spawn config` });
       return;
     }
     const { spawn: spawnFn } = await import("child_process");
     const start = Date.now();
     try {
-      const child = spawnFn(spawn4.command, [...spawn4.args || []], {
-        shell: spawn4.shell ?? false,
+      const child = spawnFn(spawn5.command, [...spawn5.args || []], {
+        shell: spawn5.shell ?? false,
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
       });
@@ -64117,27 +64157,27 @@ var DevServer = class _DevServer {
       child.stderr?.on("data", (d) => {
         stderr += d.toString().slice(0, 2e3);
       });
-      await new Promise((resolve24) => {
+      await new Promise((resolve25) => {
         const timer = setTimeout(() => {
           child.kill();
-          resolve24();
+          resolve25();
         }, 3e3);
         child.on("exit", () => {
           clearTimeout(timer);
-          resolve24();
+          resolve25();
         });
         child.stdout?.once("data", () => {
           setTimeout(() => {
             child.kill();
             clearTimeout(timer);
-            resolve24();
+            resolve25();
           }, 500);
         });
       });
       const elapsed = Date.now() - start;
       this.json(res, 200, {
         success: true,
-        command: `${spawn4.command} ${(spawn4.args || []).join(" ")}`,
+        command: `${spawn5.command} ${(spawn5.args || []).join(" ")}`,
         elapsed,
         stdout: stdout.trim(),
         stderr: stderr.trim(),
@@ -64147,7 +64187,7 @@ var DevServer = class _DevServer {
       const elapsed = Date.now() - start;
       this.json(res, 200, {
         success: false,
-        command: `${spawn4.command} ${(spawn4.args || []).join(" ")}`,
+        command: `${spawn5.command} ${(spawn5.args || []).join(" ")}`,
         elapsed,
         error: e.message
       });
@@ -64610,20 +64650,20 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: `Provider not found: ${type}` });
       return;
     }
-    const spawn4 = provider.spawn;
-    if (!spawn4) {
+    const spawn5 = provider.spawn;
+    if (!spawn5) {
       this.json(res, 400, { error: `Provider ${type} has no spawn config` });
       return;
     }
     const { spawn: spawnFn } = await import("child_process");
     const start = Date.now();
     try {
-      const args = [...spawn4.args || [], message];
-      const child = spawnFn(spawn4.command, args, {
-        shell: spawn4.shell ?? false,
+      const args = [...spawn5.args || [], message];
+      const child = spawnFn(spawn5.command, args, {
+        shell: spawn5.shell ?? false,
         timeout,
         stdio: ["pipe", "pipe", "pipe"],
-        env: { ...process.env, ...spawn4.env || {} }
+        env: { ...process.env, ...spawn5.env || {} }
       });
       let stdout = "";
       let stderr = "";
@@ -64633,14 +64673,14 @@ var DevServer = class _DevServer {
       child.stderr?.on("data", (d) => {
         stderr += d.toString();
       });
-      await new Promise((resolve24) => {
+      await new Promise((resolve25) => {
         const timer = setTimeout(() => {
           child.kill();
-          resolve24();
+          resolve25();
         }, timeout);
         child.on("exit", () => {
           clearTimeout(timer);
-          resolve24();
+          resolve25();
         });
       });
       const elapsed = Date.now() - start;
@@ -64839,14 +64879,14 @@ data: ${JSON.stringify(msg.data)}
     res.end(JSON.stringify(data, null, 2));
   }
   async readBody(req) {
-    return new Promise((resolve24) => {
+    return new Promise((resolve25) => {
       let body = "";
       req.on("data", (chunk) => body += chunk);
       req.on("end", () => {
         try {
-          resolve24(JSON.parse(body));
+          resolve25(JSON.parse(body));
         } catch {
-          resolve24({});
+          resolve25({});
         }
       });
     });
@@ -65581,7 +65621,7 @@ async function waitForReady(endpoint, timeoutMs = STARTUP_TIMEOUT_MS, requiredRe
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     if (await canConnect(endpoint, requiredRequestTypes)) return;
-    await new Promise((resolve24) => setTimeout(resolve24, STARTUP_POLL_MS));
+    await new Promise((resolve25) => setTimeout(resolve25, STARTUP_POLL_MS));
   }
   throw new Error(`Session host did not become ready within ${timeoutMs}ms`);
 }
@@ -65622,6 +65662,148 @@ async function listHostedCliRuntimes(endpoint) {
   }
 }
 
+// src/session-host/managed-host.ts
+var import_child_process11 = require("child_process");
+var fs38 = __toESM(require("fs"));
+var os30 = __toESM(require("os"));
+var path43 = __toESM(require("path"));
+var import_session_host_core12 = require("@adhdev/session-host-core");
+init_runtime_defaults();
+function createManagedSessionHost(options) {
+  const appName = options.appName;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_SESSION_HOST_READY_TIMEOUT_MS;
+  const endpoint = (0, import_session_host_core12.getDefaultSessionHostEndpoint)(appName);
+  const isManagedPid = options.isManagedPid ?? (() => true);
+  function buildEnv(baseEnv) {
+    const env = (0, import_session_host_core12.sanitizeSpawnEnv)(baseEnv);
+    env.ADHDEV_SESSION_HOST_NAME = appName;
+    return env;
+  }
+  function resolveEntry() {
+    const packagedCandidates = [
+      path43.resolve(__dirname, "../vendor/session-host-daemon/index.js"),
+      path43.resolve(__dirname, "../../vendor/session-host-daemon/index.js")
+    ];
+    for (const candidate of packagedCandidates) {
+      if (fs38.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+    return require.resolve("@adhdev/session-host-daemon");
+  }
+  function getPidFile() {
+    return path43.join(os30.homedir(), ".adhdev", `${appName}-session-host.pid`);
+  }
+  function getPid() {
+    try {
+      const pidFile = getPidFile();
+      if (!fs38.existsSync(pidFile)) return null;
+      const pid = Number.parseInt(fs38.readFileSync(pidFile, "utf8").trim(), 10);
+      return Number.isFinite(pid) ? pid : null;
+    } catch {
+      return null;
+    }
+  }
+  function killPid2(pid) {
+    try {
+      if (process.platform === "win32") {
+        const spawnOpts = { stdio: "ignore" };
+        if (options.killWindowsHide) spawnOpts.windowsHide = true;
+        (0, import_child_process11.execFileSync)("taskkill", ["/PID", String(pid), "/T", "/F"], spawnOpts);
+      } else {
+        process.kill(pid, "SIGTERM");
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  function spawnHost() {
+    const entry = resolveEntry();
+    let stdio = "ignore";
+    let logFd = null;
+    if (options.spawnStdio === "logfile") {
+      const logDir = path43.join(os30.homedir(), ".adhdev", "logs");
+      fs38.mkdirSync(logDir, { recursive: true });
+      logFd = fs38.openSync(path43.join(logDir, "session-host.log"), "a");
+      stdio = ["ignore", logFd, logFd];
+    }
+    const child = (0, import_child_process11.spawn)(process.execPath, [entry], {
+      detached: true,
+      stdio,
+      windowsHide: true,
+      env: buildEnv(process.env)
+    });
+    child.unref();
+    if (logFd !== null) {
+      try {
+        fs38.closeSync(logFd);
+      } catch {
+      }
+    }
+  }
+  function stopManagedSessionHostProcess() {
+    let stopped = false;
+    const pidFile = getPidFile();
+    try {
+      if (fs38.existsSync(pidFile)) {
+        const pid = Number.parseInt(fs38.readFileSync(pidFile, "utf8").trim(), 10);
+        if (Number.isFinite(pid) && pid !== process.pid && isManagedPid(pid)) {
+          stopped = killPid2(pid) || stopped;
+        }
+      }
+    } catch {
+    } finally {
+      try {
+        fs38.unlinkSync(pidFile);
+      } catch {
+      }
+    }
+    if (options.extraStop) {
+      stopped = options.extraStop(endpoint) || stopped;
+    }
+    return stopped;
+  }
+  async function ensureReady() {
+    options.beforeEnsureReady?.();
+    try {
+      return await ensureSessionHostReady({
+        appName,
+        spawnHost,
+        timeoutMs,
+        requiredRequestTypes: options.requiredRequestTypes
+      });
+    } catch (error) {
+      stopManagedSessionHostProcess();
+      return ensureSessionHostReady({
+        appName,
+        spawnHost,
+        timeoutMs,
+        requiredRequestTypes: options.requiredRequestTypes
+      }).catch((retryError) => {
+        const initialMessage = error instanceof Error ? error.message : String(error);
+        const retryMessage = retryError instanceof Error ? retryError.message : String(retryError);
+        throw new Error(`Session host failed to start after retry (${initialMessage}; retry: ${retryMessage})`);
+      });
+    }
+  }
+  return {
+    appName,
+    endpoint,
+    getPidFile,
+    getPid,
+    buildEnv,
+    resolveEntry,
+    killPid: killPid2,
+    spawnHost,
+    stopManagedSessionHostProcess,
+    ensureReady,
+    getStatusPaths() {
+      return { pidFile: getPidFile(), endpoint };
+    }
+  };
+}
+
 // src/session-host/startup-restore-policy.js
 function shouldAutoRestoreHostedSessionsOnStartup(env = process.env) {
   const raw = typeof env.ADHDEV_RESTORE_HOSTED_SESSIONS_ON_STARTUP === "string" ? env.ADHDEV_RESTORE_HOSTED_SESSIONS_ON_STARTUP.trim().toLowerCase() : "";
@@ -65631,7 +65813,7 @@ function shouldAutoRestoreHostedSessionsOnStartup(env = process.env) {
 }
 
 // src/installer.ts
-var import_child_process11 = require("child_process");
+var import_child_process12 = require("child_process");
 var import_util3 = require("util");
 var EXTENSION_CATALOG = [
   // AI Agent extensions
@@ -65719,7 +65901,7 @@ var EXTENSION_CATALOG = [
     apiKeyName: "OpenAI/Anthropic API key"
   }
 ];
-var execAsync4 = (0, import_util3.promisify)(import_child_process11.exec);
+var execAsync4 = (0, import_util3.promisify)(import_child_process12.exec);
 async function isExtensionInstalled(ide, marketplaceId) {
   if (!ide.cliCommand) return false;
   try {
@@ -65759,12 +65941,12 @@ async function installExtension(ide, extension) {
       const res = await fetch(extension.vsixUrl);
       if (res.ok) {
         const buffer = Buffer.from(await res.arrayBuffer());
-        const fs38 = await import("fs");
-        fs38.writeFileSync(vsixPath, buffer);
-        return new Promise((resolve24) => {
+        const fs39 = await import("fs");
+        fs39.writeFileSync(vsixPath, buffer);
+        return new Promise((resolve25) => {
           const cmd = `"${ide.cliCommand}" --install-extension "${vsixPath}" --force`;
-          (0, import_child_process11.exec)(cmd, { timeout: 6e4 }, (error, _stdout, stderr) => {
-            resolve24({
+          (0, import_child_process12.exec)(cmd, { timeout: 6e4 }, (error, _stdout, stderr) => {
+            resolve25({
               extensionId: extension.id,
               marketplaceId: extension.marketplaceId,
               success: !error,
@@ -65777,11 +65959,11 @@ async function installExtension(ide, extension) {
     } catch (e) {
     }
   }
-  return new Promise((resolve24) => {
+  return new Promise((resolve25) => {
     const cmd = `"${ide.cliCommand}" --install-extension ${extension.marketplaceId} --force`;
-    (0, import_child_process11.exec)(cmd, { timeout: 6e4 }, (error, stdout, stderr) => {
+    (0, import_child_process12.exec)(cmd, { timeout: 6e4 }, (error, stdout, stderr) => {
       if (error) {
-        resolve24({
+        resolve25({
           extensionId: extension.id,
           marketplaceId: extension.marketplaceId,
           success: false,
@@ -65789,7 +65971,7 @@ async function installExtension(ide, extension) {
           error: stderr || error.message
         });
       } else {
-        resolve24({
+        resolve25({
           extensionId: extension.id,
           marketplaceId: extension.marketplaceId,
           success: true,
@@ -65816,7 +65998,7 @@ function launchIDE(ide, workspacePath) {
   if (!ide.cliCommand) return false;
   try {
     const args = workspacePath ? `"${workspacePath}"` : "";
-    (0, import_child_process11.exec)(`"${ide.cliCommand}" ${args}`, { timeout: 1e4 });
+    (0, import_child_process12.exec)(`"${ide.cliCommand}" ${args}`, { timeout: 1e4 });
     return true;
   } catch {
     return false;
@@ -66278,7 +66460,7 @@ async function startLocalIpcServer(opts) {
       }));
     }
   }
-  await new Promise((resolve24, reject) => {
+  await new Promise((resolve25, reject) => {
     const onError = (error) => {
       httpServer?.off("listening", onListening);
       reject(error);
@@ -66286,7 +66468,7 @@ async function startLocalIpcServer(opts) {
     const onListening = () => {
       httpServer?.off("error", onError);
       listening = true;
-      resolve24();
+      resolve25();
     };
     httpServer.once("error", onError);
     httpServer.once("listening", onListening);
@@ -66313,12 +66495,12 @@ async function startLocalIpcServer(opts) {
         }
       }
       clients.clear();
-      await new Promise((resolve24) => {
+      await new Promise((resolve25) => {
         if (!httpServer) {
-          resolve24();
+          resolve25();
           return;
         }
-        httpServer.close(() => resolve24());
+        httpServer.close(() => resolve25());
       });
       httpServer = null;
       wss = null;
@@ -66570,6 +66752,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   createGitSnapshotStore,
   createGitWorkspaceMonitor,
   createInteractionId,
+  createManagedSessionHost,
   createMesh,
   createNativeHistoryDispatcher,
   createSessionDelivery,