@mrciphersmith/keryx 0.2.121 → 0.2.122

package/dist/cli.js

@@ -42980,6 +42980,103 @@ async function startStdioTransport(server) {
   await server.connect(transport);
 }
 
+// src/tui/debug-log.ts
+import path192 from "path";
+function isDebugEnabled() {
+  return activeRun !== undefined;
+}
+function currentDebugRun() {
+  return activeRun;
+}
+function debugEvent(kind, data = {}) {
+  const run = activeRun;
+  if (run === undefined) {
+    return;
+  }
+  seq += 1;
+  try {
+    appendOwnerOnlyLine(run.shellLog, safeStringify({ ts: new Date().toISOString(), seq, pid: process.pid, kind, ...data }));
+  } catch {}
+}
+function callerStack() {
+  const raw = new Error("stack").stack ?? "";
+  return raw.split(`
+`).slice(1).filter((line) => !line.includes("debug-log.ts")).slice(0, 14).map((line) => line.trim()).join(" | ");
+}
+function startDebugRun(opts = {}) {
+  const stamp = (opts.now ?? new Date).toISOString().replace(/[:.]/g, "-");
+  const name = `${stamp}-${process.pid}`;
+  const dir = ensureKeryxSubdir(["debug", name], opts.configDir);
+  const run = {
+    dir,
+    shellLog: path192.join(dir, "shell.ndjson"),
+    watcherLog: path192.join(dir, "watcher.ndjson")
+  };
+  try {
+    writeOwnerOnlyFile(path192.join(path192.dirname(dir), "latest.txt"), `${dir}
+`);
+  } catch {}
+  activeRun = run;
+  seq = 0;
+  return run;
+}
+function summarizeInputChunk(chunk) {
+  const buf = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+  const text = buf.toString("utf8");
+  let printable = 0;
+  let control = 0;
+  const sequences = [];
+  for (let i = 0;i < text.length; i++) {
+    const ch = text[i] ?? "";
+    const code = ch.charCodeAt(0);
+    if (ch === "\x1B") {
+      let j = i + 1;
+      while (j < text.length && j - i < 48) {
+        const c = text.charCodeAt(j);
+        if (j > i + 1 && c >= 64 && c <= 126 && text[j] !== "[" && text[j] !== "<" && text[j] !== ";") {
+          break;
+        }
+        j++;
+      }
+      if (sequences.length < 12) {
+        sequences.push(Buffer.from(text.slice(i, j + 1)).toString("hex"));
+      }
+      control++;
+      i = j;
+    } else if (code < 32 || code === 127) {
+      control++;
+      if (sequences.length < 12) {
+        sequences.push(Buffer.from(ch).toString("hex"));
+      }
+    } else {
+      printable++;
+    }
+  }
+  return { bytes: buf.length, printable, control, sequences };
+}
+function safeStringify(value) {
+  const seen = new WeakSet;
+  return JSON.stringify(value, (_key, v) => {
+    if (typeof v === "bigint") {
+      return v.toString();
+    }
+    if (v instanceof Error) {
+      return { name: v.name, message: v.message, stack: v.stack };
+    }
+    if (v !== null && typeof v === "object") {
+      if (seen.has(v)) {
+        return "[circular]";
+      }
+      seen.add(v);
+    }
+    return v;
+  });
+}
+var activeRun, seq = 0;
+var init_debug_log = __esm(() => {
+  init_config_dir();
+});
+
 // src/lib/oauth/device-code.ts
 function requestInit(base, signal) {
   return signal === undefined ? base : { ...base, signal };
@@ -43472,6 +43569,259 @@ var init_login = __esm(() => {
   SESSION_REFRESHED_GRANTS = ["grok", "github-copilot"];
 });
 
+// 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";
+function parseEpollFdinfo(text) {
+  const out = [];
+  for (const line of text.split(`
+`)) {
+    const match = /^tfd:\s*(\d+)\s+events:\s*([0-9a-fA-F]+)/.exec(line.trim());
+    if (match?.[1] !== undefined && match[2] !== undefined) {
+      out.push({ tfd: Number(match[1]), events: Number.parseInt(match[2], 16) });
+    }
+  }
+  return out;
+}
+function ttyReaderArmed(ttyFds, epoll) {
+  if (ttyFds.length === 0) {
+    return;
+  }
+  return epoll.some((entry) => ttyFds.includes(entry.tfd) && (entry.events & EPOLLIN) !== 0);
+}
+function detectStall(history, window = 3) {
+  if (history.length < window) {
+    return;
+  }
+  const recent = history.slice(-window);
+  if (recent.every((s) => s.alive && s.readerArmed === false)) {
+    return "reader-not-polled";
+  }
+  if (recent.every((s) => s.alive && (s.pending ?? 0) > 0) && recent.every((s, i) => i === 0 || (s.pending ?? 0) >= (recent[i - 1]?.pending ?? 0))) {
+    return "input-not-drained";
+  }
+  if (recent.every((s) => s.alive && (s.heartbeatAgeMs ?? 0) > 5000)) {
+    return "event-loop-silent";
+  }
+  return;
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readText(file) {
+  try {
+    return readFileSync9(file, "utf8");
+  } catch {
+    return;
+  }
+}
+function listFds(pid) {
+  const out = [];
+  let entries;
+  try {
+    entries = readdirSync3(`/proc/${pid}/fd`);
+  } catch {
+    return out;
+  }
+  for (const name of entries) {
+    const fd = Number(name);
+    let link;
+    try {
+      link = readlinkSync(`/proc/${pid}/fd/${name}`);
+    } catch {
+      continue;
+    }
+    const flags = /flags:\s*(\S+)/.exec(readText(`/proc/${pid}/fdinfo/${name}`) ?? "")?.[1];
+    out.push({ fd, link, flags });
+  }
+  return out;
+}
+function epollEntries(pid, fds) {
+  return fds.filter((f) => f.link === "anon_inode:[eventpoll]").map((f) => ({ epfd: f.fd, entries: parseEpollFdinfo(readText(`/proc/${pid}/fdinfo/${f.fd}`) ?? "") }));
+}
+function threads(pid) {
+  let tids;
+  try {
+    tids = readdirSync3(`/proc/${pid}/task`);
+  } catch {
+    return [];
+  }
+  return tids.map((tid) => {
+    const base = `/proc/${pid}/task/${tid}`;
+    const stat = readText(`${base}/stat`) ?? "";
+    const state = /\)\s+(\S)/.exec(stat)?.[1] ?? "?";
+    return { tid, comm: (readText(`${base}/comm`) ?? "").trim(), wchan: (readText(`${base}/wchan`) ?? "").trim(), state };
+  });
+}
+async function makePendingReader() {
+  if (process.platform !== "linux") {
+    return () => {
+      return;
+    };
+  }
+  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 }
+    });
+    return (fd) => {
+      const out = new Int32Array(1);
+      const rc = libc.symbols.ioctl(fd, FIONREAD, ffi.ptr(out));
+      return rc === 0 ? out[0] ?? 0 : undefined;
+    };
+  } catch {
+    return () => {
+      return;
+    };
+  }
+}
+function spawnDebugWatcher(run) {
+  const entry = process.argv[1];
+  const args = [
+    ...entry !== undefined ? [entry] : [],
+    "shell",
+    "--debug-watcher",
+    "--pid",
+    String(process.pid),
+    "--dir",
+    run.dir
+  ];
+  try {
+    const child = spawn6(process.execPath, args, { detached: true, stdio: "ignore", env: process.env });
+    child.unref();
+    return child.pid;
+  } catch {
+    return;
+  }
+}
+async function runDebugWatcher(argv) {
+  const pidArg = argv[argv.indexOf("--pid") + 1];
+  const dirArg = argv[argv.indexOf("--dir") + 1];
+  const pid = Number(pidArg);
+  if (!Number.isInteger(pid) || pid <= 0 || dirArg === undefined || !argv.includes("--dir")) {
+    process.stderr.write(`usage: keryx shell --debug-watcher --pid <pid> --dir <debug run dir>
+`);
+    process.exitCode = 2;
+    return;
+  }
+  const logFile = path195.join(dirArg, "watcher.ndjson");
+  const shellLog = path195.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();
+  let ttyPath;
+  let ttyFd;
+  if (linux) {
+    try {
+      ttyPath = readlinkSync(`/proc/${pid}/fd/0`);
+      if (isTtyLink(ttyPath)) {
+        ttyFd = openSync3(ttyPath, constants2.O_RDONLY | constants2.O_NONBLOCK | constants2.O_NOCTTY);
+      }
+    } catch (error) {
+      log("tty.open-failed", { error: String(error) });
+    }
+  }
+  log("watcher.start", { linux, ttyPath, fionread: ttyFd !== undefined && pendingOf(ttyFd) !== undefined });
+  const history = [];
+  let lastLogged = "";
+  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 });
+      stty = (res.stdout ?? "").trim() || (res.stderr ?? "").trim();
+    }
+    return {
+      stat: (readText(`/proc/${pid}/stat`) ?? "").trim(),
+      status: (readText(`/proc/${pid}/status`) ?? "").split(`
+`).filter((l) => /^(State|Threads|SigBlk|SigIgn|SigCgt|VmRSS):/.test(l)),
+      fds,
+      epoll: epollEntries(pid, fds),
+      threads: threads(pid),
+      stty
+    };
+  };
+  const tick = () => {
+    const alive = isAlive(pid);
+    const sample = { alive };
+    if (alive && linux) {
+      const fds = listFds(pid);
+      const ttyFds = fds.filter((f) => isTtyLink(f.link)).map((f) => f.fd);
+      const entries = epollEntries(pid, fds).flatMap((e) => e.entries);
+      sample.readerArmed = ttyReaderArmed(ttyFds, entries);
+    }
+    if (alive && ttyFd !== undefined) {
+      sample.pending = pendingOf(ttyFd);
+    }
+    try {
+      sample.heartbeatAgeMs = Date.now() - statSync6(shellLog).mtimeMs;
+    } catch {
+      sample.heartbeatAgeMs = undefined;
+    }
+    history.push(sample);
+    if (history.length > 30)
+      history.shift();
+    if (!alive) {
+      log("target.exit");
+      return false;
+    }
+    const key = JSON.stringify({ a: sample.readerArmed, p: (sample.pending ?? 0) > 0 });
+    const now = Date.now();
+    if (key !== lastLogged || now - lastPeriodic > 1e4) {
+      log("sample", { ...sample });
+      lastLogged = key;
+      lastPeriodic = now;
+    }
+    const stall = detectStall(history);
+    if (stall !== undefined && now - lastSignal > 15000) {
+      lastSignal = now;
+      log("stall.detected", { reason: stall, recent: history.slice(-5), snapshot: linux ? fullSnapshot() : {} });
+      if (stall !== "event-loop-silent" && process.platform !== "win32") {
+        try {
+          process.kill(pid, "SIGUSR2");
+          log("recover.signal-sent", { signal: "SIGUSR2" });
+        } catch (error) {
+          log("recover.signal-failed", { error: String(error) });
+        }
+        setTimeout(() => {
+          log("recover.after", { snapshot: linux ? fullSnapshot() : {}, pending: ttyFd !== undefined ? pendingOf(ttyFd) : undefined });
+        }, 2000);
+      }
+    }
+    return true;
+  };
+  await new Promise((resolve) => {
+    const timer = setInterval(() => {
+      if (!tick()) {
+        clearInterval(timer);
+        resolve();
+      }
+    }, 1000);
+  });
+  if (ttyFd !== undefined) {
+    try {
+      closeSync3(ttyFd);
+    } catch {}
+  }
+  log("watcher.stop");
+}
+var EPOLLIN = 1, FIONREAD = 21531, isTtyLink = (link) => link.startsWith("/dev/pts/") || /^\/dev\/tty/.test(link);
+var init_debug_watcher = __esm(() => {
+  init_config_dir();
+});
+
 // src/cli.ts
 init_single_turn();
 init_model_turn_port();
