@stanco323/oh-my-claude-code 4.10.3 → 4.11.0

package/bridge/team.js

@@ -1649,9 +1649,31 @@ function getDefaultShell() {
   }
   return shell;
 }
+function pathEntries(envPath) {
+  return (envPath ?? "").split(process.platform === "win32" ? ";" : ":").map((entry) => entry.trim()).filter(Boolean);
+}
+function pathCandidateNames(candidatePath) {
+  const base = basename2(candidatePath.replace(/\\/g, "/"));
+  const bare = base.replace(/\.(exe|cmd|bat)$/i, "");
+  if (process.platform === "win32") {
+    return Array.from(/* @__PURE__ */ new Set([`${bare}.exe`, `${bare}.cmd`, `${bare}.bat`, bare]));
+  }
+  return Array.from(/* @__PURE__ */ new Set([base, bare]));
+}
+function resolveShellFromPath(candidatePath) {
+  for (const dir of pathEntries(process.env.PATH)) {
+    for (const name of pathCandidateNames(candidatePath)) {
+      const full = join5(dir, name);
+      if (existsSync5(full)) return full;
+    }
+  }
+  return null;
+}
 function resolveShellFromCandidates(paths, rcFile) {
   for (const p of paths) {
     if (existsSync5(p)) return { shell: p, rcFile };
+    const resolvedFromPath = resolveShellFromPath(p);
+    if (resolvedFromPath) return { shell: resolvedFromPath, rcFile };
   }
   return null;
 }
