leglas 1.2.1 → 1.3.0

package/dist/bin.js

@@ -169,8 +169,13 @@ function parseClassify(rest) {
 function parseWatch(rest) {
   let run4;
   let port;
+  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 !== "--run" && flag !== "--port") {
@@ -191,7 +196,7 @@ function parseWatch(rest) {
     if ("error" in parsed2) return { kind: "error", message: parsed2.error };
     port = parsed2.port;
   }
-  return { kind: "watch", run: run4, port };
+  return { kind: "watch", run: run4, port, json };
 }
 function parseShare(rest) {
   const titles = [];
@@ -330,12 +335,38 @@ function parseArgs(argv) {
     let count = 3;
     let basedOn = null;
     let json = false;
+    let build = false;
+    let brief = null;
+    let port = null;
     for (let index = 0; index < rest.length; index += 1) {
       const argument = rest[index];
       if (argument === "--json") {
         json = true;
         continue;
       }
+      if (argument === "--build") {
+        build = true;
+        continue;
+      }
+      if (argument === "--brief" || argument.startsWith("--brief=")) {
+        const raw = argument.includes("=") ? argument.slice(argument.indexOf("=") + 1) : rest[index += 1];
+        if (raw === void 0 || raw.trim() === "") {
+          return {
+            kind: "error",
+            message: '--brief needs a description, for example --brief "A hero for a cooking app".'
+          };
+        }
+        brief = raw;
+        continue;
+      }
+      if (argument === "--port" || argument.startsWith("--port=")) {
+        const raw = argument.includes("=") ? argument.split("=")[1] : rest[index += 1];
+        if (raw === void 0 || !/^\d+$/.test(raw)) {
+          return { kind: "error", message: "--port needs a number, for example --port 4000." };
+        }
+        port = Number(raw);
+        continue;
+      }
       if (argument === "--count" || argument.startsWith("--count=")) {
         const raw = argument.includes("=") ? argument.split("=")[1] : rest[index += 1];
         if (raw === void 0 || !/^\d+$/.test(raw)) {
@@ -369,7 +400,19 @@ function parseArgs(argv) {
         message: "leglas explore needs a surface name, for example: npx leglas explore hero --count 6"
       };
     }
-    return { kind: "explore", surface, count, basedOn, json };
+    if (build && brief === null && basedOn === null) {
+      return {
+        kind: "error",
+        message: 'leglas explore --build needs a brief, for example: npx leglas explore hero --build --brief "A hero for a cooking app". To vary a direction instead, name it with --based-on "<title>".'
+      };
+    }
+    if (!build && brief !== null) {
+      return {
+        kind: "error",
+        message: "--brief goes with --build: add --build to have Leglas build the set."
+      };
+    }
+    return { kind: "explore", surface, count, basedOn, json, build, brief, port };
   }
   if (argv[0] === "requests") {
     const rest = argv.slice(1);
@@ -515,8 +558,8 @@ function parseArgs(argv) {
 }
 
 // src/run-classify.ts
-import { stat as stat4 } from "fs/promises";
-import { join as join14 } from "path";
+import { stat as stat5 } from "fs/promises";
+import { join as join18 } from "path";
 
 // ../server/dist/log.js
 var DEFAULT_LOG_DIR = "design-log";
@@ -597,8 +640,8 @@ function composeEntry(input) {
 }
 
 // ../server/dist/json.js
-function parseJson(text2) {
-  return JSON.parse(text2);
+function parseJson(text3) {
+  return JSON.parse(text3);
 }
 function isJsonRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -918,7 +961,7 @@ var KNOWN_AGENTS = {
     // moves that precondition and only that: `-s workspace-write` still
     // confines writes to the project, so the sandbox boundary is unchanged,
     // and in a git repository the flag does nothing at all.
-    args: (prompt, effort = null, images = []) => [
+    args: (prompt, effort = null, images2 = []) => [
       "exec",
       "--json",
       ...CODEX_WORKSPACE_CONFIG,
@@ -926,23 +969,23 @@ var KNOWN_AGENTS = {
       "-s",
       "workspace-write",
       "--skip-git-repo-check",
-      ...images.flatMap((image) => ["-i", image]),
+      ...images2.flatMap((image) => ["-i", image]),
       prompt
     ],
-    terminalArgs: (prompt, effort = null, images = []) => [
+    terminalArgs: (prompt, effort = null, images2 = []) => [
       "exec",
       ...CODEX_WORKSPACE_CONFIG,
       ...codexEffortConfig(effort),
       "-s",
       "workspace-write",
       "--skip-git-repo-check",
-      ...images.flatMap((image) => ["-i", image]),
+      ...images2.flatMap((image) => ["-i", image]),
       prompt
     ],
     // No sandbox flag here: `codex exec resume` refuses it and inherits the
     // session's own sandbox, which the first turn set to workspace-write. The
     // repository check is per invocation, so resume needs the flag of its own.
-    resumeArgs: (sessionId, prompt, effort = null, images = []) => [
+    resumeArgs: (sessionId, prompt, effort = null, images2 = []) => [
       "exec",
       "resume",
       sessionId,
@@ -950,7 +993,7 @@ var KNOWN_AGENTS = {
       ...CODEX_WORKSPACE_CONFIG,
       ...codexEffortConfig(effort),
       "--skip-git-repo-check",
-      ...images.flatMap((image) => ["-i", image]),
+      ...images2.flatMap((image) => ["-i", image]),
       prompt
     ],
     sessionFrom: (event) => event.type === "thread.started" && isString(event.thread_id) ? event.thread_id : null,
@@ -1785,12 +1828,12 @@ function buildNumber(entry) {
   const digits = /(\d+)\s*$/.exec(entry)?.[1];
   return digits === void 0 ? 0 : Number(digits);
 }
-function cacheRoots(platform, home, readdir5 = readableDirectories) {
+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");
   const newestFirst = (dir, keep = () => true) => ({
     root: dir,
-    entries: readdir5(dir).filter(keep).sort((left, right) => buildNumber(right) - buildNumber(left))
+    entries: readdir7(dir).filter(keep).sort((left, right) => buildNumber(right) - buildNumber(left))
   });
   return [
     newestFirst(playwright, (entry) => entry.startsWith("chromium-") || entry.startsWith("chromium_headless_shell-")),
@@ -1811,13 +1854,13 @@ function findBrowser(search = {}) {
   const home = search.home ?? homedir();
   const exists = search.exists ?? existsSync2;
   const onPath = search.onPath ?? ((name) => firstOnPath(name, env));
-  const readdir5 = search.readdir ?? readableDirectories;
+  const readdir7 = 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, readdir5);
+  const caches = cacheRoots(platform, home, readdir7);
   const shell = firstExisting(caches.flatMap(({ root, entries }) => entries.flatMap((entry) => HEADLESS_SHELL.map((rest) => join4(root, entry, ...rest)))));
   if (shell !== null)
     return shell;
@@ -1847,7 +1890,7 @@ function findBrowser(search = {}) {
   }
   if (platform === "darwin" || platform === "linux") {
     const playwrightRoot = platform === "darwin" ? join4(home, "Library", "Caches", "ms-playwright") : join4(home, ".cache", "ms-playwright");
-    const playwright = readdir5(playwrightRoot).filter((entry) => entry.startsWith("chromium-") || entry.startsWith("chromium_headless_shell-")).sort((left, right) => buildNumber(right) - buildNumber(left)).flatMap((entry) => {
+    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);
       return [
         ...FOR_TESTING.map((rest) => join4(root, ...rest)),
@@ -1864,7 +1907,7 @@ function findBrowser(search = {}) {
     const puppeteerCache = join4(home, ".cache", "puppeteer");
     for (const kind of ["chrome", "chrome-headless-shell"]) {
       const kindRoot = join4(puppeteerCache, kind);
-      const found = firstExisting(readdir5(kindRoot).sort((left, right) => buildNumber(right) - buildNumber(left)).flatMap((entry) => {
+      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));
       }));
@@ -1904,7 +1947,7 @@ async function connectWebSocket(url) {
     socket.addEventListener("error", failed, { once: true });
   });
   return {
-    send: (text2) => socket.send(text2),
+    send: (text3) => socket.send(text3),
     onMessage: (listener) => socket.addEventListener("message", (event) => listener(String(event.data))),
     onClose: (listener) => socket.addEventListener("close", listener),
     close: () => socket.close()
@@ -2129,10 +2172,10 @@ async function launchBrowser(executable, options = {}) {
     socketClosed = true;
     rejectPending();
   });
-  socket.onMessage((text2) => {
+  socket.onMessage((text3) => {
     let message2;
     try {
-      const parsed2 = parseJson(text2);
+      const parsed2 = parseJson(text3);
       if (!isJsonRecord(parsed2))
         return;
       message2 = parsed2;
@@ -2497,6 +2540,16 @@ function validBox(value) {
     return false;
   return [value.x, value.y, value.width, value.height].every((entry) => isNumber(entry) && Number.isFinite(entry));
 }
+function resourced(text3, url) {
+  const line = String(text3 ?? "");
+  if (!isString(url) || url === "")
+    return line;
+  try {
+    return `${line} (${new URL(url).pathname})`;
+  } catch {
+    return line;
+  }
+}
 function locatorExpression(focus) {
   return `${LOCATOR}(${JSON.stringify(focus.selector)}, ${JSON.stringify(focus.text)}, ${JSON.stringify(focus.tag)})`;
 }
@@ -2565,7 +2618,7 @@ async function render(page, input) {
     }),
     page.on("Log.entryAdded", (params) => {
       if (params?.entry?.level === "error")
-        remember(params.entry.text);
+        remember(resourced(params.entry.text, params.entry.url));
     })
   ];
   try {
@@ -2988,8 +3041,8 @@ async function rehomeCaptures(cwd, from, to, attachments) {
     file: attachment.file.startsWith(prefix) ? `${CAPTURES_DIR}/${to}/${attachment.file.slice(prefix.length)}` : attachment.file
   }));
 }
-function rehomeText(text2, from, to) {
-  return text2.split(`${CAPTURES_DIR}/${from}/`).join(`${CAPTURES_DIR}/${to}/`);
+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);
@@ -3857,13 +3910,13 @@ function imageMediaType(path) {
     return "image/gif";
   return null;
 }
-async function claudeContent(prompt, images) {
-  if (images.length === 0)
+async function claudeContent(prompt, images2) {
+  if (images2.length === 0)
     return prompt;
   const blocks = [
     { type: "text", text: prompt }
   ];
-  for (const path of images) {
+  for (const path of images2) {
     const mediaType = imageMediaType(path);
     if (mediaType === null)
       continue;
@@ -4766,7 +4819,7 @@ function isStateUpdater(value) {
   return typeof value === "function";
 }
 var SESSION_TURNS_CAP = 8;
-function resolveCommand(choice, prompt, sessionId = null, allowedCommands = [], images = []) {
+function resolveCommand(choice, prompt, sessionId = null, allowedCommands = [], images2 = []) {
   if (choice.agent === null)
     return null;
   if (choice.agent === "custom") {
@@ -4793,24 +4846,24 @@ function resolveCommand(choice, prompt, sessionId = null, allowedCommands = [],
       agent: choice.agent,
       name: adapter.name,
       command: adapter.binary,
-      args: [...adapter.resumeArgs(sessionId, prompt, choice.effort, images), ...allow],
+      args: [...adapter.resumeArgs(sessionId, prompt, choice.effort, images2), ...allow],
       prompt,
       effort: choice.effort,
       sessionId,
       resumed: true,
-      images
+      images: images2
     };
   }
   return {
     agent: choice.agent,
     name: adapter.name,
     command: adapter.binary,
-    args: [...adapter.args(prompt, choice.effort, images), ...allow],
+    args: [...adapter.args(prompt, choice.effort, images2), ...allow],
     prompt,
     effort: choice.effort,
     sessionId: null,
     resumed: false,
-    images
+    images: images2
   };
 }
 function lineReader(stream, onLine) {
@@ -5096,8 +5149,8 @@ function startRunner(options) {
       `${options.leglasCommand} show`,
       ...request.mode === "variant" ? [registrationCommand(options.leglasCommand)] : []
     ];
-    const images = (await Promise.all((request.attachments ?? []).map(async (attachment) => await isOwnCapture(options.cwd, attachment.file) ? resolve2(options.cwd, attachment.file) : null))).filter((image) => image !== null);
-    let resolved = resolveCommand(choice, request.prompt, choice.agent === null ? null : resumable(choice.agent), allowedCommands, images);
+    const images2 = (await Promise.all((request.attachments ?? []).map(async (attachment) => await isOwnCapture(options.cwd, attachment.file) ? resolve2(options.cwd, attachment.file) : null))).filter((image) => image !== null);
+    let resolved = resolveCommand(choice, request.prompt, choice.agent === null ? null : resumable(choice.agent), allowedCommands, images2);
     if (resolved === null)
       return;
     const lines2 = [];
@@ -5143,7 +5196,7 @@ function startRunner(options) {
       // nothing says "cancelled". Stopped still means stopped.
       !stopped) {
         sessions.delete(resolved.agent);
-        const cold = resolveCommand(choice, request.prompt, null, allowedCommands, images);
+        const cold = resolveCommand(choice, request.prompt, null, allowedCommands, images2);
         if (cold !== null) {
           resolved = cold;
           observed.sessionId = null;
@@ -6837,10 +6890,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 readdir3, writeFile as writeFile8 } from "fs/promises";
+import { mkdir as mkdir8, readdir as readdir5, writeFile as writeFile9 } from "fs/promises";
 import http4 from "http";
 import net3 from "net";
-import { basename as basename3, dirname as dirname8, extname as extname3, join as join12, normalize, relative as relative3 } from "path";
+import { basename as basename3, dirname as dirname10, extname as extname3, join as join16, normalize as normalize2, relative as relative4 } from "path";
 
 // ../server/dist/frame-policy.js
 var FRAMING_TIMEOUT_MS = 4e3;
@@ -6951,176 +7004,1311 @@ async function checkFraming(target, embedder, fetcher = fetch) {
   }
 }
 
-// ../server/dist/server-info.js
-import { lstat as lstat2, mkdir as mkdir7, readFile as readFile11, rename as rename2, rm as rm4, writeFile as writeFile7 } from "fs/promises";
-import { dirname as dirname7, join as join11 } from "path";
-var SERVER_INFO_PATH = ".leglas/server.json";
-async function writeServerInfo(cwd, info) {
-  const path = join11(cwd, SERVER_INFO_PATH);
-  const directory = dirname7(path);
-  await mkdir7(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 writeFile7(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(() => {
-    });
-    throw cause;
-  });
+// ../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";
+
+// ../server/dist/generation/claude.js
+var GENERATION_EFFORT = "medium";
+var RESTRICTED = [
+  "--output-format",
+  "stream-json",
+  "--verbose",
+  "--restricted",
+  "--strict-mcp-config"
+];
+function planArgs(prompt, effort = GENERATION_EFFORT) {
+  return ["-p", prompt, ...RESTRICTED, "--tools", "", "--effort", effort];
 }
-async function readServerInfo(cwd) {
+function buildArgs(prompt, effort = GENERATION_EFFORT) {
+  return [
+    "-p",
+    prompt,
+    ...RESTRICTED,
+    "--tools",
+    "Read,Write,Edit",
+    "--permission-mode",
+    "acceptEdits",
+    "--effort",
+    effort
+  ];
+}
+function resultText(lines2) {
+  for (let index = lines2.length - 1; index >= 0; index -= 1) {
+    const line = lines2[index]?.trim() ?? "";
+    if (!line.startsWith("{"))
+      continue;
+    try {
+      const event = parseJson(line);
+      if (isJsonRecord(event) && event.type === "result" && isString(event.result))
+        return event.result;
+    } catch {
+    }
+  }
+  return null;
+}
+
+// ../server/dist/generation/codex.js
+import { readFile as readFile11 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join11 } from "path";
+var RESTRICTED2 = [
+  "exec",
+  "--json",
+  "--ephemeral",
+  "--skip-git-repo-check",
+  "-c",
+  `model_reasoning_effort=${GENERATION_EFFORT}`,
+  "-c",
+  "project_doc_max_bytes=0",
+  "-c",
+  "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.
+  ...[
+    "multi_agent",
+    "apps",
+    "plugins",
+    "memories",
+    "goals",
+    "browser_use",
+    "computer_use",
+    "image_generation"
+  ].flatMap((feature) => ["-c", `features.${feature}=false`])
+];
+var BARE = /^[A-Za-z0-9_-]+$/;
+async function codexServers(home = defaultCodexHome()) {
+  let config;
   try {
-    const value = parseJson(await readFile11(join11(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 };
+    config = await readFile11(join11(home, "config.toml"), "utf8");
   } catch {
-    return null;
+    return [];
   }
-}
-async function removeServerInfo(cwd, expected) {
-  if (expected !== void 0) {
-    const current = await readServerInfo(cwd);
-    if (current !== null && (current.port !== expected.port || current.pid !== expected.pid))
-      return;
+  const names = /* @__PURE__ */ new Set();
+  for (const match of config.matchAll(/^\s*\[\s*mcp_servers\s*\.\s*(?:"([^"]+)"|'([^']+)'|([A-Za-z0-9_-]+))\s*\]\s*(?:#.*)?$/gm)) {
+    const name = match[1] ?? match[2] ?? match[3] ?? "";
+    if (BARE.test(name))
+      names.add(name);
   }
-  await rm4(join11(cwd, SERVER_INFO_PATH), { force: true });
+  return [...names];
 }
-
-// ../server/dist/server.js
-var LEGLAS_PREFIX = "/leglas";
-var DEFAULT_PORT = 4100;
-var PORT_ATTEMPTS = 20;
-var REFERENCE_MAX_BYTES = 1e7;
-var ATTACHED_WINDOW_MS = 6e3;
-var CONTENT_TYPES = {
-  ".css": "text/css; charset=utf-8",
-  ".gif": "image/gif",
-  ".html": "text/html; charset=utf-8",
-  ".ico": "image/x-icon",
-  ".jpeg": "image/jpeg",
-  ".jpg": "image/jpeg",
-  ".js": "text/javascript; charset=utf-8",
-  ".json": "application/json; charset=utf-8",
-  ".mjs": "text/javascript; charset=utf-8",
-  ".png": "image/png",
-  ".svg": "image/svg+xml",
-  ".txt": "text/plain; charset=utf-8",
-  ".webp": "image/webp",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2"
-};
-function isContentExtension(extension) {
-  return Object.hasOwn(CONTENT_TYPES, extension);
+function defaultCodexHome(env = process.env) {
+  return env.CODEX_HOME !== void 0 && env.CODEX_HOME !== "" ? env.CODEX_HOME : join11(homedir2(), ".codex");
 }
-var FILES_PREFIX = `${LEGLAS_PREFIX}/files`;
-function sendJson2(res, status, body) {
-  const payload = JSON.stringify(body);
-  res.writeHead(status, {
-    "content-type": "application/json; charset=utf-8",
-    "cache-control": "no-store"
-  });
-  res.end(payload);
+var serversOff = (servers) => servers.flatMap((name) => ["-c", `mcp_servers.${name}.enabled=false`]);
+function codexPlanArgs(prompt, servers) {
+  return [...RESTRICTED2, ...serversOff(servers), "-s", "read-only", prompt];
 }
-function etagMatches(value, etag) {
-  if (value === void 0)
+function codexBuildArgs(prompt, servers) {
+  return [...RESTRICTED2, ...serversOff(servers), "-s", "workspace-write", prompt];
+}
+function codexResultText(lines2) {
+  for (let index = lines2.length - 1; index >= 0; index -= 1) {
+    const line = lines2[index]?.trim() ?? "";
+    if (!line.startsWith("{"))
+      continue;
+    try {
+      const event = parseJson(line);
+      const item = isJsonRecord(event) ? event.item : void 0;
+      if (isJsonRecord(event) && event.type === "item.completed" && isJsonRecord(item) && item.type === "agent_message" && isString(item.text))
+        return item.text;
+    } catch {
+    }
+  }
+  return null;
+}
+
+// ../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";
+
+// ../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";
+var MAP = /const DIRECTIONS = \{([\s\S]*?)\} as const;/;
+var SOURCE = /\.(tsx|jsx|ts|js)$/;
+var SCAN_LIMIT = 3e3;
+async function isFile(path) {
+  try {
+    return (await stat4(path)).isFile();
+  } catch {
     return false;
-  const values = Array.isArray(value) ? value : [value];
-  return values.some((header) => header.split(",").some((candidate) => {
-    const tag = candidate.trim();
-    return tag === "*" || tag === etag || tag === `W/${etag}`;
-  }));
+  }
 }
-function sendConditionalJson(req, res, body) {
-  const payload = JSON.stringify(body);
-  const etag = `"${createHash2("sha256").update(payload).digest("base64url")}"`;
-  if (etagMatches(req.headers["if-none-match"], etag)) {
-    res.writeHead(304, { etag, "cache-control": "private, no-cache" });
-    res.end();
-    return;
+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)))
+      return path;
   }
-  res.writeHead(200, {
-    "content-type": "application/json; charset=utf-8",
-    "cache-control": "private, no-cache",
-    etag
+  const wanted = `"v-${slug}"`;
+  let seen = 0;
+  const walk = async (folder) => {
+    let items;
+    try {
+      items = await readdir3(join12(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);
+      if (item.isDirectory()) {
+        const found = await walk(path);
+        if (found !== null)
+          return found;
+        continue;
+      }
+      if (!SOURCE.test(item.name))
+        continue;
+      seen += 1;
+      const source = await readFile12(join12(cwd, path), "utf8").catch(() => "");
+      if (source.includes(wanted) && MAP.test(source))
+        return path;
+    }
+    return null;
+  };
+  for (const root of ["src", "app"]) {
+    const found = await walk(root);
+    if (found !== null)
+      return relative3(cwd, join12(cwd, found));
+  }
+  return null;
+}
+function readDirections(source) {
+  const imports = /* @__PURE__ */ new Map();
+  for (const match of source.matchAll(/^import \{ (\w+) \} from "([^"]+)";$/gm)) {
+    imports.set(match[1] ?? "", match[2] ?? "");
+  }
+  const body = MAP.exec(source)?.[1] ?? "";
+  const directions = [];
+  for (const match of body.matchAll(/"?([\w-]+)"?\s*:\s*(\w+)/g)) {
+    const key = match[1] ?? "";
+    const name = match[2] ?? "";
+    const from = imports.get(name);
+    if (from !== void 0)
+      directions.push({ key, name, from });
+  }
+  return directions;
+}
+function directionKeys(source) {
+  const body = MAP.exec(source)?.[1] ?? "";
+  return [...body.matchAll(/"?([\w-]+)"?\s*:/g)].flatMap((match) => match[1] === void 0 ? [] : [match[1]]);
+}
+function fallbackKey(source) {
+  return /const FALLBACK: \w+ = "([\w-]+)";/.exec(source)?.[1] ?? null;
+}
+function addSlots(source, slots) {
+  if (!MAP.test(source))
+    throw new Error("The switch file has no DIRECTIONS map.");
+  const lines2 = source.split("\n");
+  let last = -1;
+  lines2.forEach((line, index) => {
+    if (line.startsWith("import "))
+      last = index;
   });
-  res.end(payload);
+  lines2.splice(last + 1, 0, ...slots.map((slot) => `import { ${slot.name} } from "./${slot.key}";`));
+  const added = slots.map((slot) => `  "${slot.key}": ${slot.name},`).join("\n");
+  return lines2.join("\n").replace(MAP, (_, body) => `const DIRECTIONS = {
+${body.replace(/^\s*\n|\s+$/g, "").replace(/,?$/, ",")}
+${added}
+} as const;`);
+}
+function placeholderSource(name) {
+  return `export function ${name}() {
+  return null;
 }
-var CAPTURE_DEADLINE_MS = 15e3;
-var CAPTURE_LOAD_MS = Math.floor(CAPTURE_DEADLINE_MS * LOAD_SHARE);
-function captureSlug(title) {
-  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60) || "direction";
+`;
 }
-function referenceName(value) {
-  const raw = Array.isArray(value) ? value[0] ?? "" : value ?? "";
-  const safe = [...raw].filter((character) => {
-    const code = character.charCodeAt(0);
-    return code >= 32 && code <= 126 && character !== "/" && character !== "\\";
-  }).join("").trim().slice(0, 80);
-  return safe || "image";
+
+// ../server/dist/generation/facts.js
+var IMAGE = /\.(png|jpe?g|webp|avif|gif|svg)$/i;
+var IMAGE_LIMIT = 24;
+var EXAMPLE_LINES = 250;
+var VARIED_LINES = 600;
+function clip(source, limit) {
+  const lines2 = source.replace(/\n$/, "").split("\n");
+  if (lines2.length <= limit)
+    return source;
+  const hidden = lines2.length - limit;
+  return [
+    ...lines2.slice(0, limit),
+    `// \u2026 ${hidden} more ${hidden === 1 ? "line" : "lines"}, not shown`
+  ].join("\n");
+}
+var BASELINE_LINES = 15;
+var STUB = /Re-export what your|A first direction for/;
+async function text2(path) {
+  return readFile13(path, "utf8").catch(() => null);
+}
+async function firstFile(cwd, candidates) {
+  for (const candidate of candidates) {
+    if (await text2(join13(cwd, candidate)) !== null)
+      return candidate;
+  }
+  return null;
 }
-function isAddressInUse(cause) {
-  return typeof cause === "object" && cause !== null && "code" in cause && cause.code === "EADDRINUSE";
+function cssImports(source, from) {
+  return [...source.matchAll(/import\s+["']([^"']+\.css)["']/g)].map((match) => normalize(join13(dirname7(from), match[1] ?? "")));
 }
-function isKnownAgent(value) {
-  return isString(value) && Object.hasOwn(KNOWN_AGENTS, value);
+async function globalStylesheet(cwd) {
+  const entries = [];
+  const html = await text2(join13(cwd, "index.html"));
+  const script = html === null ? null : /<script[^>]+type="module"[^>]+src="\/?([^"]+)"/.exec(html);
+  if (script?.[1] !== void 0)
+    entries.push(script[1]);
+  for (const root of ["app", "src/app"]) {
+    for (const extension of ["tsx", "jsx", "ts", "js"])
+      entries.push(`${root}/layout.${extension}`);
+  }
+  const sheets = [];
+  for (const entry of entries) {
+    const source = await text2(join13(cwd, entry));
+    if (source !== null)
+      sheets.push(...cssImports(source, entry));
+  }
+  for (const sheet of sheets) {
+    const source = await text2(join13(cwd, sheet));
+    if (source !== null && /:root\s*\{|@font-face/.test(source))
+      return sheet;
+  }
+  return firstFile(cwd, sheets);
 }
-function isAllowedMutationHost(hostname) {
-  const bare = hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
-  if (bare === "localhost" || bare === "127.0.0.1" || bare === "::1")
-    return true;
-  if (bare.endsWith(".local"))
-    return true;
-  if (!net3.isIPv4(bare))
-    return false;
-  const [first, second] = bare.split(".").map(Number);
-  return first === 10 || first === 172 && second !== void 0 && second >= 16 && second <= 31 || first === 192 && second === 168;
+async function images(cwd) {
+  const found = [];
+  const walk = async (folder) => {
+    let items;
+    try {
+      items = await readdir4(join13(cwd, "public", folder), { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const item of items) {
+      if (found.length >= IMAGE_LIMIT || item.name.startsWith("."))
+        continue;
+      const path = folder === "" ? item.name : `${folder}/${item.name}`;
+      if (item.isDirectory())
+        await walk(path);
+      else if (IMAGE.test(item.name))
+        found.push(`/${path}`);
+    }
+  };
+  await walk("");
+  return found;
 }
-function isLoopbackAddress(address) {
-  if (address === void 0)
-    return false;
-  return address === "127.0.0.1" || address === "::1" || address === "::ffff:127.0.0.1" || address.startsWith("127.");
+async function componentFile(cwd, from, specifier) {
+  const base = normalize(join13(dirname7(from), specifier));
+  return firstFile(cwd, [
+    base,
+    ...["tsx", "jsx", "ts", "js"].map((extension) => `${base}.${extension}`)
+  ]);
 }
-function isTrustedMutation(req) {
-  if (!isLoopbackAddress(req.socket.remoteAddress))
-    return false;
-  if (!isString(req.headers.host))
-    return false;
-  let host;
+async function example(cwd, switchPath, prefer) {
+  const source = await text2(join13(cwd, switchPath));
+  if (source === null)
+    return null;
+  const directions = readDirections(source);
+  const first = prefer ?? fallbackKey(source);
+  const ordered = [...directions].sort((a, b) => Number(b.key === first) - Number(a.key === first));
+  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));
+    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));
+      if (followed !== null && real !== null) {
+        return {
+          key: direction.key,
+          path: followed,
+          source: clip(real, limit)
+        };
+      }
+      continue;
+    }
+    return { key: direction.key, path, source: clip(body, limit) };
+  }
+  return null;
+}
+async function dependencyNames(cwd) {
   try {
-    host = new URL(`http://${req.headers.host}`);
+    const pkg = parseJson(await text2(join13(cwd, "package.json")) ?? "");
+    return isJsonRecord(pkg) && isJsonRecord(pkg.dependencies) ? Object.keys(pkg.dependencies) : [];
   } catch {
-    return false;
+    return [];
   }
-  if (!isAllowedMutationHost(host.hostname))
-    return false;
-  const rawOrigin = req.headers.origin;
-  if (rawOrigin === void 0)
-    return true;
+}
+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));
+  return {
+    dependencies,
+    stylesheet: sheetPath === null || css === null ? null : {
+      path: sheetPath,
+      fonts: [
+        ...new Set([...css.matchAll(/font-family:\s*["']([^"']+)["']/g)].map((match) => match[1] ?? ""))
+      ],
+      tokens: /:root\s*\{[\s\S]*?\n\}/.exec(css)?.[0] ?? ""
+    },
+    images: await images(cwd),
+    example: await example(cwd, switchPath, prefer)
+  };
+}
+function factsBlock(facts, surface, varied = null) {
+  const lines2 = [
+    "Leglas read the project for you. Follow its house style: differ in the idea, not in the craft."
+  ];
+  if (facts.dependencies.length > 0)
+    lines2.push(`Dependencies: ${facts.dependencies.join(", ")}.`);
+  if (facts.stylesheet !== null) {
+    const fonts = facts.stylesheet.fonts.length === 0 ? "" : ` It declares the fonts ${facts.stylesheet.fonts.join(", ")}.`;
+    lines2.push(`The global stylesheet ${facts.stylesheet.path} is already loaded on every page.${fonts}`);
+    if (facts.stylesheet.tokens !== "")
+      lines2.push("It sets these tokens:", "```css", facts.stylesheet.tokens, "```");
+  }
+  if (facts.images.length > 0)
+    lines2.push(`Images the project already serves from its root: ${facts.images.join(", ")}.`);
+  if (facts.example !== null) {
+    lines2.push(varied?.key === facts.example.key ? `${varied.title}, the direction being varied, is ${facts.example.path}. Its imports are relative to that file:` : `The ${surface}'s current direction, ${facts.example.path}, shows how directions here are written:`, "```tsx", facts.example.source.trimEnd(), "```");
+  }
+  return lines2.join("\n");
+}
+
+// ../server/dist/generation/prompts.js
+function described(base) {
+  const idea = base.idea.replace(/\.$/, "");
+  return idea === "" ? `"${base.title}"` : `"${base.title}" (${idea})`;
+}
+function steer(brief) {
+  if (brief === "")
+    return ".";
+  return `. What to explore: ${/[.!?]$/.test(brief) ? brief : `${brief}.`}`;
+}
+var ANSWER = "Answer from this brief alone: do not read, search or run anything. Reply with only a JSON array of objects with key (kebab-case), title and idea (one line).";
+function planPrompt(input) {
+  const { base } = input;
+  if (base !== void 0 && base !== null) {
+    return `Propose ${input.count} variations of the ${input.surface} direction ${described(base)}${steer(input.brief)} Every variation stays recognisably ${base.title} and changes one deliberate thing; name each for what it changes. Decide them together so no two change the same thing. ${ANSWER}`;
+  }
+  const already = input.existing.length === 0 ? "" : ` The ${input.surface} already has these directions: ${input.existing.join(", ")}; yours must differ from them too.`;
+  return `Propose ${input.count} genuinely different design directions for the ${input.surface} of this product: ${input.brief} Decide all of them together; if two would look alike at a glance, replace one.${already} ${ANSWER}`;
+}
+function replacePrompt2(input) {
+  const avoid = input.avoid.map((concept) => `${concept.title} (${concept.idea})`).join("; ");
+  const { base } = input;
+  if (base !== void 0 && base !== null) {
+    return `Propose 1 more variation of the ${input.surface} direction ${described(base)}${steer(input.brief)} It stays recognisably ${base.title} and changes something none of these change: ${avoid}. ${ANSWER}`;
+  }
+  return `Propose 1 design direction for the ${input.surface} of this product: ${input.brief} It must not look like any of these: ${avoid}. ${ANSWER}`;
+}
+function buildPrompt(input) {
+  const others = input.others.map((other) => `${other.title} (${other.idea})`).join("; ");
+  const { base } = input;
+  const varying = base !== void 0 && base !== null;
+  const rivals = others === "" ? "" : varying ? ` The other variations are ${others}; change something different from them.` : ` The other directions are ${others}; yours must not look like any of them.`;
+  const what = varying ? `Build this variation of the ${input.surface} direction "${base.title}": ${input.concept.title}, ${input.concept.idea.replace(/\.$/, "")}. Keep it recognisably ${base.title} and change only what the variation names.` : `Build this design direction for the ${input.surface}: ${input.concept.title}, ${input.concept.idea.replace(/\.$/, "")}.`;
+  const product = varying ? steer(input.brief).slice(1) : ` The product: ${input.brief}`;
+  return `${what}${product}${rivals}
+
+Everything you need is in this message, so do not look around the project. It is ${input.stack}. Your file is ${input.file}. It holds a placeholder: read it once, then replace it in a single write with a component exported as ${input.name}. Keep every new style in that file, in a <style> element or inline.
+
+${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.`;
+}
+function kebab(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function pascal(key) {
+  return key.split("-").filter((part) => part !== "").map((part) => /^\d/.test(part) ? `N${part}` : part[0].toUpperCase() + part.slice(1)).join("");
+}
+function parseConcepts(reply, count) {
+  const start = reply.indexOf("[");
+  const end = reply.lastIndexOf("]");
+  if (start === -1 || end < start)
+    throw new Error("The plan reply held no JSON array.");
+  let parsed2;
   try {
-    const origin = new URL(rawOrigin);
-    return origin.protocol === "http:" && origin.host === host.host;
+    parsed2 = parseJson(reply.slice(start, end + 1));
   } catch {
-    return false;
+    throw new Error("The plan reply's JSON did not parse.");
   }
+  if (!Array.isArray(parsed2))
+    throw new Error("The plan reply held no JSON array.");
+  const concepts = [];
+  for (const entry of parsed2) {
+    if (!isJsonRecord(entry))
+      continue;
+    const title = isString(entry.title) ? entry.title.trim() : "";
+    const key = kebab(isString(entry.key) && entry.key.trim() !== "" ? entry.key : title);
+    if (title === "" || key === "" || concepts.some((concept) => concept.key === key))
+      continue;
+    concepts.push({ key, title, idea: isString(entry.idea) ? entry.idea.trim() : "" });
+    if (concepts.length === count)
+      return concepts;
+  }
+  throw new Error(`The plan reply named fewer than ${count} distinct directions.`);
+}
+
+// ../server/dist/generation/generation.js
+var MAX_DIRECTIONS = 6;
+var BUILD_DEADLINE_MS = 5 * 6e4;
+var PLAN_DEADLINE_MS = 2 * 6e4;
+var FIX_DEADLINE_MS = 3 * 6e4;
+var KILL_GRACE_MS = 5e3;
+var RECHECK_MS = 1500;
+var OWN_FAILURES = /* @__PURE__ */ new Set([
+  "broken",
+  "not-written",
+  "too-slow",
+  "unexpected"
+]);
+var BUSY = "A set of directions is already being built. Wait for it, or stop it first.";
+var KEPT_JOBS = 5;
+var CLAUDE = {
+  id: "claude",
+  name: "Claude",
+  plan: (prompt) => planArgs(prompt),
+  build: (prompt) => buildArgs(prompt),
+  result: resultText
+};
+function codex(servers) {
+  return {
+    id: "codex",
+    name: "Codex",
+    plan: (prompt) => codexPlanArgs(prompt, servers),
+    build: (prompt) => codexBuildArgs(prompt, servers),
+    result: codexResultText
+  };
 }
-function isEnded(request, failedIds) {
-  return isTerminal(request.status) || failedIds.includes(request.id);
+function wait(milliseconds) {
+  return new Promise((resolve5) => {
+    setTimeout(resolve5, milliseconds).unref?.();
+  });
 }
-function jsonBody(body) {
+function surfaceSlug(surface) {
+  return surface.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function baseOf(preview, surface) {
+  let key;
   try {
-    const parsed2 = parseJson(body || "{}");
-    return isJsonRecord(parsed2) ? parsed2 : null;
+    key = new URL(preview.url, "http://leglas.invalid").searchParams.get(`v-${surfaceSlug(surface)}`);
   } catch {
     return null;
   }
+  return key === null || key === "" ? null : { title: preview.title, key, idea: preview.note ?? "" };
 }
-function requestIntent(value) {
+async function stackOf(cwd, switchPath) {
+  let deps = {};
+  try {
+    const pkg = parseJson(await readFile14(join14(cwd, "package.json"), "utf8"));
+    if (isJsonRecord(pkg)) {
+      for (const group of [pkg.devDependencies, pkg.dependencies]) {
+        if (!isJsonRecord(group))
+          continue;
+        for (const [name, version2] of Object.entries(group)) {
+          if (isString(version2))
+            deps[name] = version2;
+        }
+      }
+    }
+  } catch {
+    deps = {};
+  }
+  const major = /\d+/.exec(deps.react ?? "")?.[0];
+  const react = major === void 0 ? "React" : `React ${major}`;
+  const typescript = switchPath.endsWith(".tsx") ? " and TypeScript" : "";
+  if (deps.next !== void 0)
+    return `a Next.js app with ${react}${typescript}`;
+  if (deps.vite !== void 0)
+    return `a Vite app with ${react}${typescript}`;
+  return `an app with ${react}${typescript}`;
+}
+function provenance(job) {
+  const words = job.surface.replace(/-/g, " ");
+  return {
+    askedFor: job.brief === "" ? void 0 : job.brief,
+    // Variations sit under the direction they vary, as any family does on the rail.
+    basedOn: job.basedOn ?? void 0,
+    tags: [words.charAt(0).toUpperCase() + words.slice(1)]
+  };
+}
+function copy(job) {
+  return {
+    ...job,
+    slots: job.slots.map((slot) => ({
+      ...slot,
+      failure: slot.failure === null ? null : { ...slot.failure }
+    }))
+  };
+}
+function createGenerations(deps) {
+  const now = deps.now ?? Date.now;
+  const spawn7 = deps.spawn ?? ((command, args, options) => nodeSpawn4(command, args, { ...options, env: agentEnvironment() }));
+  const lives = [];
+  let closed = false;
+  const busy = () => lives.some((live) => live.job.state === "planning" || live.job.state === "building");
+  const changed = () => deps.onChange();
+  let registry = Promise.resolve();
+  const serially = (task) => {
+    const next = registry.then(task, task);
+    registry = next.catch(() => {
+    });
+    return next;
+  };
+  const run4 = (agent, args, deadlineMs, onLine) => {
+    const lines2 = [];
+    let timedOut2 = false;
+    let child = null;
+    const done = new Promise((resolve5) => {
+      if (closed) {
+        resolve5({ code: null, lines: lines2, error: "Leglas is closing.", timedOut: timedOut2 });
+        return;
+      }
+      try {
+        child = spawn7(agent.id, args, {
+          cwd: deps.cwd,
+          shell: false,
+          stdio: ["ignore", "pipe", "pipe"],
+          ...ownGroup()
+        });
+      } catch (error) {
+        resolve5({
+          code: null,
+          lines: lines2,
+          error: error instanceof Error ? error.message : String(error),
+          timedOut: timedOut2
+        });
+        return;
+      }
+      let buffered = "";
+      const take = (chunk) => {
+        buffered += chunk.toString();
+        const parts = buffered.split("\n");
+        buffered = parts.pop() ?? "";
+        lines2.push(...parts);
+        if (onLine !== void 0)
+          for (const line of parts)
+            onLine(line);
+      };
+      child.stdout.on("data", take);
+      child.stderr.on("data", take);
+      const deadline = setTimeout(() => {
+        timedOut2 = true;
+        if (child !== null)
+          signalTree(child, "SIGTERM");
+        setTimeout(() => {
+          if (child !== null)
+            signalTree(child, "SIGKILL");
+        }, KILL_GRACE_MS).unref?.();
+      }, deadlineMs);
+      deadline.unref?.();
+      child.once("error", (error) => {
+        clearTimeout(deadline);
+        resolve5({ code: null, lines: lines2, error: error.message, timedOut: timedOut2 });
+      });
+      child.once("close", (code) => {
+        clearTimeout(deadline);
+        if (buffered !== "")
+          lines2.push(buffered);
+        resolve5({ code, lines: lines2, error: null, timedOut: timedOut2 });
+      });
+    });
+    return {
+      done,
+      stop: async () => {
+        if (child === null)
+          return;
+        signalTree(child, "SIGTERM");
+        const exited = await Promise.race([
+          done.then(() => true),
+          wait(KILL_GRACE_MS).then(() => false)
+        ]);
+        if (!exited && child !== null) {
+          signalTree(child, "SIGKILL");
+          await Promise.race([done, wait(KILL_GRACE_MS)]);
+        }
+      }
+    };
+  };
+  const failureOf2 = (agent, outcome) => classifyFailure({
+    agent: agent.name,
+    error: outcome.error,
+    exitCode: outcome.code,
+    lines: outcome.lines.slice(-40)
+  });
+  const settle = (live) => {
+    const { job } = live;
+    for (const slot of job.slots) {
+      if (slot.state !== "building" && slot.state !== "checking")
+        slot.activity = null;
+    }
+    if (job.state === "planning" || job.state === "failed")
+      return;
+    if (job.slots.some((slot) => slot.state === "building" || slot.state === "checking")) {
+      job.state = "building";
+      return;
+    }
+    job.state = job.slots.every((slot) => slot.state === "stopped") ? "stopped" : "done";
+    job.endedAt = now();
+  };
+  const restore = async (slot) => {
+    await writeFile7(join14(deps.cwd, slot.file), placeholderSource(pascal(slot.key)), "utf8").catch(() => {
+    });
+  };
+  const begin = (live, slot) => {
+    const attempt = (live.attempts.get(slot.key) ?? 0) + 1;
+    live.attempts.set(slot.key, attempt);
+    return attempt;
+  };
+  const owns = (live, slot, attempt) => live.attempts.get(slot.key) === attempt;
+  const guarded = (work, onError) => work.catch((error) => onError(error instanceof Error ? error.message : String(error)));
+  const detach = (live, work, onError) => {
+    const kept = guarded(work, onError);
+    live.pending.add(kept);
+    void kept.then(() => live.pending.delete(kept));
+  };
+  const drain = async (live) => {
+    while (live.pending.size > 0)
+      await Promise.all(live.pending);
+  };
+  const release = async (live, slot) => {
+    const running = live.runs.get(slot.key);
+    await running?.stop();
+    await restore(slot);
+    if (running !== void 0 && live.runs.get(slot.key) === running)
+      live.runs.delete(slot.key);
+  };
+  const fail = (live, slot, failure) => {
+    slot.state = "failed";
+    slot.failure = failure;
+    slot.endedAt = now();
+    detach(live, restore(slot), () => {
+    });
+    if (OWN_FAILURES.has(failure.code))
+      return;
+    const same = live.job.slots.filter((other) => other.failure?.code === failure.code).length;
+    if (same >= 2) {
+      for (const other of live.job.slots) {
+        if (other.state !== "building" && other.state !== "checking")
+          continue;
+        begin(live, other);
+        other.state = "stopped";
+        other.failure = {
+          code: "same-failure",
+          message: `Stopped after two directions failed the same way: ${failure.message}`
+        };
+        other.endedAt = now();
+        detach(live, release(live, other), () => {
+        });
+      }
+    }
+  };
+  const lost = (live, slot, attempt, message2) => {
+    if (!owns(live, slot, attempt))
+      return;
+    fail(live, slot, { code: "unexpected", message: message2 });
+    settle(live);
+    changed();
+  };
+  const follow = (live, slot, attempt) => (line) => {
+    const activity = activityFrom(live.agent.id, line, deps.cwd);
+    if (activity === null || activity === slot.activity || !owns(live, slot, attempt))
+      return;
+    slot.activity = activity;
+    changed();
+  };
+  const build = async (live, slot, attempt) => {
+    const concept = live.concepts.get(slot.key);
+    if (concept === void 0 || !owns(live, slot, attempt))
+      return;
+    slot.state = "building";
+    if (slot.startedAt === null)
+      slot.startedAt = now();
+    slot.endedAt = null;
+    slot.failure = null;
+    slot.fixed = false;
+    slot.activity = null;
+    changed();
+    const others = [...live.concepts.values()].filter((other) => other !== concept);
+    const prompt = buildPrompt({
+      surface: live.job.surface,
+      brief: live.job.brief,
+      concept,
+      others,
+      file: slot.file,
+      name: pascal(slot.key),
+      stack: live.stack,
+      facts: live.facts ?? "",
+      base: live.base
+    });
+    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;
+    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(() => "");
+    if (!owns(live, slot, attempt))
+      return;
+    if (outcome.timedOut) {
+      fail(live, slot, {
+        code: "too-slow",
+        message: `The build took longer than ${BUILD_DEADLINE_MS / 6e4} minutes, so Leglas stopped it.`
+      });
+    } else if (outcome.error !== null || outcome.code !== 0) {
+      fail(live, slot, failureOf2(live.agent, outcome));
+    } else if (written === placeholderSource(pascal(slot.key))) {
+      fail(live, slot, {
+        code: "not-written",
+        message: "The build finished without writing its file."
+      });
+    } else {
+      slot.state = "checking";
+      slot.activity = null;
+      changed();
+      await check(live, slot, attempt);
+    }
+    settle(live);
+    changed();
+  };
+  const ownErrors = 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);
+      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));
+      if (!waiting || now() >= until) {
+        return errors.filter((error) => !others.some((other) => error.includes(other.file)));
+      }
+      await wait(RECHECK_MS);
+      if (!owns(live, slot, attempt))
+        return null;
+    }
+  };
+  const check = async (live, slot, attempt) => {
+    let errors = await ownErrors(live, slot, attempt);
+    if (errors === 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));
+      live.runs.set(slot.key, fixing);
+      const outcome = await fixing.done;
+      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;
+      }
+      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;
+      }
+    }
+    slot.state = "ready";
+    slot.endedAt = now();
+  };
+  const freeTitle = (title, taken) => {
+    let candidate = title;
+    for (let suffix = 2; taken.has(candidate); suffix += 1)
+      candidate = `${title} ${suffix}`;
+    taken.add(candidate);
+    return candidate;
+  };
+  const plan = async (live, existing) => {
+    const { job } = live;
+    const planning = run4(live.agent, live.agent.plan(planPrompt({
+      surface: job.surface,
+      brief: job.brief,
+      count: job.count,
+      existing,
+      base: live.base
+    })), PLAN_DEADLINE_MS);
+    live.plan = planning;
+    const outcome = await planning.done;
+    live.plan = null;
+    if (job.state !== "planning")
+      return;
+    if (outcome.timedOut || outcome.error !== null || outcome.code !== 0) {
+      job.state = "failed";
+      job.error = outcome.timedOut ? "Planning took too long, so Leglas stopped it." : failureOf2(live.agent, outcome).message;
+      job.endedAt = now();
+      changed();
+      return;
+    }
+    let concepts;
+    try {
+      concepts = parseConcepts(live.agent.result(outcome.lines) ?? "", job.count);
+    } catch (error) {
+      job.state = "failed";
+      job.error = error instanceof Error ? error.message : String(error);
+      job.endedAt = now();
+      changed();
+      return;
+    }
+    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);
+    const titles = new Set(await deps.titles());
+    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}`));
+    for (const concept of concepts) {
+      let key = `${slug}-${concept.key}`;
+      for (let suffix = 2; await taken(key); suffix += 1)
+        key = `${slug}-${concept.key}-${suffix}`;
+      keys.add(key);
+      const title = freeTitle(concept.title, titles);
+      live.concepts.set(key, { ...concept, title });
+      slots.push({
+        key,
+        title,
+        idea: concept.idea,
+        file: join14(folder, `${key}.${extension}`),
+        state: "building",
+        startedAt: null,
+        endedAt: null,
+        failure: null,
+        fixed: false,
+        activity: null
+      });
+    }
+    const source = await readFile14(join14(deps.cwd, live.switchPath), "utf8");
+    for (const slot of slots) {
+      await writeFile7(join14(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");
+    for (const slot of slots) {
+      await serially(() => deps.register({
+        title: slot.title,
+        url: `/?v-${slug}=${slot.key}`,
+        note: slot.idea,
+        ...provenance(job)
+      }));
+    }
+    job.slots = slots;
+    if (job.state !== "planning") {
+      for (const slot of slots) {
+        slot.state = "stopped";
+        slot.endedAt = now();
+      }
+      changed();
+      return;
+    }
+    job.state = "building";
+    job.plannedAt = now();
+    changed();
+    await Promise.all(job.slots.map((slot) => {
+      const attempt = begin(live, slot);
+      return guarded(build(live, slot, attempt), (message2) => lost(live, slot, attempt, message2));
+    }));
+  };
+  const find = (id) => lives.find((live) => live.job.id === id);
+  const stop = async (id, key) => {
+    const live = find(id);
+    if (live === void 0)
+      return false;
+    const { job } = live;
+    if (key === void 0 && job.state === "planning") {
+      job.state = "stopped";
+      job.endedAt = now();
+      changed();
+      await live.plan?.stop();
+      await drain(live);
+      return true;
+    }
+    const targets = job.slots.filter((slot) => (key === void 0 || slot.key === key) && (slot.state === "building" || slot.state === "checking"));
+    for (const slot of targets) {
+      begin(live, slot);
+      slot.state = "stopped";
+      slot.endedAt = now();
+    }
+    settle(live);
+    changed();
+    await Promise.all(targets.map((slot) => release(live, slot)));
+    return targets.length > 0;
+  };
+  return {
+    async start(request) {
+      if (closed)
+        return { ok: false, error: "Leglas is closing." };
+      const agent = request.agent.agent;
+      if (agent !== "claude" && agent !== "codex") {
+        return {
+          ok: false,
+          error: "Building directions runs on Claude or Codex. Choose one of them as the agent to use it."
+        };
+      }
+      const count = Math.floor(request.count);
+      if (!Number.isFinite(count) || count < 1 || count > MAX_DIRECTIONS) {
+        return { ok: false, error: `Ask for between 1 and ${MAX_DIRECTIONS} directions.` };
+      }
+      const brief = request.brief.trim();
+      const base = request.basedOn ?? null;
+      if (brief === "" && base === null)
+        return { ok: false, error: "Describe what the directions are for." };
+      const slug = surfaceSlug(request.surface);
+      if (slug === "")
+        return { ok: false, error: "Name the surface to build directions for." };
+      if (busy())
+        return { ok: false, error: BUSY };
+      const switchPath = await findSwitch(deps.cwd, slug);
+      if (switchPath === null) {
+        return {
+          ok: false,
+          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"));
+      if (base !== null && !existing.includes(base.key)) {
+        return {
+          ok: false,
+          error: `${base.title} is not a direction of the ${slug}, so Leglas cannot build variations of it.`
+        };
+      }
+      const unbuilt = base === null ? void 0 : lives.flatMap((kept) => kept.job.slots).find((slot) => slot.key === base.key && slot.state !== "ready");
+      if (base !== null && unbuilt !== void 0) {
+        return {
+          ok: false,
+          error: `${base.title} has no finished design yet, so there is nothing to vary. Retry it first.`
+        };
+      }
+      const job = {
+        id: `gen-${now().toString(36)}`,
+        surface: slug,
+        brief,
+        count,
+        state: "planning",
+        startedAt: now(),
+        plannedAt: null,
+        endedAt: null,
+        error: null,
+        slots: [],
+        basedOn: base?.title ?? null,
+        agent
+      };
+      const live = {
+        job,
+        concepts: /* @__PURE__ */ new Map(),
+        runs: /* @__PURE__ */ new Map(),
+        plan: null,
+        switchPath,
+        facts: null,
+        stack: await stackOf(deps.cwd, switchPath),
+        attempts: /* @__PURE__ */ new Map(),
+        base,
+        agent: agent === "codex" ? codex(await codexServers(deps.codexHome)) : CLAUDE,
+        pending: /* @__PURE__ */ new Set()
+      };
+      if (busy())
+        return { ok: false, error: BUSY };
+      lives.push(live);
+      while (lives.length > KEPT_JOBS)
+        lives.shift();
+      changed();
+      detach(live, plan(live, existing), (message2) => {
+        job.state = "failed";
+        job.error = message2;
+        job.endedAt = now();
+        changed();
+      });
+      return { ok: true, job: copy(job) };
+    },
+    snapshot: () => lives.map((live) => copy(live.job)),
+    stop,
+    retry(id, key) {
+      const live = find(id);
+      const slot = live?.job.slots.find((candidate) => candidate.key === key);
+      if (closed || live === void 0 || slot === void 0 || slot.state !== "failed" && slot.state !== "stopped" || live.runs.has(slot.key))
+        return false;
+      const attempt = begin(live, slot);
+      slot.state = "building";
+      slot.startedAt = now();
+      slot.failure = null;
+      detach(live, restore(slot).then(() => build(live, slot, attempt)), (message2) => lost(live, slot, attempt, message2));
+      live.job.state = "building";
+      live.job.endedAt = null;
+      changed();
+      return true;
+    },
+    replace(id, key) {
+      const live = find(id);
+      const slot = live?.job.slots.find((candidate) => candidate.key === key);
+      if (closed || live === void 0 || slot === void 0 || slot.state === "building" || slot.state === "checking" || live.runs.has(slot.key))
+        return false;
+      const attempt = begin(live, slot);
+      slot.state = "building";
+      slot.startedAt = now();
+      slot.failure = null;
+      live.job.state = "building";
+      live.job.endedAt = null;
+      changed();
+      const replacing = async () => {
+        const asking = run4(live.agent, live.agent.plan(replacePrompt2({
+          surface: live.job.surface,
+          brief: live.job.brief,
+          avoid: [...live.concepts.values()],
+          base: live.base
+        })), PLAN_DEADLINE_MS);
+        live.runs.set(slot.key, asking);
+        const outcome = await asking.done;
+        if (!owns(live, slot, attempt))
+          return;
+        if (live.runs.get(slot.key) === asking)
+          live.runs.delete(slot.key);
+        let concept;
+        try {
+          if (outcome.code !== 0)
+            throw new Error(failureOf2(live.agent, outcome).message);
+          concept = parseConcepts(live.agent.result(outcome.lines) ?? "", 1)[0];
+        } catch (error) {
+          fail(live, slot, {
+            code: "unreadable-plan",
+            message: error instanceof Error ? error.message : String(error)
+          });
+          settle(live);
+          changed();
+          return;
+        }
+        const titles = new Set(await deps.titles());
+        if (!owns(live, slot, attempt))
+          return;
+        titles.delete(slot.title);
+        const title = freeTitle(concept.title, titles);
+        await serially(async () => {
+          await deps.unregister([slot.title]);
+          return deps.register({
+            title,
+            url: `/?v-${surfaceSlug(live.job.surface)}=${slot.key}`,
+            note: concept.idea,
+            ...provenance(live.job)
+          });
+        });
+        live.concepts.set(slot.key, { ...concept, title });
+        slot.title = title;
+        slot.idea = concept.idea;
+        if (!owns(live, slot, attempt))
+          return;
+        await restore(slot);
+        await build(live, slot, attempt);
+      };
+      detach(live, replacing(), (message2) => lost(live, slot, attempt, message2));
+      return true;
+    },
+    async close() {
+      closed = true;
+      await Promise.race([
+        Promise.all(lives.map(async (live) => {
+          await stop(live.job.id);
+          await drain(live);
+        })),
+        wait(KILL_GRACE_MS * 2 + 1e3)
+      ]);
+    }
+  };
+}
+
+// ../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";
+var SERVER_INFO_PATH = ".leglas/server.json";
+async function writeServerInfo(cwd, info) {
+  const path = join15(cwd, SERVER_INFO_PATH);
+  const directory = dirname9(path);
+  await mkdir7(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)}
+`, "utf8");
+  await rename2(temporary, path).catch(async (cause) => {
+    await rm4(temporary, { force: true }).catch(() => {
+    });
+    throw cause;
+  });
+}
+async function readServerInfo(cwd) {
+  try {
+    const value = parseJson(await readFile15(join15(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 };
+  } catch {
+    return null;
+  }
+}
+async function removeServerInfo(cwd, expected) {
+  if (expected !== void 0) {
+    const current = await readServerInfo(cwd);
+    if (current !== null && (current.port !== expected.port || current.pid !== expected.pid))
+      return;
+  }
+  await rm4(join15(cwd, SERVER_INFO_PATH), { force: true });
+}
+
+// ../server/dist/server.js
+var LEGLAS_PREFIX = "/leglas";
+var DEFAULT_PORT = 4100;
+var PORT_ATTEMPTS = 20;
+var REFERENCE_MAX_BYTES = 1e7;
+var ATTACHED_WINDOW_MS = 6e3;
+var CONTENT_TYPES = {
+  ".css": "text/css; charset=utf-8",
+  ".gif": "image/gif",
+  ".html": "text/html; charset=utf-8",
+  ".ico": "image/x-icon",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".js": "text/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".txt": "text/plain; charset=utf-8",
+  ".webp": "image/webp",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2"
+};
+function isContentExtension(extension) {
+  return Object.hasOwn(CONTENT_TYPES, extension);
+}
+var FILES_PREFIX = `${LEGLAS_PREFIX}/files`;
+function sendJson2(res, status, body) {
+  const payload = JSON.stringify(body);
+  res.writeHead(status, {
+    "content-type": "application/json; charset=utf-8",
+    "cache-control": "no-store"
+  });
+  res.end(payload);
+}
+function etagMatches(value, etag) {
+  if (value === void 0)
+    return false;
+  const values = Array.isArray(value) ? value : [value];
+  return values.some((header) => header.split(",").some((candidate) => {
+    const tag = candidate.trim();
+    return tag === "*" || tag === etag || tag === `W/${etag}`;
+  }));
+}
+function sendConditionalJson(req, res, body) {
+  const payload = JSON.stringify(body);
+  const etag = `"${createHash2("sha256").update(payload).digest("base64url")}"`;
+  if (etagMatches(req.headers["if-none-match"], etag)) {
+    res.writeHead(304, { etag, "cache-control": "private, no-cache" });
+    res.end();
+    return;
+  }
+  res.writeHead(200, {
+    "content-type": "application/json; charset=utf-8",
+    "cache-control": "private, no-cache",
+    etag
+  });
+  res.end(payload);
+}
+var CAPTURE_DEADLINE_MS = 15e3;
+var CAPTURE_LOAD_MS = Math.floor(CAPTURE_DEADLINE_MS * LOAD_SHARE);
+function captureSlug(title) {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60) || "direction";
+}
+function referenceName(value) {
+  const raw = Array.isArray(value) ? value[0] ?? "" : value ?? "";
+  const safe = [...raw].filter((character) => {
+    const code = character.charCodeAt(0);
+    return code >= 32 && code <= 126 && character !== "/" && character !== "\\";
+  }).join("").trim().slice(0, 80);
+  return safe || "image";
+}
+function isAddressInUse(cause) {
+  return typeof cause === "object" && cause !== null && "code" in cause && cause.code === "EADDRINUSE";
+}
+function isKnownAgent(value) {
+  return isString(value) && Object.hasOwn(KNOWN_AGENTS, value);
+}
+function isAllowedMutationHost(hostname) {
+  const bare = hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
+  if (bare === "localhost" || bare === "127.0.0.1" || bare === "::1")
+    return true;
+  if (bare.endsWith(".local"))
+    return true;
+  if (!net3.isIPv4(bare))
+    return false;
+  const [first, second] = bare.split(".").map(Number);
+  return first === 10 || first === 172 && second !== void 0 && second >= 16 && second <= 31 || first === 192 && second === 168;
+}
+function isLoopbackAddress(address) {
+  if (address === void 0)
+    return false;
+  return address === "127.0.0.1" || address === "::1" || address === "::ffff:127.0.0.1" || address.startsWith("127.");
+}
+function isTrustedMutation(req) {
+  if (!isLoopbackAddress(req.socket.remoteAddress))
+    return false;
+  if (!isString(req.headers.host))
+    return false;
+  let host;
+  try {
+    host = new URL(`http://${req.headers.host}`);
+  } catch {
+    return false;
+  }
+  if (!isAllowedMutationHost(host.hostname))
+    return false;
+  const rawOrigin = req.headers.origin;
+  if (rawOrigin === void 0)
+    return true;
+  try {
+    const origin = new URL(rawOrigin);
+    return origin.protocol === "http:" && origin.host === host.host;
+  } catch {
+    return false;
+  }
+}
+function isEnded(request, failedIds) {
+  return isTerminal(request.status) || failedIds.includes(request.id);
+}
+function jsonBody(body) {
+  try {
+    const parsed2 = parseJson(body || "{}");
+    return isJsonRecord(parsed2) ? parsed2 : null;
+  } catch {
+    return null;
+  }
+}
+function requestIntent(value) {
   if (value === null || value === void 0)
     return "";
   return isString(value) ? value.trim() : null;
@@ -7150,8 +8338,8 @@ function probe(target, timeoutMs = 1e3) {
   });
 }
 function serveFrom(res, dir, relativePath) {
-  const relative6 = normalize(relativePath).replace(/^(\.\.[/\\])+/, "");
-  const candidate = join12(dir, relative6);
+  const relative8 = normalize2(relativePath).replace(/^(\.\.[/\\])+/, "");
+  const candidate = join16(dir, relative8);
   if (!candidate.startsWith(dir))
     return false;
   if (!existsSync3(candidate) || !statSync(candidate).isFile())
@@ -7165,25 +8353,25 @@ function serveFrom(res, dir, relativePath) {
   return true;
 }
 function serveShellFile(res, shellDir, urlPath) {
-  const relative6 = normalize(urlPath.slice(LEGLAS_PREFIX.length)).replace(/^(\.\.[/\\])+/, "");
-  const isRoot = relative6 === "" || relative6 === "." || relative6 === "/";
-  return serveFrom(res, shellDir, isRoot ? "index.html" : relative6);
+  const relative8 = normalize2(urlPath.slice(LEGLAS_PREFIX.length)).replace(/^(\.\.[/\\])+/, "");
+  const isRoot = relative8 === "" || relative8 === "." || relative8 === "/";
+  return serveFrom(res, shellDir, isRoot ? "index.html" : relative8);
 }
 var HEALTH_PROBE_MS = 3e3;
 function fileStamp(path) {
   try {
-    const stat5 = statSync(path);
-    return `${stat5.dev}:${stat5.ino}:${stat5.size}:${stat5.mtimeMs}:${stat5.ctimeMs}`;
+    const stat6 = statSync(path);
+    return `${stat6.dev}:${stat6.ino}:${stat6.size}:${stat6.mtimeMs}:${stat6.ctimeMs}`;
   } catch {
     return null;
   }
 }
 function watchLiveFiles(cwd, configPath, live) {
-  const leglasDir = join12(cwd, ".leglas");
+  const leglasDir = join16(cwd, ".leglas");
   const targets = [
-    { path: join12(cwd, LOCAL_PREVIEWS_PATH), change: "config" },
-    { path: join12(cwd, REQUESTS_PATH), change: "requests" },
-    { path: join12(cwd, ANNOTATIONS_PATH), change: "requests" }
+    { path: join16(cwd, LOCAL_PREVIEWS_PATH), change: "config" },
+    { path: join16(cwd, REQUESTS_PATH), change: "requests" },
+    { path: join16(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)]));
@@ -7297,7 +8485,7 @@ function watchLiveFiles(cwd, configPath, live) {
   }
   if (configPath !== null) {
     try {
-      const directory = dirname8(configPath);
+      const directory = dirname10(configPath);
       const name = basename3(configPath);
       const target = { path: configPath, change: "config" };
       known.set(configPath, fileStamp(configPath));
@@ -7335,7 +8523,7 @@ function watchLiveFiles(cwd, configPath, live) {
     }
   };
 }
-function watchHealth(target, live) {
+function watchHealth(target, live, intervalMs) {
   let previous = null;
   let probing = false;
   let closed = false;
@@ -7358,7 +8546,7 @@ function watchHealth(target, live) {
     }).finally(() => {
       probing = false;
     });
-  }, HEALTH_PROBE_MS);
+  }, intervalMs);
   timer.unref?.();
   return {
     close: () => {
@@ -7382,15 +8570,15 @@ function configStalenessNotice(cwd, boot, current) {
   if (boot === null && current === null)
     return null;
   if (boot === null && current !== null) {
-    const label = relative3(cwd, current.path) || current.path;
+    const label = relative4(cwd, current.path) || current.path;
     return `${label} appeared after Leglas started. Restart leglas to pick it up.`;
   }
   if (boot !== null && current === null) {
-    const label = relative3(cwd, boot.path) || boot.path;
+    const label = relative4(cwd, boot.path) || boot.path;
     return `${label} was removed after Leglas started. Restart leglas to run without it.`;
   }
   if (boot !== null && current !== null && (boot.path !== current.path || boot.mtimeMs !== current.mtimeMs)) {
-    const label = relative3(cwd, current.path) || current.path;
+    const label = relative4(cwd, current.path) || current.path;
     return `${label} changed after Leglas started. Restart leglas to pick it up.`;
   }
   return null;
@@ -7436,7 +8624,7 @@ async function bind2(server, requested) {
   throw new Error(`No free port between ${requested} and ${requested + PORT_ATTEMPTS - 1}.`);
 }
 async function startServer(options) {
-  const { config, configErrors = [], configWarnings = [], shellDir = null, project = "", cwd = process.cwd(), leglasCommand = "npx -y leglas", fileMounts = /* @__PURE__ */ new Map(), detect = () => detectAgents() } = options;
+  const { config, configErrors = [], configWarnings = [], shellDir = null, project = "", cwd = process.cwd(), leglasCommand = "npx -y leglas", fileMounts = /* @__PURE__ */ new Map(), detect = () => detectAgents(), captureDeadlineMs = CAPTURE_DEADLINE_MS, healthProbeMs = HEALTH_PROBE_MS } = options;
   const browserPool = options.pool ?? createBrowserPool();
   let shares = null;
   let liveHealth = null;
@@ -7481,6 +8669,7 @@ async function startServer(options) {
   let lastSeen = null;
   const externallyAttached = () => lastSeen !== null && Date.now() - lastSeen < ATTACHED_WINDOW_MS;
   let runner = null;
+  let generations = null;
   let agentsCache = null;
   let agentsInflight = null;
   const AGENTS_FRESH_MS = 3e4;
@@ -7531,11 +8720,36 @@ async function startServer(options) {
       });
     });
   };
+  const readGenerationBody = (req, res, run4) => {
+    if (!hasJsonBody(req)) {
+      return sendJson2(res, 400, { ok: false, error: "A generation request must be JSON." });
+    }
+    let body = "";
+    req.on("data", (chunk) => body += chunk);
+    req.on("end", () => {
+      const parsed2 = jsonBody(body);
+      if (parsed2 === null)
+        return sendJson2(res, 400, { ok: false, error: "Body must be JSON." });
+      if (generations === null)
+        return sendJson2(res, 503, { ok: false, error: "Leglas is still starting." });
+      void run4(parsed2, generations);
+    });
+  };
+  const actOnGeneration = async (res, action, parsed2, act) => {
+    if (!isString(parsed2.id) || parsed2.slot !== void 0 && !isString(parsed2.slot)) {
+      return sendJson2(res, 400, {
+        ok: false,
+        error: "Name the generation by its id, and the direction by its slot."
+      });
+    }
+    const done = await act(parsed2.id, isString(parsed2.slot) ? parsed2.slot : void 0);
+    return done ? sendJson2(res, 200, { ok: true }) : sendJson2(res, 409, { ok: false, error: `Nothing to ${action} there right now.` });
+  };
   const handleRequest = (req, res, context) => {
     const url = req.url ?? "/";
     const path = url.split("?")[0] ?? "/";
     const query = new URLSearchParams(url.includes("?") ? url.slice(url.indexOf("?") + 1) : "");
-    if (!context.remote && req.method === "POST" && path.startsWith(`${LEGLAS_PREFIX}/api/`) && !isTrustedMutation(req)) {
+    if (!context.remote && req.method !== "GET" && req.method !== "HEAD" && path.startsWith(`${LEGLAS_PREFIX}/api/`) && !isTrustedMutation(req)) {
       return sendJson2(res, 403, { ok: false, error: "Cross-origin API mutations are refused." });
     }
     if (context.remote && path === `${LEGLAS_PREFIX}/api/config`) {
@@ -7553,6 +8767,48 @@ async function startServer(options) {
     if (context.remote && path.startsWith(`${LEGLAS_PREFIX}/api/`)) {
       return sendJson2(res, 403, { error: "Not available to viewers." });
     }
+    if (path === `${LEGLAS_PREFIX}/api/generate` && req.method === "GET") {
+      return sendJson2(res, 200, { ok: true, jobs: generations?.snapshot() ?? [] });
+    }
+    if (path === `${LEGLAS_PREFIX}/api/generate` && req.method === "POST") {
+      return void readGenerationBody(req, res, async (parsed2, running) => {
+        if (!isString(parsed2.surface) || !isString(parsed2.brief)) {
+          return sendJson2(res, 400, {
+            ok: false,
+            error: "Name a surface and describe the directions in a brief."
+          });
+        }
+        let basedOn = null;
+        if (parsed2.basedOn !== void 0 && parsed2.basedOn !== null && parsed2.basedOn !== "") {
+          const title = parsed2.basedOn;
+          const preview = isString(title) ? (await livePreviews()).find((entry) => entry.title === title) : void 0;
+          basedOn = preview === void 0 ? null : baseOf(preview, parsed2.surface);
+          if (basedOn === null) {
+            return sendJson2(res, 422, {
+              ok: false,
+              error: `${isString(title) ? title : "That"} is not a direction of the ${surfaceSlug(parsed2.surface)}, so Leglas cannot build variations of it.`
+            });
+          }
+        }
+        const started = await running.start({
+          surface: parsed2.surface,
+          brief: parsed2.brief,
+          count: isNumber(parsed2.count) ? parsed2.count : 3,
+          agent: await readAgentChoice(cwd),
+          basedOn
+        });
+        return started.ok ? sendJson2(res, 202, { ok: true, job: started.job }) : sendJson2(res, 422, { ok: false, error: started.error });
+      });
+    }
+    if (path === `${LEGLAS_PREFIX}/api/generate/stop` && req.method === "POST") {
+      return void readGenerationBody(req, res, (parsed2, running) => actOnGeneration(res, "stop", parsed2, (id, slot) => running.stop(id, slot)));
+    }
+    if (path === `${LEGLAS_PREFIX}/api/generate/retry` && req.method === "POST") {
+      return void readGenerationBody(req, res, (parsed2, running) => actOnGeneration(res, "retry", parsed2, (id, slot) => slot === void 0 ? false : running.retry(id, slot)));
+    }
+    if (path === `${LEGLAS_PREFIX}/api/generate/replace` && req.method === "POST") {
+      return void readGenerationBody(req, res, (parsed2, running) => actOnGeneration(res, "replace", parsed2, (id, slot) => slot === void 0 ? false : running.replace(id, slot)));
+    }
     if (path === `${LEGLAS_PREFIX}/api/update` && req.method === "GET" || req.method === "POST" && ["check", "skip", "install"].some((action) => path === `${LEGLAS_PREFIX}/api/update/${action}`)) {
       const updates = options.updates;
       if (updates === void 0) {
@@ -7816,8 +9072,8 @@ async function startServer(options) {
         const id = newRequestId();
         const file = `${REFERENCES_DIR}/${id}.${image.kind}`;
         try {
-          await mkdir8(join12(cwd, REFERENCES_DIR), { recursive: true });
-          await writeFile8(join12(cwd, file), body);
+          await mkdir8(join16(cwd, REFERENCES_DIR), { recursive: true });
+          await writeFile9(join16(cwd, file), body);
           void pruneReferences(cwd).catch(() => {
           });
           return sendJson2(res, 200, {
@@ -7859,7 +9115,7 @@ async function startServer(options) {
         }
         const references = parsed2.references ?? [];
         if (references.length > 0) {
-          const present = new Set((await readdir3(join12(cwd, REFERENCES_DIR)).catch(() => [])).map((name) => name.slice(0, name.indexOf(".") === -1 ? name.length : name.indexOf("."))));
+          const present = new Set((await readdir5(join16(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, {
@@ -7989,7 +9245,7 @@ async function startServer(options) {
         const timer = setTimeout(() => {
           timedOut2();
           controller.abort();
-        }, CAPTURE_DEADLINE_MS);
+        }, captureDeadlineMs);
         timer.unref?.();
         try {
           const captureInput = {
@@ -8022,8 +9278,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(join12(cwd, CAPTURES_DIR, "show"), { recursive: true });
-          await writeFile8(join12(cwd, relativeFile), shot.png);
+          await mkdir8(join16(cwd, CAPTURES_DIR, "show"), { recursive: true });
+          await writeFile9(join16(cwd, relativeFile), shot.png);
           return sendJson2(res, 200, {
             ok: true,
             file: relativeFile,
@@ -8403,15 +9659,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 relative6 = slash === -1 ? "" : rest.slice(slash + 1);
+      let relative8 = slash === -1 ? "" : rest.slice(slash + 1);
       try {
-        relative6 = decodeURIComponent(relative6);
+        relative8 = decodeURIComponent(relative8);
       } catch {
-        relative6 = "";
+        relative8 = "";
       }
       const dir = fileMounts.get(slug);
       const serveMount = () => {
-        if (dir !== void 0 && relative6 !== "" && serveFrom(res, dir, relative6))
+        if (dir !== void 0 && relative8 !== "" && serveFrom(res, dir, relative8))
           return;
         res.writeHead(404, {
           "content-type": "text/plain; charset=utf-8",
@@ -8421,7 +9677,7 @@ async function startServer(options) {
       };
       if (!context.remote)
         return serveMount();
-      if (relative6.split("/").some((segment) => segment.startsWith("."))) {
+      if (relative8.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) => {
@@ -8502,7 +9758,7 @@ async function startServer(options) {
   port = await bind2(server, options.port ?? DEFAULT_PORT);
   options.updates?.setPort(port);
   const liveFiles = watchLiveFiles(cwd, bootConfigPath, live);
-  liveHealth = watchHealth(target, live);
+  liveHealth = watchHealth(target, live, healthProbeMs);
   await pruneCaptures(cwd, (await readRequests(cwd).catch(() => [])).map((request) => request.id)).catch(() => {
   });
   await writeServerInfo(cwd, {
@@ -8522,6 +9778,42 @@ async function startServer(options) {
   if (options.claudeAgentSession !== void 0)
     runnerOptions.claudeAgentSession = options.claudeAgentSession;
   runner = startRunner(runnerOptions);
+  const renderDirection = async (title) => {
+    const preview = (await livePreviews()).find((entry) => entry.title === title);
+    if (preview === void 0)
+      return null;
+    const browser = await browserPool.acquire();
+    if (browser === null)
+      return null;
+    const address = server.address();
+    const renderPort = address !== null && !isString(address) ? address.port : options.port ?? DEFAULT_PORT;
+    try {
+      const captured = await capturePage(browser, {
+        url: previewUrl(`http://127.0.0.1:${renderPort}`, preview),
+        width: 1440,
+        timeoutMs: CAPTURE_LOAD_MS
+      });
+      return { errors: captured.errors };
+    } catch (error) {
+      return { errors: [error instanceof Error ? error.message : String(error)] };
+    }
+  };
+  const generationDeps = {
+    cwd,
+    render: renderDirection,
+    register: (input) => addLocalPreview(cwd, input, (config?.previews ?? []).filter((entry) => entry.local !== true)),
+    unregister: async (titles) => {
+      await dropLocalPreviews(cwd, titles);
+    },
+    titles: async () => {
+      const local = await readLocalPreviews(cwd).catch(() => null);
+      return new Set([...config?.previews ?? [], ...local?.previews ?? []].map((entry) => entry.title));
+    },
+    onChange: () => live.nudge("generation")
+  };
+  if (options.generationSpawn !== void 0)
+    generationDeps.spawn = options.generationSpawn;
+  generations = createGenerations(generationDeps);
   options.updates?.onBusy(() => runner?.snapshot().running ?? false);
   options.updates?.onChange(() => live.nudge("update"));
   let closePromise = null;
@@ -8539,6 +9831,7 @@ async function startServer(options) {
           shares?.close() ?? Promise.resolve(),
           branches.stop(),
           runner.stop(),
+          generations?.close() ?? Promise.resolve(),
           browserPool.close(),
           live.close()
         ]);
@@ -8560,9 +9853,9 @@ 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 writeFile9 } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { dirname as dirname9, join as join13, posix as posix2, win32 } from "path";
+import { lstat as lstat3, mkdir as mkdir9, mkdtemp, rename as rename3, rm as rm5, writeFile as writeFile10 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname11, join as join17, 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";
@@ -8762,7 +10055,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 : join13)(install.root, "node_modules", ".bin", windows ? "leglas.cmd" : "leglas");
+    const shim = (windows ? win32.join : join17)(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);
@@ -8793,7 +10086,7 @@ function readState(path) {
 }
 function defaultStatePath(home) {
   try {
-    return join13(home(), ".leglas", "update.json");
+    return join17(home(), ".leglas", "update.json");
   } catch {
     return null;
   }
@@ -8811,16 +10104,16 @@ function mergeState(current, saved) {
 async function writeState(path, state) {
   let temporary = null;
   try {
-    const directory = dirname9(path);
+    const directory = dirname11(path);
     await mkdir9(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(join13(directory, ".update-"));
-    const file = join13(temporary, "update.json");
-    await writeFile9(file, `${JSON.stringify(state, null, 2)}
+    temporary = await mkdtemp(join17(directory, ".update-"));
+    const file = join17(temporary, "update.json");
+    await writeFile10(file, `${JSON.stringify(state, null, 2)}
 `, "utf8");
     await rename3(file, path);
   } catch {
@@ -8881,7 +10174,7 @@ function installerReason(stdout, stderr) {
   const lines2 = (output2) => output2.split(/\r?\n/).filter((line) => !/^\s+at /.test(line) && !/A complete log of this run|info Visit https:\/\/yarnpkg\.com/.test(line)).map((line) => line.trim()).filter(Boolean);
   const errors = lines2(stderr);
   const output = lines2(stdout);
-  const npm = [...errors, ...output].find((line) => /^npm error\s+\S/.test(line) && !/^npm error code\s/.test(line));
+  const npm = [...errors, ...output].find((line) => /^npm error\s+\S/.test(line) && !/^npm error (code|syscall|file|path|dest|errno)\s/.test(line));
   return npm?.replace(/^npm error\s+/, "") ?? errors[0] ?? output[0] ?? null;
 }
 function installVersion(install, version2, deps) {
@@ -8981,7 +10274,7 @@ function createUpdateService(input) {
   const fetcher = deps.fetch ?? fetch;
   const now = deps.now ?? Date.now;
   const timeoutMs = deps.timeoutMs ?? 4e3;
-  const statePath = deps.statePath === void 0 ? defaultStatePath(deps.homedir ?? homedir2) : deps.statePath;
+  const statePath = deps.statePath === void 0 ? defaultStatePath(deps.homedir ?? homedir3) : deps.statePath;
   const exists = deps.exists ?? existsSync4;
   const env = deps.env ?? process.env;
   const install = detectInstall(input.entry, input.cwd, exists, deps.realpath ?? realPath, env);
@@ -9204,7 +10497,7 @@ async function runClassify(options, deps) {
   const declared = await Promise.all(
     options.changes.map(async (change) => ({
       ...change,
-      exists: await stat4(join14(options.cwd, change.path)).then(
+      exists: await stat5(join18(options.cwd, change.path)).then(
         () => true,
         () => false
       )
@@ -9291,7 +10584,7 @@ function detectFramework(packageJson) {
     return "react";
   }
 }
-function surfaceSlug(surface) {
+function surfaceSlug2(surface) {
   return surface.trim().toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
 }
 function titleCase(slug) {
@@ -9388,14 +10681,14 @@ function placeholder(label, note) {
   return `export function ${label}() {
   return (
     <div style={{ padding: "3rem", fontFamily: "system-ui" }}>
-      <p>${note}</p>
+      <p>{${JSON.stringify(note)}}</p>
     </div>
   );
 }
 `;
 }
 function planNew(options) {
-  const slug = surfaceSlug(options.surface);
+  const slug = surfaceSlug2(options.surface);
   const framework = detectFramework(options.packageJson);
   const name = titleCase(slug).replace(/\s/g, "");
   const dir = `.leglas/variants/${slug}`;
@@ -9439,7 +10732,7 @@ Rewriting your component automatically is how a tool breaks a codebase it does n
 
 // src/explore.ts
 function planExplore(surface, count, basedOn = null) {
-  const slug = surfaceSlug(surface);
+  const slug = surfaceSlug2(surface);
   const goal = basedOn === null ? `Build ${count} design directions for "${surface}".
 
 The set exists to be chosen from, and the choice only means something if the directions genuinely disagree: ${count} variants of one idea would make it empty. What counts as different is yours to decide, and the strongest sets disagree about more than styling.
@@ -9477,9 +10770,176 @@ function runExplore(options, deps) {
   return { exitCode: 0 };
 }
 
+// src/json.ts
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isString2(value) {
+  return typeof value === "string";
+}
+function isNumber2(value) {
+  return typeof value === "number";
+}
+async function bodyOf(response) {
+  try {
+    return JSON.parse(await response.text());
+  } catch {
+    return null;
+  }
+}
+
+// src/running.ts
+import { realpath as realpath2 } from "fs/promises";
+var NOT_RUNNING = "Leglas is not running here. Start it with npx leglas, then try again.";
+async function sameDirectory(left, right) {
+  const [a, b] = await Promise.all([
+    realpath2(left).catch(() => left),
+    realpath2(right).catch(() => right)
+  ]);
+  return a === b;
+}
+async function findLeglas(cwd, port, request) {
+  const server = port === null ? await readServerInfo(cwd) : null;
+  const chosen = port ?? server?.port ?? DEFAULT_PORT;
+  try {
+    const health = await request(`http://127.0.0.1:${chosen}/leglas/api/health`, {
+      signal: AbortSignal.timeout(2e3)
+    });
+    if (health.status !== 200) return { ok: false, error: NOT_RUNNING };
+    const answered = await health.text().then((text3) => JSON.parse(text3)).catch(() => ({}));
+    if (answered === null) return { ok: false, error: NOT_RUNNING };
+    if (isJsonObject(answered) && isString2(answered.cwd) && !await sameDirectory(answered.cwd, cwd)) {
+      return {
+        ok: false,
+        error: `The Leglas on port ${chosen} serves another project. Start one here with npx leglas, or name the right one with --port.`
+      };
+    }
+    return { ok: true, port: chosen, base: `http://127.0.0.1:${chosen}` };
+  } catch {
+    return { ok: false, error: NOT_RUNNING };
+  }
+}
+
+// src/run-explore-build.ts
+var POLL_MS2 = 1e3;
+var WAIT_MS = 20 * 6e4;
+function readJob(value) {
+  if (value === void 0 || !isJsonObject(value)) return null;
+  const { id, state, slots, error, startedAt, endedAt } = value;
+  if (!isString2(id) || !isString2(state) || !Array.isArray(slots)) return null;
+  const read = slots.flatMap((entry) => {
+    if (!isJsonObject(entry) || !isString2(entry.key) || !isString2(entry.title) || !isString2(entry.state))
+      return [];
+    const failure = entry.failure === void 0 || entry.failure === null || !isJsonObject(entry.failure) ? null : entry.failure;
+    return [
+      {
+        key: entry.key,
+        title: entry.title,
+        state: entry.state,
+        failure: failure !== null && isString2(failure.message) ? { message: failure.message } : null,
+        fixed: entry.fixed === true
+      }
+    ];
+  });
+  return {
+    id,
+    state,
+    error: isString2(error) ? error : null,
+    slots: read,
+    startedAt: isNumber2(startedAt) ? startedAt : Date.now(),
+    endedAt: isNumber2(endedAt) ? endedAt : null
+  };
+}
+async function runExploreBuild(options, deps) {
+  const request = deps.fetch ?? fetch;
+  const sleep = deps.sleep ?? ((milliseconds) => new Promise((resolve5) => setTimeout(resolve5, milliseconds)));
+  const fail = (error) => {
+    if (options.json) deps.log(JSON.stringify({ ok: false, error }));
+    else deps.error(error);
+    return { exitCode: 1 };
+  };
+  const found = await findLeglas(options.cwd, options.port, request);
+  if (!found.ok) return fail(found.error);
+  const base = `http://127.0.0.1:${found.port}/leglas/api/generate`;
+  let started;
+  try {
+    started = await bodyOf(
+      await request(base, {
+        method: "POST",
+        headers: { "content-type": "application/json", origin: `http://127.0.0.1:${found.port}` },
+        body: JSON.stringify({
+          surface: options.surface,
+          brief: options.brief,
+          count: options.count,
+          basedOn: options.basedOn
+        })
+      })
+    );
+  } catch {
+    return fail("Leglas did not answer. Is it still running?");
+  }
+  const answer = isJsonObject(started) ? started : null;
+  const first = readJob(answer?.job);
+  if (answer?.ok !== true || first === null) {
+    return fail(isString2(answer?.error) ? answer.error : "Leglas could not start the build.");
+  }
+  if (!options.json) {
+    deps.log(
+      options.basedOn === null ? `Planning ${options.count} directions for the ${options.surface}\u2026` : `Planning ${options.count} variations of ${options.basedOn}\u2026`
+    );
+  }
+  const said = /* @__PURE__ */ new Map();
+  let announced = false;
+  let job = first;
+  const deadline = Date.now() + WAIT_MS;
+  while (Date.now() < deadline) {
+    await sleep(POLL_MS2);
+    let listed;
+    try {
+      listed = 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 latest = Array.isArray(jobs) ? jobs.map(readJob).find((candidate) => candidate?.id === first.id) : void 0;
+    if (latest === void 0 || latest === null) continue;
+    job = latest;
+    if (!options.json && !announced && job.slots.length > 0) {
+      announced = true;
+      deps.log(
+        `On the rail: ${job.slots.map((slot) => slot.title).join(", ")}. Building them now.`
+      );
+    }
+    for (const slot of job.slots) {
+      if (options.json || said.get(slot.key) === slot.state) continue;
+      said.set(slot.key, slot.state);
+      if (slot.state === "ready")
+        deps.log(
+          `Ready: ${slot.title}${slot.fixed ? " (its first version did not render; fixed)" : ""}`
+        );
+      else if (slot.state === "failed")
+        deps.log(`Failed: ${slot.title}. ${slot.failure?.message ?? ""}`.trim());
+      else if (slot.state === "stopped") deps.log(`Stopped: ${slot.title}`);
+    }
+    if (job.state === "done" || job.state === "failed" || job.state === "stopped") break;
+  }
+  const ready = job.slots.filter((slot) => slot.state === "ready").length;
+  const ok = job.state === "done" && ready === job.slots.length && ready > 0;
+  if (options.json) {
+    deps.log(JSON.stringify({ ok, job }));
+    return { exitCode: ok ? 0 : 1 };
+  }
+  if (job.state === "failed") return fail(job.error ?? "The build failed.");
+  const seconds = job.endedAt === null ? null : Math.round((job.endedAt - job.startedAt) / 1e3);
+  deps.log(
+    `${ready} of ${job.slots.length} directions ready${seconds === null ? "" : ` in ${seconds} s`}. Compare them in the interface, or keep one with leglas keep.`
+  );
+  return { exitCode: ok ? 0 : 1 };
+}
+
 // src/run-init.ts
-import { readFile as readFile12, writeFile as writeFile10 } from "fs/promises";
-import { join as join15 } from "path";
+import { readFile as readFile16, writeFile as writeFile11 } from "fs/promises";
+import { join as join19 } from "path";
 
 // src/init.ts
 var AGENTS_MARKER_START = "<!-- leglas:start -->";
@@ -9598,7 +11058,8 @@ Useful to know:
   they have asked for that is not done yet. Add \`--screenshot\` to render a PNG
   you can inspect. Run it when handed a direction you did not register yourself.
 - Every command accepts \`--json\` and prints one envelope with a stable exit
-  code, so you can drive it without parsing prose.
+  code, so you can drive it without parsing prose. \`watch\` keeps running, so
+  it prints one JSON line per event instead.
 
 ${AGENTS_MARKER_END}
 `;
@@ -9640,7 +11101,7 @@ ${AGENTS_SECTION}`
 // src/run-init.ts
 async function readIfPresent(path) {
   try {
-    return await readFile12(path, "utf8");
+    return await readFile16(path, "utf8");
   } catch {
     return null;
   }
@@ -9648,18 +11109,18 @@ async function readIfPresent(path) {
 async function runInit(options, deps) {
   const existingConfig = findConfigFile(options.cwd);
   const plan = planInit({
-    agents: await readIfPresent(join15(options.cwd, "AGENTS.md")),
+    agents: await readIfPresent(join19(options.cwd, "AGENTS.md")),
     config: existingConfig === null ? null : "present",
-    gitignore: await readIfPresent(join15(options.cwd, ".gitignore")),
+    gitignore: await readIfPresent(join19(options.cwd, ".gitignore")),
     force: options.force
   });
   const touched = [];
   for (const write2 of plan.writes) {
-    await writeFile10(join15(options.cwd, write2.path), write2.contents, "utf8");
+    await writeFile11(join19(options.cwd, write2.path), write2.contents, "utf8");
     touched.push(write2.path);
   }
   if (plan.gitignore !== null) {
-    await writeFile10(join15(options.cwd, ".gitignore"), plan.gitignore, "utf8");
+    await writeFile11(join19(options.cwd, ".gitignore"), plan.gitignore, "utf8");
     touched.push(".gitignore");
   }
   if (options.json) {
@@ -9679,11 +11140,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 readFile13, rm as rm6, writeFile as writeFile11 } from "fs/promises";
-import { dirname as dirname10, join as join16 } from "path";
+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";
 
 // src/keep.ts
-import { basename as basename4, extname as extname4, normalize as normalize2 } from "path";
+import { basename as basename4, extname as extname4, isAbsolute as isAbsolute2, normalize as normalize3 } from "path";
 function surfaceOf(url) {
   if (!url.startsWith("/") || !url.includes("?")) return null;
   for (const pair of url.slice(url.indexOf("?") + 1).split("&")) {
@@ -9712,8 +11173,8 @@ 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 = normalize2(options.to);
-  if (to.startsWith("..")) {
+  const to = normalize3(options.to);
+  if (to.startsWith("..") || isAbsolute2(to)) {
     return { ok: false, error: "The destination has to be inside the project." };
   }
   if (to.split(/[/\\]/)[0] === ".leglas") {
@@ -9768,15 +11229,15 @@ async function writeLogEntry(options) {
     annotations: await readAnnotations(options.cwd),
     date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)
   });
-  const dir = join16(options.cwd, options.logDir);
+  const dir = join20(options.cwd, options.logDir);
   await mkdir10(dir, { recursive: true });
-  const file = join16(dir, `${entry.slug}.md`);
-  await writeFile11(file, entry.markdown, "utf8");
+  const file = join20(dir, `${entry.slug}.md`);
+  await writeFile12(file, entry.markdown, "utf8");
   if (entry.pictures.length > 0) {
-    const pictureDir = join16(dir, entry.slug);
+    const pictureDir = join20(dir, entry.slug);
     await mkdir10(pictureDir, { recursive: true });
     for (const picture of entry.pictures) {
-      await copyFile2(join16(options.cwd, picture.from), join16(pictureDir, picture.to)).catch(() => {
+      await copyFile2(join20(options.cwd, picture.from), join20(pictureDir, picture.to)).catch(() => {
       });
     }
   }
@@ -9797,19 +11258,20 @@ async function runKeep(options, deps) {
     await readRenames(options.cwd)
   );
   if (!resolved.ok) return fail(resolved.error);
-  const plan = planKeep({ title: resolved.title, previews, to: options.to });
+  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 = join16(options.cwd, plan.move.from);
-  const to = join16(options.cwd, plan.move.to);
+  const from = join20(options.cwd, plan.move.from);
+  const to = join20(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 readFile13(from, "utf8");
-  await mkdir10(dirname10(to), { recursive: true });
-  await writeFile11(to, renameExport(source, plan.exportName), "utf8");
+  const source = await readFile17(from, "utf8");
+  await mkdir10(dirname12(to), { recursive: true });
+  await writeFile12(to, renameExport(source, plan.exportName), "utf8");
   const surface = plan.removeDir.slice(plan.removeDir.lastIndexOf("/") + 1);
   let logged = null;
   let logError = null;
@@ -9824,7 +11286,7 @@ async function runKeep(options, deps) {
   } catch (error) {
     logError = error instanceof Error ? error.message : String(error);
   }
-  await rm6(join16(options.cwd, plan.removeDir), { recursive: true, force: true });
+  await rm6(join20(options.cwd, plan.removeDir), { recursive: true, force: true });
   const dropped = await dropLocalPreviews(options.cwd, plan.dropTitles);
   if (options.json) {
     deps.log(
@@ -9863,11 +11325,11 @@ async function runKeep(options, deps) {
 
 // src/run-new.ts
 import { existsSync as existsSync6 } from "fs";
-import { mkdir as mkdir11, readFile as readFile14, writeFile as writeFile12 } from "fs/promises";
-import { dirname as dirname11, join as join17 } from "path";
+import { mkdir as mkdir11, readFile as readFile18, writeFile as writeFile13 } from "fs/promises";
+import { dirname as dirname13, join as join21 } from "path";
 async function readIfPresent2(path) {
   try {
-    return await readFile14(path, "utf8");
+    return await readFile18(path, "utf8");
   } catch {
     return null;
   }
@@ -9875,7 +11337,7 @@ async function readIfPresent2(path) {
 async function runNew(options, deps) {
   let from;
   if (options.from !== void 0) {
-    const contents = await readIfPresent2(join17(options.cwd, options.from));
+    const contents = await readIfPresent2(join21(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 }));
@@ -9886,8 +11348,8 @@ async function runNew(options, deps) {
   }
   const plan = planNew({
     surface: options.surface,
-    packageJson: await readIfPresent2(join17(options.cwd, "package.json")),
-    gitignore: await readIfPresent2(join17(options.cwd, ".gitignore")),
+    packageJson: await readIfPresent2(join21(options.cwd, "package.json")),
+    gitignore: await readIfPresent2(join21(options.cwd, ".gitignore")),
     from
   });
   const fail = (error) => {
@@ -9917,7 +11379,7 @@ async function runNew(options, deps) {
     deps.log(plan.instructions);
     return { exitCode: 0, written: [] };
   }
-  const existing = plan.writes.filter((write2) => existsSync6(join17(options.cwd, write2.path)));
+  const existing = plan.writes.filter((write2) => existsSync6(join21(options.cwd, write2.path)));
   if (existing.length > 0) {
     return fail(
       `${existing[0]?.path} already exists. Delete it first, or pick another surface name.`
@@ -9925,13 +11387,13 @@ async function runNew(options, deps) {
   }
   const written = [];
   for (const write2 of plan.writes) {
-    const target = join17(options.cwd, write2.path);
-    await mkdir11(dirname11(target), { recursive: true });
-    await writeFile12(target, write2.contents, "utf8");
+    const target = join21(options.cwd, write2.path);
+    await mkdir11(dirname13(target), { recursive: true });
+    await writeFile13(target, write2.contents, "utf8");
     written.push(write2.path);
   }
   if (plan.gitignore !== null) {
-    await writeFile12(join17(options.cwd, ".gitignore"), plan.gitignore, "utf8");
+    await writeFile13(join21(options.cwd, ".gitignore"), plan.gitignore, "utf8");
     written.push(".gitignore");
   }
   if (options.json) {
@@ -9959,8 +11421,8 @@ async function runNew(options, deps) {
 }
 
 // src/run-log.ts
-import { readFile as readFile15, readdir as readdir4 } from "fs/promises";
-import { join as join18 } from "path";
+import { readFile as readFile19, readdir as readdir6 } from "fs/promises";
+import { join as join22 } from "path";
 function headline(markdown) {
   const first = markdown.split("\n", 1)[0] ?? "";
   return first.replace(/^#\s*/, "").trim();
@@ -9970,7 +11432,7 @@ async function runLog(options, deps) {
   const dir = loaded.config?.logDir ?? DEFAULT_LOG_DIR;
   let names;
   try {
-    names = (await readdir4(join18(options.cwd, dir))).filter((name) => name.endsWith(".md")).sort().reverse();
+    names = (await readdir6(join22(options.cwd, dir))).filter((name) => name.endsWith(".md")).sort().reverse();
   } catch {
     names = [];
   }
@@ -9983,7 +11445,7 @@ async function runLog(options, deps) {
       else deps.error(error);
       return { exitCode: 1 };
     }
-    const markdown = await readFile15(join18(options.cwd, dir, found), "utf8");
+    const markdown = await readFile19(join22(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 };
@@ -9991,7 +11453,7 @@ async function runLog(options, deps) {
   const entries = await Promise.all(
     names.map(async (name) => ({
       entry: name.replace(/\.md$/, ""),
-      title: headline(await readFile15(join18(options.cwd, dir, name), "utf8")),
+      title: headline(await readFile19(join22(options.cwd, dir, name), "utf8")),
       file: `${dir}/${name}`
     }))
   );
@@ -10009,21 +11471,21 @@ async function runLog(options, deps) {
 }
 
 // src/run-previews.ts
-import { readFile as readFile16, writeFile as writeFile13 } from "fs/promises";
-import { join as join19 } from "path";
+import { readFile as readFile20, writeFile as writeFile14 } from "fs/promises";
+import { join as join23 } from "path";
 function envelope(deps, ok, body) {
   deps.log(JSON.stringify({ ok, ...body }));
 }
 async function ensureIgnored(cwd) {
-  const path = join19(cwd, ".gitignore");
+  const path = join23(cwd, ".gitignore");
   let current = null;
   try {
-    current = await readFile16(path, "utf8");
+    current = await readFile20(path, "utf8");
   } catch {
     current = null;
   }
   const next = ignoreEntry(current);
-  if (next !== null) await writeFile13(path, next, "utf8");
+  if (next !== null) await writeFile14(path, next, "utf8");
 }
 async function runAdd(options, deps) {
   const loaded = await loadConfig(options.cwd);
@@ -10164,56 +11626,6 @@ async function runRequests(options, deps) {
   return { exitCode: 0 };
 }
 
-// src/json.ts
-function isJsonObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isString2(value) {
-  return typeof value === "string";
-}
-function isNumber2(value) {
-  return typeof value === "number";
-}
-async function bodyOf(response) {
-  try {
-    return JSON.parse(await response.text());
-  } catch {
-    return null;
-  }
-}
-
-// src/running.ts
-import { realpath as realpath2 } from "fs/promises";
-var NOT_RUNNING = "Leglas is not running here. Start it with npx leglas, then try again.";
-async function sameDirectory(left, right) {
-  const [a, b] = await Promise.all([
-    realpath2(left).catch(() => left),
-    realpath2(right).catch(() => right)
-  ]);
-  return a === b;
-}
-async function findLeglas(cwd, port, request) {
-  const server = port === null ? await readServerInfo(cwd) : null;
-  const chosen = port ?? server?.port ?? DEFAULT_PORT;
-  try {
-    const health = await request(`http://127.0.0.1:${chosen}/leglas/api/health`, {
-      signal: AbortSignal.timeout(2e3)
-    });
-    if (health.status !== 200) return { ok: false, error: NOT_RUNNING };
-    const answered = await health.text().then((text2) => JSON.parse(text2)).catch(() => ({}));
-    if (answered === null) return { ok: false, error: NOT_RUNNING };
-    if (isJsonObject(answered) && isString2(answered.cwd) && !await sameDirectory(answered.cwd, cwd)) {
-      return {
-        ok: false,
-        error: `The Leglas on port ${chosen} serves another project. Start one here with npx leglas, or name the right one with --port.`
-      };
-    }
-    return { ok: true, port: chosen, base: `http://127.0.0.1:${chosen}` };
-  } catch {
-    return { ok: false, error: NOT_RUNNING };
-  }
-}
-
 // src/run-share.ts
 var TUNNEL_WAIT_MS = 6e4;
 var TUNNEL_POLL_MS = 500;
@@ -10664,24 +12076,24 @@ async function runShow(options, deps) {
 
 // src/run-watch.ts
 import { spawn as spawn4 } from "child_process";
-import { mkdir as mkdir12, readFile as readFile17, writeFile as writeFile14 } from "fs/promises";
-import { dirname as dirname12, join as join20 } from "path";
-var POLL_MS2 = 2e3;
+import { mkdir as mkdir12, readFile as readFile21, writeFile as writeFile15 } from "fs/promises";
+import { dirname as dirname14, join as join24 } from "path";
+var POLL_MS3 = 2e3;
 var HEARTBEAT_TIMEOUT_MS = 1e3;
 async function saveTemplate(cwd, run4) {
-  const path = join20(cwd, WATCH_PATH);
+  const path = join24(cwd, WATCH_PATH);
   let config = {};
   try {
-    const parsed2 = JSON.parse(await readFile17(path, "utf8"));
+    const parsed2 = JSON.parse(await readFile21(path, "utf8"));
     if (isJsonObject(parsed2)) config = parsed2;
   } catch {
   }
   config.run = run4;
-  await mkdir12(dirname12(path), { recursive: true });
-  await writeFile14(path, `${JSON.stringify(config, null, 2)}
+  await mkdir12(dirname14(path), { recursive: true });
+  await writeFile15(path, `${JSON.stringify(config, null, 2)}
 `, "utf8");
 }
-function spawnAgent(command, args, cwd) {
+function spawnAgent(command, args, cwd, json) {
   return new Promise((resolve5) => {
     let settled = false;
     const settle = (outcome) => {
@@ -10689,7 +12101,10 @@ function spawnAgent(command, args, cwd) {
       settled = true;
       resolve5(outcome);
     };
-    const child = spawn4(command, args, { cwd, stdio: "inherit" });
+    const child = spawn4(command, args, {
+      cwd,
+      stdio: json ? ["inherit", 2, "inherit"] : "inherit"
+    });
     child.on("error", (error) => settle({ ok: false, error: error.message }));
     child.on(
       "close",
@@ -10700,6 +12115,13 @@ function spawnAgent(command, args, cwd) {
   });
 }
 async function runWatch(options, deps) {
+  const json = options.json === true;
+  const emit = (event) => deps.log(JSON.stringify(event));
+  const refuse2 = (error) => {
+    if (json) deps.log(JSON.stringify({ ok: false, error }));
+    else deps.error(error);
+    return { exitCode: 1 };
+  };
   const saved = options.run === void 0 ? await readAgentChoice(options.cwd) : { agent: null, run: null };
   const raw = options.run ?? saved.run;
   let template;
@@ -10707,10 +12129,7 @@ async function runWatch(options, deps) {
   let synthesizedAgent = null;
   if (raw !== null) {
     const parsed2 = parseTemplate(raw);
-    if (!parsed2.ok) {
-      deps.error(parsed2.error);
-      return { exitCode: 1 };
-    }
+    if (!parsed2.ok) return refuse2(parsed2.error);
     template = parsed2.template;
     shownCommand2 = raw;
   } else if (saved.agent !== null && saved.agent !== "custom") {
@@ -10722,10 +12141,9 @@ async function runWatch(options, deps) {
     shownCommand2 = [template.command, ...template.args].join(" ");
     synthesizedAgent = adapter.name;
   } else {
-    deps.error(
+    return refuse2(
       'Watch needs an agent command the first time: pick an agent in the interface, or pass --run "claude -p {prompt}".'
     );
-    return { exitCode: 1 };
   }
   if (options.run !== void 0) await saveTemplate(options.cwd, options.run).catch(() => {
   });
@@ -10741,26 +12159,36 @@ async function runWatch(options, deps) {
     } catch {
     }
   };
-  if (synthesizedAgent !== null) {
-    deps.log(`Using ${synthesizedAgent}, chosen in the interface.`);
+  if (json) {
+    emit({ event: "watching", command: shownCommand2, agent: synthesizedAgent });
+  } else {
+    if (synthesizedAgent !== null) {
+      deps.log(`Using ${synthesizedAgent}, chosen in the interface.`);
+    }
+    deps.log(`Watching for change requests. Each one runs: ${shownCommand2}`);
+    deps.log("Stop with Ctrl-C.");
   }
-  deps.log(`Watching for change requests. Each one runs: ${shownCommand2}`);
-  deps.log("Stop with Ctrl-C.");
   const failed = /* @__PURE__ */ new Set();
   let stopped = false;
   let busy = false;
   let announced = false;
   let inflight = null;
   const handle = async (request) => {
-    deps.log("");
-    deps.log(`  ${request.title}: ${request.intent}`);
-    if (request.target !== null) deps.log(`    ${request.target}`);
+    const { id, title, intent, target } = request;
+    if (json) {
+      emit({ event: "started", id, title, intent, target });
+    } else {
+      deps.log("");
+      deps.log(`  ${title}: ${intent}`);
+      if (target !== null) deps.log(`    ${target}`);
+    }
     await markPickedUp(options.cwd, request.id);
     const { command, args } = commandFor(template, request.prompt);
-    const outcome = await spawnAgent(command, args, options.cwd);
+    const outcome = await spawnAgent(command, args, options.cwd, json);
     if (outcome.ok && outcome.code === 0) {
       await removeRequest(options.cwd, request.id);
-      deps.log(`  done    ${request.title}`);
+      if (json) emit({ event: "done", id, title });
+      else deps.log(`  done    ${title}`);
       return;
     }
     failed.add(request.id);
@@ -10770,8 +12198,12 @@ async function runWatch(options, deps) {
       exitCode: outcome.ok ? outcome.code : null
     });
     await markFailed(options.cwd, request.id, failure);
-    deps.error(`  failed  ${request.title}: ${failure.message}`);
-    deps.error("  Left in the queue and not retried.");
+    if (json) {
+      emit({ event: "failed", id, title, code: failure.code, reason: failure.message });
+    } else {
+      deps.error(`  failed  ${title}: ${failure.message}`);
+      deps.error("  Left in the queue and not retried.");
+    }
   };
   const tick = async () => {
     if (stopped) return;
@@ -10790,14 +12222,16 @@ async function runWatch(options, deps) {
         await inflight;
       }
     } catch (error) {
-      deps.error(`  ! ${error instanceof Error ? error.message : String(error)}`);
+      const message2 = error instanceof Error ? error.message : String(error);
+      if (json) emit({ event: "error", message: message2 });
+      else deps.error(`  ! ${message2}`);
     } finally {
       inflight = null;
       busy = false;
     }
   };
   return new Promise((resolve5) => {
-    const timer = setInterval(() => void tick(), POLL_MS2);
+    const timer = setInterval(() => void tick(), POLL_MS3);
     const stop = () => {
       if (stopped) return;
       stopped = true;
@@ -10805,7 +12239,10 @@ async function runWatch(options, deps) {
       process.off("SIGINT", stop);
       process.off("SIGTERM", stop);
       void Promise.resolve(inflight).catch(() => {
-      }).then(() => heartbeat(false)).then(() => resolve5({ exitCode: 0 }));
+      }).then(() => heartbeat(false)).then(() => {
+        if (json) emit({ event: "stopped" });
+        resolve5({ exitCode: 0 });
+      });
     };
     process.on("SIGINT", stop);
     process.on("SIGTERM", stop);
@@ -10895,13 +12332,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 dirname13, join as join21, relative as relative5, resolve as resolve4 } from "path";
+import { basename as basename6, dirname as dirname15, join as join25, relative as relative7, 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 isAbsolute2, relative as relative4, resolve as resolve3 } from "path";
+import { basename as basename5, isAbsolute as isAbsolute4, relative as relative6, 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]"]);
@@ -10970,8 +12407,8 @@ async function inspectLocalDevServer(origin) {
   }
 }
 function isInside(parent, child) {
-  const path = relative4(resolve3(parent), resolve3(child));
-  return path === "" || !path.startsWith("..") && !isAbsolute2(path);
+  const path = relative6(resolve3(parent), resolve3(child));
+  return path === "" || !path.startsWith("..") && !isAbsolute4(path);
 }
 function devServerOwnerWarning(origin, projectRoot, owners) {
   const port = localDevServerPort(origin);
@@ -10984,11 +12421,11 @@ function devServerOwnerWarning(origin, projectRoot, owners) {
 
 // src/run.ts
 function findShellDir() {
-  const bundled = join21(dirname13(fileURLToPath(import.meta.url)), "shell");
-  if (existsSync7(join21(bundled, "index.html"))) return bundled;
+  const bundled = join25(dirname15(fileURLToPath(import.meta.url)), "shell");
+  if (existsSync7(join25(bundled, "index.html"))) return bundled;
   try {
     const require2 = createRequire(import.meta.url);
-    return dirname13(require2.resolve("@leglas/shell/dist/index.html"));
+    return dirname15(require2.resolve("@leglas/shell/dist/index.html"));
   } catch {
     return null;
   }
@@ -10999,7 +12436,7 @@ function shellWord(value) {
   return `'${value.replaceAll("'", `'\\''`)}'`;
 }
 function embeddedLeglasCommand() {
-  const entry = join21(dirname13(fileURLToPath(import.meta.url)), "bin.js");
+  const entry = join25(dirname15(fileURLToPath(import.meta.url)), "bin.js");
   if (!existsSync7(entry)) return "npx -y leglas";
   return [process.execPath, entry].map(shellWord).join(" ");
 }
@@ -11038,7 +12475,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 = join21(options.cwd, preview.file);
+      const absolute = join25(options.cwd, preview.file);
       if (!existsSync7(absolute)) {
         previewErrors.push(
           `"${preview.title}" names file ${preview.file}, which does not exist. The preview is skipped.`
@@ -11049,7 +12486,7 @@ async function runWithServices(options, deps, services = {}) {
       for (let suffix = 2; fileMounts.has(slug); suffix += 1) {
         slug = `${worktreeSlug(preview.title) || "file"}-${suffix}`;
       }
-      fileMounts.set(slug, dirname13(absolute));
+      fileMounts.set(slug, dirname15(absolute));
       previews.push({
         ...preview,
         url: `${FILES_PREFIX}/${slug}/${encodeURIComponent(basename6(absolute))}`
@@ -11061,8 +12498,8 @@ async function runWithServices(options, deps, services = {}) {
   const config = merged === null ? null : { ...merged, previews };
   const configWarnings = [];
   const projectRoot = await realpath4(
-    loaded.path === null ? options.cwd : dirname13(loaded.path)
-  ).catch(() => resolve4(loaded.path === null ? options.cwd : dirname13(loaded.path)));
+    loaded.path === null ? options.cwd : dirname15(loaded.path)
+  ).catch(() => resolve4(loaded.path === null ? options.cwd : dirname15(loaded.path)));
   const ownerWarning = needsApp && app === null ? (services.inspectLocalDevServer ?? inspectLocalDevServer)(devServer).then((owners) => devServerOwnerWarning(devServer, projectRoot, owners)).catch(() => null) : Promise.resolve(null);
   const serverOptions = {
     config,
@@ -11100,7 +12537,7 @@ async function runWithServices(options, deps, services = {}) {
       })
     );
   } else {
-    const configLabel = loaded.path === null ? "no config file, previewing the app root" : relative5(options.cwd, loaded.path) || loaded.path;
+    const configLabel = loaded.path === null ? "no config file, previewing the app root" : relative7(options.cwd, loaded.path) || loaded.path;
     deps.log(`Leglas   ${url}`);
     deps.log(
       `app      ${devServer}${app !== null ? "  (started by Leglas)" : health.reachable ? "" : "  (not reachable)"}`
@@ -11177,18 +12614,17 @@ async function startViewer(options, deps) {
     updates
   });
   const { handOff, handedOff } = createHandoff();
-  updates.onRestart(
-    (command) => handOff(command, result.stop, {
-      spawn: spawn5,
-      exit: (code) => process.exit(code),
-      target: process
-    })
-  );
+  const handoff = deps.handoff ?? {
+    spawn: spawn5,
+    exit: (code) => process.exit(code),
+    target: process
+  };
+  updates.onRestart((command) => handOff(command, result.stop, handoff));
   (deps.installShutdown ?? installShutdown)(async () => {
     if (handedOff()) return;
     await result.stop();
-    process.exit(0);
-  });
+    handoff.exit(0);
+  }, handoff.target);
 }
 
 // src/bin.ts
@@ -11198,7 +12634,7 @@ Usage
   leglas init                Prepare a project and teach its agents
   leglas [options]           Start the server and open the interface
   leglas new <surface>       Scaffold a branch point for a surface
-  leglas explore <surface>   Brief an agent's exploration of a surface
+  leglas explore <surface>   Brief an agent's exploration of a surface, or build it
   leglas classify            Decide where a direction should live
   leglas add --title T --url U   Register a preview on this machine
   leglas list                Show every preview, shared and local
@@ -11223,13 +12659,19 @@ Options for new
   --from <path>        Use an existing component as the baseline
 
 Options for explore
-  --count <n>          How many directions (default 3)
+  --count <n>          How many directions (default 3; up to 6 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
+  --brief <text>       What the directions are for (needs --build; optional
+                       with --based-on)
+  --port <port>        Running Leglas port (needs --build)
 
 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)
+  --json               One JSON line per event; the agent's output goes to stderr
 
 Options for classify
   --change <path>      A file the direction creates or wires up (repeatable)
@@ -11325,6 +12767,26 @@ if (parsed.kind === "keep") {
   );
   process.exit(outcome.exitCode);
 }
+if (parsed.kind === "explore" && parsed.build) {
+  const outcome = await runExploreBuild(
+    {
+      surface: parsed.surface,
+      brief: parsed.brief ?? "",
+      count: parsed.count,
+      basedOn: parsed.basedOn,
+      json: parsed.json,
+      cwd: process.cwd(),
+      port: parsed.port
+    },
+    {
+      log: (line) => process.stdout.write(`${line}
+`),
+      error: (line) => process.stderr.write(`${line}
+`)
+    }
+  );
+  process.exit(outcome.exitCode);
+}
 if (parsed.kind === "explore") {
   const outcome = runExplore(
     { surface: parsed.surface, count: parsed.count, basedOn: parsed.basedOn, json: parsed.json },
@@ -11342,7 +12804,7 @@ if (parsed.kind === "requests") {
 }
 if (parsed.kind === "watch") {
   const outcome = await runWatch(
-    { run: parsed.run, port: parsed.port, cwd: process.cwd() },
+    { run: parsed.run, port: parsed.port, cwd: process.cwd(), json: parsed.json },
     previewDeps
   );
   process.exit(outcome.exitCode);