leglas 1.3.0 → 1.4.0

package/dist/bin.js

@@ -5,20 +5,85 @@ import { spawn as spawn6 } from "child_process";
 import { createRequire as createRequire2 } from "module";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
+// src/rules.ts
+var MIN_PORT = 1;
+var MAX_PORT = 65535;
+var MIN_SHOW_WIDTH = 320;
+var MAX_SHOW_WIDTH = 3840;
+var DEFAULT_EXPLORE_COUNT = 3;
+var DEFAULT_SHARE_REACH = "open";
+function portRefusal(flag, port) {
+  return port < MIN_PORT || port > MAX_PORT ? `${flag} must be between ${MIN_PORT} and ${MAX_PORT}, received ${port}.` : null;
+}
+function valueRefusal(flag) {
+  return `${flag} needs a value.`;
+}
+function addRefusal(preview) {
+  const texts = [
+    ["--title", preview.title],
+    ["--url", preview.url],
+    ["--note", preview.note],
+    ["--branch", preview.branch],
+    ["--file", preview.file],
+    ["--based-on", preview.basedOn],
+    ["--asked-for", preview.askedFor],
+    ...(preview.tags ?? []).map((tag) => ["--tag", tag])
+  ];
+  const empty = texts.find(([, value]) => value === "");
+  if (empty !== void 0) return valueRefusal(empty[0]);
+  if (preview.url === void 0 && preview.file === void 0) {
+    return "leglas add needs --url (for example --url '/?v-hero=aurora') or --file for a page Leglas serves itself.";
+  }
+  return null;
+}
+function shareRefusal(options) {
+  const acts = [
+    options.stop && "--stop ends the share",
+    options.rotate === true && "--rotate replaces every link",
+    options.revoke !== void 0 && options.revoke !== null && "--revoke ends one link"
+  ].filter((act2) => act2 !== false);
+  if (acts.length > 1) {
+    return "leglas share takes one of --stop, --rotate or --revoke at a time.";
+  }
+  const [act] = acts;
+  if (act !== void 0 && (options.titles.length > 0 || options.reach !== void 0 || options.tunnel !== null)) {
+    return `leglas share ${act}; it takes no directions, reach or tunnel.`;
+  }
+  if (options.titles.length > 2) {
+    return "leglas share takes one direction to share alone, or two to compare. Name none to share the rail.";
+  }
+  return null;
+}
+function linkRefusal(titles) {
+  return titles.length > 2 ? "leglas link takes one direction, or two to put side by side. Name none for the rail." : null;
+}
+function widthRefusal(width) {
+  return width < MIN_SHOW_WIDTH || width > MAX_SHOW_WIDTH ? `--width must be between ${MIN_SHOW_WIDTH} and ${MAX_SHOW_WIDTH}, received ${width}.` : null;
+}
+function showRefusal(options) {
+  if (options.width !== null && !options.screenshot) {
+    return "leglas show --width needs --screenshot.";
+  }
+  if (options.port !== null && !options.screenshot) {
+    return "leglas show --port needs --screenshot.";
+  }
+  return null;
+}
+function fromRefusal(from) {
+  return from === "" ? "--from needs a path, for example --from src/Hero.tsx" : null;
+}
+
 // src/args.ts
 var SHARE_TUNNELS = ["cloudflared", "ngrok", "none"];
 var VALUE_FLAGS = /* @__PURE__ */ new Set(["--port", "--user-port", "--config"]);
 var BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["--no-open", "--json"]);
