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

package/bridge/team-bridge.cjs

@@ -46,13 +46,13 @@ __export(bridge_entry_exports, {
   validateConfigPath: () => validateConfigPath
 });
 module.exports = __toCommonJS(bridge_entry_exports);
-var import_fs13 = require("fs");
+var import_fs12 = require("fs");
 var import_path12 = require("path");
 var import_os3 = require("os");
 
 // src/team/mcp-team-bridge.ts
 var import_child_process3 = require("child_process");
-var import_fs11 = require("fs");
+var import_fs10 = require("fs");
 var import_path10 = require("path");
 
 // src/team/fs-utils.ts
@@ -102,30 +102,36 @@ function validateResolvedPath(resolvedPath, expectedBase) {
 }
 
 // src/team/task-file-ops.ts
-var import_fs5 = require("fs");
+var import_fs4 = require("fs");
 var import_path5 = require("path");
 
-// src/utils/paths.ts
+// src/utils/config-dir.ts
 var import_path2 = require("path");
-var import_fs2 = require("fs");
 var import_os = require("os");
-
-// src/utils/config-dir.ts
-var import_node_os = require("node:os");
-var import_node_path = require("node:path");
-function getConfigDir() {
-  return process.env.CLAUDE_CONFIG_DIR || (0, import_node_path.join)((0, import_node_os.homedir)(), ".claude");
+function stripTrailingSep(p) {
+  if (!p.endsWith(import_path2.sep)) {
+    return p;
+  }
+  return p === (0, import_path2.parse)(p).root ? p : p.slice(0, -1);
 }
-
-// src/utils/paths.ts
 function getClaudeConfigDir() {
-  return getConfigDir();
+  const home = (0, import_os.homedir)();
+  const configured = process.env.CLAUDE_CONFIG_DIR?.trim();
+  if (!configured) {
+    return stripTrailingSep((0, import_path2.normalize)((0, import_path2.join)(home, ".claude")));
+  }
+  if (configured === "~") {
+    return stripTrailingSep((0, import_path2.normalize)(home));
+  }
+  if (configured.startsWith("~/") || configured.startsWith("~\\")) {
+    return stripTrailingSep((0, import_path2.normalize)((0, import_path2.join)(home, configured.slice(2))));
+  }
+  return stripTrailingSep((0, import_path2.normalize)(configured));
 }
-var STALE_THRESHOLD_MS = 24 * 60 * 60 * 1e3;
 
 // src/team/tmux-session.ts
 var import_child_process = require("child_process");
-var import_fs3 = require("fs");
+var import_fs2 = require("fs");
 var import_path3 = require("path");
 var import_util = require("util");
 var import_promises = __toESM(require("fs/promises"), 1);
@@ -155,7 +161,7 @@ function killSession(teamName, workerName) {
 
 // src/platform/index.ts
 var path = __toESM(require("path"), 1);
-var import_fs4 = require("fs");
+var import_fs3 = require("fs");
 
 // src/platform/process-utils.ts
 var import_child_process2 = require("child_process");
@@ -240,19 +246,19 @@ function acquireTaskLock(teamName, taskId, opts) {
   const lockPath = (0, import_path5.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 fd = (0, import_fs4.openSync)(lockPath, import_fs4.constants.O_CREAT | import_fs4.constants.O_EXCL | import_fs4.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");
+      (0, import_fs4.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);
+            (0, import_fs4.unlinkSync)(lockPath);
           } catch {
           }
           continue;
@@ -266,21 +272,21 @@ function acquireTaskLock(teamName, taskId, opts) {
 }
 function releaseTaskLock(handle) {
   try {
-    (0, import_fs5.closeSync)(handle.fd);
+    (0, import_fs4.closeSync)(handle.fd);
   } catch {
   }
   try {
-    (0, import_fs5.unlinkSync)(handle.path);
+    (0, import_fs4.unlinkSync)(handle.path);
   } catch {
   }
 }
 function isLockStale(lockPath, staleLockMs) {
   try {
-    const stat = (0, import_fs5.statSync)(lockPath);
+    const stat = (0, import_fs4.statSync)(lockPath);
     const ageMs = Date.now() - stat.mtimeMs;
     if (ageMs < staleLockMs) return false;
     try {
-      const raw = (0, import_fs5.readFileSync)(lockPath, "utf-8");
+      const raw = (0, import_fs4.readFileSync)(lockPath, "utf-8");
       const payload = JSON.parse(raw);
       if (payload.pid && isProcessAlive(payload.pid)) return false;
     } catch {
@@ -310,9 +316,9 @@ function legacyTasksDir(teamName) {
 }
 function resolveTaskPathForRead(teamName, taskId, cwd) {
   const canonical = (0, import_path5.join)(canonicalTasksDir(teamName, cwd), `${sanitizeTaskId(taskId)}.json`);
-  if ((0, import_fs5.existsSync)(canonical)) return canonical;
+  if ((0, import_fs4.existsSync)(canonical)) return canonical;
   const legacy = (0, import_path5.join)(legacyTasksDir(teamName), `${sanitizeTaskId(taskId)}.json`);
-  if ((0, import_fs5.existsSync)(legacy)) return legacy;
+  if ((0, import_fs4.existsSync)(legacy)) return legacy;
   return canonical;
 }
 function resolveTaskPathForWrite(teamName, taskId, cwd) {
@@ -323,9 +329,9 @@ function failureSidecarPath(teamName, taskId, cwd) {
 }
 function readTask(teamName, taskId, opts) {
   const filePath = resolveTaskPathForRead(teamName, taskId, opts?.cwd);
-  if (!(0, import_fs5.existsSync)(filePath)) return null;
+  if (!(0, import_fs4.existsSync)(filePath)) return null;
   try {
-    const raw = (0, import_fs5.readFileSync)(filePath, "utf-8");
+    const raw = (0, import_fs4.readFileSync)(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -337,7 +343,7 @@ function updateTask(teamName, taskId, updates, opts) {
     const readPath = resolveTaskPathForRead(teamName, taskId, opts?.cwd);
     let task;
     try {
-      const raw = (0, import_fs5.readFileSync)(readPath, "utf-8");
+      const raw = (0, import_fs4.readFileSync)(readPath, "utf-8");
       task = JSON.parse(raw);
     } catch {
       throw new Error(`Task file not found or malformed: ${taskId}`);
@@ -366,7 +372,7 @@ function updateTask(teamName, taskId, updates, opts) {
 }
 async function findNextTask(teamName, workerName, opts) {
   const dir = canonicalTasksDir(teamName, opts?.cwd);
-  if (!(0, import_fs5.existsSync)(dir)) return null;
+  if (!(0, import_fs4.existsSync)(dir)) return null;
   const taskIds = listTaskIds(teamName, opts);
   for (const id of taskIds) {
     const task = readTask(teamName, id, opts);
@@ -385,7 +391,7 @@ async function findNextTask(teamName, workerName, opts) {
       let taskData;
       try {
         const readPath = resolveTaskPathForRead(teamName, id, opts?.cwd);
-        const raw = (0, import_fs5.readFileSync)(readPath, "utf-8");
+        const raw = (0, import_fs4.readFileSync)(readPath, "utf-8");
         taskData = JSON.parse(raw);
       } catch {
         continue;
@@ -424,9 +430,9 @@ function writeTaskFailure(teamName, taskId, error, opts) {
 }
 function readTaskFailure(teamName, taskId, opts) {
   const filePath = failureSidecarPath(teamName, taskId, opts?.cwd);
-  if (!(0, import_fs5.existsSync)(filePath)) return null;
+  if (!(0, import_fs4.existsSync)(filePath)) return null;
   try {
-    const raw = (0, import_fs5.readFileSync)(filePath, "utf-8");
+    const raw = (0, import_fs4.readFileSync)(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -434,9 +440,9 @@ function readTaskFailure(teamName, taskId, opts) {
 }
 function listTaskIds(teamName, opts) {
   const scanDir = (dir) => {
-    if (!(0, import_fs5.existsSync)(dir)) return [];
+    if (!(0, import_fs4.existsSync)(dir)) return [];
     try {
-      return (0, import_fs5.readdirSync)(dir).filter((f) => f.endsWith(".json") && !f.includes(".tmp.") && !f.includes(".failure.") && !f.endsWith(".lock")).map((f) => f.replace(".json", ""));
+      return (0, import_fs4.readdirSync)(dir).filter((f) => f.endsWith(".json") && !f.includes(".tmp.") && !f.includes(".failure.") && !f.endsWith(".lock")).map((f) => f.replace(".json", ""));
     } catch {
       return [];
     }
@@ -454,7 +460,7 @@ function listTaskIds(teamName, opts) {
 }
 
 // src/team/inbox-outbox.ts
-var import_fs6 = require("fs");
+var import_fs5 = require("fs");
 var import_path6 = require("path");
 var MAX_INBOX_READ_SIZE = 10 * 1024 * 1024;
 function teamsDir(teamName) {
@@ -488,32 +494,32 @@ function appendOutbox(teamName, workerName, message) {
 }
 function rotateOutboxIfNeeded(teamName, workerName, maxLines) {
   const filePath = outboxPath(teamName, workerName);
-  if (!(0, import_fs6.existsSync)(filePath)) return;
+  if (!(0, import_fs5.existsSync)(filePath)) return;
   try {
-    const content = (0, import_fs6.readFileSync)(filePath, "utf-8");
+    const content = (0, import_fs5.readFileSync)(filePath, "utf-8");
     const lines = content.split("\n").filter((l) => l.trim());
     if (lines.length <= maxLines) return;
     const keepCount = Math.floor(maxLines / 2);
     const kept = keepCount === 0 ? [] : lines.slice(-keepCount);
     const tmpPath = `${filePath}.tmp.${process.pid}.${Date.now()}`;
     writeFileWithMode(tmpPath, kept.join("\n") + "\n");
-    (0, import_fs6.renameSync)(tmpPath, filePath);
+    (0, import_fs5.renameSync)(tmpPath, filePath);
   } catch {
   }
 }
 function rotateInboxIfNeeded(teamName, workerName, maxSizeBytes) {
   const filePath = inboxPath(teamName, workerName);
-  if (!(0, import_fs6.existsSync)(filePath)) return;
+  if (!(0, import_fs5.existsSync)(filePath)) return;
   try {
-    const stat = (0, import_fs6.statSync)(filePath);
+    const stat = (0, import_fs5.statSync)(filePath);
     if (stat.size <= maxSizeBytes) return;
-    const content = (0, import_fs6.readFileSync)(filePath, "utf-8");
+    const content = (0, import_fs5.readFileSync)(filePath, "utf-8");
     const lines = content.split("\n").filter((l) => l.trim());
     const keepCount = Math.max(1, Math.floor(lines.length / 2));
     const kept = lines.slice(-keepCount);
     const tmpPath = `${filePath}.tmp.${process.pid}.${Date.now()}`;
     writeFileWithMode(tmpPath, kept.join("\n") + "\n");
-    (0, import_fs6.renameSync)(tmpPath, filePath);
+    (0, import_fs5.renameSync)(tmpPath, filePath);
     const cursorFile = inboxCursorPath(teamName, workerName);
     atomicWriteJson(cursorFile, { bytesRead: 0 });
   } catch {
@@ -522,16 +528,16 @@ function rotateInboxIfNeeded(teamName, workerName, maxSizeBytes) {
 function readNewInboxMessages(teamName, workerName) {
   const inbox = inboxPath(teamName, workerName);
   const cursorFile = inboxCursorPath(teamName, workerName);
-  if (!(0, import_fs6.existsSync)(inbox)) return [];
+  if (!(0, import_fs5.existsSync)(inbox)) return [];
   let offset = 0;
-  if ((0, import_fs6.existsSync)(cursorFile)) {
+  if ((0, import_fs5.existsSync)(cursorFile)) {
     try {
-      const cursor = JSON.parse((0, import_fs6.readFileSync)(cursorFile, "utf-8"));
+      const cursor = JSON.parse((0, import_fs5.readFileSync)(cursorFile, "utf-8"));
       offset = cursor.bytesRead;
     } catch {
     }
   }
-  const stat = (0, import_fs6.statSync)(inbox);
+  const stat = (0, import_fs5.statSync)(inbox);
   if (stat.size < offset) {
     offset = 0;
   }
@@ -541,12 +547,12 @@ function readNewInboxMessages(teamName, workerName) {
   if (cappedSize < readSize) {
     console.warn(`[inbox-outbox] Inbox for ${workerName} exceeds ${MAX_INBOX_READ_SIZE} bytes, reading truncated`);
   }
-  const fd = (0, import_fs6.openSync)(inbox, "r");
+  const fd = (0, import_fs5.openSync)(inbox, "r");
   const buffer = Buffer.alloc(cappedSize);
   try {
-    (0, import_fs6.readSync)(fd, buffer, 0, buffer.length, offset);
+    (0, import_fs5.readSync)(fd, buffer, 0, buffer.length, offset);
   } finally {
-    (0, import_fs6.closeSync)(fd);
+    (0, import_fs5.closeSync)(fd);
   }
   const newData = buffer.toString("utf-8");
   const lastNewlineIdx = newData.lastIndexOf("\n");
@@ -583,9 +589,9 @@ function readNewInboxMessages(teamName, workerName) {
 }
 function checkShutdownSignal(teamName, workerName) {
   const filePath = signalPath(teamName, workerName);
-  if (!(0, import_fs6.existsSync)(filePath)) return null;
+  if (!(0, import_fs5.existsSync)(filePath)) return null;
   try {
-    const raw = (0, import_fs6.readFileSync)(filePath, "utf-8");
+    const raw = (0, import_fs5.readFileSync)(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -593,18 +599,18 @@ function checkShutdownSignal(teamName, workerName) {
 }
 function deleteShutdownSignal(teamName, workerName) {
   const filePath = signalPath(teamName, workerName);
-  if ((0, import_fs6.existsSync)(filePath)) {
+  if ((0, import_fs5.existsSync)(filePath)) {
     try {
-      (0, import_fs6.unlinkSync)(filePath);
+      (0, import_fs5.unlinkSync)(filePath);
     } catch {
     }
   }
 }
 function checkDrainSignal(teamName, workerName) {
   const filePath = drainSignalPath(teamName, workerName);
-  if (!(0, import_fs6.existsSync)(filePath)) return null;
+  if (!(0, import_fs5.existsSync)(filePath)) return null;
   try {
-    const raw = (0, import_fs6.readFileSync)(filePath, "utf-8");
+    const raw = (0, import_fs5.readFileSync)(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -612,20 +618,20 @@ function checkDrainSignal(teamName, workerName) {
 }
 function deleteDrainSignal(teamName, workerName) {
   const filePath = drainSignalPath(teamName, workerName);
-  if ((0, import_fs6.existsSync)(filePath)) {
+  if ((0, import_fs5.existsSync)(filePath)) {
     try {
-      (0, import_fs6.unlinkSync)(filePath);
+      (0, import_fs5.unlinkSync)(filePath);
     } catch {
     }
   }
 }
 
 // src/team/team-registration.ts
-var import_fs8 = require("fs");
+var import_fs7 = require("fs");
 var import_path7 = require("path");
 
 // src/lib/file-lock.ts
-var import_fs7 = require("fs");
+var import_fs6 = require("fs");
 var path3 = __toESM(require("path"), 1);
 
 // src/lib/atomic-write.ts
@@ -647,9 +653,9 @@ function shadowRegistryPath(workingDirectory) {
 }
 function unregisterMcpWorker(teamName, workerName, workingDirectory) {
   const configFile = configPath(teamName);
-  if ((0, import_fs8.existsSync)(configFile)) {
+  if ((0, import_fs7.existsSync)(configFile)) {
     try {
-      const raw = (0, import_fs8.readFileSync)(configFile, "utf-8");
+      const raw = (0, import_fs7.readFileSync)(configFile, "utf-8");
       const config = JSON.parse(raw);
       const members = Array.isArray(config.members) ? config.members : [];
       config.members = members.filter((m) => m.name !== workerName);
@@ -658,9 +664,9 @@ function unregisterMcpWorker(teamName, workerName, workingDirectory) {
     }
   }
   const shadowFile = shadowRegistryPath(workingDirectory);
-  if ((0, import_fs8.existsSync)(shadowFile)) {
+  if ((0, import_fs7.existsSync)(shadowFile)) {
     try {
-      const registry = JSON.parse((0, import_fs8.readFileSync)(shadowFile, "utf-8"));
+      const registry = JSON.parse((0, import_fs7.readFileSync)(shadowFile, "utf-8"));
       registry.workers = (registry.workers || []).filter((w) => w.name !== workerName);
       atomicWriteJson(shadowFile, registry);
     } catch {
@@ -673,9 +679,9 @@ function isMcpWorker(member) {
 function listMcpWorkers(teamName, workingDirectory) {
   const workers = /* @__PURE__ */ new Map();
   const configFile = configPath(teamName);
-  if ((0, import_fs8.existsSync)(configFile)) {
+  if ((0, import_fs7.existsSync)(configFile)) {
     try {
-      const raw = (0, import_fs8.readFileSync)(configFile, "utf-8");
+      const raw = (0, import_fs7.readFileSync)(configFile, "utf-8");
       const config = JSON.parse(raw);
       const members = Array.isArray(config.members) ? config.members : [];
       for (const m of members) {
@@ -687,9 +693,9 @@ function listMcpWorkers(teamName, workingDirectory) {
     }
   }
   const shadowFile = shadowRegistryPath(workingDirectory);
-  if ((0, import_fs8.existsSync)(shadowFile)) {
+  if ((0, import_fs7.existsSync)(shadowFile)) {
     try {
-      const registry = JSON.parse((0, import_fs8.readFileSync)(shadowFile, "utf-8"));
+      const registry = JSON.parse((0, import_fs7.readFileSync)(shadowFile, "utf-8"));
       for (const w of registry.workers || []) {
         workers.set(w.name, w);
       }
@@ -700,7 +706,7 @@ function listMcpWorkers(teamName, workingDirectory) {
 }
 
 // src/team/heartbeat.ts
-var import_fs9 = require("fs");
+var import_fs8 = require("fs");
 var import_path8 = require("path");
 function heartbeatPath(workingDirectory, teamName, workerName) {
   return (0, import_path8.join)(workingDirectory, ".omc", "state", "team-bridge", sanitizeName(teamName), `${sanitizeName(workerName)}.heartbeat.json`);
@@ -711,9 +717,9 @@ function writeHeartbeat(workingDirectory, data) {
 }
 function readHeartbeat(workingDirectory, teamName, workerName) {
   const filePath = heartbeatPath(workingDirectory, teamName, workerName);
-  if (!(0, import_fs9.existsSync)(filePath)) return null;
+  if (!(0, import_fs8.existsSync)(filePath)) return null;
   try {
-    const raw = (0, import_fs9.readFileSync)(filePath, "utf-8");
+    const raw = (0, import_fs8.readFileSync)(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -732,23 +738,23 @@ function isWorkerAlive(workingDirectory, teamName, workerName, maxAgeMs) {
 }
 function deleteHeartbeat(workingDirectory, teamName, workerName) {
   const filePath = heartbeatPath(workingDirectory, teamName, workerName);
-  if ((0, import_fs9.existsSync)(filePath)) {
+  if ((0, import_fs8.existsSync)(filePath)) {
     try {
-      (0, import_fs9.unlinkSync)(filePath);
+      (0, import_fs8.unlinkSync)(filePath);
     } catch {
     }
   }
 }
 
 // src/team/audit-log.ts
-var import_node_path2 = require("node:path");
+var import_node_path = require("node:path");
 var DEFAULT_MAX_LOG_SIZE = 5 * 1024 * 1024;
 function getLogPath(workingDirectory, teamName) {
-  return (0, import_node_path2.join)(workingDirectory, ".omc", "logs", `team-bridge-${teamName}.jsonl`);
+  return (0, import_node_path.join)(workingDirectory, ".omc", "logs", `team-bridge-${teamName}.jsonl`);
 }
 function logAuditEvent(workingDirectory, event) {
   const logPath = getLogPath(workingDirectory, event.teamName);
-  const dir = (0, import_node_path2.join)(workingDirectory, ".omc", "logs");
+  const dir = (0, import_node_path.join)(workingDirectory, ".omc", "logs");
   validateResolvedPath(logPath, workingDirectory);
   ensureDirWithMode(dir);
   const line = JSON.stringify(event) + "\n";
@@ -756,7 +762,7 @@ function logAuditEvent(workingDirectory, event) {
 }
 
 // src/team/permissions.ts
-var import_node_path3 = require("node:path");
+var import_node_path2 = require("node:path");
 function matchGlob(pattern, path4) {
   let pi = 0;
   let si = 0;
@@ -810,8 +816,8 @@ function matchGlob(pattern, path4) {
   return pi === pattern.length;
 }
 function isPathAllowed(permissions, filePath, workingDirectory) {
-  const absPath = (0, import_node_path3.resolve)(workingDirectory, filePath);
-  const relPath = (0, import_node_path3.relative)(workingDirectory, absPath);
+  const absPath = (0, import_node_path2.resolve)(workingDirectory, filePath);
+  const relPath = (0, import_node_path2.relative)(workingDirectory, absPath);
   if (relPath.startsWith("..")) return false;
   for (const pattern of permissions.deniedPaths) {
     if (matchGlob(pattern, relPath)) return false;
@@ -855,8 +861,8 @@ function findPermissionViolations(changedPaths, permissions, cwd) {
   const violations = [];
   for (const filePath of changedPaths) {
     if (!isPathAllowed(permissions, filePath, cwd)) {
-      const absPath = (0, import_node_path3.resolve)(cwd, filePath);
-      const relPath = (0, import_node_path3.relative)(cwd, absPath);
+      const absPath = (0, import_node_path2.resolve)(cwd, filePath);
+      const relPath = (0, import_node_path2.relative)(cwd, absPath);
       let reason;
       if (relPath.startsWith("..")) {
         reason = `Path escapes working directory: ${relPath}`;
@@ -899,18 +905,18 @@ function getBuiltinExternalDefaultModel(provider) {
 }
 
 // src/team/team-status.ts
-var import_fs10 = require("fs");
+var import_fs9 = require("fs");
 var import_path9 = require("path");
 
 // src/team/usage-tracker.ts
 var import_node_fs = require("node:fs");
-var import_node_path4 = require("node:path");
+var import_node_path3 = require("node:path");
 function getUsageLogPath(workingDirectory, teamName) {
-  return (0, import_node_path4.join)(workingDirectory, ".omc", "logs", `team-usage-${teamName}.jsonl`);
+  return (0, import_node_path3.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");
+  const dir = (0, import_node_path3.join)(workingDirectory, ".omc", "logs");
   validateResolvedPath(logPath, workingDirectory);
   ensureDirWithMode(dir);
   appendFileWithMode(logPath, JSON.stringify(record) + "\n");
@@ -990,9 +996,9 @@ function peekRecentOutboxMessages(teamName, workerName, maxMessages = 10) {
   const safeName = sanitizeName(teamName);
   const safeWorker = sanitizeName(workerName);
   const outboxPath2 = (0, import_path9.join)(getClaudeConfigDir(), "teams", safeName, "outbox", `${safeWorker}.jsonl`);
-  if (!(0, import_fs10.existsSync)(outboxPath2)) return [];
+  if (!(0, import_fs9.existsSync)(outboxPath2)) return [];
   try {
-    const content = (0, import_fs10.readFileSync)(outboxPath2, "utf-8");
+    const content = (0, import_fs9.readFileSync)(outboxPath2, "utf-8");
     const lines = content.split("\n").filter((l) => l.trim());
     const recentLines = lines.slice(-maxMessages);
     const messages = [];
@@ -1292,11 +1298,11 @@ function getOutputPath(config, taskId) {
 }
 function readOutputSummary(outputFile) {
   try {
-    if (!(0, import_fs11.existsSync)(outputFile)) return "(no output file)";
+    if (!(0, import_fs10.existsSync)(outputFile)) return "(no output file)";
     const buf = Buffer.alloc(1024);
-    const fd = (0, import_fs11.openSync)(outputFile, "r");
+    const fd = (0, import_fs10.openSync)(outputFile, "r");
     try {
-      const bytesRead = (0, import_fs11.readSync)(fd, buf, 0, 1024, 0);
+      const bytesRead = (0, import_fs10.readSync)(fd, buf, 0, 1024, 0);
       if (bytesRead === 0) return "(empty output)";
       const content = buf.toString("utf-8", 0, bytesRead);
       if (content.length > 500) {
@@ -1304,7 +1310,7 @@ function readOutputSummary(outputFile) {
       }
       return content;
     } finally {
-      (0, import_fs11.closeSync)(fd);
+      (0, import_fs10.closeSync)(fd);
     }
   } catch {
     return "(error reading output)";
@@ -1863,7 +1869,7 @@ ${violationSummary}`
 // src/lib/worktree-paths.ts
 var import_crypto = require("crypto");
 var import_child_process4 = require("child_process");
-var import_fs12 = require("fs");
+var import_fs11 = require("fs");
 var import_os2 = require("os");
 var import_path11 = require("path");
 var MAX_WORKTREE_CACHE_SIZE = 8;
@@ -1907,7 +1913,7 @@ function validateConfigPath(configPath2, homeDir, claudeConfigDir) {
   if (!isUnderHome || !isTrustedSubpath) return false;
   try {
     const parentDir = (0, import_path12.resolve)(resolved, "..");
-    const realParent = (0, import_fs13.realpathSync)(parentDir);
+    const realParent = (0, import_fs12.realpathSync)(parentDir);
     if (!realParent.startsWith(homeDir + "/") && realParent !== homeDir) {
       return false;
     }
@@ -1918,14 +1924,14 @@ function validateConfigPath(configPath2, homeDir, claudeConfigDir) {
 function validateBridgeWorkingDirectory(workingDirectory) {
   let stat;
   try {
-    stat = (0, import_fs13.statSync)(workingDirectory);
+    stat = (0, import_fs12.statSync)(workingDirectory);
   } catch {
     throw new Error(`workingDirectory does not exist: ${workingDirectory}`);
   }
   if (!stat.isDirectory()) {
     throw new Error(`workingDirectory is not a directory: ${workingDirectory}`);
   }
-  const resolved = (0, import_fs13.realpathSync)(workingDirectory);
+  const resolved = (0, import_fs12.realpathSync)(workingDirectory);
   const home = (0, import_os3.homedir)();
   if (!resolved.startsWith(home + "/") && resolved !== home) {
     throw new Error(`workingDirectory is outside home directory: ${resolved}`);
@@ -1950,7 +1956,7 @@ function main() {
   }
   let config;
   try {
-    const raw = (0, import_fs13.readFileSync)(configPath2, "utf-8");
+    const raw = (0, import_fs12.readFileSync)(configPath2, "utf-8");
     config = JSON.parse(raw);
   } catch (err) {
     console.error(`Failed to read config from ${configPath2}: ${err.message}`);