@@ -2046,7 +2068,7 @@ function paneLooksReady(captured) {
 }
 async function waitForPaneReady(paneId, opts = {}) {
   const envTimeout = Number.parseInt(process.env.OMC_SHELL_READY_TIMEOUT_MS ?? "", 10);
-  const timeoutMs = Number.isFinite(opts.timeoutMs) && (opts.timeoutMs ?? 0) > 0 ? Number(opts.timeoutMs) : Number.isFinite(envTimeout) && envTimeout > 0 ? envTimeout : 1e4;
+  const timeoutMs = Number.isFinite(opts.timeoutMs) && (opts.timeoutMs ?? 0) > 0 ? Number(opts.timeoutMs) : Number.isFinite(envTimeout) && envTimeout > 0 ? envTimeout : 3e4;
   const pollIntervalMs = Number.isFinite(opts.pollIntervalMs) && (opts.pollIntervalMs ?? 0) > 0 ? Number(opts.pollIntervalMs) : 250;
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
@@ -2163,7 +2185,12 @@ async function sendToWorker(_sessionName, paneId, message) {
     await sendKey("C-m");
     await sleep3(120);
     await sendKey("C-m");
-    return true;
+    await sleep3(140);
+    const finalCheckCapture = await capturePaneAsync(paneId, execFileAsync2);
+    if (!finalCheckCapture || finalCheckCapture.trim() === "") {
+      return false;
+    }
+    return !paneTailContainsLiteralLine(finalCheckCapture, message);
   } catch {
     return false;
   }
@@ -2495,6 +2522,8 @@ var init_omc_cli_rendering = __esm({
 });
 
 // src/utils/config-dir.ts
+import { join as join8, normalize, parse, sep } from "path";
+import { homedir } from "os";
 var init_config_dir = __esm({
   "src/utils/config-dir.ts"() {
     "use strict";
@@ -2502,45 +2531,45 @@ var init_config_dir = __esm({
 });
 
 // src/utils/paths.ts
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 import { existsSync as existsSync6, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync, unlinkSync, rmSync } from "fs";
-import { homedir } from "os";
-function getConfigDir2() {
+import { homedir as homedir2 } from "os";
+function getConfigDir() {
   if (process.platform === "win32") {
-    return process.env.APPDATA || join8(homedir(), "AppData", "Roaming");
+    return process.env.APPDATA || join9(homedir2(), "AppData", "Roaming");
   }
-  return process.env.XDG_CONFIG_HOME || join8(homedir(), ".config");
+  return process.env.XDG_CONFIG_HOME || join9(homedir2(), ".config");
 }
 function getStateDir() {
   if (process.platform === "win32") {
-    return process.env.LOCALAPPDATA || join8(homedir(), "AppData", "Local");
+    return process.env.LOCALAPPDATA || join9(homedir2(), "AppData", "Local");
   }
-  return process.env.XDG_STATE_HOME || join8(homedir(), ".local", "state");
+  return process.env.XDG_STATE_HOME || join9(homedir2(), ".local", "state");
 }
 function prefersXdgOmcDirs() {
   return process.platform !== "win32" && process.platform !== "darwin";
 }
 function getUserHomeDir() {
   if (process.platform === "win32") {
-    return process.env.USERPROFILE || process.env.HOME || homedir();
+    return process.env.USERPROFILE || process.env.HOME || homedir2();
   }
-  return process.env.HOME || homedir();
+  return process.env.HOME || homedir2();
 }
 function getLegacyOmcDir() {
-  return join8(getUserHomeDir(), ".omc");
+  return join9(getUserHomeDir(), ".omc");
 }
 function getGlobalOmcStateRoot() {
   const explicitRoot = process.env.OMC_HOME?.trim();
   if (explicitRoot) {
-    return join8(explicitRoot, "state");
+    return join9(explicitRoot, "state");
   }
   if (prefersXdgOmcDirs()) {
-    return join8(getStateDir(), "omc");
+    return join9(getStateDir(), "omc");
   }
-  return join8(getLegacyOmcDir(), "state");
+  return join9(getLegacyOmcDir(), "state");
 }
 function getGlobalOmcStatePath(...segments) {
-  return join8(getGlobalOmcStateRoot(), ...segments);
+  return join9(getGlobalOmcStateRoot(), ...segments);
 }
 var STALE_THRESHOLD_MS;
 var init_paths = __esm({
@@ -2729,7 +2758,7 @@ var init_models = __esm({
 
 // src/config/loader.ts
 import { readFileSync as readFileSync3, existsSync as existsSync7 } from "fs";
-import { join as join9, dirname as dirname6 } from "path";
+import { join as join10, dirname as dirname6 } from "path";
 function buildDefaultConfig() {
   const defaultTierModels = getDefaultTierModels();
   return {
@@ -3519,11 +3548,11 @@ var init_delegation_enforcer = __esm({
 
 // src/lib/security-config.ts
 import { existsSync as existsSync8, readFileSync as readFileSync4 } from "fs";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 function loadSecurityFromConfigFiles() {
   const paths = [
-    join10(process.cwd(), ".claude", "omc.jsonc"),
-    join10(getConfigDir2(), "claude-omc", "config.jsonc")
+    join11(process.cwd(), ".claude", "omc.jsonc"),
+    join11(getConfigDir(), "claude-omc", "config.jsonc")
   ];
   for (const configPath of paths) {
     if (!existsSync8(configPath)) continue;
@@ -3599,7 +3628,7 @@ var init_security_config = __esm({
 
 // src/team/model-contract.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { isAbsolute as isAbsolute4, normalize, win32 as win32Path } from "path";
+import { isAbsolute as isAbsolute4, normalize as normalize2, win32 as win32Path } from "path";
 function getTrustedPrefixes() {
   const trusted = [
     "/usr/local/bin",
@@ -3617,8 +3646,8 @@ function getTrustedPrefixes() {
   return trusted;
 }
 function isTrustedPrefix(resolvedPath) {
-  const normalized = normalize(resolvedPath);
-  return getTrustedPrefixes().some((prefix) => normalized.startsWith(normalize(prefix)));
+  const normalized = normalize2(resolvedPath);
+  return getTrustedPrefixes().some((prefix) => normalized.startsWith(normalize2(prefix)));
 }
 function assertBinaryName(binary) {
   if (!/^[A-Za-z0-9._-]+$/.test(binary)) {
@@ -3642,7 +3671,7 @@ function resolveCliBinaryPath(binary) {
   if (!firstLine) {
     throw new Error(`CLI binary '${binary}' not found in PATH`);
   }
-  const resolvedPath = normalize(firstLine);
+  const resolvedPath = normalize2(firstLine);
   if (!isAbsolute4(resolvedPath)) {
     throw new Error(`Resolved CLI binary '${binary}' to relative path`);
   }
@@ -3852,9 +3881,9 @@ var init_model_contract = __esm({
 
 // src/team/worker-bootstrap.ts
 import { mkdir as mkdir3, writeFile as writeFile3, appendFile as appendFile2 } from "fs/promises";
-import { join as join11, dirname as dirname7 } from "path";
+import { join as join12, dirname as dirname7 } from "path";
 function buildInstructionPath(...parts) {
-  return join11(...parts).replaceAll("\\", "/");
+  return join12(...parts).replaceAll("\\", "/");
 }
 function generateTriggerMessage(teamName, workerName, teamStateRoot3 = ".omc/state") {
   const inboxPath = buildInstructionPath(teamStateRoot3, "team", teamName, "workers", workerName, "inbox.md");
@@ -4017,22 +4046,22 @@ ${bootstrapInstructions}
 ` : ""}`;
 }
 async function composeInitialInbox(teamName, workerName, content, cwd) {
-  const inboxPath = join11(cwd, `.omc/state/team/${teamName}/workers/${workerName}/inbox.md`);
+  const inboxPath = join12(cwd, `.omc/state/team/${teamName}/workers/${workerName}/inbox.md`);
   await mkdir3(dirname7(inboxPath), { recursive: true });
   await writeFile3(inboxPath, content, "utf-8");
 }
 async function ensureWorkerStateDir(teamName, workerName, cwd) {
-  const workerDir = join11(cwd, `.omc/state/team/${teamName}/workers/${workerName}`);
+  const workerDir = join12(cwd, `.omc/state/team/${teamName}/workers/${workerName}`);
   await mkdir3(workerDir, { recursive: true });
-  const mailboxDir = join11(cwd, `.omc/state/team/${teamName}/mailbox`);
+  const mailboxDir = join12(cwd, `.omc/state/team/${teamName}/mailbox`);
   await mkdir3(mailboxDir, { recursive: true });
-  const tasksDir = join11(cwd, `.omc/state/team/${teamName}/tasks`);
+  const tasksDir = join12(cwd, `.omc/state/team/${teamName}/tasks`);
   await mkdir3(tasksDir, { recursive: true });
 }
 async function writeWorkerOverlay(params) {
   const { teamName, workerName, cwd } = params;
   const overlay = generateWorkerOverlay(params);
-  const overlayPath = join11(cwd, `.omc/state/team/${teamName}/workers/${workerName}/AGENTS.md`);
+  const overlayPath = join12(cwd, `.omc/state/team/${teamName}/workers/${workerName}/AGENTS.md`);
   await mkdir3(dirname7(overlayPath), { recursive: true });
   await writeFile3(overlayPath, overlay, "utf-8");
   return overlayPath;
@@ -4276,16 +4305,16 @@ var init_file_lock = __esm({
 
 // src/team/git-worktree.ts
 import { existsSync as existsSync10, readFileSync as readFileSync7 } from "node:fs";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 import { execFileSync as execFileSync3 } from "node:child_process";
 function getWorktreePath(repoRoot, teamName, workerName) {
-  return join13(repoRoot, ".omc", "worktrees", sanitizeName(teamName), sanitizeName(workerName));
+  return join14(repoRoot, ".omc", "worktrees", sanitizeName(teamName), sanitizeName(workerName));
 }
 function getBranchName(teamName, workerName) {
   return `omc-team/${sanitizeName(teamName)}/${sanitizeName(workerName)}`;
 }
 function getMetadataPath(repoRoot, teamName) {
-  return join13(repoRoot, ".omc", "state", "team-bridge", sanitizeName(teamName), "worktrees.json");
+  return join14(repoRoot, ".omc", "state", "team-bridge", sanitizeName(teamName), "worktrees.json");
 }
 function readMetadata(repoRoot, teamName) {
   const metaPath = getMetadataPath(repoRoot, teamName);
@@ -4302,7 +4331,7 @@ function readMetadata(repoRoot, teamName) {
 function writeMetadata(repoRoot, teamName, entries) {
   const metaPath = getMetadataPath(repoRoot, teamName);
   validateResolvedPath(metaPath, repoRoot);
-  const dir = join13(repoRoot, ".omc", "state", "team-bridge", sanitizeName(teamName));
+  const dir = join14(repoRoot, ".omc", "state", "team-bridge", sanitizeName(teamName));
   ensureDirWithMode(dir);
   atomicWriteJson(metaPath, entries);
 }
@@ -4719,7 +4748,7 @@ __export(runtime_v2_exports, {
   writeWatchdogFailedMarker: () => writeWatchdogFailedMarker
 });
 import { execFile as execFile3 } from "child_process";
-import { join as join16, resolve as resolve3 } from "path";
+import { join as join17, resolve as resolve3 } from "path";
 import { existsSync as existsSync15 } from "fs";
 import { mkdir as mkdir7, readdir as readdir2, readFile as readFile9, writeFile as writeFile5 } from "fs/promises";
 import { performance } from "perf_hooks";
@@ -4969,30 +4998,15 @@ async function spawnV2Worker(opts) {
       opts.teamName,
       opts.workerName,
       opts.taskId,
-      opts.cwd
+      opts.cwd,
+      6
     );
     if (!settled) {
-      const renotified = await notifyStartupInbox(opts.sessionName, paneId, inboxTriggerMessage);
-      if (!renotified.ok) {
-        return {
-          paneId,
-          startupAssigned: false,
-          startupFailureReason: `${renotified.reason}:startup_evidence_missing`
-        };
-      }
-      const settledAfterRetry = await waitForWorkerStartupEvidence(
-        opts.teamName,
-        opts.workerName,
-        opts.taskId,
-        opts.cwd
-      );
-      if (!settledAfterRetry) {
-        return {
-          paneId,
-          startupAssigned: false,
-          startupFailureReason: "claude_startup_evidence_missing"
-        };
-      }
+      return {
+        paneId,
+        startupAssigned: false,
+        startupFailureReason: "claude_startup_evidence_missing"
+      };
     }
   }
   if (usePromptMode) {
@@ -5026,11 +5040,11 @@ async function startTeamV2(config) {
   }
   await mkdir7(absPath(leaderCwd, TeamPaths.tasks(sanitized)), { recursive: true });
   await mkdir7(absPath(leaderCwd, TeamPaths.workers(sanitized)), { recursive: true });
-  await mkdir7(join16(leaderCwd, ".omc", "state", "team", sanitized, "mailbox"), { recursive: true });
+  await mkdir7(join17(leaderCwd, ".omc", "state", "team", sanitized, "mailbox"), { recursive: true });
   for (let i = 0; i < config.tasks.length; i++) {
     const taskId = String(i + 1);
     const taskFilePath = absPath(leaderCwd, TeamPaths.taskFile(sanitized, taskId));
-    await mkdir7(join16(taskFilePath, ".."), { recursive: true });
+    await mkdir7(join17(taskFilePath, ".."), { recursive: true });
     await writeFile5(taskFilePath, JSON.stringify({
       id: taskId,
       subject: config.tasks[i].subject,
@@ -5221,7 +5235,7 @@ async function writeWatchdogFailedMarker(teamName, cwd, reason) {
     writtenBy: "runtime-v2"
   };
   const root = absPath(cwd, TeamPaths.root(sanitizeTeamName(teamName)));
-  const markerPath = join16(root, "watchdog-failed.json");
+  const markerPath = join17(root, "watchdog-failed.json");
   await mkdir7(root, { recursive: true });
   await writeFile6(markerPath, JSON.stringify(marker, null, 2), "utf-8");
 }
@@ -5587,7 +5601,7 @@ async function resumeTeamV2(teamName, cwd) {
   }
 }
 async function findActiveTeamsV2(cwd) {
-  const root = join16(cwd, ".omc", "state", "team");
+  const root = join17(cwd, ".omc", "state", "team");
   if (!existsSync15(root)) return [];
   const entries = await readdir2(root, { withFileTypes: true });
   const active = [];
@@ -5653,7 +5667,7 @@ import { randomUUID as randomUUID6 } from "crypto";
 import { spawn } from "child_process";
 import { existsSync as existsSync17, mkdirSync as mkdirSync3, readFileSync as readFileSync10, writeFileSync as writeFileSync2 } from "fs";
 import { readFile as readFile10, rm as rm4 } from "fs/promises";
-import { dirname as dirname13, join as join18 } from "path";
+import { dirname as dirname13, join as join19 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/team/api-interop.ts
@@ -5664,7 +5678,7 @@ init_tmux_session();
 init_dispatch_queue();
 init_worker_bootstrap();
 import { existsSync as existsSync16, readFileSync as readFileSync9 } from "node:fs";
-import { dirname as dirname12, join as join17, resolve as resolvePath } from "node:path";
+import { dirname as dirname12, join as join18, resolve as resolvePath } from "node:path";
 
 // src/team/runtime.ts
 init_model_contract();
@@ -5673,25 +5687,25 @@ init_tmux_session();
 init_worker_bootstrap();
 init_git_worktree();
 import { mkdir as mkdir4, writeFile as writeFile4, readFile as readFile6, rm as rm3, rename as rename2 } from "fs/promises";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 import { existsSync as existsSync12 } from "fs";
 
 // src/team/task-file-ops.ts
-init_paths();
+init_config_dir();
 init_tmux_session();
 init_fs_utils();
 init_platform();
 init_state_paths();
 import { readFileSync as readFileSync8, readdirSync as readdirSync3, existsSync as existsSync11, openSync as openSync4, closeSync as closeSync4, unlinkSync as unlinkSync4, writeSync as writeSync4, statSync as statSync3, constants as fsConstants2 } from "fs";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 
 // src/team/runtime.ts
 function stateRoot(cwd, teamName) {
   validateTeamName(teamName);
-  return join15(cwd, `.omc/state/team/${teamName}`);
+  return join16(cwd, `.omc/state/team/${teamName}`);
 }
 async function writeJson(filePath, data) {
-  await mkdir4(join15(filePath, ".."), { recursive: true });
+  await mkdir4(join16(filePath, ".."), { recursive: true });
   await writeFile4(filePath, JSON.stringify(data, null, 2), "utf-8");
 }
 async function readJsonSafe2(filePath) {
@@ -5721,7 +5735,7 @@ async function readJsonSafe2(filePath) {
   return null;
 }
 function taskPath(root, taskId) {
-  return join15(root, "tasks", `${taskId}.json`);
+  return join16(root, "tasks", `${taskId}.json`);
 }
 async function readTask(root, taskId) {
   return readJsonSafe2(taskPath(root, taskId));
@@ -5734,9 +5748,9 @@ async function monitorTeam(teamName, cwd, workerPaneIds) {
   const taskCounts = { pending: 0, inProgress: 0, completed: 0, failed: 0 };
   try {
     const { readdir: readdir3 } = await import("fs/promises");
-    const taskFiles = await readdir3(join15(root, "tasks"));
+    const taskFiles = await readdir3(join16(root, "tasks"));
     for (const f of taskFiles.filter((f2) => f2.endsWith(".json"))) {
-      const task = await readJsonSafe2(join15(root, "tasks", f));
+      const task = await readJsonSafe2(join16(root, "tasks", f));
       if (task?.status === "pending") taskCounts.pending++;
       else if (task?.status === "in_progress") taskCounts.inProgress++;
       else if (task?.status === "completed") taskCounts.completed++;
@@ -5752,7 +5766,7 @@ async function monitorTeam(teamName, cwd, workerPaneIds) {
     const wName = `worker-${i + 1}`;
     const paneId = workerPaneIds[i];
     const alive = await isWorkerAlive(paneId);
-    const heartbeatPath = join15(root, "workers", wName, "heartbeat.json");
+    const heartbeatPath = join16(root, "workers", wName, "heartbeat.json");
     const heartbeat = await readJsonSafe2(heartbeatPath);
     let stalled = false;
     if (heartbeat?.updatedAt) {
@@ -5794,11 +5808,11 @@ async function monitorTeam(teamName, cwd, workerPaneIds) {
 }
 async function shutdownTeam(teamName, sessionName2, cwd, timeoutMs = 3e4, workerPaneIds, leaderPaneId, ownsWindow) {
   const root = stateRoot(cwd, teamName);
-  await writeJson(join15(root, "shutdown.json"), {
+  await writeJson(join16(root, "shutdown.json"), {
     requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
     teamName
   });
-  const configData = await readJsonSafe2(join15(root, "config.json"));
+  const configData = await readJsonSafe2(join16(root, "config.json"));
   const CLI_AGENT_TYPES = /* @__PURE__ */ new Set(["claude", "codex", "gemini"]);
   const agentTypes = configData?.agentTypes ?? [];
   const isCliWorkerTeam = agentTypes.length > 0 && agentTypes.every((t) => CLI_AGENT_TYPES.has(t));
@@ -5808,7 +5822,7 @@ async function shutdownTeam(teamName, sessionName2, cwd, timeoutMs = 3e4, worker
     const expectedAcks = Array.from({ length: workerCount }, (_, i) => `worker-${i + 1}`);
     while (Date.now() < deadline && expectedAcks.length > 0) {
       for (const wName of [...expectedAcks]) {
-        const ackPath = join15(root, "workers", wName, "shutdown-ack.json");
+        const ackPath = join16(root, "workers", wName, "shutdown-ack.json");
         if (existsSync12(ackPath)) {
           expectedAcks.splice(expectedAcks.indexOf(wName), 1);
         }
@@ -5832,7 +5846,7 @@ async function shutdownTeam(teamName, sessionName2, cwd, timeoutMs = 3e4, worker
 }
 async function resumeTeam(teamName, cwd) {
   const root = stateRoot(cwd, teamName);
-  const configData = await readJsonSafe2(join15(root, "config.json"));
+  const configData = await readJsonSafe2(join16(root, "config.json"));
   if (!configData) return null;
   const { execFile: execFile4 } = await import("child_process");
   const { promisify: promisify3 } = await import("util");
@@ -5941,8 +5955,8 @@ function parseValidatedTaskIdArray(value, fieldName) {
 }
 function teamStateExists(teamName, candidateCwd) {
   if (!TEAM_NAME_SAFE_PATTERN.test(teamName)) return false;
-  const teamRoot = join17(candidateCwd, ".omc", "state", "team", teamName);
-  return existsSync16(join17(teamRoot, "config.json")) || existsSync16(join17(teamRoot, "tasks")) || existsSync16(teamRoot);
+  const teamRoot = join18(candidateCwd, ".omc", "state", "team", teamName);
+  return existsSync16(join18(teamRoot, "config.json")) || existsSync16(join18(teamRoot, "tasks")) || existsSync16(teamRoot);
 }
 function parseTeamWorkerEnv(raw) {
   if (typeof raw !== "string" || raw.trim() === "") return null;
@@ -6013,16 +6027,16 @@ function stateRootToWorkingDirectory(stateRoot2) {
   return dirname12(dirname12(absolute));
 }
 function resolveTeamWorkingDirectoryFromMetadata(teamName, candidateCwd, workerContext) {
-  const teamRoot = join17(candidateCwd, ".omc", "state", "team", teamName);
+  const teamRoot = join18(candidateCwd, ".omc", "state", "team", teamName);
   if (!existsSync16(teamRoot)) return null;
   if (workerContext?.teamName === teamName) {
-    const workerRoot = readTeamStateRootFromFile(join17(teamRoot, "workers", workerContext.workerName, "identity.json"));
+    const workerRoot = readTeamStateRootFromFile(join18(teamRoot, "workers", workerContext.workerName, "identity.json"));
     if (workerRoot) return stateRootToWorkingDirectory(workerRoot);
   }
-  const fromConfig = readTeamStateRootFromFile(join17(teamRoot, "config.json"));
+  const fromConfig = readTeamStateRootFromFile(join18(teamRoot, "config.json"));
   if (fromConfig) return stateRootToWorkingDirectory(fromConfig);
   for (const manifestName of ["manifest.json", "manifest.v2.json"]) {
-    const fromManifest = readTeamStateRootFromFile(join17(teamRoot, manifestName));
+    const fromManifest = readTeamStateRootFromFile(join18(teamRoot, manifestName));
     if (fromManifest) return stateRootToWorkingDirectory(fromManifest);
   }
   return null;
@@ -6671,7 +6685,7 @@ function resolveRuntimeCliPath(env = process.env) {
     return env.OMC_RUNTIME_CLI_PATH;
   }
   const moduleDir = dirname13(fileURLToPath3(import.meta.url));
-  return join18(moduleDir, "../../bridge/runtime-cli.cjs");
+  return join19(moduleDir, "../../bridge/runtime-cli.cjs");
 }
 function ensureJobsDir(jobsDir) {
   if (!existsSync17(jobsDir)) {
@@ -6679,16 +6693,16 @@ function ensureJobsDir(jobsDir) {
   }
 }
 function jobPath(jobsDir, jobId) {
-  return join18(jobsDir, `${jobId}.json`);
+  return join19(jobsDir, `${jobId}.json`);
 }
 function resultArtifactPath(jobsDir, jobId) {
-  return join18(jobsDir, `${jobId}-result.json`);
+  return join19(jobsDir, `${jobId}-result.json`);
 }
 function panesArtifactPath(jobsDir, jobId) {
-  return join18(jobsDir, `${jobId}-panes.json`);
+  return join19(jobsDir, `${jobId}-panes.json`);
 }
 function teamStateRoot2(cwd, teamName) {
-  return join18(cwd, ".omc", "state", "team", teamName);
+  return join19(cwd, ".omc", "state", "team", teamName);
 }
 function validateJobId(jobId) {
   if (!JOB_ID_PATTERN.test(jobId)) {

package/dist/__tests__/auto-update.test.js

@@ -26,9 +26,8 @@ vi.mock('fs', async () => {
 });
 import { execSync, execFileSync } from 'child_process';
 import { cpSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { homedir } from 'os';
 import { join } from 'path';
-import { install, isProjectScopedPlugin, checkNodeVersion } from '../installer/index.js';
+import { install, isProjectScopedPlugin, checkNodeVersion, CLAUDE_CONFIG_DIR } from '../installer/index.js';
 import * as hooksModule from '../installer/hooks.js';
 import { reconcileUpdateRuntime, performUpdate, shouldBlockStandaloneUpdateInCurrentSession, syncPluginCache, } from '../features/auto-update.js';
 const mockedExecSync = vi.mocked(execSync);
@@ -190,7 +189,7 @@ describe('auto-update reconciliation', () => {
     });
     it('syncs the plugin cache directory when cache root exists', () => {
         const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
-        const cacheRoot = join(homedir(), '.claude', 'plugins', 'cache', 'omc', 'oh-my-claudecode');
+        const cacheRoot = join(CLAUDE_CONFIG_DIR, 'plugins', 'cache', 'omc', 'oh-my-claudecode');
         const versionedCacheRoot = `${cacheRoot}/4.9.0`;
         mockedExecSync.mockImplementation((command) => {
             if (command === 'npm root -g') {
@@ -235,7 +234,7 @@ describe('auto-update reconciliation', () => {
         expect(consoleLogSpy).toHaveBeenCalledWith('[omc update] Plugin cache synced');
     });
     it('skips plugin cache sync gracefully when cache dir does not exist', () => {
-        const cacheRoot = join(homedir(), '.claude', 'plugins', 'cache', 'omc', 'oh-my-claudecode');
+        const cacheRoot = join(CLAUDE_CONFIG_DIR, 'plugins', 'cache', 'omc', 'oh-my-claudecode');
         mockedExistsSync.mockImplementation((path) => {
             const normalized = String(path).replace(/\\/g, '/');
             if (normalized === cacheRoot) {
@@ -250,7 +249,7 @@ describe('auto-update reconciliation', () => {
     });
     it('handles plugin cache sync errors non-fatally', () => {
         const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
-        const cacheRoot = join(homedir(), '.claude', 'plugins', 'cache', 'omc', 'oh-my-claudecode');
+        const cacheRoot = join(CLAUDE_CONFIG_DIR, 'plugins', 'cache', 'omc', 'oh-my-claudecode');
         const versionedCacheRoot = `${cacheRoot}/4.9.0`;
         mockedExecSync.mockImplementation((command) => {
             if (command === 'npm root -g') {
@@ -355,8 +354,8 @@ describe('auto-update reconciliation', () => {
         expect(consoleLogSpy).toHaveBeenCalledWith('[omc update] Synced plugin cache');
     });
     it('allows standalone update when CLAUDE_PLUGIN_ROOT is inherited without an active Claude session', async () => {
-        const pluginRoot = join(homedir(), '.claude', 'plugins', 'cache', 'omc', 'oh-my-claudecode', '4.1.5');
-        const cacheRoot = join(homedir(), '.claude', 'plugins', 'cache', 'omc', 'oh-my-claudecode');
+        const pluginRoot = join(CLAUDE_CONFIG_DIR, 'plugins', 'cache', 'omc', 'oh-my-claudecode', '4.1.5');
+        const cacheRoot = join(CLAUDE_CONFIG_DIR, 'plugins', 'cache', 'omc', 'oh-my-claudecode');
         process.env.OMC_UPDATE_RECONCILE = '1';
         process.env.CLAUDE_PLUGIN_ROOT = pluginRoot;
         delete process.env.CLAUDE_CODE_ENTRYPOINT;
@@ -709,7 +708,7 @@ describe('auto-update reconciliation', () => {
                 ],
             },
         };
-        const settingsPath = join(homedir(), '.claude', 'settings.json');
+        const settingsPath = join(CLAUDE_CONFIG_DIR, 'settings.json');
         const baseHooks = hooksModule.getHooksSettingsConfig();
         const freshHooks = {
             ...baseHooks,
@@ -752,7 +751,7 @@ describe('auto-update reconciliation', () => {
         });
         vi.spyOn(hooksModule, 'getHooksSettingsConfig').mockReturnValue(freshHooks);
         const originalPluginRoot = process.env.CLAUDE_PLUGIN_ROOT;
-        process.env.CLAUDE_PLUGIN_ROOT = join(homedir(), '.claude', 'plugins', 'cache', 'omc', 'oh-my-claudecode', '4.1.5');
+        process.env.CLAUDE_PLUGIN_ROOT = join(CLAUDE_CONFIG_DIR, 'plugins', 'cache', 'omc', 'oh-my-claudecode', '4.1.5');
         const result = install({
             force: true,
             skipClaudeCheck: true,