@tarfa/cli 0.0.0 → 0.1.1

package/dist/serve.js

@@ -0,0 +1,4293 @@
+#!/usr/bin/env node
+import {
+  CodexAppServer,
+  CodexAppServerDown,
+  DEVICE_REFUSED,
+  FileClaudeSessionsStore,
+  FileDeviceStore,
+  FileHiddenFoldersStore,
+  FilePairingStore,
+  FileParkedStore,
+  FileRecentStore,
+  FileStatusStore,
+  FsFileWriter,
+  FsProjectLister,
+  GitRepoRemote,
+  IN_BAND_REFUSAL,
+  IkResponder,
+  KNOWN_CLIS,
+  MAX_FRAME_BYTES,
+  MAX_MESSAGE_BYTES,
+  PROTOCOL_VERSION,
+  REFUSAL,
+  SecureSession,
+  ShortWorkspaceIds,
+  TmuxAdapter,
+  WrongStaticKeyError,
+  assertServerConfig,
+  audioMediaType,
+  b64url,
+  browseDir,
+  childEnv,
+  cliOfCommand,
+  configWarnings,
+  constantTimeEqual,
+  createWorkspace,
+  deriveWorkspaceName,
+  detectInstalled,
+  deviceFingerprint,
+  enrolDevice,
+  enrolmentMode,
+  exactTarget,
+  formatAgentMessage,
+  fsIsDirectory,
+  getRecentPaths,
+  handshakeFrame,
+  handshakePattern,
+  imageMediaType,
+  isEntrypoint,
+  isHiddenPath,
+  isNoDaemonCodex,
+  isWorkspaceStatus,
+  listWorkspaces,
+  loadConfig,
+  loadOrCreateAgentKeys,
+  locateAgentEnv,
+  loginShellResolver,
+  mayEnrol,
+  migrateStateDir,
+  packageVersion,
+  parseBrowserAgentMessage,
+  parseBrowserClientMessage,
+  parseClientMessage,
+  parseDeviceHello,
+  pathWithinRoots,
+  pdfMediaType,
+  readHandshakeFrame,
+  redeemPairing,
+  relationOf,
+  runsClaude,
+  sessionOfCodexThread,
+  standingOf,
+  startTimer,
+  systemClock,
+  systemPathResolver,
+  withLegacyEnv,
+  writeFileAtomic
+} from "./chunk-LXIGP77E.js";
+
+// src/serve.ts
+import { homedir as homedir2 } from "node:os";
+import { join as join7 } from "node:path";
+
+// src/application/claude-voice.ts
+var HOLD_REPEAT_MS = 30;
+var LEAD_MS = 1e3;
+var TAIL_MS = 500;
+var IDLE_MS = 5e3;
+var MAX_MS = 5 * 6e4;
+var DRAIN_MS = LEAD_MS + 1e4;
+function voiceSettingsProblem(settings) {
+  const s = typeof settings === "object" && settings !== null ? settings : {};
+  const enabled = s.voice?.enabled ?? s.voiceEnabled;
+  if (enabled !== true) return "Voice is off in Claude Code on this machine: run /voice in a workspace first";
+  if (s.voice?.mode !== void 0 && s.voice.mode !== "hold") {
+    return "Claude voice needs Claude Code\u2019s voice mode set to hold (/config)";
+  }
+  return null;
+}
+var errorText = (e) => e instanceof Error ? e.message : String(e);
+var Dictation = class {
+  constructor(deps, pressSpace, release) {
+    this.deps = deps;
+    this.pressSpace = pressSpace;
+    this.release = release;
+    this.done = new Promise((resolve) => this.resolve = resolve);
+    this.max = setTimeout(() => this.abort("Dictation stopped: it ran past 5 minutes"), MAX_MS);
+    this.touch();
+    void this.begin();
+  }
+  deps;
+  pressSpace;
+  release;
+  done;
+  resolve;
+  queue = [];
+  stream = null;
+  ended = false;
+  finished = false;
+  hold;
+  lead;
+  idle;
+  draining;
+  max;
+  write(pcm) {
+    if (this.finished || this.ended) return;
+    this.touch();
+    if (this.stream) this.stream.write(pcm);
+    else this.queue.push(pcm);
+  }
+  end() {
+    if (this.finished || this.ended) return;
+    this.ended = true;
+    clearTimeout(this.idle);
+    if (this.stream) this.drain(this.stream);
+  }
+  abort(reason) {
+    this.stream?.abort();
+    this.finish(reason);
+  }
+  async begin() {
+    const problem = voiceSettingsProblem(await this.deps.settings.read().catch(() => null));
+    if (this.finished) return;
+    if (problem) return this.finish(problem);
+    const press = () => {
+      try {
+        this.pressSpace();
+      } catch {
+      }
+    };
+    this.hold = setInterval(press, HOLD_REPEAT_MS);
+    press();
+    this.lead = setTimeout(() => this.play(), LEAD_MS);
+  }
+  play() {
+    if (this.finished) return;
+    let stream;
+    try {
+      stream = this.deps.player.open();
+    } catch (e) {
+      return this.finish(errorText(e));
+    }
+    this.stream = stream;
+    stream.played.catch((e) => this.finish(errorText(e)));
+    for (const pcm of this.queue.splice(0)) stream.write(pcm);
+    if (this.ended) this.drain(stream);
+  }
+  drain(stream) {
+    this.draining = setTimeout(() => this.abort("Dictation stopped: playback did not finish"), DRAIN_MS);
+    void stream.end().then(
+      () => setTimeout(() => this.finish(null), TAIL_MS),
+      (e) => this.finish(errorText(e))
+    );
+  }
+  touch() {
+    clearTimeout(this.idle);
+    this.idle = setTimeout(() => this.abort("Dictation stopped: the phone stopped sending audio"), IDLE_MS);
+  }
+  finish(result) {
+    if (this.finished) return;
+    this.finished = true;
+    clearInterval(this.hold);
+    clearTimeout(this.lead);
+    clearTimeout(this.idle);
+    clearTimeout(this.draining);
+    clearTimeout(this.max);
+    this.queue = [];
+    this.release();
+    this.resolve(result);
+  }
+};
+var ClaudeVoice = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  busy = false;
+  available() {
+    return this.deps.player.available();
+  }
+  start(pressSpace) {
+    if (this.busy) {
+      const done = Promise.resolve("Claude voice is already in use on this machine");
+      return { write: () => void 0, end: () => void 0, abort: () => void 0, done };
+    }
+    this.busy = true;
+    return new Dictation(this.deps, pressSpace, () => this.busy = false);
+  }
+};
+
+// src/infrastructure/aplay-voice-player.ts
+import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+var LOOPBACK_DEVICE = "plughw:Loopback,0";
+var aplayArgs = (device) => ["-q", "-D", device, "-t", "raw", "-f", "S16_LE", "-c", "1", "-r", "16000", "-"];
+var APLAY_ARGS = aplayArgs(LOOPBACK_DEVICE);
+var AplayVoicePlayer = class {
+  constructor(command = "aplay", args = APLAY_ARGS, cardsPath = "/proc/asound/cards") {
+    this.command = command;
+    this.args = args;
+    this.cardsPath = cardsPath;
+  }
+  command;
+  args;
+  cardsPath;
+  // Whether snd-aloop is loaded: without it there is no virtual mic to play into.
+  async available() {
+    try {
+      return /\[Loopback\s*\]/.test(await readFile(this.cardsPath, "utf8"));
+    } catch {
+      return false;
+    }
+  }
+  open() {
+    const child = spawn(this.command, this.args, { env: childEnv(), stdio: ["pipe", "ignore", "pipe"] });
+    let stderr = "";
+    child.stderr.on("data", (d) => {
+      stderr = (stderr + d.toString()).slice(-2e3);
+    });
+    const failure = () => stderr.split("\n").filter((l) => l.trim() && !l.includes("underrun")).at(-1)?.trim();
+    const played = new Promise((resolve, reject) => {
+      child.on("error", (e) => reject(new Error(`aplay: ${e.message}`)));
+      child.on(
+        "close",
+        (code, signal) => code === 0 ? resolve() : reject(new Error(`aplay: ${failure() ?? `exited with ${code ?? signal}`}`))
+      );
+    });
+    played.catch(() => void 0);
+    child.stdin.on("error", () => void 0);
+    return {
+      played,
+      write: (pcm) => {
+        if (child.stdin.writable) child.stdin.write(pcm);
+      },
+      end: () => {
+        child.stdin.end();
+        return played;
+      },
+      // Not SIGTERM: aplay's handler only flags the abort and goes back to reading stdin,
+      // keeping the device open, so every later dictation failed "Device or resource busy".
+      // Nothing is left to flush on an abort, and the kernel frees the device on exit.
+      abort: () => {
+        child.stdin.destroy();
+        child.kill("SIGKILL");
+      }
+    };
+  }
+};
+var FileClaudeSettings = class {
+  constructor(path) {
+    this.path = path;
+  }
+  path;
+  async read() {
+    try {
+      return JSON.parse(await readFile(this.path, "utf8"));
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/infrastructure/file-launchers-store.ts
+import { readFile as readFile2, mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+var MAX_LAUNCHERS = 20;
+var FileLaunchersStore = class {
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  filePath;
+  // Handlers run concurrently and each write is read-modify-write, so they are queued. One
+  // process owns the file, hence no file lock.
+  queue = Promise.resolve();
+  async list() {
+    let parsed;
+    try {
+      parsed = JSON.parse(await readFile2(this.filePath, "utf8"));
+    } catch {
+      return [];
+    }
+    return Array.isArray(parsed) ? [...new Set(parsed.filter((c) => typeof c === "string" && c !== ""))] : [];
+  }
+  remember(command) {
+    return this.serialized(async () => {
+      const all = await this.list();
+      if (all.includes(command)) return;
+      await this.persist([...all, command].slice(-MAX_LAUNCHERS));
+    });
+  }
+  forget(command) {
+    return this.serialized(async () => {
+      const all = await this.list();
+      const rest = all.filter((c) => c !== command);
+      if (rest.length !== all.length) await this.persist(rest);
+    });
+  }
+  serialized(task) {
+    const run = this.queue.then(task);
+    this.queue = run.catch(() => void 0);
+    return run;
+  }
+  async persist(commands) {
+    await mkdir(dirname(this.filePath), { recursive: true });
+    await writeFileAtomic(this.filePath, JSON.stringify(commands, null, 2));
+  }
+};
+
+// src/infrastructure/file-keyterms-store.ts
+import { readFile as readFile3 } from "node:fs/promises";
+
+// src/application/parse-keyterms.ts
+var MAX_KEYTERMS = 100;
+var MAX_TERM_LENGTH = 50;
+var MAX_TERM_WORDS = 5;
+var FORBIDDEN = /[<>{}[\]\\]/;
+function parseKeyterms(raw) {
+  const seen = /* @__PURE__ */ new Set();
+  const terms = [];
+  for (const line of raw.split(/\r?\n/)) {
+    const term = line.trim();
+    if (term.length === 0 || term.startsWith("#")) continue;
+    if (term.length > MAX_TERM_LENGTH || FORBIDDEN.test(term)) continue;
+    if (term.split(/\s+/).length > MAX_TERM_WORDS) continue;
+    const key = term.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    terms.push(term);
+    if (terms.length === MAX_KEYTERMS) break;
+  }
+  return terms;
+}
+
+// src/infrastructure/file-keyterms-store.ts
+var FileKeytermsStore = class {
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  filePath;
+  async list() {
+    try {
+      return parseKeyterms(await readFile3(this.filePath, "utf8"));
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/infrastructure/proc-system-stats.ts
+import { readFile as readFile4 } from "node:fs/promises";
+var CGROUP_ROOT = "/sys/fs/cgroup";
+var readText = (path) => readFile4(path, "utf8");
+function parseCpuSample(stat5) {
+  const line = stat5.split("\n").find((l) => l.startsWith("cpu "));
+  if (!line) return null;
+  const fields = line.trim().split(/\s+/).slice(1).map(Number);
+  if (fields.length < 4 || fields.some(Number.isNaN)) return null;
+  const total = fields.reduce((sum, n) => sum + n, 0);
+  const idle = (fields[3] ?? 0) + (fields[4] ?? 0);
+  return { busy: total - idle, total };
+}
+function parseMeminfo(meminfo) {
+  const values = /* @__PURE__ */ new Map();
+  for (const line of meminfo.split("\n")) {
+    const match = /^(\w+):\s+(\d+) kB$/.exec(line.trim());
+    if (match?.[1]) values.set(match[1], Number(match[2]) * 1024);
+  }
+  return values;
+}
+function parseStall(pressure) {
+  const match = /^some\s+avg10=([\d.]+)/m.exec(pressure);
+  return match ? Number(match[1]) : void 0;
+}
+function parseKeyedCounters(raw) {
+  const values = /* @__PURE__ */ new Map();
+  for (const line of raw.split("\n")) {
+    const [key, value] = line.trim().split(/\s+/);
+    if (key && value !== void 0 && /^\d+$/.test(value)) values.set(key, Number(value));
+  }
+  return values;
+}
+function parseLimit(raw) {
+  const value = raw.trim();
+  if (value === "max") return null;
+  const bytes = Number(value);
+  return Number.isFinite(bytes) ? bytes : null;
+}
+var ProcSystemStats = class {
+  constructor(read_ = readText, platform = process.platform) {
+    this.read_ = read_;
+    this.platform = platform;
+  }
+  read_;
+  platform;
+  previous = null;
+  async read() {
+    if (this.platform !== "linux") return null;
+    const cpuPercent = await this.sampleCpu();
+    if (cpuPercent === null) return null;
+    let meminfo;
+    try {
+      meminfo = parseMeminfo(await this.read_("/proc/meminfo"));
+    } catch {
+      return null;
+    }
+    const total = meminfo.get("MemTotal");
+    const available = meminfo.get("MemAvailable");
+    if (total === void 0 || available === void 0) return null;
+    const swapTotal = meminfo.get("SwapTotal") ?? 0;
+    const swapFree = meminfo.get("SwapFree") ?? 0;
+    return {
+      cpuPercent,
+      memory: { usedBytes: total - available, totalBytes: total },
+      swapUsedBytes: swapTotal - swapFree,
+      ...await this.readLimit() ?? {}
+    };
+  }
+  // CPU usage is a delta, so the first sample only primes the next one.
+  async sampleCpu() {
+    let sample;
+    try {
+      sample = parseCpuSample(await this.read_("/proc/stat"));
+    } catch {
+      return null;
+    }
+    if (!sample) return null;
+    const previous = this.previous;
+    this.previous = sample;
+    if (!previous) return null;
+    const window = sample.total - previous.total;
+    if (window <= 0) return null;
+    return (sample.busy - previous.busy) / window * 100;
+  }
+  async readLimit() {
+    let cgroup;
+    try {
+      cgroup = (await this.read_("/proc/self/cgroup")).trim().replace(/^0::/, "");
+    } catch {
+      return null;
+    }
+    const segments = cgroup.split("/").filter(Boolean);
+    for (let depth = segments.length; depth >= 0; depth -= 1) {
+      const dir = [CGROUP_ROOT, ...segments.slice(0, depth)].join("/");
+      const [high, max] = await Promise.all([
+        this.readNumber(`${dir}/memory.high`),
+        this.readNumber(`${dir}/memory.max`)
+      ]);
+      const totalBytes = Math.min(...[high, max].filter((n) => n !== null));
+      if (!Number.isFinite(totalBytes)) continue;
+      const usedBytes = await this.readNumber(`${dir}/memory.current`);
+      if (usedBytes === null) continue;
+      const stallPercent = await this.readStall(`${dir}/memory.pressure`);
+      const reclaimableBytes = await this.readReclaimable(`${dir}/memory.stat`);
+      const oomKills = await this.readCounter(`${dir}/memory.events`, "oom_kill");
+      return {
+        limit: {
+          usedBytes,
+          totalBytes,
+          ...stallPercent !== void 0 && { stallPercent },
+          // Only a real byte value is a kill line; an uncapped cgroup reads the literal
+          // "max", and reporting that as a ceiling would make the client's headroom fiction.
+          ...max !== null && { maxBytes: max },
+          ...reclaimableBytes !== void 0 && { reclaimableBytes },
+          ...oomKills !== void 0 && { oomKills }
+        }
+      };
+    }
+    return null;
+  }
+  // Cache and reclaimable slab, less mapped file pages: those are reclaimable in principle
+  // but are the working set of running programs, so counting them as free overstates what a
+  // new task can actually take.
+  async readReclaimable(path) {
+    let counters;
+    try {
+      counters = parseKeyedCounters(await this.read_(path));
+    } catch {
+      return void 0;
+    }
+    const file = counters.get("file");
+    const slab = counters.get("slab_reclaimable");
+    if (file === void 0 || slab === void 0) return void 0;
+    return Math.max(0, file - (counters.get("file_mapped") ?? 0) + slab);
+  }
+  async readCounter(path, key) {
+    try {
+      return parseKeyedCounters(await this.read_(path)).get(key);
+    } catch {
+      return void 0;
+    }
+  }
+  async readNumber(path) {
+    try {
+      return parseLimit(await this.read_(path));
+    } catch {
+      return null;
+    }
+  }
+  async readStall(path) {
+    try {
+      return parseStall(await this.read_(path));
+    } catch {
+      return void 0;
+    }
+  }
+};
+
+// src/infrastructure/systemd-scope-reaper.ts
+import { execFile } from "node:child_process";
+import { readFile as readFile5 } from "node:fs/promises";
+import { promisify } from "node:util";
+var exec = promisify(execFile);
+var PANE_SCOPE = /^tmux-spawn-[0-9a-f-]+\.scope$/;
+var readProcCgroup = (pid) => readFile5(`/proc/${pid}/cgroup`, "utf8");
+var execFileRunner = async (cmd, args) => {
+  await exec(cmd, args, { env: childEnv() });
+};
+function isPaneScope(name) {
+  return PANE_SCOPE.test(name);
+}
+var SystemdScopeReaper = class {
+  constructor(readCgroup = readProcCgroup, run = execFileRunner) {
+    this.readCgroup = readCgroup;
+    this.run = run;
+  }
+  readCgroup;
+  run;
+  async scopeForPid(pid) {
+    let cgroup;
+    try {
+      cgroup = await this.readCgroup(pid);
+    } catch {
+      return null;
+    }
+    const leaf = cgroup.trim().split("/").pop() ?? "";
+    return isPaneScope(leaf) ? leaf : null;
+  }
+  async stopScope(name) {
+    if (!isPaneScope(name)) {
+      throw new Error(`refusing to stop non-pane unit: ${name}`);
+    }
+    await this.run("systemctl", ["--user", "stop", name]);
+  }
+};
+
+// src/infrastructure/file-client-log-store.ts
+import { appendFile, mkdir as mkdir2 } from "node:fs/promises";
+import { dirname as dirname2 } from "node:path";
+var FileClientLogStore = class {
+  constructor(filePath, now = () => Date.now()) {
+    this.filePath = filePath;
+    this.now = now;
+  }
+  filePath;
+  now;
+  async append(batch) {
+    const rt = this.now();
+    const lines = batch.events.map(
+      (event) => JSON.stringify({ ...event, ua: batch.ua, shell: batch.shell, rt }) + "\n"
+    );
+    await mkdir2(dirname2(this.filePath), { recursive: true });
+    await appendFile(this.filePath, lines.join(""), "utf8");
+  }
+};
+
+// src/infrastructure/file-hook-event-log.ts
+import { appendFile as appendFile2, mkdir as mkdir3, rename, stat } from "node:fs/promises";
+import { dirname as dirname3 } from "node:path";
+var FileHookEventLog = class {
+  constructor(filePath, maxBytes = 50 * 1024 * 1024, now = () => Date.now()) {
+    this.filePath = filePath;
+    this.maxBytes = maxBytes;
+    this.now = now;
+  }
+  filePath;
+  maxBytes;
+  now;
+  async append(entry) {
+    await mkdir3(dirname3(this.filePath), { recursive: true });
+    const size = await stat(this.filePath).then(
+      (s) => s.size,
+      () => 0
+    );
+    if (size > this.maxBytes) await rename(this.filePath, `${this.filePath}.1`);
+    const line = JSON.stringify({ ts: new Date(this.now()).toISOString(), ...entry }) + "\n";
+    await appendFile2(this.filePath, line, "utf8");
+  }
+};
+
+// src/infrastructure/file-message-log.ts
+import { appendFile as appendFile3, mkdir as mkdir4, rename as rename2, stat as stat2 } from "node:fs/promises";
+import { dirname as dirname4 } from "node:path";
+var FileMessageLog = class {
+  constructor(filePath, maxBytes = 50 * 1024 * 1024) {
+    this.filePath = filePath;
+    this.maxBytes = maxBytes;
+  }
+  filePath;
+  maxBytes;
+  async append(entry) {
+    await mkdir4(dirname4(this.filePath), { recursive: true });
+    const size = await stat2(this.filePath).then(
+      (s) => s.size,
+      () => 0
+    );
+    if (size > this.maxBytes) await rename2(this.filePath, `${this.filePath}.1`);
+    await appendFile3(this.filePath, JSON.stringify(entry) + "\n", "utf8");
+  }
+};
+
+// src/infrastructure/proc-ancestry.ts
+import { execFile as execFile2 } from "node:child_process";
+import { readFile as readFile6 } from "node:fs/promises";
+import { promisify as promisify2 } from "node:util";
+var exec2 = promisify2(execFile2);
+var MAX_GENERATIONS = 64;
+async function procParentOf(pid, read = (path) => readFile6(path, "utf8")) {
+  try {
+    const stat5 = await read(`/proc/${pid}/stat`);
+    const ppid = Number(stat5.slice(stat5.lastIndexOf(")") + 1).trim().split(/\s+/)[1]);
+    return Number.isInteger(ppid) ? ppid : null;
+  } catch {
+    return null;
+  }
+}
+async function psParentOf(pid) {
+  try {
+    const { stdout } = await exec2("ps", ["-o", "ppid=", "-p", String(pid)], { env: childEnv() });
+    const ppid = Number(stdout.trim());
+    return stdout.trim() !== "" && Number.isInteger(ppid) ? ppid : null;
+  } catch {
+    return null;
+  }
+}
+var ProcAncestry = class {
+  constructor(parentOf = process.platform === "linux" ? procParentOf : psParentOf) {
+    this.parentOf = parentOf;
+  }
+  parentOf;
+  async isAncestor(ancestorPid, pid) {
+    let current = pid;
+    for (let step = 0; step < MAX_GENERATIONS && current > 1; step++) {
+      const parent = await this.parentOf(current);
+      if (parent === null) return false;
+      if (parent === ancestorPid) return true;
+      current = parent;
+    }
+    return false;
+  }
+};
+
+// src/infrastructure/composite-delivery.ts
+var CompositeDelivery = class {
+  constructor(byCli) {
+    this.byCli = byCli;
+  }
+  byCli;
+  async deliver(target, text) {
+    const delivery = this.byCli[target.cli];
+    if (!delivery) return { ok: false, reason: `no delivery for ${target.cli} on this agent yet` };
+    try {
+      return await delivery.deliver(target, text);
+    } catch (err) {
+      return { ok: false, reason: err instanceof Error ? err.message : String(err) };
+    }
+  }
+};
+
+// src/infrastructure/claude-inbox-delivery.ts
+import { randomUUID } from "node:crypto";
+import { connect } from "node:net";
+var PINNED_PEER_PROTOCOL = 1;
+var TIMEOUT_MS = 5e3;
+var MAX_FRAME_BYTES2 = 1e6;
+var ClaudeInboxDelivery = class {
+  constructor(sessions, firstPane = async () => null) {
+    this.sessions = sessions;
+    this.firstPane = firstPane;
+  }
+  sessions;
+  firstPane;
+  async deliver(target, text) {
+    const inbox = await this.sessions.inboxOf(target.id, await this.firstPane(target.id));
+    if (!inbox) return { ok: false, reason: `no live Claude session in ${target.id}` };
+    if (inbox === "ambiguous") return { ok: false, reason: `several Claude sessions in ${target.id}; retry in a few seconds` };
+    if (inbox.peerProtocol !== PINNED_PEER_PROTOCOL) {
+      return {
+        ok: false,
+        reason: `Claude peer protocol ${inbox.peerProtocol} is not supported (expected ${PINNED_PEER_PROTOCOL})`
+      };
+    }
+    const fromName = target.from.replace(/["<>]/g, "");
+    const frame = JSON.stringify({
+      msgV: 1,
+      msg_id: randomUUID(),
+      type: "user",
+      message: {
+        role: "user",
+        // A closing tag inside the text would end the envelope early, and an opening one would
+        // let the rest pose as a second message from another sender: both are escaped.
+        content: `<cross-session-message from-name="${fromName}">
+${text.replace(/<(\/?cross-session-message)/gi, "&lt;$1")}
+</cross-session-message>`
+      },
+      priority: "next"
+    });
+    const bytes = Buffer.byteLength(frame, "utf8");
+    if (bytes > MAX_FRAME_BYTES2) return { ok: false, reason: `message too large for Claude (${bytes} bytes)` };
+    const auth = inbox.token === void 0 ? "" : `${JSON.stringify({ type: "auth", token: inbox.token })}
+`;
+    return write(inbox.socketPath, `${auth}${frame}
+`, target.id);
+  }
+};
+function write(socketPath, payload, id) {
+  return new Promise((resolve) => {
+    const socket = connect(socketPath, () => socket.end(payload));
+    const settle = (result) => {
+      clearTimeout(timer);
+      socket.destroy();
+      resolve(result);
+    };
+    const timer = setTimeout(() => settle({ ok: false, reason: "the Claude inbox did not answer in 5 s" }), TIMEOUT_MS);
+    socket.on("error", (err) => {
+      const unreachable = err.code === "ENOENT" || err.code === "ECONNREFUSED";
+      settle({
+        ok: false,
+        reason: unreachable ? `the Claude inbox of ${id} is not reachable` : `the Claude inbox of ${id} failed: ${err.message}`
+      });
+    });
+    socket.on("close", (hadError) => {
+      if (!hadError) settle({ ok: true });
+    });
+  });
+}
+
+// src/infrastructure/pi-inbox-delivery.ts
+import { connect as connect2 } from "node:net";
+import { join } from "node:path";
+var TIMEOUT_MS2 = 5e3;
+var PiInboxDelivery = class {
+  constructor(inboxDir) {
+    this.inboxDir = inboxDir;
+  }
+  inboxDir;
+  async deliver(target, text) {
+    if (target.id.includes("/") || target.id.startsWith(".")) {
+      return { ok: false, reason: `the Pi inbox of ${target.id} failed: not a workspace id` };
+    }
+    return exchange(join(this.inboxDir, `${target.id}.sock`), `${JSON.stringify({ v: 1, text })}
+`, target.id);
+  }
+};
+function exchange(socketPath, line, id) {
+  return new Promise((resolve) => {
+    let answer = "";
+    let settled = false;
+    const socket = connect2(socketPath, () => socket.write(line));
+    socket.setEncoding("utf8");
+    const settle = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      socket.destroy();
+      resolve(result);
+    };
+    const failed = (message) => settle({ ok: false, reason: `the Pi inbox of ${id} failed: ${message}` });
+    const timer = setTimeout(() => settle({ ok: false, reason: "the Pi inbox did not answer in 5 s" }), TIMEOUT_MS2);
+    socket.on("data", (d) => {
+      answer += d;
+      const end = answer.indexOf("\n");
+      if (end < 0) return;
+      let reply;
+      try {
+        reply = JSON.parse(answer.slice(0, end));
+      } catch {
+        return failed("unexpected answer");
+      }
+      const r = reply;
+      if (r?.ok === true) return settle({ ok: true });
+      if (r?.ok === false) return settle({ ok: false, reason: `the Pi inbox refused: ${String(r.error ?? "no reason")}` });
+      failed("unexpected answer");
+    });
+    socket.on("error", (err) => {
+      if (err.code === "ENOENT" || err.code === "ECONNREFUSED") return settle({ ok: false, reason: "Pi without the Tarfa inbox" });
+      failed(err.message);
+    });
+    socket.on("close", () => failed("closed without answering"));
+  });
+}
+
+// src/infrastructure/codex-delivery.ts
+var RACE = /^(expected active turn id |no active turn to steer)/;
+var NoTurnToSteer = class extends Error {
+  constructor() {
+    super("the thread is busy with no turn to steer");
+  }
+};
+var CodexDelivery = class {
+  constructor(codex) {
+    this.codex = codex;
+  }
+  codex;
+  async deliver(target, text) {
+    const thread = target.codexThread;
+    if (!thread) {
+      return {
+        ok: false,
+        reason: `no Codex thread recorded for ${target.id} (only tarfa spawn --cli codex workspaces take messages)`
+      };
+    }
+    try {
+      if (!(await this.codex.loadedThreads()).includes(thread)) {
+        return { ok: false, reason: `the Codex thread of ${target.id} is not open` };
+      }
+      try {
+        await this.post(thread, text);
+      } catch (err) {
+        if (!(err instanceof NoTurnToSteer) && !RACE.test(err.message)) throw err;
+        await this.post(thread, text);
+      }
+      return { ok: true };
+    } catch (err) {
+      if (err instanceof CodexAppServerDown) return { ok: false, reason: err.message };
+      return { ok: false, reason: `the Codex app server failed: ${err.message}` };
+    }
+  }
+  async post(thread, text) {
+    const state2 = await this.codex.threadState(thread);
+    if (state2.status === "idle") return this.codex.startTurn(thread, text);
+    if (!state2.activeTurnId) throw new NoTurnToSteer();
+    return this.codex.steer(thread, text, state2.activeTurnId);
+  }
+};
+
+// src/infrastructure/file-workspace-log-store.ts
+import { appendFile as appendFile4, mkdir as mkdir5 } from "node:fs/promises";
+import { dirname as dirname5 } from "node:path";
+var FileWorkspaceLogStore = class {
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  filePath;
+  async append(entry) {
+    await mkdir5(dirname5(this.filePath), { recursive: true });
+    await appendFile4(this.filePath, JSON.stringify(entry) + "\n", "utf8");
+  }
+};
+
+// src/application/track-live-workspaces.ts
+async function trackLiveWorkspaces(deps) {
+  if (!deps.tmux.serverId) return [];
+  const serverId = await deps.tmux.serverId();
+  const sessions = await deps.tmux.listSessions(deps.sessionPrefix);
+  const parkedIds = new Set((await deps.parked.list()).map((p) => p.id));
+  const previous = await deps.snapshot.read();
+  const parkedNow = [];
+  if (previous && previous.serverId !== serverId) {
+    const survivors = new Set(sessions.filter((s) => s.command.trim().length > 0).map((s) => s.name));
+    for (const entry of previous.workspaces) {
+      if (survivors.has(entry.id) || parkedIds.has(entry.id)) continue;
+      const claudeSessionId = deps.status.getClaudeSessionId(entry.id) ?? entry.claudeSessionId;
+      const now = deps.clock.now();
+      try {
+        await deps.workspaceLog.append({
+          id: entry.id,
+          name: entry.name,
+          projectPath: entry.projectPath,
+          machineId: entry.machineId,
+          createdAt: entry.createdAt,
+          closedAt: now,
+          reason: "server-lost",
+          lastStatus: deps.status.get(entry.id),
+          claudeSessionId
+        });
+      } catch {
+      }
+      if (!claudeSessionId) continue;
+      await deps.parked.add({
+        ...entry,
+        command: entry.command.trim().length > 0 ? entry.command : "claude",
+        claudeSessionId,
+        parkedAt: now
+      });
+      parkedIds.add(entry.id);
+      parkedNow.push(entry.id);
+      deps.status.set(entry.id, "parked");
+    }
+  }
+  await deps.snapshot.write({
+    serverId,
+    workspaces: sessions.filter((s) => !parkedIds.has(s.name)).map((s) => {
+      const claudeSessionId = deps.status.getClaudeSessionId(s.name);
+      return {
+        id: s.name,
+        name: deriveWorkspaceName(s.title, s.startPath, s.command, s.name),
+        projectPath: s.startPath,
+        command: s.command,
+        machineId: deps.machineId,
+        createdAt: s.createdAt,
+        ...claudeSessionId ? { claudeSessionId } : {},
+        ...s.parent ? { parent: s.parent } : {}
+      };
+    })
+  });
+  return parkedNow;
+}
+
+// src/application/reconcile-parked.ts
+async function reconcileParked(deps) {
+  const orphans = [];
+  for (const { id } of await deps.parked.list()) {
+    if (await deps.tmux.hasSession(id)) {
+      await deps.tmux.killSession(id);
+      orphans.push(id);
+    }
+  }
+  return orphans;
+}
+
+// src/application/startup-reconcile.ts
+async function reconcileAtStartup(deps) {
+  try {
+    const retagged = await deps.tmux.retagLegacyOptions?.() ?? 0;
+    deps.log(`tarfa agent: re-tagged ${retagged} @perch_ tmux option(s) as @tarfa_`);
+  } catch (err) {
+    deps.log(`tarfa agent: could not re-tag @perch_ tmux options: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  try {
+    const recovered = await trackLiveWorkspaces(deps);
+    if (recovered.length > 0) deps.log(`tarfa agent: parked ${recovered.length} workspace(s) lost with the tmux server`);
+  } catch (err) {
+    deps.log(`tarfa agent: could not check for lost workspaces: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  await reconcileParked(deps);
+  const sessions = await deps.tmux.listSessions(deps.sessionPrefix);
+  const parkedIds = (await deps.parked.list()).map((p) => p.id);
+  deps.status.prune([...sessions.map((s) => s.name), ...parkedIds]);
+}
+
+// src/infrastructure/file-live-snapshot-store.ts
+import { readFile as readFile7, mkdir as mkdir6 } from "node:fs/promises";
+import { dirname as dirname6 } from "node:path";
+var FileLiveSnapshotStore = class {
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  filePath;
+  async read() {
+    let parsed;
+    try {
+      parsed = JSON.parse(await readFile7(this.filePath, "utf8"));
+    } catch {
+      return void 0;
+    }
+    if (typeof parsed !== "object" || parsed === null) return void 0;
+    const { serverId, workspaces } = parsed;
+    if (serverId !== null && typeof serverId !== "string" || !Array.isArray(workspaces)) return void 0;
+    return {
+      serverId,
+      workspaces: workspaces.map(parseEntry).filter((e) => e !== void 0)
+    };
+  }
+  async write(snapshot) {
+    const text = JSON.stringify(snapshot, null, 2);
+    const current = await readFile7(this.filePath, "utf8").catch(() => void 0);
+    if (current === text) return;
+    await mkdir6(dirname6(this.filePath), { recursive: true });
+    await writeFileAtomic(this.filePath, text);
+  }
+  async remove(id) {
+    const snapshot = await this.read();
+    if (!snapshot) return;
+    await this.write({ ...snapshot, workspaces: snapshot.workspaces.filter((w) => w.id !== id) });
+  }
+};
+function parseEntry(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const v = value;
+  const str = (k) => typeof v[k] === "string" ? v[k] : void 0;
+  const id = str("id");
+  const name = str("name");
+  const projectPath = str("projectPath");
+  const command = str("command");
+  const machineId = str("machineId");
+  const createdAt = typeof v.createdAt === "number" ? v.createdAt : void 0;
+  if (!id || !name || !projectPath || command === void 0 || !machineId || createdAt === void 0) {
+    return void 0;
+  }
+  const claudeSessionId = str("claudeSessionId");
+  const parent = str("parent");
+  return {
+    id,
+    name,
+    projectPath,
+    command,
+    machineId,
+    createdAt,
+    ...claudeSessionId ? { claudeSessionId } : {},
+    ...parent ? { parent } : {}
+  };
+}
+
+// src/infrastructure/fs-file-reader.ts
+import { open, stat as stat3 } from "node:fs/promises";
+var FsFileReader = class {
+  async read(path, maxBytes) {
+    const info = await stat3(path);
+    const truncated = info.size > maxBytes;
+    const toRead = truncated ? maxBytes : info.size;
+    const fh = await open(path, "r");
+    try {
+      const buf = Buffer.alloc(toRead);
+      const { bytesRead } = await fh.read(buf, 0, toRead, 0);
+      return { bytes: buf.subarray(0, bytesRead), truncated };
+    } finally {
+      await fh.close();
+    }
+  }
+};
+
+// src/infrastructure/node-pty-adapter.ts
+import * as pty from "node-pty";
+var NodePtyAdapter = class {
+  spawn(input) {
+    const proc = pty.spawn(input.command, input.args, {
+      // The PWA's front-end is xterm.js, a 256-colour terminal, and this is what the tmux
+      // client believes it is talking to. `xterm-color` understated it twice over: it has
+      // no `kcbt`, so tmux could not parse back-tab (\x1b[Z) and forwarded a bare `Z`,
+      // and its 8-colour claim made tmux flatten 256-colour output to the nearest ANSI
+      // colour before it ever reached the phone.
+      name: "xterm-256color",
+      cols: input.cols,
+      rows: input.rows,
+      cwd: process.env.HOME ?? process.cwd(),
+      env: childEnv()
+    });
+    return {
+      onData: (listener) => {
+        proc.onData(listener);
+      },
+      onExit: (listener) => {
+        proc.onExit(() => listener());
+      },
+      write: (data) => {
+        proc.write(data);
+      },
+      resize: (cols, rows) => {
+        proc.resize(cols, rows);
+      },
+      kill: () => {
+        proc.kill();
+      }
+    };
+  }
+};
+
+// src/infrastructure/fs-browser-discovery.ts
+import { readdir, readFile as readFile8 } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+function agentBrowserSidecarDir() {
+  const runtime = process.env.XDG_RUNTIME_DIR;
+  return runtime ? join2(runtime, "agent-browser") : join2(homedir(), ".agent-browser");
+}
+function defaultIsPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var FsBrowserDiscovery = class {
+  dir;
+  isPidAlive;
+  constructor(opts = {}) {
+    this.dir = opts.dir ?? agentBrowserSidecarDir();
+    this.isPidAlive = opts.isPidAlive ?? defaultIsPidAlive;
+  }
+  async listSessions() {
+    let entries;
+    try {
+      entries = await readdir(this.dir);
+    } catch {
+      return [];
+    }
+    const sessions = [];
+    for (const entry of entries) {
+      if (!entry.endsWith(".stream")) continue;
+      const name = entry.slice(0, -".stream".length);
+      const streamPort = await readPositiveInt(join2(this.dir, entry));
+      if (streamPort === void 0) continue;
+      const pid = await readPositiveInt(join2(this.dir, `${name}.pid`));
+      if (pid === void 0 || !this.isPidAlive(pid)) continue;
+      sessions.push({ name, streamPort });
+    }
+    return sessions;
+  }
+};
+async function readPositiveInt(path) {
+  let raw;
+  try {
+    raw = await readFile8(path, "utf8");
+  } catch {
+    return void 0;
+  }
+  const trimmed = raw.trim();
+  return /^\d+$/.test(trimmed) ? Number(trimmed) : void 0;
+}
+
+// src/infrastructure/agent-browser-cli.ts
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
+
+// src/infrastructure/agent-browser-session-env.ts
+import { readFile as readFile9 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+var NOT_REPLAYED = /* @__PURE__ */ new Set([
+  "AGENT_BROWSER_DAEMON",
+  "AGENT_BROWSER_SESSION",
+  "AGENT_BROWSER_STREAM_PORT",
+  "AGENT_BROWSER_NAMESPACE",
+  "AGENT_BROWSER_SOCKET_DIR"
+]);
+function procSessionLaunchEnv(opts = {}) {
+  const dir = opts.dir ?? agentBrowserSidecarDir();
+  const procRoot = opts.procRoot ?? "/proc";
+  return async (session) => {
+    if (session === "" || session.includes("/") || session.includes("..")) return null;
+    let environ;
+    try {
+      const pid = (await readFile9(join3(dir, `${session}.pid`), "utf8")).trim();
+      if (!/^\d+$/.test(pid)) return null;
+      environ = await readFile9(join3(procRoot, pid, "environ"), "utf8");
+    } catch {
+      return null;
+    }
+    const vars = /* @__PURE__ */ new Map();
+    for (const entry of environ.split("\0")) {
+      const eq = entry.indexOf("=");
+      if (eq > 0) vars.set(entry.slice(0, eq), entry.slice(eq + 1));
+    }
+    if (vars.get("AGENT_BROWSER_DAEMON") !== "1" || vars.get("AGENT_BROWSER_SESSION") !== session) {
+      return null;
+    }
+    const env = {};
+    for (const [name, value] of vars) {
+      if (name.startsWith("AGENT_BROWSER_") && !NOT_REPLAYED.has(name) || name === "DISPLAY") {
+        env[name] = value;
+      }
+    }
+    return env;
+  };
+}
+
+// src/infrastructure/agent-browser-cli.ts
+var exec3 = promisify3(execFile3);
+var execFileRunner2 = async (cmd, args, launchEnv) => {
+  const env = childEnv();
+  if (launchEnv) {
+    for (const name of Object.keys(env)) {
+      if (name.startsWith("AGENT_BROWSER_")) delete env[name];
+    }
+    Object.assign(env, launchEnv);
+  }
+  await exec3(cmd, args, { env });
+};
+function isHttpUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return false;
+  }
+  return parsed.protocol === "http:" || parsed.protocol === "https:";
+}
+var AgentBrowserCli = class {
+  constructor(run = execFileRunner2, launchEnv = procSessionLaunchEnv()) {
+    this.run = run;
+    this.launchEnv = launchEnv;
+  }
+  run;
+  launchEnv;
+  async agentBrowser(session, args) {
+    await this.run("agent-browser", ["--session", session, ...args], await this.launchEnv(session));
+  }
+  async start(session) {
+    await this.agentBrowser(session, ["open", "about:blank"]);
+    await this.setPhoneViewport(session);
+  }
+  // A phone-sized viewport renders ~1:1 on the phone canvas, so taps land precisely
+  // (a 1280px page scaled to a 390px screen needs sub-finger accuracy). Best-effort:
+  // an older CLI without `set viewport` still yields a usable session.
+  async setPhoneViewport(session) {
+    try {
+      await this.agentBrowser(session, ["set", "viewport", "390", "700"]);
+    } catch {
+    }
+  }
+  async navigate(session, url) {
+    if (!isHttpUrl(url)) {
+      throw new Error(`refusing to open non-http(s) URL: ${url}`);
+    }
+    await this.agentBrowser(session, ["open", url]);
+  }
+  async back(session) {
+    await this.agentBrowser(session, ["back"]);
+  }
+  async forward(session) {
+    await this.agentBrowser(session, ["forward"]);
+  }
+  async stop(session) {
+    await this.agentBrowser(session, ["close"]);
+  }
+  async setViewport(session, width, height) {
+    if (!Number.isFinite(width) || !Number.isFinite(height)) {
+      throw new Error("viewport dimensions must be finite");
+    }
+    const clamp = (n) => String(Math.min(4096, Math.max(200, Math.round(n))));
+    await this.agentBrowser(session, ["set", "viewport", clamp(width), clamp(height)]);
+  }
+};
+
+// src/infrastructure/ws-browser-stream-socket.ts
+import { WebSocket } from "ws";
+function wsBrowserStreamSocket(socket) {
+  return {
+    send: (data) => socket.send(data),
+    bufferedAmount: () => socket.bufferedAmount,
+    onMessage: (listener) => {
+      socket.on("message", (raw) => listener(raw.toString()));
+    },
+    onClose: (listener) => {
+      socket.on("close", listener);
+    },
+    close: () => socket.close()
+  };
+}
+var connectBrowserUpstream = (port) => new Promise((resolve, reject) => {
+  const socket = new WebSocket(`ws://127.0.0.1:${port}`);
+  socket.once("error", reject);
+  socket.once("open", () => {
+    socket.removeListener("error", reject);
+    socket.on("error", () => void 0);
+    resolve(wsBrowserStreamSocket(socket));
+  });
+});
+
+// src/server/ws-server.ts
+import { createServer } from "node:http";
+
+// src/ports/device-gate-port.ts
+var DeviceGateBusy = class extends Error {
+  constructor() {
+    super("device gate busy");
+  }
+};
+
+// src/server/noise-client-connection.ts
+var SECURE_CHANNEL_FAILED = 4002;
+var BUSY = IN_BAND_REFUSAL + 429;
+var AUTH_TIMEOUT_MS = 1e4;
+var PRE_AUTH_MAX_MESSAGE_BYTES = 8 * 1024;
+var MAX_AUTH_ATTEMPTS = 3;
+var MAX_HELD_MESSAGES = 16;
+var PAIRING_SECRET = /^[A-Za-z0-9_-]{43}$/;
+var NoiseClientConnection = class {
+  constructor(socket, staticPrivate, options) {
+    this.socket = socket;
+    this.staticPrivate = staticPrivate;
+    this.options = options;
+    this.cancelDeadline = (options.startTimer ?? startTimer)(() => this.fail("authentication timeout"), AUTH_TIMEOUT_MS);
+    socket.onFrame((frame) => this.receive(frame));
+    socket.onClose(() => this.cancelDeadline());
+  }
+  socket;
+  staticPrivate;
+  options;
+  session = null;
+  state = { kind: "handshake" };
+  deviceKey = null;
+  // What authenticates this client by its key: enrolled at the handshake, or paired just now.
+  keyAuth = null;
+  // While an enrolment is being written, what the handler sends waits behind its authResult.
+  outbox = null;
+  // Messages that arrived while a pairing secret was being redeemed, in order.
+  held = null;
+  authAttempts = 0;
+  // Set when the phone is served at once, until its first frame. Message 1 can be replayed by
+  // whoever saw it, so a pushed authResult does not end the deadline nor free the socket's
+  // unauthenticated slot until the phone has proven it holds the session keys by sending something.
+  awaitingPhone = false;
+  // The pushed authResult went out while awaiting the phone: authenticated once it speaks.
+  deferredAuth = false;
+  listeners = [];
+  keyAuthenticatedListeners = [];
+  cancelDeadline;
+  // The phone's X25519 device key, once its IK handshake has been read.
+  get device() {
+    return this.deviceKey;
+  }
+  get keyCredential() {
+    return this.keyAuth !== null && this.state.kind !== "failed" ? this.keyAuth : void 0;
+  }
+  // An accepted `auth` is answered with whether the device key is now enrolled: the phone drops
+  // its token or pairing secret on `enrolled`, so for a new device the answer waits for the
+  // roster to be written.
+  send(message) {
+    if (!this.session || this.state.kind === "failed") return;
+    if (this.outbox) {
+      this.outbox.push(message);
+      return;
+    }
+    if (message.type === "authResult" && message.ok) {
+      const accepted = { ...message, agent: { protocol: PROTOCOL_VERSION, ...this.options.agentVersion ? { version: this.options.agentVersion } : {} } };
+      message = accepted;
+      if (!this.awaitingPhone) this.cancelDeadline();
+      this.session.raiseCap(MAX_MESSAGE_BYTES);
+      if (this.state.kind === "enrolling") {
+        const hello = this.state.hello;
+        this.outbox = [];
+        this.held ??= [];
+        void this.enrol(hello).then(async (outcome) => {
+          if (outcome === "declined") {
+            this.held = null;
+            this.fail(await this.declinedReason(), DEVICE_REFUSED);
+            return;
+          }
+          const held = this.outbox ?? [];
+          this.outbox = null;
+          this.seal({ ...accepted, enrolled: outcome === "enrolled" });
+          this.options.onAuthenticated?.();
+          held.forEach((m) => this.send(m));
+          const incoming = this.held ?? [];
+          this.held = null;
+          incoming.forEach((raw) => this.drain(raw));
+        });
+        return;
+      }
+      if (this.keyAuth === "device") message = { ...accepted, enrolled: true };
+      this.seal(message);
+      if (this.awaitingPhone) this.deferredAuth = true;
+      else this.options.onAuthenticated?.();
+      return;
+    }
+    this.seal(message);
+  }
+  seal(message) {
+    if (!this.session || this.state.kind === "failed") return;
+    for (const frame of this.session.seal(new TextEncoder().encode(JSON.stringify(message)))) {
+      this.socket.send(frame);
+    }
+  }
+  close() {
+    this.socket.close();
+  }
+  refuse(reason) {
+    this.fail(reason, DEVICE_REFUSED);
+  }
+  onMessage(listener) {
+    this.listeners.push(listener);
+  }
+  onClose(listener) {
+    this.socket.onClose(listener);
+  }
+  onKeyAuthenticated(listener) {
+    this.keyAuthenticatedListeners.push(listener);
+  }
+  receive(frame) {
+    switch (this.state.kind) {
+      case "failed":
+        return;
+      case "checking":
+        this.fail("secure channel failed");
+        return;
+      case "handshake":
+        this.handshake(frame);
+        return;
+      default:
+        this.read(frame);
+    }
+  }
+  handshake(frame) {
+    const pattern = handshakePattern(frame);
+    if (pattern !== "ik") {
+      this.fail("secure channel failed");
+      return;
+    }
+    let responder;
+    let hello;
+    try {
+      responder = new IkResponder(this.staticPrivate);
+      hello = parseDeviceHello(responder.readMessage1(readHandshakeFrame(frame, "ik")));
+    } catch (err) {
+      if (err instanceof WrongStaticKeyError) this.fail(REFUSAL.wrongAgentKey, DEVICE_REFUSED);
+      else this.fail("secure channel failed");
+      return;
+    }
+    if (!hello) {
+      this.fail("secure channel failed");
+      return;
+    }
+    const key = b64url.encode(responder.remoteStatic());
+    this.deviceKey = key;
+    this.state = { kind: "checking" };
+    this.options.devices.check(key).then(
+      ({ standing, enrolment }) => this.admit(responder, hello, key, standing, enrolment),
+      (err) => err instanceof DeviceGateBusy ? this.fail(REFUSAL.tooManyPending, BUSY) : this.fail("device roster unreadable")
+    );
+  }
+  admit(responder, hello, key, standing, enrolment) {
+    if (this.state.kind !== "checking") return;
+    const line = `phone: device ${deviceFingerprint(key)} "${hello.name}" ${standing}`;
+    if (standing === "enrolled") this.options.log?.(line);
+    else this.logRefusal(`handshake:${standing}`, line);
+    if (standing === "revoked") {
+      this.fail(REFUSAL.revoked, DEVICE_REFUSED);
+      return;
+    }
+    if (standing === "unknown" && enrolment === "closed") {
+      this.fail(REFUSAL.notEnrolled, DEVICE_REFUSED);
+      return;
+    }
+    try {
+      this.socket.send(handshakeFrame(responder.writeMessage2(), "ik"));
+      const { send, recv } = responder.split();
+      this.session = new SecureSession(send, recv, { maxMessageBytes: PRE_AUTH_MAX_MESSAGE_BYTES });
+    } catch {
+      this.fail("secure channel failed");
+      return;
+    }
+    this.keyAuth = standing === "enrolled" ? "device" : null;
+    this.state = standing === "enrolled" ? { kind: "open" } : { kind: "enrolling", hello, tokenEnrols: enrolment === "on" };
+    if (standing === "enrolled" && hello.push && this.keyAuthenticatedListeners.length > 0 && this.options.pushBudget?.take(key)) {
+      this.awaitingPhone = true;
+      this.keyAuthenticatedListeners.forEach((l) => l());
+    }
+  }
+  read(frame) {
+    let message;
+    try {
+      message = this.session.open(frame);
+    } catch {
+      this.fail("secure channel failed");
+      return;
+    }
+    if (this.awaitingPhone) {
+      this.awaitingPhone = false;
+      if (this.deferredAuth) {
+        this.cancelDeadline();
+        this.options.onAuthenticated?.();
+      }
+    }
+    if (!message) return;
+    const text = new TextDecoder().decode(message);
+    let raw = text;
+    try {
+      raw = JSON.parse(text);
+    } catch {
+    }
+    this.dispatch(raw);
+  }
+  // Attempts and the queue are counted as messages arrive, so a sender cannot stack them up
+  // behind a pending credential check; a held message is routed, not dispatched, when it drains.
+  dispatch(raw) {
+    if (this.state.kind === "failed") return;
+    const message = raw;
+    if (message?.type === "auth" && ++this.authAttempts > MAX_AUTH_ATTEMPTS) {
+      this.fail("too many auth attempts");
+      return;
+    }
+    if (this.held) {
+      if (this.held.length >= MAX_HELD_MESSAGES) {
+        this.fail("too many messages before auth");
+        return;
+      }
+      this.held.push(raw);
+      return;
+    }
+    this.route(raw);
+  }
+  // A held message, once its wait is over: routed, unless routing one before it opened another
+  // wait (an accepted auth holds what follows until the enrolment is written). Counted already.
+  drain(raw) {
+    if (this.held) this.held.push(raw);
+    else this.route(raw);
+  }
+  route(raw) {
+    if (this.state.kind === "failed") return;
+    const message = raw;
+    if (this.state.kind === "enrolling" && (message?.type !== "auth" || message.token === "")) {
+      this.fail(REFUSAL.notEnrolled, DEVICE_REFUSED);
+      return;
+    }
+    const pairing = message?.type === "auth" && typeof message.token === "string" && PAIRING_SECRET.test(message.token);
+    if (pairing && (this.state.kind === "enrolling" || this.keyAuth !== null)) {
+      this.spendPairing(message.token, raw);
+      return;
+    }
+    if (this.refusesToken()) return;
+    this.listeners.forEach((l) => l(raw));
+  }
+  spendPairing(secret, auth) {
+    this.held = [];
+    const key = this.deviceKey;
+    const fingerprint = deviceFingerprint(key);
+    const resume = (redemption) => {
+      if (redemption.redeemed && this.keyAuth === null) this.keyAuth = "pairing";
+      if (redemption.redeemed && redemption.fresh) this.options.log?.(`phone: pairing code used by device ${fingerprint}`);
+      const held = this.held ?? [];
+      this.held = null;
+      if (this.state.kind === "failed") return;
+      if (!redemption.redeemed && redemption.reason) {
+        this.logRefusal(redemption.reason, `phone: device ${fingerprint} refused: ${redemption.reason}`);
+        this.fail(redemption.reason, DEVICE_REFUSED);
+        return;
+      }
+      if (!redemption.redeemed && this.refusesToken()) return;
+      this.listeners.forEach((l) => l(auth));
+      held.forEach((raw) => this.drain(raw));
+    };
+    const failed = () => resume({ redeemed: false });
+    if (this.state.kind === "enrolling") {
+      this.options.devices.redeemPairing(secret, key).then(resume, (err) => err instanceof DeviceGateBusy ? this.fail(REFUSAL.tooManyPending, BUSY) : failed());
+    } else {
+      this.options.devices.burnPairing(secret, key).then(
+        (burned) => resume({ redeemed: true, fresh: burned }),
+        () => resume({ redeemed: true, fresh: false })
+      );
+    }
+  }
+  // An unknown device whose `auth` is about to be checked as a token, while only a pairing code
+  // may enrol it: refused here, so the token never gets as far as the handler.
+  refusesToken() {
+    if (this.state.kind !== "enrolling" || this.state.tokenEnrols || this.keyAuth !== null) return false;
+    this.logRefusal("token-off", `phone: device ${deviceFingerprint(this.deviceKey)} refused: token enrolment is off`);
+    this.fail(REFUSAL.enrolmentOff, DEVICE_REFUSED);
+    return true;
+  }
+  // `declined`: the roster would not take the device (enrolment turned off or closed since the
+  // handshake, or its id taken), so the credential that authenticated this session no longer
+  // admits it. `failed`: the write itself failed; the session goes on unenrolled, and the phone
+  // keeps its credential to try again.
+  async enrol(hello) {
+    const key = this.deviceKey;
+    const via = this.keyAuth === "pairing" ? "pairing" : "token";
+    this.state = { kind: "open" };
+    try {
+      const enrolled = await this.options.devices.enrol({ x25519: key, ed25519: hello.sig, name: hello.name }, via);
+      this.options.log?.(
+        enrolled ? `phone: enrolled device ${deviceFingerprint(key)} "${hello.name}"` : `phone: device ${deviceFingerprint(key)} not enrolled (enrolment changed meanwhile, or its id is taken); closing its session`
+      );
+      return enrolled ? "enrolled" : "declined";
+    } catch (err) {
+      this.options.log?.(`phone: enrolling ${deviceFingerprint(key)} failed: ${String(err)}`);
+      return "failed";
+    }
+  }
+  async declinedReason() {
+    try {
+      const { enrolment } = await this.options.devices.check(this.deviceKey);
+      if (enrolment === "closed") return REFUSAL.enrolmentClosed;
+      if (enrolment === "off" && this.keyAuth !== "pairing") return REFUSAL.enrolmentOff;
+    } catch {
+    }
+    return REFUSAL.enrolmentRefused;
+  }
+  logRefusal(key, line) {
+    if (this.options.refusalLog) this.options.refusalLog.line(key, line);
+    else this.options.log?.(line);
+  }
+  fail(reason, code = SECURE_CHANNEL_FAILED) {
+    if (this.state.kind === "failed") return;
+    this.state = { kind: "failed" };
+    this.cancelDeadline();
+    this.socket.close(code, reason);
+  }
+};
+
+// src/application/resume-command.ts
+function resumeCommand(command, sessionId) {
+  if (!sessionId || command.trim().length === 0) {
+    return command;
+  }
+  const base = stripResumeFlag(unwrapResume(command));
+  return `${base} --resume ${sessionId} || exec ${base}`;
+}
+function unwrapResume(command) {
+  const at = command.indexOf(" || exec ");
+  if (at < 0) return command;
+  const fallback = command.slice(at + " || exec ".length).trim();
+  return stripResumeFlag(command.slice(0, at)) === stripResumeFlag(fallback) ? fallback : command;
+}
+function stripResumeFlag(command) {
+  const parts = command.split(/\s+/).filter((p) => p.length > 0);
+  const out = [];
+  let skipNext = false;
+  for (const part of parts) {
+    if (skipNext) {
+      skipNext = false;
+      continue;
+    }
+    if (part === "--resume") {
+      skipNext = true;
+      continue;
+    }
+    out.push(part);
+  }
+  return out.join(" ");
+}
+
+// src/application/unpark-workspace.ts
+async function unparkWorkspace(deps, id) {
+  const record = await deps.parked.get(id);
+  if (!record) {
+    return "not-parked";
+  }
+  if (!await deps.isDirectory(record.projectPath)) {
+    return "missing-directory";
+  }
+  await deps.tmux.createSession({
+    name: record.id,
+    cwd: record.projectPath,
+    command: resumeCommand(record.command, record.claudeSessionId),
+    // Recorded bare, so parking this workspace again resumes it instead of re-wrapping the
+    // `|| exec` fallback, whose first arm would then start a fresh session.
+    storedCommand: record.command,
+    ...record.parent ? { parent: record.parent } : {}
+  });
+  await restoreName(deps.tmux, record.id, record.name).catch(() => void 0);
+  await deps.parked.remove(record.id);
+  deps.status.set(record.id, "idle");
+  return "unparked";
+}
+async function restoreName(tmux, id, name) {
+  if (tmux.lockPaneTitle && await tmux.supportsTitleLock?.()) await tmux.lockPaneTitle(id);
+  await tmux.setPaneTitle?.(id, `\u2733 ${name}`);
+}
+
+// src/application/close-workspace.ts
+async function closeWorkspace(deps, id) {
+  const scope = await paneScope(deps, id);
+  await deps.tmux.killSession(id);
+  return scope;
+}
+async function paneScope(deps, id) {
+  if (!deps.scopes || !deps.tmux.panePid) return null;
+  try {
+    const pid = await deps.tmux.panePid(id);
+    return pid === null ? null : await deps.scopes.scopeForPid(pid);
+  } catch {
+    return null;
+  }
+}
+
+// src/application/browser-session-owner.ts
+var DELIMITER = "__";
+function browserSessionsForWorkspace(sessionNames, workspaceId) {
+  return sessionNames.filter(
+    (name) => name === workspaceId || name.startsWith(workspaceId + DELIMITER)
+  );
+}
+
+// src/application/close-workspace-browsers.ts
+async function closeWorkspaceBrowserSessions(deps, workspaceId) {
+  let names;
+  try {
+    const sessions = await deps.discovery.listSessions();
+    names = browserSessionsForWorkspace(
+      sessions.map((s) => s.name),
+      workspaceId
+    );
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    await deps.commands.stop(name).catch(() => void 0);
+  }
+}
+
+// src/application/reap-workspace-scope.ts
+async function reapWorkspaceScope(deps, scope) {
+  if (!deps.scopes || !scope) return;
+  try {
+    await deps.scopes.stopScope(scope);
+  } catch {
+  }
+}
+
+// src/application/record-workspace-closed.ts
+async function recordWorkspaceClosed(deps, workspace, reason) {
+  try {
+    await deps.workspaceLog.append({
+      id: workspace.id,
+      name: workspace.name,
+      projectPath: workspace.projectPath,
+      machineId: workspace.machineId,
+      createdAt: workspace.createdAt,
+      closedAt: deps.clock.now(),
+      reason,
+      lastStatus: deps.status.get(workspace.id),
+      claudeSessionId: deps.status.getClaudeSessionId(workspace.id)
+    });
+  } catch {
+    return;
+  }
+}
+
+// src/application/retire-workspace.ts
+async function retireWorkspace(deps, id) {
+  const parkedRecord = await deps.parked.get(id);
+  const workspace = deps.forgetWorkspace(id, true) ?? (parkedRecord ? {
+    machineId: parkedRecord.machineId,
+    id: parkedRecord.id,
+    name: parkedRecord.name,
+    projectPath: parkedRecord.projectPath,
+    command: parkedRecord.command,
+    createdAt: parkedRecord.createdAt,
+    lastActivityAt: parkedRecord.parkedAt,
+    status: "parked"
+  } : await deps.snapshot(id));
+  const lastStatus = deps.status.get(id);
+  const claudeSessionId = parkedRecord ? parkedRecord.claudeSessionId : deps.status.getClaudeSessionId(id);
+  if (parkedRecord) {
+    await deps.parked.remove(id);
+  }
+  const scope = await closeWorkspace({ tmux: deps.tmux, scopes: deps.scopes }, id);
+  if (workspace) {
+    await recordWorkspaceClosed(
+      {
+        workspaceLog: deps.workspaceLog,
+        status: { get: () => lastStatus, getClaudeSessionId: () => claudeSessionId },
+        clock: deps.clock
+      },
+      workspace,
+      "closed-by-user"
+    );
+  }
+  deps.dropWorkspaceState?.(id);
+  return scope;
+}
+async function finishClose(deps, id, scope) {
+  try {
+    await reapWorkspaceScope({ scopes: deps.scopes }, scope);
+    await closeWorkspaceBrowserSessions({ discovery: deps.browserDiscovery, commands: deps.browserCommands }, id);
+  } catch {
+  }
+}
+
+// src/application/remember-launcher.ts
+var BUILTINS = /* @__PURE__ */ new Set(["bash", "claude", "codex"]);
+function normalizeCommand(command) {
+  const trimmed = command.trim();
+  return trimmed === "" || BUILTINS.has(trimmed) ? null : trimmed;
+}
+
+// src/application/park-workspace.ts
+async function parkWorkspace(deps, workspace) {
+  if (await deps.parked.get(workspace.id)) {
+    return "already-parked";
+  }
+  const claudeSessionId = deps.status.getClaudeSessionId(workspace.id);
+  if (!claudeSessionId) {
+    return "not-restorable";
+  }
+  const hasCommand = workspace.command.trim().length > 0;
+  const command = hasCommand ? workspace.command : "claude";
+  await deps.parked.add({
+    id: workspace.id,
+    name: workspace.name,
+    projectPath: workspace.projectPath,
+    command,
+    machineId: workspace.machineId,
+    createdAt: workspace.createdAt,
+    parkedAt: deps.clock.now(),
+    claudeSessionId,
+    ...workspace.parentId ? { parent: workspace.parentId } : {}
+  });
+  await deps.tmux.killSession(workspace.id);
+  deps.status.set(workspace.id, "parked");
+  return "parked";
+}
+
+// src/application/make-dir.ts
+import { join as join4 } from "node:path";
+function isValidFolderName(name) {
+  return name.length > 0 && !name.includes("/") && name !== "." && name !== "..";
+}
+async function makeDir(deps, parent, name, allowedRoots) {
+  const clean = name.trim();
+  if (!isValidFolderName(clean)) {
+    throw new Error(`invalid folder name: ${name}`);
+  }
+  const target = join4(parent, clean);
+  if (!pathWithinRoots(target, allowedRoots)) {
+    throw new Error(`path outside allowed roots: ${target}`);
+  }
+  await deps.lister.makeDir(target);
+  return target;
+}
+
+// src/application/classify-text-file.ts
+var SNIFF_BYTES = 8e3;
+function classifyTextFile(bytes, truncated) {
+  if (isBinary(bytes, truncated)) return { binary: true, data: "" };
+  return { binary: false, data: Buffer.from(bytes).toString("base64") };
+}
+function isBinary(bytes, truncated) {
+  if (bytes.subarray(0, SNIFF_BYTES).includes(0)) return true;
+  if (decodes(bytes)) return false;
+  if (truncated) {
+    for (let drop = 1; drop <= 3 && drop < bytes.length; drop += 1) {
+      if (decodes(bytes.subarray(0, bytes.length - drop))) return false;
+    }
+  }
+  return true;
+}
+function decodes(bytes) {
+  try {
+    new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/application/read-file.ts
+var MAX_FILE_BYTES = 512 * 1024;
+async function readFile10(deps, path, allowedRoots) {
+  if (!pathWithinRoots(path, allowedRoots)) {
+    throw new Error(`path outside allowed roots: ${path}`);
+  }
+  const { bytes, truncated } = await deps.reader.read(path, MAX_FILE_BYTES);
+  const { binary, data } = classifyTextFile(bytes, truncated);
+  return { binary, data, truncated };
+}
+
+// src/application/store-pasted-file.ts
+import { basename, extname, join as join5 } from "node:path";
+async function storePastedFile(deps, input) {
+  const safeName = basename(input.name) || "pasted-file";
+  const dir = join5(input.projectPath, ".tmp", "files");
+  await deps.writer.ensureDir(dir);
+  const finalName = await uniqueName(deps.writer, dir, safeName);
+  await deps.writer.writeFile(join5(dir, finalName), input.bytes);
+  return join5(".tmp", "files", finalName);
+}
+async function uniqueName(writer, dir, name) {
+  if (!await writer.exists(join5(dir, name))) return name;
+  const ext = extname(name);
+  const stem = name.slice(0, name.length - ext.length);
+  for (let i = 1; ; i += 1) {
+    const candidate = `${stem}-${i}${ext}`;
+    if (!await writer.exists(join5(dir, candidate))) return candidate;
+  }
+}
+
+// src/application/read-servable-file.ts
+var MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+var MAX_PDF_BYTES = 20 * 1024 * 1024;
+var MAX_AUDIO_BYTES = 30 * 1024 * 1024;
+function servable(path) {
+  const image = imageMediaType(path);
+  if (image) return { mediaType: image, maxBytes: MAX_IMAGE_BYTES };
+  const pdf = pdfMediaType(path);
+  if (pdf) return { mediaType: pdf, maxBytes: MAX_PDF_BYTES };
+  const audio = audioMediaType(path);
+  if (audio) return { mediaType: audio, maxBytes: MAX_AUDIO_BYTES };
+  return null;
+}
+async function readServableFile(deps, path, allowedRoots) {
+  if (!pathWithinRoots(path, allowedRoots)) return { kind: "forbidden" };
+  const match = servable(path);
+  if (!match) return { kind: "not-servable" };
+  const { bytes, truncated } = await deps.reader.read(path, match.maxBytes);
+  if (truncated) return { kind: "too-large" };
+  return { kind: "ok", mediaType: match.mediaType, bytes };
+}
+
+// src/application/media-sender.ts
+var MEDIA_CHUNK_BYTES = 45 * 1024;
+var MEDIA_WINDOW = 4;
+var MediaSender = class {
+  constructor(send) {
+    this.send = send;
+  }
+  send;
+  // The id of the latest request, set before its file is read so one that is superseded
+  // while reading is never answered.
+  latest = null;
+  transfer = null;
+  async request(id, read) {
+    this.latest = id;
+    this.transfer = null;
+    let result;
+    try {
+      result = await read();
+    } catch (err) {
+      if (this.latest === id) {
+        const missing = err?.code === "ENOENT";
+        this.send({ type: "media", id, result: missing ? "not-found" : "error" });
+      }
+      return;
+    }
+    if (this.latest !== id) return;
+    if (result.kind !== "ok") {
+      this.send({ type: "media", id, result: RESULTS[result.kind] });
+      return;
+    }
+    this.send({ type: "media", id, result: "ok", mediaType: result.mediaType, size: result.bytes.byteLength });
+    this.transfer = {
+      id,
+      bytes: result.bytes,
+      chunks: Math.ceil(result.bytes.byteLength / MEDIA_CHUNK_BYTES),
+      sent: 0,
+      acked: 0
+    };
+    this.pump();
+  }
+  // Acknowledgements arrive in order; anything else (a stale id, a repeat, a chunk never sent)
+  // is ignored rather than trusted to open the window.
+  ack(id, seq) {
+    const t = this.transfer;
+    if (!t || t.id !== id || seq !== t.acked || seq >= t.sent) return;
+    t.acked += 1;
+    if (t.acked === t.chunks) {
+      this.transfer = null;
+      return;
+    }
+    this.pump();
+  }
+  cancel(id) {
+    if (this.latest === id) this.stop();
+  }
+  stop() {
+    this.latest = null;
+    this.transfer = null;
+  }
+  pump() {
+    const t = this.transfer;
+    while (t && t.sent < t.chunks && t.sent - t.acked < MEDIA_WINDOW) {
+      const start = t.sent * MEDIA_CHUNK_BYTES;
+      const data = Buffer.from(t.bytes.subarray(start, start + MEDIA_CHUNK_BYTES)).toString("base64");
+      this.send({ type: "mediaChunk", id: t.id, seq: t.sent, data });
+      t.sent += 1;
+    }
+  }
+};
+var RESULTS = {
+  forbidden: "forbidden",
+  "not-servable": "not-found",
+  "too-large": "too-large"
+};
+
+// src/server/browser-stream-handler.ts
+var FORWARDED_UPSTREAM_TYPES = /* @__PURE__ */ new Set(["frame", "tabs", "url", "status"]);
+var BrowserStreamHandler = class {
+  constructor(deps) {
+    this.deps = deps;
+    deps.client.onMessage((data) => {
+      void this.handleClientMessage(data);
+    });
+    deps.client.onDrain?.(() => {
+      if (this.pendingFrame !== null && !this.backpressured()) {
+        const frame = this.pendingFrame;
+        this.pendingFrame = null;
+        deps.client.send(frame);
+      }
+    });
+    deps.client.onClose(() => {
+      this.clientClosed = true;
+      deps.registry.release(deps.sessionName, this.viewer);
+      const upstream = this.upstream;
+      this.upstream = null;
+      upstream?.close();
+    });
+  }
+  deps;
+  authed = false;
+  clientClosed = false;
+  upstream = null;
+  pendingFrame = null;
+  // Kicked when another viewer acquires the same session: tell this client why and
+  // tear down both sides. Registered after a successful auth + upstream dial.
+  viewer = {
+    detach: () => {
+      const upstream = this.upstream;
+      this.upstream = null;
+      upstream?.close();
+      this.end("opened-elsewhere");
+    }
+  };
+  async handleClientMessage(data) {
+    let message;
+    try {
+      message = parseBrowserClientMessage(JSON.parse(data));
+    } catch {
+      return;
+    }
+    if (!this.authed) {
+      if (message.type !== "auth") {
+        this.deps.client.close();
+        return;
+      }
+      this.authed = true;
+      this.send({ type: "authResult", ok: true });
+      await this.dialUpstream();
+      return;
+    }
+    switch (message.type) {
+      case "auth":
+        return;
+      case "ping":
+        this.send({ type: "pong" });
+        return;
+      case "navigate":
+        await this.deps.commands.navigate(this.deps.sessionName, message.url).catch(() => void 0);
+        return;
+      case "back":
+        await this.deps.commands.back(this.deps.sessionName).catch(() => void 0);
+        return;
+      case "forward":
+        await this.deps.commands.forward(this.deps.sessionName).catch(() => void 0);
+        return;
+      case "setViewport":
+        await this.deps.commands.setViewport(this.deps.sessionName, message.width, message.height).catch(() => void 0);
+        return;
+      case "closeSession":
+        await this.deps.commands.stop(this.deps.sessionName).catch(() => void 0);
+        return;
+      case "input_mouse":
+      case "input_keyboard":
+      case "input_touch":
+        this.upstream?.send(data);
+        return;
+    }
+  }
+  async dialUpstream() {
+    let streamPort;
+    try {
+      const sessions = await this.deps.discovery.listSessions();
+      streamPort = sessions.find((s) => s.name === this.deps.sessionName)?.streamPort;
+    } catch {
+      this.end("error");
+      return;
+    }
+    if (streamPort === void 0) {
+      this.end("not-found");
+      return;
+    }
+    let upstream;
+    try {
+      upstream = await this.deps.connectUpstream(streamPort);
+    } catch {
+      this.end("error");
+      return;
+    }
+    if (this.clientClosed) {
+      upstream.close();
+      return;
+    }
+    this.upstream = upstream;
+    this.deps.registry.acquire(this.deps.sessionName, this.viewer);
+    upstream.onMessage((data) => {
+      this.forwardUpstreamMessage(data);
+    });
+    upstream.onClose(() => {
+      if (this.upstream !== upstream) return;
+      this.upstream = null;
+      this.end("closed");
+    });
+  }
+  forwardUpstreamMessage(data) {
+    let type;
+    try {
+      type = parseBrowserAgentMessage(JSON.parse(data)).type;
+    } catch {
+      return;
+    }
+    if (!FORWARDED_UPSTREAM_TYPES.has(type)) return;
+    if (type === "frame") {
+      if (this.backpressured()) {
+        this.pendingFrame = data;
+      } else {
+        this.pendingFrame = null;
+        this.deps.client.send(data);
+      }
+      return;
+    }
+    if (this.pendingFrame !== null && !this.backpressured()) {
+      this.deps.client.send(this.pendingFrame);
+      this.pendingFrame = null;
+    }
+    this.deps.client.send(data);
+  }
+  // One message in flight: the phone's acknowledgement is the only backpressure a proxy in front of the phone port leaves,
+  // and whatever is in flight is what terminal output waits behind. Frames arriving meanwhile
+  // are replaced, not queued (latest wins).
+  backpressured() {
+    return (this.deps.client.bufferedAmount?.() ?? 0) > 0;
+  }
+  end(reason) {
+    if (this.clientClosed) return;
+    this.send({ type: "ended", reason });
+    this.deps.client.close();
+  }
+  send(message) {
+    this.deps.client.send(JSON.stringify(message));
+  }
+};
+
+// src/server/session-browser-streams.ts
+var MAX_BROWSER_STREAMS = 4;
+var SessionBrowserStreams = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  streams = /* @__PURE__ */ new Map();
+  open(stream, session) {
+    this.streams.get(stream)?.end();
+    if (this.streams.size >= MAX_BROWSER_STREAMS) {
+      this.deps.send({ type: "browserClosed", stream });
+      return;
+    }
+    const socket = new StreamSocket(stream, this.deps.send, () => {
+      if (this.streams.get(stream) === socket) this.streams.delete(stream);
+    });
+    this.streams.set(stream, socket);
+    this.deps.serve(socket, session);
+  }
+  deliver(stream, data) {
+    this.streams.get(stream)?.deliver(data);
+  }
+  ack(stream) {
+    this.streams.get(stream)?.ack();
+  }
+  close(stream) {
+    this.streams.get(stream)?.end();
+  }
+  closeAll() {
+    for (const socket of [...this.streams.values()]) socket.end();
+  }
+};
+var StreamSocket = class {
+  constructor(stream, sendMessage2, forget) {
+    this.stream = stream;
+    this.sendMessage = sendMessage2;
+    this.forget = forget;
+  }
+  stream;
+  sendMessage;
+  forget;
+  closed = false;
+  unacked = [];
+  buffered = 0;
+  messageListeners = [];
+  closeListeners = [];
+  drainListeners = [];
+  send(data) {
+    if (this.closed) return;
+    this.unacked.push(data.length);
+    this.buffered += data.length;
+    this.sendMessage({ type: "browser", stream: this.stream, data });
+  }
+  bufferedAmount() {
+    return this.buffered;
+  }
+  onDrain(listener) {
+    this.drainListeners.push(listener);
+  }
+  onMessage(listener) {
+    this.messageListeners.push(listener);
+  }
+  onClose(listener) {
+    this.closeListeners.push(listener);
+  }
+  // The handler ends the stream: tell the phone.
+  close() {
+    if (this.closed) return;
+    this.sendMessage({ type: "browserClosed", stream: this.stream });
+    this.end();
+  }
+  deliver(data) {
+    if (!this.closed) this.messageListeners.forEach((l) => l(data));
+  }
+  // An acknowledgement for nothing in flight is ignored, never allowed to open the window.
+  ack() {
+    const size = this.unacked.shift();
+    if (size === void 0) return;
+    this.buffered -= size;
+    this.drainListeners.forEach((l) => l());
+  }
+  // The phone closed it or the connection went away: nobody to tell.
+  end() {
+    if (this.closed) return;
+    this.closed = true;
+    this.forget();
+    this.closeListeners.forEach((l) => l());
+  }
+};
+
+// src/server/connection-handler.ts
+var CLIENT_LOG_MAX_BYTES = 512 * 1024;
+var ConnectionHandler = class {
+  constructor(conn, deps) {
+    this.conn = conn;
+    this.deps = deps;
+    this.media = new MediaSender((m) => conn.send(m));
+    this.browsers = new SessionBrowserStreams({
+      send: (m) => conn.send(m),
+      serve: (client, sessionName) => new BrowserStreamHandler({
+        client,
+        sessionName,
+        discovery: deps.browserDiscovery,
+        commands: deps.browserCommands,
+        connectUpstream: deps.connectUpstream,
+        registry: deps.browserViewers
+      })
+    });
+    conn.onMessage((raw) => {
+      void this.handle(raw);
+    });
+    conn.onKeyAuthenticated?.(() => void this.serveAtOnce());
+    conn.onClose(() => {
+      this.onClose();
+    });
+  }
+  conn;
+  deps;
+  authed = false;
+  // The dictation this phone is streaming; chunks that arrive before its checks pass wait in `queue`.
+  voice = null;
+  attachment = null;
+  media;
+  browsers;
+  pushWorkspaceUpdated(workspace) {
+    if (this.authed) {
+      this.conn.send({ type: "workspaceUpdated", workspace });
+    }
+  }
+  pushClosed(workspaceId) {
+    if (this.authed) {
+      this.conn.send({ type: "closed", workspaceId });
+    }
+  }
+  pushDeviceEnrolled(device) {
+    if (this.authed && (device.x25519 === void 0 || this.conn.device !== device.x25519)) {
+      this.conn.send({ type: "deviceEnrolled", id: device.id, name: device.name, at: device.at });
+    }
+  }
+  pushStats(stats) {
+    if (this.authed) {
+      this.conn.send({ type: "stats", stats });
+    }
+  }
+  // A question or menu opened in a workspace being dictated into: from now on its held spaces
+  // would land on the menu, so the dictation ends (the phone stops recording on the reply).
+  stopVoiceIn(workspaceId, reason) {
+    if (this.voice?.workspaceId === workspaceId) this.cancelVoice(reason);
+  }
+  pushBrowserSessions(sessions) {
+    if (this.authed) {
+      this.conn.send({ type: "browserSessions", sessions });
+    }
+  }
+  onClose() {
+    this.cancelVoice("The phone disconnected");
+    this.media.stop();
+    this.browsers.closeAll();
+    const att = this.attachment;
+    if (!att) return;
+    att.terminated = true;
+    att.session.kill();
+    this.deps.registry.release(att.workspaceId, att.viewer);
+    this.attachment = null;
+  }
+  async handle(raw) {
+    let message;
+    try {
+      message = parseClientMessage(raw);
+    } catch (err) {
+      this.conn.send({ type: "error", code: "bad_message", message: errMsg(err) });
+      return;
+    }
+    if (message.type === "auth") {
+      const token = this.deps.config.token;
+      const isToken = token !== void 0 && constantTimeEqual(message.token, token);
+      const byKey = this.conn.keyCredential;
+      if (byKey === "device" && isToken && this.conn.refuse) {
+        this.conn.refuse(REFUSAL.tokenNotNeeded);
+        return;
+      }
+      if (this.authed) return;
+      if (byKey || isToken) {
+        this.authed = true;
+        this.conn.send({ type: "authResult", ok: true, credential: byKey ?? "token" });
+      } else {
+        this.conn.send({ type: "authResult", ok: false });
+        this.conn.close();
+      }
+      return;
+    }
+    if (!this.authed) {
+      this.conn.send({ type: "error", code: "unauthorized", message: "authenticate first" });
+      return;
+    }
+    try {
+      await this.route(message);
+    } catch (err) {
+      this.conn.send({ type: "error", code: "internal", message: errMsg(err) });
+    }
+  }
+  // The transport proved an enrolled device key and the phone asked to be served at once: answer
+  // `authResult` and what the phone asks for on every connect, without waiting for its `auth`.
+  async serveAtOnce() {
+    this.authed = true;
+    this.conn.send({ type: "authResult", ok: true, credential: "device", pushed: true });
+    for (const type of ["list", "listKeyterms"]) {
+      try {
+        await this.route({ type });
+      } catch (err) {
+        this.conn.send({ type: "error", code: "internal", message: errMsg(err) });
+      }
+    }
+  }
+  async route(message) {
+    const { config, tmux, recent, lister, reader, resolvePath, isDirectory, clock, ids, status, hiddenFolders, repoRemote, claudeSessions } = this.deps;
+    switch (message.type) {
+      case "list": {
+        const hidden = await hiddenFolders.list();
+        const workspaces = (await listWorkspaces({
+          tmux,
+          machineId: config.machineId,
+          sessionPrefix: config.sessionPrefix,
+          status,
+          repoRemote,
+          claudeSessions,
+          parked: this.deps.parked,
+          messagedLast: this.deps.messagedLast
+        })).filter((w) => !isHiddenPath(w.projectPath, hidden));
+        const claudeVoice = await this.deps.claudeVoice?.available() ?? false;
+        this.conn.send({ type: "workspaces", workspaces, claudeVoice });
+        await this.sendBrowserSessions();
+        return;
+      }
+      case "getRecentPaths": {
+        const hidden = await hiddenFolders.list();
+        this.conn.send({ type: "recentPaths", paths: await getRecentPaths({ recent, hidden }) });
+        return;
+      }
+      case "browseDir": {
+        const hidden = await hiddenFolders.list();
+        const { subdirs, files } = await browseDir({ lister, hidden }, message.path, await this.allowedRoots());
+        this.conn.send({ type: "dirEntries", path: message.path, subdirs, files });
+        return;
+      }
+      case "makeDir": {
+        const allowed = await this.allowedRoots();
+        const hidden = await hiddenFolders.list();
+        const created = await makeDir({ lister }, message.parent, message.name, allowed);
+        const { subdirs, files } = await browseDir({ lister, hidden }, created, allowed);
+        this.conn.send({ type: "dirEntries", path: created, subdirs, files });
+        return;
+      }
+      case "listRoots": {
+        this.conn.send({ type: "roots", roots: config.projectRoots });
+        return;
+      }
+      // Sent by PWAs from before the keyboard bar lost its command shortcuts; answering it
+      // with an error would show them a banner on every connect.
+      case "listCommands":
+        return;
+      case "listLaunchers":
+        await this.sendLaunchers();
+        return;
+      case "forgetLauncher":
+        await this.deps.launchers.forget(message.command);
+        await this.sendLaunchers();
+        return;
+      case "listKeyterms": {
+        this.conn.send({ type: "keyterms", keyterms: await this.deps.keyterms.list() });
+        return;
+      }
+      case "readFile": {
+        const { binary, data, truncated } = await readFile10({ reader }, message.path, await this.allowedRoots());
+        this.conn.send({ type: "fileContents", path: message.path, data, truncated, binary });
+        return;
+      }
+      case "create": {
+        const workspace = await createWorkspace(
+          { tmux, recent, resolvePath, isDirectory, clock, ids, machineId: config.machineId },
+          { projectPath: message.projectPath, command: message.command }
+        );
+        this.conn.send({ type: "workspaceUpdated", workspace });
+        const remembered = message.remember ? normalizeCommand(message.command) : null;
+        if (remembered) await this.deps.launchers.remember(remembered).catch(() => void 0);
+        return;
+      }
+      case "close": {
+        const scope = await retireWorkspace(
+          { ...this.deps, tmux, snapshot: (id) => this.snapshotWorkspace(id) },
+          message.workspaceId
+        );
+        this.conn.send({ type: "closed", workspaceId: message.workspaceId });
+        this.deps.broadcastClosed(message.workspaceId);
+        void finishClose(this.deps, message.workspaceId, scope);
+        return;
+      }
+      case "setStatus": {
+        if (!isWorkspaceStatus(message.status)) {
+          return;
+        }
+        if (message.status === "parked") {
+          const workspace = this.deps.forgetWorkspace(message.workspaceId) ?? await this.snapshotWorkspace(message.workspaceId);
+          if (workspace) {
+            const result = await parkWorkspace(
+              {
+                parked: this.deps.parked,
+                tmux: this.deps.tmux,
+                status: this.deps.status,
+                clock: this.deps.clock
+              },
+              workspace
+            );
+            if (result === "not-restorable") {
+              this.conn.send({
+                type: "error",
+                code: "not-restorable",
+                message: "Can't park yet: Tarfa hasn't seen a Claude session id for this workspace. Send it a message first, then park."
+              });
+            }
+          }
+          return;
+        }
+        status.set(message.workspaceId, message.status);
+        return;
+      }
+      case "setUrgent": {
+        status.setUrgent(message.workspaceId, message.urgent);
+        return;
+      }
+      case "attach": {
+        const result = await unparkWorkspace(
+          {
+            parked: this.deps.parked,
+            tmux: this.deps.tmux,
+            isDirectory: this.deps.isDirectory,
+            status: this.deps.status
+          },
+          message.workspaceId
+        );
+        if (result === "missing-directory") {
+          this.conn.send({
+            type: "error",
+            code: "missing-directory",
+            message: "the project directory no longer exists"
+          });
+          return;
+        }
+        await tmux.ensureHyperlinks?.();
+        this.attach(message.workspaceId, message.cols, message.rows);
+        return;
+      }
+      case "detach": {
+        if (this.attachment?.workspaceId === message.workspaceId) {
+          this.teardownAttachment("closed");
+        }
+        return;
+      }
+      case "input": {
+        if (this.attachment?.workspaceId === message.workspaceId) {
+          this.attachment.session.write(Buffer.from(message.data, "base64").toString("utf8"));
+        }
+        return;
+      }
+      case "resize": {
+        if (this.attachment?.workspaceId === message.workspaceId) {
+          this.attachment.session.resize(message.cols, message.rows);
+        }
+        return;
+      }
+      case "putFile": {
+        const projectPath = await this.workspacePath(message.workspaceId);
+        if (!projectPath) {
+          this.conn.send({ type: "error", code: "unknown_workspace", message: `unknown workspace: ${message.workspaceId}` });
+          return;
+        }
+        const bytes = new Uint8Array(Buffer.from(message.data, "base64"));
+        const path = await storePastedFile({ writer: this.deps.writer }, { projectPath, name: message.name, bytes });
+        this.conn.send({ type: "fileStored", workspaceId: message.workspaceId, path });
+        return;
+      }
+      case "voiceStart": {
+        const { workspaceId, id } = message;
+        this.cancelVoice("Superseded by a newer dictation");
+        const voice = { id, workspaceId, session: null, queue: [], ended: false, cancelled: null };
+        this.voice = voice;
+        const reply = (error) => {
+          if (this.voice === voice) this.voice = null;
+          this.conn.send(error ? { type: "voiceDone", id, ok: false, error } : { type: "voiceDone", id, ok: true });
+        };
+        if (!this.deps.claudeVoice) return reply("Claude voice needs a Linux machine with the voice loopback set up");
+        if (this.attachment?.workspaceId !== workspaceId) return reply("Open the workspace before dictating");
+        const tmuxSession = (await this.deps.tmux.listSessions(this.deps.config.sessionPrefix)).find((s) => s.name === workspaceId);
+        if (!tmuxSession || !runsClaude(tmuxSession.command)) return reply("Claude voice works only in a Claude Code workspace");
+        if (tmuxSession.program?.state === "blocked") return reply("Answer Claude\u2019s question first, then dictate");
+        if (voice.cancelled) return reply(voice.cancelled);
+        const session = this.deps.claudeVoice.start(() => {
+          if (this.attachment?.workspaceId === workspaceId) this.attachment.session.write(" ");
+        });
+        voice.session = session;
+        for (const pcm of voice.queue.splice(0)) session.write(pcm);
+        if (voice.ended) session.end();
+        void session.done.then(reply);
+        return;
+      }
+      case "voiceChunk": {
+        const voice = this.voice;
+        if (voice?.id !== message.id || voice.ended) return;
+        const pcm = new Uint8Array(Buffer.from(message.data, "base64"));
+        if (voice.session) voice.session.write(pcm);
+        else voice.queue.push(pcm);
+        return;
+      }
+      case "voiceEnd": {
+        const voice = this.voice;
+        if (voice?.id !== message.id) return;
+        voice.ended = true;
+        voice.session?.end();
+        return;
+      }
+      case "ping": {
+        this.conn.send({ type: "pong" });
+        return;
+      }
+      case "startBrowser": {
+        try {
+          await this.deps.browserCommands.start(message.workspaceId);
+        } catch (err) {
+          this.conn.send({ type: "error", code: "start-browser-failed", message: errMsg(err) });
+          return;
+        }
+        await this.sendBrowserSessions();
+        return;
+      }
+      case "readMedia": {
+        const { id, path } = message;
+        await this.media.request(
+          id,
+          async () => readServableFile({ reader: this.deps.reader }, path, await this.allowedRoots())
+        );
+        return;
+      }
+      case "mediaAck":
+        this.media.ack(message.id, message.seq);
+        return;
+      case "mediaCancel":
+        this.media.cancel(message.id);
+        return;
+      case "browserOpen":
+        this.browsers.open(message.stream, message.session);
+        return;
+      case "browser":
+        this.browsers.deliver(message.stream, message.data);
+        return;
+      case "browserAck":
+        this.browsers.ack(message.stream);
+        return;
+      case "browserClose":
+        this.browsers.close(message.stream);
+        return;
+      case "clientLog": {
+        let ok = JSON.stringify(message.batch).length <= CLIENT_LOG_MAX_BYTES;
+        if (ok) ok = await this.deps.clientLog.append(message.batch).then(() => true, () => false);
+        this.conn.send({ type: "clientLogAck", id: message.id, ok });
+        return;
+      }
+      default: {
+        const exhaustive = message;
+        void exhaustive;
+        this.conn.send({ type: "error", code: "unsupported", message: "unhandled message" });
+      }
+    }
+  }
+  // Names only — the stream port stays agent-side (the PWA reaches a stream through a
+  // `browserOpen` side channel in its session, never the upstream port directly). Discovery failure degrades to an
+  // empty list so a broken agent-browser install can never break the `list` reply.
+  async sendBrowserSessions() {
+    let sessions = [];
+    try {
+      sessions = (await this.deps.browserDiscovery.listSessions()).map(({ name }) => ({ name }));
+    } catch {
+    }
+    this.conn.send({ type: "browserSessions", sessions });
+  }
+  // The set of paths a client may browse/read: the configured roots ∪ the live workspaces'
+  // project paths, so a workspace's own tree is reachable even outside TARFA_PROJECT_ROOTS.
+  async sendLaunchers() {
+    const [detected, custom] = await Promise.all([this.deps.detectInstalled(KNOWN_CLIS), this.deps.launchers.list()]);
+    this.conn.send({ type: "launchers", detected, custom });
+  }
+  async allowedRoots() {
+    const { config, tmux, status } = this.deps;
+    const workspaces = await listWorkspaces({
+      tmux,
+      machineId: config.machineId,
+      sessionPrefix: config.sessionPrefix,
+      status,
+      messagedLast: this.deps.messagedLast
+    });
+    return [...config.projectRoots, ...workspaces.map((w) => w.projectPath)];
+  }
+  // The live workspace matching this id, freshly queried from tmux — used as a fallback
+  // when no poll has observed this workspace yet (e.g. it was created and closed within
+  // the same title-poll tick).
+  async snapshotWorkspace(workspaceId) {
+    const { config, tmux, status } = this.deps;
+    const workspaces = await listWorkspaces({
+      tmux,
+      machineId: config.machineId,
+      sessionPrefix: config.sessionPrefix,
+      status,
+      messagedLast: this.deps.messagedLast
+    });
+    return workspaces.find((w) => w.id === workspaceId);
+  }
+  // The cwd a workspace runs in (its projectPath), or undefined if no live session has that
+  // id. Used to anchor a pasted file under the workspace's own `.tmp/files/`.
+  async workspacePath(workspaceId) {
+    return (await this.snapshotWorkspace(workspaceId))?.projectPath;
+  }
+  attach(workspaceId, cols, rows) {
+    if (this.attachment) {
+      this.teardownAttachment("closed");
+    }
+    const session = this.deps.pty.spawn({
+      command: "tmux",
+      args: ["attach-session", "-t", exactTarget(workspaceId)],
+      cols,
+      rows
+    });
+    const viewer = {
+      detach: () => {
+        if (this.attachment?.session !== session) return;
+        this.cancelVoice("The workspace was opened on another device");
+        this.attachment.terminated = true;
+        session.kill();
+        this.attachment = null;
+        this.conn.send({ type: "detached", workspaceId, reason: "opened-elsewhere" });
+      }
+    };
+    const att = { workspaceId, session, terminated: false, viewer };
+    this.attachment = att;
+    this.deps.registry.acquire(workspaceId, viewer);
+    session.onData((data) => {
+      this.conn.send({
+        type: "output",
+        workspaceId,
+        data: Buffer.from(data, "utf8").toString("base64")
+      });
+    });
+    session.onExit(() => {
+      if (att.terminated) return;
+      if (this.attachment === att) {
+        this.cancelVoice("The workspace closed");
+        this.attachment = null;
+      }
+      this.deps.registry.release(workspaceId, viewer);
+      this.conn.send({ type: "detached", workspaceId, reason: "closed" });
+    });
+    this.conn.send({ type: "attached", workspaceId });
+  }
+  // A dictation lives only as long as its attachment: without one the held spaces go nowhere,
+  // and the machine's one dictation slot would stay taken.
+  cancelVoice(reason) {
+    const voice = this.voice;
+    if (!voice) return;
+    this.voice = null;
+    voice.cancelled = reason;
+    voice.session?.abort(reason);
+  }
+  teardownAttachment(reason) {
+    const att = this.attachment;
+    if (!att) return;
+    this.cancelVoice("The workspace was closed");
+    att.terminated = true;
+    att.session.kill();
+    this.deps.registry.release(att.workspaceId, att.viewer);
+    this.attachment = null;
+    this.conn.send({ type: "detached", workspaceId: att.workspaceId, reason });
+  }
+};
+function errMsg(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/server/viewer-registry.ts
+var ViewerRegistry = class {
+  holders = /* @__PURE__ */ new Map();
+  acquire(workspaceId, viewer) {
+    const current = this.holders.get(workspaceId);
+    if (current && current !== viewer) {
+      current.detach();
+    }
+    this.holders.set(workspaceId, viewer);
+  }
+  release(workspaceId, viewer) {
+    if (this.holders.get(workspaceId) === viewer) {
+      this.holders.delete(workspaceId);
+    }
+  }
+};
+
+// src/application/attention-decision.ts
+var WORK_TYPES = /* @__PURE__ */ new Set(["shell", "subagent", "workflow", "teammate", "cloud session"]);
+function isWaitedOnTask(task) {
+  if (typeof task !== "object" || task === null) return false;
+  const { status, type, server } = task;
+  if (status !== "running" && status !== "pending") return false;
+  return typeof type === "string" && WORK_TYPES.has(type) || typeof server === "string";
+}
+function hasRunningBackgroundTask(claude) {
+  if (typeof claude !== "object" || claude === null) return false;
+  const tasks = claude.background_tasks;
+  return Array.isArray(tasks) && tasks.some(isWaitedOnTask);
+}
+function isIdlePrompt(claude) {
+  if (typeof claude !== "object" || claude === null) return false;
+  return claude.notification_type === "idle_prompt";
+}
+function isSubagentToolCall(claude) {
+  if (typeof claude !== "object" || claude === null) return false;
+  return typeof claude.agent_id === "string";
+}
+var BLOCKING_TOOLS = /* @__PURE__ */ new Set(["AskUserQuestion", "ExitPlanMode"]);
+function isBlockingTool(claude) {
+  if (typeof claude !== "object" || claude === null) return false;
+  const name = claude.tool_name;
+  return typeof name === "string" && BLOCKING_TOOLS.has(name);
+}
+function isCodexQuestion(claude) {
+  if (typeof claude !== "object" || claude === null) return false;
+  const name = claude.tool_name;
+  return typeof name === "string" && name.startsWith("request_user_input");
+}
+function isPeerMessage(claude) {
+  if (typeof claude !== "object" || claude === null) return false;
+  return claude.tool_name === "SendMessage";
+}
+var NEW_SESSION_SOURCES = /* @__PURE__ */ new Set(["startup", "resume", "clear", "fork"]);
+function startsNewSession(claude) {
+  if (typeof claude !== "object" || claude === null) return false;
+  const source = claude.source;
+  return typeof source === "string" && NEW_SESSION_SOURCES.has(source);
+}
+var DROP_MARKS = { deferral: "clear", messagedLast: "clear", question: "clear" };
+function attentionDecision(input) {
+  const endsQuestion = input.questionPending ? { question: "clear" } : {};
+  const holdWorking = input.endedByOsc ? "working" : null;
+  switch (input.event) {
+    case "Stop":
+      if (hasRunningBackgroundTask(input.claude)) {
+        return { reason: "stop-background", status: holdWorking, deferral: "set", ...endsQuestion };
+      }
+      return input.messagedLast ? { reason: "stop-messaged", status: holdWorking, deferral: "set", ...endsQuestion } : { reason: "stop", status: "needs-feedback", deferral: "clear", ...endsQuestion };
+    // Fired instead of Stop when an API error ends the turn.
+    case "StopFailure":
+      return { reason: "stop-failure", status: "needs-feedback", ...DROP_MARKS };
+    case "SessionStart":
+      if (!startsNewSession(input.claude)) return { reason: "compact", status: null, deferral: "keep" };
+      return {
+        reason: "session-start",
+        status: input.currentStatus === "working" ? "needs-feedback" : null,
+        ...DROP_MARKS
+      };
+    case "Notification":
+      return isIdlePrompt(input.claude) && input.wasDeferred ? { reason: "idle-suppressed", status: null, deferral: "keep" } : { reason: "notification", status: "needs-feedback", deferral: "clear" };
+    case "UserPromptSubmit":
+      return { reason: "prompt", status: "working", deferral: "clear", messagedLast: "clear", ...endsQuestion };
+    // Codex asks before showing an approval prompt. A subagent's request still asks the user.
+    // With an automatic reviewer it fires too, and PostToolUse puts the status back a moment later.
+    case "PermissionRequest":
+      return { reason: "permission", status: "needs-feedback", deferral: "keep" };
+    // A background subagent's own tool calls fire these in the parent session after its Stop,
+    // so they must not clear the deferral — and must not speak for the parent's status at all.
+    case "PreToolUse":
+    case "PostToolUse":
+      if (isSubagentToolCall(input.claude)) return { reason: "subagent-tool", status: null, deferral: "keep" };
+      if (input.questionPending) return { reason: "question-pending", status: null, deferral: "keep" };
+      if (input.event === "PreToolUse" && isCodexQuestion(input.claude)) {
+        return { reason: "question", status: "needs-feedback", deferral: "keep", question: "set" };
+      }
+      if (input.event === "PreToolUse" && isBlockingTool(input.claude)) {
+        return { reason: "blocking-tool", status: "needs-feedback", deferral: "clear" };
+      }
+      if (input.event === "PostToolUse") {
+        if (input.sentDuringTool && !isPeerMessage(input.claude)) {
+          return { reason: "tarfa-send", status: "working", deferral: "keep" };
+        }
+        return {
+          reason: "tool",
+          status: "working",
+          deferral: "keep",
+          messagedLast: isPeerMessage(input.claude) ? "set" : "clear"
+        };
+      }
+      return { reason: "tool", status: "working", deferral: "keep", ...input.sentDuringTool ? {} : { messagedLast: "clear" } };
+    default:
+      return { reason: "unknown-event", status: null, deferral: "keep" };
+  }
+}
+
+// src/application/apply-hook-event.ts
+function field(claude, key) {
+  if (typeof claude !== "object" || claude === null) return void 0;
+  const value = claude[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function extractSessionId(claude) {
+  return field(claude, "session_id");
+}
+var MAX_LOGGED_TASKS = 20;
+var MAX_LOGGED_CHARS = 200;
+function trim(value) {
+  return value.length > MAX_LOGGED_CHARS ? `${value.slice(0, MAX_LOGGED_CHARS)}\u2026` : value;
+}
+function errorField(claude) {
+  if (typeof claude !== "object" || claude === null) return void 0;
+  const value = claude.error;
+  if (value === void 0 || value === null) return void 0;
+  return typeof value === "string" ? value : JSON.stringify(value);
+}
+function loggedTasks(claude) {
+  if (typeof claude !== "object" || claude === null) return void 0;
+  const tasks = claude.background_tasks;
+  if (!Array.isArray(tasks)) return void 0;
+  return tasks.slice(0, MAX_LOGGED_TASKS).map(
+    (task) => typeof task === "object" && task !== null ? Object.fromEntries(Object.entries(task).map(([k, v]) => [k, typeof v === "string" ? trim(v) : v])) : task
+  );
+}
+function logEntry(input, decision, before, after) {
+  const { claude } = input;
+  const error = errorField(claude);
+  const entry = {
+    workspace: input.sessionName,
+    event: input.event,
+    agent: input.agent,
+    sessionId: field(claude, "session_id"),
+    tool: field(claude, "tool_name"),
+    notificationType: field(claude, "notification_type"),
+    source: field(claude, "source"),
+    subagent: field(claude, "agent_id") ? true : void 0,
+    backgroundTasks: loggedTasks(claude),
+    error: error && trim(error),
+    reason: decision.reason,
+    before,
+    after
+  };
+  return Object.fromEntries(Object.entries(entry).filter(([, v]) => v !== void 0));
+}
+function markSent(marks2, id) {
+  marks2.sentDuringTool.add(id);
+  marks2.messagedLast.add(id);
+}
+function state(marks2, status, id) {
+  return {
+    ...status ? { status } : {},
+    deferred: marks2.deferred.has(id),
+    messagedLast: marks2.messagedLast.has(id),
+    questionPending: marks2.questionPending.has(id)
+  };
+}
+function applyHookEvent(deps, input) {
+  const sessionId = input.agent === "codex" ? void 0 : extractSessionId(input.claude);
+  if (sessionId) {
+    deps.store.setClaudeSessionId(input.sessionName, sessionId);
+  }
+  const currentStatus = deps.store.get(input.sessionName);
+  const before = state(deps, currentStatus, input.sessionName);
+  const decision = attentionDecision({
+    event: input.event,
+    claude: input.claude,
+    wasDeferred: before.deferred,
+    messagedLast: before.messagedLast,
+    sentDuringTool: deps.sentDuringTool.has(input.sessionName),
+    questionPending: before.questionPending,
+    currentStatus,
+    endedByOsc: deps.oscTurnEnded?.has(input.sessionName)
+  });
+  if (decision.deferral === "set") {
+    deps.deferred.add(input.sessionName);
+  } else if (decision.deferral === "clear") {
+    deps.deferred.delete(input.sessionName);
+  }
+  const startsCodexCall = input.agent === "codex" && input.event === "PreToolUse" && decision.reason === "tool";
+  if (startsCodexCall || decision.reason === "tarfa-send" && input.agent !== "codex") {
+    deps.sentDuringTool.delete(input.sessionName);
+  }
+  if (startsCodexCall) deps.messagedLast.delete(input.sessionName);
+  if (decision.messagedLast === "set") {
+    deps.messagedLast.add(input.sessionName);
+    deps.sentDuringTool.delete(input.sessionName);
+  } else if (decision.messagedLast === "clear") {
+    deps.messagedLast.delete(input.sessionName);
+    deps.sentDuringTool.delete(input.sessionName);
+  }
+  if (decision.question === "set") {
+    deps.questionPending.add(input.sessionName);
+  } else if (decision.question === "clear") {
+    deps.questionPending.delete(input.sessionName);
+  }
+  if (decision.status) {
+    deps.store.set(input.sessionName, decision.status);
+    deps.oscTurnEnded?.delete(input.sessionName);
+  }
+  if (deps.log) {
+    const after = state(deps, decision.status ?? currentStatus, input.sessionName);
+    deps.log.append(logEntry(input, decision, before, after)).catch(() => void 0);
+  }
+  return decision.status ? { workspaceId: input.sessionName, status: decision.status } : null;
+}
+
+// src/application/send-message.ts
+import { randomBytes } from "node:crypto";
+function headerSafe(name) {
+  return name.replace(/[\p{Cc}"]/gu, " ").replace(/\s+/g, " ").trim();
+}
+async function sendMessage(deps, req) {
+  const bytes = Buffer.byteLength(req.body, "utf8");
+  let from = "";
+  let relation = "peer";
+  let cli = null;
+  const refuse = async (reason) => {
+    await record("refused", reason);
+    return { result: "refused", reason };
+  };
+  const record = async (outcome, reason) => {
+    try {
+      await deps.log.append({
+        at: deps.now(),
+        from,
+        to: req.to,
+        relation,
+        cli,
+        outcome,
+        ...reason !== void 0 ? { reason } : {},
+        bytes
+      });
+    } catch {
+    }
+  };
+  if (req.body.trim() === "") return refuse("empty message");
+  const sender = req.codexThread !== void 0 ? sessionOfCodexThread(await deps.tmux.listSessions(deps.sessionPrefix), req.codexThread) : await resolveSender(deps, req.pane, req.pid);
+  if (!sender) return refuse("not run from a Tarfa workspace");
+  from = sender.name;
+  if (req.to === sender.name) return refuse("cannot message yourself");
+  const sessions = await deps.tmux.listSessions(deps.sessionPrefix);
+  const recipient = sessions.find((s) => s.name === req.to);
+  if (!recipient) {
+    if (await deps.parked.get(req.to)) return refuse(`${req.to} is parked; run tarfa unpark ${req.to} first`);
+    return refuse(`no workspace ${req.to} on this machine`);
+  }
+  relation = relationOf(
+    { id: sender.name, parentId: sender.parent },
+    { id: recipient.name, parentId: recipient.parent }
+  );
+  cli = cliOfCommand(recipient.command);
+  if (!cli) return refuse(`${req.to} runs no claude, codex or pi`);
+  if (isNoDaemonCodex(recipient.command)) return refuse(`${req.to} was started with --no-daemon`);
+  const text = formatAgentMessage({
+    from: {
+      id: sender.name,
+      name: headerSafe(deriveWorkspaceName(sender.title, sender.startPath, sender.command, sender.name)),
+      cli: cliOfCommand(sender.command) ?? "shell"
+    },
+    relation,
+    machineId: deps.machineId,
+    msgId: (deps.messageId ?? (() => randomBytes(4).toString("hex")))(),
+    body: req.body
+  });
+  const delivered = await deps.delivery.deliver(
+    {
+      id: recipient.name,
+      from: sender.name,
+      cli,
+      command: recipient.command,
+      ...recipient.codexThread ? { codexThread: recipient.codexThread } : {}
+    },
+    text
+  );
+  if (!delivered.ok) return refuse(`delivery failed: ${delivered.reason}`);
+  await record("delivered");
+  deps.onSent(sender.name);
+  return { result: "delivered" };
+}
+async function resolveSender(deps, pane, pid) {
+  if (!deps.tmux.sessionOfPane || !deps.tmux.pidOfPane) return null;
+  const name = await deps.tmux.sessionOfPane(pane);
+  if (!name) return null;
+  const session = (await deps.tmux.listSessions(deps.sessionPrefix)).find((s) => s.name === name);
+  if (!session) return null;
+  const panePid = await deps.tmux.pidOfPane(pane);
+  if (panePid === null || !await deps.ancestry.isAncestor(panePid, pid)) return null;
+  return session;
+}
+
+// src/application/program-status-decision.ts
+function programStatusDecision(input) {
+  if (input.currentStatus === "finished" || input.currentStatus === "parked") {
+    return { reason: "osc-manual", status: null };
+  }
+  switch (input.state) {
+    case "working":
+      return { reason: "osc-working", status: "working" };
+    case "blocked":
+      return { reason: "osc-blocked", status: "needs-feedback" };
+    case "done":
+    case "error":
+      if (input.deferred) return { reason: "osc-deferred", status: null };
+      if (input.messagedLast) return { reason: "osc-messaged", status: null };
+      return { reason: "osc-done", status: "needs-feedback" };
+    // An Esc interrupt, or Codex's turn end (it says `idle`, not `done`): either way the session
+    // waits on the user. Only a session still marked working is moved, so a hook's own
+    // needs-feedback is never second-guessed.
+    case "idle":
+      return input.currentStatus === "working" ? { reason: "osc-idle", status: "needs-feedback", deferral: "clear" } : { reason: "osc-idle", status: null };
+    default:
+      return { reason: "osc-unknown", status: null };
+  }
+}
+
+// src/application/apply-program-status.ts
+function marks(deps, status, id) {
+  return {
+    ...status ? { status } : {},
+    deferred: deps.deferred.has(id),
+    messagedLast: deps.messagedLast.has(id),
+    questionPending: deps.questionPending.has(id)
+  };
+}
+function applyProgramStatus(deps, panes) {
+  const changed = [];
+  const present = /* @__PURE__ */ new Set();
+  for (const { name, program } of panes) {
+    if (!program) continue;
+    present.add(name);
+    const key = `${program.state}@${program.changedAt}`;
+    const previous = deps.seen.get(name);
+    deps.seen.set(name, key);
+    if (previous === void 0 || previous === key) continue;
+    const currentStatus = deps.store.get(name);
+    const before = marks(deps, currentStatus, name);
+    const decision = programStatusDecision({
+      state: program.state,
+      currentStatus,
+      deferred: before.deferred,
+      messagedLast: before.messagedLast
+    });
+    if (decision.deferral === "clear") deps.deferred.delete(name);
+    const turnEnd = decision.reason === "osc-done" || decision.reason === "osc-idle";
+    if (decision.status && !turnEnd) deps.oscTurnEnded.delete(name);
+    if (decision.status && decision.status !== currentStatus) {
+      deps.store.set(name, decision.status);
+      if (turnEnd) deps.oscTurnEnded.add(name);
+      changed.push(name);
+    }
+    deps.log?.append({
+      workspace: name,
+      event: "OSC7501",
+      programState: program.state,
+      reason: decision.reason,
+      before,
+      after: marks(deps, decision.status ?? currentStatus, name)
+    }).catch(() => void 0);
+  }
+  for (const name of deps.seen.keys()) {
+    if (!present.has(name)) deps.seen.delete(name);
+  }
+  return changed;
+}
+
+// src/server/ws-server.ts
+var DEFAULT_TITLE_POLL_MS = 2e3;
+var DEFAULT_TICK_DEADLINE_MS = 3e4;
+var DEFAULT_STATS_POLL_MS = 5e3;
+var CLOSING_MS = 1e4;
+var LOOPBACK = "127.0.0.1";
+var HOOK_BODY_MAX_BYTES = 1024 * 1024;
+var WsServer = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  http = null;
+  registry = new ViewerRegistry();
+  // Separate registry for browser viewers: keys are session names, which could collide
+  // with the terminal registry's workspace ids (sessions are named after workspaces).
+  browserViewers = new ViewerRegistry();
+  handlers = /* @__PURE__ */ new Set();
+  phoneClients = /* @__PURE__ */ new Set();
+  titlePoll = null;
+  tickRunning = false;
+  statsPoll = null;
+  lastWorkspaces = /* @__PURE__ */ new Map();
+  // Workspaces an explicit close has forgotten while tmux may still list them (the kill is async),
+  // with when the mark lapses: pollTitles must not take them back meanwhile. Dropped once tmux no
+  // longer lists them, or after CLOSING_MS, so a kill that never lands cannot hide one for good.
+  closing = /* @__PURE__ */ new Map();
+  lastBrowserNames = /* @__PURE__ */ new Set();
+  // Sessions parked on background work or on a peer session's reply, so the idle notification
+  // that follows their Stop can be told apart from a genuine one. In-memory on purpose — see
+  // applyHookEvent.
+  deferred = /* @__PURE__ */ new Set();
+  // Sessions whose last main-loop tool call was SendMessage — see applyHookEvent. Kept in the
+  // status store rather than here, so it survives a restart and `tarfa ls` can read it.
+  messagedLast = {
+    has: (id) => this.deps.status.getMessagedLast(id),
+    add: (id) => this.deps.status.setMessagedLast(id, true),
+    delete: (id) => this.deps.status.setMessagedLast(id, false)
+  };
+  // Sessions that ran tarfa send inside their current tool call — see markSent.
+  sentDuringTool = /* @__PURE__ */ new Set();
+  // Codex sessions with a question waiting on the user — see applyHookEvent.
+  questionPending = /* @__PURE__ */ new Set();
+  // Sessions whose needs-feedback an OSC 7501 turn end set — see applyProgramStatus. In-memory:
+  // losing it costs one race won by needs-feedback, never a hidden prompt.
+  oscTurnEnded = /* @__PURE__ */ new Set();
+  // Hooks posted by Codex thread, applied one after another in arrival order.
+  threadHooks = Promise.resolve();
+  // The panes showing a question or menu at the last poll.
+  asking = /* @__PURE__ */ new Set();
+  // The last OSC 7501 record seen per pane, so only a change is applied (applyProgramStatus).
+  programSeen = /* @__PURE__ */ new Map();
+  // Removes and returns the last-known snapshot for a workspace id, if the poll has ever
+  // observed it. Used by ConnectionHandler on an explicit close, both to build the log
+  // entry (the session is about to be killed and tmux won't be able to answer afterward)
+  // and to keep the disappearance poll from separately logging it as `exited`. The tmux kill
+  // is async, so a poll tick in that gap still lists the session: `closing` keeps the poll
+  // from taking it back, which would log a duplicate `exited` once the kill lands. Only a close
+  // sets it: a park also forgets the workspace, but its parked record keeps it listed and an
+  // unpark brings the same id back, which the poll must go on following.
+  forgetWorkspace(id, closing = false) {
+    const workspace = this.lastWorkspaces.get(id);
+    this.lastWorkspaces.delete(id);
+    if (closing) this.closing.set(id, this.deps.clock.now() + CLOSING_MS);
+    void this.deps.liveSnapshot?.remove(id).catch(() => void 0);
+    return workspace;
+  }
+  // Called once a workspace has stopped and its close is logged. Ids are reused, so nothing
+  // keyed by this one may reach the next workspace that takes it: a stale `parked` status, an
+  // old Claude session id that unpark would resume, a deferral that would hide a "Needs you".
+  dropWorkspaceState(id) {
+    this.closing.delete(id);
+    this.deps.status.forget(id);
+    this.deferred.delete(id);
+    this.questionPending.delete(id);
+    this.sentDuringTool.delete(id);
+    this.oscTurnEnded.delete(id);
+    this.programSeen.delete(id);
+  }
+  // pollTitles logs and drops a workspace it saw go, but it runs only while a phone is connected
+  // and never follows a hidden folder. This drops the rest, so an exited workspace's number is
+  // free again without an agent restart. The ids are read before tmux is listed: an entry a hook
+  // writes in between belongs to a session that already exists.
+  async dropGoneWorkspaces() {
+    const known = /* @__PURE__ */ new Set([...this.deps.status.ids(), ...this.deferred, ...this.questionPending, ...this.oscTurnEnded]);
+    if (known.size === 0) return;
+    let present;
+    try {
+      const sessions = await this.deps.tmux.listSessions(this.deps.config.sessionPrefix);
+      const parked = await this.deps.parked.list();
+      present = /* @__PURE__ */ new Set([...sessions.map((s) => s.name), ...parked.map((p) => p.id)]);
+    } catch {
+      return;
+    }
+    for (const id of known) {
+      if (!present.has(id) && !this.lastWorkspaces.has(id)) this.dropWorkspaceState(id);
+    }
+  }
+  // A device was just enrolled: every phone connected here hears of it, except that device.
+  broadcastDeviceEnrolled(device) {
+    for (const handler of this.handlers) handler.pushDeviceEnrolled(device);
+  }
+  // Pushes a `closed` message to every connected device — used when a workspace is closed
+  // explicitly, so devices other than the requester learn about it immediately instead of
+  // waiting for the next title-poll tick (which no longer fires it for this id, since
+  // forgetWorkspace already removed it from the tracking map before the poll runs).
+  broadcastClosed(id) {
+    for (const handler of this.handlers) {
+      handler.pushClosed(id);
+    }
+  }
+  // Samples the machine's load and pushes it to every connected device. Skipped entirely
+  // while nobody is watching, and best-effort throughout: the interval is fire-and-forget,
+  // so a rejection here would be both silent and permanent.
+  async pollStats() {
+    if (this.handlers.size === 0) return;
+    let stats;
+    try {
+      stats = await this.deps.systemStats?.read();
+    } catch {
+      return;
+    }
+    if (!stats) return;
+    for (const handler of this.handlers) {
+      handler.pushStats(stats);
+    }
+  }
+  start() {
+    if (this.http) {
+      return Promise.reject(new Error("server already started"));
+    }
+    this.deps.status.onChange((workspaceId) => {
+      void this.broadcastWorkspace(workspaceId);
+    });
+    this.titlePoll = setInterval(() => void this.pollTick(), this.deps.titlePollMs ?? DEFAULT_TITLE_POLL_MS);
+    this.titlePoll.unref?.();
+    if (this.deps.systemStats) {
+      this.statsPoll = setInterval(() => {
+        void this.pollStats();
+      }, this.deps.statsPollMs ?? DEFAULT_STATS_POLL_MS);
+      this.statsPoll.unref?.();
+    }
+    return new Promise((resolve, reject) => {
+      const http = createServer((req, res) => {
+        this.handleHttp(req, res);
+      });
+      this.http = http;
+      http.on("error", (err) => {
+        this.http = null;
+        reject(err);
+      });
+      http.listen(this.deps.config.port, LOOPBACK, () => {
+        resolve();
+      });
+    });
+  }
+  // A socket a phone opened on the phone port, served only through the end-to-end Noise session
+  // keyed by the agent's static X25519 key.
+  acceptPhoneSocket(socket, staticPrivate, options) {
+    const conn = new NoiseClientConnection(socket, staticPrivate, options);
+    this.phoneClients.add(conn);
+    conn.onClose(() => this.phoneClients.delete(conn));
+    this.accept(conn);
+  }
+  // Closes the phone sessions of devices that have since been revoked. Only revocation closes a
+  // live session: a device that is merely unknown here may be one whose enrolment is still being
+  // written.
+  refuseRevokedDevices(isRevoked) {
+    for (const conn of this.phoneClients) {
+      if (conn.device && isRevoked(conn.device)) conn.refuse("device revoked");
+    }
+  }
+  // Serves one client connection. In production every one is a phone's Noise session
+  // (acceptPhoneSocket); tests hand in their own.
+  accept(conn) {
+    const handler = new ConnectionHandler(conn, {
+      ...this.deps,
+      registry: this.registry,
+      browserViewers: this.browserViewers,
+      forgetWorkspace: (id, closing) => this.forgetWorkspace(id, closing),
+      dropWorkspaceState: (id) => this.dropWorkspaceState(id),
+      broadcastClosed: (id) => this.broadcastClosed(id),
+      messagedLast: this.messagedLast
+    });
+    this.handlers.add(handler);
+    conn.onClose(() => {
+      this.handlers.delete(handler);
+    });
+  }
+  // Four routes, all behind the hooks secret: `/hooks` for Claude Code's hook events; `/unpark` for
+  // `tarfa unpark` and `/close` for `tarfa close`, which must go through the agent because it holds
+  // status.json in memory, writes parked.json itself and tells the phones; and `/message` for
+  // `tarfa send`, whose marks live here too.
+  handleHttp(req, res) {
+    const routes = this.deps.messaging ? ["/hooks", "/unpark", "/close", "/message"] : ["/hooks", "/unpark", "/close"];
+    if (req.method !== "POST" || !routes.includes(req.url ?? "")) {
+      res.writeHead(404).end();
+      return;
+    }
+    const route = req.url;
+    const token = this.deps.hookToken;
+    const authorization = req.headers.authorization ?? "";
+    if (!token || !constantTimeEqual(authorization, `Bearer ${token}`)) {
+      res.writeHead(401).end();
+      return;
+    }
+    let body = "";
+    let bytes = 0;
+    let refused = false;
+    req.on("data", (chunk) => {
+      if (refused) return;
+      bytes += chunk.length;
+      if (bytes > HOOK_BODY_MAX_BYTES) {
+        refused = true;
+        res.writeHead(413, { connection: "close" }).end();
+        req.destroy();
+        return;
+      }
+      body += chunk;
+    });
+    req.on("end", () => {
+      if (refused) return;
+      if (route === "/unpark") {
+        void this.handleUnpark(body, res);
+        return;
+      }
+      if (route === "/close") {
+        void this.handleClose(body, res);
+        return;
+      }
+      if (route === "/message") {
+        void this.handleMessage(body, res);
+        return;
+      }
+      try {
+        const parsed = JSON.parse(body);
+        const { sessionName, thread, event, claude, agent } = parsed;
+        if (typeof event !== "string") {
+          res.writeHead(400).end();
+          return;
+        }
+        if (typeof sessionName === "string") {
+          this.applyHook(sessionName, event, claude, agent);
+          res.writeHead(204).end();
+          return;
+        }
+        if (typeof thread !== "string") {
+          res.writeHead(400).end();
+          return;
+        }
+        if (agent !== "codex") {
+          res.writeHead(204).end();
+          return;
+        }
+        this.threadHooks = this.threadHooks.then(() => this.applyHookByThread(thread, event, claude, agent, res));
+      } catch {
+        res.writeHead(400).end();
+      }
+    });
+  }
+  // Codex under its daemon runs hooks outside every pane, so tarfa-hook.sh names the thread
+  // instead; one no workspace recorded is dropped.
+  async applyHookByThread(thread, event, claude, agent, res) {
+    try {
+      const session = sessionOfCodexThread(await this.deps.tmux.listSessions(this.deps.config.sessionPrefix), thread);
+      if (session) this.applyHook(session.name, event, claude, agent);
+      res.writeHead(204).end();
+    } catch {
+      res.writeHead(500).end();
+    }
+  }
+  applyHook(sessionName, event, claude, agent) {
+    const statusBefore = this.deps.status.get(sessionName);
+    const messagedBefore = this.messagedLast.has(sessionName);
+    applyHookEvent(
+      {
+        store: this.deps.status,
+        deferred: this.deferred,
+        messagedLast: this.messagedLast,
+        sentDuringTool: this.sentDuringTool,
+        questionPending: this.questionPending,
+        oscTurnEnded: this.oscTurnEnded,
+        log: this.deps.hookEventLog
+      },
+      { sessionName, event, claude, agent: typeof agent === "string" ? agent : void 0 }
+    );
+    if (this.messagedLast.has(sessionName) !== messagedBefore && this.deps.status.get(sessionName) === statusBefore) {
+      void this.broadcastWorkspace(sessionName).catch(() => void 0);
+    }
+  }
+  async handleUnpark(body, res) {
+    let id;
+    try {
+      id = JSON.parse(body).id;
+    } catch {
+      id = void 0;
+    }
+    if (typeof id !== "string" || id === "") {
+      res.writeHead(400).end();
+      return;
+    }
+    try {
+      const { parked, tmux, isDirectory, status } = this.deps;
+      const result = await unparkWorkspace({ parked, tmux, isDirectory, status }, id);
+      res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({ result }));
+    } catch (err) {
+      res.writeHead(500, { "content-type": "application/json" }).end(JSON.stringify({ error: err.message }));
+    }
+  }
+  async handleClose(body, res) {
+    let id;
+    try {
+      id = JSON.parse(body).id;
+    } catch {
+      id = void 0;
+    }
+    if (typeof id !== "string" || id === "") {
+      res.writeHead(400).end();
+      return;
+    }
+    const json = (status, answer) => res.writeHead(status, { "content-type": "application/json" }).end(JSON.stringify(answer));
+    try {
+      const { tmux, parked, config } = this.deps;
+      const known = (await tmux.listSessions(config.sessionPrefix)).some((s) => s.name === id) || await parked.get(id);
+      if (!known) {
+        json(200, { result: "no-such-workspace" });
+        return;
+      }
+      const scope = await retireWorkspace(
+        {
+          ...this.deps,
+          forgetWorkspace: (workspace, closing) => this.forgetWorkspace(workspace, closing),
+          dropWorkspaceState: (workspace) => this.dropWorkspaceState(workspace),
+          snapshot: async (workspace) => (await listWorkspaces({
+            tmux,
+            machineId: config.machineId,
+            sessionPrefix: config.sessionPrefix,
+            status: this.deps.status,
+            messagedLast: this.messagedLast
+          })).find((w) => w.id === workspace)
+        },
+        id
+      );
+      this.broadcastClosed(id);
+      json(200, { result: "closed" });
+      void finishClose(this.deps, id, scope);
+    } catch (err) {
+      json(500, { error: err.message });
+    }
+  }
+  async handleMessage(body, res) {
+    let req;
+    try {
+      req = JSON.parse(body);
+    } catch {
+      req = null;
+    }
+    const { pane, pid, to, body: text, codexThread } = req ?? {};
+    if (typeof pane !== "string" || !Number.isInteger(pid) || typeof to !== "string" || typeof text !== "string" || codexThread !== void 0 && typeof codexThread !== "string") {
+      res.writeHead(400).end();
+      return;
+    }
+    try {
+      const { ancestry, delivery, log } = this.deps.messaging;
+      const result = await sendMessage(
+        {
+          tmux: this.deps.tmux,
+          parked: this.deps.parked,
+          ancestry,
+          delivery,
+          log,
+          machineId: this.deps.config.machineId,
+          sessionPrefix: this.deps.config.sessionPrefix,
+          now: () => this.deps.clock.now(),
+          onSent: (senderId) => {
+            markSent({ sentDuringTool: this.sentDuringTool, messagedLast: this.messagedLast }, senderId);
+            void this.broadcastWorkspace(senderId).catch(() => void 0);
+          }
+        },
+        { pane, pid, to, body: text, ...codexThread !== void 0 ? { codexThread } : {} }
+      );
+      res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify(result));
+    } catch (err) {
+      res.writeHead(500, { "content-type": "application/json" }).end(JSON.stringify({ error: err.message }));
+    }
+  }
+  // A tick slower than the interval skips the next one rather than running beside it: a tick
+  // that read tmux before a session went and finished after a newer one saw it gone would take
+  // the workspace back, and it would be pushed closed and logged `exited` twice.
+  async pollTick() {
+    if (this.tickRunning) return;
+    this.tickRunning = true;
+    let deadline;
+    try {
+      await Promise.race([
+        Promise.all([
+          // Tracked first, so a workspace lost with its tmux server is already parked when the
+          // title poll looks for it, rather than logged and pushed as closed.
+          this.trackLive().then(() => this.pollTitles()).then(() => this.dropGoneWorkspaces()),
+          this.pollProgramStatus(),
+          this.pollBrowserSessions()
+        ]),
+        new Promise((resolve) => {
+          deadline = setTimeout(resolve, this.deps.tickDeadlineMs ?? DEFAULT_TICK_DEADLINE_MS);
+          deadline.unref?.();
+        })
+      ]);
+    } catch {
+    } finally {
+      clearTimeout(deadline);
+      this.tickRunning = false;
+    }
+    this.deps.onPollTick?.();
+  }
+  // The second status source beside the hooks, from a tmux patched to keep each pane's OSC 7501
+  // status; a stock tmux reports none and this changes nothing. Runs whether or not a client is
+  // connected: a stale `working` matters most when nobody is watching. Best-effort, like the tick.
+  async pollProgramStatus() {
+    let sessions;
+    try {
+      sessions = await this.deps.tmux.listSessions(this.deps.config.sessionPrefix);
+    } catch {
+      return;
+    }
+    applyProgramStatus(
+      {
+        store: this.deps.status,
+        deferred: this.deferred,
+        messagedLast: this.messagedLast,
+        questionPending: this.questionPending,
+        seen: this.programSeen,
+        oscTurnEnded: this.oscTurnEnded,
+        log: this.deps.hookEventLog
+      },
+      sessions
+    );
+    const asking = new Set(sessions.filter((s) => s.program?.state === "blocked").map((s) => s.name));
+    const flipped = [...asking, ...this.asking].filter((name) => asking.has(name) !== this.asking.has(name));
+    this.asking = asking;
+    for (const name of flipped) {
+      if (asking.has(name)) {
+        for (const handler of this.handlers) handler.stopVoiceIn(name, "Dictation stopped: Claude asked a question");
+      }
+      void this.broadcastWorkspace(name).catch(() => void 0);
+    }
+  }
+  // Runs whether or not a client is connected: the snapshot must be current when the server dies.
+  // Best-effort, as the interval is fire-and-forget.
+  async trackLive() {
+    if (!this.deps.liveSnapshot) return;
+    try {
+      await trackLiveWorkspaces({
+        tmux: this.deps.tmux,
+        snapshot: this.deps.liveSnapshot,
+        parked: this.deps.parked,
+        status: this.deps.status,
+        workspaceLog: this.deps.workspaceLog,
+        clock: this.deps.clock,
+        machineId: this.deps.config.machineId,
+        sessionPrefix: this.deps.config.sessionPrefix
+      });
+    } catch {
+      return;
+    }
+  }
+  // Detects pane-title renames (which have no hook) and pushes the new name, and detects
+  // sessions that have disappeared (the inner process exited and tmux destroyed the session)
+  // and pushes a `closed` so the workspace stops lingering as a ghost in connected clients.
+  // The first sighting of a session only records its name; later changes broadcast.
+  async pollTitles() {
+    if (this.handlers.size === 0) return;
+    let workspaces;
+    try {
+      workspaces = await listWorkspaces({
+        tmux: this.deps.tmux,
+        machineId: this.deps.config.machineId,
+        sessionPrefix: this.deps.config.sessionPrefix,
+        status: this.deps.status,
+        repoRemote: this.deps.repoRemote,
+        claudeSessions: this.deps.claudeSessions,
+        parked: this.deps.parked,
+        messagedLast: this.messagedLast
+      });
+    } catch {
+      return;
+    }
+    const hidden = await this.deps.hiddenFolders.list();
+    const present = /* @__PURE__ */ new Set();
+    const listed = new Set(workspaces.map((w) => w.id));
+    const now = this.deps.clock.now();
+    for (const [id, until] of this.closing) {
+      if (!listed.has(id) || now >= until) this.closing.delete(id);
+    }
+    for (const workspace of workspaces) {
+      if (isHiddenPath(workspace.projectPath, hidden) || this.closing.has(workspace.id)) continue;
+      present.add(workspace.id);
+      const previous = this.lastWorkspaces.get(workspace.id);
+      this.lastWorkspaces.set(workspace.id, workspace);
+      if (previous !== void 0 && previous.name !== workspace.name) {
+        for (const handler of this.handlers) {
+          handler.pushWorkspaceUpdated(workspace);
+        }
+      }
+    }
+    for (const id of this.lastWorkspaces.keys()) {
+      if (!present.has(id)) {
+        const workspace = this.lastWorkspaces.get(id);
+        this.lastWorkspaces.delete(id);
+        for (const handler of this.handlers) {
+          handler.pushClosed(id);
+        }
+        await recordWorkspaceClosed(
+          { workspaceLog: this.deps.workspaceLog, status: this.deps.status, clock: this.deps.clock },
+          workspace,
+          "exited"
+        );
+        this.dropWorkspaceState(id);
+        void closeWorkspaceBrowserSessions(
+          { discovery: this.deps.browserDiscovery, commands: this.deps.browserCommands },
+          id
+        );
+      }
+    }
+  }
+  // The agent only answers `list` with browserSessions, so a session started outside that
+  // request/reply cycle (the CLI, another device's start button) would stay invisible until
+  // a reconnect. This piggybacks on the title poll: when the live set of session names
+  // changes, push the fresh list to every connected client. Discovery is a cheap fs scan.
+  async pollBrowserSessions() {
+    if (this.handlers.size === 0) return;
+    let sessions;
+    try {
+      sessions = await this.deps.browserDiscovery.listSessions();
+    } catch {
+      return;
+    }
+    const names = new Set(sessions.map((s) => s.name));
+    const unchanged = names.size === this.lastBrowserNames.size && [...names].every((n) => this.lastBrowserNames.has(n));
+    if (unchanged) return;
+    this.lastBrowserNames = names;
+    const payload = sessions.map(({ name }) => ({ name }));
+    for (const handler of this.handlers) {
+      handler.pushBrowserSessions(payload);
+    }
+  }
+  // Fire-and-forget from the status store, so it must not reject: tmux failing here (its server
+  // exiting with its last session) would otherwise be an unhandled rejection, which ends the agent.
+  async broadcastWorkspace(workspaceId) {
+    let workspaces;
+    try {
+      workspaces = await listWorkspaces({
+        tmux: this.deps.tmux,
+        machineId: this.deps.config.machineId,
+        sessionPrefix: this.deps.config.sessionPrefix,
+        status: this.deps.status,
+        repoRemote: this.deps.repoRemote,
+        claudeSessions: this.deps.claudeSessions,
+        parked: this.deps.parked,
+        messagedLast: this.messagedLast
+      });
+    } catch {
+      return;
+    }
+    const workspace = workspaces.find((w) => w.id === workspaceId);
+    if (!workspace) {
+      return;
+    }
+    const hidden = await this.deps.hiddenFolders.list();
+    if (isHiddenPath(workspace.projectPath, hidden)) {
+      return;
+    }
+    for (const handler of this.handlers) {
+      handler.pushWorkspaceUpdated(workspace);
+    }
+  }
+  address() {
+    const addr = this.http?.address();
+    return { port: addr?.port ?? 0 };
+  }
+  stop() {
+    if (this.titlePoll) {
+      clearInterval(this.titlePoll);
+      this.titlePoll = null;
+    }
+    if (this.statsPoll) {
+      clearInterval(this.statsPoll);
+      this.statsPoll = null;
+    }
+    this.lastWorkspaces.clear();
+    this.lastBrowserNames.clear();
+    const http = this.http;
+    if (!http) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+      http.close((err) => {
+        this.http = null;
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+};
+
+// src/application/push-budget.ts
+var WINDOW_MS = 6e4;
+var PUSHES_PER_MINUTE = 10;
+var PushBudget = class {
+  constructor(now, perMinute = PUSHES_PER_MINUTE) {
+    this.now = now;
+    this.perMinute = perMinute;
+  }
+  now;
+  perMinute;
+  taken = /* @__PURE__ */ new Map();
+  take(deviceKey) {
+    const now = this.now();
+    const recent = (this.taken.get(deviceKey) ?? []).filter((t) => now - t < WINDOW_MS);
+    const allowed = recent.length < this.perMinute;
+    if (allowed) recent.push(now);
+    this.taken.set(deviceKey, recent);
+    return allowed;
+  }
+};
+
+// src/application/limited-log.ts
+var EVERY_MS = 6e4;
+var LimitedLog = class {
+  constructor(log, now, everyMs = EVERY_MS) {
+    this.log = log;
+    this.now = now;
+    this.everyMs = everyMs;
+  }
+  log;
+  now;
+  everyMs;
+  entries = /* @__PURE__ */ new Map();
+  line(key, text) {
+    const now = this.now();
+    const entry = this.entries.get(key) ?? { last: -Infinity, held: 0 };
+    if (now - entry.last >= this.everyMs) {
+      const held = entry.held ? ` (and ${entry.held} more in the last minute)` : "";
+      this.log(`${text}${held}`);
+      this.entries.set(key, { last: now, held: 0 });
+    } else {
+      this.entries.set(key, { ...entry, held: entry.held + 1 });
+    }
+  }
+};
+
+// src/application/device-gate.ts
+var RosterDevices = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  async check(x25519) {
+    const roster = await this.deps.store.read();
+    return { standing: standingOf(roster, x25519), enrolment: enrolmentMode(roster) };
+  }
+  async enrol(device, via) {
+    let known = true;
+    const roster = await this.deps.store.update((current) => {
+      known = standingOf(current, device.x25519) !== "unknown";
+      return mayEnrol(current, via) ? enrolDevice(current, device, this.deps.now()) : current;
+    });
+    this.deps.onChange();
+    const entry = known ? void 0 : roster.devices.find((d) => d.x25519 === device.x25519);
+    try {
+      if (entry) this.deps.onEnrolled?.({ id: entry.id, name: entry.name, at: entry.enrolledAt, x25519: entry.x25519 }, via);
+    } catch {
+    }
+    return standingOf(roster, device.x25519) === "enrolled";
+  }
+  // Spends a pairing secret for the device (X25519 key) about to be enrolled, binding it to that
+  // device. Atomic across processes, so two phones racing with one code cannot both get in. A
+  // secret this agent never issued (or has forgotten) gives no reason: it may be a token after all.
+  async redeemPairing(secret, device) {
+    if (!(await this.deps.store.read()).enrolment) return { redeemed: false, reason: REFUSAL.enrolmentClosed };
+    const outcome = await this.spend(secret, device);
+    if (outcome === "redeemed" || outcome === "mine") return { redeemed: true, fresh: outcome === "redeemed" };
+    if (outcome === "used") return { redeemed: false, reason: REFUSAL.codeUsed };
+    if (outcome === "expired") return { redeemed: false, reason: REFUSAL.codeExpired };
+    return { redeemed: false };
+  }
+  // Spends a live secret an enrolled device presented, whatever enrolment is set to: the device
+  // needs no code, and one left live would admit whoever else holds the link. True if it did.
+  async burnPairing(secret, device) {
+    return await this.spend(secret, device) === "redeemed";
+  }
+  async spend(secret, device) {
+    if (redeemPairing(await this.deps.pairings.read(), secret, this.deps.now(), device).outcome === "unknown") return "unknown";
+    let outcome = "unknown";
+    await this.deps.pairings.update((list) => {
+      const result = redeemPairing(list, secret, this.deps.now(), device);
+      outcome = result.outcome;
+      return result.list;
+    });
+    return outcome;
+  }
+};
+var RosterMonitor = class {
+  // `onRead`: every roster read, the first included, for what keeps a copy of it.
+  constructor(store, onChange, onRead) {
+    this.store = store;
+    this.onChange = onChange;
+    this.onRead = onRead;
+  }
+  store;
+  onChange;
+  onRead;
+  last = null;
+  async poll() {
+    let roster;
+    try {
+      roster = await this.store.read();
+    } catch {
+      return;
+    }
+    this.onRead?.(roster);
+    const text = JSON.stringify(roster);
+    if (this.last !== null && text !== this.last) this.onChange(roster);
+    this.last = text;
+  }
+};
+
+// src/server/device-gate-wiring.ts
+function startDeviceGate(deps) {
+  const { keys, server, store, log } = deps;
+  let last = null;
+  const wrote = () => {
+    store.read().then((roster) => last = roster, () => void 0);
+  };
+  const devices = new RosterDevices({
+    store,
+    pairings: deps.pairings,
+    now: () => /* @__PURE__ */ new Date(),
+    onChange: wrote,
+    onEnrolled: (device, via) => {
+      log(`device enrolled: ${device.id} "${device.name}" (${via === "pairing" ? "pairing code" : "token"})`);
+      server.broadcastDeviceEnrolled(device);
+    }
+  });
+  const pushBudget = new PushBudget(() => Date.now());
+  const refusalLog = new LimitedLog(log, () => Date.now());
+  const monitor = new RosterMonitor(
+    store,
+    (roster) => {
+      log(`device roster changed (${roster.devices.length} enrolled, ${roster.revoked.length} revoked)`);
+      server.refuseRevokedDevices((key) => standingOf(roster, key) === "revoked");
+    },
+    (roster) => {
+      last = roster;
+    }
+  );
+  void monitor.poll();
+  const poll = setInterval(() => void monitor.poll(), deps.rosterPollMs);
+  poll.unref();
+  return {
+    staticPrivate: b64url.decode(keys.x25519.privateKey),
+    devices,
+    options: (extra) => ({ devices, log, refusalLog, pushBudget, agentVersion: deps.agentVersion, ...extra }),
+    roster: () => last,
+    pollRoster: () => monitor.poll(),
+    stop: () => clearInterval(poll)
+  };
+}
+
+// src/infrastructure/phone-listener.ts
+import { createServer as createServer2 } from "node:http";
+import { WebSocketServer } from "ws";
+
+// src/application/phone-admission.ts
+var WINDOW_MS2 = 6e4;
+var UNAUTHENTICATED_PER_ADDRESS = 8;
+var UNAUTHENTICATED_TOTAL = 32;
+var HANDSHAKES_PER_MINUTE = 20;
+var UNAUTHENTICATED_PER_PREFIX = 3 * UNAUTHENTICATED_PER_ADDRESS;
+var HANDSHAKES_PER_MINUTE_PER_PREFIX = 3 * HANDSHAKES_PER_MINUTE;
+var UNAUTHENTICATED_PUBLIC_TOTAL = 16;
+var SWEEP_AT = 1024;
+var SWEEP_EVERY_MS = 1e3;
+var LOOPBACK2 = /^(127\.\d+\.\d+\.\d+|::1|::ffff:127\.\d+\.\d+\.\d+)$/;
+function clientAddress(peer, forwardedFor) {
+  if (!LOOPBACK2.test(peer)) return subscriber(peer);
+  const last = (forwardedFor ?? "").split(",").map((hop) => hop.trim()).filter(Boolean).at(-1);
+  return last === void 0 ? null : subscriber(last);
+}
+function isFunnelRequest(peer, header) {
+  return LOOPBACK2.test(peer) && header !== void 0;
+}
+function widePrefix(address) {
+  const match = /^([0-9a-f]+:[0-9a-f]+:[0-9a-f]+):([0-9a-f]+)::\/64$/.exec(address);
+  if (!match) return null;
+  return `${match[1]}:${(Number.parseInt(match[2], 16) & 65280).toString(16)}::/56`;
+}
+function subscriber(address) {
+  const mapped = /^::ffff:(\d+\.\d+\.\d+\.\d+)$/i.exec(address);
+  if (mapped) return mapped[1];
+  if (!address.includes(":") || address.includes(".")) return address;
+  const [head, tail, ...rest] = address.split("::");
+  if (rest.length > 0) return address;
+  const front = head ? head.split(":") : [];
+  const back = tail ? tail.split(":") : [];
+  const missing = 8 - front.length - back.length;
+  if (tail === void 0 ? front.length !== 8 : missing < 1) return address;
+  const groups = [...front, ...Array(missing).fill("0"), ...back];
+  if (!groups.every((g) => /^[0-9a-f]{1,4}$/i.test(g))) return address;
+  return `${groups.slice(0, 4).map((g) => Number.parseInt(g, 16).toString(16)).join(":")}::/64`;
+}
+var PhoneAdmission = class {
+  // Insertion order is age order.
+  pending = { tailnet: /* @__PURE__ */ new Set(), public: /* @__PURE__ */ new Set() };
+  perAddressCount = /* @__PURE__ */ new Map();
+  opened = /* @__PURE__ */ new Map();
+  lastSweep = -Infinity;
+  perAddress;
+  totals;
+  handshakesPerMinute;
+  now;
+  constructor(opts) {
+    this.now = opts.now;
+    this.perAddress = opts.perAddress ?? UNAUTHENTICATED_PER_ADDRESS;
+    this.totals = { tailnet: opts.total ?? UNAUTHENTICATED_TOTAL, public: opts.publicTotal ?? UNAUTHENTICATED_PUBLIC_TOTAL };
+    this.handshakesPerMinute = opts.handshakesPerMinute ?? HANDSHAKES_PER_MINUTE;
+  }
+  admit(address, evict, pool = "tailnet") {
+    const wide = address === null ? null : widePrefix(address);
+    const keys = address === null ? [] : wide === null ? [address] : [address, wide];
+    const caps = (i) => i === 0 ? [this.perAddress, this.handshakesPerMinute] : [UNAUTHENTICATED_PER_PREFIX, HANDSHAKES_PER_MINUTE_PER_PREFIX];
+    if (keys.some((key, i) => (this.perAddressCount.get(key) ?? 0) >= caps(i)[0])) return { ok: false, reason: "address" };
+    if (keys.length > 0) {
+      const now = this.now();
+      if (this.opened.size > SWEEP_AT && now - this.lastSweep >= SWEEP_EVERY_MS) this.sweep(now);
+      const recent = keys.map((key) => (this.opened.get(key) ?? []).filter((t) => now - t < WINDOW_MS2));
+      if (recent.some((times, i) => times.length >= caps(i)[1])) {
+        keys.forEach((key, i) => this.opened.set(key, recent[i]));
+        return { ok: false, reason: "rate" };
+      }
+      keys.forEach((key, i) => this.opened.set(key, [...recent[i], now]));
+    }
+    const pending = this.pending[pool];
+    if (pending.size >= this.totals[pool]) {
+      const oldest = pending.values().next().value;
+      this.remove(oldest);
+      oldest.evict();
+    }
+    const entry = { keys, pool, evict };
+    pending.add(entry);
+    for (const key of keys) this.perAddressCount.set(key, (this.perAddressCount.get(key) ?? 0) + 1);
+    const leave = () => this.remove(entry);
+    return { ok: true, release: leave, authenticated: leave };
+  }
+  remove(entry) {
+    if (!this.pending[entry.pool].delete(entry)) return;
+    for (const key of entry.keys) {
+      const left = (this.perAddressCount.get(key) ?? 1) - 1;
+      if (left > 0) this.perAddressCount.set(key, left);
+      else this.perAddressCount.delete(key);
+    }
+  }
+  sweep(now) {
+    this.lastSweep = now;
+    for (const [address, times] of this.opened) {
+      if (times.every((t) => now - t >= WINDOW_MS2)) this.opened.delete(address);
+    }
+  }
+};
+
+// src/application/disk-read-limiter.ts
+var WINDOW_MS3 = 6e4;
+var DISK_READS_AT_ONCE = 4;
+var DISK_READS_PER_MINUTE = 10;
+var DiskReadLimiter = class {
+  constructor(now, concurrent = DISK_READS_AT_ONCE, perMinute = DISK_READS_PER_MINUTE) {
+    this.now = now;
+    this.concurrent = concurrent;
+    this.perMinute = perMinute;
+  }
+  now;
+  concurrent;
+  perMinute;
+  running = 0;
+  started = [];
+  async run(read) {
+    const now = this.now();
+    this.started = this.started.filter((t) => now - t < WINDOW_MS3);
+    if (this.running >= this.concurrent || this.started.length >= this.perMinute) return "limited";
+    this.started.push(now);
+    this.running++;
+    try {
+      return await read();
+    } finally {
+      this.running--;
+    }
+  }
+};
+async function limited(limiter, read) {
+  const result = await limiter.run(read);
+  if (result === "limited") throw new DeviceGateBusy();
+  return result;
+}
+function limitedDevices(devices, limiter, roster) {
+  return {
+    check: async (x25519) => {
+      const known = roster();
+      if (known && standingOf(known, x25519) === "enrolled") return { standing: "enrolled", enrolment: enrolmentMode(known) };
+      return limited(limiter, () => devices.check(x25519));
+    },
+    enrol: (device, via) => devices.enrol(device, via),
+    redeemPairing: (secret, device) => limited(limiter, () => devices.redeemPairing(secret, device)),
+    burnPairing: (secret, device) => devices.burnPairing(secret, device)
+  };
+}
+
+// src/infrastructure/ws-frame-socket.ts
+var CLOSE_GRACE_MS = 1e3;
+function wsFrameSocket(socket, binaryOnly = false) {
+  return {
+    send: (frame) => socket.send(frame, { binary: true }),
+    onFrame: (listener) => socket.on("message", (data, isBinary2) => {
+      if (isBinary2 || !binaryOnly) listener(new Uint8Array(data));
+    }),
+    onClose: (listener) => socket.on("close", () => listener()),
+    close: (code, reason) => {
+      socket.close(code, reason);
+      setTimeout(() => socket.terminate(), CLOSE_GRACE_MS).unref();
+    }
+  };
+}
+
+// src/infrastructure/phone-listener.ts
+var LOOPBACK3 = "127.0.0.1";
+var HEARTBEAT_MS = 3e4;
+var HEADERS_TIMEOUT_MS = 1e4;
+var REQUEST_TIMEOUT_MS = 15e3;
+var KEEP_ALIVE_TIMEOUT_MS = 5e3;
+var TOO_MANY = IN_BAND_REFUSAL + 429;
+function startPhoneListener(opts) {
+  const { gate, server, admission, limiter } = opts;
+  const devices = limitedDevices(gate.devices, limiter, () => gate.roster());
+  const alive = /* @__PURE__ */ new WeakMap();
+  const http = createServer2((_req, res) => {
+    res.writeHead(404).end();
+  });
+  http.headersTimeout = HEADERS_TIMEOUT_MS;
+  http.requestTimeout = REQUEST_TIMEOUT_MS;
+  http.keepAliveTimeout = KEEP_ALIVE_TIMEOUT_MS;
+  const wss = new WebSocketServer({ noServer: true, maxPayload: MAX_FRAME_BYTES, perMessageDeflate: false });
+  http.on("upgrade", (req, socket, head) => {
+    socket.on("error", () => void 0);
+    const forwarded = req.headers["x-forwarded-for"];
+    const peer = req.socket.remoteAddress ?? "";
+    const address = clientAddress(peer, Array.isArray(forwarded) ? forwarded.join(",") : forwarded);
+    const funnel = req.headers["tailscale-funnel-request"];
+    const pool = isFunnelRequest(peer, Array.isArray(funnel) ? funnel.join(",") : funnel) ? "public" : "tailnet";
+    wss.handleUpgrade(req, socket, head, (ws) => {
+      ws.on("error", () => void 0);
+      const frame = wsFrameSocket(ws, true);
+      const slot = admission.admit(address, () => frame.close(TOO_MANY, REFUSAL.tooManyPending), pool);
+      if (!slot.ok) {
+        gate.options({}).refusalLog?.line(`phone:${slot.reason}`, `phone port: refused a socket from ${address ?? "a local proxy"}: too many (${slot.reason})`);
+        frame.close(TOO_MANY, REFUSAL.tooManyConnections);
+        return;
+      }
+      alive.set(ws, true);
+      ws.on("pong", () => alive.set(ws, true));
+      frame.onClose(slot.release);
+      server.acceptPhoneSocket(frame, gate.staticPrivate, {
+        ...gate.options({ onAuthenticated: slot.authenticated }),
+        devices,
+        ...opts.startTimer ? { startTimer: opts.startTimer } : {}
+      });
+    });
+  });
+  return new Promise((resolve, reject) => {
+    http.once("error", reject);
+    http.listen(opts.port, LOOPBACK3, () => {
+      http.off("error", reject);
+      http.on("error", (err) => opts.log(`phone port: ${err.message}`));
+      const heartbeat = setInterval(() => {
+        for (const ws of wss.clients) {
+          if (!alive.get(ws)) {
+            ws.terminate();
+            continue;
+          }
+          alive.set(ws, false);
+          ws.ping();
+        }
+      }, opts.heartbeatMs ?? HEARTBEAT_MS);
+      heartbeat.unref();
+      const address = http.address();
+      resolve({
+        port: typeof address === "object" && address ? address.port : opts.port,
+        close: async () => {
+          clearInterval(heartbeat);
+          for (const ws of wss.clients) ws.terminate();
+          wss.close();
+          await new Promise((done) => http.close(() => done()));
+        }
+      });
+    });
+  });
+}
+
+// src/infrastructure/token-file.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { rename as rename3, writeFile } from "node:fs/promises";
+import { join as join6 } from "node:path";
+
+// src/infrastructure/private-dir.ts
+import { chmod, mkdir as mkdir7, stat as stat4 } from "node:fs/promises";
+
+// src/application/private-files.ts
+function exposedFiles(files) {
+  return files.filter(({ mode }) => (mode & 63) !== 0).map(({ path, mode }) => `${path} is readable or writable by other users (mode ${(mode & 511).toString(8)}): run \`chmod 600 ${path}\``);
+}
+
+// src/infrastructure/private-dir.ts
+async function securePrivateDir(dir) {
+  await mkdir7(dir, { recursive: true, mode: 448 });
+  await chmod(dir, 448);
+}
+async function assertPrivateFiles(paths) {
+  const found = [];
+  for (const path of paths) {
+    try {
+      found.push({ path, mode: (await stat4(path)).mode });
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+  }
+  const problems = exposedFiles(found);
+  if (problems.length > 0) throw new Error(problems.join("\n"));
+}
+
+// src/infrastructure/token-file.ts
+async function writeHookToken(dir) {
+  await securePrivateDir(dir);
+  const token = randomBytes2(32).toString("base64url");
+  const path = join6(dir, "token");
+  const temporary = `${path}.${process.pid}.tmp`;
+  await writeFile(temporary, token, { encoding: "utf8", mode: 384 });
+  await rename3(temporary, path);
+  return token;
+}
+
+// src/infrastructure/ensure-utf8-locale.ts
+var UTF8 = /utf-?8/i;
+function ensureUtf8Locale(env) {
+  const effective = env.LC_ALL ?? env.LC_CTYPE ?? env.LANG;
+  if (effective !== void 0 && UTF8.test(effective)) return;
+  if (env.LC_ALL !== void 0) delete env.LC_ALL;
+  if (env.LC_CTYPE !== void 0) delete env.LC_CTYPE;
+  env.LANG = "en_US.UTF-8";
+}
+
+// src/serve.ts
+var ROSTER_POLL_MS = 3e3;
+var agentVersion = packageVersion();
+async function main() {
+  ensureUtf8Locale(process.env);
+  process.stdout.write(`tarfa agent: version ${agentVersion}
+`);
+  if (await migrateStateDir(homedir2()) === "moved") {
+    process.stdout.write(`tarfa agent: moved ~/.perch to ~/.tarfa (~/.perch is now a link to it)
+`);
+  }
+  const env = withLegacyEnv(process.env);
+  const config = loadConfig(env, homedir2());
+  assertServerConfig(config);
+  for (const warning of configWarnings(process.env)) process.stderr.write(`${warning}
+`);
+  await securePrivateDir(config.stateDir);
+  await assertPrivateFiles([
+    config.agentKeyPath,
+    config.devicesPath,
+    config.pairingPath,
+    join7(config.stateDir, "token"),
+    // It holds TARFA_TOKEN, which enrols a phone.
+    await locateAgentEnv(env, homedir2())
+  ]);
+  const hookToken = await writeHookToken(config.stateDir);
+  const tmux = new TmuxAdapter();
+  const status = new FileStatusStore(config.statusStorePath);
+  const parked = new FileParkedStore(config.parkedStorePath);
+  const liveSnapshot = new FileLiveSnapshotStore(config.liveSnapshotPath);
+  const workspaceLog = new FileWorkspaceLogStore(config.workspaceLogPath);
+  const claudeSessions = new FileClaudeSessionsStore(config.claudeSessionsDir);
+  await reconcileAtStartup({
+    tmux,
+    snapshot: liveSnapshot,
+    parked,
+    status,
+    workspaceLog,
+    clock: systemClock,
+    machineId: config.machineId,
+    sessionPrefix: config.sessionPrefix,
+    log: (line) => process.stdout.write(`${line}
+`)
+  });
+  const server = new WsServer({
+    config,
+    hookToken,
+    tmux,
+    recent: new FileRecentStore(config.recentStorePath),
+    lister: new FsProjectLister(),
+    reader: new FsFileReader(),
+    resolvePath: systemPathResolver,
+    isDirectory: fsIsDirectory,
+    clock: systemClock,
+    ids: new ShortWorkspaceIds({ tmux, sessionPrefix: config.sessionPrefix, parked, status, claudeSessions }),
+    pty: new NodePtyAdapter(),
+    status,
+    writer: new FsFileWriter(),
+    browserDiscovery: new FsBrowserDiscovery(),
+    browserCommands: new AgentBrowserCli(),
+    hiddenFolders: new FileHiddenFoldersStore(config.hiddenFoldersPath),
+    launchers: new FileLaunchersStore(config.launchersPath),
+    detectInstalled: (names) => detectInstalled(names, loginShellResolver()),
+    keyterms: new FileKeytermsStore(config.keytermsPath),
+    clientLog: new FileClientLogStore(config.clientLogPath),
+    hookEventLog: new FileHookEventLog(config.hookEventLogPath),
+    messaging: {
+      ancestry: new ProcAncestry(),
+      delivery: new CompositeDelivery({
+        claude: new ClaudeInboxDelivery(claudeSessions, async (id) => await tmux.firstPaneId?.(id) ?? null),
+        pi: new PiInboxDelivery(config.inboxDir),
+        codex: new CodexDelivery(new CodexAppServer())
+      }),
+      log: new FileMessageLog(config.messageLogPath)
+    },
+    workspaceLog,
+    parked,
+    liveSnapshot,
+    connectUpstream: connectBrowserUpstream,
+    repoRemote: new GitRepoRemote(),
+    claudeSessions,
+    scopes: new SystemdScopeReaper(),
+    ...config.stats === false ? {} : { systemStats: new ProcSystemStats() },
+    claudeVoice: process.platform === "linux" ? new ClaudeVoice({
+      player: new AplayVoicePlayer("aplay", aplayArgs(config.voiceDevice ?? LOOPBACK_DEVICE)),
+      settings: new FileClaudeSettings(join7(homedir2(), ".claude", "settings.json"))
+    }) : void 0
+  });
+  await server.start();
+  process.stdout.write(`tarfa agent: hooks on 127.0.0.1:${server.address().port}
+`);
+  const keys = await loadOrCreateAgentKeys(config.agentKeyPath);
+  const log = (message) => process.stdout.write(`${message}
+`);
+  const gate = startDeviceGate({
+    keys,
+    server,
+    store: new FileDeviceStore(config.devicesPath),
+    pairings: new FilePairingStore(config.pairingPath),
+    log,
+    rosterPollMs: ROSTER_POLL_MS,
+    agentVersion
+  });
+  try {
+    const phones = await startPhoneListener({
+      port: config.phonePort,
+      gate,
+      server,
+      admission: new PhoneAdmission({ now: () => Date.now() }),
+      limiter: new DiskReadLimiter(() => Date.now()),
+      log
+    });
+    log(`tarfa agent: phones on 127.0.0.1:${phones.port}`);
+    if (config.phoneAddresses.length > 0) log(`tarfa agent: phone addresses ${config.phoneAddresses.join(", ")}`);
+  } catch (err) {
+    process.stderr.write(
+      `tarfa agent: no phone port: 127.0.0.1:${config.phonePort} ${err instanceof Error ? err.message : String(err)}; set TARFA_PHONE_PORT in agent.env
+`
+    );
+  }
+}
+if (isEntrypoint(import.meta.url, process.argv[1])) {
+  main().catch((err) => {
+    process.stderr.write(`${err instanceof Error ? err.message : String(err)}
+`);
+    process.exitCode = 1;
+  });
+}
+export {
+  main
+};