oh-my-copilot 5.5.0 → 5.6.2

package/bridge/mcp-server.cjs

@@ -18313,7 +18313,7 @@ function verifyPrivateTempFile(fd, tempPath, label, operations) {
       `${label} temporary file must be a private regular single-link file`
     );
   }
-  if (fdStats.dev !== pathStats.dev || fdStats.ino !== pathStats.ino) {
+  if (!sameFileIdentity(fdStats, pathStats)) {
     throw new Error(`${label} temporary file was replaced before rename`);
   }
 }
@@ -18325,7 +18325,7 @@ function verifyPublishedFile(fd, filePath, label, operations) {
   } catch {
     throw new Error(`${label} target was replaced at publication`);
   }
-  if (!pathStats.isFile() || fdStats.dev !== pathStats.dev || fdStats.ino !== pathStats.ino) {
+  if (!pathStats.isFile() || !sameFileIdentity(fdStats, pathStats)) {
     throw new Error(`${label} target was replaced at publication`);
   }
 }
@@ -18349,6 +18349,14 @@ function preservePriorTarget(filePath, operations) {
     return null;
   }
 }
+function sameFileIdentity(a, b) {
+  if (a.ino !== b.ino) return false;
+  const isWindows = process.platform === "win32";
+  if (isWindows && (a.dev === 0 || b.dev === 0)) {
+    return true;
+  }
+  return a.dev === b.dev;
+}
 function currentFileIdentity(filePath, operations) {
   try {
     const stats = (operations?.lstat ?? fsSync.lstatSync)(filePath);
@@ -18369,7 +18377,7 @@ function rollbackPriorTarget(filePath, backupPath, expectedIdentity, operations)
   if (expectedIdentity === null) return;
   const current = currentFileIdentity(filePath, operations);
   if (current === null) return;
-  if (expectedIdentity !== null && (current.dev !== expectedIdentity.dev || current.ino !== expectedIdentity.ino)) {
+  if (expectedIdentity !== null && !sameFileIdentity(current, expectedIdentity)) {
     return;
   }
   try {
@@ -19768,6 +19776,23 @@ function readPositiveIntEnv(name, fallback) {
 function fileUri(filePath) {
   return (0, import_url3.pathToFileURL)((0, import_path10.resolve)(filePath)).href;
 }
+function uriKey(uri) {
+  if (!uri.startsWith("file://")) {
+    return uri;
+  }
+  let decoded;
+  try {
+    decoded = decodeURIComponent(uri);
+  } catch {
+    decoded = uri;
+  }
+  const match = decoded.match(/^(file:\/\/)(\/[a-zA-Z])(:.*)$/);
+  if (match) {
+    const driveLetter = match[2].charAt(1).toUpperCase();
+    decoded = `${match[1]}/${driveLetter}${match[3]}`;
+  }
+  return decoded;
+}
 function createCancellationSignal() {
   let cancel;
   const promise = new Promise((resolveCancellation) => {
@@ -20113,10 +20138,11 @@ ${content}`;
   handleNotification(notification) {
     if (notification.method === "textDocument/publishDiagnostics") {
       const params = this.translateIncomingPayload(notification.params);
-      this.diagnostics.set(params.uri, params.diagnostics);
-      const waiters = this.diagnosticWaiters.get(params.uri);
+      const key = uriKey(params.uri);
+      this.diagnostics.set(key, params.diagnostics);
+      const waiters = this.diagnosticWaiters.get(key);
       if (waiters && waiters.length > 0) {
-        this.diagnosticWaiters.delete(params.uri);
+        this.diagnosticWaiters.delete(key);
         for (const wake of waiters) wake();
       }
     }
@@ -20315,7 +20341,7 @@ ${content}`;
     }
     const content = (0, import_fs10.readFileSync)(filePath, "utf-8");
     const languageId = this.getLanguageId(filePath);
-    this.diagnostics.delete(hostUri);
+    this.diagnostics.delete(uriKey(hostUri));
     await this.notifyWithBackpressure("textDocument/didOpen", {
       textDocument: {
         uri,
@@ -20512,7 +20538,7 @@ ${content}`;
    */
   getDiagnostics(filePath) {
     const uri = fileUri(filePath);
-    return this.diagnostics.get(uri) || [];
+    return this.diagnostics.get(uriKey(uri)) || [];
   }
   /**
    * Whether the server supports LSP 3.17 pull diagnostics (textDocument/diagnostic).
@@ -20549,24 +20575,25 @@ ${content}`;
    */
   waitForDiagnostics(filePath, timeoutMs = 2e3) {
     const uri = fileUri(filePath);
+    const key = uriKey(uri);
     try {
       this.throwIfTerminal();
     } catch (error2) {
       return Promise.reject(error2);
     }
-    if (this.diagnostics.has(uri)) {
+    if (this.diagnostics.has(key)) {
       return Promise.resolve();
     }
     return new Promise((resolve16, reject) => {
       let resolved = false;
       const removeWaiter = (waiter2) => {
-        const waiters = this.diagnosticWaiters.get(uri);
+        const waiters = this.diagnosticWaiters.get(key);
         if (!waiters) return;
         const remaining = waiters.filter((candidate) => candidate !== waiter2);
         if (remaining.length === 0) {
-          this.diagnosticWaiters.delete(uri);
+          this.diagnosticWaiters.delete(key);
         } else {
-          this.diagnosticWaiters.set(uri, remaining);
+          this.diagnosticWaiters.set(key, remaining);
         }
       };
       const waiter = (error2) => {
@@ -20587,9 +20614,9 @@ ${content}`;
           resolve16();
         }
       }, timeoutMs);
-      const existing = this.diagnosticWaiters.get(uri) || [];
+      const existing = this.diagnosticWaiters.get(key) || [];
       existing.push(waiter);
-      this.diagnosticWaiters.set(uri, existing);
+      this.diagnosticWaiters.set(key, existing);
     });
   }
   /**
@@ -24560,9 +24587,9 @@ var pythonReplTool = {
 
 // src/tools/state-tools.ts
 var import_crypto10 = require("crypto");
-var import_fs28 = require("fs");
+var import_fs29 = require("fs");
 var import_os4 = require("os");
-var import_path31 = require("path");
+var import_path32 = require("path");
 
 // src/lib/session-id.ts
 function readEnv() {
@@ -24641,10 +24668,109 @@ function validatePayload(payload, limits = {}) {
 }
 
 // src/lib/mode-state-io.ts
-var import_fs16 = require("fs");
-var import_path16 = require("path");
+var import_fs17 = require("fs");
+var import_path17 = require("path");
 var import_crypto4 = require("crypto");
 var import_module2 = require("module");
+
+// src/lib/runs-ledger.ts
+var import_fs16 = require("fs");
+var import_path16 = require("path");
+var WATCHED_RUN_MODES = ["ralph", "autopilot", "team", "ultragoal"];
+var LEDGER_TAIL_LINES = 1e3;
+function isWatchedRunMode(modeName) {
+  return WATCHED_RUN_MODES.includes(modeName);
+}
+function ledgerPath(omcRoot) {
+  return (0, import_path16.join)(omcRoot, "state", "runs", "ledger.jsonl");
+}
+function closeoutWrittenFor(omcRoot, mode, startedAt) {
+  if (!startedAt || !Number.isFinite(Date.parse(startedAt))) return false;
+  const started = Date.parse(startedAt);
+  for (const name of ["problems.md", "issues.md"]) {
+    const notepad = (0, import_path16.join)(omcRoot, "notepads", mode, name);
+    try {
+      if ((0, import_fs16.existsSync)(notepad) && (0, import_fs16.statSync)(notepad).mtimeMs > started) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function appendRunLedger(omcRoot, entry) {
+  try {
+    const dir = (0, import_path16.join)(omcRoot, "state", "runs");
+    (0, import_fs16.mkdirSync)(dir, { recursive: true });
+    const path14 = ledgerPath(omcRoot);
+    rotateIfNeeded(path14);
+    (0, import_fs16.appendFileSync)(path14, `${JSON.stringify(entry)}
+`, "utf8");
+  } catch {
+  }
+}
+function rotateIfNeeded(path14) {
+  try {
+    const stat = (0, import_fs16.statSync)(path14);
+    if (!stat.isFile()) return;
+    const lines = (0, import_fs16.readFileSync)(path14, "utf8").split("\n").filter((line) => line.trim().length > 0);
+    if (lines.length < LEDGER_TAIL_LINES) return;
+    (0, import_fs16.appendFileSync)(`${path14}.1`, `${lines.join("\n")}
+`, "utf8");
+    (0, import_fs16.writeFileSync)(path14, "", "utf8");
+  } catch {
+  }
+}
+function observeModeStateWrite(omcRoot, filePath, state) {
+  try {
+    const mode = modeFromStatePath(filePath);
+    if (!mode || !isWatchedRunMode(mode)) return;
+    if (state?.active !== true) return;
+    const key = filePath;
+    if (activeLoggedPaths.get(key)) return;
+    activeLoggedPaths.set(key, true);
+    appendRunLedger(omcRoot, {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      run: mode,
+      sessionId: sessionIdFromStatePath(filePath),
+      event: "start",
+      outcome: "running"
+    });
+  } catch {
+  }
+}
+function observeModeStateClear(omcRoot, filePath, previousState) {
+  try {
+    const mode = modeFromStatePath(filePath);
+    if (!mode || !isWatchedRunMode(mode)) return;
+    if (!previousState || previousState.active !== true) return;
+    if (previousState.active === true) activeLoggedPaths.delete(filePath);
+    appendRunLedger(omcRoot, {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      run: mode,
+      sessionId: sessionIdFromStatePath(filePath),
+      event: "end",
+      outcome: typeof previousState.current_phase === "string" && /complete|done/i.test(previousState.current_phase) ? "completed" : "cancelled",
+      closeoutWritten: closeoutWrittenFor(omcRoot, mode, typeof previousState.started_at === "string" ? previousState.started_at : void 0)
+    });
+  } catch {
+  }
+}
+function modeFromStatePath(filePath) {
+  const match = filePath.replaceAll("\\", "/").match(/\/([a-z][a-z0-9-]+)-state\.json$/);
+  return match?.[1] ?? null;
+}
+function sessionIdFromStatePath(filePath) {
+  const match = filePath.replaceAll("\\", "/").match(/\/state\/sessions\/([^/]+)(?:\/|$)/);
+  return match?.[1];
+}
+var activeLoggedPaths = /* @__PURE__ */ new Map();
+
+// src/lib/mode-state-io.ts
+function omcRootFromStatePath(filePath) {
+  const normalized = filePath.replaceAll("\\", "/");
+  const idx = normalized.lastIndexOf("/state/");
+  if (idx === -1) return null;
+  return normalized.slice(0, idx);
+}
 var require2 = (0, import_module2.createRequire)(
   importMetaUrl || (typeof __filename === "string" ? __filename : process.cwd() + "/")
 );
@@ -24716,13 +24842,13 @@ function getStateMutationLockFailureMessage() {
   return sqliteBindingLoadError;
 }
 function mutationDbPath(lockPath) {
-  let current = (0, import_path16.dirname)(lockPath);
-  while ((0, import_path16.basename)(current) !== "state") {
-    const parent = (0, import_path16.dirname)(current);
-    if (parent === current) return (0, import_path16.join)((0, import_path16.dirname)(lockPath), ".state-mutation-locks.db");
+  let current = (0, import_path17.dirname)(lockPath);
+  while ((0, import_path17.basename)(current) !== "state") {
+    const parent = (0, import_path17.dirname)(current);
+    if (parent === current) return (0, import_path17.join)((0, import_path17.dirname)(lockPath), ".state-mutation-locks.db");
     current = parent;
   }
-  return (0, import_path16.join)(current, ".state-mutation-locks.db");
+  return (0, import_path17.join)(current, ".state-mutation-locks.db");
 }
 function ownerFromRow(row) {
   if (!row || row.version !== 1 || !Number.isSafeInteger(row.pid) || row.pid <= 0 || typeof row.process_start !== "string" || typeof row.created_at !== "string" || typeof row.nonce !== "string") return null;
@@ -24732,15 +24858,15 @@ function writeAllSync2(fd, content, label) {
   const bytes = Buffer.from(content, "utf8");
   let offset = 0;
   while (offset < bytes.length) {
-    const written = (0, import_fs16.writeSync)(fd, bytes, offset, bytes.length - offset);
+    const written = (0, import_fs17.writeSync)(fd, bytes, offset, bytes.length - offset);
     if (!Number.isInteger(written) || written <= 0) throw new Error(`${label} made no progress`);
     offset += written;
   }
-  if ((0, import_fs16.fstatSync)(fd).size !== bytes.length) throw new Error(`${label} size verification failed`);
+  if ((0, import_fs17.fstatSync)(fd).size !== bytes.length) throw new Error(`${label} size verification failed`);
 }
 function readLockOwner(path14) {
   try {
-    const value = JSON.parse((0, import_fs16.readFileSync)(path14, "utf8"));
+    const value = JSON.parse((0, import_fs17.readFileSync)(path14, "utf8"));
     const pid = value.pid;
     if (value.version !== 1 || !Number.isSafeInteger(pid) || pid <= 0 || typeof value.processStart !== "string" || !/^\S+$/.test(value.processStart) || typeof value.createdAt !== "string" || !Number.isFinite(Date.parse(value.createdAt)) || typeof value.nonce !== "string" || !/^[0-9a-f-]{36}$/i.test(value.nonce)) return null;
     return value;
@@ -24753,7 +24879,7 @@ function sameOwner(left, right) {
 }
 function lockArtifactIdentity(path14) {
   try {
-    const stats = (0, import_fs16.statSync)(path14);
+    const stats = (0, import_fs17.statSync)(path14);
     return stats.isFile() ? { dev: stats.dev, ino: stats.ino } : null;
   } catch {
     return null;
@@ -24762,10 +24888,10 @@ function lockArtifactIdentity(path14) {
 function reclaimDeadLockOwner(path14, observedOwner, observedIdentity) {
   const currentOwner = readLockOwner(path14);
   const currentIdentity = lockArtifactIdentity(path14);
-  if (currentOwner === "absent" || currentOwner === null || !sameOwner(currentOwner, observedOwner) || currentIdentity === null || currentIdentity.dev !== observedIdentity.dev || currentIdentity.ino !== observedIdentity.ino) return "changed";
+  if (currentOwner === "absent" || currentOwner === null || !sameOwner(currentOwner, observedOwner) || currentIdentity === null || !sameFileIdentity(currentIdentity, observedIdentity)) return "changed";
   const quarantinePath = `${path14}.reclaim.${process.pid}.${(0, import_crypto4.randomUUID)()}`;
   try {
-    (0, import_fs16.renameSync)(path14, quarantinePath);
+    (0, import_fs17.renameSync)(path14, quarantinePath);
   } catch (error2) {
     return error2.code === "ENOENT" ? "changed" : "failed";
   }
@@ -24774,9 +24900,9 @@ function reclaimDeadLockOwner(path14, observedOwner, observedIdentity) {
   try {
     movedOwner = readLockOwner(quarantinePath);
     movedIdentity = lockArtifactIdentity(quarantinePath);
-    if (movedOwner !== "absent" && movedOwner !== null && movedIdentity !== null && movedIdentity.dev === observedIdentity.dev && movedIdentity.ino === observedIdentity.ino && sameOwner(movedOwner, observedOwner)) {
+    if (movedOwner !== "absent" && movedOwner !== null && movedIdentity !== null && sameFileIdentity(movedIdentity, observedIdentity) && sameOwner(movedOwner, observedOwner)) {
       try {
-        (0, import_fs16.unlinkSync)(quarantinePath);
+        (0, import_fs17.unlinkSync)(quarantinePath);
         return "removed";
       } catch {
       }
@@ -24784,9 +24910,9 @@ function reclaimDeadLockOwner(path14, observedOwner, observedIdentity) {
   } catch {
   }
   try {
-    (0, import_fs16.linkSync)(quarantinePath, path14);
+    (0, import_fs17.linkSync)(quarantinePath, path14);
     try {
-      (0, import_fs16.unlinkSync)(quarantinePath);
+      (0, import_fs17.unlinkSync)(quarantinePath);
     } catch {
     }
   } catch {
@@ -24804,14 +24930,14 @@ function publishLockOwner(path14, owner) {
   const tempPath = `${path14}.${owner.pid}.${owner.nonce}.tmp`;
   let fd;
   try {
-    fd = (0, import_fs16.openSync)(tempPath, "wx", 384);
+    fd = (0, import_fs17.openSync)(tempPath, "wx", 384);
     writeAllSync2(fd, JSON.stringify(owner), "lock owner publication");
-    (0, import_fs16.fsyncSync)(fd);
-    (0, import_fs16.closeSync)(fd);
+    (0, import_fs17.fsyncSync)(fd);
+    (0, import_fs17.closeSync)(fd);
     fd = void 0;
-    (0, import_fs16.linkSync)(tempPath, path14);
+    (0, import_fs17.linkSync)(tempPath, path14);
     try {
-      (0, import_fs16.unlinkSync)(tempPath);
+      (0, import_fs17.unlinkSync)(tempPath);
     } catch (error2) {
       const code = error2.code;
       if (code !== "EPERM" && code !== "EBUSY") throw error2;
@@ -24819,11 +24945,11 @@ function publishLockOwner(path14, owner) {
     return true;
   } catch {
     try {
-      if (fd !== void 0) (0, import_fs16.closeSync)(fd);
+      if (fd !== void 0) (0, import_fs17.closeSync)(fd);
     } catch {
     }
     try {
-      (0, import_fs16.unlinkSync)(tempPath);
+      (0, import_fs17.unlinkSync)(tempPath);
     } catch {
     }
     return false;
@@ -24837,7 +24963,7 @@ function openMutationDb(lockPath) {
     const dbPath = mutationDbPath(lockPath);
     for (const sidecar of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`, `${dbPath}-journal`]) {
       try {
-        const stat = (0, import_fs16.statSync)(sidecar);
+        const stat = (0, import_fs17.statSync)(sidecar);
         if (!stat.isFile() || stat.nlink !== 1) {
           if (process.env.OMC_LOCK_DEBUG) console.error(`[lock-debug] openMutationDb sidecar-reject ${sidecar} isFile=${stat.isFile()} nlink=${stat.nlink}`);
           return null;
@@ -24869,9 +24995,9 @@ function acquireFileLockAt(path14, attempts) {
   lastMutationLockFailureDetail = null;
   const key = (() => {
     try {
-      return (0, import_path16.resolve)((0, import_fs16.realpathSync)((0, import_path16.dirname)(path14)), (0, import_path16.basename)(path14));
+      return (0, import_path17.resolve)((0, import_fs17.realpathSync)((0, import_path17.dirname)(path14)), (0, import_path17.basename)(path14));
     } catch {
-      return (0, import_path16.resolve)(path14);
+      return (0, import_path17.resolve)(path14);
     }
   })();
   const processStart = ownProcessStartIdentity();
@@ -24891,14 +25017,14 @@ function acquireFileLockAt(path14, attempts) {
     const tempPath = `${path14}.${owner.pid}.${owner.nonce}.tmp`;
     let fd;
     try {
-      fd = (0, import_fs16.openSync)(tempPath, "wx", 384);
+      fd = (0, import_fs17.openSync)(tempPath, "wx", 384);
       writeAllSync2(fd, JSON.stringify(owner), "lock owner publication");
-      (0, import_fs16.fsyncSync)(fd);
-      (0, import_fs16.closeSync)(fd);
+      (0, import_fs17.fsyncSync)(fd);
+      (0, import_fs17.closeSync)(fd);
       fd = void 0;
-      (0, import_fs16.linkSync)(tempPath, path14);
+      (0, import_fs17.linkSync)(tempPath, path14);
       try {
-        (0, import_fs16.unlinkSync)(tempPath);
+        (0, import_fs17.unlinkSync)(tempPath);
       } catch (error2) {
         const code = error2.code;
         if (code !== "EPERM" && code !== "EBUSY") throw error2;
@@ -24910,11 +25036,11 @@ function acquireFileLockAt(path14, attempts) {
       return lock;
     } catch (error2) {
       try {
-        if (fd !== void 0) (0, import_fs16.closeSync)(fd);
+        if (fd !== void 0) (0, import_fs17.closeSync)(fd);
       } catch {
       }
       try {
-        (0, import_fs16.unlinkSync)(tempPath);
+        (0, import_fs17.unlinkSync)(tempPath);
       } catch {
       }
       const code = error2?.code;
@@ -24923,18 +25049,20 @@ function acquireFileLockAt(path14, attempts) {
         lastMutationLockFailure = "unverifiable";
         return null;
       }
-      const existing = readLockOwner(path14);
-      if (existing === "absent") continue;
-      if (!existing) {
-        lastMutationLockFailure = "unverifiable";
-        return null;
-      }
       const observedIdentity = lockArtifactIdentity(path14);
       if (observedIdentity === null) {
         if (readLockOwner(path14) === "absent") continue;
         lastMutationLockFailure = "unverifiable";
         return null;
       }
+      const existing = readLockOwner(path14);
+      if (existing === "absent") continue;
+      if (!existing) {
+        lastMutationLockFailure = "unverifiable";
+        return null;
+      }
+      const recheck = lockArtifactIdentity(path14);
+      if (!recheck || !sameFileIdentity(recheck, observedIdentity)) continue;
       const live = verifiedLiveOwner !== null && sameOwner(existing, verifiedLiveOwner) ? true : ownerLive(existing);
       if (live === null) {
         lastMutationLockFailure = "unverifiable";
@@ -24971,12 +25099,12 @@ function cachedOwnerLive(owner, verified, slot, probe) {
 }
 function acquireLockAt(path14, attempts = 50, verified = { row: null, artifact: null, dead: [] }) {
   lastMutationLockFailureDetail = null;
-  (0, import_fs16.mkdirSync)((0, import_path16.dirname)(path14), { recursive: true });
+  (0, import_fs17.mkdirSync)((0, import_path17.dirname)(path14), { recursive: true });
   const key = (() => {
     try {
-      return (0, import_path16.resolve)((0, import_fs16.realpathSync)((0, import_path16.dirname)(path14)), (0, import_path16.basename)(path14));
+      return (0, import_path17.resolve)((0, import_fs17.realpathSync)((0, import_path17.dirname)(path14)), (0, import_path17.basename)(path14));
     } catch {
-      return (0, import_path16.resolve)(path14);
+      return (0, import_path17.resolve)(path14);
     }
   })();
   const held = localLocks.get(key);
@@ -25165,7 +25293,7 @@ function releaseMutationLock(lock) {
         console.error(`[omc-lock] state_mutation_lock_release_failed: ${lock.path}`);
         return false;
       }
-      (0, import_fs16.unlinkSync)(lock.path);
+      (0, import_fs17.unlinkSync)(lock.path);
       return true;
     } catch (error2) {
       abandonedOwnNonces.add(lock.owner.nonce);
@@ -25192,7 +25320,7 @@ function releaseMutationLock(lock) {
           console.error(`[omc-lock] state_mutation_lock_release_failed: ${lock.path}`);
           return false;
         }
-        if (artifact !== "absent") (0, import_fs16.unlinkSync)(lock.path);
+        if (artifact !== "absent") (0, import_fs17.unlinkSync)(lock.path);
         lock.db.prepare("DELETE FROM state_mutation_locks WHERE lock_key = ?").run(lock.key);
         lock.db.exec("COMMIT");
         return true;
@@ -25257,6 +25385,10 @@ function writeStateFileLocked(filePath, state) {
   } catch {
     success = false;
   }
+  if (success) {
+    const omcRoot = omcRootFromStatePath(filePath);
+    if (omcRoot) observeModeStateWrite(omcRoot, filePath, state);
+  }
   return releaseMutationLock(lock) && success;
 }
 function clearStateFileLockedIf(filePath, predicate, recoveryOptions, expectedGeneration) {
@@ -25274,14 +25406,14 @@ function clearStateFileLockedIf(filePath, predicate, recoveryOptions, expectedGe
   if (!lock) return "failed";
   let result = null;
   try {
-    if (!(0, import_fs16.existsSync)(filePath)) {
+    if (!(0, import_fs17.existsSync)(filePath)) {
       result = "skipped";
     } else if (expectedGeneration && !sameStateFileGeneration(filePath, expectedGeneration)) {
       result = "skipped";
     } else {
       let current;
       try {
-        current = JSON.parse((0, import_fs16.readFileSync)(filePath, "utf8"));
+        current = JSON.parse((0, import_fs17.readFileSync)(filePath, "utf8"));
       } catch {
         current = void 0;
       }
@@ -25296,8 +25428,10 @@ function clearStateFileLockedIf(filePath, predicate, recoveryOptions, expectedGe
         }
         if (result !== null) {
         } else {
-          (0, import_fs16.unlinkSync)(filePath);
+          (0, import_fs17.unlinkSync)(filePath);
           result = "cleared";
+          const omcRoot = omcRootFromStatePath(filePath);
+          if (omcRoot) observeModeStateClear(omcRoot, filePath, current);
         }
       }
     }
@@ -25317,17 +25451,17 @@ function writeStateFileLockedIf(filePath, predicate, transform2) {
       delete process.env.OMC_TEST_CONDITIONAL_WRITE_REPLACEMENT_BASE64;
     }
   }
-  if (!(0, import_fs16.existsSync)(filePath)) return "skipped";
+  if (!(0, import_fs17.existsSync)(filePath)) return "skipped";
   const lock = acquireMutationLock(filePath);
   if (!lock) return "failed";
   let result = "failed";
   try {
-    if (!(0, import_fs16.existsSync)(filePath)) {
+    if (!(0, import_fs17.existsSync)(filePath)) {
       result = "skipped";
     } else {
       let current;
       try {
-        current = JSON.parse((0, import_fs16.readFileSync)(filePath, "utf8"));
+        current = JSON.parse((0, import_fs17.readFileSync)(filePath, "utf8"));
       } catch {
         current = void 0;
       }
@@ -25368,9 +25502,9 @@ function writeStateFileLockedCreateIf(filePath, predicate, transform2) {
     }
     let current = null;
     let parseFailed = false;
-    if ((0, import_fs16.existsSync)(filePath)) {
+    if ((0, import_fs17.existsSync)(filePath)) {
       try {
-        current = JSON.parse((0, import_fs16.readFileSync)(filePath, "utf8"));
+        current = JSON.parse((0, import_fs17.readFileSync)(filePath, "utf8"));
       } catch (error2) {
         if (process.env.OMC_LOCK_DEBUG) console.error(`[lock-debug] CreateIf JSON-parse-failed ${filePath} ${error2?.message}`);
         parseFailed = true;
@@ -25440,36 +25574,36 @@ function publishEmergencyFileExclusive(path14, content) {
   let fd;
   try {
     if (!tempPath) return false;
-    (0, import_fs16.mkdirSync)((0, import_path16.dirname)(path14), { recursive: true });
-    fd = (0, import_fs16.openSync)(tempPath, "wx", 384);
+    (0, import_fs17.mkdirSync)((0, import_path17.dirname)(path14), { recursive: true });
+    fd = (0, import_fs17.openSync)(tempPath, "wx", 384);
     const bytes = Buffer.from(content);
     let offset = 0;
     while (offset < bytes.length) {
-      const written = (0, import_fs16.writeSync)(fd, bytes, offset, bytes.length - offset);
+      const written = (0, import_fs17.writeSync)(fd, bytes, offset, bytes.length - offset);
       if (written <= 0) throw new Error("emergency publication made no progress");
       offset += written;
     }
-    (0, import_fs16.fsyncSync)(fd);
-    if ((0, import_fs16.statSync)(tempPath).size !== bytes.length) throw new Error("emergency publication truncated");
-    (0, import_fs16.closeSync)(fd);
+    (0, import_fs17.fsyncSync)(fd);
+    if ((0, import_fs17.statSync)(tempPath).size !== bytes.length) throw new Error("emergency publication truncated");
+    (0, import_fs17.closeSync)(fd);
     fd = void 0;
-    (0, import_fs16.linkSync)(tempPath, path14);
-    (0, import_fs16.unlinkSync)(tempPath);
+    (0, import_fs17.linkSync)(tempPath, path14);
+    (0, import_fs17.unlinkSync)(tempPath);
     return true;
   } catch (error2) {
-    if (process.env.OMC_LOCK_DEBUG) console.error(`[lock-debug] publishEmergencyFileExclusive failed path=${path14} tempPath=${tempPath} pathExists=${(0, import_fs16.existsSync)(path14)} err=${error2?.code} ${error2?.message}`);
+    if (process.env.OMC_LOCK_DEBUG) console.error(`[lock-debug] publishEmergencyFileExclusive failed path=${path14} tempPath=${tempPath} pathExists=${(0, import_fs17.existsSync)(path14)} err=${error2?.code} ${error2?.message}`);
     return false;
   } finally {
     if (fd !== void 0) {
       try {
-        (0, import_fs16.closeSync)(fd);
+        (0, import_fs17.closeSync)(fd);
       } catch {
       }
     }
     if (tempPath) {
       const generation = fileIdentity(tempPath);
       try {
-        if (generation && sameFile(tempPath, generation)) (0, import_fs16.unlinkSync)(tempPath);
+        if (generation && sameFile(tempPath, generation)) (0, import_fs17.unlinkSync)(tempPath);
       } catch {
       }
     }
@@ -25497,7 +25631,7 @@ function acquireRecoveryClaim(path14, attempts = 50) {
       return null;
     }
     try {
-      (0, import_fs16.unlinkSync)(path14);
+      (0, import_fs17.unlinkSync)(path14);
     } catch (error2) {
       releaseMutationLock(lock);
       if (process.env.OMC_LOCK_DEBUG) console.error(`[lock-debug] acquireRecoveryClaim existing-unlink-failed ${path14} ${error2.code}`);
@@ -25514,7 +25648,7 @@ function acquireRecoveryClaim(path14, attempts = 50) {
 }
 function readRecoveryClaim(path14) {
   try {
-    const owner = JSON.parse((0, import_fs16.readFileSync)(path14, "utf8"));
+    const owner = JSON.parse((0, import_fs17.readFileSync)(path14, "utf8"));
     return owner.version === 1 && Number.isSafeInteger(owner.pid) && owner.pid > 0 && typeof owner.processStart === "string" && typeof owner.createdAt === "string" && typeof owner.nonce === "string" ? owner : null;
   } catch {
     return null;
@@ -25527,9 +25661,9 @@ function releaseRecoveryClaim(path14, owner) {
   const guardPath = `${path14}.recovery.guard`;
   const key = (() => {
     try {
-      return (0, import_path16.resolve)((0, import_fs16.realpathSync)((0, import_path16.dirname)(guardPath)), (0, import_path16.basename)(guardPath));
+      return (0, import_path17.resolve)((0, import_fs17.realpathSync)((0, import_path17.dirname)(guardPath)), (0, import_path17.basename)(guardPath));
     } catch {
-      return (0, import_path16.resolve)(guardPath);
+      return (0, import_path17.resolve)(guardPath);
     }
   })();
   const lock = localLocks.get(key);
@@ -25539,7 +25673,7 @@ function releaseRecoveryClaim(path14, owner) {
     if (current && sameRecoveryClaim(current, owner)) {
       for (let attempt = 0; attempt < 10; attempt += 1) {
         try {
-          (0, import_fs16.unlinkSync)(path14);
+          (0, import_fs17.unlinkSync)(path14);
           break;
         } catch (error2) {
           if (error2.code === "ENOENT") break;
@@ -25560,7 +25694,7 @@ function createEmergencyJournal(path14, journal) {
 }
 function readEmergencyJournal(path14) {
   try {
-    const journal = JSON.parse((0, import_fs16.readFileSync)(path14, "utf8"));
+    const journal = JSON.parse((0, import_fs17.readFileSync)(path14, "utf8"));
     if (journal.version !== 1 || typeof journal.transactionId !== "string" || !/^[0-9a-f-]{36}$/i.test(journal.transactionId) || !journal.owner || !Number.isInteger(journal.owner.pid) || journal.owner.pid <= 0 || typeof journal.owner.processStart !== "string" || typeof journal.owner.nonce !== "string" || !/^[0-9a-f-]{36}$/i.test(journal.owner.nonce) || journal.sessionOwner !== void 0 && typeof journal.sessionOwner !== "string" || journal.originalDigest !== void 0 && (typeof journal.originalDigest !== "string" || !/^[0-9a-f]{64}$/i.test(journal.originalDigest)) || journal.intendedDigest !== void 0 && (typeof journal.intendedDigest !== "string" || !/^[0-9a-f]{64}$/i.test(journal.intendedDigest)) || journal.intent !== void 0 && journal.intent !== "clear" && journal.intent !== "publish" || typeof journal.quarantinePath !== "string" || journal.phase !== "preparing" && journal.phase !== "prepared" && journal.phase !== "quarantined" && journal.phase !== "published") return null;
     const complete = typeof journal.originalDigest === "string" && (journal.intent === "clear" || journal.intent === "publish" && typeof journal.intendedDigest === "string");
     return journal.phase === "preparing" || complete ? journal : null;
@@ -25570,7 +25704,7 @@ function readEmergencyJournal(path14) {
 }
 function fileIdentity(path14) {
   try {
-    const stat = (0, import_fs16.statSync)(path14);
+    const stat = (0, import_fs17.statSync)(path14);
     return { dev: stat.dev, ino: stat.ino };
   } catch {
     return null;
@@ -25580,7 +25714,7 @@ function sameStateFileGeneration(path14, expected) {
   try {
     const identity = fileIdentity(path14);
     if (!identity || identity.dev !== expected.dev || identity.ino !== expected.ino) return false;
-    return stateDigest((0, import_fs16.readFileSync)(path14, "utf8")) === expected.digest;
+    return stateDigest((0, import_fs17.readFileSync)(path14, "utf8")) === expected.digest;
   } catch {
     return false;
   }
@@ -25599,29 +25733,29 @@ function replaceGenerationForTest(path14) {
 }
 function sameFile(path14, expected) {
   const actual = fileIdentity(path14);
-  return actual !== null && actual.dev === expected.dev && actual.ino === expected.ino;
+  return actual !== null && sameFileIdentity(actual, expected);
 }
 function reconcileEmergencyPublicationTemps(filePath, authorizeState) {
-  const directory = (0, import_path16.dirname)(filePath);
+  const directory = (0, import_path17.dirname)(filePath);
   const base = filePath.slice(directory.length + 1).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const pattern = new RegExp(`^${base}\\.emergency-(journal\\.json|recovery\\.claim|quarantine\\.[0-9a-f-]{36}\\.payload)\\.(\\d+)\\.([^.]+)\\.([0-9a-f-]{36})\\.tmp$`, "i");
   let names;
   try {
-    names = (0, import_fs16.readdirSync)(directory);
+    names = (0, import_fs17.readdirSync)(directory);
   } catch (error2) {
     return error2.code === "ENOENT";
   }
   for (const name of names) {
     const match = pattern.exec(name);
     if (!match) continue;
-    const path14 = (0, import_path16.join)(directory, name);
+    const path14 = (0, import_path17.join)(directory, name);
     const matchedProcessStart = decodeProcessStartFromFilename(match[3]);
     const currentStart = processStartIdentity(Number(match[2]));
     if (currentStart === null || currentStart === matchedProcessStart) return false;
     const generation = fileIdentity(path14);
     try {
       if (!generation) return false;
-      const raw = (0, import_fs16.readFileSync)(path14, "utf8");
+      const raw = (0, import_fs17.readFileSync)(path14, "utf8");
       if (authorizeState) {
         if (match[1] === "journal.json") {
           const journal = readEmergencyJournal(path14);
@@ -25634,8 +25768,8 @@ function reconcileEmergencyPublicationTemps(filePath, authorizeState) {
           if (!claim || claim.pid !== Number(match[2]) || claim.processStart !== matchedProcessStart || claim.nonce !== match[4]) return false;
         }
       }
-      if (!sameFile(path14, generation) || stateDigest((0, import_fs16.readFileSync)(path14, "utf8")) !== stateDigest(raw)) return false;
-      (0, import_fs16.unlinkSync)(path14);
+      if (!sameFile(path14, generation) || stateDigest((0, import_fs17.readFileSync)(path14, "utf8")) !== stateDigest(raw)) return false;
+      (0, import_fs17.unlinkSync)(path14);
     } catch {
       return false;
     }
@@ -25644,12 +25778,12 @@ function reconcileEmergencyPublicationTemps(filePath, authorizeState) {
 }
 function captureAndUnlinkPrimary(filePath, quarantinePath, expectedDigest) {
   try {
-    (0, import_fs16.linkSync)(filePath, quarantinePath);
+    (0, import_fs17.linkSync)(filePath, quarantinePath);
     const captured = fileIdentity(quarantinePath);
-    if (!captured || stateDigest((0, import_fs16.readFileSync)(quarantinePath, "utf8")) !== expectedDigest || !sameFile(filePath, captured)) return false;
+    if (!captured || stateDigest((0, import_fs17.readFileSync)(quarantinePath, "utf8")) !== expectedDigest || !sameFile(filePath, captured)) return false;
     emergencyReplaceAtCaptureBoundary(filePath);
-    if (!sameFile(filePath, captured) || stateDigest((0, import_fs16.readFileSync)(filePath, "utf8")) !== expectedDigest) return false;
-    (0, import_fs16.unlinkSync)(filePath);
+    if (!sameFile(filePath, captured) || stateDigest((0, import_fs17.readFileSync)(filePath, "utf8")) !== expectedDigest) return false;
+    (0, import_fs17.unlinkSync)(filePath);
     return true;
   } catch {
     return false;
@@ -25660,16 +25794,16 @@ function removeOwnedEmergencyArtifacts(journalPath, journal, removeQuarantine) {
     if (!journalIsOwned(journalPath, journal.transactionId, journal.owner)) return false;
     if (removeQuarantine) {
       try {
-        (0, import_fs16.unlinkSync)(journal.quarantinePath);
+        (0, import_fs17.unlinkSync)(journal.quarantinePath);
       } catch {
       }
     }
     try {
-      (0, import_fs16.unlinkSync)(`${journal.quarantinePath}.payload`);
+      (0, import_fs17.unlinkSync)(`${journal.quarantinePath}.payload`);
     } catch {
     }
     if (!journalIsOwned(journalPath, journal.transactionId, journal.owner)) return false;
-    (0, import_fs16.unlinkSync)(journalPath);
+    (0, import_fs17.unlinkSync)(journalPath);
     return true;
   } catch {
     return false;
@@ -25683,11 +25817,11 @@ function recoveryGenerationsAuthorized(filePath, journal, authorizeState) {
   ];
   let authenticatedJournalGeneration = journal === null;
   for (const path14 of paths) {
-    if (!(0, import_fs16.existsSync)(path14)) continue;
+    if (!(0, import_fs17.existsSync)(path14)) continue;
     let raw;
     let state;
     try {
-      raw = (0, import_fs16.readFileSync)(path14, "utf8");
+      raw = (0, import_fs17.readFileSync)(path14, "utf8");
       const parsed = JSON.parse(raw);
       if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return false;
       state = parsed;
@@ -25700,16 +25834,16 @@ function recoveryGenerationsAuthorized(filePath, journal, authorizeState) {
   return authenticatedJournalGeneration;
 }
 function hasUnattributableRecoveryClaimArtifact(filePath, recoveryClaim) {
-  const directory = (0, import_path16.dirname)(filePath);
+  const directory = (0, import_path17.dirname)(filePath);
   const base = filePath.slice(directory.length + 1).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const tempPattern = new RegExp(`^${base}\\.emergency-recovery\\.claim\\.\\d+\\.[^.]+\\.[0-9a-f-]{36}\\.tmp$`, "i");
   try {
-    if ((0, import_fs16.readdirSync)(directory).some((name) => tempPattern.test(name))) {
+    if ((0, import_fs17.readdirSync)(directory).some((name) => tempPattern.test(name))) {
       if (process.env.OMC_LOCK_DEBUG) console.error(`[lock-debug] hasUnattributable temp-match ${filePath}`);
       return true;
     }
     const claimPath = `${filePath}.emergency-recovery.claim`;
-    if (!(0, import_fs16.existsSync)(claimPath)) {
+    if (!(0, import_fs17.existsSync)(claimPath)) {
       const result2 = recoveryClaim !== void 0;
       if (result2 && process.env.OMC_LOCK_DEBUG) console.error(`[lock-debug] hasUnattributable no-claim-file-but-recoveryClaim-set ${filePath}`);
       return result2;
@@ -25731,10 +25865,10 @@ function sharedRecoveryArtifactsAuthorized(filePath, authorizeState, recoveryCla
   if (!authorizeState) return true;
   if (hasUnattributableRecoveryClaimArtifact(filePath, recoveryClaim)) return false;
   const journalPath = emergencyJournalPath(filePath);
-  if (!(0, import_fs16.existsSync)(journalPath)) {
-    if (!(0, import_fs16.existsSync)(filePath)) return true;
+  if (!(0, import_fs17.existsSync)(journalPath)) {
+    if (!(0, import_fs17.existsSync)(filePath)) return true;
     try {
-      const state = JSON.parse((0, import_fs16.readFileSync)(filePath, "utf8"));
+      const state = JSON.parse((0, import_fs17.readFileSync)(filePath, "utf8"));
       return state !== null && typeof state === "object" && !Array.isArray(state) && authorizeState(state);
     } catch {
       return false;
@@ -25747,13 +25881,13 @@ function emergencyReplaceAtRecoveryBoundary(filePath) {
   if (process.env.NODE_ENV !== "test" || process.env.OMC_TEST_EMERGENCY_RECOVERY_REPLACEMENT_PATH !== filePath || !process.env.OMC_TEST_EMERGENCY_RECOVERY_REPLACEMENT_BASE64) return;
   try {
     const replacements = JSON.parse(Buffer.from(process.env.OMC_TEST_EMERGENCY_RECOVERY_REPLACEMENT_BASE64, "base64").toString("utf8"));
-    const directory = (0, import_path16.dirname)(filePath);
-    for (const name of (0, import_fs16.readdirSync)(directory)) {
-      if (name === (0, import_path16.basename)(filePath) || name.startsWith(`${(0, import_path16.basename)(filePath)}.emergency-`)) (0, import_fs16.unlinkSync)((0, import_path16.join)(directory, name));
+    const directory = (0, import_path17.dirname)(filePath);
+    for (const name of (0, import_fs17.readdirSync)(directory)) {
+      if (name === (0, import_path17.basename)(filePath) || name.startsWith(`${(0, import_path17.basename)(filePath)}.emergency-`)) (0, import_fs17.unlinkSync)((0, import_path17.join)(directory, name));
     }
     for (const replacement of replacements) {
-      if ((0, import_path16.dirname)(replacement.path) !== directory) throw new Error("invalid recovery replacement path");
-      (0, import_fs16.writeFileSync)(replacement.path, replacement.content);
+      if ((0, import_path17.dirname)(replacement.path) !== directory) throw new Error("invalid recovery replacement path");
+      (0, import_fs17.writeFileSync)(replacement.path, replacement.content);
     }
   } finally {
     delete process.env.OMC_TEST_EMERGENCY_RECOVERY_REPLACEMENT_PATH;
@@ -25767,12 +25901,12 @@ function recoverEmergencyStateFile(filePath, options) {
     return owner === void 0 || owner === pathSessionId;
   } : void 0);
   const journalPath = emergencyJournalPath(filePath);
-  if (!(0, import_fs16.existsSync)(filePath) && !(0, import_fs16.existsSync)(journalPath)) return true;
+  if (!(0, import_fs17.existsSync)(filePath) && !(0, import_fs17.existsSync)(journalPath)) return true;
   if (!sharedRecoveryArtifactsAuthorized(filePath, authorizeState)) {
     if (process.env.OMC_LOCK_DEBUG) console.error(`[lock-debug] recoverEmergency prefilter-false ${filePath}`);
     return false;
   }
-  if (!(0, import_fs16.existsSync)(journalPath)) {
+  if (!(0, import_fs17.existsSync)(journalPath)) {
     if (!authorizeState) return reconcileEmergencyPublicationTemps(filePath);
     const claimPath2 = `${filePath}.emergency-recovery.claim`;
     const claim2 = acquireRecoveryClaim(claimPath2);
@@ -25781,7 +25915,7 @@ function recoverEmergencyStateFile(filePath, options) {
       return false;
     }
     try {
-      if ((0, import_fs16.existsSync)(journalPath) || !sharedRecoveryArtifactsAuthorized(filePath, authorizeState, claim2)) {
+      if ((0, import_fs17.existsSync)(journalPath) || !sharedRecoveryArtifactsAuthorized(filePath, authorizeState, claim2)) {
         if (process.env.OMC_LOCK_DEBUG) console.error(`[lock-debug] recoverEmergency no-journal-revalidate-false ${filePath}`);
         return false;
       }
@@ -25802,8 +25936,8 @@ function recoverEmergencyStateFile(filePath, options) {
       const current = readEmergencyJournal(journalPath);
       if (!recoveryGenerationsAuthorized(filePath, current, authorizeState)) return true;
       if (!reconcileEmergencyPublicationTemps(filePath, authorizeState)) return false;
-      if (!generation || readEmergencyJournal(journalPath) !== null || !(0, import_fs16.existsSync)(filePath) || !sameFile(journalPath, generation)) return false;
-      (0, import_fs16.unlinkSync)(journalPath);
+      if (!generation || readEmergencyJournal(journalPath) !== null || !(0, import_fs17.existsSync)(filePath) || !sameFile(journalPath, generation)) return false;
+      (0, import_fs17.unlinkSync)(journalPath);
       return true;
     } catch {
       return false;
@@ -25828,7 +25962,7 @@ function recoverEmergencyStateFile(filePath, options) {
 }
 function recoverDeadEmergencyStateFile(filePath, authorizeState) {
   const journalPath = emergencyJournalPath(filePath);
-  if (!(0, import_fs16.existsSync)(journalPath)) return true;
+  if (!(0, import_fs17.existsSync)(journalPath)) return true;
   const journal = readEmergencyJournal(journalPath);
   if (!journal || journal.quarantinePath !== `${filePath}.emergency-quarantine.${journal.transactionId}`) return false;
   if (isEmergencyOwnerLive(journal.owner)) return false;
@@ -25838,7 +25972,7 @@ function recoverDeadEmergencyStateFile(filePath, authorizeState) {
   const payloadPath = `${journal.quarantinePath}.payload`;
   const digest = (path14) => {
     try {
-      return stateDigest((0, import_fs16.readFileSync)(path14, "utf8"));
+      return stateDigest((0, import_fs17.readFileSync)(path14, "utf8"));
     } catch {
       return null;
     }
@@ -25846,14 +25980,14 @@ function recoverDeadEmergencyStateFile(filePath, authorizeState) {
   if (journal.phase === "preparing") {
     const complete = typeof journal.originalDigest === "string" && (journal.intent === "clear" || journal.intent === "publish" && typeof journal.intendedDigest === "string");
     if (!complete) {
-      if ((0, import_fs16.existsSync)(journal.quarantinePath) || (0, import_fs16.existsSync)(payloadPath)) return false;
+      if ((0, import_fs17.existsSync)(journal.quarantinePath) || (0, import_fs17.existsSync)(payloadPath)) return false;
       return removeOwnedEmergencyArtifacts(journalPath, journal, false);
     }
-    const originalStillPrimary = !(0, import_fs16.existsSync)(journal.quarantinePath) && digest(filePath) === journal.originalDigest;
+    const originalStillPrimary = !(0, import_fs17.existsSync)(journal.quarantinePath) && digest(filePath) === journal.originalDigest;
     if (journal.intent === "publish" && digest(payloadPath) !== journal.intendedDigest) {
       return originalStillPrimary && removeOwnedEmergencyArtifacts(journalPath, journal, false);
     }
-    if (journal.intent === "clear" && (0, import_fs16.existsSync)(payloadPath)) {
+    if (journal.intent === "clear" && (0, import_fs17.existsSync)(payloadPath)) {
       return originalStillPrimary && removeOwnedEmergencyArtifacts(journalPath, journal, false);
     }
     journal.phase = "prepared";
@@ -25862,8 +25996,8 @@ function recoverDeadEmergencyStateFile(filePath, authorizeState) {
   const originalDigest = journal.originalDigest;
   const intent = journal.intent;
   const intendedDigest = journal.intendedDigest;
-  const hasPrimary = (0, import_fs16.existsSync)(filePath);
-  const hasQuarantine = (0, import_fs16.existsSync)(journal.quarantinePath);
+  const hasPrimary = (0, import_fs17.existsSync)(filePath);
+  const hasQuarantine = (0, import_fs17.existsSync)(journal.quarantinePath);
   const finalize = () => removeOwnedEmergencyArtifacts(journalPath, journal, hasQuarantine);
   if (hasPrimary && hasQuarantine) {
     if (intent === "publish" && digest(filePath) === intendedDigest && digest(journal.quarantinePath) === originalDigest) return finalize();
@@ -25874,7 +26008,7 @@ function recoverDeadEmergencyStateFile(filePath, authorizeState) {
       if (intent === "publish" && digest(payloadPath) !== intendedDigest) return false;
       if (!owned()) return false;
       if (!captureAndUnlinkPrimary(filePath, journal.quarantinePath, originalDigest)) {
-        if (owned() && (0, import_fs16.existsSync)(filePath) && (0, import_fs16.existsSync)(journal.quarantinePath) && digest(filePath) !== originalDigest) {
+        if (owned() && (0, import_fs17.existsSync)(filePath) && (0, import_fs17.existsSync)(journal.quarantinePath) && digest(filePath) !== originalDigest) {
           removeOwnedEmergencyArtifacts(journalPath, journal, true);
         }
         return false;
@@ -25890,9 +26024,9 @@ function recoverDeadEmergencyStateFile(filePath, authorizeState) {
   if (digest(journal.quarantinePath) !== originalDigest || !owned()) return false;
   try {
     if (intent === "clear") return removeOwnedEmergencyArtifacts(journalPath, journal, true);
-    const payload = (0, import_fs16.readFileSync)(payloadPath, "utf8");
+    const payload = (0, import_fs17.readFileSync)(payloadPath, "utf8");
     if (stateDigest(payload) !== intendedDigest || !owned()) return false;
-    (0, import_fs16.linkSync)(payloadPath, filePath);
+    (0, import_fs17.linkSync)(payloadPath, filePath);
     journal.phase = "published";
     if (!writeEmergencyJournal(journalPath, journal)) return false;
     return removeOwnedEmergencyArtifacts(journalPath, journal, true);
@@ -25948,11 +26082,11 @@ function emergencyMutateStateFileIf(filePath, predicate, transform2, recoveryOpt
     journal = { version: 1, transactionId, owner, quarantinePath, phase: "preparing" };
     if (!createEmergencyJournal(journalPath, journal)) return false;
     const owns = () => journal !== null && journalIsOwned(journalPath, transactionId, owner);
-    if (!(0, import_fs16.existsSync)(filePath)) {
+    if (!(0, import_fs17.existsSync)(filePath)) {
       removeOwnedEmergencyArtifacts(journalPath, journal, false);
       return false;
     }
-    const originalRaw = (0, import_fs16.readFileSync)(filePath, "utf8");
+    const originalRaw = (0, import_fs17.readFileSync)(filePath, "utf8");
     const current = JSON.parse(originalRaw);
     if (!predicate(current)) {
       removeOwnedEmergencyArtifacts(journalPath, journal, false);
@@ -25976,7 +26110,7 @@ function emergencyMutateStateFileIf(filePath, predicate, transform2, recoveryOpt
     }
     journal.phase = "prepared";
     if (!writeEmergencyJournal(journalPath, journal)) return false;
-    const authenticatedRaw = (0, import_fs16.readFileSync)(filePath, "utf8");
+    const authenticatedRaw = (0, import_fs17.readFileSync)(filePath, "utf8");
     const authenticated = JSON.parse(authenticatedRaw);
     if (!owns() || stateDigest(authenticatedRaw) !== journal.originalDigest || !predicate(authenticated)) {
       removeOwnedEmergencyArtifacts(journalPath, journal, false);
@@ -25999,7 +26133,7 @@ function emergencyMutateStateFileIf(filePath, predicate, transform2, recoveryOpt
     }
     if (transformedRaw !== void 0) {
       if (!owns()) return false;
-      (0, import_fs16.linkSync)(payloadPath, filePath);
+      (0, import_fs17.linkSync)(payloadPath, filePath);
       journal.phase = "published";
       if (!writeEmergencyJournal(journalPath, journal)) return false;
       if (emergencyCrashAt("after-publication")) {
@@ -26054,7 +26188,7 @@ function resolveFile(mode, directory, sessionId) {
 }
 function discoverStateFile(path14, extra = {}) {
   try {
-    const state = JSON.parse((0, import_fs16.readFileSync)(path14, "utf-8"));
+    const state = JSON.parse((0, import_fs17.readFileSync)(path14, "utf-8"));
     return {
       path: path14,
       snapshot: JSON.stringify(state),
@@ -26069,7 +26203,7 @@ function discoverStateFile(path14, extra = {}) {
 }
 function hasAuthenticatedCompletionEvidence(path14, sessionId) {
   try {
-    const evidence = JSON.parse((0, import_fs16.readFileSync)(path14, "utf-8"));
+    const evidence = JSON.parse((0, import_fs17.readFileSync)(path14, "utf-8"));
     return evidence.session_id === sessionId && typeof evidence.ended_at === "string" && evidence.ended_at.trim().length > 0 && Number.isFinite(Date.parse(evidence.ended_at));
   } catch {
     return false;
@@ -26095,7 +26229,7 @@ function findCompletedSessionStateCandidates(mode, directory, requesterSessionId
   const baseDir = resolveStateRoot(directory);
   for (const sid of listSessionIds(baseDir)) {
     if (requesterSessionId && sid === requesterSessionId) continue;
-    const completionEvidencePath = (0, import_path16.join)(getOmcRoot(baseDir), "sessions", `${sid}.json`);
+    const completionEvidencePath = (0, import_path17.join)(getOmcRoot(baseDir), "sessions", `${sid}.json`);
     if (!hasAuthenticatedCompletionEvidence(completionEvidencePath, sid)) continue;
     const candidatePath = resolveSessionStatePath(mode, sid, baseDir);
     const candidate = discoverStateFile(candidatePath, { completedSessionId: sid, completionEvidencePath });
@@ -26140,11 +26274,11 @@ function writeModeState(mode, state, directory, sessionId) {
 }
 function readModeState(mode, directory, sessionId) {
   const filePath = resolveFile(mode, directory, sessionId);
-  if (!(0, import_fs16.existsSync)(filePath)) {
+  if (!(0, import_fs17.existsSync)(filePath)) {
     return null;
   }
   try {
-    const content = (0, import_fs16.readFileSync)(filePath, "utf-8");
+    const content = (0, import_fs17.readFileSync)(filePath, "utf-8");
     const parsed = JSON.parse(content);
     if (sessionId && parsed && typeof parsed === "object" && !canClearStateForSession(parsed, sessionId)) {
       return null;
@@ -26160,8 +26294,8 @@ function readModeState(mode, directory, sessionId) {
 }
 
 // src/hooks/mode-registry/index.ts
-var import_fs17 = require("fs");
-var import_path17 = require("path");
+var import_fs18 = require("fs");
+var import_path18 = require("path");
 
 // src/lib/mode-names.ts
 var MODE_NAMES = {
@@ -26258,26 +26392,26 @@ var MODE_CONFIGS = {
 };
 var EXCLUSIVE_MODES = [MODE_NAMES.AUTOPILOT, MODE_NAMES.AUTORESEARCH];
 function getStateDir(cwd) {
-  return (0, import_path17.join)(getOmcRoot(cwd), "state");
+  return (0, import_path18.join)(getOmcRoot(cwd), "state");
 }
 function getStateFilePath(cwd, mode, sessionId) {
   const config2 = MODE_CONFIGS[mode];
   if (sessionId) {
     return resolveSessionStatePath(mode, sessionId, cwd);
   }
-  return (0, import_path17.join)(getStateDir(cwd), config2.stateFile);
+  return (0, import_path18.join)(getStateDir(cwd), config2.stateFile);
 }
 function getMarkerFilePath(cwd, mode) {
   const config2 = MODE_CONFIGS[mode];
   if (!config2.markerFile) return null;
-  return (0, import_path17.join)(getStateDir(cwd), config2.markerFile);
+  return (0, import_path18.join)(getStateDir(cwd), config2.markerFile);
 }
 var WORKFLOW_SLOT_TOMBSTONE_TTL_MS = 24 * 60 * 60 * 1e3;
 function isWorkflowSlotTombstonedForMode(cwd, mode, sessionId, now = Date.now()) {
   try {
-    const ledgerPath = sessionId ? resolveSessionStatePath("skill-active", sessionId, cwd) : (0, import_path17.join)(getStateDir(cwd), "skill-active-state.json");
-    if (!(0, import_fs17.existsSync)(ledgerPath)) return false;
-    const raw = JSON.parse((0, import_fs17.readFileSync)(ledgerPath, "utf-8"));
+    const ledgerPath2 = sessionId ? resolveSessionStatePath("skill-active", sessionId, cwd) : (0, import_path18.join)(getStateDir(cwd), "skill-active-state.json");
+    if (!(0, import_fs18.existsSync)(ledgerPath2)) return false;
+    const raw = JSON.parse((0, import_fs18.readFileSync)(ledgerPath2, "utf-8"));
     const slots = raw.active_skills;
     if (!slots || typeof slots !== "object") return false;
     const slot = slots[mode];
@@ -26300,7 +26434,7 @@ function isJsonModeActive(cwd, mode, sessionId) {
   if (sessionId) {
     const sessionStateFile = resolveSessionStatePath(mode, sessionId, cwd);
     try {
-      const content = (0, import_fs17.readFileSync)(sessionStateFile, "utf-8");
+      const content = (0, import_fs18.readFileSync)(sessionStateFile, "utf-8");
       const state = JSON.parse(content);
       const ownerSessionId = getStateSessionOwner(state);
       if (ownerSessionId && ownerSessionId !== sessionId) {
@@ -26319,7 +26453,7 @@ function isJsonModeActive(cwd, mode, sessionId) {
   }
   const stateFile = getStateFilePath(cwd, mode);
   try {
-    const content = (0, import_fs17.readFileSync)(stateFile, "utf-8");
+    const content = (0, import_fs18.readFileSync)(stateFile, "utf-8");
     const state = JSON.parse(content);
     if (getStateSessionOwner(state)) {
       return false;
@@ -26352,7 +26486,7 @@ function getAllModeStatuses(cwd, sessionId) {
     const stateFilePath = getStateFilePath(cwd, mode, sessionId);
     const raw = (() => {
       try {
-        return JSON.parse((0, import_fs17.readFileSync)(stateFilePath, "utf8"));
+        return JSON.parse((0, import_fs18.readFileSync)(stateFilePath, "utf8"));
       } catch {
         return null;
       }
@@ -26367,7 +26501,7 @@ function getAllModeStatuses(cwd, sessionId) {
 }
 function readJsonSnapshot(filePath) {
   try {
-    const state = JSON.parse((0, import_fs17.readFileSync)(filePath, "utf-8"));
+    const state = JSON.parse((0, import_fs18.readFileSync)(filePath, "utf-8"));
     return { state, snapshot: JSON.stringify(state) };
   } catch {
     return null;
@@ -26376,14 +26510,14 @@ function readJsonSnapshot(filePath) {
 function clearDiscoveredJsonFile(filePath, observed, predicate = () => true) {
   if (!observed) {
     const result2 = clearStateFileLockedIf(filePath, predicate);
-    return result2 !== "failed" && !(result2 === "skipped" && (0, import_fs17.existsSync)(filePath));
+    return result2 !== "failed" && !(result2 === "skipped" && (0, import_fs18.existsSync)(filePath));
   }
   if (!predicate(observed.state)) return true;
   const result = clearStateFileLockedIf(
     filePath,
     (current) => predicate(current) && JSON.stringify(current) === observed.snapshot
   );
-  return result !== "failed" && !(result === "skipped" && (0, import_fs17.existsSync)(filePath));
+  return result !== "failed" && !(result === "skipped" && (0, import_fs18.existsSync)(filePath));
 }
 function clearModeState(mode, cwd, sessionId, expectedState) {
   const config2 = MODE_CONFIGS[mode];
@@ -26397,7 +26531,7 @@ function clearModeState(mode, cwd, sessionId, expectedState) {
     const sessionStateFile = resolveSessionStatePath(mode, sessionId, cwd);
     try {
       const result = clearStateFileLockedIf(sessionStateFile, (current) => canClearStateForSession(current, sessionId) && (!expectedState || JSON.stringify(current) === JSON.stringify(expectedState)));
-      if (result === "failed" || result === "skipped" && (0, import_fs17.existsSync)(sessionStateFile)) throw new Error(getStateMutationLockFailureMessage());
+      if (result === "failed" || result === "skipped" && (0, import_fs18.existsSync)(sessionStateFile)) throw new Error(getStateMutationLockFailureMessage());
     } catch (err) {
       if (err.code !== "ENOENT") {
         success = false;
@@ -26414,7 +26548,7 @@ function clearModeState(mode, cwd, sessionId, expectedState) {
     }
     if (markerFile) {
       try {
-        const markerRaw = JSON.parse((0, import_fs17.readFileSync)(markerFile, "utf-8"));
+        const markerRaw = JSON.parse((0, import_fs18.readFileSync)(markerFile, "utf-8"));
         const markerSessionId = markerRaw.session_id ?? markerRaw.sessionId;
         if (!markerSessionId || markerSessionId === sessionId) {
           try {
@@ -26440,7 +26574,7 @@ function clearModeState(mode, cwd, sessionId, expectedState) {
   if (!isSessionScopedClear) {
     try {
       const result = clearStateFileLockedIf(stateFile, (current) => !expectedState || JSON.stringify(current) === JSON.stringify(expectedState));
-      if (result === "failed" || result === "skipped" && (0, import_fs17.existsSync)(stateFile)) throw new Error(getStateMutationLockFailureMessage());
+      if (result === "failed" || result === "skipped" && (0, import_fs18.existsSync)(stateFile)) throw new Error(getStateMutationLockFailureMessage());
     } catch (err) {
       if (err.code !== "ENOENT") {
         success = false;
@@ -26462,23 +26596,23 @@ function getActiveSessionsForMode(mode, cwd) {
 }
 
 // src/hooks/autopilot/named-workflow-resume-validator.ts
-var import_fs25 = require("fs");
+var import_fs26 = require("fs");
 var import_crypto8 = require("crypto");
-var import_path27 = require("path");
+var import_path28 = require("path");
 
 // src/hooks/autopilot/pipeline.ts
 var import_crypto7 = require("crypto");
 
 // src/config/plan-output.ts
-var import_path18 = require("path");
+var import_path19 = require("path");
 
 // src/hooks/autopilot/state.ts
-var import_fs24 = require("fs");
-var import_path26 = require("path");
+var import_fs25 = require("fs");
+var import_path27 = require("path");
 
 // src/config/loader.ts
-var import_fs18 = require("fs");
-var import_path19 = require("path");
+var import_fs19 = require("fs");
+var import_path20 = require("path");
 
 // src/shared/types.ts
 var CANONICAL_TEAM_ROLES = [
@@ -26761,32 +26895,32 @@ var KNOWN_AGENT_NAME_SET = new Set(KNOWN_AGENT_NAMES);
 
 // src/hooks/ralph/loop.ts
 var import_child_process11 = require("child_process");
-var import_path24 = require("path");
+var import_path25 = require("path");
 
 // src/hooks/ralph/prd.ts
 var import_crypto5 = require("crypto");
-var import_fs19 = require("fs");
-var import_path20 = require("path");
+var import_fs20 = require("fs");
+var import_path21 = require("path");
 
 // src/hooks/ralph/stale-prd.ts
 var import_child_process10 = require("child_process");
-var import_fs20 = require("fs");
-var import_path21 = require("path");
+var import_fs21 = require("fs");
+var import_path22 = require("path");
 var DEFAULT_STALE_PRD_AFTER_MS = 2 * 60 * 60 * 1e3;
 var GIT_MAX_BUFFER = 1024 * 1024;
 
 // src/hooks/ralph/progress.ts
-var import_fs21 = require("fs");
-var import_path22 = require("path");
-
-// src/hooks/team-canonical-state.ts
 var import_fs22 = require("fs");
 var import_path23 = require("path");
 
+// src/hooks/team-canonical-state.ts
+var import_fs23 = require("fs");
+var import_path24 = require("path");
+
 // src/hooks/ralph/verifier.ts
 var import_crypto6 = require("crypto");
-var import_fs23 = require("fs");
-var import_path25 = require("path");
+var import_fs24 = require("fs");
+var import_path26 = require("path");
 
 // src/utils/omc-cli-rendering.ts
 var import_child_process12 = require("child_process");
@@ -26945,7 +27079,7 @@ function validFileIdentity(value) {
   ]) && fileId(value.device) && fileId(value.inode) && safeInteger(value.size) && typeof value.mtimeNs === "string" && /^\d+$/.test(value.mtimeNs) && typeof value.ctimeNs === "string" && /^\d+$/.test(value.ctimeNs) && typeof value.contentSha256 === "string" && /^[a-f0-9]{64}$/.test(value.contentSha256);
 }
 function namedWorkflowRuntimeSupported() {
-  return typeof import_fs25.constants.O_RDONLY === "number" && process.env.OMC_TEST_FLOCK_AVAILABLE !== "0" && ((0, import_fs25.existsSync)("/usr/bin/flock") || (0, import_fs25.existsSync)("/bin/flock") || isStateMutationLockingSupported());
+  return typeof import_fs26.constants.O_RDONLY === "number" && process.env.OMC_TEST_FLOCK_AVAILABLE !== "0" && ((0, import_fs26.existsSync)("/usr/bin/flock") || (0, import_fs26.existsSync)("/bin/flock") || isStateMutationLockingSupported());
 }
 function validBoundaryShape(value, sessionId) {
   if (!isRecord(value) || !exactKeys(value, [
@@ -26955,10 +27089,10 @@ function validBoundaryShape(value, sessionId) {
     "sessionId",
     "byteOffset",
     "fileIdentity"
-  ]) || typeof sessionId !== "string" || value.sessionId !== sessionId || typeof value.transcriptRoot !== "string" || (0, import_path27.resolve)(value.transcriptRoot) !== value.transcriptRoot || typeof value.transcriptPath !== "string" || (0, import_path27.resolve)(value.transcriptPath) !== value.transcriptPath || (0, import_path27.basename)(value.transcriptPath) !== `${sessionId}.jsonl` || value.transcriptBasename !== `${sessionId}.jsonl` || !safeInteger(value.byteOffset) || !validFileIdentity(value.fileIdentity) || value.fileIdentity.size !== value.byteOffset)
+  ]) || typeof sessionId !== "string" || value.sessionId !== sessionId || typeof value.transcriptRoot !== "string" || (0, import_path28.resolve)(value.transcriptRoot) !== value.transcriptRoot || typeof value.transcriptPath !== "string" || (0, import_path28.resolve)(value.transcriptPath) !== value.transcriptPath || (0, import_path28.basename)(value.transcriptPath) !== `${sessionId}.jsonl` || value.transcriptBasename !== `${sessionId}.jsonl` || !safeInteger(value.byteOffset) || !validFileIdentity(value.fileIdentity) || value.fileIdentity.size !== value.byteOffset)
     return false;
-  const relativePath = (0, import_path27.relative)(value.transcriptRoot, value.transcriptPath);
-  return relativePath.length > 0 && relativePath !== ".." && !relativePath.startsWith(`..${import_path27.sep}`);
+  const relativePath = (0, import_path28.relative)(value.transcriptRoot, value.transcriptPath);
+  return relativePath.length > 0 && relativePath !== ".." && !relativePath.startsWith(`..${import_path28.sep}`);
 }
 function validateNamedWorkflowStateStructure(state, sessionId) {
   if (!Object.prototype.hasOwnProperty.call(state, "workflow") || !Object.prototype.hasOwnProperty.call(state, "workflowRunId") || !Object.prototype.hasOwnProperty.call(state, "pipelineTracking")) return null;
@@ -26991,7 +27125,7 @@ function validateNamedWorkflowStateStructure(state, sessionId) {
     if (previousObservation) {
       const previousBoundary = previousObservation.activationBoundary;
       const previousStable = previousObservation.stableFile;
-      if (boundary.transcriptPath !== previousBoundary.transcriptPath || boundary.byteOffset !== previousStable.size || !sameFileIdentity(boundary.fileIdentity, previousStable)) return null;
+      if (boundary.transcriptPath !== previousBoundary.transcriptPath || boundary.byteOffset !== previousStable.size || !sameFileIdentity2(boundary.fileIdentity, previousStable)) return null;
     }
     previousObservation = observation;
   }
@@ -26999,20 +27133,20 @@ function validateNamedWorkflowStateStructure(state, sessionId) {
     const current = tracking.activationBoundary;
     const stable = previousObservation.stableFile;
     const boundary = previousObservation.activationBoundary;
-    if (current.transcriptPath !== boundary.transcriptPath || current.byteOffset !== stable.size || !sameFileIdentity(current.fileIdentity, stable)) return null;
+    if (current.transcriptPath !== boundary.transcriptPath || current.byteOffset !== stable.size || !sameFileIdentity2(current.fileIdentity, stable)) return null;
   }
   if (terminal ? state.phase !== "complete" : state.phase !== workflow.stages[tracking.currentStageIndex]) return null;
   return { tracking, task };
 }
-function sameFileIdentity(left, right) {
+function sameFileIdentity2(left, right) {
   if (!isRecord(left) || !isRecord(right)) return false;
   return sameFileId(left.device, right.device) && sameFileId(left.inode, right.inode) && left.size === right.size && left.mtimeNs === right.mtimeNs && left.ctimeNs === right.ctimeNs && left.contentSha256 === right.contentSha256;
 }
 
 // src/hooks/merge-readiness/runtime.ts
 var import_child_process13 = require("child_process");
-var import_fs26 = require("fs");
-var import_path28 = require("path");
+var import_fs27 = require("fs");
+var import_path29 = require("path");
 
 // src/hooks/merge-readiness/mcq.ts
 var MERGE_READINESS_DIMENSIONS = [
@@ -27104,7 +27238,7 @@ function isNonEvidenceStateFile(name) {
 }
 function modeStateRecordsRun(filePath) {
   try {
-    const raw = (0, import_fs26.readFileSync)(filePath, "utf-8");
+    const raw = (0, import_fs27.readFileSync)(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object") {
       if (parsed.active === true) return true;
@@ -27118,11 +27252,11 @@ function modeStateRecordsRun(filePath) {
 }
 function listArtifactFiles(directory, sessionId) {
   const root = getOmcRoot(directory);
-  const dirCandidates = ["plans", "artifacts", "logs", "specs", "interviews"].map((segment) => (0, import_path28.join)(root, segment)).filter((path14) => (0, import_fs26.existsSync)(path14));
+  const dirCandidates = ["plans", "artifacts", "logs", "specs", "interviews"].map((segment) => (0, import_path29.join)(root, segment)).filter((path14) => (0, import_fs27.existsSync)(path14));
   const found = [];
   const seen = /* @__PURE__ */ new Set();
   const pushRelative = (full) => {
-    const relativePath = (0, import_path28.relative)(root, full).replace(/\\/g, "/");
+    const relativePath = (0, import_path29.relative)(root, full).replace(/\\/g, "/");
     if (relativePath.startsWith("artifacts/merge-readiness/")) return;
     if (relativePath.includes("merge-readiness-state")) return;
     if (seen.has(relativePath)) return;
@@ -27137,10 +27271,10 @@ function listArtifactFiles(directory, sessionId) {
       const current = stack.pop();
       if (!current) continue;
       try {
-        const entries = (0, import_fs26.readdirSync)(current, { withFileTypes: true });
+        const entries = (0, import_fs27.readdirSync)(current, { withFileTypes: true });
         for (const entry of entries) {
           if (perRoot >= MAX_PER_ROOT) break;
-          const full = (0, import_path28.join)(current, entry.name);
+          const full = (0, import_path29.join)(current, entry.name);
           if (entry.isDirectory()) {
             stack.push(full);
           } else if (entry.isFile() && /\.(md|json|txt|log)$/i.test(entry.name)) {
@@ -27153,15 +27287,15 @@ function listArtifactFiles(directory, sessionId) {
       }
     }
   }
-  const stateDir = (0, import_path28.join)(root, "state");
+  const stateDir = (0, import_path29.join)(root, "state");
   const scanStateDir = (dir) => {
-    if (!(0, import_fs26.existsSync)(dir)) return;
+    if (!(0, import_fs27.existsSync)(dir)) return;
     try {
-      for (const entry of (0, import_fs26.readdirSync)(dir, { withFileTypes: true })) {
+      for (const entry of (0, import_fs27.readdirSync)(dir, { withFileTypes: true })) {
         if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
         if (isNonEvidenceStateFile(entry.name)) continue;
         if (!EVIDENCE_MODE_STATE_FILES.has(entry.name)) continue;
-        const full = (0, import_path28.join)(dir, entry.name);
+        const full = (0, import_path29.join)(dir, entry.name);
         if (!modeStateRecordsRun(full)) continue;
         pushRelative(full);
       }
@@ -27170,7 +27304,7 @@ function listArtifactFiles(directory, sessionId) {
   };
   scanStateDir(stateDir);
   if (sessionId) {
-    scanStateDir((0, import_path28.join)(stateDir, "sessions", sessionId));
+    scanStateDir((0, import_path29.join)(stateDir, "sessions", sessionId));
   }
   return found.sort();
 }
@@ -27538,8 +27672,8 @@ var import_node_crypto = require("node:crypto");
 
 // src/team/team-owner-epoch.ts
 var import_crypto9 = require("crypto");
-var import_fs27 = require("fs");
-var import_path30 = require("path");
+var import_fs28 = require("fs");
+var import_path31 = require("path");
 var import_node_child_process = require("node:child_process");
 
 // src/graph/runtime/native-contained-fs.ts
@@ -27561,7 +27695,7 @@ function getNativeContainedFs() {
           loaded = (0, import_node_module.createRequire)(importMetaUrl)(binary);
           return loaded;
         } catch (cause) {
-          throw new Error(`The contained filesystem backend is unavailable at ${binary}. Build it with node scripts/build-contained-fs.mjs before running graph commands.`, { cause });
+          throw new Error(`The contained filesystem backend is unavailable at ${binary}. Build it with node scripts/build-contained-fs.mjs (from the installed package directory) before running graph or team commands.`, { cause });
         }
       }
     }
@@ -27572,7 +27706,7 @@ function getNativeContainedFs() {
 }
 
 // src/team/state-paths.ts
-var import_path29 = require("path");
+var import_path30 = require("path");
 
 // src/team/team-owner-epoch.ts
 function darwinProcessStartFromKinfo(raw, nowSeconds = Math.floor(Date.now() / 1e3)) {
@@ -27583,7 +27717,7 @@ function darwinProcessStartFromKinfo(raw, nowSeconds = Math.floor(Date.now() / 1
   return `${seconds}:${micros}`;
 }
 function processStartIdentityForPlatform(pid, platform = process.platform, exec = import_node_child_process.execFileSync) {
-  return probeProcessStartIdentityForPlatform(pid, platform, exec, import_fs27.readFileSync, false).identity;
+  return probeProcessStartIdentityForPlatform(pid, platform, exec, import_fs28.readFileSync, false).identity;
 }
 function darwinProcessStartIdentityFromNative(pid) {
   try {
@@ -27620,7 +27754,7 @@ function probeProcessStartIdentityForPlatform(pid, platform, exec, read, strict)
         ["-NoProfile", "-NonInteractive", "-Command", command],
         { encoding: "utf8", windowsHide: true }
       ).trim();
-      return /^\d+$/.test(ticks) ? { identity: `win32:${ticks}`, precise: true } : { identity: null, precise: false };
+      return /^[1-9]\d*$/.test(ticks) ? { identity: `win32:${ticks}`, precise: true } : { identity: null, precise: false };
     }
     if (platform === "darwin") {
       if (strict) {
@@ -28037,29 +28171,29 @@ function redactMergeReadinessState(state) {
 // src/tools/state-tools.ts
 var MAX_MIGRATION_FILE_BYTES = 1048576;
 function ensureMigrationDirectoryTree(root, target) {
-  const rootResolved = (0, import_path31.resolve)(root);
-  const targetResolved = (0, import_path31.resolve)(target);
-  const suffix = (0, import_path31.relative)(rootResolved, targetResolved);
-  if (suffix.startsWith("..") || (0, import_path31.isAbsolute)(suffix)) {
+  const rootResolved = (0, import_path32.resolve)(root);
+  const targetResolved = (0, import_path32.resolve)(target);
+  const suffix = (0, import_path32.relative)(rootResolved, targetResolved);
+  if (suffix.startsWith("..") || (0, import_path32.isAbsolute)(suffix)) {
     throw new Error("state_migrate_non_git refuses a destination outside the canonical root");
   }
-  if (!(0, import_fs28.existsSync)(rootResolved)) (0, import_fs28.mkdirSync)(rootResolved, { recursive: true });
-  const rootStat = (0, import_fs28.lstatSync)(rootResolved);
+  if (!(0, import_fs29.existsSync)(rootResolved)) (0, import_fs29.mkdirSync)(rootResolved, { recursive: true });
+  const rootStat = (0, import_fs29.lstatSync)(rootResolved);
   if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) {
     throw new Error("state_migrate_non_git refuses symlinked migration roots");
   }
   let cursor = rootResolved;
   for (const segment of suffix.split(/[\\/]+/).filter(Boolean)) {
-    cursor = (0, import_path31.join)(cursor, segment);
-    if ((0, import_fs28.existsSync)(cursor)) {
-      const stat = (0, import_fs28.lstatSync)(cursor);
+    cursor = (0, import_path32.join)(cursor, segment);
+    if ((0, import_fs29.existsSync)(cursor)) {
+      const stat = (0, import_fs29.lstatSync)(cursor);
       if (stat.isSymbolicLink() || !stat.isDirectory()) {
         throw new Error("state_migrate_non_git refuses symlinked migration roots");
       }
       continue;
     }
-    (0, import_fs28.mkdirSync)(cursor);
-    const created = (0, import_fs28.lstatSync)(cursor);
+    (0, import_fs29.mkdirSync)(cursor);
+    const created = (0, import_fs29.lstatSync)(cursor);
     if (created.isSymbolicLink() || !created.isDirectory()) {
       throw new Error("state_migrate_non_git refuses symlinked migration roots");
     }
@@ -28105,7 +28239,7 @@ function getStateFileName(mode) {
 }
 function readJsonRecord(filePath) {
   try {
-    return JSON.parse((0, import_fs28.readFileSync)(filePath, "utf-8"));
+    return JSON.parse((0, import_fs29.readFileSync)(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -28122,7 +28256,7 @@ function teamStateLockPath(statePath) {
 async function writeTeamState(statePath, sessionId, patch) {
   return withProcessIdentityFileLock(teamStateLockPath(statePath), () => {
     if (!recoverEmergencyStateFile(statePath)) {
-      const existing = (0, import_fs28.existsSync)(statePath) ? readJsonRecordStrict(statePath) : void 0;
+      const existing = (0, import_fs29.existsSync)(statePath) ? readJsonRecordStrict(statePath) : void 0;
       if (existing === null) return { result: "corrupt" };
       if (sessionId && existing && getStateSessionOwner(existing) !== void 0 && getStateSessionOwner(existing) !== sessionId) {
         return { result: "foreign" };
@@ -28130,7 +28264,7 @@ async function writeTeamState(statePath, sessionId, patch) {
       return { result: "failed" };
     }
     const transaction = withStateFileMutationLock(statePath, () => {
-      if (!(0, import_fs28.existsSync)(statePath)) {
+      if (!(0, import_fs29.existsSync)(statePath)) {
         try {
           atomicWriteJsonSync(statePath, patch);
           return { result: "written", state: patch };
@@ -28164,7 +28298,7 @@ async function writeTeamState(statePath, sessionId, patch) {
 }
 function readJsonRecordStrict(filePath) {
   try {
-    const parsed = JSON.parse((0, import_fs28.readFileSync)(filePath, "utf-8"));
+    const parsed = JSON.parse((0, import_fs29.readFileSync)(filePath, "utf-8"));
     return isJsonRecord(parsed) ? parsed : null;
   } catch {
     return null;
@@ -28194,12 +28328,12 @@ function matchesNamedPauseTarget(current, sessionId, workflowRunId, stateDigest2
   return current.active === true && current.workflowRunId === workflowRunId && hasValidatedNamedWorkflowTuple(current) && getStateSessionOwner(current) === sessionId && (stateDigest2 === void 0 || (0, import_crypto10.createHash)("sha256").update(JSON.stringify(current)).digest("hex") === stateDigest2);
 }
 function listSessionIdsUnderOmcRoot(omcRoot) {
-  const sessionsDir = (0, import_path31.join)(omcRoot, "state", "sessions");
-  if (!(0, import_fs28.existsSync)(sessionsDir)) {
+  const sessionsDir = (0, import_path32.join)(omcRoot, "state", "sessions");
+  if (!(0, import_fs29.existsSync)(sessionsDir)) {
     return [];
   }
   try {
-    return (0, import_fs28.readdirSync)(sessionsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,255}$/.test(name));
+    return (0, import_fs29.readdirSync)(sessionsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,255}$/.test(name));
   } catch {
     return [];
   }
@@ -28209,8 +28343,8 @@ function getConvergedOmcRoots(root) {
   if (process.env.OMC_STATE_DIR) return [canonicalRoot];
   if (probeGitTopLevel(root).status !== "ok") return [canonicalRoot];
   const roots = /* @__PURE__ */ new Set([canonicalRoot]);
-  roots.add((0, import_path31.join)(root, OmcPaths.ROOT));
-  roots.add((0, import_path31.join)((0, import_os4.homedir)(), OmcPaths.ROOT));
+  roots.add((0, import_path32.join)(root, OmcPaths.ROOT));
+  roots.add((0, import_path32.join)((0, import_os4.homedir)(), OmcPaths.ROOT));
   return [...roots];
 }
 function getConvergedStateCandidates(mode, root, sessionId) {
@@ -28220,11 +28354,11 @@ function getConvergedStateCandidates(mode, root, sessionId) {
   const filename = getStateFileName(mode);
   const paths = /* @__PURE__ */ new Set();
   for (const omcRoot of getConvergedOmcRoots(root)) {
-    const stateDir = (0, import_path31.join)(omcRoot, "state");
+    const stateDir = (0, import_path32.join)(omcRoot, "state");
     if (sessionId) {
-      paths.add((0, import_path31.join)(stateDir, "sessions", sessionId, filename));
+      paths.add((0, import_path32.join)(stateDir, "sessions", sessionId, filename));
       for (const sid of listSessionIdsUnderOmcRoot(omcRoot)) {
-        const candidatePath = (0, import_path31.join)(stateDir, "sessions", sid, filename);
+        const candidatePath = (0, import_path32.join)(stateDir, "sessions", sid, filename);
         const raw = readJsonRecord(candidatePath);
         if (raw && getStateSessionOwner(raw) === sessionId) {
           paths.add(candidatePath);
@@ -28232,11 +28366,11 @@ function getConvergedStateCandidates(mode, root, sessionId) {
       }
     } else {
       for (const sid of listSessionIdsUnderOmcRoot(omcRoot)) {
-        paths.add((0, import_path31.join)(stateDir, "sessions", sid, filename));
+        paths.add((0, import_path32.join)(stateDir, "sessions", sid, filename));
       }
     }
-    paths.add((0, import_path31.join)(stateDir, filename));
-    paths.add((0, import_path31.join)(omcRoot, filename));
+    paths.add((0, import_path32.join)(stateDir, filename));
+    paths.add((0, import_path32.join)(omcRoot, filename));
   }
   return [...paths];
 }
@@ -28355,7 +28489,7 @@ function hasActiveConvergedState(mode, root, sessionId) {
   return getConvergedStateCandidates(mode, root, sessionId).some((statePath) => isConvergedCandidateActiveForSession(statePath, sessionId));
 }
 function recordTeamClearFailure(mode, candidate, result, teamCleanup) {
-  if (mode !== "team" || !teamCleanup || result === "cleared" || !(0, import_fs28.existsSync)(candidate.path)) return;
+  if (mode !== "team" || !teamCleanup || result === "cleared" || !(0, import_fs29.existsSync)(candidate.path)) return;
   teamCleanup.blocked = true;
 }
 function blockForeignTeamPrimary(root, requesterSessionId, teamCleanup) {
@@ -28386,7 +28520,7 @@ function getSessionStatePath(mode, root, sessionId) {
 function clearModePrimaryWithTeamLock(mode, statePath, clear, captured = true) {
   if (mode !== "team") return clear();
   try {
-    return withProcessIdentityFileLockSync(teamStateLockPath(statePath), () => captured ? clear() : !(0, import_fs28.existsSync)(statePath));
+    return withProcessIdentityFileLockSync(teamStateLockPath(statePath), () => captured ? clear() : !(0, import_fs29.existsSync)(statePath));
   } catch {
     return false;
   }
@@ -28402,33 +28536,33 @@ function getLegacyStateFileCandidates(mode, root) {
   const normalizedName = mode.endsWith("-state") ? mode : `${mode}-state`;
   const candidates = [
     getStatePath(mode, root),
-    (0, import_path31.join)(getOmcRoot(root), `${normalizedName}.json`)
+    (0, import_path32.join)(getOmcRoot(root), `${normalizedName}.json`)
   ];
-  if (mode === "autopilot" && probeGitTopLevel(root).status === "ok") candidates.push((0, import_path31.join)((0, import_os4.homedir)(), ".omg", "state", "autopilot-state.json"));
+  if (mode === "autopilot" && probeGitTopLevel(root).status === "ok") candidates.push((0, import_path32.join)((0, import_os4.homedir)(), ".omg", "state", "autopilot-state.json"));
   return [...new Set(candidates)];
 }
 function isSharedHomeAutopilotCandidate(path14, root) {
-  const sharedHomeStateRoot = (0, import_path31.resolve)((0, import_os4.homedir)(), ".omg", "state");
-  const candidatePath = (0, import_path31.resolve)(path14);
-  const canonicalStateRoot = (0, import_path31.resolve)(getOmcRoot(root), "state");
+  const sharedHomeStateRoot = (0, import_path32.resolve)((0, import_os4.homedir)(), ".omg", "state");
+  const candidatePath = (0, import_path32.resolve)(path14);
+  const canonicalStateRoot = (0, import_path32.resolve)(getOmcRoot(root), "state");
   const isDescendant = (ancestor, descendant) => {
-    const fromAncestor = (0, import_path31.relative)(ancestor, descendant);
-    return fromAncestor === "" || !fromAncestor.startsWith(`..${import_path31.sep}`) && fromAncestor !== ".." && !(0, import_path31.isAbsolute)(fromAncestor);
+    const fromAncestor = (0, import_path32.relative)(ancestor, descendant);
+    return fromAncestor === "" || !fromAncestor.startsWith(`..${import_path32.sep}`) && fromAncestor !== ".." && !(0, import_path32.isAbsolute)(fromAncestor);
   };
   return !isDescendant(canonicalStateRoot, candidatePath) && isDescendant(sharedHomeStateRoot, candidatePath);
 }
 function isStateCandidateForProject(mode, path14, state, root) {
   if (mode !== "autopilot" || !isSharedHomeAutopilotCandidate(path14, root)) return true;
-  return typeof state.project_path === "string" && (0, import_path31.resolve)(state.project_path) === (0, import_path31.resolve)(root);
+  return typeof state.project_path === "string" && (0, import_path32.resolve)(state.project_path) === (0, import_path32.resolve)(root);
 }
 function isAutopilotRecoveryCandidateForProject(path14, root) {
   if (!isSharedHomeAutopilotCandidate(path14, root)) return true;
   const primary = readJsonRecord(path14);
   if (primary) return isStateCandidateForProject("autopilot", path14, primary, root);
-  const artifactPrefix = `${(0, import_path31.basename)(path14)}.emergency-quarantine.`;
+  const artifactPrefix = `${(0, import_path32.basename)(path14)}.emergency-quarantine.`;
   let artifacts;
   try {
-    artifacts = (0, import_fs28.readdirSync)((0, import_path31.dirname)(path14)).filter(
+    artifacts = (0, import_fs29.readdirSync)((0, import_path32.dirname)(path14)).filter(
       (name) => name.startsWith(artifactPrefix) && (name.endsWith(".payload") || /^[0-9a-f-]{36}$/i.test(name.slice(artifactPrefix.length)))
     );
   } catch {
@@ -28436,12 +28570,12 @@ function isAutopilotRecoveryCandidateForProject(path14, root) {
   }
   if (artifacts.length === 0) return false;
   return artifacts.every((name) => {
-    const state = readJsonRecord((0, import_path31.join)((0, import_path31.dirname)(path14), name));
+    const state = readJsonRecord((0, import_path32.join)((0, import_path32.dirname)(path14), name));
     return state !== null && isStateCandidateForProject("autopilot", path14, state, root);
   });
 }
 function getWorkingDirectoryLocalOmcRoot(root) {
-  return (0, import_path31.join)(root, OmcPaths.ROOT);
+  return (0, import_path32.join)(root, OmcPaths.ROOT);
 }
 function shouldCheckWorkingDirectoryLocalState(root) {
   if (probeGitTopLevel(root).status !== "ok") return false;
@@ -28449,13 +28583,13 @@ function shouldCheckWorkingDirectoryLocalState(root) {
 }
 function getWorkingDirectoryLocalSessionStatePath(mode, root, sessionId) {
   const normalizedName = mode.endsWith("-state") ? mode : `${mode}-state`;
-  return (0, import_path31.join)(getWorkingDirectoryLocalOmcRoot(root), "state", "sessions", sessionId, `${normalizedName}.json`);
+  return (0, import_path32.join)(getWorkingDirectoryLocalOmcRoot(root), "state", "sessions", sessionId, `${normalizedName}.json`);
 }
 function getWorkingDirectoryLocalLegacyStateFileCandidates(mode, root) {
   const normalizedName = mode.endsWith("-state") ? mode : `${mode}-state`;
   return [
-    (0, import_path31.join)(getWorkingDirectoryLocalOmcRoot(root), "state", `${normalizedName}.json`),
-    (0, import_path31.join)(getWorkingDirectoryLocalOmcRoot(root), `${normalizedName}.json`)
+    (0, import_path32.join)(getWorkingDirectoryLocalOmcRoot(root), "state", `${normalizedName}.json`),
+    (0, import_path32.join)(getWorkingDirectoryLocalOmcRoot(root), `${normalizedName}.json`)
   ];
 }
 function getWorkingDirectoryLocalStateClearCandidates(mode, root, sessionId) {
@@ -28503,7 +28637,7 @@ function clearCompletedSessionStateCandidates(mode, root, requesterSessionId, di
   return clearStateCandidates(
     mode,
     discovered,
-    (candidate, current) => current.active === true && candidate.ownerSessionId === candidate.completedSessionId && getStateSessionOwner(current) === candidate.completedSessionId && Boolean(candidate.completionEvidencePath && (0, import_fs28.existsSync)(candidate.completionEvidencePath)),
+    (candidate, current) => current.active === true && candidate.ownerSessionId === candidate.completedSessionId && getStateSessionOwner(current) === candidate.completedSessionId && Boolean(candidate.completionEvidencePath && (0, import_fs29.existsSync)(candidate.completionEvidencePath)),
     (candidate) => emergencyRecoveryOptionsForProject(mode, candidate.path, root),
     teamCleanup
   );
@@ -28536,19 +28670,19 @@ ${checkedPaths.map((statePath) => `  - ${statePath}`).join("\n")}` : "";
   return `No state found to clear for mode: ${mode}${scope}${checked}`;
 }
 function getModeRuntimeArtifactPaths(mode, root, sessionIds, includeLegacy = true) {
-  const stateRoot = (0, import_path31.join)(getOmcRoot(root), "state");
+  const stateRoot = (0, import_path32.join)(getOmcRoot(root), "state");
   const names = [`${mode}-stop-breaker.json`, `${mode}-last-steer-at`, `${mode}-continue-steer.lock`];
   const dirs = /* @__PURE__ */ new Set([
     ...includeLegacy ? [stateRoot] : [],
-    ...[...sessionIds ?? listSessionIds(root)].map((sid) => (0, import_path31.join)(stateRoot, "sessions", sid))
+    ...[...sessionIds ?? listSessionIds(root)].map((sid) => (0, import_path32.join)(stateRoot, "sessions", sid))
   ]);
-  return [...dirs].flatMap((dir) => names.map((name) => (0, import_path31.join)(dir, name)));
+  return [...dirs].flatMap((dir) => names.map((name) => (0, import_path32.join)(dir, name)));
 }
 function captureTeamRuntimeArtifacts(root) {
   const captured = /* @__PURE__ */ new Map();
   for (const path14 of getModeRuntimeArtifactPaths("team", root)) try {
-    const stat = (0, import_fs28.lstatSync)(path14);
-    if (stat.isFile()) captured.set(path14, { bytes: (0, import_fs28.readFileSync)(path14), identity: `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}` });
+    const stat = (0, import_fs29.lstatSync)(path14);
+    if (stat.isFile()) captured.set(path14, { bytes: (0, import_fs29.readFileSync)(path14), identity: `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}` });
   } catch {
   }
   return captured;
@@ -28557,17 +28691,17 @@ function clearRuntimeArtifactPaths(paths, captured) {
   let cleared = 0, hadFailure = false;
   for (const artifactPath of paths) {
     const expected = captured?.get(artifactPath);
-    if (!(0, import_fs28.existsSync)(artifactPath) || captured && !expected) continue;
+    if (!(0, import_fs29.existsSync)(artifactPath) || captured && !expected) continue;
     if (expected) {
       try {
-        const stat = (0, import_fs28.lstatSync)(artifactPath);
-        if (!stat.isFile() || `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}` !== expected.identity || !(0, import_fs28.readFileSync)(artifactPath).equals(expected.bytes)) continue;
+        const stat = (0, import_fs29.lstatSync)(artifactPath);
+        if (!stat.isFile() || `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}` !== expected.identity || !(0, import_fs29.readFileSync)(artifactPath).equals(expected.bytes)) continue;
       } catch {
         continue;
       }
     }
     try {
-      (0, import_fs28.unlinkSync)(artifactPath);
+      (0, import_fs29.unlinkSync)(artifactPath);
       cleared++;
     } catch {
       hadFailure = true;
@@ -28606,11 +28740,11 @@ function isSessionModeActive(mode, root, sessionId) {
     return isModeActive(mode, root, sessionId);
   }
   const statePath = resolveSessionStatePath(mode, sessionId, root);
-  if (!(0, import_fs28.existsSync)(statePath)) {
+  if (!(0, import_fs29.existsSync)(statePath)) {
     return false;
   }
   try {
-    const state = JSON.parse((0, import_fs28.readFileSync)(statePath, "utf-8"));
+    const state = JSON.parse((0, import_fs29.readFileSync)(statePath, "utf-8"));
     return state.active === true;
   } catch {
     return false;
@@ -28695,11 +28829,11 @@ var stateReadTool = {
       if (sessionId) {
         validateSessionId(sessionId);
         const statePath2 = getSessionStatePath(mode, root, sessionId);
-        if (!(0, import_fs28.existsSync)(statePath2)) {
+        if (!(0, import_fs29.existsSync)(statePath2)) {
           const completedSessionPaths = findCompletedSessionStateFiles(mode, root, sessionId);
           if (completedSessionPaths.length > 0) {
             const orphanList = completedSessionPaths.map((orphanPath) => {
-              const sessionMarker = `${(0, import_path31.join)("state", "sessions")}/`;
+              const sessionMarker = `${(0, import_path32.join)("state", "sessions")}/`;
               const markerIndex = orphanPath.indexOf(sessionMarker);
               if (markerIndex === -1) return `- ${orphanPath}`;
               const rest = orphanPath.slice(markerIndex + sessionMarker.length);
@@ -28728,7 +28862,7 @@ Expected path: ${statePath2}`
             }]
           };
         }
-        const content = (0, import_fs28.readFileSync)(statePath2, "utf-8");
+        const content = (0, import_fs29.readFileSync)(statePath2, "utf-8");
         let state;
         try {
           state = JSON.parse(content);
@@ -28763,12 +28897,12 @@ ${JSON.stringify(publicStateForMode(mode, state), null, 2)}
         };
       }
       const statePath = getStatePath(mode, root);
-      const legacyExists = (0, import_fs28.existsSync)(statePath);
+      const legacyExists = (0, import_fs29.existsSync)(statePath);
       const sessionIds = listSessionIds(root);
       const activeSessions = [];
       for (const sid of sessionIds) {
         const sessionStatePath = getSessionStatePath(mode, root, sid);
-        if ((0, import_fs28.existsSync)(sessionStatePath)) {
+        if ((0, import_fs29.existsSync)(sessionStatePath)) {
           activeSessions.push(sid);
         }
       }
@@ -28792,7 +28926,7 @@ Note: Reading from legacy/aggregate path (no session_id). This may include state
       let teamReadError = false;
       if (legacyExists) {
         try {
-          const content = (0, import_fs28.readFileSync)(statePath, "utf-8");
+          const content = (0, import_fs29.readFileSync)(statePath, "utf-8");
           const state = JSON.parse(content);
           if (mode === "team" && !isJsonRecord(state)) {
             throw new Error("team state is corrupt; expected a JSON object");
@@ -28821,7 +28955,7 @@ Path: ${statePath}
         for (const sid of activeSessions) {
           const sessionStatePath = getSessionStatePath(mode, root, sid);
           try {
-            const content = (0, import_fs28.readFileSync)(sessionStatePath, "utf-8");
+            const content = (0, import_fs29.readFileSync)(sessionStatePath, "utf-8");
             const state = JSON.parse(content);
             if (mode === "team" && !isJsonRecord(state)) {
               throw new Error("team state is corrupt; expected a JSON object");
@@ -28921,7 +29055,7 @@ var stateWriteTool = {
         ensureOmcDir("state", root);
         statePath = getStatePath(mode, root);
       }
-      if (mode !== "team" && sessionId && (0, import_fs28.existsSync)(statePath)) {
+      if (mode !== "team" && sessionId && (0, import_fs29.existsSync)(statePath)) {
         const existingState = readJsonRecord(statePath);
         const ownerSessionId = existingState ? getStateSessionOwner(existingState) : void 0;
         if (ownerSessionId && ownerSessionId !== sessionId) {
@@ -28975,7 +29109,7 @@ var stateWriteTool = {
       } else if (mode === "autopilot" && builtState.active === false) {
         let currentState = null;
         try {
-          currentState = JSON.parse((0, import_fs28.readFileSync)(statePath, "utf8"));
+          currentState = JSON.parse((0, import_fs29.readFileSync)(statePath, "utf8"));
         } catch {
         }
         if (hasNamedWorkflowMarker(currentState ?? {})) {
@@ -29077,7 +29211,7 @@ function getAllRootSessionStatePaths(mode, root) {
   roots.add(getOmcRoot(root));
   for (const omcRoot of roots) {
     for (const sid of listSessionIdsUnderOmcRoot(omcRoot)) {
-      paths.add((0, import_path31.join)(omcRoot, "state", "sessions", sid, getStateFileName(mode)));
+      paths.add((0, import_path32.join)(omcRoot, "state", "sessions", sid, getStateFileName(mode)));
     }
   }
   return [...paths];
@@ -29087,9 +29221,9 @@ function discoverAllRootSessionStateCandidates(mode, root) {
 }
 function findUnresolvedTeamStatePaths(paths) {
   return [...new Set(paths)].filter((path14) => {
-    if (!(0, import_fs28.existsSync)(path14)) return false;
+    if (!(0, import_fs29.existsSync)(path14)) return false;
     if (readJsonRecordStrict(path14) !== null) return false;
-    return (0, import_fs28.existsSync)(path14);
+    return (0, import_fs29.existsSync)(path14);
   });
 }
 function recoverAutopilotEmergencyTransactions(root, sessionId) {
@@ -29101,12 +29235,12 @@ function recoverAutopilotEmergencyTransactions(root, sessionId) {
   if (shouldCheckWorkingDirectoryLocalState(root)) {
     const localOmcRoot = getWorkingDirectoryLocalOmcRoot(root);
     for (const sid of listSessionIdsUnderOmcRoot(localOmcRoot)) {
-      broadPaths.add((0, import_path31.join)(localOmcRoot, "state", "sessions", sid, getStateFileName("autopilot")));
+      broadPaths.add((0, import_path32.join)(localOmcRoot, "state", "sessions", sid, getStateFileName("autopilot")));
     }
   }
   for (const omcRoot of getConvergedOmcRoots(root)) {
     for (const sid of listSessionIdsUnderOmcRoot(omcRoot)) {
-      broadPaths.add((0, import_path31.join)(omcRoot, "state", "sessions", sid, getStateFileName("autopilot")));
+      broadPaths.add((0, import_path32.join)(omcRoot, "state", "sessions", sid, getStateFileName("autopilot")));
     }
   }
   const directSessionPaths = /* @__PURE__ */ new Set();
@@ -29114,7 +29248,7 @@ function recoverAutopilotEmergencyTransactions(root, sessionId) {
     directSessionPaths.add(resolveSessionStatePath("autopilot", sessionId, root));
     if (shouldCheckWorkingDirectoryLocalState(root)) directSessionPaths.add(getWorkingDirectoryLocalSessionStatePath("autopilot", root, sessionId));
     for (const omcRoot of getConvergedOmcRoots(root)) {
-      directSessionPaths.add((0, import_path31.join)(omcRoot, "state", "sessions", sessionId, getStateFileName("autopilot")));
+      directSessionPaths.add((0, import_path32.join)(omcRoot, "state", "sessions", sessionId, getStateFileName("autopilot")));
     }
     for (const path14 of directSessionPaths) broadPaths.add(path14);
   }
@@ -29136,10 +29270,10 @@ function recoverAutopilotEmergencyTransactions(root, sessionId) {
     }
     if (!recoverEmergencyStateFile(path14, recoveryOptions)) throw new Error(`workflow_emergency_recovery_failed: ${path14}`);
     if (recoveryOptions && !isAutopilotRecoveryCandidateForProject(path14, root)) continue;
-    const artifactPrefix = `${(0, import_path31.basename)(path14)}.emergency-`;
+    const artifactPrefix = `${(0, import_path32.basename)(path14)}.emergency-`;
     let artifacts;
     try {
-      artifacts = (0, import_fs28.readdirSync)((0, import_path31.dirname)(path14)).filter((name) => name.startsWith(artifactPrefix) && !name.endsWith(".recovery.guard"));
+      artifacts = (0, import_fs29.readdirSync)((0, import_path32.dirname)(path14)).filter((name) => name.startsWith(artifactPrefix) && !name.endsWith(".recovery.guard"));
     } catch {
       artifacts = [];
     }
@@ -29162,7 +29296,7 @@ var stateClearTool = {
       const sessionId = session_id;
       if (mode === "ultrawork") {
         try {
-          if ((0, import_fs28.lstatSync)((0, import_path31.join)((0, import_path31.resolve)(root), OmcPaths.ROOT)).isSymbolicLink()) {
+          if ((0, import_fs29.lstatSync)((0, import_path32.join)((0, import_path32.resolve)(root), OmcPaths.ROOT)).isSymbolicLink()) {
             return { content: [{ type: "text", text: `No state found to clear for mode: ${mode}` }] };
           }
         } catch {
@@ -29226,7 +29360,7 @@ var stateClearTool = {
         let directCleared = 0;
         for (const candidate of namedPrimaries) {
           const success = clearAutopilotMarkerCandidate(candidate, root);
-          if (!success || (0, import_fs28.existsSync)(candidate.path)) throw new Error(`primary state mutation failed; dependent state preserved: ${candidate.path}`);
+          if (!success || (0, import_fs29.existsSync)(candidate.path)) throw new Error(`primary state mutation failed; dependent state preserved: ${candidate.path}`);
           directCleared += 1;
         }
         const completedSessionCleanup = clearCompletedSessionStateCandidates(
@@ -29240,11 +29374,11 @@ var stateClearTool = {
         const sessionSignalCandidates = operationCandidates.filter((candidate) => !hasNamedWorkflowMarker(candidate.state));
         const signaledCandidateDirs = /* @__PURE__ */ new Set();
         for (const candidate of sessionSignalCandidates) {
-          const signalDir = (0, import_path31.dirname)(candidate.path);
+          const signalDir = (0, import_path32.dirname)(candidate.path);
           if (signaledCandidateDirs.has(signalDir)) continue;
           signaledCandidateDirs.add(signalDir);
           const now = Date.now();
-          const signalPath = (0, import_path31.join)(signalDir, "cancel-signal-state.json");
+          const signalPath = (0, import_path32.join)(signalDir, "cancel-signal-state.json");
           const payload = {
             active: true,
             requested_at: new Date(now).toISOString(),
@@ -29286,7 +29420,7 @@ var stateClearTool = {
           const clearPrimary = () => clearModeState(mode, root, sessionId, expectedDirectState);
           const directCaptured = directCandidate?.path === directStatePath;
           primarySuccess = clearModePrimaryWithTeamLock(mode, directStatePath, clearPrimary, directCaptured);
-          if (directCaptured && primarySuccess && !(0, import_fs28.existsSync)(directStatePath)) {
+          if (directCaptured && primarySuccess && !(0, import_fs29.existsSync)(directStatePath)) {
             directCleared = 1;
             if (mode === "team" && directCandidate) teamCleanup.clearedSessions.add(sessionId);
           } else if (mode === "team" && directCaptured && directCandidate) {
@@ -29302,7 +29436,7 @@ var stateClearTool = {
               const ownerNamedPrimary = mode === "autopilot" && ownerDirectCandidate && hasNamedWorkflowMarker(ownerDirectCandidate.state) ? ownerDirectCandidate : void 0;
               if (ownerNamedPrimary) {
                 const success = clearAutopilotMarkerCandidate(ownerNamedPrimary, root);
-                if (!success || (0, import_fs28.existsSync)(ownerNamedPrimary.path)) throw new Error("primary state mutation failed; dependent state preserved");
+                if (!success || (0, import_fs29.existsSync)(ownerNamedPrimary.path)) throw new Error("primary state mutation failed; dependent state preserved");
               } else {
                 writeSessionCancelSignal(root, ownerSessionId, mode, ownerDirectCandidate);
                 clearModeState(mode, root, ownerSessionId, ownerDirectCandidate?.state);
@@ -29317,9 +29451,9 @@ var stateClearTool = {
         }
         if (mode === "team" && teamRuntimeSnapshots) {
           const safeTeamSessions = new Set([...teamCleanup.clearedSessions].filter((sid) => !operationCandidates.some(
-            (candidate) => teamSessionIdForCandidate(candidate, sessionId) === sid && (0, import_fs28.existsSync)(candidate.path)
+            (candidate) => teamSessionIdForCandidate(candidate, sessionId) === sid && (0, import_fs29.existsSync)(candidate.path)
           )));
-          const eligibleTeamSessions = new Set([...safeTeamSessions].filter((sid) => !(0, import_fs28.existsSync)(getSessionStatePath("team", root, sid))));
+          const eligibleTeamSessions = new Set([...safeTeamSessions].filter((sid) => !(0, import_fs29.existsSync)(getSessionStatePath("team", root, sid))));
           const teamRuntimeCleanup = clearTeamRuntimeArtifacts(root, eligibleTeamSessions, teamRuntimeSnapshots);
           runtimeCleanup2.cleared += teamRuntimeCleanup.cleared;
           runtimeCleanup2.hadFailure ||= teamRuntimeCleanup.hadFailure;
@@ -29336,7 +29470,7 @@ var stateClearTool = {
         );
         const clearedStateOrArtifacts = directCleared + completedSessionCleanup.cleared + sessionCleanup.cleared + legacyCleanup.cleared + convergedCleanup2.cleared + workingDirectoryLocalCleanup.cleared + ownerSessionCleanup.cleared + ownerLegacyCleanup.cleared + runtimeCleanup2.cleared;
         const capturedCleanupIncomplete2 = operationCandidates.some((candidate) => {
-          if (!(0, import_fs28.existsSync)(candidate.path)) return false;
+          if (!(0, import_fs29.existsSync)(candidate.path)) return false;
           if (mode === "team") return true;
           const current = readJsonRecordStrict(candidate.path);
           if (!current) return true;
@@ -29380,7 +29514,7 @@ var stateClearTool = {
       const broadNamedPrimaries = mode === "autopilot" ? broadOperationCandidates.filter((candidate) => hasNamedWorkflowMarker(candidate.state)) : [];
       for (const candidate of broadNamedPrimaries) {
         const success = clearAutopilotMarkerCandidate(candidate, root);
-        if (!success || (0, import_fs28.existsSync)(candidate.path)) throw new Error(`primary state mutation failed; dependent state preserved: ${candidate.path}`);
+        if (!success || (0, import_fs29.existsSync)(candidate.path)) throw new Error(`primary state mutation failed; dependent state preserved: ${candidate.path}`);
       }
       const broadLegacySignalCandidates = broadLegacyCandidates.filter((candidate) => !hasNamedWorkflowMarker(candidate.state));
       const broadSessionSignalCandidates = broadSessionCandidates.filter((candidate) => !hasNamedWorkflowMarker(candidate.state));
@@ -29395,10 +29529,10 @@ var stateClearTool = {
         };
         const signaledLegacyDirs = /* @__PURE__ */ new Set();
         for (const legacyCandidate of broadLegacySignalCandidates) {
-          const signalDir = (0, import_path31.dirname)(legacyCandidate.path);
+          const signalDir = (0, import_path32.dirname)(legacyCandidate.path);
           if (signaledLegacyDirs.has(signalDir)) continue;
           signaledLegacyDirs.add(signalDir);
-          const legacySignalPath = (0, import_path31.join)(signalDir, "cancel-signal-state.json");
+          const legacySignalPath = (0, import_path32.join)(signalDir, "cancel-signal-state.json");
           const legacyPayload = {
             ...cancelSignalPayload,
             ...legacyCandidate.workflowRunId ? { target_workflow_run_id: legacyCandidate.workflowRunId } : {},
@@ -29429,14 +29563,14 @@ var stateClearTool = {
         if (primaryCandidate) {
           const clearPrimary = () => clearModeState(mode, root, void 0, primaryCandidate.state);
           const success = clearModePrimaryWithTeamLock(mode, primaryLegacyStatePath, clearPrimary);
-          if (success && !(0, import_fs28.existsSync)(primaryCandidate.path)) {
+          if (success && !(0, import_fs29.existsSync)(primaryCandidate.path)) {
             clearedCount++;
             if (mode === "team") {
               teamLegacyCleared = true;
               const ownerSessionId = teamSessionIdForCandidate(primaryCandidate);
               if (ownerSessionId) teamCleanup.clearedSessions.add(ownerSessionId);
             }
-          } else if ((0, import_fs28.existsSync)(primaryCandidate.path)) {
+          } else if ((0, import_fs29.existsSync)(primaryCandidate.path)) {
             if (mode === "team") {
               recordTeamClearFailure(mode, primaryCandidate, success ? "skipped" : "failed", teamCleanup);
             }
@@ -29491,7 +29625,7 @@ var stateClearTool = {
             const ownerSessionId = teamSessionIdForCandidate(candidate);
             if (ownerSessionId) teamCleanup.clearedSessions.add(ownerSessionId);
           }
-        } else if (result === "failed" || (0, import_fs28.existsSync)(candidate.path)) {
+        } else if (result === "failed" || (0, import_fs29.existsSync)(candidate.path)) {
           recordTeamClearFailure(mode, candidate, result, teamCleanup);
           errors.push(`session candidate: ${candidate.path}`);
         }
@@ -29501,12 +29635,12 @@ var stateClearTool = {
         ...broadConvergedCandidates,
         ...broadSessionCandidates
       ].map((candidate) => [candidate.path, candidate])).values()];
-      const capturedCleanupIncomplete = broadCapturedCandidates.some((candidate) => (0, import_fs28.existsSync)(candidate.path));
+      const capturedCleanupIncomplete = broadCapturedCandidates.some((candidate) => (0, import_fs29.existsSync)(candidate.path));
       if (mode === "team" && teamRuntimeSnapshots) {
         const safeTeamSessions = new Set([...teamCleanup.clearedSessions].filter((sid) => !broadCapturedCandidates.some(
-          (candidate) => teamSessionIdForCandidate(candidate) === sid && (0, import_fs28.existsSync)(candidate.path)
+          (candidate) => teamSessionIdForCandidate(candidate) === sid && (0, import_fs29.existsSync)(candidate.path)
         )));
-        const eligibleTeamSessions = new Set([...safeTeamSessions].filter((sid) => !(0, import_fs28.existsSync)(getSessionStatePath("team", root, sid))));
+        const eligibleTeamSessions = new Set([...safeTeamSessions].filter((sid) => !(0, import_fs29.existsSync)(getSessionStatePath("team", root, sid))));
         const teamRuntimeCleanup = clearTeamRuntimeArtifacts(root, eligibleTeamSessions, teamRuntimeSnapshots);
         runtimeCleanup.cleared += teamRuntimeCleanup.cleared;
         runtimeCleanup.hadFailure ||= teamRuntimeCleanup.hadFailure;
@@ -29520,11 +29654,11 @@ var stateClearTool = {
         errors.push("runtime artifacts");
       }
       for (const candidate of broadCapturedCandidates) {
-        if ((0, import_fs28.existsSync)(candidate.path) && !errors.some((error2) => error2.includes(candidate.path))) {
+        if ((0, import_fs29.existsSync)(candidate.path) && !errors.some((error2) => error2.includes(candidate.path))) {
           errors.push(`captured candidate survived: ${candidate.path}`);
         }
       }
-      clearedCount = broadCapturedCandidates.filter((candidate) => !(0, import_fs28.existsSync)(candidate.path)).length + runtimeCleanup.cleared;
+      clearedCount = broadCapturedCandidates.filter((candidate) => !(0, import_fs29.existsSync)(candidate.path)).length + runtimeCleanup.cleared;
       if (clearedCount === 0 && errors.length === 0) {
         return {
           content: [{
@@ -29584,8 +29718,8 @@ var stateListActiveTool = {
         for (const mode of EXTRA_STATE_ONLY_MODES) {
           try {
             const statePath = resolveSessionStatePath(mode, sessionId, root);
-            if ((0, import_fs28.existsSync)(statePath)) {
-              const content = (0, import_fs28.readFileSync)(statePath, "utf-8");
+            if ((0, import_fs29.existsSync)(statePath)) {
+              const content = (0, import_fs29.readFileSync)(statePath, "utf-8");
               const state = JSON.parse(content);
               if (state.active && canClearStateForSession(state, sessionId)) {
                 activeModes.push(mode);
@@ -29624,9 +29758,9 @@ ${modeList}`
       const legacyActiveModes = [...getActiveModes(root)].filter((activeMode) => !isRetiredWorkflowMode(activeMode));
       for (const mode of EXTRA_STATE_ONLY_MODES) {
         const statePath = getStatePath(mode, root);
-        if ((0, import_fs28.existsSync)(statePath)) {
+        if ((0, import_fs29.existsSync)(statePath)) {
           try {
-            const content = (0, import_fs28.readFileSync)(statePath, "utf-8");
+            const content = (0, import_fs29.readFileSync)(statePath, "utf-8");
             const state = JSON.parse(content);
             if (state.active) {
               legacyActiveModes.push(mode);
@@ -29653,8 +29787,8 @@ ${modeList}`
         for (const mode of EXTRA_STATE_ONLY_MODES) {
           try {
             const statePath = resolveSessionStatePath(mode, sid, root);
-            if ((0, import_fs28.existsSync)(statePath)) {
-              const content = (0, import_fs28.readFileSync)(statePath, "utf-8");
+            if ((0, import_fs29.existsSync)(statePath)) {
+              const content = (0, import_fs29.readFileSync)(statePath, "utf-8");
               const state = JSON.parse(content);
               if (state.active && canClearStateForSession(state, sid)) {
                 sessionActiveModes.push(mode);
@@ -29720,9 +29854,9 @@ var stateGetStatusTool = {
         if (sessionId) {
           validateSessionId(sessionId);
           const statePath = getSessionStatePath(mode, root, sessionId);
-          const active = !isRetiredWorkflowMode(mode) && (MODE_CONFIGS[mode] ? isModeActive(mode, root, sessionId) : (0, import_fs28.existsSync)(statePath) && (() => {
+          const active = !isRetiredWorkflowMode(mode) && (MODE_CONFIGS[mode] ? isModeActive(mode, root, sessionId) : (0, import_fs29.existsSync)(statePath) && (() => {
             try {
-              const content = (0, import_fs28.readFileSync)(statePath, "utf-8");
+              const content = (0, import_fs29.readFileSync)(statePath, "utf-8");
               const state = JSON.parse(content);
               return state.active === true && canClearStateForSession(state, sessionId);
             } catch {
@@ -29730,9 +29864,9 @@ var stateGetStatusTool = {
             }
           })());
           let statePreview = "No state file";
-          if ((0, import_fs28.existsSync)(statePath)) {
+          if ((0, import_fs29.existsSync)(statePath)) {
             try {
-              const content = (0, import_fs28.readFileSync)(statePath, "utf-8");
+              const content = (0, import_fs29.readFileSync)(statePath, "utf-8");
               const state = JSON.parse(content);
               const owner = getStateSessionOwner(state);
               if (!owner || owner === sessionId) {
@@ -29744,10 +29878,10 @@ var stateGetStatusTool = {
             }
           }
           lines2.push(`### Session: ${sessionId}`);
-          const visible = !(0, import_fs28.existsSync)(statePath) || statePreview !== "No state file" && !statePreview.includes("Error reading state file");
+          const visible = !(0, import_fs29.existsSync)(statePath) || statePreview !== "No state file" && !statePreview.includes("Error reading state file");
           lines2.push(`- **Active:** ${visible && active ? "Yes" : "No"}`);
           lines2.push(`- **State Path:** ${statePath}`);
-          lines2.push(`- **Exists:** ${visible && (0, import_fs28.existsSync)(statePath) ? "Yes" : "No"}`);
+          lines2.push(`- **Exists:** ${visible && (0, import_fs29.existsSync)(statePath) ? "Yes" : "No"}`);
           lines2.push(`
 ### State Preview
 \`\`\`json
@@ -29761,9 +29895,9 @@ ${statePreview}
           };
         }
         const legacyPath = getStatePath(mode, root);
-        const legacyActive = !isRetiredWorkflowMode(mode) && (MODE_CONFIGS[mode] ? isModeActive(mode, root) : (0, import_fs28.existsSync)(legacyPath) && (() => {
+        const legacyActive = !isRetiredWorkflowMode(mode) && (MODE_CONFIGS[mode] ? isModeActive(mode, root) : (0, import_fs29.existsSync)(legacyPath) && (() => {
           try {
-            const content = (0, import_fs28.readFileSync)(legacyPath, "utf-8");
+            const content = (0, import_fs29.readFileSync)(legacyPath, "utf-8");
             const state = JSON.parse(content);
             return state.active === true;
           } catch {
@@ -29773,13 +29907,13 @@ ${statePreview}
         lines2.push(`### Legacy Path`);
         lines2.push(`- **Active:** ${legacyActive ? "Yes" : "No"}`);
         lines2.push(`- **State Path:** ${legacyPath}`);
-        lines2.push(`- **Exists:** ${(0, import_fs28.existsSync)(legacyPath) ? "Yes" : "No"}
+        lines2.push(`- **Exists:** ${(0, import_fs29.existsSync)(legacyPath) ? "Yes" : "No"}
 `);
         const activeSessions = isRetiredWorkflowMode(mode) ? [] : MODE_CONFIGS[mode] ? getActiveSessionsForMode(mode, root) : listSessionIds(root).filter((sid) => {
           try {
             const sessionPath = resolveSessionStatePath(mode, sid, root);
-            if ((0, import_fs28.existsSync)(sessionPath)) {
-              const content = (0, import_fs28.readFileSync)(sessionPath, "utf-8");
+            if ((0, import_fs29.existsSync)(sessionPath)) {
+              const content = (0, import_fs29.readFileSync)(sessionPath, "utf-8");
               const state = JSON.parse(content);
               return state.active === true && canClearStateForSession(state, sid);
             }
@@ -29823,9 +29957,9 @@ No active sessions for this mode.`);
       for (const mode2 of EXTRA_STATE_ONLY_MODES) {
         const statePath = sessionId ? resolveSessionStatePath(mode2, sessionId, root) : getStatePath(mode2, root);
         let active = false;
-        if ((0, import_fs28.existsSync)(statePath)) {
+        if ((0, import_fs29.existsSync)(statePath)) {
           try {
-            const content = (0, import_fs28.readFileSync)(statePath, "utf-8");
+            const content = (0, import_fs29.readFileSync)(statePath, "utf-8");
             const state = JSON.parse(content);
             active = state.active === true && (!sessionId || canClearStateForSession(state, sessionId));
           } catch {
@@ -29864,68 +29998,68 @@ var stateMigrateNonGitTool = {
     try {
       if (!args.session_id) throw new Error("session_id is required");
       validateSessionId(args.session_id);
-      const sourceRoot = (0, import_fs28.realpathSync)((0, import_path31.resolve)(args.workingDirectory || process.cwd()));
-      const trustedWorkingDirectory = (0, import_fs28.realpathSync)((0, import_path31.resolve)(process.cwd()));
-      const sourceFromTrustedCwd = (0, import_path31.relative)(trustedWorkingDirectory, sourceRoot);
-      if (sourceFromTrustedCwd === ".." || sourceFromTrustedCwd.startsWith(`..${import_path31.sep}`) || (0, import_path31.isAbsolute)(sourceFromTrustedCwd)) {
+      const sourceRoot = (0, import_fs29.realpathSync)((0, import_path32.resolve)(args.workingDirectory || process.cwd()));
+      const trustedWorkingDirectory = (0, import_fs29.realpathSync)((0, import_path32.resolve)(process.cwd()));
+      const sourceFromTrustedCwd = (0, import_path32.relative)(trustedWorkingDirectory, sourceRoot);
+      if (sourceFromTrustedCwd === ".." || sourceFromTrustedCwd.startsWith(`..${import_path32.sep}`) || (0, import_path32.isAbsolute)(sourceFromTrustedCwd)) {
         throw new Error("state_migrate_non_git refuses a source outside the trusted session working directory");
       }
       const gitProbe = probeGitTopLevel(sourceRoot);
       if (gitProbe.status === "ok") throw new Error("state_migrate_non_git only accepts a non-git source directory");
       if (gitProbe.status !== "not_a_repository") throw new Error("state_migrate_non_git refused a failed Git probe");
       if (findGitMetadataDir(sourceRoot)) throw new Error("state_migrate_non_git refuses a directory with Git metadata");
-      const authorizedHome = (0, import_fs28.realpathSync)((0, import_os4.homedir)());
-      const sourceFromHome = (0, import_path31.relative)(authorizedHome, sourceRoot);
-      if (sourceFromHome === ".." || sourceFromHome.startsWith(`..${import_path31.sep}`) || (0, import_path31.isAbsolute)(sourceFromHome)) {
+      const authorizedHome = (0, import_fs29.realpathSync)((0, import_os4.homedir)());
+      const sourceFromHome = (0, import_path32.relative)(authorizedHome, sourceRoot);
+      if (sourceFromHome === ".." || sourceFromHome.startsWith(`..${import_path32.sep}`) || (0, import_path32.isAbsolute)(sourceFromHome)) {
         throw new Error("state_migrate_non_git refuses a source outside the authorized home boundary");
       }
       if (isSensitiveStateLocation(sourceRoot)) throw new Error("state_migrate_non_git refuses sensitive source directories");
       const canonicalOmc = getOmcRoot(sourceRoot);
-      const sourceDir = (0, import_path31.join)(sourceRoot, OmcPaths.ROOT, "state", "sessions", args.session_id);
-      const destinationDir = (0, import_path31.join)(canonicalOmc, "state", "sessions", args.session_id);
+      const sourceDir = (0, import_path32.join)(sourceRoot, OmcPaths.ROOT, "state", "sessions", args.session_id);
+      const destinationDir = (0, import_path32.join)(canonicalOmc, "state", "sessions", args.session_id);
       const report = { source: sourceDir, destination: destinationDir, copied: [], skipped: [], rejected: [] };
-      const sourceOmc = (0, import_path31.join)(sourceRoot, OmcPaths.ROOT);
-      if (!(0, import_fs28.existsSync)(sourceOmc)) {
+      const sourceOmc = (0, import_path32.join)(sourceRoot, OmcPaths.ROOT);
+      if (!(0, import_fs29.existsSync)(sourceOmc)) {
         return { content: [{ type: "text", text: JSON.stringify(report, null, 2) }] };
       }
-      const sourceState = (0, import_path31.join)(sourceOmc, "state");
-      const sourceSessions = (0, import_path31.join)(sourceState, "sessions");
+      const sourceState = (0, import_path32.join)(sourceOmc, "state");
+      const sourceSessions = (0, import_path32.join)(sourceState, "sessions");
       for (const path14 of [sourceOmc, sourceState, sourceSessions]) {
-        if (!(0, import_fs28.existsSync)(path14)) {
+        if (!(0, import_fs29.existsSync)(path14)) {
           return { content: [{ type: "text", text: JSON.stringify(report, null, 2) }] };
         }
-        if ((0, import_fs28.lstatSync)(path14).isSymbolicLink()) throw new Error("state_migrate_non_git refuses symlinked legacy state paths");
+        if ((0, import_fs29.lstatSync)(path14).isSymbolicLink()) throw new Error("state_migrate_non_git refuses symlinked legacy state paths");
       }
-      if (!(0, import_fs28.existsSync)(sourceDir)) {
+      if (!(0, import_fs29.existsSync)(sourceDir)) {
         return { content: [{ type: "text", text: JSON.stringify(report, null, 2) }] };
       }
-      const destinationState = (0, import_path31.join)(canonicalOmc, "state");
-      const destinationSessions = (0, import_path31.join)(destinationState, "sessions");
+      const destinationState = (0, import_path32.join)(canonicalOmc, "state");
+      const destinationSessions = (0, import_path32.join)(destinationState, "sessions");
       const migrationRoots = [canonicalOmc, destinationState, destinationSessions, destinationDir];
-      if ((0, import_fs28.lstatSync)(sourceDir).isSymbolicLink() || migrationRoots.some((path14) => (0, import_fs28.existsSync)(path14) && (0, import_fs28.lstatSync)(path14).isSymbolicLink())) {
+      if ((0, import_fs29.lstatSync)(sourceDir).isSymbolicLink() || migrationRoots.some((path14) => (0, import_fs29.existsSync)(path14) && (0, import_fs29.lstatSync)(path14).isSymbolicLink())) {
         throw new Error("state_migrate_non_git refuses symlinked migration roots");
       }
       ensureMigrationDirectoryTree(canonicalOmc, destinationDir);
-      for (const entry of (0, import_fs28.readdirSync)(sourceDir, { withFileTypes: true })) {
+      for (const entry of (0, import_fs29.readdirSync)(sourceDir, { withFileTypes: true })) {
         if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-        const sourcePath = (0, import_path31.join)(sourceDir, entry.name);
-        const sourceFd = (0, import_fs28.openSync)(sourcePath, import_fs28.constants.O_RDONLY | (import_fs28.constants.O_NOFOLLOW ?? 0));
+        const sourcePath = (0, import_path32.join)(sourceDir, entry.name);
+        const sourceFd = (0, import_fs29.openSync)(sourcePath, import_fs29.constants.O_RDONLY | (import_fs29.constants.O_NOFOLLOW ?? 0));
         let sourceBytes;
         try {
-          const sourceStat = (0, import_fs28.fstatSync)(sourceFd);
+          const sourceStat = (0, import_fs29.fstatSync)(sourceFd);
           if (!sourceStat.isFile()) throw new Error("state_migrate_non_git refuses a non-file source entry");
           if (sourceStat.size > MAX_MIGRATION_FILE_BYTES) {
             report.rejected.push(entry.name);
             continue;
           }
           sourceBytes = Buffer.alloc(sourceStat.size);
-          const bytesRead = sourceStat.size === 0 ? 0 : (0, import_fs28.readSync)(sourceFd, sourceBytes, 0, sourceStat.size, 0);
+          const bytesRead = sourceStat.size === 0 ? 0 : (0, import_fs29.readSync)(sourceFd, sourceBytes, 0, sourceStat.size, 0);
           if (bytesRead !== sourceStat.size) {
             report.rejected.push(entry.name);
             continue;
           }
         } finally {
-          (0, import_fs28.closeSync)(sourceFd);
+          (0, import_fs29.closeSync)(sourceFd);
         }
         let state = null;
         try {
@@ -29936,14 +30070,14 @@ var stateMigrateNonGitTool = {
           report.rejected.push(entry.name);
           continue;
         }
-        const destinationPath = (0, import_path31.join)(destinationDir, entry.name);
+        const destinationPath = (0, import_path32.join)(destinationDir, entry.name);
         ensureMigrationDirectoryTree(canonicalOmc, destinationDir);
-        if ((0, import_fs28.existsSync)(destinationPath)) {
+        if ((0, import_fs29.existsSync)(destinationPath)) {
           report.skipped.push(entry.name);
           continue;
         }
         try {
-          (0, import_fs28.writeFileSync)(destinationPath, sourceBytes, { flag: "wx", mode: 384 });
+          (0, import_fs29.writeFileSync)(destinationPath, sourceBytes, { flag: "wx", mode: 384 });
           report.copied.push(entry.name);
         } catch (error2) {
           if (error2.code === "EEXIST") report.skipped.push(entry.name);
@@ -30087,21 +30221,21 @@ var stateTools = [
 ];
 
 // src/hooks/notepad/index.ts
-var import_fs30 = require("fs");
-var import_path32 = require("path");
+var import_fs31 = require("fs");
+var import_path33 = require("path");
 
 // src/lib/file-lock.ts
-var import_fs29 = require("fs");
+var import_fs30 = require("fs");
 var path7 = __toESM(require("path"), 1);
 var DEFAULT_STALE_LOCK_MS = 3e4;
 var DEFAULT_RETRY_DELAY_MS = 50;
 function isLockStale(lockPath, staleLockMs) {
   try {
-    const stat = (0, import_fs29.statSync)(lockPath);
+    const stat = (0, import_fs30.statSync)(lockPath);
     const ageMs = Date.now() - stat.mtimeMs;
     if (ageMs < staleLockMs) return false;
     try {
-      const raw = (0, import_fs29.readFileSync)(lockPath, "utf-8");
+      const raw = (0, import_fs30.readFileSync)(lockPath, "utf-8");
       const payload = JSON.parse(raw);
       if (payload.pid && isProcessAlive(payload.pid)) return false;
     } catch {
@@ -30117,21 +30251,21 @@ function lockPathFor(filePath) {
 function tryAcquireSync(lockPath, staleLockMs) {
   ensureDirSync(path7.dirname(lockPath));
   try {
-    const fd = (0, import_fs29.openSync)(
+    const fd = (0, import_fs30.openSync)(
       lockPath,
-      import_fs29.constants.O_CREAT | import_fs29.constants.O_EXCL | import_fs29.constants.O_WRONLY,
+      import_fs30.constants.O_CREAT | import_fs30.constants.O_EXCL | import_fs30.constants.O_WRONLY,
       384
     );
     try {
       const payload = JSON.stringify({ pid: process.pid, timestamp: Date.now() });
-      (0, import_fs29.writeSync)(fd, payload, null, "utf-8");
+      (0, import_fs30.writeSync)(fd, payload, null, "utf-8");
     } catch (writeErr) {
       try {
-        (0, import_fs29.closeSync)(fd);
+        (0, import_fs30.closeSync)(fd);
       } catch {
       }
       try {
-        (0, import_fs29.unlinkSync)(lockPath);
+        (0, import_fs30.unlinkSync)(lockPath);
       } catch {
       }
       throw writeErr;
@@ -30141,25 +30275,25 @@ function tryAcquireSync(lockPath, staleLockMs) {
     if (err && typeof err === "object" && "code" in err && err.code === "EEXIST") {
       if (isLockStale(lockPath, staleLockMs)) {
         try {
-          (0, import_fs29.unlinkSync)(lockPath);
+          (0, import_fs30.unlinkSync)(lockPath);
         } catch {
         }
         try {
-          const fd = (0, import_fs29.openSync)(
+          const fd = (0, import_fs30.openSync)(
             lockPath,
-            import_fs29.constants.O_CREAT | import_fs29.constants.O_EXCL | import_fs29.constants.O_WRONLY,
+            import_fs30.constants.O_CREAT | import_fs30.constants.O_EXCL | import_fs30.constants.O_WRONLY,
             384
           );
           try {
             const payload = JSON.stringify({ pid: process.pid, timestamp: Date.now() });
-            (0, import_fs29.writeSync)(fd, payload, null, "utf-8");
+            (0, import_fs30.writeSync)(fd, payload, null, "utf-8");
           } catch (writeErr) {
             try {
-              (0, import_fs29.closeSync)(fd);
+              (0, import_fs30.closeSync)(fd);
             } catch {
             }
             try {
-              (0, import_fs29.unlinkSync)(lockPath);
+              (0, import_fs30.unlinkSync)(lockPath);
             } catch {
             }
             throw writeErr;
@@ -30199,11 +30333,11 @@ function acquireFileLockSync(lockPath, opts) {
 }
 function releaseFileLockSync(handle) {
   try {
-    (0, import_fs29.closeSync)(handle.fd);
+    (0, import_fs30.closeSync)(handle.fd);
   } catch {
   }
   try {
-    (0, import_fs29.unlinkSync)(handle.path);
+    (0, import_fs30.unlinkSync)(handle.path);
   } catch {
   }
 }
@@ -30281,19 +30415,19 @@ function getSectionRegexSet(header) {
   return SECTION_REGEXES[header] ?? createSectionRegexSet(header);
 }
 function getNotepadPath(directory) {
-  return (0, import_path32.join)(getOmcRoot(directory), NOTEPAD_FILENAME);
+  return (0, import_path33.join)(getOmcRoot(directory), NOTEPAD_FILENAME);
 }
 function initNotepad(directory) {
   const omcDir = getOmcRoot(directory);
-  if (!(0, import_fs30.existsSync)(omcDir)) {
+  if (!(0, import_fs31.existsSync)(omcDir)) {
     try {
-      (0, import_fs30.mkdirSync)(omcDir, { recursive: true });
+      (0, import_fs31.mkdirSync)(omcDir, { recursive: true });
     } catch {
       return false;
     }
   }
   const notepadPath = getNotepadPath(directory);
-  if ((0, import_fs30.existsSync)(notepadPath)) {
+  if ((0, import_fs31.existsSync)(notepadPath)) {
     return true;
   }
   const content = `# Notepad
@@ -30318,11 +30452,11 @@ ${MANUAL_HEADER}
 }
 function readNotepad(directory) {
   const notepadPath = getNotepadPath(directory);
-  if (!(0, import_fs30.existsSync)(notepadPath)) {
+  if (!(0, import_fs31.existsSync)(notepadPath)) {
     return null;
   }
   try {
-    return (0, import_fs30.readFileSync)(notepadPath, "utf-8");
+    return (0, import_fs31.readFileSync)(notepadPath, "utf-8");
   } catch {
     return null;
   }
@@ -30368,7 +30502,7 @@ function getManualSection(directory) {
   return extractSection(content, MANUAL_HEADER);
 }
 function setPriorityContext(directory, content, config2 = DEFAULT_CONFIG3) {
-  if (!(0, import_fs30.existsSync)(getNotepadPath(directory))) {
+  if (!(0, import_fs31.existsSync)(getNotepadPath(directory))) {
     if (!initNotepad(directory)) {
       return { success: false };
     }
@@ -30376,7 +30510,7 @@ function setPriorityContext(directory, content, config2 = DEFAULT_CONFIG3) {
   const notepadPath = getNotepadPath(directory);
   try {
     return withFileLockSync(lockPathFor(notepadPath), () => {
-      let notepadContent = (0, import_fs30.readFileSync)(notepadPath, "utf-8");
+      let notepadContent = (0, import_fs31.readFileSync)(notepadPath, "utf-8");
       const warning = content.length > config2.priorityMaxChars ? `Priority Context exceeds ${config2.priorityMaxChars} chars (${content.length} chars). Consider condensing.` : void 0;
       notepadContent = replaceSection(notepadContent, PRIORITY_HEADER, content);
       atomicWriteFileSync(notepadPath, notepadContent);
@@ -30387,7 +30521,7 @@ function setPriorityContext(directory, content, config2 = DEFAULT_CONFIG3) {
   }
 }
 function addWorkingMemoryEntry(directory, content) {
-  if (!(0, import_fs30.existsSync)(getNotepadPath(directory))) {
+  if (!(0, import_fs31.existsSync)(getNotepadPath(directory))) {
     if (!initNotepad(directory)) {
       return false;
     }
@@ -30395,7 +30529,7 @@ function addWorkingMemoryEntry(directory, content) {
   const notepadPath = getNotepadPath(directory);
   try {
     return withFileLockSync(lockPathFor(notepadPath), () => {
-      let notepadContent = (0, import_fs30.readFileSync)(notepadPath, "utf-8");
+      let notepadContent = (0, import_fs31.readFileSync)(notepadPath, "utf-8");
       const currentMemory = extractSection(notepadContent, WORKING_MEMORY_HEADER) || "";
       const now = /* @__PURE__ */ new Date();
       const timestamp2 = now.toISOString().slice(0, 16).replace("T", " ");
@@ -30416,7 +30550,7 @@ ${content}
   }
 }
 function addManualEntry(directory, content) {
-  if (!(0, import_fs30.existsSync)(getNotepadPath(directory))) {
+  if (!(0, import_fs31.existsSync)(getNotepadPath(directory))) {
     if (!initNotepad(directory)) {
       return false;
     }
@@ -30424,7 +30558,7 @@ function addManualEntry(directory, content) {
   const notepadPath = getNotepadPath(directory);
   try {
     return withFileLockSync(lockPathFor(notepadPath), () => {
-      let notepadContent = (0, import_fs30.readFileSync)(notepadPath, "utf-8");
+      let notepadContent = (0, import_fs31.readFileSync)(notepadPath, "utf-8");
       const currentManual = extractSection(notepadContent, MANUAL_HEADER) || "";
       const now = /* @__PURE__ */ new Date();
       const timestamp2 = now.toISOString().slice(0, 16).replace("T", " ");
@@ -30442,12 +30576,12 @@ ${content}
 }
 function pruneOldEntries(directory, daysOld = DEFAULT_CONFIG3.workingMemoryDays) {
   const notepadPath = getNotepadPath(directory);
-  if (!(0, import_fs30.existsSync)(notepadPath)) {
+  if (!(0, import_fs31.existsSync)(notepadPath)) {
     return { pruned: 0, remaining: 0 };
   }
   try {
     return withFileLockSync(lockPathFor(notepadPath), () => {
-      let notepadContent = (0, import_fs30.readFileSync)(notepadPath, "utf-8");
+      let notepadContent = (0, import_fs31.readFileSync)(notepadPath, "utf-8");
       const workingMemory = extractSection(notepadContent, WORKING_MEMORY_HEADER);
       if (!workingMemory) {
         return { pruned: 0, remaining: 0 };
@@ -30485,7 +30619,7 @@ ${entry.content}`).join("\n\n");
 }
 function getNotepadStats(directory) {
   const notepadPath = getNotepadPath(directory);
-  if (!(0, import_fs30.existsSync)(notepadPath)) {
+  if (!(0, import_fs31.existsSync)(notepadPath)) {
     return {
       exists: false,
       totalSize: 0,
@@ -30494,7 +30628,7 @@ function getNotepadStats(directory) {
       oldestEntry: null
     };
   }
-  const content = (0, import_fs30.readFileSync)(notepadPath, "utf-8");
+  const content = (0, import_fs31.readFileSync)(notepadPath, "utf-8");
   const priorityContext = extractSection(content, PRIORITY_HEADER) || "";
   const workingMemory = extractSection(content, WORKING_MEMORY_HEADER) || "";
   const wmMatches = workingMemory.match(
@@ -30807,7 +30941,7 @@ var notepadTools = [
 ];
 
 // src/hooks/project-memory/index.ts
-var import_path40 = __toESM(require("path"), 1);
+var import_path41 = __toESM(require("path"), 1);
 
 // src/features/context-injector/collector.ts
 var PRIORITY_ORDER = {
@@ -30917,18 +31051,18 @@ var ContextCollector = class {
 var contextCollector = new ContextCollector();
 
 // src/hooks/rules-injector/finder.ts
-var import_fs31 = require("fs");
-var import_path34 = require("path");
+var import_fs32 = require("fs");
+var import_path35 = require("path");
 
 // src/hooks/rules-injector/constants.ts
-var import_path33 = require("path");
+var import_path34 = require("path");
 var import_os5 = require("os");
-var OMC_STORAGE_DIR = (0, import_path33.join)((0, import_os5.homedir)(), ".omg");
-var RULES_INJECTOR_STORAGE = (0, import_path33.join)(OMC_STORAGE_DIR, "rules-injector");
+var OMC_STORAGE_DIR = (0, import_path34.join)((0, import_os5.homedir)(), ".omg");
+var RULES_INJECTOR_STORAGE = (0, import_path34.join)(OMC_STORAGE_DIR, "rules-injector");
 
 // src/hooks/project-memory/storage.ts
 var import_promises2 = __toESM(require("fs/promises"), 1);
-var import_path35 = __toESM(require("path"), 1);
+var import_path36 = __toESM(require("path"), 1);
 
 // src/hooks/project-memory/constants.ts
 var CACHE_EXPIRY_MS = 24 * 60 * 60 * 1e3;
@@ -30960,7 +31094,7 @@ async function loadProjectMemory(projectRoot) {
 }
 async function saveProjectMemory(projectRoot, memory) {
   const memoryPath = getMemoryPath(projectRoot);
-  const omcDir = import_path35.default.dirname(memoryPath);
+  const omcDir = import_path36.default.dirname(memoryPath);
   try {
     await import_promises2.default.mkdir(omcDir, { recursive: true });
     await atomicWriteJson(memoryPath, memory);
@@ -30976,17 +31110,17 @@ async function withProjectMemoryLock(projectRoot, fn) {
 
 // src/hooks/project-memory/detector.ts
 var import_promises4 = __toESM(require("fs/promises"), 1);
-var import_path37 = __toESM(require("path"), 1);
+var import_path38 = __toESM(require("path"), 1);
 
 // src/hooks/project-memory/directory-mapper.ts
 var import_promises3 = __toESM(require("fs/promises"), 1);
-var import_path36 = __toESM(require("path"), 1);
+var import_path37 = __toESM(require("path"), 1);
 
 // src/hooks/project-memory/formatter.ts
-var import_path39 = __toESM(require("path"), 1);
+var import_path40 = __toESM(require("path"), 1);
 
 // src/hooks/project-memory/hot-path-tracker.ts
-var import_path38 = __toESM(require("path"), 1);
+var import_path39 = __toESM(require("path"), 1);
 
 // src/hooks/project-memory/directive-detector.ts
 function addDirective(directives, newDirective) {
@@ -31369,27 +31503,27 @@ var memoryTools = [
 ];
 
 // src/tools/trace-tools.ts
-var import_fs34 = require("fs");
-var import_path43 = require("path");
+var import_fs35 = require("fs");
+var import_path44 = require("path");
 
 // src/hooks/subagent-tracker/session-replay.ts
-var import_fs32 = require("fs");
-var import_path41 = require("path");
+var import_fs33 = require("fs");
+var import_path42 = require("path");
 var REPLAY_PREFIX = "agent-replay-";
 var MAX_REPLAY_SIZE_BYTES = 5 * 1024 * 1024;
 function getReplayFilePath(directory, sessionId) {
-  const stateDir = (0, import_path41.join)(getOmcRoot(directory), "state");
-  if (!(0, import_fs32.existsSync)(stateDir)) {
-    (0, import_fs32.mkdirSync)(stateDir, { recursive: true });
+  const stateDir = (0, import_path42.join)(getOmcRoot(directory), "state");
+  if (!(0, import_fs33.existsSync)(stateDir)) {
+    (0, import_fs33.mkdirSync)(stateDir, { recursive: true });
   }
   const safeId = sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return (0, import_path41.join)(stateDir, `${REPLAY_PREFIX}${safeId}.jsonl`);
+  return (0, import_path42.join)(stateDir, `${REPLAY_PREFIX}${safeId}.jsonl`);
 }
 function readReplayEvents(directory, sessionId) {
   const filePath = getReplayFilePath(directory, sessionId);
-  if (!(0, import_fs32.existsSync)(filePath)) return [];
+  if (!(0, import_fs33.existsSync)(filePath)) return [];
   try {
-    const content = (0, import_fs32.readFileSync)(filePath, "utf-8");
+    const content = (0, import_fs33.readFileSync)(filePath, "utf-8");
     return content.split("\n").filter((line) => line.trim()).map((line) => {
       try {
         return JSON.parse(line);
@@ -31568,8 +31702,8 @@ function getReplaySummary(directory, sessionId) {
 
 // src/features/session-history-search/index.ts
 var import_child_process14 = require("child_process");
-var import_fs33 = require("fs");
-var import_path42 = require("path");
+var import_fs34 = require("fs");
+var import_path43 = require("path");
 var import_readline = require("readline");
 var DEFAULT_LIMIT = 10;
 var DEFAULT_CONTEXT_CHARS = 120;
@@ -31608,22 +31742,22 @@ function getMainRepoRoot(projectRoot) {
       stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true
     }).trim();
-    const absoluteCommonDir = (0, import_path42.resolve)(projectRoot, gitCommonDir);
-    const mainRepoRoot = (0, import_path42.dirname)(absoluteCommonDir);
+    const absoluteCommonDir = (0, import_path43.resolve)(projectRoot, gitCommonDir);
+    const mainRepoRoot = (0, import_path43.dirname)(absoluteCommonDir);
     return mainRepoRoot === projectRoot ? null : mainRepoRoot;
   } catch {
     return null;
   }
 }
 function getClaudeWorktreeParent(projectRoot) {
-  const marker = `${(0, import_path42.normalize)("/.copilot/worktrees/")}`;
-  const normalizedRoot = (0, import_path42.normalize)(projectRoot);
+  const marker = `${(0, import_path43.normalize)("/.copilot/worktrees/")}`;
+  const normalizedRoot = (0, import_path43.normalize)(projectRoot);
   const idx = normalizedRoot.indexOf(marker);
   if (idx === -1) return null;
   return normalizedRoot.slice(0, idx) || null;
 }
 function listJsonlFiles(rootDir) {
-  if (!(0, import_fs33.existsSync)(rootDir)) {
+  if (!(0, import_fs34.existsSync)(rootDir)) {
     return [];
   }
   const files = [];
@@ -31632,12 +31766,12 @@ function listJsonlFiles(rootDir) {
     const current = stack.pop();
     let entries;
     try {
-      entries = (0, import_fs33.readdirSync)(current, { withFileTypes: true });
+      entries = (0, import_fs34.readdirSync)(current, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const fullPath = (0, import_path42.join)(current, entry.name);
+      const fullPath = (0, import_path43.join)(current, entry.name);
       if (entry.isDirectory()) {
         stack.push(fullPath);
         continue;
@@ -31657,8 +31791,8 @@ function uniqueSortedTargets(targets) {
     seen.add(key);
     return true;
   }).sort((a, b) => {
-    const aTime = (0, import_fs33.existsSync)(a.filePath) ? (0, import_fs33.statSync)(a.filePath).mtimeMs : 0;
-    const bTime = (0, import_fs33.existsSync)(b.filePath) ? (0, import_fs33.statSync)(b.filePath).mtimeMs : 0;
+    const aTime = (0, import_fs34.existsSync)(a.filePath) ? (0, import_fs34.statSync)(a.filePath).mtimeMs : 0;
+    const bTime = (0, import_fs34.existsSync)(b.filePath) ? (0, import_fs34.statSync)(b.filePath).mtimeMs : 0;
     return bTime - aTime;
   });
 }
@@ -31673,22 +31807,22 @@ function buildCurrentProjectTargets(projectRoot, transcriptProjectRoots = [proje
   }
   const targets = [];
   for (const root of projectRoots) {
-    const encodedDir = (0, import_path42.join)(claudeDir, "projects", encodeProjectPath(root));
+    const encodedDir = (0, import_path43.join)(claudeDir, "projects", encodeProjectPath(root));
     for (const filePath of listJsonlFiles(encodedDir)) {
       targets.push({ filePath, sourceType: "project-transcript" });
     }
   }
-  const legacyTranscriptsDir = (0, import_path42.join)(claudeDir, "transcripts");
+  const legacyTranscriptsDir = (0, import_path43.join)(claudeDir, "transcripts");
   for (const filePath of listJsonlFiles(legacyTranscriptsDir)) {
     targets.push({ filePath, sourceType: "legacy-transcript" });
   }
   const omcRoot = getOmcRoot(projectRoot);
-  const sessionSummariesDir = (0, import_path42.join)(omcRoot, "sessions");
+  const sessionSummariesDir = (0, import_path43.join)(omcRoot, "sessions");
   for (const filePath of listJsonlFiles(sessionSummariesDir)) {
     targets.push({ filePath, sourceType: "omc-session-summary" });
   }
-  const replayDir = (0, import_path42.join)(omcRoot, "state");
-  if ((0, import_fs33.existsSync)(replayDir)) {
+  const replayDir = (0, import_path43.join)(omcRoot, "state");
+  if ((0, import_fs34.existsSync)(replayDir)) {
     for (const filePath of listJsonlFiles(replayDir)) {
       if (filePath.includes("agent-replay-") && filePath.endsWith(".jsonl")) {
         targets.push({ filePath, sourceType: "omc-session-replay" });
@@ -31700,10 +31834,10 @@ function buildCurrentProjectTargets(projectRoot, transcriptProjectRoots = [proje
 function buildAllProjectTargets() {
   const claudeDir = getCopilotConfigDir();
   const targets = [];
-  for (const filePath of listJsonlFiles((0, import_path42.join)(claudeDir, "projects"))) {
+  for (const filePath of listJsonlFiles((0, import_path43.join)(claudeDir, "projects"))) {
     targets.push({ filePath, sourceType: "project-transcript" });
   }
-  for (const filePath of listJsonlFiles((0, import_path42.join)(claudeDir, "transcripts"))) {
+  for (const filePath of listJsonlFiles((0, import_path43.join)(claudeDir, "transcripts"))) {
     targets.push({ filePath, sourceType: "legacy-transcript" });
   }
   return uniqueSortedTargets(targets);
@@ -31712,9 +31846,9 @@ function isWithinProject(projectPath, projectRoots) {
   if (!projectPath) {
     return false;
   }
-  const normalizedProjectPath = (0, import_path42.normalize)((0, import_path42.resolve)(projectPath)).replace(/\\/g, "/");
+  const normalizedProjectPath = (0, import_path43.normalize)((0, import_path43.resolve)(projectPath)).replace(/\\/g, "/");
   return projectRoots.some((root) => {
-    const normalizedRoot = (0, import_path42.normalize)((0, import_path42.resolve)(root)).replace(/\\/g, "/");
+    const normalizedRoot = (0, import_path43.normalize)((0, import_path43.resolve)(root)).replace(/\\/g, "/");
     return normalizedProjectPath === normalizedRoot || normalizedProjectPath.startsWith(`${normalizedRoot}/`);
   });
 }
@@ -31918,7 +32052,7 @@ function createMatchRetainer(limit) {
   };
 }
 async function collectMatchesFromFile(target, options) {
-  const fileMtime = (0, import_fs33.existsSync)(target.filePath) ? (0, import_fs33.statSync)(target.filePath).mtimeMs : 0;
+  const fileMtime = (0, import_fs34.existsSync)(target.filePath) ? (0, import_fs34.statSync)(target.filePath).mtimeMs : 0;
   if (target.sourceType === "omc-session-summary" && target.filePath.endsWith(".json")) {
     try {
       const payload = JSON.parse(await import("fs/promises").then((fs8) => fs8.readFile(target.filePath, "utf-8")));
@@ -31950,7 +32084,7 @@ async function collectMatchesFromFile(target, options) {
     }
     return;
   }
-  const stream = (0, import_fs33.createReadStream)(target.filePath, { encoding: "utf-8" });
+  const stream = (0, import_fs34.createReadStream)(target.filePath, { encoding: "utf-8" });
   const reader = (0, import_readline.createInterface)({ input: stream, crlfDelay: Infinity });
   let line = 0;
   try {
@@ -32009,7 +32143,7 @@ async function searchSessionHistory(rawOptions) {
   const currentProjectRoot = resolveToWorktreeRoot(workingDirectory);
   const scopeMode = buildScopeMode(rawOptions.project);
   const projectFilter = scopeMode === "project" ? rawOptions.project : void 0;
-  const literalWorkingDirectory = rawOptions.workingDirectory ? (0, import_path42.resolve)(rawOptions.workingDirectory) : workingDirectory;
+  const literalWorkingDirectory = rawOptions.workingDirectory ? (0, import_path43.resolve)(rawOptions.workingDirectory) : workingDirectory;
   const currentProjectRoots = [currentProjectRoot, literalWorkingDirectory].concat(getMainRepoRoot(currentProjectRoot) ?? []).concat(getClaudeWorktreeParent(currentProjectRoot) ?? []).filter((value, index, arr) => Boolean(value) && arr.indexOf(value) === index);
   const transcriptProjectRoots = currentProjectRoots.filter((root) => isWithinProject(root, [currentProjectRoot]));
   const targets = scopeMode === "all" ? buildAllProjectTargets() : buildCurrentProjectTargets(currentProjectRoot, transcriptProjectRoots);
@@ -32082,12 +32216,12 @@ var sessionSearchTool = {
 // src/tools/trace-tools.ts
 var REPLAY_PREFIX2 = "agent-replay-";
 function findLatestSessionId(directory) {
-  const stateDir = (0, import_path43.join)(getOmcRoot(directory), "state");
+  const stateDir = (0, import_path44.join)(getOmcRoot(directory), "state");
   try {
-    const files = (0, import_fs34.readdirSync)(stateDir).filter((f) => f.startsWith(REPLAY_PREFIX2) && f.endsWith(".jsonl")).map((f) => ({
+    const files = (0, import_fs35.readdirSync)(stateDir).filter((f) => f.startsWith(REPLAY_PREFIX2) && f.endsWith(".jsonl")).map((f) => ({
       name: f,
       sessionId: f.slice(REPLAY_PREFIX2.length, -".jsonl".length),
-      mtime: (0, import_fs34.statSync)((0, import_path43.join)(stateDir, f)).mtimeMs
+      mtime: (0, import_fs35.statSync)((0, import_path44.join)(stateDir, f)).mtimeMs
     })).sort((a, b) => b.mtime - a.mtime);
     return files.length > 0 ? files[0].sessionId : null;
   } catch {
@@ -32441,14 +32575,14 @@ No events recorded.`
 var traceTools = [traceTimelineTool, traceSummaryTool, sessionSearchTool];
 
 // src/lib/shared-memory.ts
-var import_fs35 = require("fs");
-var import_path44 = require("path");
+var import_fs36 = require("fs");
+var import_path45 = require("path");
 var CONFIG_FILE_NAME = ".omc-config.json";
 function isSharedMemoryEnabled() {
   try {
-    const configPath = (0, import_path44.join)(getCopilotConfigDir(), CONFIG_FILE_NAME);
-    if (!(0, import_fs35.existsSync)(configPath)) return true;
-    const raw = JSON.parse((0, import_fs35.readFileSync)(configPath, "utf-8"));
+    const configPath = (0, import_path45.join)(getCopilotConfigDir(), CONFIG_FILE_NAME);
+    if (!(0, import_fs36.existsSync)(configPath)) return true;
+    const raw = JSON.parse((0, import_fs36.readFileSync)(configPath, "utf-8"));
     const enabled = raw?.agents?.sharedMemory?.enabled;
     if (typeof enabled === "boolean") return enabled;
     return true;
@@ -32482,16 +32616,16 @@ function validateKey(key) {
 function getNamespaceDir(namespace, worktreeRoot) {
   validateNamespace(namespace);
   const omcRoot = getOmcRoot(worktreeRoot);
-  return (0, import_path44.join)(omcRoot, SHARED_MEMORY_DIR, namespace);
+  return (0, import_path45.join)(omcRoot, SHARED_MEMORY_DIR, namespace);
 }
 function getEntryPath(namespace, key, worktreeRoot) {
   validateKey(key);
-  return (0, import_path44.join)(getNamespaceDir(namespace, worktreeRoot), `${key}.json`);
+  return (0, import_path45.join)(getNamespaceDir(namespace, worktreeRoot), `${key}.json`);
 }
 function ensureNamespaceDir(namespace, worktreeRoot) {
   const dir = getNamespaceDir(namespace, worktreeRoot);
-  if (!(0, import_fs35.existsSync)(dir)) {
-    (0, import_fs35.mkdirSync)(dir, { recursive: true });
+  if (!(0, import_fs36.existsSync)(dir)) {
+    (0, import_fs36.mkdirSync)(dir, { recursive: true });
   }
   return dir;
 }
@@ -32506,9 +32640,9 @@ function writeEntry(namespace, key, value, ttl, worktreeRoot) {
   const lockPath = filePath + ".lock";
   const doWrite = () => {
     let existingCreatedAt = now;
-    if ((0, import_fs35.existsSync)(filePath)) {
+    if ((0, import_fs36.existsSync)(filePath)) {
       try {
-        const existing = JSON.parse((0, import_fs35.readFileSync)(filePath, "utf-8"));
+        const existing = JSON.parse((0, import_fs36.readFileSync)(filePath, "utf-8"));
         existingCreatedAt = existing.createdAt || now;
       } catch {
       }
@@ -32525,11 +32659,11 @@ function writeEntry(namespace, key, value, ttl, worktreeRoot) {
       entry.expiresAt = new Date(Date.now() + ttl * 1e3).toISOString();
     }
     const tmpPath = `${filePath}.tmp.${process.pid}.${Date.now()}`;
-    (0, import_fs35.writeFileSync)(tmpPath, JSON.stringify(entry, null, 2), "utf-8");
-    (0, import_fs35.renameSync)(tmpPath, filePath);
+    (0, import_fs36.writeFileSync)(tmpPath, JSON.stringify(entry, null, 2), "utf-8");
+    (0, import_fs36.renameSync)(tmpPath, filePath);
     try {
       const legacyTmp = filePath + ".tmp";
-      if ((0, import_fs35.existsSync)(legacyTmp)) (0, import_fs35.unlinkSync)(legacyTmp);
+      if ((0, import_fs36.existsSync)(legacyTmp)) (0, import_fs36.unlinkSync)(legacyTmp);
     } catch {
     }
     return entry;
@@ -32544,12 +32678,12 @@ function readEntry(namespace, key, worktreeRoot) {
   validateNamespace(namespace);
   validateKey(key);
   const filePath = getEntryPath(namespace, key, worktreeRoot);
-  if (!(0, import_fs35.existsSync)(filePath)) return null;
+  if (!(0, import_fs36.existsSync)(filePath)) return null;
   try {
-    const entry = JSON.parse((0, import_fs35.readFileSync)(filePath, "utf-8"));
+    const entry = JSON.parse((0, import_fs36.readFileSync)(filePath, "utf-8"));
     if (isExpired(entry)) {
       try {
-        (0, import_fs35.unlinkSync)(filePath);
+        (0, import_fs36.unlinkSync)(filePath);
       } catch {
       }
       return null;
@@ -32562,14 +32696,14 @@ function readEntry(namespace, key, worktreeRoot) {
 function listEntries(namespace, worktreeRoot) {
   validateNamespace(namespace);
   const dir = getNamespaceDir(namespace, worktreeRoot);
-  if (!(0, import_fs35.existsSync)(dir)) return [];
+  if (!(0, import_fs36.existsSync)(dir)) return [];
   const items = [];
   try {
-    const files = (0, import_fs35.readdirSync)(dir).filter((f) => f.endsWith(".json"));
+    const files = (0, import_fs36.readdirSync)(dir).filter((f) => f.endsWith(".json"));
     for (const file of files) {
       try {
-        const filePath = (0, import_path44.join)(dir, file);
-        const entry = JSON.parse((0, import_fs35.readFileSync)(filePath, "utf-8"));
+        const filePath = (0, import_path45.join)(dir, file);
+        const entry = JSON.parse((0, import_fs36.readFileSync)(filePath, "utf-8"));
         if (!isExpired(entry)) {
           items.push({
             key: entry.key,
@@ -32588,9 +32722,9 @@ function deleteEntry(namespace, key, worktreeRoot) {
   validateNamespace(namespace);
   validateKey(key);
   const filePath = getEntryPath(namespace, key, worktreeRoot);
-  if (!(0, import_fs35.existsSync)(filePath)) return false;
+  if (!(0, import_fs36.existsSync)(filePath)) return false;
   try {
-    (0, import_fs35.unlinkSync)(filePath);
+    (0, import_fs36.unlinkSync)(filePath);
     return true;
   } catch {
     return false;
@@ -32598,15 +32732,15 @@ function deleteEntry(namespace, key, worktreeRoot) {
 }
 function cleanupExpired(namespace, worktreeRoot) {
   const omcRoot = getOmcRoot(worktreeRoot);
-  const sharedMemDir = (0, import_path44.join)(omcRoot, SHARED_MEMORY_DIR);
-  if (!(0, import_fs35.existsSync)(sharedMemDir)) return { removed: 0, namespaces: [] };
+  const sharedMemDir = (0, import_path45.join)(omcRoot, SHARED_MEMORY_DIR);
+  if (!(0, import_fs36.existsSync)(sharedMemDir)) return { removed: 0, namespaces: [] };
   const namespacesToClean = [];
   if (namespace) {
     validateNamespace(namespace);
     namespacesToClean.push(namespace);
   } else {
     try {
-      const entries = (0, import_fs35.readdirSync)(sharedMemDir, { withFileTypes: true });
+      const entries = (0, import_fs36.readdirSync)(sharedMemDir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
           namespacesToClean.push(entry.name);
@@ -32619,17 +32753,17 @@ function cleanupExpired(namespace, worktreeRoot) {
   let removed = 0;
   const cleanedNamespaces = [];
   for (const ns of namespacesToClean) {
-    const nsDir = (0, import_path44.join)(sharedMemDir, ns);
-    if (!(0, import_fs35.existsSync)(nsDir)) continue;
+    const nsDir = (0, import_path45.join)(sharedMemDir, ns);
+    if (!(0, import_fs36.existsSync)(nsDir)) continue;
     let nsRemoved = 0;
     try {
-      const files = (0, import_fs35.readdirSync)(nsDir).filter((f) => f.endsWith(".json"));
+      const files = (0, import_fs36.readdirSync)(nsDir).filter((f) => f.endsWith(".json"));
       for (const file of files) {
         try {
-          const filePath = (0, import_path44.join)(nsDir, file);
-          const entry = JSON.parse((0, import_fs35.readFileSync)(filePath, "utf-8"));
+          const filePath = (0, import_path45.join)(nsDir, file);
+          const entry = JSON.parse((0, import_fs36.readFileSync)(filePath, "utf-8"));
           if (isExpired(entry)) {
-            (0, import_fs35.unlinkSync)(filePath);
+            (0, import_fs36.unlinkSync)(filePath);
             nsRemoved++;
           }
         } catch {
@@ -32646,10 +32780,10 @@ function cleanupExpired(namespace, worktreeRoot) {
 }
 function listNamespaces(worktreeRoot) {
   const omcRoot = getOmcRoot(worktreeRoot);
-  const sharedMemDir = (0, import_path44.join)(omcRoot, SHARED_MEMORY_DIR);
-  if (!(0, import_fs35.existsSync)(sharedMemDir)) return [];
+  const sharedMemDir = (0, import_path45.join)(omcRoot, SHARED_MEMORY_DIR);
+  if (!(0, import_fs36.existsSync)(sharedMemDir)) return [];
   try {
-    const entries = (0, import_fs35.readdirSync)(sharedMemDir, { withFileTypes: true });
+    const entries = (0, import_fs36.readdirSync)(sharedMemDir, { withFileTypes: true });
     return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
   } catch {
     return [];
@@ -33201,25 +33335,25 @@ var DEFAULT_WIKI_CONFIG = {
 };
 
 // src/hooks/wiki/storage.ts
-var import_fs36 = require("fs");
-var import_path45 = require("path");
+var import_fs37 = require("fs");
+var import_path46 = require("path");
 var WIKI_DIR = "wiki";
 var INDEX_FILE = "index.md";
 var LOG_FILE = "log.md";
 var ENVIRONMENT_FILE = "environment.md";
 var RESERVED_FILES = /* @__PURE__ */ new Set([INDEX_FILE, LOG_FILE, ENVIRONMENT_FILE]);
 function getWikiDir(root) {
-  return (0, import_path45.join)(getOmcRoot(root), WIKI_DIR);
+  return (0, import_path46.join)(getOmcRoot(root), WIKI_DIR);
 }
 function ensureWikiDir(root) {
   const wikiDir = getWikiDir(root);
-  if (!(0, import_fs36.existsSync)(wikiDir)) {
-    (0, import_fs36.mkdirSync)(wikiDir, { recursive: true });
+  if (!(0, import_fs37.existsSync)(wikiDir)) {
+    (0, import_fs37.mkdirSync)(wikiDir, { recursive: true });
   }
   const omcRoot = getOmcRoot(root);
-  const gitignorePath = (0, import_path45.join)(omcRoot, ".gitignore");
-  if ((0, import_fs36.existsSync)(gitignorePath)) {
-    const content = (0, import_fs36.readFileSync)(gitignorePath, "utf-8");
+  const gitignorePath = (0, import_path46.join)(omcRoot, ".gitignore");
+  if ((0, import_fs37.existsSync)(gitignorePath)) {
+    const content = (0, import_fs37.readFileSync)(gitignorePath, "utf-8");
     if (!content.includes("wiki/")) {
       atomicWriteFileSync(gitignorePath, content.trimEnd() + "\nwiki/\n");
     }
@@ -33230,7 +33364,7 @@ function ensureWikiDir(root) {
 }
 function withWikiLock(root, fn, options) {
   const wikiDir = ensureWikiDir(root);
-  const lockPath = lockPathFor((0, import_path45.join)(wikiDir, ".wiki-lock"));
+  const lockPath = lockPathFor((0, import_path46.join)(wikiDir, ".wiki-lock"));
   const remainingMs = options?.deadlineAt === void 0 ? void 0 : Math.max(0, options.deadlineAt - Date.now());
   const timeoutMs = Math.min(options?.timeoutMs ?? 5e3, remainingMs ?? Infinity);
   return withFileLockSync(lockPath, fn, { timeoutMs, retryDelayMs: 50 });
@@ -33314,9 +33448,9 @@ function safeWikiPath(wikiDir, filename) {
   if (filename.includes("/") || filename.includes("\\") || filename.includes("..")) {
     return null;
   }
-  const filePath = (0, import_path45.join)(wikiDir, filename);
-  const resolved = (0, import_path45.resolve)(filePath);
-  if (!resolved.startsWith((0, import_path45.resolve)(wikiDir) + import_path45.sep)) {
+  const filePath = (0, import_path46.join)(wikiDir, filename);
+  const resolved = (0, import_path46.resolve)(filePath);
+  if (!resolved.startsWith((0, import_path46.resolve)(wikiDir) + import_path46.sep)) {
     return null;
   }
   return filePath;
@@ -33325,9 +33459,9 @@ function readPage(root, filename) {
   const wikiDir = getWikiDir(root);
   const filePath = safeWikiPath(wikiDir, filename);
   if (!filePath) return null;
-  if (!(0, import_fs36.existsSync)(filePath)) return null;
+  if (!(0, import_fs37.existsSync)(filePath)) return null;
   try {
-    const raw = (0, import_fs36.readFileSync)(filePath, "utf-8");
+    const raw = (0, import_fs37.readFileSync)(filePath, "utf-8");
     const parsed = parseFrontmatter(raw);
     if (!parsed) return null;
     return {
@@ -33341,16 +33475,16 @@ function readPage(root, filename) {
 }
 function listPages(root) {
   const wikiDir = getWikiDir(root);
-  if (!(0, import_fs36.existsSync)(wikiDir)) return [];
-  return (0, import_fs36.readdirSync)(wikiDir).filter((f) => f.endsWith(".md") && !RESERVED_FILES.has(f)).sort();
+  if (!(0, import_fs37.existsSync)(wikiDir)) return [];
+  return (0, import_fs37.readdirSync)(wikiDir).filter((f) => f.endsWith(".md") && !RESERVED_FILES.has(f)).sort();
 }
 function readAllPages(root) {
   return listPages(root).map((f) => readPage(root, f)).filter((p) => p !== null);
 }
 function readIndex(root) {
-  const indexPath = (0, import_path45.join)(getWikiDir(root), INDEX_FILE);
-  if (!(0, import_fs36.existsSync)(indexPath)) return null;
-  return (0, import_fs36.readFileSync)(indexPath, "utf-8");
+  const indexPath = (0, import_path46.join)(getWikiDir(root), INDEX_FILE);
+  if (!(0, import_fs37.existsSync)(indexPath)) return null;
+  return (0, import_fs37.readFileSync)(indexPath, "utf-8");
 }
 function writePageUnsafe(root, page) {
   if (RESERVED_FILES.has(page.filename)) {
@@ -33365,8 +33499,8 @@ function deletePageUnsafe(root, filename) {
   const wikiDir = getWikiDir(root);
   const filePath = safeWikiPath(wikiDir, filename);
   if (!filePath) return false;
-  if (!(0, import_fs36.existsSync)(filePath)) return false;
-  (0, import_fs36.unlinkSync)(filePath);
+  if (!(0, import_fs37.existsSync)(filePath)) return false;
+  (0, import_fs37.unlinkSync)(filePath);
   return true;
 }
 function updateIndexUnsafe(root) {
@@ -33395,19 +33529,19 @@ function updateIndexUnsafe(root) {
     lines.push("");
   }
   const wikiDir = ensureWikiDir(root);
-  atomicWriteFileSync((0, import_path45.join)(wikiDir, INDEX_FILE), lines.join("\n"));
+  atomicWriteFileSync((0, import_path46.join)(wikiDir, INDEX_FILE), lines.join("\n"));
 }
 function appendLogUnsafe(root, entry) {
   const wikiDir = ensureWikiDir(root);
-  const logPath = (0, import_path45.join)(wikiDir, LOG_FILE);
+  const logPath = (0, import_path46.join)(wikiDir, LOG_FILE);
   const logLine = `## [${entry.timestamp}] ${entry.operation}
 - **Pages:** ${entry.pagesAffected.join(", ") || "none"}
 - **Summary:** ${entry.summary}
 
 `;
   let existing = "";
-  if ((0, import_fs36.existsSync)(logPath)) {
-    existing = (0, import_fs36.readFileSync)(logPath, "utf-8");
+  if ((0, import_fs37.existsSync)(logPath)) {
+    existing = (0, import_fs37.readFileSync)(logPath, "utf-8");
   } else {
     existing = "# Wiki Log\n\n";
   }
@@ -34167,37 +34301,37 @@ var wikiTools = [
 ];
 
 // src/tools/skills-tools.ts
-var import_path49 = require("path");
+var import_path50 = require("path");
 var import_os7 = require("os");
 
 // src/hooks/learner/loader.ts
-var import_fs38 = require("fs");
+var import_fs39 = require("fs");
 var import_crypto11 = require("crypto");
-var import_path48 = require("path");
+var import_path49 = require("path");
 
 // src/hooks/learner/finder.ts
-var import_fs37 = require("fs");
-var import_path47 = require("path");
+var import_fs38 = require("fs");
+var import_path48 = require("path");
 
 // src/hooks/learner/constants.ts
-var import_path46 = require("path");
+var import_path47 = require("path");
 var import_os6 = require("os");
-var USER_SKILLS_DIR = (0, import_path46.join)(getCopilotConfigDir(), "skills", "omc-learned");
-var GLOBAL_SKILLS_DIR = (0, import_path46.join)((0, import_os6.homedir)(), ".omg", "skills");
+var USER_SKILLS_DIR = (0, import_path47.join)(getCopilotConfigDir(), "skills", "omc-learned");
+var GLOBAL_SKILLS_DIR = (0, import_path47.join)((0, import_os6.homedir)(), ".omg", "skills");
 var PROJECT_SKILLS_SUBDIR = OmcPaths.SKILLS;
-var PROJECT_AGENT_SKILLS_SUBDIR = (0, import_path46.join)(".agents", "skills");
+var PROJECT_AGENT_SKILLS_SUBDIR = (0, import_path47.join)(".agents", "skills");
 var MAX_RECURSION_DEPTH = 10;
 var SKILL_EXTENSION = ".md";
 var DEBUG_ENABLED = process.env.OMC_DEBUG === "1";
 
 // src/hooks/learner/finder.ts
 function findSkillFilesRecursive(dir, results, depth = 0) {
-  if (!(0, import_fs37.existsSync)(dir)) return;
+  if (!(0, import_fs38.existsSync)(dir)) return;
   if (depth > MAX_RECURSION_DEPTH) return;
   try {
-    const entries = (0, import_fs37.readdirSync)(dir, { withFileTypes: true });
+    const entries = (0, import_fs38.readdirSync)(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = (0, import_path47.join)(dir, entry.name);
+      const fullPath = (0, import_path48.join)(dir, entry.name);
       if (entry.isDirectory()) {
         findSkillFilesRecursive(fullPath, results, depth + 1);
       } else if (entry.isFile() && entry.name.endsWith(SKILL_EXTENSION)) {
@@ -34212,15 +34346,15 @@ function findSkillFilesRecursive(dir, results, depth = 0) {
 }
 function safeRealpathSync(filePath) {
   try {
-    return (0, import_fs37.realpathSync)(filePath);
+    return (0, import_fs38.realpathSync)(filePath);
   } catch {
     return filePath;
   }
 }
 function isWithinBoundary(realPath, boundary) {
-  const normalizedReal = (0, import_path47.normalize)(realPath);
-  const normalizedBoundary = (0, import_path47.normalize)(safeRealpathSync(boundary));
-  return normalizedReal === normalizedBoundary || normalizedReal.startsWith(normalizedBoundary + import_path47.sep);
+  const normalizedReal = (0, import_path48.normalize)(realPath);
+  const normalizedBoundary = (0, import_path48.normalize)(safeRealpathSync(boundary));
+  return normalizedReal === normalizedBoundary || normalizedReal.startsWith(normalizedBoundary + import_path48.sep);
 }
 function findSkillFiles(projectRoot, options) {
   const candidates = [];
@@ -34228,8 +34362,8 @@ function findSkillFiles(projectRoot, options) {
   const scope = options?.scope ?? "all";
   if (projectRoot && (scope === "project" || scope === "all")) {
     const projectSkillDirs = [
-      (0, import_path47.join)(projectRoot, PROJECT_SKILLS_SUBDIR),
-      (0, import_path47.join)(projectRoot, PROJECT_AGENT_SKILLS_SUBDIR)
+      (0, import_path48.join)(projectRoot, PROJECT_SKILLS_SUBDIR),
+      (0, import_path48.join)(projectRoot, PROJECT_AGENT_SKILLS_SUBDIR)
     ];
     for (const projectSkillsDir of projectSkillDirs) {
       const projectFiles = [];
@@ -34438,7 +34572,7 @@ function loadAllSkills(projectRoot) {
   const seenIds = /* @__PURE__ */ new Map();
   for (const candidate of candidates) {
     try {
-      const rawContent = (0, import_fs38.readFileSync)(candidate.path, "utf-8");
+      const rawContent = (0, import_fs39.readFileSync)(candidate.path, "utf-8");
       const { metadata, content, valid, errors } = parseSkillFile(rawContent);
       if (!valid) {
         if (DEBUG_ENABLED) {
@@ -34447,7 +34581,7 @@ function loadAllSkills(projectRoot) {
         continue;
       }
       const skillId = metadata.id;
-      const relativePath = (0, import_path48.normalize)((0, import_path48.relative)(candidate.sourceDir, candidate.path));
+      const relativePath = (0, import_path49.normalize)((0, import_path49.relative)(candidate.sourceDir, candidate.path));
       const skill = {
         path: candidate.path,
         relativePath,
@@ -34473,13 +34607,13 @@ function loadAllSkills(projectRoot) {
 // src/tools/skills-tools.ts
 var ALLOWED_BOUNDARIES = [process.cwd(), (0, import_os7.homedir)()];
 function validateProjectRoot(input) {
-  const normalized = (0, import_path49.normalize)((0, import_path49.resolve)(input));
+  const normalized = (0, import_path50.normalize)((0, import_path50.resolve)(input));
   if (input.includes("..")) {
     throw new Error("Invalid project root: path traversal not allowed");
   }
   const isWithinAllowed = ALLOWED_BOUNDARIES.some((boundary) => {
-    const normalizedBoundary = (0, import_path49.normalize)(boundary);
-    return normalized === normalizedBoundary || normalized.startsWith(normalizedBoundary + import_path49.sep);
+    const normalizedBoundary = (0, import_path50.normalize)(boundary);
+    return normalized === normalizedBoundary || normalized.startsWith(normalizedBoundary + import_path50.sep);
   });
   if (!isWithinAllowed) {
     throw new Error("Invalid project root: path is outside allowed directories");