-var MIN_SHOW_WIDTH = 320;
-var MAX_SHOW_WIDTH = 3840;
 function parsePort(flag, raw) {
   if (!/^\d+$/.test(raw)) {
     return { error: `${flag} needs a number, received ${JSON.stringify(raw)}.` };
   }
   const port = Number(raw);
-  if (port < 1 || port > 65535) {
-    return { error: `${flag} must be between 1 and 65535, received ${port}.` };
-  }
+  const refusal = portRefusal(flag, port);
+  if (refusal !== null) return { error: refusal };
   return { port };
 }
 function parseNew(rest) {
@@ -30,9 +95,8 @@ function parseNew(rest) {
     const argument = rest[index];
     if (argument === "--from" || argument.startsWith("--from=")) {
       from = argument.includes("=") ? argument.split("=").slice(1).join("=") : rest[index += 1];
-      if (from === void 0 || from === "") {
-        return { kind: "error", message: "--from needs a path, for example --from src/Hero.tsx" };
-      }
+      const refusal = fromRefusal(from ?? "");
+      if (refusal !== null) return { kind: "error", message: refusal };
       continue;
     }
     if (argument === "--print") {
@@ -100,7 +164,7 @@ function parseAdd(rest) {
       return { kind: "error", message: `leglas add does not take ${flag}.` };
     }
     if (value === void 0 || value === "") {
-      return { kind: "error", message: `${flag} needs a value.` };
+      return { kind: "error", message: valueRefusal(flag) };
     }
     if (flag === "--title") title = value;
     else if (flag === "--url") url = value;
@@ -117,26 +181,19 @@ function parseAdd(rest) {
       message: "leglas add needs --title, which is how the preview is identified."
     };
   }
-  if (url === void 0 && file === void 0) {
-    return {
-      kind: "error",
-      message: "leglas add needs --url (for example --url '/?v-hero=aurora') or --file for a page Leglas serves itself."
-    };
-  }
-  return {
-    kind: "add",
-    preview: {
-      title,
-      url,
-      note,
-      tags: tags.length > 0 ? tags : void 0,
-      branch,
-      file,
-      basedOn,
-      askedFor
-    },
-    json
+  const preview = {
+    title,
+    url,
+    note,
+    tags: tags.length > 0 ? tags : void 0,
+    branch,
+    file,
+    basedOn,
+    askedFor
   };
+  const refusal = addRefusal(preview);
+  if (refusal !== null) return { kind: "error", message: refusal };
+  return { kind: "add", preview, json };
 }
 function parseClassify(rest) {
   const changes = [];
@@ -185,7 +242,7 @@ function parseWatch(rest) {
     if (value === void 0 || value === "") {
       return {
         kind: "error",
-        message: flag === "--run" ? '--run needs an agent command, for example --run "claude -p {prompt}"' : "--port needs a value."
+        message: flag === "--run" ? '--run needs an agent command, for example --run "claude -p {prompt}"' : valueRefusal(flag)
       };
     }
     if (flag === "--run") {
@@ -200,10 +257,12 @@ function parseWatch(rest) {
 }
 function parseShare(rest) {
   const titles = [];
-  let reach = "open";
+  let reach = DEFAULT_SHARE_REACH;
   let reachGiven = false;
   let tunnel = null;
   let stop = false;
+  let rotate = false;
+  let revoke = null;
   let port = null;
   let json = false;
   for (let index = 0; index < rest.length; index += 1) {
@@ -216,12 +275,22 @@ function parseShare(rest) {
       stop = true;
       continue;
     }
+    if (argument === "--rotate") {
+      rotate = true;
+      continue;
+    }
     const equals = argument.indexOf("=");
     const flag = equals === -1 ? argument : argument.slice(0, equals);
+    if (flag === "--revoke") {
+      const raw = equals === -1 ? rest[index += 1] : argument.slice(equals + 1);
+      if (raw === void 0 || raw === "") return { kind: "error", message: valueRefusal(flag) };
+      revoke = raw;
+      continue;
+    }
     if (flag === "--reach" || flag === "--tunnel" || flag === "--port") {
       const raw = equals === -1 ? rest[index += 1] : argument.slice(equals + 1);
       if (raw === void 0 || raw === "") {
-        return { kind: "error", message: `${flag} needs a value.` };
+        return { kind: "error", message: valueRefusal(flag) };
       }
       if (flag === "--port") {
         const parsed2 = parsePort(flag, raw);
@@ -255,19 +324,45 @@ function parseShare(rest) {
     }
     titles.push(argument);
   }
-  if (stop && (titles.length > 0 || reachGiven || tunnel !== null)) {
-    return {
-      kind: "error",
-      message: "leglas share --stop ends the share; it takes no directions, reach or tunnel."
-    };
-  }
-  if (titles.length > 2) {
-    return {
-      kind: "error",
-      message: "leglas share takes one direction to share alone, or two to compare. Name none to share the rail."
-    };
+  const refusal = shareRefusal({
+    titles,
+    reach: reachGiven ? reach : void 0,
+    tunnel,
+    stop,
+    rotate,
+    revoke
+  });
+  if (refusal !== null) return { kind: "error", message: refusal };
+  return { kind: "share", titles, reach, tunnel, stop, rotate, revoke, port, json };
+}
+function parseLink(rest) {
+  const titles = [];
+  let port = null;
+  let json = false;
+  for (let index = 0; index < rest.length; index += 1) {
+    const argument = rest[index];
+    if (argument === "--json") {
+      json = true;
+      continue;
+    }
+    const equals = argument.indexOf("=");
+    const flag = equals === -1 ? argument : argument.slice(0, equals);
+    if (flag === "--port") {
+      const raw = equals === -1 ? rest[index += 1] : argument.slice(equals + 1);
+      if (raw === void 0 || raw === "") return { kind: "error", message: valueRefusal(flag) };
+      const parsed2 = parsePort(flag, raw);
+      if ("error" in parsed2) return { kind: "error", message: parsed2.error };
+      port = parsed2.port;
+      continue;
+    }
+    if (argument.startsWith("-")) {
+      return { kind: "error", message: `leglas link does not take ${argument}.` };
+    }
+    titles.push(argument);
   }
-  return { kind: "share", titles, reach, tunnel, stop, port, json };
+  const refusal = linkRefusal(titles);
+  if (refusal !== null) return { kind: "error", message: refusal };
+  return { kind: "link", titles, port, json };
 }
 function parseArgs(argv) {
   const [command] = argv;
@@ -332,7 +427,7 @@ function parseArgs(argv) {
   if (argv[0] === "explore") {
     const rest = argv.slice(1);
     let surface;
-    let count = 3;
+    let count = DEFAULT_EXPLORE_COUNT;
     let basedOn = null;
     let json = false;
     let build = false;
@@ -465,7 +560,7 @@ function parseArgs(argv) {
         const flag = equals === -1 ? argument : argument.slice(0, equals);
         const raw = equals === -1 ? rest[index += 1] : argument.slice(equals + 1);
         if (raw === void 0 || raw === "") {
-          return { kind: "error", message: `${flag} needs a value.` };
+          return { kind: "error", message: valueRefusal(flag) };
         }
         if (flag === "--port") {
           const parsed2 = parsePort(flag, raw);
@@ -480,12 +575,8 @@ function parseArgs(argv) {
           };
         }
         width = Number(raw);
-        if (width < MIN_SHOW_WIDTH || width > MAX_SHOW_WIDTH) {
-          return {
-            kind: "error",
-            message: `--width must be between ${MIN_SHOW_WIDTH} and ${MAX_SHOW_WIDTH}, received ${width}.`
-          };
-        }
+        const refusal2 = widthRefusal(width);
+        if (refusal2 !== null) return { kind: "error", message: refusal2 };
         continue;
       }
       if (argument.startsWith("-")) {
@@ -502,15 +593,27 @@ function parseArgs(argv) {
         message: 'leglas show needs a direction title, for example: npx leglas show "Aurora" --json'
       };
     }
-    if (width !== null && !screenshot) {
-      return { kind: "error", message: "leglas show --width needs --screenshot." };
-    }
-    if (port !== null && !screenshot) {
-      return { kind: "error", message: "leglas show --port needs --screenshot." };
-    }
+    const refusal = showRefusal({ screenshot, width, port });
+    if (refusal !== null) return { kind: "error", message: refusal };
     return { kind: "show", title, json, screenshot, width, port };
   }
   if (argv[0] === "share") return parseShare(argv.slice(1));
+  if (argv[0] === "link") return parseLink(argv.slice(1));
+  if (argv[0] === "remove") {
+    const rest = argv.slice(1);
+    const unknown = rest.find((argument) => argument.startsWith("-") && argument !== "--json");
+    if (unknown !== void 0) {
+      return { kind: "error", message: `leglas remove does not take ${unknown}.` };
+    }
+    const titles = rest.filter((argument) => argument !== "--json");
+    if (titles.length === 0) {
+      return {
+        kind: "error",
+        message: 'leglas remove needs a direction title, for example: npx leglas remove "Aurora"'
+      };
+    }
+    return { kind: "remove", titles, json: rest.includes("--json") };
+  }
   const options = {
     port: void 0,
     userPort: void 0,
@@ -543,7 +646,7 @@ function parseArgs(argv) {
       value = argument.slice(equals + 1);
     }
     if (value === void 0 || value === "" || value.startsWith("--")) {
-      return { kind: "error", message: `${flag} needs a value.` };
+      return { kind: "error", message: valueRefusal(flag) };
     }
     if (flag === "--config") {
       options.configPath = value;
@@ -559,7 +662,7 @@ function parseArgs(argv) {
 
 // src/run-classify.ts
 import { stat as stat5 } from "fs/promises";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 
 // ../server/dist/log.js
 var DEFAULT_LOG_DIR = "design-log";
@@ -788,13 +891,18 @@ function normalizeConfig(raw, options = {}) {
   if (!isBoolean(scanPreviews)) {
     errors.push("scanPreviews must be a boolean.");
   }
-  if (errors.length > 0 || !isString(devServer) || !isBoolean(scanPreviews) || !isString(installCommand) || !isString(logDir))
+  const recordSets = source["recordSets"] ?? true;
+  if (!isBoolean(recordSets)) {
+    errors.push("recordSets must be a boolean.");
+  }
+  if (errors.length > 0 || !isString(devServer) || !isBoolean(scanPreviews) || !isBoolean(recordSets) || !isString(installCommand) || !isString(logDir))
     return { config: null, errors };
   return {
     config: {
       devServer,
       previews,
       scanPreviews,
+      recordSets,
       devCommand: isString(devCommand) ? devCommand : void 0,
       installCommand,
       logDir
@@ -887,9 +995,9 @@ function nextRequest(requests, failed) {
 
 // ../server/dist/agents/agents.js
 import { spawn } from "child_process";
-import { constants, readdirSync } from "fs";
+import { constants, readdirSync, realpathSync } from "fs";
 import { access, mkdir, readFile, writeFile } from "fs/promises";
-import { delimiter, dirname, isAbsolute, join, relative } from "path";
+import { delimiter, dirname, isAbsolute, join, normalize, relative } from "path";
 var AGENT_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
 var effortFlag = (effort) => effort === null ? [] : ["--effort", effort];
 var codexEffortConfig = (effort) => effort === null ? [] : ["-c", `model_reasoning_effort=${effort}`];
@@ -1040,13 +1148,15 @@ var KNOWN_AGENTS = {
     // the earlier turn.
     activityVerified: true,
     authArgs: ["status"],
-    // The signed-in form was read from the CLI: "✓ Logged in as <email>",
-    // exit 0. The signed-out form has not been, so that side of the reading
-    // stays loose, and anything ambiguous stays unknown.
+    // Both answers read from cursor-agent 2026.09.02, and both exit 0: "✓ Logged
+    // in as <email>" and "Not logged in". The second contains the first's
+    // words, so a "not logged in" or "not signed in" is read first.
     authVerdict: (result) => {
+      if (/not (logged|signed) in/i.test(result.stdout))
+        return "signed-out";
       if (/logged in|signed in/i.test(result.stdout))
         return "ok";
-      if (result.code !== 0 || /not logged in|log in|sign in/i.test(result.stdout))
+      if (result.code !== 0 || /log in|sign in/i.test(result.stdout))
         return "signed-out";
       return "unknown";
     }
@@ -1266,6 +1376,45 @@ function cursorActivity(event, cwd) {
   const path = shownPath(args?.path, cwd);
   return path === null ? `using ${tool}` : `using ${tool} on ${path}`;
 }
+function editedFiles(agent, line, cwd) {
+  let event;
+  try {
+    event = record(parseJson(line));
+  } catch {
+    return [];
+  }
+  const paths = [];
+  if (agent === "claude" && event?.type === "assistant") {
+    const content = record(event.message)?.content;
+    for (const rawBlock of Array.isArray(content) ? content : []) {
+      const block = record(rawBlock);
+      const input = record(block?.input);
+      if (block?.type === "tool_use" && isString(block.name) && ["Edit", "Write", "MultiEdit", "NotebookEdit"].includes(block.name))
+        paths.push(input?.file_path ?? input?.notebook_path ?? null);
+    }
+  }
+  if (agent === "codex" && (event?.type === "item.started" || event?.type === "item.completed") && record(event.item)?.type === "file_change") {
+    const item = record(event.item);
+    for (const change of Array.isArray(item?.changes) ? item.changes : [])
+      paths.push(record(change)?.path ?? null);
+    paths.push(item?.path ?? null);
+  }
+  if (paths.length === 0)
+    return [];
+  let root = cwd;
+  try {
+    root = realpathSync(cwd);
+  } catch {
+  }
+  return paths.flatMap((path) => {
+    if (!isString(path) || path === "")
+      return [];
+    if (!isAbsolute(path))
+      return [normalize(path)];
+    const shown = [relative(cwd, path), relative(root, path)].find((form) => !form.startsWith(".."));
+    return [normalize(shown ?? path)];
+  });
+}
 function activityFrom(agent, line, cwd = process.cwd()) {
   let event;
   try {
@@ -1491,9 +1640,21 @@ async function loadConfig(cwd) {
 }
 
 // ../server/dist/config/local-previews.js
-import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { randomUUID } from "crypto";
+import { mkdir as mkdir2, readFile as readFile3, rename, rm, writeFile as writeFile2 } from "fs/promises";
 import { dirname as dirname3, join as join3 } from "path";
 var LOCAL_PREVIEWS_PATH = ".leglas/previews.json";
+async function writeRegistry(path, stored) {
+  await mkdir2(dirname3(path), { recursive: true });
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  await writeFile2(temporary, `${JSON.stringify({ previews: stored }, null, 2)}
+`, "utf8");
+  await rename(temporary, path).catch(async (cause) => {
+    await rm(temporary, { force: true }).catch(() => {
+    });
+    throw cause;
+  });
+}
 async function readLocalPreviews(cwd) {
   const path = join3(cwd, LOCAL_PREVIEWS_PATH);
   let raw;
@@ -1565,10 +1726,10 @@ async function addLocalPreview(cwd, input, shared) {
   if (check.config === null) {
     return { ok: false, error: check.errors.join(" ") };
   }
-  const path = join3(cwd, LOCAL_PREVIEWS_PATH);
-  await mkdir2(dirname3(path), { recursive: true });
-  await writeFile2(path, `${JSON.stringify({ previews: [...existing.previews.map(toStored), candidate] }, null, 2)}
-`, "utf8");
+  await writeRegistry(join3(cwd, LOCAL_PREVIEWS_PATH), [
+    ...existing.previews.map(toStored),
+    candidate
+  ]);
   return { ok: true };
 }
 function toStored(preview) {
@@ -1580,13 +1741,127 @@ async function dropLocalPreviews(cwd, titles) {
   const keep = existing.previews.filter((preview) => !titles.includes(preview.title));
   if (keep.length === existing.previews.length)
     return 0;
-  const path = join3(cwd, LOCAL_PREVIEWS_PATH);
-  await mkdir2(dirname3(path), { recursive: true });
-  await writeFile2(path, `${JSON.stringify({ previews: keep.map(toStored) }, null, 2)}
-`, "utf8");
+  await writeRegistry(join3(cwd, LOCAL_PREVIEWS_PATH), keep.map(toStored));
   return existing.previews.length - keep.length;
 }
 
+// ../server/dist/generation/record.js
+import { randomUUID as randomUUID2 } from "crypto";
+import { appendFile, mkdir as mkdir3, readdir, readFile as readFile4, rename as rename2, rm as rm2, writeFile as writeFile3 } from "fs/promises";
+import { join as join4 } from "path";
+var RECORDS_DIR = ".leglas/generations";
+var KEPT_RECORDS = 100;
+async function recordIds(cwd) {
+  const names = await readdir(join4(cwd, RECORDS_DIR)).catch(() => []);
+  const started = (id) => Number.parseInt(id.slice(4), 36);
+  return names.filter((name) => /^gen-[a-z0-9]+$/.test(name)).sort((a, b) => started(b) - started(a));
+}
+async function directionsOf(cwd, id) {
+  let parsed2;
+  try {
+    parsed2 = parseJson(await readFile4(join4(cwd, RECORDS_DIR, id, "set.json"), "utf8"));
+  } catch {
+    return [];
+  }
+  if (!isJsonRecord(parsed2) || !Array.isArray(parsed2.directions))
+    return [];
+  return parsed2.directions.flatMap((direction) => {
+    if (!isJsonRecord(direction) || !isString(direction.key))
+      return [];
+    const attempts2 = Array.isArray(direction.attempts) ? direction.attempts : [];
+    const last = attempts2.at(-1);
+    return [
+      {
+        key: direction.key,
+        title: isJsonRecord(last) && isString(last.title) ? last.title : null
+      }
+    ];
+  });
+}
+async function appendEvent(cwd, id, event) {
+  const dir = join4(cwd, RECORDS_DIR, id);
+  await mkdir3(dir, { recursive: true });
+  await appendFile(join4(dir, "events.jsonl"), `${JSON.stringify(event)}
+`, "utf8");
+}
+async function setsOfTitles(cwd, titles) {
+  const found = /* @__PURE__ */ new Map();
+  for (const id of await recordIds(cwd)) {
+    if (found.size === titles.length)
+      break;
+    for (const direction of await directionsOf(cwd, id)) {
+      const title = direction.title;
+      if (title !== null && titles.includes(title) && !found.has(title))
+        found.set(title, { id, key: direction.key });
+    }
+  }
+  return found;
+}
+async function setOfKey(cwd, key) {
+  for (const id of await recordIds(cwd)) {
+    if ((await directionsOf(cwd, id)).some((each) => each.key === key))
+      return id;
+  }
+  return null;
+}
+async function noteDirections(cwd, titles, kind, detail) {
+  const unique = [...new Set(titles)];
+  const found = await setsOfTitles(cwd, unique).catch(() => /* @__PURE__ */ new Map());
+  for (const title of unique) {
+    const set = found.get(title);
+    if (set === void 0)
+      continue;
+    const event = { at: Date.now(), kind, direction: set.key };
+    if (detail !== void 0)
+      event.detail = detail;
+    await appendEvent(cwd, set.id, event).catch(() => {
+    });
+  }
+}
+function createRecords(cwd) {
+  let queue = Promise.resolve();
+  const enqueue = (task) => {
+    queue = queue.then(task).catch(() => {
+    });
+  };
+  return {
+    async prune() {
+      const ids = await recordIds(cwd);
+      for (const id of ids.slice(KEPT_RECORDS - 1)) {
+        await rm2(join4(cwd, RECORDS_DIR, id), { recursive: true, force: true }).catch(() => {
+        });
+      }
+    },
+    save(record3) {
+      const body = `${JSON.stringify(record3, null, 2)}
+`;
+      enqueue(async () => {
+        const dir = join4(cwd, RECORDS_DIR, record3.id);
+        const path = join4(dir, "set.json");
+        const temporary = `${path}.${randomUUID2()}.tmp`;
+        await mkdir3(dir, { recursive: true });
+        await writeFile3(temporary, body, "utf8");
+        await rename2(temporary, path).catch(async (cause) => {
+          await rm2(temporary, { force: true }).catch(() => {
+          });
+          throw cause;
+        });
+      });
+    },
+    picture(id, name, image) {
+      enqueue(async () => {
+        const dir = join4(cwd, RECORDS_DIR, id);
+        await mkdir3(dir, { recursive: true });
+        await writeFile3(join4(dir, name), image);
+      });
+    },
+    event(id, event) {
+      enqueue(() => appendEvent(cwd, id, event));
+    },
+    flush: () => queue
+  };
+}
+
 // ../server/dist/proxy.js
 import http, {} from "http";
 import net from "net";
@@ -1755,9 +2030,9 @@ import { randomBytes } from "crypto";
 import nodeProcess from "process";
 import { spawn as nodeSpawn } from "child_process";
 import { accessSync, constants as constants2, existsSync as existsSync2, mkdirSync, readdirSync as readdirSync2, writeFileSync } from "fs";
-import { readFile as readFile4, readdir, rm, stat } from "fs/promises";
+import { readFile as readFile5, readdir as readdir2, rm as rm3, stat } from "fs/promises";
 import { homedir, tmpdir as osTmpdir } from "os";
-import { delimiter as delimiter2, join as join4 } from "path";
+import { delimiter as delimiter2, join as join5 } from "path";
 var NO_BROWSER = "No Chrome, Chromium, Brave or Edge was found on this machine, so Leglas could not take a screenshot. On a machine with no browser at all, `npx playwright install chromium` puts one where Leglas will find it. Set LEGLAS_BROWSER to point at a specific binary.";
 var DARWIN_APPS = [
   "Google Chrome.app/Contents/MacOS/Google Chrome",
@@ -1790,7 +2065,7 @@ function firstOnPath(name, env) {
   for (const directory of (env.PATH ?? "").split(delimiter2)) {
     if (directory === "")
       continue;
-    const candidate = join4(directory, name);
+    const candidate = join5(directory, name);
     try {
       accessSync(candidate, constants2.X_OK);
       return candidate;
@@ -1828,17 +2103,17 @@ function buildNumber(entry) {
   const digits = /(\d+)\s*$/.exec(entry)?.[1];
   return digits === void 0 ? 0 : Number(digits);
 }
-function cacheRoots(platform, home, readdir7 = readableDirectories) {
-  const playwright = platform === "darwin" ? join4(home, "Library", "Caches", "ms-playwright") : join4(home, ".cache", "ms-playwright");
-  const puppeteer = join4(home, ".cache", "puppeteer");
+function cacheRoots(platform, home, readdir8 = readableDirectories) {
+  const playwright = platform === "darwin" ? join5(home, "Library", "Caches", "ms-playwright") : join5(home, ".cache", "ms-playwright");
+  const puppeteer = join5(home, ".cache", "puppeteer");
   const newestFirst = (dir, keep = () => true) => ({
     root: dir,
-    entries: readdir7(dir).filter(keep).sort((left, right) => buildNumber(right) - buildNumber(left))
+    entries: readdir8(dir).filter(keep).sort((left, right) => buildNumber(right) - buildNumber(left))
   });
   return [
     newestFirst(playwright, (entry) => entry.startsWith("chromium-") || entry.startsWith("chromium_headless_shell-")),
-    newestFirst(join4(puppeteer, "chrome-headless-shell")),
-    newestFirst(join4(puppeteer, "chrome"))
+    newestFirst(join5(puppeteer, "chrome-headless-shell")),
+    newestFirst(join5(puppeteer, "chrome"))
   ];
 }
 function readableDirectories(dir) {
@@ -1854,18 +2129,18 @@ function findBrowser(search = {}) {
   const home = search.home ?? homedir();
   const exists = search.exists ?? existsSync2;
   const onPath = search.onPath ?? ((name) => firstOnPath(name, env));
-  const readdir7 = search.readdir ?? readableDirectories;
+  const readdir8 = search.readdir ?? readableDirectories;
   const firstExisting = (paths) => paths.find((path) => exists(path)) ?? null;
   for (const candidate of [env.LEGLAS_BROWSER, env.CHROME_PATH, env.PUPPETEER_EXECUTABLE_PATH]) {
     if (isString(candidate) && candidate !== "" && exists(candidate))
       return candidate;
   }
-  const caches = cacheRoots(platform, home, readdir7);
-  const shell = firstExisting(caches.flatMap(({ root, entries }) => entries.flatMap((entry) => HEADLESS_SHELL.map((rest) => join4(root, entry, ...rest)))));
+  const caches = cacheRoots(platform, home, readdir8);
+  const shell = firstExisting(caches.flatMap(({ root, entries }) => entries.flatMap((entry) => HEADLESS_SHELL.map((rest) => join5(root, entry, ...rest)))));
   if (shell !== null)
     return shell;
   if (platform === "darwin") {
-    const installed = firstExisting(["/Applications", join4(home, "Applications")].flatMap((root) => DARWIN_APPS.map((app) => join4(root, app))));
+    const installed = firstExisting(["/Applications", join5(home, "Applications")].flatMap((root) => DARWIN_APPS.map((app) => join5(root, app))));
     if (installed !== null)
       return installed;
   }
@@ -1876,7 +2151,7 @@ function findBrowser(search = {}) {
         return found;
     }
     const installed = firstExisting([
-      ...LINUX_NAMES.flatMap((name) => [join4("/usr/bin", name), join4("/snap/bin", name)]),
+      ...LINUX_NAMES.flatMap((name) => [join5("/usr/bin", name), join5("/snap/bin", name)]),
       "/opt/google/chrome/chrome"
     ]);
     if (installed !== null)
@@ -1884,32 +2159,32 @@ function findBrowser(search = {}) {
   }
   if (platform === "win32") {
     const roots = [env.PROGRAMFILES, env["PROGRAMFILES(X86)"], env.LOCALAPPDATA].filter((entry) => isString(entry) && entry !== "");
-    const installed = firstExisting(roots.flatMap((root) => WINDOWS_BROWSERS.map((browser) => join4(root, browser))));
+    const installed = firstExisting(roots.flatMap((root) => WINDOWS_BROWSERS.map((browser) => join5(root, browser))));
     if (installed !== null)
       return installed;
   }
   if (platform === "darwin" || platform === "linux") {
-    const playwrightRoot = platform === "darwin" ? join4(home, "Library", "Caches", "ms-playwright") : join4(home, ".cache", "ms-playwright");
-    const playwright = readdir7(playwrightRoot).filter((entry) => entry.startsWith("chromium-") || entry.startsWith("chromium_headless_shell-")).sort((left, right) => buildNumber(right) - buildNumber(left)).flatMap((entry) => {
-      const root = join4(playwrightRoot, entry);
+    const playwrightRoot = platform === "darwin" ? join5(home, "Library", "Caches", "ms-playwright") : join5(home, ".cache", "ms-playwright");
+    const playwright = readdir8(playwrightRoot).filter((entry) => entry.startsWith("chromium-") || entry.startsWith("chromium_headless_shell-")).sort((left, right) => buildNumber(right) - buildNumber(left)).flatMap((entry) => {
+      const root = join5(playwrightRoot, entry);
       return [
-        ...FOR_TESTING.map((rest) => join4(root, ...rest)),
-        ...HEADLESS_SHELL.map((rest) => join4(root, ...rest)),
+        ...FOR_TESTING.map((rest) => join5(root, ...rest)),
+        ...HEADLESS_SHELL.map((rest) => join5(root, ...rest)),
         // Older builds shipped a plain Chromium app.
-        join4(root, "chrome-mac-arm64", "Chromium.app", "Contents", "MacOS", "Chromium"),
-        join4(root, "chrome-mac", "Chromium.app", "Contents", "MacOS", "Chromium"),
-        join4(root, "chrome-linux", "chrome")
+        join5(root, "chrome-mac-arm64", "Chromium.app", "Contents", "MacOS", "Chromium"),
+        join5(root, "chrome-mac", "Chromium.app", "Contents", "MacOS", "Chromium"),
+        join5(root, "chrome-linux", "chrome")
       ];
     });
     const playwrightBrowser = firstExisting(playwright);
     if (playwrightBrowser !== null)
       return playwrightBrowser;
-    const puppeteerCache = join4(home, ".cache", "puppeteer");
+    const puppeteerCache = join5(home, ".cache", "puppeteer");
     for (const kind of ["chrome", "chrome-headless-shell"]) {
-      const kindRoot = join4(puppeteerCache, kind);
-      const found = firstExisting(readdir7(kindRoot).sort((left, right) => buildNumber(right) - buildNumber(left)).flatMap((entry) => {
-        const root = join4(kindRoot, entry);
-        return [...FOR_TESTING, ...HEADLESS_SHELL].map((rest) => join4(root, ...rest));
+      const kindRoot = join5(puppeteerCache, kind);
+      const found = firstExisting(readdir8(kindRoot).sort((left, right) => buildNumber(right) - buildNumber(left)).flatMap((entry) => {
+        const root = join5(kindRoot, entry);
+        return [...FOR_TESTING, ...HEADLESS_SHELL].map((rest) => join5(root, ...rest));
       }));
       if (found !== null)
         return found;
@@ -2034,8 +2309,8 @@ async function closeOrphan(url, connect) {
 async function reapOrphanedBrowsers(deps = {}) {
   const root = deps.tmpdir ?? osTmpdir();
   const clock2 = deps.now ?? (() => Date.now());
-  const list = deps.list ?? (async (path) => (await readdir(path, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name));
-  const read = deps.read ?? ((path) => readFile4(path, "utf8"));
+  const list = deps.list ?? (async (path) => (await readdir2(path, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name));
+  const read = deps.read ?? ((path) => readFile5(path, "utf8"));
   const alive = deps.alive ?? livePid;
   const profileOf = deps.profile ?? (async (path) => {
     const entry = await stat(path);
@@ -2044,7 +2319,7 @@ async function reapOrphanedBrowsers(deps = {}) {
   const currentUid = deps.uid ?? (() => nodeProcess.getuid?.() ?? null);
   const connect = deps.connect ?? connectWebSocket;
   const remove = deps.remove ?? (async (path) => {
-    await rm(path, { recursive: true, force: true });
+    await rm3(path, { recursive: true, force: true });
   });
   let names;
   try {
@@ -2057,7 +2332,7 @@ async function reapOrphanedBrowsers(deps = {}) {
   for (const name of names) {
     if (!name.startsWith(PROFILE_PREFIX))
       continue;
-    const directory = join4(root, name);
+    const directory = join5(root, name);
     const details = await profileOf(directory).catch(() => null);
     if (details === null)
       continue;
@@ -2065,7 +2340,7 @@ async function reapOrphanedBrowsers(deps = {}) {
       continue;
     let record3 = null;
     try {
-      const raw = await read(join4(directory, OWNER_FILE));
+      const raw = await read(join5(directory, OWNER_FILE));
       const parsed2 = raw === null ? null : parseJson(raw);
       record3 = isJsonRecord(parsed2) ? parsed2 : null;
     } catch {
@@ -2087,11 +2362,11 @@ async function launchBrowser(executable, options = {}) {
   const spawn7 = options.spawn ?? nodeSpawn;
   const connect = options.connect ?? connectWebSocket;
   const commandTimeoutMs = options.commandTimeoutMs ?? 3e4;
-  const userDataDir = join4(options.tmpdir ?? osTmpdir(), `leglas-browser-${randomBytes(8).toString("hex")}`);
+  const userDataDir = join5(options.tmpdir ?? osTmpdir(), `leglas-browser-${randomBytes(8).toString("hex")}`);
   const owned = (fields) => {
     try {
       mkdirSync(userDataDir, { recursive: true, mode: 448 });
-      writeFileSync(join4(userDataDir, OWNER_FILE), `${JSON.stringify({ owner: nodeProcess.pid, ...fields })}
+      writeFileSync(join5(userDataDir, OWNER_FILE), `${JSON.stringify({ owner: nodeProcess.pid, ...fields })}
 `, { encoding: "utf8", mode: 384 });
     } catch {
     }
@@ -2111,11 +2386,10 @@ async function launchBrowser(executable, options = {}) {
     "--mute-audio",
     "--force-color-profile=srgb",
     "--window-size=1440,900",
-    // Everything a desktop browser does on the way up that a screenshot
-    // does not need. Measured on this project: about 300MB and half a
-    // second off a Chrome launch, and most of the wait off a headless
-    // shell. `--use-mock-keychain` matters most on macOS, where Chrome
-    // otherwise reaches for the login keychain before it will start.
+    // Desktop startup work a screenshot doesn't need. Measured here: about
+    // 300MB and half a second off a Chrome launch, most of the wait off a
+    // headless shell. `--use-mock-keychain` matters most on macOS, where
+    // Chrome otherwise waits on the login keychain.
     "--disable-dev-shm-usage",
     "--disable-breakpad",
     "--disable-client-side-phishing-detection",
@@ -2132,7 +2406,7 @@ async function launchBrowser(executable, options = {}) {
   try {
     websocketUrl = await endpoint(process2, options.startTimeoutMs ?? START_TIMEOUT_MS);
   } catch (error) {
-    await rm(userDataDir, { recursive: true, force: true }).catch(() => {
+    await rm3(userDataDir, { recursive: true, force: true }).catch(() => {
     });
     throw error;
   }
@@ -2142,7 +2416,7 @@ async function launchBrowser(executable, options = {}) {
     socket = await connect(websocketUrl);
   } catch (error) {
     process2.kill("SIGKILL");
-    await rm(userDataDir, { recursive: true, force: true }).catch(() => {
+    await rm3(userDataDir, { recursive: true, force: true }).catch(() => {
     });
     throw error;
   }
@@ -2295,7 +2569,7 @@ async function launchBrowser(executable, options = {}) {
         ]);
       }
       socket.close();
-      await rm(userDataDir, { recursive: true, force: true }).catch(() => {
+      await rm3(userDataDir, { recursive: true, force: true }).catch(() => {
       });
     })();
     return closing;
@@ -2303,8 +2577,8 @@ async function launchBrowser(executable, options = {}) {
   return {
     withPage,
     close,
-    // A socket that went with the process still alive is the same thing to
-    // a caller: nothing can be sent, so the pool must not hand it out again.
+    // A socket gone with the process alive is the same to a caller: the pool
+    // must not hand it out.
     get closed() {
       return processClosed || socketClosed;
     }
@@ -2448,6 +2722,367 @@ function hydrationEvidence(messages) {
   return null;
 }
 
+// ../server/dist/capture/layout.js
+function isEdge(value) {
+  return value === "left" || value === "right" || value === "top" || value === "bottom";
+}
+var LAYOUT_PROBE = `(() => {
+  const OVERLAP_SHARE = 0.05;
+  const OVERLAP_MIN = 1;
+  const CUT_MIN = 3;
+  const CUT_SHARE = 0.08;
+  const LAYERED = 4;
+  const TILT = 6;
+  // Only a page gone wrong everywhere reaches this. The app's own findings are
+  // subtracted after, so a low cap could crowd out a direction's.
+  const LIMIT = 100;
+  const width = window.innerWidth;
+  const states = new Map();
+  const inks = new Map();
+  const context = document.createElement("canvas").getContext("2d");
+
+  // rgba(r, g, b, a), or a / before the alpha in the newer functions
+  // (oklab, oklch, color), which computed colours keep.
+  const alpha = (colour) => {
+    if (colour === "transparent") return 0;
+    const slash = /\\/\\s*([\\d.]+)(%?)\\s*\\)$/.exec(colour || "");
+    if (slash) return parseFloat(slash[1]) / (slash[2] ? 100 : 1);
+    const match = /rgba\\(([^)]+)\\)/.exec(colour || "");
+    const parts = match ? match[1].split(/[\\s,]+/).filter(Boolean) : [];
+    return parts.length > 3 ? parseFloat(parts[3]) : 1;
+  };
+
+  // Degrees this element turns its content by, or Infinity for a skew or a
+  // 3D transform, whose boxes say nothing useful.
+  const angleOf = (a, b, c, d) =>
+    Math.abs(a * c + b * d) > 0.01 ? Infinity : (Math.atan2(b, a) * 180) / Math.PI;
+
+  const turnOf = (element, style) => {
+    let turn = 0;
+    if (style.rotate && style.rotate !== "none") turn += parseFloat(style.rotate) || 0;
+    const transform = style.transform;
+    if (transform && transform !== "none") {
+      if (transform.startsWith("matrix3d")) return Infinity;
+      const [a, b, c, d] = transform.slice(7, -1).split(",").map(Number);
+      turn += angleOf(a, b, c, d);
+    }
+    return turn;
+  };
+
+  const looping = new Set();
+  try {
+    for (const animation of document.getAnimations()) {
+      const timing = animation.effect && animation.effect.getComputedTiming();
+      const target = animation.effect && animation.effect.target;
+      if (timing && timing.iterations === Infinity && target) looping.add(target);
+    }
+  } catch (error) {
+    // An engine without getAnimations; nothing is excluded for it.
+  }
+
+  const stateOf = (element) => {
+    if (states.has(element)) return states.get(element);
+    const style = getComputedStyle(element);
+    const parent = element.parentElement ? stateOf(element.parentElement) : null;
+    const clipsText = /text/.test(style.backgroundClip || "") || /text/.test(style.webkitBackgroundClip || "");
+    const state = {
+      style,
+      opacity: (parent ? parent.opacity : 1) * parseFloat(style.opacity || "1"),
+      turn: element instanceof SVGGraphicsElement && element.getCTM
+        ? (() => {
+            const matrix = element.getCTM();
+            return matrix ? angleOf(matrix.a, matrix.b, matrix.c, matrix.d) + (parent ? parent.turnOutsideSvg : 0) : 0;
+          })()
+        : (parent ? parent.turn : 0) + turnOf(element, style),
+      // An <svg>'s own CSS transform is outside every getCTM beneath it.
+      turnOutsideSvg: element.namespaceURI === "http://www.w3.org/2000/svg" && element.ownerSVGElement
+        ? (parent ? parent.turnOutsideSvg : 0)
+        : (parent ? parent.turn : 0) + turnOf(element, style),
+      masked:
+        (parent ? parent.masked : false) ||
+        (style.clipPath && style.clipPath !== "none") ||
+        (style.maskImage && style.maskImage !== "none") ||
+        (style.webkitMaskImage && style.webkitMaskImage !== "none"),
+      truncates:
+        (parent ? parent.truncates : false) ||
+        style.textOverflow === "ellipsis" ||
+        (style.webkitLineClamp && style.webkitLineClamp !== "none"),
+      moving: (parent ? parent.moving : false) || looping.has(element),
+      paintsText: (parent ? parent.paintsText : false) || clipsText,
+    };
+    states.set(element, state);
+    return state;
+  };
+
+  const blockOf = (element) => {
+    if (element.namespaceURI === "http://www.w3.org/2000/svg") return element.closest("text") || element;
+    for (let node = element; node; node = node.parentElement) {
+      const display = stateOf(node).style.display;
+      if (display !== "inline" && display !== "contents") return node;
+    }
+    return document.body;
+  };
+
+  const set = (value) => Boolean(value) && value !== "none" && value !== "normal";
+
+  const establishes = (style) =>
+    set(style.transform) ||
+    set(style.scale) ||
+    set(style.rotate) ||
+    set(style.translate) ||
+    set(style.perspective) ||
+    set(style.filter) ||
+    set(style.backdropFilter) ||
+    set(style.containerType) ||
+    style.contentVisibility === "auto" ||
+    /transform|perspective|filter|scale|rotate|translate/.test(style.willChange || "") ||
+    /paint|layout|strict|content/.test(style.contain || "");
+
+  const clipRect = (element, style) => {
+    const match = /rect\\(([^)]+)\\)/.exec(style.clip || "");
+    if (!match || (style.position !== "absolute" && style.position !== "fixed")) return null;
+    const outer = element.getBoundingClientRect();
+    const [top, right, bottom, left] = match[1].split(/[\\s,]+/).filter(Boolean);
+    const at = (value, fallback, origin) => (value === "auto" ? fallback : origin + parseFloat(value));
+    return {
+      left: at(left, outer.left, outer.left),
+      right: at(right, outer.right, outer.left),
+      top: at(top, outer.top, outer.top),
+      bottom: at(bottom, outer.bottom, outer.top),
+      page: false,
+      cutsX: true,
+      cutsY: true,
+    };
+  };
+
+  // With the root's overflow visible, the body's overflow is the viewport's,
+  // which the page clip already is, and the body's own box clips nothing.
+  const rootStyle = getComputedStyle(document.documentElement);
+  const bodyIsViewport = rootStyle.overflowX === "visible" && rootStyle.overflowY === "visible";
+
+  // Every box that clips the text: its own element first. A positioned box
+  // escapes every clipping box between it and its containing block.
+  const clippers = (element) => {
+    const found = [{ left: 0, right: width, top: 0, bottom: Infinity, page: true, cutsX: true, cutsY: true }];
+    let escaping = null;
+    for (let node = element; node && node !== document.documentElement; node = node.parentElement) {
+      const style = stateOf(node).style;
+      if (node !== element) {
+        if (escaping === "absolute" && (style.position !== "static" || establishes(style))) escaping = null;
+        if (escaping === "fixed" && establishes(style)) escaping = null;
+      }
+      if (escaping === null) {
+        // A scrolling box hides what is scrolled away but cuts nothing off: the
+        // rest is a scroll away. The document's own scroller hides nothing.
+        const root = node === document.body;
+        const hides = (value) => !(root && bodyIsViewport) && (value === "hidden" || value === "clip");
+        const scrolls = (value) => !root && (value === "auto" || value === "scroll");
+        const x = hides(style.overflowX) || scrolls(style.overflowX);
+        const y = hides(style.overflowY) || scrolls(style.overflowY);
+        if (x || y) {
+          // The client box is measured before transforms, the bounding box after.
+          const outer = node.getBoundingClientRect();
+          const wide = typeof node.offsetWidth === "number" ? node.offsetWidth : node.clientWidth + 2 * node.clientLeft;
+          const tall = typeof node.offsetHeight === "number" ? node.offsetHeight : node.clientHeight + 2 * node.clientTop;
+          const across = wide > 0 ? outer.width / wide : 1;
+          const down = tall > 0 ? outer.height / tall : 1;
+          const left = outer.left + node.clientLeft * across;
+          const top = outer.top + node.clientTop * down;
+          found.push({
+            left: x ? left : -Infinity,
+            right: x ? left + node.clientWidth * across : Infinity,
+            top: y ? top : -Infinity,
+            bottom: y ? top + node.clientHeight * down : Infinity,
+            page: false,
+            cutsX: hides(style.overflowX),
+            cutsY: hides(style.overflowY),
+          });
+        }
+        const clipped = clipRect(node, style);
+        if (clipped) found.push(clipped);
+      }
+      if (style.position === "absolute" || style.position === "fixed") escaping = style.position;
+    }
+    return found;
+  };
+
+  // The box around the letters themselves: a font's line box reaches past its
+  // ink, and display type set tight overlaps line to line without touching.
+  const inkOf = (words, style) => {
+    const shown = style.textTransform === "uppercase" ? words.toUpperCase() : words;
+    const font = [style.fontStyle, style.fontWeight, style.fontSize, style.fontFamily].join(" ");
+    const key = font + "\\u0000" + style.letterSpacing + "\\u0000" + shown;
+    if (inks.has(key)) return inks.get(key);
+    let ink = null;
+    if (context) {
+      context.font = font;
+      if ("letterSpacing" in context) context.letterSpacing = style.letterSpacing === "normal" ? "0px" : style.letterSpacing;
+      const measured = context.measureText(shown);
+      if (typeof measured.fontBoundingBoxAscent === "number") {
+        ink = {
+          top: Math.max(0, measured.fontBoundingBoxAscent - measured.actualBoundingBoxAscent),
+          bottom: Math.max(0, measured.fontBoundingBoxDescent - measured.actualBoundingBoxDescent),
+          left: -measured.actualBoundingBoxLeft,
+          right: measured.actualBoundingBoxRight,
+          height: measured.fontBoundingBoxAscent + measured.fontBoundingBoxDescent,
+          advance: measured.width,
+        };
+      }
+    }
+    inks.set(key, ink);
+    return ink;
+  };
+
+  const area = (box) => Math.max(0, box.right - box.left) * Math.max(0, box.bottom - box.top);
+
+  const texts = [];
+  const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT);
+  for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+    const words = node.nodeValue.replace(/\\s+/g, " ").trim();
+    const element = node.parentElement;
+    if (words === "" || !element || /^(SCRIPT|STYLE|NOSCRIPT|TEMPLATE)$/.test(element.tagName)) continue;
+    const state = stateOf(element);
+    // A slight tilt keeps its box close to its letters; more and the box lies.
+    const tilt = Math.abs((((state.turn % 360) + 540) % 360) - 180);
+    if (state.style.visibility !== "visible" || state.opacity < 0.05 || state.masked || !(tilt <= TILT)) continue;
+    if (alpha(state.style.color) < 0.05 && alpha(state.style.webkitTextFillColor) < 0.05 && !state.paintsText) continue;
+    const range = document.createRange();
+    range.selectNodeContents(node);
+    const ink = inkOf(words, state.style);
+    const clips = clippers(element);
+    const boxes = [];
+    const lines = [...range.getClientRects()].filter((raw) => raw.width >= 2 && raw.height >= 2);
+    const rtl = state.style.direction === "rtl";
+    for (const raw of lines) {
+      // Scaled type (an SVG viewBox, a scale transform) draws at another size
+      // than its computed font-size; the box's own height says by how much.
+      const scale = ink && ink.height > 0 ? raw.height / ink.height : 1;
+      const top = ink ? ink.top * scale : 0;
+      const bottom = ink ? ink.bottom * scale : 0;
+      const box = raw.height - top - bottom >= 1
+        ? { left: raw.left, right: raw.right, top: raw.top + top, bottom: raw.bottom - bottom }
+        : { left: raw.left, right: raw.right, top: raw.top, bottom: raw.bottom };
+      // Across, the ink is known only when the whole string is on this one line,
+      // and a line can be stretched one way only (scaleX).
+      const wide = ink && ink.advance > 0 ? raw.width / ink.advance : scale;
+      if (ink && lines.length === 1 && !rtl && (ink.right - ink.left) * wide >= 1) {
+        box.left = Math.max(box.left, raw.left + ink.left * wide);
+        box.right = Math.min(box.right, raw.left + ink.right * wide);
+      }
+      const seen = { ...box };
+      for (const clip of clips) {
+        seen.left = Math.max(seen.left, clip.left);
+        seen.right = Math.min(seen.right, clip.right);
+        seen.top = Math.max(seen.top, clip.top);
+        seen.bottom = Math.min(seen.bottom, clip.bottom);
+      }
+      const shows = seen.right - seen.left >= 2 && seen.bottom - seen.top >= 2;
+      boxes.push({ box, seen, shows, share: area(box) === 0 ? 0 : area(seen) / area(box), clips });
+    }
+    if (boxes.length === 0) continue;
+    const drawn = ink && ink.height > 0 ? lines[0].height / ink.height : 1;
+    const size = (parseFloat(state.style.fontSize) || 16) * drawn;
+    texts.push({ words: words.slice(0, 80), boxes, block: blockOf(element), state, size });
+  }
+
+  const findings = [];
+  const seen = new Set();
+
+  // Collisions between what shows of each box, swept by top edge.
+  const shown = texts.flatMap((text) =>
+    text.boxes.filter((entry) => entry.share >= 0.5).map((entry) => ({ box: entry.seen, text })),
+  );
+  shown.sort((a, b) => a.box.top - b.box.top);
+  for (let i = 0; i < shown.length && findings.length < LIMIT; i += 1) {
+    const a = shown[i];
+    for (let j = i + 1; j < shown.length && shown[j].box.top < a.box.bottom; j += 1) {
+      const b = shown[j];
+      if (a.text.block === b.text.block || a.text === b.text) continue;
+      if (a.text.state.moving || b.text.state.moving) continue;
+      const across = Math.min(a.box.right, b.box.right) - Math.max(a.box.left, b.box.left);
+      const down = Math.min(a.box.bottom, b.box.bottom) - Math.max(a.box.top, b.box.top);
+      if (across < OVERLAP_MIN || down < OVERLAP_MIN) continue;
+      if ((across * down) / Math.min(area(a.box), area(b.box)) < OVERLAP_SHARE) continue;
+      // Words laid over giant display type are a composition, not a collision,
+      // and a variable font's width is past what the canvas can measure.
+      const larger = Math.max(a.text.size, b.text.size);
+      const smaller = Math.min(a.text.size, b.text.size);
+      if (larger >= LAYERED * smaller) continue;
+      const pair = [a.text.words, b.text.words].sort().join("\\u0000");
+      if (seen.has(pair)) continue;
+      seen.add(pair);
+      findings.push({ kind: "overlap", text: a.text.words, other: b.text.words });
+      if (findings.length >= LIMIT) break;
+    }
+  }
+
+  // Cut off: partly shown. Text hidden whole is a choice (screen reader
+  // text, a rolling digit, a carousel), not a mistake.
+  for (const text of texts) {
+    if (findings.length >= LIMIT) break;
+    if (text.state.truncates || text.state.moving) continue;
+    let cut = null;
+    for (const entry of text.boxes) {
+      if (!entry.shows || entry.share > 0.97) continue;
+      const { box } = entry;
+      // Nearest clip first, the page last. Past a scroll box, a clip further
+      // out sees only what the scroll box shows.
+      const inner = { ...box };
+      for (const clip of [...entry.clips.slice(1), entry.clips[0]]) {
+        const sides = [
+          ...(clip.cutsX ? [["left", clip.left - inner.left, box.right - box.left], ["right", inner.right - clip.right, box.right - box.left]] : []),
+          ...(clip.cutsY ? [["top", clip.top - inner.top, box.bottom - box.top], ["bottom", inner.bottom - clip.bottom, box.bottom - box.top]] : []),
+        ];
+        for (const [edge, by, extent] of sides) {
+          // A box flush with the page's edge cuts where the page does; say the page.
+          const deeper = cut === null || by > cut.by || (clip.page && by === cut.by);
+          if (by > Math.max(CUT_MIN, extent * CUT_SHARE) && deeper) {
+            cut = { edge, by, within: clip.page ? "page" : "container" };
+          }
+        }
+        if (!clip.cutsX) {
+          inner.left = Math.max(inner.left, clip.left);
+          inner.right = Math.min(inner.right, clip.right);
+        }
+        if (!clip.cutsY) {
+          inner.top = Math.max(inner.top, clip.top);
+          inner.bottom = Math.min(inner.bottom, clip.bottom);
+        }
+      }
+    }
+    if (cut) findings.push({ kind: "cut-off", text: text.words, edge: cut.edge, by: Math.round(cut.by), within: cut.within });
+  }
+
+  return findings;
+})()`;
+function layoutFindings(value) {
+  if (!Array.isArray(value))
+    return [];
+  const findings = [];
+  for (const entry of value) {
+    if (!isJsonRecord(entry) || !isString(entry.text))
+      continue;
+    if (entry.kind === "overlap" && isString(entry.other)) {
+      findings.push({ kind: "overlap", text: entry.text, other: entry.other });
+    } else if (entry.kind === "cut-off" && isString(entry.edge) && isEdge(entry.edge) && isNumber(entry.by) && (entry.within === "page" || entry.within === "container")) {
+      findings.push({
+        kind: "cut-off",
+        text: entry.text,
+        edge: entry.edge,
+        by: entry.by,
+        within: entry.within
+      });
+    }
+  }
+  return findings;
+}
+function describeFinding(finding) {
+  if (finding.kind === "overlap")
+    return `"${finding.text}" runs into "${finding.other}"`;
+  const where = finding.within === "page" ? "the page" : "the box around it";
+  return `"${finding.text}" is cut off ${finding.by}px past the ${finding.edge} edge of ${where}`;
+}
+
 // ../server/dist/capture/capture.js
 var FRAME_MAX_HEIGHT = 4e3;
 var MIN_WIDTH = 320;
@@ -2553,6 +3188,13 @@ function resourced(text3, url) {
 function locatorExpression(focus) {
   return `${LOCATOR}(${JSON.stringify(focus.selector)}, ${JSON.stringify(focus.text)}, ${JSON.stringify(focus.tag)})`;
 }
+async function inspectLayout(page) {
+  const response = await bounded(page.send("Runtime.evaluate", {
+    expression: LAYOUT_PROBE,
+    returnByValue: true
+  }), 2e3, null).catch(() => null);
+  return layoutFindings(resultValue(response));
+}
 async function render(page, input) {
   const width = clamp(Math.round(input.width), MIN_WIDTH, MAX_WIDTH);
   const errors = [];
@@ -2712,22 +3354,30 @@ async function render(page, input) {
       returnByValue: true
     }), 2e3, void 0).catch(() => {
     });
+    const layout = input.inspect === true ? await inspectLayout(page) : [];
     const metrics = await page.send("Page.getLayoutMetrics");
     const size2 = metrics.cssContentSize ?? metrics.contentSize ?? { width, height: 900 };
     const pageWidth = Math.max(width, Math.ceil(size2.width));
     const contentHeight = Math.max(1, Math.ceil(size2.height));
     const pageHeight = Math.min(FRAME_MAX_HEIGHT, contentHeight);
     const cut = size2.height > FRAME_MAX_HEIGHT;
+    const clip2 = { x: 0, y: 0, width, height: pageHeight, scale: 1 };
     const frameResponse = await page.send("Page.captureScreenshot", {
       format: "png",
       captureBeyondViewport: true,
-      clip: { x: 0, y: 0, width, height: pageHeight, scale: 1 }
+      clip: clip2
     });
     const frame = {
       png: Buffer.from(frameResponse.data, "base64"),
       width,
       height: pageHeight
     };
+    const jpeg = input.jpeg === true ? await page.send("Page.captureScreenshot", {
+      format: "jpeg",
+      quality: 80,
+      captureBeyondViewport: true,
+      clip: clip2
+    }).then((shot) => Buffer.from(shot.data, "base64"), () => null) : null;
     const crops = [];
     for (const focus of input.focuses ?? []) {
       const located = await page.send("Runtime.evaluate", {
@@ -2763,7 +3413,7 @@ async function render(page, input) {
         resolved
       });
     }
-    return { frame, crops, errors, hydration, cut };
+    return { frame, crops, errors, hydration, cut, layout, jpeg };
   } finally {
     for (const stop of unlisten)
       stop();
@@ -2775,8 +3425,8 @@ async function capturePage(browser, input) {
 }
 
 // ../server/dist/requests/attachments.js
-import { copyFile, lstat, mkdir as mkdir3, readdir as readdir2, readFile as readFile5, realpath, rename, rm as rm2, stat as stat2, unlink, writeFile as writeFile3 } from "fs/promises";
-import { basename as basename2, extname, join as join5, resolve, sep } from "path";
+import { copyFile, lstat, mkdir as mkdir4, readdir as readdir3, readFile as readFile6, realpath, rename as rename3, rm as rm4, stat as stat2, unlink, writeFile as writeFile4 } from "fs/promises";
+import { basename as basename2, extname, join as join6, resolve, sep } from "path";
 var CAPTURES_DIR = ".leglas/captures";
 var REFERENCES_DIR = ".leglas/references";
 var LOAD_SHARE = 0.6;
@@ -2867,7 +3517,7 @@ function sniffImage(bytes) {
 async function moveReference(cwd, id, destinationDir, index) {
   let names;
   try {
-    names = await readdir2(join5(cwd, REFERENCES_DIR));
+    names = await readdir3(join6(cwd, REFERENCES_DIR));
   } catch {
     return null;
   }
@@ -2876,17 +3526,17 @@ async function moveReference(cwd, id, destinationDir, index) {
     return null;
   const extension = extname(sourceName).toLowerCase();
   const destinationName = `reference-${index}${extension}`;
-  const source = join5(cwd, REFERENCES_DIR, sourceName);
-  const destination = join5(destinationDir, destinationName);
-  await mkdir3(destinationDir, { recursive: true });
+  const source = join6(cwd, REFERENCES_DIR, sourceName);
+  const destination = join6(destinationDir, destinationName);
+  await mkdir4(destinationDir, { recursive: true });
   try {
-    await rename(source, destination);
+    await rename3(source, destination);
   } catch {
     await copyFile(source, destination);
     await unlink(source).catch(() => {
     });
   }
-  const sniffed = sniffImage(await readFile5(destination));
+  const sniffed = sniffImage(await readFile6(destination));
   return {
     kind: "reference",
     file: `${CAPTURES_DIR}/${basename2(destinationDir)}/${destinationName}`,
@@ -2908,7 +3558,7 @@ function focusOf(note) {
 async function attachRequest(cwd, requestId, input, deps) {
   const capture = deps.capture ?? capturePage;
   const deadlineMs = deps.deadlineMs ?? 12e3;
-  const destination = join5(cwd, CAPTURES_DIR, requestId);
+  const destination = join6(cwd, CAPTURES_DIR, requestId);
   const captured = {
     attachments: [],
     errors: [],
@@ -2954,8 +3604,8 @@ async function attachRequest(cwd, requestId, input, deps) {
       const direction = await capture(browser, directionInput);
       if (expired2)
         return;
-      await mkdir3(destination, { recursive: true });
-      await writeFile3(join5(destination, "frame.png"), direction.frame.png);
+      await mkdir4(destination, { recursive: true });
+      await writeFile4(join6(destination, "frame.png"), direction.frame.png);
       captured.attachments.push({
         kind: "frame",
         file: `${CAPTURES_DIR}/${requestId}/frame.png`,
@@ -2973,7 +3623,7 @@ async function attachRequest(cwd, requestId, input, deps) {
         if (crop === null || crop === void 0 || note === void 0 || expired2)
           continue;
         const name = `note-${index + 1}.png`;
-        await writeFile3(join5(destination, name), crop.shot.png);
+        await writeFile4(join6(destination, name), crop.shot.png);
         captured.attachments.push({
           kind: "note",
           file: `${CAPTURES_DIR}/${requestId}/${name}`,
@@ -2994,7 +3644,7 @@ async function attachRequest(cwd, requestId, input, deps) {
         const comparison = await capture(browser, compareInput);
         if (expired2)
           return;
-        await writeFile3(join5(destination, "compare.png"), comparison.frame.png);
+        await writeFile4(join6(destination, "compare.png"), comparison.frame.png);
         captured.attachments.push({
           kind: "compare",
           file: `${CAPTURES_DIR}/${requestId}/compare.png`,
@@ -3018,13 +3668,13 @@ async function attachRequest(cwd, requestId, input, deps) {
   return captured;
 }
 function captureDirectory(cwd, requestId) {
-  return /^[A-Za-z0-9_-]{1,32}$/.test(requestId) ? join5(cwd, CAPTURES_DIR, requestId) : null;
+  return /^[A-Za-z0-9_-]{1,32}$/.test(requestId) ? join6(cwd, CAPTURES_DIR, requestId) : null;
 }
 async function removeCaptures(cwd, requestId) {
   const directory = captureDirectory(cwd, requestId);
   if (directory === null)
     return;
-  await rm2(directory, { recursive: true, force: true });
+  await rm4(directory, { recursive: true, force: true });
 }
 async function rehomeCaptures(cwd, from, to, attachments) {
   if (attachments.length === 0)
@@ -3033,8 +3683,8 @@ async function rehomeCaptures(cwd, from, to, attachments) {
   const destination = captureDirectory(cwd, to);
   if (source === null || destination === null)
     return [...attachments];
-  await mkdir3(join5(cwd, CAPTURES_DIR), { recursive: true });
-  await rename(source, destination);
+  await mkdir4(join6(cwd, CAPTURES_DIR), { recursive: true });
+  await rename3(source, destination);
   const prefix = `${CAPTURES_DIR}/${from}/`;
   return attachments.map((attachment) => ({
     ...attachment,
@@ -3045,7 +3695,7 @@ function rehomeText(text3, from, to) {
   return text3.split(`${CAPTURES_DIR}/${from}/`).join(`${CAPTURES_DIR}/${to}/`);
 }
 async function ownCapturesRoot(cwd) {
-  const root = join5(cwd, CAPTURES_DIR);
+  const root = join6(cwd, CAPTURES_DIR);
   try {
     const entry = await lstat(root);
     return entry.isDirectory() ? root : null;
@@ -3054,7 +3704,7 @@ async function ownCapturesRoot(cwd) {
   }
 }
 async function isOwnCapture(cwd, file) {
-  const root = await realpath(join5(cwd, CAPTURES_DIR)).catch(() => null);
+  const root = await realpath(join6(cwd, CAPTURES_DIR)).catch(() => null);
   if (root === null)
     return false;
   const real = await realpath(resolve(cwd, file)).catch(() => null);
@@ -3068,21 +3718,21 @@ async function pruneCaptures(cwd, keep) {
   if (root === null)
     return void await pruneReferences(cwd);
   try {
-    const entries = await readdir2(root, { withFileTypes: true });
-    await Promise.all(entries.filter((entry) => entry.isDirectory() && !kept.has(entry.name)).map((entry) => rm2(join5(root, entry.name), { recursive: true, force: true })));
+    const entries = await readdir3(root, { withFileTypes: true });
+    await Promise.all(entries.filter((entry) => entry.isDirectory() && !kept.has(entry.name)).map((entry) => rm4(join6(root, entry.name), { recursive: true, force: true })));
   } catch {
   }
   await pruneReferences(cwd);
 }
 async function pruneReferences(cwd) {
-  const references = join5(cwd, REFERENCES_DIR);
+  const references = join6(cwd, REFERENCES_DIR);
   try {
     if (!(await lstat(references)).isDirectory())
       return;
-    const entries = await readdir2(references, { withFileTypes: true });
+    const entries = await readdir3(references, { withFileTypes: true });
     const old = Date.now() - 60 * 60 * 1e3;
     await Promise.all(entries.filter((entry) => entry.isFile()).map(async (entry) => {
-      const file = join5(references, entry.name);
+      const file = join6(references, entry.name);
       if ((await stat2(file)).mtimeMs < old)
         await unlink(file).catch(() => {
         });
@@ -3093,9 +3743,9 @@ async function pruneReferences(cwd) {
 
 // ../server/dist/branches/worktree.js
 import { execFile, spawn as spawn2 } from "child_process";
-import { rm as rm3 } from "fs/promises";
+import { rm as rm5 } from "fs/promises";
 import net2 from "net";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 import { promisify } from "util";
 var run = promisify(execFile);
 var WORKTREES_DIR = ".leglas/worktrees";
@@ -3137,10 +3787,10 @@ async function answeringHost(port) {
 }
 async function startWorktree(options) {
   const readyTimeoutMs = options.readyTimeoutMs ?? 9e4;
-  const path = join6(options.cwd, WORKTREES_DIR, worktreeSlug(options.branch));
+  const path = join7(options.cwd, WORKTREES_DIR, worktreeSlug(options.branch));
   const log = options.onLog ?? (() => {
   });
-  await rm3(path, { recursive: true, force: true });
+  await rm5(path, { recursive: true, force: true });
   await run("git", ["worktree", "prune"], { cwd: options.cwd }).catch(() => {
   });
   try {
@@ -3152,7 +3802,7 @@ async function startWorktree(options) {
   const cleanup = async () => {
     await run("git", ["worktree", "remove", "--force", path], { cwd: options.cwd }).catch(() => {
     });
-    await rm3(path, { recursive: true, force: true }).catch(() => {
+    await rm5(path, { recursive: true, force: true }).catch(() => {
     });
   };
   try {
@@ -3201,8 +3851,8 @@ async function startAppProcess(options) {
     child = spawn2(substitutePort(options.devCommand, port), {
       cwd: options.cwd,
       shell: true,
-      // Own process group, so stopping kills the shell and whatever it spawned
-      // rather than orphaning a dev server holding the port.
+      // Own process group, so stopping kills the shell and everything it
+      // spawned instead of orphaning a dev server on the port.
       detached: true,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -3448,8 +4098,8 @@ function conversationFailure(code) {
 
 // ../server/dist/requests/annotations.js
 import { randomBytes as randomBytes2 } from "crypto";
-import { mkdir as mkdir4, readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname4, join as join7 } from "path";
+import { mkdir as mkdir5, readFile as readFile7, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname4, join as join8 } from "path";
 var ANNOTATIONS_PATH = ".leglas/annotations.json";
 var NOTE_CAP = 500;
 var SELECTOR_CAP = 300;
@@ -3513,7 +4163,7 @@ function anchorFrom(value) {
 }
 async function readAnnotations(cwd) {
   try {
-    const raw = await readFile6(join7(cwd, ANNOTATIONS_PATH), "utf8");
+    const raw = await readFile7(join8(cwd, ANNOTATIONS_PATH), "utf8");
     const parsed2 = parseJson(raw);
     if (!isJsonRecord(parsed2) || !Array.isArray(parsed2.annotations))
       return [];
@@ -3538,9 +4188,9 @@ async function readAnnotations(cwd) {
   }
 }
 async function write(cwd, annotations) {
-  const path = join7(cwd, ANNOTATIONS_PATH);
-  await mkdir4(dirname4(path), { recursive: true });
-  await writeFile4(path, `${JSON.stringify({ annotations }, null, 2)}
+  const path = join8(cwd, ANNOTATIONS_PATH);
+  await mkdir5(dirname4(path), { recursive: true });
+  await writeFile5(path, `${JSON.stringify({ annotations }, null, 2)}
 `, "utf8");
 }
 var writing = Promise.resolve();
@@ -3611,9 +4261,9 @@ function describeAnnotations(annotations) {
 }
 
 // ../server/dist/requests/requests.js
-import { mkdir as mkdir5, readFile as readFile7, writeFile as writeFile5 } from "fs/promises";
+import { mkdir as mkdir6, readFile as readFile8, writeFile as writeFile6 } from "fs/promises";
 import { randomBytes as randomBytes3 } from "crypto";
-import { dirname as dirname5, join as join8 } from "path";
+import { dirname as dirname5, join as join9 } from "path";
 var SAFE_SEGMENT = /^[a-z0-9][a-z0-9-]*$/i;
 function variantSlot(url) {
   if (!url.startsWith("/"))
@@ -3792,7 +4442,7 @@ function failureOf(entry) {
 }
 async function readRequests(cwd) {
   try {
-    const raw = await readFile7(join8(cwd, REQUESTS_PATH), "utf8");
+    const raw = await readFile8(join9(cwd, REQUESTS_PATH), "utf8");
     const parsed2 = parseJson(raw);
     if (!isJsonRecord(parsed2) || !Array.isArray(parsed2.requests))
       return [];
@@ -3828,9 +4478,9 @@ async function readRequests(cwd) {
   }
 }
 async function writeQueue(cwd, requests) {
-  const path = join8(cwd, REQUESTS_PATH);
-  await mkdir5(dirname5(path), { recursive: true });
-  await writeFile5(path, `${JSON.stringify({ requests }, null, 2)}
+  const path = join9(cwd, REQUESTS_PATH);
+  await mkdir6(dirname5(path), { recursive: true });
+  await writeFile6(path, `${JSON.stringify({ requests }, null, 2)}
 `, "utf8");
 }
 async function appendRequest(cwd, request, id = newRequestId()) {
@@ -3888,12 +4538,12 @@ async function clearRequests(cwd) {
 
 // ../server/dist/agents/runner.js
 import { spawn as nodeSpawn3 } from "child_process";
-import { readFile as readFile9 } from "fs/promises";
-import { join as join9, resolve as resolve2 } from "path";
+import { readFile as readFile10 } from "fs/promises";
+import { join as join10, resolve as resolve2 } from "path";
 
 // ../server/dist/agents/claude-agent-session.js
 import { EventEmitter } from "events";
-import { readFile as readFile8, stat as stat3 } from "fs/promises";
+import { readFile as readFile9, stat as stat3 } from "fs/promises";
 import { extname as extname2 } from "path";
 import { PassThrough } from "stream";
 var INITIALIZE_TIMEOUT_MS = 3e4;
@@ -3923,7 +4573,7 @@ async function claudeContent(prompt, images2) {
     try {
       if ((await stat3(path)).size > IMAGE_MAX_BYTES)
         continue;
-      const data = await readFile8(path);
+      const data = await readFile9(path);
       blocks.push({
         type: "image",
         source: { type: "base64", media_type: mediaType, data: data.toString("base64") }
@@ -4056,11 +4706,10 @@ var PersistentClaudeSession = class {
   warmedFor = null;
   closed = false;
   /**
-   * Counts every ask for a warm process. The runner fires warm() and
-   * release() without awaiting either, so the two race in both directions:
-   * a release must outlast a warm that started while it was settling, and
-   * must stand down for a warm asked for after it began. The generation a
-   * release captured at entry says which side of that it is on.
+   * Counts every ask for a warm process. warm() and release() aren't awaited
+   * and race both ways: a release must outlast a warm that started while it
+   * settled, and stand down for a warm asked for after it began. The generation
+   * it captured says which.
    */
   generation = 0;
   constructor(cwd, allowedCommands, startup) {
@@ -4170,13 +4819,10 @@ var PersistentClaudeSession = class {
     }
   }
   /**
-   * Let the native process go without ending the transport.
-   *
-   * The process is the cost, not this object: a warm session is Claude Code
-   * plus every MCP server the user has configured, held for a request that
-   * may never come. The runner calls this once nothing has asked for Claude
-   * in a while, and the next warm() starts it again. A session id the runner
-   * still holds is served by the `claude --resume` fallback in the meantime.
+   * Ends the native process but keeps the transport. A warm session is Claude
+   * Code plus every MCP server the user configured, held for a request that may
+   * not come. Called after an idle spell; the next warm() starts it again, and
+   * a held session id goes through `claude --resume` meanwhile.
    */
   async release() {
     const asOf = this.generation;
@@ -4380,12 +5026,10 @@ var PersistentCodexAppServer = class {
     this.requestTimeoutMs = requestTimeoutMs;
   }
   /**
-   * Counts every ask for a warm process. The runner fires warm() and
-   * release() without awaiting either, so the two race in both directions:
-   * a release must outlast a warm that was queued behind its reset, and must
-   * stand down for a warm asked for after it began. A warm queued behind a
-   * reset restarts through start() rather than warm(), so waiting its turn
-   * does not read as a fresh ask.
+   * Counts every ask for a warm process. warm() and release() aren't awaited
+   * and race both ways: a release must outlast a warm queued behind its reset,
+   * and stand down for a warm asked for after it began. A queued warm restarts
+   * through start(), so waiting doesn't count as a new ask.
    */
   generation = 0;
   warm(_sessionId = null) {
@@ -4506,11 +5150,9 @@ var PersistentCodexAppServer = class {
     }
   }
   /**
-   * Let the app-server process go without ending the transport.
-   *
-   * The runner calls this once nothing has asked for Codex in a while; the
-   * next warm() spawns and handshakes again. A thread id the runner still
-   * holds is resumed by the new process through `thread/resume`.
+   * Ends the app-server process but keeps the transport. Called after an idle
+   * spell; the next warm() spawns again and resumes a held thread through
+   * `thread/resume`.
    */
   async release() {
     const asOf = this.generation;
@@ -5143,7 +5785,7 @@ function startRunner(options) {
         active = null;
     }
   };
-  const registered = () => readFile9(join9(options.cwd, LOCAL_PREVIEWS_PATH), "utf8").catch(() => null);
+  const registered = () => readFile10(join10(options.cwd, LOCAL_PREVIEWS_PATH), "utf8").catch(() => null);
   const handle = async (request, choice) => {
     const allowedCommands = options.leglasCommand === void 0 ? [] : [
       `${options.leglasCommand} show`,
@@ -5187,13 +5829,11 @@ function startRunner(options) {
         retry: observed.retry
       });
       let failure = verdict();
-      if (!(outcome.ok && outcome.code === 0) && resolved.resumed && !observed.edited && // The edited flag is only evidence where Leglas has read the vendor's
-      // real output. Where it has not, "did not edit" means "was not seen
-      // to edit", and rerunning on that is how a half-applied change gets
-      // applied twice. Such a vendor keeps the failure card and its Retry.
-      activityVerified(resolved.agent) && conversationFailure(failure.code) && // Not redundant with the verdict: a stop that lands between the first
-      // child settling and the retry starting finds no child to cancel, so
-      // nothing says "cancelled". Stopped still means stopped.
+      if (!(outcome.ok && outcome.code === 0) && resolved.resumed && !observed.edited && // The edited flag is evidence only where Leglas has read the vendor's
+      // real output; elsewhere "didn't edit" means "wasn't seen to edit".
+      // Those vendors keep the failure card and its Retry.
+      activityVerified(resolved.agent) && conversationFailure(failure.code) && // Not redundant: a stop between the first child settling and the retry
+      // starting finds no child to cancel.
       !stopped) {
         sessions.delete(resolved.agent);
         const cold = resolveCommand(choice, request.prompt, null, allowedCommands, images2);
@@ -5338,9 +5978,8 @@ function startRunner(options) {
     snapshot: () => ({ ...state, failedIds: [...failed] }),
     cancel,
     prepare,
-    // A nudge during a tick is latched and checked as soon as that tick
-    // settles; a nudge between ticks starts immediately. Neither can overlap
-    // the active agent.
+    // A nudge during a tick is latched until the tick settles; between ticks it
+    // starts one at once. Neither overlaps the active agent.
     nudge: () => schedule(true)
   };
 }
@@ -5549,7 +6188,7 @@ Sec-WebSocket-Accept: ${accept}\r
 }
 
 // ../server/dist/share/share.js
-import { randomBytes as randomBytes4, randomUUID, timingSafeEqual } from "crypto";
+import { randomBytes as randomBytes4, randomUUID as randomUUID3, timingSafeEqual } from "crypto";
 import http3 from "http";
 import { posix } from "path";
 
@@ -5870,10 +6509,10 @@ var DEV_CONTROL_ROUTES = [
   /** read, browser-sync 3.0.4: its client surface and server metadata. */
   "/__browser_sync__",
   /**
-   * read, webpack-dev-server 6.0.0, which mounts its own surface here: the
-   * file listing, `/webpack-dev-server/invalidate`, which forces a rebuild,
-   * and `/webpack-dev-server/open-editor`, which calls the same launch-editor
-   * package Vite does. The subtree match below takes all three.
+   * read, webpack-dev-server 6.0.0: the file listing,
+   * `/webpack-dev-server/invalidate` (forces a rebuild) and
+   * `/webpack-dev-server/open-editor` (launch-editor again). The subtree match
+   * covers all three.
    */
   "/webpack-dev-server",
   /** reported: Rails Web Console, an interactive server-side REPL. */
@@ -5898,17 +6537,12 @@ var DEV_CONTROL_ROUTES = [
 var DEV_CONTROL_PREFIXES = [
   /** read, Next 16.3.1. Its app assets sit at `/_next/` and stay allowed. */
   "/__nextjs_",
-  /**
-   * read, Nuxt DevTools 4.0.0-alpha.16. Nuxt's own bundle is at `/_nuxt/`,
-   * one underscore and a different prefix, so the app is untouched.
-   */
+  /** read, Nuxt DevTools 4.0.0-alpha.16. Nuxt's bundle is at `/_nuxt/`, a different prefix. */
   "/__nuxt_devtools__",
   /**
-   * read, Parcel 2.16.4: `__parcel_launch_editor` reads a `file` parameter
-   * and calls the same launch-editor code Vite does. Beside it sit
-   * `__parcel_source_map`, `__parcel_source_root` and `__parcel_code_frame`,
-   * which serve source, and the HMR and health routes, which a viewer has no
-   * use for: their live-reload socket is already refused.
+   * read, Parcel 2.16.4: `__parcel_launch_editor` takes a `file` and calls
+   * launch-editor. Its source-map, source-root, code-frame, HMR and health
+   * routes serve source or are useless to a viewer.
    */
   "/__parcel_"
 ];
@@ -6284,7 +6918,7 @@ function createShareManager(options) {
       token = randomBytes4(24).toString("base64url");
     const at = now();
     const grant = {
-      id: randomUUID(),
+      id: randomUUID3(),
       name,
       token,
       createdAt: at,
@@ -6599,7 +7233,7 @@ function createShareManager(options) {
       }
       const share = {
         ...parsed2.manifest,
-        id: randomUUID(),
+        id: randomUUID3(),
         grants: /* @__PURE__ */ new Map(),
         tombstones: [],
         port,
@@ -6630,8 +7264,8 @@ function createShareManager(options) {
           share.runningTunnel = runTunnel({
             provider,
             port,
-            // Whichever link exists when the tunnel starts: the probe only
-            // needs a path the listener answers, and a share always has one.
+            // Whichever link exists when the tunnel starts; a share always has
+            // one, and the probe only needs a path the listener answers.
             entryPath: `${ENTRY_PREFIX}${Array.from(share.grants.values())[0]?.token ?? ""}`,
             onState: (next) => {
               if (active !== share || JSON.stringify(share.tunnel) === JSON.stringify(next))
@@ -6784,11 +7418,9 @@ function createShareManager(options) {
       return null;
     return {
       ...options.viewerConfig,
-      // The project id is the config's absolute path, which keys the sharer's
-      // saved layout and names their machine's directories, and the dev
-      // server's address names their network. A viewer keeps no layout and
-      // never dials the dev server, so the share's own id does the job and
-      // the address is left blank.
+      // The project id is the config's absolute path and the dev server address
+      // names the sharer's network. Viewers keep no layout and never dial the
+      // dev server, so they get the share's id and a blank address.
       project: `share:${share.id}`,
       devServer: "",
       previews: options.previewsForConfig(previews),
@@ -6856,12 +7488,12 @@ function createShareManager(options) {
 }
 
 // ../server/dist/config/renames.js
-import { mkdir as mkdir6, readFile as readFile10, writeFile as writeFile6 } from "fs/promises";
-import { dirname as dirname6, join as join10 } from "path";
+import { mkdir as mkdir7, readFile as readFile11, writeFile as writeFile7 } from "fs/promises";
+import { dirname as dirname6, join as join11 } from "path";
 var RENAMES_PATH = ".leglas/renames.json";
 async function readRenames(cwd) {
   try {
-    const raw = await readFile10(join10(cwd, RENAMES_PATH), "utf8");
+    const raw = await readFile11(join11(cwd, RENAMES_PATH), "utf8");
     const parsed2 = parseJson(raw);
     if (!isJsonRecord(parsed2) || !isJsonRecord(parsed2.renames) && !Array.isArray(parsed2.renames))
       return {};
@@ -6871,9 +7503,9 @@ async function readRenames(cwd) {
   }
 }
 async function writeRenames(cwd, renames) {
-  const path = join10(cwd, RENAMES_PATH);
-  await mkdir6(dirname6(path), { recursive: true });
-  await writeFile6(path, `${JSON.stringify({ renames }, null, 2)}
+  const path = join11(cwd, RENAMES_PATH);
+  await mkdir7(dirname6(path), { recursive: true });
+  await writeFile7(path, `${JSON.stringify({ renames }, null, 2)}
 `, "utf8");
 }
 function resolveTitle(input, titles, renames) {
@@ -6890,10 +7522,10 @@ function resolveTitle(input, titles, renames) {
 // ../server/dist/server.js
 import { createReadStream, existsSync as existsSync3, statSync, unwatchFile, watch as watchFs, watchFile } from "fs";
 import { createHash as createHash2 } from "crypto";
-import { mkdir as mkdir8, readdir as readdir5, writeFile as writeFile9 } from "fs/promises";
+import { mkdir as mkdir9, readdir as readdir6, writeFile as writeFile10 } from "fs/promises";
 import http4 from "http";
 import net3 from "net";
-import { basename as basename3, dirname as dirname10, extname as extname3, join as join16, normalize as normalize2, relative as relative4 } from "path";
+import { basename as basename3, dirname as dirname10, extname as extname3, join as join17, normalize as normalize4, relative as relative4 } from "path";
 
 // ../server/dist/frame-policy.js
 var FRAMING_TIMEOUT_MS = 4e3;
@@ -7006,8 +7638,8 @@ async function checkFraming(target, embedder, fetcher = fetch) {
 
 // ../server/dist/generation/generation.js
 import { spawn as nodeSpawn4 } from "child_process";
-import { readFile as readFile14, writeFile as writeFile7 } from "fs/promises";
-import { dirname as dirname8, join as join14 } from "path";
+import { readFile as readFile15, writeFile as writeFile8 } from "fs/promises";
+import { dirname as dirname8, join as join15, normalize as normalize3 } from "path";
 
 // ../server/dist/generation/claude.js
 var GENERATION_EFFORT = "medium";
@@ -7050,9 +7682,9 @@ function resultText(lines2) {
 }
 
 // ../server/dist/generation/codex.js
-import { readFile as readFile11 } from "fs/promises";
+import { readFile as readFile12 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 var RESTRICTED2 = [
   "exec",
   "--json",
@@ -7066,8 +7698,8 @@ var RESTRICTED2 = [
   "skills.include_instructions=false",
   "-c",
   "skills.bundled.enabled=false",
-  // Through the config, not `--disable`: a Codex that lacks one of these
-  // ignores it here, where `--disable` refuses to start at all.
+  // Through the config, not `--disable`: an unknown feature is ignored here,
+  // while `--disable` refuses to start.
   ...[
     "multi_agent",
     "apps",
@@ -7083,7 +7715,7 @@ var BARE = /^[A-Za-z0-9_-]+$/;
 async function codexServers(home = defaultCodexHome()) {
   let config;
   try {
-    config = await readFile11(join11(home, "config.toml"), "utf8");
+    config = await readFile12(join12(home, "config.toml"), "utf8");
   } catch {
     return [];
   }
@@ -7096,7 +7728,7 @@ async function codexServers(home = defaultCodexHome()) {
   return [...names];
 }
 function defaultCodexHome(env = process.env) {
-  return env.CODEX_HOME !== void 0 && env.CODEX_HOME !== "" ? env.CODEX_HOME : join11(homedir2(), ".codex");
+  return env.CODEX_HOME !== void 0 && env.CODEX_HOME !== "" ? env.CODEX_HOME : join12(homedir2(), ".codex");
 }
 var serversOff = (servers) => servers.flatMap((name) => ["-c", `mcp_servers.${name}.enabled=false`]);
 function codexPlanArgs(prompt, servers) {
@@ -7122,12 +7754,12 @@ function codexResultText(lines2) {
 }
 
 // ../server/dist/generation/facts.js
-import { readFile as readFile13, readdir as readdir4 } from "fs/promises";
-import { dirname as dirname7, join as join13, normalize } from "path";
+import { readFile as readFile14, readdir as readdir5 } from "fs/promises";
+import { dirname as dirname7, join as join14, normalize as normalize2 } from "path";
 
 // ../server/dist/generation/switch-file.js
-import { readFile as readFile12, readdir as readdir3, stat as stat4 } from "fs/promises";
-import { join as join12, relative as relative3 } from "path";
+import { readFile as readFile13, readdir as readdir4, stat as stat4 } from "fs/promises";
+import { join as join13, relative as relative3 } from "path";
 var MAP = /const DIRECTIONS = \{([\s\S]*?)\} as const;/;
 var SOURCE = /\.(tsx|jsx|ts|js)$/;
 var SCAN_LIMIT = 3e3;
@@ -7140,8 +7772,8 @@ async function isFile(path) {
 }
 async function findSwitch(cwd, slug) {
   for (const name of ["switch.tsx", "switch.jsx"]) {
-    const path = join12(".leglas", "variants", slug, name);
-    if (await isFile(join12(cwd, path)))
+    const path = join13(".leglas", "variants", slug, name);
+    if (await isFile(join13(cwd, path)))
       return path;
   }
   const wanted = `"v-${slug}"`;
@@ -7149,14 +7781,14 @@ async function findSwitch(cwd, slug) {
   const walk = async (folder) => {
     let items;
     try {
-      items = await readdir3(join12(cwd, folder), { withFileTypes: true });
+      items = await readdir4(join13(cwd, folder), { withFileTypes: true });
     } catch {
       return null;
     }
     for (const item of items) {
       if (seen >= SCAN_LIMIT || item.name.startsWith(".") || item.name === "node_modules")
         continue;
-      const path = join12(folder, item.name);
+      const path = join13(folder, item.name);
       if (item.isDirectory()) {
         const found = await walk(path);
         if (found !== null)
@@ -7166,7 +7798,7 @@ async function findSwitch(cwd, slug) {
       if (!SOURCE.test(item.name))
         continue;
       seen += 1;
-      const source = await readFile12(join12(cwd, path), "utf8").catch(() => "");
+      const source = await readFile13(join13(cwd, path), "utf8").catch(() => "");
       if (source.includes(wanted) && MAP.test(source))
         return path;
     }
@@ -7175,7 +7807,7 @@ async function findSwitch(cwd, slug) {
   for (const root of ["src", "app"]) {
     const found = await walk(root);
     if (found !== null)
-      return relative3(cwd, join12(cwd, found));
+      return relative3(cwd, join13(cwd, found));
   }
   return null;
 }
@@ -7243,21 +7875,21 @@ function clip(source, limit) {
 var BASELINE_LINES = 15;
 var STUB = /Re-export what your|A first direction for/;
 async function text2(path) {
-  return readFile13(path, "utf8").catch(() => null);
+  return readFile14(path, "utf8").catch(() => null);
 }
 async function firstFile(cwd, candidates) {
   for (const candidate of candidates) {
-    if (await text2(join13(cwd, candidate)) !== null)
+    if (await text2(join14(cwd, candidate)) !== null)
       return candidate;
   }
   return null;
 }
 function cssImports(source, from) {
-  return [...source.matchAll(/import\s+["']([^"']+\.css)["']/g)].map((match) => normalize(join13(dirname7(from), match[1] ?? "")));
+  return [...source.matchAll(/import\s+["']([^"']+\.css)["']/g)].map((match) => normalize2(join14(dirname7(from), match[1] ?? "")));
 }
 async function globalStylesheet(cwd) {
   const entries = [];
-  const html = await text2(join13(cwd, "index.html"));
+  const html = await text2(join14(cwd, "index.html"));
   const script = html === null ? null : /<script[^>]+type="module"[^>]+src="\/?([^"]+)"/.exec(html);
   if (script?.[1] !== void 0)
     entries.push(script[1]);
@@ -7267,12 +7899,12 @@ async function globalStylesheet(cwd) {
   }
   const sheets = [];
   for (const entry of entries) {
-    const source = await text2(join13(cwd, entry));
+    const source = await text2(join14(cwd, entry));
     if (source !== null)
       sheets.push(...cssImports(source, entry));
   }
   for (const sheet of sheets) {
-    const source = await text2(join13(cwd, sheet));
+    const source = await text2(join14(cwd, sheet));
     if (source !== null && /:root\s*\{|@font-face/.test(source))
       return sheet;
   }
@@ -7283,7 +7915,7 @@ async function images(cwd) {
   const walk = async (folder) => {
     let items;
     try {
-      items = await readdir4(join13(cwd, "public", folder), { withFileTypes: true });
+      items = await readdir5(join14(cwd, "public", folder), { withFileTypes: true });
     } catch {
       return;
     }
@@ -7301,14 +7933,14 @@ async function images(cwd) {
   return found;
 }
 async function componentFile(cwd, from, specifier) {
-  const base = normalize(join13(dirname7(from), specifier));
+  const base = normalize2(join14(dirname7(from), specifier));
   return firstFile(cwd, [
     base,
     ...["tsx", "jsx", "ts", "js"].map((extension) => `${base}.${extension}`)
   ]);
 }
 async function example(cwd, switchPath, prefer) {
-  const source = await text2(join13(cwd, switchPath));
+  const source = await text2(join14(cwd, switchPath));
   if (source === null)
     return null;
   const directions = readDirections(source);
@@ -7317,13 +7949,13 @@ async function example(cwd, switchPath, prefer) {
   for (const direction of ordered) {
     const limit = direction.key === prefer ? VARIED_LINES : EXAMPLE_LINES;
     const path = await componentFile(cwd, switchPath, direction.from);
-    const body = path === null ? null : await text2(join13(cwd, path));
+    const body = path === null ? null : await text2(join14(cwd, path));
     if (path === null || body === null || body === placeholderSource(direction.name) || STUB.test(body))
       continue;
     if (body.split("\n").length < BASELINE_LINES) {
       const target = /from\s+["'](\.[^"']+)["']/.exec(body)?.[1];
       const followed = target === void 0 ? null : await componentFile(cwd, path, target);
-      const real = followed === null ? null : await text2(join13(cwd, followed));
+      const real = followed === null ? null : await text2(join14(cwd, followed));
       if (followed !== null && real !== null) {
         return {
           key: direction.key,
@@ -7339,7 +7971,7 @@ async function example(cwd, switchPath, prefer) {
 }
 async function dependencyNames(cwd) {
   try {
-    const pkg = parseJson(await text2(join13(cwd, "package.json")) ?? "");
+    const pkg = parseJson(await text2(join14(cwd, "package.json")) ?? "");
     return isJsonRecord(pkg) && isJsonRecord(pkg.dependencies) ? Object.keys(pkg.dependencies) : [];
   } catch {
     return [];
@@ -7348,7 +7980,7 @@ async function dependencyNames(cwd) {
 async function readProjectFacts(cwd, switchPath, prefer = null) {
   const dependencies = await dependencyNames(cwd);
   const sheetPath = await globalStylesheet(cwd);
-  const css = sheetPath === null ? null : await text2(join13(cwd, sheetPath));
+  const css = sheetPath === null ? null : await text2(join14(cwd, sheetPath));
   return {
     dependencies,
     stylesheet: sheetPath === null || css === null ? null : {
@@ -7425,7 +8057,13 @@ ${input.facts}
 This is a first draft for someone comparing directions side by side, not a finished page. Aim for about 250 lines and write it in one pass: no second drafts, and no review, lint, tests or screenshots. Leglas renders and captures it for you. Your task ends when the file is written.`;
 }
 function fixPrompt(input) {
-  return `Leglas rendered ${input.file} and the page reported: ${input.errors.slice(0, 3).join(" | ")}. Fix what your file causes, in as few edits as you can, and change nothing else. If nothing in your file causes it, change nothing. Do not look around the project.`;
+  const layout = input.layout ?? [];
+  const reported = `Leglas rendered ${input.file} and the page reported: ${input.errors.slice(0, 3).join(" | ")}.`;
+  if (layout.length === 0) {
+    return `${reported} Fix what your file causes, in as few edits as you can, and change nothing else. If nothing in your file causes it, change nothing. Do not look around the project.`;
+  }
+  const opening = input.errors.length === 0 ? `Leglas rendered ${input.file}.` : reported;
+  return `${opening} At 1440 by 900, text a person would see runs into other text or is cut off: ${layout.slice(0, 5).join("; ")}. Fix it where it happens: move, wrap or re-set that text, or nudge what crowds it. Keep the design's scale and composition, and never shrink the design or its type to make room. A crop or an overlap of shapes and pictures can stay. If nothing in your file causes it, change nothing. Do not look around the project.`;
 }
 function kebab(value) {
   return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -7476,6 +8114,16 @@ var OWN_FAILURES = /* @__PURE__ */ new Set([
 ]);
 var BUSY = "A set of directions is already being built. Wait for it, or stop it first.";
 var KEPT_JOBS = 5;
+var guardKey = (slot, attempt) => `${slot.key}#${attempt}`;
+function listed(items) {
+  return items.length <= 1 ? items[0] ?? "" : `${items.slice(0, -1).join(", ")} and ${items.at(-1)}`;
+}
+function strayMessage(paths, restored, named) {
+  const which = paths.length === 1 ? "which is not its own file" : "which are not its own files";
+  const back = restored.length === 0 ? "" : restored.length === paths.length ? ` and put ${paths.length === 1 ? "the file" : "them"} back` : ` and put ${listed(restored)} back`;
+  const check = named.length === 0 ? "." : `. Check ${listed(named)} before trying again.`;
+  return `The build edited ${listed(paths)}, ${which}, so Leglas stopped it${back}${check}`;
+}
 var CLAUDE = {
   id: "claude",
   name: "Claude",
@@ -7492,6 +8140,10 @@ function codex(servers) {
     result: codexResultText
   };
 }
+function argsOf(agent) {
+  const mark = "\0prompt";
+  return agent.build(mark).map((arg) => arg === mark ? "<prompt>" : arg);
+}
 function wait(milliseconds) {
   return new Promise((resolve5) => {
     setTimeout(resolve5, milliseconds).unref?.();
@@ -7512,7 +8164,7 @@ function baseOf(preview, surface) {
 async function stackOf(cwd, switchPath) {
   let deps = {};
   try {
-    const pkg = parseJson(await readFile14(join14(cwd, "package.json"), "utf8"));
+    const pkg = parseJson(await readFile15(join15(cwd, "package.json"), "utf8"));
     if (isJsonRecord(pkg)) {
       for (const group of [pkg.devDependencies, pkg.dependencies]) {
         if (!isJsonRecord(group))
@@ -7560,6 +8212,81 @@ function createGenerations(deps) {
   let closed = false;
   const busy = () => lives.some((live) => live.job.state === "planning" || live.job.state === "building");
   const changed = () => deps.onChange();
+  const records = createRecords(deps.cwd);
+  const runRecord = (prompt) => ({
+    prompt,
+    startedAt: now(),
+    endedAt: null,
+    exitCode: null,
+    timedOut: false,
+    error: null,
+    result: null,
+    tail: []
+  });
+  const ended = (agent, record3, outcome) => {
+    const failed = outcome.timedOut || outcome.error !== null || outcome.code !== 0;
+    record3.endedAt = now();
+    record3.exitCode = outcome.code;
+    record3.timedOut = outcome.timedOut;
+    record3.error = outcome.error;
+    record3.result = agent.result(outcome.lines);
+    record3.tail = failed ? outcome.lines.slice(-40) : [];
+  };
+  const attemptRecord = (live, key, attempt) => live.record?.directions.find((direction) => direction.key === key)?.attempts.find((each) => each.attempt === attempt);
+  const opened = (live, slot, attempt, cause) => {
+    live.record?.directions.find((direction) => direction.key === slot.key)?.attempts.push({
+      attempt,
+      cause,
+      title: slot.title,
+      idea: slot.idea,
+      ideaRun: null,
+      build: null,
+      renders: [],
+      fix: null,
+      state: slot.state,
+      failure: null,
+      fixed: false,
+      layout: [],
+      picture: null
+    });
+  };
+  const saveRecord = (live) => {
+    const { job, record: record3 } = live;
+    if (record3 === null)
+      return;
+    record3.state = job.state;
+    record3.error = job.error;
+    record3.plannedAt = job.plannedAt;
+    record3.endedAt = job.endedAt;
+    for (const slot of job.slots) {
+      const latest = record3.directions.find((each) => each.key === slot.key)?.attempts.at(-1);
+      if (latest === void 0)
+        continue;
+      latest.title = slot.title;
+      latest.idea = slot.idea;
+      latest.state = slot.state;
+      latest.failure = slot.failure === null ? null : { ...slot.failure };
+      latest.fixed = slot.fixed;
+      latest.layout = [...slot.layout];
+    }
+    records.save(record3);
+  };
+  const noted = (live, kind, direction) => {
+    if (live.record === null)
+      return;
+    records.event(live.record.id, { at: now(), kind, direction });
+    saveRecord(live);
+  };
+  const rendered = (live, slot, attempt, report) => {
+    const record3 = attemptRecord(live, slot.key, attempt);
+    if (live.record === null || record3 === void 0)
+      return;
+    record3.renders.push({ at: now(), errors: [...report.errors], layout: [...report.layout] });
+    if (report.frame === null)
+      return;
+    record3.picture = `${slot.key}-${attempt}.jpg`;
+    records.picture(live.record.id, record3.picture, report.frame);
+  };
   let registry = Promise.resolve();
   const serially = (task) => {
     const next = registry.then(task, task);
@@ -7620,8 +8347,10 @@ function createGenerations(deps) {
       });
       child.once("close", (code) => {
         clearTimeout(deadline);
-        if (buffered !== "")
+        if (buffered !== "") {
           lines2.push(buffered);
+          onLine?.(buffered);
+        }
         resolve5({ code, lines: lines2, error: null, timedOut: timedOut2 });
       });
     });
@@ -7664,7 +8393,7 @@ function createGenerations(deps) {
     job.endedAt = now();
   };
   const restore = async (slot) => {
-    await writeFile7(join14(deps.cwd, slot.file), placeholderSource(pascal(slot.key)), "utf8").catch(() => {
+    await writeFile8(join15(deps.cwd, slot.file), placeholderSource(pascal(slot.key)), "utf8").catch(() => {
     });
   };
   const begin = (live, slot) => {
@@ -7721,8 +8450,85 @@ function createGenerations(deps) {
     fail(live, slot, { code: "unexpected", message: message2 });
     settle(live);
     changed();
+    saveRecord(live);
+  };
+  const strayed = async (live, slot, attempt) => {
+    const guard = live.guards.get(guardKey(slot, attempt));
+    if (guard === void 0 || guard.strays.size === 0)
+      return null;
+    const paths = [...guard.strays];
+    const restored = [];
+    const named = [];
+    const building = new Set(lives.flatMap((other) => other.job.slots.flatMap((each) => each.state === "building" || each.state === "checking" ? [normalize3(each.file)] : [])));
+    for (const path of paths) {
+      const kept = guard.kept.get(path);
+      if (kept === void 0 || building.has(path)) {
+        named.push(path);
+        continue;
+      }
+      const back = await writeFile8(join15(deps.cwd, path), kept, "utf8").then(() => true, () => false);
+      (back ? restored : named).push(path);
+    }
+    guard.strays.clear();
+    return {
+      failure: { code: "outside-file", message: strayMessage(paths, restored, named) },
+      putBack: named.length === 0
+    };
+  };
+  const pendingStrays = (except) => {
+    const pending = /* @__PURE__ */ new Map();
+    for (const [key, guard] of lives.flatMap((other) => [...other.guards.entries()])) {
+      if (except !== void 0 && key.startsWith(`${except.key}#`))
+        continue;
+      for (const path of guard.strays) {
+        const kept = guard.kept.get(path);
+        if (kept !== void 0)
+          pending.set(path, kept);
+      }
+    }
+    return pending;
+  };
+  const keptFiles = async (live, own = new Set(live.job.slots.map((slot) => normalize3(slot.file)))) => {
+    const switchPath = live.switchPath;
+    const pending = pendingStrays();
+    const read = async (path) => pending.get(normalize3(path)) ?? await readFile15(join15(deps.cwd, path), "utf8").catch(() => null);
+    const source = await read(switchPath);
+    const kept = /* @__PURE__ */ new Map();
+    if (source === null)
+      return kept;
+    kept.set(normalize3(switchPath), source);
+    const keep = async (path) => {
+      if (path === null || own.has(normalize3(path)) || kept.has(normalize3(path)))
+        return null;
+      const body = await read(path);
+      if (body !== null)
+        kept.set(normalize3(path), body);
+      return body;
+    };
+    for (const direction of readDirections(source)) {
+      const path = await componentFile(deps.cwd, switchPath, direction.from);
+      const body = await keep(path);
+      if (path === null || body === null)
+        continue;
+      for (const match of body.matchAll(/(?:from\s+|import\s*\(?\s*)["'](\.{1,2}\/[^"']+)["']/g)) {
+        await keep(await componentFile(deps.cwd, path, match[1] ?? ""));
+      }
+    }
+    return kept;
   };
   const follow = (live, slot, attempt) => (line) => {
+    const guard = live.guards.get(guardKey(slot, attempt));
+    for (const path of editedFiles(live.agent.id, line, deps.cwd)) {
+      if (guard === void 0 || path === normalize3(slot.file) || guard.strays.has(path))
+        continue;
+      guard.strays.add(path);
+      if (guard.strays.size > 1 || !owns(live, slot, attempt))
+        continue;
+      const running = live.runs.get(slot.key);
+      if (running !== void 0)
+        detach(live, running.stop(), () => {
+        });
+    }
     const activity = activityFrom(live.agent.id, line, deps.cwd);
     if (activity === null || activity === slot.activity || !owns(live, slot, attempt))
       return;
@@ -7739,8 +8545,21 @@ function createGenerations(deps) {
     slot.endedAt = null;
     slot.failure = null;
     slot.fixed = false;
+    slot.layout = [];
     slot.activity = null;
     changed();
+    const key = guardKey(slot, attempt);
+    if (!live.guards.has(key))
+      live.guards.set(key, { kept: await keptFiles(live), strays: /* @__PURE__ */ new Set() });
+    try {
+      if (!owns(live, slot, attempt))
+        return;
+      await buildOwned(live, slot, attempt, concept);
+    } finally {
+      live.guards.delete(key);
+    }
+  };
+  const buildOwned = async (live, slot, attempt, concept) => {
     const others = [...live.concepts.values()].filter((other) => other !== concept);
     const prompt = buildPrompt({
       surface: live.job.surface,
@@ -7753,17 +8572,26 @@ function createGenerations(deps) {
       facts: live.facts ?? "",
       base: live.base
     });
+    const buildRun = runRecord(prompt);
+    const own = attemptRecord(live, slot.key, attempt);
+    if (own !== void 0)
+      own.build = buildRun;
     const building = run4(live.agent, live.agent.build(prompt), BUILD_DEADLINE_MS, follow(live, slot, attempt));
     live.runs.set(slot.key, building);
     const outcome = await building.done;
+    ended(live.agent, buildRun, outcome);
+    saveRecord(live);
+    const outside = await strayed(live, slot, attempt);
     if (!owns(live, slot, attempt))
       return;
     if (live.runs.get(slot.key) === building)
       live.runs.delete(slot.key);
-    const written = await readFile14(join14(deps.cwd, slot.file), "utf8").catch(() => "");
+    const written = await readFile15(join15(deps.cwd, slot.file), "utf8").catch(() => "");
     if (!owns(live, slot, attempt))
       return;
-    if (outcome.timedOut) {
+    if (outside !== null) {
+      fail(live, slot, outside.failure);
+    } else if (outcome.timedOut) {
       fail(live, slot, {
         code: "too-slow",
         message: `The build took longer than ${BUILD_DEADLINE_MS / 6e4} minutes, so Leglas stopped it.`
@@ -7783,19 +8611,25 @@ function createGenerations(deps) {
     }
     settle(live);
     changed();
+    saveRecord(live);
   };
-  const ownErrors = async (live, slot, attempt) => {
+  const ownReport = async (live, slot, attempt) => {
     const others = live.job.slots.filter((other) => other !== slot);
     const until = now() + BUILD_DEADLINE_MS + FIX_DEADLINE_MS;
     for (; ; ) {
-      const report = await deps.render(slot.title);
+      const report = await deps.render(slot.title, { picture: live.record !== null });
       if (!owns(live, slot, attempt))
         return null;
       const errors = report?.errors ?? [];
       const names = (file) => errors.some((error) => error.includes(file));
-      const waiting = !names(slot.file) && others.some((other) => (other.state === "building" || other.state === "checking") && names(other.file));
+      const pending = [...pendingStrays(slot).keys()];
+      const waiting = !names(slot.file) && (pending.some(names) || others.some((other) => (other.state === "building" || other.state === "checking") && names(other.file)));
       if (!waiting || now() >= until) {
-        return errors.filter((error) => !others.some((other) => error.includes(other.file)));
+        return {
+          errors: errors.filter((error) => !others.some((other) => error.includes(other.file))),
+          layout: [...report?.layout ?? []],
+          frame: report?.frame ?? null
+        };
       }
       await wait(RECHECK_MS);
       if (!owns(live, slot, attempt))
@@ -7803,35 +8637,67 @@ function createGenerations(deps) {
     }
   };
   const check = async (live, slot, attempt) => {
-    let errors = await ownErrors(live, slot, attempt);
-    if (errors === null)
+    let report = await ownReport(live, slot, attempt);
+    if (report === null)
       return;
-    if (errors.length > 0) {
-      const fixing = run4(live.agent, live.agent.build(fixPrompt({ file: slot.file, errors })), FIX_DEADLINE_MS, follow(live, slot, attempt));
+    rendered(live, slot, attempt, report);
+    if (report.errors.length > 0 || report.layout.length > 0) {
+      const repairs = report.errors.length > 0;
+      const found = report.layout;
+      const working = repairs ? null : await readFile15(join15(deps.cwd, slot.file), "utf8").catch(() => null);
+      if (!owns(live, slot, attempt))
+        return;
+      const prompt = fixPrompt({ file: slot.file, errors: report.errors, layout: report.layout });
+      const fixRun = runRecord(prompt);
+      const own = attemptRecord(live, slot.key, attempt);
+      if (own !== void 0)
+        own.fix = fixRun;
+      const fixing = run4(live.agent, live.agent.build(prompt), FIX_DEADLINE_MS, follow(live, slot, attempt));
       live.runs.set(slot.key, fixing);
       const outcome = await fixing.done;
+      ended(live.agent, fixRun, outcome);
+      const outside = await strayed(live, slot, attempt);
       if (!owns(live, slot, attempt))
         return;
       slot.activity = null;
       changed();
       if (live.runs.get(slot.key) === fixing)
         live.runs.delete(slot.key);
-      if (outcome.timedOut || outcome.error !== null || outcome.code !== 0) {
-        fail(live, slot, outcome.timedOut ? { code: "too-slow", message: "The fix took too long, so Leglas stopped it." } : failureOf2(live.agent, outcome));
-        return;
+      let failure = outside?.failure ?? (outcome.timedOut ? { code: "too-slow", message: "The fix took too long, so Leglas stopped it." } : outcome.error !== null || outcome.code !== 0 ? failureOf2(live.agent, outcome) : null);
+      if (failure === null) {
+        slot.fixed = repairs;
+        report = await ownReport(live, slot, attempt);
+        if (report === null)
+          return;
+        rendered(live, slot, attempt, report);
+        if (report.errors.length > 0) {
+          failure = {
+            code: "broken",
+            message: `The page still reports: ${report.errors[0] ?? ""}`
+          };
+        }
       }
-      slot.fixed = true;
-      errors = await ownErrors(live, slot, attempt);
-      if (errors === null)
-        return;
-      if (errors.length > 0) {
-        fail(live, slot, {
-          code: "broken",
-          message: `The page still reports: ${errors[0] ?? ""}`
-        });
-        return;
+      const worse = failure === null && !repairs && report.layout.length > found.length;
+      if (failure !== null || worse) {
+        if (working !== null && outside?.putBack !== false) {
+          const restored = await writeFile8(join15(deps.cwd, slot.file), working, "utf8").then(() => true, () => false);
+          if (!owns(live, slot, attempt))
+            return;
+          if (restored) {
+            slot.fixed = false;
+            slot.layout = found;
+            slot.state = "ready";
+            slot.endedAt = now();
+            return;
+          }
+        }
+        if (failure !== null) {
+          fail(live, slot, failure);
+          return;
+        }
       }
     }
+    slot.layout = report.layout;
     slot.state = "ready";
     slot.endedAt = now();
   };
@@ -7844,16 +8710,22 @@ function createGenerations(deps) {
   };
   const plan = async (live, existing) => {
     const { job } = live;
-    const planning = run4(live.agent, live.agent.plan(planPrompt({
+    const prompt = planPrompt({
       surface: job.surface,
       brief: job.brief,
       count: job.count,
       existing,
       base: live.base
-    })), PLAN_DEADLINE_MS);
+    });
+    const planRun = { ...runRecord(prompt), concepts: [] };
+    if (live.record !== null)
+      live.record.plan = planRun;
+    const planning = run4(live.agent, live.agent.plan(prompt), PLAN_DEADLINE_MS);
     live.plan = planning;
     const outcome = await planning.done;
     live.plan = null;
+    ended(live.agent, planRun, outcome);
+    saveRecord(live);
     if (job.state !== "planning")
       return;
     if (outcome.timedOut || outcome.error !== null || outcome.code !== 0) {
@@ -7861,6 +8733,7 @@ function createGenerations(deps) {
       job.error = outcome.timedOut ? "Planning took too long, so Leglas stopped it." : failureOf2(live.agent, outcome).message;
       job.endedAt = now();
       changed();
+      saveRecord(live);
       return;
     }
     let concepts;
@@ -7871,8 +8744,10 @@ function createGenerations(deps) {
       job.error = error instanceof Error ? error.message : String(error);
       job.endedAt = now();
       changed();
+      saveRecord(live);
       return;
     }
+    planRun.concepts = concepts;
     live.facts = factsBlock(await readProjectFacts(deps.cwd, live.switchPath, live.base?.key ?? null), job.surface, live.base);
     const slug = surfaceSlug(job.surface);
     const keys = new Set(existing);
@@ -7880,7 +8755,7 @@ function createGenerations(deps) {
     const folder = dirname8(live.switchPath);
     const slots = [];
     const extension = live.switchPath.endsWith(".jsx") ? "jsx" : "tsx";
-    const taken = async (key) => keys.has(key) || await isFile(join14(deps.cwd, folder, `${key}.${extension}`));
+    const taken = async (key) => keys.has(key) || await isFile(join15(deps.cwd, folder, `${key}.${extension}`));
     for (const concept of concepts) {
       let key = `${slug}-${concept.key}`;
       for (let suffix = 2; await taken(key); suffix += 1)
@@ -7892,23 +8767,25 @@ function createGenerations(deps) {
         key,
         title,
         idea: concept.idea,
-        file: join14(folder, `${key}.${extension}`),
+        file: join15(folder, `${key}.${extension}`),
         state: "building",
         startedAt: null,
         endedAt: null,
         failure: null,
         fixed: false,
+        layout: [],
         activity: null
       });
     }
-    const source = await readFile14(join14(deps.cwd, live.switchPath), "utf8");
+    const source = await readFile15(join15(deps.cwd, live.switchPath), "utf8");
     for (const slot of slots) {
-      await writeFile7(join14(deps.cwd, slot.file), placeholderSource(pascal(slot.key)), {
+      await writeFile8(join15(deps.cwd, slot.file), placeholderSource(pascal(slot.key)), {
         encoding: "utf8",
         flag: "wx"
       });
     }
-    await writeFile7(join14(deps.cwd, live.switchPath), addSlots(source, slots.map((slot) => ({ key: slot.key, name: pascal(slot.key) }))), "utf8");
+    await writeFile8(join15(deps.cwd, live.switchPath), addSlots(source, slots.map((slot) => ({ key: slot.key, name: pascal(slot.key) }))), "utf8");
+    const kept = await keptFiles(live, new Set(slots.map((slot) => normalize3(slot.file))));
     for (const slot of slots) {
       await serially(() => deps.register({
         title: slot.title,
@@ -7918,21 +8795,33 @@ function createGenerations(deps) {
       }));
     }
     job.slots = slots;
+    if (live.record !== null) {
+      live.record.directions = slots.map((slot) => ({
+        key: slot.key,
+        file: slot.file,
+        attempts: []
+      }));
+    }
     if (job.state !== "planning") {
       for (const slot of slots) {
         slot.state = "stopped";
         slot.endedAt = now();
       }
       changed();
+      saveRecord(live);
       return;
     }
     job.state = "building";
     job.plannedAt = now();
     changed();
-    await Promise.all(job.slots.map((slot) => {
+    const builds = job.slots.map((slot) => {
       const attempt = begin(live, slot);
+      live.guards.set(guardKey(slot, attempt), { kept, strays: /* @__PURE__ */ new Set() });
+      opened(live, slot, attempt, "plan");
       return guarded(build(live, slot, attempt), (message2) => lost(live, slot, attempt, message2));
-    }));
+    });
+    saveRecord(live);
+    await Promise.all(builds);
   };
   const find = (id) => lives.find((live) => live.job.id === id);
   const stop = async (id, key) => {
@@ -7944,6 +8833,7 @@ function createGenerations(deps) {
       job.state = "stopped";
       job.endedAt = now();
       changed();
+      noted(live, "stop", null);
       await live.plan?.stop();
       await drain(live);
       return true;
@@ -7956,6 +8846,8 @@ function createGenerations(deps) {
     }
     settle(live);
     changed();
+    if (targets.length > 0)
+      noted(live, "stop", key ?? null);
     await Promise.all(targets.map((slot) => release(live, slot)));
     return targets.length > 0;
   };
@@ -7990,7 +8882,7 @@ function createGenerations(deps) {
           error: `The ${slug} has no switch file yet. Run \`leglas new ${slug} --from <your component>\` and render ${pascal(slug)}Switch where the ${slug} is, then build directions into it.`
         };
       }
-      const existing = directionKeys(await readFile14(join14(deps.cwd, switchPath), "utf8"));
+      const existing = directionKeys(await readFile15(join15(deps.cwd, switchPath), "utf8"));
       if (base !== null && !existing.includes(base.key)) {
         return {
           ok: false,
@@ -8029,19 +8921,54 @@ function createGenerations(deps) {
         attempts: /* @__PURE__ */ new Map(),
         base,
         agent: agent === "codex" ? codex(await codexServers(deps.codexHome)) : CLAUDE,
-        pending: /* @__PURE__ */ new Set()
+        guards: /* @__PURE__ */ new Map(),
+        pending: /* @__PURE__ */ new Set(),
+        record: null
       };
+      const recording = deps.record?.() !== false;
+      if (recording)
+        await records.prune();
+      const baseSet = base === null || !recording ? null : await setOfKey(deps.cwd, base.key).catch(() => null);
       if (busy())
         return { ok: false, error: BUSY };
       lives.push(live);
       while (lives.length > KEPT_JOBS)
         lives.shift();
       changed();
+      if (recording) {
+        live.record = {
+          version: 1,
+          id: job.id,
+          surface: slug,
+          brief,
+          count,
+          agent,
+          args: argsOf(live.agent),
+          basedOn: base === null ? null : { title: base.title, key: base.key, set: baseSet },
+          state: job.state,
+          error: null,
+          startedAt: job.startedAt,
+          plannedAt: null,
+          endedAt: null,
+          plan: null,
+          directions: []
+        };
+        saveRecord(live);
+        if (base !== null && baseSet !== null) {
+          records.event(baseSet, {
+            at: now(),
+            kind: "more-like",
+            direction: base.key,
+            detail: job.id
+          });
+        }
+      }
       detach(live, plan(live, existing), (message2) => {
         job.state = "failed";
         job.error = message2;
         job.endedAt = now();
         changed();
+        saveRecord(live);
       });
       return { ok: true, job: copy(job) };
     },
@@ -8056,10 +8983,12 @@ function createGenerations(deps) {
       slot.state = "building";
       slot.startedAt = now();
       slot.failure = null;
+      opened(live, slot, attempt, "retry");
       detach(live, restore(slot).then(() => build(live, slot, attempt)), (message2) => lost(live, slot, attempt, message2));
       live.job.state = "building";
       live.job.endedAt = null;
       changed();
+      noted(live, "retry", slot.key);
       return true;
     },
     replace(id, key) {
@@ -8071,18 +9000,27 @@ function createGenerations(deps) {
       slot.state = "building";
       slot.startedAt = now();
       slot.failure = null;
+      opened(live, slot, attempt, "replace");
       live.job.state = "building";
       live.job.endedAt = null;
       changed();
+      noted(live, "replace", slot.key);
       const replacing = async () => {
-        const asking = run4(live.agent, live.agent.plan(replacePrompt2({
+        const prompt = replacePrompt2({
           surface: live.job.surface,
           brief: live.job.brief,
           avoid: [...live.concepts.values()],
           base: live.base
-        })), PLAN_DEADLINE_MS);
+        });
+        const ideaRun = runRecord(prompt);
+        const own = attemptRecord(live, slot.key, attempt);
+        if (own !== void 0)
+          own.ideaRun = ideaRun;
+        const asking = run4(live.agent, live.agent.plan(prompt), PLAN_DEADLINE_MS);
         live.runs.set(slot.key, asking);
         const outcome = await asking.done;
+        ended(live.agent, ideaRun, outcome);
+        saveRecord(live);
         if (!owns(live, slot, attempt))
           return;
         if (live.runs.get(slot.key) === asking)
@@ -8099,6 +9037,7 @@ function createGenerations(deps) {
           });
           settle(live);
           changed();
+          saveRecord(live);
           return;
         }
         const titles = new Set(await deps.titles());
@@ -8118,6 +9057,7 @@ function createGenerations(deps) {
         live.concepts.set(slot.key, { ...concept, title });
         slot.title = title;
         slot.idea = concept.idea;
+        saveRecord(live);
         if (!owns(live, slot, attempt))
           return;
         await restore(slot);
@@ -8135,35 +9075,36 @@ function createGenerations(deps) {
         })),
         wait(KILL_GRACE_MS * 2 + 1e3)
       ]);
+      await Promise.race([records.flush(), wait(KILL_GRACE_MS)]);
     }
   };
 }
 
 // ../server/dist/server-info.js
-import { lstat as lstat2, mkdir as mkdir7, readFile as readFile15, rename as rename2, rm as rm4, writeFile as writeFile8 } from "fs/promises";
-import { dirname as dirname9, join as join15 } from "path";
+import { lstat as lstat2, mkdir as mkdir8, readFile as readFile16, rename as rename4, rm as rm6, writeFile as writeFile9 } from "fs/promises";
+import { dirname as dirname9, join as join16 } from "path";
 var SERVER_INFO_PATH = ".leglas/server.json";
 async function writeServerInfo(cwd, info) {
-  const path = join15(cwd, SERVER_INFO_PATH);
+  const path = join16(cwd, SERVER_INFO_PATH);
   const directory = dirname9(path);
-  await mkdir7(directory, { recursive: true });
+  await mkdir8(directory, { recursive: true });
   if (!(await lstat2(directory)).isDirectory())
     return;
   const existing = await lstat2(path).catch(() => null);
   if (existing !== null && !existing.isFile())
     return;
   const temporary = `${path}.${process.pid}.tmp`;
-  await writeFile8(temporary, `${JSON.stringify({ ...info, startedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2)}
+  await writeFile9(temporary, `${JSON.stringify({ ...info, startedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2)}
 `, "utf8");
-  await rename2(temporary, path).catch(async (cause) => {
-    await rm4(temporary, { force: true }).catch(() => {
+  await rename4(temporary, path).catch(async (cause) => {
+    await rm6(temporary, { force: true }).catch(() => {
     });
     throw cause;
   });
 }
 async function readServerInfo(cwd) {
   try {
-    const value = parseJson(await readFile15(join15(cwd, SERVER_INFO_PATH), "utf8"));
+    const value = parseJson(await readFile16(join16(cwd, SERVER_INFO_PATH), "utf8"));
     if (!isJsonRecord(value) || !isNumber(value.port) || !Number.isInteger(value.port) || value.port < 1 || value.port > 65535 || !isString(value.url) || value.url === "" || !isNumber(value.pid) || !Number.isInteger(value.pid))
       return null;
     return { port: value.port, url: value.url, pid: value.pid };
@@ -8177,7 +9118,7 @@ async function removeServerInfo(cwd, expected) {
     if (current !== null && (current.port !== expected.port || current.pid !== expected.pid))
       return;
   }
-  await rm4(join15(cwd, SERVER_INFO_PATH), { force: true });
+  await rm6(join16(cwd, SERVER_INFO_PATH), { force: true });
 }
 
 // ../server/dist/server.js
@@ -8326,7 +9267,7 @@ function probe(target, timeoutMs = 1e3) {
       return resolve5(false);
     }
     const port = Number(url.port || (url.protocol === "https:" ? 443 : 80));
-    const socket = net3.connect(port, url.hostname);
+    const socket = net3.connect(port, url.hostname.replace(/^\[|\]$/g, ""));
     const settle = (reachable) => {
       socket.destroy();
       resolve5(reachable);
@@ -8338,8 +9279,8 @@ function probe(target, timeoutMs = 1e3) {
   });
 }
 function serveFrom(res, dir, relativePath) {
-  const relative8 = normalize2(relativePath).replace(/^(\.\.[/\\])+/, "");
-  const candidate = join16(dir, relative8);
+  const relative9 = normalize4(relativePath).replace(/^(\.\.[/\\])+/, "");
+  const candidate = join17(dir, relative9);
   if (!candidate.startsWith(dir))
     return false;
   if (!existsSync3(candidate) || !statSync(candidate).isFile())
@@ -8353,9 +9294,9 @@ function serveFrom(res, dir, relativePath) {
   return true;
 }
 function serveShellFile(res, shellDir, urlPath) {
-  const relative8 = normalize2(urlPath.slice(LEGLAS_PREFIX.length)).replace(/^(\.\.[/\\])+/, "");
-  const isRoot = relative8 === "" || relative8 === "." || relative8 === "/";
-  return serveFrom(res, shellDir, isRoot ? "index.html" : relative8);
+  const relative9 = normalize4(urlPath.slice(LEGLAS_PREFIX.length)).replace(/^(\.\.[/\\])+/, "");
+  const isRoot = relative9 === "" || relative9 === "." || relative9 === "/";
+  return serveFrom(res, shellDir, isRoot ? "index.html" : relative9);
 }
 var HEALTH_PROBE_MS = 3e3;
 function fileStamp(path) {
@@ -8367,11 +9308,11 @@ function fileStamp(path) {
   }
 }
 function watchLiveFiles(cwd, configPath, live) {
-  const leglasDir = join16(cwd, ".leglas");
+  const leglasDir = join17(cwd, ".leglas");
   const targets = [
-    { path: join16(cwd, LOCAL_PREVIEWS_PATH), change: "config" },
-    { path: join16(cwd, REQUESTS_PATH), change: "requests" },
-    { path: join16(cwd, ANNOTATIONS_PATH), change: "requests" }
+    { path: join17(cwd, LOCAL_PREVIEWS_PATH), change: "config" },
+    { path: join17(cwd, REQUESTS_PATH), change: "requests" },
+    { path: join17(cwd, ANNOTATIONS_PATH), change: "requests" }
   ];
   const byName = new Map(targets.map((target) => [basename3(target.path), target]));
   const known = new Map(targets.map((target) => [target.path, fileStamp(target.path)]));
@@ -9024,6 +9965,7 @@ async function startServer(options) {
             });
           }
           const deleted = await dropLocalPreviews(cwd, unique);
+          await noteDirections(cwd, unique, "remove");
           return sendJson2(res, 200, { ok: true, deleted });
         } catch {
           return sendJson2(res, 500, {
@@ -9072,8 +10014,8 @@ async function startServer(options) {
         const id = newRequestId();
         const file = `${REFERENCES_DIR}/${id}.${image.kind}`;
         try {
-          await mkdir8(join16(cwd, REFERENCES_DIR), { recursive: true });
-          await writeFile9(join16(cwd, file), body);
+          await mkdir9(join17(cwd, REFERENCES_DIR), { recursive: true });
+          await writeFile10(join17(cwd, file), body);
           void pruneReferences(cwd).catch(() => {
           });
           return sendJson2(res, 200, {
@@ -9115,7 +10057,7 @@ async function startServer(options) {
         }
         const references = parsed2.references ?? [];
         if (references.length > 0) {
-          const present = new Set((await readdir5(join16(cwd, REFERENCES_DIR)).catch(() => [])).map((name) => name.slice(0, name.indexOf(".") === -1 ? name.length : name.indexOf("."))));
+          const present = new Set((await readdir6(join17(cwd, REFERENCES_DIR)).catch(() => [])).map((name) => name.slice(0, name.indexOf(".") === -1 ? name.length : name.indexOf("."))));
           const gone = references.filter((id2) => !present.has(id2));
           if (gone.length > 0) {
             return sendJson2(res, 410, {
@@ -9145,9 +10087,8 @@ async function startServer(options) {
         };
         const compare = isString(parsed2.compare) && parsed2.compare !== preview.title ? previews.find((entry) => entry.title === parsed2.compare) ?? null : null;
         const sameContext = (entry) => (entry.compare ?? null) === (compare?.title ?? null) && [...entry.references ?? []].sort().join(",") === [...references].sort().join(",");
-        if (live2.some((entry) => entry.title === preview.title && entry.intent === intent && // The same words in the other mode are not the same request:
-        // one forks the direction and the other rewrites it. Only a
-        // genuine repeat is refused.
+        if (live2.some((entry) => entry.title === preview.title && entry.intent === intent && // The same words in the other mode aren't the same request: one
+        // forks, one rewrites.
         (entry.mode ?? "replace") === mode && sameNotes(entry) && sameContext(entry))) {
           return sendJson2(res, 409, {
             ok: false,
@@ -9172,9 +10113,8 @@ async function startServer(options) {
             title: preview.title,
             url: preview.url,
             intent,
-            // The ids travel with the request so a change made in place can
-            // forget the notes it answered. A fork leaves them where they are:
-            // the direction they point at was not touched.
+            // The ids travel with the request so a change in place can forget
+            // the notes it answered. A fork leaves them.
             ...composed
           };
           if (notes.length > 0)
@@ -9278,8 +10218,8 @@ async function startServer(options) {
           const noteSuffix = isString(parsed2.note) ? `-${parsed2.note.replace(/[^A-Za-z0-9_-]+/g, "-")}` : "";
           const name = `${captureSlug(preview.title)}-${result.frame.width}${noteSuffix}.png`;
           const relativeFile = `${CAPTURES_DIR}/show/${name}`;
-          await mkdir8(join16(cwd, CAPTURES_DIR, "show"), { recursive: true });
-          await writeFile9(join16(cwd, relativeFile), shot.png);
+          await mkdir9(join17(cwd, CAPTURES_DIR, "show"), { recursive: true });
+          await writeFile10(join17(cwd, relativeFile), shot.png);
           return sendJson2(res, 200, {
             ok: true,
             file: relativeFile,
@@ -9414,16 +10354,14 @@ async function startServer(options) {
           title,
           intent,
           // A fork leaves its parent's document alone; the interface keeps
-          // the parent's duplicate verdict on the strength of this.
+          // the parent's duplicate verdict because of this.
           mode,
-          // Which pins this change speaks for. The interface marks them, so
-          // a note already sitting in a prompt an agent holds does not look
-          // like one nobody has read.
+          // Which pins this change speaks for, so the interface can show a
+          // note already in an agent's prompt as read.
           notes: notes ?? [],
-          // The run in flight is the one thing the file cannot know. After
-          // that the file is the record, including across a restart, and the
-          // process-local failed set only covers a request whose verdict
-          // could not be written.
+          // The file can't know the run in flight. Otherwise it's the record,
+          // across restarts; the in-memory failed set only covers a verdict
+          // that couldn't be written.
           status: snapshot.running && snapshot.requestId === id ? "running" : status === "queued" && snapshot.failedIds.includes(id) ? "failed" : status,
           failure: failure ?? null
         })),
@@ -9433,13 +10371,13 @@ async function startServer(options) {
           name: snapshot.running ? snapshot.agent : null,
           activity: snapshot.running ? snapshot.activity : null,
           startedAt: snapshot.running ? snapshot.startedAt : null,
-          // A stop that has been asked for but not yet obeyed. The card
-          // says so rather than going on describing a live run.
+          // A stop asked for but not yet obeyed, so the card stops describing
+          // a live run.
           stopping: snapshot.running && snapshot.stopping,
           // Why a run that looks stalled is stalled, while it is stalled.
           waiting: snapshot.running ? snapshot.waiting : null,
-          // When a run that has gone quiet last said anything. A run on its
-          // way out is not quiet, it is stopping.
+          // When a quiet run last said anything. A run on its way out is
+          // stopping, not quiet.
           quietSince: snapshot.running && !snapshot.stopping ? snapshot.quietSince : null
         }
       }));
@@ -9496,12 +10434,11 @@ async function startServer(options) {
             url: request.url,
             intent: request.intent,
             target: request.target,
-            // The prompt names the captures by path, and the embedded pipes
-            // are not its only readers: watch, a custom command and
-            // `requests --json` all hand the text over as it stands.
+            // The prompt names captures by path, and watch, a custom command
+            // and `requests --json` hand the text over as is.
             prompt: attachments.length === 0 ? request.prompt : rehomeText(request.prompt, request.id, retryId)
-            // The stored prompt already carries the mode's instructions;
-            // its notes and visual context travel with the retry too.
+            // The stored prompt already carries the mode's instructions; its
+            // notes and visual context travel with the retry.
           };
           if (request.mode !== void 0)
             retry.mode = request.mode;
@@ -9659,15 +10596,15 @@ async function startServer(options) {
       const rest = path.slice(FILES_PREFIX.length + 1);
       const slash = rest.indexOf("/");
       const slug = slash === -1 ? rest : rest.slice(0, slash);
-      let relative8 = slash === -1 ? "" : rest.slice(slash + 1);
+      let relative9 = slash === -1 ? "" : rest.slice(slash + 1);
       try {
-        relative8 = decodeURIComponent(relative8);
+        relative9 = decodeURIComponent(relative9);
       } catch {
-        relative8 = "";
+        relative9 = "";
       }
       const dir = fileMounts.get(slug);
       const serveMount = () => {
-        if (dir !== void 0 && relative8 !== "" && serveFrom(res, dir, relative8))
+        if (dir !== void 0 && relative9 !== "" && serveFrom(res, dir, relative9))
           return;
         res.writeHead(404, {
           "content-type": "text/plain; charset=utf-8",
@@ -9677,7 +10614,7 @@ async function startServer(options) {
       };
       if (!context.remote)
         return serveMount();
-      if (relative8.split("/").some((segment) => segment.startsWith("."))) {
+      if (relative9.split("/").some((segment) => segment.startsWith("."))) {
         return sendJson2(res, 403, { ok: false, error: "Not available to viewers." });
       }
       return void (shares?.fileSlugAllowed(slug, context.grantId ?? "") ?? Promise.resolve(false)).then((allowed) => {
@@ -9778,7 +10715,7 @@ async function startServer(options) {
   if (options.claudeAgentSession !== void 0)
     runnerOptions.claudeAgentSession = options.claudeAgentSession;
   runner = startRunner(runnerOptions);
-  const renderDirection = async (title) => {
+  const renderDirection = async (title, { picture = false } = {}) => {
     const preview = (await livePreviews()).find((entry) => entry.title === title);
     if (preview === void 0)
       return null;
@@ -9787,15 +10724,29 @@ async function startServer(options) {
       return null;
     const address = server.address();
     const renderPort = address !== null && !isString(address) ? address.port : options.port ?? DEFAULT_PORT;
+    const url = previewUrl(`http://127.0.0.1:${renderPort}`, preview);
+    const settings = { width: 1440, timeoutMs: CAPTURE_LOAD_MS, inspect: true };
     try {
       const captured = await capturePage(browser, {
-        url: previewUrl(`http://127.0.0.1:${renderPort}`, preview),
-        width: 1440,
-        timeoutMs: CAPTURE_LOAD_MS
+        ...settings,
+        url,
+        jpeg: picture
       });
-      return { errors: captured.errors };
+      const layout = captured.layout.map(describeFinding);
+      const frame = captured.jpeg;
+      if (layout.length === 0)
+        return { errors: captured.errors, layout, frame };
+      const plain = new URL(url);
+      plain.search = new URLSearchParams([...plain.searchParams].filter(([key]) => !key.startsWith("v-"))).toString();
+      const before = await capturePage(browser, { ...settings, url: plain.href }).catch(() => null);
+      const known = new Set(before?.layout.map(describeFinding) ?? []);
+      return {
+        errors: captured.errors,
+        layout: layout.filter((line) => !known.has(line)),
+        frame
+      };
     } catch (error) {
-      return { errors: [error instanceof Error ? error.message : String(error)] };
+      return { errors: [error instanceof Error ? error.message : String(error)], layout: [] };
     }
   };
   const generationDeps = {
@@ -9809,7 +10760,8 @@ async function startServer(options) {
       const local = await readLocalPreviews(cwd).catch(() => null);
       return new Set([...config?.previews ?? [], ...local?.previews ?? []].map((entry) => entry.title));
     },
-    onChange: () => live.nudge("generation")
+    onChange: () => live.nudge("generation"),
+    record: () => config?.recordSets !== false
   };
   if (options.generationSpawn !== void 0)
     generationDeps.spawn = options.generationSpawn;
@@ -9852,10 +10804,10 @@ async function startServer(options) {
 
 // ../server/dist/update.js
 import { spawn as spawnChild2 } from "child_process";
-import { existsSync as existsSync4, readFileSync, realpathSync } from "fs";
-import { lstat as lstat3, mkdir as mkdir9, mkdtemp, rename as rename3, rm as rm5, writeFile as writeFile10 } from "fs/promises";
+import { existsSync as existsSync4, readFileSync, realpathSync as realpathSync2 } from "fs";
+import { lstat as lstat3, mkdir as mkdir10, mkdtemp, rename as rename5, rm as rm7, writeFile as writeFile11 } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname11, join as join17, posix as posix2, win32 } from "path";
+import { dirname as dirname11, join as join18, posix as posix2, win32 } from "path";
 var DAY_MS = 24 * 60 * 60 * 1e3;
 var INSTALL_DEADLINE_MS = 5 * 60 * 1e3;
 var REGISTRY = "https://registry.npmjs.org";
@@ -9867,7 +10819,7 @@ function normalized(path) {
 }
 function realPath(path) {
   try {
-    return realpathSync(path);
+    return realpathSync2(path);
   } catch {
     return null;
   }
@@ -10055,7 +11007,7 @@ function restartCommand(install, argv, latest, port, options) {
     return spawnCommand(["leglas", ...rest], options.platform);
   }
   if (install.kind === "project" && install.root !== void 0) {
-    const shim = (windows ? win32.join : join17)(install.root, "node_modules", ".bin", windows ? "leglas.cmd" : "leglas");
+    const shim = (windows ? win32.join : join18)(install.root, "node_modules", ".bin", windows ? "leglas.cmd" : "leglas");
     return spawnCommand(options.exists(shim) ? [shim, ...rest] : ["yarn", "leglas", ...rest], options.platform);
   }
   throw new Error(CHECKOUT_NOTICE);
@@ -10086,7 +11038,7 @@ function readState(path) {
 }
 function defaultStatePath(home) {
   try {
-    return join17(home(), ".leglas", "update.json");
+    return join18(home(), ".leglas", "update.json");
   } catch {
     return null;
   }
@@ -10105,21 +11057,21 @@ async function writeState(path, state) {
   let temporary = null;
   try {
     const directory = dirname11(path);
-    await mkdir9(directory, { recursive: true });
+    await mkdir10(directory, { recursive: true });
     if (!(await lstat3(directory)).isDirectory())
       return;
     const existing = await lstat3(path).catch(() => null);
     if (existing !== null && !existing.isFile())
       return;
-    temporary = await mkdtemp(join17(directory, ".update-"));
-    const file = join17(temporary, "update.json");
-    await writeFile10(file, `${JSON.stringify(state, null, 2)}
+    temporary = await mkdtemp(join18(directory, ".update-"));
+    const file = join18(temporary, "update.json");
+    await writeFile11(file, `${JSON.stringify(state, null, 2)}
 `, "utf8");
-    await rename3(file, path);
+    await rename5(file, path);
   } catch {
   } finally {
     if (temporary !== null)
-      await rm5(temporary, { recursive: true, force: true }).catch(() => {
+      await rm7(temporary, { recursive: true, force: true }).catch(() => {
       });
   }
 }
@@ -10497,7 +11449,7 @@ async function runClassify(options, deps) {
   const declared = await Promise.all(
     options.changes.map(async (change) => ({
       ...change,
-      exists: await stat5(join18(options.cwd, change.path)).then(
+      exists: await stat5(join19(options.cwd, change.path)).then(
         () => true,
         () => false
       )
@@ -10819,6 +11771,38 @@ async function findLeglas(cwd, port, request) {
     return { ok: false, error: NOT_RUNNING };
   }
 }
+function interfaceUrl(port, titles) {
+  const url = new URL(`http://localhost:${port}${LEGLAS_PREFIX}`);
+  const [direction, compare] = titles;
+  if (direction !== void 0) url.searchParams.set("direction", direction);
+  if (compare !== void 0) url.searchParams.set("compare", compare);
+  return url.href;
+}
+async function railTitles(port, request) {
+  try {
+    const response = await request(`http://127.0.0.1:${port}${LEGLAS_PREFIX}/api/config`, {
+      signal: AbortSignal.timeout(2e3)
+    });
+    if (!response.ok) return null;
+    const payload = await bodyOf(response);
+    if (!isJsonObject(payload) || !Array.isArray(payload.previews)) return null;
+    return new Set(
+      payload.previews.flatMap(
+        (preview) => isJsonObject(preview) && isString2(preview.title) ? [preview.title] : []
+      )
+    );
+  } catch {
+    return null;
+  }
+}
+async function recordedRail(cwd, request) {
+  const record3 = await readServerInfo(cwd);
+  if (record3 === null) return null;
+  const found = await findLeglas(cwd, record3.port, request);
+  if (!found.ok) return null;
+  const titles = await railTitles(found.port, request);
+  return titles === null ? null : { port: found.port, titles };
+}
 
 // src/run-explore-build.ts
 var POLL_MS2 = 1e3;
@@ -10894,13 +11878,13 @@ async function runExploreBuild(options, deps) {
   const deadline = Date.now() + WAIT_MS;
   while (Date.now() < deadline) {
     await sleep(POLL_MS2);
-    let listed;
+    let listed2;
     try {
-      listed = await bodyOf(await request(base));
+      listed2 = await bodyOf(await request(base));
     } catch {
       return fail("Leglas stopped answering while the directions were being built.");
     }
-    const jobs = isJsonObject(listed) ? listed.jobs : void 0;
+    const jobs = isJsonObject(listed2) ? listed2.jobs : void 0;
     const latest = Array.isArray(jobs) ? jobs.map(readJob).find((candidate) => candidate?.id === first.id) : void 0;
     if (latest === void 0 || latest === null) continue;
     job = latest;
@@ -10938,8 +11922,8 @@ async function runExploreBuild(options, deps) {
 }
 
 // src/run-init.ts
-import { readFile as readFile16, writeFile as writeFile11 } from "fs/promises";
-import { join as join19 } from "path";
+import { readFile as readFile17, writeFile as writeFile12 } from "fs/promises";
+import { join as join20 } from "path";
 
 // src/init.ts
 var AGENTS_MARKER_START = "<!-- leglas:start -->";
@@ -11052,6 +12036,12 @@ Useful to know:
 - Titles identify previews and must be unique. The user may rename one in the
   rail, which renames it on their machine only; the commands answer to either
   name, so use whichever they said.
+- \`npx leglas link "<title>"\` prints a link that opens the interface on that
+  direction, and \`npx leglas link "<new>" "<old>"\` one that puts two side by
+  side. Give it to the user when you finish a direction they asked for, rather
+  than telling them where to click.
+- \`npx leglas remove "<title>"\` takes a direction registered on this machine
+  off the rail when the user asks. One the config lists is theirs to edit.
 - \`npx leglas list\` shows every direction, shared and local.
 - \`npx leglas show "<title>" --json\` answers for one of them: the file behind it,
   the variants based on it, what it is being compared against and anything
@@ -11101,7 +12091,7 @@ ${AGENTS_SECTION}`
 // src/run-init.ts
 async function readIfPresent(path) {
   try {
-    return await readFile16(path, "utf8");
+    return await readFile17(path, "utf8");
   } catch {
     return null;
   }
@@ -11109,18 +12099,18 @@ async function readIfPresent(path) {
 async function runInit(options, deps) {
   const existingConfig = findConfigFile(options.cwd);
   const plan = planInit({
-    agents: await readIfPresent(join19(options.cwd, "AGENTS.md")),
+    agents: await readIfPresent(join20(options.cwd, "AGENTS.md")),
     config: existingConfig === null ? null : "present",
-    gitignore: await readIfPresent(join19(options.cwd, ".gitignore")),
+    gitignore: await readIfPresent(join20(options.cwd, ".gitignore")),
     force: options.force
   });
   const touched = [];
   for (const write2 of plan.writes) {
-    await writeFile11(join19(options.cwd, write2.path), write2.contents, "utf8");
+    await writeFile12(join20(options.cwd, write2.path), write2.contents, "utf8");
     touched.push(write2.path);
   }
   if (plan.gitignore !== null) {
-    await writeFile11(join19(options.cwd, ".gitignore"), plan.gitignore, "utf8");
+    await writeFile12(join20(options.cwd, ".gitignore"), plan.gitignore, "utf8");
     touched.push(".gitignore");
   }
   if (options.json) {
@@ -11140,11 +12130,11 @@ async function runInit(options, deps) {
 
 // src/run-keep.ts
 import { existsSync as existsSync5 } from "fs";
-import { copyFile as copyFile2, mkdir as mkdir10, readFile as readFile17, rm as rm6, writeFile as writeFile12 } from "fs/promises";
-import { dirname as dirname12, isAbsolute as isAbsolute3, join as join20, relative as relative5 } from "path";
+import { copyFile as copyFile2, mkdir as mkdir11, readFile as readFile18, rm as rm8, writeFile as writeFile13 } from "fs/promises";
+import { dirname as dirname12, isAbsolute as isAbsolute3, join as join21, relative as relative5 } from "path";
 
 // src/keep.ts
-import { basename as basename4, extname as extname4, isAbsolute as isAbsolute2, normalize as normalize3 } from "path";
+import { basename as basename4, extname as extname4, isAbsolute as isAbsolute2, normalize as normalize5 } from "path";
 function surfaceOf(url) {
   if (!url.startsWith("/") || !url.includes("?")) return null;
   for (const pair of url.slice(url.indexOf("?") + 1).split("&")) {
@@ -11173,7 +12163,7 @@ function planKeep(options) {
       error: `Cannot tell which file produces ${JSON.stringify(options.title)}. Its URL (${winner.url}) was not generated by leglas new, so there is nothing safe to move.`
     };
   }
-  const to = normalize3(options.to);
+  const to = normalize5(options.to);
   if (to.startsWith("..") || isAbsolute2(to)) {
     return { ok: false, error: "The destination has to be inside the project." };
   }
@@ -11229,15 +12219,15 @@ async function writeLogEntry(options) {
     annotations: await readAnnotations(options.cwd),
     date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)
   });
-  const dir = join20(options.cwd, options.logDir);
-  await mkdir10(dir, { recursive: true });
-  const file = join20(dir, `${entry.slug}.md`);
-  await writeFile12(file, entry.markdown, "utf8");
+  const dir = join21(options.cwd, options.logDir);
+  await mkdir11(dir, { recursive: true });
+  const file = join21(dir, `${entry.slug}.md`);
+  await writeFile13(file, entry.markdown, "utf8");
   if (entry.pictures.length > 0) {
-    const pictureDir = join20(dir, entry.slug);
-    await mkdir10(pictureDir, { recursive: true });
+    const pictureDir = join21(dir, entry.slug);
+    await mkdir11(pictureDir, { recursive: true });
     for (const picture of entry.pictures) {
-      await copyFile2(join20(options.cwd, picture.from), join20(pictureDir, picture.to)).catch(() => {
+      await copyFile2(join21(options.cwd, picture.from), join21(pictureDir, picture.to)).catch(() => {
       });
     }
   }
@@ -11261,17 +12251,17 @@ async function runKeep(options, deps) {
   const destination = isAbsolute3(options.to) ? relative5(options.cwd, options.to) : options.to;
   const plan = planKeep({ title: resolved.title, previews, to: destination });
   if (!plan.ok) return fail(plan.error);
-  const from = join20(options.cwd, plan.move.from);
-  const to = join20(options.cwd, plan.move.to);
+  const from = join21(options.cwd, plan.move.from);
+  const to = join21(options.cwd, plan.move.to);
   if (!existsSync5(from)) {
     return fail(`${plan.move.from} does not exist. Nothing to keep.`);
   }
   if (existsSync5(to)) {
     return fail(`${plan.move.to} already exists. Choose another destination or move it aside.`);
   }
-  const source = await readFile17(from, "utf8");
-  await mkdir10(dirname12(to), { recursive: true });
-  await writeFile12(to, renameExport(source, plan.exportName), "utf8");
+  const source = await readFile18(from, "utf8");
+  await mkdir11(dirname12(to), { recursive: true });
+  await writeFile13(to, renameExport(source, plan.exportName), "utf8");
   const surface = plan.removeDir.slice(plan.removeDir.lastIndexOf("/") + 1);
   let logged = null;
   let logError = null;
@@ -11286,8 +12276,9 @@ async function runKeep(options, deps) {
   } catch (error) {
     logError = error instanceof Error ? error.message : String(error);
   }
-  await rm6(join20(options.cwd, plan.removeDir), { recursive: true, force: true });
+  await rm8(join21(options.cwd, plan.removeDir), { recursive: true, force: true });
   const dropped = await dropLocalPreviews(options.cwd, plan.dropTitles);
+  await noteDirections(options.cwd, [resolved.title], "keep", plan.move.to);
   if (options.json) {
     deps.log(
       JSON.stringify({
@@ -11323,13 +12314,99 @@ async function runKeep(options, deps) {
   return { exitCode: 0 };
 }
 
+// src/run-link.ts
+async function runLink(options, deps) {
+  const fail = (error) => {
+    if (options.json) deps.log(JSON.stringify({ ok: false, error }));
+    else deps.error(error);
+    return { exitCode: 1 };
+  };
+  const loaded = await loadConfig(options.cwd);
+  const local = await readLocalPreviews(options.cwd);
+  const renames = await readRenames(options.cwd);
+  const known = [
+    ...new Set(
+      [...loaded.config?.previews ?? [], ...local.previews].map((preview) => preview.title)
+    )
+  ];
+  const titles = [];
+  for (const asked of options.titles) {
+    const resolved = resolveOrExplain(asked, known, renames);
+    if (!resolved.ok) return fail(resolved.error);
+    titles.push(resolved.title);
+  }
+  const [first, second] = titles;
+  if (first !== void 0 && first === second) {
+    return fail(`Both names are ${first}. Name two different directions to put side by side.`);
+  }
+  const request = deps.fetch ?? fetch;
+  const found = await findLeglas(options.cwd, options.port, request);
+  if (!found.ok) return fail(found.error);
+  const rail = await railTitles(found.port, request);
+  if (rail === null) return fail("Leglas did not say which directions are on its rail.");
+  const absent = titles.find((title) => !rail.has(title));
+  if (absent !== void 0) {
+    return fail(
+      `${absent} isn't on the running rail yet. A branch or file direction joins it when Leglas restarts.`
+    );
+  }
+  const url = interfaceUrl(found.port, titles);
+  if (options.json) deps.log(JSON.stringify({ ok: true, url }));
+  else deps.log(url);
+  return { exitCode: 0 };
+}
+
+// src/run-remove.ts
+import { relative as relative6 } from "path";
+async function runRemove(options, deps) {
+  const fail = (error) => {
+    if (options.json) deps.log(JSON.stringify({ ok: false, error }));
+    else deps.error(error);
+    return { exitCode: 1 };
+  };
+  const loaded = await loadConfig(options.cwd);
+  const local = await readLocalPreviews(options.cwd);
+  if (local.errors.length > 0) {
+    return fail(`${LOCAL_PREVIEWS_PATH} has entries Leglas can't read: ${local.errors.join(" ")}`);
+  }
+  const known = [
+    ...new Set(
+      [...loaded.config?.previews ?? [], ...local.previews].map((preview) => preview.title)
+    )
+  ];
+  const renames = await readRenames(options.cwd);
+  const titles = [];
+  for (const asked of options.titles) {
+    const resolved = resolveOrExplain(asked, known, renames);
+    if (!resolved.ok) return fail(resolved.error);
+    if (!titles.includes(resolved.title)) titles.push(resolved.title);
+  }
+  const registered = new Set(local.previews.map((preview) => preview.title));
+  const listed2 = new Set((loaded.config?.previews ?? []).map((preview) => preview.title));
+  const shared = titles.find((title) => listed2.has(title) || !registered.has(title));
+  if (shared !== void 0) {
+    const where = loaded.path === null ? "the config" : relative6(options.cwd, loaded.path);
+    return fail(`${shared} is in ${where}, which the project shares. Remove it there.`);
+  }
+  await dropLocalPreviews(options.cwd, titles);
+  await noteDirections(options.cwd, titles, "remove");
+  if (options.json) {
+    deps.log(JSON.stringify({ ok: true, removed: titles }));
+  } else {
+    for (const title of titles) deps.log(`  removed  ${title}`);
+    deps.log("");
+    deps.log(`The files behind ${titles.length === 1 ? "it" : "them"} stay where they are.`);
+  }
+  return { exitCode: 0 };
+}
+
 // src/run-new.ts
 import { existsSync as existsSync6 } from "fs";
-import { mkdir as mkdir11, readFile as readFile18, writeFile as writeFile13 } from "fs/promises";
-import { dirname as dirname13, join as join21 } from "path";
+import { mkdir as mkdir12, readFile as readFile19, writeFile as writeFile14 } from "fs/promises";
+import { dirname as dirname13, join as join22 } from "path";
 async function readIfPresent2(path) {
   try {
-    return await readFile18(path, "utf8");
+    return await readFile19(path, "utf8");
   } catch {
     return null;
   }
@@ -11337,7 +12414,7 @@ async function readIfPresent2(path) {
 async function runNew(options, deps) {
   let from;
   if (options.from !== void 0) {
-    const contents = await readIfPresent2(join21(options.cwd, options.from));
+    const contents = await readIfPresent2(join22(options.cwd, options.from));
     if (contents === null) {
       const message2 = `${options.from} does not exist, so there is nothing to use as the baseline.`;
       if (options.json) deps.log(JSON.stringify({ ok: false, error: message2 }));
@@ -11348,8 +12425,8 @@ async function runNew(options, deps) {
   }
   const plan = planNew({
     surface: options.surface,
-    packageJson: await readIfPresent2(join21(options.cwd, "package.json")),
-    gitignore: await readIfPresent2(join21(options.cwd, ".gitignore")),
+    packageJson: await readIfPresent2(join22(options.cwd, "package.json")),
+    gitignore: await readIfPresent2(join22(options.cwd, ".gitignore")),
     from
   });
   const fail = (error) => {
@@ -11379,7 +12456,7 @@ async function runNew(options, deps) {
     deps.log(plan.instructions);
     return { exitCode: 0, written: [] };
   }
-  const existing = plan.writes.filter((write2) => existsSync6(join21(options.cwd, write2.path)));
+  const existing = plan.writes.filter((write2) => existsSync6(join22(options.cwd, write2.path)));
   if (existing.length > 0) {
     return fail(
       `${existing[0]?.path} already exists. Delete it first, or pick another surface name.`
@@ -11387,13 +12464,13 @@ async function runNew(options, deps) {
   }
   const written = [];
   for (const write2 of plan.writes) {
-    const target = join21(options.cwd, write2.path);
-    await mkdir11(dirname13(target), { recursive: true });
-    await writeFile13(target, write2.contents, "utf8");
+    const target = join22(options.cwd, write2.path);
+    await mkdir12(dirname13(target), { recursive: true });
+    await writeFile14(target, write2.contents, "utf8");
     written.push(write2.path);
   }
   if (plan.gitignore !== null) {
-    await writeFile13(join21(options.cwd, ".gitignore"), plan.gitignore, "utf8");
+    await writeFile14(join22(options.cwd, ".gitignore"), plan.gitignore, "utf8");
     written.push(".gitignore");
   }
   if (options.json) {
@@ -11421,8 +12498,8 @@ async function runNew(options, deps) {
 }
 
 // src/run-log.ts
-import { readFile as readFile19, readdir as readdir6 } from "fs/promises";
-import { join as join22 } from "path";
+import { readFile as readFile20, readdir as readdir7 } from "fs/promises";
+import { join as join23 } from "path";
 function headline(markdown) {
   const first = markdown.split("\n", 1)[0] ?? "";
   return first.replace(/^#\s*/, "").trim();
@@ -11432,7 +12509,7 @@ async function runLog(options, deps) {
   const dir = loaded.config?.logDir ?? DEFAULT_LOG_DIR;
   let names;
   try {
-    names = (await readdir6(join22(options.cwd, dir))).filter((name) => name.endsWith(".md")).sort().reverse();
+    names = (await readdir7(join23(options.cwd, dir))).filter((name) => name.endsWith(".md")).sort().reverse();
   } catch {
     names = [];
   }
@@ -11445,7 +12522,7 @@ async function runLog(options, deps) {
       else deps.error(error);
       return { exitCode: 1 };
     }
-    const markdown = await readFile19(join22(options.cwd, dir, found), "utf8");
+    const markdown = await readFile20(join23(options.cwd, dir, found), "utf8");
     if (options.json) deps.log(JSON.stringify({ ok: true, entry: wanted, markdown }));
     else deps.log(markdown.trimEnd());
     return { exitCode: 0 };
@@ -11453,7 +12530,7 @@ async function runLog(options, deps) {
   const entries = await Promise.all(
     names.map(async (name) => ({
       entry: name.replace(/\.md$/, ""),
-      title: headline(await readFile19(join22(options.cwd, dir, name), "utf8")),
+      title: headline(await readFile20(join23(options.cwd, dir, name), "utf8")),
       file: `${dir}/${name}`
     }))
   );
@@ -11471,21 +12548,21 @@ async function runLog(options, deps) {
 }
 
 // src/run-previews.ts
-import { readFile as readFile20, writeFile as writeFile14 } from "fs/promises";
-import { join as join23 } from "path";
+import { readFile as readFile21, writeFile as writeFile15 } from "fs/promises";
+import { join as join24 } from "path";
 function envelope(deps, ok, body) {
   deps.log(JSON.stringify({ ok, ...body }));
 }
 async function ensureIgnored(cwd) {
-  const path = join23(cwd, ".gitignore");
+  const path = join24(cwd, ".gitignore");
   let current = null;
   try {
-    current = await readFile20(path, "utf8");
+    current = await readFile21(path, "utf8");
   } catch {
     current = null;
   }
   const next = ignoreEntry(current);
-  if (next !== null) await writeFile14(path, next, "utf8");
+  if (next !== null) await writeFile15(path, next, "utf8");
 }
 async function runAdd(options, deps) {
   const loaded = await loadConfig(options.cwd);
@@ -11521,6 +12598,8 @@ async function runAdd(options, deps) {
   }
   await ensureIgnored(options.cwd);
   const needsDevCommand = options.preview.branch !== void 0 && loaded.config?.devCommand === void 0;
+  const rail = await recordedRail(options.cwd, deps.fetch ?? fetch);
+  const opens = rail !== null && rail.titles.has(options.preview.title) ? interfaceUrl(rail.port, [options.preview.title]) : null;
   if (options.json) {
     const added = { added: options.preview.title };
     if (options.preview.url !== void 0) added.url = options.preview.url;
@@ -11531,11 +12610,13 @@ async function runAdd(options, deps) {
     if (needsDevCommand) {
       added.warning = "The config sets no devCommand, so Leglas cannot start this branch yet. Add devCommand (with {port}) to the config.";
     }
+    if (opens !== null) added.interfaceUrl = opens;
     envelope(deps, true, added);
   } else {
     deps.log(
       `  added  ${options.preview.title}  ${options.preview.url ?? options.preview.file ?? ""}`
     );
+    if (opens !== null) deps.log(`  open   ${opens}`);
     deps.log("");
     if (needsDevCommand) {
       deps.log("  ! The config sets no devCommand, so Leglas cannot start this branch yet.");
@@ -11559,12 +12640,10 @@ async function runList(options, deps) {
     ...local.previews
   ];
   if (options.json) {
+    const rail = await recordedRail(options.cwd, deps.fetch ?? fetch);
     envelope(deps, errors.length === 0, {
-      // The whole record, not a summary of it. What the config holds about a
-      // preview — its note, its tags, the direction it is a variant of — is
-      // exactly what tells an agent why these are being compared, and leaving
-      // it out made the listing thinner than the reference block that points
-      // at it.
+      // The whole record: a preview's note, tags and base direction are what
+      // tell an agent why these are being compared.
       previews: previews.map((preview) => ({
         title: preview.title,
         url: preview.url,
@@ -11574,7 +12653,8 @@ async function runList(options, deps) {
         askedFor: preview.askedFor ?? null,
         local: preview.local,
         branch: preview.branch ?? null,
-        file: preview.file ?? null
+        file: preview.file ?? null,
+        interfaceUrl: rail !== null && rail.titles.has(preview.title) ? interfaceUrl(rail.port, [preview.title]) : null
       })),
       errors
     });
@@ -11653,8 +12733,11 @@ function tunnelFrom(value) {
   }
 }
 function linkFrom(value) {
-  if (!isJsonObject(value) || !isString2(value.localUrl) || !isNumber2(value.expiresAt)) return null;
+  if (!isJsonObject(value) || !isString2(value.id) || !isString2(value.localUrl) || !isNumber2(value.expiresAt)) {
+    return null;
+  }
   return {
+    id: value.id,
     name: isString2(value.name) ? value.name : "",
     url: isString2(value.url) ? value.url : null,
     localUrl: value.localUrl,
@@ -11775,11 +12858,12 @@ async function runShare(options, deps) {
   const running = await readShare(found.base, request);
   if (!running.ok) return fail(running.error);
   const { installed } = running.value;
-  const report = (share2, already, leftOut2) => {
+  const report = (share2, already, leftOut2, done = null) => {
     if (options.json) {
       deps.log(
         JSON.stringify({
           ok: true,
+          ...done?.json,
           alreadySharing: already,
           share: {
             scope: share2.scope,
@@ -11793,6 +12877,7 @@ async function runShare(options, deps) {
       );
       return { exitCode: 0 };
     }
+    if (done !== null) deps.log(done.line);
     deps.log(`  sharing  ${describe(share2)}${already ? " (already running)" : ""}`);
     if (share2.reach === "listed") {
       deps.log("  reach    only the paths the share lists; allow more from the share panel");
@@ -11802,6 +12887,9 @@ async function runShare(options, deps) {
       if (link.url !== null) deps.log(`  link     ${label}${link.url}`);
       else deps.log(`  local    ${label}${link.localUrl}`);
     }
+    if (share2.links.length === 0) {
+      deps.log("  links    no link is live; npx leglas share --rotate starts one");
+    }
     const tunnel = tunnelLine(share2.tunnel, installed);
     if (tunnel !== null) deps.log(`  tunnel   ${tunnel}`);
     const ends = share2.links.map((link) => link.expiresAt);
@@ -11812,6 +12900,66 @@ async function runShare(options, deps) {
     deps.log("  stop     npx leglas share --stop");
     return { exitCode: 0 };
   };
+  const settle = async (share2) => {
+    let settled2 = share2;
+    for (let waited = 0; settled2.tunnel.status === "starting" && waited < TUNNEL_WAIT_MS; waited += TUNNEL_POLL_MS) {
+      await sleep(TUNNEL_POLL_MS);
+      const read = await readShare(found.base, request);
+      if (!read.ok) return read;
+      if (read.value.share === null) return { ok: true, value: null };
+      settled2 = read.value.share;
+    }
+    return { ok: true, value: settled2 };
+  };
+  const revoke = options.revoke ?? null;
+  if (options.rotate === true || revoke !== null) {
+    const current2 = running.value.share;
+    if (current2 === null) {
+      return fail("Nothing is being shared. Start a share with npx leglas share.");
+    }
+    if (revoke !== null) {
+      const named = revoke;
+      const link = current2.links.find(
+        (candidate) => candidate.id === named || candidate.url === named || candidate.localUrl === named
+      );
+      if (link === void 0) {
+        return fail(`No live link is ${JSON.stringify(named)}. npx leglas share lists them.`);
+      }
+      const revoked = await post(
+        found.base,
+        "/leglas/api/share/grants/revoke",
+        { id: link.id },
+        request,
+        "Leglas could not end that link."
+      );
+      if (!revoked.ok) return fail(revoked.error);
+      const after = isJsonObject(revoked.value) ? shareFrom(revoked.value.share) : null;
+      if (after === null) return fail("Leglas ended the link but did not say what is left.");
+      return report(after, true, [], {
+        json: { revoked: link },
+        line: `  revoked  ${link.name === "" ? "" : `${link.name}  `}${link.url ?? link.localUrl}`
+      });
+    }
+    const rotated = await post(
+      found.base,
+      "/leglas/api/share/rotate",
+      {},
+      request,
+      "Leglas could not replace the links."
+    );
+    if (!rotated.ok) return fail(rotated.error);
+    const replaced = isJsonObject(rotated.value) ? shareFrom(rotated.value.share) : null;
+    if (replaced === null) return fail("Leglas replaced the links but did not say with what.");
+    const settled2 = await settle(replaced);
+    if (!settled2.ok) return fail(settled2.error);
+    if (settled2.value === null) {
+      return fail("The share was stopped while its new tunnel was starting.");
+    }
+    return report(settled2.value, true, [], {
+      json: { rotated: true },
+      line: "  rotated  every earlier link has ended"
+    });
+  }
   const loaded = await loadConfig(options.cwd);
   const local = await readLocalPreviews(options.cwd);
   const renames = await readRenames(options.cwd);
@@ -11880,20 +13028,16 @@ async function runShare(options, deps) {
   if (!created.ok) {
     return created.answered ? fail(created.error) : giveUp("Leglas stopped answering while the share was starting.", false);
   }
-  let share = isJsonObject(created.value) ? shareFrom(created.value.share) : null;
+  const share = isJsonObject(created.value) ? shareFrom(created.value.share) : null;
   if (share === null) {
     return giveUp("Leglas started a share this version of the command cannot read.");
   }
-  for (let waited = 0; share.tunnel.status === "starting" && waited < TUNNEL_WAIT_MS; waited += TUNNEL_POLL_MS) {
-    await sleep(TUNNEL_POLL_MS);
-    const read = await readShare(found.base, request);
-    if (!read.ok) return giveUp(read.error);
-    if (read.value.share === null) {
-      return fail("The share was stopped while its tunnel was starting.");
-    }
-    share = read.value.share;
+  const settled = await settle(share);
+  if (!settled.ok) return giveUp(settled.error);
+  if (settled.value === null) {
+    return fail("The share was stopped while its tunnel was starting.");
   }
-  return report(share, false, leftOut);
+  return report(settled.value, false, leftOut);
 }
 
 // src/show.ts
@@ -11907,9 +13051,9 @@ function describe2(preview) {
     branch: preview.branch ?? null,
     file: preview.file ?? null,
     local: preview.local === true,
-    // A file preview names its own source. Everything else is decoded from the
+    // A file preview names its own source; anything else is decoded from the
     // URL, and a URL outside the convention yields nothing rather than a path
-    // that looks authoritative and is not there.
+    // that isn't there.
     target: preview.file ?? targetFor(preview.url)
   };
 }
@@ -11927,8 +13071,7 @@ function planShow({ title, previews, requests }) {
     ok: true,
     direction: describe2(found),
     variants,
-    // Its own variants are already listed in full, so they are not repeated
-    // here; this is the rest of the comparison.
+    // Its variants are listed above, so this is the rest of the comparison.
     comparedWith: previews.map((preview) => preview.title).filter((other) => other !== title && !variantTitles.has(other)),
     requests: requests.filter((request) => request.title === title).map((request) => ({
       id: request.id,
@@ -11980,21 +13123,23 @@ async function runShow(options, deps) {
   }
   const envelope2 = {
     ok: true,
-    direction: plan.direction,
+    direction: { ...plan.direction, interfaceUrl: null },
     variants: plan.variants,
     comparedWith: plan.comparedWith,
     requests: plan.requests
   };
+  const request = deps.fetch ?? fetch;
+  let running = null;
   if (options.screenshot) {
     const fail = (error) => {
       if (options.json) deps.log(JSON.stringify({ ok: false, error }));
       else deps.error(error);
       return { exitCode: 1 };
     };
-    const request = deps.fetch ?? fetch;
     const found = await findLeglas(options.cwd, options.port, request);
     if (!found.ok) return fail(found.error);
     const port = found.port;
+    running = port;
     let response;
     try {
       response = await request(`http://127.0.0.1:${port}/leglas/api/capture`, {
@@ -12028,17 +13173,22 @@ async function runShow(options, deps) {
       cut: captured.cut === true
     };
   }
+  const rail = running === null ? await recordedRail(options.cwd, request) : { port: running, titles: await railTitles(running, request) ?? /* @__PURE__ */ new Set() };
+  if (rail !== null && rail.titles.has(plan.direction.title)) {
+    envelope2.direction.interfaceUrl = interfaceUrl(rail.port, [plan.direction.title]);
+  }
   if (options.json) {
     deps.log(JSON.stringify(envelope2));
     return { exitCode: 0 };
   }
-  const { direction } = plan;
+  const { direction } = envelope2;
   deps.log(`  ${direction.title}${direction.local ? "  (local)" : ""}`);
   if (direction.note !== null) deps.log(`  ${direction.note}`);
   deps.log("");
   if (direction.target !== null) deps.log(`  file        ${direction.target}`);
   if (direction.branch !== null) deps.log(`  branch      ${direction.branch}`);
   deps.log(`  url         ${direction.url}`);
+  if (direction.interfaceUrl !== null) deps.log(`  open        ${direction.interfaceUrl}`);
   if (direction.tags.length > 0) deps.log(`  tags        ${direction.tags.join(", ")}`);
   if (direction.basedOn !== null) deps.log(`  variant of  ${direction.basedOn}`);
   if (plan.variants.length > 0) {
@@ -12067,7 +13217,7 @@ async function runShow(options, deps) {
   if (plan.requests.length > 0) {
     deps.log("");
     deps.log(`  Pending, not yet done (${plan.requests.length}):`);
-    for (const request of plan.requests) deps.log(`    ${request.status}  ${request.intent}`);
+    for (const request2 of plan.requests) deps.log(`    ${request2.status}  ${request2.intent}`);
     deps.log("");
     deps.log("  Run npx leglas requests --json for the full prompts.");
   }
@@ -12076,21 +13226,21 @@ async function runShow(options, deps) {
 
 // src/run-watch.ts
 import { spawn as spawn4 } from "child_process";
-import { mkdir as mkdir12, readFile as readFile21, writeFile as writeFile15 } from "fs/promises";
-import { dirname as dirname14, join as join24 } from "path";
+import { mkdir as mkdir13, readFile as readFile22, writeFile as writeFile16 } from "fs/promises";
+import { dirname as dirname14, join as join25 } from "path";
 var POLL_MS3 = 2e3;
 var HEARTBEAT_TIMEOUT_MS = 1e3;
 async function saveTemplate(cwd, run4) {
-  const path = join24(cwd, WATCH_PATH);
+  const path = join25(cwd, WATCH_PATH);
   let config = {};
   try {
-    const parsed2 = JSON.parse(await readFile21(path, "utf8"));
+    const parsed2 = JSON.parse(await readFile22(path, "utf8"));
     if (isJsonObject(parsed2)) config = parsed2;
   } catch {
   }
   config.run = run4;
-  await mkdir12(dirname14(path), { recursive: true });
-  await writeFile15(path, `${JSON.stringify(config, null, 2)}
+  await mkdir13(dirname14(path), { recursive: true });
+  await writeFile16(path, `${JSON.stringify(config, null, 2)}
 `, "utf8");
 }
 function spawnAgent(command, args, cwd, json) {
@@ -12254,7 +13404,7 @@ async function runWatch(options, deps) {
 
 // src/bin-start.ts
 import { spawn as spawn5 } from "child_process";
-import { realpathSync as realpathSync2 } from "fs";
+import { realpathSync as realpathSync3 } from "fs";
 
 // src/shutdown.ts
 var SHUTDOWN_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
@@ -12332,13 +13482,13 @@ function createHandoff() {
 import { existsSync as existsSync7 } from "fs";
 import { realpath as realpath4 } from "fs/promises";
 import { createRequire } from "module";
-import { basename as basename6, dirname as dirname15, join as join25, relative as relative7, resolve as resolve4 } from "path";
+import { basename as basename6, dirname as dirname15, join as join26, relative as relative8, resolve as resolve4 } from "path";
 import { fileURLToPath } from "url";
 
 // src/dev-server-owner.ts
 import { execFile as execFile2 } from "child_process";
 import { realpath as realpath3 } from "fs/promises";
-import { basename as basename5, isAbsolute as isAbsolute4, relative as relative6, resolve as resolve3 } from "path";
+import { basename as basename5, isAbsolute as isAbsolute4, relative as relative7, resolve as resolve3 } from "path";
 import { promisify as promisify2 } from "util";
 var run2 = promisify2(execFile2);
 var LOCAL_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
@@ -12407,7 +13557,7 @@ async function inspectLocalDevServer(origin) {
   }
 }
 function isInside(parent, child) {
-  const path = relative6(resolve3(parent), resolve3(child));
+  const path = relative7(resolve3(parent), resolve3(child));
   return path === "" || !path.startsWith("..") && !isAbsolute4(path);
 }
 function devServerOwnerWarning(origin, projectRoot, owners) {
@@ -12421,8 +13571,8 @@ function devServerOwnerWarning(origin, projectRoot, owners) {
 
 // src/run.ts
 function findShellDir() {
-  const bundled = join25(dirname15(fileURLToPath(import.meta.url)), "shell");
-  if (existsSync7(join25(bundled, "index.html"))) return bundled;
+  const bundled = join26(dirname15(fileURLToPath(import.meta.url)), "shell");
+  if (existsSync7(join26(bundled, "index.html"))) return bundled;
   try {
     const require2 = createRequire(import.meta.url);
     return dirname15(require2.resolve("@leglas/shell/dist/index.html"));
@@ -12436,7 +13586,7 @@ function shellWord(value) {
   return `'${value.replaceAll("'", `'\\''`)}'`;
 }
 function embeddedLeglasCommand() {
-  const entry = join25(dirname15(fileURLToPath(import.meta.url)), "bin.js");
+  const entry = join26(dirname15(fileURLToPath(import.meta.url)), "bin.js");
   if (!existsSync7(entry)) return "npx -y leglas";
   return [process.execPath, entry].map(shellWord).join(" ");
 }
@@ -12475,7 +13625,7 @@ async function runWithServices(options, deps, services = {}) {
   const fileMounts = /* @__PURE__ */ new Map();
   for (const preview of merged?.previews ?? []) {
     if (preview.file !== void 0) {
-      const absolute = join25(options.cwd, preview.file);
+      const absolute = join26(options.cwd, preview.file);
       if (!existsSync7(absolute)) {
         previewErrors.push(
           `"${preview.title}" names file ${preview.file}, which does not exist. The preview is skipped.`
@@ -12507,8 +13657,8 @@ async function runWithServices(options, deps, services = {}) {
     configWarnings,
     fileMounts,
     shellDir: findShellDir(),
-    // The config file identifies the project when there is one; otherwise the
-    // directory does. Either way saved layout survives a port change.
+    // The config file identifies the project, else the directory, so saved
+    // layout survives a port change.
     project: loaded.path ?? options.cwd,
     cwd: options.cwd,
     leglasCommand: embeddedLeglasCommand()
@@ -12537,7 +13687,7 @@ async function runWithServices(options, deps, services = {}) {
       })
     );
   } else {
-    const configLabel = loaded.path === null ? "no config file, previewing the app root" : relative7(options.cwd, loaded.path) || loaded.path;
+    const configLabel = loaded.path === null ? "no config file, previewing the app root" : relative8(options.cwd, loaded.path) || loaded.path;
     deps.log(`Leglas   ${url}`);
     deps.log(
       `app      ${devServer}${app !== null ? "  (started by Leglas)" : health.reachable ? "" : "  (not reachable)"}`
@@ -12594,7 +13744,7 @@ async function runWithServices(options, deps, services = {}) {
 async function startViewer(options, deps) {
   let entry = deps.entry;
   try {
-    entry = (deps.realpath ?? realpathSync2)(entry);
+    entry = (deps.realpath ?? realpathSync3)(entry);
   } catch {
   }
   const updates = (deps.createUpdateService ?? createUpdateService)({
@@ -12627,7 +13777,7 @@ async function startViewer(options, deps) {
   }, handoff.target);
 }
 
-// src/bin.ts
+// src/help.ts
 var HELP = `leglas - compare design directions inside your own running app
 
 Usage
@@ -12641,25 +13791,30 @@ Usage
   leglas log [entry]         What past explorations decided
   leglas show <title>        Everything Leglas knows about one direction
   leglas share [title] [title]  Share the rail, one direction or a pair
+  leglas link [title] [title]   A link that opens the interface on them
+  leglas remove <title>...   Take directions this machine registered off the rail
   leglas requests            Show change requests made from the interface
   leglas watch --run "<cmd>" Hand each request to your agent as it arrives
   leglas keep <title> --to <path>  Keep a winner and end the exploration
 
 Options
   --user-port <port>   Port your dev server is on (default: from config, or 3000)
-  --port <port>        Port for Leglas itself (default: 4100, next free if taken)
+  --port <port>        Port for Leglas itself (default: ${DEFAULT_PORT}, next free if taken)
   --config <path>      Config file to use instead of searching upward
   --no-open            Do not open the browser
   --json               Print a single machine-readable envelope
   -h, --help           Show this
   -v, --version        Show the version
 
+Options for init
+  --force              Rewrite the AGENTS.md section if it is already there
+
 Options for new
   --print              Print the scaffold instead of writing it
   --from <path>        Use an existing component as the baseline
 
 Options for explore
-  --count <n>          How many directions (default 3; up to 6 with --build)
+  --count <n>          How many directions (default ${DEFAULT_EXPLORE_COUNT}; up to ${MAX_DIRECTIONS} with --build)
   --based-on <title>     Variants of an existing direction instead of new ones
   --build              Build the set with your agent (Claude or Codex) in the
                        running Leglas, instead of printing a brief for an agent
@@ -12667,10 +13822,13 @@ Options for explore
                        with --based-on)
   --port <port>        Running Leglas port (needs --build)
 
+Options for requests
+  --clear              Acknowledge the requests once they are done
+
 Options for watch
   --run <command>      Your agent, with {prompt} where the request goes, for
                        example "claude -p {prompt}". Remembered after first use
-  --port <port>        Port Leglas itself is on (default: 4100)
+  --port <port>        Port Leglas itself is on (default: ${DEFAULT_PORT})
   --json               One JSON line per event; the agent's output goes to stderr
 
 Options for classify
@@ -12687,15 +13845,22 @@ Options for add
 
 Options for show
   --screenshot         Render the direction and write a PNG
-  --width <n>          Capture width from 320 to 3840 (needs --screenshot)
+  --width <n>          Capture width from ${MIN_SHOW_WIDTH} to ${MAX_SHOW_WIDTH} (needs --screenshot)
   --port <port>        Running Leglas port (needs --screenshot)
 
 Options for share
-  --reach <open|listed>  How far viewers reach into the app (default open)
+  --reach <open|listed>  How far viewers reach into the app (default ${DEFAULT_SHARE_REACH})
   --tunnel <name>      cloudflared, ngrok or none (default: the first found)
   --stop               End the share, and every link to it
+  --rotate             End every link and start a new one, through a new tunnel
+  --revoke <link>      End one link, named by its address or its id
+  --port <port>        Running Leglas port
+
+Options for link
   --port <port>        Running Leglas port
 `;
+
+// src/bin.ts
 function version() {
   const require2 = createRequire2(import.meta.url);
   const pkg = require2("../package.json");
@@ -12827,6 +13992,8 @@ if (parsed.kind === "share") {
       reach: parsed.reach,
       tunnel: parsed.tunnel,
       stop: parsed.stop,
+      rotate: parsed.rotate,
+      revoke: parsed.revoke,
       port: parsed.port,
       json: parsed.json,
       cwd: process.cwd()
@@ -12835,6 +14002,20 @@ if (parsed.kind === "share") {
   );
   process.exit(outcome.exitCode);
 }
+if (parsed.kind === "remove") {
+  const outcome = await runRemove(
+    { titles: parsed.titles, json: parsed.json, cwd: process.cwd() },
+    previewDeps
+  );
+  process.exit(outcome.exitCode);
+}
+if (parsed.kind === "link") {
+  const outcome = await runLink(
+    { titles: parsed.titles, port: parsed.port, json: parsed.json, cwd: process.cwd() },
+    previewDeps
+  );
+  process.exit(outcome.exitCode);
+}
 if (parsed.kind === "show") {
   const outcome = await runShow(
     {