coderemote 0.3.9 → 0.3.10

package/dist/coderemote.js

@@ -1,22 +1,23 @@
 #!/usr/bin/env node
 
 // bin/coderemote.js
-import { execFile as execFile11, execFileSync, spawn as spawn5 } from "node:child_process";
-import { randomBytes as randomBytes4 } from "node:crypto";
-import fs19 from "node:fs";
+import { execFile as execFile11, execFileSync, spawn as spawn6 } from "node:child_process";
+import { randomBytes as randomBytes6 } from "node:crypto";
+import fs22 from "node:fs";
 import net3 from "node:net";
-import os7 from "node:os";
-import path16 from "node:path";
+import os9 from "node:os";
+import path19 from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify as promisify4 } from "node:util";
 import qrcode from "qrcode-terminal";
 
 // ../../packages/agent-core/src/server.js
 import { createReadStream as createReadStream2, createWriteStream as createWriteStream2 } from "node:fs";
-import fs13 from "node:fs/promises";
+import fs15 from "node:fs/promises";
 import http3 from "node:http";
-import os6 from "node:os";
-import path10 from "node:path";
+import os8 from "node:os";
+import path12 from "node:path";
+import tls from "node:tls";
 import { pipeline as pipeline3 } from "node:stream/promises";
 import { randomUUID as randomUUID5, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
 
@@ -44,10 +45,20 @@ var Routes = Object.freeze({
   gitUnstage: "POST /api/git/unstage",
   gitDiscard: "POST /api/git/discard",
   gitCommit: "POST /api/git/commit",
+  // Added within v4: older agents answer 404.
+  gitCommitMessage: "POST /api/git/commit-message",
   gitLog: "GET /api/git/log",
   gitShow: "GET /api/git/show",
   gitPull: "POST /api/git/pull",
   gitPush: "POST /api/git/push",
+  // Added within v4 after the commit-message route: older agents answer 404.
+  gitFetch: "POST /api/git/fetch",
+  gitBranches: "GET /api/git/branches",
+  gitCheckout: "POST /api/git/checkout",
+  gitStashes: "GET /api/git/stashes",
+  gitStash: "POST /api/git/stash",
+  gitStashApply: "POST /api/git/stash/apply",
+  gitStashDrop: "POST /api/git/stash/drop",
   portsList: "GET /api/ports",
   portsKill: "POST /api/ports/kill",
   previewList: "GET /api/preview",
@@ -80,6 +91,8 @@ var Routes = Object.freeze({
   agentsStop: "POST /api/agents/stop",
   agentsForget: "POST /api/agents/forget",
   agentsUpload: "POST /api/agents/uploads",
+  // Added within v4: older agents answer 404.
+  agentsUploadFile: "GET /api/agents/uploads",
   pushDeviceSet: "PUT /api/push/device",
   pushDeviceDelete: "DELETE /api/push/device",
   pushTest: "POST /api/push/test"
@@ -87,6 +100,7 @@ var Routes = Object.freeze({
 var TUNNEL_HANDOFF_PATH = "/vsremote/handoff";
 var TUNNEL_AUTH_CALLBACK_HOST = "tunnel-auth";
 var TERMINAL_WS_PATH = "/api/term/ws";
+var LAN_SERVICE_TYPE = "_coderemote._tcp";
 var TerminalServerMessage = Object.freeze({ session: "session", exit: "exit" });
 var TerminalClientMessage = Object.freeze({ input: "input", resize: "resize" });
 var AGENTS_WS_PATH = "/api/agents/ws";
@@ -104,17 +118,28 @@ var AgentsClientMessage = Object.freeze({ presence: "presence" });
 function webUrl({ url, token }) {
   return `${url}/#token=${encodeURIComponent(token)}`;
 }
-function pairingUrl({ url, token }) {
-  return `${PAIRING_SCHEME}://pair?url=${encodeURIComponent(url)}&token=${encodeURIComponent(token)}`;
+function pairingUrl({ url = null, token, agentId = null, lan = null }) {
+  if (!url && !lan) throw new Error("a pairing link needs a tunnel URL or the LAN listener");
+  if (lan && !agentId) throw new Error("a pairing link with the LAN listener needs the agent id");
+  const q = new URLSearchParams();
+  if (url) q.set("url", url);
+  q.set("token", token);
+  if (agentId) q.set("id", agentId);
+  if (lan) {
+    q.set("lan", String(lan.port));
+    q.set("addr", lan.addresses.join(","));
+    q.set("fp", lan.fingerprint);
+  }
+  return `${PAIRING_SCHEME}://pair?${q.toString().replace(/\+/g, "%20")}`;
 }
 
 // ../../packages/agent-core/src/server.js
 import { WebSocketServer } from "ws";
 
 // ../../packages/agent-core/src/agents.js
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 import { EventEmitter } from "node:events";
-import path2 from "node:path";
+import path3 from "node:path";
 
 // ../../packages/agent-core/src/sandbox.js
 import fsSync from "node:fs";
@@ -264,6 +289,10 @@ function isTyped(text) {
   return t && !t.startsWith("<command-") && !t.startsWith("<local-command") && !t.startsWith("[Request interrupted");
 }
 function* entriesOf(record) {
+  if (record?.type === "ai-title" && typeof record.aiTitle === "string" && record.aiTitle.trim()) {
+    yield { time: 0, kind: "title", text: record.aiTitle.trim() };
+    return;
+  }
   if (!record || record.isSidechain || record.isMeta) return;
   const time2 = Date.parse(record.timestamp) || 0;
   const content = record.message?.content;
@@ -279,20 +308,38 @@ function* entriesOf(record) {
       }
     }
     const text = textOf(content);
-    if (isTyped(text) && content.every((c) => c?.type !== "tool_result")) yield { time: time2, kind: "prompt", text };
+    if (content.some((c) => c?.type === "tool_result")) return;
+    const images = content.filter((c) => c?.type === "image" && c.source?.type === "base64" && typeof c.source.data === "string").map((c) => ({ type: c.source.media_type ?? "image/png", data: c.source.data }));
+    if (isTyped(text) || images.length && !text.trim()) yield { time: time2, kind: "prompt", text, ...images.length ? { images } : {} };
   } else if (record.type === "assistant" && Array.isArray(content)) {
+    const model = record.message?.model;
+    if (typeof model === "string" && model && model !== "<synthetic>") yield { time: time2, kind: "model", model };
     for (const c of content) {
       if (c?.type === "text" && c.text?.trim()) yield { time: time2, kind: "assistant", text: c.text.trimEnd() };
+      else if (c?.type === "thinking" && c.thinking?.trim()) yield { time: time2, kind: "assistant", text: c.thinking.trimEnd(), thinking: true };
       else if (c?.type === "tool_use") yield { time: time2, kind: "tool", toolUseId: c.id ?? null, name: c.name ?? null, input: c.input ?? null };
     }
   }
 }
+function parse(text) {
+  const entries2 = [];
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      entries2.push(...entriesOf(JSON.parse(line)));
+    } catch {
+    }
+  }
+  return entries2;
+}
 async function readTranscript(file, limit = 500) {
   let text;
+  let end = 0;
   try {
     const handle = await fs3.open(file, "r");
     try {
       const { size } = await handle.stat();
+      end = size;
       const start2 = Math.max(0, size - TAIL_BYTES);
       const buf = Buffer.alloc(size - start2);
       await handle.read(buf, 0, buf.length, start2);
@@ -304,19 +351,179 @@ async function readTranscript(file, limit = 500) {
   } catch {
     return [];
   }
-  const entries2 = [];
+  const all = parse(text);
+  const title = all.findLast((e) => e.kind === "title");
+  const model = all.findLast((e) => e.kind === "model");
+  const entries2 = all.filter((e) => e.kind !== "title" && e.kind !== "model").slice(-limit);
+  if (model) entries2.unshift(model);
+  if (title) entries2.unshift(title);
+  entries2.end = end;
+  return entries2;
+}
+async function readTranscriptSince(file, offset) {
+  try {
+    const handle = await fs3.open(file, "r");
+    try {
+      const { size } = await handle.stat();
+      if (size < offset) return { entries: [], end: size };
+      const buf = Buffer.alloc(Math.min(size - offset, TAIL_BYTES));
+      await handle.read(buf, 0, buf.length, offset);
+      const last = buf.lastIndexOf(10);
+      if (last < 0) return { entries: [], end: offset };
+      return { entries: parse(buf.subarray(0, last + 1).toString("utf8")), end: offset + last + 1 };
+    } finally {
+      await handle.close();
+    }
+  } catch {
+    return null;
+  }
+}
+
+// ../../packages/agent-core/src/uploads.js
+import { execFile } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { createWriteStream } from "node:fs";
+import fs4 from "node:fs/promises";
+import os from "node:os";
+import path2 from "node:path";
+import { Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { promisify } from "node:util";
+var run = promisify(execFile);
+var UPLOAD_LIMIT = 100 * 1024 * 1024;
+var KEEP = 7 * 24 * 60 * 60 * 1e3;
+var ID = /^[0-9a-f-]{36}$/;
+var IMAGE_EXTENSIONS = { "image/png": ".png", "image/jpeg": ".jpg", "image/gif": ".gif", "image/webp": ".webp" };
+function imageType(file) {
+  const ext = path2.extname(String(file)).toLowerCase();
+  if (ext === ".jpeg") return "image/jpeg";
+  return Object.keys(IMAGE_EXTENSIONS).find((t) => IMAGE_EXTENSIONS[t] === ext) ?? null;
+}
+function attachedFiles(text, dir, typeOf = () => "application/octet-stream") {
+  if (!dir || !text.includes(dir)) return { text, files: [] };
+  const root2 = dir.endsWith(path2.sep) ? dir : dir + path2.sep;
+  const files = [];
+  const kept = [];
   for (const line of text.split("\n")) {
-    if (!line.trim()) continue;
+    const rest2 = line.trim().startsWith(root2) ? line.trim().slice(root2.length) : null;
+    const m = rest2 && /^\d{4}-\d{2}-\d{2}[\\/]([0-9a-f-]{36})-(.+)$/.exec(rest2);
+    if (m) files.push({ id: m[1], name: m[2], type: typeOf(m[2]) });
+    else kept.push(line);
+  }
+  return files.length ? { text: kept.join("\n").trim(), files } : { text, files };
+}
+function safeName(name) {
+  const base2 = path2.basename(String(name ?? "").replace(/\\/g, "/"));
+  const clean = base2.replace(/[^\p{L}\p{N}._ -]/gu, "_").replace(/^[.\s]+/, "").slice(-80).trim();
+  return clean || "file";
+}
+var UploadStore = class {
+  constructor(dir, { now = Date.now } = {}) {
+    this.dir = dir;
+    this.now = now;
+  }
+  /** Streams `body` to disk. 413 past `limit`; HEIC photos become JPEG on macOS. */
+  async save(body, { name, type, length, limit = UPLOAD_LIMIT }) {
+    if (Number(length) > limit) throw new HttpError(413, `files are limited to ${limit / 1024 / 1024} MB`);
+    const id = randomUUID();
+    const day = new Date(this.now()).toISOString().slice(0, 10);
+    await fs4.mkdir(path2.join(this.dir, day), { recursive: true, mode: 448 });
+    let file = path2.join(this.dir, day, `${id}-${safeName(name)}`);
+    let size = 0;
+    const counter = new Transform({
+      transform(chunk, _enc, done) {
+        size += chunk.length;
+        done(size > limit ? new HttpError(413, `files are limited to ${limit / 1024 / 1024} MB`) : null, chunk);
+      }
+    });
     try {
-      entries2.push(...entriesOf(JSON.parse(line)));
+      await pipeline(body, counter, createWriteStream(file, { mode: 384 }));
+    } catch (e) {
+      await fs4.rm(file, { force: true });
+      throw e;
+    }
+    let kind = type || "application/octet-stream";
+    if ((kind === "image/heic" || /\.heic$/i.test(file)) && os.platform() === "darwin") {
+      const jpeg = file.replace(/(\.heic)?$/i, ".jpg");
+      try {
+        await run("sips", ["-s", "format", "jpeg", file, "--out", jpeg], { timeout: 3e4 });
+        await fs4.rm(file);
+        file = jpeg;
+        kind = "image/jpeg";
+        size = (await fs4.stat(file)).size;
+      } catch {
+      }
+    }
+    return { id, name: path2.basename(file).slice(id.length + 1), type: kind, size, path: file };
+  }
+  /** The file of an upload; 404 once it's gone (swept, or never existed). */
+  async path(id) {
+    if (typeof id !== "string" || !ID.test(id)) throw new HttpError(400, "invalid upload id");
+    let days = [];
+    try {
+      days = (await fs4.readdir(this.dir)).sort().reverse();
+    } catch {
+    }
+    for (const day of days) {
+      let names = [];
+      try {
+        names = await fs4.readdir(path2.join(this.dir, day));
+      } catch {
+      }
+      const hit = names.find((n) => n.startsWith(`${id}-`));
+      if (hit) return path2.join(this.dir, day, hit);
+    }
+    throw new HttpError(404, "no such upload (they are kept for 7 days)");
+  }
+  /**
+   * Keeps bytes the agent found itself (an image in a transcript) as an upload, named by their
+   * content so the same image read again is the same upload. Resolves `{ id, type }`.
+   */
+  async keep(bytes2, type) {
+    const hash = createHash("sha256").update(bytes2).digest("hex");
+    const id = `${hash.slice(0, 8)}-${hash.slice(8, 12)}-${hash.slice(12, 16)}-${hash.slice(16, 20)}-${hash.slice(20, 32)}`;
+    const existing = await this.path(id).catch(() => null);
+    if (existing) {
+      const now = new Date(this.now());
+      await fs4.utimes(existing, now, now).catch(() => {
+      });
+      return { id, type };
+    }
+    const day = new Date(this.now()).toISOString().slice(0, 10);
+    await fs4.mkdir(path2.join(this.dir, day), { recursive: true, mode: 448 });
+    await fs4.writeFile(path2.join(this.dir, day, `${id}-image${IMAGE_EXTENSIONS[type] ?? ""}`), bytes2, { mode: 384 });
+    return { id, type };
+  }
+  /** Deletes uploads older than a week. */
+  async sweep() {
+    let days = [];
+    try {
+      days = await fs4.readdir(this.dir);
     } catch {
+      return;
+    }
+    const cutoff = this.now() - KEEP;
+    for (const day of days) {
+      const dir = path2.join(this.dir, day);
+      let names = [];
+      try {
+        names = await fs4.readdir(dir);
+      } catch {
+        continue;
+      }
+      for (const n of names) {
+        const file = path2.join(dir, n);
+        const stat = await fs4.stat(file).catch(() => null);
+        if (stat && stat.mtimeMs < cutoff) await fs4.rm(file, { force: true });
+      }
+      if (!(await fs4.readdir(dir).catch(() => [])).length) await fs4.rm(dir, { recursive: true, force: true });
     }
   }
-  return entries2.slice(-limit);
-}
+};
 
 // ../../packages/agent-core/src/agents.js
 var MAX_ENTRIES = 500;
+var SAVED_ENTRIES = 200;
 var MAX_TEXT = 16 * 1024;
 var MAX_TITLE = 80;
 var ENDED_TTL = 24 * 60 * 60 * 1e3;
@@ -327,7 +534,7 @@ var SEQUENTIAL_REQUEST_TTL = 10 * 60 * 1e3;
 var ADAPTERS = {
   claude: {
     name: "Claude Code",
-    capabilities: { approvals: "parallel", alwaysAllow: true, keys: ["interrupt", "cycle_mode", "/compact", "/clear", "/model"] },
+    capabilities: { approvals: "parallel", alwaysAllow: true, keys: ["interrupt", "cycle_mode", "set_mode", "/compact", "/clear", "/model"] },
     normalize: (e) => e
   },
   codex: {
@@ -367,6 +574,33 @@ function resultText(response) {
   }
   return JSON.stringify(response, null, 2);
 }
+function isNotice(prompt) {
+  return prompt.trimStart().startsWith("<task-notification>");
+}
+var PERMISSION_MODES = ["manual", "acceptEdits", "plan", "auto", "bypassPermissions", "dontAsk"];
+function modeOf(value) {
+  if (value === "default") return "manual";
+  return PERMISSION_MODES.includes(value) ? value : null;
+}
+var FOOTER_MODES = {
+  "manual mode": "manual",
+  "accept edits": "acceptEdits",
+  "plan mode": "plan",
+  "auto mode": "auto",
+  "bypass permissions": "bypassPermissions",
+  "don't ask": "dontAsk"
+};
+var FOOTER = /(?:⏸|⏵⏵) *(manual mode|accept edits|plan mode|auto mode|bypass permissions|don't ask) on/g;
+var CURSOR_RIGHT = /\x1b\[(\d*)C/g;
+var ANSI = /\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b\[[0-9;?<>=]*[ -/]*[@-~]|\x1b[()][0-9A-B]|\x1b./g;
+function plain(text) {
+  return text.replace(CURSOR_RIGHT, (_, n) => " ".repeat(Math.min(Number(n) || 1, 200))).replace(ANSI, "");
+}
+function footerMode(text) {
+  let mode = null;
+  for (const m of plain(text).matchAll(FOOTER)) mode = FOOTER_MODES[m[1]];
+  return mode;
+}
 function titleOf(prompt) {
   const line = prompt.trim().split("\n")[0].trim();
   return line.length > MAX_TITLE ? `${line.slice(0, MAX_TITLE - 1)}\u2026` : line;
@@ -376,17 +610,17 @@ var AgentSession = class {
     this.id = id;
     this.agent = agent;
     this.cwd = cwd;
-    this.title = path2.basename(cwd || "") || "Session";
+    this.title = path3.basename(cwd || "") || "Session";
     this.capabilities = (ADAPTERS[agent] ?? ADAPTERS.claude).capabilities;
     this.titled = false;
     this.state = "idle";
     this.terminal = terminal;
-    this.app = null;
     this.startedAt = now;
     this.lastActivityAt = now;
     this.endedAt = null;
     this.starting = false;
     this.error = null;
+    this.cleared = false;
     this.turnStartedAt = null;
     this.entries = [];
     this.seq = 0;
@@ -395,6 +629,8 @@ var AgentSession = class {
     this.prompts = [];
     this.tail = null;
     this.ready = Promise.resolve();
+    this.permissionMode = null;
+    this.model = null;
   }
   toJSON() {
     return {
@@ -409,7 +645,9 @@ var AgentSession = class {
       pending: this.requests.size,
       starting: this.starting,
       error: this.error,
-      capabilities: this.capabilities
+      capabilities: this.capabilities,
+      permissionMode: this.permissionMode,
+      model: this.model
     };
   }
 };
@@ -419,9 +657,14 @@ var AgentHub = class extends EventEmitter {
   #now;
   #requestTtl;
   #transcript;
+  #transcriptSince;
   #startTimeout;
   #sequentialTtl;
   #rolloutTail;
+  // Terminal id -> the tail of its output, for a footer split across chunks.
+  #footers = /* @__PURE__ */ new Map();
+  // Session id -> callbacks waiting for the footer to show a mode.
+  #modeWaiters = /* @__PURE__ */ new Map();
   /**
    * `present` says whether someone is at the computer or looking at it in a client; agents whose
    * approvals are sequential ask there instead of holding the request for the phone.
@@ -431,28 +674,39 @@ var AgentHub = class extends EventEmitter {
     requestTtl = REQUEST_TTL,
     sequentialTtl = SEQUENTIAL_REQUEST_TTL,
     transcript = readTranscript,
+    transcriptSince = readTranscriptSince,
     startTimeout = START_TIMEOUT,
     present = async () => false,
-    rolloutTail = (file, onItem, onTurnEnd) => new RolloutTail(file, onItem, onTurnEnd)
+    rolloutTail = (file, onItem, onTurnEnd) => new RolloutTail(file, onItem, onTurnEnd),
+    // Keeps an image from a transcript where clients can fetch it: (bytes, type) => { id, type }.
+    keepImage = null,
+    // Where files sent from clients are kept, and the media type of one by its name: prompts
+    // show the files they name there as attachments instead of paths.
+    uploadsDir = null,
+    fileType = void 0
   } = {}) {
     super();
     this.#now = now;
     this.#requestTtl = requestTtl;
     this.#sequentialTtl = sequentialTtl;
     this.#transcript = transcript;
+    this.#transcriptSince = transcriptSince;
     this.#startTimeout = startTimeout;
     this.present = present;
     this.#rolloutTail = rolloutTail;
+    this.keepImage = keepImage;
+    this.uploadsDir = uploadsDir;
+    this.fileType = fileType;
     this.presenceSet = arguments[0]?.present !== void 0;
   }
   /**
    * A prompt a client typed into a session's terminal. Once Claude Code reports a matching
    * `UserPromptSubmit`, the socket gets `prompt_confirmed` with this id.
    */
-  prompted(sessionId, { id, text, paths = [] }) {
+  prompted(sessionId, { id, text, paths = [], images = [] }) {
     const s = this.#sessions.get(sessionId);
     if (!s) return;
-    s.prompts.push({ id, text: comparable(text, paths), at: this.#now() });
+    s.prompts.push({ id, text: comparable(text, paths), images, at: this.#now() });
     s.prompts = s.prompts.filter((p) => this.#now() - p.at < 6e4).slice(-20);
   }
   /**
@@ -466,6 +720,59 @@ var AgentHub = class extends EventEmitter {
     this.#endTurn(s, this.#now());
     this.#emitSession(s);
   }
+  /**
+   * Output of one of the agent's terminals. Shift+Tab reports no hook, so a Claude Code session's
+   * permission mode follows its footer.
+   */
+  terminalOutput(terminal, buf) {
+    const s = [...this.#sessions.values()].find((x) => x.terminal === terminal && x.agent === "claude" && x.state !== "ended");
+    if (!s) {
+      this.#footers.delete(terminal);
+      return;
+    }
+    const text = (this.#footers.get(terminal) ?? "") + buf.toString("utf8");
+    this.#footers.set(terminal, text.slice(-256));
+    const mode = footerMode(text);
+    if (!mode) return;
+    const waiters = this.#modeWaiters.get(s.id) ?? [];
+    const left = waiters.filter((w) => w.from === mode);
+    if (left.length) this.#modeWaiters.set(s.id, left);
+    else this.#modeWaiters.delete(s.id);
+    for (const w of waiters) if (w.from !== mode) w.done(mode);
+    if (mode !== s.permissionMode) {
+      s.permissionMode = mode;
+      this.#emitSession(s);
+    }
+  }
+  /**
+   * The mode the footer shows next that isn't `from` (a running session redraws its footer
+   * unchanged all the time), or null if none shows within `ms`.
+   */
+  waitForMode(sessionId, ms, from = this.#sessions.get(sessionId)?.permissionMode ?? null) {
+    return new Promise((resolve) => {
+      const waiter = {
+        from,
+        done: (mode) => {
+          clearTimeout(timer);
+          resolve(mode);
+        }
+      };
+      const timer = setTimeout(() => {
+        const left = (this.#modeWaiters.get(sessionId) ?? []).filter((w) => w !== waiter);
+        if (left.length) this.#modeWaiters.set(sessionId, left);
+        else this.#modeWaiters.delete(sessionId);
+        resolve(null);
+      }, ms);
+      this.#modeWaiters.set(sessionId, [...this.#modeWaiters.get(sessionId) ?? [], waiter]);
+    });
+  }
+  /** The model a client switched a session to with `/model`, until its transcript names it. */
+  modelChosen(sessionId, model) {
+    const s = this.#sessions.get(sessionId);
+    if (!s || !model || model === s.model) return;
+    s.model = model;
+    this.#emitSession(s);
+  }
   /** Whether `resume` may reopen a session: only one no process runs any more. */
   canResume(id) {
     const s = this.#sessions.get(id);
@@ -510,10 +817,10 @@ var AgentHub = class extends EventEmitter {
   session(id) {
     return this.#sessions.get(id)?.toJSON() ?? null;
   }
-  /** Where a session runs: one of the agent's terminals, or an app on the computer (or neither known). */
+  /** Where a session runs: `terminal` is one of the agent's terminals, null for one started outside Code Remote. */
   host(id) {
     const s = this.#sessions.get(id);
-    return s ? { terminal: s.terminal, app: s.app } : null;
+    return s ? { terminal: s.terminal } : null;
   }
   timeline(id, after = 0) {
     const s = this.#sessions.get(id);
@@ -521,12 +828,70 @@ var AgentHub = class extends EventEmitter {
     const entries2 = s.entries.filter((e) => e.seq > after);
     return { entries: entries2, next: s.seq, requests: [...s.requests.values()].map((r) => r.request) };
   }
+  /** Settles once a session's history (read from its transcript) is in. */
+  async ready(id) {
+    await this.#sessions.get(id)?.ready;
+  }
+  /**
+   * The sessions as `restore` takes them back after the agent restarts. Claude Code's transcript
+   * holds a session's whole timeline, so its entries are read again from there (with whatever
+   * happened while the agent was down); others keep their latest entries.
+   */
+  snapshot() {
+    return [...this.#sessions.values()].filter((s) => !s.starting).map((s) => ({
+      id: s.id,
+      agent: s.agent,
+      cwd: s.cwd,
+      title: s.title,
+      titled: s.titled,
+      state: s.state,
+      terminal: s.terminal,
+      startedAt: s.startedAt,
+      lastActivityAt: s.lastActivityAt,
+      endedAt: s.endedAt,
+      error: s.error,
+      cleared: s.cleared,
+      transcriptPath: s.transcriptPath ?? null,
+      permissionMode: s.permissionMode,
+      model: s.model,
+      seq: s.seq,
+      entries: s.agent === "claude" && s.transcriptPath ? [] : s.entries.slice(-SAVED_ENTRIES)
+    }));
+  }
+  /**
+   * Brings back the sessions of `snapshot`. Those that ran in the agent's terminals ended with
+   * them; others may still run, and their next hook event says how they are doing.
+   */
+  restore(saved) {
+    const now = this.#now();
+    for (const r of Array.isArray(saved) ? saved : []) {
+      if (!r || typeof r.id !== "string" || this.#sessions.has(r.id) || !Object.hasOwn(ADAPTERS, r.agent)) continue;
+      if (r.state === "ended" && !(r.endedAt >= now - ENDED_TTL)) continue;
+      const s = new AgentSession({ id: r.id, agent: r.agent, cwd: r.cwd ?? null, terminal: null, now: r.startedAt ?? now });
+      s.title = typeof r.title === "string" ? r.title : s.title;
+      s.titled = r.titled === true;
+      s.lastActivityAt = r.lastActivityAt ?? now;
+      s.error = r.error ?? null;
+      s.cleared = r.cleared === true;
+      s.permissionMode = modeOf(r.permissionMode);
+      s.model = typeof r.model === "string" ? r.model : null;
+      s.seq = Number.isInteger(r.seq) ? r.seq : 0;
+      if (r.state === "ended" || r.terminal) {
+        s.state = "ended";
+        s.endedAt = r.state === "ended" ? r.endedAt ?? now : now;
+      }
+      if (typeof r.transcriptPath === "string") s.transcriptPath = r.transcriptPath;
+      if (s.agent === "claude" && s.transcriptPath) s.ready = this.#backfill(s, s.transcriptPath);
+      else s.entries = Array.isArray(r.entries) ? r.entries.filter((e) => Number.isInteger(e?.seq) && e.seq <= s.seq) : [];
+      this.#sessions.set(s.id, s);
+    }
+  }
   /**
    * Takes one hook event. Resolves with the hook's output: for `PermissionRequest` once the
    * request is answered (null when the computer should decide), `{}` for everything else.
    * Aborting `signal` (the hook was killed because the computer answered) withdraws the request.
    */
-  async handle(raw, { agent = "claude", terminal = null, app = null, signal } = {}) {
+  async handle(raw, { agent = "claude", terminal = null, signal } = {}) {
     if (!raw || typeof raw.session_id !== "string" || !raw.session_id) {
       throw new HttpError(400, "hook event without session_id");
     }
@@ -536,8 +901,8 @@ var AgentHub = class extends EventEmitter {
     let replaced = null;
     if (!this.#sessions.has(event.session_id)) {
       const cleared = event.hook_event_name === "SessionStart" && event.source === "clear" && terminal;
-      const candidates = [...this.#sessions.values()].filter(
-        (p) => cleared ? p.terminal === terminal && p.agent === agent : p.starting && (terminal ? p.terminal === terminal : p.agent === agent && p.cwd === event.cwd)
+      const candidates = cleared ? [...this.#sessions.values()].filter((p) => p.terminal === terminal && p.agent === agent && (p.state !== "ended" || p.cleared)).sort((a, b) => b.lastActivityAt - a.lastActivityAt).slice(0, 1) : [...this.#sessions.values()].filter(
+        (p) => p.starting && (terminal ? p.terminal === terminal : p.agent === agent && p.cwd === event.cwd)
       );
       if (candidates.length === 1) {
         replaced = candidates[0];
@@ -550,9 +915,14 @@ var AgentHub = class extends EventEmitter {
       s = new AgentSession({ id: event.session_id, agent, cwd: event.cwd ?? null, terminal, now });
       this.#sessions.set(s.id, s);
       const fresh = event.hook_event_name === "SessionStart" && event.source !== "resume";
-      if (!fresh && typeof event.transcript_path === "string") s.ready = this.#backfill(s, event.transcript_path);
+      if (typeof event.transcript_path === "string") {
+        s.transcriptPath = event.transcript_path;
+        if (fresh) s.transcriptOffset = 0;
+        else s.ready = this.#backfill(s, event.transcript_path);
+      }
     }
     await s.ready;
+    if (["PreToolUse", "Stop", "StopFailure"].includes(event.hook_event_name)) await this.#catchUp(s);
     if (s.agent === "codex" && !s.tail && typeof event.transcript_path === "string") {
       s.tail = this.#rolloutTail(event.transcript_path, (item) => this.#fromRollout(s, item), (error) => this.#rolloutTurnEnd(s, error));
       s.tail.poll?.().catch(() => {
@@ -563,31 +933,38 @@ var AgentHub = class extends EventEmitter {
       this.emit("message", { type: "session_removed", session: replaced.id, replacedBy: s.id });
     }
     if (terminal && !s.terminal) s.terminal = terminal;
-    if (app) s.app = app;
     s.starting = false;
     s.lastActivityAt = now;
     if (s.state === "ended" && event.hook_event_name !== "SessionEnd") {
       s.state = "idle";
       s.endedAt = null;
+      s.cleared = false;
     }
+    s.permissionMode = modeOf(event.permission_mode) ?? s.permissionMode;
+    if (typeof event.model === "string" && event.model) s.model = event.model;
+    this.#withdrawAnsweredElsewhere(s, event);
     switch (event.hook_event_name) {
       case "SessionStart":
         if (s.state === "running" && s.turnStartedAt == null) s.state = "idle";
         break;
       case "UserPromptSubmit": {
-        const text = typeof event.prompt === "string" ? event.prompt : "";
-        if (!s.titled && text.trim()) {
+        const said = typeof event.prompt === "string" ? event.prompt : "";
+        const { text, files } = this.#withFiles(said);
+        if (!s.titled && text.trim() && !isNotice(text)) {
           s.title = titleOf(text);
           s.titled = true;
         }
         this.#startTurn(s, now);
-        this.#entry(s, { kind: "prompt", text });
-        const said = comparable(text);
-        const i = s.prompts.findIndex((p) => p.text === said || p.text && said.startsWith(p.text));
-        if (i >= 0) {
-          const [prompt] = s.prompts.splice(i, 1);
-          this.emit("message", { type: "prompt_confirmed", session: s.id, prompt: prompt.id });
-        }
+        const typed = comparable(said);
+        const i = s.prompts.findIndex((p) => p.text === typed || p.text && typed.startsWith(p.text));
+        const [prompt] = i >= 0 ? s.prompts.splice(i, 1) : [];
+        this.#entry(s, {
+          kind: "prompt",
+          text,
+          ...prompt?.images?.length ? { images: prompt.images } : {},
+          ...files.length ? { files } : {}
+        });
+        if (prompt) this.emit("message", { type: "prompt_confirmed", session: s.id, prompt: prompt.id });
         break;
       }
       case "PreToolUse":
@@ -653,6 +1030,7 @@ var AgentHub = class extends EventEmitter {
         }
         break;
       case "SessionEnd":
+        if (event.reason === "clear") s.cleared = true;
         this.#end(s);
         break;
       default:
@@ -661,8 +1039,27 @@ var AgentHub = class extends EventEmitter {
     this.#emitSession(s);
     return {};
   }
+  /**
+   * Claude Code kills a waiting PermissionRequest hook when its own dialog is answered, but not
+   * always when the answer comes from somewhere else (Claude's remote control on another device),
+   * so the request would stay open. The session going on proves it was answered: the asking tool
+   * ran (PostToolUse), or the turn moved on or ended.
+   */
+  #withdrawAnsweredElsewhere(s, event) {
+    if (!s.requests.size) return;
+    const name = event.hook_event_name;
+    let stale = [];
+    if (name === "PostToolUse" || name === "PostToolUseFailure") {
+      const oldest = [...s.requests.values()].find((p) => p.request.tool === (event.tool_name ?? null));
+      if (oldest) stale = [oldest];
+    } else if (["UserPromptSubmit", "Stop", "StopFailure", "Interrupt"].includes(name) || name === "Notification" && event.notification_type === "idle_prompt") {
+      stale = [...s.requests.values()];
+    }
+    for (const pending of stale) this.#resolve(pending, null, "withdrawn", "computer");
+  }
   /** The terminal a session ran in exited: whatever ran in it is over. */
   terminalExited(terminal) {
+    this.#footers.delete(terminal);
     for (const s of this.#sessions.values()) {
       if (s.terminal === terminal && s.state !== "ended") {
         if (s.starting) s.error = `${(ADAPTERS[s.agent] ?? ADAPTERS.claude).name} exited before it started. Open the terminal to see why.`;
@@ -734,7 +1131,7 @@ var AgentHub = class extends EventEmitter {
     const isQuestion = event.tool_name === "AskUserQuestion";
     const input = event.tool_input ?? {};
     const request = {
-      id: randomUUID(),
+      id: randomUUID2(),
       session: s.id,
       kind: isQuestion ? "question" : "permission",
       tool: event.tool_name ?? null,
@@ -788,14 +1185,68 @@ var AgentHub = class extends EventEmitter {
       } else if (e.kind === "tool_result") {
         e.name ??= tools.get(e.toolUseId) ?? null;
         ({ text: e.output, truncated: e.truncated } = clip(e.output));
-      } else if (e.kind === "prompt" && !s.titled && e.text.trim()) {
+      } else if (e.kind === "title") {
         s.title = titleOf(e.text);
         s.titled = true;
+        continue;
+      } else if (e.kind === "model") {
+        s.model = e.model;
+        continue;
+      } else if (e.kind === "prompt") {
+        const { text, files } = this.#withFiles(e.text);
+        e.text = text;
+        if (files.length) e.files = files;
+        if (!s.titled && e.text.trim() && !isNotice(e.text)) {
+          s.title = titleOf(e.text);
+          s.titled = true;
+        }
+        if (e.images) {
+          const kept = await Promise.all(
+            e.images.map((i) => Promise.resolve(this.keepImage?.(Buffer.from(i.data, "base64"), i.type)).catch(() => null))
+          );
+          e.images = kept.filter(Boolean);
+          if (!e.images.length) delete e.images;
+        }
       }
       s.entries.push({ seq: ++s.seq, ...e });
     }
+    if (s.agent === "claude" && Number.isInteger(entries2.end)) s.transcriptOffset = entries2.end;
     if (s.entries.length > MAX_ENTRIES) s.entries.splice(0, s.entries.length - MAX_ENTRIES);
   }
+  /**
+   * Claude Code's shown thinking, its title for the conversation and the model answering, from the part of the
+   * transcript written since the last look. Text, tools and prompts come from the hooks.
+   */
+  #catchUp(s) {
+    s.catchingUp = (s.catchingUp ?? Promise.resolve()).then(() => this.#readSince(s)).catch(() => {
+    });
+    return s.catchingUp;
+  }
+  async #readSince(s) {
+    if (s.agent !== "claude" || !s.transcriptPath || !Number.isInteger(s.transcriptOffset)) return;
+    const read = await this.#transcriptSince(s.transcriptPath, s.transcriptOffset);
+    if (!read) return;
+    s.transcriptOffset = read.end;
+    let changed = false;
+    for (const e of read.entries) {
+      if (e.kind === "model") {
+        if (e.model !== s.model) {
+          s.model = e.model;
+          changed = true;
+        }
+      } else if (e.kind === "title") {
+        const title = titleOf(e.text);
+        if (title !== s.title) {
+          s.title = title;
+          changed = true;
+        }
+        s.titled = true;
+      } else if (e.kind === "assistant" && e.thinking) {
+        this.#entry(s, { kind: "assistant", text: e.text, thinking: true });
+      }
+    }
+    if (changed) this.#emitSession(s);
+  }
   /** Something Codex said or a tool's result, from its rollout, unless the hooks told it already. */
   #endTurn(s, now, error = null) {
     s.streaming.clear();
@@ -856,14 +1307,18 @@ var AgentHub = class extends EventEmitter {
     if (s.entries.length > MAX_ENTRIES) s.entries.shift();
     this.emit("message", { type: "entry", session: s.id, entry: entry3 });
   }
+  /** A prompt's text without the paths of files a client attached, and those files. */
+  #withFiles(text) {
+    return attachedFiles(text, this.uploadsDir, this.fileType);
+  }
   #emitSession(s) {
     this.emit("message", { type: "session", session: s.toJSON() });
   }
 };
 
 // ../../packages/agent-core/src/commands.js
-import fs4 from "node:fs/promises";
-import path3 from "node:path";
+import fs5 from "node:fs/promises";
+import path4 from "node:path";
 var HEAD_BYTES = 4096;
 var MAX_DESCRIPTION = 300;
 var MAX_DEPTH = 3;
@@ -1005,7 +1460,7 @@ function frontmatter(text) {
 async function readHead(file) {
   let handle;
   try {
-    handle = await fs4.open(file, "r");
+    handle = await fs5.open(file, "r");
     const { buffer, bytesRead } = await handle.read(Buffer.alloc(HEAD_BYTES), 0, HEAD_BYTES, 0);
     return frontmatter(buffer.subarray(0, bytesRead).toString("utf8")) ?? {};
   } catch {
@@ -1016,14 +1471,14 @@ async function readHead(file) {
 }
 async function entries(dir) {
   try {
-    return await fs4.readdir(dir, { withFileTypes: true });
+    return await fs5.readdir(dir, { withFileTypes: true });
   } catch {
     return [];
   }
 }
 async function readJson(file) {
   try {
-    return JSON.parse(await fs4.readFile(file, "utf8"));
+    return JSON.parse(await fs5.readFile(file, "utf8"));
   } catch {
     return null;
   }
@@ -1042,7 +1497,7 @@ async function commandFiles(dir, prefix, source, depth = 0, parts = []) {
   const out = [];
   for (const e of await entries(dir)) {
     if (e.name.startsWith(".")) continue;
-    const file = path3.join(dir, e.name);
+    const file = path4.join(dir, e.name);
     if (e.isDirectory() && depth < MAX_DEPTH) {
       out.push(...await commandFiles(file, prefix, source, depth + 1, [...parts, e.name]));
     } else if (e.isFile() && e.name.endsWith(".md")) {
@@ -1056,9 +1511,9 @@ async function skillFiles(dir, { sigil = "/", prefix = "", source, kind = "comma
   const out = [];
   for (const e of await entries(dir)) {
     if (!e.isDirectory() || e.name.startsWith(".")) continue;
-    const file = path3.join(dir, e.name, "SKILL.md");
+    const file = path4.join(dir, e.name, "SKILL.md");
     try {
-      await fs4.access(file);
+      await fs5.access(file);
     } catch {
       continue;
     }
@@ -1070,45 +1525,45 @@ async function skillFiles(dir, { sigil = "/", prefix = "", source, kind = "comma
   return out;
 }
 async function claudePlugins(home, cwd) {
-  const installed = (await readJson(path3.join(home, ".claude", "plugins", "installed_plugins.json")))?.plugins ?? {};
+  const installed = (await readJson(path4.join(home, ".claude", "plugins", "installed_plugins.json")))?.plugins ?? {};
   const enabled = {};
   for (const file of [
-    path3.join(home, ".claude", "settings.json"),
-    path3.join(cwd, ".claude", "settings.json"),
-    path3.join(cwd, ".claude", "settings.local.json")
+    path4.join(home, ".claude", "settings.json"),
+    path4.join(cwd, ".claude", "settings.json"),
+    path4.join(cwd, ".claude", "settings.local.json")
   ]) {
     Object.assign(enabled, (await readJson(file))?.enabledPlugins ?? {});
   }
   const out = [];
   for (const [key, installs] of Object.entries(installed)) {
     if (enabled[key] !== true || !Array.isArray(installs)) continue;
-    const install = installs.find((i) => !i.projectPath || path3.resolve(i.projectPath) === path3.resolve(cwd));
+    const install = installs.find((i) => !i.projectPath || path4.resolve(i.projectPath) === path4.resolve(cwd));
     if (install?.installPath) out.push({ name: key.split("@")[0], root: install.installPath });
   }
   return out;
 }
 async function claudeCommands(home, cwd) {
-  const user = path3.join(home, ".claude");
-  const project = path3.join(cwd, ".claude");
+  const user = path4.join(home, ".claude");
+  const project = path4.join(cwd, ".claude");
   const found = [
-    ...await commandFiles(path3.join(user, "commands"), "", "user"),
-    ...await skillFiles(path3.join(user, "skills"), { source: "user" })
+    ...await commandFiles(path4.join(user, "commands"), "", "user"),
+    ...await skillFiles(path4.join(user, "skills"), { source: "user" })
   ];
-  for (const e of await entries(path3.join(user, "skills", "synced"))) {
+  for (const e of await entries(path4.join(user, "skills", "synced"))) {
     if (e.isDirectory() && !e.name.startsWith(".")) {
-      found.push(...await skillFiles(path3.join(user, "skills", "synced", e.name), { prefix: "anthropic-skills:", source: "user" }));
+      found.push(...await skillFiles(path4.join(user, "skills", "synced", e.name), { prefix: "anthropic-skills:", source: "user" }));
     }
   }
-  if (path3.resolve(project) !== path3.resolve(user)) {
+  if (path4.resolve(project) !== path4.resolve(user)) {
     found.push(
-      ...await commandFiles(path3.join(project, "commands"), "", "project"),
-      ...await skillFiles(path3.join(project, "skills"), { source: "project" })
+      ...await commandFiles(path4.join(project, "commands"), "", "project"),
+      ...await skillFiles(path4.join(project, "skills"), { source: "project" })
     );
   }
   for (const plugin of await claudePlugins(home, cwd)) {
     found.push(
-      ...await commandFiles(path3.join(plugin.root, "commands"), `${plugin.name}:`, "plugin"),
-      ...await skillFiles(path3.join(plugin.root, "skills"), { prefix: `${plugin.name}:`, source: "plugin" })
+      ...await commandFiles(path4.join(plugin.root, "commands"), `${plugin.name}:`, "plugin"),
+      ...await skillFiles(path4.join(plugin.root, "skills"), { prefix: `${plugin.name}:`, source: "plugin" })
     );
   }
   return found;
@@ -1117,7 +1572,7 @@ async function codexDisabled(codexHome) {
   const off = /* @__PURE__ */ new Set();
   let text = "";
   try {
-    text = await fs4.readFile(path3.join(codexHome, "config.toml"), "utf8");
+    text = await fs5.readFile(path4.join(codexHome, "config.toml"), "utf8");
   } catch {
   }
   let section = null;
@@ -1133,17 +1588,17 @@ async function latestVersion(dir) {
   let best = null;
   for (const e of await entries(dir)) {
     if (!e.isDirectory() || e.name.startsWith(".")) continue;
-    const { mtimeMs } = await fs4.stat(path3.join(dir, e.name));
-    if (!best || mtimeMs > best.mtimeMs) best = { dir: path3.join(dir, e.name), mtimeMs };
+    const { mtimeMs } = await fs5.stat(path4.join(dir, e.name));
+    if (!best || mtimeMs > best.mtimeMs) best = { dir: path4.join(dir, e.name), mtimeMs };
   }
   return best?.dir ?? null;
 }
 async function projectDirs(cwd, home) {
   const dirs = [];
-  for (let dir = path3.resolve(cwd); dir !== path3.resolve(home) && dir !== path3.dirname(dir); dir = path3.dirname(dir)) {
+  for (let dir = path4.resolve(cwd); dir !== path4.resolve(home) && dir !== path4.dirname(dir); dir = path4.dirname(dir)) {
     dirs.push(dir);
     try {
-      await fs4.access(path3.join(dir, ".git"));
+      await fs5.access(path4.join(dir, ".git"));
       break;
     } catch {
     }
@@ -1152,27 +1607,27 @@ async function projectDirs(cwd, home) {
 }
 async function codexMentions(home, codexHome, cwd) {
   const mention = { sigil: "$", kind: "mention" };
-  const skills = path3.join(codexHome, "skills");
+  const skills = path4.join(codexHome, "skills");
   const found = [
     ...await skillFiles(skills, { ...mention, source: "user" }),
-    ...await skillFiles(path3.join(skills, ".system"), { ...mention, source: "user" })
+    ...await skillFiles(path4.join(skills, ".system"), { ...mention, source: "user" })
   ];
   for (const dir of await projectDirs(cwd, home)) {
-    found.push(...await skillFiles(path3.join(dir, ".agents", "skills"), { ...mention, source: "project" }));
+    found.push(...await skillFiles(path4.join(dir, ".agents", "skills"), { ...mention, source: "project" }));
   }
   const off = await codexDisabled(codexHome);
-  const cache = path3.join(codexHome, "plugins", "cache");
+  const cache = path4.join(codexHome, "plugins", "cache");
   for (const market of await entries(cache)) {
     if (!market.isDirectory()) continue;
-    for (const plugin of await entries(path3.join(cache, market.name))) {
+    for (const plugin of await entries(path4.join(cache, market.name))) {
       if (!plugin.isDirectory() || off.has(`${plugin.name}@${market.name}`)) continue;
-      const root2 = await latestVersion(path3.join(cache, market.name, plugin.name));
-      if (root2) found.push(...await skillFiles(path3.join(root2, "skills"), { ...mention, prefix: `${plugin.name}:`, source: "plugin" }));
+      const root2 = await latestVersion(path4.join(cache, market.name, plugin.name));
+      if (root2) found.push(...await skillFiles(path4.join(root2, "skills"), { ...mention, prefix: `${plugin.name}:`, source: "plugin" }));
     }
   }
   return found;
 }
-async function listCommands({ agent, cwd, home, codexHome = path3.join(home, ".codex") }) {
+async function listCommands({ agent, cwd, home, codexHome = path4.join(home, ".codex") }) {
   const builtins = (BUILTINS[agent] ?? BUILTINS.claude).map(builtin);
   const found = agent === "codex" ? await codexMentions(home, codexHome, cwd) : await claudeCommands(home, cwd);
   const byName = new Map(builtins.map((c) => [c.name, c]));
@@ -1182,12 +1637,12 @@ async function listCommands({ agent, cwd, home, codexHome = path3.join(home, ".c
 }
 
 // ../../packages/agent-core/src/builds.js
-import { execFile, spawn } from "node:child_process";
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { execFile as execFile2, spawn } from "node:child_process";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import { EventEmitter as EventEmitter2 } from "node:events";
-import fs5 from "node:fs/promises";
-import os from "node:os";
-import path4 from "node:path";
+import fs6 from "node:fs/promises";
+import os2 from "node:os";
+import path5 from "node:path";
 var MAX_LINES = 5e3;
 var MAX_LINE = 2048;
 var MAX_ERRORS = 20;
@@ -1204,19 +1659,19 @@ var SIGNING_HINTS = [
 async function findContainer(folder) {
   let names;
   try {
-    names = await fs5.readdir(folder);
+    names = await fs6.readdir(folder);
   } catch {
     return null;
   }
   for (const [ext, kind] of [[".xcworkspace", "workspace"], [".xcodeproj", "project"]]) {
     const name = names.filter((n) => n.endsWith(ext)).sort()[0];
-    if (name) return { container: path4.join(folder, name), kind };
+    if (name) return { container: path5.join(folder, name), kind };
   }
   return null;
 }
-function run(command, args, { cwd, timeout = 12e4 } = {}) {
+function run2(command, args, { cwd, timeout = 12e4 } = {}) {
   return new Promise((resolve, reject) => {
-    execFile(command, args, { cwd, timeout, maxBuffer: 16 * 1024 * 1024 }, (error, stdout, stderr) => {
+    execFile2(command, args, { cwd, timeout, maxBuffer: 16 * 1024 * 1024 }, (error, stdout, stderr) => {
       if (error) reject(Object.assign(new HttpError(409, (stderr || error.message).trim().split("\n").slice(-3).join("\n")), { code: "EXCODE" }));
       else resolve(stdout);
     });
@@ -1225,9 +1680,9 @@ function run(command, args, { cwd, timeout = 12e4 } = {}) {
 async function listSchemes(folder, { xcodebuild = "xcodebuild" } = {}) {
   const found = await findContainer(folder);
   if (!found) throw new HttpError(404, "no Xcode project or workspace in this folder");
-  const out = JSON.parse(await run(xcodebuild, ["-list", "-json", `-${found.kind}`, found.container], { cwd: folder }));
+  const out = JSON.parse(await run2(xcodebuild, ["-list", "-json", `-${found.kind}`, found.container], { cwd: folder }));
   const schemes = out[found.kind]?.schemes ?? [];
-  return { container: path4.basename(found.container), kind: found.kind, schemes };
+  return { container: path5.basename(found.container), kind: found.kind, schemes };
 }
 function failureOf(lines) {
   const compile = [...new Set(lines.filter((l) => /^\S.*?:\d+:(?:\d+:)? error: /.test(l)))];
@@ -1251,11 +1706,11 @@ function exportOptions() {
 `;
 }
 async function readInfo(appPath) {
-  const info = JSON.parse(await run("plutil", ["-convert", "json", "-o", "-", path4.join(appPath, "Info.plist")]));
+  const info = JSON.parse(await run2("plutil", ["-convert", "json", "-o", "-", path5.join(appPath, "Info.plist")]));
   return {
     bundleId: info.CFBundleIdentifier,
     version: info.CFBundleShortVersionString ?? info.CFBundleVersion ?? "1.0",
-    name: info.CFBundleDisplayName ?? info.CFBundleName ?? path4.basename(appPath, ".app")
+    name: info.CFBundleDisplayName ?? info.CFBundleName ?? path5.basename(appPath, ".app")
   };
 }
 var BuildRunner = class extends EventEmitter2 {
@@ -1267,7 +1722,7 @@ var BuildRunner = class extends EventEmitter2 {
   #build = null;
   #lines = [];
   #child = null;
-  constructor({ xcodebuild = "xcodebuild", readInfo: info = readInfo, dir = path4.join(os.homedir(), ".coderemote", "builds"), now = Date.now, killAfter = KILL_AFTER } = {}) {
+  constructor({ xcodebuild = "xcodebuild", readInfo: info = readInfo, dir = path5.join(os2.homedir(), ".coderemote", "builds"), now = Date.now, killAfter = KILL_AFTER } = {}) {
     super();
     this.#xcodebuild = xcodebuild;
     this.#readInfo = info;
@@ -1296,10 +1751,10 @@ var BuildRunner = class extends EventEmitter2 {
     if (!/^[\w .-]+$/.test(configuration)) throw new HttpError(400, "invalid configuration");
     const found = await findContainer(folder);
     if (!found) throw new HttpError(404, "no Xcode project or workspace in this folder");
-    const id = randomUUID2();
-    const out = path4.join(this.#dir, id);
-    await fs5.rm(this.#dir, { recursive: true, force: true });
-    await fs5.mkdir(out, { recursive: true });
+    const id = randomUUID3();
+    const out = path5.join(this.#dir, id);
+    await fs6.rm(this.#dir, { recursive: true, force: true });
+    await fs6.mkdir(out, { recursive: true });
     this.#lines = [];
     this.#build = { id, path: folder, scheme, configuration, state: "running", step: "archiving", startedAt: this.#now(), endedAt: null, error: null, first: 0, artifact: null };
     const build = this.#build;
@@ -1329,8 +1784,8 @@ var BuildRunner = class extends EventEmitter2 {
     }
   }
   async #run(build, { container, kind }, out) {
-    const archive = path4.join(out, "App.xcarchive");
-    const exported = path4.join(out, "export");
+    const archive = path5.join(out, "App.xcarchive");
+    const exported = path5.join(out, "export");
     try {
       await this.#xcode(build, [
         `-${kind}`,
@@ -1348,8 +1803,8 @@ var BuildRunner = class extends EventEmitter2 {
         "archive"
       ], build.path);
       build.step = "exporting";
-      const options = path4.join(out, "ExportOptions.plist");
-      await fs5.writeFile(options, exportOptions());
+      const options = path5.join(out, "ExportOptions.plist");
+      await fs6.writeFile(options, exportOptions());
       await this.#xcode(build, [
         "-exportArchive",
         "-archivePath",
@@ -1360,14 +1815,14 @@ var BuildRunner = class extends EventEmitter2 {
         options,
         "-allowProvisioningUpdates"
       ], build.path);
-      const ipaName = (await fs5.readdir(exported)).find((n) => n.endsWith(".ipa"));
+      const ipaName = (await fs6.readdir(exported)).find((n) => n.endsWith(".ipa"));
       if (!ipaName) throw new Error("the export made no .ipa");
-      const apps = path4.join(archive, "Products", "Applications");
-      const appName = (await fs5.readdir(apps)).find((n) => n.endsWith(".app"));
+      const apps = path5.join(archive, "Products", "Applications");
+      const appName = (await fs6.readdir(apps)).find((n) => n.endsWith(".app"));
       if (!appName) throw new Error("the archive holds no app");
-      const ipa = path4.join(exported, ipaName);
-      const { size } = await fs5.stat(ipa);
-      build.artifact = { ipa, app: { ...await this.#readInfo(path4.join(apps, appName)), size } };
+      const ipa = path5.join(exported, ipaName);
+      const { size } = await fs6.stat(ipa);
+      build.artifact = { ipa, app: { ...await this.#readInfo(path5.join(apps, appName)), size } };
       build.state = "succeeded";
     } catch (e) {
       if (build.cancelled) {
@@ -1422,8 +1877,8 @@ var BuildRunner = class extends EventEmitter2 {
 };
 
 // ../../packages/agent-core/src/history.js
-import fs6 from "node:fs/promises";
-import path5 from "node:path";
+import fs7 from "node:fs/promises";
+import path6 from "node:path";
 var LIMIT = 50;
 var HEAD_BYTES2 = 128 * 1024;
 var TAIL_BYTES2 = 64 * 1024;
@@ -1431,7 +1886,7 @@ var MAX_TITLE2 = 80;
 async function slice(file, position, length) {
   let handle;
   try {
-    handle = await fs6.open(file, "r");
+    handle = await fs7.open(file, "r");
     const { size } = await handle.stat();
     const start2 = position < 0 ? Math.max(0, size + position) : position;
     const { buffer, bytesRead } = await handle.read(Buffer.alloc(Math.min(length, size)), 0, Math.min(length, size), start2);
@@ -1465,18 +1920,18 @@ function typedPrompt(record) {
   return t && !t.startsWith("<") && !t.startsWith("[Request interrupted") ? t : null;
 }
 async function claudeHistory(home, cwd) {
-  const dir = path5.join(home, ".claude", "projects", path5.resolve(cwd).replace(/[^a-zA-Z0-9]/g, "-"));
+  const dir = path6.join(home, ".claude", "projects", path6.resolve(cwd).replace(/[^a-zA-Z0-9]/g, "-"));
   let names = [];
   try {
-    names = (await fs6.readdir(dir)).filter((n) => n.endsWith(".jsonl"));
+    names = (await fs7.readdir(dir)).filter((n) => n.endsWith(".jsonl"));
   } catch {
     return [];
   }
   const files = [];
   for (const name of names) {
     try {
-      const { mtimeMs, size } = await fs6.stat(path5.join(dir, name));
-      files.push({ id: name.slice(0, -6), file: path5.join(dir, name), mtimeMs, size });
+      const { mtimeMs, size } = await fs7.stat(path6.join(dir, name));
+      files.push({ id: name.slice(0, -6), file: path6.join(dir, name), mtimeMs, size });
     } catch {
     }
   }
@@ -1502,7 +1957,7 @@ async function claudeHistory(home, cwd) {
 async function codexHistory(codexHome, cwd) {
   const names = /* @__PURE__ */ new Map();
   try {
-    for (const r of records(await fs6.readFile(path5.join(codexHome, "session_index.jsonl"), "utf8"))) {
+    for (const r of records(await fs7.readFile(path6.join(codexHome, "session_index.jsonl"), "utf8"))) {
       if (typeof r.id === "string" && typeof r.thread_name === "string") names.set(r.id, r.thread_name);
     }
   } catch {
@@ -1511,31 +1966,31 @@ async function codexHistory(codexHome, cwd) {
   const walk = async (dir, depth) => {
     let entries2 = [];
     try {
-      entries2 = await fs6.readdir(dir, { withFileTypes: true });
+      entries2 = await fs7.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries2) {
-      const p = path5.join(dir, e.name);
+      const p = path6.join(dir, e.name);
       if (e.isDirectory() && depth < 3) await walk(p, depth + 1);
       else if (e.isFile() && /^rollout-.*\.jsonl$/.test(e.name)) {
         try {
-          const { mtimeMs, size } = await fs6.stat(p);
+          const { mtimeMs, size } = await fs7.stat(p);
           files.push({ file: p, mtimeMs, size });
         } catch {
         }
       }
     }
   };
-  await walk(path5.join(codexHome, "sessions"), 0);
+  await walk(path6.join(codexHome, "sessions"), 0);
   files.sort((a, b) => b.mtimeMs - a.mtimeMs);
-  const want = path5.resolve(cwd);
+  const want = path6.resolve(cwd);
   const out = [];
   for (const f of files) {
     if (out.length >= LIMIT) break;
     const head = await slice(f.file, 0, HEAD_BYTES2);
     const meta = records(head.split("\n")[0])[0]?.payload;
-    if (!meta || typeof meta.id !== "string" || typeof meta.cwd !== "string" || path5.resolve(meta.cwd) !== want) continue;
+    if (!meta || typeof meta.id !== "string" || typeof meta.cwd !== "string" || path6.resolve(meta.cwd) !== want) continue;
     const prompt = records(head).filter((r) => r.type === "response_item" && r.payload?.type === "message" && r.payload.role === "user").flatMap((r) => Array.isArray(r.payload.content) ? r.payload.content : []).map((c) => c?.type === "input_text" && typeof c.text === "string" ? c.text.trim() : "").find((t) => t && !t.startsWith("<") && !t.startsWith("# AGENTS.md"));
     const title = names.get(meta.id) ?? prompt;
     if (!title) continue;
@@ -1549,16 +2004,16 @@ async function codexHistory(codexHome, cwd) {
   }
   return out;
 }
-async function listHistory({ agent, cwd, home, codexHome = path5.join(home, ".codex") }) {
+async function listHistory({ agent, cwd, home, codexHome = path6.join(home, ".codex") }) {
   return agent === "codex" ? codexHistory(codexHome, cwd) : claudeHistory(home, cwd);
 }
 
 // ../../packages/agent-core/src/install-links.js
 import { randomBytes } from "node:crypto";
 import { createReadStream } from "node:fs";
-import fs7 from "node:fs/promises";
+import fs8 from "node:fs/promises";
 import http from "node:http";
-import { pipeline } from "node:stream/promises";
+import { pipeline as pipeline2 } from "node:stream/promises";
 var TTL = 10 * 60 * 1e3;
 var SHARE_HOURS = 1;
 var xml = (s) => String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
@@ -1683,24 +2138,24 @@ var InstallLinks = class {
       res.end(req.method === "HEAD" ? void 0 : body);
       return;
     }
-    const { size } = await fs7.stat(link.ipa);
+    const { size } = await fs8.stat(link.ipa);
     res.writeHead(200, { "content-type": "application/octet-stream", "content-length": size, "cache-control": "no-store" });
     if (req.method === "HEAD") return res.end();
-    await pipeline(createReadStream(link.ipa), res);
+    await pipeline2(createReadStream(link.ipa), res);
     this.#expire(m[1]);
   }
 };
 
 // ../../packages/agent-core/src/git.js
-import { execFile as execFile2 } from "node:child_process";
-import fs8 from "node:fs/promises";
-import path6 from "node:path";
+import { execFile as execFile3 } from "node:child_process";
+import fs9 from "node:fs/promises";
+import path7 from "node:path";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".build", "build", "dist", "DerivedData", "Pods", "vendor", ".venv", "target"]);
 var MAX_SCAN_DEPTH = 4;
 var MAX_DIFF_BYTES = 2 * 1024 * 1024;
 function git(cwd, args, { timeout = 3e4, okCodes = [0], maxBuffer = 16 * 1024 * 1024 } = {}) {
   return new Promise((resolve, reject) => {
-    execFile2(
+    execFile3(
       "git",
       args,
       {
@@ -1723,21 +2178,21 @@ async function findRepos(root2) {
   async function walk(dir, depth) {
     let entries2;
     try {
-      entries2 = await fs8.readdir(dir, { withFileTypes: true });
+      entries2 = await fs9.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     if (entries2.some((e) => e.name === ".git")) repos.push(dir);
     if (depth >= MAX_SCAN_DEPTH) return;
     const subdirs = entries2.filter((e) => e.isDirectory() && !e.name.startsWith(".") && !SKIP_DIRS.has(e.name));
-    await Promise.all(subdirs.map((e) => walk(path6.join(dir, e.name), depth + 1)));
+    await Promise.all(subdirs.map((e) => walk(path7.join(dir, e.name), depth + 1)));
   }
   await walk(root2, 0);
-  repos.sort((a, b) => a.split(path6.sep).length - b.split(path6.sep).length || a.localeCompare(b));
+  repos.sort((a, b) => a.split(path7.sep).length - b.split(path7.sep).length || a.localeCompare(b));
   return Promise.all(
     repos.map(async (repo) => ({
       path: repo,
-      name: repo === root2 ? path6.basename(root2) : path6.relative(root2, repo),
+      name: repo === root2 ? path7.basename(root2) : path7.relative(root2, repo),
       branch: await currentBranch(repo),
       ...await summary(repo)
     }))
@@ -1847,27 +2302,335 @@ async function push(repo) {
   const { stdout, stderr } = await git(repo, ["push"], { timeout: 12e4 });
   return (stdout + stderr).trim();
 }
+async function fetch2(repo) {
+  const { stdout, stderr } = await git(repo, ["fetch", "--all", "--prune"], { timeout: 12e4 });
+  return (stdout + stderr).trim();
+}
+async function branchName(repo, name) {
+  if (typeof name !== "string" || !name.trim() || name.startsWith("-")) throw new HttpError(400, "invalid branch");
+  try {
+    await git(repo, ["check-ref-format", "--branch", name]);
+  } catch {
+    throw new HttpError(400, "invalid branch");
+  }
+  return name;
+}
+async function branches(repo) {
+  const { stdout } = await git(repo, [
+    "for-each-ref",
+    "--sort=-committerdate",
+    "--format=%(refname)%1f%(refname:short)%1f%(HEAD)%1f%(upstream:short)%1f%(committerdate:unix)%1f%(subject)",
+    "refs/heads",
+    "refs/remotes"
+  ]);
+  const all = stdout.split("\n").filter(Boolean).map((line) => {
+    const [ref, name, head, upstream, at, subject] = line.split("");
+    return {
+      name,
+      remote: ref.startsWith("refs/remotes/"),
+      current: head === "*",
+      upstream: upstream || null,
+      date: at ? parseInt(at, 10) * 1e3 : null,
+      subject: subject ?? "",
+      ref
+    };
+  }).filter((b) => !(b.remote && b.ref.endsWith("/HEAD")));
+  const tracked = new Set(all.filter((b) => !b.remote && b.upstream).map((b) => b.upstream));
+  return all.filter((b) => !b.remote || !tracked.has(b.name)).map(({ ref, ...b }) => b);
+}
+async function checkout(repo, branch, { create = false } = {}) {
+  const name = await branchName(repo, branch);
+  const has = async (ref) => (await git(repo, ["show-ref", "--verify", "-q", ref], { okCodes: [0, 1] })).code === 0;
+  if (create) {
+    await git(repo, ["switch", "-q", "-c", name]);
+  } else if (!await has(`refs/heads/${name}`) && name.includes("/") && await has(`refs/remotes/${name}`)) {
+    const local = name.slice(name.indexOf("/") + 1);
+    await git(repo, await has(`refs/heads/${local}`) ? ["switch", "-q", local] : ["switch", "-q", "-c", local, "--track", name]);
+  } else {
+    await git(repo, ["switch", "-q", name]);
+  }
+  return status(repo);
+}
+async function stashes(repo) {
+  const { stdout } = await git(repo, ["stash", "list", "-z", "--format=%gd%x1f%gs%x1f%ct"]);
+  return stdout.split("\0").filter(Boolean).map((record) => {
+    const [ref, message, at] = record.split("");
+    return { index: parseInt(ref.match(/\{(\d+)\}/)?.[1] ?? "0", 10), message, date: parseInt(at, 10) * 1e3 };
+  });
+}
+async function stash(repo, { message, untracked = true } = {}) {
+  if (message !== void 0 && message !== null && typeof message !== "string") throw new HttpError(400, "invalid message");
+  const { files } = await status(repo);
+  if (!files.length) throw new HttpError(409, "nothing to stash");
+  const args = ["stash", "push", "-q", ...untracked ? ["--include-untracked"] : []];
+  if (message?.trim()) args.push("-m", message.trim());
+  await git(repo, args);
+  return status(repo);
+}
+function stashRef(index) {
+  if (!Number.isInteger(index) || index < 0) throw new HttpError(400, "invalid stash");
+  return `stash@{${index}}`;
+}
+async function stashApply(repo, index, { pop = false } = {}) {
+  await git(repo, ["stash", pop ? "pop" : "apply", "-q", stashRef(index)]);
+  return status(repo);
+}
+async function stashDrop(repo, index) {
+  await git(repo, ["stash", "drop", "-q", stashRef(index)]);
+  return status(repo);
+}
 function truncate(text) {
   if (Buffer.byteLength(text) <= MAX_DIFF_BYTES) return { text, truncated: false };
   return { text: Buffer.from(text).subarray(0, MAX_DIFF_BYTES).toString("utf8"), truncated: true };
 }
 
-// ../../packages/agent-core/src/handoff.js
-import { createHmac, timingSafeEqual } from "node:crypto";
-var NONCE_WINDOW_MS = 5 * 6e4;
-var REUSE_MIN_LIFETIME_MS = 12 * 36e5;
-var TunnelHandoff = class {
-  /**
-   * @param {object} opts
-   * @param {string} opts.token  the agent's bearer token (the HMAC key)
-   * @param {() => Promise<{token: string, expiresAt: number} | null>} opts.mint
-   */
-  constructor({ token, mint, now = Date.now }) {
-    this.key = token;
-    this.mint = mint;
-    this.now = now;
-    this.used = /* @__PURE__ */ new Map();
-    this.cached = null;
+// ../../packages/agent-core/src/commit-message.js
+import { spawn as spawn3 } from "node:child_process";
+import fs11 from "node:fs/promises";
+import os3 from "node:os";
+import path9 from "node:path";
+
+// ../../packages/agent-core/src/platform.js
+import { execFile as execFile4, spawn as spawn2 } from "node:child_process";
+import fs10 from "node:fs";
+import path8 from "node:path";
+var isWindows = process.platform === "win32";
+function shellQuote(arg) {
+  return `'${String(arg).replace(/'/g, `'\\''`)}'`;
+}
+function runnable(file) {
+  try {
+    if (!isWindows) fs10.accessSync(file, fs10.constants.X_OK);
+    return fs10.statSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+function findExecutable(name, env = process.env) {
+  const exts = isWindows && !path8.extname(name) ? (env.PATHEXT || ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean) : [""];
+  const match = (base2) => exts.map((e) => base2 + e).find(runnable) ?? null;
+  if (name.includes("/") || name.includes(path8.sep)) return match(path8.resolve(name));
+  for (const dir of (env.PATH ?? env.Path ?? "").split(path8.delimiter)) {
+    const found = dir && match(path8.join(dir.replace(/^"(.*)"$/, "$1"), name));
+    if (found) return found;
+  }
+  return null;
+}
+function interactiveShell() {
+  if (!isWindows) return { file: process.env.SHELL || "/bin/sh", args: ["-l"] };
+  return { file: findExecutable("pwsh") ?? "powershell.exe", args: ["-NoLogo"] };
+}
+function cmdQuote(arg) {
+  const s = String(arg);
+  if (/["%\r\n]/.test(s)) throw new Error(`${JSON.stringify(s)} can't be passed through cmd.exe`);
+  return `"${s.replace(/(\\+)$/, "$1$1")}"`;
+}
+function resolveCommand(argv2) {
+  const [name, ...rest2] = argv2;
+  if (!isWindows) return { file: name, args: rest2, verbatim: false };
+  const file = findExecutable(name) ?? name;
+  if (!/\.(bat|cmd)$/i.test(file)) return { file, args: rest2, verbatim: false };
+  const line = [file, ...rest2].map(cmdQuote).join(" ");
+  return { file: process.env.ComSpec || "cmd.exe", args: ["/d", "/v:off", "/s", "/c", `"${line}"`], verbatim: true };
+}
+function terminalCommand(argv2) {
+  if (!isWindows) return { file: interactiveShell().file, args: ["-l", "-c", `exec ${argv2.map(shellQuote).join(" ")}`] };
+  const { file, args, verbatim } = resolveCommand(argv2);
+  return { file, args: verbatim ? args.join(" ") : args };
+}
+function spawnCommand(argv2, options = {}) {
+  const { file, args, verbatim } = resolveCommand(argv2);
+  return spawn2(file, args, { ...options, windowsVerbatimArguments: verbatim });
+}
+function execCommand(argv2, options = {}) {
+  return new Promise((resolve, reject) => {
+    const { file, args, verbatim } = resolveCommand(argv2);
+    execFile4(
+      file,
+      args,
+      { ...options, windowsVerbatimArguments: verbatim },
+      (err, stdout, stderr) => err ? reject(Object.assign(err, { stdout, stderr })) : resolve({ stdout, stderr })
+    );
+  });
+}
+function loginShell(script2, timeout) {
+  return new Promise((resolve) => {
+    execFile4(
+      interactiveShell().file,
+      ["-l", "-c", script2],
+      { timeout, maxBuffer: 16 * 1024 * 1024 },
+      (err, out) => resolve(err ? null : out)
+    );
+  });
+}
+async function capture(argv2, { timeout = 2e4 } = {}) {
+  if (!isWindows) return loginShell(argv2.map(shellQuote).join(" "), timeout);
+  try {
+    return (await execCommand(argv2, { timeout, maxBuffer: 16 * 1024 * 1024 })).stdout;
+  } catch {
+    return null;
+  }
+}
+async function commandExists(command) {
+  if (isWindows) return findExecutable(command) !== null;
+  return Boolean((await loginShell(`command -v ${shellQuote(command)}`, 2e4))?.trim());
+}
+
+// ../../packages/agent-core/src/commit-message.js
+var MAX_DIFF_CHARS = 24e3;
+var TIMEOUT_MS = 12e4;
+var EXCLUDE = [
+  "*.lock",
+  "package-lock.json",
+  "npm-shrinkwrap.json",
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  "Cargo.lock",
+  "Gemfile.lock",
+  "poetry.lock",
+  "composer.lock",
+  "go.sum",
+  "Package.resolved",
+  "*.min.js",
+  "*.min.css",
+  "*.map",
+  "*.snap",
+  "*.pbxproj"
+].map((p) => `:(exclude,glob)**/${p}`);
+async function pendingChanges(repo) {
+  const staged = (await git(repo, ["diff", "--cached", "--quiet"], { okCodes: [0, 1] })).code === 1;
+  const base2 = staged ? ["--cached"] : await hasHead(repo) ? ["HEAD"] : ["--cached"];
+  const [stat, patch, untracked] = await Promise.all([
+    git(repo, ["diff", "--no-color", "--stat=120", ...base2]).then((r) => r.stdout),
+    git(repo, ["diff", "--no-color", "--no-ext-diff", ...base2, "--", ".", ...EXCLUDE]).then((r) => r.stdout),
+    staged ? "" : git(repo, ["ls-files", "--others", "--exclude-standard"]).then((r) => r.stdout)
+  ]);
+  if (!stat.trim() && !untracked.trim()) throw new HttpError(409, "nothing to commit");
+  const diff2 = patch.length > MAX_DIFF_CHARS ? `${patch.slice(0, MAX_DIFF_CHARS)}
+[diff truncated]
+` : patch;
+  return { staged, stat, diff: diff2, untracked: untracked.split("\n").filter(Boolean) };
+}
+async function hasHead(repo) {
+  return (await git(repo, ["rev-parse", "--verify", "-q", "HEAD"], { okCodes: [0, 1, 128] })).code === 0;
+}
+function buildPrompt({ stat, diff: diff2, untracked }, recentSubjects) {
+  return [
+    "Write a git commit message for the changes below.",
+    "Match the style of this repository's recent commits (language, tense, prefixes, capitalisation).",
+    "First line: a summary of at most 72 characters.",
+    'Then a blank line and a body of 1 to 4 short lines saying what changed and why, as "- " bullets',
+    "when there is more than one point. Do not list file names or restate the diff line by line.",
+    "Reply with the commit message only: no preamble, no quotes, no code fences.",
+    "",
+    "Recent commits:",
+    ...recentSubjects.length ? recentSubjects.map((s) => `- ${s}`) : ["(none yet)"],
+    "",
+    "Files changed:",
+    stat.trim(),
+    ...untracked.length ? ["", "New files:", ...untracked.slice(0, 100)] : [],
+    "",
+    "Diff:",
+    diff2.trim()
+  ].join("\n");
+}
+function cleanMessage(text) {
+  let s = String(text).replace(/\r\n/g, "\n").trim();
+  s = s.replace(/^```[\w-]*\n([\s\S]*?)\n```$/, "$1").trim();
+  s = s.replace(/^(?:commit message|message)\s*:\s*\n?/i, "").trim();
+  if (/^(["'`]).*\1$/s.test(s)) s = s.slice(1, -1).trim();
+  return s;
+}
+var SYSTEM_PROMPT = "You write git commit messages. Reply with the commit message only: no preamble, no quotes, no code fences.";
+function draftCommand(agent, { claudeCommand = "claude", codexCommand = "codex", outFile, model = null } = {}) {
+  if (agent === "claude") {
+    const quoted = isWindows ? [] : ["--settings", '{"disableAllHooks":true}', "--system-prompt", SYSTEM_PROMPT];
+    return [claudeCommand, "-p", "--model", model || "haiku", "--tools", "", "--no-session-persistence", "--strict-mcp-config", ...quoted];
+  }
+  return [
+    codexCommand,
+    "exec",
+    "--ephemeral",
+    "--skip-git-repo-check",
+    "-s",
+    "read-only",
+    ...model ? ["-m", model] : [],
+    "-c",
+    'model_reasoning_effort="low"',
+    "-c",
+    "mcp_servers={}",
+    "-o",
+    outFile,
+    "-"
+  ];
+}
+function runWithInput(argv2, { cwd, input, timeout = TIMEOUT_MS, env = {} }) {
+  return new Promise((resolve, reject) => {
+    const options = { cwd, env: { ...process.env, CODEREMOTE_NO_HOOK: "1", ...env }, stdio: ["pipe", "pipe", "pipe"] };
+    let child;
+    if (isWindows) child = spawnCommand(argv2, options);
+    else {
+      const { file, args } = terminalCommand(argv2);
+      child = spawn3(file, args, options);
+    }
+    let out = "";
+    let err = "";
+    const timer = setTimeout(() => child.kill(), timeout);
+    child.stdout.on("data", (d) => out += d);
+    child.stderr.on("data", (d) => err += d);
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
+    child.on("close", (code, signal) => {
+      clearTimeout(timer);
+      if (code === 0) return resolve(out);
+      const why = signal ? "timed out" : (err || out).trim().split("\n").slice(-3).join("\n") || `exited with ${code}`;
+      reject(new HttpError(signal ? 504 : 502, why));
+    });
+    child.stdin.on("error", () => {
+    });
+    child.stdin.end(input);
+  });
+}
+async function draftCommitMessage(repo, agent, { claudeCommand, codexCommand, model = null, run: run7 = runWithInput } = {}) {
+  const changes = await pendingChanges(repo);
+  const recent = await hasHead(repo) ? (await git(repo, ["log", "-n12", "--no-merges", "--format=%s"])).stdout.split("\n").filter(Boolean) : [];
+  const input = buildPrompt(changes, recent);
+  let text;
+  if (agent === "codex") {
+    const dir = await fs11.mkdtemp(path9.join(os3.tmpdir(), "coderemote-commit-"));
+    const outFile = path9.join(dir, "message.txt");
+    try {
+      await run7(draftCommand("codex", { codexCommand, outFile, model }), { cwd: repo, input });
+      text = await fs11.readFile(outFile, "utf8");
+    } finally {
+      await fs11.rm(dir, { recursive: true, force: true });
+    }
+  } else {
+    text = await run7(draftCommand("claude", { claudeCommand, model }), { cwd: os3.tmpdir(), input });
+  }
+  const message = cleanMessage(text);
+  if (!message) throw new HttpError(502, "the agent returned no message");
+  return { message, agent, staged: changes.staged };
+}
+
+// ../../packages/agent-core/src/handoff.js
+import { createHmac, timingSafeEqual } from "node:crypto";
+var NONCE_WINDOW_MS = 5 * 6e4;
+var REUSE_MIN_LIFETIME_MS = 12 * 36e5;
+var TunnelHandoff = class {
+  /**
+   * @param {object} opts
+   * @param {string} opts.token  the agent's bearer token (the HMAC key)
+   * @param {() => Promise<{token: string, expiresAt: number} | null>} opts.mint
+   */
+  constructor({ token, mint, now = Date.now }) {
+    this.key = token;
+    this.mint = mint;
+    this.now = now;
+    this.used = /* @__PURE__ */ new Map();
+    this.cached = null;
   }
   /** `nonce` is `<unix seconds>.<random>`; each one works once, within five minutes. */
   verify(nonce, sig) {
@@ -1948,102 +2711,150 @@ var LANDING_HTML = `<!doctype html>
 </html>
 `;
 
-// ../../packages/agent-core/src/ports.js
-import { execFile as execFile4 } from "node:child_process";
-import fs10 from "node:fs/promises";
-import net from "node:net";
-import os2 from "node:os";
+// ../../packages/agent-core/src/lan.js
+import { X509Certificate } from "node:crypto";
+import fs12 from "node:fs";
+import os4 from "node:os";
+import path10 from "node:path";
 
-// ../../packages/agent-core/src/platform.js
-import { execFile as execFile3, spawn as spawn2 } from "node:child_process";
-import fs9 from "node:fs";
-import path7 from "node:path";
-var isWindows = process.platform === "win32";
-function shellQuote(arg) {
-  return `'${String(arg).replace(/'/g, `'\\''`)}'`;
+// ../../packages/agent-core/src/x509.js
+import { generateKeyPairSync, randomBytes as randomBytes2, sign } from "node:crypto";
+function tlv(tag, ...parts) {
+  const body = Buffer.concat(parts);
+  const n = body.length;
+  let len;
+  if (n < 128) len = Buffer.from([n]);
+  else {
+    const bytes2 = [];
+    for (let v = n; v > 0; v >>= 8) bytes2.unshift(v & 255);
+    len = Buffer.from([128 | bytes2.length, ...bytes2]);
+  }
+  return Buffer.concat([Buffer.from([tag]), len, body]);
+}
+var seq = (...parts) => tlv(48, ...parts);
+var set = (...parts) => tlv(49, ...parts);
+function oid(dotted) {
+  const [a, b, ...rest2] = dotted.split(".").map(Number);
+  const out = [40 * a + b];
+  for (const n of rest2) {
+    const chunk = [n & 127];
+    for (let v = n >> 7; v > 0; v >>= 7) chunk.unshift(128 | v & 127);
+    out.push(...chunk);
+  }
+  return tlv(6, Buffer.from(out));
+}
+function utcTime(date) {
+  const s = date.toISOString();
+  return tlv(23, Buffer.from(`${s.slice(2, 4)}${s.slice(5, 7)}${s.slice(8, 10)}${s.slice(11, 13)}${s.slice(14, 16)}${s.slice(17, 19)}Z`));
+}
+var ECDSA_SHA256 = seq(oid("1.2.840.10045.4.3.2"));
+function extension(id, critical, value) {
+  return seq(oid(id), ...critical ? [tlv(1, Buffer.from([255]))] : [], tlv(4, value));
+}
+var pem = (label, der) => `-----BEGIN ${label}-----
+${der.toString("base64").match(/.{1,64}/g).join("\n")}
+-----END ${label}-----
+`;
+function selfSignedCertificate({ commonName = "coderemote", days = 3650, now = /* @__PURE__ */ new Date() } = {}) {
+  const { privateKey, publicKey } = generateKeyPairSync("ec", { namedCurve: "prime256v1" });
+  const serial = randomBytes2(16);
+  serial[0] = serial[0] & 127 | 64;
+  const name = seq(set(seq(oid("2.5.4.3"), tlv(12, Buffer.from(commonName, "utf8")))));
+  const day = 24 * 60 * 60 * 1e3;
+  const tbs = seq(
+    tlv(160, tlv(2, Buffer.from([2]))),
+    // v3
+    tlv(2, serial),
+    ECDSA_SHA256,
+    name,
+    seq(utcTime(new Date(now.getTime() - day)), utcTime(new Date(now.getTime() + days * day))),
+    name,
+    publicKey.export({ type: "spki", format: "der" }),
+    tlv(
+      163,
+      seq(
+        extension("2.5.29.19", true, seq()),
+        // basicConstraints: not a CA
+        extension("2.5.29.15", true, tlv(3, Buffer.from([7, 128]))),
+        // keyUsage: digitalSignature
+        extension("2.5.29.37", false, seq(oid("1.3.6.1.5.5.7.3.1")))
+        // extKeyUsage: serverAuth
+      )
+    )
+  );
+  const signature = sign("sha256", tbs, privateKey);
+  const cert = seq(tbs, ECDSA_SHA256, tlv(3, Buffer.from([0]), signature));
+  return {
+    key: privateKey.export({ type: "pkcs8", format: "pem" }),
+    cert: pem("CERTIFICATE", cert)
+  };
 }
-function runnable(file) {
+
+// ../../packages/agent-core/src/lan.js
+function certFingerprint(pem2) {
+  return new X509Certificate(pem2).fingerprint256.replace(/:/g, "").toLowerCase();
+}
+async function lanCertificate(dir) {
+  const keyFile = path10.join(dir, "key.pem");
+  const certFile = path10.join(dir, "cert.pem");
+  const load = () => {
+    const key = fs12.readFileSync(keyFile, "utf8");
+    const cert = fs12.readFileSync(certFile, "utf8");
+    return { key, cert, fingerprint: certFingerprint(cert) };
+  };
   try {
-    if (!isWindows) fs9.accessSync(file, fs9.constants.X_OK);
-    return fs9.statSync(file).isFile();
+    return load();
   } catch {
-    return false;
   }
-}
-function findExecutable(name, env = process.env) {
-  const exts = isWindows && !path7.extname(name) ? (env.PATHEXT || ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean) : [""];
-  const match = (base2) => exts.map((e) => base2 + e).find(runnable) ?? null;
-  if (name.includes("/") || name.includes(path7.sep)) return match(path7.resolve(name));
-  for (const dir of (env.PATH ?? env.Path ?? "").split(path7.delimiter)) {
-    const found = dir && match(path7.join(dir.replace(/^"(.*)"$/, "$1"), name));
-    if (found) return found;
+  try {
+    const { key, cert } = selfSignedCertificate();
+    fs12.mkdirSync(dir, { recursive: true, mode: 448 });
+    fs12.writeFileSync(keyFile, key, { mode: 384 });
+    fs12.chmodSync(keyFile, 384);
+    fs12.writeFileSync(certFile, cert);
+    return load();
+  } catch (e) {
+    for (const f of [keyFile, certFile]) {
+      try {
+        fs12.rmSync(f, { force: true });
+      } catch {
+      }
+    }
+    return { error: `could not create a certificate: ${e.message}` };
   }
-  return null;
 }
-function interactiveShell() {
-  if (!isWindows) return { file: process.env.SHELL || "/bin/sh", args: ["-l"] };
-  return { file: findExecutable("pwsh") ?? "powershell.exe", args: ["-NoLogo"] };
+var VIRTUAL = /^(utun|ipsec|ppp|bridge|docker|br-|veth|vboxnet|vmnet|vEthernet|awdl|llw|anpi|ap\d|gif|stf|tailscale|zt|wg|VirtualBox|VMware|ZeroTier|Hyper-V|Bluetooth|Local Area Connection\*)/i;
+function privateV4(address) {
+  const [a, b] = address.split(".").map(Number);
+  return a === 10 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168;
 }
-function cmdQuote(arg) {
-  const s = String(arg);
-  if (/["%\r\n]/.test(s)) throw new Error(`${JSON.stringify(s)} can't be passed through cmd.exe`);
-  return `"${s.replace(/(\\+)$/, "$1$1")}"`;
-}
-function resolveCommand(argv2) {
-  const [name, ...rest2] = argv2;
-  if (!isWindows) return { file: name, args: rest2, verbatim: false };
-  const file = findExecutable(name) ?? name;
-  if (!/\.(bat|cmd)$/i.test(file)) return { file, args: rest2, verbatim: false };
-  const line = [file, ...rest2].map(cmdQuote).join(" ");
-  return { file: process.env.ComSpec || "cmd.exe", args: ["/d", "/v:off", "/s", "/c", `"${line}"`], verbatim: true };
-}
-function terminalCommand(argv2) {
-  if (!isWindows) return { file: interactiveShell().file, args: ["-l", "-c", `exec ${argv2.map(shellQuote).join(" ")}`] };
-  const { file, args, verbatim } = resolveCommand(argv2);
-  return { file, args: verbatim ? args.join(" ") : args };
-}
-function spawnCommand(argv2, options = {}) {
-  const { file, args, verbatim } = resolveCommand(argv2);
-  return spawn2(file, args, { ...options, windowsVerbatimArguments: verbatim });
-}
-function execCommand(argv2, options = {}) {
-  return new Promise((resolve, reject) => {
-    const { file, args, verbatim } = resolveCommand(argv2);
-    execFile3(
-      file,
-      args,
-      { ...options, windowsVerbatimArguments: verbatim },
-      (err, stdout, stderr) => err ? reject(Object.assign(err, { stdout, stderr })) : resolve({ stdout, stderr })
-    );
-  });
-}
-function loginShell(script, timeout) {
-  return new Promise((resolve) => {
-    execFile3(
-      interactiveShell().file,
-      ["-l", "-c", script],
-      { timeout, maxBuffer: 16 * 1024 * 1024 },
-      (err, out) => resolve(err ? null : out)
-    );
-  });
-}
-async function capture(argv2, { timeout = 2e4 } = {}) {
-  if (!isWindows) return loginShell(argv2.map(shellQuote).join(" "), timeout);
-  try {
-    return (await execCommand(argv2, { timeout, maxBuffer: 16 * 1024 * 1024 })).stdout;
-  } catch {
-    return null;
+function lanAddresses(interfaces = os4.networkInterfaces()) {
+  const v4 = [];
+  const v6 = [];
+  for (const [name, addrs] of Object.entries(interfaces)) {
+    if (VIRTUAL.test(name)) continue;
+    for (const a of addrs ?? []) {
+      if (a.internal) continue;
+      const family = a.family === 4 ? "IPv4" : a.family === 6 ? "IPv6" : a.family;
+      if (family === "IPv4" && !a.address.startsWith("169.254.")) v4.push(a.address);
+      if (family === "IPv6" && !/^fe[89ab]/i.test(a.address)) v6.push(a.address);
+    }
   }
+  return [.../* @__PURE__ */ new Set([...v4.filter(privateV4), ...v4.filter((a) => !privateV4(a)), ...v6])];
 }
-async function commandExists(command) {
-  if (isWindows) return findExecutable(command) !== null;
-  return Boolean((await loginShell(`command -v ${shellQuote(command)}`, 2e4))?.trim());
+function qrAddresses(addresses) {
+  const firstV6 = addresses.find((a) => a.includes(":"));
+  return addresses.filter((a) => !a.includes(":") || a === firstV6).slice(0, 3);
 }
 
 // ../../packages/agent-core/src/ports.js
-function run2(cmd2, args) {
+import { execFile as execFile5 } from "node:child_process";
+import fs13 from "node:fs/promises";
+import net from "node:net";
+import os5 from "node:os";
+function run3(cmd2, args) {
   return new Promise((resolve, reject) => {
-    execFile4(cmd2, args, { maxBuffer: 8 * 1024 * 1024 }, (err, stdout) => {
+    execFile5(cmd2, args, { maxBuffer: 8 * 1024 * 1024 }, (err, stdout) => {
       if (err?.code === "ENOENT") reject(err);
       else resolve(stdout || "");
     });
@@ -2057,7 +2868,7 @@ function splitHostPort(name) {
 }
 async function listeningSockets() {
   try {
-    const out2 = await run2("lsof", ["-nP", "-a", "-u", String(os2.userInfo().uid), "-iTCP", "-sTCP:LISTEN", "-F", "pcn"]);
+    const out2 = await run3("lsof", ["-nP", "-a", "-u", String(os5.userInfo().uid), "-iTCP", "-sTCP:LISTEN", "-F", "pcn"]);
     const sockets2 = [];
     let pid;
     let name;
@@ -2072,9 +2883,9 @@ async function listeningSockets() {
     }
     return sockets2;
   } catch (e) {
-    if (e.code !== "ENOENT" || os2.platform() !== "linux") throw e;
+    if (e.code !== "ENOENT" || os5.platform() !== "linux") throw e;
   }
-  const out = await run2("ss", ["-Hltnp"]);
+  const out = await run3("ss", ["-Hltnp"]);
   const sockets = [];
   for (const line of out.split("\n")) {
     const cols = line.trim().split(/\s+/);
@@ -2085,7 +2896,7 @@ async function listeningSockets() {
   return sockets;
 }
 async function processTable() {
-  const out = await run2("ps", ["-A", "-ww", "-o", "pid=,ppid=,tty=,command="]);
+  const out = await run3("ps", ["-A", "-ww", "-o", "pid=,ppid=,tty=,command="]);
   const table = /* @__PURE__ */ new Map();
   for (const line of out.split("\n")) {
     const m = line.match(/^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.*)$/);
@@ -2096,11 +2907,11 @@ async function processTable() {
 async function workingDirs(pids) {
   const dirs = /* @__PURE__ */ new Map();
   if (!pids.length || isWindows) return dirs;
-  if (os2.platform() === "linux") {
-    await Promise.all(pids.map(async (pid2) => dirs.set(pid2, await fs10.readlink(`/proc/${pid2}/cwd`).catch(() => null))));
+  if (os5.platform() === "linux") {
+    await Promise.all(pids.map(async (pid2) => dirs.set(pid2, await fs13.readlink(`/proc/${pid2}/cwd`).catch(() => null))));
     return dirs;
   }
-  const out = await run2("lsof", ["-a", "-p", pids.join(","), "-d", "cwd", "-F", "pn"]).catch(() => "");
+  const out = await run3("lsof", ["-a", "-p", pids.join(","), "-d", "cwd", "-F", "pn"]).catch(() => "");
   let pid;
   for (const line of out.split("\n")) {
     if (line[0] === "p") pid = parseInt(line.slice(1), 10);
@@ -2112,9 +2923,9 @@ var WINDOWS_SHELLS = /* @__PURE__ */ new Set(["cmd.exe", "powershell.exe", "pwsh
 async function windowsListeners() {
   const query = "Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,Name,CommandLine | ConvertTo-Json -Compress";
   const [v4, v6, json] = await Promise.all([
-    run2("netstat", ["-ano", "-p", "TCP"]),
-    run2("netstat", ["-ano", "-p", "TCPv6"]),
-    run2("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", query])
+    run3("netstat", ["-ano", "-p", "TCP"]),
+    run3("netstat", ["-ano", "-p", "TCPv6"]),
+    run3("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", query])
   ]);
   const table = /* @__PURE__ */ new Map();
   for (const p of [JSON.parse(json || "[]")].flat()) {
@@ -2201,18 +3012,18 @@ function isListening(port2, timeout = 2e3) {
 }
 
 // ../../packages/agent-core/src/push.js
-import { execFile as execFile5 } from "node:child_process";
-import { createCipheriv, randomBytes as randomBytes2 } from "node:crypto";
-import os3 from "node:os";
-import { promisify } from "node:util";
-var run3 = promisify(execFile5);
-var FINISHED_AFTER = 60 * 1e3;
+import { execFile as execFile6 } from "node:child_process";
+import { createCipheriv, randomBytes as randomBytes3 } from "node:crypto";
+import os6 from "node:os";
+import { promisify as promisify2 } from "node:util";
+var run4 = promisify2(execFile6);
+var FINISHED_AFTER = 30 * 1e3;
+var REPLY_CHARS = 180;
 var ACTIVE_WITHIN = 2 * 60;
-var AT_SESSION_WITHIN = 30;
 async function macIdleSeconds() {
-  if (os3.platform() !== "darwin") return null;
+  if (os6.platform() !== "darwin") return null;
   try {
-    const { stdout } = await run3("ioreg", ["-c", "IOHIDSystem", "-d", "4", "-k", "HIDIdleTime"], { timeout: 2e3 });
+    const { stdout } = await run4("ioreg", ["-c", "IOHIDSystem", "-d", "4", "-k", "HIDIdleTime"], { timeout: 2e3 });
     const ns = stdout.match(/"HIDIdleTime"\s*=\s*(\d+)/)?.[1];
     return ns ? Number(BigInt(ns) / 1000000000n) : null;
   } catch {
@@ -2223,25 +3034,8 @@ async function userActiveHere() {
   const idle = await macIdleSeconds();
   return idle !== null && idle < ACTIVE_WITHIN;
 }
-async function frontAppHere() {
-  if (os3.platform() !== "darwin") return null;
-  try {
-    const { stdout: asn } = await run3("lsappinfo", ["front"], { timeout: 2e3 });
-    if (!asn.trim()) return null;
-    const { stdout } = await run3("lsappinfo", ["info", asn.trim()], { timeout: 2e3 });
-    return stdout.match(/bundle path="([^"]+)"/)?.[1] ?? null;
-  } catch {
-    return null;
-  }
-}
-async function atSessionHere(session, { idle = macIdleSeconds, front = frontAppHere } = {}) {
-  if (!session || session.terminal) return false;
-  const seconds = await idle();
-  if (seconds === null || seconds >= AT_SESSION_WITHIN) return false;
-  return !session.app || await front() === session.app;
-}
 function seal(key, data) {
-  const nonce = randomBytes2(12);
+  const nonce = randomBytes3(12);
   const cipher = createCipheriv("aes-256-gcm", key, nonce);
   const body = Buffer.concat([cipher.update(JSON.stringify(data), "utf8"), cipher.final()]);
   return Buffer.concat([nonce, body, cipher.getAuthTag()]).toString("base64");
@@ -2284,15 +3078,26 @@ function describeRequest(request) {
   return detail2 ? `${request.tool}: ${String(detail2).split("\n")[0].slice(0, 200)}` : `Allow ${request.tool}?`;
 }
 function minutes(ms) {
+  if (ms < 6e4) return `${Math.round(ms / 1e3)} s`;
   const m = Math.round(ms / 6e4);
   return m < 60 ? `${m} min` : `${Math.floor(m / 60)} h ${m % 60} min`;
 }
+function lastReply(entries2) {
+  for (let i = entries2.length - 1; i >= 0; i--) {
+    const e = entries2[i];
+    if (e.kind === "prompt" || e.kind === "turn_end" && i < entries2.length - 1) return null;
+    if (e.kind !== "assistant" || !e.text?.trim()) continue;
+    const text = e.text.replace(/```[\s\S]*?(```|$)/g, " ").replace(/!?\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/^\s{0,3}(#{1,6}\s+|>\s?|[-*+]\s+|\d+\.\s+)/gm, "").replace(/[*_`~|]/g, "").replace(/\s+/g, " ").trim();
+    if (!text) continue;
+    return text.length > REPLY_CHARS ? `${text.slice(0, REPLY_CHARS - 1).trimEnd()}\u2026` : text;
+  }
+  return null;
+}
 var PushSender = class {
   #devices;
   #store;
   #hub;
   #shows;
-  #atSession;
   #fetch;
   // Requests a notification went out for, so their resolution can replace it.
   #notified = /* @__PURE__ */ new Set();
@@ -2302,16 +3107,13 @@ var PushSender = class {
    * @param {{ load: () => object[], save: (devices: object[]) => void }} [opts.store]
    * @param {(what: { session?: string, builds?: boolean }) => boolean} [opts.shows]  whether a
    *        client shows that session (or the builds) right now
-   * @param {(host: { terminal: string | null, app: string | null } | null) => Promise<boolean>} [opts.atSession]
-   *        whether someone at the computer is working in the session running there
    */
-  constructor({ hub, store = null, shows = () => false, atSession = atSessionHere, fetch: fetch2 = globalThis.fetch }) {
+  constructor({ hub, store = null, shows = () => false, fetch: fetch3 = globalThis.fetch }) {
     this.#hub = hub;
     this.#store = store;
     this.#devices = store?.load() ?? [];
     this.#shows = shows;
-    this.#atSession = atSession;
-    this.#fetch = fetch2;
+    this.#fetch = fetch3;
     hub.on("message", (msg) => this.#follow(msg).catch(() => {
     }));
   }
@@ -2343,21 +3145,22 @@ var PushSender = class {
   #save() {
     this.#store?.save(this.#devices);
   }
-  /** No push about a session someone is looking at, on a client or at the computer. */
-  async #quiet(what) {
+  /**
+   * No push about a session a client shows, nor about one started outside Code Remote: that one
+   * runs in a terminal of the computer's own, so it is followed there (or wherever else it is
+   * driven from, like Claude's own remote control), not from the phone.
+   */
+  #quiet(what) {
     if (this.#shows(what)) return true;
     if (!what.session) return false;
-    try {
-      return await this.#atSession(this.#hub.host(what.session));
-    } catch {
-      return false;
-    }
+    const host = this.#hub.host(what.session);
+    return !host || !host.terminal;
   }
   async #follow(msg) {
     if (!this.#devices.length) return;
     if (msg.type === "request") {
       const { request } = msg;
-      if (await this.#quiet({ session: request.session })) return;
+      if (this.#quiet({ session: request.session })) return;
       if (!this.#hub.requests().some((r) => r.id === request.id)) return;
       this.#notified.add(request.id);
       const question = request.kind === "question";
@@ -2389,12 +3192,19 @@ var PushSender = class {
         fallback: "Answered on your computer"
       });
     } else if (msg.type === "entry" && msg.entry.kind === "turn_end" && msg.entry.duration >= FINISHED_AFTER) {
-      if (await this.#quiet({ session: msg.session })) return;
+      if (this.#quiet({ session: msg.session })) return;
       const session = this.#hub.session(msg.session);
+      let reply = null;
+      try {
+        reply = lastReply(this.#hub.timeline(msg.session).entries);
+      } catch {
+      }
+      const took = `Finished after ${minutes(msg.entry.duration)}`;
       await this.#broadcast("finished", {
         kind: "finished",
         title: session?.title ?? "Claude Code",
-        body: `Finished after ${minutes(msg.entry.duration)}`,
+        body: reply ? `${reply}
+${took}` : took,
         session: msg.session,
         category: "DONE",
         fallback: "A session finished"
@@ -2404,7 +3214,7 @@ var PushSender = class {
   /** A build ended (see builds.js): ready to install, or failed. Cancelled builds say nothing. */
   async buildEnded(build) {
     if (!this.#devices.length || build.state === "cancelled") return;
-    if (await this.#quiet({ builds: true })) return;
+    if (this.#quiet({ builds: true })) return;
     const ok = build.state === "succeeded";
     const firstError = String(build.error ?? "").split("\n").find((l) => l.trim()) ?? "";
     await this.#broadcast("finished", {
@@ -2635,9 +3445,9 @@ function detail(e) {
 }
 
 // ../../packages/agent-core/src/search.js
-import { execFile as execFile6, spawn as spawn3 } from "node:child_process";
-import fs11 from "node:fs/promises";
-import path8 from "node:path";
+import { execFile as execFile7, spawn as spawn4 } from "node:child_process";
+import fs14 from "node:fs/promises";
+import path11 from "node:path";
 import readline from "node:readline";
 var ALWAYS_SKIPPED = /* @__PURE__ */ new Set([".git", "node_modules"]);
 var MAX_FILE_BYTES = 2 * 1024 * 1024;
@@ -2649,7 +3459,7 @@ var NAME_LIMIT = 100;
 var DEFAULT_LIMIT = 500;
 var MAX_LIMIT = 2e3;
 var PER_FILE = 100;
-var TIMEOUT_MS = 15e3;
+var TIMEOUT_MS2 = 15e3;
 var rgPath;
 function ripgrep() {
   if (rgPath === void 0) rgPath = findExecutable("rg");
@@ -2742,7 +3552,7 @@ function preview(line, re) {
 }
 function runGit(cwd, args) {
   return new Promise((resolve) => {
-    execFile6(
+    execFile7(
       "git",
       args,
       { cwd, maxBuffer: 256 * 1024 * 1024, env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" } },
@@ -2752,7 +3562,7 @@ function runGit(cwd, args) {
 }
 async function exists(p) {
   try {
-    await fs11.lstat(p);
+    await fs14.lstat(p);
     return true;
   } catch {
     return false;
@@ -2786,21 +3596,21 @@ async function listFiles(root2, signal) {
       if (rel.endsWith("/")) subdirs.push(rel.slice(0, -1));
       else files.push(join(prefix, rel));
     }
-    for (const rel of subdirs) await visit(path8.join(dir, rel), join(prefix, rel));
+    for (const rel of subdirs) await visit(path11.join(dir, rel), join(prefix, rel));
     return true;
   }
   async function visit(dir, prefix) {
     if (signal?.aborted) return;
-    if (await exists(path8.join(dir, ".git")) && await fromGit(dir, prefix)) return;
+    if (await exists(path11.join(dir, ".git")) && await fromGit(dir, prefix)) return;
     let entries2;
     try {
-      entries2 = await fs11.readdir(dir, { withFileTypes: true });
+      entries2 = await fs14.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries2) {
       if (ALWAYS_SKIPPED.has(e.name)) continue;
-      if (e.isDirectory()) await visit(path8.join(dir, e.name), join(prefix, e.name));
+      if (e.isDirectory()) await visit(path11.join(dir, e.name), join(prefix, e.name));
       else if (e.isFile()) files.push(join(prefix, e.name));
     }
   }
@@ -2837,17 +3647,17 @@ var Results = class {
   }
 };
 async function searchFile(root2, rel, test, re, results) {
-  const abs = path8.join(root2, ...rel.split("/"));
+  const abs = path11.join(root2, ...rel.split("/"));
   let stat;
   try {
-    stat = await fs11.lstat(abs);
+    stat = await fs14.lstat(abs);
   } catch {
     return;
   }
   if (!stat.isFile() || stat.size > MAX_FILE_BYTES || stat.size === 0) return;
   let buf;
   try {
-    buf = await fs11.readFile(abs);
+    buf = await fs14.readFile(abs);
   } catch {
     return;
   }
@@ -2871,7 +3681,7 @@ async function searchHere(root2, files, test, re, results, signal) {
 }
 function runRipgrep(rg, root2, args, onLine, signal) {
   return new Promise((resolve, reject) => {
-    const child = spawn3(rg, ["--no-config", "--no-messages", "--hidden", "--glob", "!.git", "--glob", "!node_modules", ...args], {
+    const child = spawn4(rg, ["--no-config", "--no-messages", "--hidden", "--glob", "!.git", "--glob", "!node_modules", ...args], {
       cwd: root2,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -2918,7 +3728,7 @@ async function search({
   const rg = engine === "node" ? null : ripgrep();
   if (engine === "rg" && !rg) throw new HttpError(500, "ripgrep is not installed");
   const timeout = new AbortController();
-  const timer = setTimeout(() => timeout.abort(), TIMEOUT_MS);
+  const timer = setTimeout(() => timeout.abort(), TIMEOUT_MS2);
   const stop = signal ? AbortSignal.any([signal, timeout.signal]) : timeout.signal;
   const results = new Results(limit);
   const names = [];
@@ -2988,9 +3798,9 @@ async function search({
 }
 
 // ../../packages/agent-core/src/sessions.js
-import { execFile as execFile7 } from "node:child_process";
-import { randomUUID as randomUUID3 } from "node:crypto";
-import os4 from "node:os";
+import { execFile as execFile8 } from "node:child_process";
+import { randomUUID as randomUUID4 } from "node:crypto";
+import os7 from "node:os";
 import pty from "node-pty";
 var SCROLLBACK_LIMIT = 256 * 1024;
 function guardConpty(term) {
@@ -3009,7 +3819,7 @@ var TerminalSession = class {
    * terminalCommand says; the session ends when it exits.
    */
   constructor({ cols, rows, cwd, env = {}, command = null }) {
-    this.id = randomUUID3();
+    this.id = randomUUID4();
     this.createdAt = Date.now();
     this.chunks = [];
     this.bufferedBytes = 0;
@@ -3022,7 +3832,7 @@ var TerminalSession = class {
       name: "xterm-256color",
       cols,
       rows,
-      cwd: cwd || os4.homedir(),
+      cwd: cwd || os7.homedir(),
       // CODEREMOTE_TERM_ID lets `coderemote hook` tell which terminal a coding agent runs in.
       env: { ...process.env, ...env, CODEREMOTE_TERM_ID: this.id, TERM: "xterm-256color", COLORTERM: "truecolor" }
     });
@@ -3045,199 +3855,102 @@ var TerminalSession = class {
       this.bufferedBytes -= this.chunks.shift().length;
     }
     for (const ws of this.clients) ws.send(buf, { binary: true });
+    this.onOutput?.(buf);
   }
-  attach(ws) {
-    this.clients.add(ws);
-    const replay = Buffer.concat(this.chunks);
-    ws.send(JSON.stringify({ type: "session", id: this.id, shell: this.shell, replay: replay.length }));
-    if (replay.length) ws.send(replay, { binary: true });
-    ws.on("message", (data, isBinary) => {
-      if (isBinary) {
-        this.write(data.toString("utf8"));
-        return;
-      }
-      let msg;
-      try {
-        msg = JSON.parse(data.toString("utf8"));
-      } catch {
-        return;
-      }
-      if (msg.type === "input" && typeof msg.data === "string") this.write(msg.data);
-      else if (msg.type === "resize") this.resize(msg.cols, msg.rows);
-    });
-    ws.on("close", () => this.clients.delete(ws));
-  }
-  resize(cols, rows) {
-    if (this.exitCode === null && Number.isInteger(cols) && Number.isInteger(rows) && cols > 0 && rows > 0) {
-      this.pty.resize(cols, rows);
-    }
-  }
-  /** Ends the session; on Windows, which has no signals, always forcibly (see releaseConpty). */
-  kill(signal) {
-    if (!isWindows) this.pty.kill(signal);
-    else if (this.exitCode === null) execFile7("taskkill", ["/T", "/F", "/PID", String(this.pty.pid)], () => {
-    });
-  }
-  /** Types into the session, as a client's keyboard would; nothing once it has exited. */
-  write(data) {
-    if (this.exitCode === null) this.pty.write(data);
-  }
-  toJSON() {
-    return {
-      id: this.id,
-      shell: this.shell,
-      pid: this.pty.pid,
-      title: this.pty.process,
-      createdAt: this.createdAt,
-      attached: this.clients.size
-    };
-  }
-};
-var SessionManager = class {
-  #sessions = /* @__PURE__ */ new Map();
-  /** @param {{ onExit?: (id: string) => void }} [opts] */
-  constructor({ onExit } = {}) {
-    this.onExit = onExit;
-  }
-  create(opts) {
-    const session = new TerminalSession(opts);
-    session.onExit = () => {
-      this.#sessions.delete(session.id);
-      this.onExit?.(session.id);
-    };
-    this.#sessions.set(session.id, session);
-    return session;
-  }
-  get(id) {
-    return this.#sessions.get(id);
-  }
-  list() {
-    return [...this.#sessions.values()].map((s) => s.toJSON());
-  }
-  /**
-   * Ends every session; resolves once they have all exited, or after `timeout` ms. Wait for it
-   * before exiting: on Windows terminals end asynchronously (see releaseConpty), and exiting
-   * while node-pty still holds a console open can crash the process.
-   */
-  killAll(timeout = 3e3) {
-    const exited = [...this.#sessions.values()].map((s) => {
-      const done = new Promise((resolve) => s.pty.onExit(resolve));
-      s.kill();
-      return done;
-    });
-    let timer;
-    const late = new Promise((resolve) => {
-      timer = setTimeout(resolve, timeout);
-    });
-    return Promise.race([Promise.all(exited), late]).finally(() => clearTimeout(timer));
-  }
-};
-
-// ../../packages/agent-core/src/uploads.js
-import { execFile as execFile8 } from "node:child_process";
-import { randomUUID as randomUUID4 } from "node:crypto";
-import { createWriteStream } from "node:fs";
-import fs12 from "node:fs/promises";
-import os5 from "node:os";
-import path9 from "node:path";
-import { Transform } from "node:stream";
-import { pipeline as pipeline2 } from "node:stream/promises";
-import { promisify as promisify2 } from "node:util";
-var run4 = promisify2(execFile8);
-var UPLOAD_LIMIT = 100 * 1024 * 1024;
-var KEEP = 7 * 24 * 60 * 60 * 1e3;
-var ID = /^[0-9a-f-]{36}$/;
-function safeName(name) {
-  const base2 = path9.basename(String(name ?? "").replace(/\\/g, "/"));
-  const clean = base2.replace(/[^\p{L}\p{N}._ -]/gu, "_").replace(/^[.\s]+/, "").slice(-80).trim();
-  return clean || "file";
-}
-var UploadStore = class {
-  constructor(dir, { now = Date.now } = {}) {
-    this.dir = dir;
-    this.now = now;
-  }
-  /** Streams `body` to disk. 413 past `limit`; HEIC photos become JPEG on macOS. */
-  async save(body, { name, type, length, limit = UPLOAD_LIMIT }) {
-    if (Number(length) > limit) throw new HttpError(413, `files are limited to ${limit / 1024 / 1024} MB`);
-    const id = randomUUID4();
-    const day = new Date(this.now()).toISOString().slice(0, 10);
-    await fs12.mkdir(path9.join(this.dir, day), { recursive: true, mode: 448 });
-    let file = path9.join(this.dir, day, `${id}-${safeName(name)}`);
-    let size = 0;
-    const counter = new Transform({
-      transform(chunk, _enc, done) {
-        size += chunk.length;
-        done(size > limit ? new HttpError(413, `files are limited to ${limit / 1024 / 1024} MB`) : null, chunk);
-      }
-    });
-    try {
-      await pipeline2(body, counter, createWriteStream(file, { mode: 384 }));
-    } catch (e) {
-      await fs12.rm(file, { force: true });
-      throw e;
-    }
-    let kind = type || "application/octet-stream";
-    if ((kind === "image/heic" || /\.heic$/i.test(file)) && os5.platform() === "darwin") {
-      const jpeg = file.replace(/(\.heic)?$/i, ".jpg");
-      try {
-        await run4("sips", ["-s", "format", "jpeg", file, "--out", jpeg], { timeout: 3e4 });
-        await fs12.rm(file);
-        file = jpeg;
-        kind = "image/jpeg";
-        size = (await fs12.stat(file)).size;
-      } catch {
-      }
-    }
-    return { id, name: path9.basename(file).slice(id.length + 1), type: kind, size, path: file };
-  }
-  /** The file of an upload; 404 once it's gone (swept, or never existed). */
-  async path(id) {
-    if (typeof id !== "string" || !ID.test(id)) throw new HttpError(400, "invalid upload id");
-    let days = [];
-    try {
-      days = (await fs12.readdir(this.dir)).sort().reverse();
-    } catch {
-    }
-    for (const day of days) {
-      let names = [];
-      try {
-        names = await fs12.readdir(path9.join(this.dir, day));
-      } catch {
-      }
-      const hit = names.find((n) => n.startsWith(`${id}-`));
-      if (hit) return path9.join(this.dir, day, hit);
-    }
-    throw new HttpError(404, "no such upload (they are kept for 7 days)");
-  }
-  /** Deletes uploads older than a week. */
-  async sweep() {
-    let days = [];
-    try {
-      days = await fs12.readdir(this.dir);
-    } catch {
-      return;
-    }
-    const cutoff = this.now() - KEEP;
-    for (const day of days) {
-      const dir = path9.join(this.dir, day);
-      let names = [];
+  attach(ws) {
+    this.clients.add(ws);
+    const replay = Buffer.concat(this.chunks);
+    ws.send(JSON.stringify({ type: "session", id: this.id, shell: this.shell, replay: replay.length }));
+    if (replay.length) ws.send(replay, { binary: true });
+    ws.on("message", (data, isBinary) => {
+      if (isBinary) {
+        this.write(data.toString("utf8"));
+        return;
+      }
+      let msg;
       try {
-        names = await fs12.readdir(dir);
+        msg = JSON.parse(data.toString("utf8"));
       } catch {
-        continue;
-      }
-      for (const n of names) {
-        const file = path9.join(dir, n);
-        const stat = await fs12.stat(file).catch(() => null);
-        if (stat && stat.mtimeMs < cutoff) await fs12.rm(file, { force: true });
+        return;
       }
-      if (!(await fs12.readdir(dir).catch(() => [])).length) await fs12.rm(dir, { recursive: true, force: true });
+      if (msg.type === "input" && typeof msg.data === "string") this.write(msg.data);
+      else if (msg.type === "resize") this.resize(msg.cols, msg.rows);
+    });
+    ws.on("close", () => this.clients.delete(ws));
+  }
+  resize(cols, rows) {
+    if (this.exitCode === null && Number.isInteger(cols) && Number.isInteger(rows) && cols > 0 && rows > 0) {
+      this.pty.resize(cols, rows);
     }
   }
+  /** Ends the session; on Windows, which has no signals, always forcibly (see releaseConpty). */
+  kill(signal) {
+    if (!isWindows) this.pty.kill(signal);
+    else if (this.exitCode === null) execFile8("taskkill", ["/T", "/F", "/PID", String(this.pty.pid)], () => {
+    });
+  }
+  /** Types into the session, as a client's keyboard would; nothing once it has exited. */
+  write(data) {
+    if (this.exitCode === null) this.pty.write(data);
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      shell: this.shell,
+      pid: this.pty.pid,
+      title: this.pty.process,
+      createdAt: this.createdAt,
+      attached: this.clients.size
+    };
+  }
+};
+var SessionManager = class {
+  #sessions = /* @__PURE__ */ new Map();
+  /** @param {{ onExit?: (id: string) => void, onOutput?: (id: string, buf: Buffer) => void }} [opts] */
+  constructor({ onExit, onOutput } = {}) {
+    this.onExit = onExit;
+    this.onOutput = onOutput;
+  }
+  create(opts) {
+    const session = new TerminalSession(opts);
+    session.onExit = () => {
+      this.#sessions.delete(session.id);
+      this.onExit?.(session.id);
+    };
+    session.onOutput = (buf) => this.onOutput?.(session.id, buf);
+    this.#sessions.set(session.id, session);
+    return session;
+  }
+  get(id) {
+    return this.#sessions.get(id);
+  }
+  list() {
+    return [...this.#sessions.values()].map((s) => s.toJSON());
+  }
+  /**
+   * Ends every session; resolves once they have all exited, or after `timeout` ms. Wait for it
+   * before exiting: on Windows terminals end asynchronously (see releaseConpty), and exiting
+   * while node-pty still holds a console open can crash the process.
+   */
+  killAll(timeout = 3e3) {
+    const exited = [...this.#sessions.values()].map((s) => {
+      const done = new Promise((resolve) => s.pty.onExit(resolve));
+      s.kill();
+      return done;
+    });
+    let timer;
+    const late = new Promise((resolve) => {
+      timer = setTimeout(resolve, timeout);
+    });
+    return Promise.race([Promise.all(exited), late]).finally(() => clearTimeout(timer));
+  }
 };
 
 // ../../packages/agent-core/src/server.js
+var OVER_LAN = Symbol("overLan");
+function tunnelOnly(method, pathname) {
+  return pathname === TUNNEL_HANDOFF_PATH || pathname === "/api/tunnel" || pathname.startsWith("/api/tunnel/") || pathname === "/api/preview" || pathname.startsWith("/api/preview/") || `${method} ${pathname}` === Routes.buildsInstall || `${method} ${pathname}` === Routes.agentsHook;
+}
 function kindOf(stat) {
   if (stat.isDirectory()) return "dir";
   if (stat.isFile()) return "file";
@@ -3245,11 +3958,11 @@ function kindOf(stat) {
   return "other";
 }
 async function describe(fullPath, name) {
-  const lst = await fs13.lstat(fullPath);
+  const lst = await fs15.lstat(fullPath);
   const entry3 = { name, type: kindOf(lst), size: lst.size, mtime: lst.mtimeMs };
   if (lst.isSymbolicLink()) {
     try {
-      entry3.target = kindOf(await fs13.stat(fullPath));
+      entry3.target = kindOf(await fs15.stat(fullPath));
     } catch {
       entry3.target = "broken";
     }
@@ -3291,6 +4004,15 @@ function typeable(text) {
   return text.replace(/\r\n?/g, "\n").replace(/[\x00-\x08\x0b-\x1f\x7f]/g, "");
 }
 var LAUNCH_MODES = ["manual", "acceptEdits", "plan", "auto"];
+var MODE_TIMEOUT = 2e3;
+var MODE_NAMES = {
+  manual: "Manual mode",
+  acceptEdits: "Accept edits",
+  plan: "Plan mode",
+  auto: "Auto mode",
+  bypassPermissions: "Bypass permissions",
+  dontAsk: "Don't ask"
+};
 function sendJson(res, status2, body) {
   const json = JSON.stringify(body);
   res.writeHead(status2, { "content-type": "application/json", "content-length": Buffer.byteLength(json) });
@@ -3317,24 +4039,52 @@ function createAgentServer({
   uploadsDir = null,
   claudeCommand = "claude",
   codexCommand = "codex",
-  codexHome = process.env.CODEX_HOME || path10.join(os6.homedir(), ".codex"),
-  home = os6.homedir(),
+  codexHome = process.env.CODEX_HOME || path12.join(os8.homedir(), ".codex"),
+  home = os8.homedir(),
   xcodebuild = "xcodebuild",
   builds = new BuildRunner({ xcodebuild }),
   pluginInstalled = null,
   agents = new AgentHub(),
   pushStore: pushStore2 = null,
+  sessionStore: sessionStore2 = null,
   pushOptions = {},
   previewSweep = {},
-  version = null
+  version = null,
+  lan = null,
+  lanAddresses: lanAddresses2 = lanAddresses,
+  agentId = null,
+  tunnelUrl = () => null
 }) {
   const handoff = new TunnelHandoff({ token, mint: tunnelToken });
   const sandbox = new Sandbox(root2);
-  const sessions = new SessionManager({ onExit: (id) => agents.terminalExited(id) });
+  const sessions = new SessionManager({
+    onExit: (id) => agents.terminalExited(id),
+    onOutput: (id, buf) => agents.terminalOutput(id, buf)
+  });
   const expected = Buffer.from(`Bearer ${token}`);
   const uploads = uploadsDir ? new UploadStore(uploadsDir) : null;
+  if (uploads && !agents.keepImage) agents.keepImage = (bytes2, type) => uploads.keep(bytes2, type);
+  agents.uploadsDir ??= uploadsDir;
+  agents.fileType ??= (name) => imageType(name) ?? MEDIA_TYPES[path12.extname(name).toLowerCase()] ?? "application/octet-stream";
+  let saveTimer = null;
+  const saveSessions = () => {
+    clearTimeout(saveTimer);
+    saveTimer = null;
+    try {
+      sessionStore2?.save(agents.snapshot());
+    } catch {
+    }
+  };
+  if (sessionStore2) {
+    agents.restore(sessionStore2.load());
+    agents.on("message", () => {
+      saveTimer ??= setTimeout(saveSessions, 1e3);
+      saveTimer.unref?.();
+    });
+  }
   const sweep = setInterval(() => {
     agents.sweep();
+    if (sessionStore2) saveSessions();
     uploads?.sweep().catch(() => {
     });
   }, 10 * 60 * 1e3);
@@ -3367,6 +4117,17 @@ function createAgentServer({
     if (!whileWaiting && session.state === "waiting") throw new HttpError(409, "answer the pending request first");
     return { session, term };
   }
+  async function setMode(id, mode) {
+    if (!PERMISSION_MODES.includes(mode)) throw new HttpError(400, `mode must be one of ${PERMISSION_MODES.join(", ")}`);
+    const { term } = typingTarget(id, { whileWaiting: false });
+    for (let i = 0; i <= PERMISSION_MODES.length; i++) {
+      if (agents.session(id)?.permissionMode === mode) return agents.session(id);
+      const shown = agents.waitForMode(id, MODE_TIMEOUT);
+      term.write(KEYS.cycle_mode);
+      if (!await shown) break;
+    }
+    throw new HttpError(409, `${MODE_NAMES[mode]} isn't available in this session`);
+  }
   async function typeInto(term, text) {
     term.write(`${PASTE_START}${text}${PASTE_END}`);
     await new Promise((r) => setTimeout(r, 300));
@@ -3436,7 +4197,7 @@ function createAgentServer({
   }
   async function codexModels() {
     try {
-      const { models } = JSON.parse(await fs13.readFile(path10.join(codexHome, "models_cache.json"), "utf8"));
+      const { models } = JSON.parse(await fs15.readFile(path12.join(codexHome, "models_cache.json"), "utf8"));
       return models.filter((m) => m.visibility === "list" && typeof m.slug === "string").sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0)).map((m) => ({ id: m.slug, name: m.display_name || m.slug, description: m.description ?? "" }));
     } catch {
       return [];
@@ -3522,20 +4283,20 @@ function createAgentServer({
   async function repoOf(p) {
     const repo = await sandbox.resolve(p);
     try {
-      await fs13.access(path10.join(repo, ".git"));
+      await fs15.access(path12.join(repo, ".git"));
     } catch {
       throw new HttpError(400, "not a git repository");
     }
     return repo;
   }
   async function filesIn(repo, files) {
-    if (!Array.isArray(files) || !files.length || files.some((f) => typeof f !== "string" || !f || path10.isAbsolute(f))) {
+    if (!Array.isArray(files) || !files.length || files.some((f) => typeof f !== "string" || !f || path12.isAbsolute(f))) {
       throw new HttpError(400, "files must be a non-empty list of paths relative to the repository");
     }
     return Promise.all(
       files.map(async (f) => {
-        const abs = await sandbox.resolve(path10.join(repo, f), { allowMissing: true });
-        const rel = path10.relative(repo, abs);
+        const abs = await sandbox.resolve(path12.join(repo, f), { allowMissing: true });
+        const rel = path12.relative(repo, abs);
         if (!rel || rel.startsWith("..")) throw new HttpError(403, "path is outside the repository");
         return rel;
       })
@@ -3543,31 +4304,35 @@ function createAgentServer({
   }
   const routes = {
     [Routes.info]: async () => ({
+      ...lanInfo(),
       protocol: PROTOCOL_VERSION,
       minClientProtocol: MIN_CLIENT_PROTOCOL,
       version,
-      hostname: os6.hostname(),
-      platform: os6.platform(),
+      hostname: os8.hostname(),
+      platform: os8.platform(),
       root: sandbox.root,
-      user: os6.userInfo().username,
+      user: os8.userInfo().username,
       // On Windows, terminals run PowerShell whatever $SHELL (Git Bash sets one) says.
-      shell: isWindows ? interactiveShell().file : process.env.SHELL || null
+      shell: isWindows ? interactiveShell().file : process.env.SHELL || null,
+      agentId,
+      // Null until the tunnel is hosted (an agent started offline connects it later).
+      tunnel: tunnelUrl() ? { url: tunnelUrl() } : null
     }),
     [Routes.fsList]: async (url) => {
       const dir = await sandbox.resolve(url.searchParams.get("path"));
-      const names = await fs13.readdir(dir);
-      const entries2 = (await Promise.all(names.map((n) => describe(path10.join(dir, n), n).catch(() => null)))).filter(Boolean);
+      const names = await fs15.readdir(dir);
+      const entries2 = (await Promise.all(names.map((n) => describe(path12.join(dir, n), n).catch(() => null)))).filter(Boolean);
       return { path: dir, entries: entries2 };
     },
     [Routes.fsStat]: async (url) => {
       const p = await sandbox.resolve(url.searchParams.get("path"));
-      return { path: p, ...await describe(p, path10.basename(p)) };
+      return { path: p, ...await describe(p, path12.basename(p)) };
     },
     [Routes.fsRead]: async (url, req, res) => {
       const p = await sandbox.resolve(url.searchParams.get("path"));
-      const stat = await fs13.stat(p);
+      const stat = await fs15.stat(p);
       if (!stat.isFile()) throw new HttpError(400, "not a file");
-      const type = MEDIA_TYPES[path10.extname(p).toLowerCase()] ?? "application/octet-stream";
+      const type = MEDIA_TYPES[path12.extname(p).toLowerCase()] ?? "application/octet-stream";
       const range = byteRange(req.headers.range, stat.size);
       if (range === "unsatisfiable") {
         res.writeHead(416, { "content-range": `bytes */${stat.size}`, "accept-ranges": "bytes" });
@@ -3592,24 +4357,24 @@ function createAgentServer({
       const tmp = `${p}.vsremote-${process.pid}-${Date.now()}.tmp`;
       try {
         await pipeline3(req, createWriteStream2(tmp));
-        await fs13.rename(tmp, p);
+        await fs15.rename(tmp, p);
       } catch (e) {
-        await fs13.rm(tmp, { force: true });
+        await fs15.rm(tmp, { force: true });
         throw e;
       }
-      return describe(p, path10.basename(p));
+      return describe(p, path12.basename(p));
     },
     [Routes.fsMkdir]: async (url) => {
-      await fs13.mkdir(await sandbox.resolve(url.searchParams.get("path"), { allowMissing: true }), { recursive: true });
+      await fs15.mkdir(await sandbox.resolve(url.searchParams.get("path"), { allowMissing: true }), { recursive: true });
       return {};
     },
     [Routes.fsRename]: async (url, req) => {
       const { from, to } = await readJson2(req);
-      await fs13.rename(await sandbox.resolveChild(from), await sandbox.resolveChild(to, { allowMissing: true }));
+      await fs15.rename(await sandbox.resolveChild(from), await sandbox.resolveChild(to, { allowMissing: true }));
       return {};
     },
     [Routes.fsDelete]: async (url) => {
-      await fs13.rm(await sandbox.resolveChild(url.searchParams.get("path")), { recursive: true });
+      await fs15.rm(await sandbox.resolveChild(url.searchParams.get("path")), { recursive: true });
       return {};
     },
     [Routes.fsSearch]: async (url, req, res) => {
@@ -3665,12 +4430,54 @@ function createAgentServer({
       const { repo: r, message } = await readJson2(req);
       return commit(await repoOf(r), message);
     },
+    [Routes.gitCommitMessage]: async (url, req) => {
+      const { repo: r, agent: wanted, model: chosen } = await readJson2(req);
+      const repo = await repoOf(r);
+      if (wanted !== void 0 && wanted !== null && !(wanted in launchers)) throw new HttpError(400, "unknown agent");
+      if (chosen !== void 0 && chosen !== null && (typeof chosen !== "string" || !/^[\w.:\[\]-]{1,100}$/.test(chosen))) {
+        throw new HttpError(400, "invalid model");
+      }
+      let agent = null;
+      for (const a of wanted ? [wanted] : ["claude", "codex"]) {
+        if (await installed(a)) {
+          agent = a;
+          break;
+        }
+      }
+      if (!agent) {
+        const name = wanted ? launchers[wanted].name : "Claude Code or Codex";
+        throw Object.assign(new HttpError(409, `Drafting a commit message needs ${name} installed on the computer.`), {
+          code: "ENOAGENT"
+        });
+      }
+      const model = wanted && chosen || (agent === "codex" ? (await codexModels())[0]?.id ?? null : null);
+      return draftCommitMessage(repo, agent, { claudeCommand, codexCommand, model });
+    },
     [Routes.gitLog]: async (url) => ({
       commits: await log(await repoOf(url.searchParams.get("repo")), parseInt(url.searchParams.get("limit"), 10) || 50)
     }),
     [Routes.gitShow]: async (url) => show(await repoOf(url.searchParams.get("repo")), url.searchParams.get("commit")),
     [Routes.gitPull]: async (url, req) => ({ output: await pull(await repoOf((await readJson2(req)).repo)) }),
     [Routes.gitPush]: async (url, req) => ({ output: await push(await repoOf((await readJson2(req)).repo)) }),
+    [Routes.gitFetch]: async (url, req) => ({ output: await fetch2(await repoOf((await readJson2(req)).repo)) }),
+    [Routes.gitBranches]: async (url) => ({ branches: await branches(await repoOf(url.searchParams.get("repo"))) }),
+    [Routes.gitCheckout]: async (url, req) => {
+      const { repo, branch, create } = await readJson2(req);
+      return checkout(await repoOf(repo), branch, { create: create === true });
+    },
+    [Routes.gitStashes]: async (url) => ({ stashes: await stashes(await repoOf(url.searchParams.get("repo"))) }),
+    [Routes.gitStash]: async (url, req) => {
+      const { repo, message, untracked } = await readJson2(req);
+      return stash(await repoOf(repo), { message, untracked: untracked !== false });
+    },
+    [Routes.gitStashApply]: async (url, req) => {
+      const { repo, index, pop } = await readJson2(req);
+      return stashApply(await repoOf(repo), index, { pop: pop === true });
+    },
+    [Routes.gitStashDrop]: async (url, req) => {
+      const { repo, index } = await readJson2(req);
+      return stashDrop(await repoOf(repo), index);
+    },
     [Routes.termList]: async () => ({ sessions: sessions.list() }),
     [Routes.portsList]: async () => ({ ports: await listPorts(shellPids()) }),
     [Routes.portsKill]: async (url, req) => {
@@ -3762,7 +4569,10 @@ function createAgentServer({
       return issued;
     },
     [Routes.agentsSessions]: async () => ({ sessions: agents.sessions() }),
-    [Routes.agentsTimeline]: async (url) => agents.timeline(url.searchParams.get("session"), parseInt(url.searchParams.get("after"), 10) || 0),
+    [Routes.agentsTimeline]: async (url) => {
+      await agents.ready(url.searchParams.get("session"));
+      return agents.timeline(url.searchParams.get("session"), parseInt(url.searchParams.get("after"), 10) || 0);
+    },
     [Routes.agentsSetup]: async () => {
       const [claude, codex] = await Promise.all([installed("claude"), installed("codex")]);
       const [plugin, codexPlugin] = await Promise.all([claude && hasPlugin("claude"), codex && hasPlugin("codex")]);
@@ -3816,7 +4626,7 @@ function createAgentServer({
       } catch (e) {
         throw new HttpError(400, e.message);
       }
-      if (!(await fs13.stat(dir)).isDirectory()) throw new HttpError(400, "cwd must be a folder");
+      if (!(await fs15.stat(dir)).isDirectory()) throw new HttpError(400, "cwd must be a folder");
       if (model !== void 0 && (typeof model !== "string" || !/^[A-Za-z0-9._[\]-]{1,80}$/.test(model))) {
         throw new HttpError(400, "invalid model");
       }
@@ -3838,7 +4648,7 @@ function createAgentServer({
         throw Object.assign(new HttpError(400, launcher.missingPlugin), { code: "ENOPLUGIN" });
       }
       const id = resume ?? randomUUID5();
-      if (uploadsDir) await fs13.mkdir(uploadsDir, { recursive: true, mode: 448 });
+      if (uploadsDir) await fs15.mkdir(uploadsDir, { recursive: true, mode: 448 });
       const argv2 = [
         launcher.command,
         ...launcher.args({
@@ -3867,7 +4677,8 @@ function createAgentServer({
       const paths = await attachmentPaths(attachments);
       const typed = typeable([text.trim(), ...paths].join("\n"));
       const prompt = randomUUID5();
-      agents.prompted(id, { id: prompt, text: typed, paths });
+      const images = paths.map((p, i) => ({ id: attachments[i], type: imageType(p) })).filter((i) => i.type);
+      agents.prompted(id, { id: prompt, text: typed, paths, images });
       await typeInto(term, typed);
       return { prompt };
     },
@@ -3885,8 +4696,16 @@ function createAgentServer({
       });
       return { id, name: saved, type, size };
     },
+    [Routes.agentsUploadFile]: async (url, req, res) => {
+      const file = await uploadPath(url.searchParams.get("id"));
+      const stat = await fs15.stat(file).catch(() => null);
+      if (!stat?.isFile()) throw new HttpError(404, "no such upload (they are kept for 7 days)");
+      const type = imageType(file) ?? MEDIA_TYPES[path12.extname(file).toLowerCase()] ?? "application/octet-stream";
+      res.writeHead(200, { "content-type": type, "content-length": stat.size, "cache-control": "private, max-age=604800, immutable" });
+      await pipeline3(createReadStream2(file), res);
+    },
     [Routes.agentsKeys]: async (url, req) => {
-      const { session: id, action, command, args } = await readJson2(req);
+      const { session: id, action, command, args, mode } = await readJson2(req);
       const allowed = agents.session(typeof id === "string" ? id : "")?.capabilities?.keys;
       if (action !== "command" && allowed && !allowed.includes(action)) {
         throw new HttpError(400, `this session takes ${allowed.join(", ")}`);
@@ -3900,11 +4719,14 @@ function createAgentServer({
           throw new HttpError(400, `${command} is not a command this session takes`);
         }
         await typeInto(term, typeable(args?.trim() ? `${command} ${args.trim()}` : command));
+        if (command === "/model" && args?.trim()) agents.modelChosen(id, args.trim());
+      } else if (action === "set_mode") {
+        return { session: await setMode(id, mode) };
       } else if (Object.hasOwn(KEYS, action)) {
         typingTarget(id, { whileWaiting: true }).term.write(KEYS[action]);
         if (action === "interrupt") agents.interrupted(id);
       } else {
-        throw new HttpError(400, `action must be one of ${[...Object.keys(KEYS), "command"].join(", ")}`);
+        throw new HttpError(400, `action must be one of ${[...Object.keys(KEYS), "set_mode", "command"].join(", ")}`);
       }
       return {};
     },
@@ -3960,6 +4782,9 @@ function createAgentServer({
       });
       return res.end(LANDING_HTML);
     }
+    if (req.socket[OVER_LAN] === true && tunnelOnly(req.method, url.pathname)) {
+      return sendJson(res, 404, { error: "not found" });
+    }
     if (req.method === "GET" && url.pathname === TUNNEL_HANDOFF_PATH) return handoffRedirect(url, res);
     if (`${req.method} ${url.pathname}` === Routes.agentsHook) return hookDelivery(url, req, res);
     if (!authorized(req)) return sendJson(res, 401, { error: "unauthorized" });
@@ -3978,7 +4803,6 @@ function createAgentServer({
     if (!hookAuthorized(req)) return sendJson(res, 401, { error: "unauthorized" });
     plugins[url.searchParams.get("agent") || "claude"] = { installed: true, checkedAt: Date.now() };
     const terminal = url.searchParams.get("terminal");
-    const app = url.searchParams.get("app");
     const closed = new AbortController();
     res.on("close", () => {
       if (!res.writableFinished) closed.abort();
@@ -3987,7 +4811,6 @@ function createAgentServer({
       const output = await agents.handle(await readJson2(req), {
         agent: url.searchParams.get("agent") || "claude",
         terminal: terminal && sessions.get(terminal) ? terminal : null,
-        app: app && app.length <= 1024 && /\.app$/.test(app) ? app : null,
         signal: closed.signal
       });
       if (res.destroyed) return;
@@ -4080,10 +4903,41 @@ function createAgentServer({
       presences.delete(ws);
     });
   }
+  let lanServer = null;
+  function lanInfo() {
+    const port2 = lanServer?.listening ? lanServer.address().port : null;
+    return { lan: port2 ? { port: port2, addresses: lanAddresses2(), fingerprint: lan.fingerprint } : null };
+  }
+  server.listenLan = (port2, host = "::") => {
+    if (!lan) return Promise.reject(new Error("no LAN certificate"));
+    const tlsServer = tls.createServer({ key: lan.key, cert: lan.cert, minVersion: "TLSv1.2" }, (socket) => {
+      socket[OVER_LAN] = true;
+      server.emit("connection", socket);
+    });
+    tlsServer.on("tlsClientError", () => {
+    });
+    return new Promise((resolve, reject) => {
+      tlsServer.once("error", (e) => {
+        if (host === "::" && (e.code === "EAFNOSUPPORT" || e.code === "EADDRNOTAVAIL")) {
+          return resolve(server.listenLan(port2, "0.0.0.0"));
+        }
+        reject(e);
+      });
+      tlsServer.listen(port2, host, () => {
+        tlsServer.removeAllListeners("error");
+        tlsServer.on("error", () => {
+        });
+        lanServer = tlsServer;
+        resolve(tlsServer);
+      });
+    });
+  };
   server.on("close", () => {
+    lanServer?.close();
     installs?.close();
     clearInterval(sweep);
     clearInterval(previewTimer);
+    if (saveTimer) saveSessions();
     sessions.killAll();
     for (const proxy of proxies.values()) proxy.close();
   });
@@ -4093,14 +4947,15 @@ function createAgentServer({
   server.clientShows = clientShows;
   server.push = push2;
   server.agentsUploadPath = (id) => uploadPath(id);
+  server.saveAgentSessions = () => sessionStore2 && saveSessions();
   return server;
 }
 
 // src/devtunnel.js
 import { execFile as execFile9 } from "node:child_process";
-import { createHash } from "node:crypto";
-import fs14 from "node:fs";
-import path11 from "node:path";
+import { createHash as createHash2 } from "node:crypto";
+import fs16 from "node:fs";
+import path13 from "node:path";
 import { promisify as promisify3 } from "node:util";
 var run5 = promisify3(execFile9);
 var DOWNLOAD_BASE = "https://tunnelsassetsprod.blob.core.windows.net/cli";
@@ -4131,11 +4986,11 @@ async function ensureDevtunnel({ dir, progress }) {
       `No devtunnel build for ${process.platform}-${process.arch}. Install it yourself: https://learn.microsoft.com/azure/developer/dev-tunnels/get-started`
     );
   }
-  const bin = path11.join(dir, isWindows ? "devtunnel.exe" : "devtunnel");
-  const metaFile = path11.join(dir, "devtunnel.json");
+  const bin = path13.join(dir, isWindows ? "devtunnel.exe" : "devtunnel");
+  const metaFile = path13.join(dir, "devtunnel.json");
   let meta = {};
   try {
-    meta = JSON.parse(fs14.readFileSync(metaFile, "utf8"));
+    meta = JSON.parse(fs16.readFileSync(metaFile, "utf8"));
   } catch {
   }
   const installed = findExecutable(bin) !== null;
@@ -4146,7 +5001,7 @@ async function ensureDevtunnel({ dir, progress }) {
       const head = await fetch(url, { method: "HEAD", signal: AbortSignal.timeout(3e3) });
       const lastModified = head.headers.get("last-modified");
       if (head.ok && lastModified && lastModified === meta.lastModified) {
-        fs14.writeFileSync(metaFile, JSON.stringify({ ...meta, checkedAt: Date.now() }));
+        fs16.writeFileSync(metaFile, JSON.stringify({ ...meta, checkedAt: Date.now() }));
         return bin;
       }
     } catch {
@@ -4161,13 +5016,13 @@ async function ensureDevtunnel({ dir, progress }) {
   return bin;
 }
 async function download(url, bin, metaFile, progress) {
-  fs14.mkdirSync(path11.dirname(bin), { recursive: true, mode: 448 });
+  fs16.mkdirSync(path13.dirname(bin), { recursive: true, mode: 448 });
   const res = await fetch(url, { signal: AbortSignal.timeout(12e4) });
   if (!res.ok || !res.body) throw new Error(`Downloading devtunnel failed: HTTP ${res.status} from ${url}`);
   const total = Number(res.headers.get("content-length")) || 0;
   const tmp = `${bin}.${process.pid}.download`;
-  const out = fs14.createWriteStream(tmp, { mode: 493 });
-  const md5 = createHash("md5");
+  const out = fs16.createWriteStream(tmp, { mode: 493 });
+  const md5 = createHash2("md5");
   let received = 0;
   try {
     for await (const chunk of res.body) {
@@ -4179,14 +5034,14 @@ async function download(url, bin, metaFile, progress) {
     await new Promise((resolve, reject) => out.end((e) => e ? reject(e) : resolve()));
     if (total && received !== total) throw new Error(`devtunnel download was cut short (${received} of ${total} bytes)`);
     await verify(tmp, md5.digest("base64"), res.headers.get("content-md5"));
-    fs14.chmodSync(tmp, 493);
-    fs14.renameSync(tmp, bin);
+    fs16.chmodSync(tmp, 493);
+    fs16.renameSync(tmp, bin);
   } catch (e) {
     out.destroy();
-    fs14.rmSync(tmp, { force: true });
+    fs16.rmSync(tmp, { force: true });
     throw e;
   }
-  fs14.writeFileSync(metaFile, JSON.stringify({ lastModified: res.headers.get("last-modified"), checkedAt: Date.now() }));
+  fs16.writeFileSync(metaFile, JSON.stringify({ lastModified: res.headers.get("last-modified"), checkedAt: Date.now() }));
 }
 async function verify(file, md5, expectedMd5) {
   if (expectedMd5 && md5 !== expectedMd5) throw new Error("devtunnel download is corrupt (MD5 mismatch)");
@@ -4201,11 +5056,11 @@ async function verify(file, md5, expectedMd5) {
   }
 }
 async function verifyAuthenticode(file) {
-  const script = '$s = Get-AuthenticodeSignature -LiteralPath $env:CODEREMOTE_VERIFY; "$($s.Status)|$($s.SignerCertificate.Subject)"';
+  const script2 = '$s = Get-AuthenticodeSignature -LiteralPath $env:CODEREMOTE_VERIFY; "$($s.Status)|$($s.SignerCertificate.Subject)"';
   let status2;
   let signer;
   try {
-    const { stdout } = await run5("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], {
+    const { stdout } = await run5("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script2], {
       env: { ...process.env, CODEREMOTE_VERIFY: file }
     });
     [status2, signer] = stdout.trim().split("|");
@@ -4218,52 +5073,51 @@ async function verifyAuthenticode(file) {
 }
 
 // src/hook.js
-import { execFile as execFile10 } from "node:child_process";
-import { randomBytes as randomBytes3 } from "node:crypto";
-import fs15 from "node:fs";
+import { randomBytes as randomBytes4 } from "node:crypto";
+import fs17 from "node:fs";
 import http4 from "node:http";
-import path12 from "node:path";
+import path14 from "node:path";
 var CONNECT_TIMEOUT = 1e3;
 var EVENT_TIMEOUT = 5e3;
 function ensureHookSecret(dir) {
-  const file = path12.join(dir, "hook-secret");
+  const file = path14.join(dir, "hook-secret");
   try {
-    const secret2 = fs15.readFileSync(file, "utf8").trim();
+    const secret2 = fs17.readFileSync(file, "utf8").trim();
     if (secret2) return secret2;
   } catch {
   }
-  fs15.mkdirSync(dir, { recursive: true, mode: 448 });
-  const secret = randomBytes3(32).toString("base64url");
-  fs15.writeFileSync(file, secret, { mode: 384 });
+  fs17.mkdirSync(dir, { recursive: true, mode: 448 });
+  const secret = randomBytes4(32).toString("base64url");
+  fs17.writeFileSync(file, secret, { mode: 384 });
   return secret;
 }
-function writeHookLauncher(dir, { node = process.execPath, script }) {
-  const bin = path12.join(dir, "bin");
-  fs15.mkdirSync(bin, { recursive: true, mode: 448 });
+function writeHookLauncher(dir, { node = process.execPath, script: script2 }) {
+  const bin = path14.join(dir, "bin");
+  fs17.mkdirSync(bin, { recursive: true, mode: 448 });
   const quote = (s) => `'${String(s).replace(/'/g, `'\\''`)}'`;
-  const file = path12.join(bin, "hook");
-  fs15.writeFileSync(file, `#!/bin/sh
-exec ${quote(node)} ${quote(script)} hook "$@"
+  const file = path14.join(bin, "hook");
+  fs17.writeFileSync(file, `#!/bin/sh
+exec ${quote(node)} ${quote(script2)} hook "$@"
 `, { mode: 493 });
-  fs15.chmodSync(file, 493);
-  fs15.writeFileSync(path12.join(bin, "hook.json"), JSON.stringify({ node, script }), { mode: 384 });
+  fs17.chmodSync(file, 493);
+  fs17.writeFileSync(path14.join(bin, "hook.json"), JSON.stringify({ node, script: script2 }), { mode: 384 });
   return file;
 }
 function readHookSecret(dir) {
   try {
-    return fs15.readFileSync(path12.join(dir, "hook-secret"), "utf8").trim() || null;
+    return fs17.readFileSync(path14.join(dir, "hook-secret"), "utf8").trim() || null;
   } catch {
     return null;
   }
 }
 function real(p) {
   try {
-    return fs15.realpathSync.native(p);
+    return fs17.realpathSync.native(p);
   } catch {
-    return path12.resolve(p);
+    return path14.resolve(p);
   }
 }
-var within = (dir, root2) => dir === root2 || dir.startsWith(root2.endsWith(path12.sep) ? root2 : root2 + path12.sep);
+var within = (dir, root2) => dir === root2 || dir.startsWith(root2.endsWith(path14.sep) ? root2 : root2 + path14.sep);
 function hookTarget(agents, cwd, env = process.env) {
   const port2 = parseInt(env.CODEREMOTE_AGENT_PORT, 10);
   if (port2 && agents.some((a) => a.port === port2)) return { port: port2, terminal: env.CODEREMOTE_TERM_ID || null };
@@ -4272,33 +5126,10 @@ function hookTarget(agents, cwd, env = process.env) {
   const match = agents.map((a) => ({ ...a, real: real(a.root) })).filter((a) => within(dir, a.real)).sort((a, b) => b.real.length - a.real.length)[0];
   return match ? { port: match.port, terminal: null } : null;
 }
-var HOST_EVENTS = /* @__PURE__ */ new Set(["SessionStart", "UserPromptSubmit", "PermissionRequest"]);
-function hostAppFrom(psOutput, pid) {
-  const parents = /* @__PURE__ */ new Map();
-  for (const line of psOutput.split("\n")) {
-    const m = line.match(/^\s*(\d+)\s+(\d+)\s+(.+)$/);
-    if (m) parents.set(Number(m[1]), { ppid: Number(m[2]), comm: m[3] });
-  }
-  for (let seen = 0, p = parents.get(pid); p && seen < 64; seen++, p = parents.get(p.ppid)) {
-    const at = p.comm.indexOf(".app/");
-    if (at > 0) return p.comm.slice(0, at + 4);
-    if (p.ppid <= 1) break;
-  }
-  return null;
-}
-function hostApp() {
-  if (process.platform !== "darwin") return Promise.resolve(null);
-  return new Promise((resolve) => {
-    execFile10("ps", ["-A", "-o", "pid=,ppid=,comm="], { timeout: 1e3, maxBuffer: 8 * 1024 * 1024 }, (err, stdout) => {
-      resolve(err ? null : hostAppFrom(stdout, process.ppid));
-    });
-  });
-}
-function deliverHook({ port: port2, terminal, app = null, agent, secret, body, wait }) {
+function deliverHook({ port: port2, terminal, agent, secret, body, wait }) {
   return new Promise((resolve) => {
     const query = new URLSearchParams({ agent });
     if (terminal) query.set("terminal", terminal);
-    if (app) query.set("app", app);
     const req = http4.request({
       host: "127.0.0.1",
       port: port2,
@@ -4326,8 +5157,8 @@ function deliverHook({ port: port2, terminal, app = null, agent, secret, body, w
     req.end(body);
   });
 }
-async function runHook({ input, agents, secret, agent = "claude", env = process.env, findApp = hostApp }) {
-  if (!secret) return "";
+async function runHook({ input, agents, secret, agent = "claude", env = process.env }) {
+  if (!secret || env.CODEREMOTE_NO_HOOK) return "";
   let event;
   try {
     event = JSON.parse(input);
@@ -4337,15 +5168,15 @@ async function runHook({ input, agents, secret, agent = "claude", env = process.
   const target = hookTarget(agents, event?.cwd, env);
   if (!target) return "";
   const wait = event.hook_event_name === "PermissionRequest";
-  const app = !target.terminal && HOST_EVENTS.has(event.hook_event_name) ? await findApp() : null;
-  const out = await deliverHook({ ...target, app, agent, secret, body: input, wait });
+  const out = await deliverHook({ ...target, agent, secret, body: input, wait });
   return wait ? out.trim() : "";
 }
 
 // src/preview.js
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 
 // src/tunnels.js
+import { randomBytes as randomBytes5 } from "node:crypto";
 var TUNNEL_LIMIT = 10;
 var PREVIEW_LABEL = "coderemote-preview";
 var LOGIN_NEEDED = /not logged in|login token expired|login required|please log ?in/i;
@@ -4390,6 +5221,7 @@ function forgetTunnel(cfg2, id) {
     for (const [port2, t] of Object.entries(cfg2[key] ?? {})) {
       if (base(t) !== base(id)) continue;
       delete cfg2[key][port2];
+      if (key === "tunnels" && cfg2.tunnelUrls) delete cfg2.tunnelUrls[port2];
       changed = true;
     }
   }
@@ -4419,6 +5251,18 @@ function tunnelLimitHelp(tunnels, cfg2 = {}) {
     "  coderemote tunnels delete <tunnel id>..."
   ].join("\n");
 }
+function ensureAgentId(cfg2, port2) {
+  const known = cfg2.agentIds?.[port2];
+  if (typeof known === "string" && /^[0-9a-f]{32}$/.test(known)) return known;
+  const id = randomBytes5(16).toString("hex");
+  cfg2.agentIds = { ...cfg2.agentIds, [port2]: id };
+  return id;
+}
+function rememberTunnelUrl(cfg2, port2, url) {
+  if (!url || cfg2.tunnelUrls?.[port2] === url) return false;
+  cfg2.tunnelUrls = { ...cfg2.tunnelUrls, [port2]: url };
+  return true;
+}
 
 // src/preview.js
 var HOST_READY_TIMEOUT_MS = 3e4;
@@ -4596,7 +5440,7 @@ ${created.out}`);
   }
   #startHost() {
     return new Promise((resolve, reject) => {
-      const child = spawn4(this.command(), ["host", this.#tunnelId], { stdio: ["ignore", "pipe", "pipe"] });
+      const child = spawn5(this.command(), ["host", this.#tunnelId], { stdio: ["ignore", "pipe", "pipe"] });
       const urls = /* @__PURE__ */ new Map();
       let log2 = "";
       const timer = setTimeout(() => {
@@ -4631,69 +5475,102 @@ ${log2}`));
 };
 
 // src/push-store.js
-import fs16 from "node:fs";
-import path13 from "node:path";
+import fs18 from "node:fs";
+import path15 from "node:path";
 function pushStore(dir, port2) {
-  const file = path13.join(dir, `${port2}.json`);
+  const file = path15.join(dir, `${port2}.json`);
   return {
     load() {
       try {
-        const devices = JSON.parse(fs16.readFileSync(file, "utf8"));
+        const devices = JSON.parse(fs18.readFileSync(file, "utf8"));
         return Array.isArray(devices) ? devices : [];
       } catch {
         return [];
       }
     },
     save(devices) {
-      fs16.mkdirSync(dir, { recursive: true, mode: 448 });
-      fs16.writeFileSync(file, JSON.stringify(devices, null, 2), { mode: 384 });
+      fs18.mkdirSync(dir, { recursive: true, mode: 448 });
+      fs18.writeFileSync(file, JSON.stringify(devices, null, 2), { mode: 384 });
+    }
+  };
+}
+
+// src/session-store.js
+import fs19 from "node:fs";
+import path16 from "node:path";
+function sessionStore(dir, port2) {
+  const file = path16.join(dir, `${port2}.json`);
+  return {
+    load() {
+      try {
+        const sessions = JSON.parse(fs19.readFileSync(file, "utf8"));
+        return Array.isArray(sessions) ? sessions : [];
+      } catch {
+        return [];
+      }
+    },
+    save(sessions) {
+      fs19.mkdirSync(dir, { recursive: true, mode: 448 });
+      const tmp = `${file}.${process.pid}.tmp`;
+      fs19.writeFileSync(tmp, JSON.stringify(sessions), { mode: 384 });
+      fs19.renameSync(tmp, file);
     }
   };
 }
 
 // src/registry.js
-import fs17 from "node:fs";
-import path14 from "node:path";
+import fs20 from "node:fs";
+import path17 from "node:path";
 var AgentRegistry = class {
   constructor(dir) {
     this.dir = dir;
   }
   register({ port: port2, root: root2, url }) {
-    fs17.mkdirSync(this.dir, { recursive: true, mode: 448 });
+    fs20.mkdirSync(this.dir, { recursive: true, mode: 448 });
     const file = this.#file(port2);
-    fs17.writeFileSync(file, JSON.stringify({ pid: process.pid, port: port2, root: root2, url, startedAt: Date.now() }), { mode: 384 });
+    let startedAt = Date.now();
+    try {
+      const previous = JSON.parse(fs20.readFileSync(file, "utf8"));
+      if (previous.pid === process.pid) startedAt = previous.startedAt;
+    } catch {
+    }
+    fs20.writeFileSync(file, JSON.stringify({ pid: process.pid, port: port2, root: root2, url, startedAt }), { mode: 384 });
     const cleanup = () => {
       try {
-        if (JSON.parse(fs17.readFileSync(file, "utf8")).pid === process.pid) fs17.rmSync(file);
+        if (JSON.parse(fs20.readFileSync(file, "utf8")).pid === process.pid) fs20.rmSync(file);
       } catch {
       }
     };
-    process.on("exit", cleanup);
+    if (!this.cleanups) this.cleanups = /* @__PURE__ */ new Set();
+    if (!this.cleanups.has(file)) {
+      this.cleanups.add(file);
+      process.on("exit", cleanup);
+    }
     return cleanup;
   }
   /** Live agents; entries left behind by crashed processes are removed. */
   list() {
     let names = [];
     try {
-      names = fs17.readdirSync(this.dir).filter((n) => n.endsWith(".json"));
+      names = fs20.readdirSync(this.dir).filter((n) => n.endsWith(".json"));
     } catch {
       return [];
     }
     const agents = [];
     for (const name of names) {
-      const file = path14.join(this.dir, name);
+      const file = path17.join(this.dir, name);
       try {
-        const agent = JSON.parse(fs17.readFileSync(file, "utf8"));
+        const agent = JSON.parse(fs20.readFileSync(file, "utf8"));
         process.kill(agent.pid, 0);
         agents.push(agent);
       } catch {
-        fs17.rmSync(file, { force: true });
+        fs20.rmSync(file, { force: true });
       }
     }
     return agents.sort((a, b) => a.port - b.port);
   }
   #file(port2) {
-    return path14.join(this.dir, `${port2}.json`);
+    return path17.join(this.dir, `${port2}.json`);
   }
 };
 
@@ -4701,7 +5578,7 @@ var AgentRegistry = class {
 var MACHINE_LABEL = "coderemote";
 var PROVIDER = "devtunnels";
 var CACHE_MS = 15e3;
-function parse(out) {
+function parse2(out) {
   return JSON.parse(out.slice(out.indexOf("{")));
 }
 function machineName(description) {
@@ -4737,13 +5614,13 @@ function tunnelStatus({ devtunnel: devtunnel2, tunnelId, account, anonymous: ano
       devtunnel2("list", "--limit", "100", "--json")
     ]);
     if (!own.ok) throw new Error(`devtunnel show failed: ${own.out.trim()}`);
-    const tunnel = parse(own.out).tunnel;
-    const all = listed.ok ? parse(listed.out).tunnels ?? [] : null;
+    const tunnel = parse2(own.out).tunnel;
+    const all = listed.ok ? parse2(listed.out).tunnels ?? [] : null;
     const others = (all ?? []).filter((t) => t.tunnelId !== id && t.labels?.includes(MACHINE_LABEL));
     const shown = await Promise.all(
       others.map(async (t) => {
         const res = await devtunnel2("show", t.tunnelId, "--json");
-        return res.ok ? parse(res.out).tunnel : null;
+        return res.ok ? parse2(res.out).tunnel : null;
       })
     );
     const machines = [machine(tunnel, true), ...shown.filter(Boolean).map((t) => machine(t, false))];
@@ -4805,9 +5682,95 @@ function tunnelDelete({ devtunnel: devtunnel2, tunnelId, deleted = () => {
   };
 }
 
+// src/tunnel-retry.js
+import http5 from "node:http";
+import https from "node:https";
+var RELAY_CHECK_URL = process.env.CODEREMOTE_RELAY_CHECK_URL || "https://global.rel.tunnels.api.visualstudio.com/";
+function relayReachable({ url = RELAY_CHECK_URL, timeoutMs = 4e3, request = url.startsWith("http:") ? http5.request : https.request } = {}) {
+  return new Promise((resolve) => {
+    let done = false;
+    const finish = (ok) => {
+      if (done) return;
+      done = true;
+      resolve(ok);
+    };
+    try {
+      const req = request(url, { method: "HEAD", timeout: timeoutMs }, (res) => {
+        res.resume();
+        finish(true);
+      });
+      req.on("timeout", () => {
+        req.destroy();
+        finish(false);
+      });
+      req.on("error", () => finish(false));
+      req.end();
+    } catch {
+      finish(false);
+    }
+  });
+}
+var NotSignedIn = class extends Error {
+  constructor() {
+    super("not signed in to dev tunnels");
+    this.code = "ENOTSIGNEDIN";
+  }
+};
+function retryTunnel({
+  reachable,
+  connect,
+  onSignedOut = () => {
+  },
+  onError = () => {
+  },
+  firstMs = 15e3,
+  maxMs = 3e5,
+  setTimer = setTimeout,
+  clearTimer = clearTimeout
+}) {
+  let delay = firstMs;
+  let timer = null;
+  let stopped = false;
+  let toldSignedOut = false;
+  let resolveDone;
+  const done = new Promise((r) => resolveDone = r);
+  const schedule = () => {
+    if (stopped) return;
+    timer = setTimer(attempt, delay);
+    timer?.unref?.();
+    delay = Math.min(delay * 2, maxMs);
+  };
+  async function attempt() {
+    timer = null;
+    if (stopped) return;
+    if (!await reachable()) return schedule();
+    try {
+      const result = await connect();
+      if (stopped) return;
+      stopped = true;
+      resolveDone(result);
+    } catch (e) {
+      if (stopped) return;
+      if (e?.code === "ENOTSIGNEDIN") {
+        if (!toldSignedOut) onSignedOut();
+        toldSignedOut = true;
+      } else onError(e);
+      schedule();
+    }
+  }
+  schedule();
+  return {
+    done,
+    stop() {
+      stopped = true;
+      if (timer) clearTimer(timer);
+    }
+  };
+}
+
 // src/update.js
-import fs18 from "node:fs";
-import path15 from "node:path";
+import fs21 from "node:fs";
+import path18 from "node:path";
 var LATEST_URL = "https://registry.npmjs.org/coderemote/latest";
 var CHECK_INTERVAL_MS = 24 * 36e5;
 var SEMVER = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/;
@@ -4820,9 +5783,9 @@ function isNewer(latest, current) {
   }
   return !a[4] && !!b[4];
 }
-async function fetchLatest({ fetch: fetch2 = globalThis.fetch, timeoutMs = 3e3 } = {}) {
+async function fetchLatest({ fetch: fetch3 = globalThis.fetch, timeoutMs = 3e3 } = {}) {
   try {
-    const res = await fetch2(LATEST_URL, { signal: AbortSignal.timeout(timeoutMs) });
+    const res = await fetch3(LATEST_URL, { signal: AbortSignal.timeout(timeoutMs) });
     if (!res.ok) return null;
     const { version } = await res.json();
     return SEMVER.test(version) ? version : null;
@@ -4830,21 +5793,21 @@ async function fetchLatest({ fetch: fetch2 = globalThis.fetch, timeoutMs = 3e3 }
     return null;
   }
 }
-async function availableUpdate({ current, dir, fetch: fetch2, now = Date.now() }) {
-  const file = path15.join(dir, "update.json");
+async function availableUpdate({ current, dir, fetch: fetch3, now = Date.now() }) {
+  const file = path18.join(dir, "update.json");
   let cache = {};
   try {
-    cache = JSON.parse(fs18.readFileSync(file, "utf8"));
+    cache = JSON.parse(fs21.readFileSync(file, "utf8"));
   } catch {
   }
   let latest = cache.latest;
   if (!latest || !(now - (cache.checkedAt ?? 0) < CHECK_INTERVAL_MS)) {
-    const fetched = await fetchLatest({ fetch: fetch2 });
+    const fetched = await fetchLatest({ fetch: fetch3 });
     if (fetched) {
       latest = fetched;
       try {
-        fs18.mkdirSync(dir, { recursive: true, mode: 448 });
-        fs18.writeFileSync(file, JSON.stringify({ latest, checkedAt: now }));
+        fs21.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs21.writeFileSync(file, JSON.stringify({ latest, checkedAt: now }));
       } catch {
       }
     }
@@ -4852,12 +5815,12 @@ async function availableUpdate({ current, dir, fetch: fetch2, now = Date.now() }
   return isNewer(latest, current) ? latest : null;
 }
 function installCommand(installedAt) {
-  const p = installedAt.split(path15.sep).join("/");
+  const p = installedAt.split(path18.sep).join("/");
   const runtime = p.match(/^(.*\/runtime\/node)\/(lib\/)?node_modules\/coderemote\//);
   if (runtime) {
     const prefix = installedAt.slice(0, runtime[1].length);
-    const [node, modules] = runtime[2] ? [path15.join(prefix, "bin", "node"), path15.join(prefix, "lib", "node_modules")] : [path15.join(prefix, "node.exe"), path15.join(prefix, "node_modules")];
-    return [node, [path15.join(modules, "npm", "bin", "npm-cli.js"), "install", "-g", "--prefix", prefix, "coderemote@latest"]];
+    const [node, modules] = runtime[2] ? [path18.join(prefix, "bin", "node"), path18.join(prefix, "lib", "node_modules")] : [path18.join(prefix, "node.exe"), path18.join(prefix, "node_modules")];
+    return [node, [path18.join(modules, "npm", "bin", "npm-cli.js"), "install", "-g", "--prefix", prefix, "coderemote@latest"]];
   }
   if (p.includes("/Cellar/coderemote/")) return ["brew", ["upgrade", "coderemote"]];
   if (p.includes("/pnpm/") || p.includes("/.pnpm/")) return ["pnpm", ["add", "-g", "coderemote@latest"]];
@@ -4869,7 +5832,7 @@ function installCommand(installedAt) {
 // package.json
 var package_default = {
   name: "coderemote",
-  version: "0.3.9",
+  version: "0.3.10",
   description: "Use your computer from your iPhone: files, git and a real terminal over a secure Microsoft Dev Tunnel. No SSH, no port forwarding, no VPN.",
   keywords: [
     "remote",
@@ -5191,29 +6154,124 @@ ${log2}`));
   });
 }
 
+// src/windows-firewall.js
+import { execFile as execFile10 } from "node:child_process";
+var psQuote = (s) => `'${String(s).replace(/'/g, "''")}'`;
+function script(execPath) {
+  return `
+$ErrorActionPreference = 'SilentlyContinue'
+$exe = ${psQuote(execPath)}
+$profiles = @(Get-NetConnectionProfile | ForEach-Object {
+	@{ alias = $_.InterfaceAlias; category = [string]$_.NetworkCategory }
+})
+$blocks = @(Get-NetFirewallRule -Direction Inbound -Action Block -Enabled True | ForEach-Object {
+	$rule = $_
+	$program = ($rule | Get-NetFirewallApplicationFilter).Program
+	if ($program -and [Environment]::ExpandEnvironmentVariables($program) -ieq $exe) {
+		@{ name = $rule.Name; displayName = $rule.DisplayName; profile = [string]$rule.Profile }
+	}
+})
+# The effective settings, Group Policy included: AllowLocalFirewallRules False ignores local rules.
+$firewall = @(Get-NetFirewallProfile -PolicyStore ActiveStore | ForEach-Object {
+	@{ name = [string]$_.Name; enabled = [string]$_.Enabled; allowLocalRules = [string]$_.AllowLocalFirewallRules }
+})
+ConvertTo-Json -Compress -Depth 4 @{ profiles = $profiles; blockRules = $blocks; firewall = $firewall }
+`;
+}
+function firewallReport({ execPath = process.execPath, timeoutMs = 1e4, run: run7 = execFile10, platform = process.platform } = {}) {
+  if (platform !== "win32") return Promise.resolve(null);
+  return new Promise((resolve) => {
+    try {
+      run7(
+        "powershell.exe",
+        ["-NoProfile", "-NonInteractive", "-EncodedCommand", Buffer.from(script(execPath), "utf16le").toString("base64")],
+        { timeout: timeoutMs, windowsHide: true },
+        (err, stdout) => {
+          if (err) return resolve(null);
+          try {
+            const got = JSON.parse(stdout);
+            resolve({
+              profiles: [got.profiles ?? []].flat(),
+              blockRules: [got.blockRules ?? []].flat(),
+              firewall: [got.firewall ?? []].flat()
+            });
+          } catch {
+            resolve(null);
+          }
+        }
+      );
+    } catch {
+      resolve(null);
+    }
+  });
+}
+function lanAdapters(interfaces) {
+  return Object.entries(interfaces).filter(([name, addrs]) => lanAddresses({ [name]: addrs }).length > 0).map(([name]) => name);
+}
+var PROFILE_OF = { Public: "Public", Private: "Private", DomainAuthenticated: "Domain" };
+var covers = (ruleProfile, category) => ruleProfile === "Any" || ruleProfile.split(/,\s*/).includes(PROFILE_OF[category]);
+function firewallAdvice(report, { lanPort, adapters }) {
+  if (!report) return [];
+  const lines = [];
+  const settings = (p) => (report.firewall ?? []).find((f) => f.name === PROFILE_OF[p.category]);
+  const lan = report.profiles.filter((p) => adapters.includes(p.alias) && settings(p)?.enabled !== "False");
+  if (lan.some((p) => settings(p)?.allowLocalRules === "False")) {
+    return [
+      "Your organization manages this computer's firewall, and rules set on it are ignored:",
+      "phones on this network may not reach it directly. The app then goes through the tunnel; your IT",
+      `can allow inbound TCP port ${lanPort} from the local network.`
+    ];
+  }
+  const publicOnes = lan.filter((p) => p.category === "Public");
+  const blocking = report.blockRules.filter((r) => lan.some((p) => p.category !== "Public" && covers(r.profile, p.category)));
+  const blockingPublic = report.blockRules.some((r) => covers(r.profile, "Public"));
+  if (publicOnes.length) {
+    const names = publicOnes.map((p) => `"${p.alias}"`).join(", ");
+    lines.push(`Windows treats ${names} as a Public network, and its firewall keeps phones on it out.`);
+    lines.push("On a network you trust, make it Private (in PowerShell run as administrator):");
+    for (const p of publicOnes) lines.push(`  Set-NetConnectionProfile -InterfaceAlias "${p.alias}" -NetworkCategory Private`);
+    if (!blockingPublic) {
+      lines.push("Or let in only this port, from the local network (Command Prompt or PowerShell as administrator):");
+      lines.push(
+        `  netsh advfirewall firewall add rule name="Code Remote LAN ${lanPort}" dir=in action=allow protocol=TCP localport=${lanPort} remoteip=localsubnet`
+      );
+    }
+  }
+  if (blocking.length) {
+    lines.push(`The firewall blocks node ("${blocking[0].displayName}", left by choosing Cancel when Windows asked), so phones can't connect.`);
+    lines.push("Remove it (in PowerShell run as administrator), then start coderemote again and choose Allow:");
+    lines.push(`  Remove-NetFirewallRule -Name ${blocking.map((r) => `"${r.name}"`).join(",")}`);
+  }
+  return lines;
+}
+
 // bin/coderemote.js
 var run6 = promisify4(execFile11);
-var CONFIG_DIR = path16.join(os7.homedir(), ".coderemote");
-var LEGACY_CONFIG_DIR = path16.join(os7.homedir(), ".vsremote");
-if (!fs19.existsSync(CONFIG_DIR) && fs19.existsSync(LEGACY_CONFIG_DIR)) fs19.renameSync(LEGACY_CONFIG_DIR, CONFIG_DIR);
-var CONFIG_FILE = path16.join(CONFIG_DIR, "config.json");
-var PUSH_DIR = path16.join(CONFIG_DIR, "push");
-var UPLOADS_DIR = path16.join(CONFIG_DIR, "uploads");
+var CONFIG_DIR = path19.join(os9.homedir(), ".coderemote");
+var LEGACY_CONFIG_DIR = path19.join(os9.homedir(), ".vsremote");
+if (!fs22.existsSync(CONFIG_DIR) && fs22.existsSync(LEGACY_CONFIG_DIR)) fs22.renameSync(LEGACY_CONFIG_DIR, CONFIG_DIR);
+var CONFIG_FILE = path19.join(CONFIG_DIR, "config.json");
+var PUSH_DIR = path19.join(CONFIG_DIR, "push");
+var AGENT_SESSIONS_DIR = path19.join(CONFIG_DIR, "agent-sessions");
+var UPLOADS_DIR = path19.join(CONFIG_DIR, "uploads");
+var LAN_DIR = path19.join(CONFIG_DIR, "lan");
+var LAN_PORT_OFFSET = 1e3;
 var DEFAULT_PORT = 31580;
 var VERSION = package_default.version;
-var PACKAGED = path16.basename(path16.dirname(fileURLToPath(import.meta.url))) === "dist";
+var PACKAGED = path19.basename(path19.dirname(fileURLToPath(import.meta.url))) === "dist";
 var spinner = new Spinner();
 function loadConfig() {
   let cfg2 = {};
   try {
-    cfg2 = JSON.parse(fs19.readFileSync(CONFIG_FILE, "utf8"));
+    cfg2 = JSON.parse(fs22.readFileSync(CONFIG_FILE, "utf8"));
   } catch {
   }
   if (!cfg2.token) {
-    cfg2.token = randomBytes4(32).toString("base64url");
+    cfg2.token = randomBytes6(32).toString("base64url");
     saveConfig(cfg2);
-    fs19.rmSync(PUSH_DIR, { recursive: true, force: true });
-    fs19.rmSync(UPLOADS_DIR, { recursive: true, force: true });
+    fs22.rmSync(PUSH_DIR, { recursive: true, force: true });
+    fs22.rmSync(UPLOADS_DIR, { recursive: true, force: true });
+    fs22.rmSync(LAN_DIR, { recursive: true, force: true });
   }
   if (cfg2.tunnelId && !cfg2.tunnels) {
     cfg2.tunnels = { [DEFAULT_PORT]: cfg2.tunnelId };
@@ -5229,8 +6287,8 @@ function stopAgent(pid) {
   }
 }
 function saveConfig(cfg2) {
-  fs19.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
-  fs19.writeFileSync(CONFIG_FILE, JSON.stringify(cfg2, null, 2), { mode: 384 });
+  fs22.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  fs22.writeFileSync(CONFIG_FILE, JSON.stringify(cfg2, null, 2), { mode: 384 });
 }
 function portFree(port2) {
   return new Promise((resolve) => {
@@ -5239,9 +6297,9 @@ function portFree(port2) {
     probe.listen(port2, "127.0.0.1", () => probe.close(() => resolve(true)));
   });
 }
-function listen(token, port2, root2, tunnelToken, preview2, status2, remover) {
+function listen(token, port2, root2, tunnelToken, preview2, status2, remover, lan, agentId, tunnelUrl) {
   const hookSecret = ensureHookSecret(CONFIG_DIR);
-  writeHookLauncher(CONFIG_DIR, { script: fs19.realpathSync(process.argv[1]) });
+  writeHookLauncher(CONFIG_DIR, { script: fs22.realpathSync(process.argv[1]) });
   const server = createAgentServer({
     token,
     root: root2,
@@ -5251,21 +6309,62 @@ function listen(token, port2, root2, tunnelToken, preview2, status2, remover) {
     tunnelDelete: remover,
     hookSecret,
     // This very CLI, so coding agents in the app's terminals report through the same version.
-    hookBin: fs19.realpathSync(process.argv[1]),
+    hookBin: fs22.realpathSync(process.argv[1]),
     pushStore: pushStore(PUSH_DIR, port2),
+    sessionStore: sessionStore(AGENT_SESSIONS_DIR, port2),
     uploadsDir: UPLOADS_DIR,
-    version: VERSION
+    version: VERSION,
+    lan,
+    agentId,
+    tunnelUrl
   });
   return new Promise((resolve, reject) => {
     server.once("error", reject);
     server.listen(port2, "127.0.0.1", () => resolve(server));
   });
 }
+async function openLan(server, agentPort) {
+  const remembered = cfg.lanPorts?.[root];
+  const claimed = new Set(Object.entries(cfg.lanPorts ?? {}).filter(([r]) => r !== root).map(([, p]) => p));
+  const busy = new Set(registry.list().map((a) => a.port));
+  let candidate = remembered ?? agentPort + LAN_PORT_OFFSET;
+  for (let tries = 0; tries < 50; tries++, candidate++) {
+    if (candidate !== remembered && (claimed.has(candidate) || busy.has(candidate))) continue;
+    try {
+      const lanPort = (await server.listenLan(candidate)).address().port;
+      if (lanPort !== remembered) {
+        cfg.lanPorts = { ...cfg.lanPorts, [root]: lanPort };
+        saveConfig(cfg);
+      }
+      return { port: lanPort };
+    } catch (e) {
+      if (e.code !== "EADDRINUSE") return { error: e.message };
+    }
+  }
+  return { error: "no free port" };
+}
+function advertiseLan(lanPort, fingerprint, agentPort) {
+  if (process.platform !== "darwin") return null;
+  const host = os9.hostname().replace(/\.local$/, "");
+  const name = agentPort === DEFAULT_PORT ? host : `${host} :${agentPort}`;
+  try {
+    const child = spawn6(
+      "dns-sd",
+      ["-R", name, LAN_SERVICE_TYPE, "local", String(lanPort), `fp=${fingerprint.slice(0, 16)}`, `proto=${PROTOCOL_VERSION}`],
+      { stdio: "ignore" }
+    );
+    child.on("error", () => {
+    });
+    return child;
+  } catch {
+    return null;
+  }
+}
 var DEVTUNNEL = "devtunnel";
 async function resolveDevtunnel() {
   let installing = false;
   DEVTUNNEL = await ensureDevtunnel({
-    dir: path16.join(CONFIG_DIR, "bin"),
+    dir: path19.join(CONFIG_DIR, "bin"),
     progress: (detail2) => {
       if (!installing) {
         installing = true;
@@ -5292,7 +6391,7 @@ function loginArgs(opts = rest) {
 }
 function interactiveLogin(args) {
   return new Promise((resolve) => {
-    spawn5(DEVTUNNEL, args, { stdio: "inherit" }).on("exit", resolve);
+    spawn6(DEVTUNNEL, args, { stdio: "inherit" }).on("exit", resolve);
   });
 }
 async function login(reason) {
@@ -5322,10 +6421,11 @@ function applyAccess(tunnelId, anonymous2) {
 async function ensureTunnel(cfg2, port2, anonymous2) {
   const known = cfg2.tunnels?.[port2];
   if (known) {
-    const [updated, access] = await Promise.all([
-      devtunnel("update", known, "--expiration", "30d", "--add-labels", MACHINE_LABEL),
-      applyAccess(known, anonymous2)
-    ]);
+    const update = () => devtunnel("update", known, "--expiration", "30d", "--add-labels", MACHINE_LABEL);
+    let [updated, access] = await Promise.all([update(), applyAccess(known, anonymous2)]);
+    const conflict = (res) => !res.ok && /conflicting request/i.test(res.out);
+    if (conflict(updated)) updated = await update();
+    if (conflict(access)) access = await applyAccess(known, anonymous2);
     if (updated.ok) {
       if (!access.ok) throw new Error(`devtunnel access failed:
 ${access.out}`);
@@ -5334,18 +6434,13 @@ ${access.out}`);
     if (!/not found/i.test(updated.out)) throw new Error(`devtunnel update failed:
 ${updated.out}`);
   }
-  const name = port2 === DEFAULT_PORT ? os7.hostname() : `${os7.hostname()} :${port2}`;
+  const name = port2 === DEFAULT_PORT ? os9.hostname() : `${os9.hostname()} :${port2}`;
   const createArgs = ["create", "--expiration", "30d", "-d", `coderemote ${name}`, "--labels", MACHINE_LABEL, "--json"];
   if (anonymous2) createArgs.push("--allow-anonymous");
   let created = await devtunnel(...createArgs);
   if (!created.ok) {
     const room = await makeRoom(devtunnel);
-    if (room?.full) {
-      spinner.fail();
-      console.error(`
-${tunnelLimitHelp(room.full, cfg2)}`);
-      process.exit(1);
-    }
+    if (room?.full) throw Object.assign(new Error(tunnelLimitHelp(room.full, cfg2)), { code: "ETUNNELLIMIT" });
     if (room?.freed) {
       spinner.update(`(deleted ${room.freed.length} idle preview tunnel${room.freed.length > 1 ? "s" : ""} to make room)`);
       if (room.freed.filter((id) => forgetTunnel(cfg2, id)).length) saveConfig(cfg2);
@@ -5376,7 +6471,7 @@ ${res.out}`);
 }
 function hostTunnel(tunnelId, port2) {
   return new Promise((resolve, reject) => {
-    const child = spawn5(DEVTUNNEL, ["host", tunnelId], { stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn6(DEVTUNNEL, ["host", tunnelId], { stdio: ["ignore", "pipe", "pipe"] });
     let log2 = "";
     const onData = (d) => {
       log2 += d;
@@ -5389,20 +6484,22 @@ function hostTunnel(tunnelId, port2) {
 ${log2}`)));
   });
 }
-function printPairing(url, token, access, vscodeUrl) {
-  const pair = pairingUrl({ url, token });
+function printPairing(url, token, access, vscodeUrl, link) {
+  const pair = pairingUrl({ url, token, agentId: link?.agentId, lan: link?.lan });
   if (access) console.log(`  Access:  ${access}`);
   const label = (name) => `${name}:`.padEnd(vscodeUrl ? 9 : 4);
   console.log("");
   if (vscodeUrl) console.log(`  ${label("VS Code")}  ${vscodeUrl}`);
-  console.log(`  ${label("Web")}  ${webUrl({ url, token })}`);
+  if (url) console.log(`  ${label("Web")}  ${webUrl({ url, token })}`);
   console.log(`  ${label("App")}  ${pair}
 `);
+  if (!url) console.log("  No tunnel yet: pair the Code Remote app on this Wi-Fi (an app too old for that calls this link invalid).\n");
   if (vscodeUrl) console.log("  VS Code opens in the browser after signing in with the account of `code tunnel`.");
-  console.log("  Scan with the iPhone Camera, or open either link on the phone:\n");
+  console.log(`  Scan with the iPhone Camera, or open ${url ? "either link" : "the link"} on the phone:
+`);
   qrcode.generate(pair, { small: true });
   console.log(
-    anonymous ? "\n  The links contain your access token. Anyone with them can use this machine." : "\n  The links contain your access token; the phone or browser must also sign in as you."
+    anonymous ? "\n  The links contain your access token. Anyone with them can use this machine." : url ? "\n  The links contain your access token; the phone or browser must also sign in as you." : "\n  The link contains your access token; away from this network the phone must also sign in as you."
   );
   console.log("  Run `coderemote rotate-token` to revoke every paired device.\n");
 }
@@ -5440,7 +6537,9 @@ async function startVSCodeTunnel() {
 var USAGE = `Usage: coderemote <command> [options]
 
   up                   share this folder through a dev tunnel and print the pairing QR;
-                       the phone or browser must sign in with your dev tunnels account
+                       the phone or browser must sign in with your dev tunnels account.
+                       Without internet it serves the local network only and connects
+                       the tunnel once it can
   serve                share this folder on 127.0.0.1 only (no tunnel)
   status               list running agents and their terminal sessions
   kill <id>... | --all kill terminal sessions (an id prefix is enough)
@@ -5470,7 +6569,10 @@ Options:
   --allow-anonymous    up: skip the sign-in, the pairing token alone grants access
                        (alias --no-auth)
   --web                up: also run \`code tunnel\` and print a vscode.dev link that opens
-                       this folder in VS Code in the browser (needs VS Code's \`code\`)`;
+                       this folder in VS Code in the browser (needs VS Code's \`code\`)
+  --no-lan             up: don't let phones on the same network connect directly (over TLS,
+                       still with the token); they use the tunnel. "lan": false in
+                       ~/.coderemote/config.json makes it the default, --lan overrides that`;
 var HELP_FLAGS = ["help", "--help", "-help", "-h"];
 var argv = process.argv.slice(2);
 var [cmd, ...rest] = argv.length === 0 || argv.some((a) => HELP_FLAGS.includes(a)) ? ["help"] : argv.some((a) => a === "--version" || a === "-v") ? ["version"] : argv;
@@ -5480,9 +6582,9 @@ var flag = (name) => {
 };
 var anonymous = rest.includes("--allow-anonymous") || rest.includes("--no-auth");
 var port = flag("--port") ? parseInt(flag("--port"), 10) : DEFAULT_PORT;
-var root = path16.resolve(flag("--root") ?? process.cwd());
+var root = path19.resolve(flag("--root") ?? process.cwd());
 var cfg = loadConfig();
-var registry = new AgentRegistry(path16.join(CONFIG_DIR, "agents"));
+var registry = new AgentRegistry(path19.join(CONFIG_DIR, "agents"));
 async function start({ tunnel }) {
   const agents = registry.list();
   if (flag("--port")) {
@@ -5517,7 +6619,7 @@ async function start({ tunnel }) {
   const preview2 = tunnel ? new PreviewTunnel({
     devtunnel,
     command: () => DEVTUNNEL,
-    description: `coderemote preview ${os7.hostname()}`,
+    description: `coderemote preview ${os9.hostname()}`,
     leftover: cfg.previewTunnels?.[port],
     remember: (id) => {
       cfg.previewTunnels = { ...cfg.previewTunnels, [port]: id };
@@ -5537,9 +6639,21 @@ async function start({ tunnel }) {
       if (forgetTunnel(saved, id)) saveConfig(saved);
     }
   }) : null;
+  const lanWanted = tunnel && (rest.includes("--no-lan") ? false : rest.includes("--lan") || cfg.lan !== false);
+  let lanCert = null;
+  let lan = { off: true };
+  if (lanWanted) {
+    const got = await lanCertificate(LAN_DIR);
+    if (got.error) lan = { error: got.error };
+    else lanCert = got;
+  }
+  const hadAgentId = cfg.agentIds?.[port];
+  const agentId = ensureAgentId(cfg, port);
+  if (agentId !== hadAgentId) saveConfig(cfg);
+  let hostedUrl = null;
   spinner.start("Starting agent");
   try {
-    server = await listen(cfg.token, port, root, tunnelToken, preview2, status2, remover);
+    server = await listen(cfg.token, port, root, tunnelToken, preview2, status2, remover, lanCert, agentId, () => hostedUrl);
   } catch (e) {
     spinner.fail();
     if (e.code !== "EADDRINUSE") throw e;
@@ -5548,35 +6662,105 @@ async function start({ tunnel }) {
     console.error("Stop that process, or pick another port with --port.");
     process.exit(1);
   }
+  let advertiser = null;
+  let firewall = null;
+  if (lanCert) {
+    lan = await openLan(server, port);
+    if (lan.port) advertiser = advertiseLan(lan.port, lanCert.fingerprint, port);
+    if (lan.port && isWindows) {
+      const lanPort = lan.port;
+      firewall = firewallReport().then((report) => firewallAdvice(report, { lanPort, adapters: lanAdapters(os9.networkInterfaces()) }));
+    }
+  }
   let child;
   let access;
   let url = `http://127.0.0.1:${port}`;
-  if (tunnel) {
-    spinner.succeed();
+  let later = null;
+  async function connectTunnel({ interactive }) {
     await resolveDevtunnel();
-    spinner.start("Checking dev tunnels sign-in");
-    const user = await tunnelUser();
+    if (interactive) spinner.start("Checking dev tunnels sign-in");
+    let user;
+    if (interactive) user = await tunnelUser();
+    else {
+      user = signedInUser(await devtunnel("user", "show"));
+      if (!user) throw new NotSignedIn();
+    }
     account = user;
-    spinner.succeed();
-    spinner.start("Connecting to the relay");
+    if (interactive) {
+      spinner.succeed();
+      spinner.start("Connecting to the relay");
+    }
     const known = cfg.tunnels?.[port];
     let hosting = known ? hostTunnel(known, port) : null;
     hosting?.catch(() => {
     });
-    tunnelId = await ensureTunnel(cfg, port, anonymous);
-    if (tunnelId !== known) {
+    let id;
+    try {
+      id = await ensureTunnel(cfg, port, anonymous);
+    } catch (e) {
       hosting?.then((h) => h.child.kill(), () => {
       });
-      hosting = hostTunnel(tunnelId, port);
+      throw e;
     }
-    ({ child, url } = await hosting);
+    if (id !== known) {
+      hosting?.then((h) => h.child.kill(), () => {
+      });
+      hosting = hostTunnel(id, port);
+    }
+    const hosted = await hosting;
+    tunnelId = id;
+    child = hosted.child;
+    url = hosted.url;
+    hostedUrl = url;
+    status2?.invalidate?.();
+    if (rememberTunnelUrl(cfg, port, url)) saveConfig(cfg);
     access = anonymous ? "anyone with the link (no sign-in, --allow-anonymous)" : `sign-in required as ${user}`;
+    return url;
+  }
+  let offline = false;
+  if (tunnel) {
+    spinner.succeed();
+    if (lan.port) {
+      spinner.start("Checking the internet");
+      offline = !await relayReachable();
+    }
+    if (!offline) {
+      try {
+        await connectTunnel({ interactive: true });
+      } catch (e) {
+        spinner.fail();
+        if (e.code !== "ETUNNELLIMIT") throw e;
+        console.error(`
+${e.message}`);
+        process.exit(1);
+      }
+    } else {
+      spinner.fail();
+      url = cfg.tunnelUrls?.[port] ?? null;
+      later = retryTunnel({
+        reachable: () => relayReachable(),
+        connect: () => connectTunnel({ interactive: false }),
+        onSignedOut: () => console.log("\n  Internet is back, but no one is signed in to dev tunnels: run `coderemote login`."),
+        onError: (e) => console.log(`
+  Couldn't connect the tunnel yet (${e.message.split("\n")[0]}); retrying.`)
+      });
+      later.done.then((connected) => {
+        registry.register({ port, root, url: connected });
+        console.log(`
+  Tunnel connected: ${connected}`);
+        console.log(`  Web:  ${webUrl({ url: connected, token: cfg.token })}`);
+        console.log("  Phones paired on this network pick it up on their own; sign in on them to use it away from here.\n");
+      });
+    }
   }
   spinner.succeed();
-  registry.register({ port, root, url });
+  registry.register({ port, root, url: url ?? `http://127.0.0.1:${port}` });
   const shutdown = async () => {
+    later?.stop();
     child?.kill();
+    advertiser?.kill();
     await preview2?.close();
+    server.saveAgentSessions();
     await server.killAllSessions();
     server.close();
     process.exit(0);
@@ -5585,10 +6769,16 @@ async function start({ tunnel }) {
   process.on("SIGTERM", shutdown);
   process.on("SIGHUP", shutdown);
   process.on("exit", () => {
+    later?.stop();
     child?.kill();
+    advertiser?.kill();
     preview2?.stop();
   });
-  return { url, access };
+  const lanLink = lan.port ? {
+    agentId,
+    lan: offline ? { port: lan.port, addresses: qrAddresses(lanAddresses()), fingerprint: lanCert.fingerprint } : null
+  } : null;
+  return { url, access, lan, offline, lanLink, firewall };
 }
 var PLUGIN = "coderemote@coderemote";
 async function claudeCli(...args) {
@@ -5709,7 +6899,7 @@ function currentAgent() {
   const agents = registry.list();
   if (flag("--port")) return agents.find((a) => a.port === port);
   const here = process.cwd();
-  const containing = agents.filter((a) => here === a.root || here.startsWith(a.root + path16.sep)).sort((a, b) => b.root.length - a.root.length);
+  const containing = agents.filter((a) => here === a.root || here.startsWith(a.root + path19.sep)).sort((a, b) => b.root.length - a.root.length);
   return containing[0] ?? (agents.length === 1 ? agents[0] : void 0);
 }
 async function previewPorts(agent, given) {
@@ -5775,11 +6965,27 @@ Token: ${cfg.token}`);
       spinner.fail();
       throw e;
     }
-    const { url, access } = started;
-    const vscodeUrl = rest.includes("--web") ? await startVSCodeTunnel() : null;
+    const { url, access, lan, offline, lanLink, firewall } = started;
+    const vscodeUrl = rest.includes("--web") && !offline ? await startVSCodeTunnel() : null;
     console.log(`
   Sharing: ${root}`);
-    printPairing(url, cfg.token, access, vscodeUrl);
+    if (offline) console.log("  Tunnel:  not connected (no internet); phones on this network can pair and connect. It connects on its own once the internet is back.");
+    if (lan.port) {
+      console.log(`  LAN:     on (port ${lan.port}); phones on this network connect directly`);
+      if (process.platform === "darwin") console.log("           If macOS asks whether node may accept incoming connections, choose Allow.");
+      if (isWindows) console.log("           If Windows asks whether node may accept incoming connections, choose Allow (Private networks).");
+    } else if (lan.error) console.log(`  LAN:     off (${lan.error}); phones connect through the tunnel`);
+    const showFirewall = (lines) => {
+      if (lines.length) console.log(`
+${lines.map((l) => `  ${l}`).join("\n")}
+`);
+    };
+    let firewallLines = null;
+    firewall?.then((lines) => firewallLines = lines);
+    await new Promise((r) => setImmediate(r));
+    if (firewallLines) showFirewall(firewallLines);
+    else firewall?.then(showFirewall);
+    printPairing(url, cfg.token, access, vscodeUrl, lanLink);
     const newer = await update;
     if (newer) {
       const c = (code, s) => process.stdout.isTTY ? `\x1B[${code}m${s}\x1B[0m` : s;
@@ -5845,8 +7051,9 @@ Token: ${cfg.token}`);
     break;
   }
   case "rotate-token": {
-    cfg.token = randomBytes4(32).toString("base64url");
+    cfg.token = randomBytes6(32).toString("base64url");
     saveConfig(cfg);
+    fs22.rmSync(LAN_DIR, { recursive: true, force: true });
     const agents = registry.list();
     for (const agent of agents) {
       stopAgent(agent.pid);
@@ -5918,7 +7125,7 @@ Token: ${cfg.token}`);
       console.log(`coderemote ${VERSION} is the latest version.`);
       break;
     }
-    const [command, args] = installCommand(fs19.realpathSync(process.argv[1]));
+    const [command, args] = installCommand(fs22.realpathSync(process.argv[1]));
     console.log(`Updating coderemote ${VERSION} \u2192 ${latest}: ${command} ${args.join(" ")}
 `);
     const code = await new Promise((resolve) => {