claudecode-omc 4.4.5 → 4.4.7

package/bridge/runtime-cli.cjs

@@ -0,0 +1,1550 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/team/runtime-cli.ts
+var import_fs7 = require("fs");
+var import_promises4 = require("fs/promises");
+var import_path10 = require("path");
+
+// src/team/runtime.ts
+var import_promises3 = require("fs/promises");
+var import_path9 = require("path");
+var import_fs6 = require("fs");
+
+// src/team/model-contract.ts
+var import_child_process = require("child_process");
+
+// src/team/team-name.ts
+var TEAM_NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,48}[a-z0-9]$/;
+function validateTeamName(teamName) {
+  if (!TEAM_NAME_PATTERN.test(teamName)) {
+    throw new Error(
+      `Invalid team name: "${teamName}". Team name must match /^[a-z0-9][a-z0-9-]{0,48}[a-z0-9]$/.`
+    );
+  }
+  return teamName;
+}
+
+// src/team/model-contract.ts
+var CONTRACTS = {
+  claude: {
+    agentType: "claude",
+    binary: "claude",
+    installInstructions: "Install Claude CLI: https://claude.ai/download",
+    buildLaunchArgs(model, extraFlags = []) {
+      const args = ["--dangerously-skip-permissions"];
+      if (model) args.push("--model", model);
+      return [...args, ...extraFlags];
+    },
+    parseOutput(rawOutput) {
+      return rawOutput.trim();
+    }
+  },
+  codex: {
+    agentType: "codex",
+    binary: "codex",
+    installInstructions: "Install Codex CLI: npm install -g @openai/codex",
+    supportsPromptMode: true,
+    // Codex accepts prompt as a positional argument (no flag needed):
+    //   codex [OPTIONS] [PROMPT]
+    buildLaunchArgs(model, extraFlags = []) {
+      const args = ["--dangerously-bypass-approvals-and-sandbox"];
+      if (model) args.push("--model", model);
+      return [...args, ...extraFlags];
+    },
+    parseOutput(rawOutput) {
+      const lines = rawOutput.trim().split("\n").filter(Boolean);
+      for (let i = lines.length - 1; i >= 0; i--) {
+        try {
+          const parsed = JSON.parse(lines[i]);
+          if (parsed.type === "message" && parsed.role === "assistant") {
+            return parsed.content ?? rawOutput;
+          }
+          if (parsed.type === "result" || parsed.output) {
+            return parsed.output ?? parsed.result ?? rawOutput;
+          }
+        } catch {
+        }
+      }
+      return rawOutput.trim();
+    }
+  },
+  gemini: {
+    agentType: "gemini",
+    binary: "gemini",
+    installInstructions: "Install Gemini CLI: npm install -g @google/gemini-cli",
+    supportsPromptMode: true,
+    promptModeFlag: "-p",
+    buildLaunchArgs(model, extraFlags = []) {
+      const args = ["--yolo"];
+      if (model) args.push("--model", model);
+      return [...args, ...extraFlags];
+    },
+    parseOutput(rawOutput) {
+      return rawOutput.trim();
+    }
+  }
+};
+function getContract(agentType) {
+  const contract = CONTRACTS[agentType];
+  if (!contract) {
+    throw new Error(`Unknown agent type: ${agentType}. Supported: ${Object.keys(CONTRACTS).join(", ")}`);
+  }
+  return contract;
+}
+function isCliAvailable(agentType) {
+  const contract = getContract(agentType);
+  try {
+    const result = (0, import_child_process.spawnSync)(contract.binary, ["--version"], { timeout: 5e3, shell: true });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+function validateCliAvailable(agentType) {
+  if (!isCliAvailable(agentType)) {
+    const contract = getContract(agentType);
+    throw new Error(
+      `CLI agent '${agentType}' not found. ${contract.installInstructions}`
+    );
+  }
+}
+function buildLaunchArgs(agentType, config) {
+  return getContract(agentType).buildLaunchArgs(config.model, config.extraFlags);
+}
+function buildWorkerArgv(agentType, config) {
+  validateTeamName(config.teamName);
+  const contract = getContract(agentType);
+  const args = buildLaunchArgs(agentType, config);
+  return [contract.binary, ...args];
+}
+function getWorkerEnv(teamName, workerName2, agentType) {
+  validateTeamName(teamName);
+  return {
+    OMC_TEAM_WORKER: `${teamName}/${workerName2}`,
+    OMC_TEAM_NAME: teamName,
+    OMC_WORKER_AGENT_TYPE: agentType
+  };
+}
+function isPromptModeAgent(agentType) {
+  const contract = getContract(agentType);
+  return !!contract.supportsPromptMode;
+}
+function getPromptModeArgs(agentType, instruction) {
+  const contract = getContract(agentType);
+  if (!contract.supportsPromptMode) {
+    return [];
+  }
+  if (contract.promptModeFlag) {
+    return [contract.promptModeFlag, instruction];
+  }
+  return [instruction];
+}
+
+// src/team/tmux-session.ts
+var import_child_process2 = require("child_process");
+var import_path = require("path");
+var import_util = require("util");
+var import_promises = __toESM(require("fs/promises"), 1);
+var promisifiedExec = (0, import_util.promisify)(import_child_process2.exec);
+var promisifiedExecFile = (0, import_util.promisify)(import_child_process2.execFile);
+function isUnixLikeOnWindows() {
+  return process.platform === "win32" && !!(process.env.MSYSTEM || process.env.MINGW_PREFIX);
+}
+async function tmuxAsync(args) {
+  if (args.some((a) => a.includes("#{"))) {
+    const escaped = args.map((a) => `"${a.replace(/"/g, '\\"')}"`).join(" ");
+    return promisifiedExec(`tmux ${escaped}`);
+  }
+  return promisifiedExecFile("tmux", args);
+}
+function getDefaultShell() {
+  if (process.platform === "win32" && !isUnixLikeOnWindows()) {
+    return process.env.COMSPEC || "cmd.exe";
+  }
+  return process.env.SHELL || "/bin/bash";
+}
+function escapeForCmdSet(value) {
+  return value.replace(/"/g, '""');
+}
+function shellNameFromPath(shellPath) {
+  const shellName = (0, import_path.basename)(shellPath.replace(/\\/g, "/"));
+  return shellName.replace(/\.(exe|cmd|bat)$/i, "");
+}
+function shellEscape(value) {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+function assertSafeEnvKey(key) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+    throw new Error(`Invalid environment key: "${key}"`);
+  }
+}
+function getLaunchWords(config) {
+  if (config.launchBinary) {
+    return [config.launchBinary, ...config.launchArgs ?? []];
+  }
+  if (config.launchCmd) {
+    return [config.launchCmd];
+  }
+  throw new Error("Missing worker launch command. Provide launchBinary or launchCmd.");
+}
+function buildWorkerStartCommand(config) {
+  const shell = getDefaultShell();
+  const launchWords = getLaunchWords(config);
+  if (process.platform === "win32" && !isUnixLikeOnWindows()) {
+    const envPrefix = Object.entries(config.envVars).map(([k, v]) => {
+      assertSafeEnvKey(k);
+      return `set "${k}=${escapeForCmdSet(v)}"`;
+    }).join(" && ");
+    const launch = config.launchBinary ? launchWords.map((part) => `"${escapeForCmdSet(part)}"`).join(" ") : launchWords[0];
+    const cmdBody = envPrefix ? `${envPrefix} && ${launch}` : launch;
+    return `${shell} /d /s /c "${cmdBody}"`;
+  }
+  if (config.launchBinary) {
+    const envAssignments = Object.entries(config.envVars).map(([key, value]) => {
+      assertSafeEnvKey(key);
+      return `${key}=${shellEscape(value)}`;
+    });
+    const shellName2 = shellNameFromPath(shell) || "bash";
+    const rcFile2 = process.env.HOME ? `${process.env.HOME}/.${shellName2}rc` : "";
+    const script = rcFile2 ? `[ -f ${shellEscape(rcFile2)} ] && . ${shellEscape(rcFile2)}; exec "$@"` : 'exec "$@"';
+    return [
+      "env",
+      ...envAssignments,
+      shell,
+      "-lc",
+      script,
+      "--",
+      ...launchWords
+    ].map(shellEscape).join(" ");
+  }
+  const envString = Object.entries(config.envVars).map(([k, v]) => {
+    assertSafeEnvKey(k);
+    return `${k}=${shellEscape(v)}`;
+  }).join(" ");
+  const shellName = shellNameFromPath(shell) || "bash";
+  const rcFile = process.env.HOME ? `${process.env.HOME}/.${shellName}rc` : "";
+  const sourceCmd = rcFile ? `[ -f "${rcFile}" ] && source "${rcFile}"; ` : "";
+  return `env ${envString} ${shell} -c "${sourceCmd}exec ${launchWords[0]}"`;
+}
+function sanitizeName(name) {
+  const sanitized = name.replace(/[^a-zA-Z0-9-]/g, "");
+  if (sanitized.length === 0) {
+    throw new Error(`Invalid name: "${name}" contains no valid characters (alphanumeric or hyphen)`);
+  }
+  if (sanitized.length < 2) {
+    throw new Error(`Invalid name: "${name}" too short after sanitization (minimum 2 characters)`);
+  }
+  return sanitized.slice(0, 50);
+}
+async function createTeamSession(teamName, workerCount, cwd) {
+  const { execFile: execFile2 } = await import("child_process");
+  const { promisify: promisify2 } = await import("util");
+  const execFileAsync = promisify2(execFile2);
+  if (!process.env.TMUX) {
+    throw new Error("Team mode requires running inside tmux. Start one: tmux new-session");
+  }
+  const envPaneIdRaw = (process.env.TMUX_PANE ?? "").trim();
+  const envPaneId = /^%\d+$/.test(envPaneIdRaw) ? envPaneIdRaw : "";
+  let sessionAndWindow = "";
+  let leaderPaneId = envPaneId;
+  if (envPaneId) {
+    try {
+      const targetedContextResult = await execFileAsync("tmux", [
+        "display-message",
+        "-p",
+        "-t",
+        envPaneId,
+        "#S:#I"
+      ]);
+      sessionAndWindow = targetedContextResult.stdout.trim();
+    } catch {
+      sessionAndWindow = "";
+      leaderPaneId = "";
+    }
+  }
+  if (!sessionAndWindow || !leaderPaneId) {
+    const contextResult = await tmuxAsync([
+      "display-message",
+      "-p",
+      "#S:#I #{pane_id}"
+    ]);
+    const contextLine = contextResult.stdout.trim();
+    const contextMatch = contextLine.match(/^(\S+)\s+(%\d+)$/);
+    if (!contextMatch) {
+      throw new Error(`Failed to resolve tmux context: "${contextLine}"`);
+    }
+    sessionAndWindow = contextMatch[1];
+    leaderPaneId = contextMatch[2];
+  }
+  const teamTarget = sessionAndWindow;
+  const resolvedSessionName = teamTarget.split(":")[0];
+  const workerPaneIds = [];
+  if (workerCount <= 0) {
+    try {
+      await execFileAsync("tmux", ["set-option", "-t", resolvedSessionName, "mouse", "on"]);
+    } catch {
+    }
+    try {
+      await execFileAsync("tmux", ["select-pane", "-t", leaderPaneId]);
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 300));
+    return { sessionName: teamTarget, leaderPaneId, workerPaneIds };
+  }
+  for (let i = 0; i < workerCount; i++) {
+    const splitTarget = i === 0 ? leaderPaneId : workerPaneIds[i - 1];
+    const splitType = i === 0 ? "-h" : "-v";
+    const splitResult = await tmuxAsync([
+      "split-window",
+      splitType,
+      "-t",
+      splitTarget,
+      "-d",
+      "-P",
+      "-F",
+      "#{pane_id}",
+      "-c",
+      cwd
+    ]);
+    const paneId = splitResult.stdout.split("\n")[0]?.trim();
+    if (paneId) {
+      workerPaneIds.push(paneId);
+    }
+  }
+  try {
+    await execFileAsync("tmux", ["select-layout", "-t", teamTarget, "main-vertical"]);
+  } catch {
+  }
+  try {
+    const widthResult = await tmuxAsync([
+      "display-message",
+      "-p",
+      "-t",
+      teamTarget,
+      "#{window_width}"
+    ]);
+    const width = parseInt(widthResult.stdout.trim(), 10);
+    if (Number.isFinite(width) && width >= 40) {
+      const half = String(Math.floor(width / 2));
+      await execFileAsync("tmux", ["set-window-option", "-t", teamTarget, "main-pane-width", half]);
+      await execFileAsync("tmux", ["select-layout", "-t", teamTarget, "main-vertical"]);
+    }
+  } catch {
+  }
+  try {
+    await execFileAsync("tmux", ["set-option", "-t", resolvedSessionName, "mouse", "on"]);
+  } catch {
+  }
+  try {
+    await execFileAsync("tmux", ["select-pane", "-t", leaderPaneId]);
+  } catch {
+  }
+  await new Promise((r) => setTimeout(r, 300));
+  return { sessionName: teamTarget, leaderPaneId, workerPaneIds };
+}
+async function spawnWorkerInPane(sessionName, paneId, config) {
+  const { execFile: execFile2 } = await import("child_process");
+  const { promisify: promisify2 } = await import("util");
+  const execFileAsync = promisify2(execFile2);
+  validateTeamName(config.teamName);
+  const startCmd = buildWorkerStartCommand(config);
+  await execFileAsync("tmux", [
+    "send-keys",
+    "-t",
+    paneId,
+    "-l",
+    startCmd
+  ]);
+  await execFileAsync("tmux", ["send-keys", "-t", paneId, "Enter"]);
+}
+function normalizeTmuxCapture(value) {
+  return value.replace(/\r/g, "").replace(/\s+/g, " ").trim();
+}
+async function capturePaneAsync(paneId, execFileAsync) {
+  try {
+    const result = await execFileAsync("tmux", ["capture-pane", "-t", paneId, "-p", "-S", "-80"]);
+    return result.stdout;
+  } catch {
+    return "";
+  }
+}
+function paneHasTrustPrompt(captured) {
+  const lines = captured.split("\n").map((l) => l.replace(/\r/g, "").trim()).filter((l) => l.length > 0);
+  const tail = lines.slice(-12);
+  const hasQuestion = tail.some((l) => /Do you trust the contents of this directory\?/i.test(l));
+  const hasChoices = tail.some((l) => /Yes,\s*continue|No,\s*quit|Press enter to continue/i.test(l));
+  return hasQuestion && hasChoices;
+}
+function paneHasActiveTask(captured) {
+  const lines = captured.split("\n").map((l) => l.replace(/\r/g, "").trim()).filter((l) => l.length > 0);
+  const tail = lines.slice(-40);
+  if (tail.some((l) => /esc to interrupt/i.test(l))) return true;
+  if (tail.some((l) => /\bbackground terminal running\b/i.test(l))) return true;
+  return false;
+}
+function paneLooksReady(captured) {
+  const lines = captured.split("\n").map((line) => line.replace(/\r/g, "").trim()).filter((line) => line.length > 0);
+  if (lines.length === 0) return false;
+  const tail = lines.slice(-20);
+  const hasPrompt = tail.some((line) => /^\s*[›>❯]\s*/u.test(line));
+  if (hasPrompt) return true;
+  const hasCodexHint = tail.some(
+    (line) => /\bgpt-[\w.-]+\b/i.test(line) || /\b\d+% left\b/i.test(line)
+  );
+  return hasCodexHint;
+}
+function paneTailContainsLiteralLine(captured, text) {
+  return normalizeTmuxCapture(captured).includes(normalizeTmuxCapture(text));
+}
+async function paneInCopyMode(paneId, execFileAsync) {
+  try {
+    const result = await tmuxAsync(["display-message", "-t", paneId, "-p", "#{pane_in_mode}"]);
+    return result.stdout.trim() === "1";
+  } catch {
+    return false;
+  }
+}
+function shouldAttemptAdaptiveRetry(args) {
+  if (process.env.OMX_TEAM_AUTO_INTERRUPT_RETRY === "0") return false;
+  if (args.retriesAttempted >= 1) return false;
+  if (args.paneInCopyMode) return false;
+  if (!args.paneBusy) return false;
+  if (typeof args.latestCapture !== "string") return false;
+  if (!paneTailContainsLiteralLine(args.latestCapture, args.message)) return false;
+  if (paneHasActiveTask(args.latestCapture)) return false;
+  if (!paneLooksReady(args.latestCapture)) return false;
+  return true;
+}
+async function sendToWorker(_sessionName, paneId, message) {
+  if (message.length > 200) {
+    console.warn(`[tmux-session] sendToWorker: message truncated to 200 chars`);
+    message = message.slice(0, 200);
+  }
+  try {
+    const { execFile: execFile2 } = await import("child_process");
+    const { promisify: promisify2 } = await import("util");
+    const execFileAsync = promisify2(execFile2);
+    const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+    const sendKey = async (key) => {
+      await execFileAsync("tmux", ["send-keys", "-t", paneId, key]);
+    };
+    if (await paneInCopyMode(paneId, execFileAsync)) {
+      return false;
+    }
+    const initialCapture = await capturePaneAsync(paneId, execFileAsync);
+    const paneBusy = paneHasActiveTask(initialCapture);
+    if (paneHasTrustPrompt(initialCapture)) {
+      await sendKey("C-m");
+      await sleep(120);
+      await sendKey("C-m");
+      await sleep(200);
+    }
+    await execFileAsync("tmux", ["send-keys", "-t", paneId, "-l", "--", message]);
+    await sleep(150);
+    const submitRounds = 6;
+    for (let round = 0; round < submitRounds; round++) {
+      await sleep(100);
+      if (round === 0 && paneBusy) {
+        await sendKey("Tab");
+        await sleep(80);
+        await sendKey("C-m");
+      } else {
+        await sendKey("C-m");
+        await sleep(200);
+        await sendKey("C-m");
+      }
+      await sleep(140);
+      const checkCapture = await capturePaneAsync(paneId, execFileAsync);
+      if (!paneTailContainsLiteralLine(checkCapture, message)) return true;
+      await sleep(140);
+    }
+    if (await paneInCopyMode(paneId, execFileAsync)) {
+      return false;
+    }
+    const finalCapture = await capturePaneAsync(paneId, execFileAsync);
+    const paneModeBeforeAdaptiveRetry = await paneInCopyMode(paneId, execFileAsync);
+    if (shouldAttemptAdaptiveRetry({
+      paneBusy,
+      latestCapture: finalCapture,
+      message,
+      paneInCopyMode: paneModeBeforeAdaptiveRetry,
+      retriesAttempted: 0
+    })) {
+      if (await paneInCopyMode(paneId, execFileAsync)) {
+        return false;
+      }
+      await sendKey("C-u");
+      await sleep(80);
+      if (await paneInCopyMode(paneId, execFileAsync)) {
+        return false;
+      }
+      await execFileAsync("tmux", ["send-keys", "-t", paneId, "-l", "--", message]);
+      await sleep(120);
+      for (let round = 0; round < 4; round++) {
+        await sendKey("C-m");
+        await sleep(180);
+        await sendKey("C-m");
+        await sleep(140);
+        const retryCapture = await capturePaneAsync(paneId, execFileAsync);
+        if (!paneTailContainsLiteralLine(retryCapture, message)) return true;
+      }
+    }
+    if (await paneInCopyMode(paneId, execFileAsync)) {
+      return false;
+    }
+    await sendKey("C-m");
+    await sleep(120);
+    await sendKey("C-m");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isWorkerAlive(paneId) {
+  try {
+    const { execFile: execFile2 } = await import("child_process");
+    const { promisify: promisify2 } = await import("util");
+    const execFileAsync = promisify2(execFile2);
+    const result = await tmuxAsync([
+      "display-message",
+      "-t",
+      paneId,
+      "-p",
+      "#{pane_dead}"
+    ]);
+    return result.stdout.trim() === "0";
+  } catch {
+    return false;
+  }
+}
+async function killTeamSession(sessionName, workerPaneIds, leaderPaneId) {
+  const { execFile: execFile2 } = await import("child_process");
+  const { promisify: promisify2 } = await import("util");
+  const execFileAsync = promisify2(execFile2);
+  if (sessionName.includes(":")) {
+    if (!workerPaneIds?.length) return;
+    for (const id of workerPaneIds) {
+      if (id === leaderPaneId) continue;
+      try {
+        await execFileAsync("tmux", ["kill-pane", "-t", id]);
+      } catch {
+      }
+    }
+    return;
+  }
+  try {
+    await execFileAsync("tmux", ["kill-session", "-t", sessionName]);
+  } catch {
+  }
+}
+
+// src/team/worker-bootstrap.ts
+var import_promises2 = require("fs/promises");
+var import_path4 = require("path");
+
+// src/agents/prompt-helpers.ts
+var import_fs2 = require("fs");
+var import_path3 = require("path");
+var import_url2 = require("url");
+
+// src/agents/utils.ts
+var import_fs = require("fs");
+var import_path2 = require("path");
+var import_url = require("url");
+
+// src/agents/prompt-helpers.ts
+var import_meta = {};
+function getPackageDir() {
+  try {
+    if (import_meta?.url) {
+      const __filename = (0, import_url2.fileURLToPath)(import_meta.url);
+      const __dirname2 = (0, import_path3.dirname)(__filename);
+      return (0, import_path3.join)(__dirname2, "..", "..");
+    }
+  } catch {
+  }
+  if (typeof __dirname !== "undefined") {
+    return (0, import_path3.join)(__dirname, "..");
+  }
+  return process.cwd();
+}
+var _cachedRoles = null;
+function getValidAgentRoles() {
+  if (_cachedRoles) return _cachedRoles;
+  try {
+    if (typeof __AGENT_ROLES__ !== "undefined" && Array.isArray(__AGENT_ROLES__) && __AGENT_ROLES__.length > 0) {
+      _cachedRoles = __AGENT_ROLES__;
+      return _cachedRoles;
+    }
+  } catch {
+  }
+  try {
+    const agentsDir = (0, import_path3.join)(getPackageDir(), "agents");
+    const files = (0, import_fs2.readdirSync)(agentsDir);
+    _cachedRoles = files.filter((f) => f.endsWith(".md")).map((f) => (0, import_path3.basename)(f, ".md")).sort();
+  } catch (err) {
+    console.error("[prompt-injection] CRITICAL: Could not scan agents/ directory for role discovery:", err);
+    _cachedRoles = [];
+  }
+  return _cachedRoles;
+}
+var VALID_AGENT_ROLES = getValidAgentRoles();
+function sanitizePromptContent(content, maxLength = 4e3) {
+  if (!content) return "";
+  let sanitized = content.length > maxLength ? content.slice(0, maxLength) : content;
+  if (sanitized.length > 0) {
+    const lastCode = sanitized.charCodeAt(sanitized.length - 1);
+    if (lastCode >= 55296 && lastCode <= 56319) {
+      sanitized = sanitized.slice(0, -1);
+    }
+  }
+  sanitized = sanitized.replace(/<(\/?)(TASK_SUBJECT)[^>]*>/gi, "[$1$2]");
+  sanitized = sanitized.replace(/<(\/?)(TASK_DESCRIPTION)[^>]*>/gi, "[$1$2]");
+  sanitized = sanitized.replace(/<(\/?)(INBOX_MESSAGE)[^>]*>/gi, "[$1$2]");
+  sanitized = sanitized.replace(/<(\/?)(INSTRUCTIONS)[^>]*>/gi, "[$1$2]");
+  sanitized = sanitized.replace(/<(\/?)(SYSTEM)[^>]*>/gi, "[$1$2]");
+  return sanitized;
+}
+
+// src/team/worker-bootstrap.ts
+function generateWorkerOverlay(params) {
+  const { teamName, workerName: workerName2, agentType, tasks, bootstrapInstructions } = params;
+  const sanitizedTasks = tasks.map((t) => ({
+    id: t.id,
+    subject: sanitizePromptContent(t.subject),
+    description: sanitizePromptContent(t.description)
+  }));
+  const sentinelPath = `.omc/state/team/${teamName}/workers/${workerName2}/.ready`;
+  const heartbeatPath = `.omc/state/team/${teamName}/workers/${workerName2}/heartbeat.json`;
+  const inboxPath = `.omc/state/team/${teamName}/workers/${workerName2}/inbox.md`;
+  const taskDir = `.omc/state/team/${teamName}/tasks`;
+  const donePath = `.omc/state/team/${teamName}/workers/${workerName2}/done.json`;
+  const taskList = sanitizedTasks.length > 0 ? sanitizedTasks.map((t) => `- **Task ${t.id}**: ${t.subject}`).join("\n") : "- No tasks assigned yet. Check your inbox for assignments.";
+  return `# Team Worker Protocol
+
+## FIRST ACTION REQUIRED
+Before doing anything else, write your ready sentinel file:
+\`\`\`bash
+mkdir -p $(dirname ${sentinelPath}) && touch ${sentinelPath}
+\`\`\`
+
+## Identity
+- **Team**: ${teamName}
+- **Worker**: ${workerName2}
+- **Agent Type**: ${agentType}
+- **Environment**: OMC_TEAM_WORKER=${teamName}/${workerName2}
+
+## Your Tasks
+${taskList}
+
+## Task Claiming Protocol
+To claim a task, update the task file atomically:
+1. Read task from: ${taskDir}/{taskId}.json
+2. Update status to "in_progress", set owner to "${workerName2}"
+3. Write back to task file
+4. Do the work
+5. Update status to "completed", write result to task file
+
+## Communication Protocol
+- **Inbox**: Read ${inboxPath} for new instructions
+- **Heartbeat**: Update ${heartbeatPath} every few minutes:
+  \`\`\`json
+  {"workerName":"${workerName2}","status":"working","updatedAt":"<ISO timestamp>","currentTaskId":"<id or null>"}
+  \`\`\`
+
+## Task Completion Protocol
+When you finish a task (success or failure), write a done signal file:
+- Path: ${donePath}
+- Content (JSON, one line):
+  {"taskId":"<id>","status":"completed","summary":"<1-2 sentence summary>","completedAt":"<ISO timestamp>"}
+- For failures, set status to "failed" and include the error in summary.
+- Use "completed" or "failed" only for status.
+
+## Shutdown Protocol
+When you see a shutdown request (check .omc/state/team/${teamName}/shutdown.json):
+1. Finish your current task if close to completion
+2. Write an ACK file: .omc/state/team/${teamName}/workers/${workerName2}/shutdown-ack.json
+3. Exit
+
+${bootstrapInstructions ? `## Additional Instructions
+${bootstrapInstructions}
+` : ""}`;
+}
+async function composeInitialInbox(teamName, workerName2, content, cwd) {
+  const inboxPath = (0, import_path4.join)(cwd, `.omc/state/team/${teamName}/workers/${workerName2}/inbox.md`);
+  await (0, import_promises2.mkdir)((0, import_path4.dirname)(inboxPath), { recursive: true });
+  await (0, import_promises2.writeFile)(inboxPath, content, "utf-8");
+}
+async function ensureWorkerStateDir(teamName, workerName2, cwd) {
+  const workerDir = (0, import_path4.join)(cwd, `.omc/state/team/${teamName}/workers/${workerName2}`);
+  await (0, import_promises2.mkdir)(workerDir, { recursive: true });
+  const mailboxDir = (0, import_path4.join)(cwd, `.omc/state/team/${teamName}/mailbox`);
+  await (0, import_promises2.mkdir)(mailboxDir, { recursive: true });
+  const tasksDir = (0, import_path4.join)(cwd, `.omc/state/team/${teamName}/tasks`);
+  await (0, import_promises2.mkdir)(tasksDir, { recursive: true });
+}
+async function writeWorkerOverlay(params) {
+  const { teamName, workerName: workerName2, cwd } = params;
+  const overlay = generateWorkerOverlay(params);
+  const overlayPath = (0, import_path4.join)(cwd, `.omc/state/team/${teamName}/workers/${workerName2}/AGENTS.md`);
+  await (0, import_promises2.mkdir)((0, import_path4.dirname)(overlayPath), { recursive: true });
+  await (0, import_promises2.writeFile)(overlayPath, overlay, "utf-8");
+  return overlayPath;
+}
+
+// src/team/task-file-ops.ts
+var import_fs5 = require("fs");
+var import_path8 = require("path");
+
+// src/utils/paths.ts
+var import_path5 = require("path");
+var import_fs3 = require("fs");
+var import_os = require("os");
+var STALE_THRESHOLD_MS = 24 * 60 * 60 * 1e3;
+
+// src/team/fs-utils.ts
+var import_fs4 = require("fs");
+var import_path6 = require("path");
+function ensureDirWithMode(dirPath, mode = 448) {
+  if (!(0, import_fs4.existsSync)(dirPath)) (0, import_fs4.mkdirSync)(dirPath, { recursive: true, mode });
+}
+function canonicalizePath(p) {
+  const absInput = (0, import_path6.resolve)(p);
+  const tail = [];
+  let probe = absInput;
+  while (true) {
+    try {
+      const realBase = (0, import_fs4.realpathSync)(probe);
+      return tail.reduce((acc, seg) => (0, import_path6.resolve)(acc, seg), realBase);
+    } catch {
+      const parent = (0, import_path6.dirname)(probe);
+      if (parent === probe) return absInput;
+      tail.unshift((0, import_path6.basename)(probe));
+      probe = parent;
+    }
+  }
+}
+function validateResolvedPath(resolvedPath, expectedBase) {
+  const absResolved = canonicalizePath(resolvedPath);
+  const absBase = canonicalizePath(expectedBase);
+  const rel = (0, import_path6.relative)(absBase, absResolved);
+  if (rel !== "" && (rel.startsWith("..") || (0, import_path6.isAbsolute)(rel) || (0, import_path6.resolve)(absBase, rel) !== absResolved)) {
+    throw new Error(`Path traversal detected: "${resolvedPath}" escapes base "${expectedBase}"`);
+  }
+}
+
+// src/team/state-paths.ts
+var import_path7 = require("path");
+var TeamPaths = {
+  root: (teamName) => `.omc/state/team/${teamName}`,
+  config: (teamName) => `.omc/state/team/${teamName}/config.json`,
+  shutdown: (teamName) => `.omc/state/team/${teamName}/shutdown.json`,
+  tasks: (teamName) => `.omc/state/team/${teamName}/tasks`,
+  taskFile: (teamName, taskId) => `.omc/state/team/${teamName}/tasks/${taskId}.json`,
+  workers: (teamName) => `.omc/state/team/${teamName}/workers`,
+  workerDir: (teamName, workerName2) => `.omc/state/team/${teamName}/workers/${workerName2}`,
+  heartbeat: (teamName, workerName2) => `.omc/state/team/${teamName}/workers/${workerName2}/heartbeat.json`,
+  inbox: (teamName, workerName2) => `.omc/state/team/${teamName}/workers/${workerName2}/inbox.md`,
+  outbox: (teamName, workerName2) => `.omc/state/team/${teamName}/workers/${workerName2}/outbox.jsonl`,
+  ready: (teamName, workerName2) => `.omc/state/team/${teamName}/workers/${workerName2}/.ready`,
+  overlay: (teamName, workerName2) => `.omc/state/team/${teamName}/workers/${workerName2}/AGENTS.md`,
+  shutdownAck: (teamName, workerName2) => `.omc/state/team/${teamName}/workers/${workerName2}/shutdown-ack.json`,
+  done: (teamName, workerName2) => `.omc/state/team/${teamName}/workers/${workerName2}/done.json`,
+  mailbox: (teamName, workerName2) => `.omc/state/team/${teamName}/mailbox/${workerName2}.jsonl`
+};
+function getTaskStoragePath(cwd, teamName, taskId) {
+  if (taskId !== void 0) {
+    return (0, import_path7.join)(cwd, TeamPaths.taskFile(teamName, taskId));
+  }
+  return (0, import_path7.join)(cwd, TeamPaths.tasks(teamName));
+}
+
+// src/team/task-file-ops.ts
+var DEFAULT_STALE_LOCK_MS = 3e4;
+function isPidAlive(pid) {
+  if (pid <= 0 || !Number.isFinite(pid)) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    if (e && typeof e === "object" && "code" in e && e.code === "EPERM") return true;
+    return false;
+  }
+}
+function acquireTaskLock(teamName, taskId, opts) {
+  const staleLockMs = opts?.staleLockMs ?? DEFAULT_STALE_LOCK_MS;
+  const dir = canonicalTasksDir(teamName, opts?.cwd);
+  ensureDirWithMode(dir);
+  const lockPath = (0, import_path8.join)(dir, `${sanitizeTaskId(taskId)}.lock`);
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const fd = (0, import_fs5.openSync)(lockPath, import_fs5.constants.O_CREAT | import_fs5.constants.O_EXCL | import_fs5.constants.O_WRONLY, 384);
+      const payload = JSON.stringify({
+        pid: process.pid,
+        workerName: opts?.workerName ?? "",
+        timestamp: Date.now()
+      });
+      (0, import_fs5.writeSync)(fd, payload, null, "utf-8");
+      return { fd, path: lockPath };
+    } catch (err) {
+      if (err && typeof err === "object" && "code" in err && err.code === "EEXIST") {
+        if (attempt === 0 && isLockStale(lockPath, staleLockMs)) {
+          try {
+            (0, import_fs5.unlinkSync)(lockPath);
+          } catch {
+          }
+          continue;
+        }
+        return null;
+      }
+      throw err;
+    }
+  }
+  return null;
+}
+function releaseTaskLock(handle) {
+  try {
+    (0, import_fs5.closeSync)(handle.fd);
+  } catch {
+  }
+  try {
+    (0, import_fs5.unlinkSync)(handle.path);
+  } catch {
+  }
+}
+async function withTaskLock(teamName, taskId, fn, opts) {
+  const handle = acquireTaskLock(teamName, taskId, opts);
+  if (!handle) return null;
+  try {
+    return await fn();
+  } finally {
+    releaseTaskLock(handle);
+  }
+}
+function isLockStale(lockPath, staleLockMs) {
+  try {
+    const stat = (0, import_fs5.statSync)(lockPath);
+    const ageMs = Date.now() - stat.mtimeMs;
+    if (ageMs < staleLockMs) return false;
+    try {
+      const raw = (0, import_fs5.readFileSync)(lockPath, "utf-8");
+      const payload = JSON.parse(raw);
+      if (payload.pid && isPidAlive(payload.pid)) return false;
+    } catch {
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function sanitizeTaskId(taskId) {
+  if (!/^[A-Za-z0-9._-]+$/.test(taskId)) {
+    throw new Error(`Invalid task ID: "${taskId}" contains unsafe characters`);
+  }
+  return taskId;
+}
+function canonicalTasksDir(teamName, cwd) {
+  const root = cwd ?? process.cwd();
+  const dir = getTaskStoragePath(root, sanitizeName(teamName));
+  validateResolvedPath(dir, (0, import_path8.join)(root, ".omc", "state", "team"));
+  return dir;
+}
+
+// src/team/runtime.ts
+function workerName(index) {
+  return `worker-${index + 1}`;
+}
+function stateRoot(cwd, teamName) {
+  validateTeamName(teamName);
+  return (0, import_path9.join)(cwd, `.omc/state/team/${teamName}`);
+}
+async function writeJson(filePath, data) {
+  await (0, import_promises3.mkdir)((0, import_path9.join)(filePath, ".."), { recursive: true });
+  await (0, import_promises3.writeFile)(filePath, JSON.stringify(data, null, 2), "utf-8");
+}
+async function readJsonSafe(filePath) {
+  try {
+    const content = await (0, import_promises3.readFile)(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function parseWorkerIndex(workerNameValue) {
+  const match = workerNameValue.match(/^worker-(\d+)$/);
+  if (!match) return 0;
+  const parsed = Number.parseInt(match[1], 10) - 1;
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
+}
+function taskPath(root, taskId) {
+  return (0, import_path9.join)(root, "tasks", `${taskId}.json`);
+}
+async function writePanesTrackingFileIfPresent(runtime) {
+  const jobId = process.env.OMC_JOB_ID;
+  const omcJobsDir = process.env.OMC_JOBS_DIR;
+  if (!jobId || !omcJobsDir) return;
+  const panesPath = (0, import_path9.join)(omcJobsDir, `${jobId}-panes.json`);
+  const tempPath = `${panesPath}.tmp`;
+  await (0, import_promises3.writeFile)(
+    tempPath,
+    JSON.stringify({ paneIds: [...runtime.workerPaneIds], leaderPaneId: runtime.leaderPaneId }),
+    "utf-8"
+  );
+  await (0, import_promises3.rename)(tempPath, panesPath);
+}
+async function readTask(root, taskId) {
+  return readJsonSafe(taskPath(root, taskId));
+}
+async function writeTask(root, task) {
+  await writeJson(taskPath(root, task.id), task);
+}
+async function markTaskInProgress(root, taskId, owner, teamName, cwd) {
+  const result = await withTaskLock(teamName, taskId, async () => {
+    const task = await readTask(root, taskId);
+    if (!task || task.status !== "pending") return false;
+    task.status = "in_progress";
+    task.owner = owner;
+    task.assignedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await writeTask(root, task);
+    return true;
+  }, { cwd });
+  return result ?? false;
+}
+async function resetTaskToPending(root, taskId) {
+  const task = await readTask(root, taskId);
+  if (!task) return;
+  task.status = "pending";
+  task.owner = null;
+  task.assignedAt = void 0;
+  await writeTask(root, task);
+}
+async function markTaskFromDone(root, taskId, status, summary) {
+  const task = await readTask(root, taskId);
+  if (!task) return;
+  task.status = status;
+  task.result = summary;
+  task.summary = summary;
+  if (status === "completed") {
+    task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  } else {
+    task.failedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  await writeTask(root, task);
+}
+async function markTaskFailedDeadPane(root, taskId, workerNameValue) {
+  const task = await readTask(root, taskId);
+  if (!task) return;
+  task.status = "failed";
+  task.owner = workerNameValue;
+  task.summary = `Worker pane died before done.json was written (${workerNameValue})`;
+  task.result = task.summary;
+  task.failedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeTask(root, task);
+}
+async function nextPendingTaskIndex(runtime) {
+  const root = stateRoot(runtime.cwd, runtime.teamName);
+  for (let i = 0; i < runtime.config.tasks.length; i++) {
+    const task = await readTask(root, String(i + 1));
+    if (task?.status === "pending") return i;
+  }
+  return null;
+}
+async function notifyPaneWithRetry(sessionName, paneId, message, maxAttempts = 6, retryDelayMs = 350) {
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    if (await sendToWorker(sessionName, paneId, message)) {
+      return true;
+    }
+    if (attempt < maxAttempts) {
+      await new Promise((r) => setTimeout(r, retryDelayMs));
+    }
+  }
+  return false;
+}
+async function allTasksTerminal(runtime) {
+  const root = stateRoot(runtime.cwd, runtime.teamName);
+  for (let i = 0; i < runtime.config.tasks.length; i++) {
+    const task = await readTask(root, String(i + 1));
+    if (!task) return false;
+    if (task.status !== "completed" && task.status !== "failed") return false;
+  }
+  return true;
+}
+function buildInitialTaskInstruction(teamName, workerName2, task, taskId) {
+  const donePath = `.omc/state/team/${teamName}/workers/${workerName2}/done.json`;
+  return [
+    `## Initial Task Assignment`,
+    `Task ID: ${taskId}`,
+    `Worker: ${workerName2}`,
+    `Subject: ${task.subject}`,
+    ``,
+    task.description,
+    ``,
+    `When complete, write done signal to ${donePath}:`,
+    `{"taskId":"${taskId}","status":"completed","summary":"<brief summary>","completedAt":"<ISO timestamp>"}`,
+    ``,
+    `IMPORTANT: Execute ONLY the task assigned to you in this inbox. After writing done.json, exit immediately. Do not read from the task directory or claim other tasks.`
+  ].join("\n");
+}
+async function startTeam(config) {
+  const { teamName, agentTypes, tasks, cwd } = config;
+  validateTeamName(teamName);
+  for (const agentType of [...new Set(agentTypes)]) {
+    validateCliAvailable(agentType);
+  }
+  const root = stateRoot(cwd, teamName);
+  await (0, import_promises3.mkdir)((0, import_path9.join)(root, "tasks"), { recursive: true });
+  await (0, import_promises3.mkdir)((0, import_path9.join)(root, "mailbox"), { recursive: true });
+  await writeJson((0, import_path9.join)(root, "config.json"), config);
+  for (let i = 0; i < tasks.length; i++) {
+    const taskId = String(i + 1);
+    await writeJson((0, import_path9.join)(root, "tasks", `${taskId}.json`), {
+      id: taskId,
+      subject: tasks[i].subject,
+      description: tasks[i].description,
+      status: "pending",
+      owner: null,
+      result: null,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  const workerNames = [];
+  for (let i = 0; i < tasks.length; i++) {
+    const wName = workerName(i);
+    workerNames.push(wName);
+    const agentType = agentTypes[i % agentTypes.length] ?? agentTypes[0] ?? "claude";
+    await ensureWorkerStateDir(teamName, wName, cwd);
+    await writeWorkerOverlay({
+      teamName,
+      workerName: wName,
+      agentType,
+      tasks: tasks.map((t, idx) => ({ id: String(idx + 1), subject: t.subject, description: t.description })),
+      cwd
+    });
+  }
+  const session = await createTeamSession(teamName, 0, cwd);
+  const runtime = {
+    teamName,
+    sessionName: session.sessionName,
+    leaderPaneId: session.leaderPaneId,
+    config,
+    workerNames,
+    workerPaneIds: session.workerPaneIds,
+    // initially empty []
+    activeWorkers: /* @__PURE__ */ new Map(),
+    cwd
+  };
+  const maxConcurrentWorkers = agentTypes.length;
+  for (let i = 0; i < maxConcurrentWorkers; i++) {
+    const taskIndex = await nextPendingTaskIndex(runtime);
+    if (taskIndex == null) break;
+    await spawnWorkerForTask(runtime, workerName(i), taskIndex);
+  }
+  runtime.stopWatchdog = watchdogCliWorkers(runtime, 1e3);
+  return runtime;
+}
+async function monitorTeam(teamName, cwd, workerPaneIds) {
+  validateTeamName(teamName);
+  const monitorStartedAt = Date.now();
+  const root = stateRoot(cwd, teamName);
+  const taskScanStartedAt = Date.now();
+  const taskCounts = { pending: 0, inProgress: 0, completed: 0, failed: 0 };
+  try {
+    const { readdir } = await import("fs/promises");
+    const taskFiles = await readdir((0, import_path9.join)(root, "tasks"));
+    for (const f of taskFiles.filter((f2) => f2.endsWith(".json"))) {
+      const task = await readJsonSafe((0, import_path9.join)(root, "tasks", f));
+      if (task?.status === "pending") taskCounts.pending++;
+      else if (task?.status === "in_progress") taskCounts.inProgress++;
+      else if (task?.status === "completed") taskCounts.completed++;
+      else if (task?.status === "failed") taskCounts.failed++;
+    }
+  } catch {
+  }
+  const listTasksMs = Date.now() - taskScanStartedAt;
+  const workerScanStartedAt = Date.now();
+  const workers = [];
+  const deadWorkers = [];
+  for (let i = 0; i < workerPaneIds.length; i++) {
+    const wName = `worker-${i + 1}`;
+    const paneId = workerPaneIds[i];
+    const alive = await isWorkerAlive(paneId);
+    const heartbeatPath = (0, import_path9.join)(root, "workers", wName, "heartbeat.json");
+    const heartbeat = await readJsonSafe(heartbeatPath);
+    let stalled = false;
+    if (heartbeat?.updatedAt) {
+      const age = Date.now() - new Date(heartbeat.updatedAt).getTime();
+      stalled = age > 6e4;
+    }
+    const status = {
+      workerName: wName,
+      alive,
+      paneId,
+      currentTaskId: heartbeat?.currentTaskId,
+      lastHeartbeat: heartbeat?.updatedAt,
+      stalled
+    };
+    workers.push(status);
+    if (!alive) deadWorkers.push(wName);
+  }
+  const workerScanMs = Date.now() - workerScanStartedAt;
+  let phase = "executing";
+  if (taskCounts.inProgress === 0 && taskCounts.pending > 0 && taskCounts.completed === 0) {
+    phase = "planning";
+  } else if (taskCounts.failed > 0 && taskCounts.pending === 0 && taskCounts.inProgress === 0) {
+    phase = "fixing";
+  } else if (taskCounts.completed > 0 && taskCounts.pending === 0 && taskCounts.inProgress === 0 && taskCounts.failed === 0) {
+    phase = "completed";
+  }
+  return {
+    teamName,
+    phase,
+    workers,
+    taskCounts,
+    deadWorkers,
+    monitorPerformance: {
+      listTasksMs,
+      workerScanMs,
+      totalMs: Date.now() - monitorStartedAt
+    }
+  };
+}
+function watchdogCliWorkers(runtime, intervalMs) {
+  let tickInFlight = false;
+  let consecutiveFailures = 0;
+  const MAX_CONSECUTIVE_FAILURES = 3;
+  const unresponsiveCounts = /* @__PURE__ */ new Map();
+  const UNRESPONSIVE_KILL_THRESHOLD = 3;
+  const tick = async () => {
+    if (tickInFlight) return;
+    tickInFlight = true;
+    try {
+      const workers = [...runtime.activeWorkers.entries()];
+      if (workers.length === 0) return;
+      const root = stateRoot(runtime.cwd, runtime.teamName);
+      const [doneSignals, aliveResults] = await Promise.all([
+        Promise.all(workers.map(([wName]) => {
+          const donePath = (0, import_path9.join)(root, "workers", wName, "done.json");
+          return readJsonSafe(donePath);
+        })),
+        Promise.all(workers.map(([, active]) => isWorkerAlive(active.paneId)))
+      ]);
+      for (let i = 0; i < workers.length; i++) {
+        const [wName, active] = workers[i];
+        const donePath = (0, import_path9.join)(root, "workers", wName, "done.json");
+        const signal = doneSignals[i];
+        if (signal) {
+          unresponsiveCounts.delete(wName);
+          await markTaskFromDone(root, signal.taskId || active.taskId, signal.status, signal.summary);
+          try {
+            const { unlink } = await import("fs/promises");
+            await unlink(donePath);
+          } catch {
+          }
+          await killWorkerPane(runtime, wName, active.paneId);
+          if (!await allTasksTerminal(runtime)) {
+            const nextTaskIndexValue = await nextPendingTaskIndex(runtime);
+            if (nextTaskIndexValue != null) {
+              await spawnWorkerForTask(runtime, wName, nextTaskIndexValue);
+            }
+          }
+          continue;
+        }
+        const alive = aliveResults[i];
+        if (!alive) {
+          unresponsiveCounts.delete(wName);
+          await markTaskFailedDeadPane(root, active.taskId, wName);
+          await killWorkerPane(runtime, wName, active.paneId);
+          if (!await allTasksTerminal(runtime)) {
+            const nextTaskIndexValue = await nextPendingTaskIndex(runtime);
+            if (nextTaskIndexValue != null) {
+              await spawnWorkerForTask(runtime, wName, nextTaskIndexValue);
+            }
+          }
+          continue;
+        }
+        const heartbeatPath = (0, import_path9.join)(root, "workers", wName, "heartbeat.json");
+        const heartbeat = await readJsonSafe(heartbeatPath);
+        const isStalled = heartbeat?.updatedAt ? Date.now() - new Date(heartbeat.updatedAt).getTime() > 6e4 : false;
+        if (isStalled) {
+          const count = (unresponsiveCounts.get(wName) ?? 0) + 1;
+          unresponsiveCounts.set(wName, count);
+          if (count < UNRESPONSIVE_KILL_THRESHOLD) {
+            console.warn(`[watchdog] worker ${wName} unresponsive (${count}/${UNRESPONSIVE_KILL_THRESHOLD}), task ${active.taskId}`);
+          } else {
+            console.warn(`[watchdog] worker ${wName} unresponsive ${count} consecutive ticks \u2014 killing and reassigning task ${active.taskId}`);
+            unresponsiveCounts.delete(wName);
+            await markTaskFailedDeadPane(root, active.taskId, wName);
+            await killWorkerPane(runtime, wName, active.paneId);
+            if (!await allTasksTerminal(runtime)) {
+              const nextTaskIndexValue = await nextPendingTaskIndex(runtime);
+              if (nextTaskIndexValue != null) {
+                await spawnWorkerForTask(runtime, wName, nextTaskIndexValue);
+              }
+            }
+          }
+        } else {
+          unresponsiveCounts.delete(wName);
+        }
+      }
+      consecutiveFailures = 0;
+    } catch (err) {
+      consecutiveFailures++;
+      console.warn("[watchdog] tick error:", err);
+      if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+        console.warn(`[watchdog] ${consecutiveFailures} consecutive failures \u2014 marking team as failed`);
+        try {
+          const root = stateRoot(runtime.cwd, runtime.teamName);
+          await writeJson((0, import_path9.join)(root, "watchdog-failed.json"), {
+            failedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            consecutiveFailures,
+            lastError: err instanceof Error ? err.message : String(err)
+          });
+        } catch {
+        }
+        clearInterval(intervalId);
+      }
+    } finally {
+      tickInFlight = false;
+    }
+  };
+  const intervalId = setInterval(() => {
+    tick();
+  }, intervalMs);
+  return () => clearInterval(intervalId);
+}
+async function spawnWorkerForTask(runtime, workerNameValue, taskIndex) {
+  const root = stateRoot(runtime.cwd, runtime.teamName);
+  const taskId = String(taskIndex + 1);
+  const task = runtime.config.tasks[taskIndex];
+  if (!task) return "";
+  const marked = await markTaskInProgress(root, taskId, workerNameValue, runtime.teamName, runtime.cwd);
+  if (!marked) return "";
+  const { execFile: execFile2 } = await import("child_process");
+  const { promisify: promisify2 } = await import("util");
+  const execFileAsync = promisify2(execFile2);
+  const splitTarget = runtime.workerPaneIds.length === 0 ? runtime.leaderPaneId : runtime.workerPaneIds[runtime.workerPaneIds.length - 1];
+  const splitType = runtime.workerPaneIds.length === 0 ? "-h" : "-v";
+  const splitResult = await execFileAsync("tmux", [
+    "split-window",
+    splitType,
+    "-t",
+    splitTarget,
+    "-d",
+    "-P",
+    "-F",
+    "#{pane_id}",
+    "-c",
+    runtime.cwd
+  ]);
+  const paneId = splitResult.stdout.split("\n")[0]?.trim();
+  if (!paneId) return "";
+  const workerIndex = parseWorkerIndex(workerNameValue);
+  const agentType = runtime.config.agentTypes[workerIndex % runtime.config.agentTypes.length] ?? runtime.config.agentTypes[0] ?? "claude";
+  const usePromptMode = isPromptModeAgent(agentType);
+  const instruction = buildInitialTaskInstruction(runtime.teamName, workerNameValue, task, taskId);
+  await composeInitialInbox(runtime.teamName, workerNameValue, instruction, runtime.cwd);
+  const relInboxPath = `.omc/state/team/${runtime.teamName}/workers/${workerNameValue}/inbox.md`;
+  const envVars = getWorkerEnv(runtime.teamName, workerNameValue, agentType);
+  const [launchBinary, ...launchArgs] = buildWorkerArgv(agentType, {
+    teamName: runtime.teamName,
+    workerName: workerNameValue,
+    cwd: runtime.cwd
+  });
+  if (usePromptMode) {
+    const promptArgs = getPromptModeArgs(agentType, `Read and execute your task from: ${relInboxPath}`);
+    launchArgs.push(...promptArgs);
+  }
+  const paneConfig = {
+    teamName: runtime.teamName,
+    workerName: workerNameValue,
+    envVars,
+    launchBinary,
+    launchArgs,
+    cwd: runtime.cwd
+  };
+  await spawnWorkerInPane(runtime.sessionName, paneId, paneConfig);
+  runtime.workerPaneIds.push(paneId);
+  runtime.activeWorkers.set(workerNameValue, { paneId, taskId, spawnedAt: Date.now() });
+  try {
+    await execFileAsync("tmux", ["select-layout", "-t", runtime.sessionName, "main-vertical"]);
+  } catch {
+  }
+  try {
+    await writePanesTrackingFileIfPresent(runtime);
+  } catch {
+  }
+  if (!usePromptMode) {
+    await new Promise((r) => setTimeout(r, 4e3));
+    if (agentType === "gemini") {
+      const confirmed = await notifyPaneWithRetry(runtime.sessionName, paneId, "1");
+      if (!confirmed) {
+        await killWorkerPane(runtime, workerNameValue, paneId);
+        await resetTaskToPending(root, taskId);
+        throw new Error(`worker_notify_failed:${workerNameValue}:trust-confirm`);
+      }
+      await new Promise((r) => setTimeout(r, 800));
+    }
+    const notified = await notifyPaneWithRetry(
+      runtime.sessionName,
+      paneId,
+      `Read and execute your task from: ${relInboxPath}`
+    );
+    if (!notified) {
+      await killWorkerPane(runtime, workerNameValue, paneId);
+      await resetTaskToPending(root, taskId);
+      throw new Error(`worker_notify_failed:${workerNameValue}:initial-inbox`);
+    }
+  }
+  return paneId;
+}
+async function killWorkerPane(runtime, workerNameValue, paneId) {
+  try {
+    const { execFile: execFile2 } = await import("child_process");
+    const { promisify: promisify2 } = await import("util");
+    const execFileAsync = promisify2(execFile2);
+    await execFileAsync("tmux", ["kill-pane", "-t", paneId]);
+  } catch {
+  }
+  const paneIndex = runtime.workerPaneIds.indexOf(paneId);
+  if (paneIndex >= 0) {
+    runtime.workerPaneIds.splice(paneIndex, 1);
+  }
+  runtime.activeWorkers.delete(workerNameValue);
+  try {
+    await writePanesTrackingFileIfPresent(runtime);
+  } catch {
+  }
+}
+async function shutdownTeam(teamName, sessionName, cwd, timeoutMs = 3e4, workerPaneIds, leaderPaneId) {
+  const root = stateRoot(cwd, teamName);
+  await writeJson((0, import_path9.join)(root, "shutdown.json"), {
+    requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    teamName
+  });
+  const configData = await readJsonSafe((0, import_path9.join)(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));
+  if (!isCliWorkerTeam) {
+    const deadline = Date.now() + timeoutMs;
+    const workerCount = configData?.workerCount ?? 0;
+    const expectedAcks = Array.from({ length: workerCount }, (_, i) => `worker-${i + 1}`);
+    while (Date.now() < deadline && expectedAcks.length > 0) {
+      for (const wName of [...expectedAcks]) {
+        const ackPath = (0, import_path9.join)(root, "workers", wName, "shutdown-ack.json");
+        if ((0, import_fs6.existsSync)(ackPath)) {
+          expectedAcks.splice(expectedAcks.indexOf(wName), 1);
+        }
+      }
+      if (expectedAcks.length > 0) {
+        await new Promise((r) => setTimeout(r, 500));
+      }
+    }
+  }
+  await killTeamSession(sessionName, workerPaneIds, leaderPaneId);
+  try {
+    await (0, import_promises3.rm)(root, { recursive: true, force: true });
+  } catch {
+  }
+}
+
+// src/team/runtime-cli.ts
+async function writePanesFile(jobId, paneIds, leaderPaneId) {
+  const omcJobsDir = process.env.OMC_JOBS_DIR;
+  if (!jobId || !omcJobsDir) return;
+  const panesPath = (0, import_path10.join)(omcJobsDir, `${jobId}-panes.json`);
+  await (0, import_promises4.writeFile)(
+    panesPath + ".tmp",
+    JSON.stringify({ paneIds: [...paneIds], leaderPaneId })
+  );
+  await (0, import_promises4.rename)(panesPath + ".tmp", panesPath);
+}
+function collectTaskResults(stateRoot2) {
+  const tasksDir = (0, import_path10.join)(stateRoot2, "tasks");
+  try {
+    const files = (0, import_fs7.readdirSync)(tasksDir).filter((f) => f.endsWith(".json"));
+    return files.map((f) => {
+      try {
+        const raw = (0, import_fs7.readFileSync)((0, import_path10.join)(tasksDir, f), "utf-8");
+        const task = JSON.parse(raw);
+        return {
+          taskId: task.id ?? f.replace(".json", ""),
+          status: task.status ?? "unknown",
+          summary: task.result ?? task.summary ?? ""
+        };
+      } catch {
+        return { taskId: f.replace(".json", ""), status: "unknown", summary: "" };
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+async function main() {
+  const startTime = Date.now();
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  const rawInput = Buffer.concat(chunks).toString("utf-8").trim();
+  let input;
+  try {
+    input = JSON.parse(rawInput);
+  } catch (err) {
+    process.stderr.write(`[runtime-cli] Failed to parse stdin JSON: ${err}
+`);
+    process.exit(1);
+  }
+  const missing = [];
+  if (!input.teamName) missing.push("teamName");
+  if (!input.agentTypes || !Array.isArray(input.agentTypes) || input.agentTypes.length === 0) missing.push("agentTypes");
+  if (!input.tasks || !Array.isArray(input.tasks) || input.tasks.length === 0) missing.push("tasks");
+  if (!input.cwd) missing.push("cwd");
+  if (missing.length > 0) {
+    process.stderr.write(`[runtime-cli] Missing required fields: ${missing.join(", ")}
+`);
+    process.exit(1);
+  }
+  const {
+    teamName,
+    agentTypes,
+    tasks,
+    cwd,
+    pollIntervalMs = 5e3
+  } = input;
+  const workerCount = input.workerCount ?? agentTypes.length;
+  const stateRoot2 = (0, import_path10.join)(cwd, `.omc/state/team/${teamName}`);
+  const config = {
+    teamName,
+    workerCount,
+    agentTypes,
+    tasks,
+    cwd
+  };
+  let runtime = null;
+  let finalStatus = "failed";
+  let pollActive = true;
+  function exitCodeFor(status) {
+    return status === "completed" ? 0 : 1;
+  }
+  async function doShutdown(status) {
+    pollActive = false;
+    finalStatus = status;
+    if (runtime?.stopWatchdog) {
+      runtime.stopWatchdog();
+    }
+    const taskResults = collectTaskResults(stateRoot2);
+    if (runtime) {
+      try {
+        await shutdownTeam(
+          runtime.teamName,
+          runtime.sessionName,
+          runtime.cwd,
+          2e3,
+          runtime.workerPaneIds,
+          runtime.leaderPaneId
+        );
+      } catch (err) {
+        process.stderr.write(`[runtime-cli] shutdownTeam error: ${err}
+`);
+      }
+    }
+    const duration = (Date.now() - startTime) / 1e3;
+    const output = {
+      status: finalStatus,
+      teamName,
+      taskResults,
+      duration,
+      workerCount
+    };
+    process.stdout.write(JSON.stringify(output) + "\n");
+    process.exit(exitCodeFor(status));
+  }
+  process.on("SIGINT", () => {
+    process.stderr.write("[runtime-cli] Received SIGINT, shutting down...\n");
+    doShutdown("failed").catch(() => process.exit(1));
+  });
+  process.on("SIGTERM", () => {
+    process.stderr.write("[runtime-cli] Received SIGTERM, shutting down...\n");
+    doShutdown("failed").catch(() => process.exit(1));
+  });
+  try {
+    runtime = await startTeam(config);
+  } catch (err) {
+    process.stderr.write(`[runtime-cli] startTeam failed: ${err}
+`);
+    process.exit(1);
+  }
+  const jobId = process.env.OMC_JOB_ID;
+  try {
+    await writePanesFile(jobId, runtime.workerPaneIds, runtime.leaderPaneId);
+  } catch (err) {
+    process.stderr.write(`[runtime-cli] Failed to persist pane IDs: ${err}
+`);
+  }
+  while (pollActive) {
+    await new Promise((r) => setTimeout(r, pollIntervalMs));
+    if (!pollActive) break;
+    let snap;
+    try {
+      snap = await monitorTeam(teamName, cwd, runtime.workerPaneIds);
+    } catch (err) {
+      process.stderr.write(`[runtime-cli] monitorTeam error: ${err}
+`);
+      continue;
+    }
+    try {
+      await writePanesFile(jobId, runtime.workerPaneIds, runtime.leaderPaneId);
+    } catch (err) {
+      process.stderr.write(`[runtime-cli] Failed to persist pane IDs: ${err}
+`);
+    }
+    process.stderr.write(
+      `[runtime-cli] phase=${snap.phase} pending=${snap.taskCounts.pending} inProgress=${snap.taskCounts.inProgress} completed=${snap.taskCounts.completed} failed=${snap.taskCounts.failed} dead=${snap.deadWorkers.length} monitorMs=${snap.monitorPerformance.totalMs} tasksMs=${snap.monitorPerformance.listTasksMs} workerMs=${snap.monitorPerformance.workerScanMs}
+`
+    );
+    if (snap.phase === "completed") {
+      await doShutdown("completed");
+      return;
+    }
+    const allWorkersDead = runtime.workerPaneIds.length > 0 && snap.deadWorkers.length === runtime.workerPaneIds.length;
+    const hasOutstandingWork = snap.taskCounts.pending + snap.taskCounts.inProgress > 0;
+    const deadWorkerFailure = allWorkersDead && hasOutstandingWork;
+    const fixingWithNoWorkers = snap.phase === "fixing" && allWorkersDead;
+    if (deadWorkerFailure || fixingWithNoWorkers) {
+      process.stderr.write(`[runtime-cli] Failure detected: deadWorkerFailure=${deadWorkerFailure} fixingWithNoWorkers=${fixingWithNoWorkers}
+`);
+      await doShutdown("failed");
+      return;
+    }
+  }
+}
+if (require.main === module) {
+  main().catch((err) => {
+    process.stderr.write(`[runtime-cli] Fatal error: ${err}
+`);
+    process.exit(1);
+  });
+}