claudecode-omc 4.4.5 → 4.4.7

package/bridge/team-bridge.cjs

@@ -12,9 +12,11 @@ try {
 } catch (_e) { /* npm not available - native modules will gracefully degrade */ }
 
 "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 __export = (target, all) => {
   for (var name in all)
@@ -28,6 +30,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   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
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/team/bridge-entry.ts
@@ -37,13 +47,13 @@ __export(bridge_entry_exports, {
 });
 module.exports = __toCommonJS(bridge_entry_exports);
 var import_fs10 = require("fs");
-var import_path10 = require("path");
+var import_path12 = require("path");
 var import_os2 = require("os");
 
 // src/team/mcp-team-bridge.ts
 var import_child_process2 = require("child_process");
 var import_fs8 = require("fs");
-var import_path8 = require("path");
+var import_path10 = require("path");
 
 // src/team/fs-utils.ts
 var import_fs = require("fs");
@@ -69,31 +79,34 @@ function appendFileWithMode(filePath, data, mode = 384) {
 function ensureDirWithMode(dirPath, mode = 448) {
   if (!(0, import_fs.existsSync)(dirPath)) (0, import_fs.mkdirSync)(dirPath, { recursive: true, mode });
 }
-function safeRealpath(p) {
-  try {
-    return (0, import_fs.realpathSync)(p);
-  } catch {
-    const parent = (0, import_path.dirname)(p);
-    const name = (0, import_path.basename)(p);
+function canonicalizePath(p) {
+  const absInput = (0, import_path.resolve)(p);
+  const tail = [];
+  let probe = absInput;
+  while (true) {
     try {
-      return (0, import_path.resolve)((0, import_fs.realpathSync)(parent), name);
+      const realBase = (0, import_fs.realpathSync)(probe);
+      return tail.reduce((acc, seg) => (0, import_path.resolve)(acc, seg), realBase);
     } catch {
-      return (0, import_path.resolve)(p);
+      const parent = (0, import_path.dirname)(probe);
+      if (parent === probe) return absInput;
+      tail.unshift((0, import_path.basename)(probe));
+      probe = parent;
     }
   }
 }
 function validateResolvedPath(resolvedPath, expectedBase) {
-  const absResolved = safeRealpath(resolvedPath);
-  const absBase = safeRealpath(expectedBase);
+  const absResolved = canonicalizePath(resolvedPath);
+  const absBase = canonicalizePath(expectedBase);
   const rel = (0, import_path.relative)(absBase, absResolved);
-  if (rel.startsWith("..") || (0, import_path.resolve)(absBase, rel) !== absResolved) {
+  if (rel !== "" && (rel.startsWith("..") || (0, import_path.isAbsolute)(rel) || (0, import_path.resolve)(absBase, rel) !== absResolved)) {
     throw new Error(`Path traversal detected: "${resolvedPath}" escapes base "${expectedBase}"`);
   }
 }
 
 // src/team/task-file-ops.ts
 var import_fs3 = require("fs");
-var import_path3 = require("path");
+var import_path5 = require("path");
 
 // src/utils/paths.ts
 var import_path2 = require("path");
@@ -111,11 +124,16 @@ function getConfigDir() {
 function getClaudeConfigDir() {
   return getConfigDir();
 }
-var STALE_THRESHOLD_MS = 60 * 60 * 1e3;
+var STALE_THRESHOLD_MS = 24 * 60 * 60 * 1e3;
 
 // src/team/tmux-session.ts
 var import_child_process = require("child_process");
+var import_path3 = require("path");
+var import_util = require("util");
+var import_promises = __toESM(require("fs/promises"), 1);
 var TMUX_SESSION_PREFIX = "omc-team";
+var promisifiedExec = (0, import_util.promisify)(import_child_process.exec);
+var promisifiedExecFile = (0, import_util.promisify)(import_child_process.execFile);
 function sanitizeName(name) {
   const sanitized = name.replace(/[^a-zA-Z0-9-]/g, "");
   if (sanitized.length === 0) {
@@ -137,6 +155,38 @@ function killSession(teamName, workerName) {
   }
 }
 
+// src/team/state-paths.ts
+var import_path4 = 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, workerName) => `.omc/state/team/${teamName}/workers/${workerName}`,
+  heartbeat: (teamName, workerName) => `.omc/state/team/${teamName}/workers/${workerName}/heartbeat.json`,
+  inbox: (teamName, workerName) => `.omc/state/team/${teamName}/workers/${workerName}/inbox.md`,
+  outbox: (teamName, workerName) => `.omc/state/team/${teamName}/workers/${workerName}/outbox.jsonl`,
+  ready: (teamName, workerName) => `.omc/state/team/${teamName}/workers/${workerName}/.ready`,
+  overlay: (teamName, workerName) => `.omc/state/team/${teamName}/workers/${workerName}/AGENTS.md`,
+  shutdownAck: (teamName, workerName) => `.omc/state/team/${teamName}/workers/${workerName}/shutdown-ack.json`,
+  done: (teamName, workerName) => `.omc/state/team/${teamName}/workers/${workerName}/done.json`,
+  mailbox: (teamName, workerName) => `.omc/state/team/${teamName}/mailbox/${workerName}.jsonl`
+};
+function getTaskStoragePath(cwd, teamName, taskId) {
+  if (taskId !== void 0) {
+    return (0, import_path4.join)(cwd, TeamPaths.taskFile(teamName, taskId));
+  }
+  return (0, import_path4.join)(cwd, TeamPaths.tasks(teamName));
+}
+function getLegacyTaskStoragePath(claudeConfigDir, teamName, taskId) {
+  if (taskId !== void 0) {
+    return (0, import_path4.join)(claudeConfigDir, "tasks", teamName, `${taskId}.json`);
+  }
+  return (0, import_path4.join)(claudeConfigDir, "tasks", teamName);
+}
+
 // src/team/task-file-ops.ts
 var DEFAULT_STALE_LOCK_MS = 3e4;
 function isPidAlive(pid) {
@@ -151,9 +201,9 @@ function isPidAlive(pid) {
 }
 function acquireTaskLock(teamName, taskId, opts) {
   const staleLockMs = opts?.staleLockMs ?? DEFAULT_STALE_LOCK_MS;
-  const dir = tasksDir(teamName);
+  const dir = canonicalTasksDir(teamName, opts?.cwd);
   ensureDirWithMode(dir);
-  const lockPath = (0, import_path3.join)(dir, `${sanitizeTaskId(taskId)}.lock`);
+  const lockPath = (0, import_path5.join)(dir, `${sanitizeTaskId(taskId)}.lock`);
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
       const fd = (0, import_fs3.openSync)(lockPath, import_fs3.constants.O_CREAT | import_fs3.constants.O_EXCL | import_fs3.constants.O_WRONLY, 384);
@@ -212,19 +262,33 @@ function sanitizeTaskId(taskId) {
   }
   return taskId;
 }
-function tasksDir(teamName) {
-  const result = (0, import_path3.join)(getClaudeConfigDir(), "tasks", sanitizeName(teamName));
-  validateResolvedPath(result, (0, import_path3.join)(getClaudeConfigDir(), "tasks"));
-  return result;
+function canonicalTasksDir(teamName, cwd) {
+  const root = cwd ?? process.cwd();
+  const dir = getTaskStoragePath(root, sanitizeName(teamName));
+  validateResolvedPath(dir, (0, import_path5.join)(root, ".omc", "state", "team"));
+  return dir;
 }
-function taskPath(teamName, taskId) {
-  return (0, import_path3.join)(tasksDir(teamName), `${sanitizeTaskId(taskId)}.json`);
+function legacyTasksDir(teamName) {
+  const claudeConfigDir = getClaudeConfigDir();
+  const dir = getLegacyTaskStoragePath(claudeConfigDir, sanitizeName(teamName));
+  validateResolvedPath(dir, (0, import_path5.join)(claudeConfigDir, "tasks"));
+  return dir;
+}
+function resolveTaskPathForRead(teamName, taskId, cwd) {
+  const canonical = (0, import_path5.join)(canonicalTasksDir(teamName, cwd), `${sanitizeTaskId(taskId)}.json`);
+  if ((0, import_fs3.existsSync)(canonical)) return canonical;
+  const legacy = (0, import_path5.join)(legacyTasksDir(teamName), `${sanitizeTaskId(taskId)}.json`);
+  if ((0, import_fs3.existsSync)(legacy)) return legacy;
+  return canonical;
+}
+function resolveTaskPathForWrite(teamName, taskId, cwd) {
+  return (0, import_path5.join)(canonicalTasksDir(teamName, cwd), `${sanitizeTaskId(taskId)}.json`);
 }
-function failureSidecarPath(teamName, taskId) {
-  return (0, import_path3.join)(tasksDir(teamName), `${sanitizeTaskId(taskId)}.failure.json`);
+function failureSidecarPath(teamName, taskId, cwd) {
+  return (0, import_path5.join)(canonicalTasksDir(teamName, cwd), `${sanitizeTaskId(taskId)}.failure.json`);
 }
-function readTask(teamName, taskId) {
-  const filePath = taskPath(teamName, taskId);
+function readTask(teamName, taskId, opts) {
+  const filePath = resolveTaskPathForRead(teamName, taskId, opts?.cwd);
   if (!(0, import_fs3.existsSync)(filePath)) return null;
   try {
     const raw = (0, import_fs3.readFileSync)(filePath, "utf-8");
@@ -236,10 +300,10 @@ function readTask(teamName, taskId) {
 function updateTask(teamName, taskId, updates, opts) {
   const useLock = opts?.useLock ?? true;
   const doUpdate = () => {
-    const filePath = taskPath(teamName, taskId);
+    const readPath = resolveTaskPathForRead(teamName, taskId, opts?.cwd);
     let task;
     try {
-      const raw = (0, import_fs3.readFileSync)(filePath, "utf-8");
+      const raw = (0, import_fs3.readFileSync)(readPath, "utf-8");
       task = JSON.parse(raw);
     } catch {
       throw new Error(`Task file not found or malformed: ${taskId}`);
@@ -249,13 +313,14 @@ function updateTask(teamName, taskId, updates, opts) {
         task[key] = value;
       }
     }
-    atomicWriteJson(filePath, task);
+    const writePath = resolveTaskPathForWrite(teamName, taskId, opts?.cwd);
+    atomicWriteJson(writePath, task);
   };
   if (!useLock) {
     doUpdate();
     return;
   }
-  const handle = acquireTaskLock(teamName, taskId);
+  const handle = acquireTaskLock(teamName, taskId, { cwd: opts?.cwd });
   if (!handle) {
     if (typeof process !== "undefined" && process.stderr) {
       process.stderr.write(`[task-file-ops] WARN: could not acquire lock for task ${taskId}, updating without lock
@@ -270,27 +335,28 @@ function updateTask(teamName, taskId, updates, opts) {
     releaseTaskLock(handle);
   }
 }
-async function findNextTask(teamName, workerName) {
-  const dir = tasksDir(teamName);
+async function findNextTask(teamName, workerName, opts) {
+  const dir = canonicalTasksDir(teamName, opts?.cwd);
   if (!(0, import_fs3.existsSync)(dir)) return null;
-  const taskIds = listTaskIds(teamName);
+  const taskIds = listTaskIds(teamName, opts);
   for (const id of taskIds) {
-    const task = readTask(teamName, id);
+    const task = readTask(teamName, id, opts);
     if (!task) continue;
     if (task.status !== "pending") continue;
     if (task.owner !== workerName) continue;
-    if (!areBlockersResolved(teamName, task.blockedBy)) continue;
-    const handle = acquireTaskLock(teamName, id, { workerName });
+    if (!areBlockersResolved(teamName, task.blockedBy, opts)) continue;
+    const handle = acquireTaskLock(teamName, id, { workerName, cwd: opts?.cwd });
     if (!handle) continue;
     try {
-      const freshTask = readTask(teamName, id);
-      if (!freshTask || freshTask.status !== "pending" || freshTask.owner !== workerName || !areBlockersResolved(teamName, freshTask.blockedBy)) {
+      const freshTask = readTask(teamName, id, opts);
+      if (!freshTask || freshTask.status !== "pending" || freshTask.owner !== workerName || !areBlockersResolved(teamName, freshTask.blockedBy, opts)) {
         continue;
       }
-      const filePath = (0, import_path3.join)(tasksDir(teamName), `${sanitizeTaskId(id)}.json`);
+      const filePath = resolveTaskPathForWrite(teamName, id, opts?.cwd);
       let taskData;
       try {
-        const raw = (0, import_fs3.readFileSync)(filePath, "utf-8");
+        const readPath = resolveTaskPathForRead(teamName, id, opts?.cwd);
+        const raw = (0, import_fs3.readFileSync)(readPath, "utf-8");
         taskData = JSON.parse(raw);
       } catch {
         continue;
@@ -307,17 +373,17 @@ async function findNextTask(teamName, workerName) {
   }
   return null;
 }
-function areBlockersResolved(teamName, blockedBy) {
+function areBlockersResolved(teamName, blockedBy, opts) {
   if (!blockedBy || blockedBy.length === 0) return true;
   for (const blockerId of blockedBy) {
-    const blocker = readTask(teamName, blockerId);
+    const blocker = readTask(teamName, blockerId, opts);
     if (!blocker || blocker.status !== "completed") return false;
   }
   return true;
 }
-function writeTaskFailure(teamName, taskId, error) {
-  const filePath = failureSidecarPath(teamName, taskId);
-  const existing = readTaskFailure(teamName, taskId);
+function writeTaskFailure(teamName, taskId, error, opts) {
+  const filePath = failureSidecarPath(teamName, taskId, opts?.cwd);
+  const existing = readTaskFailure(teamName, taskId, opts);
   const sidecar = {
     taskId,
     lastError: error,
@@ -326,8 +392,8 @@ function writeTaskFailure(teamName, taskId, error) {
   };
   atomicWriteJson(filePath, sidecar);
 }
-function readTaskFailure(teamName, taskId) {
-  const filePath = failureSidecarPath(teamName, taskId);
+function readTaskFailure(teamName, taskId, opts) {
+  const filePath = failureSidecarPath(teamName, taskId, opts?.cwd);
   if (!(0, import_fs3.existsSync)(filePath)) return null;
   try {
     const raw = (0, import_fs3.readFileSync)(filePath, "utf-8");
@@ -337,52 +403,58 @@ function readTaskFailure(teamName, taskId) {
   }
 }
 var DEFAULT_MAX_TASK_RETRIES = 5;
-function isTaskRetryExhausted(teamName, taskId, maxRetries = DEFAULT_MAX_TASK_RETRIES) {
-  const failure = readTaskFailure(teamName, taskId);
+function isTaskRetryExhausted(teamName, taskId, maxRetries = DEFAULT_MAX_TASK_RETRIES, opts) {
+  const failure = readTaskFailure(teamName, taskId, opts);
   if (!failure) return false;
   return failure.retryCount >= maxRetries;
 }
-function listTaskIds(teamName) {
-  const dir = tasksDir(teamName);
-  if (!(0, import_fs3.existsSync)(dir)) return [];
-  try {
-    return (0, import_fs3.readdirSync)(dir).filter((f) => f.endsWith(".json") && !f.includes(".tmp.") && !f.includes(".failure.")).map((f) => f.replace(".json", "")).sort((a, b) => {
-      const numA = parseInt(a, 10);
-      const numB = parseInt(b, 10);
-      if (!isNaN(numA) && !isNaN(numB)) return numA - numB;
-      return a.localeCompare(b);
-    });
-  } catch {
-    return [];
-  }
+function listTaskIds(teamName, opts) {
+  const scanDir = (dir) => {
+    if (!(0, import_fs3.existsSync)(dir)) return [];
+    try {
+      return (0, import_fs3.readdirSync)(dir).filter((f) => f.endsWith(".json") && !f.includes(".tmp.") && !f.includes(".failure.") && !f.endsWith(".lock")).map((f) => f.replace(".json", ""));
+    } catch {
+      return [];
+    }
+  };
+  let ids = scanDir(canonicalTasksDir(teamName, opts?.cwd));
+  if (ids.length === 0) {
+    ids = scanDir(legacyTasksDir(teamName));
+  }
+  return ids.sort((a, b) => {
+    const numA = parseInt(a, 10);
+    const numB = parseInt(b, 10);
+    if (!isNaN(numA) && !isNaN(numB)) return numA - numB;
+    return a.localeCompare(b);
+  });
 }
 
 // src/team/inbox-outbox.ts
 var import_fs4 = require("fs");
-var import_path4 = require("path");
+var import_path6 = require("path");
 var MAX_INBOX_READ_SIZE = 10 * 1024 * 1024;
 function teamsDir(teamName) {
-  const result = (0, import_path4.join)(getClaudeConfigDir(), "teams", sanitizeName(teamName));
-  validateResolvedPath(result, (0, import_path4.join)(getClaudeConfigDir(), "teams"));
+  const result = (0, import_path6.join)(getClaudeConfigDir(), "teams", sanitizeName(teamName));
+  validateResolvedPath(result, (0, import_path6.join)(getClaudeConfigDir(), "teams"));
   return result;
 }
 function inboxPath(teamName, workerName) {
-  return (0, import_path4.join)(teamsDir(teamName), "inbox", `${sanitizeName(workerName)}.jsonl`);
+  return (0, import_path6.join)(teamsDir(teamName), "inbox", `${sanitizeName(workerName)}.jsonl`);
 }
 function inboxCursorPath(teamName, workerName) {
-  return (0, import_path4.join)(teamsDir(teamName), "inbox", `${sanitizeName(workerName)}.offset`);
+  return (0, import_path6.join)(teamsDir(teamName), "inbox", `${sanitizeName(workerName)}.offset`);
 }
 function outboxPath(teamName, workerName) {
-  return (0, import_path4.join)(teamsDir(teamName), "outbox", `${sanitizeName(workerName)}.jsonl`);
+  return (0, import_path6.join)(teamsDir(teamName), "outbox", `${sanitizeName(workerName)}.jsonl`);
 }
 function signalPath(teamName, workerName) {
-  return (0, import_path4.join)(teamsDir(teamName), "signals", `${sanitizeName(workerName)}.shutdown`);
+  return (0, import_path6.join)(teamsDir(teamName), "signals", `${sanitizeName(workerName)}.shutdown`);
 }
 function drainSignalPath(teamName, workerName) {
-  return (0, import_path4.join)(teamsDir(teamName), "signals", `${sanitizeName(workerName)}.drain`);
+  return (0, import_path6.join)(teamsDir(teamName), "signals", `${sanitizeName(workerName)}.drain`);
 }
 function ensureDir(filePath) {
-  const dir = (0, import_path4.dirname)(filePath);
+  const dir = (0, import_path6.dirname)(filePath);
   ensureDirWithMode(dir);
 }
 function appendOutbox(teamName, workerName, message) {
@@ -398,7 +470,7 @@ function rotateOutboxIfNeeded(teamName, workerName, maxLines) {
     const lines = content.split("\n").filter((l) => l.trim());
     if (lines.length <= maxLines) return;
     const keepCount = Math.floor(maxLines / 2);
-    const kept = lines.slice(-keepCount);
+    const kept = keepCount === 0 ? [] : lines.slice(-keepCount);
     const tmpPath = `${filePath}.tmp.${process.pid}.${Date.now()}`;
     writeFileWithMode(tmpPath, kept.join("\n") + "\n");
     (0, import_fs4.renameSync)(tmpPath, filePath);
@@ -475,7 +547,8 @@ function readNewInboxMessages(teamName, workerName) {
       messages.push(JSON.parse(cleanLine));
       bytesProcessed += lineBytes;
     } catch {
-      break;
+      console.warn(`[inbox-outbox] Skipping malformed JSONL line for ${workerName}: ${cleanLine.slice(0, 80)}`);
+      bytesProcessed += lineBytes;
     }
   }
   const newOffset = offset + (bytesProcessed > 0 ? bytesProcessed : 0);
@@ -525,15 +598,15 @@ function deleteDrainSignal(teamName, workerName) {
 
 // src/team/team-registration.ts
 var import_fs5 = require("fs");
-var import_path5 = require("path");
+var import_path7 = require("path");
 function configPath(teamName) {
-  const result = (0, import_path5.join)(getClaudeConfigDir(), "teams", sanitizeName(teamName), "config.json");
-  validateResolvedPath(result, (0, import_path5.join)(getClaudeConfigDir(), "teams"));
+  const result = (0, import_path7.join)(getClaudeConfigDir(), "teams", sanitizeName(teamName), "config.json");
+  validateResolvedPath(result, (0, import_path7.join)(getClaudeConfigDir(), "teams"));
   return result;
 }
 function shadowRegistryPath(workingDirectory) {
-  const result = (0, import_path5.join)(workingDirectory, ".omc", "state", "team-mcp-workers.json");
-  validateResolvedPath(result, (0, import_path5.join)(workingDirectory, ".omc", "state"));
+  const result = (0, import_path7.join)(workingDirectory, ".omc", "state", "team-mcp-workers.json");
+  validateResolvedPath(result, (0, import_path7.join)(workingDirectory, ".omc", "state"));
   return result;
 }
 function unregisterMcpWorker(teamName, workerName, workingDirectory) {
@@ -592,9 +665,9 @@ function listMcpWorkers(teamName, workingDirectory) {
 
 // src/team/heartbeat.ts
 var import_fs6 = require("fs");
-var import_path6 = require("path");
+var import_path8 = require("path");
 function heartbeatPath(workingDirectory, teamName, workerName) {
-  return (0, import_path6.join)(workingDirectory, ".omc", "state", "team-bridge", sanitizeName(teamName), `${sanitizeName(workerName)}.heartbeat.json`);
+  return (0, import_path8.join)(workingDirectory, ".omc", "state", "team-bridge", sanitizeName(teamName), `${sanitizeName(workerName)}.heartbeat.json`);
 }
 function writeHeartbeat(workingDirectory, data) {
   const filePath = heartbeatPath(workingDirectory, data.teamName, data.workerName);
@@ -767,11 +840,96 @@ function findPermissionViolations(changedPaths, permissions, cwd) {
 
 // src/team/team-status.ts
 var import_fs7 = require("fs");
-var import_path7 = require("path");
+var import_path9 = require("path");
+
+// src/team/usage-tracker.ts
+var import_node_fs = require("node:fs");
+var import_node_path4 = require("node:path");
+function getUsageLogPath(workingDirectory, teamName) {
+  return (0, import_node_path4.join)(workingDirectory, ".omc", "logs", `team-usage-${teamName}.jsonl`);
+}
+function recordTaskUsage(workingDirectory, teamName, record) {
+  const logPath = getUsageLogPath(workingDirectory, teamName);
+  const dir = (0, import_node_path4.join)(workingDirectory, ".omc", "logs");
+  validateResolvedPath(logPath, workingDirectory);
+  ensureDirWithMode(dir);
+  appendFileWithMode(logPath, JSON.stringify(record) + "\n");
+}
+function measureCharCounts(promptFilePath, outputFilePath) {
+  let promptChars = 0;
+  let responseChars = 0;
+  try {
+    if ((0, import_node_fs.existsSync)(promptFilePath)) {
+      promptChars = (0, import_node_fs.statSync)(promptFilePath).size;
+    }
+  } catch {
+  }
+  try {
+    if ((0, import_node_fs.existsSync)(outputFilePath)) {
+      responseChars = (0, import_node_fs.statSync)(outputFilePath).size;
+    }
+  } catch {
+  }
+  return { promptChars, responseChars };
+}
+function readUsageRecords(workingDirectory, teamName) {
+  const logPath = getUsageLogPath(workingDirectory, teamName);
+  if (!(0, import_node_fs.existsSync)(logPath)) return [];
+  const content = (0, import_node_fs.readFileSync)(logPath, "utf-8");
+  const lines = content.split("\n").filter((l) => l.trim());
+  const records = [];
+  for (const line of lines) {
+    try {
+      records.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return records;
+}
+function generateUsageReport(workingDirectory, teamName) {
+  const records = readUsageRecords(workingDirectory, teamName);
+  const workerMap = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    const existing = workerMap.get(r.workerName);
+    if (existing) {
+      existing.taskCount++;
+      existing.totalWallClockMs += r.wallClockMs;
+      existing.totalPromptChars += r.promptChars;
+      existing.totalResponseChars += r.responseChars;
+    } else {
+      workerMap.set(r.workerName, {
+        workerName: r.workerName,
+        provider: r.provider,
+        model: r.model,
+        taskCount: 1,
+        totalWallClockMs: r.wallClockMs,
+        totalPromptChars: r.promptChars,
+        totalResponseChars: r.responseChars
+      });
+    }
+  }
+  const workers = Array.from(workerMap.values());
+  return {
+    teamName,
+    totalWallClockMs: workers.reduce((sum, w) => sum + w.totalWallClockMs, 0),
+    taskCount: workers.reduce((sum, w) => sum + w.taskCount, 0),
+    workers
+  };
+}
+
+// src/team/team-status.ts
+function emptyUsageReport(teamName) {
+  return {
+    teamName,
+    totalWallClockMs: 0,
+    taskCount: 0,
+    workers: []
+  };
+}
 function peekRecentOutboxMessages(teamName, workerName, maxMessages = 10) {
   const safeName = sanitizeName(teamName);
   const safeWorker = sanitizeName(workerName);
-  const outboxPath2 = (0, import_path7.join)(getClaudeConfigDir(), "teams", safeName, "outbox", `${safeWorker}.jsonl`);
+  const outboxPath2 = (0, import_path9.join)(getClaudeConfigDir(), "teams", safeName, "outbox", `${safeWorker}.jsonl`);
   if (!(0, import_fs7.existsSync)(outboxPath2)) return [];
   try {
     const content = (0, import_fs7.readFileSync)(outboxPath2, "utf-8");
@@ -789,14 +947,18 @@ function peekRecentOutboxMessages(teamName, workerName, maxMessages = 10) {
     return [];
   }
 }
-function getTeamStatus(teamName, workingDirectory, heartbeatMaxAgeMs = 3e4) {
+function getTeamStatus(teamName, workingDirectory, heartbeatMaxAgeMs = 3e4, options) {
+  const startedAt = Date.now();
   const mcpWorkers = listMcpWorkers(teamName, workingDirectory);
-  const taskIds = listTaskIds(teamName);
+  const taskScanStartedAt = Date.now();
+  const taskIds = listTaskIds(teamName, { cwd: workingDirectory });
   const tasks = [];
   for (const id of taskIds) {
-    const task = readTask(teamName, id);
+    const task = readTask(teamName, id, { cwd: workingDirectory });
     if (task) tasks.push(task);
   }
+  const taskScanMs = Date.now() - taskScanStartedAt;
+  const workerScanStartedAt = Date.now();
   const workers = mcpWorkers.map((w) => {
     const heartbeat = readHeartbeat(workingDirectory, teamName, w.name);
     const alive = isWorkerAlive(workingDirectory, teamName, w.name, heartbeatMaxAgeMs);
@@ -821,6 +983,15 @@ function getTeamStatus(teamName, workingDirectory, heartbeatMaxAgeMs = 3e4) {
       taskStats
     };
   });
+  const workerScanMs = Date.now() - workerScanStartedAt;
+  const includeUsage = options?.includeUsage ?? true;
+  let usage = emptyUsageReport(teamName);
+  let usageReadMs = 0;
+  if (includeUsage) {
+    const usageReadStartedAt = Date.now();
+    usage = generateUsageReport(workingDirectory, teamName);
+    usageReadMs = Date.now() - usageReadStartedAt;
+  }
   const totalFailed = tasks.filter((t) => t.status === "completed" && t.metadata?.permanentlyFailed === true).length;
   const taskSummary = {
     total: tasks.length,
@@ -833,6 +1004,13 @@ function getTeamStatus(teamName, workingDirectory, heartbeatMaxAgeMs = 3e4) {
     teamName,
     workers,
     taskSummary,
+    usage,
+    performance: {
+      taskScanMs,
+      workerScanMs,
+      usageReadMs,
+      totalMs: Date.now() - startedAt
+    },
     lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
@@ -989,18 +1167,18 @@ function buildTaskPrompt(task, messages, config) {
   return result;
 }
 function writePromptFile(config, taskId, prompt) {
-  const dir = (0, import_path8.join)(config.workingDirectory, ".omc", "prompts");
+  const dir = (0, import_path10.join)(config.workingDirectory, ".omc", "prompts");
   ensureDirWithMode(dir);
   const filename = `team-${config.teamName}-task-${taskId}-${Date.now()}.md`;
-  const filePath = (0, import_path8.join)(dir, filename);
+  const filePath = (0, import_path10.join)(dir, filename);
   writeFileWithMode(filePath, prompt);
   return filePath;
 }
 function getOutputPath(config, taskId) {
-  const dir = (0, import_path8.join)(config.workingDirectory, ".omc", "outputs");
+  const dir = (0, import_path10.join)(config.workingDirectory, ".omc", "outputs");
   ensureDirWithMode(dir);
   const suffix = Math.random().toString(36).slice(2, 8);
-  return (0, import_path8.join)(dir, `team-${config.teamName}-task-${taskId}-${Date.now()}-${suffix}.md`);
+  return (0, import_path10.join)(dir, `team-${config.teamName}-task-${taskId}-${Date.now()}-${suffix}.md`);
 }
 function readOutputSummary(outputFile) {
   try {
@@ -1022,6 +1200,22 @@ function readOutputSummary(outputFile) {
     return "(error reading output)";
   }
 }
+function recordTaskCompletionUsage(args) {
+  const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const wallClockMs = Math.max(0, Date.now() - args.startedAt);
+  const { promptChars, responseChars } = measureCharCounts(args.promptFile, args.outputFile);
+  recordTaskUsage(args.config.workingDirectory, args.config.teamName, {
+    taskId: args.taskId,
+    workerName: args.config.workerName,
+    provider: args.provider,
+    model: args.config.model ?? "default",
+    startedAt: args.startedAtIso,
+    completedAt,
+    wallClockMs,
+    promptChars,
+    responseChars
+  });
+}
 var MAX_CODEX_OUTPUT_SIZE = 1024 * 1024;
 function parseCodexOutput(output) {
   const lines = output.trim().split("\n").filter((l) => l.trim());
@@ -1065,7 +1259,7 @@ function spawnCliProcess(provider, prompt, model, cwd, timeoutMs) {
   let cmd;
   if (provider === "codex") {
     cmd = "codex";
-    args = ["exec", "-m", model || "gpt-5.3-codex", "--json", "--full-auto", "--skip-git-repo-check"];
+    args = ["exec", "-m", model || "gpt-5.3-codex", "--json", "--dangerously-bypass-approvals-and-sandbox", "--skip-git-repo-check"];
   } else {
     cmd = "gemini";
     args = ["--yolo"];
@@ -1240,8 +1434,10 @@ async function runBridge(config) {
           await handleShutdown(config, shutdownBeforeSpawn, null);
           return;
         }
+        const taskStartedAt = Date.now();
+        const taskStartedAtIso = new Date(taskStartedAt).toISOString();
         const prompt = buildTaskPrompt(task, messages, config);
-        const _promptFile = writePromptFile(config, task.id, prompt);
+        const promptFile = writePromptFile(config, task.id, prompt);
         const outputFile = getOutputPath(config, task.id);
         log(`[bridge] Executing task ${task.id}: ${task.subject}`);
         try {
@@ -1295,6 +1491,19 @@ ${violationSummary}`,
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
               log(`[bridge] Task ${task.id} failed: permission violations (enforce mode)`);
+              try {
+                recordTaskCompletionUsage({
+                  config,
+                  taskId: task.id,
+                  promptFile,
+                  outputFile,
+                  provider,
+                  startedAt: taskStartedAt,
+                  startedAtIso: taskStartedAtIso
+                });
+              } catch (usageErr) {
+                log(`[bridge] usage tracking failed for task ${task.id}: ${usageErr.message}`);
+              }
               consecutiveErrors = 0;
             } else {
               audit(config, "permission_audit", task.id, {
@@ -1314,6 +1523,19 @@ ${violationSummary}`);
 [AUDIT WARNING: ${violations.length} permission violation(s) detected]`,
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
+              try {
+                recordTaskCompletionUsage({
+                  config,
+                  taskId: task.id,
+                  promptFile,
+                  outputFile,
+                  provider,
+                  startedAt: taskStartedAt,
+                  startedAtIso: taskStartedAtIso
+                });
+              } catch (usageErr) {
+                log(`[bridge] usage tracking failed for task ${task.id}: ${usageErr.message}`);
+              }
               log(`[bridge] Task ${task.id} completed (with ${violations.length} audit warning(s))`);
             }
           } else {
@@ -1327,6 +1549,19 @@ ${violationSummary}`);
               summary,
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
             });
+            try {
+              recordTaskCompletionUsage({
+                config,
+                taskId: task.id,
+                promptFile,
+                outputFile,
+                provider,
+                startedAt: taskStartedAt,
+                startedAtIso: taskStartedAtIso
+              });
+            } catch (usageErr) {
+              log(`[bridge] usage tracking failed for task ${task.id}: ${usageErr.message}`);
+            }
             log(`[bridge] Task ${task.id} completed`);
           }
         } catch (err) {
@@ -1358,6 +1593,19 @@ ${violationSummary}`);
               error: `Task permanently failed after ${attempt} attempts: ${errorMsg}`,
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
             });
+            try {
+              recordTaskCompletionUsage({
+                config,
+                taskId: task.id,
+                promptFile,
+                outputFile,
+                provider,
+                startedAt: taskStartedAt,
+                startedAtIso: taskStartedAtIso
+              });
+            } catch (usageErr) {
+              log(`[bridge] usage tracking failed for task ${task.id}: ${usageErr.message}`);
+            }
             log(`[bridge] Task ${task.id} permanently failed after ${attempt} attempts`);
           } else {
             updateTask(teamName, task.id, { status: "pending" });
@@ -1382,7 +1630,7 @@ ${violationSummary}`);
           idleNotified = true;
         }
         try {
-          const teamStatus = getTeamStatus(teamName, workingDirectory);
+          const teamStatus = getTeamStatus(teamName, workingDirectory, 3e4, { includeUsage: false });
           if (teamStatus.taskSummary.total > 0 && teamStatus.taskSummary.pending === 0 && teamStatus.taskSummary.inProgress === 0) {
             log(`[bridge] All team tasks complete. Auto-terminating worker.`);
             appendOutbox(teamName, workerName, {
@@ -1410,14 +1658,19 @@ ${violationSummary}`);
 }
 
 // src/lib/worktree-paths.ts
+var import_crypto = require("crypto");
 var import_child_process3 = require("child_process");
 var import_fs9 = require("fs");
-var import_path9 = require("path");
-var worktreeCache = null;
+var import_path11 = require("path");
+var MAX_WORKTREE_CACHE_SIZE = 8;
+var worktreeCacheMap = /* @__PURE__ */ new Map();
 function getWorktreeRoot(cwd) {
   const effectiveCwd = cwd || process.cwd();
-  if (worktreeCache && worktreeCache.cwd === effectiveCwd) {
-    return worktreeCache.root || null;
+  if (worktreeCacheMap.has(effectiveCwd)) {
+    const root = worktreeCacheMap.get(effectiveCwd);
+    worktreeCacheMap.delete(effectiveCwd);
+    worktreeCacheMap.set(effectiveCwd, root);
+    return root || null;
   }
   try {
     const root = (0, import_child_process3.execSync)("git rev-parse --show-toplevel", {
@@ -1425,7 +1678,13 @@ function getWorktreeRoot(cwd) {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    worktreeCache = { cwd: effectiveCwd, root };
+    if (worktreeCacheMap.size >= MAX_WORKTREE_CACHE_SIZE) {
+      const oldest = worktreeCacheMap.keys().next().value;
+      if (oldest !== void 0) {
+        worktreeCacheMap.delete(oldest);
+      }
+    }
+    worktreeCacheMap.set(effectiveCwd, root);
     return root;
   } catch {
     return null;
@@ -1434,15 +1693,15 @@ function getWorktreeRoot(cwd) {
 
 // src/team/bridge-entry.ts
 function validateConfigPath(configPath2, homeDir, claudeConfigDir) {
-  const resolved = (0, import_path10.resolve)(configPath2);
+  const resolved = (0, import_path12.resolve)(configPath2);
   const isUnderHome = resolved.startsWith(homeDir + "/") || resolved === homeDir;
-  const normalizedConfigDir = (0, import_path10.resolve)(claudeConfigDir);
-  const normalizedOmcDir = (0, import_path10.resolve)(homeDir, ".omc");
+  const normalizedConfigDir = (0, import_path12.resolve)(claudeConfigDir);
+  const normalizedOmcDir = (0, import_path12.resolve)(homeDir, ".omc");
   const hasOmcComponent = resolved.includes("/.omc/") || resolved.endsWith("/.omc");
   const isTrustedSubpath = resolved === normalizedConfigDir || resolved.startsWith(normalizedConfigDir + "/") || resolved === normalizedOmcDir || resolved.startsWith(normalizedOmcDir + "/") || hasOmcComponent;
   if (!isUnderHome || !isTrustedSubpath) return false;
   try {
-    const parentDir = (0, import_path10.resolve)(resolved, "..");
+    const parentDir = (0, import_path12.resolve)(resolved, "..");
     const realParent = (0, import_fs10.realpathSync)(parentDir);
     if (!realParent.startsWith(homeDir + "/") && realParent !== homeDir) {
       return false;
@@ -1477,7 +1736,7 @@ function main() {
     console.error("Usage: node bridge-entry.js --config <path-to-config.json>");
     process.exit(1);
   }
-  const configPath2 = (0, import_path10.resolve)(process.argv[configIdx + 1]);
+  const configPath2 = (0, import_path12.resolve)(process.argv[configIdx + 1]);
   const home = (0, import_os2.homedir)();
   const claudeConfigDir = getClaudeConfigDir();
   if (!validateConfigPath(configPath2, home, claudeConfigDir)) {