frizz 0.1.0 → 0.2.0

package/dist/dev-child.js

@@ -568,6 +568,124 @@ var init_project_identity = __esm({
   }
 });
 
+// packages/server/src/project-root.ts
+import { createHash as createHash2, randomUUID as randomUUID3 } from "node:crypto";
+import { closeSync as closeSync2, existsSync as existsSync2, fsyncSync as fsyncSync2, mkdirSync as mkdirSync2, openSync as openSync2, readFileSync as readFileSync3, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { dirname as dirname2, join as join3, parse, resolve as resolve2 } from "node:path";
+function projectIdPath(root) {
+  return join3(root, FRIZZ_DIR, ID_FILE);
+}
+function readProjectIdFile(root) {
+  let raw2;
+  try {
+    raw2 = readFileSync3(projectIdPath(root), "utf8");
+  } catch {
+    return void 0;
+  }
+  try {
+    return validateProjectId(raw2.trim());
+  } catch {
+    throw new Error(`${projectIdPath(root)} is invalid; expected exactly one UUID`);
+  }
+}
+function writeProjectIdFile(root, id) {
+  const dir = join3(root, FRIZZ_DIR);
+  mkdirSync2(dir, { recursive: true });
+  const ignore = join3(dir, SELF_IGNORE);
+  if (!existsSync2(ignore)) {
+    try {
+      writeFileSync2(ignore, "*\n", { flag: "wx" });
+    } catch {
+    }
+  }
+  const path = projectIdPath(root);
+  const temp = join3(dir, `.${ID_FILE}.${process.pid}.${randomUUID3()}.tmp`);
+  let fd;
+  try {
+    fd = openSync2(temp, "wx", 384);
+    writeFileSync2(fd, `${id}
+`, "utf8");
+    fsyncSync2(fd);
+    closeSync2(fd);
+    fd = void 0;
+    renameSync2(temp, path);
+  } catch (error) {
+    if (fd !== void 0) {
+      try {
+        closeSync2(fd);
+      } catch {
+      }
+    }
+    try {
+      rmSync2(temp, { force: true });
+    } catch {
+    }
+    throw error;
+  }
+  return id;
+}
+function projectRootLockName(root) {
+  return `identity-path-${createHash2("sha256").update(root).digest("hex")}.lock`;
+}
+function ensureProjectIdFile(root, home = homedir3(), seed) {
+  const existing = readProjectIdFile(root);
+  if (existing) return existing;
+  const release = acquireNamedLaunchLockSync(home, projectRootLockName(root));
+  try {
+    const raced = readProjectIdFile(root);
+    if (raced) return raced;
+    return writeProjectIdFile(root, seed ? validateProjectId(seed) : randomUUID3());
+  } finally {
+    release();
+  }
+}
+function hasAny(dir, names) {
+  return names.some((name) => existsSync2(join3(dir, name)));
+}
+function discoverProjectRoot(cwd = process.cwd(), home = homedir3()) {
+  let dir;
+  try {
+    dir = resolve2(cwd);
+  } catch {
+    return resolve2(cwd);
+  }
+  const stop = resolve2(home);
+  const filesystemRoot = parse(dir).root;
+  for (let at = dir; ; at = dirname2(at)) {
+    if (at === stop || at === filesystemRoot) break;
+    if (existsSync2(projectIdPath(at))) return at;
+    if (hasAny(at, REPO_MARKERS)) return at;
+    if (hasAny(at, PROJECT_MARKERS)) return at;
+    if (dirname2(at) === at) break;
+  }
+  return dir;
+}
+var FRIZZ_DIR, ID_FILE, SELF_IGNORE, REPO_MARKERS, PROJECT_MARKERS;
+var init_project_root = __esm({
+  "packages/server/src/project-root.ts"() {
+    "use strict";
+    init_project_identity();
+    FRIZZ_DIR = ".frizz";
+    ID_FILE = ".id";
+    SELF_IGNORE = ".gitignore";
+    REPO_MARKERS = [".git", ".jj", ".hg", ".svn"];
+    PROJECT_MARKERS = [
+      "package.json",
+      "pyproject.toml",
+      "go.mod",
+      "Cargo.toml",
+      "deno.json",
+      "deno.jsonc",
+      "composer.json",
+      "Gemfile",
+      "pom.xml",
+      "build.gradle",
+      "Makefile"
+    ];
+  }
+});
+
 // packages/server/src/sqlite-quiet.ts
 function isSqliteExperimentalNotice(warning, type) {
   const name = typeof warning === "string" ? type : warning?.name;
@@ -795,39 +913,39 @@ var init_sqlite = __esm({
 
 // packages/server/src/migrate-fray.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { existsSync as existsSync2, lstatSync, readdirSync, realpathSync as realpathSync2, renameSync as renameSync2, rmdirSync } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { join as join3, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync3, lstatSync, readdirSync, realpathSync as realpathSync2, renameSync as renameSync3, rmdirSync } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join4, resolve as resolve3 } from "node:path";
 function xdg2(env, name) {
   const value = env[name];
   return value && (value.startsWith("/") || /^[A-Za-z]:[\\/]/u.test(value)) ? value : void 0;
 }
 function movesFor(env, platform3, home) {
-  const moves = [{ from: join3(home, ".fray"), to: join3(home, ".frizz") }];
+  const moves = [{ from: join4(home, ".fray"), to: join4(home, ".frizz") }];
   if (platform3 === "win32") {
-    const local = env.LOCALAPPDATA || join3(env.USERPROFILE || home, "AppData", "Local");
-    moves.push({ from: join3(local, "Fray"), to: join3(local, "Frizz") });
+    const local = env.LOCALAPPDATA || join4(env.USERPROFILE || home, "AppData", "Local");
+    moves.push({ from: join4(local, "Fray"), to: join4(local, "Frizz") });
   } else if (platform3 === "darwin") {
-    const support = join3(home, "Library", "Application Support");
-    moves.push({ from: join3(support, "Fray"), to: join3(support, "Frizz") });
-    moves.push({ from: join3(home, "Library", "Caches", "Fray"), to: join3(home, "Library", "Caches", "Frizz") });
+    const support = join4(home, "Library", "Application Support");
+    moves.push({ from: join4(support, "Fray"), to: join4(support, "Frizz") });
+    moves.push({ from: join4(home, "Library", "Caches", "Fray"), to: join4(home, "Library", "Caches", "Frizz") });
   } else {
-    moves.push({ from: join3(home, ".local", "share", "fray"), to: join3(home, ".local", "share", "frizz") });
-    moves.push({ from: join3(home, ".local", "state", "fray"), to: join3(home, ".local", "state", "frizz") });
-    moves.push({ from: join3(home, ".cache", "fray"), to: join3(home, ".cache", "frizz") });
+    moves.push({ from: join4(home, ".local", "share", "fray"), to: join4(home, ".local", "share", "frizz") });
+    moves.push({ from: join4(home, ".local", "state", "fray"), to: join4(home, ".local", "state", "frizz") });
+    moves.push({ from: join4(home, ".cache", "fray"), to: join4(home, ".cache", "frizz") });
   }
   for (const name of ["XDG_DATA_HOME", "XDG_STATE_HOME", "XDG_CACHE_HOME"]) {
     const base = xdg2(env, name);
-    if (base) moves.push({ from: join3(base, "fray"), to: join3(base, "frizz") });
+    if (base) moves.push({ from: join4(base, "fray"), to: join4(base, "frizz") });
   }
   return moves;
 }
 function migrateFrayGlobalRoots(options = {}) {
   const env = options.env ?? process.env;
   const platform3 = options.platform ?? process.platform;
-  const home = options.home ?? homedir3();
-  const exists = options.exists ?? existsSync2;
-  const rename2 = options.rename ?? renameSync2;
+  const home = options.home ?? homedir4();
+  const exists = options.exists ?? existsSync3;
+  const rename2 = options.rename ?? renameSync3;
   const merge = options.merge ?? mergeInto;
   const moved = [];
   for (const move of movesFor(env, platform3, home)) {
@@ -847,10 +965,10 @@ function migrateFrayGlobalRoots(options = {}) {
 function mergeInto(from, to) {
   let moved = false;
   for (const entry of readdirSync(from, { withFileTypes: true })) {
-    const src = join3(from, entry.name);
-    const dst = join3(to, entry.name);
-    if (!existsSync2(dst)) {
-      renameSync2(src, dst);
+    const src = join4(from, entry.name);
+    const dst = join4(to, entry.name);
+    if (!existsSync3(dst)) {
+      renameSync3(src, dst);
       moved = true;
       continue;
     }
@@ -863,12 +981,12 @@ function mergeInto(from, to) {
   return moved;
 }
 function migrateFrayProjectDir(projectDir) {
-  const from = join3(projectDir, ".fray");
-  const to = join3(projectDir, ".frizz");
+  const from = join4(projectDir, ".fray");
+  const to = join4(projectDir, ".frizz");
   try {
     if (!lstatSync(from).isDirectory()) return false;
-    if (!existsSync2(to)) {
-      renameSync2(from, to);
+    if (!existsSync3(to)) {
+      renameSync3(from, to);
       return true;
     }
     return lstatSync(to).isDirectory() ? mergeInto(from, to) : false;
@@ -905,8 +1023,8 @@ function writeId(dir, scope, id) {
   return readId(dir, scope, CURRENT_KEY) === id;
 }
 function hasBoard(id, home) {
-  const db = join3(projectStateDir(id, home), "ui.db");
-  if (!existsSync2(db)) return false;
+  const db = join4(projectStateDir(id, home), "ui.db");
+  if (!existsSync3(db)) return false;
   let sql;
   try {
     sql = new Database(db, { readonly: true });
@@ -930,7 +1048,7 @@ function linkedWorktreeScopes(dir) {
         env: { ...process.env, LC_ALL: "C" },
         stdio: ["ignore", "pipe", "ignore"]
       }).trim();
-      return realpathSync2(resolve2(dir, raw2));
+      return realpathSync2(resolve3(dir, raw2));
     } catch {
       return void 0;
     }
@@ -939,8 +1057,8 @@ function linkedWorktreeScopes(dir) {
   const commonGitDir = gitPath("--git-common-dir");
   if (!gitDir || !commonGitDir || gitDir === commonGitDir) return void 0;
   return {
-    legacy: ["--file", join3(gitDir, "fray.config")],
-    current: ["--file", join3(gitDir, "frizz.config")]
+    legacy: ["--file", join4(gitDir, "fray.config")],
+    current: ["--file", join4(gitDir, "frizz.config")]
   };
 }
 function adopt(dir, legacy, current, home) {
@@ -977,15 +1095,14 @@ var init_migrate_fray = __esm({
 
 // packages/server/src/project.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
-import { mkdirSync as mkdirSync2, realpathSync as realpathSync3 } from "node:fs";
-import { homedir as homedir4, tmpdir } from "node:os";
-import { basename, join as join4, resolve as resolve3 } from "node:path";
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { mkdirSync as mkdirSync3, realpathSync as realpathSync3 } from "node:fs";
+import { homedir as homedir5, tmpdir } from "node:os";
+import { basename, join as join5, resolve as resolve4 } from "node:path";
 function trustedLocalFileRoots(project) {
-  return [project.dir, tmpdir(), "/tmp", resolve3(homedir4(), "Screenshots"), join4(project.stateDir, "attachments")];
+  return [project.dir, tmpdir(), "/tmp", resolve4(homedir5(), "Screenshots"), join5(project.stateDir, "attachments")];
 }
 function openableFileRoots(project) {
-  return [homedir4(), ...trustedLocalFileRoots(project)];
+  return [homedir5(), ...trustedLocalFileRoots(project)];
 }
 function isNotGitRepositoryError(error) {
   if (!error || typeof error !== "object" || !("stderr" in error)) return false;
@@ -1001,15 +1118,23 @@ function resolveProjectDir(cwd = process.cwd()) {
     }).trim();
     return realpathSync3(root);
   } catch (error) {
-    if (!isNotGitRepositoryError(error)) throw new Error("unable to resolve Git repository root");
+    if (!isNotGitRepositoryError(error) && !isMissingGitBinary(error)) {
+      throw new Error("unable to resolve Git repository root");
+    }
+    const root = discoverProjectRoot(cwd);
     try {
-      return realpathSync3(cwd);
+      return realpathSync3(root);
     } catch {
-      return resolve3(cwd);
+      return resolve4(root);
     }
   }
 }
-function resolveProjectIdentity(dir, home = homedir4()) {
+function isMissingGitBinary(error) {
+  const code = error?.code;
+  return code === "ENOENT" || code === "EACCES";
+}
+function resolveProjectIdentity(dir, home = homedir5()) {
+  let insideWorktree = false;
   try {
     const inside = execFileSync4("git", ["rev-parse", "--is-inside-work-tree"], {
       cwd: dir,
@@ -1018,12 +1143,15 @@ function resolveProjectIdentity(dir, home = homedir4()) {
       stdio: ["ignore", "pipe", "pipe"]
     }).trim();
     if (inside !== "true") throw new Error("Git directory is not a worktree");
+    insideWorktree = true;
   } catch (error) {
-    if (!isNotGitRepositoryError(error)) throw new Error("unable to inspect Git repository identity");
-    return { id: randomUUID3(), scope: "repository", root: dir };
+    if (!isNotGitRepositoryError(error) && !isMissingGitBinary(error)) {
+      throw new Error("unable to inspect Git repository identity");
+    }
   }
-  const identity = resolveGitProjectIdentity(dir, home);
-  return { id: identity.id, scope: identity.scope, root: identity.root };
+  const git = insideWorktree ? resolveGitProjectIdentity(dir, home) : void 0;
+  const root = git?.root ?? dir;
+  return { id: ensureProjectIdFile(root, home, git?.id), scope: git?.scope ?? "repository", root };
 }
 function cwdSlug(absPath) {
   return absPath.replace(/[/.]/g, "-");
@@ -1054,7 +1182,7 @@ function resolveProjectLabel(dir) {
     return null;
   }
 }
-function resolveProject(cwd = process.cwd(), home = homedir4(), env = process.env, { migrate = false } = {}) {
+function resolveProject(cwd = process.cwd(), home = homedir5(), env = process.env, { migrate = false } = {}) {
   if (migrate) migrateFrayGlobalRoots({ env, home });
   const projectDir = resolveProjectDir(cwd);
   if (migrate) migrateFrayProjectId(projectDir, { home });
@@ -1063,7 +1191,7 @@ function resolveProject(cwd = process.cwd(), home = homedir4(), env = process.en
   if (migrate) migrateFrayProjectDir(dir);
   const id = identity.id;
   const stateDir = projectStateDir(id, home);
-  mkdirSync2(stateDir, { recursive: true });
+  mkdirSync3(stateDir, { recursive: true });
   const name = basename(dir) || dir;
   const target = {
     projectId: id,
@@ -1082,10 +1210,10 @@ function resolveProject(cwd = process.cwd(), home = homedir4(), env = process.en
   };
 }
 function permRequestDir(project) {
-  return join4(project.stateDir, "perm-requests");
+  return join5(project.stateDir, "perm-requests");
 }
 function permMarkerPath(project, slug) {
-  return join4(permRequestDir(project), `${slug}.json`);
+  return join5(permRequestDir(project), `${slug}.json`);
 }
 function projectLaunchTarget(project) {
   return {
@@ -1118,25 +1246,26 @@ var init_project = __esm({
   "packages/server/src/project.ts"() {
     "use strict";
     init_project_identity();
+    init_project_root();
     init_frizz_paths();
     init_migrate_fray();
   }
 });
 
 // packages/server/src/project-launch.ts
-import { createHash as createHash2, randomUUID as randomUUID4 } from "node:crypto";
+import { createHash as createHash3, randomUUID as randomUUID4 } from "node:crypto";
 import {
-  closeSync as closeSync2,
-  fsyncSync as fsyncSync2,
-  mkdirSync as mkdirSync3,
-  openSync as openSync2,
-  readFileSync as readFileSync3,
-  renameSync as renameSync3,
-  rmSync as rmSync2,
+  closeSync as closeSync3,
+  fsyncSync as fsyncSync3,
+  mkdirSync as mkdirSync4,
+  openSync as openSync3,
+  readFileSync as readFileSync4,
+  renameSync as renameSync4,
+  rmSync as rmSync3,
   statSync as statSync2,
-  writeFileSync as writeFileSync2
+  writeFileSync as writeFileSync3
 } from "node:fs";
-import { basename as basename2, dirname as dirname2, isAbsolute, join as join5 } from "node:path";
+import { basename as basename2, dirname as dirname3, isAbsolute, join as join6 } from "node:path";
 function errorCode3(error) {
   return error && typeof error === "object" && "code" in error && typeof error.code === "string" ? error.code : void 0;
 }
@@ -1146,40 +1275,40 @@ function validText(value, max = 4096) {
 function syncDirectory2(path) {
   let fd;
   try {
-    fd = openSync2(path, "r");
-    fsyncSync2(fd);
+    fd = openSync3(path, "r");
+    fsyncSync3(fd);
   } catch {
   } finally {
     if (fd !== void 0) {
       try {
-        closeSync2(fd);
+        closeSync3(fd);
       } catch {
       }
     }
   }
 }
 function atomicJson(path, value) {
-  mkdirSync3(dirname2(path), { recursive: true, mode: 448 });
-  const temp = join5(dirname2(path), `.${basename2(path)}.${process.pid}.${randomUUID4()}.tmp`);
+  mkdirSync4(dirname3(path), { recursive: true, mode: 448 });
+  const temp = join6(dirname3(path), `.${basename2(path)}.${process.pid}.${randomUUID4()}.tmp`);
   let fd;
   try {
-    fd = openSync2(temp, "wx", 384);
-    writeFileSync2(fd, `${JSON.stringify(value)}
+    fd = openSync3(temp, "wx", 384);
+    writeFileSync3(fd, `${JSON.stringify(value)}
 `, "utf8");
-    fsyncSync2(fd);
-    closeSync2(fd);
+    fsyncSync3(fd);
+    closeSync3(fd);
     fd = void 0;
-    renameSync3(temp, path);
-    syncDirectory2(dirname2(path));
+    renameSync4(temp, path);
+    syncDirectory2(dirname3(path));
   } catch (error) {
     if (fd !== void 0) {
       try {
-        closeSync2(fd);
+        closeSync3(fd);
       } catch {
       }
     }
     try {
-      rmSync2(temp, { force: true });
+      rmSync3(temp, { force: true });
     } catch {
     }
     throw error;
@@ -1188,12 +1317,12 @@ function atomicJson(path, value) {
 function quarantine(path, suffix) {
   const moved = `${path}.${suffix}-${process.pid}-${randomUUID4()}`;
   try {
-    renameSync3(path, moved);
+    renameSync4(path, moved);
   } catch {
     return false;
   }
   try {
-    rmSync2(moved, { recursive: true, force: true });
+    rmSync3(moved, { recursive: true, force: true });
   } catch {
   }
   return true;
@@ -1210,7 +1339,7 @@ function parseGeneration(value) {
 }
 function parseGuard(path) {
   try {
-    const value = JSON.parse(readFileSync3(path, "utf8"));
+    const value = JSON.parse(readFileSync4(path, "utf8"));
     const generation = parseGeneration(value);
     if (value.version !== 1 || !generation || typeof value.token !== "string" || !UUID_RE.test(value.token) || !validText(value.at, 128)) return null;
     return { version: 1, token: value.token, at: value.at, ...generation };
@@ -1219,25 +1348,25 @@ function parseGuard(path) {
   }
 }
 function acquireMutationGuard(stateDir, timeoutMs = GUARD_TIMEOUT_MS, adapter = defaultProcessPlatformAdapter) {
-  const path = join5(stateDir, MUTATION_GUARD_NAME);
-  mkdirSync3(stateDir, { recursive: true, mode: 448 });
+  const path = join6(stateDir, MUTATION_GUARD_NAME);
+  mkdirSync4(stateDir, { recursive: true, mode: 448 });
   const deadline = adapter.now() + Math.max(0, timeoutMs);
   for (; ; ) {
     const generation = currentProcessGeneration(adapter);
     const token = randomUUID4();
     let fd;
     try {
-      fd = openSync2(path, "wx", 384);
+      fd = openSync3(path, "wx", 384);
       const record = {
         version: 1,
         token,
         at: new Date(adapter.now()).toISOString(),
         ...generation
       };
-      writeFileSync2(fd, `${JSON.stringify(record)}
+      writeFileSync3(fd, `${JSON.stringify(record)}
 `, "utf8");
-      fsyncSync2(fd);
-      closeSync2(fd);
+      fsyncSync3(fd);
+      closeSync3(fd);
       fd = void 0;
       const committed = parseGuard(path);
       if (!committed || committed.token !== token || committed.pid !== generation.pid || committed.processStart !== generation.processStart) continue;
@@ -1252,7 +1381,7 @@ function acquireMutationGuard(stateDir, timeoutMs = GUARD_TIMEOUT_MS, adapter =
     } catch (error) {
       if (fd !== void 0) {
         try {
-          closeSync2(fd);
+          closeSync3(fd);
         } catch {
         }
       }
@@ -1290,7 +1419,7 @@ function parseDelegates(value) {
 }
 function parseOwner(path) {
   try {
-    const value = JSON.parse(readFileSync3(path, "utf8"));
+    const value = JSON.parse(readFileSync4(path, "utf8"));
     const generation = parseGeneration(value);
     if (value.version !== 1 && value.version !== OWNER_VERSION || !generation || typeof value.token !== "string" || !UUID_RE.test(value.token) || typeof value.projectId !== "string" || !UUID_RE.test(value.projectId) || !validText(value.projectDir) || !isAbsolute(value.projectDir) || !validRole(value.role) || !validText(value.acquiredAt, 128) || !validText(value.updatedAt, 128)) return null;
     const delegates = value.version === 1 ? [] : parseDelegates(value.delegates);
@@ -1313,7 +1442,7 @@ function parseOwner(path) {
   }
 }
 function projectLaunchOwnerPath(stateDir) {
-  return join5(stateDir, OWNER_NAME);
+  return join6(stateDir, OWNER_NAME);
 }
 function sameTarget(record, target) {
   return record.projectId === target.projectId && record.projectDir === target.projectDir;
@@ -1323,13 +1452,13 @@ function sameProjectIdentity(record, target) {
 }
 function projectLaunchTokenProof(target, token) {
   if (!UUID_RE.test(token)) throw new Error("invalid Frizz project launch owner token");
-  return createHash2("sha256").update("frizz-project-launch-v2\0").update(target.projectId).update("\0").update(target.projectDir).update("\0").update(token).digest("hex");
+  return createHash3("sha256").update("frizz-project-launch-v2\0").update(target.projectId).update("\0").update(target.projectDir).update("\0").update(token).digest("hex");
 }
 function removeStatusesForToken(stateDir, token) {
   for (const name of ["dev-supervisor.lock", "server.lock"]) {
-    const path = join5(stateDir, name);
+    const path = join6(stateDir, name);
     try {
-      const value = JSON.parse(readFileSync3(path, "utf8"));
+      const value = JSON.parse(readFileSync4(path, "utf8"));
       if (value.ownerToken === token) quarantine(path, "stale");
     } catch {
     }
@@ -1338,17 +1467,17 @@ function removeStatusesForToken(stateDir, token) {
 function writeNewOwner(path, record) {
   let fd;
   try {
-    fd = openSync2(path, "wx", 384);
-    writeFileSync2(fd, `${JSON.stringify(record)}
+    fd = openSync3(path, "wx", 384);
+    writeFileSync3(fd, `${JSON.stringify(record)}
 `, "utf8");
-    fsyncSync2(fd);
-    closeSync2(fd);
+    fsyncSync3(fd);
+    closeSync3(fd);
     fd = void 0;
-    syncDirectory2(dirname2(path));
+    syncDirectory2(dirname3(path));
   } catch (error) {
     if (fd !== void 0) {
       try {
-        closeSync2(fd);
+        closeSync3(fd);
       } catch {
       }
     }
@@ -1576,7 +1705,7 @@ function writeProjectStatus(path, value) {
 }
 function removeProjectStatus(path, expected) {
   try {
-    const value = JSON.parse(readFileSync3(path, "utf8"));
+    const value = JSON.parse(readFileSync4(path, "utf8"));
     if (value.pid !== expected.pid || value.processStart !== expected.processStart || value.publisherToken !== expected.publisherToken || value.ownerToken !== expected.ownerToken) return false;
     return quarantine(path, "release");
   } catch {
@@ -1640,7 +1769,7 @@ function createRetryableCleanup(run2) {
 }
 function withPhaseTimeout(name, promise, timeoutMs) {
   if (timeoutMs === void 0 || !Number.isFinite(timeoutMs) || timeoutMs <= 0) return promise;
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     let settled = false;
     const settle = (apply) => {
       if (settled) return;
@@ -1651,18 +1780,18 @@ function withPhaseTimeout(name, promise, timeoutMs) {
     const timer = setTimeout(() => settle(() => reject(new ShutdownPhaseTimeoutError(name, timeoutMs))), timeoutMs);
     timer.unref?.();
     promise.then(
-      () => settle(resolve9),
+      () => settle(resolve10),
       (error) => settle(() => reject(error))
     );
   });
 }
 function defaultDeadline(drained, timeoutMs) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     const timer = setTimeout(() => reject(new ShutdownTimeoutError(timeoutMs)), timeoutMs);
     void drained.then(
       () => {
         clearTimeout(timer);
-        resolve9();
+        resolve10();
       },
       (error) => {
         clearTimeout(timer);
@@ -1795,41 +1924,41 @@ var init_shutdown = __esm({
 // packages/server/src/logging.ts
 import {
   appendFileSync,
-  mkdirSync as mkdirSync4,
-  openSync as openSync3,
+  mkdirSync as mkdirSync5,
+  openSync as openSync4,
   readdirSync as readdirSync2,
-  rmSync as rmSync3,
+  rmSync as rmSync4,
   statSync as statSync3,
   symlinkSync,
-  writeFileSync as writeFileSync3,
+  writeFileSync as writeFileSync4,
   writeSync
 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import { join as join6 } from "node:path";
-function defaultLogRoot(stateDir, home = homedir5()) {
-  return stateDir ? join6(stateDir, "logs") : join6(frizzPaths({ home }).state, "logs");
+import { homedir as homedir6 } from "node:os";
+import { join as join7 } from "node:path";
+function defaultLogRoot(stateDir, home = homedir6()) {
+  return stateDir ? join7(stateDir, "logs") : join7(frizzPaths({ home }).state, "logs");
 }
 function runStamp(at) {
   const pad = (value) => String(value).padStart(2, "0");
   return `${at.getFullYear()}-${pad(at.getMonth() + 1)}-${pad(at.getDate())}T${pad(at.getHours())}-${pad(at.getMinutes())}-${pad(at.getSeconds())}`;
 }
-function runLogPath(stateDir, at = /* @__PURE__ */ new Date(), pid = process.pid, home = homedir5(), env = process.env) {
+function runLogPath(stateDir, at = /* @__PURE__ */ new Date(), pid = process.pid, home = homedir6(), env = process.env) {
   const name = `frizz-${runStamp(at)}-${pid}.log`;
   const override = env[LOG_PATH_ENV]?.trim();
-  if (override) return override.endsWith(".log") ? override : join6(override, name);
-  return join6(defaultLogRoot(stateDir, home), name);
+  if (override) return override.endsWith(".log") ? override : join7(override, name);
+  return join7(defaultLogRoot(stateDir, home), name);
 }
 function latestLogPath(dir) {
-  return join6(dir, "latest.log");
+  return join7(dir, "latest.log");
 }
 function linkLatest(dir, target) {
   const link = latestLogPath(dir);
   try {
-    rmSync3(link, { force: true });
+    rmSync4(link, { force: true });
     symlinkSync(target, link);
   } catch {
     try {
-      writeFileSync3(link, `${target}
+      writeFileSync4(link, `${target}
 `, { mode: 384 });
     } catch {
     }
@@ -1844,7 +1973,7 @@ function pruneRunLogs(dir, keep = RETAINED_RUNS, days = RETAINED_DAYS, now = Dat
   }
   const dated = entries.map((name) => {
     try {
-      return { name, at: statSync3(join6(dir, name)).mtimeMs };
+      return { name, at: statSync3(join7(dir, name)).mtimeMs };
     } catch {
       return { name, at: 0 };
     }
@@ -1853,7 +1982,7 @@ function pruneRunLogs(dir, keep = RETAINED_RUNS, days = RETAINED_DAYS, now = Dat
   const stale = dated.filter((entry, index) => index >= keep || entry.at < cutoff);
   for (const entry of stale) {
     try {
-      rmSync3(join6(dir, entry.name), { force: true });
+      rmSync4(join7(dir, entry.name), { force: true });
     } catch {
     }
   }
@@ -1867,8 +1996,8 @@ function formatDiskLine(record) {
 }
 function openLogFile(path) {
   try {
-    mkdirSync4(join6(path, ".."), { recursive: true, mode: 448 });
-    return openSync3(path, "a", 384);
+    mkdirSync5(join7(path, ".."), { recursive: true, mode: 448 });
+    return openSync4(path, "a", 384);
   } catch {
     return null;
   }
@@ -1881,7 +2010,7 @@ function createLogger(options = {}) {
   const maxBytes = options.maxBytes ?? MAX_LOG_BYTES;
   let fd = path === null ? null : openLogFile(path);
   if (fd !== null && path !== null && options.owner !== false) {
-    const dir = join6(path, "..");
+    const dir = join7(path, "..");
     pruneRunLogs(dir);
     linkLatest(dir, path);
   }
@@ -6746,8 +6875,8 @@ function createDrainableWorker(process2, options = {}) {
     },
     drain() {
       if (closed || queue.length === 0 && inFlight === 0) return Promise.resolve();
-      return new Promise((resolve9) => {
-        waiters.push(resolve9);
+      return new Promise((resolve10) => {
+        waiters.push(resolve10);
       });
     },
     outstanding: () => queue.length + inFlight,
@@ -10723,15 +10852,15 @@ var init_settings = __esm({
 });
 
 // packages/server/src/discover.ts
-import { readdirSync as readdirSync3, statSync as statSync4, openSync as openSync4, readSync, closeSync as closeSync3 } from "node:fs";
-import { join as join7 } from "node:path";
+import { readdirSync as readdirSync3, statSync as statSync4, openSync as openSync5, readSync, closeSync as closeSync4 } from "node:fs";
+import { join as join8 } from "node:path";
 function sentinelFor(sessionId) {
   return `threads/${sessionId}/scratch.md`;
 }
 function readHead(path) {
   let fd;
   try {
-    fd = openSync4(path, "r");
+    fd = openSync5(path, "r");
     const buf = Buffer.allocUnsafe(HEAD_BYTES);
     const n = readSync(fd, buf, 0, HEAD_BYTES, 0);
     return buf.toString("utf8", 0, n);
@@ -10740,7 +10869,7 @@ function readHead(path) {
   } finally {
     if (fd !== void 0) {
       try {
-        closeSync3(fd);
+        closeSync4(fd);
       } catch {
       }
     }
@@ -10761,7 +10890,7 @@ function discoverTranscriptId(logDir, sessionId, opts = {}) {
     if (name.startsWith(".") || !name.endsWith(".jsonl")) continue;
     const id = name.slice(0, -".jsonl".length);
     if (!id || id === sessionId || exclude?.has(id)) continue;
-    const path = join7(logDir, name);
+    const path = join8(logDir, name);
     let mtime;
     try {
       mtime = statSync4(path).mtimeMs;
@@ -10789,12 +10918,12 @@ var init_discover = __esm({
 });
 
 // packages/server/src/session-files.ts
-import { lstatSync as lstatSync2, rmSync as rmSync4 } from "node:fs";
+import { lstatSync as lstatSync2, rmSync as rmSync5 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 function systemPromptPath(sessionId) {
   if (!SESSION_ID_RE.test(sessionId)) throw new Error("invalid session id");
-  return join8(SYSTEM_PROMPT_DIR, `${sessionId}.md`);
+  return join9(SYSTEM_PROMPT_DIR, `${sessionId}.md`);
 }
 function isDirectDirectory(path) {
   try {
@@ -10814,9 +10943,9 @@ function pathAbsent(path) {
 }
 function unlinkDirectChild(parent, filename) {
   if (!isDirectDirectory(parent)) return pathAbsent(parent);
-  const child = join8(parent, filename);
+  const child = join9(parent, filename);
   try {
-    rmSync4(child, { force: true });
+    rmSync5(child, { force: true });
   } catch {
     return false;
   }
@@ -10824,14 +10953,14 @@ function unlinkDirectChild(parent, filename) {
 }
 function cleanupAdoptionSessionFiles(projectDir, sessionId) {
   if (!SESSION_ID_RE.test(sessionId)) return false;
-  const frizzDir = join8(projectDir, ".frizz");
+  const frizzDir = join9(projectDir, ".frizz");
   let clean = true;
   if (isDirectDirectory(frizzDir)) {
-    const threads = join8(frizzDir, "threads");
+    const threads = join9(frizzDir, "threads");
     if (isDirectDirectory(threads)) {
-      const child = join8(threads, sessionId);
+      const child = join9(threads, sessionId);
       try {
-        rmSync4(child, { recursive: true, force: true });
+        rmSync5(child, { recursive: true, force: true });
       } catch {
         clean = false;
       }
@@ -10844,7 +10973,7 @@ var SYSTEM_PROMPT_DIR, SESSION_ID_RE;
 var init_session_files = __esm({
   "packages/server/src/session-files.ts"() {
     "use strict";
-    SYSTEM_PROMPT_DIR = join8(tmpdir2(), "frizz-sysprompts");
+    SYSTEM_PROMPT_DIR = join9(tmpdir2(), "frizz-sysprompts");
     SESSION_ID_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{0,199}$/;
   }
 });
@@ -11080,10 +11209,10 @@ var init_adoption_recovery = __esm({
 });
 
 // packages/server/src/backend/codex-models.ts
-import { join as join9 } from "node:path";
-import { readFileSync as readFileSync4 } from "node:fs";
+import { join as join10 } from "node:path";
+import { readFileSync as readFileSync5 } from "node:fs";
 function cachePath(codexHome) {
-  return join9(codexHome, "models_cache.json");
+  return join10(codexHome, "models_cache.json");
 }
 function toCodexModel(raw2) {
   if (!raw2 || typeof raw2 !== "object") return void 0;
@@ -11119,7 +11248,7 @@ function readCodexModels(codexHome = defaultCodexHome()) {
   if (hit && now - hit.at < TTL_MS) return hit.models;
   let models;
   try {
-    models = parseCodexModelsCache(readFileSync4(path, "utf8"));
+    models = parseCodexModelsCache(readFileSync5(path, "utf8"));
   } catch {
     models = CODEX_MODELS_FALLBACK;
   }
@@ -11509,17 +11638,17 @@ var init_usage_limit = __esm({
 });
 
 // packages/server/src/backend/claude-broker-diagnostics.ts
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync5, readFileSync as readFileSync5, renameSync as renameSync4, statSync as statSync5 } from "node:fs";
-import { join as join10 } from "node:path";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync6, readFileSync as readFileSync6, renameSync as renameSync5, statSync as statSync5 } from "node:fs";
+import { join as join11 } from "node:path";
 function claudeBrokerDiagnosticLogPath(stateDir, sessionId) {
-  return join10(stateDir, "claude-broker", `${sessionId}.diagnostics.log`);
+  return join11(stateDir, "claude-broker", `${sessionId}.diagnostics.log`);
 }
 function readClaudeBrokerExit(stateDir, sessionId) {
   let newest = null;
   for (const path of [`${claudeBrokerDiagnosticLogPath(stateDir, sessionId)}.1`, claudeBrokerDiagnosticLogPath(stateDir, sessionId)]) {
     let text;
     try {
-      text = readFileSync5(path, "utf8");
+      text = readFileSync6(path, "utf8");
     } catch {
       continue;
     }
@@ -11554,11 +11683,11 @@ var init_claude_broker_diagnostics = __esm({
 });
 
 // packages/server/src/detached-daemons.ts
-import { existsSync as existsSync3 } from "node:fs";
+import { existsSync as existsSync4 } from "node:fs";
 import { fileURLToPath } from "node:url";
 function resolveDetachedDaemonEntry(moduleUrl, basename9) {
   const candidates = [`./${basename9}.js`, `./${basename9}.ts`].map((rel) => fileURLToPath(new URL(rel, moduleUrl)));
-  const found = candidates.find((path) => existsSync3(path));
+  const found = candidates.find((path) => existsSync4(path));
   if (!found) throw new Error(`frizz is missing the ${basename9} entry \u2014 looked for ${candidates.join(" and ")}`);
   return found;
 }
@@ -11570,19 +11699,19 @@ var init_detached_daemons = __esm({
 
 // packages/server/src/backend/claude-broker-host.ts
 import { spawn } from "node:child_process";
-import { createHash as createHash3, randomUUID as randomUUID7 } from "node:crypto";
-import { accessSync, constants as fsConstants, mkdirSync as mkdirSync6, readFileSync as readFileSync6, readdirSync as readdirSync4, unlinkSync } from "node:fs";
-import { delimiter, dirname as dirname3, isAbsolute as isAbsolute2, join as join11 } from "node:path";
+import { createHash as createHash4, randomUUID as randomUUID7 } from "node:crypto";
+import { accessSync, constants as fsConstants, mkdirSync as mkdirSync7, readFileSync as readFileSync7, readdirSync as readdirSync4, unlinkSync } from "node:fs";
+import { delimiter, dirname as dirname4, isAbsolute as isAbsolute2, join as join12 } from "node:path";
 function windowsShimTarget(shimPath) {
   let body;
   try {
-    body = readFileSync6(shimPath, "utf8");
+    body = readFileSync7(shimPath, "utf8");
   } catch {
     return void 0;
   }
   const target = WINDOWS_SHIM_TARGET.exec(body)?.[1];
   if (!target) return void 0;
-  const full = join11(dirname3(shimPath), target);
+  const full = join12(dirname4(shimPath), target);
   try {
     accessSync(full, fsConstants.F_OK);
     return full;
@@ -11597,17 +11726,17 @@ function resolveClaudeExecutableAbsolute(bin, env = process.env) {
   for (const dir of (env.PATH ?? "").split(delimiter)) {
     if (!dir) continue;
     if (windows) {
-      const exe = join11(dir, `${candidate}.exe`);
+      const exe = join12(dir, `${candidate}.exe`);
       try {
         accessSync(exe, fsConstants.F_OK);
         return exe;
       } catch {
       }
-      const viaShim = windowsShimTarget(join11(dir, `${candidate}.cmd`));
+      const viaShim = windowsShimTarget(join12(dir, `${candidate}.cmd`));
       if (viaShim) return viaShim;
       continue;
     }
-    const full = join11(dir, candidate);
+    const full = join12(dir, candidate);
     try {
       accessSync(full, fsConstants.X_OK);
       return full;
@@ -11617,13 +11746,13 @@ function resolveClaudeExecutableAbsolute(bin, env = process.env) {
   throw new Error(`Claude session broker: could not resolve '${candidate}' to an absolute executable path on PATH (the SDK requires one)`);
 }
 function claudeBrokerSocketPath(stateDir, sessionId) {
-  const key = createHash3("sha256").update(stateDir).update("\0").update(sessionId).digest("hex").slice(0, 16);
+  const key = createHash4("sha256").update(stateDir).update("\0").update(sessionId).digest("hex").slice(0, 16);
   if (process.platform === "win32") return `\\\\.\\pipe\\frizz-claude-${key}`;
-  return join11(process.env.TMPDIR ?? "/tmp", `frizz-claude-${key}.sock`);
+  return join12(process.env.TMPDIR ?? "/tmp", `frizz-claude-${key}.sock`);
 }
 function claudeBrokerRecordPath(stateDir, sessionId) {
-  const key = createHash3("sha256").update(sessionId).digest("hex").slice(0, 16);
-  return join11(stateDir, "claude-broker", `${key}.json`);
+  const key = createHash4("sha256").update(sessionId).digest("hex").slice(0, 16);
+  return join12(stateDir, "claude-broker", `${key}.json`);
 }
 function pidAlive(pid) {
   try {
@@ -11635,7 +11764,7 @@ function pidAlive(pid) {
 }
 function readBrokerRecord(recordPath2) {
   try {
-    return JSON.parse(readFileSync6(recordPath2, "utf8"));
+    return JSON.parse(readFileSync7(recordPath2, "utf8"));
   } catch {
     return null;
   }
@@ -11652,7 +11781,7 @@ function liveBrokerRecord(recordPath2) {
   return null;
 }
 function liveBrokerRecords(stateDir) {
-  const dir = join11(stateDir, "claude-broker");
+  const dir = join12(stateDir, "claude-broker");
   let names;
   try {
     names = readdirSync4(dir);
@@ -11662,7 +11791,7 @@ function liveBrokerRecords(stateDir) {
   const out = [];
   for (const name of names) {
     if (!name.endsWith(".json")) continue;
-    const record = liveBrokerRecord(join11(dir, name));
+    const record = liveBrokerRecord(join12(dir, name));
     if (record) out.push(record);
   }
   return out;
@@ -11670,7 +11799,7 @@ function liveBrokerRecords(stateDir) {
 function forkBroker(options) {
   const socketPath = claudeBrokerSocketPath(options.stateDir, options.sessionId);
   const recordPath2 = claudeBrokerRecordPath(options.stateDir, options.sessionId);
-  mkdirSync6(dirname3(recordPath2), { recursive: true });
+  mkdirSync7(dirname4(recordPath2), { recursive: true });
   const config = {
     socketPath,
     cwd: options.cwd,
@@ -11701,10 +11830,10 @@ function forkBroker(options) {
   });
   child.unref();
   const deadline = Date.now() + (options.timeoutMs ?? 3e4);
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     const poll = () => {
       const record = readBrokerRecord(recordPath2);
-      if (record && pidAlive(record.daemonPid)) return resolve9(record);
+      if (record && pidAlive(record.daemonPid)) return resolve10(record);
       if (Date.now() > deadline) return reject(new Error(`Claude broker for session ${options.sessionId} did not become ready`));
       setTimeout(poll, 50);
     };
@@ -12103,7 +12232,7 @@ var init_delivery_ledger = __esm({
 });
 
 // packages/server/src/codex-subagents.ts
-import { closeSync as closeSync4, openSync as openSync5, readSync as readSync2, statSync as statSync6 } from "node:fs";
+import { closeSync as closeSync5, openSync as openSync6, readSync as readSync2, statSync as statSync6 } from "node:fs";
 function createCodexSubAgentTracker(deps) {
   const findRollouts = deps.findRollouts ?? ((ids) => findRolloutsByIds(ids, deps.codexHome));
   const readAppended = deps.readAppended ?? defaultReadAppended;
@@ -12294,13 +12423,13 @@ function defaultReadAppended(path, offset) {
   const from = restarted ? 0 : offset;
   if (size <= from) return { text: "", offset: from, restarted };
   try {
-    const fd = openSync5(path, "r");
+    const fd = openSync6(path, "r");
     try {
       const buf = Buffer.allocUnsafe(size - from);
       const read = readSync2(fd, buf, 0, buf.length, from);
       return { text: buf.toString("utf8", 0, read), offset: from + read, restarted };
     } finally {
-      closeSync4(fd);
+      closeSync5(fd);
     }
   } catch {
     return void 0;
@@ -12396,16 +12525,16 @@ var init_completion_relay = __esm({
 });
 
 // packages/server/src/tail-cache.ts
-import { createHash as createHash4 } from "node:crypto";
-import { closeSync as closeSync5, openSync as openSync6, readFileSync as readFileSync7, readSync as readSync3, statSync as statSync7 } from "node:fs";
-import { join as join12 } from "node:path";
+import { createHash as createHash5 } from "node:crypto";
+import { closeSync as closeSync6, openSync as openSync7, readFileSync as readFileSync8, readSync as readSync3, statSync as statSync7 } from "node:fs";
+import { join as join13 } from "node:path";
 function foldSchemaDigest(dir = import.meta.dirname) {
   if (foldSchemaMemo) return foldSchemaMemo;
-  const hash = createHash4("sha256").update("frizz-tail-state-v1\0");
+  const hash = createHash5("sha256").update("frizz-tail-state-v1\0");
   let read = 0;
   for (const name of FOLD_SOURCES) {
     try {
-      hash.update(name).update("\0").update(readFileSync7(join12(dir, name)));
+      hash.update(name).update("\0").update(readFileSync8(join13(dir, name)));
       read++;
     } catch {
       hash.update(name).update("\0missing\0");
@@ -12437,14 +12566,14 @@ function measureFence(path, offset) {
   try {
     const stat2 = statSync7(path);
     if (stat2.size < offset) return null;
-    fd = openSync6(path, "r");
+    fd = openSync7(path, "r");
     const window = Math.min(SAMPLE_BYTES, offset);
     const head = Buffer.allocUnsafe(window);
     const headRead = readSync3(fd, head, 0, window, 0);
     const tail = Buffer.allocUnsafe(window);
     const tailRead = readSync3(fd, tail, 0, window, offset - window);
     if (headRead !== window || tailRead !== window) return null;
-    const contentDigest = createHash4("sha256").update(String(offset)).update("\0").update(head).update("\0").update(tail).digest("hex").slice(0, 32);
+    const contentDigest = createHash5("sha256").update(String(offset)).update("\0").update(head).update("\0").update(tail).digest("hex").slice(0, 32);
     return {
       offset,
       size: stat2.size,
@@ -12457,7 +12586,7 @@ function measureFence(path, offset) {
   } finally {
     if (fd !== void 0) {
       try {
-        closeSync5(fd);
+        closeSync6(fd);
       } catch {
       }
     }
@@ -12601,9 +12730,9 @@ var init_tail_cache = __esm({
 });
 
 // packages/server/src/tailer.ts
-import { statSync as statSync8, openSync as openSync7, readSync as readSync4, closeSync as closeSync6, readdirSync as readdirSync5, mkdirSync as mkdirSync7, writeFileSync as writeFileSync4, readFileSync as readFileSync8, existsSync as existsSync4 } from "node:fs";
-import { join as join13 } from "node:path";
-import { homedir as homedir6, tmpdir as tmpdir3 } from "node:os";
+import { statSync as statSync8, openSync as openSync8, readSync as readSync4, closeSync as closeSync7, readdirSync as readdirSync5, mkdirSync as mkdirSync8, writeFileSync as writeFileSync5, readFileSync as readFileSync9, existsSync as existsSync5 } from "node:fs";
+import { join as join14 } from "node:path";
+import { homedir as homedir7, tmpdir as tmpdir3 } from "node:os";
 function activityMinute(at) {
   if (!at) return "";
   const ms = Date.parse(at);
@@ -12865,7 +12994,7 @@ function launchTaskId(text) {
 function readDescendantSidecars(sessionDir, mtimeMs) {
   let names;
   try {
-    names = readdirSync5(join13(sessionDir, "subagents"));
+    names = readdirSync5(join14(sessionDir, "subagents"));
   } catch {
     return [];
   }
@@ -12876,7 +13005,7 @@ function readDescendantSidecars(sessionDir, mtimeMs) {
     if (!agentId) continue;
     let parsed;
     try {
-      parsed = JSON.parse(readFileSync8(join13(sessionDir, "subagents", name), "utf8"));
+      parsed = JSON.parse(readFileSync9(join14(sessionDir, "subagents", name), "utf8"));
     } catch {
       continue;
     }
@@ -12890,7 +13019,7 @@ function readDescendantSidecars(sessionDir, mtimeMs) {
       agentType: text(meta.agentType),
       parentAgentId: text(meta.parentAgentId),
       spawnDepth: typeof meta.spawnDepth === "number" && Number.isFinite(meta.spawnDepth) ? meta.spawnDepth : void 0,
-      spawnedAtMs: mtimeMs(join13(sessionDir, "subagents", name))
+      spawnedAtMs: mtimeMs(join14(sessionDir, "subagents", name))
     });
   }
   return out;
@@ -13338,13 +13467,13 @@ function defaultMtimeMs(path) {
   }
 }
 function defaultLogDir(project) {
-  return join13(homedir6(), ".claude", "projects", project.cwdSlug);
+  return join14(homedir7(), ".claude", "projects", project.cwdSlug);
 }
 function defaultReadPermMarker(project) {
   if (!project.stateDir) return () => void 0;
   return (slug) => {
     try {
-      const parsed = JSON.parse(readFileSync8(permMarkerPath(project, slug), "utf8"));
+      const parsed = JSON.parse(readFileSync9(permMarkerPath(project, slug), "utf8"));
       return isPermMarker(parsed) ? parsed : void 0;
     } catch {
       return void 0;
@@ -13362,7 +13491,7 @@ function defaultBrokerDaemonAlive(project, now) {
     try {
       const path = claudeBrokerRecordPath(project.stateDir, sessionId);
       const record = readBrokerRecord(path);
-      if (!record) alive = existsSync4(path);
+      if (!record) alive = existsSync5(path);
       else if (typeof record.daemonPid !== "number") alive = true;
       else {
         try {
@@ -13508,7 +13637,7 @@ function createTailer(deps) {
     return "";
   }
   const defaultBackend = {
-    transcriptPath: (sessionId) => join13(logDir, `${sessionId}.jsonl`),
+    transcriptPath: (sessionId) => join14(logDir, `${sessionId}.jsonl`),
     foldLine: (state, line) => {
       const rec = parseLine(line);
       if (rec) applyRecord(state, rec);
@@ -13629,7 +13758,7 @@ ${ask}`;
     return state.path.replace(/\.jsonl$/, "");
   }
   function descendantSidecars(state) {
-    const at = mtimeMs(join13(sessionDirOf(state), "subagents"));
+    const at = mtimeMs(join14(sessionDirOf(state), "subagents"));
     const cached2 = descendantIndex.get(state.slug);
     if (cached2 && cached2.at === at) return cached2.all;
     const all = readDescendantSidecars(sessionDirOf(state), mtimeMs);
@@ -13643,7 +13772,7 @@ ${ask}`;
     return descendantIndex.get(state.slug)?.byToolUse.get(id);
   }
   function descendantTranscript(state, meta) {
-    return join13(sessionDirOf(state), "subagents", `agent-${meta.agentId}.jsonl`);
+    return join14(sessionDirOf(state), "subagents", `agent-${meta.agentId}.jsonl`);
   }
   function subAgentDescendantTasks(slug, id) {
     const state = states.get(slug);
@@ -13902,7 +14031,7 @@ ${ask}`;
       if (name.startsWith(".") || !name.endsWith(".jsonl")) continue;
       const id = name.slice(0, -".jsonl".length);
       if (!id || registered.has(id)) continue;
-      const path = join13(logDir, name);
+      const path = join14(logDir, name);
       let mtime;
       try {
         mtime = statSync8(path).mtimeMs;
@@ -14106,14 +14235,14 @@ ${ask}`;
     if (size <= state.offset) return;
     let chunk = "";
     try {
-      const fd = openSync7(state.path, "r");
+      const fd = openSync8(state.path, "r");
       try {
         const buf = Buffer.allocUnsafe(size - state.offset);
         const read = readSync4(fd, buf, 0, buf.length, state.offset);
         chunk = buf.toString("utf8", 0, read);
         state.offset += read;
       } finally {
-        closeSync6(fd);
+        closeSync7(fd);
       }
     } catch {
       return;
@@ -14152,8 +14281,8 @@ ${ask}`;
       `thread ${row.slug} (session ${row.session_id}): no transcript ${DISCOVERY_GRACE_MS / 1e3}s after dispatch \u2014 likely a boot failure. ${isHeadlessRow(row) && !pane.trim() && !authFailure ? "" : "Pane:\n"}${detail.slice(0, 4e3)}`
     );
     try {
-      mkdirSync7(STALL_LOG_DIR, { recursive: true });
-      writeFileSync4(join13(STALL_LOG_DIR, `${row.slug}.stall.log`), `session_id: ${row.session_id}
+      mkdirSync8(STALL_LOG_DIR, { recursive: true });
+      writeFileSync5(join14(STALL_LOG_DIR, `${row.slug}.stall.log`), `session_id: ${row.session_id}
 captured_at: ${new Date(now()).toISOString()}
 
 ${detail}
@@ -14192,7 +14321,7 @@ ${detail}
         committed = false;
       }
       if (!committed) return false;
-      state.path = join13(logDir, `${found}.jsonl`);
+      state.path = join14(logDir, `${found}.jsonl`);
       state.offset = 0;
       state.partial = "";
       state.primed = false;
@@ -14220,7 +14349,7 @@ ${detail}
       let state = states.get(row.slug);
       const runtimeGeneration = row.runtime_generation ?? 0;
       if (!state || state.sessionId !== row.session_id || state.nativeSessionId !== nativeId || state.runtimeGeneration !== runtimeGeneration) {
-        const path = backend.transcriptPath(nativeId) ?? join13(logDir, `${nativeId}.jsonl`);
+        const path = backend.transcriptPath(nativeId) ?? join14(logDir, `${nativeId}.jsonl`);
         state = newTailState(row.slug, row.session_id, path, false, nativeId, runtimeGeneration);
         state.dismissedOps = deps.storage.retiredOps(row.slug, row.session_id);
         hydrateFromCache(state, row, nativeId);
@@ -14588,7 +14717,7 @@ var init_tailer = __esm({
     CACHE_FLUSH_MS = 3e4;
     PRIME_PROGRESS_EVERY = 20;
     DISCOVER_RETRY_MS = 15e3;
-    STALL_LOG_DIR = join13(tmpdir3(), "frizz-worker-logs");
+    STALL_LOG_DIR = join14(tmpdir3(), "frizz-worker-logs");
     PERM_YES_OPTION = /(^|\n)\s*(❯\s*)?1\.\s+Yes\b/;
     PERM_QUESTION = /\b(?:Do you want|Would you like)\b/;
     PERM_FOOTER = /\bEsc to (cancel|reject)\b/;
@@ -14653,14 +14782,14 @@ var init_tailer = __esm({
 });
 
 // packages/server/src/backend/codex.ts
-import { join as join14 } from "node:path";
-import { homedir as homedir7 } from "node:os";
+import { join as join15 } from "node:path";
+import { homedir as homedir8 } from "node:os";
 import { readdirSync as readdirSync6, statSync as statSync9 } from "node:fs";
 function defaultCodexHome() {
-  return process.env.CODEX_HOME && process.env.CODEX_HOME.trim() ? process.env.CODEX_HOME : join14(homedir7(), ".codex");
+  return process.env.CODEX_HOME && process.env.CODEX_HOME.trim() ? process.env.CODEX_HOME : join15(homedir8(), ".codex");
 }
 function sessionsDir(codexHome) {
-  return join14(codexHome, "sessions");
+  return join15(codexHome, "sessions");
 }
 function codexSandbox(mode) {
   switch (mode) {
@@ -15077,17 +15206,17 @@ function collectRollouts(dir, out, budget) {
   const files = entries.filter((e) => e.isFile() && e.name.startsWith("rollout-") && e.name.endsWith(".jsonl")).sort(descByName);
   for (const d of dirs) {
     if (budget.n <= 0) return;
-    collectRollouts(join14(dir, d.name), out, budget);
+    collectRollouts(join15(dir, d.name), out, budget);
   }
   for (const f of files) {
     if (budget.n <= 0) return;
     let mtimeMs;
     try {
-      mtimeMs = statSync9(join14(dir, f.name)).mtimeMs;
+      mtimeMs = statSync9(join15(dir, f.name)).mtimeMs;
     } catch {
       continue;
     }
-    out.push({ path: join14(dir, f.name), mtimeMs });
+    out.push({ path: join15(dir, f.name), mtimeMs });
     budget.n--;
   }
 }
@@ -17508,7 +17637,7 @@ var require_extension = __commonJS({
       if (dest[name] === void 0) dest[name] = [elem];
       else dest[name].push(elem);
     }
-    function parse(header) {
+    function parse2(header) {
       const offers = /* @__PURE__ */ Object.create(null);
       let params = /* @__PURE__ */ Object.create(null);
       let mustUnescape = false;
@@ -17648,7 +17777,7 @@ var require_extension = __commonJS({
         }).join(", ");
       }).join(", ");
     }
-    module.exports = { format, parse };
+    module.exports = { format, parse: parse2 };
   }
 });
 
@@ -17661,7 +17790,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net2 = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes2, createHash: createHash15 } = __require("crypto");
+    var { randomBytes: randomBytes2, createHash: createHash16 } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -17682,7 +17811,7 @@ var require_websocket = __commonJS({
     var {
       EventTarget: { addEventListener: addEventListener2, removeEventListener }
     } = require_event_target();
-    var { format, parse } = require_extension();
+    var { format, parse: parse2 } = require_extension();
     var { toBuffer } = require_buffer_util();
     var kAborted = Symbol("kAborted");
     var protocolVersions = [8, 13];
@@ -18329,7 +18458,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash15("sha1").update(key + GUID).digest("base64");
+        const digest = createHash16("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -18359,7 +18488,7 @@ var require_websocket = __commonJS({
           }
           let extensions;
           try {
-            extensions = parse(secWebSocketExtensions);
+            extensions = parse2(secWebSocketExtensions);
           } catch (err) {
             const message = "Invalid Sec-WebSocket-Extensions header";
             abortHandshake(websocket, socket, message);
@@ -18651,7 +18780,7 @@ var require_subprotocol = __commonJS({
   "node_modules/.pnpm/ws@8.21.0/node_modules/ws/lib/subprotocol.js"(exports, module) {
     "use strict";
     var { tokenChars } = require_validation();
-    function parse(header) {
+    function parse2(header) {
       const protocols = /* @__PURE__ */ new Set();
       let start = -1;
       let end = -1;
@@ -18687,7 +18816,7 @@ var require_subprotocol = __commonJS({
       protocols.add(protocol);
       return protocols;
     }
-    module.exports = { parse };
+    module.exports = { parse: parse2 };
   }
 });
 
@@ -18698,7 +18827,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash15 } = __require("crypto");
+    var { createHash: createHash16 } = __require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -19005,7 +19134,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash15("sha1").update(key + GUID).digest("base64");
+        const digest = createHash16("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -19175,21 +19304,21 @@ var init_codex_mcp = __esm({
 // packages/server/src/backend/codex-app-server-native.ts
 import { spawn as spawn2 } from "node:child_process";
 import { connect } from "node:net";
-import { createHash as createHash5, randomUUID as randomUUID8 } from "node:crypto";
-import { existsSync as existsSync5, mkdirSync as mkdirSync8, readFileSync as readFileSync9, unlinkSync as unlinkSync2, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join15 } from "node:path";
+import { createHash as createHash6, randomUUID as randomUUID8 } from "node:crypto";
+import { existsSync as existsSync6, mkdirSync as mkdirSync9, readFileSync as readFileSync10, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join16 } from "node:path";
 import { PassThrough, Writable } from "node:stream";
 import { StringDecoder } from "node:string_decoder";
 function nativeDir(stateDir) {
-  return join15(stateDir, "codex-app-server-native");
+  return join16(stateDir, "codex-app-server-native");
 }
 function nativeRecordPath(stateDir, projectId) {
-  return join15(nativeDir(stateDir), `${projectId}.json`);
+  return join16(nativeDir(stateDir), `${projectId}.json`);
 }
 function nativeListenSocketPath(stateDir, projectId) {
-  const key = createHash5("sha256").update(stateDir).update("\0").update(projectId).digest("hex").slice(0, 16);
+  const key = createHash6("sha256").update(stateDir).update("\0").update(projectId).digest("hex").slice(0, 16);
   if (process.platform === "win32") return `\\\\.\\pipe\\frizz-codex-native-${key}`;
-  return join15(process.env.TMPDIR ?? "/tmp", `frizz-codex-native-${key}.sock`);
+  return join16(process.env.TMPDIR ?? "/tmp", `frizz-codex-native-${key}.sock`);
 }
 function pidAlive2(pid) {
   try {
@@ -19201,7 +19330,7 @@ function pidAlive2(pid) {
 }
 function readNativeRecord(stateDir, projectId) {
   try {
-    const value = JSON.parse(readFileSync9(nativeRecordPath(stateDir, projectId), "utf8"));
+    const value = JSON.parse(readFileSync10(nativeRecordPath(stateDir, projectId), "utf8"));
     if (typeof value.listenerPid !== "number" || typeof value.socketPath !== "string" || typeof value.generation !== "string") return null;
     return {
       projectId,
@@ -19217,7 +19346,7 @@ function readNativeRecord(stateDir, projectId) {
 function liveNativeRecord(stateDir, projectId) {
   const record = readNativeRecord(stateDir, projectId);
   if (!record) return null;
-  if (pidAlive2(record.listenerPid) && existsSync5(record.socketPath)) return record;
+  if (pidAlive2(record.listenerPid) && existsSync6(record.socketPath)) return record;
   try {
     unlinkSync2(nativeRecordPath(stateDir, projectId));
   } catch {
@@ -19242,7 +19371,7 @@ async function stopNativeListener(stateDir, projectId, timeoutMs = 1e4) {
   if (!record) return;
   const deadline = Date.now() + timeoutMs;
   while (pidAlive2(record.listenerPid) && Date.now() < deadline) {
-    await new Promise((resolve9) => setTimeout(resolve9, 25));
+    await new Promise((resolve10) => setTimeout(resolve10, 25));
   }
   if (pidAlive2(record.listenerPid)) {
     try {
@@ -19250,16 +19379,16 @@ async function stopNativeListener(stateDir, projectId, timeoutMs = 1e4) {
     } catch {
     }
     while (pidAlive2(record.listenerPid) && Date.now() < deadline + 2e3) {
-      await new Promise((resolve9) => setTimeout(resolve9, 25));
+      await new Promise((resolve10) => setTimeout(resolve10, 25));
     }
   }
 }
 function socketAccepting(socketPath) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     const probe = connect(socketPath);
     const done = (value) => {
       probe.destroy();
-      resolve9(value);
+      resolve10(value);
     };
     probe.once("connect", () => done(true));
     probe.once("error", () => done(false));
@@ -19267,7 +19396,7 @@ function socketAccepting(socketPath) {
   });
 }
 function attach(record, timeoutMs) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     const socket = new import_websocket.default(`ws+unix://${record.socketPath}:/`, { perMessageDeflate: false });
     const stdout = new PassThrough();
     const stderr = new PassThrough();
@@ -19320,7 +19449,7 @@ function attach(record, timeoutMs) {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve9(handle);
+      resolve10(handle);
     });
     socket.on("message", (data) => {
       const text = typeof data === "string" ? data : Buffer.isBuffer(data) ? data.toString("utf8") : Buffer.concat(data).toString("utf8");
@@ -19348,9 +19477,9 @@ function attach(record, timeoutMs) {
 }
 async function startListener(options) {
   const { stateDir, projectId } = options;
-  mkdirSync8(nativeDir(stateDir), { recursive: true });
+  mkdirSync9(nativeDir(stateDir), { recursive: true });
   const socketPath = nativeListenSocketPath(stateDir, projectId);
-  if (existsSync5(socketPath) && !await socketAccepting(socketPath)) {
+  if (existsSync6(socketPath) && !await socketAccepting(socketPath)) {
     try {
       unlinkSync2(socketPath);
     } catch {
@@ -19371,13 +19500,13 @@ async function startListener(options) {
     socketPath,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  writeFileSync5(nativeRecordPath(stateDir, projectId), JSON.stringify(record));
+  writeFileSync6(nativeRecordPath(stateDir, projectId), JSON.stringify(record));
   const deadline = Date.now() + (options.timeoutMs ?? 3e4);
   for (; ; ) {
-    if (existsSync5(socketPath) && await socketAccepting(socketPath)) return record;
+    if (existsSync6(socketPath) && await socketAccepting(socketPath)) return record;
     if (!pidAlive2(record.listenerPid)) throw new Error("codex app-server listener exited before it became ready");
     if (Date.now() > deadline) throw new Error("codex app-server listener did not become ready");
-    await new Promise((resolve9) => setTimeout(resolve9, 50));
+    await new Promise((resolve10) => setTimeout(resolve10, 50));
   }
 }
 var PRESUMED_LOSSY_REJOIN, nativeListenCodexAppServerHost;
@@ -19438,21 +19567,21 @@ var init_codex_app_server_native = __esm({
 // packages/server/src/backend/codex-app-server-host.ts
 import { spawn as spawn3 } from "node:child_process";
 import { createConnection } from "node:net";
-import { createHash as createHash6, randomUUID as randomUUID9 } from "node:crypto";
-import { existsSync as existsSync6, mkdirSync as mkdirSync9, readFileSync as readFileSync10, unlinkSync as unlinkSync3 } from "node:fs";
-import { join as join16 } from "node:path";
+import { createHash as createHash7, randomUUID as randomUUID9 } from "node:crypto";
+import { existsSync as existsSync7, mkdirSync as mkdirSync10, readFileSync as readFileSync11, unlinkSync as unlinkSync3 } from "node:fs";
+import { join as join17 } from "node:path";
 import { PassThrough as PassThrough2, Writable as Writable2 } from "node:stream";
 import { StringDecoder as StringDecoder2 } from "node:string_decoder";
 function daemonDir(stateDir) {
-  return join16(stateDir, "codex-app-server");
+  return join17(stateDir, "codex-app-server");
 }
 function recordPath(stateDir, projectId) {
-  return join16(daemonDir(stateDir), `${projectId}.json`);
+  return join17(daemonDir(stateDir), `${projectId}.json`);
 }
 function codexAppServerSocketPath(stateDir, projectId) {
-  const key = createHash6("sha256").update(stateDir).update("\0").update(projectId).digest("hex").slice(0, 16);
+  const key = createHash7("sha256").update(stateDir).update("\0").update(projectId).digest("hex").slice(0, 16);
   if (process.platform === "win32") return `\\\\.\\pipe\\frizz-codex-${key}`;
-  return join16(process.env.TMPDIR ?? "/tmp", `frizz-codex-${key}.sock`);
+  return join17(process.env.TMPDIR ?? "/tmp", `frizz-codex-${key}.sock`);
 }
 function pidAlive3(pid) {
   try {
@@ -19464,7 +19593,7 @@ function pidAlive3(pid) {
 }
 function readDaemonRecord(stateDir, projectId) {
   try {
-    const value = JSON.parse(readFileSync10(recordPath(stateDir, projectId), "utf8"));
+    const value = JSON.parse(readFileSync11(recordPath(stateDir, projectId), "utf8"));
     if (typeof value.daemonPid !== "number" || typeof value.socketPath !== "string" || typeof value.generation !== "string") return null;
     return {
       projectId,
@@ -19480,7 +19609,7 @@ function readDaemonRecord(stateDir, projectId) {
 }
 function readDaemonExitBreadcrumb(stateDir, projectId) {
   try {
-    const value = JSON.parse(readFileSync10(`${recordPath(stateDir, projectId)}.exit`, "utf8"));
+    const value = JSON.parse(readFileSync11(`${recordPath(stateDir, projectId)}.exit`, "utf8"));
     if (typeof value.generation !== "string" || typeof value.reason !== "string") return null;
     return {
       generation: value.generation,
@@ -19522,7 +19651,7 @@ async function stopCodexAppServerDaemon(stateDir, projectId, timeoutMs = 1e4) {
   if (!record) return;
   const deadline = Date.now() + timeoutMs;
   while (pidAlive3(record.daemonPid) && Date.now() < deadline) {
-    await new Promise((resolve9) => setTimeout(resolve9, 25));
+    await new Promise((resolve10) => setTimeout(resolve10, 25));
   }
   if (pidAlive3(record.daemonPid)) {
     try {
@@ -19530,13 +19659,13 @@ async function stopCodexAppServerDaemon(stateDir, projectId, timeoutMs = 1e4) {
     } catch {
     }
     while (pidAlive3(record.daemonPid) && Date.now() < deadline + 2e3) {
-      await new Promise((resolve9) => setTimeout(resolve9, 25));
+      await new Promise((resolve10) => setTimeout(resolve10, 25));
     }
   }
 }
 function forkDaemon(options) {
   const { stateDir, projectId } = options;
-  mkdirSync9(daemonDir(stateDir), { recursive: true });
+  mkdirSync10(daemonDir(stateDir), { recursive: true });
   const record = recordPath(stateDir, projectId);
   try {
     unlinkSync3(record);
@@ -19572,10 +19701,10 @@ function forkDaemon(options) {
   });
   child.unref();
   const deadline = Date.now() + (options.timeoutMs ?? 3e4);
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     const poll = () => {
       const found = readDaemonRecord(stateDir, projectId);
-      if (found && pidAlive3(found.daemonPid)) return resolve9(found);
+      if (found && pidAlive3(found.daemonPid)) return resolve10(found);
       if (!pidAlive3(child.pid ?? -1) && !found) return reject(new Error("codex app-server daemon exited before it became ready"));
       if (Date.now() > deadline) return reject(new Error("codex app-server daemon did not become ready"));
       setTimeout(poll, 50);
@@ -19593,7 +19722,7 @@ function helloDropCount(line) {
   }
 }
 function attach2(record, timeoutMs) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     const socket = createConnection(record.socketPath);
     const stdout = new PassThrough2();
     const stderr = new PassThrough2();
@@ -19643,7 +19772,7 @@ function attach2(record, timeoutMs) {
           if (!settled) {
             settled = true;
             clearTimeout(timer);
-            resolve9({ process: handle, droppedWhileDetached: helloDropCount(trimmed) });
+            resolve10({ process: handle, droppedWhileDetached: helloDropCount(trimmed) });
           }
           continue;
         }
@@ -19711,7 +19840,7 @@ var init_codex_app_server_host = __esm({
       }
       if (process.platform !== "win32") {
         const stale = codexAppServerSocketPath(options.stateDir, options.projectId);
-        if (existsSync6(stale) && !liveDaemonRecord(options.stateDir, options.projectId)) {
+        if (existsSync7(stale) && !liveDaemonRecord(options.stateDir, options.projectId)) {
           try {
             unlinkSync3(stale);
           } catch {
@@ -19731,7 +19860,7 @@ var init_codex_app_server_host = __esm({
 });
 
 // packages/server/src/backend/codex-app-server.ts
-import { createHash as createHash7, randomUUID as randomUUID10 } from "node:crypto";
+import { createHash as createHash8, randomUUID as randomUUID10 } from "node:crypto";
 import { StringDecoder as StringDecoder3 } from "node:string_decoder";
 function selectCodexHostKind(flagValue, platform3, hasSpawn) {
   if (hasSpawn) return "direct";
@@ -19741,11 +19870,11 @@ function selectCodexHostKind(flagValue, platform3, hasSpawn) {
   return nativeSupported ? "native" : "daemon";
 }
 function compareCodexVersions(a, b) {
-  const parse = (v) => {
+  const parse2 = (v) => {
     const m = v.match(/^(\d+)\.(\d+)\.(\d+)/);
     return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : [-1, -1, -1];
   };
-  const [x, y] = [parse(a), parse(b)];
+  const [x, y] = [parse2(a), parse2(b)];
   for (let i = 0; i < 3; i++) if (x[i] !== y[i]) return x[i] < y[i] ? -1 : 1;
   return 0;
 }
@@ -20078,7 +20207,7 @@ function canonicalJson2(value) {
   return JSON.stringify(normalize2(value));
 }
 function logicalRequestId(method, parts) {
-  const digest = createHash7("sha256").update(JSON.stringify([method, ...parts])).digest("hex");
+  const digest = createHash8("sha256").update(JSON.stringify([method, ...parts])).digest("hex");
   return `codex-${digest}`;
 }
 function requestFingerprint(value) {
@@ -20088,7 +20217,7 @@ function requestFingerprint(value) {
     delete record.startedAtMs;
     delete record.autoResolutionMs;
   }
-  return createHash7("sha256").update(canonicalJson2(normalized)).digest("hex");
+  return createHash8("sha256").update(canonicalJson2(normalized)).digest("hex");
 }
 function decision(id, semantic, label) {
   return { id, semantic, label };
@@ -20556,12 +20685,12 @@ var init_codex_app_server = __esm({
         if (this.pending.size >= MAX_OUTBOUND_REQUESTS) throw new Error("Codex app-server outbound request queue is full");
         if (!Number.isSafeInteger(this.nextId)) throw new Error("Codex app-server request id space is exhausted");
         const id = this.nextId++;
-        const result = new Promise((resolve9, reject) => {
+        const result = new Promise((resolve10, reject) => {
           const timer = setTimeout(() => {
             this.pending.delete(id);
             reject(new Error(`Codex app-server request timed out: ${method}`));
           }, this.timeoutMs);
-          this.pending.set(id, { resolve: resolve9, reject, timer });
+          this.pending.set(id, { resolve: resolve10, reject, timer });
         });
         try {
           await this.write({ id, method, params });
@@ -20598,7 +20727,7 @@ var init_codex_app_server = __esm({
       }
       whenIdle() {
         if (!this.draining) return Promise.resolve();
-        return new Promise((resolve9) => this.idleWaiters.add(resolve9));
+        return new Promise((resolve10) => this.idleWaiters.add(resolve10));
       }
       consume(chunk) {
         if (this.closed) return;
@@ -20657,7 +20786,7 @@ var init_codex_app_server = __esm({
             queueMicrotask(() => void this.drain());
           }
           if (!this.draining) {
-            for (const resolve9 of this.idleWaiters) resolve9();
+            for (const resolve10 of this.idleWaiters) resolve10();
             this.idleWaiters.clear();
           }
         }
@@ -20721,8 +20850,8 @@ var init_codex_app_server = __esm({
         if (Buffer.byteLength(line, "utf8") > MAX_JSONL_BYTES) {
           return Promise.reject(new Error("Codex app-server outbound message exceeded its limit"));
         }
-        return new Promise((resolve9, reject) => {
-          this.child.stdin.write(line, "utf8", (error) => error ? reject(error) : resolve9());
+        return new Promise((resolve10, reject) => {
+          this.child.stdin.write(line, "utf8", (error) => error ? reject(error) : resolve10());
         });
       }
       fail(reason, error) {
@@ -21303,7 +21432,7 @@ var init_codex_app_server = __esm({
         while (Date.now() - start < ms) {
           const row = this.bindingForScope(threadSlug, sessionId);
           if (!row || row.current_turn_id !== turnId) return;
-          await new Promise((resolve9) => setTimeout(resolve9, 50));
+          await new Promise((resolve10) => setTimeout(resolve10, 50));
         }
       }
       async waitForTurnCleared(threadSlug, sessionId, ms) {
@@ -21311,7 +21440,7 @@ var init_codex_app_server = __esm({
         while (Date.now() - start < ms) {
           const row = this.bindingForScope(threadSlug, sessionId);
           if (!row || row.current_turn_id === null) return;
-          await new Promise((resolve9) => setTimeout(resolve9, 100));
+          await new Promise((resolve10) => setTimeout(resolve10, 100));
         }
       }
       // Dispatch entry: create a PERSISTED (ephemeral:false, restart-resumable) session with the worker
@@ -21515,14 +21644,14 @@ var init_codex_app_server = __esm({
           released = true;
           this.activeOperations--;
           if (this.activeOperations === 0) {
-            for (const resolve9 of this.operationWaiters) resolve9();
+            for (const resolve10 of this.operationWaiters) resolve10();
             this.operationWaiters.clear();
           }
         };
       }
       whenOperationsIdle() {
         if (this.activeOperations === 0) return Promise.resolve();
-        return new Promise((resolve9) => this.operationWaiters.add(resolve9));
+        return new Promise((resolve10) => this.operationWaiters.add(resolve10));
       }
       closeDatabase() {
         if (this.dbClosed) return;
@@ -22036,18 +22165,18 @@ var init_codex_app_server = __esm({
             if (set.size === 0) this.settingsWaiters.delete(threadId);
           }
         };
-        const promise = new Promise((resolve9) => {
-          settle = resolve9;
+        const promise = new Promise((resolve10) => {
+          settle = resolve10;
           listener = (observed) => {
             detach();
-            resolve9(observed);
+            resolve10(observed);
           };
           const set = this.settingsWaiters.get(threadId) ?? /* @__PURE__ */ new Set();
           set.add(listener);
           this.settingsWaiters.set(threadId, set);
           timer = setTimeout(() => {
             detach();
-            resolve9(void 0);
+            resolve10(void 0);
           }, timeoutMs);
           timer.unref?.();
         });
@@ -22620,11 +22749,11 @@ var init_codex_app_server = __esm({
 });
 
 // packages/server/src/backend/codex-quota.ts
-import { join as join17 } from "node:path";
-import { readdirSync as readdirSync7, statSync as statSync10, openSync as openSync8, readSync as readSync5, fstatSync, closeSync as closeSync7 } from "node:fs";
+import { join as join18 } from "node:path";
+import { readdirSync as readdirSync7, statSync as statSync10, openSync as openSync9, readSync as readSync5, fstatSync, closeSync as closeSync8 } from "node:fs";
 import { spawn as spawn4 } from "node:child_process";
 function sessionsDir2(codexHome) {
-  return join17(codexHome, "sessions");
+  return join18(codexHome, "sessions");
 }
 function newestRollouts(dir, out, budget) {
   if (budget.n <= 0) return;
@@ -22638,18 +22767,18 @@ function newestRollouts(dir, out, budget) {
   const files = entries.filter((e) => e.isFile() && e.name.startsWith("rollout-") && e.name.endsWith(".jsonl")).map((e) => e.name).sort(descByName2);
   for (const d of dirs) {
     if (budget.n <= 0) return;
-    newestRollouts(join17(dir, d), out, budget);
+    newestRollouts(join18(dir, d), out, budget);
   }
   for (const f of files) {
     if (budget.n <= 0) return;
-    out.push(join17(dir, f));
+    out.push(join18(dir, f));
     budget.n--;
   }
 }
 function readTail(path) {
   let fd;
   try {
-    fd = openSync8(path, "r");
+    fd = openSync9(path, "r");
     const size = fstatSync(fd).size;
     const start = Math.max(0, size - TAIL_BYTES);
     const len = size - start;
@@ -22666,7 +22795,7 @@ function readTail(path) {
   } finally {
     if (fd !== void 0) {
       try {
-        closeSync7(fd);
+        closeSync8(fd);
       } catch {
       }
     }
@@ -22747,7 +22876,7 @@ function parseCodexQuotaFromRateLimits(result) {
   return { status: "ok", planType, windows };
 }
 function queryCodexRateLimits(codexHome = defaultCodexHome(), codexBin = "codex", timeoutMs = 12e3) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     let child;
     try {
       child = spawn4(codexBin, ["app-server"], {
@@ -22755,7 +22884,7 @@ function queryCodexRateLimits(codexHome = defaultCodexHome(), codexBin = "codex"
         env: { ...process.env, CODEX_HOME: codexHome }
       });
     } catch {
-      resolve9(void 0);
+      resolve10(void 0);
       return;
     }
     let settled = false;
@@ -22767,7 +22896,7 @@ function queryCodexRateLimits(codexHome = defaultCodexHome(), codexBin = "codex"
         child.kill("SIGKILL");
       } catch {
       }
-      resolve9(quota);
+      resolve10(quota);
     };
     const timer = setTimeout(() => finish(void 0), timeoutMs);
     const send = (msg) => {
@@ -22842,15 +22971,15 @@ var init_codex_quota = __esm({
 });
 
 // packages/server/src/backend/claude-quota.ts
-import { join as join18 } from "node:path";
-import { homedir as homedir8, platform } from "node:os";
-import { createHash as createHash8 } from "node:crypto";
+import { join as join19 } from "node:path";
+import { homedir as homedir9, platform } from "node:os";
+import { createHash as createHash9 } from "node:crypto";
 import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 function claudeConfigDir() {
   const override = process.env.CLAUDE_CONFIG_DIR;
-  return override && override.trim() ? override : join18(homedir8(), ".claude");
+  return override && override.trim() ? override : join19(homedir9(), ".claude");
 }
 function tokenFromCredentialsJson(raw2) {
   let doc;
@@ -22879,7 +23008,7 @@ async function readKeychainToken() {
 }
 async function readAccessToken(configDir) {
   try {
-    const fromFile = tokenFromCredentialsJson(await readFile(join18(configDir, ".credentials.json"), "utf8"));
+    const fromFile = tokenFromCredentialsJson(await readFile(join19(configDir, ".credentials.json"), "utf8"));
     if (fromFile) return fromFile;
   } catch {
   }
@@ -22946,10 +23075,10 @@ function parseClaudeUsage(body, planType) {
   return { status: "ok", planType, windows };
 }
 function cachePaths(cacheDir, configDir) {
-  const profile = createHash8("sha256").update(configDir).digest("hex").slice(0, 12);
+  const profile = createHash9("sha256").update(configDir).digest("hex").slice(0, 12);
   return {
-    data: join18(cacheDir, `claude-${profile}.json`),
-    lock: join18(cacheDir, `claude-${profile}.lock`)
+    data: join19(cacheDir, `claude-${profile}.json`),
+    lock: join19(cacheDir, `claude-${profile}.lock`)
   };
 }
 async function readShared(path) {
@@ -22972,7 +23101,7 @@ async function writeShared(path, value) {
   }
 }
 function delay(ms) {
-  return new Promise((resolve9) => setTimeout(resolve9, ms));
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
 }
 async function acquireLock(path) {
   const deadline = Date.now() + LOCK_WAIT_MS;
@@ -23141,7 +23270,7 @@ function refreshSharedInBackground(paths, claudeBin, deps, now) {
 async function refreshClaudeQuotaInBackground(claudeBin = "claude", deps = {}) {
   const now = (deps.now ?? Date.now)();
   const configDir = claudeConfigDir();
-  const cacheDir = deps.cacheDir ?? join18(frizzRoots().cache, "quota-cache");
+  const cacheDir = deps.cacheDir ?? join19(frizzRoots().cache, "quota-cache");
   try {
     await mkdir(cacheDir, { recursive: true, mode: 448 });
   } catch {
@@ -23152,7 +23281,7 @@ async function refreshClaudeQuotaInBackground(claudeBin = "claude", deps = {}) {
 async function readClaudeQuota(claudeBin = "claude", deps = {}, options = {}) {
   const now = (deps.now ?? Date.now)();
   const configDir = claudeConfigDir();
-  const cacheDir = deps.cacheDir ?? join18(frizzRoots().cache, "quota-cache");
+  const cacheDir = deps.cacheDir ?? join19(frizzRoots().cache, "quota-cache");
   const paths = cachePaths(cacheDir, configDir);
   try {
     await mkdir(cacheDir, { recursive: true, mode: 448 });
@@ -23311,20 +23440,20 @@ var init_quota = __esm({
 // packages/server/src/frizz.ts
 import { execFile as execFile2 } from "node:child_process";
 import { lstatSync as lstatSync3, realpathSync as realpathSync4 } from "node:fs";
-import { basename as basename3, dirname as dirname4, join as join19, resolve as resolve4 } from "node:path";
+import { basename as basename3, dirname as dirname5, join as join20, resolve as resolve5 } from "node:path";
 import { promisify as promisify2 } from "node:util";
 function frizzScriptsDir() {
   if (process.env.FRIZZ_SCRIPTS_DIR) return process.env.FRIZZ_SCRIPTS_DIR;
-  return resolve4(import.meta.dirname, "..", "..", "..", "board");
+  return resolve5(import.meta.dirname, "..", "..", "..", "board");
 }
 function directFrizzRoot(projectDir) {
   try {
     const projectRoot = realpathSync4(projectDir);
-    const path = join19(projectRoot, ".frizz");
+    const path = join20(projectRoot, ".frizz");
     const stat2 = lstatSync3(path);
     if (!stat2.isDirectory() || stat2.isSymbolicLink()) return null;
     const real = realpathSync4(path);
-    return dirname4(real) === projectRoot && basename3(real) === ".frizz" ? real : null;
+    return dirname5(real) === projectRoot && basename3(real) === ".frizz" ? real : null;
   } catch {
     return null;
   }
@@ -23334,7 +23463,7 @@ function frizzDirExists(projectDir) {
 }
 async function readBoard(projectDir, scriptsDir = frizzScriptsDir()) {
   if (!directFrizzRoot(projectDir)) throw new Error("unsafe or missing .frizz directory");
-  const { stdout } = await execFileP("node", [join19(scriptsDir, "index.mjs"), "--json"], {
+  const { stdout } = await execFileP("node", [join20(scriptsDir, "index.mjs"), "--json"], {
     cwd: projectDir,
     env: { ...process.env, CLAUDE_PROJECT_DIR: projectDir },
     maxBuffer: 32 * 1024 * 1024
@@ -23359,7 +23488,7 @@ async function readBoard(projectDir, scriptsDir = frizzScriptsDir()) {
   };
 }
 async function runThreadUpdate(projectDir, slug, args, scriptsDir = frizzScriptsDir()) {
-  await execFileP("node", [join19(scriptsDir, "thread-update.mjs"), slug, ...args], {
+  await execFileP("node", [join20(scriptsDir, "thread-update.mjs"), slug, ...args], {
     cwd: projectDir,
     env: { ...process.env, CLAUDE_PROJECT_DIR: projectDir }
   });
@@ -24202,7 +24331,7 @@ function connectClaudeBroker(socketPath, handlers, options = {}) {
     sendInput: (message) => send({ t: "input", message }),
     answerPermission: (requestId, decision2) => send({ t: "permission", requestId, decision: decision2 }),
     interrupt: () => send({ t: "interrupt" }),
-    cancelInput: (id) => new Promise((resolve9, reject) => {
+    cancelInput: (id) => new Promise((resolve10, reject) => {
       if (closed) {
         reject(new Error("the broker connection is closed"));
         return;
@@ -24213,10 +24342,10 @@ function connectClaudeBroker(socketPath, handlers, options = {}) {
         reject(new Error("the Claude session did not answer the unqueue request"));
       }, cancelTimeoutMs);
       if (timer.unref) timer.unref();
-      pendingCancels.set(requestId, { settle: resolve9, fail: reject, timer });
+      pendingCancels.set(requestId, { settle: resolve10, fail: reject, timer });
       send({ t: "cancel-input", requestId, id });
     }),
-    stopTask: (taskId) => new Promise((resolve9, reject) => {
+    stopTask: (taskId) => new Promise((resolve10, reject) => {
       if (closed) {
         reject(new Error("the broker connection is closed"));
         return;
@@ -24227,12 +24356,12 @@ function connectClaudeBroker(socketPath, handlers, options = {}) {
         reject(new Error("the Claude session did not answer the stop request"));
       }, cancelTimeoutMs);
       if (timer.unref) timer.unref();
-      pendingStops.set(requestId, { settle: resolve9, fail: reject, timer });
+      pendingStops.set(requestId, { settle: resolve10, fail: reject, timer });
       send({ t: "stop-task", requestId, taskId });
     }),
     // A reload re-scans the plugin closure and can re-handshake MCP servers, so it gets a longer
     // deadline than an unqueue/stop — those are answered by bookkeeping the CLI already holds.
-    reloadPlugins: () => new Promise((resolve9, reject) => {
+    reloadPlugins: () => new Promise((resolve10, reject) => {
       if (closed) {
         reject(new Error("the broker connection is closed"));
         return;
@@ -24243,11 +24372,11 @@ function connectClaudeBroker(socketPath, handlers, options = {}) {
         reject(new Error("the Claude session did not answer the plugin reload"));
       }, reloadTimeoutMs);
       if (timer.unref) timer.unref();
-      pendingReloads.set(requestId, { settle: resolve9, fail: reject, timer });
+      pendingReloads.set(requestId, { settle: resolve10, fail: reject, timer });
       send({ t: "reload-plugins", requestId });
     }),
     // Shares the reload deadline: a re-title is a provider round trip, not local bookkeeping.
-    renameSession: (description) => new Promise((resolve9, reject) => {
+    renameSession: (description) => new Promise((resolve10, reject) => {
       if (closed) {
         reject(new Error("the broker connection is closed"));
         return;
@@ -24258,7 +24387,7 @@ function connectClaudeBroker(socketPath, handlers, options = {}) {
         reject(new Error("the Claude session did not answer the rename request"));
       }, reloadTimeoutMs);
       if (timer.unref) timer.unref();
-      pendingRenames.set(requestId, { settle: resolve9, fail: reject, timer });
+      pendingRenames.set(requestId, { settle: resolve10, fail: reject, timer });
       send({ t: "rename", requestId, description });
     }),
     setPermissionMode: (mode) => send({ t: "set-mode", mode }),
@@ -24449,12 +24578,12 @@ var init_claude_agent_sdk_protocol = __esm({
 });
 
 // packages/server/src/backend/claude-permission-interactions.ts
-import { homedir as homedir9 } from "node:os";
+import { homedir as homedir10 } from "node:os";
 function clip(text, max) {
   return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
 }
 function tildePath(path) {
-  const home = homedir9();
+  const home = homedir10();
   if (!path.startsWith(home)) return path;
   const rest = path.slice(home.length);
   return rest === "" ? "~" : rest.startsWith("/") ? `~${rest}` : path;
@@ -25060,19 +25189,19 @@ var init_claude_agent_broker_bridge = __esm({
 });
 
 // packages/server/src/backend/auth-status.ts
-import { join as join20 } from "node:path";
-import { homedir as homedir10, platform as platform2 } from "node:os";
-import { readFileSync as readFileSync11, statSync as statSync11 } from "node:fs";
+import { join as join21 } from "node:path";
+import { homedir as homedir11, platform as platform2 } from "node:os";
+import { readFileSync as readFileSync12, statSync as statSync11 } from "node:fs";
 import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
 function claudeConfigDir2() {
   const override = process.env.CLAUDE_CONFIG_DIR;
-  return override && override.trim() ? override : join20(homedir10(), ".claude");
+  return override && override.trim() ? override : join21(homedir11(), ".claude");
 }
 function claudeFileState(configDir) {
   let raw2;
   try {
-    raw2 = readFileSync11(join20(configDir, ".credentials.json"), "utf8");
+    raw2 = readFileSync12(join21(configDir, ".credentials.json"), "utf8");
   } catch (err) {
     return err.code === "ENOENT" ? "absent" : "error";
   }
@@ -25105,7 +25234,7 @@ function readCodexAuthState(codexHome = defaultCodexHome()) {
   if (process.env.OPENAI_API_KEY || process.env.CODEX_API_KEY || process.env.CODEX_ACCESS_TOKEN) return "authed";
   let raw2;
   try {
-    raw2 = readFileSync11(join20(codexHome, "auth.json"), "utf8");
+    raw2 = readFileSync12(join21(codexHome, "auth.json"), "utf8");
   } catch (err) {
     return err.code === "ENOENT" ? "signed-out" : "unknown";
   }
@@ -25170,7 +25299,7 @@ function asEmail(value) {
 }
 function claudeAccountFile() {
   const override = process.env.CLAUDE_CONFIG_DIR;
-  return override && override.trim() ? join20(override, ".claude.json") : join20(homedir10(), ".claude.json");
+  return override && override.trim() ? join21(override, ".claude.json") : join21(homedir11(), ".claude.json");
 }
 function readClaudeAccountEmail(path = claudeAccountFile()) {
   let stat2;
@@ -25183,7 +25312,7 @@ function readClaudeAccountEmail(path = claudeAccountFile()) {
   if (memo3 && memo3.path === path && memo3.mtimeMs === stat2.mtimeMs && memo3.size === stat2.size) return memo3.email;
   let email;
   try {
-    const doc = JSON.parse(readFileSync11(path, "utf8"));
+    const doc = JSON.parse(readFileSync12(path, "utf8"));
     email = asEmail(doc?.oauthAccount?.emailAddress);
   } catch {
     email = void 0;
@@ -25194,7 +25323,7 @@ function readClaudeAccountEmail(path = claudeAccountFile()) {
 function readCodexAccountEmail(codexHome = defaultCodexHome()) {
   let doc;
   try {
-    doc = JSON.parse(readFileSync11(join20(codexHome, "auth.json"), "utf8"));
+    doc = JSON.parse(readFileSync12(join21(codexHome, "auth.json"), "utf8"));
   } catch {
     return void 0;
   }
@@ -25261,10 +25390,10 @@ var init_auth_status = __esm({
 });
 
 // packages/server/src/dispatch.ts
-import { closeSync as closeSync8, constants, existsSync as existsSync7, fstatSync as fstatSync2, lstatSync as lstatSync4, openSync as openSync9, readFileSync as readFileSync12, realpathSync as realpathSync5, statSync as statSync12, writeFileSync as writeFileSync6, renameSync as renameSync5, mkdirSync as mkdirSync10, rmSync as rmSync5 } from "node:fs";
-import { basename as basename4, join as join21, dirname as dirname5 } from "node:path";
+import { closeSync as closeSync9, constants, existsSync as existsSync8, fstatSync as fstatSync2, lstatSync as lstatSync4, openSync as openSync10, readFileSync as readFileSync13, realpathSync as realpathSync5, statSync as statSync12, writeFileSync as writeFileSync7, renameSync as renameSync6, mkdirSync as mkdirSync11, rmSync as rmSync6 } from "node:fs";
+import { basename as basename4, join as join22, dirname as dirname6 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { createHash as createHash9, randomUUID as randomUUID12 } from "node:crypto";
+import { createHash as createHash10, randomUUID as randomUUID12 } from "node:crypto";
 function fallbackTitle(prompt) {
   const firstLine = prompt.trim().split("\n", 1)[0].trim();
   let allWords = firstLine.split(/\s+/).filter(Boolean);
@@ -25282,7 +25411,7 @@ function fallbackTitle(prompt) {
 }
 function resolveSlug(frizzDir, base, taken) {
   base = ThreadSlug.parse(base);
-  const isTaken = (slug) => existsSync7(join21(frizzDir, `${slug}.md`)) || (taken?.(slug) ?? false);
+  const isTaken = (slug) => existsSync8(join22(frizzDir, `${slug}.md`)) || (taken?.(slug) ?? false);
   if (!isTaken(base)) return base;
   for (let n = 2; ; n++) {
     const suffix = `-${n}`;
@@ -25299,26 +25428,26 @@ function resolveLegacyThreadFile(projectDir, value) {
   if (!parsed.success) return null;
   try {
     const projectRoot = realpathSync5(projectDir);
-    const frizzPath = join21(projectRoot, ".frizz");
+    const frizzPath = join22(projectRoot, ".frizz");
     const frizzStat = lstatSync4(frizzPath);
     if (!frizzStat.isDirectory() || frizzStat.isSymbolicLink()) return null;
     const realFrizz = realpathSync5(frizzPath);
-    if (dirname5(realFrizz) !== projectRoot || basename4(realFrizz) !== ".frizz") return null;
-    const path = join21(realFrizz, `${parsed.data}.md`);
+    if (dirname6(realFrizz) !== projectRoot || basename4(realFrizz) !== ".frizz") return null;
+    const path = join22(realFrizz, `${parsed.data}.md`);
     const before = lstatSync4(path);
     if (!before.isFile() || before.isSymbolicLink()) return null;
     const realPath = realpathSync5(path);
-    if (dirname5(realPath) !== realFrizz || basename4(realPath) !== `${parsed.data}.md`) return null;
+    if (dirname6(realPath) !== realFrizz || basename4(realPath) !== `${parsed.data}.md`) return null;
     let contents;
     let openedBefore;
     let openedAfter;
-    const fd = openSync9(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    const fd = openSync10(path, constants.O_RDONLY | constants.O_NOFOLLOW);
     try {
       openedBefore = fstatSync2(fd);
-      contents = readFileSync12(fd);
+      contents = readFileSync13(fd);
       openedAfter = fstatSync2(fd);
     } finally {
-      closeSync8(fd);
+      closeSync9(fd);
     }
     const after = lstatSync4(path);
     if (before.dev !== openedBefore.dev || before.ino !== openedBefore.ino || openedBefore.dev !== openedAfter.dev || openedBefore.ino !== openedAfter.ino || openedBefore.size !== openedAfter.size || openedBefore.mtimeMs !== openedAfter.mtimeMs || openedBefore.ctimeMs !== openedAfter.ctimeMs || after.dev !== openedAfter.dev || after.ino !== openedAfter.ino || after.size !== openedAfter.size || after.mtimeMs !== openedAfter.mtimeMs || after.ctimeMs !== openedAfter.ctimeMs || !openedAfter.isFile() || !after.isFile() || after.isSymbolicLink()) {
@@ -25333,7 +25462,7 @@ function resolveLegacyThreadFile(projectDir, value) {
       size: after.size,
       mtimeMs: after.mtimeMs,
       ctimeMs: after.ctimeMs,
-      digest: createHash9("sha256").update(contents).digest("hex")
+      digest: createHash10("sha256").update(contents).digest("hex")
     };
   } catch {
     return null;
@@ -25348,9 +25477,9 @@ function boardAuthorizesAdoption(board, slug) {
   return !board.errorItems.some((item) => item.file === `${slug}.md`);
 }
 function ensureSafeDirectDirectory(parent, name) {
-  const path = join21(parent, name);
+  const path = join22(parent, name);
   try {
-    mkdirSync10(path);
+    mkdirSync11(path);
   } catch (error) {
     const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
     if (code !== "EEXIST") throw error;
@@ -25358,7 +25487,7 @@ function ensureSafeDirectDirectory(parent, name) {
   const stat2 = lstatSync4(path);
   if (!stat2.isDirectory() || stat2.isSymbolicLink()) throw new Error("unsafe project directory");
   const real = realpathSync5(path);
-  if (dirname5(real) !== parent || basename4(real) !== name) throw new Error("unsafe project directory");
+  if (dirname6(real) !== parent || basename4(real) !== name) throw new Error("unsafe project directory");
   return real;
 }
 function scratchpadContent(title, kind = "claude") {
@@ -25421,14 +25550,14 @@ function writeScratchpad(projectDir, sessionId, title, kind = "claude") {
   const threadsDir = ensureSafeDirectDirectory(frizzDir, "threads");
   const dir = ensureSafeDirectDirectory(threadsDir, sessionId);
   const rel = scratchpadRelPath(sessionId);
-  const path = join21(dir, "scratch.md");
-  const tmp = join21(dir, ".scratch.tmp");
+  const path = join22(dir, "scratch.md");
+  const tmp = join22(dir, ".scratch.tmp");
   try {
-    writeFileSync6(tmp, scratchpadContent(title, kind), { flag: "wx", mode: 384 });
-    if (existsSync7(path)) throw new Error("scratchpad already exists");
-    renameSync5(tmp, path);
+    writeFileSync7(tmp, scratchpadContent(title, kind), { flag: "wx", mode: 384 });
+    if (existsSync8(path)) throw new Error("scratchpad already exists");
+    renameSync6(tmp, path);
   } catch (error) {
-    rmSync5(tmp, { force: true });
+    rmSync6(tmp, { force: true });
     throw error;
   }
   return rel;
@@ -25446,8 +25575,8 @@ function codexScratchpadHookConfig(hookScript, sessionId) {
       }
     ]
   });
-  const bashBackgroundHook = join21(dirname5(hookScript), "bash-background.mjs");
-  const scratchpadStopHook = join21(dirname5(hookScript), "scratchpad-stop.mjs");
+  const bashBackgroundHook = join22(dirname6(hookScript), "bash-background.mjs");
+  const scratchpadStopHook = join22(dirname6(hookScript), "scratchpad-stop.mjs");
   return {
     bypass_hook_trust: true,
     hooks: {
@@ -25480,7 +25609,7 @@ function codexScratchpadHookConfig(hookScript, sessionId) {
 }
 function scratchpadHookScript() {
   const plugin = workerPluginDir();
-  return plugin ? join21(plugin, "hooks", "scratchpad.mjs") : void 0;
+  return plugin ? join22(plugin, "hooks", "scratchpad.mjs") : void 0;
 }
 function composePrompt(sessionId, prompt, kind = "claude") {
   const scratch = kind === "codex" ? `Your scratchpad is \`.frizz/threads/${sessionId}/scratch.md\` \u2014 an OPTIONAL scratch file kept for you, not a deliverable. A single direct task usually needs nothing in it, and writing in it never substitutes for doing the work. On a long effort it is useful crash insurance and a shared progress document for native sub-agents: keep the approach, what you rejected, and the human's decisions in it as you go, mid-work, then keep working; re-read it after any compaction or resume before asserting anything. Each native sub-agent should merge its own scoped progress into it rather than leaving the root as its sole writer, but must re-read before each edit, preserve all existing content, and never delete, truncate, reinitialize, move, or replace the whole file.` : `Your scratchpad is \`.frizz/threads/${sessionId}/scratch.md\` \u2014 an OPTIONAL scratch file kept for you, not a deliverable. A single direct task usually needs nothing in it, and writing in it never substitutes for doing the work. On a long effort it is useful crash insurance and the shared blackboard for your sub-agents: keep the approach, what you rejected, and the human's decisions in it as you go, mid-work, then keep working; re-read it after any compaction or resume, and pass its path to every sub-agent you dispatch. Each sub-agent should merge its own scoped progress into it rather than leaving the root as its sole writer, but must re-read before each edit, preserve all existing content, and never delete, truncate, reinitialize, move, or replace the whole file.`;
@@ -25497,12 +25626,12 @@ function scratchpadOrientation(sessionId, planPath, kind = "claude") {
   return lines.join("\n");
 }
 function frizzConfigBlock(projectDir) {
-  const path = join21(projectDir, "FRIZZ.md");
+  const path = join22(projectDir, "FRIZZ.md");
   let body;
   try {
     const st = statSync12(path);
     if (!st.isFile() || st.size > FRIZZ_MD_MAX_BYTES) return "";
-    body = readFileSync12(path, "utf8").trim();
+    body = readFileSync13(path, "utf8").trim();
   } catch {
     return "";
   }
@@ -25516,7 +25645,7 @@ ${clipped}`;
 }
 function validPlanPath(projectDir, planPath) {
   if (!planPath || !PLAN_PATH_RE.test(planPath)) return null;
-  return existsSync7(join21(projectDir, planPath)) ? planPath : null;
+  return existsSync8(join22(projectDir, planPath)) ? planPath : null;
 }
 function workerPermissionMode(m) {
   return m === "plan" ? "auto" : m;
@@ -25532,16 +25661,16 @@ function effectivePermissionMode(kind, mode) {
 }
 function systemPromptFlags(sessionId, system) {
   if (!system) return [];
-  mkdirSync10(SYSTEM_PROMPT_DIR, { recursive: true });
+  mkdirSync11(SYSTEM_PROMPT_DIR, { recursive: true });
   const path = systemPromptPath(sessionId);
-  writeFileSync6(path, system);
+  writeFileSync7(path, system);
   return ["--append-system-prompt-file", path];
 }
 function resolveFrizzMcp(stateDir, moduleUrl = import.meta.url, env = process.env, slug) {
   const pluginDir = resolveWorkerPluginDir(moduleUrl, env);
   if (!pluginDir) return void 0;
-  const scriptPath = join21(pluginDir, "bin", FRIZZ_MCP.script);
-  if (!existsSync7(scriptPath)) return void 0;
+  const scriptPath = join22(pluginDir, "bin", FRIZZ_MCP.script);
+  if (!existsSync8(scriptPath)) return void 0;
   return { scriptPath, stateDir, ...slug ? { slug } : {} };
 }
 function claudeMcpConfig(mcp) {
@@ -25582,13 +25711,13 @@ function buildClaudeCommand(opts) {
 }
 function resolveWorkerPluginDir(moduleUrl = import.meta.url, env = process.env) {
   const override = env.FRIZZ_WORKER_PLUGIN_DIR;
-  if (override && existsSync7(join21(override, ".claude-plugin", "plugin.json")))
+  if (override && existsSync8(join22(override, ".claude-plugin", "plugin.json")))
     return override;
-  let current = dirname5(fileURLToPath2(moduleUrl));
+  let current = dirname6(fileURLToPath2(moduleUrl));
   for (; ; ) {
-    const candidate = join21(current, "cc-worker");
-    if (existsSync7(join21(candidate, ".claude-plugin", "plugin.json"))) return candidate;
-    const parent = dirname5(current);
+    const candidate = join22(current, "cc-worker");
+    if (existsSync8(join22(candidate, ".claude-plugin", "plugin.json"))) return candidate;
+    const parent = dirname6(current);
     if (parent === current) return void 0;
     current = parent;
   }
@@ -25629,12 +25758,12 @@ function buildClaudeResumeCommand(opts) {
 }
 function createDispatcher(deps) {
   const readBoardSource = deps.readBoard ?? readBoard;
-  const frizzDir = join21(deps.project.dir, ".frizz");
+  const frizzDir = join22(deps.project.dir, ".frizz");
   const adoptionRuntime = deps.adoptionRuntime ?? productionRuntime;
   function cleanupPrewrites(built) {
     for (const path of new Set(built.prewrite.map((file) => file.path))) {
       try {
-        rmSync5(path, { force: true });
+        rmSync6(path, { force: true });
       } catch {
       }
     }
@@ -25642,7 +25771,7 @@ function createDispatcher(deps) {
   function cleanupDispatchFiles(scratchRel, built, sessionId) {
     cleanupPrewrites(built);
     try {
-      rmSync5(join21(deps.project.dir, scratchRel), { force: true });
+      rmSync6(join22(deps.project.dir, scratchRel), { force: true });
     } catch {
     }
     cleanupAdoptionSessionFiles(deps.project.dir, sessionId);
@@ -26013,28 +26142,28 @@ var init_dispatch = __esm({
 
 // packages/server/src/plan-files.ts
 import {
-  closeSync as closeSync9,
+  closeSync as closeSync10,
   constants as constants2,
   fstatSync as fstatSync3,
   lstatSync as lstatSync5,
-  openSync as openSync10,
-  readFileSync as readFileSync13,
+  openSync as openSync11,
+  readFileSync as readFileSync14,
   readdirSync as readdirSync8,
   realpathSync as realpathSync6,
   unlinkSync as unlinkSync4
 } from "node:fs";
-import { createHash as createHash10 } from "node:crypto";
-import { basename as basename5, dirname as dirname6, join as join22 } from "node:path";
+import { createHash as createHash11 } from "node:crypto";
+import { basename as basename5, dirname as dirname7, join as join23 } from "node:path";
 function sameStat(a, b) {
   return a.dev === b.dev && a.ino === b.ino && a.mode === b.mode && a.size === b.size && a.mtimeMs === b.mtimeMs && a.ctimeMs === b.ctimeMs;
 }
 function directDirectory(parentRealPath, name) {
   try {
-    const path = join22(parentRealPath, name);
+    const path = join23(parentRealPath, name);
     const stat2 = lstatSync5(path);
     if (!stat2.isDirectory() || stat2.isSymbolicLink()) return null;
     const realPath = realpathSync6(path);
-    if (dirname6(realPath) !== parentRealPath || basename5(realPath) !== name) return null;
+    if (dirname7(realPath) !== parentRealPath || basename5(realPath) !== name) return null;
     return { path, realPath, stat: stat2 };
   } catch {
     return null;
@@ -26068,22 +26197,22 @@ function resolvePlanFile(projectDir, value, hooks = {}) {
     const directoryBefore = planDirectory(projectDir);
     if (!directoryBefore) return null;
     hooks.afterDirectoryCheck?.();
-    const path = join22(directoryBefore.plans.realPath, filename);
+    const path = join23(directoryBefore.plans.realPath, filename);
     const before = lstatSync5(path);
     if (!before.isFile() || before.isSymbolicLink()) return null;
     const realPath = realpathSync6(path);
-    if (dirname6(realPath) !== directoryBefore.plans.realPath || basename5(realPath) !== filename) return null;
+    if (dirname7(realPath) !== directoryBefore.plans.realPath || basename5(realPath) !== filename) return null;
     hooks.afterFileCheck?.();
     let contents;
     let openedBefore;
     let openedAfter;
-    const fd = openSync10(path, constants2.O_RDONLY | constants2.O_NOFOLLOW);
+    const fd = openSync11(path, constants2.O_RDONLY | constants2.O_NOFOLLOW);
     try {
       openedBefore = fstatSync3(fd);
-      contents = readFileSync13(fd);
+      contents = readFileSync14(fd);
       openedAfter = fstatSync3(fd);
     } finally {
-      closeSync9(fd);
+      closeSync10(fd);
     }
     const after = lstatSync5(path);
     const realPathAfter = realpathSync6(path);
@@ -26100,7 +26229,7 @@ function resolvePlanFile(projectDir, value, hooks = {}) {
       size: after.size,
       mtimeMs: after.mtimeMs,
       ctimeMs: after.ctimeMs,
-      digest: createHash10("sha256").update(contents).digest("hex")
+      digest: createHash11("sha256").update(contents).digest("hex")
     };
   } catch {
     return null;
@@ -26144,10 +26273,10 @@ var init_plan_files = __esm({
 
 // packages/server/src/board.ts
 import {
-  existsSync as existsSync8,
+  existsSync as existsSync9,
   watch as fsWatch
 } from "node:fs";
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 import watcher from "@parcel/watcher";
 function appServerTurnStalled(liveness, lastActivityAt, nowMs) {
   if (!liveness) return false;
@@ -26253,7 +26382,7 @@ function deriveAwaitingBackground(row, tele, runtime, hasActionableInteraction =
 }
 function scratchpadPathIfExists(projectDir, sessionId) {
   const rel = scratchpadRelPath(sessionId);
-  return existsSync8(join23(projectDir, rel)) ? rel : void 0;
+  return existsSync9(join24(projectDir, rel)) ? rel : void 0;
 }
 function resolveSessionProfile(row, tele) {
   const persistedModel = row.model?.trim() || void 0;
@@ -26626,7 +26755,7 @@ function createBoard(project, storage, bus, tailer, bootId, deps = {}) {
     if (parcelSub || stopped) return Promise.resolve();
     if (watchSetup) return watchSetup;
     const setup = (async () => {
-      const next = await subscribe(join23(project.dir, ".frizz"), () => scheduleRebuild());
+      const next = await subscribe(join24(project.dir, ".frizz"), () => scheduleRebuild());
       if (stopped) {
         await next.unsubscribe();
         return;
@@ -27166,14 +27295,14 @@ function createGithubReviewFetcher(deps = {}) {
     pending = /* @__PURE__ */ new Map();
     if (batch.size === 0) return;
     if (now() < notBeforeMs) {
-      for (const entry of batch.values()) for (const resolve9 of entry.resolve) resolve9({ status: "deferred" });
+      for (const entry of batch.values()) for (const resolve10 of entry.resolve) resolve10({ status: "deferred" });
       return;
     }
     const entries = [...batch.values()];
     for (let offset = 0; offset < entries.length; offset += MAX_REFS_PER_REQUEST) {
       const chunk = entries.slice(offset, offset + MAX_REFS_PER_REQUEST);
       if (offset > 0 && now() < rateLimitBlockedUntilMs) {
-        for (const entry of chunk) for (const resolve9 of entry.resolve) resolve9({ status: "deferred" });
+        for (const entry of chunk) for (const resolve10 of entry.resolve) resolve10({ status: "deferred" });
         continue;
       }
       let results;
@@ -27193,15 +27322,15 @@ function createGithubReviewFetcher(deps = {}) {
           status: "error",
           failure: { kind: "shape", message: `No GitHub result for ${refKey(entry.ref)}` }
         };
-        for (const resolve9 of entry.resolve) resolve9(result);
+        for (const resolve10 of entry.resolve) resolve10(result);
       }
     }
   };
-  return (ref) => new Promise((resolve9) => {
+  return (ref) => new Promise((resolve10) => {
     const key = refKey(ref);
     const existing = pending.get(key);
-    if (existing) existing.resolve.push(resolve9);
-    else pending.set(key, { ref, resolve: [resolve9] });
+    if (existing) existing.resolve.push(resolve10);
+    else pending.set(key, { ref, resolve: [resolve10] });
     if (!flushScheduled) {
       flushScheduled = true;
       queueMicrotask(() => {
@@ -27226,7 +27355,7 @@ var init_github_review = __esm({
 // packages/server/src/scheduler.ts
 import { execFile as execFile5 } from "node:child_process";
 import { promisify as promisify5 } from "node:util";
-import { createHash as createHash11, randomUUID as randomUUID13 } from "node:crypto";
+import { createHash as createHash12, randomUUID as randomUUID13 } from "node:crypto";
 function parsePrRef(value) {
   const m = value.trim().match(PR_REF_RE);
   if (!m) return void 0;
@@ -27307,7 +27436,7 @@ function fenceIdentity(hints, fenceAt) {
   return `${fenceAt ?? ""}
${hintId}`;
 }
 function wakeDeliveryId(slug, sessionId, fenceId) {
-  return createHash11("sha256").update(slug).update("\0").update(sessionId).update("\0").update(fenceId).digest("hex");
+  return createHash12("sha256").update(slug).update("\0").update(sessionId).update("\0").update(fenceId).digest("hex");
 }
 function limitFenceId(fault) {
   return `${LIMIT_FENCE_PREFIX}${fault.at}`;
@@ -27326,7 +27455,7 @@ function isReportFenceId(fenceId) {
   return fenceId.startsWith(`${REPORT_FENCE_PREFIX}:`);
 }
 function snoozeFenceId(until, prompt) {
-  const digest = createHash11("sha256").update(prompt).digest("hex").slice(0, 16);
+  const digest = createHash12("sha256").update(prompt).digest("hex").slice(0, 16);
   return `${SNOOZE_FENCE_PREFIX}:${until}:${digest}`;
 }
 function isSnoozeFenceId(fenceId) {
@@ -28352,7 +28481,7 @@ var init_resume = __esm({
 });
 
 // packages/server/src/backend/claude.ts
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 function toolResultText2(content) {
   if (typeof content === "string") return content;
   if (!Array.isArray(content)) return "";
@@ -28441,7 +28570,7 @@ function createClaudeBackend(opts) {
       return { argv, env: claudeWorkerEnvironment(), prewrite: [] };
     },
     transcriptPath(sessionId) {
-      return join24(opts.logDir, `${sessionId}.jsonl`);
+      return join25(opts.logDir, `${sessionId}.jsonl`);
     },
     parseLine(line) {
       return parseClaudeLine(line);
@@ -28936,24 +29065,24 @@ CI: \`gh pr checks {n} -R {repo}\``;
 });
 
 // packages/server/src/backend/codex-app-server-diagnostics.ts
-import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync11, renameSync as renameSync6, statSync as statSync13 } from "node:fs";
-import { join as join25 } from "node:path";
+import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync12, renameSync as renameSync7, statSync as statSync13 } from "node:fs";
+import { join as join26 } from "node:path";
 function codexDiagnosticLogPath(stateDir, projectId) {
-  return join25(stateDir, "codex-app-server", `${projectId}.diagnostics.log`);
+  return join26(stateDir, "codex-app-server", `${projectId}.diagnostics.log`);
 }
 function createCodexDiagnosticSink(stateDir, projectId, now = () => /* @__PURE__ */ new Date()) {
-  const dir = join25(stateDir, "codex-app-server");
+  const dir = join26(stateDir, "codex-app-server");
   const path = codexDiagnosticLogPath(stateDir, projectId);
   let ensured = false;
   return (event) => {
     if (event.event === "stderr") return;
     try {
       if (!ensured) {
-        mkdirSync11(dir, { recursive: true });
+        mkdirSync12(dir, { recursive: true });
         ensured = true;
       }
       try {
-        if (statSync13(path).size > MAX_BYTES2) renameSync6(path, `${path}.1`);
+        if (statSync13(path).size > MAX_BYTES2) renameSync7(path, `${path}.1`);
       } catch {
       }
       appendFileSync3(path, `${JSON.stringify({ at: now().toISOString(), ...event })}
@@ -28974,13 +29103,13 @@ var init_codex_app_server_diagnostics = __esm({
 import { execFile as execFile7 } from "node:child_process";
 import { readdirSync as readdirSync9, unlinkSync as unlinkSync5 } from "node:fs";
 import { connect as connectSocket } from "node:net";
-import { join as join26 } from "node:path";
+import { join as join27 } from "node:path";
 function sweepStaleSockets(options, deps = {}) {
   if (process.platform === "win32") return;
   const keep = new Set(options.keep ?? []);
   let candidates;
   try {
-    candidates = (deps.readdir ?? readdirSync9)(options.dir).filter((name) => name.startsWith(options.prefix) && name.endsWith(".sock")).map((name) => join26(options.dir, name)).filter((path) => !keep.has(path));
+    candidates = (deps.readdir ?? readdirSync9)(options.dir).filter((name) => name.startsWith(options.prefix) && name.endsWith(".sock")).map((name) => join27(options.dir, name)).filter((path) => !keep.has(path));
   } catch {
     return;
   }
@@ -29032,7 +29161,7 @@ var init_stale_socket_sweep = __esm({
 
 // packages/server/src/orphan-reaper.ts
 import { execFileSync as execFileSync5 } from "node:child_process";
-import { dirname as dirname7 } from "node:path";
+import { dirname as dirname8 } from "node:path";
 function firstTokenBasename(command) {
   const first = command.trimStart().split(/\s+/, 1)[0] ?? "";
   const slash = first.lastIndexOf("/");
@@ -29243,7 +29372,7 @@ function sweepOrphansOnce(deps = {}) {
 }
 function sweepStaleBrokerSockets() {
   try {
-    sweepStaleSockets({ dir: dirname7(claudeBrokerSocketPath("", "")), prefix: CLAUDE_BROKER_SOCKET_PREFIX });
+    sweepStaleSockets({ dir: dirname8(claudeBrokerSocketPath("", "")), prefix: CLAUDE_BROKER_SOCKET_PREFIX });
   } catch {
   }
 }
@@ -29293,7 +29422,7 @@ var init_orphan_reaper = __esm({
 });
 
 // packages/server/src/context.ts
-import { join as join27 } from "node:path";
+import { join as join28 } from "node:path";
 import { randomUUID as randomUUID14 } from "node:crypto";
 function reconcileSessions(storage) {
   for (const row of storage.allSessions()) {
@@ -29428,7 +29557,7 @@ async function createContext(opts = {}) {
 }
 function createContextUnchecked(opts, resources) {
   const project = opts.project ?? resolveProject();
-  const dbPath = join27(project.stateDir, "ui.db");
+  const dbPath = join28(project.stateDir, "ui.db");
   const storage = createStorage(dbPath);
   resources.storage = storage;
   const bus = new Bus();
@@ -32418,8 +32547,8 @@ var init_server = __esm({
 });
 
 // packages/server/src/repair.ts
-import { existsSync as existsSync9, readFileSync as readFileSync14, writeFileSync as writeFileSync7 } from "node:fs";
-import { basename as basename6, dirname as dirname8, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync10, readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "node:fs";
+import { basename as basename6, dirname as dirname9, resolve as resolve7 } from "node:path";
 function quoteValue(v) {
   if (/^[\w./#:+-]+$/.test(v)) return v;
   return `"${v.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
@@ -32429,12 +32558,12 @@ function deriveTitle(body, slug) {
   return m ? m[1].trim() : slug;
 }
 function repairThreadFile(frizzDir, file) {
-  const root = resolve6(frizzDir);
-  const abs = resolve6(root, file);
-  if (dirname8(abs) !== root) throw new RepairError(`refusing to repair "${file}": not directly under .frizz/`);
+  const root = resolve7(frizzDir);
+  const abs = resolve7(root, file);
+  if (dirname9(abs) !== root) throw new RepairError(`refusing to repair "${file}": not directly under .frizz/`);
   if (!abs.endsWith(".md")) throw new RepairError(`refusing to repair "${file}": not a .md thread file`);
-  if (!existsSync9(abs)) throw new RepairError(`no thread file to repair: ${basename6(abs)}`);
-  const content = readFileSync14(abs, "utf8");
+  if (!existsSync10(abs)) throw new RepairError(`no thread file to repair: ${basename6(abs)}`);
+  const content = readFileSync15(abs, "utf8");
   const firstLine = content.replace(/^/, "").split(/\r?\n/).find((l) => l.trim() !== "");
   if (firstLine?.trim() === "---") {
     throw new RepairError(`${basename6(abs)} already opens with a "---" block \u2014 repair only heals a MISSING frontmatter block`);
@@ -32449,7 +32578,7 @@ function repairThreadFile(frizzDir, file) {
     "---",
     ""
   ].join("\n");
-  writeFileSync7(abs, frontmatter + content);
+  writeFileSync8(abs, frontmatter + content);
   return { slug };
 }
 var RepairError, REPAIR_STATUS_TEXT;
@@ -32467,7 +32596,7 @@ var init_repair = __esm({
 });
 
 // cc-worker/hooks/bash-background.mjs
-import { readFileSync as readFileSync15 } from "node:fs";
+import { readFileSync as readFileSync16 } from "node:fs";
 import { basename as basename7 } from "node:path";
 import { pathToFileURL } from "node:url";
 function emit(obj) {
@@ -32616,7 +32745,7 @@ var init_bash_background = __esm({
     if (isDirectHookExecution(process.argv[1], import.meta.url)) {
       try {
         const env = process.argv.includes("--frizz-thread") ? { ...process.env, FRIZZ_THREAD: process.env.FRIZZ_THREAD || "codex-worker" } : process.env;
-        emit(evaluateBashBackgroundHook(JSON.parse(readFileSync15(0, "utf8")), env));
+        emit(evaluateBashBackgroundHook(JSON.parse(readFileSync16(0, "utf8")), env));
       } catch {
         emit({});
       }
@@ -32625,11 +32754,11 @@ var init_bash_background = __esm({
 });
 
 // packages/server/src/transcript.ts
-import { closeSync as closeSync10, existsSync as existsSync10, fstatSync as fstatSync4, mkdirSync as mkdirSync12, openSync as openSync11, readdirSync as readdirSync10, readFileSync as readFileSync16, readSync as readSync6, renameSync as renameSync7, statSync as statSync14, unlinkSync as unlinkSync6, writeFileSync as writeFileSync8 } from "node:fs";
-import { createHash as createHash12 } from "node:crypto";
+import { closeSync as closeSync11, existsSync as existsSync11, fstatSync as fstatSync4, mkdirSync as mkdirSync13, openSync as openSync12, readdirSync as readdirSync10, readFileSync as readFileSync17, readSync as readSync6, renameSync as renameSync8, statSync as statSync14, unlinkSync as unlinkSync6, writeFileSync as writeFileSync9 } from "node:fs";
+import { createHash as createHash13 } from "node:crypto";
 import { StringDecoder as StringDecoder4 } from "node:string_decoder";
-import { join as join28 } from "node:path";
-import { homedir as homedir11, tmpdir as tmpdir4 } from "node:os";
+import { join as join29 } from "node:path";
+import { homedir as homedir12, tmpdir as tmpdir4 } from "node:os";
 function isInjectedNoise(text) {
   const t = text.trimStart();
   return NOISE_PREFIXES.some((p) => t.startsWith(p));
@@ -33121,14 +33250,14 @@ function pruneScreenshotCache() {
     if (entries.length <= SCREENSHOT_CACHE_MAX) return;
     const byMtime = entries.map((n) => {
       try {
-        return { n, m: statSync14(join28(SCREENSHOT_CACHE_DIR, n)).mtimeMs };
+        return { n, m: statSync14(join29(SCREENSHOT_CACHE_DIR, n)).mtimeMs };
       } catch {
         return { n, m: 0 };
       }
     }).sort((a, b) => b.m - a.m);
     for (const { n } of byMtime.slice(SCREENSHOT_CACHE_MAX)) {
       try {
-        unlinkSync6(join28(SCREENSHOT_CACHE_DIR, n));
+        unlinkSync6(join29(SCREENSHOT_CACHE_DIR, n));
       } catch {
       }
     }
@@ -33157,17 +33286,17 @@ function persistDataUrlImage(dataUrl, idKey) {
 function persistBase64Image(mediaType, data, idKey) {
   const ext = IMAGE_MEDIA_EXT[typeof mediaType === "string" ? mediaType.toLowerCase() : ""];
   if (!ext || !data) return void 0;
-  const name = createHash12("sha256").update(idKey).digest("hex").slice(0, 32);
-  const path = join28(SCREENSHOT_CACHE_DIR, `${name}.${ext}`);
+  const name = createHash13("sha256").update(idKey).digest("hex").slice(0, 32);
+  const path = join29(SCREENSHOT_CACHE_DIR, `${name}.${ext}`);
   try {
-    if (existsSync10(path)) return path;
+    if (existsSync11(path)) return path;
     if (data.length > SCREENSHOT_MAX_BASE64) return void 0;
     const buf = Buffer.from(data, "base64");
     if (buf.length === 0 || !looksLikeImage(buf, ext)) return void 0;
-    mkdirSync12(SCREENSHOT_CACHE_DIR, { recursive: true });
-    const tmp = join28(SCREENSHOT_CACHE_DIR, `.${name}.${process.pid}.${screenshotTmpSeq++}.tmp`);
-    writeFileSync8(tmp, buf);
-    renameSync7(tmp, path);
+    mkdirSync13(SCREENSHOT_CACHE_DIR, { recursive: true });
+    const tmp = join29(SCREENSHOT_CACHE_DIR, `.${name}.${process.pid}.${screenshotTmpSeq++}.tmp`);
+    writeFileSync9(tmp, buf);
+    renameSync8(tmp, path);
     pruneScreenshotCache();
     return path;
   } catch {
@@ -33179,17 +33308,17 @@ function persistSentFile(srcPath, idKey) {
   if (!ATTACHMENT_IMAGE_EXTENSIONS.includes(ext)) return void 0;
   const outExt = ext === "jpeg" ? "jpg" : ext;
   try {
-    const name = createHash12("sha256").update(idKey).digest("hex").slice(0, 32);
-    const dest = join28(SCREENSHOT_CACHE_DIR, `${name}.${outExt}`);
-    if (existsSync10(dest)) return dest;
+    const name = createHash13("sha256").update(idKey).digest("hex").slice(0, 32);
+    const dest = join29(SCREENSHOT_CACHE_DIR, `${name}.${outExt}`);
+    if (existsSync11(dest)) return dest;
     const size = statSync14(srcPath).size;
     if (size === 0 || size > SENT_IMAGE_MAX_BYTES) return void 0;
-    const buf = readFileSync16(srcPath);
+    const buf = readFileSync17(srcPath);
     if (!looksLikeImage(buf, outExt)) return void 0;
-    mkdirSync12(SCREENSHOT_CACHE_DIR, { recursive: true });
-    const tmp = join28(SCREENSHOT_CACHE_DIR, `.${name}.${process.pid}.${screenshotTmpSeq++}.tmp`);
-    writeFileSync8(tmp, buf);
-    renameSync7(tmp, dest);
+    mkdirSync13(SCREENSHOT_CACHE_DIR, { recursive: true });
+    const tmp = join29(SCREENSHOT_CACHE_DIR, `.${name}.${process.pid}.${screenshotTmpSeq++}.tmp`);
+    writeFileSync9(tmp, buf);
+    renameSync8(tmp, dest);
     pruneScreenshotCache();
     return dest;
   } catch {
@@ -33536,11 +33665,11 @@ function retainedFoldEntry(path, identityPrefix, fileId, size) {
   return { entry, hit };
 }
 function readTranscript(project, sessionId) {
-  const path = join28(homedir11(), ".claude", "projects", project.cwdSlug, `${sessionId}.jsonl`);
+  const path = join29(homedir12(), ".claude", "projects", project.cwdSlug, `${sessionId}.jsonl`);
   const identityPrefix = `claude:${sessionId}`;
   let fd;
   try {
-    fd = openSync11(path, "r");
+    fd = openSync12(path, "r");
     const st = fstatSync4(fd);
     const size = st.size;
     const fileId = `${st.dev}:${st.ino}:${Math.trunc(st.birthtimeMs)}`;
@@ -33559,12 +33688,12 @@ function readTranscript(project, sessionId) {
   } catch {
     return [];
   } finally {
-    if (fd !== void 0) closeSync10(fd);
+    if (fd !== void 0) closeSync11(fd);
   }
 }
 function verifyIncrementalParse(path, identityPrefix, incremental) {
   try {
-    const fresh = parseTranscript(readFileSync16(path, "utf8"), identityPrefix);
+    const fresh = parseTranscript(readFileSync17(path, "utf8"), identityPrefix);
     const a = JSON.stringify(incremental);
     const b = JSON.stringify(fresh);
     if (a !== b) {
@@ -33584,7 +33713,7 @@ function verifyIncrementalParse(path, identityPrefix, incremental) {
   }
 }
 function logDirOf(project) {
-  return join28(homedir11(), ".claude", "projects", project.cwdSlug);
+  return join29(homedir12(), ".claude", "projects", project.cwdSlug);
 }
 function projectCodexTranscript(raw2, identityPrefix = "codex") {
   const out = [];
@@ -33842,7 +33971,7 @@ function latestTranscriptWindow(messages) {
     );
     if (tools.length === 0) continue;
     pinned.push({
-      sourceId: `pinned-bg:${createHash12("sha256").update(message.sourceId).digest("base64url").slice(0, 24)}`,
+      sourceId: `pinned-bg:${createHash13("sha256").update(message.sourceId).digest("base64url").slice(0, 24)}`,
       pinnedFromSourceId: message.sourceId,
       role: "assistant",
       text: "",
@@ -34495,7 +34624,7 @@ function sourceForThread(project, storage, slug, backendFor) {
   if (row) {
     const backend = row.backend === "codex" ? "codex" : "claude";
     const nativeId = backend === "codex" ? row.agent_session_id ?? row.session_id : row.transcript_id ?? row.session_id;
-    const path = backend === "codex" ? (backendFor?.("codex") ?? defaultCodexBackend()).transcriptPath(nativeId) : join28(logDirOf(project), `${nativeId}.jsonl`);
+    const path = backend === "codex" ? (backendFor?.("codex") ?? defaultCodexBackend()).transcriptPath(nativeId) : join29(logDirOf(project), `${nativeId}.jsonl`);
     if (!path) return void 0;
     return {
       slug,
@@ -34513,7 +34642,7 @@ function sourceForThread(project, storage, slug, backendFor) {
     nativeId: slug,
     backend: "claude",
     runtimeGeneration: 0,
-    path: join28(logDirOf(project), `${slug}.jsonl`)
+    path: join29(logDirOf(project), `${slug}.jsonl`)
   };
 }
 function discoveredClaudeSource(project, storage, slug, expectedNativeId) {
@@ -34534,13 +34663,13 @@ function discoveredClaudeSource(project, storage, slug, expectedNativeId) {
     nativeId,
     backend: "claude",
     runtimeGeneration: row.runtime_generation ?? 0,
-    path: join28(logDirOf(project), `${nativeId}.jsonl`)
+    path: join29(logDirOf(project), `${nativeId}.jsonl`)
   };
 }
 function fixedSnapshot(source) {
   let fd;
   try {
-    fd = openSync11(source.path, "r");
+    fd = openSync12(source.path, "r");
     const before = fstatSync4(fd);
     if (!Number.isSafeInteger(before.size) || before.size < 0) throw new Error("transcript is too large to page safely");
     const bytes = Buffer.allocUnsafe(before.size);
@@ -34555,7 +34684,7 @@ function fixedSnapshot(source) {
       throw new Error("transcript changed while it was being read; retry");
     }
     const fileKey = `${before.dev}:${before.ino}:${Math.trunc(before.birthtimeMs)}`;
-    const transcriptKey = createHash12("sha256").update(`${source.slug}\0${source.sessionId}\0${source.nativeId}\0${source.backend}\0${source.runtimeGeneration}\0${fileKey}`).digest("base64url").slice(0, 32);
+    const transcriptKey = createHash13("sha256").update(`${source.slug}\0${source.sessionId}\0${source.nativeId}\0${source.backend}\0${source.runtimeGeneration}\0${fileKey}`).digest("base64url").slice(0, 32);
     let rawText;
     return {
       ...source,
@@ -34571,7 +34700,7 @@ function fixedSnapshot(source) {
     if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return void 0;
     throw error;
   } finally {
-    if (fd !== void 0) closeSync10(fd);
+    if (fd !== void 0) closeSync11(fd);
   }
 }
 function projectSnapshot(snapshot) {
@@ -34586,7 +34715,7 @@ function projectSnapshot(snapshot) {
   return retireStaleQueuedBubbles([...entry.fold.allMessages()]);
 }
 function digestPrefix(bytes, length = bytes.length) {
-  return createHash12("sha256").update(bytes.subarray(0, length)).digest("base64url");
+  return createHash13("sha256").update(bytes.subarray(0, length)).digest("base64url");
 }
 function fullDigest(snapshot) {
   const key = `${snapshot.fileKey}\0${snapshot.bytes.length}`;
@@ -34671,7 +34800,7 @@ function emptyTranscriptPage(source) {
     beforeCursor: null,
     hasEarlier: false,
     reachedTurnBoundary: true,
-    transcriptKey: createHash12("sha256").update(keySeed).digest("base64url").slice(0, 32)
+    transcriptKey: createHash13("sha256").update(keySeed).digest("base64url").slice(0, 32)
   };
 }
 function readLatestThreadTranscriptPage(project, storage, slug, backendFor) {
@@ -34738,7 +34867,7 @@ function readEarlierThreadTranscriptPage(project, storage, slug, cursor, backend
 }
 function readCodexTranscriptFile(absPath, nativeId = absPath) {
   try {
-    return parseCodexTranscript(readFileSync16(absPath, "utf8"), `codex:${nativeId}`);
+    return parseCodexTranscript(readFileSync17(absPath, "utf8"), `codex:${nativeId}`);
   } catch {
     return [];
   }
@@ -34815,8 +34944,8 @@ function projectTranscriptPageAgentLifecycles(page, lookup) {
 }
 function readTranscriptFile(absPath) {
   try {
-    const pathKey = createHash12("sha256").update(absPath).digest("base64url").slice(0, 16);
-    return parseTranscript(readFileSync16(absPath, "utf8"), `claude-file:${pathKey}`);
+    const pathKey = createHash13("sha256").update(absPath).digest("base64url").slice(0, 16);
+    return parseTranscript(readFileSync17(absPath, "utf8"), `claude-file:${pathKey}`);
   } catch {
     return [];
   }
@@ -34858,7 +34987,7 @@ var init_transcript = __esm({
       "image/gif": "gif",
       "image/webp": "webp"
     };
-    SCREENSHOT_CACHE_DIR = join28(tmpdir4(), "frizz-tool-images");
+    SCREENSHOT_CACHE_DIR = join29(tmpdir4(), "frizz-tool-images");
     SCREENSHOT_CACHE_MAX = 200;
     SCREENSHOT_MAX_BASE64 = 32e6;
     screenshotTmpSeq = 0;
@@ -34910,8 +35039,8 @@ var init_open_external = __esm({
 // packages/server/src/local-file.ts
 import { spawn as spawn6 } from "node:child_process";
 import { realpathSync as realpathSync7, statSync as statSync15 } from "node:fs";
-import { homedir as homedir12 } from "node:os";
-import { isAbsolute as isAbsolute3, join as join29, resolve as resolve7, sep } from "node:path";
+import { homedir as homedir13 } from "node:os";
+import { isAbsolute as isAbsolute3, join as join30, resolve as resolve8, sep } from "node:path";
 function isUnder(real, root) {
   let rootReal;
   try {
@@ -34938,10 +35067,10 @@ function resolveLocalFile(rawPath, roots) {
   }
   return real;
 }
-function resolveOpenableFile(raw2, projectDir, roots, home = homedir12()) {
+function resolveOpenableFile(raw2, projectDir, roots, home = homedir13()) {
   const trimmed = raw2.trim().replace(/:\d+(?::\d+)?$/, "");
   if (!trimmed) return null;
-  const abs = trimmed === "~" ? home : trimmed.startsWith("~/") ? join29(home, trimmed.slice(2)) : isAbsolute3(trimmed) ? trimmed : resolve7(projectDir, trimmed);
+  const abs = trimmed === "~" ? home : trimmed.startsWith("~/") ? join30(home, trimmed.slice(2)) : isAbsolute3(trimmed) ? trimmed : resolve8(projectDir, trimmed);
   try {
     return resolveLocalFile(abs, roots);
   } catch {
@@ -35007,7 +35136,7 @@ var init_account_actions = __esm({
 });
 
 // packages/server/src/awaiting.ts
-import { createHash as createHash13 } from "node:crypto";
+import { createHash as createHash14 } from "node:crypto";
 function parsePrRef2(value) {
   const m = value.trim().match(PR_REF_RE2);
   if (!m) return void 0;
@@ -35022,7 +35151,7 @@ function isActionableAwaitingHint(hint) {
   return false;
 }
 function awaitingFenceIdentity(hint, fenceAt) {
-  return createHash13("sha256").update(fenceAt).update("\0").update(hint.kind).update("\0").update(hint.value).digest("hex");
+  return createHash14("sha256").update(fenceAt).update("\0").update(hint.kind).update("\0").update(hint.value).digest("hex");
 }
 var PR_REF_RE2;
 var init_awaiting = __esm({
@@ -35109,11 +35238,11 @@ var init_external_terminal = __esm({
 });
 
 // packages/server/src/background-shell-output.ts
-import { closeSync as closeSync11, fstatSync as fstatSync5, openSync as openSync12, readSync as readSync7 } from "node:fs";
+import { closeSync as closeSync12, fstatSync as fstatSync5, openSync as openSync13, readSync as readSync7 } from "node:fs";
 function readBackgroundShellOutput(path, maxBytes = OUTPUT_TAIL_BYTES) {
   let fd;
   try {
-    fd = openSync12(path, "r");
+    fd = openSync13(path, "r");
     const size = fstatSync5(fd).size;
     const length = Math.min(size, maxBytes);
     const offset = Math.max(0, size - length);
@@ -35129,13 +35258,13 @@ function readBackgroundShellOutput(path, maxBytes = OUTPUT_TAIL_BYTES) {
   } catch {
     return { output: "", truncated: false };
   } finally {
-    if (fd !== void 0) closeSync11(fd);
+    if (fd !== void 0) closeSync12(fd);
   }
 }
 function backgroundShellLineCount(path) {
   let fd;
   try {
-    fd = openSync12(path, "r");
+    fd = openSync13(path, "r");
     const stat2 = fstatSync5(fd);
     const size = stat2.size;
     let state = scans.get(path);
@@ -35174,7 +35303,7 @@ function backgroundShellLineCount(path) {
   } catch {
     return void 0;
   } finally {
-    if (fd !== void 0) closeSync11(fd);
+    if (fd !== void 0) closeSync12(fd);
   }
 }
 var OUTPUT_TAIL_BYTES, SCAN_CHUNK_BYTES, SCAN_CEILING_BYTES, SCAN_CACHE_LIMIT, ANSI_ESCAPE_RE, scans;
@@ -35191,8 +35320,8 @@ var init_background_shell_output = __esm({
 });
 
 // packages/server/src/router.ts
-import { readFileSync as readFileSync17 } from "node:fs";
-import { join as join30 } from "node:path";
+import { readFileSync as readFileSync18 } from "node:fs";
+import { join as join31 } from "node:path";
 import { randomUUID as randomUUID15 } from "node:crypto";
 function validateGithubDispatchProfile(input) {
   validateThreadProfile(input.backend, input.model, input.effort);
@@ -35328,7 +35457,7 @@ async function stopAndForgetRegisteredRuntime(storage, row, runtime = cachedLive
   return forgotten;
 }
 function createRouter(ctx) {
-  const frizzDir = join30(ctx.project.dir, ".frizz");
+  const frizzDir = join31(ctx.project.dir, ".frizz");
   const openRoots = openableFileRoots(ctx.project);
   function isAutoTitledSession(slug) {
     return ctx.storage.getSession(slug)?.title_auto === 1;
@@ -36445,7 +36574,7 @@ function createRouter(ctx) {
         const row = ctx.storage.getSession(input.slug);
         if (!row) return { markdown: "" };
         try {
-          return { markdown: readFileSync17(join30(ctx.project.dir, scratchpadRelPath(row.session_id)), "utf8") };
+          return { markdown: readFileSync18(join31(ctx.project.dir, scratchpadRelPath(row.session_id)), "utf8") };
         } catch {
           return { markdown: "" };
         }
@@ -36980,7 +37109,7 @@ var init_local_origin = __esm({
 });
 
 // packages/server/src/local-image.ts
-import { readFileSync as readFileSync18, realpathSync as realpathSync8, statSync as statSync16 } from "node:fs";
+import { readFileSync as readFileSync19, realpathSync as realpathSync8, statSync as statSync16 } from "node:fs";
 import { extname, isAbsolute as isAbsolute4 } from "node:path";
 function resolveLocalImage(rawPath) {
   if (!rawPath || !isAbsolute4(rawPath)) return { status: 400 };
@@ -36994,7 +37123,7 @@ function resolveLocalImage(rawPath) {
   }
   try {
     if (!statSync16(real).isFile()) return { status: 404 };
-    return { status: 200, contentType, body: readFileSync18(real) };
+    return { status: 200, contentType, body: readFileSync19(real) };
   } catch {
     return { status: 404 };
   }
@@ -37014,8 +37143,8 @@ var init_local_image = __esm({
 });
 
 // packages/server/src/local-visualization.ts
-import { readdirSync as readdirSync11, readFileSync as readFileSync19, realpathSync as realpathSync9, statSync as statSync17 } from "node:fs";
-import { join as join31, sep as sep2 } from "node:path";
+import { readdirSync as readdirSync11, readFileSync as readFileSync20, realpathSync as realpathSync9, statSync as statSync17 } from "node:fs";
+import { join as join32, sep as sep2 } from "node:path";
 function children(path, pattern) {
   try {
     return readdirSync11(path, { withFileTypes: true }).filter((entry) => entry.isDirectory() && pattern.test(entry.name)).map((entry) => entry.name).sort().reverse();
@@ -37027,7 +37156,7 @@ function isUnder2(path, root) {
   return path === root || path.startsWith(root.endsWith(sep2) ? root : root + sep2);
 }
 function resolveFragment(projectDir, sessionId, file) {
-  const base = join31(projectDir, ".codex", "visualizations");
+  const base = join32(projectDir, ".codex", "visualizations");
   let projectReal;
   let baseReal;
   try {
@@ -37038,12 +37167,12 @@ function resolveFragment(projectDir, sessionId, file) {
   }
   if (!isUnder2(baseReal, projectReal)) return null;
   for (const year of children(base, YEAR_PART)) {
-    const yearDir = join31(base, year);
+    const yearDir = join32(base, year);
     for (const month of children(yearDir, DATE_PART)) {
-      const monthDir = join31(yearDir, month);
+      const monthDir = join32(yearDir, month);
       for (const day of children(monthDir, DATE_PART)) {
-        const sessionRoot = join31(baseReal, year, month, day, sessionId);
-        const candidate = join31(monthDir, day, sessionId, file);
+        const sessionRoot = join32(baseReal, year, month, day, sessionId);
+        const candidate = join32(monthDir, day, sessionId, file);
         try {
           const real = realpathSync9(candidate);
           if (isUnder2(real, sessionRoot) && statSync17(real).isFile()) return real;
@@ -37129,7 +37258,7 @@ function resolveLocalVisualization(projectDir, sessionId, file) {
   try {
     const size = statSync17(path).size;
     if (size > MAX_FRAGMENT_BYTES) return { status: 413 };
-    fragment = readFileSync19(path, "utf8");
+    fragment = readFileSync20(path, "utf8");
   } catch {
     return { status: 404 };
   }
@@ -37171,8 +37300,8 @@ var init_local_visualization = __esm({
 });
 
 // packages/server/src/app.ts
-import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join32 } from "node:path";
+import { mkdirSync as mkdirSync14, writeFileSync as writeFileSync10 } from "node:fs";
+import { join as join33 } from "node:path";
 import { randomUUID as randomUUID16 } from "node:crypto";
 function createApp(ctx, options = {}) {
   const app = new Hono2();
@@ -37249,11 +37378,11 @@ function createApp(ctx, options = {}) {
     if (typeof body.data !== "string" || body.data.length > ATTACHMENT_MAX_BASE64_CHARS) return c.json({ error: "bad payload" }, 400);
     const ext = `.${attachmentExtension(name)}`;
     const buf = Buffer.from(body.data, "base64");
-    const dir = join32(ctx.project.stateDir, "attachments");
-    mkdirSync13(dir, { recursive: true });
+    const dir = join33(ctx.project.stateDir, "attachments");
+    mkdirSync14(dir, { recursive: true });
     const base = name.replace(/\.[^.]+$/, "").replace(/[^a-zA-Z0-9_-]+/g, "-").slice(0, 40) || "file";
-    const path = join32(dir, `${Date.now()}-${randomUUID16().slice(0, 8)}-${base}${ext}`);
-    writeFileSync9(path, buf);
+    const path = join33(dir, `${Date.now()}-${randomUUID16().slice(0, 8)}-${base}${ext}`);
+    writeFileSync10(path, buf);
     return c.json({ path });
   });
   app.get(
@@ -37280,10 +37409,10 @@ function createApp(ctx, options = {}) {
       const heartbeat = setInterval(() => void stream2.writeSSE({ event: "heartbeat", data: "" }).catch(() => {
       }), 1e4);
       await new Promise(
-        (resolve9) => stream2.onAbort(() => {
+        (resolve10) => stream2.onAbort(() => {
           unsubscribe();
           clearInterval(heartbeat);
-          resolve9();
+          resolve10();
         })
       );
     })
@@ -37664,13 +37793,13 @@ function createTerminalServer(deps = {}) {
         }
         for (const viewer of [...viewers]) viewer.shutdown();
         let drainTimer;
-        const boundedServerDrain = new Promise((resolve9) => {
+        const boundedServerDrain = new Promise((resolve10) => {
           let resolved = false;
           const finish = () => {
             if (resolved) return;
             resolved = true;
             clearTimeout(drainTimer);
-            resolve9();
+            resolve10();
           };
           drainTimer = setTimeout(finish, shutdownGraceMs);
           try {
@@ -37710,7 +37839,7 @@ var init_terminal = __esm({
 });
 
 // packages/server/src/app-socket.ts
-import { createHash as createHash14 } from "node:crypto";
+import { createHash as createHash15 } from "node:crypto";
 function isWsPath(url) {
   return (url ?? "").split("?")[0] === WS_PATH;
 }
@@ -37845,7 +37974,7 @@ function createAppSocketServer(deps) {
     sendEncoded(ws, frame, false);
   }
   function frameSignature(frame) {
-    return createHash14("sha256").update(frame.text).digest("base64url");
+    return createHash15("sha256").update(frame.text).digest("base64url");
   }
   const globalReadTimes = [];
   const originReadTimes = /* @__PURE__ */ new Map();
@@ -38343,13 +38472,13 @@ function createAppSocketServer(deps) {
       clearTranscriptSnapshots();
       globalReadTimes.length = 0;
       originReadTimes.clear();
-      const socketDrains = [...wss.clients].map((ws) => new Promise((resolve9) => {
-        if (ws.readyState === ws.CLOSED) return resolve9();
-        ws.once("close", () => resolve9());
+      const socketDrains = [...wss.clients].map((ws) => new Promise((resolve10) => {
+        if (ws.readyState === ws.CLOSED) return resolve10();
+        ws.once("close", () => resolve10());
         try {
           ws.terminate();
         } catch {
-          resolve9();
+          resolve10();
         }
       }));
       lastSig.clear();
@@ -38475,10 +38604,10 @@ var init_app_socket = __esm({
 });
 
 // packages/server/src/boot-progress.ts
-import { mkdirSync as mkdirSync14, readFileSync as readFileSync20, renameSync as renameSync8, rmSync as rmSync6, writeFileSync as writeFileSync10 } from "node:fs";
-import { basename as basename8, dirname as dirname9, join as join33 } from "node:path";
+import { mkdirSync as mkdirSync15, readFileSync as readFileSync21, renameSync as renameSync9, rmSync as rmSync7, writeFileSync as writeFileSync11 } from "node:fs";
+import { basename as basename8, dirname as dirname10, join as join34 } from "node:path";
 function bootProgressPath(stateDir) {
-  return join33(stateDir, BOOT_PROGRESS_NAME);
+  return join34(stateDir, BOOT_PROGRESS_NAME);
 }
 function createBootProgressPublisher(stateDir, minIntervalMs = 200) {
   if (!stateDir) {
@@ -38498,18 +38627,18 @@ function createBootProgressPublisher(stateDir, minIntervalMs = 200) {
     lastAt = now;
     step++;
     try {
-      mkdirSync14(dirname9(path), { recursive: true, mode: 448 });
-      const temp = join33(dirname9(path), `.${basename8(path)}.${process.pid}.tmp`);
-      writeFileSync10(temp, `${JSON.stringify({ pid: process.pid, step, phase, at: new Date(now).toISOString() })}
+      mkdirSync15(dirname10(path), { recursive: true, mode: 448 });
+      const temp = join34(dirname10(path), `.${basename8(path)}.${process.pid}.tmp`);
+      writeFileSync11(temp, `${JSON.stringify({ pid: process.pid, step, phase, at: new Date(now).toISOString() })}
 `, "utf8");
-      renameSync8(temp, path);
+      renameSync9(temp, path);
     } catch {
     }
   };
   return Object.assign(write, {
     done: () => {
       try {
-        rmSync6(path, { force: true });
+        rmSync7(path, { force: true });
       } catch {
       }
     }
@@ -38534,8 +38663,8 @@ __export(index_exports, {
   startServer: () => startServer
 });
 import { createServer } from "node:http";
-import { readFileSync as readFileSync21, existsSync as existsSync11 } from "node:fs";
-import { join as join34, resolve as resolve8, extname as extname2, normalize } from "node:path";
+import { readFileSync as readFileSync22, existsSync as existsSync12 } from "node:fs";
+import { join as join35, resolve as resolve9, extname as extname2, normalize } from "node:path";
 async function pipeToApp(app, req, res, port2, controller) {
   const url = `http://127.0.0.1:${port2}${req.url ?? "/"}`;
   res.on("close", () => {
@@ -38604,11 +38733,11 @@ function createShutdownSignalHandler(options) {
 }
 function serveStatic(distDir, req, res) {
   const rel = normalize((req.url ?? "/").split("?")[0]).replace(/^(\.\.[/\\])+/, "");
-  let file = join34(distDir, rel === "/" ? "index.html" : rel);
-  if (!file.startsWith(distDir)) file = join34(distDir, "index.html");
-  if (!existsSync11(file)) file = join34(distDir, "index.html");
+  let file = join35(distDir, rel === "/" ? "index.html" : rel);
+  if (!file.startsWith(distDir)) file = join35(distDir, "index.html");
+  if (!existsSync12(file)) file = join35(distDir, "index.html");
   try {
-    const body = readFileSync21(file);
+    const body = readFileSync22(file);
     res.writeHead(200, { "content-type": MIME[extname2(file)] ?? "application/octet-stream" });
     res.end(body);
   } catch {
@@ -38893,9 +39022,9 @@ async function startServer(opts = {}) {
     } else {
       await phase("wake scheduler", () => void 0);
     }
-    statusPath = join34(ctx.project.stateDir, "server.lock");
-    const webRoot = resolve8(import.meta.dirname, "..", "..", "web");
-    const distDir = opts.webDistDir ? resolve8(opts.webDistDir) : join34(webRoot, "dist");
+    statusPath = join35(ctx.project.stateDir, "server.lock");
+    const webRoot = resolve9(import.meta.dirname, "..", "..", "web");
+    const distDir = opts.webDistDir ? resolve9(opts.webDistDir) : join35(webRoot, "dist");
     startupPhase = "Vite";
     if (opts.dev) {
       try {
@@ -38939,7 +39068,7 @@ async function startServer(opts = {}) {
       if (vite) {
         vite.middlewares(req, res, () => {
           try {
-            const html = readFileSync21(join34(webRoot, "index.html"), "utf8");
+            const html = readFileSync22(join35(webRoot, "index.html"), "utf8");
             void vite.transformIndexHtml(url, html).then((out) => {
               res.writeHead(200, { "content-type": "text/html" });
               res.end(out);
@@ -38951,7 +39080,7 @@ async function startServer(opts = {}) {
         });
         return;
       }
-      if (existsSync11(distDir)) {
+      if (existsSync12(distDir)) {
         serveStatic(distDir, req, res);
         return;
       }
@@ -39119,8 +39248,8 @@ init_project();
 init_project_launch();
 init_shutdown();
 init_logging();
-import { existsSync as existsSync12 } from "node:fs";
-import { join as join35 } from "node:path";
+import { existsSync as existsSync13 } from "node:fs";
+import { join as join36 } from "node:path";
 process.on("uncaughtException", (error) => {
   log.error("dev-child", `uncaught exception: ${error instanceof Error ? error.stack ?? error.message : error}`);
   process.exit(1);
@@ -39158,9 +39287,9 @@ try {
       ["FRIZZ_SCRIPTS_DIR", process.env.FRIZZ_SCRIPTS_DIR, "index.mjs"],
       ["FRIZZ_WORKER_PLUGIN_DIR", process.env.FRIZZ_WORKER_PLUGIN_DIR, ".claude-plugin/plugin.json"]
     ];
-    if (!existsSync12(stableWebDist)) throw new Error("stable artifact launch is missing its verified web directory");
+    if (!existsSync13(stableWebDist)) throw new Error("stable artifact launch is missing its verified web directory");
     for (const [name, directory, requiredFile] of required) {
-      if (!directory || !existsSync12(join35(directory, requiredFile)))
+      if (!directory || !existsSync13(join36(directory, requiredFile)))
         throw new Error(`stable artifact launch is missing verified ${name}`);
     }
   }