frizz 0.7.7 → 0.8.0

package/dist/frizz.js

@@ -140,52 +140,9 @@ function isTrustedLocalHttpRequest(headers, expectedPort, allowMissingOrigin = f
 function allowedLocalCorsOrigin(origin, expectedPort, policy) {
   return parseLocalHttpOrigin(origin, expectedPort, policy) ? origin : void 0;
 }
-function normalizeBindHost(value) {
-  const trimmed = value.trim();
-  if (!trimmed) throw new Error("--host requires an address");
-  const bare = trimmed.startsWith("[") && trimmed.endsWith("]") ? trimmed.slice(1, -1) : trimmed;
-  const lower = bare.toLowerCase();
-  if (lower === "localhost") return LOOPBACK_BIND_HOST;
-  if (isIP(bare) === 0) {
-    throw new Error(`invalid --host address: ${value} (use an IP address such as 0.0.0.0, :: or 127.0.0.1)`);
-  }
-  return bare;
-}
 function bindHostIsExposed(host) {
   return !LOOPBACK_BIND_HOSTS.has(host.trim().toLowerCase());
 }
-function normalizePublicOrigin(value) {
-  const trimmed = value.trim();
-  const invalid = (why) => new Error(`invalid --public-origin: ${value} (${why})`);
-  if (!trimmed) throw new Error("--public-origin requires a URL");
-  let url;
-  try {
-    url = new URL(trimmed);
-  } catch {
-    throw invalid("use a full URL such as https://frizz.example.com");
-  }
-  if (url.protocol !== "https:" && url.protocol !== "http:") throw invalid("only http and https are supported");
-  if (url.username || url.password) throw invalid("an origin carries no credentials");
-  if (url.pathname !== "/" || url.search || url.hash) throw invalid("an origin is a scheme and host only, with no path");
-  if (!url.hostname) throw invalid("no hostname");
-  return url.origin;
-}
-function machineHostNames(hostname) {
-  const full = hostname.trim().toLowerCase().replace(/\.$/, "");
-  if (!full || full === "localhost" || isIP(full) !== 0) return [];
-  const short = full.split(".")[0];
-  return [.../* @__PURE__ */ new Set([full, short, `${short}.local`])].filter((name) => name !== "localhost" && name !== "localhost.local");
-}
-function normalizeAllowedHosts(values) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const value of values) {
-    for (const entry of value.split(",")) {
-      const host = entry.trim().toLowerCase();
-      if (host) seen.add(host);
-    }
-  }
-  return [...seen];
-}
 function rejectWebSocketUpgrade(socket, status = 403, reason = "Forbidden") {
   const body = `${reason}
 `;
@@ -206,7 +163,7 @@ function rejectWebSocketUpgrade(socket, status = 403, reason = "Forbidden") {
     }
   }
 }
-var LOCAL_HOSTNAMES, FORWARDED_HEADERS, LOOPBACK_BIND_HOST, ALL_INTERFACES_BIND_HOST, LOOPBACK_BIND_HOSTS;
+var LOCAL_HOSTNAMES, FORWARDED_HEADERS, LOOPBACK_BIND_HOST, LOOPBACK_BIND_HOSTS;
 var init_local_origin = __esm({
   "packages/server/src/local-origin.ts"() {
     "use strict";
@@ -219,7 +176,6 @@ var init_local_origin = __esm({
       "x-forwarded-proto"
     ];
     LOOPBACK_BIND_HOST = "127.0.0.1";
-    ALL_INTERFACES_BIND_HOST = "0.0.0.0";
     LOOPBACK_BIND_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "::1", "localhost", "[::1]"]);
   }
 });
@@ -12747,7 +12703,7 @@ var init_src = __esm({
       questions: external_exports.array(AskQuestion)
     });
     AwaitingHint = external_exports.object({
-      kind: external_exports.enum(["shell", "agent", "timer", "pr", "for"]),
+      kind: external_exports.enum(["shell", "agent", "timer", "pr", "for", "title"]),
       value: external_exports.string()
     });
     RETIRED_AWAITING_KINDS = ["watch", "pr-watch", "human", "ci", "session", "shell", "agent", "timer", "pr", "reason"];