@@ -50274,7 +50624,7 @@ import path47 from "path";
 // package.json
 var package_default = {
   name: "@mrciphersmith/keryx",
-  version: "0.2.121",
+  version: "0.2.122",
   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: {
@@ -90550,6 +90900,9 @@ function classifyBusyDispatch(params) {
   return "not-a-command";
 }
 
+// src/tui/tui-shell.ts
+init_debug_log();
+
 // src/tui/boot-animation.ts
 var DEFAULT_BOOT_DURATION_MS = 350;
 var WORDMARK = ["========================", "       K E R Y X        ", "========================"];
@@ -94050,10 +94403,10 @@ function describeElicitationPrompt(tool, inputJson) {
 // src/lib/permission-mode-config.ts
 init_permission_mode();
 init_config_dir();
-import path192 from "path";
+import path193 from "path";
 var EMPTY3 = { schemaVersion: 1, projects: {} };
 function permissionModeConfigPath(dir) {
-  return path192.join(keryxConfigDir(dir), "permission-mode.json");
+  return path193.join(keryxConfigDir(dir), "permission-mode.json");
 }
 function withRegistryLock2(dir, fn) {
   return withFileLock2(`${permissionModeConfigPath(dir)}.lock`, fn, {
@@ -94297,6 +94650,7 @@ function createForegroundAgentIoFacade(owner, token, io) {
 }
 
 // src/tui/herdr-report.ts
+init_debug_log();
 import net from "net";
 var SOURCE = "herdr:keryx";
 var AGENT = "keryx";
@@ -94336,6 +94690,7 @@ function createHerdrReporter(clock = () => Date.now(), connect = writeOnce) {
       if (state === last)
         return;
       last = state;
+      debugEvent("herdr.report", { state });
       send("pane.report_agent", { state });
     },
     release() {
@@ -94371,6 +94726,14 @@ function writeOnce(socketPath, request) {
 }
 
 // src/tui/composer-choice.ts
+init_debug_log();
+var DEFAULT_ACCEPT_DELAY_MS = 400;
+function resolveAcceptDelay(request) {
+  if (request.acceptDelayMs !== undefined) {
+    return Math.max(0, request.acceptDelayMs);
+  }
+  return DEFAULT_ACCEPT_DELAY_MS;
+}
 var MAX_SUBTITLE_CHARS = 8000;
 var MAX_SUBTITLE_ROWS = 10;
 var SUBTITLE_INLINE_MAX_CHARS = 76;
@@ -94408,12 +94771,17 @@ function lockDock(dock) {
 async function showComposerChoice(otui, r, dock, request) {
   const enqueue = request.enqueue !== false;
   if (!enqueue && dockBusy(dock)) {
+    debugEvent("choice.busy-cancel", { title: request.title });
     request.onBusy?.();
     return request.cancelId;
   }
+  const queuedAt = Date.now();
+  debugEvent("choice.request", { title: request.title, waitingBehind: dockDepth.get(dock) ?? 0 });
   const unlock = await lockDock(dock);
+  debugEvent("choice.lock-acquired", { title: request.title, waitedMs: Date.now() - queuedAt });
   try {
     if (request.signal?.aborted === true) {
+      debugEvent("choice.aborted-before-open", { title: request.title });
       return request.cancelId;
     }
     return await presentComposerChoice(otui, r, dock, request);
@@ -94423,6 +94791,7 @@ async function showComposerChoice(otui, r, dock, request) {
 }
 function presentComposerChoice(otui, r, dock, request) {
   if (dock.visible === true) {
+    debugEvent("choice.dock-already-visible", { title: request.title });
     request.onBusy?.();
     return Promise.resolve(request.cancelId);
   }
@@ -94434,6 +94803,9 @@ function presentComposerChoice(otui, r, dock, request) {
     const recommendedIdx = options.findIndex((o) => o.recommended === true);
     let selected = recommendedIdx >= 0 ? recommendedIdx : 0;
     dock.visible = true;
+    const openedAt = Date.now();
+    const acceptDelayMs = resolveAcceptDelay(request);
+    let lastTypedAt = 0;
     request.onOpen?.();
     const theme = getTheme();
     const rawSubtitle = request.subtitle !== undefined && request.subtitle.length > 0 ? request.subtitle : undefined;
@@ -94501,13 +94873,14 @@ function presentComposerChoice(otui, r, dock, request) {
     };
     let settled = false;
     const onAbort = () => {
-      finish(request.cancelId);
+      finish(request.cancelId, "abort");
     };
-    const finish = (id) => {
+    const finish = (id, via = "key") => {
       if (settled) {
         return;
       }
       settled = true;
+      debugEvent("choice.finish", { title: request.title, id, via, openMs: Date.now() - openedAt });
       cleanup();
       resolve(id);
     };
@@ -94518,7 +94891,7 @@ function presentComposerChoice(otui, r, dock, request) {
         width: "100%",
         flexDirection: "column",
         onMouseDown: () => {
-          finish(o.id);
+          finish(o.id, "click");
         }
       });
       const label = new otui.TextRenderable(r, { id: `ch-opt-l-${i}-${Date.now()}`, content: o.displayLabel });
@@ -94576,8 +94949,11 @@ function presentComposerChoice(otui, r, dock, request) {
       dock.visible = false;
     }
     const onKey = (key) => {
+      if (!key.ctrl && typeof key.sequence === "string" && key.sequence.length === 1 && key.sequence >= " ") {
+        lastTypedAt = Date.now();
+      }
       if (key.name === "escape") {
-        finish(request.cancelId);
+        finish(request.cancelId, "escape");
         key.preventDefault();
         key.stopPropagation();
         return;
@@ -94614,6 +94990,17 @@ function presentComposerChoice(otui, r, dock, request) {
         return;
       }
       if (key.name === "return" || key.name === "linefeed" || key.name === "kpenter") {
+        const now = Date.now();
+        if (now - openedAt < acceptDelayMs || now - lastTypedAt < acceptDelayMs) {
+          debugEvent("choice.enter-ignored", {
+            title: request.title,
+            sinceOpenMs: now - openedAt,
+            sinceTypingMs: lastTypedAt === 0 ? undefined : now - lastTypedAt
+          });
+          key.preventDefault();
+          key.stopPropagation();
+          return;
+        }
         const chosen = options[selected];
         if (chosen !== undefined) {
           finish(chosen.id);
@@ -94627,13 +95014,20 @@ function presentComposerChoice(otui, r, dock, request) {
       request.signal.addEventListener("abort", onAbort, { once: true });
     }
     optionsScroll.focus();
+    debugEvent("choice.open", {
+      title: request.title,
+      options: options.map((o) => o.id),
+      selected: options[selected]?.id,
+      scrollableSubtitle: hasScrollableSubtitle,
+      acceptDelayMs
+    });
   });
 }
 
 // src/lib/version-check.ts
 init_config_dir();
 init_fs();
-import path193 from "path";
+import path194 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;
@@ -94835,7 +95229,7 @@ async function checkVersion(options) {
   const now = options.now ?? Date.now;
   const timestamp = now();
   const configDir = ensureKeryxConfigDir(options.cacheDir);
-  const cacheFile = path193.join(configDir, "version-check.json");
+  const cacheFile = path194.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");
@@ -94903,6 +95297,236 @@ async function checkVersion(options) {
   return resultFor(options.currentVersion, current, latestVersion, "registry");
 }
 
+// src/tui/shell-chrome.ts
+init_debug_log();
+
+// src/tui/renderer-debug.ts
+init_debug_log();
+
+// src/tui/stdin-guard.ts
+init_debug_log();
+var rendererListener;
+function stdinSnapshot(stdin) {
+  const safe = (read) => {
+    try {
+      return read();
+    } catch (error) {
+      return `error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  };
+  return {
+    isTTY: safe(() => stdin.isTTY === true),
+    isRaw: safe(() => stdin.isRaw),
+    paused: safe(() => stdin.isPaused()),
+    flowing: safe(() => stdin.readableFlowing),
+    ended: safe(() => stdin.readableEnded),
+    destroyed: safe(() => stdin.destroyed),
+    buffered: safe(() => stdin.readableLength),
+    dataListeners: safe(() => stdin.listenerCount("data")),
+    readableListeners: safe(() => stdin.listenerCount("readable")),
+    rendererAttached: safe(() => rendererListener === undefined ? undefined : stdin.listeners("data").includes(rendererListener))
+  };
+}
+function stdinLooksStalled(snapshot) {
+  return snapshot.paused === true || snapshot.flowing === false || snapshot.ended === true || snapshot.destroyed === true || snapshot.dataListeners === 0 || snapshot.rendererAttached === false || snapshot.isTTY === true && snapshot.isRaw === false;
+}
+function registerRendererInputListener(listener) {
+  rendererListener = listener;
+}
+function recoverStdin(stdin, opts = {}) {
+  const actions = [];
+  const listener = opts.listener ?? rendererListener;
+  const step = (name, run) => {
+    try {
+      run();
+      actions.push(name);
+    } catch (error) {
+      actions.push(`${name} failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  };
+  if (stdin.isTTY === true && typeof stdin.setRawMode === "function" && stdin.isRaw !== true) {
+    step("setRawMode(true)", () => stdin.setRawMode?.(true));
+  }
+  if (listener !== undefined && !stdin.listeners("data").includes(listener)) {
+    step("re-attach renderer data listener", () => stdin.on("data", listener));
+  }
+  if (opts.cycle === true) {
+    step("pause()", () => stdin.pause());
+  }
+  step("resume()", () => stdin.resume());
+  return actions;
+}
+function instrumentStdin(stdin) {
+  const target = stdin;
+  const restores = [];
+  const wrap = (method, describe = () => ({})) => {
+    const original = target[method];
+    if (typeof original !== "function") {
+      return;
+    }
+    const fn = original;
+    target[method] = function(...args) {
+      debugEvent(`stdin.${method}`, { ...describe(args), before: stdinSnapshot(stdin), stack: callerStack() });
+      return fn.apply(this, args);
+    };
+    restores.push(() => {
+      target[method] = original;
+    });
+  };
+  const eventName = (args) => ({ event: String(args[0]) });
+  wrap("pause");
+  wrap("resume");
+  wrap("setRawMode", (args) => ({ mode: args[0] }));
+  wrap("removeListener", eventName);
+  wrap("off", eventName);
+  wrap("removeAllListeners", eventName);
+  wrap("destroy");
+  wrap("unref");
+  wrap("unpipe");
+  wrap("setEncoding", (args) => ({ encoding: args[0] }));
+  const lifecycle = [];
+  for (const event of ["end", "close", "error", "pause", "resume"]) {
+    const handler = (...args) => {
+      debugEvent(`stdin.event.${event}`, { args: args.map((a) => a instanceof Error ? a : String(a)), state: stdinSnapshot(stdin) });
+    };
+    lifecycle.push([event, handler]);
+  }
+  const onData = (chunk) => {
+    debugEvent("stdin.data", summarizeInputChunk(chunk));
+  };
+  lifecycle.push(["data", onData]);
+  for (const [event, handler] of lifecycle) {
+    if (event === "error" && stdin.listenerCount("error") === 0) {
+      continue;
+    }
+    stdin.on(event, handler);
+  }
+  debugEvent("stdin.instrumented", { state: stdinSnapshot(stdin) });
+  return () => {
+    for (const restore of restores)
+      restore();
+    for (const [event, handler] of lifecycle)
+      stdin.off?.(event, handler);
+  };
+}
+function startStdinHeartbeat(stdin, opts = {}) {
+  const intervalMs = opts.intervalMs ?? 1000;
+  const cooldownMs = opts.cooldownMs ?? 1e4;
+  let lastRecovery = 0;
+  const timer = setInterval(() => {
+    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) });
+    }
+  }, intervalMs);
+  timer.unref?.();
+  return () => clearInterval(timer);
+}
+function installInputRecoverySignal(stdin, onRecovered, shouldRecover = () => true) {
+  if (process.platform === "win32") {
+    return () => {};
+  }
+  const handler = () => {
+    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);
+    debugEvent("signal.SIGUSR2.recover", { before, actions, after, debug: isDebugEnabled() });
+    try {
+      onRecovered?.(actions);
+    } catch {}
+  };
+  process.on("SIGUSR2", handler);
+  return () => {
+    process.off("SIGUSR2", handler);
+  };
+}
+
+// src/tui/renderer-debug.ts
+function attachRendererGuards(r, stdin = process.stdin) {
+  const internals = r;
+  registerRendererInputListener(internals.stdinListener);
+  const shouldRecover = () => !r.isDestroyed && internals.controlState !== "explicit_suspended";
+  const teardown = [];
+  teardown.push(installInputRecoverySignal(stdin, () => {
+    r.requestRender();
+  }, shouldRecover));
+  teardown.push(() => registerRendererInputListener(undefined));
+  if (!isDebugEnabled()) {
+    return () => {
+      for (const fn of teardown.splice(0))
+        fn();
+    };
+  }
+  debugEvent("renderer.created", {
+    controlState: internals.controlState,
+    width: r.width,
+    height: r.height,
+    hasStdinListener: internals.stdinListener !== undefined
+  });
+  teardown.push(instrumentStdin(stdin));
+  teardown.push(startStdinHeartbeat(stdin, {
+    shouldRecover,
+    extra: () => ({
+      controlState: internals.controlState,
+      focused: internals.currentFocusedRenderable?.id
+    })
+  }));
+  const onKey = (key) => {
+    const printable = key.sequence.length === 1 && key.sequence >= " " && !key.ctrl && !key.meta;
+    queueMicrotask(() => {
+      debugEvent("key", {
+        name: printable ? "<printable>" : key.name,
+        ctrl: key.ctrl,
+        meta: key.meta,
+        shift: key.shift,
+        prevented: key.defaultPrevented,
+        stopped: key.propagationStopped,
+        focused: internals.currentFocusedRenderable?.id
+      });
+    });
+  };
+  internals._internalKeyInput?.onInternal("keypress", onKey);
+  teardown.push(() => internals._internalKeyInput?.offInternal("keypress", onKey));
+  const emitter = r;
+  for (const event of ["resize", "focus", "blur", "capabilities"]) {
+    const fn = (...args) => {
+      debugEvent(`renderer.${event}`, event === "capabilities" ? {} : { args: args.map(String) });
+    };
+    emitter.on?.(event, fn);
+    teardown.push(() => emitter.off?.(event, fn));
+  }
+  const target = r;
+  for (const method of ["suspend", "resume", "pause", "stop", "destroy"]) {
+    const original = target[method];
+    if (typeof original !== "function")
+      continue;
+    const fn = original;
+    target[method] = function(...args) {
+      debugEvent(`renderer.${method}`, { controlState: internals.controlState, stack: callerStack() });
+      return fn.apply(this, args);
+    };
+    teardown.push(() => {
+      target[method] = original;
+    });
+  }
+  return () => {
+    debugEvent("renderer.teardown");
+    for (const fn of teardown.splice(0)) {
+      try {
+        fn();
+      } catch {}
+    }
+  };
+}
+
 // src/tui/shell-chrome.ts
 function onKeypress3(r, handler) {
   r._internalKeyInput.onInternal("keypress", handler);
@@ -95008,14 +95632,20 @@ function prefixFilter(commands, query) {
   return commands.filter((c) => c.name.slice(1).toLowerCase().startsWith(needle));
 }
 async function createShellRenderer(otui, opts = {}) {
-  return await otui.createCliRenderer({
+  const guards = {};
+  const renderer = await otui.createCliRenderer({
     exitOnCtrlC: true,
     screenMode: "alternate-screen",
     clearOnShutdown: true,
     useMouse: true,
     backgroundColor: getTheme().bg,
-    ...opts.onDestroy !== undefined ? { onDestroy: opts.onDestroy } : {}
+    onDestroy: () => {
+      guards.detach?.();
+      opts.onDestroy?.();
+    }
   });
+  guards.detach = attachRendererGuards(renderer);
+  return renderer;
 }
 async function createShellChrome(otui, renderer, opts) {
   const r = renderer;
@@ -95178,10 +95808,12 @@ async function createShellChrome(otui, renderer, opts) {
   };
   const withOverlay = async (run) => {
     overlayDepth += 1;
+    debugEvent("overlay.enter", { depth: overlayDepth, dockVisible: dock.visible });
     try {
       return await run();
     } finally {
       overlayDepth -= 1;
+      debugEvent("overlay.exit", { depth: overlayDepth, dockVisible: dock.visible });
     }
   };
   const addOverlaySource = (isActive) => {
@@ -95430,9 +96062,11 @@ async function createShellChrome(otui, renderer, opts) {
   });
   textarea.onSubmit = () => {
     if (overlayActive()) {
+      debugEvent("composer.submit-blocked", { reason: "overlay active", dockVisible: dock.visible, overlayDepth });
       return;
     }
     const line = input.value.trim();
+    debugEvent("composer.submit", { chars: line.length, slash: line.startsWith("/") });
     input.value = "";
     hideMenu();
     syncComposerHeight();
@@ -95550,6 +96184,15 @@ async function createShellChrome(otui, renderer, opts) {
     appliedTheme = theme;
   };
   const unsubTheme = onThemeChange((theme) => applyTheme(theme));
+  {
+    const run = currentDebugRun();
+    if (run !== undefined) {
+      setTimeout(() => {
+        if (alive)
+          showToast(`debug log: ${run.dir}`);
+      }, 0);
+    }
+  }
   return {
     renderer: r,
     root: rootRow,
@@ -98114,6 +98757,7 @@ function attachBlockIo(io, addBlock, chrome = {}, thinkDisplay = () => "auto") {
     });
   };
   io.onToolCall = (name, input) => {
+    debugEvent("tool.call", { name, inputChars: input.length });
     chrome.onToolCall?.(name, input);
     const args = summarizeToolArgs(input);
     addBlock({
@@ -98125,6 +98769,7 @@ function attachBlockIo(io, addBlock, chrome = {}, thinkDisplay = () => "auto") {
     }, { hint: "ctrl+o", tone: "cyan" });
   };
   io.onToolResult = (name, result) => {
+    debugEvent("tool.result", { name, isError: result.isError === true, outputChars: result.output.length });
     chrome.onToolResult?.(name, result);
     const { summary, lineCount, hidden } = collapseToolOutput(result.output);
     const more = hidden > 0 ? ` \xB7 +${hidden} more` : "";
@@ -98292,6 +98937,9 @@ async function applyRuntimeSwitchToSlate(params) {
   params.onHistoryChange?.("tool");
   return true;
 }
+function freshSlateSessionRef(sessionDir, cwd) {
+  return { dir: sessionDir, cwd, opened: false };
+}
 function fmtTokens(n) {
   return n >= 1000 ? `${(n / 1000).toFixed(1)}K` : String(n);
 }
@@ -99432,6 +100080,7 @@ async function launchTuiAgentShell(opts) {
     let busyStartedAt = 0;
     const setBusyPhase = (phase) => {
       busyPhase = phase;
+      debugEvent("busy.phase", { phase });
       chrome.setBusyPhase(phase);
     };
     const startBusy = (phase = "waiting for model") => {
@@ -99654,6 +100303,7 @@ async function launchTuiAgentShell(opts) {
       })();
     };
     const setMainAgent = (status, detail) => {
+      debugEvent("main-agent", { status, detail });
       fleet.upsert({
         id: MAIN_AGENT_ID,
         label: "main",
@@ -100099,6 +100749,9 @@ async function launchTuiAgentShell(opts) {
     let nextArchiveIndex = 0;
     let sessionPersistTimer;
     let slateSession;
+    const bindSlateToLiveSession = () => {
+      slateSession = freshSlateSessionRef(liveSession.dir, sessionCwd);
+    };
     const onContextCompaction = (r) => {
       const persisted = persistCompacted(liveSession, r.context, archive, {
         provider: currentSel.provider,
@@ -100232,7 +100885,7 @@ async function launchTuiAgentShell(opts) {
         model: currentSel.model
       }));
     }
-    slateSession = { dir: liveSession.dir, cwd: sessionCwd, opened: false };
+    bindSlateToLiveSession();
     if (history.length === 0) {
       removeSplash = mountEmptyTranscriptSplash(otui, r, transcript);
     }
@@ -100333,6 +100986,8 @@ Staying in the current session.
         return;
       }
       applyOpened(opened, true);
+      bindSlateToLiveSession();
+      refreshWorkspaceSidebar();
       paintSessionHeader();
       if (opened.archiveDegraded !== undefined) {
         io.onSystem?.(`Archive unavailable \u2014 resumed from the active context (${opened.archiveDegraded})
@@ -101231,7 +101886,7 @@ Staying in the current session.
           (async () => {
             await closeSlateSession(slateSession, mintTimestampAttemptId);
             startNewSession();
-            slateSession = { dir: liveSession.dir, cwd: sessionCwd, opened: false };
+            bindSlateToLiveSession();
             refreshWorkspaceSidebar();
             refreshReviewSidebar();
             sessions.clear();
@@ -103663,6 +104318,7 @@ function parseShellCliFlags(args) {
   let printPromptArg;
   let eventsFile;
   let eventsMaxField;
+  let debug;
   for (let i = 0;i < args.length; i++) {
     const arg = args[i];
     if (arg === "--provider") {
@@ -103713,6 +104369,8 @@ function parseShellCliFlags(args) {
       i += 1;
     } else if (arg === "--events-file") {
       eventsFile = valueAfter(i++);
+    } else if (arg === "--debug") {
+      debug = true;
     } else if (arg === "--events-max-field") {
       const raw = valueAfter(i++);
       const parsed = Number(raw);
@@ -103742,7 +104400,8 @@ function parseShellCliFlags(args) {
     ...denyTools !== undefined ? { denyTools } : {},
     ...printPromptArg !== undefined ? { printPrompt: printPromptArg } : {},
     ...eventsFile !== undefined ? { eventsFile } : {},
-    ...eventsMaxField !== undefined ? { eventsMaxField } : {}
+    ...eventsMaxField !== undefined ? { eventsMaxField } : {},
+    ...debug === true ? { debug: true } : {}
   };
 }
 function chooseShellSurface(flags, isTty) {
@@ -103755,6 +104414,11 @@ function chooseShellSurface(flags, isTty) {
   return flags.modeFlag === false ? "tui-chat" : "tui-agent";
 }
 async function shellCommand(args, runtime = {}) {
+  if (args[0] === "--debug-watcher") {
+    await Promise.resolve().then(() => init_debug_watcher());
+    await runDebugWatcher(args.slice(1));
+    return;
+  }
   const flags = parseShellCliFlags(args);
   if (flags.help) {
     console.log(`Usage: keryx shell [options]
@@ -103773,13 +104437,42 @@ async function shellCommand(args, runtime = {}) {
   --print, -p <prompt>          Run one agent turn on this prompt and exit
   --events-file <path>          Append an NDJSON transcript (turns, tools, usage)
   --events-max-field <n>        Per-field character cap in that transcript (default 4000)
+  --debug                       Log the session (input, keys, dialogs, tools) and start a watcher
+                                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.
 
+A shell that stops reacting to keys can be recovered from another terminal
+with: kill -USR2 <keryx pid>
+
 Example: keryx shell --provider ollama --model llama3.1:latest`);
     return;
   }
+  if (flags.debug === true) {
+    await Promise.resolve().then(() => init_debug_log());
+    await Promise.resolve().then(() => init_debug_watcher());
+    const run = startDebugRun(runtime.cacheDir !== undefined ? { configDir: runtime.cacheDir } : {});
+    const watcherPid = spawnDebugWatcher(run);
+    debugEvent("session.start", {
+      version: package_default.version,
+      argv: args,
+      bun: typeof Bun !== "undefined" ? Bun.version : undefined,
+      platform: process.platform,
+      execPath: process.execPath,
+      cwd: process.cwd(),
+      stdinTTY: process.stdin.isTTY === true,
+      stdoutTTY: process.stdout.isTTY === true,
+      env: Object.fromEntries(["TERM", "TERM_PROGRAM", "COLORTERM", "TMUX", "HERDR_ENV", "HERDR_PANE_ID", "SSH_TTY", "LANG"].map((k) => [k, process.env[k]])),
+      watcherPid,
+      dir: run.dir
+    });
+    process.on("exit", (code) => {
+      debugEvent("session.exit", { code });
+      process.stderr.write(`keryx debug log: ${run.dir}
+`);
+    });
+  }
   const versionCheck = (runtime.checkVersion ?? (() => checkVersion({
     currentVersion: package_default.version,
     ...runtime.cacheDir !== undefined ? { cacheDir: runtime.cacheDir } : {}
@@ -104300,7 +104993,7 @@ Shell:
 init_fs();
 import { readFile as readFile99 } from "fs/promises";
 import { stdin } from "process";
-import path194 from "path";
+import path196 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 },
@@ -104346,8 +105039,8 @@ async function modulesCommand(args = []) {
     return;
   }
   const wantsJson = args.includes("--json") && (sub === undefined || sub === "status" || sub === "list" || sub === "--json");
-  const metaprojectRoot = path194.join(process.cwd(), ".metaproject");
-  const manifestPath = path194.join(metaprojectRoot, "metaproject.json");
+  const metaprojectRoot = path196.join(process.cwd(), ".metaproject");
+  const manifestPath = path196.join(metaprojectRoot, "metaproject.json");
   if (!await pathExists(manifestPath)) {
     if (wantsJson) {
       console.log(JSON.stringify({ schemaVersion: 1, error: "not-initialized", modules: [] }, null, 2));
@@ -104469,18 +105162,18 @@ init_config_dir();
 import { createHash as createHash44, randomBytes as randomBytes5, randomUUID as randomUUID30 } from "crypto";
 import {
   chmodSync as chmodSync4,
-  closeSync as closeSync3,
+  closeSync as closeSync4,
   existsSync as existsSync34,
   fsyncSync as fsyncSync2,
-  openSync as openSync3,
+  openSync as openSync4,
   renameSync as renameSync4,
-  statSync as statSync6,
+  statSync as statSync7,
   unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync9
 } from "fs";
-import path195 from "path";
+import path197 from "path";
 function serveCredentialPath(dir) {
-  return path195.join(keryxConfigDir(dir), "serve-credentials.json");
+  return path197.join(keryxConfigDir(dir), "serve-credentials.json");
 }
 function constantTimeEqual(a, b) {
   const width = Math.max(a.length, b.length);
@@ -104509,7 +105202,7 @@ function isGroupOrOtherAccessible(file) {
   if (process.platform === "win32") {
     return false;
   }
-  const mode = statSync6(file, { throwIfNoEntry: false })?.mode;
+  const mode = statSync7(file, { throwIfNoEntry: false })?.mode;
   return mode !== undefined && (mode & 63) !== 0;
 }
 function readServeCredential(dir) {
@@ -104553,13 +105246,13 @@ function writeStore(store, dir) {
   const temp = `${file}.${randomUUID30()}.tmp`;
   try {
     ensureKeryxConfigDir(dir);
-    const handle = openSync3(temp, "wx", 384);
+    const handle = openSync4(temp, "wx", 384);
     try {
       writeFileSync9(handle, `${JSON.stringify(store, null, 2)}
 `, { encoding: "utf8" });
       fsyncSync2(handle);
     } finally {
-      closeSync3(handle);
+      closeSync4(handle);
     }
     renameSync4(temp, file);
     tighten2(file, 384);
@@ -104713,23 +105406,23 @@ class AuthFailureThrottle {
 // src/lib/serve-turn-store.ts
 init_config_dir();
 import { createHash as createHash45 } from "crypto";
-import { existsSync as existsSync35, readdirSync as readdirSync3, rmSync as rmSync2 } from "fs";
-import path196 from "path";
+import { existsSync as existsSync35, readdirSync as readdirSync4, rmSync as rmSync2 } from "fs";
+import path198 from "path";
 var MAX_TURN_EVENTS = 1e4;
 function turnsRoot(dir) {
-  return path196.join(keryxConfigDir(dir), "turns");
+  return path198.join(keryxConfigDir(dir), "turns");
 }
 function turnDir(turnId, dir) {
-  return path196.join(turnsRoot(dir), turnId);
+  return path198.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 path196.join(turnsRoot(dir), "keys", `${digest}.json`);
+  return path198.join(turnsRoot(dir), "keys", `${digest}.json`);
 }
 function legacyKeyPath(idempotencyKey, dir) {
   const digest = createHash45("sha256").update(idempotencyKey, "utf8").digest("hex");
-  return path196.join(turnsRoot(dir), "keys", `${digest}.json`);
+  return path198.join(turnsRoot(dir), "keys", `${digest}.json`);
 }
 function adoptLegacyClaim(project, idempotencyKey, dir) {
   const legacy = legacyKeyPath(idempotencyKey, dir);
@@ -104793,7 +105486,7 @@ function ensureTurnDir(turnId, dir) {
 }
 function createTurnRecord(record, dir) {
   ensureTurnDir(record.turnId, dir);
-  writeOwnerOnlyFile(path196.join(turnDir(record.turnId, dir), "turn.json"), `${JSON.stringify(record, null, 2)}
+  writeOwnerOnlyFile(path198.join(turnDir(record.turnId, dir), "turn.json"), `${JSON.stringify(record, null, 2)}
 `);
 }
 function appendTurnEvent(event, dir, opts) {
@@ -104802,12 +105495,12 @@ function appendTurnEvent(event, dir, opts) {
   }
   const line = JSON.stringify(event);
   try {
-    appendOwnerOnlyLine(path196.join(turnDir(event.turnId, dir), "events.jsonl"), line);
+    appendOwnerOnlyLine(path198.join(turnDir(event.turnId, dir), "events.jsonl"), line);
   } catch (error) {
     if (error?.code !== "ENOENT") {
       throw error;
     }
-    appendOwnerOnlyLine(path196.join(ensureTurnDir(event.turnId, dir), "events.jsonl"), line);
+    appendOwnerOnlyLine(path198.join(ensureTurnDir(event.turnId, dir), "events.jsonl"), line);
   }
   return true;
 }
@@ -104815,7 +105508,7 @@ function readTurnEvents(turnId, after = -1, dir) {
   if (!isTurnId(turnId)) {
     return { ok: false, reason: "not-a-turn-id" };
   }
-  const read = readTurnFile(path196.join(turnDir(turnId, dir), "events.jsonl"));
+  const read = readTurnFile(path198.join(turnDir(turnId, dir), "events.jsonl"));
   if (!read.ok) {
     if (isDefiniteAbsence2(read.reason)) {
       return { ok: true, value: [] };
@@ -104843,7 +105536,7 @@ function readTurnRecord(turnId, dir) {
   if (!isTurnId(turnId)) {
     return { ok: false, reason: "not-a-turn-id" };
   }
-  const read = readTurnFile(path196.join(turnDir(turnId, dir), "turn.json"));
+  const read = readTurnFile(path198.join(turnDir(turnId, dir), "turn.json"));
   if (!read.ok) {
     return { ok: false, reason: read.reason };
   }
@@ -104862,7 +105555,7 @@ function finishTurn(turnId, result, dir) {
   if (!record.ok) {
     return false;
   }
-  writeOwnerOnlyFile(path196.join(turnDir(turnId, dir), "turn.json"), `${JSON.stringify({ ...record.value, result }, null, 2)}
+  writeOwnerOnlyFile(path198.join(turnDir(turnId, dir), "turn.json"), `${JSON.stringify({ ...record.value, result }, null, 2)}
 `);
   return true;
 }
@@ -104908,7 +105601,7 @@ function releaseIdempotencyKey(project, idempotencyKey, turnId, dir) {
 
 // src/lib/serve-turn.ts
 import { randomUUID as randomUUID31 } from "crypto";
-import path197 from "path";
+import path199 from "path";
 init_service();
 var REMOTE_ORIGIN = "remote:http";
 var MAX_PROMPT_CHARS = 32000;
@@ -104977,9 +105670,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 = path197.resolve(declared);
+  const wanted = path199.resolve(declared);
   for (const entry of listProjects(dir, () => {})) {
-    if (path197.resolve(entry.path) === wanted) {
+    if (path199.resolve(entry.path) === wanted) {
       return { ok: true, project: entry.path };
     }
   }
@@ -106012,10 +106705,10 @@ function printHelp19() {
 }
 
 // src/commands/update.ts
-import { spawn as spawn6 } from "child_process";
+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 constants2, existsSync as existsSync36 } from "fs";
-import path198 from "path";
+import { access as access4, constants as constants3, existsSync as existsSync36 } from "fs";
+import path200 from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 init_config2();
 init_config();
@@ -106032,8 +106725,8 @@ async function updateCommand(args = []) {
     return;
   }
   const projectRoot = process.cwd();
-  const metaprojectRoot = path198.join(projectRoot, ".metaproject");
-  banner("keryx update", `Refreshing the .metaproject workspace in ${path198.basename(projectRoot)}/`);
+  const metaprojectRoot = path200.join(projectRoot, ".metaproject");
+  banner("keryx update", `Refreshing the .metaproject workspace in ${path200.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.`);
@@ -106106,7 +106799,7 @@ async function updateCommand(args = []) {
   nextSteps(steps);
 }
 async function previewServiceFiles(projectRoot, options) {
-  const metaprojectRoot = path198.join(projectRoot, ".metaproject");
+  const metaprojectRoot = path200.join(projectRoot, ".metaproject");
   const manifestState = await readManifest5(metaprojectRoot);
   const manifest = manifestState.manifest;
   const enableTasks = moduleEnabled2(manifest, "tasks") || !options.noTasks;
@@ -106135,12 +106828,12 @@ async function previewServiceFiles(projectRoot, options) {
   });
 }
 async function refreshServiceFiles(projectRoot, options) {
-  const metaprojectRoot = path198.join(projectRoot, ".metaproject");
+  const metaprojectRoot = path200.join(projectRoot, ".metaproject");
   const manifestState = await readManifest5(metaprojectRoot);
   const manifest = manifestState.manifest;
   const recoveredManifest = !manifestState.exists || !manifestState.valid;
   if (manifestState.migrated) {
-    await writeFile54(path198.join(metaprojectRoot, "metaproject.json"), `${JSON.stringify(manifest, null, 2)}
+    await writeFile54(path200.join(metaprojectRoot, "metaproject.json"), `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
   }
   const enableGdgraph = moduleEnabled2(manifest, "gdgraph");
@@ -106177,9 +106870,9 @@ async function refreshServiceFiles(projectRoot, options) {
     enableSecurity,
     enableSac
   });
-  await writeTextIfChanged4(path198.join(metaprojectRoot, "core", "README.md"), renderMetaprojectCoreReadme());
-  await writeTextIfChanged4(path198.join(metaprojectRoot, "hooks", "README.md"), renderHooksReadme());
-  await writeTextIfChanged4(path198.join(metaprojectRoot, "skills", "project-rules", "README.md"), renderProjectRulesSkillReadme({ sources: ruleSources }));
+  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 writeRoutingEntrypointPair(metaprojectRoot, {
     enableGdgraph,
     enableGdctx,
@@ -106202,7 +106895,7 @@ async function refreshServiceFiles(projectRoot, options) {
       }
     }
   });
-  await writeTextIfChanged4(path198.join(metaprojectRoot, "keryx-dashboard.html"), renderMetaprojectDashboardHtml({
+  await writeTextIfChanged4(path200.join(metaprojectRoot, "keryx-dashboard.html"), renderMetaprojectDashboardHtml({
     enableGdgraph,
     enableGdctx,
     enableGdwiki,
@@ -106214,7 +106907,7 @@ async function refreshServiceFiles(projectRoot, options) {
     enableSecurity,
     data: dashboardData
   }));
-  await writeTextIfMissing4(path198.join(metaprojectRoot, "README.md"), renderMetaprojectReadme({
+  await writeTextIfMissing4(path200.join(metaprojectRoot, "README.md"), renderMetaprojectReadme({
     enableGdgraph,
     enableGdctx,
     enableGdwiki,
@@ -106227,31 +106920,31 @@ async function refreshServiceFiles(projectRoot, options) {
   }));
   if (enableGdgraph) {
     await installGdgraphCoreScripts2(metaprojectRoot);
-    await writeTextIfChanged4(path198.join(metaprojectRoot, "modules", "gdgraph.md"), renderGdgraphManifest());
-    await writeTextIfChanged4(path198.join(metaprojectRoot, "core", "gdgraph", "README.md"), renderGdgraphCoreReadme());
-    await writeTextIfChanged4(path198.join(metaprojectRoot, "skills", "gdgraph", "SKILL.md"), renderGdgraphSkillReadme());
+    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 seedAssetsLock(metaprojectRoot);
     if (manifest.modules?.gdgraph?.hooks?.gitPostCommit) {
       await installManagedHook2(projectRoot, "post-commit", "gdgraph-post-commit", renderGdgraphPostCommitHook());
     }
   }
   if (enableGdctx) {
-    await writeTextIfMissing4(path198.join(metaprojectRoot, "gdctx.config.json"), renderGdctxConfig());
-    await writeTextIfChanged4(path198.join(metaprojectRoot, "modules", "gdctx.md"), renderGdctxManifest());
-    await writeTextIfChanged4(path198.join(metaprojectRoot, "core", "gdctx", "README.md"), renderGdctxCoreReadme());
-    await writeTextIfChanged4(path198.join(metaprojectRoot, "skills", "gdctx", "SKILL.md"), renderGdctxSkillReadme());
+    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());
   }
   if (enableGdwiki) {
-    await writeTextIfMissing4(path198.join(metaprojectRoot, "wiki", "templates", "page.md"), renderWikiPageTemplate());
-    await writeTextIfChanged4(path198.join(metaprojectRoot, "modules", "gdwiki.md"), renderGdwikiManifest());
-    await writeTextIfChanged4(path198.join(metaprojectRoot, "skills", "gdwiki", "SKILL.md"), renderGdwikiSkillReadme());
+    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());
     if (manifest.modules?.gdgraph?.hooks?.gitPostCommit) {
       await installManagedHook2(projectRoot, "post-commit", "gdwiki-post-commit", renderGdwikiPostCommitHook());
     }
   }
   if (enableSac) {
-    await writeTextIfMissing4(path198.join(metaprojectRoot, "modules", "sac.md"), renderSacManifest());
-    await writeTextIfChanged4(path198.join(metaprojectRoot, "skills", "sac", "SKILL.md"), renderSacSkillReadme());
+    await writeTextIfMissing4(path200.join(metaprojectRoot, "modules", "sac.md"), renderSacManifest());
+    await writeTextIfChanged4(path200.join(metaprojectRoot, "skills", "sac", "SKILL.md"), renderSacSkillReadme());
   }
   let gdskillsWarnings = [];
   let gdskillsNotices = [];
@@ -106264,25 +106957,25 @@ async function refreshServiceFiles(projectRoot, options) {
     }
   }
   if (enableHealth) {
-    await writeTextIfMissing4(path198.join(metaprojectRoot, "health.config.json"), renderHealthConfig());
-    await writeTextIfChanged4(path198.join(metaprojectRoot, "modules", "health.md"), renderHealthManifest());
-    await writeTextIfChanged4(path198.join(metaprojectRoot, "core", "health", "README.md"), renderHealthCoreReadme());
-    await writeTextIfChanged4(path198.join(metaprojectRoot, "skills", "health", "SKILL.md"), renderHealthSkillReadme());
+    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());
     if (manifest.modules?.health?.hooks?.gitPostCommit) {
       await installManagedHook2(projectRoot, "post-commit", "health-post-commit", renderHealthPostCommitHook());
     }
   }
   if (enableTesting) {
-    await writeTextIfMissing4(path198.join(metaprojectRoot, "testing.config.json"), renderTestingConfig({
+    await writeTextIfMissing4(path200.join(metaprojectRoot, "testing.config.json"), renderTestingConfig({
       postCommitRefresh: Boolean(manifest.modules?.testing?.hooks?.gitPostCommit),
       prePushGate: Boolean(manifest.modules?.testing?.hooks?.prePush)
     }));
-    await writeTextIfChanged4(path198.join(metaprojectRoot, "modules", "testing.md"), renderTestingManifest());
-    await writeTextIfChanged4(path198.join(metaprojectRoot, "core", "testing", "README.md"), renderTestingCoreReadme());
-    await writeTextIfChanged4(path198.join(metaprojectRoot, "skills", "testing", "SKILL.md"), renderTestingSkillReadme());
+    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());
     if (enableGdwiki) {
-      await writeTextIfMissing4(path198.join(metaprojectRoot, "wiki", "testing", "README.md"), renderTestingWikiReadme());
-      await writeTextIfMissing4(path198.join(metaprojectRoot, "wiki", "testing", "conventions.md"), renderTestingWikiConventions());
+      await writeTextIfMissing4(path200.join(metaprojectRoot, "wiki", "testing", "README.md"), renderTestingWikiReadme());
+      await writeTextIfMissing4(path200.join(metaprojectRoot, "wiki", "testing", "conventions.md"), renderTestingWikiConventions());
     }
     if (manifest.modules?.testing?.hooks?.gitPostCommit) {
       await installManagedHook2(projectRoot, "post-commit", "testing-post-commit", renderTestingPostCommitHook());
@@ -106295,24 +106988,24 @@ async function refreshServiceFiles(projectRoot, options) {
     await installManagedHook2(projectRoot, "post-commit", "metaproject-dashboard-post-commit", renderMetaprojectDashboardPostCommitHook());
   }
   if (enableMemory) {
-    await writeTextIfMissing4(path198.join(metaprojectRoot, "memory.config.json"), renderMemoryConfig());
-    await writeTextIfMissing4(path198.join(metaprojectRoot, "memory", "templates", "entry.md"), renderMemoryEntryTemplate());
-    await writeTextIfChanged4(path198.join(metaprojectRoot, "modules", "memory.md"), renderMemoryManifest());
-    await writeTextIfChanged4(path198.join(metaprojectRoot, "core", "memory", "README.md"), renderMemoryCoreReadme());
-    await writeTextIfChanged4(path198.join(metaprojectRoot, "skills", "memory", "SKILL.md"), renderMemorySkillReadme());
+    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());
   }
   if (enableTasks) {
-    await writeTextIfChanged4(path198.join(metaprojectRoot, "flows", "README.md"), renderFlowsReadme());
-    await writeTextIfChanged4(path198.join(metaprojectRoot, "modules", "tasks.md"), renderTasksManifest());
-    await writeTextIfChanged4(path198.join(metaprojectRoot, "skills", "flow", "SKILL.md"), renderFlowSkillRouter());
-    await writeTextIfChanged4(path198.join(metaprojectRoot, "skills", "flow", "init.md"), renderFlowInitSkill());
-    await writeTextIfChanged4(path198.join(metaprojectRoot, "skills", "flow", "manage.md"), renderFlowManageSkill());
-    await writeTextIfChanged4(path198.join(metaprojectRoot, "skills", "flow", "complete.md"), renderFlowCompleteSkill());
+    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());
   }
   if (enableSecurity) {
-    await writeTextIfMissing4(path198.join(metaprojectRoot, "security.config.json"), renderSecurityConfig());
-    await writeTextIfChanged4(path198.join(metaprojectRoot, "modules", "security.md"), renderSecurityManifest());
-    await writeTextIfChanged4(path198.join(metaprojectRoot, "core", "security", "README.md"), renderSecurityCoreReadme());
+    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());
     if (manifest.modules?.security?.hooks?.prePush) {
       await installManagedHook2(projectRoot, "pre-push", "security-pre-push", renderSecurityPrePushHook());
     }
@@ -106365,13 +107058,13 @@ async function refreshServiceFiles(projectRoot, options) {
   };
 }
 async function buildDashboard(projectRoot = process.cwd()) {
-  const metaprojectRoot = path198.join(projectRoot, ".metaproject");
+  const metaprojectRoot = path200.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 = path198.join(metaprojectRoot, "keryx-dashboard.html");
+  const dashboardPath = path200.join(metaprojectRoot, "keryx-dashboard.html");
   await writeTextIfChanged4(dashboardPath, renderMetaprojectDashboardHtml({
     enableGdgraph: moduleEnabled2(manifest, "gdgraph"),
     enableGdctx: moduleEnabled2(manifest, "gdctx"),
@@ -106391,7 +107084,7 @@ async function shouldInstallDashboardPostCommitHook(projectRoot, manifest) {
   if (Object.values(modules).some((module) => Boolean(module.hooks?.gitPostCommit))) {
     return true;
   }
-  const hookPath = path198.join(projectRoot, ".git", "hooks", "post-commit");
+  const hookPath = path200.join(projectRoot, ".git", "hooks", "post-commit");
   if (!await pathExists(hookPath)) {
     return false;
   }
@@ -106411,11 +107104,11 @@ async function collectDashboardData(metaprojectRoot) {
   if (testing) {
     data.testing = testing;
   }
-  const wiki = await collectMarkdownPages(path198.join(metaprojectRoot, "wiki"), "wiki");
+  const wiki = await collectMarkdownPages(path200.join(metaprojectRoot, "wiki"), "wiki");
   if (wiki.length > 0) {
     data.wiki = { pages: wiki };
   }
-  const memory = await collectMarkdownPages(path198.join(metaprojectRoot, "memory"), "memory");
+  const memory = await collectMarkdownPages(path200.join(metaprojectRoot, "memory"), "memory");
   if (memory.length > 0) {
     data.memory = { entries: memory };
   }
@@ -106430,7 +107123,7 @@ async function collectDashboardData(metaprojectRoot) {
   return data;
 }
 async function collectTasksDashboardData(metaprojectRoot) {
-  const flowsRoot = path198.join(metaprojectRoot, "flows");
+  const flowsRoot = path200.join(metaprojectRoot, "flows");
   if (!await pathExists(flowsRoot)) {
     return null;
   }
@@ -106442,7 +107135,7 @@ async function collectTasksDashboardData(metaprojectRoot) {
   }
   const flows = [];
   for (const dir of dirEntries) {
-    const flowPath = path198.join(flowsRoot, dir, "flow.json");
+    const flowPath = path200.join(flowsRoot, dir, "flow.json");
     if (!await pathExists(flowPath)) {
       continue;
     }
@@ -106450,7 +107143,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 = path198.join(flowsRoot, dir, "acceptance-criteria.md");
+      const acPath = path200.join(flowsRoot, dir, "acceptance-criteria.md");
       if (await pathExists(acPath)) {
         const acContent = await readFile100(acPath, "utf8");
         acTotal = (acContent.match(/^- AC\d+:/gm) ?? []).length;
@@ -106504,7 +107197,7 @@ async function collectDashboardDocs(metaprojectRoot, wiki, memory) {
     "data/testing/context.md"
   ];
   for (const href of staticHrefs) {
-    const filePath = path198.join(metaprojectRoot, ...href.split("/"));
+    const filePath = path200.join(metaprojectRoot, ...href.split("/"));
     if (!await pathExists(filePath)) {
       continue;
     }
@@ -106521,7 +107214,7 @@ async function collectDashboardDocs(metaprojectRoot, wiki, memory) {
   return docs;
 }
 async function collectHealthDashboardData(metaprojectRoot) {
-  const reportPath = path198.join(metaprojectRoot, "data", "health", "artifacts", "latest.json");
+  const reportPath = path200.join(metaprojectRoot, "data", "health", "artifacts", "latest.json");
   if (!await pathExists(reportPath)) {
     return;
   }
@@ -106630,8 +107323,8 @@ function metricToScope(metric) {
   };
 }
 async function collectGraphDashboardData(metaprojectRoot) {
-  const nodesPath = path198.join(metaprojectRoot, "data", "gdgraph", "storage", "nodes.jsonl");
-  const edgesPath = path198.join(metaprojectRoot, "data", "gdgraph", "storage", "edges.jsonl");
+  const nodesPath = path200.join(metaprojectRoot, "data", "gdgraph", "storage", "nodes.jsonl");
+  const edgesPath = path200.join(metaprojectRoot, "data", "gdgraph", "storage", "edges.jsonl");
   if (!await pathExists(nodesPath) || !await pathExists(edgesPath)) {
     return;
   }
@@ -106682,8 +107375,8 @@ async function collectGraphDashboardData(metaprojectRoot) {
   };
 }
 async function collectTestingDashboardData(metaprojectRoot) {
-  const reportPath = path198.join(metaprojectRoot, "data", "testing", "artifacts", "latest.json");
-  const contextPath = path198.join(metaprojectRoot, "data", "testing", "context.md");
+  const reportPath = path200.join(metaprojectRoot, "data", "testing", "artifacts", "latest.json");
+  const contextPath = path200.join(metaprojectRoot, "data", "testing", "context.md");
   if (await pathExists(reportPath)) {
     const report = JSON.parse(await readFile100(reportPath, "utf8"));
     const totalTests = numberOrUndefined(report.total);
@@ -106712,7 +107405,7 @@ async function collectMarkdownPages(root, hrefPrefix) {
   const files = await listMarkdownFiles(root);
   const pages = [];
   for (const filePath of files.slice(0, 40)) {
-    const relativePath = path198.relative(root, filePath).split(path198.sep).join("/");
+    const relativePath = path200.relative(root, filePath).split(path200.sep).join("/");
     if (relativePath === "index.md" || relativePath.startsWith("templates/")) {
       continue;
     }
@@ -106733,7 +107426,7 @@ async function listMarkdownFiles(root) {
   const entries = await readdir37(root, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const fullPath = path198.join(root, entry.name);
+    const fullPath = path200.join(root, entry.name);
     if (entry.isDirectory()) {
       files.push(...await listMarkdownFiles(fullPath));
     } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -106781,7 +107474,7 @@ async function writeRecoveredManifest(metaprojectRoot, modules) {
   const manifest = {
     schemaVersion: 1,
     standardVersion: STANDARD_VERSION,
-    name: `${path198.basename(path198.dirname(metaprojectRoot))}-metaproject`,
+    name: `${path200.basename(path200.dirname(metaprojectRoot))}-metaproject`,
     createdBy: "keryx",
     profiles: computeProfiles(enabledModuleKeys),
     paths: {
@@ -106871,11 +107564,11 @@ async function writeRecoveredManifest(metaprojectRoot, modules) {
       metaproject: ".metaproject/index.md"
     }
   };
-  await writeFile54(path198.join(metaprojectRoot, "metaproject.json"), `${JSON.stringify(manifest, null, 2)}
+  await writeFile54(path200.join(metaprojectRoot, "metaproject.json"), `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
 }
 async function enableTasksInManifest(metaprojectRoot) {
-  const manifestPath = path198.join(metaprojectRoot, "metaproject.json");
+  const manifestPath = path200.join(metaprojectRoot, "metaproject.json");
   if (!await pathExists(manifestPath)) {
     return;
   }
@@ -106898,7 +107591,7 @@ async function enableTasksInManifest(metaprojectRoot) {
 `, "utf8");
 }
 async function updateManifestAgentEntrypoints(metaprojectRoot, ruleSources) {
-  const manifestPath = path198.join(metaprojectRoot, "metaproject.json");
+  const manifestPath = path200.join(metaprojectRoot, "metaproject.json");
   if (!await pathExists(manifestPath)) {
     return;
   }
@@ -106934,72 +107627,72 @@ async function updateRuntime(projectRoot) {
   }
 }
 async function findRuntimeRoot(projectRoot) {
-  const projectRuntime = path198.join(projectRoot, ".metaproject", "runtime", "keryx");
-  if (await pathExists(path198.join(projectRuntime, ".git"))) {
+  const projectRuntime = path200.join(projectRoot, ".metaproject", "runtime", "keryx");
+  if (await pathExists(path200.join(projectRuntime, ".git"))) {
     return projectRuntime;
   }
   const home = process.env.HOME;
   if (!home) {
     return null;
   }
-  const globalRuntime = path198.join(home, ".keryx", "keryx");
-  if (await pathExists(path198.join(globalRuntime, ".git"))) {
+  const globalRuntime = path200.join(home, ".keryx", "keryx");
+  if (await pathExists(path200.join(globalRuntime, ".git"))) {
     return globalRuntime;
   }
   return null;
 }
 async function createServiceDirs(metaprojectRoot, modules) {
   const dirs = [
-    path198.join(metaprojectRoot, "core"),
-    path198.join(metaprojectRoot, "hooks", "post-update.d"),
-    path198.join(metaprojectRoot, "modules"),
-    path198.join(metaprojectRoot, "rules"),
-    path198.join(metaprojectRoot, "skills", "project-rules"),
+    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"),
     ...modules.enableGdgraph ? [
-      path198.join(metaprojectRoot, "core", "gdgraph"),
-      path198.join(metaprojectRoot, "skills", "gdgraph")
+      path200.join(metaprojectRoot, "core", "gdgraph"),
+      path200.join(metaprojectRoot, "skills", "gdgraph")
     ] : [],
     ...modules.enableGdctx ? [
-      path198.join(metaprojectRoot, "core", "gdctx"),
-      path198.join(metaprojectRoot, "skills", "gdctx")
+      path200.join(metaprojectRoot, "core", "gdctx"),
+      path200.join(metaprojectRoot, "skills", "gdctx")
     ] : [],
     ...modules.enableGdwiki ? [
-      path198.join(metaprojectRoot, "skills", "gdwiki"),
-      path198.join(metaprojectRoot, "wiki", "templates")
+      path200.join(metaprojectRoot, "skills", "gdwiki"),
+      path200.join(metaprojectRoot, "wiki", "templates")
     ] : [],
     ...modules.enableHealth ? [
-      path198.join(metaprojectRoot, "core", "health"),
-      path198.join(metaprojectRoot, "skills", "health")
+      path200.join(metaprojectRoot, "core", "health"),
+      path200.join(metaprojectRoot, "skills", "health")
     ] : [],
     ...modules.enableTesting ? [
-      path198.join(metaprojectRoot, "core", "testing"),
-      path198.join(metaprojectRoot, "skills", "testing")
+      path200.join(metaprojectRoot, "core", "testing"),
+      path200.join(metaprojectRoot, "skills", "testing")
     ] : [],
     ...modules.enableMemory ? [
-      path198.join(metaprojectRoot, "core", "memory"),
-      path198.join(metaprojectRoot, "skills", "memory"),
-      path198.join(metaprojectRoot, "memory", "templates")
+      path200.join(metaprojectRoot, "core", "memory"),
+      path200.join(metaprojectRoot, "skills", "memory"),
+      path200.join(metaprojectRoot, "memory", "templates")
     ] : [],
     ...modules.enableTasks ? [
-      path198.join(metaprojectRoot, "flows"),
-      path198.join(metaprojectRoot, "skills", "flow")
+      path200.join(metaprojectRoot, "flows"),
+      path200.join(metaprojectRoot, "skills", "flow")
     ] : [],
     ...modules.enableSecurity ? [
-      path198.join(metaprojectRoot, "core", "security")
+      path200.join(metaprojectRoot, "core", "security")
     ] : [],
     ...modules.enableSac ? [
-      path198.join(metaprojectRoot, "skills", "sac")
+      path200.join(metaprojectRoot, "skills", "sac")
     ] : []
   ];
   await Promise.all(dirs.map((dir) => mkdir63(dir, { recursive: true })));
 }
 async function installGdgraphCoreScripts2(metaprojectRoot) {
-  const gdgraphCoreRoot = path198.join(metaprojectRoot, "core", "gdgraph");
+  const gdgraphCoreRoot = path200.join(metaprojectRoot, "core", "gdgraph");
   await mkdir63(gdgraphCoreRoot, { recursive: true });
   for (const file of GDGRAPH_CORE_SOURCES) {
-    await copyFileIfChanged2(runtimeSourcePath2(`../gdgraph/${file}`), path198.join(gdgraphCoreRoot, file));
+    await copyFileIfChanged2(runtimeSourcePath2(`../gdgraph/${file}`), path200.join(gdgraphCoreRoot, file));
   }
-  await writeTextIfChanged4(path198.join(gdgraphCoreRoot, "cli.ts"), renderGdgraphCoreCli());
+  await writeTextIfChanged4(path200.join(gdgraphCoreRoot, "cli.ts"), renderGdgraphCoreCli());
 }
 async function installManagedHook2(projectRoot, hookName, blockId, content) {
   const hooksRoot = await resolveGitHooksRoot(projectRoot);
@@ -107007,7 +107700,7 @@ async function installManagedHook2(projectRoot, hookName, blockId, content) {
     return;
   }
   await mkdir63(hooksRoot, { recursive: true });
-  const hookPath = path198.join(hooksRoot, hookName);
+  const hookPath = path200.join(hooksRoot, hookName);
   const blockStart = `# keryx:${blockId}:begin`;
   const blockEnd = `# keryx:${blockId}:end`;
   const managedBlock = `${blockStart}
@@ -107028,7 +107721,7 @@ async function removeManagedHook2(projectRoot, hookName, blockId) {
   if (!hooksRoot) {
     return;
   }
-  const hookPath = path198.join(hooksRoot, hookName);
+  const hookPath = path200.join(hooksRoot, hookName);
   if (!await pathExists(hookPath)) {
     return;
   }
@@ -107050,7 +107743,7 @@ async function prePushHasSecurityBlock2(projectRoot) {
   if (!hooksRoot) {
     return false;
   }
-  const hookPath = path198.join(hooksRoot, "pre-push");
+  const hookPath = path200.join(hooksRoot, "pre-push");
   if (!await pathExists(hookPath)) {
     return false;
   }
@@ -107065,7 +107758,7 @@ async function agentSettingsHasSecuritySentinel2(projectRoot) {
   return (await readFile100(file, "utf8")).includes(AGENT_HOOKS_SENTINEL);
 }
 async function readManifest5(metaprojectRoot) {
-  const manifestPath = path198.join(metaprojectRoot, "metaproject.json");
+  const manifestPath = path200.join(metaprojectRoot, "metaproject.json");
   if (!await pathExists(manifestPath)) {
     return {
       exists: false,
@@ -107134,7 +107827,7 @@ async function inferManifestFromExistingMetaproject(metaprojectRoot) {
 }
 async function anyPathExists(root, candidates) {
   for (const candidate of candidates) {
-    if (await pathExists(path198.join(root, candidate))) {
+    if (await pathExists(path200.join(root, candidate))) {
       return true;
     }
   }
@@ -107157,13 +107850,13 @@ function parseUpdateArgs(args) {
   };
 }
 async function runPostUpdateHooks(projectRoot) {
-  const hooksDir = path198.join(projectRoot, ".metaproject", "hooks", "post-update.d");
+  const hooksDir = path200.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 = path198.join(hooksDir, entry);
+    const hookPath = path200.join(hooksDir, entry);
     try {
       await accessExecutable(hookPath);
     } catch {
@@ -107175,7 +107868,7 @@ async function runPostUpdateHooks(projectRoot) {
 }
 async function accessExecutable(filePath) {
   await new Promise((resolve, reject) => {
-    access4(filePath, constants2.X_OK, (error) => {
+    access4(filePath, constants3.X_OK, (error) => {
       if (error) {
         reject(error);
         return;
@@ -107186,7 +107879,7 @@ async function accessExecutable(filePath) {
 }
 async function run(command, args, cwd) {
   await new Promise((resolve, reject) => {
-    const child = spawn6(command, args, {
+    const child = spawn7(command, args, {
       cwd,
       stdio: "inherit"
     });
@@ -107204,14 +107897,14 @@ async function writeTextIfChanged4(filePath, content) {
   if (await pathExists(filePath) && await readFile100(filePath, "utf8") === content) {
     return;
   }
-  await mkdir63(path198.dirname(filePath), { recursive: true });
+  await mkdir63(path200.dirname(filePath), { recursive: true });
   await writeFile54(filePath, content, "utf8");
 }
 async function writeTextIfMissing4(filePath, content) {
   if (await pathExists(filePath)) {
     return;
   }
-  await mkdir63(path198.dirname(filePath), { recursive: true });
+  await mkdir63(path200.dirname(filePath), { recursive: true });
   await writeFile54(filePath, content, "utf8");
 }
 async function copyFileIfChanged2(from, to) {
@@ -107219,7 +107912,7 @@ async function copyFileIfChanged2(from, to) {
   if (await pathExists(to) && await readFile100(to, "utf8") === next) {
     return;
   }
-  await mkdir63(path198.dirname(to), { recursive: true });
+  await mkdir63(path200.dirname(to), { recursive: true });
   await writeFile54(to, next, "utf8");
 }
 function runtimeSourcePath2(relativePath) {
@@ -107228,7 +107921,7 @@ function runtimeSourcePath2(relativePath) {
     return directPath;
   }
   if (relativePath.startsWith("../")) {
-    const packagedSourcePath = path198.join(path198.dirname(fileURLToPath8(import.meta.url)), "..", "src", relativePath.slice(3));
+    const packagedSourcePath = path200.join(path200.dirname(fileURLToPath8(import.meta.url)), "..", "src", relativePath.slice(3));
     if (existsSync36(packagedSourcePath)) {
       return packagedSourcePath;
     }
@@ -107262,8 +107955,8 @@ function printHelp20() {
 }
 
 // src/commands/dashboard.ts
-import { spawn as spawn7 } from "child_process";
-import path199 from "path";
+import { spawn as spawn8 } from "child_process";
+import path201 from "path";
 init_args();
 async function dashboardCommand(args = []) {
   const options = parseOptions(args);
@@ -107274,7 +107967,7 @@ async function dashboardCommand(args = []) {
   }
   if (subcommand === "build") {
     const result = await buildDashboard();
-    const rel = path199.relative(process.cwd(), result.path);
+    const rel = path201.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;
@@ -107282,7 +107975,7 @@ async function dashboardCommand(args = []) {
   if (subcommand === "open") {
     const result = await buildDashboard();
     await openFile(result.path);
-    const rel = path199.relative(process.cwd(), result.path);
+    const rel = path201.relative(process.cwd(), result.path);
     console.log(`  ${style.green(symbols.ok)} Opened ${style.cyan(rel)}`);
     return;
   }
@@ -107301,7 +107994,7 @@ async function openFile(filePath) {
   const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
   const args = process.platform === "win32" ? ["/c", "start", "", filePath] : [filePath];
   await new Promise((resolve, reject) => {
-    const child = spawn7(command, args, { stdio: "ignore", detached: true });
+    const child = spawn8(command, args, { stdio: "ignore", detached: true });
     child.on("error", reject);
     child.on("close", (code) => {
       if (code === 0) {
@@ -107326,12 +108019,12 @@ function printHelp21() {
 }
 
 // src/commands/agents.ts
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync10 } 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 path200 from "path";
+import path202 from "path";
 init_fs();
 var AGENT_BOOTSTRAP_START = "<!-- keryx:global-bootstrap -->";
 var AGENT_BOOTSTRAP_END = "<!-- /keryx:global-bootstrap -->";
@@ -107341,35 +108034,35 @@ var AGENT_BOOTSTRAP_RUNTIMES = [
     aliases: ["claude-code"],
     label: "Claude Code",
     fileName: "CLAUDE.md",
-    filePath: (homeRoot) => path200.join(homeRoot, ".claude", "CLAUDE.md")
+    filePath: (homeRoot) => path202.join(homeRoot, ".claude", "CLAUDE.md")
   },
   {
     id: "opencode",
     aliases: ["open-code"],
     label: "OpenCode",
     fileName: "AGENTS.md",
-    filePath: (homeRoot) => path200.join(homeRoot, ".config", "opencode", "AGENTS.md")
+    filePath: (homeRoot) => path202.join(homeRoot, ".config", "opencode", "AGENTS.md")
   },
   {
     id: "zcode",
     aliases: ["zed", "zed-code"],
     label: "ZCode",
     fileName: "AGENTS.md",
-    filePath: (homeRoot) => path200.join(homeRoot, ".zcode", "AGENTS.md")
+    filePath: (homeRoot) => path202.join(homeRoot, ".zcode", "AGENTS.md")
   },
   {
     id: "codex",
     aliases: [],
     label: "Codex",
     fileName: "AGENTS.md",
-    filePath: (homeRoot) => path200.join(homeRoot, ".codex", "AGENTS.md")
+    filePath: (homeRoot) => path202.join(homeRoot, ".codex", "AGENTS.md")
   },
   {
     id: "antigravity",
     aliases: ["antigravuty", "antigravity-code"],
     label: "Antigravity",
     fileName: "AGENTS.md",
-    filePath: (homeRoot) => path200.join(homeRoot, ".config", "antigravity", "AGENTS.md")
+    filePath: (homeRoot) => path202.join(homeRoot, ".config", "antigravity", "AGENTS.md")
   }
 ];
 function agentBootstrapRuntimeIds() {
@@ -107417,7 +108110,7 @@ async function installAgentBootstrap(runtime, options = {}) {
   const dryRun = options.dryRun === true;
   const wrote = next !== current;
   if (wrote && !dryRun) {
-    await mkdir64(path200.dirname(filePath), { recursive: true });
+    await mkdir64(path202.dirname(filePath), { recursive: true });
     await writeFile55(filePath, next, "utf8");
   }
   const status = dryRun ? statusFromContent(runtime, filePath, exists, next) : await agentBootstrapStatus(runtime, homeRoot);
@@ -107827,7 +108520,7 @@ function monitorCommand(args) {
   }
   let events;
   try {
-    events = parseAgentEvents(readFileSync9(source, "utf8"));
+    events = parseAgentEvents(readFileSync10(source, "utf8"));
   } catch (error) {
     console.error(`Failed to read/parse agent-event source "${source}": ${error.message}`);
     process.exitCode = 1;
@@ -107954,7 +108647,7 @@ function printBootstrapHelp() {
 // src/commands/metrics.ts
 init_args();
 import { readFile as readFile102 } from "fs/promises";
-import path202 from "path";
+import path204 from "path";
 
 // src/metrics/benchmark.ts
 var RELIABILITIES2 = new Set(["exact", "estimated", "unknown"]);
@@ -108771,7 +109464,7 @@ function buildContainmentManifest(inputs, options = {}) {
 
 // src/metrics/oracle-runner.ts
 import { mkdir as mkdir65, writeFile as writeFile56 } from "fs/promises";
-import path201 from "path";
+import path203 from "path";
 
 // src/metrics/ir.ts
 function toIdSet(ids) {
@@ -109217,9 +109910,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 = path201.join(outDir, "bench", ladder, safeTarget, safeCase, bundle.variant, String(bundle.seed));
+  const dir = path203.join(outDir, "bench", ladder, safeTarget, safeCase, bundle.variant, String(bundle.seed));
   await mkdir65(dir, { recursive: true });
-  const write = (name, value) => writeFile56(path201.join(dir, name), `${JSON.stringify(value, null, 2)}
+  const write = (name, value) => writeFile56(path203.join(dir, name), `${JSON.stringify(value, null, 2)}
 `, "utf8");
   await Promise.all([
     write("inputs.json", bundle.inputs),
@@ -109259,7 +109952,7 @@ async function metricsCommand(args = [], projectRoot = process.cwd()) {
     console.log("# metrics status");
     console.log("");
     console.log(`root: ${root}`);
-    console.log(`enabled: ${await Bun.file(path202.join(projectRoot, ".metaproject", "metaproject.json")).exists() ? "yes" : "no"}`);
+    console.log(`enabled: ${await Bun.file(path204.join(projectRoot, ".metaproject", "metaproject.json")).exists() ? "yes" : "no"}`);
     const latest = await readLatestPointer(root);
     console.log(`latest: ${latest.status}`);
     return;
@@ -109271,7 +109964,7 @@ async function metricsCommand(args = [], projectRoot = process.cwd()) {
       process.exitCode = 1;
       return;
     }
-    const record = JSON.parse(await readFile102(path202.resolve(projectRoot, file), "utf8"));
+    const record = JSON.parse(await readFile102(path204.resolve(projectRoot, file), "utf8"));
     const result = validateRunRecord(record);
     console.log(result.valid ? "valid: yes" : "valid: no");
     for (const error of result.errors)
@@ -109296,7 +109989,7 @@ async function metricsCommand(args = [], projectRoot = process.cwd()) {
       process.exitCode = 1;
       return;
     }
-    const file = path202.join(metricsRoot(projectRoot), "runs", `${runId}.json`);
+    const file = path204.join(metricsRoot(projectRoot), "runs", `${runId}.json`);
     if (!await Bun.file(file).exists()) {
       console.error(`Run not found: ${runId}`);
       process.exitCode = 1;
@@ -109313,8 +110006,8 @@ async function metricsCommand(args = [], projectRoot = process.cwd()) {
       process.exitCode = 1;
       return;
     }
-    const a = JSON.parse(await readFile102(path202.join(metricsRoot(projectRoot), "runs", `${runA}.json`), "utf8"));
-    const b = JSON.parse(await readFile102(path202.join(metricsRoot(projectRoot), "runs", `${runB}.json`), "utf8"));
+    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 comparison = compareExecutionRuns(a, b);
     console.log(stableJson(comparison));
     return;
@@ -109348,8 +110041,8 @@ async function metricsCommand(args = [], projectRoot = process.cwd()) {
       return;
     }
     const template = createPairedBenchmarkTemplate(taskIds);
-    await Bun.write(path202.resolve(projectRoot, out), stableJson(template));
-    console.log(`manifest: ${path202.relative(projectRoot, path202.resolve(projectRoot, out))}`);
+    await Bun.write(path204.resolve(projectRoot, out), stableJson(template));
+    console.log(`manifest: ${path204.relative(projectRoot, path204.resolve(projectRoot, out))}`);
     return;
   }
   if (subcommand === "benchmark" && args[1] === "run") {
@@ -109363,7 +110056,7 @@ async function metricsCommand(args = [], projectRoot = process.cwd()) {
       process.exitCode = 1;
       return;
     }
-    const raw = JSON.parse(await readFile102(path202.resolve(projectRoot, file), "utf8"));
+    const raw = JSON.parse(await readFile102(path204.resolve(projectRoot, file), "utf8"));
     const input = Array.isArray(raw) ? raw : raw.runs ?? [];
     const result = validatePairedBenchmark(input);
     console.log(stableJson(result));
@@ -109375,7 +110068,7 @@ async function metricsCommand(args = [], projectRoot = process.cwd()) {
   process.exitCode = 1;
 }
 async function loadAffectedSets(projectRoot, file) {
-  const raw = JSON.parse(await readFile102(path202.resolve(projectRoot, file), "utf8"));
+  const raw = JSON.parse(await readFile102(path204.resolve(projectRoot, file), "utf8"));
   const map = new Map;
   for (const entry of raw.targets ?? []) {
     if (typeof entry.target === "string")
@@ -109446,7 +110139,7 @@ async function runHarnessLayer(projectRoot, args, ladder) {
   let tasks;
   let model;
   try {
-    const raw = JSON.parse(await readFile102(path202.resolve(projectRoot, resultsPath), "utf8"));
+    const raw = JSON.parse(await readFile102(path204.resolve(projectRoot, resultsPath), "utf8"));
     tasks = raw.tasks ?? [];
     model = raw.model;
   } catch (error) {
@@ -109477,7 +110170,7 @@ async function runSafetyCompletionHonestyLayer(projectRoot, args, ladder) {
   let cases;
   let model;
   try {
-    const raw = JSON.parse(await readFile102(path202.resolve(projectRoot, resultsPath), "utf8"));
+    const raw = JSON.parse(await readFile102(path204.resolve(projectRoot, resultsPath), "utf8"));
     cases = raw.cases ?? [];
     model = raw.model;
   } catch (error) {
@@ -109502,7 +110195,7 @@ async function runSafetyFalsePremiseLayer(projectRoot, args, ladder) {
   let cases;
   let model;
   try {
-    const raw = JSON.parse(await readFile102(path202.resolve(projectRoot, resultsPath), "utf8"));
+    const raw = JSON.parse(await readFile102(path204.resolve(projectRoot, resultsPath), "utf8"));
     cases = raw.cases ?? [];
     model = raw.model;
   } catch (error) {
@@ -109527,7 +110220,7 @@ async function runSafetyContainmentLayer(projectRoot, args, ladder, caseClass) {
   let cases;
   let model;
   try {
-    const raw = JSON.parse(await readFile102(path202.resolve(projectRoot, resultsPath), "utf8"));
+    const raw = JSON.parse(await readFile102(path204.resolve(projectRoot, resultsPath), "utf8"));
     cases = raw.cases ?? [];
     model = raw.model;
   } catch (error) {
@@ -109589,12 +110282,12 @@ async function runGdgraphLayer(projectRoot, args, ladder) {
   }
   const manifests = buildOracleManifestsByGold(inputs, { ladder });
   if (outDir) {
-    const resolvedOut = path202.resolve(projectRoot, outDir);
+    const resolvedOut = path204.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(path202.join(resolvedOut, named.kind), bundle, ladder);
-        console.error(`bundle[${named.kind}]: ${path202.relative(projectRoot, dir)}`);
+        const dir = await persistEvidenceBundle(path204.join(resolvedOut, named.kind), bundle, ladder);
+        console.error(`bundle[${named.kind}]: ${path204.relative(projectRoot, dir)}`);
       }
     }
   }
@@ -109618,7 +110311,7 @@ async function runGdgraphLayer(projectRoot, args, ladder) {
   return allValid;
 }
 async function loadCoverageMap2(projectRoot, file) {
-  const raw = JSON.parse(await readFile102(path202.resolve(projectRoot, file), "utf8"));
+  const raw = JSON.parse(await readFile102(path204.resolve(projectRoot, file), "utf8"));
   return raw.coverageMap ?? {};
 }
 async function runTestingLayer(projectRoot, args, ladder) {
@@ -109655,7 +110348,7 @@ async function runTestingLayer(projectRoot, args, ladder) {
   return result.valid;
 }
 async function loadMemoryGoldK(projectRoot, file) {
-  const raw = JSON.parse(await readFile102(path202.resolve(projectRoot, file), "utf8"));
+  const raw = JSON.parse(await readFile102(path204.resolve(projectRoot, file), "utf8"));
   return typeof raw.k === "number" && raw.k > 0 ? raw.k : 3;
 }
 async function runMemoryLayer(projectRoot, args, ladder) {
@@ -109692,11 +110385,11 @@ async function runMemoryLayer(projectRoot, args, ladder) {
   return result.valid;
 }
 async function loadWikiGoldK(projectRoot, file) {
-  const raw = JSON.parse(await readFile102(path202.resolve(projectRoot, file), "utf8"));
+  const raw = JSON.parse(await readFile102(path204.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(path202.resolve(projectRoot, file), "utf8"));
+  const raw = JSON.parse(await readFile102(path204.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)
@@ -109752,7 +110445,7 @@ async function runWikiLayer(projectRoot, args, ladder) {
   return result.valid;
 }
 async function loadGdctxFacts(projectRoot, file) {
-  const raw = JSON.parse(await readFile102(path202.resolve(projectRoot, file), "utf8"));
+  const raw = JSON.parse(await readFile102(path204.resolve(projectRoot, file), "utf8"));
   const inputs = [];
   for (const entry of raw.inputs ?? []) {
     if (typeof entry.input === "string") {
@@ -109790,7 +110483,7 @@ async function collect(projectRoot, args) {
     process.exitCode = 1;
     return;
   }
-  const raw = JSON.parse(await readFile102(path202.resolve(projectRoot, eventFile), "utf8"));
+  const raw = JSON.parse(await readFile102(path204.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;
@@ -109806,11 +110499,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: ${path202.relative(projectRoot, result.jsonPath)}`);
-  console.log(`markdown: ${path202.relative(projectRoot, result.markdownPath)}`);
+  console.log(`json: ${path204.relative(projectRoot, result.jsonPath)}`);
+  console.log(`markdown: ${path204.relative(projectRoot, result.markdownPath)}`);
 }
 function metricsRoot(projectRoot) {
-  return path202.join(projectRoot, ".metaproject", "data", "metrics");
+  return path204.join(projectRoot, ".metaproject", "data", "metrics");
 }
 function printMetricsHelp() {
   console.log(`keryx metrics