@adhdev/daemon-core 0.9.82-rc.315 → 0.9.82-rc.317

package/dist/index.mjs

@@ -35,6 +35,35 @@ function resolveNodeSchedulingPriority(nodePolicy) {
   const raw = Number(nodePolicy?.schedulingPriority);
   return Number.isFinite(raw) ? raw : 0;
 }
+function resolveTaskAffinityRole(taskMode, policy) {
+  if (!taskMode) return null;
+  if (policy?.enabled === false) return null;
+  const override = policy?.byTaskMode && Object.prototype.hasOwnProperty.call(policy.byTaskMode, taskMode) ? policy.byTaskMode[taskMode] : void 0;
+  if (typeof override === "string") {
+    const trimmed = override.trim().toLowerCase();
+    return trimmed ? trimmed : null;
+  }
+  const fallback = DEFAULT_TASKMODE_ROLE_MAP[taskMode];
+  return fallback ?? null;
+}
+function resolveMeshRoleOptions(policy) {
+  const out = [...STANDARD_MESH_ROLES];
+  const seen = new Set(out);
+  const add = (raw) => {
+    if (typeof raw !== "string") return;
+    const role = raw.trim().toLowerCase();
+    if (!role || seen.has(role)) return;
+    seen.add(role);
+    out.push(role);
+  };
+  if (policy?.byTaskMode) {
+    for (const value of Object.values(policy.byTaskMode)) add(value);
+  }
+  if (Array.isArray(policy?.customRoles)) {
+    for (const value of policy.customRoles) add(value);
+  }
+  return out;
+}
 function resolveAutoConvergeCodeChange(policy) {
   return policy?.autoConvergeCodeChange === true;
 }
@@ -65,7 +94,7 @@ function resolveProviderMaxParallel(nodePolicy, providerType) {
   if (!Number.isFinite(raw) || raw < 0) return void 0;
   return Math.floor(raw);
 }
