@mrciphersmith/keryx 0.2.122 → 0.2.123

package/dist/cli.js

@@ -4194,7 +4194,19 @@ var init_exfil = __esm(() => {
 
 // src/lib/fs.ts
 import { randomUUID as randomUUID2 } from "crypto";
+import {
+  chmodSync as chmodSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync3,
+  renameSync as renameSync2,
+  rmdirSync,
+  rmSync,
+  statSync as statSync2,
+  utimesSync,
+  writeFileSync as writeFileSync2
+} from "fs";
 import { access, mkdir, readFile, rename, rm, stat, utimes, writeFile } from "fs/promises";
+import { hostname } from "os";
 import path8 from "path";
 async function pathExists(filePath) {
   try {
@@ -4319,7 +4331,197 @@ function processIsAlive(pid) {
 function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-var DEFAULT_LOCK_STALE_MS = 30000;
+function readLeaseOwnerSync(lockPath) {
+  try {
+    const value = JSON.parse(readFileSync3(path8.join(lockPath, LEASE_OWNER_FILE), "utf8"));
+    if (value === null || typeof value !== "object")
+      return;
+    const record = value;
+    const wellFormed = typeof record.token === "string" && record.token.length > 0 && Number.isSafeInteger(record.pid) && Number(record.pid) > 0 && typeof record.host === "string" && typeof record.heartbeatAt === "string" && !Number.isNaN(Date.parse(record.heartbeatAt));
+    return wellFormed ? record : undefined;
+  } catch {
+    return;
+  }
+}
+function inspectLeaseSync(lockPath, opts) {
+  const now = (opts.now ?? Date.now)();
+  let dirMtimeMs;
+  try {
+    dirMtimeMs = statSync2(lockPath).mtimeMs;
+  } catch (error) {
+    if (isNotFound(error))
+      return { state: "free" };
+    throw error;
+  }
+  const holder = readLeaseOwnerSync(lockPath);
+  if (holder === undefined) {
+    return { state: now - dirMtimeMs <= opts.staleMs ? "live" : "gone", holder: undefined };
+  }
+  if (opts.reclaimIf?.(holder) === true) {
+    return { state: "gone", holder };
+  }
+  if (now - Date.parse(holder.heartbeatAt) <= opts.staleMs) {
+    return { state: "live", holder };
+  }
+  const thisHost = opts.host ?? hostname();
+  const isAlive = opts.isAlive ?? processIsAlive;
+  return { state: holder.host === thisHost && isAlive(holder.pid) ? "stale" : "gone", holder };
+}
+function acquireLeaseSync(lockPath, owner, opts) {
+  return acquireOrReclaim(lockPath, owner, opts, false);
+}
+function reclaimStaleLeaseSync(lockPath, owner, opts) {
+  return acquireOrReclaim(lockPath, owner, opts, true);
+}
+function acquireOrReclaim(lockPath, owner, opts, takeStale) {
+  const now = opts.now ?? Date.now;
+  mkdirSync2(path8.dirname(lockPath), { recursive: true, mode: 448 });
+  for (let attempt = 0;attempt < MAX_LEASE_ATTEMPTS; attempt += 1) {
+    const createdIno = tryCreateLease(lockPath, owner, opts.raceHook);
+    if (createdIno !== undefined) {
+      return { ok: true, handle: createLeaseHandle(lockPath, owner, createdIno, now, opts.raceHook) };
+    }
+    const seen = inspectLeaseSync(lockPath, opts);
+    if (seen.state === "free")
+      continue;
+    if (seen.state === "live" || seen.state === "stale" && !takeStale) {
+      return { ok: false, holder: seen.holder, state: seen.state };
+    }
+    removeLeaseDirIfUnchanged(lockPath, seen.holder?.token);
+  }
+  const last = inspectLeaseSync(lockPath, opts);
+  return {
+    ok: false,
+    holder: last.state === "free" ? undefined : last.holder,
+    state: last.state === "stale" ? "stale" : "live"
+  };
+}
+function tryCreateLease(lockPath, owner, raceHook) {
+  try {
+    mkdirSync2(lockPath, { mode: 448 });
+  } catch (error) {
+    if (isAlreadyExistsError(error))
+      return;
+    throw error;
+  }
+  let createdIno;
+  try {
+    createdIno = statSync2(lockPath).ino;
+  } catch (error) {
+    if (isNotFound(error))
+      return;
+    throw error;
+  }
+  raceHook?.("create");
+  const ownerPath = path8.join(lockPath, LEASE_OWNER_FILE);
+  try {
+    chmodSync2(lockPath, 448);
+    writeFileSync2(ownerPath, JSON.stringify(owner), { encoding: "utf8", flag: "wx", mode: 384 });
+  } catch (error) {
+    const stillOurs = inodeOf(lockPath) === createdIno;
+    if (stillOurs) {
+      if (!isAlreadyExistsError(error))
+        rmSync(ownerPath, { force: true });
+      try {
+        rmdirSync(lockPath);
+      } catch {}
+    }
+    if (!stillOurs || isAlreadyExistsError(error))
+      return;
+    throw error;
+  }
+  return createdIno;
+}
+function inodeOf(target) {
+  try {
+    return statSync2(target).ino;
+  } catch {
+    return;
+  }
+}
+function moveLeaseAside(lockPath, removeIf, keepOnConflict) {
+  const aside = `${lockPath}.aside.${process.pid}.${randomUUID2()}`;
+  try {
+    renameSync2(lockPath, aside);
+  } catch {
+    return;
+  }
+  if (!removeIf(readLeaseOwnerSync(aside))) {
+    try {
+      renameSync2(aside, lockPath);
+      return;
+    } catch {
+      if (keepOnConflict)
+        return;
+    }
+  }
+  rmSync(aside, { recursive: true, force: true });
+}
+function removeLeaseDirIfUnchanged(lockPath, expectedToken) {
+  moveLeaseAside(lockPath, (moved) => moved === undefined || moved.token === expectedToken, false);
+}
+function createLeaseHandle(lockPath, initial, createdIno, now, raceHook) {
+  let current = { ...initial };
+  let released = false;
+  const ownerPath = path8.join(lockPath, LEASE_OWNER_FILE);
+  const ownership = () => {
+    let ino;
+    try {
+      ino = statSync2(lockPath).ino;
+    } catch (error) {
+      const code = error?.code;
+      return code === "ENOENT" || code === "ENOTDIR" ? "lost" : "unknown";
+    }
+    if (ino !== createdIno)
+      return "lost";
+    const record = readLeaseOwnerSync(lockPath);
+    if (record === undefined)
+      return "unknown";
+    return record.token === initial.token ? "held" : "lost";
+  };
+  const holds = () => ownership() === "held";
+  return {
+    get owner() {
+      return current;
+    },
+    refresh(patch) {
+      if (released || !holds())
+        return false;
+      raceHook?.("refresh");
+      const next = { ...current, ...patch, token: initial.token, heartbeatAt: new Date(now()).toISOString() };
+      const tmp = path8.join(lockPath, `.${LEASE_OWNER_FILE}.${randomUUID2()}.tmp`);
+      try {
+        writeFileSync2(tmp, JSON.stringify(next), { encoding: "utf8", flag: "wx", mode: 384 });
+        if (!holds()) {
+          rmSync(tmp, { force: true });
+          return false;
+        }
+        renameSync2(tmp, ownerPath);
+      } catch {
+        rmSync(tmp, { force: true });
+        return false;
+      }
+      current = next;
+      try {
+        const touched = new Date;
+        utimesSync(lockPath, touched, touched);
+      } catch {}
+      return true;
+    },
+    holds,
+    ownership,
+    release() {
+      if (released)
+        return;
+      released = true;
+      if (!holds())
+        return;
+      raceHook?.("release");
+      moveLeaseAside(lockPath, (moved) => moved?.token === initial.token, true);
+    }
+  };
+}
+var DEFAULT_LOCK_STALE_MS = 30000, LEASE_OWNER_FILE = "owner.json", MAX_LEASE_ATTEMPTS = 3;
 var init_fs = () => {};
 
 // src/lib/contained-path.ts
@@ -6599,7 +6801,7 @@ var init_self_protect = __esm(() => {
 });
 
 // src/lib/descriptor-read.ts
-import { constants, fstatSync, lstatSync as lstatSync2, statSync as statSync2 } from "fs";
+import { constants, fstatSync, lstatSync as lstatSync2, statSync as statSync3 } from "fs";
 import path18 from "path";
 import { dlopen, FFIType, ptr } from "bun:ffi";
 function readDescriptorChain(workspaceRoot, absolutePath, options = {}) {
@@ -6637,7 +6839,7 @@ function readDescriptorChain(workspaceRoot, absolutePath, options = {}) {
     const name = components.at(-1);
     if (!name)
       throw new DescriptorReadError("invalid-path", "safe source path has no final component");
-    const expected = options.expectedTargetIdentity ?? statSync2(absolutePath);
+    const expected = options.expectedTargetIdentity ?? statSync3(absolutePath);
     const finalFlags = constants.O_RDONLY | constants.O_NOFOLLOW | (options.requireRegularFile ? constants.O_NONBLOCK ?? 0 : 0);
     const file = openAt(libc, directoryFd, name, finalFlags);
     opened.push(file);
@@ -25250,12 +25452,12 @@ var init_guarded_owner_writer = () => {};
 
 // src/session/store.ts
 import {
-  chmodSync as chmodSync3,
+  chmodSync as chmodSync4,
   existsSync as existsSync15,
-  mkdirSync as mkdirSync4,
+  mkdirSync as mkdirSync5,
   readdirSync,
-  renameSync as renameSync3,
-  writeFileSync as writeFileSync5
+  renameSync as renameSync4,
+  writeFileSync as writeFileSync6
 } from "fs";
 import path98 from "path";
 import { randomUUID as randomUUID9 } from "crypto";
@@ -25336,7 +25538,7 @@ function ensureDir(dir, dataDir) {
   if (shared) {
     ensureKeryxConfigDir();
   }
-  mkdirSync4(dir, { recursive: true, mode: 448 });
+  mkdirSync5(dir, { recursive: true, mode: 448 });
   if (process.platform === "win32") {
     return;
   }
@@ -25355,13 +25557,13 @@ function ensureDir(dir, dataDir) {
 }
 function tighten(target) {
   try {
-    chmodSync3(target, 448);
+    chmodSync4(target, 448);
   } catch {}
 }
 function atomicWriteText(file, body) {
   const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
-  writeFileSync5(tmp, body, { encoding: "utf8", mode: 384 });
-  renameSync3(tmp, file);
+  writeFileSync6(tmp, body, { encoding: "utf8", mode: 384 });
+  renameSync4(tmp, file);
 }
 function atomicWriteJson(file, value) {
   atomicWriteText(file, `${JSON.stringify(value, null, 2)}
@@ -28474,23 +28676,48 @@ async function openSlate(opts) {
 async function closeSlate(dir, mintAttemptId) {
   await archiveSlate(dir, mintAttemptId());
 }
+function detachSlateSession(ref) {
+  if (ref !== undefined) {
+    ref.detached = true;
+  }
+}
+function isSlateSessionDetached(ref) {
+  return ref.detached === true;
+}
+function slateSessionDir(ref) {
+  return isSlateSessionDetached(ref) ? undefined : ref.dir;
+}
+async function writeSlateSession(ref, update) {
+  if (isSlateSessionDetached(ref)) {
+    return;
+  }
+  return writeSlate(ref.dir, update);
+}
+async function readSlateSession(ref) {
+  if (isSlateSessionDetached(ref)) {
+    return;
+  }
+  return readSlate(ref.dir);
+}
 async function ensureSlateOpened(ref, mintAttemptId, runtime) {
+  if (isSlateSessionDetached(ref)) {
+    return;
+  }
   if (ref.opened) {
     const live = await readSlate(ref.dir);
     if (live !== undefined) {
       return;
     }
   }
-  await openSlate({
-    dir: ref.dir,
-    cwd: ref.cwd,
-    mintAttemptId,
-    ...runtime !== undefined ? { runtime } : {}
-  });
+  const anchors = await computeAnchors({ cwd: ref.cwd, ...runtime !== undefined ? { runtime } : {} });
+  if (isSlateSessionDetached(ref)) {
+    return;
+  }
+  await openSlateAtomic(ref.dir, mintAttemptId, () => ({ anchors, course: {}, seeds: [] }));
   ref.opened = true;
 }
 async function closeSlateSession(ref, mintAttemptId) {
-  if (ref === undefined) {
+  if (ref === undefined || isSlateSessionDetached(ref)) {
     return;
   }
   await closeSlate(ref.dir, mintAttemptId);
@@ -28540,6 +28767,12 @@ async function recordSlateTouch(dir, touched, extra) {
   });
   return { changed, slate };
 }
+async function recordSlateSessionTouch(ref, touched, extra) {
+  if (isSlateSessionDetached(ref)) {
+    return;
+  }
+  return recordSlateTouch(ref.dir, touched, extra);
+}
 function mintTimestampAttemptId(now = new Date) {
   timestampMintCounter += 1;
   return `${now.toISOString().replace(/:/g, "-")}-${timestampMintCounter}`;
@@ -29024,7 +29257,7 @@ async function resolveTerminalStateSnapshots(options) {
   const ref = options.slateSession;
   if (ref !== undefined && ref.opened) {
     try {
-      const slate = await readSlate(ref.dir);
+      const slate = await readSlateSession(ref);
       if (slate !== undefined) {
         return { courseSnapshot: slate.course, anchorsSnapshot: slate.anchors };
       }
@@ -29044,9 +29277,10 @@ async function emitTerminalState(io, deps, options, reason) {
   };
   io.onTerminalState?.(state);
   const ref = options.slateSession;
-  if (ref !== undefined && ref.opened) {
+  const terminalDir = ref !== undefined && ref.opened ? slateSessionDir(ref) : undefined;
+  if (terminalDir !== undefined) {
     try {
-      await writeTerminalState(ref.dir, state);
+      await writeTerminalState(terminalDir, state);
     } catch {}
   }
   const block = renderTerminalStateBlock(state);
@@ -29082,7 +29316,7 @@ async function closeSlateOnFlowDone(io, deps, options) {
     return;
   }
   try {
-    const slate = await readSlate(ref.dir);
+    const slate = await readSlateSession(ref);
     const course = await courseFromSlate(ref.cwd, slate);
     if (isCourseDone(course)) {
       if (slate !== undefined) {
@@ -29147,7 +29381,7 @@ async function runAgentTurnCore(io, deps, history, userLine, options = {}) {
   if (options.slateSession !== undefined) {
     try {
       if (options.skipCloseTrigger !== true && isClosePhrase(userLine)) {
-        const liveSlate = await readSlate(options.slateSession.dir);
+        const liveSlate = await readSlateSession(options.slateSession);
         if (liveSlate !== undefined) {
           await dispatchWrapUpBestEffort(io, options, "explicit", options.slateSession.cwd, options.slateSession.dir, liveSlate);
         }
@@ -29159,7 +29393,7 @@ async function runAgentTurnCore(io, deps, history, userLine, options = {}) {
           model: deps.modelId
         });
         if (!wasOpened && options.slateSession.opened) {
-          const freshSlate = await readSlate(options.slateSession.dir);
+          const freshSlate = await readSlateSession(options.slateSession);
           if (freshSlate !== undefined) {
             history.push({ role: "user", content: renderAnchorsBlock(freshSlate.anchors), provenance: "project", ts: now() });
             io.onHistoryChange?.("tool");
@@ -29577,10 +29811,10 @@ ${modelOutput}` : modelOutput,
       if (options.slateSession !== undefined && options.slateSession.opened === true) {
         try {
           const touchedPaths = extractTouchedFromToolInput(call.name, parseToolInput3(call.input));
-          const touch = await recordSlateTouch(options.slateSession.dir, touchedPaths, {
+          const touch = await recordSlateSessionTouch(options.slateSession, touchedPaths, {
             runtime: { provider: deps.providerId, model: deps.modelId }
           });
-          if (touch.changed) {
+          if (touch?.changed === true) {
             anchorsToAnnounce = touch.slate.anchors;
           }
         } catch (err) {
@@ -40654,7 +40888,7 @@ var init_deep_enrich = __esm(() => {
 });
 
 // src/wiki/enrich.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync23, mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync7 } from "fs";
 import { readFile as readFile77, writeFile as writeFile42 } from "fs/promises";
 import path137 from "path";
 function resolveEnrichProviderModel(input) {
@@ -40672,7 +40906,7 @@ function loadResumeState(cwd) {
     if (!existsSync23(file)) {
       return { updatedAt: new Date().toISOString(), completed: [], failed: [] };
     }
-    const raw = JSON.parse(readFileSync6(file, "utf8"));
+    const raw = JSON.parse(readFileSync7(file, "utf8"));
     if (raw === null || typeof raw !== "object") {
       return { updatedAt: new Date().toISOString(), completed: [], failed: [] };
     }
@@ -40695,8 +40929,8 @@ function isStringRecord(value) {
 function saveResumeState(cwd, state) {
   try {
     const file = resumeStatePath(cwd);
-    mkdirSync5(path137.dirname(file), { recursive: true });
-    writeFileSync6(file, `${JSON.stringify({ ...state, updatedAt: new Date().toISOString() }, null, 2)}
+    mkdirSync6(path137.dirname(file), { recursive: true });
+    writeFileSync7(file, `${JSON.stringify({ ...state, updatedAt: new Date().toISOString() }, null, 2)}
 `, "utf8");
   } catch {}
 }
@@ -43570,9 +43804,9 @@ var init_login = __esm(() => {
 });
 
 // src/tui/debug-watcher.ts
-import { spawn as spawn6, spawnSync as spawnSync3 } from "child_process";
-import { closeSync as closeSync3, constants as constants2, openSync as openSync3, readdirSync as readdirSync3, readFileSync as readFileSync9, readlinkSync, statSync as statSync6 } from "fs";
-import path195 from "path";
+import { spawn as spawn6, spawnSync as spawnSync4 } from "child_process";
+import { closeSync as closeSync3, constants as constants2, openSync as openSync4, readdirSync as readdirSync3, readFileSync as readFileSync11, readlinkSync as readlinkSync3, statSync as statSync7 } from "fs";
+import path196 from "path";
 function parseEpollFdinfo(text) {
   const out = [];
   for (const line of text.split(`
@@ -43616,7 +43850,7 @@ function isAlive(pid) {
 }
 function readText(file) {
   try {
-    return readFileSync9(file, "utf8");
+    return readFileSync11(file, "utf8");
   } catch {
     return;
   }
@@ -43633,7 +43867,7 @@ function listFds(pid) {
     const fd = Number(name);
     let link;
     try {
-      link = readlinkSync(`/proc/${pid}/fd/${name}`);
+      link = readlinkSync3(`/proc/${pid}/fd/${name}`);
     } catch {
       continue;
     }
@@ -43659,26 +43893,77 @@ function threads(pid) {
     return { tid, comm: (readText(`${base}/comm`) ?? "").trim(), wchan: (readText(`${base}/wchan`) ?? "").trim(), state };
   });
 }
-async function makePendingReader() {
+function ttyHolders(ttyPath) {
+  const out = [];
+  let pids;
+  try {
+    pids = readdirSync3("/proc").filter((name) => /^\d+$/.test(name));
+  } catch {
+    return out;
+  }
+  for (const pid of pids) {
+    let fdNames;
+    try {
+      fdNames = readdirSync3(`/proc/${pid}/fd`);
+    } catch {
+      continue;
+    }
+    const fds = [];
+    for (const fd of fdNames) {
+      try {
+        if (readlinkSync3(`/proc/${pid}/fd/${fd}`) === ttyPath)
+          fds.push(Number(fd));
+      } catch {}
+    }
+    if (fds.length === 0)
+      continue;
+    const cmd = (readText(`/proc/${pid}/cmdline`) ?? "").split("\x00").join(" ").trim().slice(0, 300);
+    const ppid = /\)\s+\S\s+(\d+)/.exec(readText(`/proc/${pid}/stat`) ?? "")?.[1];
+    out.push({ pid: Number(pid), ...ppid !== undefined ? { ppid } : {}, cmd, fds });
+  }
+  return out;
+}
+function decodeTermios(buf) {
+  const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  const iflag = view.getUint32(0, true);
+  const lflag = view.getUint32(12, true);
+  return {
+    iflag,
+    lflag,
+    vmin: buf[CC_OFFSET + VMIN] ?? 0,
+    vtime: buf[CC_OFFSET + VTIME] ?? 0,
+    icanon: (lflag & ICANON) !== 0,
+    echo: (lflag & ECHO) !== 0
+  };
+}
+async function makeTtyProbes() {
+  const none = { pending: () => {
+    return;
+  }, termios: () => {
+    return;
+  } };
   if (process.platform !== "linux") {
-    return () => {
-      return;
-    };
+    return none;
   }
   try {
     const ffi = await import("bun:ffi");
     const libc = ffi.dlopen("libc.so.6", {
-      ioctl: { args: [ffi.FFIType.i32, ffi.FFIType.u64, ffi.FFIType.ptr], returns: ffi.FFIType.i32 }
+      ioctl: { args: [ffi.FFIType.i32, ffi.FFIType.u64, ffi.FFIType.ptr], returns: ffi.FFIType.i32 },
+      tcgetattr: { args: [ffi.FFIType.i32, ffi.FFIType.ptr], returns: ffi.FFIType.i32 }
     });
-    return (fd) => {
-      const out = new Int32Array(1);
-      const rc = libc.symbols.ioctl(fd, FIONREAD, ffi.ptr(out));
-      return rc === 0 ? out[0] ?? 0 : undefined;
+    return {
+      pending: (fd) => {
+        const out = new Int32Array(1);
+        const rc = libc.symbols.ioctl(fd, FIONREAD, ffi.ptr(out));
+        return rc === 0 ? out[0] ?? 0 : undefined;
+      },
+      termios: (fd) => {
+        const buf = new Uint8Array(TERMIOS_SIZE);
+        return libc.symbols.tcgetattr(fd, ffi.ptr(buf)) === 0 ? decodeTermios(buf) : undefined;
+      }
     };
   } catch {
-    return () => {
-      return;
-    };
+    return none;
   }
 }
 function spawnDebugWatcher(run) {
@@ -43710,22 +43995,23 @@ async function runDebugWatcher(argv) {
     process.exitCode = 2;
     return;
   }
-  const logFile = path195.join(dirArg, "watcher.ndjson");
-  const shellLog = path195.join(dirArg, "shell.ndjson");
+  const logFile = path196.join(dirArg, "watcher.ndjson");
+  const shellLog = path196.join(dirArg, "shell.ndjson");
   const log = (kind, data = {}) => {
     try {
       appendOwnerOnlyLine(logFile, JSON.stringify({ ts: new Date().toISOString(), watcher: process.pid, target: pid, kind, ...data }));
     } catch {}
   };
   const linux = process.platform === "linux" && isAlive(pid) && readText(`/proc/${pid}/stat`) !== undefined;
-  const pendingOf = await makePendingReader();
+  const probes = await makeTtyProbes();
+  const pendingOf = probes.pending;
   let ttyPath;
   let ttyFd;
   if (linux) {
     try {
-      ttyPath = readlinkSync(`/proc/${pid}/fd/0`);
+      ttyPath = readlinkSync3(`/proc/${pid}/fd/0`);
       if (isTtyLink(ttyPath)) {
-        ttyFd = openSync3(ttyPath, constants2.O_RDONLY | constants2.O_NONBLOCK | constants2.O_NOCTTY);
+        ttyFd = openSync4(ttyPath, constants2.O_RDONLY | constants2.O_NONBLOCK | constants2.O_NOCTTY);
       }
     } catch (error) {
       log("tty.open-failed", { error: String(error) });
@@ -43734,13 +44020,14 @@ async function runDebugWatcher(argv) {
   log("watcher.start", { linux, ttyPath, fionread: ttyFd !== undefined && pendingOf(ttyFd) !== undefined });
   const history = [];
   let lastLogged = "";
+  let lastTermios = "";
   let lastPeriodic = 0;
   let lastSignal = 0;
   const fullSnapshot = () => {
     const fds = listFds(pid);
     let stty;
     if (ttyPath !== undefined) {
-      const res = spawnSync3("stty", ["-a", "-F", ttyPath], { encoding: "utf8", timeout: 2000 });
+      const res = spawnSync4("stty", ["-a", "-F", ttyPath], { encoding: "utf8", timeout: 2000 });
       stty = (res.stdout ?? "").trim() || (res.stderr ?? "").trim();
     }
     return {
@@ -43766,7 +44053,7 @@ async function runDebugWatcher(argv) {
       sample.pending = pendingOf(ttyFd);
     }
     try {
-      sample.heartbeatAgeMs = Date.now() - statSync6(shellLog).mtimeMs;
+      sample.heartbeatAgeMs = Date.now() - statSync7(shellLog).mtimeMs;
     } catch {
       sample.heartbeatAgeMs = undefined;
     }
@@ -43802,10 +44089,25 @@ async function runDebugWatcher(argv) {
     }
     return true;
   };
+  const termiosTimer = ttyFd === undefined ? undefined : setInterval(() => {
+    const termios = probes.termios(ttyFd);
+    const key = JSON.stringify(termios);
+    if (termios !== undefined && key !== lastTermios) {
+      const suspicious = termios.vmin === 0 || termios.icanon;
+      log("termios", {
+        ...termios,
+        suspicious,
+        ...suspicious && lastTermios !== "" && ttyPath !== undefined ? { ttyHolders: ttyHolders(ttyPath) } : {}
+      });
+      lastTermios = key;
+    }
+  }, 50);
   await new Promise((resolve) => {
     const timer = setInterval(() => {
       if (!tick()) {
         clearInterval(timer);
+        if (termiosTimer !== undefined)
+          clearInterval(termiosTimer);
         resolve();
       }
     }, 1000);
@@ -43817,7 +44119,7 @@ async function runDebugWatcher(argv) {
   }
   log("watcher.stop");
 }
-var EPOLLIN = 1, FIONREAD = 21531, isTtyLink = (link) => link.startsWith("/dev/pts/") || /^\/dev\/tty/.test(link);
+var EPOLLIN = 1, FIONREAD = 21531, isTtyLink = (link) => link.startsWith("/dev/pts/") || /^\/dev\/tty/.test(link), TERMIOS_SIZE = 60, CC_OFFSET = 17, VTIME = 5, VMIN = 6, ICANON = 2, ECHO = 8;
 var init_debug_watcher = __esm(() => {
   init_config_dir();
 });
@@ -43918,23 +44220,23 @@ import path24 from "path";
 // src/lib/project-registry.ts
 init_config_dir();
 import {
-  chmodSync as chmodSync2,
+  chmodSync as chmodSync3,
   closeSync as closeSync2,
   copyFileSync,
   existsSync as existsSync4,
   fsyncSync,
   openSync as openSync2,
   realpathSync as realpathSync2,
-  renameSync as renameSync2,
-  statSync as statSync4,
+  renameSync as renameSync3,
+  statSync as statSync5,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync4
 } from "fs";
 import path23 from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 
 // src/lib/file-lock.ts
-import { closeSync, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync3, rmSync, statSync as statSync3, writeFileSync as writeFileSync2 } from "fs";
+import { closeSync, mkdirSync as mkdirSync3, openSync, readFileSync as readFileSync4, rmSync as rmSync2, statSync as statSync4, writeFileSync as writeFileSync3 } from "fs";
 import { randomUUID as randomUUID3 } from "crypto";
 import path22 from "path";
 var LOCK_STALE_MS = 1e4;
@@ -43950,7 +44252,7 @@ function sleepSync(ms) {
 }
 function withFileLock2(lockPath, fn, options = {}) {
   try {
-    mkdirSync2(path22.dirname(lockPath), { recursive: true, mode: 448 });
+    mkdirSync3(path22.dirname(lockPath), { recursive: true, mode: 448 });
   } catch {
     return null;
   }
@@ -43966,18 +44268,18 @@ function withFileLock2(lockPath, fn, options = {}) {
     try {
       handle = openSync(lockPath, "wx", 384);
       try {
-        writeFileSync2(handle, nonce, { encoding: "utf8" });
+        writeFileSync3(handle, nonce, { encoding: "utf8" });
       } catch (cause) {
         closeSync(handle);
         handle = null;
-        rmSync(lockPath, { force: true });
+        rmSync2(lockPath, { force: true });
         throw cause;
       }
     } catch {
-      const age = statSync3(lockPath, { throwIfNoEntry: false })?.mtimeMs;
+      const age = statSync4(lockPath, { throwIfNoEntry: false })?.mtimeMs;
       if (age !== undefined && Date.now() - age > LOCK_STALE_MS) {
         try {
-          rmSync(lockPath, { force: true });
+          rmSync2(lockPath, { force: true });
         } catch {}
       }
       if (!announced && Date.now() - started > 1000) {
@@ -43994,8 +44296,8 @@ function withFileLock2(lockPath, fn, options = {}) {
       closeSync(handle);
     } catch {}
     try {
-      if (readFileSync3(lockPath, "utf8") === nonce) {
-        rmSync(lockPath, { force: true });
+      if (readFileSync4(lockPath, "utf8") === nonce) {
+        rmSync2(lockPath, { force: true });
       }
     } catch {}
   }
@@ -44117,7 +44419,7 @@ function tightenBackup(file) {
     return;
   }
   try {
-    chmodSync2(file, 384);
+    chmodSync3(file, 384);
   } catch {}
 }
 function quarantineDamagedRegistry(dir, onWarn) {
@@ -44145,13 +44447,13 @@ function saveProjectRegistry(registry, dir, onWarn) {
     };
     const handle = openSync2(temp, "wx", 384);
     try {
-      writeFileSync3(handle, `${JSON.stringify(sorted, null, 2)}
+      writeFileSync4(handle, `${JSON.stringify(sorted, null, 2)}
 `, { encoding: "utf8" });
       fsyncSync(handle);
     } finally {
       closeSync2(handle);
     }
-    renameSync2(temp, file);
+    renameSync3(temp, file);
     return true;
   } catch {
     try {
@@ -44231,7 +44533,7 @@ function forgetProject(projectId, dir, onWarn) {
   return outcome ?? "write-failed";
 }
 function isInitializedProject(projectPath) {
-  return statSync4(path23.join(projectPath, ".metaproject"), { throwIfNoEntry: false })?.isDirectory() === true;
+  return statSync5(path23.join(projectPath, ".metaproject"), { throwIfNoEntry: false })?.isDirectory() === true;
 }
 function listProjects(dir, onWarn) {
   const registry = loadProjectRegistry(dir, onWarn);
@@ -45182,7 +45484,7 @@ async function choice(question, choices, defaultValue) {
 
 // src/lib/project-sandbox-policy.ts
 init_paths();
-import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
 import path29 from "path";
 
 // src/harness/process/sandbox/network-run.ts
@@ -45376,7 +45678,7 @@ function loadProjectSandboxPolicy(cwdOrRoot) {
     if (!existsSync7(file)) {
       return {};
     }
-    const raw = JSON.parse(readFileSync4(file, "utf8"));
+    const raw = JSON.parse(readFileSync5(file, "utf8"));
     return sanitizeProjectSandboxPolicy(raw);
   } catch {
     return {};
@@ -45399,8 +45701,8 @@ function writeProjectSandboxPolicySkeletonIfMissing(cwdOrRoot) {
     if (existsSync7(file)) {
       return false;
     }
-    mkdirSync3(path29.dirname(file), { recursive: true });
-    writeFileSync4(file, projectSandboxPolicySkeleton(), { mode: 420 });
+    mkdirSync4(path29.dirname(file), { recursive: true });
+    writeFileSync5(file, projectSandboxPolicySkeleton(), { mode: 420 });
     return true;
   } catch {
     return false;
@@ -45408,7 +45710,7 @@ function writeProjectSandboxPolicySkeletonIfMissing(cwdOrRoot) {
 }
 
 // src/gdskills/catalog.ts
-import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
 import path30 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var GDSKILLS_PROFILES = [
@@ -45903,7 +46205,7 @@ function readBundledSkillRouting(category, name) {
   if (file === undefined) {
     throw new Error(`bundled skill "${category}/${name}" ships no SKILL.md under src/gdskills/bundled/skills, and BUNDLED_GDSKILLS reads its description and triggers from there. Declare it with renderedSkill() if it has no file.`);
   }
-  const { description, triggers } = parseSkillFrontmatter(readFileSync5(file, "utf8"));
+  const { description, triggers } = parseSkillFrontmatter(readFileSync6(file, "utf8"));
   if (description === undefined || description.length === 0 || triggers === undefined || triggers.length === 0) {
     throw new Error(`${file}: frontmatter must declare a non-empty \`description\` and \`triggers:\` list; the skill router scores both.`);
   }
@@ -50624,7 +50926,7 @@ import path47 from "path";
 // package.json
 var package_default = {
   name: "@mrciphersmith/keryx",
-  version: "0.2.122",
+  version: "0.2.123",
   description: "Version-controlled project context for AI coding agents: code graph, architecture wiki, project memory, relevant tests, quality signals, and task flows.",
   private: false,
   publishConfig: {
@@ -60575,7 +60877,7 @@ function escapeRegExp6(value) {
 }
 
 // src/gdskills/bundled-eval.ts
-import { existsSync as existsSync25, readFileSync as readFileSync7, readdirSync as readdirSync2 } from "fs";
+import { existsSync as existsSync25, readFileSync as readFileSync8, readdirSync as readdirSync2 } from "fs";
 import path147 from "path";
 
 // src/gdskills/model-tier.ts
@@ -61514,7 +61816,7 @@ function evaluateBundledTree(root = defaultBundledRoot()) {
     const skill = path147.basename(skillDir);
     const rel = path147.relative(skillsRoot, file).split(path147.sep).join("/");
     const category = path147.dirname(rel).split("/")[0] ?? "";
-    const text = readFileSync7(file, "utf8");
+    const text = readFileSync8(file, "utf8");
     const add = (check, line, message) => {
       findings.push({ check, skill, file: rel, line, message });
     };
@@ -61664,7 +61966,7 @@ function evaluateBundledTree(root = defaultBundledRoot()) {
   }
   for (const file of bundledRuleFiles(root)) {
     const rel = path147.relative(root, file).split(path147.sep).join("/");
-    const text = readFileSync7(file, "utf8");
+    const text = readFileSync8(file, "utf8");
     const add = (check, line, message) => {
       findings.push({ check, skill: path147.basename(file, path147.extname(file)), file: rel, line, message });
     };
@@ -61674,7 +61976,7 @@ function evaluateBundledTree(root = defaultBundledRoot()) {
     const skillDir = path147.dirname(file);
     const skill = path147.basename(skillDir);
     const rel = path147.relative(skillsRoot, file).split(path147.sep).join("/");
-    const text = readFileSync7(file, "utf8");
+    const text = readFileSync8(file, "utf8");
     const add = (check, line, message) => {
       findings.push({ check, skill, file: rel, line, message });
     };
@@ -61703,7 +62005,7 @@ function evaluateBundledTree(root = defaultBundledRoot()) {
     const dir = path147.dirname(file);
     let canonicalComparable;
     try {
-      canonicalComparable = buildComparableText(readFileSync7(file, "utf8"));
+      canonicalComparable = buildComparableText(readFileSync8(file, "utf8"));
     } catch {
       continue;
     }
@@ -61716,7 +62018,7 @@ function evaluateBundledTree(root = defaultBundledRoot()) {
         continue;
       let buildComparable;
       try {
-        buildComparable = buildComparableText(readFileSync7(buildPath, "utf8"));
+        buildComparable = buildComparableText(readFileSync8(buildPath, "utf8"));
       } catch {
         continue;
       }
@@ -74022,11 +74324,11 @@ function wrapSeatbelt(command, profile) {
 }
 
 // src/harness/process/sandbox/bwrap.ts
-import { statSync as statSync5 } from "fs";
+import { statSync as statSync6 } from "fs";
 var BWRAP_PROGRAM = "bwrap";
 function inspectMaskTarget(target) {
   try {
-    return statSync5(target).isDirectory() ? "dir" : "file";
+    return statSync6(target).isDirectory() ? "dir" : "file";
   } catch {
     return "missing";
   }
@@ -76397,7 +76699,7 @@ function credentialSummary(raw) {
 
 // src/mcp-servers/store.ts
 init_config_dir();
-import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync7 } from "fs";
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync8 } from "fs";
 import path170 from "path";
 var SERVER_NAME_PATTERN = /^[A-Za-z0-9_-]+$/;
 function userConfigFile(configDir) {
@@ -76446,8 +76748,8 @@ function writeDocument(file, doc, scope) {
     writeOwnerOnlyFileAtomic(file, body);
     return;
   }
-  mkdirSync6(path170.dirname(file), { recursive: true });
-  writeFileSync7(file, body, { encoding: "utf8" });
+  mkdirSync7(path170.dirname(file), { recursive: true });
+  writeFileSync8(file, body, { encoding: "utf8" });
 }
 function addServer(options) {
   if (!SERVER_NAME_PATTERN.test(options.name)) {
@@ -79853,7 +80155,7 @@ Reports the workspace root and one enabled/disabled line per module. Use
 }
 
 // src/commands/harness.ts
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync8 } from "fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync9 } from "fs";
 import path182 from "path";
 import { randomUUID as randomUUID20 } from "crypto";
 
@@ -81766,7 +82068,7 @@ async function harnessCommand(args, deps) {
     const result = await runOffline(input, config, runDeps);
     structured = toStructured(result);
     if (record !== undefined && record.length > 0) {
-      writeFileSync8(record, `${JSON.stringify(toRunRecord(result, {
+      writeFileSync9(record, `${JSON.stringify(toRunRecord(result, {
         runId: result.output.runId,
         status: result.output.status,
         recordedAt: result.output.startedAt
@@ -81812,7 +82114,7 @@ function parseReplayArgs(args) {
 function readJsonFile2(file) {
   let text;
   try {
-    text = readFileSync8(file, "utf8");
+    text = readFileSync9(file, "utf8");
   } catch (error) {
     return { ok: false, reason: error instanceof Error ? error.message : String(error) };
   }
@@ -81867,7 +82169,7 @@ function harnessReplay(args, deps) {
     return;
   }
   if (parsed.writeFixture !== undefined && parsed.writeFixture.length > 0) {
-    writeFileSync8(parsed.writeFixture, `${JSON.stringify(fixture.value, null, 2)}
+    writeFileSync9(parsed.writeFixture, `${JSON.stringify(fixture.value, null, 2)}
 `, {
       encoding: "utf8",
       mode: 384
@@ -82179,7 +82481,7 @@ function readSpecArg(args) {
   if (specPath === undefined) {
     throw new Error("keryx harness: a --spec <path> argument is required when no spec is injected.");
   }
-  return JSON.parse(readFileSync8(specPath, "utf8"));
+  return JSON.parse(readFileSync9(specPath, "utf8"));
 }
 var DEFAULT_CHILD_RESULT = `STATUS: DONE
 Extension completed within its granted capabilities.`;
@@ -82286,7 +82588,7 @@ init_providers();
 init_make_provider();
 init_orient();
 init_metaproject_adapter();
-import { randomUUID as randomUUID29 } from "crypto";
+import { randomUUID as randomUUID30 } from "crypto";
 import * as readline2 from "readline";
 
 // src/commands/agent-approval-context.ts
@@ -88542,7 +88844,7 @@ async function runGoalCommand(params) {
       const wasOpened = slateSession.opened;
       await ensureSlateOpened(slateSession, mintAttemptId, { provider: deps.providerId, model: deps.modelId });
       if (!wasOpened && slateSession.opened) {
-        const freshSlate = await readSlate(slateSession.dir);
+        const freshSlate = await readSlateSession(slateSession);
         if (freshSlate !== undefined) {
           history.push({ role: "user", content: renderAnchorsBlock(freshSlate.anchors), provenance: "project" });
           io.onHistoryChange?.("tool");
@@ -88550,17 +88852,17 @@ async function runGoalCommand(params) {
       }
       if (parsed.workspaceId !== undefined) {
         const workspaceId = parsed.workspaceId;
-        await writeSlate(slateSession.dir, (prev) => {
+        await writeSlateSession(slateSession, (prev) => {
           const base = prev ?? { anchors: { root: "", touched: [] }, course: {}, seeds: [] };
           return { ...base, workspaceId };
         });
       }
       if (parsed.auto !== undefined) {
-        const forCourse = await readSlate(slateSession.dir);
+        const forCourse = await readSlateSession(slateSession);
         let flowRefForBinding = forCourse?.course.flowRef;
         if (forCourse !== undefined && forCourse.course.flowRef === undefined) {
           const flowId = await autoProvisionFlow(cwd, parsed.text);
-          await writeSlate(slateSession.dir, (prev) => {
+          await writeSlateSession(slateSession, (prev) => {
             if (!prev)
               throw new Error(`SLATE-27 bind: no open slate in ${slateSession.dir}`);
             return { ...prev, course: { ...prev.course, flowRef: flowId } };
@@ -88583,7 +88885,7 @@ async function runGoalCommand(params) {
     delete slateSession.autoGoalRounds;
     let roundsLeft = roundsCap;
     let round = 1;
-    while (roundsLeft > 0 && slateSession.opened) {
+    while (roundsLeft > 0 && slateSession.opened && !isSlateSessionDetached(slateSession)) {
       roundsLeft -= 1;
       round += 1;
       const continuationText = await buildContinuationMessage(cwd, slateSession, round, roundsCap);
@@ -88596,8 +88898,18 @@ async function runGoalCommand(params) {
         break;
       }
     }
+    if (isSlateSessionDetached(slateSession)) {
+      systemLine(io, `/goal --auto: stopped \u2014 another shell took this session over.
+`);
+      return;
+    }
     const wasOpenBeforeVerifier = slateSession.opened;
     const verdict = await runGoalVerifier(deps, parsed.text, cwd, slateSession, history, io, mintAttemptId);
+    if (isSlateSessionDetached(slateSession)) {
+      systemLine(io, `/goal --auto: stopped \u2014 another shell took this session over.
+`);
+      return;
+    }
     if (verdict === undefined) {
       systemLine(io, `/goal --auto: verifier unavailable \u2014 outcome not independently checked.
 `);
@@ -88612,12 +88924,12 @@ async function runGoalCommand(params) {
         if (!wasOpenBeforeVerifier) {
           try {
             await ensureSlateOpened(slateSession, mintAttemptId, { provider: deps.providerId, model: deps.modelId });
-            const reopened = await readSlate(slateSession.dir);
+            const reopened = await readSlateSession(slateSession);
             if (reopened !== undefined) {
               history.push({ role: "user", content: renderAnchorsBlock(reopened.anchors), provenance: "project" });
               io.onHistoryChange?.("tool");
             }
-            await writeSlate(slateSession.dir, (prev) => {
+            await writeSlateSession(slateSession, (prev) => {
               if (!prev)
                 throw new Error(`SLATE-27 verifier-reopen: no open slate in ${slateSession.dir}`);
               return {
@@ -88647,7 +88959,7 @@ async function runGoalCommand(params) {
 
 // src/tui/tui-shell.ts
 init_metaproject_adapter();
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync as spawnSync3 } from "child_process";
 
 // src/tui/transcript-blocks.ts
 var EVICTED_BLOCK_TEXT = "(output no longer retained)";
@@ -94649,6 +94961,463 @@ function createForegroundAgentIoFacade(owner, token, io) {
   };
 }
 
+// src/session/lease.ts
+init_fs();
+init_paths();
+init_store3();
+import { randomUUID as randomUUID29 } from "crypto";
+import { hostname as hostname2 } from "os";
+import path194 from "path";
+var SESSION_LEASE_STALE_MS = 15000;
+var SESSION_LEASE_HEARTBEAT_MS = 5000;
+var instanceId;
+function processInstanceId() {
+  instanceId ??= randomUUID29();
+  return instanceId;
+}
+var MIN_ENV_STALE_MS = 250;
+var MIN_ENV_HEARTBEAT_MS = 50;
+function envInt(name) {
+  const raw = process.env[name];
+  return raw !== undefined && /^\d+$/.test(raw) ? Number(raw) : undefined;
+}
+function leaseTimingEnvEnabled() {
+  return process.env.KERYX_TEST_LEASE_TIMING === "1";
+}
+function resolveSessionLeaseTiming(timing = {}) {
+  const fromEnv = leaseTimingEnvEnabled();
+  const envStale = fromEnv ? envInt("KERYX_SESSION_LEASE_STALE_MS") : undefined;
+  const staleMs = timing.staleMs ?? (envStale !== undefined && envStale >= MIN_ENV_STALE_MS ? envStale : SESSION_LEASE_STALE_MS);
+  const maxHeartbeat = Math.floor(staleMs / 3);
+  const envHeartbeat = fromEnv ? envInt("KERYX_SESSION_LEASE_HEARTBEAT_MS") : undefined;
+  const heartbeatMs = timing.heartbeatMs ?? (envHeartbeat !== undefined && envHeartbeat >= MIN_ENV_HEARTBEAT_MS && envHeartbeat <= maxHeartbeat ? envHeartbeat : Math.max(1, Math.min(SESSION_LEASE_HEARTBEAT_MS, maxHeartbeat)));
+  return { ...timing, staleMs, heartbeatMs };
+}
+var resolveTiming = resolveSessionLeaseTiming;
+function isMine(holder) {
+  return holder !== undefined && holder.instanceId === processInstanceId() && holder.pid === process.pid;
+}
+function leaseOptions(timing) {
+  return {
+    staleMs: timing.staleMs,
+    ...timing.now !== undefined ? { now: timing.now } : {},
+    ...timing.isAlive !== undefined ? { isAlive: timing.isAlive } : {},
+    ...timing.host !== undefined ? { host: timing.host } : {}
+  };
+}
+function sessionLeasePath(cwd, sessionId, dataDir) {
+  return path194.join(sessionDir(resolveProjectRoot2(cwd), sessionId, dataDir), "active.lease");
+}
+function sessionLeaseState(cwd, sessionId, dataDir, timing) {
+  const resolved = resolveTiming(timing);
+  const seen = inspectLeaseSync(sessionLeasePath(cwd, sessionId, dataDir), leaseOptions(resolved));
+  if (seen.state === "free" || seen.state === "gone")
+    return { state: "free" };
+  if (isMine(seen.holder))
+    return { state: "mine", holder: seen.holder };
+  return { state: seen.state, ...seen.holder !== undefined ? { holder: seen.holder } : {} };
+}
+function latestUnleasedSession(cwd, dataDir, timing) {
+  let skipped;
+  for (const summary of listSessions(cwd, dataDir)) {
+    const { state, holder } = sessionLeaseState(cwd, summary.id, dataDir, timing);
+    if (state === "free" || state === "mine") {
+      return { summary, ...skipped !== undefined ? { skipped } : {} };
+    }
+    skipped ??= { summary, holder, state };
+  }
+  return { summary: undefined, ...skipped !== undefined ? { skipped } : {} };
+}
+function describeLeaseHolder(holder) {
+  if (holder === undefined)
+    return "another instance (still starting)";
+  if (typeof holder.name === "string" && holder.name.length > 0)
+    return `@${holder.name} (pid ${holder.pid})`;
+  return `instance ${String(holder.instanceId).slice(0, 8)} (pid ${holder.pid})`;
+}
+
+class SessionLeasedError extends Error {
+  summary;
+  holder;
+  state;
+  constructor(summary, holder, state, opts = {}) {
+    const where = `session ${shortSessionId(summary.id)} is open in ${describeLeaseHolder(holder)}`;
+    const hint = opts.takeOverRefused === true ? "; the holder is live, so --take-over is refused; use --fork" : state === "stale" ? "; use --fork or --take-over" : "; use --fork";
+    super(`${where}${hint}`);
+    this.name = "SessionLeasedError";
+    this.summary = summary;
+    this.holder = holder;
+    this.state = state;
+  }
+}
+var heldByThisProcess = new Map;
+function wrapHandle(sessionId, lockPath, inner, heartbeatMs) {
+  let released = false;
+  let lost = false;
+  let lostTo;
+  const lostListeners = new Set;
+  let timer;
+  const onExit = () => {
+    handle.release();
+  };
+  const stopHeartbeat = () => {
+    if (timer !== undefined)
+      clearInterval(timer);
+    timer = undefined;
+  };
+  const markLost = () => {
+    if (lost || released)
+      return;
+    lost = true;
+    lostTo = readLeaseOwnerSync(lockPath);
+    stopHeartbeat();
+    if (heldByThisProcess.get(lockPath) === handle)
+      heldByThisProcess.delete(lockPath);
+    const listeners = [...lostListeners];
+    lostListeners.clear();
+    for (const cb of listeners) {
+      try {
+        cb();
+      } catch {}
+    }
+  };
+  const handle = {
+    sessionId,
+    lockPath,
+    get owner() {
+      return inner.owner;
+    },
+    get released() {
+      return released;
+    },
+    get heartbeatTimer() {
+      return timer;
+    },
+    get lost() {
+      return lost;
+    },
+    get lostTo() {
+      return lostTo;
+    },
+    refresh(patch) {
+      if (released || lost)
+        return false;
+      if (inner.refresh(patch))
+        return true;
+      if (inner.ownership() === "lost")
+        markLost();
+      return false;
+    },
+    checkLost() {
+      if (!lost && !released && inner.ownership() === "lost")
+        markLost();
+      return lost;
+    },
+    onLost(cb) {
+      if (lost) {
+        cb();
+        return () => {};
+      }
+      lostListeners.add(cb);
+      return () => {
+        lostListeners.delete(cb);
+      };
+    },
+    release() {
+      if (released)
+        return;
+      released = true;
+      stopHeartbeat();
+      lostListeners.clear();
+      process.off("exit", onExit);
+      if (heldByThisProcess.get(lockPath) === handle)
+        heldByThisProcess.delete(lockPath);
+      if (!lost)
+        inner.release();
+    }
+  };
+  timer = setInterval(() => {
+    handle.refresh();
+  }, heartbeatMs);
+  timer.unref?.();
+  process.on("exit", onExit);
+  heldByThisProcess.set(lockPath, handle);
+  return handle;
+}
+function mintOwner(now) {
+  const at = new Date(now()).toISOString();
+  return {
+    schemaVersion: 1,
+    token: randomUUID29(),
+    pid: process.pid,
+    host: hostname2(),
+    instanceId: processInstanceId(),
+    name: null,
+    acquiredAt: at,
+    heartbeatAt: at
+  };
+}
+function leaseSession(cwd, summary, dataDir, timing, takeOver) {
+  const lockPath = sessionLeasePath(cwd, summary.id, dataDir);
+  const existing = heldByThisProcess.get(lockPath);
+  if (existing !== undefined && !existing.released && !existing.lost)
+    return { handle: existing, minted: false };
+  const owner = mintOwner(timing.now ?? Date.now);
+  const opts = {
+    ...leaseOptions(timing),
+    reclaimIf: (holder) => isMine(holder)
+  };
+  const result = takeOver ? reclaimStaleLeaseSync(lockPath, owner, opts) : acquireLeaseSync(lockPath, owner, opts);
+  if (!result.ok) {
+    throw new SessionLeasedError(summary, result.holder, result.state, {
+      takeOverRefused: takeOver && result.state === "live"
+    });
+  }
+  return { handle: wrapHandle(summary.id, lockPath, result.handle, timing.heartbeatMs), minted: true };
+}
+function describeLeaseLoss(handle) {
+  const short = shortSessionId(handle.sessionId);
+  const by = handle.lostTo !== undefined ? describeLeaseHolder(handle.lostTo) : "another instance";
+  return `session ${short} was taken over by ${by}; this shell no longer saves it. ` + `Use /new, or restart with -r ${short} --fork to keep your turns.
+`;
+}
+var LOST_LEASE_COMPACT_REFUSAL = `Not compacted: another shell took this session over, and this shell no longer saves it. Use /new.
+`;
+function watchLeaseLoss(notify) {
+  let current;
+  let unsubscribe;
+  return {
+    track(next) {
+      if (next === current)
+        return;
+      unsubscribe?.();
+      unsubscribe = undefined;
+      current = next;
+      if (next !== undefined) {
+        unsubscribe = next.onLost(() => {
+          notify(describeLeaseLoss(next), next);
+        });
+      }
+    },
+    canPersist() {
+      return current === undefined || !current.checkLost();
+    }
+  };
+}
+function whilePersisting(value, canPersist) {
+  return value !== undefined && !canPersist() ? undefined : value;
+}
+function gateBoxByLease(box, canPersist) {
+  let value = box.current;
+  Object.defineProperty(box, "current", {
+    configurable: true,
+    enumerable: true,
+    get: () => whilePersisting(value, canPersist),
+    set: (next) => {
+      value = next;
+    }
+  });
+}
+function releaseSessionLease(handle) {
+  handle?.release();
+}
+function openLeasedSession(opts) {
+  const { takeOver, fork, staleMs, heartbeatMs, now, isAlive, host, resumeId: rawResumeId, continueLast, ...base } = opts;
+  const timing = resolveTiming({
+    ...staleMs !== undefined ? { staleMs } : {},
+    ...heartbeatMs !== undefined ? { heartbeatMs } : {},
+    ...now !== undefined ? { now } : {},
+    ...isAlive !== undefined ? { isAlive } : {},
+    ...host !== undefined ? { host } : {}
+  });
+  const { cwd, dataDir } = base;
+  const resumeId = rawResumeId !== undefined && rawResumeId.length > 0 ? rawResumeId : undefined;
+  const openWith = (target, lease) => {
+    try {
+      const opened = openSession({ ...base, ...target !== undefined ? { resumeId: target } : {} });
+      return { ...opened, lease: lease?.handle ?? leaseSession(cwd, opened.handle.summary, dataDir, timing, false).handle };
+    } catch (error) {
+      if (lease?.minted === true)
+        releaseSessionLease(lease.handle);
+      throw error;
+    }
+  };
+  if (fork === true) {
+    if (resumeId === undefined) {
+      throw new Error("--fork needs a session id (-r <id>).");
+    }
+    const forked = forkSession({
+      cwd,
+      sourceIdOrPrefix: resumeId,
+      ...dataDir !== undefined ? { dataDir } : {}
+    });
+    const summary = forked.handle.summary;
+    return openWith(summary.id, leaseSession(cwd, summary, dataDir, timing, false));
+  }
+  if (resumeId !== undefined) {
+    const found = findSession(cwd, resumeId, dataDir);
+    if (found === undefined) {
+      return openWith(resumeId);
+    }
+    return openWith(found.id, leaseSession(cwd, found, dataDir, timing, takeOver === true));
+  }
+  let skipped;
+  if (continueLast === true) {
+    for (let attempt = 0;attempt < 3; attempt += 1) {
+      const pick = latestUnleasedSession(cwd, dataDir, timing);
+      skipped ??= pick.skipped;
+      if (pick.summary === undefined)
+        break;
+      let lease;
+      try {
+        lease = leaseSession(cwd, pick.summary, dataDir, timing, false);
+      } catch (error) {
+        if (!(error instanceof SessionLeasedError))
+          throw error;
+        skipped ??= { summary: error.summary, holder: error.holder, state: error.state };
+        continue;
+      }
+      return { ...openWith(pick.summary.id, lease), ...skipped !== undefined ? { skipped } : {} };
+    }
+  }
+  return { ...openWith(undefined), ...skipped !== undefined ? { skipped } : {} };
+}
+function switchLeasedSession(current, openTarget) {
+  const next = openTarget();
+  if (current !== undefined && current !== next.lease) {
+    releaseSessionLease(current);
+  }
+  return next;
+}
+
+// src/session/lease-choice.ts
+init_store3();
+function leasedChoiceRows(error) {
+  return [
+    { choice: "fork", label: "fork (default): continue in a copy of the session" },
+    { choice: "view", label: "view (read-only), then start a new session" },
+    { choice: "cancel", label: "cancel" },
+    ...error.state === "stale" ? [{ choice: "take-over", label: "take over (the holder is stale)" }] : []
+  ];
+}
+function describeLeasedSession(error) {
+  const stale = error.state === "stale" ? " (stale)" : "";
+  return `Session ${shortSessionId(error.summary.id)} \xB7 ${error.summary.title} is open in ${describeLeaseHolder(error.holder)}${stale}.`;
+}
+function describeSkippedSession(skipped) {
+  const stale = skipped.state === "stale" ? " (stale)" : "";
+  return `Skipped session ${shortSessionId(skipped.summary.id)} \xB7 ${skipped.summary.title}: open in ${describeLeaseHolder(skipped.holder)}${stale}
+`;
+}
+
+// src/tui/tui-session-lease.ts
+function leaseMarker(state) {
+  if (state === "live")
+    return "\u25CF live";
+  if (state === "stale")
+    return "\u25CC stale";
+  return "";
+}
+function leaseStateLookup(cwd, dataDir) {
+  return (sessionId) => {
+    try {
+      return sessionLeaseState(cwd, sessionId, dataDir).state;
+    } catch {
+      return "free";
+    }
+  };
+}
+function withLeaseMarker(label, state) {
+  const marker = leaseMarker(state);
+  return marker.length > 0 ? `${label}  ${marker}` : label;
+}
+function leasedChoiceRequest(error) {
+  const descriptions = {
+    fork: "Continue in a copy of the session; the other shell keeps the original",
+    view: "Show the session read-only, then start a new session",
+    cancel: "Exit without opening a session",
+    "take-over": "Reclaim the lease: the holder has stopped refreshing it"
+  };
+  return {
+    title: describeLeasedSession(error),
+    subtitle: "Esc = cancel",
+    cancelId: "cancel",
+    options: leasedChoiceRows(error).map((row) => ({
+      id: row.choice,
+      label: row.label,
+      description: descriptions[row.choice],
+      ...row.choice === "fork" ? { recommended: true } : {}
+    }))
+  };
+}
+function toLeasedChoice(error, id) {
+  const offered = leasedChoiceRows(error).find((row) => row.choice === id);
+  return offered?.choice ?? "cancel";
+}
+async function resolveLeasedStartup(first, deps) {
+  let error = first;
+  for (;; ) {
+    const choice = await deps.choose(error);
+    if (choice === "cancel") {
+      return { kind: "cancelled" };
+    }
+    if (choice === "view") {
+      try {
+        deps.showReadOnly(deps.exportSession(error.summary.id));
+      } catch (cause) {
+        deps.notice(`Could not render the session: ${cause instanceof Error ? cause.message : String(cause)}`);
+      }
+      return { kind: "opened", opened: deps.open({}) };
+    }
+    try {
+      const target = choice === "fork" ? { resumeId: error.summary.id, fork: true } : { resumeId: error.summary.id, takeOver: true };
+      return { kind: "opened", opened: deps.open(target) };
+    } catch (cause) {
+      if (!(cause instanceof SessionLeasedError)) {
+        throw cause;
+      }
+      deps.notice(cause.message);
+      error = cause;
+    }
+  }
+}
+function createTuiLeaseHolder() {
+  let current;
+  let lossListener;
+  const watch = watchLeaseLoss((message) => lossListener?.(message));
+  const set = (next) => {
+    current = next;
+    watch.track(next);
+  };
+  return {
+    get current() {
+      return current;
+    },
+    hold(next) {
+      if (current !== undefined && current !== next) {
+        releaseSessionLease(current);
+      }
+      set(next);
+    },
+    switchTo(openTarget) {
+      const next = switchLeasedSession(current, openTarget);
+      set(next.lease);
+      return next;
+    },
+    release() {
+      const held = current;
+      set(undefined);
+      releaseSessionLease(held);
+    },
+    canPersist() {
+      return watch.canPersist();
+    },
+    onLost(listener) {
+      lossListener = listener;
+    }
+  };
+}
+
 // src/tui/herdr-report.ts
 init_debug_log();
 import net from "net";
@@ -95027,7 +95796,7 @@ function presentComposerChoice(otui, r, dock, request) {
 // src/lib/version-check.ts
 init_config_dir();
 init_fs();
-import path194 from "path";
+import path195 from "path";
 var REGISTRY_URL = "https://registry.npmjs.org/@mrciphersmith%2Fkeryx/latest";
 var FIXED_INSTALL_COMMAND = "npm install -g @mrciphersmith/keryx@latest";
 var RESPONSE_BODY_LIMIT_BYTES = 64 * 1024;
@@ -95229,7 +95998,7 @@ async function checkVersion(options) {
   const now = options.now ?? Date.now;
   const timestamp = now();
   const configDir = ensureKeryxConfigDir(options.cacheDir);
-  const cacheFile = path194.join(configDir, "version-check.json");
+  const cacheFile = path195.join(configDir, "version-check.json");
   const cache = parseCache(cacheFile);
   if (cache?.latestVersion !== undefined && cache.successAt !== undefined && timestamp - cache.successAt >= 0 && timestamp - cache.successAt < SUCCESS_CACHE_TTL_MS) {
     return resultFor(options.currentVersion, current, cache.latestVersion, "cache");
@@ -95302,9 +96071,39 @@ init_debug_log();
 
 // src/tui/renderer-debug.ts
 init_debug_log();
+import { spawnSync as spawnSync2 } from "child_process";
+import { readFileSync as readFileSync10, readlinkSync as readlinkSync2 } from "fs";
 
 // src/tui/stdin-guard.ts
 init_debug_log();
+import { openSync as openSync3, readlinkSync } from "fs";
+import tty from "tty";
+var resolveStdin = (source) => typeof source === "function" ? source() : source;
+function stdinIsDead(stdin) {
+  return stdin.destroyed === true || stdin.readableEnded === true;
+}
+function openTerminalInput() {
+  let target = "/dev/tty";
+  if (process.platform === "linux") {
+    try {
+      const link = readlinkSync("/proc/self/fd/0");
+      if (link.startsWith("/dev/pts/") || link.startsWith("/dev/tty")) {
+        target = link;
+      }
+    } catch {}
+  }
+  try {
+    const fd = openSync3(target, "r");
+    const stream = new tty.ReadStream(fd);
+    stream.setRawMode(false);
+    stream.setRawMode(true);
+    debugEvent("stdin.reopened", { path: target, fd });
+    return stream;
+  } catch (error) {
+    debugEvent("stdin.reopen-failed", { path: target, error: error instanceof Error ? error.message : String(error) });
+    return;
+  }
+}
 var rendererListener;
 function stdinSnapshot(stdin) {
   const safe = (read) => {
@@ -95409,35 +96208,37 @@ function instrumentStdin(stdin) {
       stdin.off?.(event, handler);
   };
 }
-function startStdinHeartbeat(stdin, opts = {}) {
+function startStdinHeartbeat(source, opts = {}) {
   const intervalMs = opts.intervalMs ?? 1000;
   const cooldownMs = opts.cooldownMs ?? 1e4;
   let lastRecovery = 0;
   const timer = setInterval(() => {
+    const stdin = resolveStdin(source);
     const state = stdinSnapshot(stdin);
     const stalled = stdinLooksStalled(state);
     debugEvent("heartbeat", { stdin: state, stalled, ...opts.extra?.() ?? {} });
     if (stalled && (opts.shouldRecover?.() ?? true) && Date.now() - lastRecovery > cooldownMs) {
       lastRecovery = Date.now();
-      const actions = recoverStdin(stdin, { cycle: true });
-      debugEvent("stdin.stall.recovered-in-process", { before: state, actions, after: stdinSnapshot(stdin) });
+      const actions = opts.recover?.() ?? recoverStdin(stdin, { cycle: true });
+      debugEvent("stdin.stall.recovered-in-process", { before: state, actions, after: stdinSnapshot(resolveStdin(source)) });
     }
   }, intervalMs);
   timer.unref?.();
   return () => clearInterval(timer);
 }
-function installInputRecoverySignal(stdin, onRecovered, shouldRecover = () => true) {
+function installInputRecoverySignal(source, onRecovered, shouldRecover = () => true, recover) {
   if (process.platform === "win32") {
     return () => {};
   }
   const handler = () => {
+    const stdin = resolveStdin(source);
     if (!shouldRecover()) {
       debugEvent("signal.SIGUSR2.skipped", { reason: "renderer suspended or destroyed", stdin: stdinSnapshot(stdin) });
       return;
     }
     const before = stdinSnapshot(stdin);
-    const actions = recoverStdin(stdin, { cycle: true });
-    const after = stdinSnapshot(stdin);
+    const actions = recover?.() ?? recoverStdin(stdin, { cycle: true });
+    const after = stdinSnapshot(resolveStdin(source));
     debugEvent("signal.SIGUSR2.recover", { before, actions, after, debug: isDebugEnabled() });
     try {
       onRecovered?.(actions);
@@ -95450,15 +96251,110 @@ function installInputRecoverySignal(stdin, onRecovered, shouldRecover = () => tr
 }
 
 // src/tui/renderer-debug.ts
-function attachRendererGuards(r, stdin = process.stdin) {
+var MAX_REOPENS_PER_MINUTE = 5;
+function eofDiagnostics() {
+  if (process.platform !== "linux") {
+    return {};
+  }
+  let tty;
+  try {
+    tty = readlinkSync2("/proc/self/fd/0");
+  } catch {
+    tty = undefined;
+  }
+  let stat;
+  try {
+    stat = readFileSync10("/proc/self/stat", "utf8").trim();
+  } catch {
+    stat = "";
+  }
+  const fields = stat.replace(/^.*\)\s+/, "").split(" ");
+  const stty = tty !== undefined ? spawnSync2("stty", ["-a", "-F", tty], { encoding: "utf8", timeout: 1500 }).stdout?.trim() : undefined;
+  return { tty, pgrp: fields[2], session: fields[3], tpgid: fields[5], stty };
+}
+function attachRendererGuards(r, initial = process.stdin, deps = {}) {
   const internals = r;
-  registerRendererInputListener(internals.stdinListener);
+  const listener = internals.stdinListener;
+  registerRendererInputListener(listener);
   const shouldRecover = () => !r.isDestroyed && internals.controlState !== "explicit_suspended";
   const teardown = [];
-  teardown.push(installInputRecoverySignal(stdin, () => {
+  let current = initial;
+  let unwatch = () => {};
+  let undoInstrument = () => {};
+  const reopenTimes = [];
+  const reopen = (reason) => {
+    const now = Date.now();
+    while (reopenTimes.length > 0 && now - (reopenTimes[0] ?? 0) > 60000)
+      reopenTimes.shift();
+    if (reopenTimes.length >= MAX_REOPENS_PER_MINUTE) {
+      debugEvent("stdin.reopen-gave-up", { reason, reopensLastMinute: reopenTimes.length });
+      return ["reopen skipped: rate limit"];
+    }
+    reopenTimes.push(now);
+    const next = (deps.openInput ?? openTerminalInput)();
+    if (next === undefined) {
+      return ["reopen failed"];
+    }
+    const previous = current;
+    unwatch();
+    undoInstrument();
+    undoInstrument = () => {};
+    if (listener !== undefined) {
+      try {
+        previous.off?.("data", listener);
+      } catch {}
+      next.on("data", listener);
+    }
+    current = next;
+    internals.stdin = next;
+    watch(next);
+    if (isDebugEnabled()) {
+      undoInstrument = instrumentStdin(next);
+    }
+    next.resume();
+    debugEvent("stdin.replaced", { reason, state: stdinSnapshot(next) });
+    r.requestRender();
+    return [`reopened terminal input (${reason})`];
+  };
+  function watch(stream) {
+    const onDead = (event) => () => {
+      if (current !== stream) {
+        return;
+      }
+      if (isDebugEnabled()) {
+        debugEvent(`stdin.dead.${event}`, { state: stdinSnapshot(stream), ...eofDiagnostics() });
+      }
+      if (!shouldRecover()) {
+        return;
+      }
+      setTimeout(() => {
+        if (current === stream && shouldRecover()) {
+          reopen(event);
+        }
+      }, 0);
+    };
+    const onEnd = onDead("end");
+    const onClose = onDead("close");
+    stream.on("end", onEnd);
+    stream.on("close", onClose);
+    unwatch = () => {
+      stream.off?.("end", onEnd);
+      stream.off?.("close", onClose);
+    };
+  }
+  watch(current);
+  const recover = () => stdinIsDead(current) ? reopen("recover") : recoverStdin(current, { cycle: true });
+  teardown.push(installInputRecoverySignal(() => current, () => {
     r.requestRender();
-  }, shouldRecover));
-  teardown.push(() => registerRendererInputListener(undefined));
+  }, shouldRecover, recover));
+  teardown.push(() => {
+    unwatch();
+    undoInstrument();
+    registerRendererInputListener(undefined);
+    if (current !== initial) {
+      current.destroy?.();
+    }
+  });
   if (!isDebugEnabled()) {
     return () => {
       for (const fn of teardown.splice(0))
@@ -95471,9 +96367,10 @@ function attachRendererGuards(r, stdin = process.stdin) {
     height: r.height,
     hasStdinListener: internals.stdinListener !== undefined
   });
-  teardown.push(instrumentStdin(stdin));
-  teardown.push(startStdinHeartbeat(stdin, {
+  undoInstrument = instrumentStdin(current);
+  teardown.push(startStdinHeartbeat(() => current, {
     shouldRecover,
+    recover,
     extra: () => ({
       controlState: internals.controlState,
       focused: internals.currentFocusedRenderable?.id
@@ -98425,7 +99322,7 @@ function parseGitHubRemote(remote) {
 }
 function runGitText(args, cwd) {
   try {
-    const proc = spawnSync2("git", args, {
+    const proc = spawnSync3("git", args, {
       cwd,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"],
@@ -98442,7 +99339,7 @@ function runGitText(args, cwd) {
 }
 function runGhJson(repo, branch, cwd) {
   try {
-    const proc = spawnSync2("gh", ["pr", "view", branch, "--repo", repo, "--json", "url"], {
+    const proc = spawnSync3("gh", ["pr", "view", branch, "--repo", repo, "--json", "url"], {
       cwd,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"],
@@ -98925,8 +99822,8 @@ async function applyRuntimeSwitchToSlate(params) {
   if (params.slateSession === undefined || !params.slateSession.opened) {
     return false;
   }
-  const result = await recordSlateTouch(params.slateSession.dir, [], { runtime: params.runtime });
-  if (!result.changed) {
+  const result = await recordSlateSessionTouch(params.slateSession, [], { runtime: params.runtime });
+  if (result === undefined || !result.changed) {
     return false;
   }
   params.history.push({
@@ -99896,21 +100793,40 @@ function formatSessionDate(iso) {
   const short = iso.trim().replace("T", " ");
   return short.length >= 16 ? short.slice(0, 16) : short;
 }
-function pickSessionInTui(otui, rOrChrome, sessions) {
-  const chrome = isModalChrome(rOrChrome) ? rOrChrome : undefined;
-  const r = chrome !== undefined ? chrome.renderer : rOrChrome;
-  const all = sessions.map((s) => {
+function sessionPickerOptions(sessions, leaseState = () => "free") {
+  return sessions.map((s) => {
     const created = formatSessionDate(s.createdAt);
     const updated = formatSessionDate(s.updatedAt);
     const short = shortSessionId(s.id);
     const title = s.title.length > 52 ? `${s.title.slice(0, 49)}\u2026` : s.title;
+    const label = withLeaseMarker(`${short} \xB7 ${title}`, leaseState(s.id));
     return {
       value: s.id,
-      label: `${short} \xB7 ${title}`,
+      label,
       description: `${s.projectPath} \xB7 created ${created} \xB7 updated ${updated}`,
-      search: `${s.id} ${short} ${s.projectPath} ${s.title} ${created} ${updated}`.toLowerCase()
+      search: `${s.id} ${label} ${s.projectPath} ${s.title} ${created} ${updated}`.toLowerCase()
     };
   });
+}
+function startupSessionChoices(rows, leaseState = () => "free") {
+  return [
+    {
+      id: "__new__",
+      label: "New session",
+      description: "Start fresh (old sessions stay on disk)",
+      recommended: true
+    },
+    ...rows.map((s) => ({
+      id: s.id,
+      label: withLeaseMarker(s.title.length > 40 ? `${s.title.slice(0, 37)}\u2026` : s.title, leaseState(s.id)),
+      description: `${shortSessionId(s.id)} \xB7 ctx ${s.messageCount} \xB7 ${s.updatedAt.slice(0, 16).replace("T", " ")}`
+    }))
+  ];
+}
+function pickSessionInTui(otui, rOrChrome, sessions, leaseState) {
+  const chrome = isModalChrome(rOrChrome) ? rOrChrome : undefined;
+  const r = chrome !== undefined ? chrome.renderer : rOrChrome;
+  const all = sessionPickerOptions(sessions, leaseState);
   const listSpec = {
     idPrefix: "sp",
     items: all,
@@ -100017,11 +100933,13 @@ async function launchTuiAgentShell(opts) {
   let liveJobs;
   let detachExternal;
   const foregroundOperation = createForegroundOperationOwner();
+  const sessionLease = createTuiLeaseHolder();
   try {
     const r = renderer = await createShellRenderer(otui, {
       onDestroy: () => {
         foregroundOperation.cancel("renderer destroyed");
         foregroundOperation.dispose();
+        sessionLease.release();
         mountedChrome?.destroy();
         setAskUserHost(undefined);
         setSubagentFleetListener(undefined);
@@ -100054,7 +100972,8 @@ async function launchTuiAgentShell(opts) {
     saveShellConfig(sel.baseUrl === undefined ? { provider: sel.provider, model: sel.model } : { provider: sel.provider, model: sel.model, baseUrl: sel.baseUrl });
     let currentSel = sel;
     const suggestionGate = new NextStepSuggestionGate;
-    let deps = await opts.makeAgentDeps(sel, () => slateSession);
+    const liveSlateSession = () => whilePersisting(slateSession, () => sessionLease.canPersist());
+    let deps = await opts.makeAgentDeps(sel, liveSlateSession);
     liveDeps = deps;
     let reasoningOverride;
     let thinkDisplayMode = resolveThinkDisplayMode(loadShellConfig().thinkDisplay);
@@ -100127,7 +101046,7 @@ async function launchTuiAgentShell(opts) {
       }));
     };
     const refreshWorkspaceSidebar = async () => {
-      const dir = slateSession?.dir;
+      const dir = liveSlateSession()?.dir;
       const workspaceId = dir !== undefined ? (await readSlate(dir).catch(() => {
         return;
       }))?.workspaceId : undefined;
@@ -100753,6 +101672,9 @@ async function launchTuiAgentShell(opts) {
       slateSession = freshSlateSessionRef(liveSession.dir, sessionCwd);
     };
     const onContextCompaction = (r) => {
+      if (!sessionLease.canPersist()) {
+        return;
+      }
       const persisted = persistCompacted(liveSession, r.context, archive, {
         provider: currentSel.provider,
         model: currentSel.model
@@ -100784,7 +101706,7 @@ async function launchTuiAgentShell(opts) {
         return;
       }
       chrome.hideMenu();
-      const pickId = await chrome.withOverlay(() => pickSessionInTui(otui, chrome, rows));
+      const pickId = await chrome.withOverlay(() => pickSessionInTui(otui, chrome, rows, leaseState));
       input.focus();
       if (pickId === undefined) {
         return;
@@ -100797,98 +101719,142 @@ async function launchTuiAgentShell(opts) {
       }
       return found;
     };
+    const leasedOpen = (target = {}) => sessionLease.switchTo(() => openLeasedSession({
+      cwd: sessionCwd,
+      ...target,
+      provider: currentSel.provider,
+      model: currentSel.model
+    }));
+    const leaseState = leaseStateLookup(sessionCwd);
+    const showOpenedNotes = (opened) => {
+      if (opened.skipped !== undefined) {
+        transcript.add(new otui.TextRenderable(r, {
+          id: `sessskip${uid++}`,
+          content: otui.t`${otui.yellow(describeSkippedSession(opened.skipped).replace(/\n+$/, ""))}`,
+          marginTop: 1
+        }));
+      }
+      if (opened.archiveDegraded !== undefined) {
+        transcript.add(new otui.TextRenderable(r, {
+          id: `sessdeg${uid++}`,
+          content: otui.t`${otui.yellow(`archive unavailable \u2014 resumed from the active context (${opened.archiveDegraded})`)}`,
+          marginTop: 1
+        }));
+      }
+      if (opened.resumed) {
+        transcript.add(new otui.TextRenderable(r, {
+          id: `sess${uid++}`,
+          content: otui.t`${otui.dim(`session ${shortSessionId(liveSession.summary.id)} \xB7 ${liveSession.summary.title} \xB7 ctx ${history.length} \xB7 archive ${archive.length}`)}`,
+          marginTop: 1
+        }));
+        for (const m of history.filter((x) => x.role === "user").slice(-5)) {
+          const t = m.content.length > 100 ? `${m.content.slice(0, 97)}\u2026` : m.content;
+          transcript.add(new otui.TextRenderable(r, {
+            id: `sessu${uid++}`,
+            content: otui.t`${otui.dim(`  \u276F ${t}`)}`
+          }));
+        }
+      }
+    };
+    let startupCancelled = false;
+    let viewedReadOnly = false;
     try {
       if (opts.session?.pickOnStart === true && opts.session.resumeId === undefined) {
         const rows = listSessions(sessionCwd).slice(0, 12);
         if (rows.length === 0) {
-          applyOpened(openSession({
-            cwd: sessionCwd,
-            provider: currentSel.provider,
-            model: currentSel.model
-          }));
+          applyOpened(leasedOpen());
         } else {
           chrome.hideMenu();
           const pickId = await showComposerChoice(otui, r, chrome.dock, {
             title: "Resume session (this project)",
             subtitle: "Esc = new session",
             cancelId: "__new__",
-            options: [
-              {
-                id: "__new__",
-                label: "New session",
-                description: "Start fresh (old sessions stay on disk)",
-                recommended: true
-              },
-              ...rows.map((s) => ({
-                id: s.id,
-                label: s.title.length > 40 ? `${s.title.slice(0, 37)}\u2026` : s.title,
-                description: `${shortSessionId(s.id)} \xB7 ctx ${s.messageCount} \xB7 ${s.updatedAt.slice(0, 16).replace("T", " ")}`
-              }))
-            ]
+            options: startupSessionChoices(rows, leaseState)
           });
           input.focus();
           if (pickId === "__new__") {
-            applyOpened(openSession({
-              cwd: sessionCwd,
-              provider: currentSel.provider,
-              model: currentSel.model
-            }));
+            applyOpened(leasedOpen());
           } else {
-            applyOpened(openSession({
-              cwd: sessionCwd,
-              resumeId: pickId,
-              provider: currentSel.provider,
-              model: currentSel.model
-            }));
+            const opened = leasedOpen({ resumeId: pickId });
+            applyOpened(opened);
+            showOpenedNotes(opened);
           }
         }
       } else {
-        const opened = openSession({
-          cwd: sessionCwd,
+        const opened = leasedOpen({
           ...opts.session?.continueLast === true ? { continueLast: true } : {},
           ...opts.session?.resumeId !== undefined ? { resumeId: opts.session.resumeId } : {},
-          provider: currentSel.provider,
-          model: currentSel.model
+          ...opts.session?.fork === true ? { fork: true } : {},
+          ...opts.session?.takeOver === true ? { takeOver: true } : {}
         });
         applyOpened(opened);
-        if (opened.archiveDegraded !== undefined) {
-          transcript.add(new otui.TextRenderable(r, {
-            id: `sessdeg${uid++}`,
-            content: otui.t`${otui.yellow(`archive unavailable \u2014 resumed from the active context (${opened.archiveDegraded})`)}`,
-            marginTop: 1
-          }));
-        }
-        if (opened.resumed) {
-          transcript.add(new otui.TextRenderable(r, {
-            id: `sess${uid++}`,
-            content: otui.t`${otui.dim(`session ${shortSessionId(liveSession.summary.id)} \xB7 ${liveSession.summary.title} \xB7 ctx ${history.length} \xB7 archive ${archive.length}`)}`,
-            marginTop: 1
-          }));
-          for (const m of history.filter((x) => x.role === "user").slice(-5)) {
-            const t = m.content.length > 100 ? `${m.content.slice(0, 97)}\u2026` : m.content;
-            transcript.add(new otui.TextRenderable(r, {
-              id: `sessu${uid++}`,
-              content: otui.t`${otui.dim(`  \u276F ${t}`)}`
-            }));
+        showOpenedNotes(opened);
+      }
+    } catch (cause) {
+      let failure = cause;
+      if (cause instanceof SessionLeasedError) {
+        try {
+          const outcome = await resolveLeasedStartup(cause, {
+            choose: async (error) => {
+              chrome.hideMenu();
+              const id = await showComposerChoice(otui, r, chrome.dock, leasedChoiceRequest(error));
+              input.focus();
+              return toLeasedChoice(error, id);
+            },
+            open: (target) => leasedOpen(target),
+            exportSession: (sessionId) => exportSessionMarkdown(sessionCwd, sessionId),
+            showReadOnly: (markdown) => {
+              viewedReadOnly = true;
+              transcript.add(new otui.TextRenderable(r, {
+                id: `sessview${uid++}`,
+                content: otui.t`${otui.dim(`${markdown.replace(/\n+$/, "")}
+
+\u2014 read-only view; a new session starts below \u2014`)}`,
+                marginTop: 1
+              }));
+            },
+            notice: (text) => {
+              transcript.add(new otui.TextRenderable(r, {
+                id: `sesslease${uid++}`,
+                content: otui.t`${otui.yellow(text)}`,
+                marginTop: 1
+              }));
+            }
+          });
+          if (outcome.kind === "cancelled") {
+            startupCancelled = true;
+          } else {
+            applyOpened(outcome.opened);
+            showOpenedNotes(outcome.opened);
           }
+          failure = undefined;
+        } catch (leaseCause) {
+          failure = leaseCause;
         }
       }
-    } catch (cause) {
-      transcript.add(new otui.TextRenderable(r, {
-        id: `sesserr${uid++}`,
-        content: otui.t`${otui.red(cause instanceof Error ? cause.message : String(cause))}`,
-        marginTop: 1
-      }));
-      applyOpened(openSession({
-        cwd: sessionCwd,
-        provider: currentSel.provider,
-        model: currentSel.model
-      }));
+      if (failure !== undefined) {
+        transcript.add(new otui.TextRenderable(r, {
+          id: `sesserr${uid++}`,
+          content: otui.t`${otui.red(failure instanceof Error ? failure.message : String(failure))}`,
+          marginTop: 1
+        }));
+        applyOpened(leasedOpen());
+      }
+    }
+    if (startupCancelled) {
+      r.off("theme_mode", onThemeMode);
+      r.destroy();
+      await done;
+      return true;
     }
     bindSlateToLiveSession();
     if (history.length === 0) {
       removeSplash = mountEmptyTranscriptSplash(otui, r, transcript);
     }
+    if (viewedReadOnly) {
+      removeSplash?.();
+      removeSplash = undefined;
+    }
     refreshWorkspaceSidebar();
     refreshReviewSidebar();
     const paintSessionHeader = () => {
@@ -100898,7 +101864,19 @@ async function launchTuiAgentShell(opts) {
       const cx = liveSession.summary.compactCount > 0 ? ` \xB7 c\xD7${liveSession.summary.compactCount}` : "";
       chrome.setTitle(`keryx \xB7 ${title} \xB7 ${sid}${cx} \xB7 ${label}`);
     };
+    sessionLease.onLost((message) => {
+      detachSlateSession(slateSession);
+      slateSession = undefined;
+      if (sessionPersistTimer !== undefined) {
+        clearTimeout(sessionPersistTimer);
+        sessionPersistTimer = undefined;
+      }
+      io.onSystem?.(message);
+    });
     const saveSession = () => {
+      if (!sessionLease.canPersist()) {
+        return;
+      }
       liveSession = persistHistory(liveSession, history, {
         archive,
         provider: currentSel.provider,
@@ -100951,12 +101929,17 @@ async function launchTuiAgentShell(opts) {
       usage.resetUsage();
     };
     const startNewSession = (note) => {
+      let opened;
+      try {
+        opened = leasedOpen();
+      } catch (cause) {
+        io.onSystem?.(`Could not start a new session: ${cause instanceof Error ? cause.message : String(cause)}
+Staying in the current session.
+`);
+        return false;
+      }
       resetSessionSurface();
-      liveSession = createSession({
-        cwd: sessionCwd,
-        provider: currentSel.provider,
-        model: currentSel.model
-      });
+      liveSession = opened.handle;
       history = [];
       archive = [];
       nextArchiveIndex = 0;
@@ -100965,6 +101948,7 @@ async function launchTuiAgentShell(opts) {
         io.onSystem?.(`${note}
 `);
       }
+      return true;
     };
     const resumeSessionInteractive = async () => {
       const found = await pickRecentSession();
@@ -100973,15 +101957,12 @@ async function launchTuiAgentShell(opts) {
       }
       let opened;
       try {
-        opened = openSession({
-          cwd: sessionCwd,
-          resumeId: found.id,
-          provider: currentSel.provider,
-          model: currentSel.model
-        });
+        opened = leasedOpen({ resumeId: found.id });
       } catch (cause) {
+        const hint = cause instanceof SessionLeasedError ? `To continue it in this shell, start one with: keryx shell -r ${shortSessionId(found.id)} --fork
+` : "";
         io.onSystem?.(`Could not resume ${shortSessionId(found.id)}: ${cause instanceof Error ? cause.message : String(cause)}
-Staying in the current session.
+` + hint + `Staying in the current session.
 `);
         return;
       }
@@ -101049,7 +102030,7 @@ Staying in the current session.
     };
     const showWorkspace = () => {
       (async () => {
-        const dir = slateSession?.dir;
+        const dir = liveSlateSession()?.dir;
         const workspaceId = dir !== undefined ? (await readSlate(dir).catch(() => {
           return;
         }))?.workspaceId : undefined;
@@ -101268,7 +102249,7 @@ Staying in the current session.
     };
     const switchTo = async (ns) => {
       currentSel = ns;
-      deps = { ...await opts.makeAgentDeps(ns, () => slateSession), onContextCompaction };
+      deps = { ...await opts.makeAgentDeps(ns, liveSlateSession), onContextCompaction };
       liveDeps = deps;
       saveShellConfig(ns.baseUrl === undefined ? { provider: ns.provider, model: ns.model } : { provider: ns.provider, model: ns.model, baseUrl: ns.baseUrl });
       updateModelLabels();
@@ -101556,7 +102537,7 @@ Staying in the current session.
           });
           let answer = "";
           try {
-            const base = await opts.makeAgentDeps(currentSel, () => slateSession);
+            const base = await opts.makeAgentDeps(currentSel, liveSlateSession);
             const tools = base.tools.filter((t) => t.definition.risk === "read" && !SIDE_WORKER_DENIED_TOOL_NAMES.has(t.definition.name));
             const sideDeps = {
               ...base,
@@ -101673,6 +102654,7 @@ Staying in the current session.
               await closeSlateSession(slateSession, mintTimestampAttemptId);
               await deps.sweepBackgroundJobs?.();
               jobs.removeAll();
+              sessionLease.release();
               r.off("theme_mode", onThemeMode);
               r.destroy();
             })();
@@ -101861,6 +102843,7 @@ Staying in the current session.
             await closeSlateSession(slateSession, mintTimestampAttemptId);
             await deps.sweepBackgroundJobs?.();
             jobs.removeAll();
+            sessionLease.release();
             r.off("theme_mode", onThemeMode);
             r.destroy();
           })();
@@ -101885,7 +102868,9 @@ Staying in the current session.
         if (command.name === "/clear" || command.name === "/new") {
           (async () => {
             await closeSlateSession(slateSession, mintTimestampAttemptId);
-            startNewSession();
+            if (!startNewSession()) {
+              return;
+            }
             bindSlateToLiveSession();
             refreshWorkspaceSidebar();
             refreshReviewSidebar();
@@ -101916,6 +102901,10 @@ Staying in the current session.
           return;
         }
         if (command.name === "/compact") {
+          if (!sessionLease.canPersist()) {
+            io.onSystem?.(LOST_LEASE_COMPACT_REFUSAL);
+            return;
+          }
           const focus = line.trim().split(/\s+/).slice(1).join(" ").trim();
           const packed = compactSession(liveSession, history, archive, {
             keepLastUserTurns: 3,
@@ -102450,6 +103439,7 @@ ${tail}`,
   } catch {
     return false;
   } finally {
+    sessionLease.release();
     await herdr.release();
     try {
       renderer?.destroy();
@@ -102850,6 +103840,7 @@ init_patch_risk();
 init_permission_mode();
 init_agent();
 init_slate_lifecycle();
+init_slate_lifecycle();
 function reportMcpProblems(runtime) {
   for (const problem of runtime.problems()) {
     console.error(`keryx mcp: ${problem.file} ${problem.message}`);
@@ -102896,6 +103887,132 @@ function readlineAgentHelpText() {
 ` + renderCommandHelp("agent", READLINE_AGENT_COMMANDS) + `Sessions are per-project: keryx shell -c | -r [id] | keryx sessions list
 `;
 }
+function bareResumeTarget(cwd, emit) {
+  const pick = latestUnleasedSession(cwd);
+  if (pick.skipped !== undefined) {
+    emit(describeSkippedSession(pick.skipped));
+  }
+  return pick.summary?.id;
+}
+function leasedOpenOptions(session, cwd, provider, model) {
+  return {
+    cwd,
+    ...session?.continueLast === true ? { continueLast: true } : {},
+    ...session?.resumeId !== undefined ? { resumeId: session.resumeId } : {},
+    ...session?.fork === true ? { fork: true } : {},
+    ...session?.takeOver === true ? { takeOver: true } : {},
+    provider,
+    model
+  };
+}
+function openFreshLeasedSession(open, cwd, provider, model) {
+  try {
+    const opened = open({ cwd, provider, model });
+    return { handle: opened.handle, lease: opened.lease };
+  } catch {
+    return;
+  }
+}
+async function resolveLeasedChoice(io, error) {
+  const rows = leasedChoiceRows(error);
+  io.write(`${describeLeasedSession(error)}
+` + rows.map((row, index) => `  ${index + 1}) ${row.label}
+`).join(""));
+  for (;; ) {
+    io.write(`Choose [1-${rows.length}, default 1]: `);
+    const line = await io.readLine();
+    if (line === undefined) {
+      io.write(`
+`);
+      return "cancel";
+    }
+    const answer = line.trim().toLowerCase();
+    if (answer.length === 0) {
+      return "fork";
+    }
+    const byNumber = /^\d+$/.test(answer) ? rows[Number(answer) - 1] : undefined;
+    const byName = rows.find((row) => row.choice === answer || row.choice.replace("-", " ") === answer || row.choice.replace("-", "") === answer);
+    const picked = byNumber ?? byName;
+    if (picked !== undefined) {
+      return picked.choice;
+    }
+    io.write(`Not one of the choices: ${line.trim()}
+`);
+  }
+}
+async function runWithLeaseChoice(session, run, runtime) {
+  let current = session;
+  for (;; ) {
+    try {
+      await run(current);
+      return;
+    } catch (error) {
+      if (!(error instanceof SessionLeasedError)) {
+        throw error;
+      }
+      if (!runtime.isTty) {
+        runtime.writeError(`${error.message}
+`);
+        return 1;
+      }
+      const choice = await resolveLeasedChoice(runtime.io, error);
+      const base = {
+        cwd: current.cwd,
+        ...current.enabled !== undefined ? { enabled: current.enabled } : {},
+        ...current.leaseBox !== undefined ? { leaseBox: current.leaseBox } : {},
+        ...current.openLeased !== undefined ? { openLeased: current.openLeased } : {}
+      };
+      if (choice === "cancel") {
+        return 0;
+      }
+      if (choice === "view") {
+        try {
+          const render = runtime.exportSession ?? ((cwd, id) => exportSessionMarkdown(cwd, id));
+          runtime.io.write(`${render(current.cwd, error.summary.id)}
+`);
+        } catch (cause) {
+          runtime.io.write(`Could not render the session: ${cause instanceof Error ? cause.message : String(cause)}
+`);
+        }
+        current = base;
+      } else if (choice === "fork") {
+        current = { ...base, resumeId: error.summary.id, fork: true };
+      } else {
+        current = { ...base, resumeId: error.summary.id, takeOver: true };
+      }
+    }
+  }
+}
+async function runLeasedChatShell(io, deps, run = runShell, notes = []) {
+  const system = (text) => {
+    if (io.onSystem !== undefined) {
+      io.onSystem(text);
+    } else {
+      io.write(text);
+    }
+  };
+  for (const note of notes) {
+    system(note);
+  }
+  if (deps.session === undefined) {
+    await run(io, deps);
+    return;
+  }
+  let iterator;
+  const runtime = {
+    isTty: true,
+    io: {
+      write: system,
+      readLine: async () => {
+        iterator ??= io.lines[Symbol.asyncIterator]();
+        const next = await iterator.next();
+        return next.done === true ? undefined : next.value;
+      }
+    },
+    writeError: system
+  };
+  return runWithLeaseChoice(deps.session, (session) => run(io, { ...deps, session }), runtime);
+}
 async function runShell(io, deps) {
   let providerName = deps.initial.provider;
   let modelName = deps.initial.model;
@@ -102914,17 +104031,22 @@ async function runShell(io, deps) {
   let live;
   let history = [];
   let archive = [];
+  let lease;
+  const leaseWatch = watchLeaseLoss((message) => system(message));
+  const holdLease = (next) => {
+    lease = next;
+    leaseWatch.track(next);
+    if (deps.session?.leaseBox !== undefined)
+      deps.session.leaseBox.current = next;
+  };
+  const openLeased = deps.session?.openLeased ?? openLeasedSession;
   if (sessionsOn) {
     try {
-      const resumeId = deps.session?.resumeId;
-      if (resumeId === undefined && deps.session?.continueLast !== true) {}
-      const opened = openSession({
-        cwd: sessionCwd,
-        ...deps.session?.continueLast === true ? { continueLast: true } : {},
-        ...resumeId !== undefined ? { resumeId } : {},
-        provider: providerName,
-        model: modelName
-      });
+      const opened = openLeased(leasedOpenOptions(deps.session, sessionCwd, providerName, modelName));
+      holdLease(opened.lease);
+      if (opened.skipped !== undefined) {
+        system(describeSkippedSession(opened.skipped));
+      }
       live = opened.handle;
       history = opened.history;
       archive = opened.archive.length > 0 ? [...opened.archive] : [...opened.history];
@@ -102937,7 +104059,12 @@ async function runShell(io, deps) {
 `);
       }
     } catch (cause) {
-      live = createSession({ cwd: sessionCwd, provider: providerName, model: modelName });
+      if (cause instanceof SessionLeasedError) {
+        throw cause;
+      }
+      const fresh = openFreshLeasedSession(openLeased, sessionCwd, providerName, modelName);
+      holdLease(fresh?.lease);
+      live = fresh?.handle ?? createSession({ cwd: sessionCwd, provider: providerName, model: modelName });
       history = [];
       archive = [];
       system(`${cause instanceof Error ? cause.message : String(cause)}
@@ -102945,8 +104072,12 @@ Starting a new session.
 `);
     }
   }
+  const releaseLease = () => {
+    releaseSessionLease(lease);
+    holdLease(undefined);
+  };
   const save = () => {
-    if (live === undefined) {
+    if (live === undefined || !leaseWatch.canPersist()) {
       return;
     }
     try {
@@ -102973,6 +104104,7 @@ Starting a new session.
       const command = parts[0] ?? "";
       const argument = parts.slice(1).join(" ");
       if (command === "/exit" || command === "/quit") {
+        releaseLease();
         return;
       }
       if (command === "/help") {
@@ -103032,7 +104164,16 @@ ${formatThemeList(getThemeId())}`);
       }
       if (command === "/clear" || command === "/new") {
         if (sessionsOn) {
-          live = createSession({ cwd: sessionCwd, provider: providerName, model: modelName });
+          try {
+            const next = switchLeasedSession(lease, () => openLeased({ cwd: sessionCwd, provider: providerName, model: modelName }));
+            holdLease(next.lease);
+            live = next.handle;
+          } catch (cause) {
+            system(`${cause instanceof Error ? cause.message : String(cause)}
+Kept the current session.
+`);
+            continue;
+          }
           history = [];
           archive = [];
           system(`New session ${shortSessionId(live.summary.id)} (previous kept on disk)
@@ -103048,6 +104189,10 @@ ${formatThemeList(getThemeId())}`);
 `);
           continue;
         }
+        if (!leaseWatch.canPersist()) {
+          system(LOST_LEASE_COMPACT_REFUSAL);
+          continue;
+        }
         const focus = argument.trim();
         const packed = compactSession(live, history, archive, {
           keepLastUserTurns: 3,
@@ -103183,6 +104328,7 @@ ${formatThemeList(getThemeId())}`);
 
 `);
   }
+  releaseLease();
 }
 function realMakeProvider(write) {
   return (name, model, baseUrl) => {
@@ -103799,7 +104945,7 @@ ${text.trim()}`;
   deps = {
     ...deps,
     onContextCompaction: (r) => {
-      if (live === undefined) {
+      if (live === undefined || !leaseWatch.canPersist()) {
         return;
       }
       const persisted = persistCompacted(live, r.context, archive, {
@@ -103812,17 +104958,44 @@ ${text.trim()}`;
 `);
     }
   };
+  let lease;
+  const leaseWatch = watchLeaseLoss((message) => {
+    detachSlateSession(slateSession);
+    slateSession = undefined;
+    slateSessionBox.current = undefined;
+    agentIo.onSystem?.(message);
+  });
+  gateBoxByLease(slateSessionBox, () => leaseWatch.canPersist());
+  const holdLease = (next) => {
+    lease = next;
+    leaseWatch.track(next);
+    if (sessionOpts?.leaseBox !== undefined)
+      sessionOpts.leaseBox.current = next;
+  };
+  const openLeased = sessionOpts?.openLeased ?? openLeasedSession;
+  const switchNewSession = () => {
+    try {
+      const next = switchLeasedSession(lease, () => openLeased({ cwd: sessionCwd, provider: deps.providerId, model: deps.modelId }));
+      holdLease(next.lease);
+      return next.handle;
+    } catch (cause) {
+      agentIo.onSystem?.(`${cause instanceof Error ? cause.message : String(cause)}
+Kept the current session.
+`);
+      return false;
+    }
+  };
+  const releaseLease = () => {
+    releaseSessionLease(lease);
+    holdLease(undefined);
+  };
   if (sessionsOn) {
     try {
-      const resumeId = sessionOpts?.resumeId;
-      if (resumeId === undefined && sessionOpts?.continueLast !== true && sessionOpts !== undefined) {}
-      const opened = openSession({
-        cwd: sessionCwd,
-        ...sessionOpts?.continueLast === true ? { continueLast: true } : {},
-        ...resumeId !== undefined ? { resumeId } : {},
-        provider: deps.providerId,
-        model: deps.modelId
-      });
+      const opened = openLeased(leasedOpenOptions(sessionOpts, sessionCwd, deps.providerId, deps.modelId));
+      holdLease(opened.lease);
+      if (opened.skipped !== undefined) {
+        agentIo.onSystem?.(describeSkippedSession(opened.skipped));
+      }
       live = opened.handle;
       history = opened.history;
       archive = opened.archive.length > 0 ? [...opened.archive] : [...opened.history];
@@ -103835,7 +105008,12 @@ ${text.trim()}`;
 `);
       }
     } catch (cause) {
-      live = createSession({
+      if (cause instanceof SessionLeasedError) {
+        throw cause;
+      }
+      const fresh = openFreshLeasedSession(openLeased, sessionCwd, deps.providerId, deps.modelId);
+      holdLease(fresh?.lease);
+      live = fresh?.handle ?? createSession({
         cwd: sessionCwd,
         provider: deps.providerId,
         model: deps.modelId
@@ -103851,7 +105029,7 @@ New session ${shortSessionId(live.summary.id)}.
   slateSession = live !== undefined ? { dir: live.dir, cwd: sessionCwd, opened: false } : undefined;
   slateSessionBox.current = slateSession;
   const save = () => {
-    if (live === undefined) {
+    if (live === undefined || !leaseWatch.canPersist()) {
       return;
     }
     try {
@@ -103927,6 +105105,7 @@ ${GUTTER}${turnSeparator()}
     if (line === undefined) {
       await closeSlateSession(slateSession, mintTimestampAttemptId);
       await deps.sweepBackgroundJobs?.();
+      releaseLease();
       return;
     }
     rich.safeBoundary?.();
@@ -103937,6 +105116,7 @@ ${GUTTER}${turnSeparator()}
       if (command === "/exit" || command === "/quit") {
         await closeSlateSession(slateSession, mintTimestampAttemptId);
         await deps.sweepBackgroundJobs?.();
+        releaseLease();
         return;
       }
       if (command === "/help") {
@@ -103981,13 +105161,14 @@ ${GUTTER}${turnSeparator()}
 `);
         }
       } else if (command === "/new" || command === "/clear") {
+        const nextLive = sessionsOn ? switchNewSession() : undefined;
+        if (nextLive === false) {
+          rich.printPrompt();
+          continue;
+        }
         await closeSlateSession(slateSession, mintTimestampAttemptId);
-        if (sessionsOn) {
-          live = createSession({
-            cwd: sessionCwd,
-            provider: deps.providerId,
-            model: deps.modelId
-          });
+        if (nextLive !== undefined) {
+          live = nextLive;
           history = [];
           archive = [];
           nextArchiveIndex = 0;
@@ -104005,6 +105186,8 @@ ${GUTTER}${turnSeparator()}
         if (live === undefined) {
           agentIo.onSystem?.(`No persistent session.
 `);
+        } else if (!leaseWatch.canPersist()) {
+          agentIo.onSystem?.(LOST_LEASE_COMPACT_REFUSAL);
         } else {
           const packed = compactSession(live, history, archive, {
             keepLastUserTurns: 3,
@@ -104291,6 +105474,14 @@ async function resolveTuiStartup(opts) {
     appliedKeys
   };
 }
+
+class ShellFlagError extends Error {
+  exitCode = 2;
+  constructor(message) {
+    super(`${message}. See keryx shell --help.`);
+    this.name = "ShellFlagError";
+  }
+}
 function parseShellCliFlags(args) {
   if (args.includes("--help") || args.includes("-h")) {
     return { help: true, wantTui: true };
@@ -104313,6 +105504,8 @@ function parseShellCliFlags(args) {
   let continueLast;
   let resumeId;
   let resumePick;
+  let fork;
+  let takeOver;
   let permissionModeFlag;
   let denyTools;
   let printPromptArg;
@@ -104349,6 +105542,10 @@ function parseShellCliFlags(args) {
       } else {
         resumePick = true;
       }
+    } else if (arg === "--fork") {
+      fork = true;
+    } else if (arg === "--take-over") {
+      takeOver = true;
     } else if (arg === "--permission-mode") {
       const next = valueAfter(i++);
       if (!isPermissionMode(next))
@@ -104384,6 +105581,18 @@ function parseShellCliFlags(args) {
   if (continueLast && (resumeId !== undefined || resumePick)) {
     invalid("--continue and --resume cannot be combined");
   }
+  const leaseFlag = fork === true ? "--fork" : takeOver === true ? "--take-over" : undefined;
+  if (leaseFlag !== undefined) {
+    if (continueLast === true) {
+      throw new ShellFlagError(`${leaseFlag} cannot be combined with --continue; use -r <id> ${leaseFlag}`);
+    }
+    if (fork === true && takeOver === true) {
+      throw new ShellFlagError("--fork and --take-over cannot be combined; choose one");
+    }
+    if (resumeId === undefined) {
+      throw new ShellFlagError(`${leaseFlag} needs an explicit session id; use -r <id> ${leaseFlag}`);
+    }
+  }
   if (printPromptArg !== undefined && modeFlag === false) {
     invalid("--print is agent-mode only and cannot be combined with --chat");
   }
@@ -104396,6 +105605,8 @@ function parseShellCliFlags(args) {
     ...continueLast === true ? { continueLast: true } : {},
     ...resumeId !== undefined ? { resumeId } : {},
     ...resumePick === true ? { resumePick: true } : {},
+    ...fork === true ? { fork: true } : {},
+    ...takeOver === true ? { takeOver: true } : {},
     ...permissionModeFlag !== undefined ? { permissionModeFlag } : {},
     ...denyTools !== undefined ? { denyTools } : {},
     ...printPromptArg !== undefined ? { printPrompt: printPromptArg } : {},
@@ -104429,8 +105640,10 @@ async function shellCommand(args, runtime = {}) {
   --base-url <url>              Override the provider endpoint
   --agent | --chat              Choose agent (default) or chat mode
   --tui | --no-tui              Prefer TUI (default) or readline; last flag wins
-  --continue, -c                Continue the latest project session
+  --continue, -c                Continue the most recent session no other shell has open
   --resume, -r [id-or-title]     Resume a session, or open the session picker
+  --fork                        With -r <id>: continue in a fork of that session
+  --take-over                   With -r <id>: take the session from a stale holder
   --permission-mode <mode>      Agent permissions: ask, trust or auto
   --deny-tools <a,b>            Withhold these tools from the session entirely
   --ask | --trust | --auto       Permission shortcuts; last flag wins
@@ -104441,7 +105654,10 @@ async function shellCommand(args, runtime = {}) {
                                 that re-arms terminal input if it stops; see debug/latest.txt
 
 Session continuation and resume are mutually exclusive. Permission flags
-are ignored in chat mode. Without a TTY, resume without an ID uses the latest session.
+are ignored in chat mode. Without a TTY, resume without an ID uses the latest
+session no other shell has open. A session open in another shell is refused;
+--fork and --take-over (stale holders only) need an explicit -r <id> and
+cannot be combined with each other or with --continue.
 
 A shell that stops reacting to keys can be recovered from another terminal
 with: kill -USR2 <keryx pid>
@@ -104481,6 +105697,10 @@ Example: keryx shell --provider ollama --model llama3.1:latest`);
   const modelArg = flags.modelArg;
   let baseUrl = flags.baseUrl;
   let modeFlag = flags.modeFlag;
+  const leaseFlagOpts = {
+    ...flags.fork === true ? { fork: true } : {},
+    ...flags.takeOver === true ? { takeOver: true } : {}
+  };
   {
     await Promise.resolve().then(() => init_login());
     const oauthFetch = (input, init) => globalThis.fetch(input, init);
@@ -104580,7 +105800,7 @@ Example: keryx shell --provider ollama --model llama3.1:latest`);
           sessionOverride: reasoningSessionOverride,
           globalEffort: loadShellConfig(runtime.cacheDir).reasoningEffort
         }),
-        idSeq: () => randomUUID29(),
+        idSeq: () => randomUUID30(),
         askUser: invokeAskUserHost,
         sweepBackgroundJobs: () => jobRegistry.sweepAll(),
         jobRegistry,
@@ -104611,29 +105831,40 @@ Example: keryx shell --provider ollama --model llama3.1:latest`);
     });
     const tuiInitial = startup.initial;
     const tuiDetected = startup.detected;
+    const chatLeaseBox = { current: undefined };
     try {
       if (surface === "tui-chat") {
         const chatFactory = realMakeProvider(() => {});
         let chatResumeId = flags.resumeId;
+        const chatNotes = [];
         if (flags.resumePick === true && chatResumeId === undefined) {
-          chatResumeId = latestSession(cwd)?.id;
+          chatResumeId = bareResumeTarget(cwd, (text) => {
+            chatNotes.push(text);
+          });
         }
         if (await (runtime.launchChat ?? launchTuiChatShell)({
           detected: tuiDetected,
           redetect,
           ...tuiInitial !== undefined ? { initial: tuiInitial } : {},
-          runShell,
+          runShell: async (chatIo, chatDeps) => {
+            const code = await runLeasedChatShell(chatIo, chatDeps, runShell, chatNotes.splice(0));
+            if (code !== undefined) {
+              process.exitCode = code;
+            }
+          },
           makeShellDeps: (sel) => {
             const resolvedModelParams = resolveProviderModelParamsByName(sel.provider, loadShellConfig(runtime.cacheDir), runtime.cacheDir);
             return {
               makeProvider: chatFactory,
               clock: () => new Date().toISOString(),
-              idSeq: () => randomUUID29(),
+              idSeq: () => randomUUID30(),
               initial: Object.keys(resolvedModelParams).length > 0 ? { ...sel, modelParams: resolvedModelParams } : sel,
               session: {
                 cwd,
                 ...flags.continueLast === true ? { continueLast: true } : {},
-                ...chatResumeId !== undefined ? { resumeId: chatResumeId } : {}
+                ...chatResumeId !== undefined ? { resumeId: chatResumeId } : {},
+                ...leaseFlagOpts,
+                leaseBox: chatLeaseBox
               }
             };
           },
@@ -104653,7 +105884,8 @@ Example: keryx shell --provider ollama --model llama3.1:latest`);
           cwd,
           ...flags.continueLast === true ? { continueLast: true } : {},
           ...flags.resumeId !== undefined ? { resumeId: flags.resumeId } : {},
-          ...flags.resumePick === true ? { pickOnStart: true } : {}
+          ...flags.resumePick === true ? { pickOnStart: true } : {},
+          ...leaseFlagOpts
         },
         ...flags.permissionModeFlag !== undefined ? { initialPermissionMode: flags.permissionModeFlag } : {},
         versionCheck
@@ -104661,6 +105893,8 @@ Example: keryx shell --provider ollama --model llama3.1:latest`);
         return;
       }
     } finally {
+      releaseSessionLease(chatLeaseBox.current);
+      chatLeaseBox.current = undefined;
       if (mcpRuntime !== undefined) {
         await mcpRuntime.close();
         reportMcpProblems(mcpRuntime);
@@ -104669,7 +105903,10 @@ Example: keryx shell --provider ollama --model llama3.1:latest`);
   }
   const rl = readline2.createInterface({ input: process.stdin });
   let readlineMcp;
+  const leaseBox = { current: undefined };
   const closeAndExit = (code) => () => {
+    releaseSessionLease(leaseBox.current);
+    leaseBox.current = undefined;
     (async () => {
       try {
         await readlineMcp?.close();
@@ -104688,6 +105925,27 @@ Example: keryx shell --provider ollama --model llama3.1:latest`);
     }
   };
   const { io, emitSystem, printHeader, printPrompt, destroy } = createRichIo(sharedLines, versionCheck);
+  const leaseChoiceRuntime = {
+    isTty: process.stdin.isTTY === true && oneShotPrompt === undefined,
+    io: {
+      write: (text) => {
+        io.write(text);
+      },
+      readLine: async () => {
+        const next = await lineIterator.next();
+        return next.done === true ? undefined : next.value;
+      }
+    },
+    writeError: (text) => {
+      process.stderr.write(text);
+    }
+  };
+  const bareResumeId = () => bareResumeTarget(process.cwd(), emitSystem);
+  const finishLeased = (code) => {
+    if (code !== undefined) {
+      process.exitCode = code;
+    }
+  };
   let provider;
   let model;
   try {
@@ -104727,7 +105985,7 @@ Example: keryx shell --provider ollama --model llama3.1:latest`);
     const deps = {
       makeProvider: baseFactory,
       clock: () => new Date().toISOString(),
-      idSeq: () => randomUUID29(),
+      idSeq: () => randomUUID30(),
       initial: {
         provider,
         model,
@@ -104799,7 +106057,7 @@ Example: keryx shell --provider ollama --model llama3.1:latest`);
           sessionOverride: reasoningSessionOverride,
           globalEffort: loadShellConfig(runtime.cacheDir).reasoningEffort
         }),
-        idSeq: () => randomUUID29(),
+        idSeq: () => randomUUID30(),
         askUser: invokeAskUserHost,
         sweepBackgroundJobs: () => jobRegistry.sweepAll(),
         ...resetSubagentBudget !== undefined ? { resetSubagentBudget } : {},
@@ -104815,34 +106073,38 @@ Example: keryx shell --provider ollama --model llama3.1:latest`);
       };
       let resumeId = flags.resumeId;
       if (flags.resumePick === true && resumeId === undefined) {
-        resumeId = latestSession(process.cwd())?.id;
+        resumeId = bareResumeId();
       }
       const events = flags.eventsFile === undefined ? undefined : createFileEventSink(flags.eventsFile, (message) => {
         emitSystem(`${message}
 `);
       }, flags.eventsMaxField);
+      const runRepl = async (session) => {
+        await runAgentRepl(sharedLines, { printPrompt, safeBoundary: io.onSafeBoundary }, agentDeps, metaprojectPort, session, flags.permissionModeFlag, slateSessionBox, events, runtime.cacheDir);
+      };
       try {
-        await runAgentRepl(sharedLines, { printPrompt, safeBoundary: io.onSafeBoundary }, agentDeps, metaprojectPort, {
+        finishLeased(await runWithLeaseChoice({
           cwd: process.cwd(),
           ...flags.continueLast === true ? { continueLast: true } : {},
-          ...resumeId !== undefined ? { resumeId } : {}
-        }, flags.permissionModeFlag, slateSessionBox, events, runtime.cacheDir);
+          ...resumeId !== undefined ? { resumeId } : {},
+          ...leaseFlagOpts,
+          leaseBox
+        }, runRepl, leaseChoiceRuntime));
       } finally {
         await mcpRuntime.close();
       }
     } else {
       let resumeId = flags.resumeId;
       if (flags.resumePick === true && resumeId === undefined) {
-        resumeId = latestSession(process.cwd())?.id;
+        resumeId = bareResumeId();
       }
-      await runShell(io, {
-        ...deps,
-        session: {
-          cwd: process.cwd(),
-          ...flags.continueLast === true ? { continueLast: true } : {},
-          ...resumeId !== undefined ? { resumeId } : {}
-        }
-      });
+      finishLeased(await runWithLeaseChoice({
+        cwd: process.cwd(),
+        ...flags.continueLast === true ? { continueLast: true } : {},
+        ...resumeId !== undefined ? { resumeId } : {},
+        ...leaseFlagOpts,
+        leaseBox
+      }, (session) => runShell(io, { ...deps, session }), leaseChoiceRuntime));
     }
   } finally {
     try {
@@ -104863,12 +106125,13 @@ async function sessionsCommand(args) {
   const cwd = process.cwd();
   if (sub === "list") {
     const asJson = args.includes("--json");
-    const rows = listSessions(cwd);
+    const listed = listSessions(cwd).map((s) => ({ summary: s, lease: leaseColumn(cwd, s.id) }));
     if (asJson) {
+      const rows = listed.map(({ summary, lease }) => ({ ...summary, live: lease === "?" ? null : lease }));
       console.log(JSON.stringify({ schemaVersion: 1, project: resolveProjectRoot2(cwd), sessions: rows }, null, 2));
       return;
     }
-    if (rows.length === 0) {
+    if (listed.length === 0) {
       console.log(`No sessions for project ${resolveProjectRoot2(cwd)}`);
       console.log(`(store: ${projectSessionsDir(cwd)})`);
       return;
@@ -104876,10 +106139,10 @@ async function sessionsCommand(args) {
     console.log(`Project: ${resolveProjectRoot2(cwd)}`);
     console.log(`Store:   ${projectSessionsDir(cwd)}`);
     console.log("");
-    console.log(pad("ID", 10) + pad("UPDATED", 22) + pad("MSGS", 6) + pad("MODEL", 24) + "TITLE");
-    for (const s of rows) {
+    console.log(pad("ID", 10) + pad("UPDATED", 22) + pad("MSGS", 6) + pad("LIVE", 7) + pad("MODEL", 24) + "TITLE");
+    for (const { summary: s, lease } of listed) {
       const model = s.provider !== undefined && s.model !== undefined ? `${s.provider}/${s.model}` : s.model ?? "-";
-      console.log(pad(shortSessionId(s.id), 10) + pad(s.updatedAt.slice(0, 19).replace("T", " "), 22) + pad(String(s.messageCount), 6) + pad(clip8(model, 22), 24) + (s.parentSessionId !== undefined ? `\u21B3 ${s.title}` : s.title));
+      console.log(pad(shortSessionId(s.id), 10) + pad(s.updatedAt.slice(0, 19).replace("T", " "), 22) + pad(String(s.messageCount), 6) + pad(lease ?? "", 7) + pad(clip8(model, 22), 24) + (s.parentSessionId !== undefined ? `\u21B3 ${s.title}` : s.title));
     }
     console.log("");
     console.log("Resume: keryx shell -r <id>   Continue last: keryx shell -c");
@@ -104966,6 +106229,19 @@ async function sessionsCommand(args) {
   printHelp17();
   process.exitCode = 1;
 }
+function leaseColumn(cwd, sessionId) {
+  let state;
+  try {
+    state = sessionLeaseState(cwd, sessionId).state;
+  } catch {
+    return "?";
+  }
+  if (state === "live" || state === "mine")
+    return "live";
+  if (state === "stale")
+    return "stale";
+  return null;
+}
 function pad(s, n) {
   return s.length >= n ? `${s.slice(0, n - 1)} ` : s + " ".repeat(n - s.length);
 }
@@ -104983,9 +106259,16 @@ Usage:
   keryx sessions export <id>       Export transcript as Markdown
   keryx sessions path              Print the on-disk sessions directory
 
+List columns: ID, UPDATED, MSGS, LIVE, MODEL, TITLE. LIVE is "live" when a
+shell has the session open, "stale" when its holder stopped heartbeating, and
+blank when no shell holds it. In --json every row carries "live": "live" |
+"stale" | null.
+
 Shell:
-  keryx shell -c                   Continue last session in this project
+  keryx shell -c                   Continue the last session no other shell has open
   keryx shell -r [id]              Resume session (id / short id / title)
+  keryx shell -r <id> --fork       Fork a session another shell has open
+  keryx shell -r <id> --take-over  Take over a session whose holder is stale
 `);
 }
 
@@ -104993,7 +106276,7 @@ Shell:
 init_fs();
 import { readFile as readFile99 } from "fs/promises";
 import { stdin } from "process";
-import path196 from "path";
+import path197 from "path";
 var MODULES = [
   { name: "gdgraph", flag: "--no-gdgraph", desc: "code graph, symbols, affected context", defaultEnabled: true },
   { name: "gdctx", flag: "--no-gdctx", desc: "token-aware command/read output", defaultEnabled: true },
@@ -105039,8 +106322,8 @@ async function modulesCommand(args = []) {
     return;
   }
   const wantsJson = args.includes("--json") && (sub === undefined || sub === "status" || sub === "list" || sub === "--json");
-  const metaprojectRoot = path196.join(process.cwd(), ".metaproject");
-  const manifestPath = path196.join(metaprojectRoot, "metaproject.json");
+  const metaprojectRoot = path197.join(process.cwd(), ".metaproject");
+  const manifestPath = path197.join(metaprojectRoot, "metaproject.json");
   if (!await pathExists(manifestPath)) {
     if (wantsJson) {
       console.log(JSON.stringify({ schemaVersion: 1, error: "not-initialized", modules: [] }, null, 2));
@@ -105154,26 +106437,26 @@ function printHelp18() {
 }
 
 // src/commands/serve.ts
-import { randomUUID as randomUUID32 } from "crypto";
+import { randomUUID as randomUUID33 } from "crypto";
 init_serve_config();
 
 // src/lib/serve-credential.ts
 init_config_dir();
-import { createHash as createHash44, randomBytes as randomBytes5, randomUUID as randomUUID30 } from "crypto";
+import { createHash as createHash44, randomBytes as randomBytes5, randomUUID as randomUUID31 } from "crypto";
 import {
-  chmodSync as chmodSync4,
+  chmodSync as chmodSync5,
   closeSync as closeSync4,
   existsSync as existsSync34,
   fsyncSync as fsyncSync2,
-  openSync as openSync4,
-  renameSync as renameSync4,
-  statSync as statSync7,
+  openSync as openSync5,
+  renameSync as renameSync5,
+  statSync as statSync8,
   unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync9
+  writeFileSync as writeFileSync10
 } from "fs";
-import path197 from "path";
+import path198 from "path";
 function serveCredentialPath(dir) {
-  return path197.join(keryxConfigDir(dir), "serve-credentials.json");
+  return path198.join(keryxConfigDir(dir), "serve-credentials.json");
 }
 function constantTimeEqual(a, b) {
   const width = Math.max(a.length, b.length);
@@ -105202,7 +106485,7 @@ function isGroupOrOtherAccessible(file) {
   if (process.platform === "win32") {
     return false;
   }
-  const mode = statSync7(file, { throwIfNoEntry: false })?.mode;
+  const mode = statSync8(file, { throwIfNoEntry: false })?.mode;
   return mode !== undefined && (mode & 63) !== 0;
 }
 function readServeCredential(dir) {
@@ -105243,18 +106526,18 @@ function readServeCredential(dir) {
 }
 function writeStore(store, dir) {
   const file = serveCredentialPath(dir);
-  const temp = `${file}.${randomUUID30()}.tmp`;
+  const temp = `${file}.${randomUUID31()}.tmp`;
   try {
     ensureKeryxConfigDir(dir);
-    const handle = openSync4(temp, "wx", 384);
+    const handle = openSync5(temp, "wx", 384);
     try {
-      writeFileSync9(handle, `${JSON.stringify(store, null, 2)}
+      writeFileSync10(handle, `${JSON.stringify(store, null, 2)}
 `, { encoding: "utf8" });
       fsyncSync2(handle);
     } finally {
       closeSync4(handle);
     }
-    renameSync4(temp, file);
+    renameSync5(temp, file);
     tighten2(file, 384);
     return true;
   } catch {
@@ -105269,7 +106552,7 @@ function tighten2(target, mode) {
     return;
   }
   try {
-    chmodSync4(target, mode);
+    chmodSync5(target, mode);
   } catch {}
 }
 function withServeCredentialLock(dir, fn, onWaiting) {
@@ -105283,7 +106566,7 @@ function mintRecord(now) {
   const salt = randomBytes5(32).toString("hex");
   return {
     token,
-    record: { id: randomUUID30(), algorithm: "sha256", salt, hash: hashToken(salt, token), createdAt: now }
+    record: { id: randomUUID31(), algorithm: "sha256", salt, hash: hashToken(salt, token), createdAt: now }
   };
 }
 function issueServeToken(dir, now = () => new Date().toISOString(), onWaiting) {
@@ -105406,23 +106689,23 @@ class AuthFailureThrottle {
 // src/lib/serve-turn-store.ts
 init_config_dir();
 import { createHash as createHash45 } from "crypto";
-import { existsSync as existsSync35, readdirSync as readdirSync4, rmSync as rmSync2 } from "fs";
-import path198 from "path";
+import { existsSync as existsSync35, readdirSync as readdirSync4, rmSync as rmSync3 } from "fs";
+import path199 from "path";
 var MAX_TURN_EVENTS = 1e4;
 function turnsRoot(dir) {
-  return path198.join(keryxConfigDir(dir), "turns");
+  return path199.join(keryxConfigDir(dir), "turns");
 }
 function turnDir(turnId, dir) {
-  return path198.join(turnsRoot(dir), turnId);
+  return path199.join(turnsRoot(dir), turnId);
 }
 function keyPath(project, idempotencyKey, dir) {
   const projectBytes = Buffer.byteLength(project, "utf8");
   const digest = createHash45("sha256").update(`${projectBytes}:${project}\x00${idempotencyKey}`, "utf8").digest("hex");
-  return path198.join(turnsRoot(dir), "keys", `${digest}.json`);
+  return path199.join(turnsRoot(dir), "keys", `${digest}.json`);
 }
 function legacyKeyPath(idempotencyKey, dir) {
   const digest = createHash45("sha256").update(idempotencyKey, "utf8").digest("hex");
-  return path198.join(turnsRoot(dir), "keys", `${digest}.json`);
+  return path199.join(turnsRoot(dir), "keys", `${digest}.json`);
 }
 function adoptLegacyClaim(project, idempotencyKey, dir) {
   const legacy = legacyKeyPath(idempotencyKey, dir);
@@ -105443,7 +106726,7 @@ function adoptLegacyClaim(project, idempotencyKey, dir) {
   } catch {}
   const record = turnId === undefined ? undefined : readTurnRecord(turnId, dir);
   if (turnId === undefined || record === undefined || !record.ok) {
-    rmSync2(legacy, { force: true });
+    rmSync3(legacy, { force: true });
     return null;
   }
   if (record.value.project !== project) {
@@ -105451,7 +106734,7 @@ function adoptLegacyClaim(project, idempotencyKey, dir) {
   }
   writeOwnerOnlyFile(scoped, `${JSON.stringify({ turnId }, null, 2)}
 `);
-  rmSync2(legacy, { force: true });
+  rmSync3(legacy, { force: true });
   return turnId;
 }
 function isServerFault(reason) {
@@ -105486,7 +106769,7 @@ function ensureTurnDir(turnId, dir) {
 }
 function createTurnRecord(record, dir) {
   ensureTurnDir(record.turnId, dir);
-  writeOwnerOnlyFile(path198.join(turnDir(record.turnId, dir), "turn.json"), `${JSON.stringify(record, null, 2)}
+  writeOwnerOnlyFile(path199.join(turnDir(record.turnId, dir), "turn.json"), `${JSON.stringify(record, null, 2)}
 `);
 }
 function appendTurnEvent(event, dir, opts) {
@@ -105495,12 +106778,12 @@ function appendTurnEvent(event, dir, opts) {
   }
   const line = JSON.stringify(event);
   try {
-    appendOwnerOnlyLine(path198.join(turnDir(event.turnId, dir), "events.jsonl"), line);
+    appendOwnerOnlyLine(path199.join(turnDir(event.turnId, dir), "events.jsonl"), line);
   } catch (error) {
     if (error?.code !== "ENOENT") {
       throw error;
     }
-    appendOwnerOnlyLine(path198.join(ensureTurnDir(event.turnId, dir), "events.jsonl"), line);
+    appendOwnerOnlyLine(path199.join(ensureTurnDir(event.turnId, dir), "events.jsonl"), line);
   }
   return true;
 }
@@ -105508,7 +106791,7 @@ function readTurnEvents(turnId, after = -1, dir) {
   if (!isTurnId(turnId)) {
     return { ok: false, reason: "not-a-turn-id" };
   }
-  const read = readTurnFile(path198.join(turnDir(turnId, dir), "events.jsonl"));
+  const read = readTurnFile(path199.join(turnDir(turnId, dir), "events.jsonl"));
   if (!read.ok) {
     if (isDefiniteAbsence2(read.reason)) {
       return { ok: true, value: [] };
@@ -105536,7 +106819,7 @@ function readTurnRecord(turnId, dir) {
   if (!isTurnId(turnId)) {
     return { ok: false, reason: "not-a-turn-id" };
   }
-  const read = readTurnFile(path198.join(turnDir(turnId, dir), "turn.json"));
+  const read = readTurnFile(path199.join(turnDir(turnId, dir), "turn.json"));
   if (!read.ok) {
     return { ok: false, reason: read.reason };
   }
@@ -105555,7 +106838,7 @@ function finishTurn(turnId, result, dir) {
   if (!record.ok) {
     return false;
   }
-  writeOwnerOnlyFile(path198.join(turnDir(turnId, dir), "turn.json"), `${JSON.stringify({ ...record.value, result }, null, 2)}
+  writeOwnerOnlyFile(path199.join(turnDir(turnId, dir), "turn.json"), `${JSON.stringify({ ...record.value, result }, null, 2)}
 `);
   return true;
 }
@@ -105595,13 +106878,13 @@ function releaseIdempotencyKey(project, idempotencyKey, turnId, dir) {
   } catch {
     return false;
   }
-  rmSync2(file, { force: true });
+  rmSync3(file, { force: true });
   return true;
 }
 
 // src/lib/serve-turn.ts
-import { randomUUID as randomUUID31 } from "crypto";
-import path199 from "path";
+import { randomUUID as randomUUID32 } from "crypto";
+import path200 from "path";
 init_service();
 var REMOTE_ORIGIN = "remote:http";
 var MAX_PROMPT_CHARS = 32000;
@@ -105670,9 +106953,9 @@ function isUuid(value) {
   return typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(value);
 }
 function resolveProject(declared, dir) {
-  const wanted = path199.resolve(declared);
+  const wanted = path200.resolve(declared);
   for (const entry of listProjects(dir, () => {})) {
-    if (path199.resolve(entry.path) === wanted) {
+    if (path200.resolve(entry.path) === wanted) {
       return { ok: true, project: entry.path };
     }
   }
@@ -105719,7 +107002,7 @@ async function redactOut(security, text) {
 async function runRemoteTurn(input) {
   const scanRoot = input.scanRoot;
   const security = createSecurityService(scanRoot);
-  const newId = input.newId ?? (() => randomUUID31());
+  const newId = input.newId ?? (() => randomUUID32());
   const clock = input.clock ?? (() => new Date().toISOString());
   const turnId = input.turnId ?? newId();
   const sessionId = input.request.sessionId ?? newId();
@@ -105862,7 +107145,7 @@ function outcomeOf(status, gate, unresolvedBlockerIds) {
 }
 function createSubmitTurn(deps) {
   return async (request, project) => {
-    const turnId = (deps.newId ?? (() => randomUUID31()))();
+    const turnId = (deps.newId ?? (() => randomUUID32()))();
     const scanned = await scanPrompt(deps.dir, request.prompt);
     if (scanned.rejected) {
       return { kind: "rejected" };
@@ -106550,7 +107833,7 @@ function runConfig(args) {
       return;
     }
     const credential = readServeCredential();
-    const credentialId = credential.status === "ok" ? credential.record.id : randomUUID32();
+    const credentialId = credential.status === "ok" ? credential.record.id : randomUUID33();
     const config = defaultServeConfig(credentialId, {
       address: parsed.parsed.values.get("--bind") ?? DEFAULT_SERVE_BIND_ADDRESS,
       port: port ?? DEFAULT_SERVE_PORT,
@@ -106708,7 +107991,7 @@ function printHelp19() {
 import { spawn as spawn7 } from "child_process";
 import { chmod as chmod4, mkdir as mkdir63, readFile as readFile100, readdir as readdir37, writeFile as writeFile54 } from "fs/promises";
 import { access as access4, constants as constants3, existsSync as existsSync36 } from "fs";
-import path200 from "path";
+import path201 from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 init_config2();
 init_config();
@@ -106725,8 +108008,8 @@ async function updateCommand(args = []) {
     return;
   }
   const projectRoot = process.cwd();
-  const metaprojectRoot = path200.join(projectRoot, ".metaproject");
-  banner("keryx update", `Refreshing the .metaproject workspace in ${path200.basename(projectRoot)}/`);
+  const metaprojectRoot = path201.join(projectRoot, ".metaproject");
+  banner("keryx update", `Refreshing the .metaproject workspace in ${path201.basename(projectRoot)}/`);
   if (!await pathExists(metaprojectRoot)) {
     console.log(`  ${style.red(symbols.cross)} Metaproject is not initialized.`);
     console.log(`  ${style.cyan(symbols.arrow)} Run ${style.cyan("keryx init")} first.`);
@@ -106799,7 +108082,7 @@ async function updateCommand(args = []) {
   nextSteps(steps);
 }
 async function previewServiceFiles(projectRoot, options) {
-  const metaprojectRoot = path200.join(projectRoot, ".metaproject");
+  const metaprojectRoot = path201.join(projectRoot, ".metaproject");
   const manifestState = await readManifest5(metaprojectRoot);
   const manifest = manifestState.manifest;
   const enableTasks = moduleEnabled2(manifest, "tasks") || !options.noTasks;
@@ -106828,12 +108111,12 @@ async function previewServiceFiles(projectRoot, options) {
   });
 }
 async function refreshServiceFiles(projectRoot, options) {
-  const metaprojectRoot = path200.join(projectRoot, ".metaproject");
+  const metaprojectRoot = path201.join(projectRoot, ".metaproject");
   const manifestState = await readManifest5(metaprojectRoot);
   const manifest = manifestState.manifest;
   const recoveredManifest = !manifestState.exists || !manifestState.valid;
   if (manifestState.migrated) {
-    await writeFile54(path200.join(metaprojectRoot, "metaproject.json"), `${JSON.stringify(manifest, null, 2)}
+    await writeFile54(path201.join(metaprojectRoot, "metaproject.json"), `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
   }
   const enableGdgraph = moduleEnabled2(manifest, "gdgraph");
@@ -106870,9 +108153,9 @@ async function refreshServiceFiles(projectRoot, options) {
     enableSecurity,
     enableSac
   });
-  await writeTextIfChanged4(path200.join(metaprojectRoot, "core", "README.md"), renderMetaprojectCoreReadme());
-  await writeTextIfChanged4(path200.join(metaprojectRoot, "hooks", "README.md"), renderHooksReadme());
-  await writeTextIfChanged4(path200.join(metaprojectRoot, "skills", "project-rules", "README.md"), renderProjectRulesSkillReadme({ sources: ruleSources }));
+  await writeTextIfChanged4(path201.join(metaprojectRoot, "core", "README.md"), renderMetaprojectCoreReadme());
+  await writeTextIfChanged4(path201.join(metaprojectRoot, "hooks", "README.md"), renderHooksReadme());
+  await writeTextIfChanged4(path201.join(metaprojectRoot, "skills", "project-rules", "README.md"), renderProjectRulesSkillReadme({ sources: ruleSources }));
   await writeRoutingEntrypointPair(metaprojectRoot, {
     enableGdgraph,
     enableGdctx,
@@ -106895,7 +108178,7 @@ async function refreshServiceFiles(projectRoot, options) {
       }
     }
   });
-  await writeTextIfChanged4(path200.join(metaprojectRoot, "keryx-dashboard.html"), renderMetaprojectDashboardHtml({
+  await writeTextIfChanged4(path201.join(metaprojectRoot, "keryx-dashboard.html"), renderMetaprojectDashboardHtml({
     enableGdgraph,
     enableGdctx,
     enableGdwiki,
@@ -106907,7 +108190,7 @@ async function refreshServiceFiles(projectRoot, options) {
     enableSecurity,
     data: dashboardData
   }));
-  await writeTextIfMissing4(path200.join(metaprojectRoot, "README.md"), renderMetaprojectReadme({
+  await writeTextIfMissing4(path201.join(metaprojectRoot, "README.md"), renderMetaprojectReadme({
     enableGdgraph,
     enableGdctx,
     enableGdwiki,
@@ -106920,31 +108203,31 @@ async function refreshServiceFiles(projectRoot, options) {
   }));
   if (enableGdgraph) {
     await installGdgraphCoreScripts2(metaprojectRoot);
-    await writeTextIfChanged4(path200.join(metaprojectRoot, "modules", "gdgraph.md"), renderGdgraphManifest());
-    await writeTextIfChanged4(path200.join(metaprojectRoot, "core", "gdgraph", "README.md"), renderGdgraphCoreReadme());
-    await writeTextIfChanged4(path200.join(metaprojectRoot, "skills", "gdgraph", "SKILL.md"), renderGdgraphSkillReadme());
+    await writeTextIfChanged4(path201.join(metaprojectRoot, "modules", "gdgraph.md"), renderGdgraphManifest());
+    await writeTextIfChanged4(path201.join(metaprojectRoot, "core", "gdgraph", "README.md"), renderGdgraphCoreReadme());
+    await writeTextIfChanged4(path201.join(metaprojectRoot, "skills", "gdgraph", "SKILL.md"), renderGdgraphSkillReadme());
     await seedAssetsLock(metaprojectRoot);
     if (manifest.modules?.gdgraph?.hooks?.gitPostCommit) {
       await installManagedHook2(projectRoot, "post-commit", "gdgraph-post-commit", renderGdgraphPostCommitHook());
     }
   }
   if (enableGdctx) {
-    await writeTextIfMissing4(path200.join(metaprojectRoot, "gdctx.config.json"), renderGdctxConfig());
-    await writeTextIfChanged4(path200.join(metaprojectRoot, "modules", "gdctx.md"), renderGdctxManifest());
-    await writeTextIfChanged4(path200.join(metaprojectRoot, "core", "gdctx", "README.md"), renderGdctxCoreReadme());
-    await writeTextIfChanged4(path200.join(metaprojectRoot, "skills", "gdctx", "SKILL.md"), renderGdctxSkillReadme());
+    await writeTextIfMissing4(path201.join(metaprojectRoot, "gdctx.config.json"), renderGdctxConfig());
+    await writeTextIfChanged4(path201.join(metaprojectRoot, "modules", "gdctx.md"), renderGdctxManifest());
+    await writeTextIfChanged4(path201.join(metaprojectRoot, "core", "gdctx", "README.md"), renderGdctxCoreReadme());
+    await writeTextIfChanged4(path201.join(metaprojectRoot, "skills", "gdctx", "SKILL.md"), renderGdctxSkillReadme());
   }
   if (enableGdwiki) {
-    await writeTextIfMissing4(path200.join(metaprojectRoot, "wiki", "templates", "page.md"), renderWikiPageTemplate());
-    await writeTextIfChanged4(path200.join(metaprojectRoot, "modules", "gdwiki.md"), renderGdwikiManifest());
-    await writeTextIfChanged4(path200.join(metaprojectRoot, "skills", "gdwiki", "SKILL.md"), renderGdwikiSkillReadme());
+    await writeTextIfMissing4(path201.join(metaprojectRoot, "wiki", "templates", "page.md"), renderWikiPageTemplate());
+    await writeTextIfChanged4(path201.join(metaprojectRoot, "modules", "gdwiki.md"), renderGdwikiManifest());
+    await writeTextIfChanged4(path201.join(metaprojectRoot, "skills", "gdwiki", "SKILL.md"), renderGdwikiSkillReadme());
     if (manifest.modules?.gdgraph?.hooks?.gitPostCommit) {
       await installManagedHook2(projectRoot, "post-commit", "gdwiki-post-commit", renderGdwikiPostCommitHook());
     }
   }
   if (enableSac) {
-    await writeTextIfMissing4(path200.join(metaprojectRoot, "modules", "sac.md"), renderSacManifest());
-    await writeTextIfChanged4(path200.join(metaprojectRoot, "skills", "sac", "SKILL.md"), renderSacSkillReadme());
+    await writeTextIfMissing4(path201.join(metaprojectRoot, "modules", "sac.md"), renderSacManifest());
+    await writeTextIfChanged4(path201.join(metaprojectRoot, "skills", "sac", "SKILL.md"), renderSacSkillReadme());
   }
   let gdskillsWarnings = [];
   let gdskillsNotices = [];
@@ -106957,25 +108240,25 @@ async function refreshServiceFiles(projectRoot, options) {
     }
   }
   if (enableHealth) {
-    await writeTextIfMissing4(path200.join(metaprojectRoot, "health.config.json"), renderHealthConfig());
-    await writeTextIfChanged4(path200.join(metaprojectRoot, "modules", "health.md"), renderHealthManifest());
-    await writeTextIfChanged4(path200.join(metaprojectRoot, "core", "health", "README.md"), renderHealthCoreReadme());
-    await writeTextIfChanged4(path200.join(metaprojectRoot, "skills", "health", "SKILL.md"), renderHealthSkillReadme());
+    await writeTextIfMissing4(path201.join(metaprojectRoot, "health.config.json"), renderHealthConfig());
+    await writeTextIfChanged4(path201.join(metaprojectRoot, "modules", "health.md"), renderHealthManifest());
+    await writeTextIfChanged4(path201.join(metaprojectRoot, "core", "health", "README.md"), renderHealthCoreReadme());
+    await writeTextIfChanged4(path201.join(metaprojectRoot, "skills", "health", "SKILL.md"), renderHealthSkillReadme());
     if (manifest.modules?.health?.hooks?.gitPostCommit) {
       await installManagedHook2(projectRoot, "post-commit", "health-post-commit", renderHealthPostCommitHook());
     }
   }
   if (enableTesting) {
-    await writeTextIfMissing4(path200.join(metaprojectRoot, "testing.config.json"), renderTestingConfig({
+    await writeTextIfMissing4(path201.join(metaprojectRoot, "testing.config.json"), renderTestingConfig({
       postCommitRefresh: Boolean(manifest.modules?.testing?.hooks?.gitPostCommit),
       prePushGate: Boolean(manifest.modules?.testing?.hooks?.prePush)
     }));
-    await writeTextIfChanged4(path200.join(metaprojectRoot, "modules", "testing.md"), renderTestingManifest());
-    await writeTextIfChanged4(path200.join(metaprojectRoot, "core", "testing", "README.md"), renderTestingCoreReadme());
-    await writeTextIfChanged4(path200.join(metaprojectRoot, "skills", "testing", "SKILL.md"), renderTestingSkillReadme());
+    await writeTextIfChanged4(path201.join(metaprojectRoot, "modules", "testing.md"), renderTestingManifest());
+    await writeTextIfChanged4(path201.join(metaprojectRoot, "core", "testing", "README.md"), renderTestingCoreReadme());
+    await writeTextIfChanged4(path201.join(metaprojectRoot, "skills", "testing", "SKILL.md"), renderTestingSkillReadme());
     if (enableGdwiki) {
-      await writeTextIfMissing4(path200.join(metaprojectRoot, "wiki", "testing", "README.md"), renderTestingWikiReadme());
-      await writeTextIfMissing4(path200.join(metaprojectRoot, "wiki", "testing", "conventions.md"), renderTestingWikiConventions());
+      await writeTextIfMissing4(path201.join(metaprojectRoot, "wiki", "testing", "README.md"), renderTestingWikiReadme());
+      await writeTextIfMissing4(path201.join(metaprojectRoot, "wiki", "testing", "conventions.md"), renderTestingWikiConventions());
     }
     if (manifest.modules?.testing?.hooks?.gitPostCommit) {
       await installManagedHook2(projectRoot, "post-commit", "testing-post-commit", renderTestingPostCommitHook());
@@ -106988,24 +108271,24 @@ async function refreshServiceFiles(projectRoot, options) {
     await installManagedHook2(projectRoot, "post-commit", "metaproject-dashboard-post-commit", renderMetaprojectDashboardPostCommitHook());
   }
   if (enableMemory) {
-    await writeTextIfMissing4(path200.join(metaprojectRoot, "memory.config.json"), renderMemoryConfig());
-    await writeTextIfMissing4(path200.join(metaprojectRoot, "memory", "templates", "entry.md"), renderMemoryEntryTemplate());
-    await writeTextIfChanged4(path200.join(metaprojectRoot, "modules", "memory.md"), renderMemoryManifest());
-    await writeTextIfChanged4(path200.join(metaprojectRoot, "core", "memory", "README.md"), renderMemoryCoreReadme());
-    await writeTextIfChanged4(path200.join(metaprojectRoot, "skills", "memory", "SKILL.md"), renderMemorySkillReadme());
+    await writeTextIfMissing4(path201.join(metaprojectRoot, "memory.config.json"), renderMemoryConfig());
+    await writeTextIfMissing4(path201.join(metaprojectRoot, "memory", "templates", "entry.md"), renderMemoryEntryTemplate());
+    await writeTextIfChanged4(path201.join(metaprojectRoot, "modules", "memory.md"), renderMemoryManifest());
+    await writeTextIfChanged4(path201.join(metaprojectRoot, "core", "memory", "README.md"), renderMemoryCoreReadme());
+    await writeTextIfChanged4(path201.join(metaprojectRoot, "skills", "memory", "SKILL.md"), renderMemorySkillReadme());
   }
   if (enableTasks) {
-    await writeTextIfChanged4(path200.join(metaprojectRoot, "flows", "README.md"), renderFlowsReadme());
-    await writeTextIfChanged4(path200.join(metaprojectRoot, "modules", "tasks.md"), renderTasksManifest());
-    await writeTextIfChanged4(path200.join(metaprojectRoot, "skills", "flow", "SKILL.md"), renderFlowSkillRouter());
-    await writeTextIfChanged4(path200.join(metaprojectRoot, "skills", "flow", "init.md"), renderFlowInitSkill());
-    await writeTextIfChanged4(path200.join(metaprojectRoot, "skills", "flow", "manage.md"), renderFlowManageSkill());
-    await writeTextIfChanged4(path200.join(metaprojectRoot, "skills", "flow", "complete.md"), renderFlowCompleteSkill());
+    await writeTextIfChanged4(path201.join(metaprojectRoot, "flows", "README.md"), renderFlowsReadme());
+    await writeTextIfChanged4(path201.join(metaprojectRoot, "modules", "tasks.md"), renderTasksManifest());
+    await writeTextIfChanged4(path201.join(metaprojectRoot, "skills", "flow", "SKILL.md"), renderFlowSkillRouter());
+    await writeTextIfChanged4(path201.join(metaprojectRoot, "skills", "flow", "init.md"), renderFlowInitSkill());
+    await writeTextIfChanged4(path201.join(metaprojectRoot, "skills", "flow", "manage.md"), renderFlowManageSkill());
+    await writeTextIfChanged4(path201.join(metaprojectRoot, "skills", "flow", "complete.md"), renderFlowCompleteSkill());
   }
   if (enableSecurity) {
-    await writeTextIfMissing4(path200.join(metaprojectRoot, "security.config.json"), renderSecurityConfig());
-    await writeTextIfChanged4(path200.join(metaprojectRoot, "modules", "security.md"), renderSecurityManifest());
-    await writeTextIfChanged4(path200.join(metaprojectRoot, "core", "security", "README.md"), renderSecurityCoreReadme());
+    await writeTextIfMissing4(path201.join(metaprojectRoot, "security.config.json"), renderSecurityConfig());
+    await writeTextIfChanged4(path201.join(metaprojectRoot, "modules", "security.md"), renderSecurityManifest());
+    await writeTextIfChanged4(path201.join(metaprojectRoot, "core", "security", "README.md"), renderSecurityCoreReadme());
     if (manifest.modules?.security?.hooks?.prePush) {
       await installManagedHook2(projectRoot, "pre-push", "security-pre-push", renderSecurityPrePushHook());
     }
@@ -107058,13 +108341,13 @@ async function refreshServiceFiles(projectRoot, options) {
   };
 }
 async function buildDashboard(projectRoot = process.cwd()) {
-  const metaprojectRoot = path200.join(projectRoot, ".metaproject");
+  const metaprojectRoot = path201.join(projectRoot, ".metaproject");
   if (!await pathExists(metaprojectRoot)) {
     throw new Error("Metaproject is not initialized. Run: keryx init");
   }
   const manifest = (await readManifest5(metaprojectRoot)).manifest;
   const data = await collectDashboardData(metaprojectRoot);
-  const dashboardPath = path200.join(metaprojectRoot, "keryx-dashboard.html");
+  const dashboardPath = path201.join(metaprojectRoot, "keryx-dashboard.html");
   await writeTextIfChanged4(dashboardPath, renderMetaprojectDashboardHtml({
     enableGdgraph: moduleEnabled2(manifest, "gdgraph"),
     enableGdctx: moduleEnabled2(manifest, "gdctx"),
@@ -107084,7 +108367,7 @@ async function shouldInstallDashboardPostCommitHook(projectRoot, manifest) {
   if (Object.values(modules).some((module) => Boolean(module.hooks?.gitPostCommit))) {
     return true;
   }
-  const hookPath = path200.join(projectRoot, ".git", "hooks", "post-commit");
+  const hookPath = path201.join(projectRoot, ".git", "hooks", "post-commit");
   if (!await pathExists(hookPath)) {
     return false;
   }
@@ -107104,11 +108387,11 @@ async function collectDashboardData(metaprojectRoot) {
   if (testing) {
     data.testing = testing;
   }
-  const wiki = await collectMarkdownPages(path200.join(metaprojectRoot, "wiki"), "wiki");
+  const wiki = await collectMarkdownPages(path201.join(metaprojectRoot, "wiki"), "wiki");
   if (wiki.length > 0) {
     data.wiki = { pages: wiki };
   }
-  const memory = await collectMarkdownPages(path200.join(metaprojectRoot, "memory"), "memory");
+  const memory = await collectMarkdownPages(path201.join(metaprojectRoot, "memory"), "memory");
   if (memory.length > 0) {
     data.memory = { entries: memory };
   }
@@ -107123,7 +108406,7 @@ async function collectDashboardData(metaprojectRoot) {
   return data;
 }
 async function collectTasksDashboardData(metaprojectRoot) {
-  const flowsRoot = path200.join(metaprojectRoot, "flows");
+  const flowsRoot = path201.join(metaprojectRoot, "flows");
   if (!await pathExists(flowsRoot)) {
     return null;
   }
@@ -107135,7 +108418,7 @@ async function collectTasksDashboardData(metaprojectRoot) {
   }
   const flows = [];
   for (const dir of dirEntries) {
-    const flowPath = path200.join(flowsRoot, dir, "flow.json");
+    const flowPath = path201.join(flowsRoot, dir, "flow.json");
     if (!await pathExists(flowPath)) {
       continue;
     }
@@ -107143,7 +108426,7 @@ async function collectTasksDashboardData(metaprojectRoot) {
       const flow = JSON.parse(await readFile100(flowPath, "utf8"));
       const tasks = Array.isArray(flow.tasks) ? flow.tasks : [];
       let acTotal = 0;
-      const acPath = path200.join(flowsRoot, dir, "acceptance-criteria.md");
+      const acPath = path201.join(flowsRoot, dir, "acceptance-criteria.md");
       if (await pathExists(acPath)) {
         const acContent = await readFile100(acPath, "utf8");
         acTotal = (acContent.match(/^- AC\d+:/gm) ?? []).length;
@@ -107197,7 +108480,7 @@ async function collectDashboardDocs(metaprojectRoot, wiki, memory) {
     "data/testing/context.md"
   ];
   for (const href of staticHrefs) {
-    const filePath = path200.join(metaprojectRoot, ...href.split("/"));
+    const filePath = path201.join(metaprojectRoot, ...href.split("/"));
     if (!await pathExists(filePath)) {
       continue;
     }
@@ -107214,7 +108497,7 @@ async function collectDashboardDocs(metaprojectRoot, wiki, memory) {
   return docs;
 }
 async function collectHealthDashboardData(metaprojectRoot) {
-  const reportPath = path200.join(metaprojectRoot, "data", "health", "artifacts", "latest.json");
+  const reportPath = path201.join(metaprojectRoot, "data", "health", "artifacts", "latest.json");
   if (!await pathExists(reportPath)) {
     return;
   }
@@ -107323,8 +108606,8 @@ function metricToScope(metric) {
   };
 }
 async function collectGraphDashboardData(metaprojectRoot) {
-  const nodesPath = path200.join(metaprojectRoot, "data", "gdgraph", "storage", "nodes.jsonl");
-  const edgesPath = path200.join(metaprojectRoot, "data", "gdgraph", "storage", "edges.jsonl");
+  const nodesPath = path201.join(metaprojectRoot, "data", "gdgraph", "storage", "nodes.jsonl");
+  const edgesPath = path201.join(metaprojectRoot, "data", "gdgraph", "storage", "edges.jsonl");
   if (!await pathExists(nodesPath) || !await pathExists(edgesPath)) {
     return;
   }
@@ -107375,8 +108658,8 @@ async function collectGraphDashboardData(metaprojectRoot) {
   };
 }
 async function collectTestingDashboardData(metaprojectRoot) {
-  const reportPath = path200.join(metaprojectRoot, "data", "testing", "artifacts", "latest.json");
-  const contextPath = path200.join(metaprojectRoot, "data", "testing", "context.md");
+  const reportPath = path201.join(metaprojectRoot, "data", "testing", "artifacts", "latest.json");
+  const contextPath = path201.join(metaprojectRoot, "data", "testing", "context.md");
   if (await pathExists(reportPath)) {
     const report = JSON.parse(await readFile100(reportPath, "utf8"));
     const totalTests = numberOrUndefined(report.total);
@@ -107405,7 +108688,7 @@ async function collectMarkdownPages(root, hrefPrefix) {
   const files = await listMarkdownFiles(root);
   const pages = [];
   for (const filePath of files.slice(0, 40)) {
-    const relativePath = path200.relative(root, filePath).split(path200.sep).join("/");
+    const relativePath = path201.relative(root, filePath).split(path201.sep).join("/");
     if (relativePath === "index.md" || relativePath.startsWith("templates/")) {
       continue;
     }
@@ -107426,7 +108709,7 @@ async function listMarkdownFiles(root) {
   const entries = await readdir37(root, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const fullPath = path200.join(root, entry.name);
+    const fullPath = path201.join(root, entry.name);
     if (entry.isDirectory()) {
       files.push(...await listMarkdownFiles(fullPath));
     } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -107474,7 +108757,7 @@ async function writeRecoveredManifest(metaprojectRoot, modules) {
   const manifest = {
     schemaVersion: 1,
     standardVersion: STANDARD_VERSION,
-    name: `${path200.basename(path200.dirname(metaprojectRoot))}-metaproject`,
+    name: `${path201.basename(path201.dirname(metaprojectRoot))}-metaproject`,
     createdBy: "keryx",
     profiles: computeProfiles(enabledModuleKeys),
     paths: {
@@ -107564,11 +108847,11 @@ async function writeRecoveredManifest(metaprojectRoot, modules) {
       metaproject: ".metaproject/index.md"
     }
   };
-  await writeFile54(path200.join(metaprojectRoot, "metaproject.json"), `${JSON.stringify(manifest, null, 2)}
+  await writeFile54(path201.join(metaprojectRoot, "metaproject.json"), `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
 }
 async function enableTasksInManifest(metaprojectRoot) {
-  const manifestPath = path200.join(metaprojectRoot, "metaproject.json");
+  const manifestPath = path201.join(metaprojectRoot, "metaproject.json");
   if (!await pathExists(manifestPath)) {
     return;
   }
@@ -107591,7 +108874,7 @@ async function enableTasksInManifest(metaprojectRoot) {
 `, "utf8");
 }
 async function updateManifestAgentEntrypoints(metaprojectRoot, ruleSources) {
-  const manifestPath = path200.join(metaprojectRoot, "metaproject.json");
+  const manifestPath = path201.join(metaprojectRoot, "metaproject.json");
   if (!await pathExists(manifestPath)) {
     return;
   }
@@ -107627,72 +108910,72 @@ async function updateRuntime(projectRoot) {
   }
 }
 async function findRuntimeRoot(projectRoot) {
-  const projectRuntime = path200.join(projectRoot, ".metaproject", "runtime", "keryx");
-  if (await pathExists(path200.join(projectRuntime, ".git"))) {
+  const projectRuntime = path201.join(projectRoot, ".metaproject", "runtime", "keryx");
+  if (await pathExists(path201.join(projectRuntime, ".git"))) {
     return projectRuntime;
   }
   const home = process.env.HOME;
   if (!home) {
     return null;
   }
-  const globalRuntime = path200.join(home, ".keryx", "keryx");
-  if (await pathExists(path200.join(globalRuntime, ".git"))) {
+  const globalRuntime = path201.join(home, ".keryx", "keryx");
+  if (await pathExists(path201.join(globalRuntime, ".git"))) {
     return globalRuntime;
   }
   return null;
 }
 async function createServiceDirs(metaprojectRoot, modules) {
   const dirs = [
-    path200.join(metaprojectRoot, "core"),
-    path200.join(metaprojectRoot, "hooks", "post-update.d"),
-    path200.join(metaprojectRoot, "modules"),
-    path200.join(metaprojectRoot, "rules"),
-    path200.join(metaprojectRoot, "skills", "project-rules"),
+    path201.join(metaprojectRoot, "core"),
+    path201.join(metaprojectRoot, "hooks", "post-update.d"),
+    path201.join(metaprojectRoot, "modules"),
+    path201.join(metaprojectRoot, "rules"),
+    path201.join(metaprojectRoot, "skills", "project-rules"),
     ...modules.enableGdgraph ? [
-      path200.join(metaprojectRoot, "core", "gdgraph"),
-      path200.join(metaprojectRoot, "skills", "gdgraph")
+      path201.join(metaprojectRoot, "core", "gdgraph"),
+      path201.join(metaprojectRoot, "skills", "gdgraph")
     ] : [],
     ...modules.enableGdctx ? [
-      path200.join(metaprojectRoot, "core", "gdctx"),
-      path200.join(metaprojectRoot, "skills", "gdctx")
+      path201.join(metaprojectRoot, "core", "gdctx"),
+      path201.join(metaprojectRoot, "skills", "gdctx")
     ] : [],
     ...modules.enableGdwiki ? [
-      path200.join(metaprojectRoot, "skills", "gdwiki"),
-      path200.join(metaprojectRoot, "wiki", "templates")
+      path201.join(metaprojectRoot, "skills", "gdwiki"),
+      path201.join(metaprojectRoot, "wiki", "templates")
     ] : [],
     ...modules.enableHealth ? [
-      path200.join(metaprojectRoot, "core", "health"),
-      path200.join(metaprojectRoot, "skills", "health")
+      path201.join(metaprojectRoot, "core", "health"),
+      path201.join(metaprojectRoot, "skills", "health")
     ] : [],
     ...modules.enableTesting ? [
-      path200.join(metaprojectRoot, "core", "testing"),
-      path200.join(metaprojectRoot, "skills", "testing")
+      path201.join(metaprojectRoot, "core", "testing"),
+      path201.join(metaprojectRoot, "skills", "testing")
     ] : [],
     ...modules.enableMemory ? [
-      path200.join(metaprojectRoot, "core", "memory"),
-      path200.join(metaprojectRoot, "skills", "memory"),
-      path200.join(metaprojectRoot, "memory", "templates")
+      path201.join(metaprojectRoot, "core", "memory"),
+      path201.join(metaprojectRoot, "skills", "memory"),
+      path201.join(metaprojectRoot, "memory", "templates")
     ] : [],
     ...modules.enableTasks ? [
-      path200.join(metaprojectRoot, "flows"),
-      path200.join(metaprojectRoot, "skills", "flow")
+      path201.join(metaprojectRoot, "flows"),
+      path201.join(metaprojectRoot, "skills", "flow")
     ] : [],
     ...modules.enableSecurity ? [
-      path200.join(metaprojectRoot, "core", "security")
+      path201.join(metaprojectRoot, "core", "security")
     ] : [],
     ...modules.enableSac ? [
-      path200.join(metaprojectRoot, "skills", "sac")
+      path201.join(metaprojectRoot, "skills", "sac")
     ] : []
   ];
   await Promise.all(dirs.map((dir) => mkdir63(dir, { recursive: true })));
 }
 async function installGdgraphCoreScripts2(metaprojectRoot) {
-  const gdgraphCoreRoot = path200.join(metaprojectRoot, "core", "gdgraph");
+  const gdgraphCoreRoot = path201.join(metaprojectRoot, "core", "gdgraph");
   await mkdir63(gdgraphCoreRoot, { recursive: true });
   for (const file of GDGRAPH_CORE_SOURCES) {
-    await copyFileIfChanged2(runtimeSourcePath2(`../gdgraph/${file}`), path200.join(gdgraphCoreRoot, file));
+    await copyFileIfChanged2(runtimeSourcePath2(`../gdgraph/${file}`), path201.join(gdgraphCoreRoot, file));
   }
-  await writeTextIfChanged4(path200.join(gdgraphCoreRoot, "cli.ts"), renderGdgraphCoreCli());
+  await writeTextIfChanged4(path201.join(gdgraphCoreRoot, "cli.ts"), renderGdgraphCoreCli());
 }
 async function installManagedHook2(projectRoot, hookName, blockId, content) {
   const hooksRoot = await resolveGitHooksRoot(projectRoot);
@@ -107700,7 +108983,7 @@ async function installManagedHook2(projectRoot, hookName, blockId, content) {
     return;
   }
   await mkdir63(hooksRoot, { recursive: true });
-  const hookPath = path200.join(hooksRoot, hookName);
+  const hookPath = path201.join(hooksRoot, hookName);
   const blockStart = `# keryx:${blockId}:begin`;
   const blockEnd = `# keryx:${blockId}:end`;
   const managedBlock = `${blockStart}
@@ -107721,7 +109004,7 @@ async function removeManagedHook2(projectRoot, hookName, blockId) {
   if (!hooksRoot) {
     return;
   }
-  const hookPath = path200.join(hooksRoot, hookName);
+  const hookPath = path201.join(hooksRoot, hookName);
   if (!await pathExists(hookPath)) {
     return;
   }
@@ -107743,7 +109026,7 @@ async function prePushHasSecurityBlock2(projectRoot) {
   if (!hooksRoot) {
     return false;
   }
-  const hookPath = path200.join(hooksRoot, "pre-push");
+  const hookPath = path201.join(hooksRoot, "pre-push");
   if (!await pathExists(hookPath)) {
     return false;
   }
@@ -107758,7 +109041,7 @@ async function agentSettingsHasSecuritySentinel2(projectRoot) {
   return (await readFile100(file, "utf8")).includes(AGENT_HOOKS_SENTINEL);
 }
 async function readManifest5(metaprojectRoot) {
-  const manifestPath = path200.join(metaprojectRoot, "metaproject.json");
+  const manifestPath = path201.join(metaprojectRoot, "metaproject.json");
   if (!await pathExists(manifestPath)) {
     return {
       exists: false,
@@ -107827,7 +109110,7 @@ async function inferManifestFromExistingMetaproject(metaprojectRoot) {
 }
 async function anyPathExists(root, candidates) {
   for (const candidate of candidates) {
-    if (await pathExists(path200.join(root, candidate))) {
+    if (await pathExists(path201.join(root, candidate))) {
       return true;
     }
   }
@@ -107850,13 +109133,13 @@ function parseUpdateArgs(args) {
   };
 }
 async function runPostUpdateHooks(projectRoot) {
-  const hooksDir = path200.join(projectRoot, ".metaproject", "hooks", "post-update.d");
+  const hooksDir = path201.join(projectRoot, ".metaproject", "hooks", "post-update.d");
   if (!await pathExists(hooksDir)) {
     return;
   }
   const entries = (await readdir37(hooksDir)).sort();
   for (const entry of entries) {
-    const hookPath = path200.join(hooksDir, entry);
+    const hookPath = path201.join(hooksDir, entry);
     try {
       await accessExecutable(hookPath);
     } catch {
@@ -107897,14 +109180,14 @@ async function writeTextIfChanged4(filePath, content) {
   if (await pathExists(filePath) && await readFile100(filePath, "utf8") === content) {
     return;
   }
-  await mkdir63(path200.dirname(filePath), { recursive: true });
+  await mkdir63(path201.dirname(filePath), { recursive: true });
   await writeFile54(filePath, content, "utf8");
 }
 async function writeTextIfMissing4(filePath, content) {
   if (await pathExists(filePath)) {
     return;
   }
-  await mkdir63(path200.dirname(filePath), { recursive: true });
+  await mkdir63(path201.dirname(filePath), { recursive: true });
   await writeFile54(filePath, content, "utf8");
 }
 async function copyFileIfChanged2(from, to) {
@@ -107912,7 +109195,7 @@ async function copyFileIfChanged2(from, to) {
   if (await pathExists(to) && await readFile100(to, "utf8") === next) {
     return;
   }
-  await mkdir63(path200.dirname(to), { recursive: true });
+  await mkdir63(path201.dirname(to), { recursive: true });
   await writeFile54(to, next, "utf8");
 }
 function runtimeSourcePath2(relativePath) {
@@ -107921,7 +109204,7 @@ function runtimeSourcePath2(relativePath) {
     return directPath;
   }
   if (relativePath.startsWith("../")) {
-    const packagedSourcePath = path200.join(path200.dirname(fileURLToPath8(import.meta.url)), "..", "src", relativePath.slice(3));
+    const packagedSourcePath = path201.join(path201.dirname(fileURLToPath8(import.meta.url)), "..", "src", relativePath.slice(3));
     if (existsSync36(packagedSourcePath)) {
       return packagedSourcePath;
     }
@@ -107956,7 +109239,7 @@ function printHelp20() {
 
 // src/commands/dashboard.ts
 import { spawn as spawn8 } from "child_process";
-import path201 from "path";
+import path202 from "path";
 init_args();
 async function dashboardCommand(args = []) {
   const options = parseOptions(args);
@@ -107967,7 +109250,7 @@ async function dashboardCommand(args = []) {
   }
   if (subcommand === "build") {
     const result = await buildDashboard();
-    const rel = path201.relative(process.cwd(), result.path);
+    const rel = path202.relative(process.cwd(), result.path);
     console.log(`  ${style.green(symbols.ok)} Dashboard built ${style.cyan(symbols.arrow)} ${style.cyan(rel)}`);
     note(`Open it: keryx dashboard open`);
     return;
@@ -107975,7 +109258,7 @@ async function dashboardCommand(args = []) {
   if (subcommand === "open") {
     const result = await buildDashboard();
     await openFile(result.path);
-    const rel = path201.relative(process.cwd(), result.path);
+    const rel = path202.relative(process.cwd(), result.path);
     console.log(`  ${style.green(symbols.ok)} Opened ${style.cyan(rel)}`);
     return;
   }
@@ -108019,12 +109302,12 @@ function printHelp21() {
 }
 
 // src/commands/agents.ts
-import { readFileSync as readFileSync10 } from "fs";
+import { readFileSync as readFileSync12 } from "fs";
 
 // src/agents/bootstrap.ts
 import { mkdir as mkdir64, readFile as readFile101, writeFile as writeFile55 } from "fs/promises";
 import { homedir as homedir10 } from "os";
-import path202 from "path";
+import path203 from "path";
 init_fs();
 var AGENT_BOOTSTRAP_START = "<!-- keryx:global-bootstrap -->";
 var AGENT_BOOTSTRAP_END = "<!-- /keryx:global-bootstrap -->";
@@ -108034,35 +109317,35 @@ var AGENT_BOOTSTRAP_RUNTIMES = [
     aliases: ["claude-code"],
     label: "Claude Code",
     fileName: "CLAUDE.md",
-    filePath: (homeRoot) => path202.join(homeRoot, ".claude", "CLAUDE.md")
+    filePath: (homeRoot) => path203.join(homeRoot, ".claude", "CLAUDE.md")
   },
   {
     id: "opencode",
     aliases: ["open-code"],
     label: "OpenCode",
     fileName: "AGENTS.md",
-    filePath: (homeRoot) => path202.join(homeRoot, ".config", "opencode", "AGENTS.md")
+    filePath: (homeRoot) => path203.join(homeRoot, ".config", "opencode", "AGENTS.md")
   },
   {
     id: "zcode",
     aliases: ["zed", "zed-code"],
     label: "ZCode",
     fileName: "AGENTS.md",
-    filePath: (homeRoot) => path202.join(homeRoot, ".zcode", "AGENTS.md")
+    filePath: (homeRoot) => path203.join(homeRoot, ".zcode", "AGENTS.md")
   },
   {
     id: "codex",
     aliases: [],
     label: "Codex",
     fileName: "AGENTS.md",
-    filePath: (homeRoot) => path202.join(homeRoot, ".codex", "AGENTS.md")
+    filePath: (homeRoot) => path203.join(homeRoot, ".codex", "AGENTS.md")
   },
   {
     id: "antigravity",
     aliases: ["antigravuty", "antigravity-code"],
     label: "Antigravity",
     fileName: "AGENTS.md",
-    filePath: (homeRoot) => path202.join(homeRoot, ".config", "antigravity", "AGENTS.md")
+    filePath: (homeRoot) => path203.join(homeRoot, ".config", "antigravity", "AGENTS.md")
   }
 ];
 function agentBootstrapRuntimeIds() {
@@ -108110,7 +109393,7 @@ async function installAgentBootstrap(runtime, options = {}) {
   const dryRun = options.dryRun === true;
   const wrote = next !== current;
   if (wrote && !dryRun) {
-    await mkdir64(path202.dirname(filePath), { recursive: true });
+    await mkdir64(path203.dirname(filePath), { recursive: true });
     await writeFile55(filePath, next, "utf8");
   }
   const status = dryRun ? statusFromContent(runtime, filePath, exists, next) : await agentBootstrapStatus(runtime, homeRoot);
@@ -108520,7 +109803,7 @@ function monitorCommand(args) {
   }
   let events;
   try {
-    events = parseAgentEvents(readFileSync10(source, "utf8"));
+    events = parseAgentEvents(readFileSync12(source, "utf8"));
   } catch (error) {
     console.error(`Failed to read/parse agent-event source "${source}": ${error.message}`);
     process.exitCode = 1;
@@ -108647,7 +109930,7 @@ function printBootstrapHelp() {
 // src/commands/metrics.ts
 init_args();
 import { readFile as readFile102 } from "fs/promises";
-import path204 from "path";
+import path205 from "path";
 
 // src/metrics/benchmark.ts
 var RELIABILITIES2 = new Set(["exact", "estimated", "unknown"]);
@@ -109464,7 +110747,7 @@ function buildContainmentManifest(inputs, options = {}) {
 
 // src/metrics/oracle-runner.ts
 import { mkdir as mkdir65, writeFile as writeFile56 } from "fs/promises";
-import path203 from "path";
+import path204 from "path";
 
 // src/metrics/ir.ts
 function toIdSet(ids) {
@@ -109910,9 +111193,9 @@ function buildEvidenceBundle(input, options = {}) {
 async function persistEvidenceBundle(outDir, bundle, ladder = "metastore") {
   const safeTarget = bundle.target.replace(/[^A-Za-z0-9._/-]/g, "_");
   const safeCase = bundle.caseId.replace(/[^A-Za-z0-9._-]/g, "_");
-  const dir = path203.join(outDir, "bench", ladder, safeTarget, safeCase, bundle.variant, String(bundle.seed));
+  const dir = path204.join(outDir, "bench", ladder, safeTarget, safeCase, bundle.variant, String(bundle.seed));
   await mkdir65(dir, { recursive: true });
-  const write = (name, value) => writeFile56(path203.join(dir, name), `${JSON.stringify(value, null, 2)}
+  const write = (name, value) => writeFile56(path204.join(dir, name), `${JSON.stringify(value, null, 2)}
 `, "utf8");
   await Promise.all([
     write("inputs.json", bundle.inputs),
@@ -109952,7 +111235,7 @@ async function metricsCommand(args = [], projectRoot = process.cwd()) {
     console.log("# metrics status");
     console.log("");
     console.log(`root: ${root}`);
-    console.log(`enabled: ${await Bun.file(path204.join(projectRoot, ".metaproject", "metaproject.json")).exists() ? "yes" : "no"}`);
+    console.log(`enabled: ${await Bun.file(path205.join(projectRoot, ".metaproject", "metaproject.json")).exists() ? "yes" : "no"}`);
     const latest = await readLatestPointer(root);
     console.log(`latest: ${latest.status}`);
     return;
@@ -109964,7 +111247,7 @@ async function metricsCommand(args = [], projectRoot = process.cwd()) {
       process.exitCode = 1;
       return;
     }
-    const record = JSON.parse(await readFile102(path204.resolve(projectRoot, file), "utf8"));
+    const record = JSON.parse(await readFile102(path205.resolve(projectRoot, file), "utf8"));
     const result = validateRunRecord(record);
     console.log(result.valid ? "valid: yes" : "valid: no");
     for (const error of result.errors)
@@ -109989,7 +111272,7 @@ async function metricsCommand(args = [], projectRoot = process.cwd()) {
       process.exitCode = 1;
       return;
     }
-    const file = path204.join(metricsRoot(projectRoot), "runs", `${runId}.json`);
+    const file = path205.join(metricsRoot(projectRoot), "runs", `${runId}.json`);
     if (!await Bun.file(file).exists()) {
       console.error(`Run not found: ${runId}`);
       process.exitCode = 1;
@@ -110006,8 +111289,8 @@ async function metricsCommand(args = [], projectRoot = process.cwd()) {
       process.exitCode = 1;
       return;
     }
-    const a = JSON.parse(await readFile102(path204.join(metricsRoot(projectRoot), "runs", `${runA}.json`), "utf8"));
-    const b = JSON.parse(await readFile102(path204.join(metricsRoot(projectRoot), "runs", `${runB}.json`), "utf8"));
+    const a = JSON.parse(await readFile102(path205.join(metricsRoot(projectRoot), "runs", `${runA}.json`), "utf8"));
+    const b = JSON.parse(await readFile102(path205.join(metricsRoot(projectRoot), "runs", `${runB}.json`), "utf8"));
     const comparison = compareExecutionRuns(a, b);
     console.log(stableJson(comparison));
     return;
@@ -110041,8 +111324,8 @@ async function metricsCommand(args = [], projectRoot = process.cwd()) {
       return;
     }
     const template = createPairedBenchmarkTemplate(taskIds);
-    await Bun.write(path204.resolve(projectRoot, out), stableJson(template));
-    console.log(`manifest: ${path204.relative(projectRoot, path204.resolve(projectRoot, out))}`);
+    await Bun.write(path205.resolve(projectRoot, out), stableJson(template));
+    console.log(`manifest: ${path205.relative(projectRoot, path205.resolve(projectRoot, out))}`);
     return;
   }
   if (subcommand === "benchmark" && args[1] === "run") {
@@ -110056,7 +111339,7 @@ async function metricsCommand(args = [], projectRoot = process.cwd()) {
       process.exitCode = 1;
       return;
     }
-    const raw = JSON.parse(await readFile102(path204.resolve(projectRoot, file), "utf8"));
+    const raw = JSON.parse(await readFile102(path205.resolve(projectRoot, file), "utf8"));
     const input = Array.isArray(raw) ? raw : raw.runs ?? [];
     const result = validatePairedBenchmark(input);
     console.log(stableJson(result));
@@ -110068,7 +111351,7 @@ async function metricsCommand(args = [], projectRoot = process.cwd()) {
   process.exitCode = 1;
 }
 async function loadAffectedSets(projectRoot, file) {
-  const raw = JSON.parse(await readFile102(path204.resolve(projectRoot, file), "utf8"));
+  const raw = JSON.parse(await readFile102(path205.resolve(projectRoot, file), "utf8"));
   const map = new Map;
   for (const entry of raw.targets ?? []) {
     if (typeof entry.target === "string")
@@ -110139,7 +111422,7 @@ async function runHarnessLayer(projectRoot, args, ladder) {
   let tasks;
   let model;
   try {
-    const raw = JSON.parse(await readFile102(path204.resolve(projectRoot, resultsPath), "utf8"));
+    const raw = JSON.parse(await readFile102(path205.resolve(projectRoot, resultsPath), "utf8"));
     tasks = raw.tasks ?? [];
     model = raw.model;
   } catch (error) {
@@ -110170,7 +111453,7 @@ async function runSafetyCompletionHonestyLayer(projectRoot, args, ladder) {
   let cases;
   let model;
   try {
-    const raw = JSON.parse(await readFile102(path204.resolve(projectRoot, resultsPath), "utf8"));
+    const raw = JSON.parse(await readFile102(path205.resolve(projectRoot, resultsPath), "utf8"));
     cases = raw.cases ?? [];
     model = raw.model;
   } catch (error) {
@@ -110195,7 +111478,7 @@ async function runSafetyFalsePremiseLayer(projectRoot, args, ladder) {
   let cases;
   let model;
   try {
-    const raw = JSON.parse(await readFile102(path204.resolve(projectRoot, resultsPath), "utf8"));
+    const raw = JSON.parse(await readFile102(path205.resolve(projectRoot, resultsPath), "utf8"));
     cases = raw.cases ?? [];
     model = raw.model;
   } catch (error) {
@@ -110220,7 +111503,7 @@ async function runSafetyContainmentLayer(projectRoot, args, ladder, caseClass) {
   let cases;
   let model;
   try {
-    const raw = JSON.parse(await readFile102(path204.resolve(projectRoot, resultsPath), "utf8"));
+    const raw = JSON.parse(await readFile102(path205.resolve(projectRoot, resultsPath), "utf8"));
     cases = raw.cases ?? [];
     model = raw.model;
   } catch (error) {
@@ -110282,12 +111565,12 @@ async function runGdgraphLayer(projectRoot, args, ladder) {
   }
   const manifests = buildOracleManifestsByGold(inputs, { ladder });
   if (outDir) {
-    const resolvedOut = path204.resolve(projectRoot, outDir);
+    const resolvedOut = path205.resolve(projectRoot, outDir);
     for (const input of inputs) {
       for (const named of input.golds) {
         const bundle = buildEvidenceBundle({ target: input.target, system: input.system, gold: named.gold }, { ladder, goldReference: goldPathFor(named.kind), timestamp: new Date().toISOString() });
-        const dir = await persistEvidenceBundle(path204.join(resolvedOut, named.kind), bundle, ladder);
-        console.error(`bundle[${named.kind}]: ${path204.relative(projectRoot, dir)}`);
+        const dir = await persistEvidenceBundle(path205.join(resolvedOut, named.kind), bundle, ladder);
+        console.error(`bundle[${named.kind}]: ${path205.relative(projectRoot, dir)}`);
       }
     }
   }
@@ -110311,7 +111594,7 @@ async function runGdgraphLayer(projectRoot, args, ladder) {
   return allValid;
 }
 async function loadCoverageMap2(projectRoot, file) {
-  const raw = JSON.parse(await readFile102(path204.resolve(projectRoot, file), "utf8"));
+  const raw = JSON.parse(await readFile102(path205.resolve(projectRoot, file), "utf8"));
   return raw.coverageMap ?? {};
 }
 async function runTestingLayer(projectRoot, args, ladder) {
@@ -110348,7 +111631,7 @@ async function runTestingLayer(projectRoot, args, ladder) {
   return result.valid;
 }
 async function loadMemoryGoldK(projectRoot, file) {
-  const raw = JSON.parse(await readFile102(path204.resolve(projectRoot, file), "utf8"));
+  const raw = JSON.parse(await readFile102(path205.resolve(projectRoot, file), "utf8"));
   return typeof raw.k === "number" && raw.k > 0 ? raw.k : 3;
 }
 async function runMemoryLayer(projectRoot, args, ladder) {
@@ -110385,11 +111668,11 @@ async function runMemoryLayer(projectRoot, args, ladder) {
   return result.valid;
 }
 async function loadWikiGoldK(projectRoot, file) {
-  const raw = JSON.parse(await readFile102(path204.resolve(projectRoot, file), "utf8"));
+  const raw = JSON.parse(await readFile102(path205.resolve(projectRoot, file), "utf8"));
   return typeof raw.k === "number" && raw.k > 0 ? raw.k : 5;
 }
 async function loadWikiGroundedness(projectRoot, file) {
-  const raw = JSON.parse(await readFile102(path204.resolve(projectRoot, file), "utf8"));
+  const raw = JSON.parse(await readFile102(path205.resolve(projectRoot, file), "utf8"));
   const map = new Map;
   for (const entry of raw.targets ?? []) {
     if (typeof entry.target !== "string" || !Array.isArray(entry.scores) || entry.scores.length !== 3)
@@ -110445,7 +111728,7 @@ async function runWikiLayer(projectRoot, args, ladder) {
   return result.valid;
 }
 async function loadGdctxFacts(projectRoot, file) {
-  const raw = JSON.parse(await readFile102(path204.resolve(projectRoot, file), "utf8"));
+  const raw = JSON.parse(await readFile102(path205.resolve(projectRoot, file), "utf8"));
   const inputs = [];
   for (const entry of raw.inputs ?? []) {
     if (typeof entry.input === "string") {
@@ -110483,7 +111766,7 @@ async function collect(projectRoot, args) {
     process.exitCode = 1;
     return;
   }
-  const raw = JSON.parse(await readFile102(path204.resolve(projectRoot, eventFile), "utf8"));
+  const raw = JSON.parse(await readFile102(path205.resolve(projectRoot, eventFile), "utf8"));
   const events = Array.isArray(raw) ? raw : raw.events;
   const startedAt = optionValue(args, "--started-at") ?? events[0]?.timestamp_utc ?? new Date().toISOString();
   const finishedAt = optionValue(args, "--finished-at") ?? events.at(-1)?.timestamp_utc ?? startedAt;
@@ -110499,11 +111782,11 @@ async function collect(projectRoot, args) {
     parentRunId: optionValue(args, "--parent-run-id") ?? null
   });
   const result = await writeRunArtifacts(metricsRoot(projectRoot), record, { cwd: projectRoot });
-  console.log(`json: ${path204.relative(projectRoot, result.jsonPath)}`);
-  console.log(`markdown: ${path204.relative(projectRoot, result.markdownPath)}`);
+  console.log(`json: ${path205.relative(projectRoot, result.jsonPath)}`);
+  console.log(`markdown: ${path205.relative(projectRoot, result.markdownPath)}`);
 }
 function metricsRoot(projectRoot) {
-  return path204.join(projectRoot, ".metaproject", "data", "metrics");
+  return path205.join(projectRoot, ".metaproject", "data", "metrics");
 }
 function printMetricsHelp() {
   console.log(`keryx metrics
@@ -110555,7 +111838,7 @@ async function versionCommand(args, deps = {}) {
 // src/commands/workspace.ts
 init_args();
 init_workspace_service();
-import { randomUUID as randomUUID33 } from "crypto";
+import { randomUUID as randomUUID34 } from "crypto";
 import { writeFile as writeFile57 } from "fs/promises";
 
 // src/sac/fwk-explain.ts
@@ -110634,7 +111917,7 @@ async function workspaceCommand(args) {
       const component = optionValue(args, "--component");
       if (!title)
         throw new Error("Usage: keryx workspace create --title <title> [--component <workspace-relative-ref>]");
-      const workspace = await service6().create({ request: undefined, requestCorrelationId: randomUUID33(), id: newWorkspaceId(), title, ...component ? { component: { kind: "component", uri: component } } : {} });
+      const workspace = await service6().create({ request: undefined, requestCorrelationId: randomUUID34(), id: newWorkspaceId(), title, ...component ? { component: { kind: "component", uri: component } } : {} });
       console.log(JSON.stringify(workspace, null, 2));
       return;
     }
@@ -110664,7 +111947,7 @@ async function workspaceCommand(args) {
       const revision = optionValue(args, "--revision");
       if (!workspaceId || !kind || !uri)
         throw new Error("Usage: keryx workspace add-resource <workspace-id> --kind <kind> --uri <workspace-relative-ref> [--revision <revision>]");
-      console.log(JSON.stringify(await service6().addResource({ request: undefined, requestCorrelationId: randomUUID33(), workspaceId, resource: { kind, uri, ...revision ? { revision } : {} } }), null, 2));
+      console.log(JSON.stringify(await service6().addResource({ request: undefined, requestCorrelationId: randomUUID34(), workspaceId, resource: { kind, uri, ...revision ? { revision } : {} } }), null, 2));
       return;
     }
     if (subcommand === "archive") {
@@ -110672,7 +111955,7 @@ async function workspaceCommand(args) {
       const workspaceId = args[1];
       if (!workspaceId)
         throw new Error("Usage: keryx workspace archive <workspace-id>");
-      console.log(JSON.stringify(await service6().archive({ request: undefined, requestCorrelationId: randomUUID33(), workspaceId }), null, 2));
+      console.log(JSON.stringify(await service6().archive({ request: undefined, requestCorrelationId: randomUUID34(), workspaceId }), null, 2));
       return;
     }
     if (subcommand === "remove-resource") {
@@ -110681,7 +111964,7 @@ async function workspaceCommand(args) {
       const uri = optionValue(args, "--uri");
       if (!workspaceId || !uri)
         throw new Error("Usage: keryx workspace remove-resource <workspace-id> --uri <workspace-relative-ref>");
-      console.log(JSON.stringify(await service6().removeResource({ request: undefined, requestCorrelationId: randomUUID33(), workspaceId, uri }), null, 2));
+      console.log(JSON.stringify(await service6().removeResource({ request: undefined, requestCorrelationId: randomUUID34(), workspaceId, uri }), null, 2));
       return;
     }
     if (subcommand === "rename") {
@@ -110690,7 +111973,7 @@ async function workspaceCommand(args) {
       const title = optionValue(args, "--title");
       if (!workspaceId || !title)
         throw new Error("Usage: keryx workspace rename <workspace-id> --title <title>");
-      console.log(JSON.stringify(await service6().rename({ request: undefined, requestCorrelationId: randomUUID33(), workspaceId, title }), null, 2));
+      console.log(JSON.stringify(await service6().rename({ request: undefined, requestCorrelationId: randomUUID34(), workspaceId, title }), null, 2));
       return;
     }
     if (subcommand === "overview") {
@@ -110702,7 +111985,7 @@ async function workspaceCommand(args) {
       const maxTokens = Number(optionValue(args, "--max-tokens") ?? "4096");
       if (!Number.isInteger(maxItems) || !Number.isInteger(maxTokens) || maxItems < 0 || maxTokens < 0)
         throw new Error("--max-items and --max-tokens must be non-negative integers");
-      const result = await createLocalFwkReadService(process.cwd()).overview({ workspaceId, request: undefined, requestCorrelationId: randomUUID33(), budget: { maxItems, maxTokens } });
+      const result = await createLocalFwkReadService(process.cwd()).overview({ workspaceId, request: undefined, requestCorrelationId: randomUUID34(), budget: { maxItems, maxTokens } });
       const normalized = normalizeFwkResult(result);
       console.log(JSON.stringify(normalized, null, 2));
       if (args.includes("--explain"))
@@ -110719,7 +112002,7 @@ async function workspaceCommand(args) {
       const maxTokens = Number(optionValue(args, "--max-tokens") ?? "4096");
       if (!Number.isInteger(maxItems) || !Number.isInteger(maxTokens) || maxItems < 0 || maxTokens < 0)
         throw new Error("--max-items and --max-tokens must be non-negative integers");
-      const result = await createLocalFwkReadService(process.cwd()).read({ workspaceId, itemId, request: undefined, requestCorrelationId: randomUUID33(), budget: { maxItems, maxTokens } });
+      const result = await createLocalFwkReadService(process.cwd()).read({ workspaceId, itemId, request: undefined, requestCorrelationId: randomUUID34(), budget: { maxItems, maxTokens } });
       const normalized = normalizeFwkResult(result);
       console.log(JSON.stringify(normalized, null, 2));
       if (args.includes("--explain"))
@@ -110741,14 +112024,14 @@ async function workspaceCommand(args) {
       const session = findSession(cwd, sessionRef);
       if (!session)
         throw new Error(`no session matching "${sessionRef}" in this project \u2014 use \`keryx sessions list\``);
-      const proposalId = `proposal-${randomUUID33().replace(/-/g, "").slice(0, 16)}`;
+      const proposalId = `proposal-${randomUUID34().replace(/-/g, "").slice(0, 16)}`;
       const notePath = proposalNotePath(cwd, workspaceId, proposalId);
       const materializedNote = note === undefined ? undefined : prepareOutputForPersistence(await guardOutput({ cwd, content: note, target: "task", source: "generated", path: notePath }), note);
       if (materializedNote !== undefined && !materializedNote.allowed)
         throw new Error(materializedNote.reason);
       const persistedNote = materializedNote?.allowed ? materializedNote.content : undefined;
       const { service, wrapUpAuthority, authorizationServer } = createHarnessProposalLifecycleService(cwd, { workspaceId, ...persistedNote ? { note: persistedNote } : {} });
-      const requestCorrelationId = randomUUID33();
+      const requestCorrelationId = randomUUID34();
       const actor = await authorizationServer.actorContextFor(undefined, requestCorrelationId);
       if (!actor)
         throw new Error("trusted ActorContext is required");
@@ -110788,13 +112071,13 @@ async function workspaceCommand(args) {
       const proposalId = args[2];
       const decision = optionValue(args, "--decision");
       const reason = optionValue(args, "--reason");
-      const idempotencyKey = optionValue(args, "--idempotency-key") ?? randomUUID33();
+      const idempotencyKey = optionValue(args, "--idempotency-key") ?? randomUUID34();
       const confirmToken = optionValue(args, "--confirm-token");
       if (!workspaceId || !proposalId || !decision)
         throw new Error("Usage: keryx workspace review <workspace-id> <proposal-id> --decision <accepted|rejected|dismissed> [--reason <reason>] [--idempotency-key <key>] [--confirm-token <token>]");
       if (decision === "accepted" && !confirmToken)
         throw new Error("--decision accepted requires --confirm-token \u2014 run `keryx workspace confirm-review " + workspaceId + " " + proposalId + "` first");
-      const result = await createHarnessProposalLifecycleService(process.cwd(), { workspaceId }).service.review({ request: undefined, requestCorrelationId: randomUUID33(), workspaceId, proposalId, decision, idempotencyKey, interactive: true, ...reason ? { reason } : {}, ...confirmToken ? { confirmToken } : {} });
+      const result = await createHarnessProposalLifecycleService(process.cwd(), { workspaceId }).service.review({ request: undefined, requestCorrelationId: randomUUID34(), workspaceId, proposalId, decision, idempotencyKey, interactive: true, ...reason ? { reason } : {}, ...confirmToken ? { confirmToken } : {} });
       console.log(JSON.stringify(normalizeProposalLifecycleResult(result), null, 2));
       return;
     }
@@ -110819,7 +112102,7 @@ async function workspaceCommand(args) {
       const artifactRef = optionValue(args, "--artifact");
       if (!workspaceId || !to || !artifactRef)
         throw new Error("Usage: keryx workspace handoff <workspace-id> --to <subject> --artifact <ref>");
-      const activity = await createLocalCollaborationService(process.cwd()).record({ request: undefined, requestCorrelationId: randomUUID33(), workspaceId, activity: { kind: "handoff-recorded", handoff: { to, artifactRef } } });
+      const activity = await createLocalCollaborationService(process.cwd()).record({ request: undefined, requestCorrelationId: randomUUID34(), workspaceId, activity: { kind: "handoff-recorded", handoff: { to, artifactRef } } });
       console.log(JSON.stringify(activity, null, 2));
       return;
     }
@@ -110828,7 +112111,7 @@ async function workspaceCommand(args) {
       const workspaceId = args[1];
       if (!workspaceId)
         throw new Error("Usage: keryx workspace collaboration <workspace-id>");
-      console.log(JSON.stringify(await createLocalCollaborationService(process.cwd()).overview({ workspaceId, request: undefined, requestCorrelationId: randomUUID33() }), null, 2));
+      console.log(JSON.stringify(await createLocalCollaborationService(process.cwd()).overview({ workspaceId, request: undefined, requestCorrelationId: randomUUID34() }), null, 2));
       return;
     }
     if (subcommand === "policy-readiness") {
@@ -110855,7 +112138,7 @@ async function workspaceCommand(args) {
       const workspaceId = args[1];
       const cwd = process.cwd();
       const authorizationServer = localWorkspaceAuthorizationServer();
-      const actor = await authorizationServer.actorContextFor(undefined, randomUUID33());
+      const actor = await authorizationServer.actorContextFor(undefined, randomUUID34());
       if (!actor)
         throw new Error("trusted ActorContext is required");
       if (workspaceId) {
@@ -111594,13 +112877,17 @@ Commands:
   forgetting Read the deletion trail \u2014 was this removed, or did it never exist?
 `);
 }
+function exitCodeForError(error) {
+  return error instanceof ShellFlagError ? error.exitCode : 1;
+}
 if (import.meta.main) {
   main().catch((error) => {
     console.error(error instanceof Error ? error.message : String(error));
-    process.exitCode = 1;
+    process.exitCode = exitCodeForError(error);
   });
 }
 export {
   CLI_ROUTES,
+  exitCodeForError,
   main
 };