@@ -13324,6 +13280,14 @@ var init_src = __esm({
       // Default action for a vetted non-image local path in agent markdown. Image clicks always use the
       // OS default viewer so screenshots retain their expected behavior.
       localFileOpener: LocalFileOpener.optional(),
+      // The token count at which a NEW Claude worker auto-compacts its conversation. Frizz requests the
+      // 1M context window on every dispatch (resolveClaudeLaunchModel), so without this a worker grows
+      // toward 1M before it ever compacts — and every turn past 200K re-sends up to 5x the conversation a
+      // 200K TUI session would, which is the single largest reason a Frizz thread spends quota faster than
+      // the TUI (measured 2026-08-26). Reaches the worker as CLAUDE_CODE_AUTO_COMPACT_WINDOW, which Claude
+      // Code caps to the model's real window. Optional so an old blob parses; defaultSettings pins 500_000
+      // (maintainer 2026-08-26: "a default compaction window of 500k by default").
+      autoCompactWindow: external_exports.number().int().positive().optional(),
       // The GitHub batch-dispatch prompt template (the picker's per-item worker prompt). Optional: when
       // unset OR blank the server falls back to its exported DEFAULT_GITHUB_PROMPT. Substitution tokens
       // the server fills: {repo} {n} {title} {url} {labels} {body}. The leading `THREAD: <slug>` tag is
@@ -17842,9 +17806,9 @@ var init_wrapper = __esm({
 
 // packages/server/src/frizz-paths.ts
 import { existsSync as existsSync2 } from "node:fs";
-import { homedir as homedir4, tmpdir } from "node:os";
+import { homedir as homedir5, tmpdir } from "node:os";
 import { dirname as dirname4, join as join5 } from "node:path";
-function legacyFrizzRoot(home = homedir4()) {
+function legacyFrizzRoot(home = homedir5()) {
   return join5(home, LEGACY_DIR_NAME);
 }
 function xdg(env, name) {
@@ -17886,7 +17850,7 @@ function xdgRoots(env, home) {
 function frizzPaths(options2 = {}) {
   const env = options2.env ?? process.env;
   const platform = options2.platform ?? process.platform;
-  const home = options2.home ?? homedir4();
+  const home = options2.home ?? homedir5();
   const exists = options2.exists ?? existsSync2;
   const legacyRoot = legacyFrizzRoot(home);
   if (exists(legacyRoot)) {
@@ -17925,22 +17889,22 @@ import {
   mkdirSync as mkdirSync4,
   openSync,
   readdirSync,
-  rmSync,
+  rmSync as rmSync2,
   statSync as statSync2,
   symlinkSync,
   writeFileSync as writeFileSync4,
   writeSync
 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
+import { homedir as homedir6 } from "node:os";
 import { join as join6 } from "node:path";
-function defaultLogRoot(stateDir, home = homedir5()) {
+function defaultLogRoot(stateDir, home = homedir6()) {
   return stateDir ? join6(stateDir, "logs") : join6(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);
@@ -17952,7 +17916,7 @@ function latestLogPath(dir) {
 function linkLatest(dir, target2) {
   const link = latestLogPath(dir);
   try {
-    rmSync(link, { force: true });
+    rmSync2(link, { force: true });
     symlinkSync(target2, link);
   } catch {
     try {
@@ -17980,7 +17944,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 {
-      rmSync(join6(dir, entry.name), { force: true });
+      rmSync2(join6(dir, entry.name), { force: true });
     } catch {
     }
   }
@@ -18252,11 +18216,11 @@ import {
   readFileSync as readFileSync6,
   realpathSync as realpathSync2,
   renameSync,
-  rmSync as rmSync2,
+  rmSync as rmSync3,
   statSync as statSync3,
   writeFileSync as writeFileSync5
 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
+import { homedir as homedir7 } from "node:os";
 import { dirname as dirname5, join as join8, resolve } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 function errorCode2(error) {
@@ -18272,7 +18236,7 @@ function canonicalHome(home) {
     return resolve(home);
   }
 }
-function globalLaunchLockPath(home = homedir6()) {
+function globalLaunchLockPath(home = homedir7()) {
   return join8(frizzPaths({ home: canonicalHome(home) }).state, GLOBAL_LOCK_NAME);
 }
 function namedLaunchLockPath(home, name) {
@@ -18356,7 +18320,7 @@ function quarantineLock(lockPath) {
     return false;
   }
   try {
-    rmSync2(quarantine2, { recursive: true, force: true });
+    rmSync3(quarantine2, { recursive: true, force: true });
   } catch {
   }
   return true;
@@ -18402,7 +18366,7 @@ function tryAcquireLock(lockPath, adapter) {
     const quarantine2 = `${lockPath}.release-${process.pid}-${owner.token}`;
     try {
       renameSync(lockPath, quarantine2);
-      rmSync2(quarantine2, { recursive: true, force: true });
+      rmSync3(quarantine2, { recursive: true, force: true });
     } catch {
     }
   };
@@ -18410,10 +18374,10 @@ function tryAcquireLock(lockPath, adapter) {
 function tryAcquireGlobalLaunchLock(home, adapter) {
   return tryAcquireLock(globalLaunchLockPath(home), adapter);
 }
-function portReservationPath(port, home = homedir6()) {
+function portReservationPath(port, home = homedir7()) {
   return join8(frizzPaths({ home: canonicalHome(home) }).state, PORT_LOCK_DIR, `${port}.lock`);
 }
-function tryReservePort(port, home = homedir6(), adapter = defaultProcessPlatformAdapter) {
+function tryReservePort(port, home = homedir7(), adapter = defaultProcessPlatformAdapter) {
   const lockPath = portReservationPath(port, home);
   const release = tryAcquireLock(lockPath, adapter);
   if (release) return release;
@@ -18426,7 +18390,7 @@ function lockTimeoutError(observation) {
     observation.ownerPid === void 0 ? "another Frizz launch still owns the global launch lock" : `another Frizz launch (pid ${observation.ownerPid}) still owns the global launch lock`
   );
 }
-async function acquireGlobalLaunchLock(home = homedir6(), timeoutMs = 1e4, adapter = defaultProcessPlatformAdapter) {
+async function acquireGlobalLaunchLock(home = homedir7(), timeoutMs = 1e4, adapter = defaultProcessPlatformAdapter) {
   const deadline = Date.now() + Math.max(0, timeoutMs);
   let observation = { stale: false };
   for (; ; ) {
@@ -18594,7 +18558,7 @@ function resolvedIdentity(worktree) {
   }
   return { ...worktree, id: worktreeId };
 }
-function resolveGitProjectIdentity(dir, home = homedir6()) {
+function resolveGitProjectIdentity(dir, home = homedir7()) {
   let worktree = resolveGitWorktree(dir);
   const existing = resolvedIdentity(worktree);
   if (existing) return existing;
@@ -18668,7 +18632,7 @@ import {
   openSync as openSync3,
   readFileSync as readFileSync7,
   renameSync as renameSync2,
-  rmSync as rmSync3,
+  rmSync as rmSync4,
   statSync as statSync4,
   writeFileSync as writeFileSync6
 } from "node:fs";
@@ -18715,7 +18679,7 @@ function atomicJson(path, value) {
       }
     }
     try {
-      rmSync3(temp, { force: true });
+      rmSync4(temp, { force: true });
     } catch {
     }
     throw error;
@@ -18729,7 +18693,7 @@ function quarantine(path, suffix) {
     return false;
   }
   try {
-    rmSync3(moved, { recursive: true, force: true });
+    rmSync4(moved, { recursive: true, force: true });
   } catch {
   }
   return true;
@@ -19116,7 +19080,7 @@ var init_project_launch = __esm({
 });
 
 // packages/server/src/boot-progress.ts
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync8, renameSync as renameSync3, rmSync as rmSync4, writeFileSync as writeFileSync7 } from "node:fs";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync8, renameSync as renameSync3, rmSync as rmSync5, writeFileSync as writeFileSync7 } from "node:fs";
 import { basename as basename3, dirname as dirname7, join as join10 } from "node:path";
 function bootProgressPath(stateDir) {
   return join10(stateDir, BOOT_PROGRESS_NAME);
@@ -19140,8 +19104,8 @@ var init_boot_progress = __esm({
 
 // packages/server/src/project-root.ts
 import { createHash as createHash3, randomUUID as randomUUID4 } from "node:crypto";
-import { closeSync as closeSync3, existsSync as existsSync3, fsyncSync as fsyncSync3, mkdirSync as mkdirSync8, openSync as openSync4, readFileSync as readFileSync9, realpathSync as realpathSync3, renameSync as renameSync4, rmSync as rmSync5, writeFileSync as writeFileSync8 } from "node:fs";
-import { homedir as homedir7 } from "node:os";
+import { closeSync as closeSync3, existsSync as existsSync3, fsyncSync as fsyncSync3, mkdirSync as mkdirSync8, openSync as openSync4, readFileSync as readFileSync9, realpathSync as realpathSync3, renameSync as renameSync4, rmSync as rmSync6, writeFileSync as writeFileSync8 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
 import { dirname as dirname8, join as join11, parse, resolve as resolve2 } from "node:path";
 function projectIdPath(root) {
   return join11(root, FRIZZ_DIR, ID_FILE);
@@ -19188,7 +19152,7 @@ function writeProjectIdFile(root, id) {
       }
     }
     try {
-      rmSync5(temp, { force: true });
+      rmSync6(temp, { force: true });
     } catch {
     }
     throw error;
@@ -19198,7 +19162,7 @@ function writeProjectIdFile(root, id) {
 function projectRootLockName(root) {
   return `identity-path-${createHash3("sha256").update(root).digest("hex")}.lock`;
 }
-function ensureProjectIdFile(root, home = homedir7(), seed) {
+function ensureProjectIdFile(root, home = homedir8(), seed) {
   const existing = readProjectIdFile(root);
   if (existing) return existing;
   const release = acquireNamedLaunchLockSync(home, projectRootLockName(root));
@@ -19220,7 +19184,7 @@ function isNotAGitWorktree(error) {
 function hasAny(dir, names) {
   return names.some((name) => existsSync3(join11(dir, name)));
 }
-function isHomeDirectory(dir, home = homedir7()) {
+function isHomeDirectory(dir, home = homedir8()) {
   const canonical = (value) => {
     try {
       return realpathSync3(resolve2(value));
@@ -19249,7 +19213,7 @@ function isExistingProjectRoot(dir) {
 function hasProjectMarker(dir) {
   return hasAny(dir, REPO_MARKERS) || hasAny(dir, PROJECT_MARKERS);
 }
-function discoverProjectRoot(cwd = process.cwd(), home = homedir7()) {
+function discoverProjectRoot(cwd = process.cwd(), home = homedir8()) {
   let dir;
   try {
     dir = resolve2(cwd);
@@ -19293,13 +19257,13 @@ var init_project_root = __esm({
 });
 
 // packages/server/src/project-registry.ts
-import { closeSync as closeSync4, existsSync as existsSync4, fsyncSync as fsyncSync4, mkdirSync as mkdirSync9, openSync as openSync5, readFileSync as readFileSync10, readdirSync as readdirSync2, realpathSync as realpathSync4, renameSync as renameSync5, rmSync as rmSync6, writeFileSync as writeFileSync9 } from "node:fs";
-import { homedir as homedir8 } from "node:os";
+import { closeSync as closeSync4, existsSync as existsSync4, fsyncSync as fsyncSync4, mkdirSync as mkdirSync9, openSync as openSync5, readFileSync as readFileSync10, readdirSync as readdirSync2, realpathSync as realpathSync4, renameSync as renameSync5, rmSync as rmSync7, writeFileSync as writeFileSync9 } from "node:fs";
+import { homedir as homedir9 } from "node:os";
 import { basename as basename4, dirname as dirname9, join as join12 } from "node:path";
-function registryPath(home = homedir8()) {
+function registryPath(home = homedir9()) {
   return join12(frizzPaths({ home }).data, "registry.json");
 }
-function readRegistry(home = homedir8()) {
+function readRegistry(home = homedir9()) {
   let raw;
   try {
     raw = readFileSync10(registryPath(home), "utf8");
@@ -19319,7 +19283,7 @@ function readRegistry(home = homedir8()) {
     return { ...EMPTY, projects: [] };
   }
 }
-function writeRegistry(registry, home = homedir8()) {
+function writeRegistry(registry, home = homedir9()) {
   const path = registryPath(home);
   mkdirSync9(dirname9(path), { recursive: true });
   const temp = `${path}.${process.pid}.tmp`;
@@ -19340,7 +19304,7 @@ function writeRegistry(registry, home = homedir8()) {
       }
     }
     try {
-      rmSync6(temp, { force: true });
+      rmSync7(temp, { force: true });
     } catch {
     }
     throw error;
@@ -19375,7 +19339,7 @@ function canonicalPath(dir) {
     return dir;
   }
 }
-function registerProject(input, home = homedir8()) {
+function registerProject(input, home = homedir9()) {
   input = { ...input, dir: canonicalPath(input.dir) };
   const registry = readRegistry(home);
   const at = (input.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
@@ -19410,7 +19374,7 @@ function registerProject(input, home = homedir8()) {
   writeRegistry(registry, home);
   return { entry, action: "created" };
 }
-function listProjects(home = homedir8()) {
+function listProjects(home = homedir9()) {
   const byRecency = (a, b) => a.lastOpenedAt < b.lastOpenedAt ? 1 : a.lastOpenedAt > b.lastOpenedAt ? -1 : 0;
   return readRegistry(home).projects.map((p) => ({ ...p, stale: !existsSync4(p.path) })).sort((a, b) => {
     if (a.order === void 0 && b.order === void 0) return byRecency(a, b);
@@ -19419,7 +19383,7 @@ function listProjects(home = homedir8()) {
     return a.order - b.order;
   });
 }
-function findByPath(path, home = homedir8()) {
+function findByPath(path, home = homedir9()) {
   const canonical = canonicalPath(path);
   return readRegistry(home).projects.find((p) => p.path === canonical || p.path === path);
 }
@@ -19475,7 +19439,7 @@ var init_project_registry = __esm({
 // src/production.ts
 init_local_origin();
 import { readFileSync as readFileSync13 } from "node:fs";
-import { homedir as homedir10 } from "node:os";
+import { homedir as homedir11 } from "node:os";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { join as join15 } from "node:path";
 
@@ -19723,7 +19687,7 @@ function openCdpSession(browserPath, dataPath) {
   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 call2 = (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");
@@ -19735,7 +19699,7 @@ function openCdpSession(browserPath, dataPath) {
     }, timeoutMs).unref();
   });
   const close = async () => {
-    await call("Browser.close").catch(() => {
+    await call2("Browser.close").catch(() => {
     });
     if (child.exitCode !== null || child.signalCode !== null) return;
     await new Promise((resolve5) => {
@@ -19750,7 +19714,7 @@ function openCdpSession(browserPath, dataPath) {
       });
     });
   };
-  return { call, close, kill: () => child.kill() };
+  return { call: call2, close, kill: () => child.kill() };
 }
 async function cdpInstallPwa(browserPath, url, dataPath) {
   const manifestId = manifestIdFor(url);
@@ -19935,8 +19899,41 @@ import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join as join2 } from "node:path";
 var CODE_BYTES = 16;
 var SESSION_BYTES = 32;
+var SESSION_ID_BYTES = 6;
 var DEFAULT_CODE_TTL_MS = 5 * 6e4;
 var DEFAULT_SESSION_TTL_MS = 365 * 24 * 60 * 6e4;
+function memorySessionDirectory(seed = []) {
+  const records = new Map(seed.map((r) => [r.id, r]));
+  return {
+    record: (r) => void records.set(r.id, r),
+    isRevoked: (id) => records.get(id)?.revokedAt !== void 0,
+    // Reverse FIRST, then sort. Array.sort is stable, so two devices that redeemed in the same
+    // millisecond — which two taps on one page reliably are — keep newest-inserted-first instead of
+    // falling back to insertion order and reading as oldest first.
+    list: () => [...records.values()].reverse().sort((a, b) => b.createdAt - a.createdAt),
+    revoke(id) {
+      const found = records.get(id);
+      if (!found || found.revokedAt !== void 0) return false;
+      found.revokedAt = Date.now();
+      return true;
+    },
+    revokeAll() {
+      let n = 0;
+      for (const r of records.values()) if (r.revokedAt === void 0) {
+        r.revokedAt = Date.now();
+        n++;
+      }
+      return n;
+    }
+  };
+}
+function describeDevice(userAgent) {
+  const ua = userAgent ?? "";
+  if (!ua.trim()) return "unknown device";
+  const os = /iPhone/i.test(ua) ? "iPhone" : /iPad/i.test(ua) ? "iPad" : /Android/i.test(ua) ? "Android" : /Mac OS X|Macintosh/i.test(ua) ? "macOS" : /Windows/i.test(ua) ? "Windows" : /Linux/i.test(ua) ? "Linux" : "unknown device";
+  const browser = /Edg\//i.test(ua) ? "Edge" : /OPR\/|Opera/i.test(ua) ? "Opera" : /Firefox\//i.test(ua) ? "Firefox" : /Chrome\//i.test(ua) ? "Chrome" : /Safari\//i.test(ua) ? "Safari" : "";
+  return browser ? `${browser} on ${os}` : os;
+}
 function defaultRandomToken(bytes) {
   return randomBytes(bytes).toString("base64url");
 }
@@ -19945,13 +19942,15 @@ function secretsMatch(a, b) {
   const right = Buffer.from(b);
   return left.length === right.length && timingSafeEqual(left, right);
 }
-var AccessStore = class {
+var AccessStore = class _AccessStore {
   codes = /* @__PURE__ */ new Map();
   options;
+  sessions;
   /** Signing key for sessions. Persisted by the caller; a fresh one signs every device out. */
   signingKey;
   constructor(options2 = {}) {
     this.signingKey = options2.signingKey ?? randomBytes(32);
+    this.sessions = options2.sessions ?? memorySessionDirectory();
     this.options = {
       codeTtlMs: options2.codeTtlMs ?? DEFAULT_CODE_TTL_MS,
       sessionTtlMs: options2.sessionTtlMs ?? DEFAULT_SESSION_TTL_MS,
@@ -19980,7 +19979,7 @@ var AccessStore = class {
    * atomicity is what makes "single-use" true rather than aspirational — it is the first thing the
    * tests attack.
    */
-  redeem(code) {
+  redeem(code, device) {
     if (!code) return { ok: false, reason: "unknown" };
     const stored = this.codes.get(code);
     if (!stored || !secretsMatch(stored.code, code)) return { ok: false, reason: "unknown" };
@@ -19993,18 +19992,32 @@ var AccessStore = class {
     stored.consumedAt = now;
     this.sweep();
     this.options.onConsumed?.(code);
-    return { ok: true, session: this.mintSession(now), expiresAt: now + this.options.sessionTtlMs };
+    const minted = this.mintSession(now);
+    this.sessions.record({ id: minted.id, label: device ?? "unknown device", createdAt: now });
+    return { ok: true, session: minted.session, expiresAt: now + this.options.sessionTtlMs, id: minted.id };
   }
   /**
-   * A session is `<expiry>.<hmac>` — stateless, so it needs no server-side table, and signed with a key
-   * the caller persists so it survives a restart. Self-describing expiry means a stale cookie is
-   * rejected without a lookup, and rotating the key revokes every outstanding session at once.
+   * A session is `<expiry>.<id>.<nonce>.<hmac>` — signed with a key the caller persists so it survives
+   * a restart, and self-describing enough that a stale cookie is rejected without any lookup.
+   *
+   * The `id` is what makes ONE device signable-out. It is short because an operator types it into
+   * `frizz --sign-out <id>`, and it is inside the signed payload so it cannot be swapped for another
+   * device's. Rotating the key still revokes everything at once; this is the scalpel beside that axe.
+   *
+   * A session minted before ids existed has a two-part payload and still verifies — it simply has no id
+   * to revoke individually. Upgrading must not sign every device out.
    */
   mintSession(now) {
     const expiresAt = now + this.options.sessionTtlMs;
+    const id = this.options.randomToken(SESSION_ID_BYTES);
     const nonce = this.options.randomToken(SESSION_BYTES);
-    const payload = `${expiresAt}.${nonce}`;
-    return `${payload}.${this.sign(payload)}`;
+    const payload = `${expiresAt}.${id}.${nonce}`;
+    return { session: `${payload}.${this.sign(payload)}`, id };
+  }
+  /** The id inside a session payload, or null for a legacy two-part one. */
+  static idOf(payload) {
+    const parts = payload.split(".");
+    return parts.length >= 3 ? parts[1] ?? null : null;
   }
   sign(payload) {
     return createHmac("sha256", this.signingKey).update(payload).digest("base64url");
@@ -20018,7 +20031,9 @@ var AccessStore = class {
     const signature = session.slice(cut + 1);
     if (!secretsMatch(signature, this.sign(payload))) return false;
     const expiresAt = Number(payload.slice(0, payload.indexOf(".")));
-    return Number.isFinite(expiresAt) && this.options.now() < expiresAt;
+    if (!Number.isFinite(expiresAt) || this.options.now() >= expiresAt) return false;
+    const id = _AccessStore.idOf(payload);
+    return !(id && this.sessions.isRevoked(id));
   }
   /**
    * Drop codes past their expiry so a long-lived board does not accumulate them forever.
@@ -20040,6 +20055,46 @@ var AccessStore = class {
     return [...this.codes.values()].filter((stored) => stored.consumedAt === void 0).map(({ code, createdAt, expiresAt }) => ({ code, createdAt, expiresAt }));
   }
 };
+function fileSessionDirectory(stateDir, now = Date.now) {
+  const path = join2(stateDir, "sessions.json");
+  let records = [];
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (Array.isArray(parsed)) {
+      records = parsed.filter(
+        (r) => !!r && typeof r.id === "string" && typeof r.createdAt === "number"
+      );
+    }
+  } catch {
+  }
+  const inner = memorySessionDirectory(records);
+  const flush = () => {
+    try {
+      mkdirSync(dirname(path), { recursive: true });
+      writeFileSync(path, JSON.stringify(inner.list()), { mode: 384 });
+    } catch (error) {
+      if (process.env.FRIZZ_DEBUG_SESSIONS) console.error("[sessions] flush failed:", error);
+    }
+  };
+  return {
+    record(r) {
+      inner.record(r);
+      flush();
+    },
+    isRevoked: (id) => inner.isRevoked(id),
+    list: () => inner.list(),
+    revoke(id) {
+      const ok = inner.revoke(id);
+      if (ok) flush();
+      return ok;
+    },
+    revokeAll() {
+      const n = inner.revokeAll();
+      if (n > 0) flush();
+      return n;
+    }
+  };
+}
 function loadOrCreateSessionKey(stateDir) {
   const path = join2(stateDir, "session-key");
   try {
@@ -21746,6 +21801,7 @@ var SUPERVISOR_RESTART_PATH = `${SUPERVISOR_CONTROL_PREFIX}/restart`;
 var SUPERVISOR_UPDATE_RESTART_PATH = `${SUPERVISOR_CONTROL_PREFIX}/update-restart`;
 var SUPERVISOR_STATUS_PATH = `${SUPERVISOR_CONTROL_PREFIX}/status`;
 var SUPERVISOR_ACCESS_CODE_PATH = `${SUPERVISOR_CONTROL_PREFIX}/access-code`;
+var SUPERVISOR_SESSIONS_PATH = `${SUPERVISOR_CONTROL_PREFIX}/sessions`;
 var SUPERVISOR_CONTROL_PROTOCOL = 1;
 function responseJson(res, status, value) {
   res.writeHead(status, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
@@ -21786,7 +21842,7 @@ function unlistedHostPage(name) {
 }
 function isControlRequest(req) {
   const url = new URL(req.url ?? "/", "http://frizz.invalid");
-  return url.pathname === SUPERVISOR_RESTART_PATH || url.pathname === SUPERVISOR_UPDATE_RESTART_PATH || url.pathname === SUPERVISOR_STATUS_PATH || url.pathname === SUPERVISOR_ACCESS_CODE_PATH;
+  return url.pathname === SUPERVISOR_RESTART_PATH || url.pathname === SUPERVISOR_UPDATE_RESTART_PATH || url.pathname === SUPERVISOR_STATUS_PATH || url.pathname === SUPERVISOR_ACCESS_CODE_PATH || url.pathname === SUPERVISOR_SESSIONS_PATH;
 }
 function isLocalImageRequest(req) {
   if (req.method !== "GET" && req.method !== "HEAD") return false;
@@ -21794,6 +21850,22 @@ function isLocalImageRequest(req) {
   return LOCAL_IMAGE_PATH.test(pathname);
 }
 var LOCAL_IMAGE_PATH = new RegExp(`^${FRIZZ_ROUTE_PREFIX}(?:/[^/]+)?/local-image$`);
+async function readJsonBody(req, limit = 64 * 1024) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    size += chunk.byteLength;
+    if (size > limit) return null;
+    chunks.push(chunk);
+  }
+  if (chunks.length === 0) return {};
+  try {
+    const parsed = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
 var RestartSupervisorProxy = class {
   server = null;
   restartInFlight = null;
@@ -21808,6 +21880,8 @@ var RestartSupervisorProxy = class {
    * judged here first.
    */
   policy;
+  /** The origin a tunnel or proxy serves this board at; undefined while loopback-only. Live: see setPublicOrigin. */
+  publicOrigin;
   /**
    * Codes and sessions for the public origin, or null when no public origin is declared (loopback-only
    * boards are never gated, so there is nothing to store).
@@ -21818,14 +21892,28 @@ var RestartSupervisorProxy = class {
   constructor(options2) {
     this.options = options2;
     this.host = options2.host ?? LOOPBACK_BIND_HOST;
-    this.access = options2.publicOrigin ? new AccessStore({
+    this.publicOrigin = options2.publicOrigin;
+    this.access = new AccessStore({
       onConsumed: () => options2.onCodeConsumed?.(),
-      ...options2.sessionKey ? { signingKey: options2.sessionKey } : {}
-    }) : null;
-    this.policy = {
+      ...options2.sessionKey ? { signingKey: options2.sessionKey } : {},
+      ...options2.sessionDirectory ? { sessions: options2.sessionDirectory } : {}
+    });
+    this.policy = this.buildPolicy();
+  }
+  /**
+   * Change the public origin on a running board — what the R pane does when the operator picks or
+   * clears a remote setup. Requests already in flight finish under the policy they started with; the
+   * next one is judged by the new origin. Sessions survive the change.
+   */
+  setPublicOrigin(origin) {
+    this.publicOrigin = origin;
+    this.policy = this.buildPolicy();
+  }
+  buildPolicy() {
+    return {
       exposed: bindHostIsExposed(this.host),
-      allowedHosts: options2.allowedHosts ?? [],
-      ...options2.publicOrigin ? { publicOrigin: options2.publicOrigin } : {}
+      allowedHosts: this.options.allowedHosts ?? [],
+      ...this.publicOrigin ? { publicOrigin: this.publicOrigin } : {}
     };
   }
   /**
@@ -21835,11 +21923,11 @@ var RestartSupervisorProxy = class {
    * asking at once, must not silently break the first QR somebody is still walking towards.
    */
   issueAccessCode() {
-    return this.access?.issue() ?? null;
+    return this.publicOrigin ? this.access.issue() : null;
   }
   /** The full URL to show as a link or a QR. */
   accessUrl(code) {
-    const origin = this.options.publicOrigin;
+    const origin = this.publicOrigin;
     return origin ? `${origin}/?${ACCESS_CODE_PARAM}=${encodeURIComponent(code)}` : null;
   }
   async listen() {
@@ -21980,6 +22068,42 @@ var RestartSupervisorProxy = class {
       responseJson(res, 200, { url, expiresAt: link.expiresAt });
       return;
     }
+    if (pathname === SUPERVISOR_SESSIONS_PATH) {
+      if (this.arrivedPublicly(req)) {
+        res.writeHead(403);
+        res.end("Forbidden");
+        return;
+      }
+      if (!this.publicOrigin) {
+        responseJson(res, 409, { error: "this board has no public origin, so nothing is signed in" });
+        return;
+      }
+      if (req.method === "GET") {
+        responseJson(res, 200, { sessions: this.access.sessions.list() });
+        return;
+      }
+      if (req.method !== "POST") {
+        res.writeHead(405, { allow: "GET, POST" });
+        res.end();
+        return;
+      }
+      const body = await readJsonBody(req);
+      const id = typeof body?.id === "string" ? body.id : void 0;
+      if (body?.all === true) {
+        responseJson(res, 200, { signedOut: this.access.sessions.revokeAll() });
+        return;
+      }
+      if (!id) {
+        responseJson(res, 400, { error: "name a device id, or pass all: true" });
+        return;
+      }
+      if (!this.access.sessions.revoke(id)) {
+        responseJson(res, 404, { error: `no signed-in device has the id ${id}` });
+        return;
+      }
+      responseJson(res, 200, { signedOut: 1 });
+      return;
+    }
     if (pathname === SUPERVISOR_STATUS_PATH && req.method === "GET") {
       responseJson(res, 200, { protocol: SUPERVISOR_CONTROL_PROTOCOL, ...this.status() });
       return;
@@ -22036,7 +22160,7 @@ var RestartSupervisorProxy = class {
    * a tunnelled board stays bound to 127.0.0.1 while being reachable from the internet by name.
    */
   arrivedPublicly(req) {
-    const declared = this.options.publicOrigin;
+    const declared = this.publicOrigin;
     if (!declared) return false;
     const host = parseLocalHost(req.headers.host, this.options.port, this.policy);
     return !!host && !LOOPBACK_HOSTNAMES.has(host.hostname);
@@ -22056,7 +22180,7 @@ var RestartSupervisorProxy = class {
    * staying in somebody's URL bar.
    */
   sessionAccepted(req) {
-    if (!this.access) return true;
+    if (!this.publicOrigin) return true;
     return this.access.verifySession(readCookie(req.headers.cookie, SESSION_COOKIE));
   }
   /**
@@ -22067,7 +22191,7 @@ var RestartSupervisorProxy = class {
     const url = new URL(req.url ?? "/", "http://frizz.invalid");
     const code = url.searchParams.get(ACCESS_CODE_PARAM);
     if (code === null) return false;
-    const redeemed = this.access?.redeem(code);
+    const redeemed = this.access.redeem(code, describeDevice(req.headers["user-agent"]));
     if (!redeemed?.ok) {
       res.writeHead(401, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" });
       res.end(unauthorizedPage(redeemed?.reason));
@@ -22171,66 +22295,78 @@ var RestartSupervisorProxy = class {
   }
 };
 
-// src/access-pane.ts
-var ALT_SCREEN_ON = "\x1B[?1049h";
-var ALT_SCREEN_OFF = "\x1B[?1049l";
-var HIDE_CURSOR = "\x1B[?25l";
-var SHOW_CURSOR = "\x1B[?25h";
-var CLEAR = "\x1B[2J\x1B[H";
-var DIM = "\x1B[2m";
-var RESET2 = "\x1B[0m";
-var OPEN_KEYS = /* @__PURE__ */ new Set(["l", "L"]);
-var CTRL_C = "";
-function secondsUntil(expiresAt, now) {
-  return Math.max(0, Math.ceil((expiresAt - now) / 1e3));
+// src/sessions-cli.ts
+var ago = (at, now = Date.now()) => {
+  const seconds = Math.max(0, Math.round((now - at) / 1e3));
+  if (seconds < 90) return "just now";
+  const minutes = Math.round(seconds / 60);
+  if (minutes < 90) return `${minutes}m ago`;
+  const hours = Math.round(minutes / 60);
+  if (hours < 36) return `${hours}h ago`;
+  return `${Math.round(hours / 24)}d ago`;
+};
+async function call(port, init) {
+  const response = await fetch(`http://127.0.0.1:${port}${SUPERVISOR_SESSIONS_PATH}`, {
+    ...init,
+    headers: { origin: `http://127.0.0.1:${port}`, ...init?.body ? { "content-type": "application/json" } : {}, ...init?.headers }
+  }).catch(() => void 0);
+  if (!response) {
+    console.error("frizz: the running board did not answer");
+    process.exit(1);
+  }
+  const body = await response.json().catch(() => void 0);
+  if (!response.ok) {
+    console.error(`frizz: ${body?.error ?? `the board answered ${response.status}`}`);
+    process.exit(1);
+  }
+  return body;
 }
-function installAccessPane(options2) {
+async function listSessions(port) {
+  const body = await call(port);
+  const sessions = body?.sessions ?? [];
+  const live = sessions.filter((s) => s.revokedAt === void 0);
+  if (live.length === 0) {
+    console.log("No device has redeemed an access link.");
+    process.exit(0);
+  }
+  const width = Math.max(...live.map((s) => s.id.length));
+  for (const session of live) {
+    console.log(`  ${session.id.padEnd(width)}  ${session.label}  ${ago(session.createdAt)}`);
+  }
+  console.log(`
+  frizz --sign-out <id>   sign one out
+  frizz --sign-out all    sign every device out`);
+  process.exit(0);
+}
+async function signOutSession(port, target2) {
+  const all = target2 === "all";
+  const body = await call(port, {
+    method: "POST",
+    body: JSON.stringify(all ? { all: true } : { id: target2 })
+  });
+  const count = Number(body?.signedOut ?? 0);
+  if (all) {
+    console.log(count === 0 ? "No device was signed in." : `Signed out ${count} device${count === 1 ? "" : "s"}.`);
+  } else {
+    console.log(`Signed out ${target2}.`);
+  }
+  process.exit(0);
+}
+
+// src/pane-host.ts
+var CTRL_C = "";
+function installPaneHost(options2) {
   const input = options2.input ?? process.stdin;
   const output = options2.output ?? process.stdout;
-  const now = options2.now ?? Date.now;
   const onInterrupt = options2.onInterrupt ?? (() => process.kill(process.pid, "SIGINT"));
   if (!input.isTTY || !output.isTTY || typeof input.setRawMode !== "function") return null;
-  let open = false;
+  let active = null;
   let disposed = false;
-  let shown = null;
-  let consumed = false;
-  const paint = () => {
-    if (!shown) return;
-    const remaining = secondsUntil(shown.expiresAt, now());
-    const status = consumed ? "This link has been used. Press L for another." : remaining === 0 ? "This link has expired. Press L for another." : `Single use, expires in ${remaining}s.`;
-    output.write(CLEAR);
-    output.write("\n");
-    for (const row of renderQrLines(shown.url)) output.write(`  ${row}
-`);
-    output.write(`
-  ${shown.url}
-`);
-    output.write(`
-  ${DIM}${status}  Press any other key to close.${RESET2}
-`);
-  };
-  let ticker;
-  const close = () => {
-    if (!open) return;
-    open = false;
-    shown = null;
-    consumed = false;
-    if (ticker) clearInterval(ticker);
-    ticker = void 0;
-    output.write(ALT_SCREEN_OFF);
-    output.write(SHOW_CURSOR);
-  };
-  const openPane = () => {
-    const link = options2.issue();
-    if (!link) return;
-    shown = link;
-    consumed = false;
-    open = true;
-    output.write(ALT_SCREEN_ON);
-    output.write(HIDE_CURSOR);
-    paint();
-    ticker = setInterval(paint, 1e3);
-    ticker.unref?.();
+  const closeActive = () => {
+    if (!active) return;
+    const pane = active;
+    active = null;
+    pane.close();
   };
   const onKey = (chunk) => {
     const key = chunk.toString();
@@ -22239,16 +22375,17 @@ function installAccessPane(options2) {
       onInterrupt();
       return;
     }
-    if (open) {
-      close();
+    if (active) {
+      if (active.key(key) === "close") closeActive();
       return;
     }
-    if (OPEN_KEYS.has(key)) openPane();
+    const pane = options2.bindings[key];
+    if (pane && pane.open()) active = pane;
   };
   const restore = () => {
     if (disposed) return;
     disposed = true;
-    close();
+    closeActive();
     input.off("data", onKey);
     try {
       input.setRawMode?.(false);
@@ -22262,9 +22399,70 @@ function installAccessPane(options2) {
   input.setEncoding("utf8");
   input.on("data", onKey);
   process.on("exit", restore);
+  return { dispose: restore, isOpen: () => active !== null };
+}
+
+// src/access-pane.ts
+var ALT_SCREEN_ON = "\x1B[?1049h";
+var ALT_SCREEN_OFF = "\x1B[?1049l";
+var HIDE_CURSOR = "\x1B[?25l";
+var SHOW_CURSOR = "\x1B[?25h";
+var CLEAR = "\x1B[2J\x1B[H";
+var DIM = "\x1B[2m";
+var RESET2 = "\x1B[0m";
+function secondsUntil(expiresAt, now) {
+  return Math.max(0, Math.ceil((expiresAt - now) / 1e3));
+}
+function createAccessPane(options2) {
+  const output = options2.output ?? process.stdout;
+  const now = options2.now ?? Date.now;
+  let open = false;
+  let shown = null;
+  let consumed = false;
+  let ticker;
+  const paint = () => {
+    if (!shown) return;
+    const remaining = secondsUntil(shown.expiresAt, now());
+    const status = consumed ? "This link has been used. Press L for another." : remaining === 0 ? "This link has expired. Press L for another." : `Single use, expires in ${remaining}s.`;
+    output.write(CLEAR);
+    output.write("\n");
+    for (const row of renderQrLines(shown.url)) output.write(`  ${row}
+`);
+    output.write(`
+  ${shown.url}
+`);
+    output.write(`
+  ${DIM}${status}  Press any other key to close.${RESET2}
+`);
+  };
   return {
-    dispose: restore,
-    markConsumed: () => {
+    open() {
+      const link = options2.issue();
+      if (!link) return false;
+      shown = link;
+      consumed = false;
+      open = true;
+      output.write(ALT_SCREEN_ON);
+      output.write(HIDE_CURSOR);
+      paint();
+      ticker = setInterval(paint, 1e3);
+      ticker.unref?.();
+      return true;
+    },
+    key() {
+      return "close";
+    },
+    close() {
+      if (!open) return;
+      open = false;
+      shown = null;
+      consumed = false;
+      if (ticker) clearInterval(ticker);
+      ticker = void 0;
+      output.write(ALT_SCREEN_OFF);
+      output.write(SHOW_CURSOR);
+    },
+    markConsumed() {
       if (!open) return;
       consumed = true;
       paint();
@@ -22272,10 +22470,13 @@ function installAccessPane(options2) {
   };
 }
 
+// src/remote-controller.ts
+import { homedir as homedir4 } from "node:os";
+
 // src/cloud.ts
 init_src();
 import { spawn as spawn2 } from "node:child_process";
-import { existsSync, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3, rmSync } from "node:fs";
 import { createInterface } from "node:readline/promises";
 import { homedir as homedir3 } from "node:os";
 import { dirname as dirname3, join as join4 } from "node:path";
@@ -22604,6 +22805,7 @@ var b64url = (bytes) => {
   for (const byte of view) binary += String.fromCharCode(byte);
   return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 };
+var SETTLED_MS = 1e4;
 function defaultBackoff(attempt, random = Math.random) {
   const base = Math.min(3e4, 500 * 2 ** Math.min(attempt, 6));
   return Math.round(base / 2 + random() * (base / 2));
@@ -22653,8 +22855,11 @@ function connectRelay(options2) {
     const url = `${options2.relayOrigin.replace(/^http/, "ws").replace(/\/$/, "")}/_relay/connect?h=${encoded}`;
     const next = makeSocket(url);
     socket = next;
+    let settled;
     next.addEventListener("open", () => {
-      attempt = 0;
+      settled = setTimer(() => {
+        attempt = 0;
+      }, SETTLED_MS);
       options2.onStatus?.("connected");
     });
     next.addEventListener("message", (event) => {
@@ -22695,6 +22900,10 @@ function connectRelay(options2) {
     });
     const dropped = () => {
       if (socket !== next) return;
+      if (settled !== void 0) {
+        clearTimer(settled);
+        settled = void 0;
+      }
       socket = null;
       for (const session of nested.values()) session.close();
       nested.clear();
@@ -22724,6 +22933,14 @@ function connectRelay(options2) {
 }
 
 // src/cloud.ts
+function isExternalConfig(config) {
+  return config.serve === "external";
+}
+function describeCloudConfig(config) {
+  if (isClaimedConfig(config)) return "frizz.sh";
+  if (isExternalConfig(config)) return config.provider === "tailscale" ? "Tailscale" : "your proxy";
+  return "Cloudflare Tunnel";
+}
 var REGISTRAR_IS_LIVE = true;
 function isClaimedConfig(config) {
   return typeof config.claim === "string" && config.claim.length > 0;
@@ -22731,6 +22948,22 @@ function isClaimedConfig(config) {
 function isRelayConfig(config) {
   return isClaimedConfig(config) && config.serve === "relay";
 }
+var CLAIM_ZONE = "frizz.sh";
+function zoneClaimLabel(hostname) {
+  const suffix = `.${CLAIM_ZONE}`;
+  if (!hostname.endsWith(suffix)) return null;
+  const label = hostname.slice(0, -suffix.length);
+  return label.length > 0 && !label.includes(".") ? label : null;
+}
+async function reconcileCloudConfig(config, port, home = homedir3(), onNotice, origin, github = githubCli) {
+  if (isRelayConfig(config)) return config;
+  const label = config.claim ?? zoneClaimLabel(config.hostname);
+  if (!label) return config;
+  onNotice?.(
+    isClaimedConfig(config) ? `${config.hostname} is served by the Frizz relay now; moving this board off its tunnel` : `${config.hostname} is inside ${CLAIM_ZONE}, where names are claimed, not tunnelled; claiming ${label}`
+  );
+  return establishCloudConfig(label, port, home, origin, github);
+}
 function cloudConfigPath(home = homedir3()) {
   return join4(home, ".frizz", "cloud.json");
 }
@@ -22740,12 +22973,14 @@ function readCloudConfig(home = homedir3()) {
     if (typeof parsed.hostname !== "string" || !parsed.hostname) return null;
     const claimed = typeof parsed.claim === "string" && parsed.claim.length > 0;
     const named = typeof parsed.tunnel === "string" && parsed.tunnel.length > 0;
-    if (!claimed && !named) return null;
+    const external = parsed.serve === "external";
+    if (!claimed && !named && !external) return null;
     return {
       hostname: parsed.hostname,
       ...named ? { tunnel: parsed.tunnel } : {},
       ...claimed ? { claim: parsed.claim } : {},
-      ...parsed.serve === "relay" || parsed.serve === "tunnel" ? { serve: parsed.serve } : {},
+      ...parsed.serve === "relay" || parsed.serve === "tunnel" || external ? { serve: parsed.serve } : {},
+      ...external && (parsed.provider === "tailscale" || parsed.provider === "other") ? { provider: parsed.provider } : {},
       ...parsed.config ? { config: parsed.config } : {}
     };
   } catch {
@@ -22769,6 +23004,9 @@ function writeTunnelToken(token, home = homedir3()) {
   writeFileSync3(path, `${token}
 `, { mode: 384 });
 }
+function deleteCloudConfig(home = homedir3()) {
+  rmSync(cloudConfigPath(home), { force: true });
+}
 function writeCloudConfig(config, home = homedir3()) {
   const path = cloudConfigPath(home);
   mkdirSync3(dirname3(path), { recursive: true });
@@ -22782,19 +23020,6 @@ function normalizeHostname(raw) {
   }
   return trimmed.toLowerCase();
 }
-async function promptForCloudName() {
-  if (!process.stdin.isTTY) {
-    throw new Error(
-      "--cloud needs a saved name when there is no terminal to ask \u2014 run it once interactively first"
-    );
-  }
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  try {
-    return (await rl.question("Name for this board \u2014 a word claims <name>.frizz.sh, or paste a hostname you already run a tunnel for: ")).trim();
-  } finally {
-    rl.close();
-  }
-}
 async function promptForTunnelName(hostname, fallback) {
   if (!process.stdin.isTTY) return fallback;
   const rl = createInterface({ input: process.stdin, output: process.stdout });
@@ -22808,8 +23033,8 @@ async function promptForTunnelName(hostname, fallback) {
 async function establishCloudConfig(answer, port, home = homedir3(), origin, github = githubCli) {
   if (answer.includes(".")) {
     const hostname = normalizeHostname(answer);
-    const tunnel2 = await promptForTunnelName(hostname, hostname.split(".")[0]);
-    return { hostname, tunnel: tunnel2 };
+    const tunnel = await promptForTunnelName(hostname, hostname.split(".")[0]);
+    return { hostname, tunnel };
   }
   if (!REGISTRAR_IS_LIVE && !origin && !process.env.FRIZZ_REGISTRAR) {
     throw new Error(
@@ -22912,6 +23137,421 @@ function startTunnel(config, onExit, onError, home = homedir3(), runToken) {
   };
 }
 
+// src/remote-controller.ts
+function createRemoteController(options2) {
+  const home = options2.home ?? homedir4();
+  let config = null;
+  let transport = null;
+  const stopTransport = () => {
+    transport?.stop();
+    transport = null;
+  };
+  const startTransport = async (next, justClaimed) => {
+    if (isExternalConfig(next)) return;
+    if (isRelayConfig(next)) {
+      if (!justClaimed) {
+        await resolveRunToken(next, options2.port, home, (message) => {
+          options2.log.warn("relay", message);
+          options2.say(message);
+        });
+      }
+      transport = await startRelay(next, options2.port, home, (message) => options2.log.info("relay", message));
+      options2.log.info("relay", `serving ${next.hostname} through the Frizz relay`);
+      return;
+    }
+    const runToken = isClaimedConfig(next) ? justClaimed ? readTunnelToken(home) : await resolveRunToken(next, options2.port, home, (message) => {
+      options2.log.warn("tunnel", message);
+      options2.say(message);
+    }) : null;
+    transport = startTunnel(
+      next,
+      (code) => {
+        if (code === 0 || code === null) return;
+        options2.log.error("tunnel", `cloudflared exited with code ${code}; the public hostname is now unreachable`);
+      },
+      (message) => {
+        options2.log.error("tunnel", message);
+        options2.say(message);
+      },
+      home,
+      runToken ?? void 0
+    );
+    options2.log.info("tunnel", `running cloudflared for ${next.hostname}`);
+  };
+  const originOf = (next) => next ? `https://${next.hostname}` : void 0;
+  return {
+    current: () => config,
+    origin: () => originOf(config),
+    async serveSaved() {
+      const saved = readCloudConfig(home);
+      if (!saved) return;
+      const reconciled = await reconcileCloudConfig(saved, options2.port, home, (message) => {
+        options2.log.warn("cloud", message);
+        options2.say(message);
+      });
+      const justClaimed = reconciled !== saved;
+      if (justClaimed) writeCloudConfig(reconciled, home);
+      await startTransport(reconciled, justClaimed);
+      config = reconciled;
+      options2.host.setPublicOrigin(originOf(reconciled));
+    },
+    async apply(next, applyOptions = {}) {
+      stopTransport();
+      options2.host.setPublicOrigin(void 0);
+      if (!next) {
+        deleteCloudConfig(home);
+        config = null;
+        return;
+      }
+      writeCloudConfig(next, home);
+      try {
+        await startTransport(next, applyOptions.justClaimed ?? false);
+      } catch (error) {
+        config = null;
+        throw error;
+      }
+      config = next;
+      options2.host.setPublicOrigin(originOf(next));
+    },
+    stop: stopTransport
+  };
+}
+
+// src/remote-detect.ts
+import { execFile as execFile3 } from "node:child_process";
+var PROBE_TIMEOUT_MS = 4e3;
+function run2(command, args2) {
+  return new Promise((resolve5) => {
+    execFile3(command, args2, { encoding: "utf8", timeout: PROBE_TIMEOUT_MS }, (error, stdout) => {
+      resolve5(error ? null : stdout);
+    });
+  });
+}
+async function probeGithub() {
+  const version = await run2("gh", ["--version"]);
+  if (version === null) return { login: null, installed: false };
+  const login = await run2("gh", ["api", "user", "--jq", ".login"]);
+  return { login: login?.trim() || null, installed: true };
+}
+async function probeCloudflared() {
+  const out = await run2("cloudflared", ["--version"]);
+  const version = out?.match(/\d+\.\d+\.\d+/)?.[0] ?? (out ? out.trim() : null);
+  return { version };
+}
+async function probeTailscale() {
+  const out = await run2("tailscale", ["status", "--json"]);
+  if (out === null) return { installed: await run2("tailscale", ["--version"]) !== null, dnsName: null };
+  try {
+    const status = JSON.parse(out);
+    const dnsName = status.Self?.DNSName?.replace(/\.$/, "") || null;
+    return { installed: true, dnsName };
+  } catch {
+    return { installed: true, dnsName: null };
+  }
+}
+
+// src/remote-pane.ts
+var CHOICES = [
+  { kind: "frizz", title: "frizz.sh name", blurb: "<name>.frizz.sh \u2014 nothing to install; needs the GitHub CLI" },
+  { kind: "cloudflare", title: "Cloudflare Tunnel", blurb: "a domain you own on Cloudflare; cloudflared on this machine" },
+  { kind: "tailscale", title: "Tailscale", blurb: "your tailnet; tailscale serve does the TLS" },
+  { kind: "other", title: "Something else", blurb: "any proxy or tunnel you run \u2014 tell Frizz its address" },
+  { kind: "off", title: "Off", blurb: "loopback only" }
+];
+var ENTER = /* @__PURE__ */ new Set(["\r", "\n"]);
+var BACKSPACE = /* @__PURE__ */ new Set(["\x7F", "\b"]);
+var ESC = "\x1B";
+var UP = "\x1B[A";
+var DOWN = "\x1B[B";
+var TAB = "	";
+var SHIFT_TAB = "\x1B[Z";
+function kindOf(config) {
+  if (!config) return "off";
+  if (isClaimedConfig(config)) return "frizz";
+  if (isExternalConfig(config)) return config.provider === "tailscale" ? "tailscale" : "other";
+  return "cloudflare";
+}
+function wrap(text, width = 74) {
+  const lines = [];
+  for (const paragraph of text.split("\n")) {
+    let line = "";
+    for (const word of paragraph.split(" ")) {
+      if (line && line.length + 1 + word.length > width) {
+        lines.push(line);
+        line = word;
+      } else line = line ? `${line} ${word}` : word;
+    }
+    lines.push(line);
+  }
+  return lines;
+}
+function createRemotePane(options2) {
+  const output = options2.output ?? process.stdout;
+  let open = false;
+  let screen = { name: "menu", index: 0 };
+  let github = null;
+  let cloudflared = null;
+  let tailscale = null;
+  const write = (lines) => {
+    if (!open) return;
+    output.write(CLEAR);
+    output.write("\n");
+    for (const line of lines) output.write(`  ${line}
+`);
+  };
+  const check = (ok, text) => ok ? `${text} \u2713` : text;
+  const paint = () => {
+    if (!open) return;
+    const s = screen;
+    if (s.name === "menu") {
+      const current = kindOf(options2.current());
+      write([
+        "Reach this board from anywhere",
+        "",
+        ...wrap(
+          "Frizz binds 127.0.0.1 and has no login. Reaching it from another device means something in front of it does the authenticating. Whatever you pick here is remembered; from then on a plain `npx frizz` serves it."
+        ),
+        "",
+        ...CHOICES.map((choice, index) => {
+          const marker = index === s.index ? "\u276F" : " ";
+          const title = choice.title.padEnd(18);
+          const now = choice.kind === current ? `  ${DIM}(current)${RESET2}` : "";
+          return `${marker} ${title}${DIM}${choice.blurb}${RESET2}${now}`;
+        }),
+        "",
+        `${DIM}\u2191\u2193 move \xB7 enter choose \xB7 esc back${RESET2}`
+      ]);
+      return;
+    }
+    if (s.name === "form") {
+      const head = formHead(s.kind);
+      const fields = s.fields.map((field, index) => {
+        const focused = index === s.focus;
+        const shown = field.value || (field.placeholder ? `${DIM}${field.placeholder}${RESET2}` : "");
+        const cursor = focused ? "\u2588" : "";
+        return `${field.label.padEnd(10)} ${shown}${cursor}`;
+      });
+      write([...head, "", ...fields, ...s.note ? ["", s.note] : [], "", `${DIM}enter ${s.kind === "frizz" ? "claim" : "save"} \xB7 tab next field \xB7 esc back${RESET2}`]);
+      return;
+    }
+    if (s.name === "busy") {
+      write([s.message, "", `${DIM}working\u2026${RESET2}`]);
+      return;
+    }
+    if (s.name === "done") {
+      const lines = [s.message, ""];
+      if (s.link) {
+        for (const row of renderQrLines(s.link.url)) lines.push(row);
+        lines.push("", s.link.url, "", `${DIM}Scan to sign in on a phone. Single use, expires in 5 minutes. Press L later for another.${RESET2}`);
+      }
+      lines.push("", `${DIM}press any key to return${RESET2}`);
+      write(lines);
+      return;
+    }
+    write([`Could not apply that: ${s.message}`, "", `${DIM}press any key to go back${RESET2}`]);
+  };
+  const formHead = (kind) => {
+    if (kind === "frizz") {
+      const gh = github === "pending" || github === null ? `${DIM}GitHub CLI   checking\u2026${RESET2}` : !github.installed ? "GitHub CLI   not installed \u2014 see https://cli.github.com, then `gh auth login`" : github.login ? check(true, `GitHub CLI   signed in as ${github.login}`) : "GitHub CLI   not signed in \u2014 run `gh auth login` in another terminal";
+      return [
+        "frizz.sh name",
+        "",
+        ...wrap(
+          "Claims <name>.frizz.sh for your GitHub account. The board dials out to frizz.sh \u2014 no port, no DNS record, no tunnel binary. One name per account; a name nobody runs for 30 days is released."
+        ),
+        ...options2.sandbox ? ["", ...wrap("This is a sandbox, but a claim is real: it binds this machine's one name to your account, and your real board keeps it. Only the setup saved here is thrown away.")] : [],
+        "",
+        gh
+      ];
+    }
+    if (kind === "cloudflare") {
+      const cf = cloudflared === "pending" || cloudflared === null ? `${DIM}cloudflared   checking\u2026${RESET2}` : cloudflared.version ? check(true, `cloudflared   found, ${cloudflared.version}`) : "cloudflared   not found \u2014 install it from https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/";
+      return [
+        "Cloudflare Tunnel",
+        "",
+        "Needs a domain on Cloudflare and cloudflared on this machine.",
+        cf,
+        "",
+        "Create the tunnel and its DNS record once, in another terminal:",
+        "",
+        "  cloudflared tunnel login",
+        "  cloudflared tunnel create my-board",
+        "  cloudflared tunnel route dns my-board board.example.com",
+        "",
+        ...wrap(
+          `Then name them here. Frizz writes ~/.cloudflared/frizz.yml (ingress to http://127.0.0.1:${options2.port}) and runs the tunnel beside the board, so the two share a lifetime.`
+        )
+      ];
+    }
+    if (kind === "tailscale") {
+      const ts = tailscale === "pending" || tailscale === null ? `${DIM}tailscale   checking\u2026${RESET2}` : !tailscale.installed ? "tailscale   not found \u2014 install it from https://tailscale.com/download" : tailscale.dnsName ? check(true, `tailscale   found, this machine is ${tailscale.dnsName}`) : "tailscale   found, but the daemon did not answer \u2014 is it signed in?";
+      return [
+        "Tailscale",
+        "",
+        ...wrap("Serves the board on your tailnet. Tailscale terminates TLS and only devices signed into the tailnet can reach the name."),
+        ts,
+        "",
+        "Run once, in another terminal:",
+        "",
+        `  tailscale serve --bg ${options2.port}`,
+        "",
+        "Tailscale answers at the address below \u2014 that is the origin Frizz accepts."
+      ];
+    }
+    return [
+      "Something else",
+      "",
+      ...wrap(
+        `Terminate TLS wherever you like, proxy to http://127.0.0.1:${options2.port}, and give Frizz the exact origin a browser will show \u2014 scheme and host, no path. Frizz answers only to that Host and prints a single-use sign-in link.`
+      )
+    ];
+  };
+  const openForm = (kind) => {
+    const current = options2.current();
+    const same = kindOf(current) === kind ? current : null;
+    let fields;
+    if (kind === "frizz") {
+      github = "pending";
+      void options2.probes.github().then((result) => {
+        github = result;
+        if (screen.name === "form" && screen.kind === "frizz" && !screen.fields[0].value && result.login) {
+          screen.fields[0].placeholder = result.login;
+        }
+        paint();
+      });
+      fields = [{ label: "Name", value: same?.claim ?? "" }];
+    } else if (kind === "cloudflare") {
+      cloudflared = "pending";
+      void options2.probes.cloudflared().then((result) => {
+        cloudflared = result;
+        paint();
+      });
+      fields = [
+        { label: "Hostname", value: same?.hostname ?? "", placeholder: "board.example.com" },
+        { label: "Tunnel", value: same?.tunnel ?? "", placeholder: "my-board" }
+      ];
+    } else if (kind === "tailscale") {
+      tailscale = "pending";
+      void options2.probes.tailscale().then((result) => {
+        tailscale = result;
+        if (screen.name === "form" && screen.kind === "tailscale" && !screen.fields[0].value && result.dnsName) {
+          screen.fields[0].placeholder = `https://${result.dnsName}`;
+        }
+        paint();
+      });
+      fields = [{ label: "Origin", value: same ? `https://${same.hostname}` : "", placeholder: "https://mac-mini.your-tailnet.ts.net" }];
+    } else {
+      fields = [{ label: "Origin", value: same ? `https://${same.hostname}` : "", placeholder: "https://board.example.com" }];
+    }
+    screen = { name: "form", kind, fields, focus: 0 };
+    paint();
+  };
+  const valueOf = (field) => field.value || field.placeholder || "";
+  const submit = async (form) => {
+    const back = form;
+    try {
+      let next;
+      let justClaimed = false;
+      if (form.kind === "frizz") {
+        const name = valueOf(form.fields[0]).trim();
+        if (!name) throw new Error("a name is needed");
+        screen = { name: "busy", message: `claiming ${name}.frizz.sh\u2026` };
+        paint();
+        next = await options2.claim(name);
+        justClaimed = true;
+      } else if (form.kind === "cloudflare") {
+        const hostname = normalizeHostname(valueOf(form.fields[0]));
+        const tunnel = valueOf(form.fields[1]).trim();
+        if (!tunnel) throw new Error("the tunnel's name is needed");
+        next = { hostname, tunnel };
+      } else {
+        const hostname = normalizeHostname(valueOf(form.fields[0]));
+        next = { hostname, serve: "external", provider: form.kind === "tailscale" ? "tailscale" : "other" };
+      }
+      screen = { name: "busy", message: `serving ${next.hostname}\u2026` };
+      paint();
+      await options2.apply(next, { justClaimed });
+      options2.onChanged?.(next);
+      screen = { name: "done", message: `Serving https://${next.hostname} (${describeCloudConfig(next)}).`, link: options2.issueLink(), config: next };
+    } catch (error) {
+      screen = { name: "error", message: error instanceof Error ? error.message : String(error), back };
+    }
+    paint();
+  };
+  const turnOff = async () => {
+    screen = { name: "busy", message: "back to loopback only\u2026" };
+    paint();
+    try {
+      await options2.apply(null);
+      options2.onChanged?.(null);
+      screen = { name: "done", message: "Loopback only. This board is reachable from this machine alone.", link: null, config: null };
+    } catch (error) {
+      screen = { name: "error", message: error instanceof Error ? error.message : String(error), back: { name: "menu", index: CHOICES.length - 1 } };
+    }
+    paint();
+  };
+  return {
+    open() {
+      open = true;
+      const current = kindOf(options2.current());
+      screen = { name: "menu", index: Math.max(0, CHOICES.findIndex((choice) => choice.kind === current)) };
+      output.write(ALT_SCREEN_ON);
+      output.write(HIDE_CURSOR);
+      paint();
+      return true;
+    },
+    key(key) {
+      const s = screen;
+      if (s.name === "busy") return "keep";
+      if (s.name === "done") return "close";
+      if (s.name === "error") {
+        screen = s.back;
+        paint();
+        return "keep";
+      }
+      if (s.name === "menu") {
+        if (key === ESC || key === "q") return "close";
+        if (key === UP || key === "k") s.index = (s.index + CHOICES.length - 1) % CHOICES.length;
+        else if (key === DOWN || key === "j") s.index = (s.index + 1) % CHOICES.length;
+        else if (/^[1-5]$/.test(key)) s.index = Number(key) - 1;
+        else if (ENTER.has(key)) {
+          const choice = CHOICES[s.index];
+          if (choice.kind === "off") void turnOff();
+          else openForm(choice.kind);
+          return "keep";
+        }
+        paint();
+        return "keep";
+      }
+      if (key === ESC) {
+        screen = { name: "menu", index: CHOICES.findIndex((choice) => choice.kind === s.kind) };
+        paint();
+        return "keep";
+      }
+      const field = s.fields[s.focus];
+      if (ENTER.has(key)) {
+        if (s.focus < s.fields.length - 1 && valueOf(field)) s.focus += 1;
+        else void submit(s);
+      } else if (key === TAB || key === DOWN) s.focus = (s.focus + 1) % s.fields.length;
+      else if (key === SHIFT_TAB || key === UP) s.focus = (s.focus + s.fields.length - 1) % s.fields.length;
+      else if (BACKSPACE.has(key)) field.value = field.value.slice(0, -1);
+      else if (key.length === 1 && key >= " ") field.value += key;
+      else if (!key.startsWith(ESC)) field.value += key.replace(/[\r\n\t]/g, "");
+      paint();
+      return "keep";
+    },
+    close() {
+      if (!open) return;
+      open = false;
+      output.write(ALT_SCREEN_OFF);
+      output.write(SHOW_CURSOR);
+    }
+  };
+}
+
+// src/production.ts
+init_local_origin();
+
 // src/readout.ts
 var SPINNER = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 var SYNC_BEGIN = "\x1B[?2026h";
@@ -23258,33 +23898,27 @@ init_src();
 init_project_registry();
 import { execFileSync as execFileSync3 } from "node:child_process";
 import { createServer as createServer2 } from "node:net";
-import { mkdirSync as mkdirSync10, readFileSync as readFileSync11, realpathSync as realpathSync5, writeFileSync as writeFileSync10 } from "node:fs";
-import { homedir as homedir9, hostname as osHostname, networkInterfaces } from "node:os";
+import { existsSync as existsSync5, mkdirSync as mkdirSync10, mkdtempSync, readdirSync as readdirSync3, readFileSync as readFileSync11, realpathSync as realpathSync5, rmSync as rmSync8, symlinkSync as symlinkSync2, writeFileSync as writeFileSync10 } from "node:fs";
+import { homedir as homedir10, tmpdir as tmpdir2 } from "node:os";
 import { basename as basename5, join as join13, resolve as resolve3 } from "node:path";
 import { setTimeout as delay2 } from "node:timers/promises";
 var PORT_SCAN_COUNT = 100;
 var LAUNCH_TIMEOUT_MS = 3e4;
 var LAUNCH_HARD_TIMEOUT_MS = 10 * 6e4;
-function looksLikeBindHost(value) {
-  if (value === void 0 || value.startsWith("-")) return false;
-  try {
-    normalizeBindHost(value);
-    return true;
-  } catch {
-    return false;
-  }
+var RETIRED_NETWORK_FLAGS = ["--host", "--allowed-host", "--public-origin", "--cloud"];
+function retiredFlagMessage(flag) {
+  return `${flag} was retired \u2014 how a board is reached is set up from the running board now: press R in its terminal to pick a frizz.sh name, a Cloudflare Tunnel, Tailscale or a proxy of your own. The choice is remembered, so a plain launch serves it.`;
 }
 function parseCliArgs(argv) {
   const args2 = new Set(argv);
-  let upCommand = false;
   let rawPort;
-  let rawHost;
-  let rawPublicOrigin;
-  const rawAllowedHosts = [];
+  let rawSignOut;
   const consumed = /* @__PURE__ */ new Set();
   for (let index = 0; index < argv.length; index++) {
     const arg = argv[index];
     if (consumed.has(index)) continue;
+    const retired = arg === "up" ? "up" : RETIRED_NETWORK_FLAGS.find((flag) => arg === flag || arg.startsWith(`${flag}=`));
+    if (retired) throw new Error(retiredFlagMessage(retired));
     if (arg === "--port") {
       rawPort = argv[++index];
       if (rawPort === void 0 || rawPort.startsWith("-"))
@@ -23296,49 +23930,21 @@ function parseCliArgs(argv) {
       rawPort = arg.slice("--port=".length);
       continue;
     }
-    if (arg === "--host") {
-      if (looksLikeBindHost(argv[index + 1])) {
-        rawHost = argv[++index];
-        consumed.add(index);
-      } else {
-        rawHost = ALL_INTERFACES_BIND_HOST;
-      }
-      continue;
-    }
-    if (arg.startsWith("--host=")) {
-      rawHost = arg.slice("--host=".length);
-      continue;
-    }
-    if (arg === "--allowed-host") {
-      const value = argv[++index];
-      if (value === void 0 || value.startsWith("-"))
-        throw new Error("--allowed-host requires a value");
-      consumed.add(index);
-      rawAllowedHosts.push(value);
-      continue;
-    }
-    if (arg.startsWith("--allowed-host=")) {
-      rawAllowedHosts.push(arg.slice("--allowed-host=".length));
-      continue;
-    }
-    if (arg === "--public-origin") {
-      const value = argv[++index];
+    if (arg === "--sign-out") {
+      const value = argv[index + 1];
       if (value === void 0 || value.startsWith("-"))
-        throw new Error("--public-origin requires a value");
+        throw new Error("--sign-out requires a device id, or `all` to sign out every device");
+      index++;
       consumed.add(index);
-      rawPublicOrigin = value;
+      rawSignOut = value;
       continue;
     }
-    if (arg.startsWith("--public-origin=")) {
-      rawPublicOrigin = arg.slice("--public-origin=".length);
+    if (arg.startsWith("--sign-out=")) {
+      rawSignOut = arg.slice("--sign-out=".length);
+      if (!rawSignOut) throw new Error("--sign-out requires a device id, or `all` to sign out every device");
       continue;
     }
     if (arg.startsWith("-")) continue;
-    if (arg === "up") {
-      upCommand = true;
-      consumed.add(index);
-      continue;
-    }
     throw new Error(
       `unexpected argument: ${arg} \u2014 Frizz takes no repository path, because one server serves every project on this machine. cd into the directory you want and run it with no arguments.`
     );
@@ -23349,9 +23955,6 @@ function parseCliArgs(argv) {
     if (!Number.isInteger(port) || port < 1 || port > 65535)
       throw new Error(`invalid --port value: ${rawPort}`);
   }
-  if ((upCommand || args2.has("--cloud")) && rawPublicOrigin !== void 0)
-    throw new Error("choose either up (the saved public hostname) or --public-origin, not both");
-  const host = rawHost === void 0 ? void 0 : normalizeBindHost(rawHost);
   const known = /* @__PURE__ */ new Set([
     "--app",
     "--no-app",
@@ -23360,15 +23963,14 @@ function parseCliArgs(argv) {
     "--stop",
     "--status",
     "--link",
-    "--cloud",
+    "--sandbox",
+    "--sessions",
+    "--sign-out",
     "--help",
     "-h",
     "--dev",
     "--prod",
     "--port",
-    "--host",
-    "--allowed-host",
-    "--public-origin",
     "--debug"
   ]);
   for (let index = 0; index < argv.length; index++) {
@@ -23378,13 +23980,23 @@ function parseCliArgs(argv) {
       index++;
       continue;
     }
-    if (arg.startsWith("--port=") || arg.startsWith("--host=") || arg.startsWith("--allowed-host=") || arg.startsWith("--public-origin=")) continue;
+    if (arg === "--sign-out") {
+      index++;
+      continue;
+    }
+    if (arg.startsWith("--port=") || arg.startsWith("--sign-out=")) continue;
     if (!known.has(arg)) throw new Error(`unknown option: ${arg}`);
   }
   if (args2.has("--detach"))
     throw new Error("--detach is no longer available; frizz-dev always runs in the foreground");
   if (args2.has("--app") && args2.has("--no-app"))
     throw new Error("choose either --app or --no-app");
+  if (args2.has("--sandbox")) {
+    for (const query of ["--stop", "--status", "--link", "--sessions", "--sign-out"]) {
+      if (args2.has(query) || argv.some((arg) => arg.startsWith(`${query}=`)))
+        throw new Error(`${query} asks the running board, and --sandbox starts a fresh disposable one \u2014 run ${query} without --sandbox`);
+    }
+  }
   return {
     noApp: args2.has("--no-app"),
     appMode: args2.has("--app"),
@@ -23392,65 +24004,71 @@ function parseCliArgs(argv) {
     foreground: true,
     stop: args2.has("--stop"),
     link: args2.has("--link"),
-    cloud: upCommand || args2.has("--cloud"),
+    sandbox: args2.has("--sandbox"),
+    sessions: args2.has("--sessions"),
+    ...rawSignOut !== void 0 ? { signOut: rawSignOut } : {},
     status: args2.has("--status"),
     help: args2.has("--help") || args2.has("-h"),
     dev: args2.has("--dev"),
     debug: args2.has("--debug"),
-    port,
-    host,
-    allowedHosts: normalizeAllowedHosts(rawAllowedHosts),
-    ...rawPublicOrigin === void 0 ? {} : { publicOrigin: normalizePublicOrigin(rawPublicOrigin) }
-  };
-}
-var EXPOSED_WARNING = "Anyone who can reach this address can run commands on this machine as you. Frizz has no login \u2014 only do this on a network you trust.";
-var REUSED_NETWORK_FLAGS_WARNING = "This joined the Frizz already running on this machine, so --host/--public-origin were ignored. Stop it first (frizz --stop) and relaunch with the flag to change how the board is reached.";
-var PUBLIC_ORIGIN_WARNING = "Frizz has no login of its own, so whatever sits in front of this origin IS the access control. Require authentication there (Cloudflare Access, Tailscale) \u2014 an unauthenticated tunnel lets anyone with the URL run commands on this machine as you.";
-function resolveBindSelection(options2, env = process.env, machineName = osHostname()) {
-  const fromEnv = env.FRIZZ_HOST?.trim();
-  const host = options2.host ?? (fromEnv ? normalizeBindHost(fromEnv) : LOOPBACK_BIND_HOST);
-  const exposed = bindHostIsExposed(host);
-  const ownNames = exposed ? machineHostNames(machineName) : [];
-  const allowedHosts = normalizeAllowedHosts([
-    ...options2.allowedHosts,
-    ...env.FRIZZ_ALLOWED_HOSTS ? [env.FRIZZ_ALLOWED_HOSTS] : [],
-    ...ownNames
-  ]);
-  const publicOriginRaw = options2.publicOrigin ?? env.FRIZZ_PUBLIC_ORIGIN?.trim();
-  const publicOrigin = publicOriginRaw ? normalizePublicOrigin(publicOriginRaw) : void 0;
-  return {
-    host,
-    exposed,
-    allowedHosts,
-    ...ownNames.length > 0 ? { hostname: ownNames[0] } : {},
-    ...publicOrigin ? { publicOrigin } : {}
+    port
   };
 }
 function boardAddress(url) {
   return url.includes("?") || url.endsWith("/") ? url : `${url}/`;
 }
-function networkUrls(port, host, interfaces = networkInterfaces, hostname) {
-  if (!bindHostIsExposed(host)) return [];
-  const urls = hostname ? [`http://${hostname}:${port}`] : [];
-  const wildcard = host === ALL_INTERFACES_BIND_HOST || host === "::";
-  const push = (address, family) => {
-    if (address.startsWith("fe80:")) return;
-    urls.push(family === "IPv6" ? `http://[${address}]:${port}` : `http://${address}:${port}`);
+function prepareSandbox(env = process.env, realHome = homedir10()) {
+  const home = mkdtempSync(join13(tmpdir2(), "frizz-sandbox-"));
+  shareCredentials(realHome, home);
+  env.HOME = home;
+  env.USERPROFILE = home;
+  const project = join13(home, "sandbox");
+  mkdirSync10(project, { recursive: true });
+  writeFileSync10(join13(project, "README.md"), "# frizz sandbox\n\nA throwaway project; everything here is deleted when the sandbox exits.\n");
+  try {
+    execFileSync3("git", ["init", "-q"], { cwd: project, stdio: "ignore" });
+  } catch {
+    throw new Error("--sandbox mints a throwaway git repository and git is not available \u2014 install git, or play in a repo of your own with a temp HOME");
+  }
+  process.chdir(project);
+  return { home, project };
+}
+function shareCredentials(realHome, home) {
+  const link = (from, to) => {
+    try {
+      symlinkSync2(from, to);
+    } catch {
+    }
   };
-  if (!wildcard) {
-    push(host, host.includes(":") ? "IPv6" : "IPv4");
-    return urls;
+  mkdirSync10(join13(realHome, ".frizz"), { recursive: true });
+  mkdirSync10(join13(home, ".frizz"), { recursive: true });
+  link(join13(realHome, ".frizz", "identity.key"), join13(home, ".frizz", "identity.key"));
+  if (existsSync5(join13(realHome, ".config", "gh"))) {
+    mkdirSync10(join13(home, ".config"), { recursive: true });
+    link(join13(realHome, ".config", "gh"), join13(home, ".config", "gh"));
   }
-  for (const entries of Object.values(interfaces())) {
-    for (const entry of entries ?? []) {
-      if (entry.internal) continue;
-      if (host === ALL_INTERFACES_BIND_HOST && entry.family !== "IPv4") continue;
-      push(entry.address, entry.family);
+  const cloudflared = join13(realHome, ".cloudflared");
+  if (existsSync5(cloudflared)) {
+    mkdirSync10(join13(home, ".cloudflared"), { recursive: true });
+    for (const entry of readdirSync3(cloudflared)) {
+      if (entry === "cert.pem" || entry.endsWith(".json")) link(join13(cloudflared, entry), join13(home, ".cloudflared", entry));
     }
   }
-  return urls;
+  for (const entry of [".claude", ".claude.json", ".codex"]) {
+    if (existsSync5(join13(realHome, entry))) link(join13(realHome, entry), join13(home, entry));
+  }
+  if (process.platform === "darwin" && existsSync5(join13(realHome, "Library", "Keychains"))) {
+    mkdirSync10(join13(home, "Library"), { recursive: true });
+    link(join13(realHome, "Library", "Keychains"), join13(home, "Library", "Keychains"));
+  }
+}
+function cleanupSandbox(home) {
+  try {
+    rmSync8(home, { recursive: true, force: true });
+  } catch {
+  }
 }
-function resolveLaunchIntent(cwd = process.cwd(), home = homedir9(), env = process.env) {
+function resolveLaunchIntent(cwd = process.cwd(), home = homedir10(), env = process.env) {
   const candidate = realpathSync5(discoverProjectRoot(cwd, home));
   const known = isExistingProjectRoot(candidate) || findByPath(candidate, home) !== void 0;
   if ((known || hasProjectMarker(candidate)) && !isHomeDirectory(candidate, home))
@@ -23470,7 +24088,7 @@ function mostRecentProject(home, env) {
   }
   return void 0;
 }
-function resolveWorkspace(cwd = process.cwd(), home = homedir9(), env = process.env) {
+function resolveWorkspace(cwd = process.cwd(), home = homedir10(), env = process.env) {
   let gitRoot;
   try {
     gitRoot = execFileSync3("git", ["rev-parse", "--show-toplevel"], {
@@ -23704,7 +24322,7 @@ init_project_launch();
 init_project_launch();
 import { fork } from "node:child_process";
 import { randomUUID as randomUUID5 } from "node:crypto";
-import { existsSync as existsSync5, mkdirSync as mkdirSync11, readFileSync as readFileSync12 } from "node:fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync11, readFileSync as readFileSync12 } from "node:fs";
 import { createServer as createNetServer } from "node:net";
 import { basename as basename6, dirname as dirname10, extname as extname2, isAbsolute as isAbsolute3, relative, resolve as resolve4, sep as sep2 } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -23745,12 +24363,15 @@ function devCrashRetryDelay(attempt) {
   return Math.min(DEV_CRASH_RETRY_BASE_MS * 2 ** exponent, DEV_CRASH_RETRY_MAX_MS);
 }
 var SUPERVISOR_ESCALATE_GRACE_MS = 500;
+var SUPERVISOR_DRAIN_DEADLINE_MS = CHILD_STOP_TIMEOUT_MS + 5e3;
 function stripPrefix(line) {
   return line.startsWith("[frizz] ") ? line.slice("[frizz] ".length) : line;
 }
 function createSupervisorShutdownHandler(options2) {
   const now = options2.now ?? (() => Date.now());
   const escalateAfterMs = options2.escalateAfterMs ?? SUPERVISOR_ESCALATE_GRACE_MS;
+  const drainDeadlineMs = options2.drainDeadlineMs ?? SUPERVISOR_DRAIN_DEADLINE_MS;
+  const scheduleForce = options2.scheduleForce ?? ((callback, delayMs) => setTimeout(callback, delayMs));
   let startedAt = 0;
   let stopping = false;
   let decided = false;
@@ -23764,20 +24385,27 @@ function createSupervisorShutdownHandler(options2) {
     }
     options2.exit(code);
   };
+  const abandon = (reason) => {
+    options2.error?.(`[frizz] ${reason} \u2014 abandoning the graceful drain`);
+    try {
+      options2.force?.();
+    } catch (error) {
+      options2.error?.(`[frizz] forced supervisor stop failed: ${error instanceof Error ? error.message : error}`);
+    }
+    decide(1);
+  };
   return () => {
     if (stopping) {
       if (decided || now() - startedAt < escalateAfterMs) return;
-      options2.error?.("[frizz] second stop signal \u2014 abandoning the graceful drain");
-      try {
-        options2.force?.();
-      } catch (error) {
-        options2.error?.(`[frizz] forced supervisor stop failed: ${error instanceof Error ? error.message : error}`);
-      }
-      decide(1);
+      abandon("second stop signal");
       return;
     }
     stopping = true;
     startedAt = now();
+    options2.onStop?.();
+    scheduleForce(() => {
+      if (!decided) abandon(`graceful stop did not finish in ${drainDeadlineMs}ms`);
+    }, drainDeadlineMs).unref?.();
     void options2.close().then(
       () => decide(0),
       (error) => {
@@ -23987,6 +24615,7 @@ var Supervisor = class {
       publicOrigin: opts.publicOrigin,
       onCodeConsumed: opts.onCodeConsumed,
       sessionKey: opts.sessionKey,
+      sessionDirectory: opts.sessionDirectory,
       childPort: () => this.childPort,
       restart: () => this.restartFromBrowser(),
       updateRestart: this.updateRestart ? () => this.updateFromBrowser() : void 0,
@@ -24012,6 +24641,9 @@ var Supervisor = class {
     return this.boot;
   }
   /** Mint a single-use access link for the public origin, or null when none is declared. */
+  setPublicOrigin(origin) {
+    this.publicProxy.setPublicOrigin(origin);
+  }
   issueAccessLink() {
     const code = this.publicProxy.issueAccessCode();
     if (!code) return null;
@@ -24027,7 +24659,7 @@ var Supervisor = class {
       await this.publicProxy.listen();
       if (this.watchEnabled) {
         const settled = await Promise.allSettled(
-          this.roots.filter(existsSync5).map((root) => this.watchSubscribe(root, (err, events) => this.onWatch(err, events), {
+          this.roots.filter(existsSync6).map((root) => this.watchSubscribe(root, (err, events) => this.onWatch(err, events), {
             ignore: DEV_WATCH_IGNORE
           }))
         );
@@ -24082,7 +24714,7 @@ var Supervisor = class {
     if (this.closed) return;
     this.reloadLauncher ||= reloadLauncher;
     if (this.debounce) clearTimeout(this.debounce);
-    const run2 = () => {
+    const run3 = () => {
       this.debounce = null;
       const scope = this.reloadLauncher ? "control plane + launcher" : "control plane";
       this.logLine(
@@ -24091,8 +24723,8 @@ var Supervisor = class {
       this.writeStatus("restarting", reason);
       void this.restart();
     };
-    if (immediate) run2();
-    else this.debounce = setTimeout(run2, delayMs);
+    if (immediate) run3();
+    else this.debounce = setTimeout(run3, delayMs);
   }
   async restart() {
     if (this.restartRunning) {
@@ -24479,7 +25111,7 @@ async function startDevSupervisor(opts) {
 }
 
 // src/production-update.ts
-import { execFile as execFile3, spawn as spawn3 } from "node:child_process";
+import { execFile as execFile4, spawn as spawn3 } from "node:child_process";
 var PRODUCTION_REEXEC_FLAG = "--_frizz-production-reexec";
 function compareReleaseVersions(a, b) {
   const parse2 = (value) => {
@@ -24528,7 +25160,7 @@ function handoffToRegistrySuccessor(plan, request, adapter) {
 var npmRegistryReleaseAdapter = {
   latestVersion(packageName) {
     return new Promise((resolveVersion, reject) => {
-      execFile3("npm", ["view", `${packageName}@latest`, "version", "--json"], { encoding: "utf8" }, (error, stdout) => {
+      execFile4("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);
@@ -24649,11 +25281,7 @@ if (options.help) {
   console.log(
     `Frizz production launcher
 
-Usage: npx ${PACKAGE_NAME} [up] [options]
-
-Commands:
-  up                     serve at the saved public hostname and run its tunnel; asked once,
-                         then remembered
+Usage: npx ${PACKAGE_NAME} [options]
 
 Run it in the directory you want to work in. One server serves EVERY project on this machine,
 each at its own /project/<name> URL, so a second run joins the one already going. Runs the
@@ -24663,45 +25291,30 @@ for a source checkout.
 Options:
   --no-app               print the URL without opening a browser
   --port <port>          request a fixed port for a new workspace server
-  --host [address]       serve on a network address instead of loopback (bare --host means 0.0.0.0)
-  --allowed-host <name>  with --host, also accept this DNS name as the board's address (repeatable)
-  --public-origin <url>  serve behind a proxy/tunnel reachable at this exact origin
-  --cloud                alias of up, for saved commands
+  --sandbox              a disposable Frizz to try things in: throwaway home and project, its
+                         own port, deleted when this terminal closes; credentials (gh,
+                         cloudflared, Claude, Codex, the machine's frizz.sh key) are shared
   --link                 print a fresh single-use access link for the running board
+  --sessions             list the devices signed in to the running board
+  --sign-out <id|all>    sign one device out, or every one of them
   --debug                stream the full event feed to the terminal instead of the compact readout
   -h, --help             show this help
 
-Environment:
-  FRIZZ_HOST              same as --host
-  FRIZZ_ALLOWED_HOSTS     same as --allowed-host, comma separated
-  FRIZZ_PUBLIC_ORIGIN     same as --public-origin
-
---host puts a board that can run shell commands as you on the network, and Frizz has no login: anyone
-who reaches the port controls it. Only do this on a network you trust. An IP address and this
-machine's own hostname work as-is; any other DNS name must be listed with --allowed-host ("*"
-allows any).
 
---public-origin serves the board through a tunnel or reverse proxy without putting it on the LAN
-at all \u2014 Frizz stays on loopback and the tunnel dials it. It prints a SINGLE-USE access link, and
-shows it as a QR so you can scan it from a phone; press L for a fresh one at any time. Scanning it
-trades the code for a session cookie, so the link itself stops working the moment it is used.`
+To reach the board from a phone or another machine, press R in the terminal running it: a short
+walkthrough sets up a frizz.sh name, a Cloudflare Tunnel, Tailscale, or a proxy of your own, and
+remembers the choice, so a plain launch serves it from then on. The board stays on loopback and
+shows a single-use sign-in link as a QR; press L for a fresh one, or run --link from another shell.`
   );
   process.exit(0);
 }
 if (options.dev || rawArgs.includes("--prod")) fail("--dev and --prod are not available from the registry launcher");
-var cloudConfig = options.cloud ? readCloudConfig() : null;
-if (cloudConfig) options.publicOrigin = `https://${cloudConfig.hostname}`;
-var tunnel = null;
+var sandbox = options.sandbox ? prepareSandbox() : null;
+if (sandbox) process.on("exit", () => cleanupSandbox(sandbox.home));
+var remote = null;
+var paneHost = null;
 var accessPane = null;
 var activeAccessLink = null;
-var justClaimed = false;
-var bind = (() => {
-  try {
-    return resolveBindSelection(options, process.env);
-  } catch (error) {
-    return fail(error);
-  }
-})();
 var launchIntent;
 var workspace = (() => {
   try {
@@ -24726,6 +25339,15 @@ var workspace = (() => {
   }
 })();
 process.chdir(workspace.root);
+if (options.sessions || options.signOut !== void 0) {
+  const running = liveWorkspaceOwner(workspace.stateDir, workspaceLaunchTarget(workspace));
+  if (!running?.port) {
+    console.error("frizz: no board is running for this workspace");
+    process.exit(1);
+  }
+  if (options.signOut !== void 0) await signOutSession(running.port, options.signOut);
+  await listSessions(running.port);
+}
 if (options.link) {
   const running = liveWorkspaceOwner(workspace.stateDir, workspaceLaunchTarget(workspace));
   if (!running?.port) {
@@ -24770,7 +25392,7 @@ function ownSlug() {
   try {
     return registerProject(
       { dir: workspace.root, id: target.projectId, remoteOwner: resolveProjectLabel(workspace.root)?.split("/")[0] },
-      homedir10()
+      homedir11()
     ).entry?.slug;
   } catch {
     return void 0;
@@ -24821,27 +25443,20 @@ async function openOrPrint(port, reused, path = "") {
   } else {
     readout?.settle("browser", "done", url);
   }
-  const network = reused ? [] : networkUrls(port, bind.host, void 0, bind.hostname);
-  const publicOrigin = reused ? void 0 : bind.publicOrigin;
-  const networkFlagsIgnored = reused && (bind.publicOrigin !== void 0 || bindHostIsExposed(bind.host));
-  const warnings = [
-    ...network.length > 0 ? [EXPOSED_WARNING] : [],
-    ...publicOrigin ? [PUBLIC_ORIGIN_WARNING] : [],
-    ...networkFlagsIgnored ? [REUSED_NETWORK_FLAGS_WARNING] : []
-  ];
+  const publicOrigin = reused ? void 0 : remote?.origin();
+  const warnings = [];
+  if (sandbox) warnings.push(`Sandbox: everything here is throwaway (${sandbox.home}) and is deleted when this terminal closes.`);
   if (!readout) {
     console.log(`${reused ? "reusing" : "started"} Frizz ${PACKAGE_VERSION} for ${workspace.root}`);
     console.log(url);
-    for (const address of network) console.log(address);
     if (publicOrigin) console.log(activeAccessLink?.url ?? `${publicOrigin}/`);
     for (const warning of warnings) console.log(warning);
     return;
   }
-  const home = homedir10();
+  const home = homedir11();
   readout.ready(
     [
       { label: "Local", value: boardAddress(url), accent: true },
-      ...network.map((address) => ({ label: "Network", value: `${address}/`, accent: true })),
       ...publicOrigin ? [{ label: "Public", value: activeAccessLink?.url ?? `${publicOrigin}/`, accent: true }] : [],
       { label: "Project", value: `${workspace.name} \u2014 ${tildePath(workspace.root, home)}` },
       ...logger.file ? [{ label: "Logs", value: tildePath(logger.file, home) }] : []
@@ -24849,10 +25464,11 @@ async function openOrPrint(port, reused, path = "") {
     reused ? (
       // This launch owns nothing and exits immediately, so ctrl-c would not stop what it reopened.
       "reopened the server already running for this project \xB7 stop it from the terminal that started it"
-    ) : options.debug ? void 0 : "press ctrl-c to stop \xB7 run with --debug for the full event feed",
+    ) : options.debug ? void 0 : publicOrigin ? "press L for a fresh sign-in link \xB7 R to change how this board is reached \xB7 ctrl-c to stop" : "press R to reach this board from a phone or another machine \xB7 ctrl-c to stop",
     {
       ...reused ? { status: `already running on port ${port}` } : {},
-      ...warnings.length > 0 ? { warning: warnings.join(" ") } : {}
+      ...warnings.length > 0 ? { warning: warnings.join(" ") } : {},
+      ...activeAccessLink && !reused ? { qr: renderQrLines(activeAccessLink.url) } : {}
     }
   );
 }
@@ -24889,21 +25505,17 @@ async function runSupervisor(port, token) {
   void refreshUpdateAvailable();
   const updateAvailablePoll = setInterval(() => void refreshUpdateAvailable(), 30 * 60 * 1e3);
   updateAvailablePoll.unref();
-  if (options.cloud && !cloudConfig) {
-    cloudConfig = await establishCloudConfig(await promptForCloudName(), port);
-    writeCloudConfig(cloudConfig);
-    bind.publicOrigin = `https://${cloudConfig.hostname}`;
-    justClaimed = true;
-  }
   const supervisor = await startDevSupervisor({
     port,
-    host: bind.host,
-    allowedHosts: bind.allowedHosts,
-    ...bind.publicOrigin ? { publicOrigin: bind.publicOrigin } : {},
+    host: LOOPBACK_BIND_HOST,
+    allowedHosts: [],
     // A spent code repaints the open QR pane as stale, so nobody photographs a dead link.
     onCodeConsumed: () => accessPane?.markConsumed(),
     // Persisted beside the project's other state, so a restart does not sign every device out.
-    ...bind.publicOrigin ? { sessionKey: loadOrCreateSessionKey(workspace.stateDir) } : {},
+    // Always, not only when public: the origin can be switched on later (press R), and a phone signed
+    // in through one name stays signed in through the next.
+    sessionKey: loadOrCreateSessionKey(workspace.stateDir),
+    sessionDirectory: fileSessionDirectory(workspace.stateDir),
     cwd: workspace.root,
     stateDir: workspace.stateDir,
     launchTarget: target,
@@ -24945,49 +25557,42 @@ async function runSupervisor(port, token) {
       process.exit(0);
     }
   });
-  activeAccessLink = bind.publicOrigin ? supervisor.issueAccessLink() : null;
-  if (cloudConfig) {
-    if (isRelayConfig(cloudConfig)) {
-      if (!justClaimed) {
-        await resolveRunToken(cloudConfig, port, homedir10(), (message) => {
-          logger.warn("relay", message);
-          console.error(`frizz: ${message}`);
-        });
-      }
-      tunnel = await startRelay(cloudConfig, port, homedir10(), (message) => logger.info("relay", message));
-      logger.info("relay", `serving ${cloudConfig.hostname} through the Frizz relay`);
-    } else {
-      const runToken = justClaimed ? readTunnelToken() : await resolveRunToken(cloudConfig, port, homedir10(), (message) => {
-        logger.warn("tunnel", message);
-        console.error(`frizz: ${message}`);
-      });
-      tunnel = startTunnel(
-        cloudConfig,
-        (code) => {
-          if (code === 0 || code === null) return;
-          logger.error("tunnel", `cloudflared exited with code ${code}; the public hostname is now unreachable`);
-        },
-        (message) => {
-          logger.error("tunnel", message);
-          console.error(`frizz: ${message}`);
-        },
-        homedir10(),
-        runToken ?? void 0
-      );
-      logger.info("tunnel", `running cloudflared for ${cloudConfig.hostname}`);
-    }
+  remote = createRemoteController({ host: supervisor, port, log: logger, say: (message) => console.error(`frizz: ${message}`) });
+  try {
+    await remote.serveSaved();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error("remote", message);
+    console.error(`frizz: the saved remote setup could not start: ${message}`);
   }
-  if (bind.publicOrigin) accessPane = installAccessPane({ issue: () => supervisor.issueAccessLink() });
+  activeAccessLink = remote.origin() ? supervisor.issueAccessLink() : null;
+  accessPane = createAccessPane({ issue: () => supervisor.issueAccessLink() });
+  const remotePane = createRemotePane({
+    port,
+    current: () => remote?.current() ?? null,
+    apply: (next, applyOptions) => remote.apply(next, applyOptions),
+    claim: (name) => establishCloudConfig(name, port),
+    issueLink: () => supervisor.issueAccessLink(),
+    probes: { github: probeGithub, cloudflared: probeCloudflared, tailscale: probeTailscale },
+    onChanged: (config) => logger.info("remote", config ? `reached at https://${config.hostname}` : "loopback only"),
+    sandbox: sandbox !== null
+  });
+  paneHost = installPaneHost({ bindings: { l: accessPane, L: accessPane, r: remotePane, R: remotePane } });
   const stop = createSupervisorShutdownHandler({
     close: () => supervisor.close(),
     force: () => supervisor.forceStop(),
     release: () => owner.release(),
+    // Acknowledge the first signal on the spot; the drain that follows is bounded but not instant.
+    onStop: () => {
+      logger.info("launcher", "stop signal received; draining the control plane");
+      readout?.notice("progress", "Stopping", "draining the control plane \u2014 press ctrl-c again to force");
+    },
     exit: (code) => {
       logger.info("launcher", `stopped with code ${code}`);
-      accessPane?.dispose();
-      tunnel?.stop();
+      paneHost?.dispose();
+      remote?.stop();
       const suffix = logger.file ? `
-  log: ${tildePath(logger.file, homedir10())}` : "";
+  log: ${tildePath(logger.file, homedir11())}` : "";
       process.stdout.write(
         code === 0 ? `
   Frizz stopped. Running agents keep going \u2014 they are detached daemons.${suffix}
@@ -25031,7 +25636,7 @@ try {
   let release = await acquireGlobalLaunchLock();
   let portReservation;
   try {
-    const allocation = await allocatePort(options.port, readPreferredPort(workspace.stateDir), { host: bind.host });
+    const allocation = await allocatePort(options.port, readPreferredPort(workspace.stateDir), { host: LOOPBACK_BIND_HOST });
     const port = allocation.port;
     portReservation = allocation.release;
     const running = runSupervisor(port, claim.lease.token);