frayui 0.1.2 → 0.1.3

package/dist/frayui.js

@@ -10,6 +10,193 @@ var __export = (target2, all) => {
     __defProp(target2, name, { get: all[name], enumerable: true });
 };
 
+// packages/server/src/logging.ts
+import {
+  appendFileSync,
+  mkdirSync,
+  openSync,
+  readdirSync,
+  rmSync,
+  statSync,
+  symlinkSync,
+  writeFileSync,
+  writeSync
+} from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+function defaultLogRoot(stateDir, home = homedir2()) {
+  return stateDir ? join2(stateDir, "logs") : join2(home, ".fray", "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 = homedir2(), env = process.env) {
+  const name = `fray-${runStamp(at)}-${pid}.log`;
+  const override = env[LOG_PATH_ENV]?.trim();
+  if (override) return override.endsWith(".log") ? override : join2(override, name);
+  return join2(defaultLogRoot(stateDir, home), name);
+}
+function latestLogPath(dir) {
+  return join2(dir, "latest.log");
+}
+function linkLatest(dir, target2) {
+  const link = latestLogPath(dir);
+  try {
+    rmSync(link, { force: true });
+    symlinkSync(target2, link);
+  } catch {
+    try {
+      writeFileSync(link, `${target2}
+`, { mode: 384 });
+    } catch {
+    }
+  }
+}
+function pruneRunLogs(dir, keep = RETAINED_RUNS, days = RETAINED_DAYS, now = Date.now()) {
+  let entries;
+  try {
+    entries = readdirSync(dir).filter((name) => name.endsWith(".log") && name !== "latest.log");
+  } catch {
+    return;
+  }
+  const dated = entries.map((name) => {
+    try {
+      return { name, at: statSync(join2(dir, name)).mtimeMs };
+    } catch {
+      return { name, at: 0 };
+    }
+  }).sort((a, b) => b.at - a.at);
+  const cutoff = now - days * 24 * 60 * 60 * 1e3;
+  const stale = dated.filter((entry, index) => index >= keep || entry.at < cutoff);
+  for (const entry of stale) {
+    try {
+      rmSync(join2(dir, entry.name), { force: true });
+    } catch {
+    }
+  }
+}
+function formatDiskLine(record) {
+  const at = new Date(record.at);
+  const pad = (value, width = 2) => String(value).padStart(width, "0");
+  const clock = `${pad(at.getHours())}:${pad(at.getMinutes())}:${pad(at.getSeconds())}.${pad(at.getMilliseconds(), 3)}`;
+  return `${clock}  ${record.level.toUpperCase().padEnd(5)}  ${record.scope.padEnd(12)}  ${record.message}
+`;
+}
+function openLogFile(path) {
+  try {
+    mkdirSync(join2(path, ".."), { recursive: true, mode: 448 });
+    return openSync(path, "a", 384);
+  } catch {
+    return null;
+  }
+}
+function createLogger(options2 = {}) {
+  const path = options2.file === null ? null : options2.file ?? runLogPath(options2.stateDir);
+  const level = options2.level ?? "debug";
+  const now = options2.now ?? Date.now;
+  const threshold = LEVEL_ORDER[level];
+  const maxBytes = options2.maxBytes ?? MAX_LOG_BYTES;
+  let fd = path === null ? null : openLogFile(path);
+  if (fd !== null && path !== null && options2.owner !== false) {
+    const dir = join2(path, "..");
+    pruneRunLogs(dir);
+    linkLatest(dir, path);
+  }
+  let written = 0;
+  const listeners = /* @__PURE__ */ new Set();
+  const emit = (recordLevel, scope, message) => {
+    if (LEVEL_ORDER[recordLevel] < threshold) return;
+    const record = { at: now(), level: recordLevel, scope, message };
+    if (fd !== null) {
+      try {
+        const line = formatDiskLine(record);
+        if (written + line.length > maxBytes) {
+          writeSync(fd, `--- log truncated at ${maxBytes} bytes ---
+`);
+          fd = null;
+        } else {
+          writeSync(fd, line);
+          written += line.length;
+        }
+      } catch {
+        fd = null;
+      }
+    }
+    for (const listener of listeners) {
+      try {
+        listener(record);
+      } catch {
+      }
+    }
+  };
+  return {
+    debug: (scope, message) => emit("debug", scope, message),
+    info: (scope, message) => emit("info", scope, message),
+    warn: (scope, message) => emit("warn", scope, message),
+    error: (scope, message) => emit("error", scope, message),
+    get file() {
+      return fd === null ? null : path;
+    },
+    onRecord(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    close() {
+      listeners.clear();
+      fd = null;
+    }
+  };
+}
+function setAmbientLogger(logger2) {
+  ambient = logger2;
+  return logger2;
+}
+function formatFeedLine(record) {
+  return formatDiskLine(record).trimEnd();
+}
+function attachTerminalMirror(logger2, enabled = process.env.FRAY_DEBUG === "1") {
+  if (!enabled) return () => {
+  };
+  return logger2.onRecord((record) => process.stderr.write(`${formatFeedLine(record)}
+`));
+}
+function ambientLogger() {
+  if (ambient) return ambient;
+  const inherited = process.env[LOG_FILE_ENV] ?? process.env[LOG_PATH_ENV];
+  const level = process.env[LOG_LEVEL_ENV];
+  const logger2 = createLogger({
+    ...inherited ? { file: inherited, owner: false } : { file: null },
+    ...level && level in LEVEL_ORDER ? { level } : {}
+  });
+  attachTerminalMirror(logger2);
+  ambient = logger2;
+  return ambient;
+}
+function logEnvironment(logger2, level = "debug") {
+  return logger2.file ? { [LOG_FILE_ENV]: logger2.file, [LOG_LEVEL_ENV]: level } : {};
+}
+var LEVEL_ORDER, LOG_FILE_ENV, LOG_LEVEL_ENV, LOG_PATH_ENV, RETAINED_RUNS, RETAINED_DAYS, MAX_LOG_BYTES, ambient, log;
+var init_logging = __esm({
+  "packages/server/src/logging.ts"() {
+    "use strict";
+    LEVEL_ORDER = { debug: 10, info: 20, warn: 30, error: 40 };
+    LOG_FILE_ENV = "FRAY_LOG_FILE";
+    LOG_LEVEL_ENV = "FRAY_LOG_LEVEL";
+    LOG_PATH_ENV = "FRAY_LOG_PATH";
+    RETAINED_RUNS = 20;
+    RETAINED_DAYS = 14;
+    MAX_LOG_BYTES = 32 * 1024 * 1024;
+    ambient = null;
+    log = {
+      debug: (scope, message) => ambientLogger().debug(scope, message),
+      info: (scope, message) => ambientLogger().info(scope, message),
+      warn: (scope, message) => ambientLogger().warn(scope, message),
+      error: (scope, message) => ambientLogger().error(scope, message)
+    };
+  }
+});
+
 // packages/server/src/process-generation.ts
 import { execFileSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
@@ -116,17 +303,17 @@ import { createHash, randomUUID as randomUUID2 } from "node:crypto";
 import {
   closeSync,
   fsyncSync,
-  mkdirSync,
-  openSync,
+  mkdirSync as mkdirSync2,
+  openSync as openSync2,
   readFileSync as readFileSync2,
   realpathSync,
   renameSync,
-  rmSync,
-  statSync,
-  writeFileSync
+  rmSync as rmSync2,
+  statSync as statSync2,
+  writeFileSync as writeFileSync2
 } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { dirname, join as join3, resolve } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 function errorCode2(error) {
   return error && typeof error === "object" && "code" in error && typeof error.code === "string" ? error.code : void 0;
@@ -141,11 +328,11 @@ function canonicalHome(home) {
     return resolve(home);
   }
 }
-function globalLaunchLockPath(home = homedir()) {
-  return join(canonicalHome(home), ".fray", GLOBAL_LOCK_NAME);
+function globalLaunchLockPath(home = homedir3()) {
+  return join3(canonicalHome(home), ".fray", GLOBAL_LOCK_NAME);
 }
 function namedLaunchLockPath(home, name) {
-  return join(canonicalHome(home), ".fray", name);
+  return join3(canonicalHome(home), ".fray", name);
 }
 function pidIsAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
@@ -159,7 +346,7 @@ function pidIsAlive(pid) {
 function syncDirectory(path) {
   let fd;
   try {
-    fd = openSync(path, "r");
+    fd = openSync2(path, "r");
     fsyncSync(fd);
   } catch {
   } finally {
@@ -173,7 +360,7 @@ function syncDirectory(path) {
 }
 function lockOwnerPath(lockPath) {
   try {
-    return statSync(lockPath).isDirectory() ? join(lockPath, GLOBAL_LOCK_OWNER) : lockPath;
+    return statSync2(lockPath).isDirectory() ? join3(lockPath, GLOBAL_LOCK_OWNER) : lockPath;
   } catch {
     return lockPath;
   }
@@ -204,10 +391,10 @@ function observeLock(lockPath, adapter) {
   }
   try {
     const ownerPath = lockOwnerPath(lockPath);
-    let modified = statSync(lockPath).mtimeMs;
+    let modified = statSync2(lockPath).mtimeMs;
     if (ownerPath !== lockPath) {
       try {
-        modified = Math.max(modified, statSync(ownerPath).mtimeMs);
+        modified = Math.max(modified, statSync2(ownerPath).mtimeMs);
       } catch {
       }
     }
@@ -225,16 +412,16 @@ function quarantineLock(lockPath) {
     return false;
   }
   try {
-    rmSync(quarantine2, { recursive: true, force: true });
+    rmSync2(quarantine2, { recursive: true, force: true });
   } catch {
   }
   return true;
 }
 function tryAcquireLock(lockPath, adapter) {
-  mkdirSync(dirname(lockPath), { recursive: true, mode: 448 });
+  mkdirSync2(dirname(lockPath), { recursive: true, mode: 448 });
   let fd;
   try {
-    fd = openSync(lockPath, "wx", 384);
+    fd = openSync2(lockPath, "wx", 384);
   } catch (error) {
     if (errorCode2(error) === "EEXIST") return void 0;
     throw error;
@@ -248,7 +435,7 @@ function tryAcquireLock(lockPath, adapter) {
     at: new Date(adapter.now()).toISOString()
   };
   try {
-    writeFileSync(fd, `${JSON.stringify(owner)}
+    writeFileSync2(fd, `${JSON.stringify(owner)}
 `, "utf8");
     fsyncSync(fd);
     closeSync(fd);
@@ -271,7 +458,7 @@ function tryAcquireLock(lockPath, adapter) {
     const quarantine2 = `${lockPath}.release-${process.pid}-${owner.token}`;
     try {
       renameSync(lockPath, quarantine2);
-      rmSync(quarantine2, { recursive: true, force: true });
+      rmSync2(quarantine2, { recursive: true, force: true });
     } catch {
     }
   };
@@ -279,12 +466,23 @@ function tryAcquireLock(lockPath, adapter) {
 function tryAcquireGlobalLaunchLock(home, adapter) {
   return tryAcquireLock(globalLaunchLockPath(home), adapter);
 }
+function portReservationPath(port, home = homedir3()) {
+  return join3(canonicalHome(home), ".fray", PORT_LOCK_DIR, `${port}.lock`);
+}
+function tryReservePort(port, home = homedir3(), adapter = defaultProcessPlatformAdapter) {
+  const lockPath = portReservationPath(port, home);
+  const release = tryAcquireLock(lockPath, adapter);
+  if (release) return release;
+  const observation = observeLock(lockPath, adapter);
+  if (!observation.stale || !quarantineLock(lockPath)) return void 0;
+  return tryAcquireLock(lockPath, adapter);
+}
 function lockTimeoutError(observation) {
   return new Error(
     observation.ownerPid === void 0 ? "another Fray launch still owns the global launch lock" : `another Fray launch (pid ${observation.ownerPid}) still owns the global launch lock`
   );
 }
-async function acquireGlobalLaunchLock(home = homedir(), timeoutMs = 1e4, adapter = defaultProcessPlatformAdapter) {
+async function acquireGlobalLaunchLock(home = homedir3(), timeoutMs = 1e4, adapter = defaultProcessPlatformAdapter) {
   const deadline = Date.now() + Math.max(0, timeoutMs);
   let observation = { stale: false };
   for (; ; ) {
@@ -350,7 +548,7 @@ function resolveGitWorktree(dir) {
     // Do not enable Git's repository-wide `extensions.worktreeConfig` merely to hold one private Fray
     // value. A config file inside the linked worktree's own administrative directory has Git's atomic
     // config-lock behavior, survives `git worktree move`, and disappears with `git worktree remove`.
-    ...scope === "worktree" ? { identityConfig: join(gitDir, "fray.config") } : {}
+    ...scope === "worktree" ? { identityConfig: join3(gitDir, "fray.config") } : {}
   };
 }
 function readProjectIdConfig(dir, args2, description) {
@@ -385,7 +583,7 @@ function readGitWorktreeProjectId(worktree) {
   );
 }
 function syncGitConfigPath(path) {
-  const fd = openSync(path, "r");
+  const fd = openSync2(path, "r");
   try {
     fsyncSync(fd);
   } finally {
@@ -452,7 +650,7 @@ function resolvedIdentity(worktree) {
   }
   return { ...worktree, id: worktreeId };
 }
-function resolveGitProjectIdentity(dir, home = homedir()) {
+function resolveGitProjectIdentity(dir, home = homedir3()) {
   let worktree = resolveGitWorktree(dir);
   const existing = resolvedIdentity(worktree);
   if (existing) return existing;
@@ -472,13 +670,14 @@ function resolveGitProjectIdentity(dir, home = homedir()) {
     release();
   }
 }
-var GLOBAL_LOCK_NAME, GLOBAL_LOCK_OWNER, INCOMPLETE_LOCK_GRACE_MS, LOCK_POLL_MS, PROJECT_ID_RE, SYNC_WAIT2;
+var GLOBAL_LOCK_NAME, GLOBAL_LOCK_OWNER, PORT_LOCK_DIR, INCOMPLETE_LOCK_GRACE_MS, LOCK_POLL_MS, PROJECT_ID_RE, SYNC_WAIT2;
 var init_project_identity = __esm({
   "packages/server/src/project-identity.ts"() {
     "use strict";
     init_process_generation();
     GLOBAL_LOCK_NAME = "dev-launch.lock";
     GLOBAL_LOCK_OWNER = "owner.json";
+    PORT_LOCK_DIR = "ports";
     INCOMPLETE_LOCK_GRACE_MS = 1e3;
     LOCK_POLL_MS = 50;
     PROJECT_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu;
@@ -491,15 +690,15 @@ import { createHash as createHash2, randomUUID as randomUUID3 } from "node:crypt
 import {
   closeSync as closeSync2,
   fsyncSync as fsyncSync2,
-  mkdirSync as mkdirSync2,
-  openSync as openSync2,
+  mkdirSync as mkdirSync3,
+  openSync as openSync3,
   readFileSync as readFileSync3,
   renameSync as renameSync2,
-  rmSync as rmSync2,
-  statSync as statSync2,
-  writeFileSync as writeFileSync2
+  rmSync as rmSync3,
+  statSync as statSync3,
+  writeFileSync as writeFileSync3
 } from "node:fs";
-import { basename, dirname as dirname2, isAbsolute, join as join2 } from "node:path";
+import { basename as basename2, dirname as dirname2, isAbsolute, join as join4 } from "node:path";
 function errorCode3(error) {
   return error && typeof error === "object" && "code" in error && typeof error.code === "string" ? error.code : void 0;
 }
@@ -509,7 +708,7 @@ function validText(value, max = 4096) {
 function syncDirectory2(path) {
   let fd;
   try {
-    fd = openSync2(path, "r");
+    fd = openSync3(path, "r");
     fsyncSync2(fd);
   } catch {
   } finally {
@@ -522,12 +721,12 @@ function syncDirectory2(path) {
   }
 }
 function atomicJson(path, value) {
-  mkdirSync2(dirname2(path), { recursive: true, mode: 448 });
-  const temp = join2(dirname2(path), `.${basename(path)}.${process.pid}.${randomUUID3()}.tmp`);
+  mkdirSync3(dirname2(path), { recursive: true, mode: 448 });
+  const temp = join4(dirname2(path), `.${basename2(path)}.${process.pid}.${randomUUID3()}.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);
@@ -542,7 +741,7 @@ function atomicJson(path, value) {
       }
     }
     try {
-      rmSync2(temp, { force: true });
+      rmSync3(temp, { force: true });
     } catch {
     }
     throw error;
@@ -556,14 +755,14 @@ function quarantine(path, suffix) {
     return false;
   }
   try {
-    rmSync2(moved, { recursive: true, force: true });
+    rmSync3(moved, { recursive: true, force: true });
   } catch {
   }
   return true;
 }
 function pathAge(path) {
   try {
-    return Date.now() - statSync2(path).mtimeMs;
+    return Date.now() - statSync3(path).mtimeMs;
   } catch {
     return void 0;
   }
@@ -582,22 +781,22 @@ function parseGuard(path) {
   }
 }
 function acquireMutationGuard(stateDir, timeoutMs = GUARD_TIMEOUT_MS, adapter = defaultProcessPlatformAdapter) {
-  const path = join2(stateDir, MUTATION_GUARD_NAME);
-  mkdirSync2(stateDir, { recursive: true, mode: 448 });
+  const path = join4(stateDir, MUTATION_GUARD_NAME);
+  mkdirSync3(stateDir, { recursive: true, mode: 448 });
   const deadline = adapter.now() + Math.max(0, timeoutMs);
   for (; ; ) {
     const generation = currentProcessGeneration(adapter);
     const token = randomUUID3();
     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);
@@ -677,7 +876,7 @@ function parseOwner(path) {
   }
 }
 function projectLaunchOwnerPath(stateDir) {
-  return join2(stateDir, OWNER_NAME);
+  return join4(stateDir, OWNER_NAME);
 }
 function readProjectLaunchOwner(stateDir) {
   return parseOwner(projectLaunchOwnerPath(stateDir));
@@ -694,7 +893,7 @@ function projectLaunchTokenProof(target2, token) {
 }
 function removeStatusesForToken(stateDir, token) {
   for (const name of ["dev-supervisor.lock", "server.lock"]) {
-    const path = join2(stateDir, name);
+    const path = join4(stateDir, name);
     try {
       const value = JSON.parse(readFileSync3(path, "utf8"));
       if (value.ownerToken === token) quarantine(path, "stale");
@@ -705,8 +904,8 @@ 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);
@@ -960,16 +1159,16 @@ import {
   closeSync as closeSync3,
   existsSync,
   fsyncSync as fsyncSync3,
-  mkdirSync as mkdirSync3,
-  openSync as openSync3,
+  mkdirSync as mkdirSync4,
+  openSync as openSync4,
   readFileSync as readFileSync4,
   realpathSync as realpathSync2,
   renameSync as renameSync3,
-  rmSync as rmSync3,
-  statSync as statSync3,
-  writeFileSync as writeFileSync3
+  rmSync as rmSync4,
+  statSync as statSync4,
+  writeFileSync as writeFileSync4
 } from "node:fs";
-import { dirname as dirname3, isAbsolute as isAbsolute2, join as join3, relative, resolve as resolve2, sep } from "node:path";
+import { dirname as dirname3, isAbsolute as isAbsolute2, join as join5, relative, resolve as resolve2, sep as sep2 } from "node:path";
 function canonicalUuid(value) {
   return value && UUID_RE2.test(value) ? value.toLowerCase() : null;
 }
@@ -1039,7 +1238,7 @@ function parseTmuxSocketInspection(output) {
 function syncDirectory3(path) {
   let fd;
   try {
-    fd = openSync3(path, "r");
+    fd = openSync4(path, "r");
     fsyncSync3(fd);
   } catch {
   } finally {
@@ -1050,12 +1249,12 @@ function syncDirectory3(path) {
   }
 }
 function atomicJson2(path, value) {
-  mkdirSync3(dirname3(path), { recursive: true, mode: 448 });
+  mkdirSync4(dirname3(path), { recursive: true, mode: 448 });
   const temp = `${path}.${process.pid}.${randomUUID4()}.tmp`;
   let fd;
   try {
-    fd = openSync3(temp, "wx", 384);
-    writeFileSync3(fd, `${JSON.stringify(value)}
+    fd = openSync4(temp, "wx", 384);
+    writeFileSync4(fd, `${JSON.stringify(value)}
 `, "utf8");
     fsyncSync3(fd);
     closeSync3(fd);
@@ -1068,14 +1267,14 @@ function atomicJson2(path, value) {
     } catch {
     }
     try {
-      rmSync3(temp, { force: true });
+      rmSync4(temp, { force: true });
     } catch {
     }
   }
 }
 function readGuard(path) {
   try {
-    const value = JSON.parse(readFileSync4(join3(path, GUARD_OWNER), "utf8"));
+    const value = JSON.parse(readFileSync4(join5(path, GUARD_OWNER), "utf8"));
     if (value.version !== 1 || !UUID_RE2.test(value.token ?? "") || !Number.isInteger(value.pid) || value.pid <= 0 || typeof value.processStart !== "string") return null;
     return value;
   } catch {
@@ -1083,15 +1282,15 @@ function readGuard(path) {
   }
 }
 function acquireGuard(stateDir) {
-  const path = join3(stateDir, GUARD_NAME);
-  mkdirSync3(stateDir, { recursive: true, mode: 448 });
+  const path = join5(stateDir, GUARD_NAME);
+  mkdirSync4(stateDir, { recursive: true, mode: 448 });
   const deadline = Date.now() + GUARD_TIMEOUT_MS2;
   for (; ; ) {
     try {
-      mkdirSync3(path, { mode: 448 });
+      mkdirSync4(path, { mode: 448 });
       const generation = currentProcessGeneration();
       const owner2 = { version: 1, token: randomUUID4(), ...generation };
-      atomicJson2(join3(path, GUARD_OWNER), owner2);
+      atomicJson2(join5(path, GUARD_OWNER), owner2);
       let released = false;
       return () => {
         if (released) return;
@@ -1101,7 +1300,7 @@ function acquireGuard(stateDir) {
         const quarantine2 = `${path}.release-${owner2.token}`;
         try {
           renameSync3(path, quarantine2);
-          rmSync3(quarantine2, { recursive: true, force: true });
+          rmSync4(quarantine2, { recursive: true, force: true });
         } catch {
         }
       };
@@ -1112,7 +1311,7 @@ function acquireGuard(stateDir) {
     let stale = owner ? processGenerationIsStale(owner) : false;
     if (!owner) {
       try {
-        const age = Date.now() - statSync3(path).mtimeMs;
+        const age = Date.now() - statSync4(path).mtimeMs;
         stale = age >= PARTIAL_GRACE_MS2 || age < -PARTIAL_GRACE_MS2;
       } catch {
         stale = false;
@@ -1122,7 +1321,7 @@ function acquireGuard(stateDir) {
       try {
         const quarantine2 = `${path}.stale-${process.pid}-${randomUUID4()}`;
         renameSync3(path, quarantine2);
-        rmSync3(quarantine2, { recursive: true, force: true });
+        rmSync4(quarantine2, { recursive: true, force: true });
         continue;
       } catch {
       }
@@ -1132,7 +1331,7 @@ function acquireGuard(stateDir) {
   }
 }
 function tmuxSocketMigrationPath(stateDir) {
-  return join3(stateDir, MIGRATION_NAME);
+  return join5(stateDir, MIGRATION_NAME);
 }
 function readTmuxSocketMigration(stateDir) {
   try {
@@ -1171,7 +1370,7 @@ function pathBelongsToProject(path, projectDir) {
     canonical = resolve2(path);
   }
   const rel = relative(projectDir, canonical);
-  return rel === "" || rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute2(rel);
+  return rel === "" || rel !== ".." && !rel.startsWith(`..${sep2}`) && !isAbsolute2(rel);
 }
 function markerlessLegacyIsAttributable(observation, target2) {
   return observation.panes.length > 0 && observation.panes.every(
@@ -1262,7 +1461,7 @@ function resolveProjectTmuxSocket(target2, options2 = {}) {
         record.phase === "claiming"
       );
     }
-    if (!existsSync(join3(target2.stateDir, "ui.db")) && !oldOwnerPinsLegacy) {
+    if (!existsSync(join5(target2.stateDir, "ui.db")) && !oldOwnerPinsLegacy) {
       validateFullSocket(runtime, fullSocket, target2);
       return writeMigration(target2, legacySocket, fullSocket, "full").selectedSocket;
     }
@@ -1350,10 +1549,10 @@ var init_tmux_socket = __esm({
 });
 
 // packages/server/src/boot-progress.ts
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync5, renameSync as renameSync4, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import { basename as basename2, dirname as dirname4, join as join4 } from "node:path";
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync5, renameSync as renameSync4, rmSync as rmSync5, writeFileSync as writeFileSync5 } from "node:fs";
+import { basename as basename3, dirname as dirname4, join as join6 } from "node:path";
 function bootProgressPath(stateDir) {
-  return join4(stateDir, BOOT_PROGRESS_NAME);
+  return join6(stateDir, BOOT_PROGRESS_NAME);
 }
 function readBootProgress(stateDir) {
   try {
@@ -5797,6 +5996,14 @@ var init_interactions = __esm({
         ...CommonPayload,
         kind: external_exports.literal("permission-approval"),
         permission: InteractionOpaqueId,
+        // The exact text of what is being authorized — a command, a path, a request body. Multi-line and
+        // rendered monospace, because a Bash command is the one thing the operator actually reads and a
+        // single-line label cannot hold a heredoc. Adapters redact and clamp it before it gets here.
+        preview: InteractionPreview.optional(),
+        // A shell prompt to render in FRONT of `preview`, which is how a terminal shows a command and where
+        // the working directory belongs when there is one. Set it only when the preview genuinely IS a shell
+        // command line: a file path or an MCP argument behind a `❯` would be a lie about what runs.
+        promptLabel: plainText(256, 512).optional(),
         resourceLabel: plainText(1024, 2048).optional(),
         workingDirectoryLabel: plainText(1024, 2048).optional(),
         scopeLabel: InteractionDescription.optional(),
@@ -6031,7 +6238,7 @@ var init_receipt_bus = __esm({
 });
 
 // packages/shared/src/index.ts
-var ATTACHMENT_IMAGE_EXTENSIONS, ATTACHMENT_DOC_EXTENSIONS, ATTACHMENT_EXTENSIONS, ATTACHMENT_MAX_BASE64_CHARS, ATTACHMENT_MAX_BYTES, ATTACHMENT_EXT_SET, ATTACHMENT_ACCEPT, FrayStatus, BlockMechanism, RuntimeState, Backend, CodexModel, ThreadProfileOption, ThreadAgent, SubAgentView, BgShellView, CompletionHoldOp, CompletionHold, AskOption, AskQuestion, PendingAsk, NativeInputRequired, AwaitingHint, SnoozeUntil, SNOOZE_PROMPT_MAX, SnoozePrompt, ThreadFence, PlanView, LimitWindow, LimitPause, ThreadView, BoardErrorItem, BoardSnapshot, QuotaWindow, ProviderQuota, QuotaSnapshot, ProviderAuth, AuthSnapshot, AccountLogoutInput, AccountLogoutResult, AccountLoginStartInput, AccountLoginStartResult, AccountLoginStatusInput, AccountLoginStatusResult, PermissionMode, LocalFileOpener, Settings, DispatchProviderPreferences, DispatchPreferences, DispatchProfileSnapshot, SetDispatchPreferenceInput, DispatchInput, ADOPT_THREAD_MESSAGE_MAX_CHARS, AdoptThreadInput, AdoptThreadResult, FollowUpInput, UnqueueFollowUpInput, UnqueueFollowUpResult, SetThreadSnoozeInput, ConfirmAwaitingInput, RenameThreadInput, AiRenameThreadInput, AiRenameThreadResult, SetThreadPermissionInput, SetThreadPermissionResult, ThreadProfileOptionsInput, ThreadProfileOptionsResult, SetThreadProfileInput, SetThreadProfileResult, DISPATCH_TASK_BANNER, DISPATCH_TASK_BANNER_MARKER, WAKE_SCOPE, WAKE_REF, WAKE_SINGLE, WAKE_MULTI_HEAD, GithubStatus, GithubItem, GithubListInput, GithubBatchInput, GithubBatchResult, BoardMeta, ServerEvent, TranscriptEdit, TranscriptTodo, TranscriptToolCall, TranscriptPart, TranscriptMessage, TranscriptPageCursor, TranscriptPage, TranscriptEarlierInput, SocketTranscriptSlug, SocketClientMsg, DEFAULT_PORT;
+var ATTACHMENT_IMAGE_EXTENSIONS, ATTACHMENT_DOC_EXTENSIONS, ATTACHMENT_EXTENSIONS, ATTACHMENT_MAX_BASE64_CHARS, ATTACHMENT_MAX_BYTES, ATTACHMENT_EXT_SET, ATTACHMENT_ACCEPT, FrayStatus, BlockMechanism, RuntimeState, Backend, CodexModel, ThreadProfileOption, ThreadAgent, SubAgentView, BgShellView, CompletionHoldOp, CompletionHold, AskOption, AskQuestion, PendingAsk, NativeInputRequired, AwaitingHint, SnoozeUntil, SNOOZE_PROMPT_MAX, SnoozePrompt, ThreadFence, PlanView, LimitWindow, LimitPause, ThreadView, BoardErrorItem, BoardSnapshot, QuotaWindow, ProviderQuota, QuotaSnapshot, ProviderAuth, AuthSnapshot, AccountLogoutInput, AccountLogoutResult, AccountLoginStartInput, AccountLoginStartResult, AccountLoginStatusInput, AccountLoginStatusResult, PermissionMode, LocalFileOpener, Settings, DispatchProviderPreferences, DispatchPreferences, DispatchProfileSnapshot, SetDispatchPreferenceInput, DispatchInput, ADOPT_THREAD_MESSAGE_MAX_CHARS, AdoptThreadInput, AdoptThreadResult, FollowUpInput, UnqueueFollowUpInput, UnqueueFollowUpResult, SetThreadSnoozeInput, ConfirmAwaitingInput, RenameThreadInput, AiRenameThreadInput, AiRenameThreadResult, SetThreadPermissionInput, SetThreadPermissionResult, ThreadProfileOptionsInput, ThreadProfileOptionsResult, SetThreadProfileInput, SetThreadProfileResult, DISPATCH_TASK_BANNER, DISPATCH_TASK_BANNER_MARKER, GithubWakeItem, GithubWakeSteer, WAKE_SCOPE, WAKE_REF, WAKE_SINGLE, WAKE_MULTI_HEAD, GithubStatus, GithubItem, GithubListInput, GithubBatchInput, GithubBatchResult, BoardMeta, ServerEvent, TranscriptEdit, TranscriptTodo, TranscriptToolCall, TranscriptPart, TranscriptMessage, TranscriptPageCursor, TranscriptPage, TranscriptEarlierInput, SocketTranscriptSlug, SocketClientMsg, DEFAULT_PORT;
 var init_src = __esm({
   "packages/shared/src/index.ts"() {
     "use strict";
@@ -6664,7 +6871,13 @@ var init_src = __esm({
       sessionId: external_exports.string().min(1),
       message: external_exports.string().min(1),
       // Generated once before the optimistic clear so a transport replay can be idempotent.
-      deliveryId: external_exports.string().min(1).max(200).optional()
+      deliveryId: external_exports.string().min(1).max(200).optional(),
+      // Retire the worker's live process before delivering, so this message lands in a `claude` that has
+      // just started. The operator's "Restart worker" verb — the ONLY caller that sets it — exists because
+      // a worker inherits its plugin/hooks AND its system prompt at process start and can never pick up a
+      // newer fray build in place (hooks are read once, at startup). Everything else that needs a fresh
+      // process derives it server-side; see needsFreshProcessForLimit.
+      freshProcess: external_exports.boolean().optional()
     });
     UnqueueFollowUpInput = external_exports.object({
       slug: ThreadSlug,
@@ -6732,6 +6945,25 @@ var init_src = __esm({
 ${DISPATCH_TASK_BANNER}
 
 `;
+    GithubWakeItem = external_exports.object({
+      label: external_exports.string(),
+      // the activity's noun ("comment", "approval", "change request", …)
+      actor: external_exports.string(),
+      // GitHub login, no leading @
+      bot: external_exports.boolean(),
+      // drives the 🤖/👤 icon; an app files most of what wakes this watcher
+      at: external_exports.string().optional(),
+      // ISO8601
+      url: external_exports.string().optional()
+      // the item's own permalink
+    });
+    GithubWakeSteer = external_exports.object({
+      ref: external_exports.string(),
+      // owner/repo#N
+      items: external_exports.array(GithubWakeItem),
+      omitted: external_exports.number()
+      // fresh items counted but not named (the enumeration cap)
+    });
     WAKE_SCOPE = "ignore older activity you have already handled";
     WAKE_REF = String.raw`[A-Za-z0-9][\w.-]*\/[A-Za-z0-9][\w.-]*#\d+`;
     WAKE_SINGLE = new RegExp(
@@ -7028,11 +7260,20 @@ ${DISPATCH_TASK_BANNER}
       // non-reasoning messages and on any reasoning block whose timing couldn't be derived.
       durationMs: external_exports.number().nonnegative().optional(),
       // A turn-BOUNDARY marker: this `kind:"event"` line was emitted at the position an EXTERNAL wake — a
-      // background task/shell completion `<task-notification>` — re-invoked the agent and started a fresh
-      // turn. The client renders it as a centered divider rule carrying the cause label, so two consecutive
-      // assistant turns (each with its own trailing signal) no longer paint as one seamless bubble. Additive
-      // + optional: an old client ignores it and shows the plain quiet event line (graceful degrade).
-      boundary: external_exports.boolean().optional(),
+      // This event opened a fresh turn, so it renders as a centered divider rule carrying the cause label —
+      // without it, two consecutive assistant turns (each with its own trailing signal) paint as one
+      // seamless bubble. Additive + optional: an old client ignores it and shows the plain quiet event line
+      // (graceful degrade).
+      //
+      // It names WHICH KIND of boundary, because two unrelated events earn the divider and the client has to
+      // tell them apart to put the right glyph on each:
+      //   wake       — a background task/shell completion `<task-notification>` re-invoked the agent
+      //   compaction — the provider rewrote the conversation and dropped everything above this point
+      // It was a bare boolean until the dividers grew icons (a shell glyph on a compaction line is simply
+      // wrong), and the kind has to come from the SERVER: the alternative is the client sniffing the label
+      // text, which is the guess this codebase refuses everywhere else. A string stays truthy, so any
+      // surviving `if (boundary)` reads exactly as it did.
+      boundary: external_exports.enum(["wake", "compaction"]).optional(),
       // Block-ordered content for an assistant turn (see TranscriptPart). Defaults to [] so a pre-restart
       // server (which ships only text/tools) parses; the client renders `parts` when non-empty and falls
       // back to the legacy tools-then-text layout when it's empty. `text`/`tools` stay populated for that
@@ -7061,6 +7302,17 @@ ${DISPATCH_TASK_BANNER}
       // old client ignores it and shows the plain bubble (the previous behavior), and an old server simply
       // never sets it.
       wake: external_exports.boolean().optional(),
+      // The STRUCTURED wake, parsed by the server from the same text the same build formatted. The chat
+      // renders the divider from this rather than re-deriving it from prose in the browser.
+      //
+      // It exists because re-deriving it in the browser is version-skewed by construction. `web/api/boot.ts`
+      // adopts a new server boot id IN PLACE (so an unsent draft survives a restart), so a promoted artifact
+      // swaps the server under tabs that keep their old bundle — and on 2026-07-31 a steer that gained two
+      // agent-facing lines met parsers that predated them, which cost every open tab its card and dumped the
+      // raw `gh api …` text into the transcript instead. Server-side, formatter and parser can never
+      // disagree. Additive + optional: absent from a legacy transcript or an older server, and the client
+      // falls back to `parseGithubWakeSteer` on the text.
+      wakeSteer: GithubWakeSteer.optional(),
       // A SUB-AGENT (or peer session) wrote this user turn, not the human — the same defect class `wake`
       // above corrects. Claude Code's agent-to-agent channel (a background child calling
       // `SendMessage({to:"main"})`) delivers UPWARD into the parent's queue like any follow-up, so the
@@ -7181,7 +7433,7 @@ var init_local_origin = __esm({
 });
 
 // packages/server/src/local-image.ts
-import { readFileSync as readFileSync7, realpathSync as realpathSync4, statSync as statSync4 } from "node:fs";
+import { readFileSync as readFileSync7, realpathSync as realpathSync4, statSync as statSync5 } from "node:fs";
 import { extname, isAbsolute as isAbsolute3 } from "node:path";
 function resolveLocalImage(rawPath) {
   if (!rawPath || !isAbsolute3(rawPath)) return { status: 400 };
@@ -7194,7 +7446,7 @@ function resolveLocalImage(rawPath) {
     return { status: 404 };
   }
   try {
-    if (!statSync4(real).isFile()) return { status: 404 };
+    if (!statSync5(real).isFile()) return { status: 404 };
     return { status: 200, contentType, body: readFileSync7(real) };
   } catch {
     return { status: 404 };
@@ -7215,23 +7467,756 @@ var init_local_image = __esm({
 });
 
 // src/production.ts
-import { spawn as spawn2 } from "node:child_process";
-import { closeSync as closeSync4, openSync as openSync4 } from "node:fs";
+import { readFileSync as readFileSync9 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { join as join7 } from "node:path";
-import { setTimeout as delay3 } from "node:timers/promises";
+import { join as join9 } from "node:path";
+
+// src/browser.ts
+import { spawn, execFile } from "node:child_process";
+import { access, readdir, mkdir, writeFile, readFile, rm } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, delimiter, sep } from "node:path";
+function defaultBrowserOpenCommand(rawUrl, platform = process.platform) {
+  let url;
+  try {
+    url = new URL(rawUrl);
+  } catch {
+    throw new Error(`Cannot open invalid browser URL: ${rawUrl}`);
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`Cannot open unsupported browser URL scheme: ${url.protocol}`);
+  }
+  if (platform === "darwin") return { command: "/usr/bin/open", args: [url.toString()] };
+  if (platform === "win32") {
+    return { command: "rundll32.exe", args: ["url.dll,FileProtocolHandler", url.toString()] };
+  }
+  if (platform === "linux" || platform === "freebsd" || platform === "openbsd") {
+    return { command: "xdg-open", args: [url.toString()] };
+  }
+  throw new Error(`Opening the default browser is not supported on ${platform}`);
+}
+async function launchBrowserTab(rawUrl, options2 = {}) {
+  const platform = options2.platform ?? process.platform;
+  const runCommand = options2.runCommand ?? execFileP;
+  const launch = defaultBrowserOpenCommand(rawUrl, platform);
+  await runCommand(launch.command, launch.args);
+}
+var browserPaths = {
+  win32: process.platform === "win32" && {
+    chrome: [
+      join("Google", "Chrome", "Application", "chrome.exe"),
+      join(process.env.USERPROFILE ?? "", "scoop", "apps", "googlechrome", "current", "chrome.exe")
+    ],
+    chrome_canary: join("Google", "Chrome SxS", "Application", "chrome.exe"),
+    chromium: [
+      join("Chromium", "Application", "chrome.exe"),
+      join(process.env.USERPROFILE ?? "", "scoop", "apps", "chromium", "current", "chrome.exe")
+    ],
+    edge: join("Microsoft", "Edge", "Application", "msedge.exe"),
+    brave: join("BraveSoftware", "Brave-Browser", "Application", "brave.exe"),
+    vivaldi: join("Vivaldi", "Application", "vivaldi.exe"),
+    thorium: join("Thorium", "Application", "thorium.exe"),
+    firefox: [
+      join("Mozilla Firefox", "firefox.exe"),
+      join(process.env.USERPROFILE ?? "", "scoop", "apps", "firefox", "current", "firefox.exe")
+    ],
+    firefox_developer: join("Firefox Developer Edition", "firefox.exe"),
+    firefox_nightly: join("Firefox Nightly", "firefox.exe"),
+    librewolf: join("LibreWolf", "librewolf.exe"),
+    waterfox: join("Waterfox", "waterfox.exe")
+  },
+  linux: {
+    chrome: ["chrome", "google-chrome", "chrome-browser", "google-chrome-stable"],
+    chrome_canary: ["chrome-canary", "google-chrome-canary"],
+    chromium: ["chromium", "chromium-browser"],
+    edge: ["microsoft-edge", "microsoft-edge-stable"],
+    brave: ["brave", "brave-browser"],
+    vivaldi: ["vivaldi", "vivaldi-browser"],
+    thorium: ["thorium", "thorium-browser"],
+    firefox: ["firefox", "firefox-browser"],
+    firefox_nightly: ["firefox-nightly"],
+    librewolf: ["librewolf", "librewolf-browser"],
+    waterfox: ["waterfox", "waterfox-browser"]
+  },
+  darwin: {
+    chrome: "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    chrome_canary: "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
+    chromium: "/Applications/Chromium.app/Contents/MacOS/Chromium",
+    edge: "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+    brave: "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
+    vivaldi: "/Applications/Vivaldi.app/Contents/MacOS/Vivaldi",
+    thorium: "/Applications/Thorium.app/Contents/MacOS/Thorium",
+    firefox: "/Applications/Firefox.app/Contents/MacOS/firefox",
+    firefox_nightly: "/Applications/Firefox Nightly.app/Contents/MacOS/firefox",
+    librewolf: "/Applications/LibreWolf.app/Contents/MacOS/librewolf",
+    waterfox: "/Applications/Waterfox.app/Contents/MacOS/waterfox"
+  }
+}[process.platform] || void 0;
+if (process.platform === "win32" && browserPaths) {
+  for (const browser in browserPaths) {
+    const val = browserPaths[browser];
+    const isArray = Array.isArray(val);
+    const basePath = isArray ? val[0] : val;
+    if (!basePath) continue;
+    browserPaths[browser] = [
+      join(process.env.PROGRAMFILES ?? "", basePath),
+      join(process.env.LOCALAPPDATA ?? "", basePath),
+      join(process.env["PROGRAMFILES(X86)"] ?? "", basePath),
+      ...isArray ? val.slice(1) : []
+    ];
+  }
+}
+var _binariesInPath;
+async function getBinariesInPath() {
+  if (_binariesInPath) return _binariesInPath;
+  _binariesInPath = (await Promise.all(
+    (process.env.PATH ?? "").replaceAll('"', "").split(delimiter).filter(Boolean).map((x) => readdir(x.replace(/"+/g, "")).catch(() => []))
+  )).flat();
+  return _binariesInPath;
+}
+async function pathExists(path) {
+  if (path.includes(sep)) return access(path).then(() => true).catch(() => false);
+  return (await getBinariesInPath()).includes(path);
+}
+async function getBrowserPath(browser) {
+  if (!browserPaths) return null;
+  const paths = browserPaths[browser];
+  if (!paths) return null;
+  for (const p of Array.isArray(paths) ? paths : [paths]) {
+    if (await pathExists(p)) return p;
+  }
+  return null;
+}
+function getBrowserType(name) {
+  if (name.startsWith("firefox") || ["librewolf", "waterfox"].includes(name)) return "firefox";
+  return "chromium";
+}
+async function findBrowser(forceBrowser) {
+  if (!browserPaths) return null;
+  if (forceBrowser) {
+    const path = await getBrowserPath(forceBrowser);
+    if (path) return { path, name: forceBrowser, type: getBrowserType(forceBrowser) };
+    return null;
+  }
+  for (const name in browserPaths) {
+    const path = await getBrowserPath(name);
+    if (path) return { path, name, type: getBrowserType(name) };
+  }
+  return null;
+}
+async function launchApp(url, opts = {}) {
+  const { windowSize = [1400, 900], dataPath } = opts;
+  const browser = await findBrowser();
+  if (!browser) {
+    throw new Error("No supported browser found for --app mode");
+  }
+  if (browser.type === "chromium") {
+    if (process.platform === "darwin" && dataPath) {
+      const shim = await ensureAppShim(browser.path, url, dataPath);
+      if (shim && await openShimVerified(shim, dataPath)) return;
+    }
+    launchChromium(browser.path, url, windowSize, dataPath);
+  } else {
+    await launchFirefox(browser.path, url, windowSize, dataPath);
+  }
+}
+var CHROME_APPS_DIR = join(homedir(), "Applications", "Chrome Apps.localized");
+var EXPECTED_BUNDLE_NAME = "Fray";
+function bundleNameMatchesManifest(bundleName) {
+  if (bundleName === EXPECTED_BUNDLE_NAME) return true;
+  return new RegExp(`^${EXPECTED_BUNDLE_NAME} \\d+$`).test(bundleName);
+}
+var STANDALONE_SENTINEL = ".fray-pwa-standalone";
+function manifestIdFor(url) {
+  return url.endsWith("/") ? url : `${url}/`;
+}
+function execFileP(cmd, args2) {
+  return new Promise((resolve5, reject) => {
+    execFile(
+      cmd,
+      args2,
+      { encoding: "utf8", timeout: 1e4 },
+      (err, stdout) => err ? reject(err) : resolve5(stdout)
+    );
+  });
+}
+async function findAppShim(url, dataPath) {
+  const manifestId = manifestIdFor(url);
+  const bundles = await readdir(CHROME_APPS_DIR).catch(() => []);
+  for (const name of bundles) {
+    if (!name.endsWith(".app")) continue;
+    const plist = join(CHROME_APPS_DIR, name, "Contents", "Info.plist");
+    try {
+      const info = JSON.parse(await execFileP("plutil", ["-convert", "json", "-o", "-", plist]));
+      if (info.CrAppModeShortcutURL === manifestId && info.CrAppModeUserDataDir?.startsWith(dataPath + sep)) {
+        return { path: join(CHROME_APPS_DIR, name), bundleName: info.CFBundleName ?? "" };
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function escapeERE(s) {
+  return s.replace(/[.^$*+?()[\]{}|\\]/g, "\\$&");
+}
+async function pgrepMatches(pattern) {
+  try {
+    const out = await execFileP("pgrep", ["-f", "--", escapeERE(pattern)]);
+    return out.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+async function profileInUse(dataPath) {
+  return pgrepMatches(`--user-data-dir=${dataPath}`);
+}
+function openCdpSession(browserPath, dataPath) {
+  const child = spawn(
+    browserPath,
+    [
+      `--user-data-dir=${dataPath}`,
+      "--remote-debugging-pipe",
+      "--no-startup-window",
+      "--no-first-run",
+      "--no-default-browser-check",
+      "--disable-sync",
+      "--disable-background-networking"
+    ],
+    { stdio: ["ignore", "ignore", "ignore", "pipe", "pipe"] }
+  );
+  const cmdPipe = child.stdio[3];
+  const resPipe = child.stdio[4];
+  let seq = 0;
+  const pending = /* @__PURE__ */ new Map();
+  let buf = Buffer.alloc(0);
+  resPipe.on("data", (chunk) => {
+    buf = Buffer.concat([buf, chunk]);
+    let nul;
+    while ((nul = buf.indexOf(0)) !== -1) {
+      const raw = buf.subarray(0, nul).toString("utf8");
+      buf = buf.subarray(nul + 1);
+      try {
+        const msg = JSON.parse(raw);
+        if (msg.id !== void 0 && pending.has(msg.id)) {
+          const p = pending.get(msg.id);
+          pending.delete(msg.id);
+          if (msg.error) p.reject(new Error(msg.error.message));
+          else p.resolve(msg.result);
+        }
+      } catch {
+      }
+    }
+  });
+  const failAll = (e) => {
+    for (const [, p] of pending) p.reject(e);
+    pending.clear();
+  };
+  child.on("error", failAll);
+  cmdPipe.on("error", failAll);
+  resPipe.on("error", failAll);
+  child.on("exit", () => failAll(new Error("chrome exited before the CDP handshake completed")));
+  const call = (method, params = {}, timeoutMs = 2e4) => new Promise((resolve5, reject) => {
+    const id = ++seq;
+    pending.set(id, { resolve: resolve5, reject });
+    cmdPipe.write(JSON.stringify({ id, method, params }) + "\0");
+    setTimeout(() => {
+      if (pending.has(id)) {
+        pending.delete(id);
+        reject(new Error(`${method}: timed out`));
+      }
+    }, timeoutMs).unref();
+  });
+  const close = async () => {
+    await call("Browser.close").catch(() => {
+    });
+    if (child.exitCode !== null || child.signalCode !== null) return;
+    await new Promise((resolve5) => {
+      const t = setTimeout(() => {
+        child.kill();
+        resolve5();
+      }, 1e4);
+      t.unref();
+      child.once("exit", () => {
+        clearTimeout(t);
+        resolve5();
+      });
+    });
+  };
+  return { call, close, kill: () => child.kill() };
+}
+async function cdpInstallPwa(browserPath, url, dataPath) {
+  const manifestId = manifestIdFor(url);
+  const s = openCdpSession(browserPath, dataPath);
+  try {
+    await s.call("Browser.getVersion");
+    await s.call("PWA.install", { manifestId, installUrlOrBundleUrl: manifestId }, 3e4);
+    await s.call("PWA.changeAppUserSettings", { manifestId, displayMode: "standalone" });
+    await writeFile(join(dataPath, STANDALONE_SENTINEL), "");
+    await s.close();
+  } catch (err) {
+    s.kill();
+    throw err;
+  }
+}
+async function cdpUninstallPwa(browserPath, url, dataPath) {
+  const manifestId = manifestIdFor(url);
+  const s = openCdpSession(browserPath, dataPath);
+  try {
+    await s.call("Browser.getVersion");
+    await s.call("PWA.uninstall", { manifestId });
+    await s.close();
+  } catch (err) {
+    s.kill();
+    throw err;
+  }
+  await rm(join(dataPath, STANDALONE_SENTINEL), { force: true }).catch(() => {
+  });
+}
+async function waitForShimIdle(shimPath) {
+  const appearBy = Date.now() + 6e3;
+  let appeared = false;
+  while (Date.now() < appearBy) {
+    if (await pgrepMatches(shimPath)) {
+      appeared = true;
+      break;
+    }
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  if (!appeared) return;
+  const idleBy = Date.now() + 15e3;
+  while (Date.now() < idleBy) {
+    if (!await pgrepMatches(shimPath)) return;
+    await new Promise((r) => setTimeout(r, 250));
+  }
+}
+async function openShimVerified(shimPath, dataPath) {
+  spawn("open", [shimPath], { detached: true, stdio: "ignore" }).unref();
+  const deadline = Date.now() + 1e4;
+  while (Date.now() < deadline) {
+    if (await profileInUse(dataPath)) return true;
+    await new Promise((r) => setTimeout(r, 150));
+  }
+  return false;
+}
+async function standaloneSentinelExists(dataPath) {
+  return access(join(dataPath, STANDALONE_SENTINEL)).then(() => true).catch(() => false);
+}
+async function seedFirstRunState(dataPath) {
+  await writeFile(join(dataPath, "First Run"), "", { flag: "wx" }).catch(() => {
+  });
+  if (await profileInUse(dataPath)) return;
+  const prefsPath = join(dataPath, "Default", "Preferences");
+  try {
+    const prefs = JSON.parse(await readFile(prefsPath, "utf8"));
+    if (prefs.browser?.check_default_browser === false) return;
+    prefs.browser = { ...prefs.browser ?? {}, check_default_browser: false };
+    await writeFile(prefsPath, JSON.stringify(prefs));
+  } catch {
+  }
+}
+async function ensureAppShim(browserPath, url, dataPath) {
+  try {
+    const existing = await findAppShim(url, dataPath);
+    if (existing && bundleNameMatchesManifest(existing.bundleName) && await standaloneSentinelExists(dataPath)) {
+      await seedFirstRunState(dataPath);
+      return existing.path;
+    }
+    if (await profileInUse(dataPath)) return null;
+    if (existing) {
+      await cdpUninstallPwa(browserPath, url, dataPath).catch(() => {
+      });
+    }
+    await cdpInstallPwa(browserPath, url, dataPath);
+    await seedFirstRunState(dataPath);
+    const installed = await findAppShim(url, dataPath);
+    if (installed) await waitForShimIdle(installed.path);
+    return installed?.path ?? null;
+  } catch {
+    return null;
+  }
+}
+function launchChromium(browserPath, url, windowSize, dataPath) {
+  const args2 = [
+    `--app=${url}`,
+    `--window-size=${windowSize.join(",")}`,
+    "--new-window",
+    "--no-first-run",
+    "--no-default-browser-check",
+    "--disable-translate",
+    "--disable-sync",
+    "--disable-popup-blocking",
+    "--disable-background-networking",
+    "--disable-default-apps",
+    "--disable-component-extensions-with-background-pages",
+    "--autoplay-policy=no-user-gesture-required"
+  ];
+  if (dataPath) {
+    args2.push(`--user-data-dir=${dataPath}`);
+  }
+  spawn(browserPath, args2, { detached: true, stdio: "ignore" }).unref();
+}
+async function launchFirefox(browserPath, url, windowSize, dataPath) {
+  const profileDir = dataPath ?? join(
+    process.env.HOME ?? process.env.USERPROFILE ?? ".",
+    ".gent",
+    "firefox-profile"
+  );
+  await mkdir(profileDir, { recursive: true });
+  await writeFile(
+    join(profileDir, "user.js"),
+    `
+user_pref("toolkit.legacyUserProfileCustomizations.stylesheets", true);
+user_pref("browser.shell.checkDefaultBrowser", false);
+user_pref("toolkit.telemetry.reportingpolicy.firstRun", false);
+user_pref("privacy.resistFingerprinting", false);
+user_pref("ui.key.menuAccessKeyFocuses", false);
+user_pref("media.autoplay.blocking_policy", 0);
+${process.platform === "darwin" ? 'user_pref("browser.tabs.inTitlebar", 0);' : ""}
+`
+  );
+  await mkdir(join(profileDir, "chrome"), { recursive: true });
+  await writeFile(
+    join(profileDir, "chrome", "userChrome.css"),
+    `
+.titlebar-spacer, #firefox-view-button, #alltabs-button,
+#tabbrowser-arrowscrollbox-periphery, .tab-close-button {
+  display: none;
+}
+#nav-bar, #urlbar-container, #searchbar { visibility: collapse !important; }
+.tab-background, .tab-content, #tabbrowser-tabs {
+  background: none !important;
+  margin: 0 !important;
+  padding: 0 !important;
+  border: none !important;
+  box-shadow: none !important;
+}
+#tabbrowser-tabs { margin: 0 6px !important; }
+.tabbrowser-tab { pointer-events: none; }
+#titlebar, .tabbrowser-tab { height: 20px; }
+.tab-content { height: 42px; }
+html:not([tabsintitlebar="true"]) #titlebar,
+html:not([tabsintitlebar="true"]) .tabbrowser-tab,
+html:not([tabsintitlebar="true"]) .tab-background,
+html:not([tabsintitlebar="true"]) .tab-content,
+html:not([tabsintitlebar="true"]) #tabbrowser-tabs {
+  display: none !important;
+}
+`
+  );
+  spawn(
+    browserPath,
+    [
+      "-width",
+      String(windowSize[0]),
+      "-height",
+      String(windowSize[1]),
+      "-profile",
+      profileDir,
+      "-new-window",
+      url,
+      "-new-instance",
+      "-no-remote"
+    ],
+    { detached: true, stdio: "ignore" }
+  ).unref();
+}
+
+// src/readout.ts
+var SPINNER = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var SYNC_BEGIN = "\x1B[?2026h";
+var SYNC_END = "\x1B[?2026l";
+var ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  red: "\x1B[31m"
+};
+function formatDuration(ms) {
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  if (ms < 1e4) return `${(ms / 1e3).toFixed(1)}s`;
+  return `${Math.round(ms / 1e3)}s`;
+}
+function tildePath(path, home) {
+  if (!home || !path.startsWith(home)) return path;
+  const rest = path.slice(home.length);
+  return rest === "" ? "~" : rest.startsWith("/") ? `~${rest}` : path;
+}
+var Readout = class {
+  out;
+  tty;
+  colorEnabled;
+  debug;
+  version;
+  now;
+  startedAt;
+  steps = [];
+  frame = 0;
+  timer;
+  /** Rows currently occupied by the repainting region, so the next paint knows what to erase. */
+  painted = 0;
+  stepStartedAt = /* @__PURE__ */ new Map();
+  settled = false;
+  /** Non-TTY only: suppress repeating an identical status row. */
+  lastPlainLine = "";
+  constructor(options2 = {}) {
+    this.out = options2.output ?? process.stdout;
+    this.tty = this.out.isTTY === true;
+    this.debug = options2.debug === true;
+    this.colorEnabled = options2.color ?? (this.tty && !process.env.NO_COLOR && process.env.TERM !== "dumb");
+    this.version = options2.version;
+    this.now = options2.now ?? Date.now;
+    this.startedAt = this.now();
+    if (this.tty && !this.debug) {
+      const timer = setInterval(() => this.paint(), options2.tickMs ?? 80);
+      timer.unref?.();
+      this.timer = timer;
+    }
+  }
+  c(code, text) {
+    return this.colorEnabled ? `${code}${text}${ANSI.reset}` : text;
+  }
+  get width() {
+    return Math.max(40, this.out.columns ?? 80);
+  }
+  /** Truncate to the terminal width so a row can never wrap — wrapping desynchronizes the repaint. */
+  fit(line) {
+    const limit = this.width - 1;
+    if (visibleLength(line) <= limit) return line;
+    return `${sliceVisible(line, limit - 1)}\u2026`;
+  }
+  // ── Steps ────────────────────────────────────────────────────────────────────────────────────────
+  /** Declare the boot's shape up front so the operator can see what is still ahead. */
+  plan(steps) {
+    for (const step of steps) {
+      if (!this.steps.some((existing) => existing.key === step.key)) {
+        this.steps.push({ ...step, state: "pending" });
+      }
+    }
+    this.paint(true);
+  }
+  begin(key, detail) {
+    const step = this.steps.find((candidate) => candidate.key === key);
+    if (!step) return;
+    for (const earlier of this.steps) {
+      if (earlier === step) break;
+      if (earlier.state === "active") this.settle(earlier.key, "done");
+    }
+    step.state = "active";
+    if (detail !== void 0) step.detail = detail;
+    this.stepStartedAt.set(key, this.now());
+    this.emitPlain(step);
+    this.paint(true);
+  }
+  /** Update the live sub-phase of the active step without changing which step is active. */
+  detail(key, detail) {
+    const step = this.steps.find((candidate) => candidate.key === key);
+    if (!step || step.state !== "active") return;
+    if (step.detail === detail) return;
+    step.detail = detail;
+    this.emitPlain(step);
+    this.paint(true);
+  }
+  settle(key, state, detail) {
+    const step = this.steps.find((candidate) => candidate.key === key);
+    if (!step) return;
+    step.state = state;
+    step.detail = detail;
+    const startedAt = this.stepStartedAt.get(key);
+    if (startedAt !== void 0) step.ms = this.now() - startedAt;
+    this.emitPlain(step);
+    this.paint(true);
+  }
+  /** The step currently doing work, for a failure message that can name where the boot stopped. */
+  activeStep() {
+    return this.steps.find((step) => step.state === "active");
+  }
+  // ── Painting ─────────────────────────────────────────────────────────────────────────────────────
+  glyph(step) {
+    switch (step.state) {
+      case "done":
+        return this.c(ANSI.green, "\u2713");
+      case "failed":
+        return this.c(ANSI.red, "\u2717");
+      case "skipped":
+        return this.c(ANSI.dim, "\u2212");
+      case "active":
+        return this.c(ANSI.cyan, SPINNER[this.frame % SPINNER.length]);
+      default:
+        return this.c(ANSI.dim, "\xB7");
+    }
+  }
+  stepRow(step) {
+    const elapsed = step.state === "active" ? formatDuration(this.now() - (this.stepStartedAt.get(step.key) ?? this.now())) : step.ms !== void 0 && step.ms >= 1e3 ? formatDuration(step.ms) : "";
+    const tail = [step.detail, elapsed].filter(Boolean).join("  ");
+    const label = tail ? step.label.padEnd(18) : step.label;
+    const styled = step.state === "pending" ? this.c(ANSI.dim, label) : label;
+    return this.fit(`  ${this.glyph(step)}  ${styled}${tail ? this.c(ANSI.dim, tail) : ""}`);
+  }
+  header() {
+    const name = this.c(`${ANSI.bold}${ANSI.magenta}`, "FRAY");
+    const version = this.version ? ` ${this.c(ANSI.dim, `v${this.version}`)}` : "";
+    return ["", `  ${name}${version}`, ""];
+  }
+  /** Return the cursor to the top of the painted region and clear everything below it. */
+  rewind() {
+    return this.painted > 0 ? `\x1B[${this.painted}A\r\x1B[0J` : "\r\x1B[0J";
+  }
+  paint(force = false) {
+    if (this.settled) return;
+    if (!this.tty || this.debug) return;
+    if (!force) this.frame++;
+    const lines = [...this.header(), ...this.steps.map((step) => this.stepRow(step))];
+    this.out.write(`${SYNC_BEGIN}${this.rewind()}${lines.join("\n")}
+${SYNC_END}`);
+    this.painted = lines.length;
+  }
+  /**
+   * Non-TTY transcript: one settled, parseable row per state change, so a pipe still sees progress.
+   *
+   * Silent under `--debug`, where the log feed is the authoritative account and these rows were
+   * duplicating it in a second format ("fray: ··· artifact — checking …" immediately beside
+   * "INFO artifact Checking …"). The final ready/fail summary still prints in both modes.
+   */
+  emitPlain(step) {
+    if (this.tty || this.debug) return;
+    const mark = step.state === "done" ? "done" : step.state === "failed" ? "failed" : step.state === "skipped" ? "skipped" : "\xB7\xB7\xB7";
+    const detail = step.detail ? ` \u2014 ${step.detail}` : "";
+    const line = `fray: ${mark} ${step.label.toLowerCase()}${detail}`;
+    if (line === this.lastPlainLine) return;
+    this.lastPlainLine = line;
+    this.out.write(`${line}
+`);
+  }
+  /** Print a line without disturbing the repaint region (used for the debug feed and warnings). */
+  note(line) {
+    if (this.settled || !this.tty || this.debug) {
+      this.out.write(`${line}
+`);
+      return;
+    }
+    this.out.write(`${SYNC_BEGIN}${this.rewind()}${this.fit(line)}
+${SYNC_END}`);
+    this.painted = 0;
+    this.paint(true);
+  }
+  // ── The final block ──────────────────────────────────────────────────────────────────────────────
+  /**
+   * Replace the boot region with the block that stays on screen, then stop repainting for good.
+   * `entries` are the label/value rows: the URL first, then project, source, log path.
+   */
+  ready(entries, hint) {
+    for (const step of this.steps) if (step.state === "active") this.settle(step.key, "done");
+    const elapsed = formatDuration(this.now() - this.startedAt);
+    this.stop();
+    if (!this.tty || this.debug) {
+      this.out.write(`fray: ready in ${elapsed}
+`);
+      for (const entry of entries) this.out.write(`fray: ${entry.label.toLowerCase()}: ${entry.value}
+`);
+      return;
+    }
+    const width = entries.reduce((max, entry) => Math.max(max, entry.label.length), 0) + 1;
+    const lines = [
+      "",
+      `  ${this.c(`${ANSI.bold}${ANSI.magenta}`, "FRAY")}${this.version ? ` ${this.c(ANSI.dim, `v${this.version}`)}` : ""}  ${this.c(ANSI.dim, `ready in ${elapsed}`)}`,
+      "",
+      // Deliberately NOT truncated. These rows carry an address and a log path the operator has to
+      // be able to copy, and a clipped path is worse than a wrapped one. Truncation exists to stop a
+      // wrap desynchronizing the repaint region — and this is the last paint, so there is no region
+      // left to protect.
+      ...entries.map((entry) => {
+        const arrow = this.c(ANSI.green, "\u279C");
+        const label = this.c(ANSI.bold, `${entry.label}:`.padEnd(width + 1));
+        const value = entry.accent ? this.c(ANSI.cyan, entry.value) : this.c(ANSI.dim, entry.value);
+        return `  ${arrow}  ${label} ${value}`;
+      }),
+      ...hint ? ["", `  ${this.c(ANSI.dim, hint)}`] : [],
+      ""
+    ];
+    const rewind = this.painted > 0 ? `\x1B[${this.painted}A\r\x1B[0J` : "\r\x1B[0J";
+    this.out.write(`${rewind}${lines.join("\n")}
+`);
+    this.painted = 0;
+  }
+  /** Terminal failure: settle the active step as failed, then print the reason and where to look. */
+  fail(message, logPath) {
+    const active = this.activeStep();
+    if (active) this.settle(active.key, "failed");
+    this.stop();
+    if (!this.tty || this.debug) {
+      this.out.write(`fray: failed: ${message}
+`);
+      if (logPath) this.out.write(`fray: log: ${logPath}
+`);
+      return;
+    }
+    const lines = [
+      "",
+      `  ${this.c(ANSI.red, "\u2717")}  ${this.c(ANSI.bold, "Fray could not start")}`,
+      "",
+      // Not truncated, for the same reason as `ready()`: the operator has to be able to read the whole
+      // error and copy the whole path, and nothing repaints after this.
+      ...message.split("\n").map((row) => `     ${this.c(ANSI.red, row)}`),
+      ...logPath ? ["", `     ${this.c(ANSI.dim, `Full log: ${logPath}`)}`] : [],
+      ""
+    ];
+    const rewind = this.painted > 0 ? `\x1B[${this.painted}A\r\x1B[0J` : "\r\x1B[0J";
+    this.out.write(`${rewind}${lines.join("\n")}
+`);
+    this.painted = 0;
+  }
+  /** Stop repainting without printing anything, e.g. before ordinary console output takes over. */
+  stop() {
+    if (this.settled) return;
+    this.settled = true;
+    if (this.timer) clearInterval(this.timer);
+    this.timer = void 0;
+  }
+};
+var SGR = /\x1b\[[0-9;]*m/g;
+function visibleLength(line) {
+  return line.replace(SGR, "").length;
+}
+function sliceVisible(line, limit) {
+  let visible = 0;
+  let out = "";
+  for (let index = 0; index < line.length; ) {
+    SGR.lastIndex = index;
+    const match = /^\x1b\[[0-9;]*m/.exec(line.slice(index));
+    if (match) {
+      out += match[0];
+      index += match[0].length;
+      continue;
+    }
+    if (visible >= limit) break;
+    out += line[index];
+    visible++;
+    index++;
+  }
+  return `${out}${ANSI.reset}`;
+}
+
+// src/production.ts
+init_logging();
 
 // src/launcher.ts
 init_project_identity();
 init_project_launch();
 init_tmux_socket();
 init_boot_progress();
+init_logging();
 init_src();
 import { execFileSync as execFileSync4 } from "node:child_process";
 import { createServer } from "node:net";
-import { mkdirSync as mkdirSync5, readFileSync as readFileSync6, realpathSync as realpathSync3, writeFileSync as writeFileSync5 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { basename as basename3, join as join5, resolve as resolve3 } from "node:path";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync6, realpathSync as realpathSync3, writeFileSync as writeFileSync6 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { basename as basename4, join as join7, resolve as resolve3 } from "node:path";
 import { setTimeout as delay2 } from "node:timers/promises";
 var PORT_SCAN_COUNT = 100;
 var LAUNCH_TIMEOUT_MS = 3e4;
@@ -7274,7 +8259,8 @@ function parseCliArgs(argv) {
     "-h",
     "--dev",
     "--prod",
-    "--port"
+    "--port",
+    "--debug"
   ]);
   for (let index = 0; index < argv.length; index++) {
     const arg = argv[index];
@@ -7299,11 +8285,12 @@ function parseCliArgs(argv) {
     status: args2.has("--status"),
     help: args2.has("--help") || args2.has("-h"),
     dev: args2.has("--dev"),
+    debug: args2.has("--debug"),
     port,
     repoPath
   };
 }
-function resolveWorkspace(cwd = process.cwd(), home = homedir2(), env = process.env) {
+function resolveWorkspace(cwd = process.cwd(), home = homedir4(), env = process.env) {
   let gitRoot;
   try {
     gitRoot = execFileSync4("git", ["rev-parse", "--show-toplevel"], {
@@ -7319,8 +8306,8 @@ function resolveWorkspace(cwd = process.cwd(), home = homedir2(), env = process.
   const identity = resolveGitProjectIdentity(realpathSync3(gitRoot), home);
   const root = identity.root;
   const id = identity.id;
-  const stateDir = join5(home, ".fray", "projects", id);
-  mkdirSync5(stateDir, { recursive: true });
+  const stateDir = join7(home, ".fray", "projects", id);
+  mkdirSync6(stateDir, { recursive: true });
   const target2 = {
     projectId: id,
     projectDir: root,
@@ -7334,7 +8321,7 @@ function resolveWorkspace(cwd = process.cwd(), home = homedir2(), env = process.
     root,
     id,
     stateDir,
-    name: basename3(root),
+    name: basename4(root),
     identityScope: identity.scope,
     tmuxSocket: selected.socket,
     tmuxSocketManaged: selected.managed
@@ -7366,7 +8353,7 @@ function workspaceFromLaunchTarget(target2, env = process.env) {
     root,
     id: target2.projectId,
     stateDir: target2.stateDir,
-    name: basename3(root),
+    name: basename4(root),
     identityScope: target2.identityScope === "worktree" ? "worktree" : "repository",
     tmuxSocket: selected.socket,
     tmuxSocketManaged: selected.managed
@@ -7403,12 +8390,12 @@ function liveWorkspaceOwner(stateDir, expected2, adapter = defaultProcessPlatfor
   if (authoritative && processGenerationIsStale(authoritative, adapter))
     return null;
   return parseStatusFile(
-    join5(stateDir, "dev-supervisor.lock"),
+    join7(stateDir, "dev-supervisor.lock"),
     authoritative,
     expected2,
     adapter
   ) ?? parseStatusFile(
-    join5(stateDir, "server.lock"),
+    join7(stateDir, "server.lock"),
     authoritative,
     expected2,
     adapter
@@ -7417,7 +8404,7 @@ function liveWorkspaceOwner(stateDir, expected2, adapter = defaultProcessPlatfor
 function readPreferredPort(stateDir) {
   try {
     const value = JSON.parse(
-      readFileSync6(join5(stateDir, "launcher.json"), "utf8")
+      readFileSync6(join7(stateDir, "launcher.json"), "utf8")
     );
     return Number.isInteger(value.port) && value.port > 0 && value.port <= 65535 ? value.port : void 0;
   } catch {
@@ -7467,25 +8454,38 @@ async function canBindPort(port) {
   });
   return bind(port);
 }
-async function choosePort(explicit, preferred, available = canBindPort) {
-  if (explicit !== void 0) {
-    if (!await available(explicit))
-      throw new Error(`port ${explicit} is already in use`);
-    return explicit;
-  }
-  const candidates = [
+function portCandidates(preferred) {
+  return [
     preferred,
     ...Array.from(
       { length: PORT_SCAN_COUNT },
       (_, index) => DEFAULT_PORT + index
     )
-  ];
-  for (const port of candidates) {
-    if (port && port <= 65535 && await available(port)) return port;
+  ].filter((port) => !!port && port <= 65535);
+}
+function noFreePortMessage() {
+  return `no free Fray development port found in ${DEFAULT_PORT}-${DEFAULT_PORT + PORT_SCAN_COUNT - 1}`;
+}
+async function allocatePort(explicit, preferred, options2 = {}) {
+  const available = options2.available ?? canBindPort;
+  const reserve = options2.reserve ?? ((port) => tryReservePort(port));
+  const claim = async (port) => {
+    const release = reserve(port);
+    if (!release) return void 0;
+    if (await available(port)) return { port, release };
+    release();
+    return void 0;
+  };
+  if (explicit !== void 0) {
+    const allocated = await claim(explicit);
+    if (!allocated) throw new Error(`port ${explicit} is already in use`);
+    return allocated;
   }
-  throw new Error(
-    `no free Fray development port found in ${DEFAULT_PORT}-${DEFAULT_PORT + PORT_SCAN_COUNT - 1}`
-  );
+  for (const port of portCandidates(preferred)) {
+    const allocated = await claim(port);
+    if (allocated) return allocated;
+  }
+  throw new Error(noFreePortMessage());
 }
 async function waitForWorkspace(port, expected2, timeoutMs = LAUNCH_TIMEOUT_MS, options2 = {}) {
   const started = Date.now();
@@ -7522,9 +8522,9 @@ init_project_launch();
 init_project_launch();
 import { fork } from "node:child_process";
 import { randomUUID as randomUUID5 } from "node:crypto";
-import { existsSync as existsSync2, mkdirSync as mkdirSync6, readFileSync as readFileSync8 } from "node:fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync7, readFileSync as readFileSync8 } from "node:fs";
 import { createServer as createNetServer } from "node:net";
-import { basename as basename4, dirname as dirname5, extname as extname2, isAbsolute as isAbsolute4, relative as relative2, resolve as resolve4, sep as sep2 } from "node:path";
+import { basename as basename5, dirname as dirname5, extname as extname2, isAbsolute as isAbsolute4, relative as relative2, resolve as resolve4, sep as sep3 } from "node:path";
 import { fileURLToPath } from "node:url";
 import watcher from "@parcel/watcher";
 
@@ -7601,14 +8601,20 @@ var RestartSupervisorProxy = class {
       ...ownerTransition ? { state: this.state, ...this.message ? { message: this.message } : {} } : delegated ?? { state: this.state, ...this.message ? { message: this.message } : {} },
       // Never infer this from the generic protocol: legacy/static supervisors can recover a child
       // but cannot build and promote the canonical Fray artifact.
-      updateRestart: typeof this.options.updateRestart === "function"
+      updateRestart: typeof this.options.updateRestart === "function",
+      // Sent ONLY when the launcher can actually answer it, so an older client — and fray-dev, which
+      // has no notion of "already current" — keeps today's behaviour on its absence.
+      ...this.options.updateAvailable ? { updateAvailable: this.options.updateAvailable() === true } : {}
     };
   }
   async runAction(action) {
     if (this.restartInFlight) return this.restartInFlight;
     this.state = "restarting";
     this.message = void 0;
-    const work = action().then(
+    const work = (async () => {
+      await new Promise((resume) => setImmediate(resume));
+      return action();
+    })().then(
       (result) => {
         this.state = result.state;
         this.message = result.message;
@@ -7742,6 +8748,7 @@ var RestartSupervisorProxy = class {
 };
 
 // packages/server/src/dev-supervisor.ts
+init_logging();
 var DEV_RESTART_DEBOUNCE_MS = 180;
 var DEV_CRASH_STABLE_MS = 5e3;
 var DEV_CRASH_RETRY_BASE_MS = 500;
@@ -7777,6 +8784,9 @@ function devCrashRetryDelay(attempt) {
   return Math.min(DEV_CRASH_RETRY_BASE_MS * 2 ** exponent, DEV_CRASH_RETRY_MAX_MS);
 }
 var SUPERVISOR_ESCALATE_GRACE_MS = 500;
+function stripPrefix(line) {
+  return line.startsWith("[fray-ui] ") ? line.slice("[fray-ui] ".length) : line;
+}
 function createSupervisorShutdownHandler(options2) {
   const now = options2.now ?? (() => Date.now());
   const escalateAfterMs = options2.escalateAfterMs ?? SUPERVISOR_ESCALATE_GRACE_MS;
@@ -7824,10 +8834,10 @@ function defaultDevWatchRoots() {
 }
 function isWithin(path, root) {
   const rel = relative2(root, path);
-  return rel === "" || rel !== ".." && !rel.startsWith(`..${sep2}`) && !isAbsolute4(rel);
+  return rel === "" || rel !== ".." && !rel.startsWith(`..${sep3}`) && !isAbsolute4(rel);
 }
 function ignoredDevPath(path) {
-  const parts = resolve4(path).split(sep2);
+  const parts = resolve4(path).split(sep3);
   const name = parts.at(-1) ?? "";
   return parts.some((part) => GENERATED_DIRS.has(part) || part === "fixtures" || part.endsWith(".fixtures")) || /\.(?:test|spec)\.[^.]+$/.test(name) || name.includes(".golden.");
 }
@@ -7836,9 +8846,9 @@ function classifyDevChange(path, roots = defaultDevWatchRoots()) {
   const root = roots.find((candidate) => isWithin(absolute, resolve4(candidate)));
   if (!root) return null;
   if (ignoredDevPath(absolute)) return null;
-  const name = basename4(absolute);
+  const name = basename5(absolute);
   const relToWorkspace = relative2(resolve4(root), absolute);
-  const parts = relToWorkspace.split(sep2);
+  const parts = relToWorkspace.split(sep3);
   const packageName = parts[0] === "packages" ? parts[1] : void 0;
   if (name === "package.json" && parts.length === 3 && packageName && CHILD_PACKAGE_METADATA.has(packageName)) {
     return "child";
@@ -7858,7 +8868,7 @@ function classifyDevChange(path, roots = defaultDevWatchRoots()) {
   return null;
 }
 function devConfigSyntaxError(path) {
-  const name = basename4(path);
+  const name = basename5(path);
   const isTsconfig = /^tsconfig(?:\.[^.]+)?\.json$/.test(name);
   if (name !== "package.json" && !isTsconfig) return null;
   let text;
@@ -7996,8 +9006,8 @@ var Supervisor = class {
     }
     this.supervisorLock = resolve4(opts.launchTarget.stateDir, "dev-supervisor.lock");
     this.ownerToken = opts.launchOwnerToken;
-    this.logLine = opts.log ?? ((line) => console.log(line));
-    this.errorLine = opts.error ?? ((line) => console.error(line));
+    this.logLine = opts.log ?? ((line) => log.info("supervisor", stripPrefix(line)));
+    this.errorLine = opts.error ?? ((line) => log.error("supervisor", stripPrefix(line)));
     this.updateRestart = opts.updateRestart;
     this.rollbackUpdate = opts.rollbackUpdate;
     this.durableReexec = opts.durableReexec;
@@ -8006,6 +9016,7 @@ var Supervisor = class {
       childPort: () => this.childPort,
       restart: () => this.restartFromBrowser(),
       updateRestart: this.updateRestart ? () => this.updateFromBrowser() : void 0,
+      updateAvailable: opts.updateAvailable,
       status: () => {
         if (this.browserRestart || this.restartRunning) return { state: "restarting" };
         const failed = this.child === null && this.boot === null;
@@ -8025,7 +9036,7 @@ var Supervisor = class {
   }
   async start() {
     if (this.supervisorLock) {
-      mkdirSync6(dirname5(this.supervisorLock), { recursive: true });
+      mkdirSync7(dirname5(this.supervisorLock), { recursive: true });
       this.writeStatus("starting", "watcher initializing");
     }
     try {
@@ -8447,7 +9458,7 @@ async function startDevSupervisor(opts) {
 }
 
 // src/production-update.ts
-import { execFile, spawn } from "node:child_process";
+import { execFile as execFile2, spawn as spawn2 } from "node:child_process";
 var PRODUCTION_REEXEC_FLAG = "--_fray-production-reexec";
 function compareReleaseVersions(a, b) {
   const parse = (value) => {
@@ -8496,7 +9507,7 @@ function handoffToRegistrySuccessor(plan, request, adapter) {
 var npmRegistryReleaseAdapter = {
   latestVersion(packageName) {
     return new Promise((resolveVersion, reject) => {
-      execFile("npm", ["view", `${packageName}@latest`, "version", "--json"], { encoding: "utf8" }, (error, stdout) => {
+      execFile2("npm", ["view", `${packageName}@latest`, "version", "--json"], { encoding: "utf8" }, (error, stdout) => {
         if (error) return reject(new Error(`could not check npm for ${packageName}: ${error.message}`));
         try {
           const parsed = JSON.parse(stdout);
@@ -8508,7 +9519,7 @@ var npmRegistryReleaseAdapter = {
     });
   },
   spawnNpmExec({ packageSpec, bin, args: args2, cwd, env }) {
-    return spawn("npm", ["exec", "--yes", `--package=${packageSpec}`, "--", bin, ...args2], {
+    return spawn2("npm", ["exec", "--yes", `--package=${packageSpec}`, "--", bin, ...args2], {
       cwd,
       env,
       detached: true,
@@ -8519,10 +9530,10 @@ var npmRegistryReleaseAdapter = {
 
 // src/preflight.ts
 import { spawnSync } from "node:child_process";
-import { chmodSync, statSync as statSync5 } from "node:fs";
+import { chmodSync, statSync as statSync6 } from "node:fs";
 import { createRequire } from "node:module";
-import { dirname as dirname6, join as join6 } from "node:path";
-var MINIMUM_NODE = { major: 20, minor: 19 };
+import { dirname as dirname6, join as join8 } from "node:path";
+var MINIMUM_NODE = { major: 22, minor: 12 };
 function commandIsAvailable(command) {
   const versionArg = command === "tmux" ? "-V" : "--version";
   const result = spawnSync(command, [versionArg], {
@@ -8549,11 +9560,11 @@ function assertLaunchPrerequisites(options2 = {}) {
 function ensureNativeHelperPermissions(options2 = {}) {
   const platform = options2.platform ?? process.platform;
   if (platform === "win32") return;
-  const stat = options2.stat ?? ((path) => statSync5(path));
+  const stat = options2.stat ?? ((path) => statSync6(path));
   const chmod = options2.chmod ?? ((path, mode) => chmodSync(path, mode));
   const resolvePty = options2.resolvePty ?? (() => createRequire(import.meta.url).resolve("node-pty/package.json"));
   try {
-    const helper = join6(
+    const helper = join8(
       dirname6(resolvePty()),
       "prebuilds",
       `${platform}-${options2.arch ?? process.arch}`,
@@ -8567,9 +9578,16 @@ function ensureNativeHelperPermissions(options2 = {}) {
 }
 
 // src/production.ts
-var ABANDON_GRACE_MS = 3e3;
 var PACKAGE_NAME = process.env.FRAY_REGISTRY_PACKAGE ?? "frayui";
-var PACKAGE_VERSION = process.env.npm_package_version ?? "0.0.1";
+function resolvePackageVersion() {
+  try {
+    const manifest = JSON.parse(readFileSync9(join9(import.meta.dirname, "..", "package.json"), "utf8"));
+    if (typeof manifest.version === "string" && manifest.version.trim()) return manifest.version.trim();
+  } catch {
+  }
+  return process.env.npm_package_version ?? "0.0.1";
+}
+var PACKAGE_VERSION = resolvePackageVersion();
 var rawArgs = process.argv.slice(2);
 var reexec = rawArgs.includes(PRODUCTION_REEXEC_FLAG);
 var args = rawArgs.filter((arg) => arg !== PRODUCTION_REEXEC_FLAG);
@@ -8585,7 +9603,21 @@ var options = (() => {
   }
 })();
 if (options.help) {
-  console.log("Fray production launcher\n\nUsage: npx frayui [options] [repository]\n\nRuns the npm-resolved immutable Fray package. Use fray-dev only for a source checkout.");
+  console.log(
+    `Fray production launcher
+
+Usage: npx ${PACKAGE_NAME} [options] [repository]
+
+Runs the npm-resolved immutable Fray package, then opens it in your default browser. Use fray-dev
+only for a source checkout.
+
+Options:
+  --app                use the legacy dedicated app window instead of a browser tab
+  --no-app             print the URL without opening a browser
+  --port <port>        request a fixed port for a new workspace server
+  --debug              stream the full event feed to the terminal instead of the compact readout
+  -h, --help           show this help`
+  );
   process.exit(0);
 }
 if (options.dev || rawArgs.includes("--prod")) fail("--dev and --prod are not available from the registry launcher");
@@ -8602,59 +9634,94 @@ var workspace = (() => {
   }
 })();
 process.chdir(workspace.root);
+var logger = setAmbientLogger(
+  process.env.FRAY_LOG_FILE ? createLogger({ file: process.env.FRAY_LOG_FILE, owner: false }) : createLogger({ file: runLogPath(workspace.stateDir) })
+);
+var readout = reexec || process.env.FRAY_PRODUCTION_SUPERVISOR === "1" ? void 0 : new Readout({ debug: options.debug, version: PACKAGE_VERSION });
+attachTerminalMirror(logger, options.debug || process.env.FRAY_DEBUG === "1");
+readout?.plan([
+  { key: "server", label: "Server" },
+  { key: "browser", label: options.noApp ? "Address" : "Browser" }
+]);
+readout?.begin("server", "starting");
+logger.info("launcher", `frayui ${PACKAGE_VERSION} starting for ${workspace.root}`);
 var target = workspaceLaunchTarget(workspace);
 var expected = expectedOwnerHealth(target, readProjectLaunchOwner(workspace.stateDir));
-async function abandonLaunchedChild(pid, port) {
-  if (!pid) return;
-  const signalGroup = (signal) => {
-    try {
-      process.kill(-pid, signal);
-      return true;
-    } catch {
-    }
-    try {
-      process.kill(pid, signal);
-      return true;
-    } catch {
-      return false;
-    }
-  };
-  if (!signalGroup("SIGTERM")) return;
-  const deadline = Date.now() + ABANDON_GRACE_MS;
-  while (Date.now() < deadline) {
-    if (!pidIsAlive(pid)) return;
-    await delay3(100);
-  }
-  signalGroup("SIGKILL");
-  await delay3(200);
-  if (pidIsAlive(pid)) {
-    console.error(
-      `fray: could not stop the abandoned Fray supervisor (pid ${pid}, port ${port}); stop it manually before retrying`
-    );
-  }
-}
 async function existingPort() {
   const owner = liveWorkspaceOwner(workspace.stateDir, target);
   const ports = [owner?.port, readPreferredPort(workspace.stateDir)].filter((value) => !!value);
   for (const port of new Set(ports)) if (await probeFray(port, expected)) return port;
   return void 0;
 }
-function openOrPrint(port, reused) {
+async function openOrPrint(port, reused) {
   const url = `http://127.0.0.1:${port}`;
-  console.log(`${reused ? "reusing" : "started"} Fray ${PACKAGE_VERSION} for ${workspace.root}`);
-  console.log(url);
+  logger.info("launcher", `${reused ? "reusing" : "started"} Fray at ${url}`);
+  readout?.settle("server", "done", `port ${port}`);
+  let browser;
+  if (!options.noApp) {
+    readout?.begin("browser", options.appMode ? "requesting app window" : "requesting default browser");
+    try {
+      if (options.appMode) {
+        await launchApp(url, { dataPath: join9(workspace.stateDir, "browser-profile") });
+        browser = reused ? "focused the Fray app window" : "opened the Fray app window";
+      } else {
+        await launchBrowserTab(url);
+        browser = "opened in your default browser";
+      }
+      logger.info("launcher", browser);
+    } catch (error) {
+      browser = `could not open the ${options.appMode ? "app window" : "default browser"} \u2014 open the address above`;
+      logger.warn("launcher", `${browser}: ${error instanceof Error ? error.message : error}`);
+    }
+    readout?.settle("browser", "done", browser);
+  } else {
+    readout?.settle("browser", "done", url);
+  }
+  if (!readout) {
+    console.log(`${reused ? "reusing" : "started"} Fray ${PACKAGE_VERSION} for ${workspace.root}`);
+    console.log(url);
+    return;
+  }
+  const home = homedir5();
+  readout.ready(
+    [
+      { label: "Local", value: `${url}/`, accent: true },
+      { label: "Project", value: `${workspace.name} \u2014 ${tildePath(workspace.root, home)}` },
+      ...logger.file ? [{ label: "Logs", value: tildePath(logger.file, home) }] : []
+    ],
+    options.debug ? void 0 : "press ctrl-c to stop \xB7 run with --debug for the full event feed"
+  );
 }
 async function runSupervisor(port, token) {
   assertLaunchPrerequisites();
   ensureNativeHelperPermissions();
   const owner = adoptProjectLaunchOwner(target, token, "supervisor");
-  const env = projectLaunchEnvironment({ ...process.env, FRAY_PRODUCTION_SUPERVISOR: "1" }, target, owner.token);
-  const webDist = join7(import.meta.dirname, "..", "web-dist");
-  const runtimeDir = join7(import.meta.dirname, "..", "runtime");
-  const scriptsDir = join7(runtimeDir, "board");
-  const workerPluginDir = join7(runtimeDir, "cc-worker");
+  const env = projectLaunchEnvironment(
+    {
+      ...process.env,
+      FRAY_PRODUCTION_SUPERVISOR: "1",
+      ...logEnvironment(logger, options.debug ? "debug" : "info"),
+      ...options.debug ? { FRAY_DEBUG: "1" } : {}
+    },
+    target,
+    owner.token
+  );
+  const webDist = join9(import.meta.dirname, "..", "web-dist");
+  const runtimeDir = join9(import.meta.dirname, "..", "runtime");
+  const scriptsDir = join9(runtimeDir, "board");
+  const workerPluginDir = join9(runtimeDir, "cc-worker");
   const childEntry = fileURLToPath2(new URL("./dev-child.js", import.meta.url));
   let plannedUpdate;
+  let updateAvailable = true;
+  const refreshUpdateAvailable = async () => {
+    try {
+      updateAvailable = await planRegistryUpdate(PACKAGE_NAME, PACKAGE_VERSION, npmRegistryReleaseAdapter) !== null;
+    } catch {
+    }
+  };
+  void refreshUpdateAvailable();
+  const updateAvailablePoll = setInterval(() => void refreshUpdateAvailable(), 30 * 60 * 1e3);
+  updateAvailablePoll.unref();
   const supervisor = await startDevSupervisor({
     port,
     cwd: workspace.root,
@@ -8665,10 +9732,14 @@ async function runSupervisor(port, token) {
     watch: false,
     childEntry,
     childEnvironment: () => ({ FRAY_STABLE_WEB_DIST: webDist, FRAY_STABLE_ARTIFACT: `npm:${PACKAGE_NAME}@${PACKAGE_VERSION}`, FRAY_SCRIPTS_DIR: scriptsDir, FRAY_WORKER_PLUGIN_DIR: workerPluginDir }),
+    updateAvailable: () => updateAvailable,
     updateRestart: async () => {
       try {
         const plan = await planRegistryUpdate(PACKAGE_NAME, PACKAGE_VERSION, npmRegistryReleaseAdapter);
-        if (!plan) return { state: "failed", message: `Fray ${PACKAGE_VERSION} is already current` };
+        if (!plan) {
+          updateAvailable = false;
+          return { state: "failed", message: `Fray ${PACKAGE_VERSION} is already current` };
+        }
         plannedUpdate = plan;
         return { state: "ready", message: `Fray ${plan.latestVersion} will start in a new npm execution cache` };
       } catch (error) {
@@ -8682,7 +9753,27 @@ async function runSupervisor(port, token) {
       process.exit(0);
     }
   });
-  const stop = createSupervisorShutdownHandler({ close: () => supervisor.close(), force: () => supervisor.forceStop(), release: () => owner.release(), exit: (code) => process.exit(code), error: (line) => console.error(line) });
+  const stop = createSupervisorShutdownHandler({
+    close: () => supervisor.close(),
+    force: () => supervisor.forceStop(),
+    release: () => owner.release(),
+    exit: (code) => {
+      logger.info("launcher", `stopped with code ${code}`);
+      const suffix = logger.file ? `
+  log: ${tildePath(logger.file, homedir5())}` : "";
+      process.stdout.write(
+        code === 0 ? `
+  Fray stopped. Agent sessions in tmux keep running.${suffix}
+
+` : `
+  Fray stopped with errors (exit ${code}).${suffix}
+
+`
+      );
+      process.exit(code);
+    },
+    error: (line) => logger.error("supervisor", line.startsWith("[fray-ui] ") ? line.slice(10) : line)
+  });
   process.on("SIGINT", stop);
   process.on("SIGTERM", stop);
   void supervisor.stopRequested.then(stop);
@@ -8699,40 +9790,47 @@ try {
   }
   const existing = await existingPort();
   if (existing) {
-    openOrPrint(existing, true);
+    await openOrPrint(existing, true);
     process.exit(0);
   }
   const claim = tryAcquireProjectLaunchOwner(target, "launcher");
   if (claim.kind !== "acquired") throw new Error("Fray is starting for this project; retry shortly");
-  const release = await acquireGlobalLaunchLock();
+  let release = await acquireGlobalLaunchLock();
+  let portReservation;
   try {
-    const port = await choosePort(options.port, readPreferredPort(workspace.stateDir));
-    if (options.foreground) await runSupervisor(port, claim.lease.token);
-    const log = openSync4(join7(workspace.stateDir, "fray.log"), "a");
-    const child = spawn2(process.execPath, [process.argv[1], "--foreground", "--no-app", "--port", String(port)], {
-      cwd: workspace.root,
-      detached: true,
-      env: projectLaunchEnvironment({ ...process.env, FRAY_PRODUCTION_SUPERVISOR: "1" }, target, claim.lease.token),
-      stdio: ["ignore", log, log]
-    });
-    child.unref();
-    closeSync4(log);
-    try {
-      await waitForWorkspace(
+    const allocation = await allocatePort(options.port, readPreferredPort(workspace.stateDir));
+    const port = allocation.port;
+    portReservation = allocation.release;
+    const running = runSupervisor(port, claim.lease.token);
+    release();
+    release = void 0;
+    await Promise.race([
+      waitForWorkspace(
         port,
         expectedOwnerHealth(target, readProjectLaunchOwner(workspace.stateDir)),
         void 0,
         { stateDir: workspace.stateDir }
-      );
-    } catch (error) {
-      await abandonLaunchedChild(child.pid, port);
-      throw error;
-    }
-    openOrPrint(port, false);
+      ),
+      running
+    ]);
+    portReservation();
+    portReservation = void 0;
+    await openOrPrint(port, false);
+    await running;
   } finally {
-    release();
+    release?.();
+    portReservation?.();
     claim.lease.release();
   }
 } catch (error) {
+  logger.error("launcher", `startup failed: ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+  if (readout) {
+    const where = readout.activeStep();
+    readout.fail(
+      `${where ? `${where.label.toLowerCase()}: ` : ""}${error instanceof Error ? error.message : String(error)}`,
+      logger.file ?? void 0
+    );
+    process.exit(1);
+  }
   fail(error);
 }