-var MESH_SCHEDULING_STRATEGIES, DEFAULT_MESH_SCHEDULING_STRATEGY, MESH_CONVERGE_REFINE_TAG, MESH_CONVERGE_FAST_FORWARD_TAG, DEFAULT_MESH_POLICY;
+var MESH_SCHEDULING_STRATEGIES, DEFAULT_MESH_SCHEDULING_STRATEGY, MESH_CONVERGE_REFINE_TAG, MESH_CONVERGE_FAST_FORWARD_TAG, STANDARD_MESH_ROLES, DEFAULT_TASKMODE_ROLE_MAP, DEFAULT_MESH_POLICY;
 var init_repo_mesh_types = __esm({
   "src/repo-mesh-types.ts"() {
     "use strict";
@@ -78,6 +107,14 @@ var init_repo_mesh_types = __esm({
     DEFAULT_MESH_SCHEDULING_STRATEGY = "first_eligible";
     MESH_CONVERGE_REFINE_TAG = "converge=refine";
     MESH_CONVERGE_FAST_FORWARD_TAG = "converge=fast_forward";
+    STANDARD_MESH_ROLES = ["investigator", "coder", "validator", "converger"];
+    DEFAULT_TASKMODE_ROLE_MAP = {
+      live_debug_readonly: "investigator",
+      code_change: "coder",
+      launch_app: "coder",
+      validation: "validator",
+      convergence: "converger"
+    };
     DEFAULT_MESH_POLICY = {
       requirePreTaskCheckpoint: false,
       requirePostTaskCheckpoint: true,
@@ -311,10 +348,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "e28347641639c9d0a1e46a6141e3cfed2bc90ac2" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "e2834764" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.315" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-18T05:47:44.462Z" : void 0);
+  const commit = readInjected(true ? "b4484284652748bf8096f40a00eb5cb463963576" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "b4484284" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.317" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-18T08:55:18.955Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -640,14 +677,79 @@ function emptyStatus(workspace, lastCheckedAt, error) {
 async function getSubmoduleStatuses(repo, options) {
   if (!repo.repoRoot) return [];
   try {
-    const result = await runGit(repo, ["submodule", "status"], options);
-    const submodules = parseSubmoduleStatusOutput(result.stdout, repo.repoRoot, options.submoduleIgnorePaths);
+    const submodules = await deriveSubmoduleGitlinkStatuses(repo, options);
     await Promise.all(submodules.map((submodule) => enrichSubmoduleWorktreeStatus(repo, submodule, options)));
     return submodules;
   } catch {
     return [];
   }
 }
+async function deriveSubmoduleGitlinkStatuses(repo, options) {
+  if (!repo.repoRoot) return [];
+  const paths = await readSubmodulePaths(repo, options);
+  const ignoreSet = new Set(options.submoduleIgnorePaths || []);
+  const lastCheckedAt = Date.now();
+  const entries = await Promise.all(
+    paths.filter((path41) => !ignoreSet.has(path41)).map(async (path41) => {
+      const repoPath = repo.repoRoot + "/" + path41;
+      const expected = await readGitlinkExpectedSha(repo, path41, options);
+      const actual = await readSubmoduleHeadSha(repo, repoPath, options);
+      const outOfSync = actual === null ? true : expected !== null && expected !== actual;
+      return {
+        path: path41,
+        // 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 ?? "",
+        repoPath,
+        dirty: false,
+        outOfSync,
+        lastCheckedAt
+      };
+    })
+  );
+  return entries;
+}
+async function readSubmodulePaths(repo, options) {
+  if (!repo.repoRoot) return [];
+  const gitmodulesPath = repo.repoRoot + "/.gitmodules";
+  try {
+    const result = await runGit(
+      repo,
+      ["config", "--file", gitmodulesPath, "--get-regexp", "^submodule\\..*\\.path$"],
+      options
+    );
+    const paths = [];
+    for (const line of result.stdout.split("\n")) {
+      const spaceIdx = line.indexOf(" ");
+      if (spaceIdx < 0) continue;
+      const value = line.slice(spaceIdx + 1).trim();
+      if (value) paths.push(value);
+    }
+    return paths;
+  } catch {
+    return [];
+  }
+}
+async function readGitlinkExpectedSha(repo, submodulePath, options) {
+  try {
+    const result = await runGit(repo, ["ls-tree", "HEAD", submodulePath], options);
+    const line = result.stdout.split("\n").find((l) => l.trim().length > 0);
+    if (!line) return null;
+    const match = line.match(/^\s*\d+\s+commit\s+([0-9a-f]{40})\b/);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+async function readSubmoduleHeadSha(repo, repoPath, options) {
+  try {
+    const result = await runGit(repo, ["rev-parse", "HEAD"], { ...options, cwd: repoPath });
+    const sha = result.stdout.trim();
+    return /^[0-9a-f]{40}$/.test(sha) ? sha : null;
+  } catch {
+    return null;
+  }
+}
 async function enrichSubmoduleWorktreeStatus(repo, submodule, options) {
   try {
     const result = await runGit(repo, ["status", "--porcelain=v2", "--branch"], {
@@ -662,28 +764,6 @@ async function enrichSubmoduleWorktreeStatus(repo, submodule, options) {
     submodule.error = formatGitError(error);
   }
 }
-function parseSubmoduleStatusOutput(output, repoRoot, ignorePaths) {
-  const submodules = [];
-  const ignoreSet = new Set(ignorePaths || []);
-  for (const line of output.split("\n")) {
-    if (!line.trim()) continue;
-    const match = line.match(/^([\-+U\s])([0-9a-f]{40})\s+(\S+)(?:\s+\(([^)]+)\))?/);
-    if (!match) continue;
-    const prefix = match[1];
-    const commit = match[2];
-    const path41 = match[3];
-    if (ignoreSet.has(path41)) continue;
-    submodules.push({
-      path: path41,
-      commit,
-      repoPath: repoRoot + "/" + path41,
-      dirty: prefix === "U",
-      outOfSync: prefix === "-" || prefix === "+",
-      lastCheckedAt: Date.now()
-    });
-  }
-  return submodules;
-}
 var lastKnownGoodStatus, DAEMON_RUNTIME_PACKAGES, WEB_ONLY_PACKAGES;
 var init_git_status = __esm({
   "src/git/git-status.ts"() {
@@ -1575,8 +1655,61 @@ function mergeMeshPolicy(base, patch) {
   } else {
     delete policy.autoConvergeCodeChange;
   }
+  const normalizedAffinity = normalizeTaskAffinityPolicy(policy.taskAffinity);
+  if (normalizedAffinity) {
+    policy.taskAffinity = normalizedAffinity;
+  } else {
+    delete policy.taskAffinity;
+  }
   return policy;
 }
+function normalizeTaskAffinityPolicy(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const record = value;
+  const out = {};
+  let hasContent = false;
+  if (typeof record.enabled === "boolean") {
+    out.enabled = record.enabled;
+    if (record.enabled === false) hasContent = true;
+    else delete out.enabled;
+  }
+  if (record.byTaskMode && typeof record.byTaskMode === "object" && !Array.isArray(record.byTaskMode)) {
+    const byTaskMode = {};
+    for (const [mode, raw] of Object.entries(record.byTaskMode)) {
+      const modeKey = mode.trim();
+      if (!modeKey) continue;
+      if (typeof raw !== "string") continue;
+      const role = raw.trim().toLowerCase();
+      byTaskMode[modeKey] = role;
+      if (role && !STANDARD_MESH_ROLES.includes(role)) {
+        try {
+          console.warn(`[mesh] task_affinity.byTaskMode.${modeKey}: custom role "${role}" is not a standard mesh role (${STANDARD_MESH_ROLES.join("/")}); routing still applies`);
+        } catch {
+        }
+      }
+    }
+    if (Object.keys(byTaskMode).length > 0) {
+      out.byTaskMode = byTaskMode;
+      hasContent = true;
+    }
+  }
+  if (Array.isArray(record.customRoles)) {
+    const seen = /* @__PURE__ */ new Set();
+    const customRoles = [];
+    for (const raw of record.customRoles) {
+      if (typeof raw !== "string") continue;
+      const role = raw.trim().toLowerCase();
+      if (!role || seen.has(role)) continue;
+      seen.add(role);
+      customRoles.push(role);
+    }
+    if (customRoles.length > 0) {
+      out.customRoles = customRoles;
+      hasContent = true;
+    }
+  }
+  return hasContent ? out : void 0;
+}
 function normalizeAutoFastForwardPolicy(value) {
   const record = value && typeof value === "object" && !Array.isArray(value) ? value : {};
   const maxBehind = Number(record.maxBehind);
@@ -2867,6 +3000,7 @@ __export(mesh_work_queue_exports, {
   recordTaskAutoLaunch: () => recordTaskAutoLaunch,
   requeueTask: () => requeueTask,
   resolveConvergeRequiredTags: () => resolveConvergeRequiredTags,
+  resolveTaskAffinityRequiredTags: () => resolveTaskAffinityRequiredTags,
   updateDirectDispatchStatus: () => updateDirectDispatchStatus,
   updateSessionTaskStatus: () => updateSessionTaskStatus,
   updateTaskStatus: () => updateTaskStatus,
@@ -3006,6 +3140,31 @@ function resolveConvergeRequiredTags(meshId, taskMode, explicitRequiredTags, opt
   if (!optedIn) return explicitRequiredTags;
   return normalizeMeshCapabilityTags([...explicitRequiredTags, MESH_CONVERGE_REFINE_TAG]);
 }
+function meshHasNodeAdvertisingRole(nodes, role) {
+  if (!Array.isArray(nodes) || nodes.length === 0) return false;
+  const wanted = `role=${role}`;
+  return nodes.some((node) => buildMeshNodeCapabilityTags(node).includes(wanted));
+}
+function resolveTaskAffinityRequiredTags(meshId, taskMode, explicitRequiredTags, opts) {
+  if (typeof opts?.targetNodeId === "string" && opts.targetNodeId.trim()) return explicitRequiredTags;
+  if (opts?.callerSpecifiedRequiredTags === true) return explicitRequiredTags;
+  let mesh;
+  try {
+    mesh = getMesh(meshId);
+  } catch {
+    return explicitRequiredTags;
+  }
+  const role = resolveTaskAffinityRole(taskMode, mesh?.policy?.taskAffinity);
+  if (!role) return explicitRequiredTags;
+  if (!meshHasNodeAdvertisingRole(mesh?.nodes, role)) {
+    try {
+      console.warn(`[mesh] task_affinity: no node advertises role=${role} for taskMode=${taskMode} in mesh ${meshId}; skipping injection (least_loaded fallback)`);
+    } catch {
+    }
+    return explicitRequiredTags;
+  }
+  return normalizeMeshCapabilityTags([...explicitRequiredTags, `role=${role}`]);
+}
 function withQueueLock(_meshId, fn) {
   return MeshRuntimeStore.getInstance().transaction(fn);
 }
@@ -3056,6 +3215,20 @@ function enqueueTask(meshId, message, opts) {
       throw new Error(`duplicate_task_id: task '${id}' already exists in mesh '${meshId}'`);
     }
     assertNoDependencyCycle(meshId, id, dependsOn);
+    const callerTags = normalizeMeshCapabilityTags(opts?.requiredTags);
+    const callerSpecifiedRequiredTags = callerTags.length > 0;
+    let resolvedRequiredTags = resolveConvergeRequiredTags(
+      meshId,
+      modeValidation.taskMode,
+      callerTags,
+      { targetNodeId: opts?.targetNodeId }
+    );
+    resolvedRequiredTags = resolveTaskAffinityRequiredTags(
+      meshId,
+      modeValidation.taskMode,
+      resolvedRequiredTags,
+      { targetNodeId: opts?.targetNodeId, callerSpecifiedRequiredTags }
+    );
     const entry = {
       id,
       meshId,
@@ -3064,15 +3237,7 @@ function enqueueTask(meshId, message, opts) {
       taskMode: modeValidation.taskMode,
       targetNodeId: opts?.targetNodeId,
       targetSessionId: opts?.targetSessionId,
-      // Convergence routing (opt-in): auto-inject converge=refine for code_change
-      // tasks so they hard-filter onto refine-capable worktree nodes. No-op unless
-      // the mesh opts in; explicit target_node_id / required_tags are preserved.
-      requiredTags: resolveConvergeRequiredTags(
-        meshId,
-        modeValidation.taskMode,
-        normalizeMeshCapabilityTags(opts?.requiredTags),
-        { targetNodeId: opts?.targetNodeId }
-      ),
+      requiredTags: resolvedRequiredTags,
       ...dependsOn.length > 0 ? { dependsOn } : {},
       ...typeof opts?.missionId === "string" && opts.missionId.trim() ? { missionId: opts.missionId.trim() } : {},
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -3827,6 +3992,18 @@ var init_mesh_runtime_store = __esm({
         `).get(meshId, nodeId);
         return row?.count ?? 0;
       }
+      /**
+       * O(1) count of queue tasks in 'pending' status for a mesh. A COUNT(*) over the
+       * indexed status column, so it avoids JSON.parse-ing every queue row — used as a
+       * cheap guard before the reconcile loop runs a full triggerMeshQueue scan.
+       */
+      pendingQueueTaskCount(meshId) {
+        const row = this.db.prepare(`
+            SELECT COUNT(*) as count FROM mesh_queue
+            WHERE mesh_id = ? AND status = 'pending'
+        `).get(meshId);
+        return row?.count ?? 0;
+      }
       /**
        * Read the current per-mesh round-robin cursor (0 when unset). Used to rotate
        * the tie-break winner among nodes tied at the least load.
@@ -8760,7 +8937,7 @@ async function triggerMeshQueue(components, meshId) {
   }
   const remoteCandidates = [];
   for (const idle of remoteSessions) {
-    const node = mesh.nodes.find((n) => n.id === idle.nodeId);
+    const node = mesh.nodes.find((n) => meshNodeIdMatches(n, idle.nodeId));
     if (node) {
       remoteIdleSessionsChecked += 1;
       remoteCandidates.push({ nodeId: idle.nodeId, sessionId: idle.sessionId, providerType: idle.providerType, origin: "remote", node });
@@ -9563,6 +9740,21 @@ async function runMeshReconcileTick(components) {
       }
     }
   }
+  for (const mesh of listMeshes()) {
+    const selfIds = resolveCoordinatorSelfIds(mesh, drainDaemonIds);
+    if (!daemonHostsMesh(mesh, selfIds)) continue;
+    if (store) {
+      try {
+        if (store.pendingQueueTaskCount(mesh.id) === 0) continue;
+      } catch {
+      }
+    }
+    try {
+      await triggerMeshQueue(components, mesh.id);
+    } catch (e) {
+      LOG.warn("MeshReconcile", `Pending-claim recovery trigger failed for mesh ${mesh.id}: ${e?.message || e}`);
+    }
+  }
   const coordinators = findLiveCoordinators(components);
   if (coordinators.length === 0) {
     return;
@@ -10959,8 +11151,24 @@ function findBinary(name) {
   }
   const isWin = os12.platform() === "win32";
   const paths = (process.env.PATH || "").split(path17.delimiter);
+  const extraDirs = [];
+  if (isWin) {
+    if (process.env.APPDATA) extraDirs.push(path17.join(process.env.APPDATA, "npm"));
+    try {
+      extraDirs.push(path17.dirname(process.execPath));
+    } catch {
+    }
+  } else {
+    extraDirs.push(path17.join(os12.homedir(), ".npm-global", "bin"));
+    extraDirs.push("/usr/local/bin", "/opt/homebrew/bin");
+    try {
+      extraDirs.push(path17.dirname(process.execPath));
+    } catch {
+    }
+  }
+  const searchDirs = [...paths, ...extraDirs];
   const exes = isWin ? [".exe", ".cmd", ".bat", ""] : [""];
-  for (const p of paths) {
+  for (const p of searchDirs) {
     if (!p) continue;
     for (const ext of exes) {
       const fullPath = path17.join(p, trimmed + ext);
@@ -14357,6 +14565,37 @@ ${lastSnapshot}`;
         if (!this.ptyProcess || typeof this.ptyProcess.getMetadata !== "function") return null;
         return this.ptyProcess.getMetadata();
       }
+      /**
+       * Launch metadata for the dashboard Session info panel. Re-derives the spawn plan
+       * (pure — same inputs the live PTY was spawned with) so the dashboard sees the
+       * resolved binary, full arg vector, and cwd without us having to persist it.
+       * extraEnv values are intentionally dropped (keys only) so secrets passed at
+       * launch time never reach the dashboard.
+       */
+      getLaunchInfo() {
+        let command;
+        let args = [...this.extraArgs];
+        try {
+          const plan = resolveCliSpawnPlan({
+            provider: this.provider,
+            runtimeSettings: this.runtimeSettings,
+            workingDir: this.workingDir,
+            extraArgs: this.extraArgs,
+            extraEnv: this.extraEnv
+          });
+          command = plan.binaryPath;
+          args = plan.allArgs;
+        } catch {
+        }
+        return {
+          command,
+          args,
+          extraArgs: [...this.extraArgs],
+          cwd: this.workingDir,
+          extraEnvKeys: Object.keys(this.extraEnv || {}),
+          providerSessionId: this.providerSessionId || void 0
+        };
+      }
       updateRuntimeMeta(meta, replace = false) {
         const nextProviderSessionId = typeof meta?.providerSessionId === "string" ? meta.providerSessionId.trim() : "";
         if (nextProviderSessionId) {
@@ -18588,8 +18827,8 @@ async function detectIDEs(providerLoader) {
       if (existsSync16(bundledCli)) resolvedCli = bundledCli;
     }
     if (!resolvedCli && appPath && os30 === "win32") {
-      const { dirname: dirname14 } = await import("path");
-      const appDir = dirname14(appPath);
+      const { dirname: dirname15 } = await import("path");
+      const appDir = dirname15(appPath);
       const candidates = [
         `${appDir}\\\\bin\\\\${def.cli}.cmd`,
         `${appDir}\\\\bin\\\\${def.cli}`,
@@ -41197,7 +41436,7 @@ init_mesh_refine_status();
 
 // src/mesh/mesh-init.ts
 import { existsSync as existsSync35, mkdirSync as mkdirSync15, writeFileSync as writeFileSync17 } from "fs";
-import { dirname as dirname7, join as join37 } from "path";
+import { dirname as dirname8, join as join37 } from "path";
 var MESH_INIT_REFINE_CONFIG_PATH = MESH_REFINE_CONFIG_LOCATIONS[0];
 var MESH_INIT_WORKTREE_BOOTSTRAP_CONFIG_PATH = MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS[0];
 var CANDIDATE_STALE_INPUTS = [
@@ -41212,7 +41451,7 @@ var CANDIDATE_STALE_INPUTS = [
 ];
 function writeConfigFile(workspace, relativePath, config) {
   const target = join37(workspace, relativePath);
-  mkdirSync15(dirname7(target), { recursive: true });
+  mkdirSync15(dirname8(target), { recursive: true });
   writeFileSync17(target, `${JSON.stringify(config, null, 2)}
 `, "utf-8");
   return target;
@@ -42776,7 +43015,15 @@ var MESH_DIRECT_PROBE_MAX_RETRIES = 2;
 function readMeshConnectionState(connection) {
   return readStringValue(connection?.state);
 }
+function isMeshConnectionDefinitivelyDown(connection) {
+  if (!connection) return true;
+  const state = readMeshConnectionState(connection);
+  return state === "failed" || state === "closed" || state === "disconnected";
+}
 async function probeRemoteMeshGitStatusWithRetry(args) {
+  if (args.getConnection && isMeshConnectionDefinitivelyDown(args.getConnection(args.daemonId))) {
+    return null;
+  }
   for (let attempt = 0; attempt <= MESH_DIRECT_PROBE_MAX_RETRIES; attempt += 1) {
     if (attempt > 0) {
       const connection = args.getConnection?.(args.daemonId);
@@ -46757,6 +47004,7 @@ ${hintLines.join("\n")}` : "",
         if (!target && !coord) return { success: false, error: "Session not found", sessionId };
         const adapter = target ? this.deps.cliManager.findAdapter(target.providerType, { instanceKey: sessionId })?.adapter : void 0;
         const runtimeMeta = adapter && typeof adapter.getRuntimeMetadata === "function" ? adapter.getRuntimeMetadata() : void 0;
+        const launchInfo = adapter && typeof adapter.getLaunchInfo === "function" ? adapter.getLaunchInfo() : void 0;
         const providerType = target?.providerType || coord?.cliType || "";
         const providerMetaForSession = providerType ? this.deps.providerLoader.resolve?.(providerType) || this.deps.providerLoader.getMeta(providerType) : void 0;
         return {
@@ -46768,8 +47016,11 @@ ${hintLines.join("\n")}` : "",
             transport: target?.transport,
             workspace: target?.workspace || coord?.workspace,
             spawnedAtMs: target?.spawnedAtMs || coord?.startedAt,
-            providerSessionId: target?.providerSessionId,
-            runtimeMetadata: runtimeMeta
+            // providerSessionId now comes from the live adapter's launch info
+            // (the registry target never carried it — it was always undefined).
+            providerSessionId: launchInfo?.providerSessionId || target?.providerSessionId,
+            runtimeMetadata: runtimeMeta,
+            launch: launchInfo
           },
           coordinator: coord ? {
             meshId: coord.meshId,
@@ -48610,7 +48861,7 @@ ${ptyResult.output.slice(-2e3)}`);
             };
           }
           const { existsSync: existsSync44, readFileSync: readFileSync35, writeFileSync: writeFileSync23, copyFileSync: copyFileSync4, mkdirSync: mkdirSync21 } = await import("fs");
-          const { dirname: dirname14 } = await import("path");
+          const { dirname: dirname15 } = await import("path");
           const mcpConfigPath = coordinatorSetup.configPath;
           const hermesManualFallback = cliType === "hermes-cli" && configFormat === "hermes_config_yaml" ? createHermesManualMeshCoordinatorSetup(meshId, workspace) : null;
           let hermesBaseConfig = null;
@@ -48645,7 +48896,7 @@ ${ptyResult.output.slice(-2e3)}`);
             };
           }
           try {
-            mkdirSync21(dirname14(mcpConfigPath), { recursive: true });
+            mkdirSync21(dirname15(mcpConfigPath), { recursive: true });
           } catch (error) {
             const message = `Could not prepare MCP config path for automatic setup: ${error?.message || error}`;
             LOG.error("MeshCoordinator", message);
@@ -48655,7 +48906,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const hadExistingMcpConfig = existsSync44(mcpConfigPath);
           let existingMcpConfig = hermesBaseConfig?.config || {};
           if (hermesBaseConfig) {
-            copyHermesCoordinatorCredentialFiles(hermesBaseConfig.sourceHome, dirname14(mcpConfigPath));
+            copyHermesCoordinatorCredentialFiles(hermesBaseConfig.sourceHome, dirname15(mcpConfigPath));
           }
           if (hadExistingMcpConfig) {
             try {
@@ -48693,7 +48944,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const cliArgs = [];
           const launchEnv = {};
           if (configFormat === "hermes_config_yaml") {
-            launchEnv.HERMES_HOME = dirname14(mcpConfigPath);
+            launchEnv.HERMES_HOME = dirname15(mcpConfigPath);
             launchEnv.HERMES_IGNORE_USER_CONFIG = "";
           }
           let autoImportContextFilePath;
@@ -57718,11 +57969,11 @@ init_parse_session();
 // src/providers/sdk/v1/fixture-tooling/replay.ts
 init_provider_cli_shared();
 import { readFileSync as readFileSync33 } from "fs";
-import { dirname as dirname12, resolve as resolve22 } from "path";
+import { dirname as dirname13, resolve as resolve22 } from "path";
 
 // src/providers/sdk/v1/validators/taint.ts
 import { readFileSync as readFileSync34, existsSync as existsSync43 } from "fs";
-import { resolve as resolve23, dirname as dirname13, join as join44 } from "path";
+import { resolve as resolve23, dirname as dirname14, join as join44 } from "path";
 
 // src/providers/sdk/v1/validators/index.ts
 init_manifest();
@@ -57827,6 +58078,7 @@ export {
   DEFAULT_STATUS_INITIAL_REPORT_DELAY_MS,
   DEFAULT_STATUS_P2P_REPORT_INTERVAL_MS,
   DEFAULT_STATUS_SERVER_REPORT_INTERVAL_MS,
+  DEFAULT_TASKMODE_ROLE_MAP,
   DEV_SERVER_PORT,
   DaemonAgentStreamManager,
   DaemonCdpInitializer,
@@ -57866,6 +58118,7 @@ export {
   RawTerminalAttachment,
   STALE_TERMINAL_REFINE_WINDOW_MS,
   STANDALONE_CDP_SCAN_INTERVAL_MS,
+  STANDARD_MESH_ROLES,
   SessionHostPtyTransportFactory,
   TerminalAdapter,
   TurnSnapshotTracker,
@@ -58099,9 +58352,12 @@ export {
   resolveGitRepository,
   resolveMeshHostStatus,
   resolveMeshRefineValidationPlan,
+  resolveMeshRoleOptions,
   resolveNodeSchedulingPriority,
   resolveSessionHostAppName,
   resolveSessionHostAppNameResolution,
+  resolveTaskAffinityRequiredTags,
+  resolveTaskAffinityRole,
   resolveWorktreePath,
   runAsyncBatch,
   runGit,