leglas 0.2.0 → 0.4.0

package/dist/index.js

@@ -45,7 +45,7 @@ function parseNew(rest) {
   if (surface === void 0) {
     return {
       kind: "error",
-      message: "leglas new needs a surface name, for example: leglas new hero"
+      message: "leglas new needs a surface name, for example: npx leglas new hero"
     };
   }
   return { kind: "new", surface, print, json, from };
@@ -128,7 +128,7 @@ function parseClassify(rest) {
   if (changes.length === 0) {
     return {
       kind: "error",
-      message: "leglas classify needs what the direction will touch, for example: leglas classify --change package.json --rewrite src/theme.css"
+      message: "leglas classify needs what the direction will touch, for example: npx leglas classify --change package.json --rewrite src/theme.css"
     };
   }
   return { kind: "classify", changes, json };
@@ -203,7 +203,7 @@ function parseArgs(argv) {
     if (title === void 0) {
       return {
         kind: "error",
-        message: 'leglas keep needs a direction title, for example: leglas keep "Aurora" --to src/components/hero.tsx'
+        message: 'leglas keep needs a direction title, for example: npx leglas keep "Aurora" --to src/components/hero.tsx'
       };
     }
     if (to === void 0) {
@@ -253,7 +253,7 @@ function parseArgs(argv) {
     if (surface === void 0) {
       return {
         kind: "error",
-        message: "leglas explore needs a surface name, for example: leglas explore hero --count 6"
+        message: "leglas explore needs a surface name, for example: npx leglas explore hero --count 6"
       };
     }
     return { kind: "explore", surface, count, basedOn, json };
@@ -294,7 +294,7 @@ function parseArgs(argv) {
     if (title === void 0) {
       return {
         kind: "error",
-        message: 'leglas show needs a direction title, for example: leglas show "Aurora" --json'
+        message: 'leglas show needs a direction title, for example: npx leglas show "Aurora" --json'
       };
     }
     return { kind: "show", title, json };
@@ -556,8 +556,8 @@ The set exists to be chosen from, and the choice only means something if the dir
 One trap, seen every time this goes wrong: a set collapses toward whichever direction is built first. Decide all ${count} before building any, and if two would read as the same direction at a glance, replace one of them.` : `Build ${count} variations of the "${basedOn}" direction for "${surface}".
 
 The set exists to pick a variant of a direction already chosen, so every variation must stay recognisably that direction. The trap here is drift: change enough and the comparison stops being about the variant. Vary each one deliberately and hold everything else still; if a variation grows into a new direction, it belongs in its own exploration instead.`;
-  const register = basedOn === null ? `  leglas add --title "<name>" --url "/?v-${slug}=<key>" --note "<the idea, one line>"` : `  leglas add --title "<name>" --url "/?v-${slug}=<key>" --based-on ${JSON.stringify(basedOn)} --note "<the idea, one line>"`;
-  const mechanics = `Each one is its own file under .leglas/variants/${slug}/, listed in the DIRECTIONS map in that folder's switch file. If there is no switch file yet, run \`leglas new ${slug}\` first. Register each one the moment it renders, not the set at the end. The interface picks a registration up within seconds, so whoever asked watches the set fill in:
+  const register = basedOn === null ? `  npx leglas add --title "<name>" --url "/?v-${slug}=<key>" --note "<the idea, one line>"` : `  npx leglas add --title "<name>" --url "/?v-${slug}=<key>" --based-on ${JSON.stringify(basedOn)} --note "<the idea, one line>"`;
+  const mechanics = `Each one is its own file under .leglas/variants/${slug}/, listed in the DIRECTIONS map in that folder's switch file. If there is no switch file yet, run \`npx leglas new ${slug}\` first. Register each one the moment it renders, not the set at the end. The interface picks a registration up within seconds, so whoever asked watches the set fill in:
 
 ${register}
 
@@ -609,46 +609,48 @@ When asked for design variations, alternatives, or "a few options":
    If a direction cannot be additive, because it must change dependencies,
    change build configuration, or rewrite an existing file's behaviour, ask
    where it should live before writing it:
-   \`leglas classify --change package.json --rewrite src/theme.css --json\`.
+   \`npx leglas classify --change package.json --rewrite src/theme.css --json\`.
    When the answer is \`checkout\`, build the direction on its own git branch
-   and register it with \`leglas add --title "\u2026" --url "/" --branch <branch>\`
+   and register it with \`npx leglas add --title "\u2026" --url "/" --branch <branch>\`
    (the config needs \`devCommand\` with \`{port}\`). Everything below is the
    ordinary, in-app path.
-2. Run \`leglas explore <surface> --count <n>\` first, adding
+2. Run \`npx leglas explore <surface> --count <n>\` first, adding
    \`--based-on "<title>"\` when the user wants variations of a direction they
    already like. It prints what the set needs and how to register it. In
    short: new directions must genuinely disagree with each other, variants of
    one must not, and either way decide the whole set before building any of
    it. The designs themselves are yours.
 3. If the surface has no switcher yet, run
-   \`leglas new <surface> --from <the component that renders it today>\`. It
+   \`npx leglas new <surface> --from <the component that renders it today>\`. It
    writes one under \`.leglas/variants/<surface>/\` and prints the single line
    to add where that surface renders. \`--from\` makes the baseline re-export
    the real component rather than copying it, so it stays live.
-4. Before building, make sure the interface is up. If \`leglas\` is not
-   already running, tell the user to run it, and hand them the URL now
-   rather than when the set is done: the rail picks up each registration
-   within seconds, so they get to watch the exploration fill in.
+4. Before building, make sure the interface is up. If Leglas is not
+   already running, tell the user to run \`npx leglas\`, and hand them the
+   URL now rather than when the set is done: the rail picks up each
+   registration within seconds, so they get to watch the exploration fill in.
 5. Build one direction at a time: its own file beside the others in
    \`.leglas/variants/<surface>/\`, listed in the \`DIRECTIONS\` map in that
    folder's \`switch\` file, then registered the moment it renders:
-   \`leglas add --title "Aurora" --url "/?v-<surface>=aurora" --note "One line on the idea."\`
+   \`npx leglas add --title "Aurora" --url "/?v-<surface>=aurora" --note "One line on the idea."\`
    Register each direction as it lands, never the whole set at the end. To
    the user watching the rail, a batch at the end is minutes of nothing and
    then everything at once.
 
-When the user asks to change one direction, check \`leglas requests --json\`
+When the user asks to change one direction, check \`npx leglas requests --json\`
 first: they may have described it from the interface, and the request names the
-exact file. Clear the queue with \`leglas requests --clear\` once done.
+exact file. Acknowledge them with \`npx leglas requests --clear\` once done: it
+drops what you collected and reports anything the user typed while you worked,
+which is yours to collect and do next.
 
 If the user wants requests handled the moment they are typed, without relaying
-each one, tell them about \`leglas watch --run "claude -p {prompt}"\` (any
+each one, tell them about \`npx leglas watch --run "claude -p {prompt}"\` (any
 agent command works; {prompt} receives the request). It runs in their
 terminal, hands each request to that command as it arrives, and the interface
 shows the request's progress.
 
 When the user picks a winner, run
-\`leglas keep "<title>" --to <path in real source>\`. It moves that direction
+\`npx leglas keep "<title>" --to <path in real source>\`. It moves that direction
 out of the ignored directory, deletes the rest of the exploration, and drops
 them from the rail. Then change their component to use the kept component
 instead of the switcher.
@@ -659,14 +661,14 @@ Useful to know:
   ships. Move a direction into real source only when it wins.
 - If the project has no running app yet, a direction can be a plain HTML
   file: write it under \`.leglas/pages/\` and register it with
-  \`leglas add --title "Aurora" --file .leglas/pages/aurora.html\`. Leglas
+  \`npx leglas add --title "Aurora" --file .leglas/pages/aurora.html\`. Leglas
   serves the file itself, so no dev server is needed. Sibling assets in the
   same directory resolve normally.
 - Titles identify previews and must be unique. The user may rename one in the
   rail, which renames it on their machine only; the commands answer to either
   name, so use whichever they said.
-- \`leglas list\` shows every direction, shared and local.
-- \`leglas show "<title>" --json\` answers for one of them: the file behind it,
+- \`npx leglas list\` shows every direction, shared and local.
+- \`npx leglas show "<title>" --json\` answers for one of them: the file behind it,
   the variants based on it, what it is being compared against, and anything
   they have asked for that is not done yet. Run it when handed a direction you
   did not register yourself.
@@ -676,7 +678,7 @@ Useful to know:
 ${AGENTS_MARKER_END}
 `;
 var STARTER_CONFIG = `// Previews are URLs of your own app. Add one per direction you want to
-// compare, then run \`leglas\`.
+// compare, then run \`npx leglas\`.
 export default {
   // Where your dev server is. Override at the command line with --user-port.
   devServer: "http://localhost:3000",
@@ -843,6 +845,360 @@ function normalizeConfig(raw, options = {}) {
   };
 }
 
+// ../server/dist/agent-command.js
+var WATCH_PATH = ".leglas/watch.json";
+var PROMPT_TOKEN = "{prompt}";
+var EXAMPLE = `npx leglas watch --run "claude -p ${PROMPT_TOKEN}"`;
+function tokenize(template) {
+  const tokens = [];
+  let current = "";
+  let started = false;
+  let quote = null;
+  for (const character of template) {
+    if (quote !== null) {
+      if (character === quote)
+        quote = null;
+      else
+        current += character;
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+      started = true;
+      continue;
+    }
+    if (/\s/.test(character)) {
+      if (started)
+        tokens.push(current);
+      current = "";
+      started = false;
+      continue;
+    }
+    current += character;
+    started = true;
+  }
+  if (quote !== null) {
+    return { ok: false, error: `The agent command has an unclosed ${quote} quote.` };
+  }
+  if (started)
+    tokens.push(current);
+  return { ok: true, tokens };
+}
+function parseTemplate(raw) {
+  const tokenized = tokenize(raw);
+  if (!tokenized.ok)
+    return tokenized;
+  const { tokens } = tokenized;
+  const [command, ...args] = tokens;
+  if (command === void 0) {
+    return { ok: false, error: `Watch needs an agent command, for example: ${EXAMPLE}` };
+  }
+  if (tokens.some((token) => token !== PROMPT_TOKEN && token.includes(PROMPT_TOKEN))) {
+    return {
+      ok: false,
+      error: `${PROMPT_TOKEN} must stand as a word of its own, for example: ${EXAMPLE}`
+    };
+  }
+  const placeholders = tokens.filter((token) => token === PROMPT_TOKEN).length;
+  if (placeholders > 1) {
+    return {
+      ok: false,
+      error: `The agent command takes ${PROMPT_TOKEN} once, for example: ${EXAMPLE}`
+    };
+  }
+  if (command === PROMPT_TOKEN) {
+    return {
+      ok: false,
+      error: `The agent command must name a program before ${PROMPT_TOKEN}, for example: ${EXAMPLE}`
+    };
+  }
+  return { ok: true, template: { command, args } };
+}
+function commandFor(template, prompt) {
+  if (!template.args.includes(PROMPT_TOKEN)) {
+    return { command: template.command, args: [...template.args, prompt] };
+  }
+  return {
+    command: template.command,
+    args: template.args.map((argument) => argument === PROMPT_TOKEN ? prompt : argument)
+  };
+}
+function nextRequest(requests, failed) {
+  return requests.find((request) => request.status === "queued" && !failed.has(request.id)) ?? null;
+}
+
+// ../server/dist/agents.js
+import { spawn } from "child_process";
+import { constants } from "fs";
+import { access, mkdir, readFile, writeFile } from "fs/promises";
+import { delimiter, dirname, isAbsolute, join, relative } from "path";
+var KNOWN_AGENTS = {
+  claude: {
+    name: "Claude",
+    binary: "claude",
+    args: (prompt) => [
+      "-p",
+      prompt,
+      "--output-format",
+      "stream-json",
+      "--verbose",
+      "--permission-mode",
+      "acceptEdits"
+    ],
+    terminalArgs: (prompt) => [
+      "-p",
+      prompt,
+      "--permission-mode",
+      "acceptEdits"
+    ],
+    resumeArgs: (sessionId, prompt) => [
+      "-p",
+      "--resume",
+      sessionId,
+      prompt,
+      "--output-format",
+      "stream-json",
+      "--verbose",
+      "--permission-mode",
+      "acceptEdits"
+    ],
+    // Every stream-json event names its session.
+    sessionFrom: (event) => typeof event.session_id === "string" && event.session_id !== "" ? event.session_id : null,
+    authArgs: ["auth", "status"],
+    // `claude auth status` prints JSON with a loggedIn boolean. Only that
+    // field decides; any other shape stays unknown.
+    authVerdict: (result) => {
+      try {
+        const parsed = record(JSON.parse(result.stdout));
+        if (parsed?.loggedIn === true)
+          return "ok";
+        if (parsed?.loggedIn === false)
+          return "signed-out";
+      } catch {
+      }
+      return "unknown";
+    }
+  },
+  codex: {
+    name: "Codex",
+    binary: "codex",
+    args: (prompt) => ["exec", "--json", "-s", "workspace-write", prompt],
+    terminalArgs: (prompt) => ["exec", "-s", "workspace-write", 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.
+    resumeArgs: (sessionId, prompt) => [
+      "exec",
+      "resume",
+      sessionId,
+      "--json",
+      prompt
+    ],
+    sessionFrom: (event) => event.type === "thread.started" && typeof event.thread_id === "string" ? event.thread_id : null,
+    authArgs: ["login", "status"],
+    // `codex login status` exits 0 when logged in and nonzero when not.
+    authVerdict: (result) => result.code === 0 ? "ok" : "signed-out"
+  },
+  cursor: {
+    name: "Cursor",
+    binary: "cursor-agent",
+    args: (prompt) => ["-p", prompt, "--output-format", "stream-json"],
+    terminalArgs: (prompt) => ["-p", prompt],
+    authArgs: ["status"],
+    // UNVERIFIED: cursor-agent was not available on the build machine. The
+    // reading is deliberately loose, and anything ambiguous stays unknown.
+    authVerdict: (result) => {
+      if (/logged in|signed in/i.test(result.stdout))
+        return "ok";
+      if (result.code !== 0 || /not logged in|log in|sign in/i.test(result.stdout))
+        return "signed-out";
+      return "unknown";
+    }
+  }
+};
+var PROBE_TIMEOUT_MS = 3e3;
+function execProbe(binary, args) {
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn(binary, [...args], { shell: false, stdio: ["ignore", "pipe", "ignore"] });
+    } catch {
+      return resolve(null);
+    }
+    let stdout = "";
+    child.stdout?.on("data", (chunk) => {
+      if (stdout.length < 4096)
+        stdout += chunk.toString();
+    });
+    const deadline = setTimeout(() => child.kill("SIGKILL"), PROBE_TIMEOUT_MS);
+    child.once("error", () => {
+      clearTimeout(deadline);
+      resolve(null);
+    });
+    child.once("close", (code, signal) => {
+      clearTimeout(deadline);
+      resolve(signal !== null ? null : { code: code ?? 0, stdout });
+    });
+  });
+}
+async function pathLookup(binary) {
+  const entries = (process.env.PATH ?? "").split(delimiter).filter((entry) => entry !== "");
+  const extensions = process.platform === "win32" ? (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter((entry) => entry !== "") : [""];
+  for (const entry of entries) {
+    for (const extension of extensions) {
+      try {
+        await access(join(entry, `${binary}${extension}`), constants.X_OK);
+        return true;
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+async function detectAgents(lookup = pathLookup, probe2 = execProbe) {
+  const entries = Object.entries(KNOWN_AGENTS);
+  return Promise.all(entries.map(async ([id, adapter]) => {
+    const available = await lookup(adapter.binary).catch(() => false);
+    if (!available)
+      return { id, name: adapter.name, available, auth: "unknown" };
+    const result = await probe2(adapter.binary, adapter.authArgs).catch(() => null);
+    return {
+      id,
+      name: adapter.name,
+      available,
+      auth: result === null ? "unknown" : adapter.authVerdict(result)
+    };
+  }));
+}
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function shownPath(value, cwd) {
+  if (typeof value !== "string" || value === "")
+    return null;
+  if (!isAbsolute(value))
+    return value;
+  return relative(cwd, value) || ".";
+}
+function shownCommand(value) {
+  let command = Array.isArray(value) ? value.filter((part) => typeof part === "string").join(" ") : typeof value === "string" ? value : "";
+  command = command.trim();
+  const wrapped = /^(?:\S*\/)?(?:bash|sh|zsh)\s+-l?c\s+([\s\S]*)$/.exec(command);
+  if (wrapped?.[1] !== void 0) {
+    command = wrapped[1].trim();
+    const quote = command[0];
+    if ((quote === "'" || quote === '"') && command.endsWith(quote) && command.length > 1) {
+      command = command.slice(1, -1);
+    }
+  }
+  command = (command.split("\n")[0] ?? "").replace(/\s+/g, " ").trim();
+  if (command === "")
+    return null;
+  return command.length > 48 ? `${command.slice(0, 47)}\u2026` : command;
+}
+function claudeActivity(event, cwd) {
+  if (event.type !== "assistant")
+    return null;
+  const message = record(event.message);
+  if (message === null || !Array.isArray(message.content))
+    return null;
+  for (const rawBlock of message.content) {
+    const block = record(rawBlock);
+    if (block?.type !== "tool_use" || typeof block.name !== "string")
+      continue;
+    const input = record(block.input);
+    if (["Edit", "Write", "MultiEdit", "NotebookEdit"].includes(block.name)) {
+      const path = shownPath(input?.file_path ?? input?.notebook_path, cwd);
+      return path === null ? `using ${block.name}` : `editing ${path}`;
+    }
+    if (block.name === "Read") {
+      const path = shownPath(input?.file_path ?? input?.path, cwd);
+      return path === null ? "using Read" : `reading ${path}`;
+    }
+    if (block.name === "Bash") {
+      const command = shownCommand(input?.command);
+      return command === null ? "running a command" : `running ${command}`;
+    }
+    if (block.name === "Grep" || block.name === "Glob")
+      return "searching the project";
+    return `using ${block.name}`;
+  }
+  return null;
+}
+function codexActivity(event, cwd) {
+  if (event.type !== "item.started" && event.type !== "item.completed")
+    return null;
+  const item = record(event.item);
+  if (item === null)
+    return null;
+  if (item.type === "command_execution") {
+    const command = shownCommand(item.command);
+    return command === null ? "running a command" : `running ${command}`;
+  }
+  if (item.type !== "file_change")
+    return null;
+  const first = Array.isArray(item.changes) ? record(item.changes[0]) : null;
+  const path = shownPath(first?.path ?? item.path, cwd);
+  return path === null ? null : `editing ${path}`;
+}
+function activityFrom(agent, line, cwd = process.cwd()) {
+  let event;
+  try {
+    event = record(JSON.parse(line));
+  } catch {
+    return null;
+  }
+  if (event === null)
+    return null;
+  if (agent === "claude")
+    return claudeActivity(event, cwd);
+  if (agent === "codex")
+    return codexActivity(event, cwd);
+  if (agent === "cursor")
+    return claudeActivity(event, cwd);
+  return null;
+}
+function sessionFrom(agent, line) {
+  if (agent !== "claude" && agent !== "codex")
+    return null;
+  let event;
+  try {
+    event = record(JSON.parse(line));
+  } catch {
+    return null;
+  }
+  if (event === null)
+    return null;
+  return KNOWN_AGENTS[agent].sessionFrom(event);
+}
+function isAgentChoice(value) {
+  return value === "custom" || typeof value === "string" && Object.hasOwn(KNOWN_AGENTS, value);
+}
+async function readWatchConfig(cwd) {
+  try {
+    const parsed = JSON.parse(await readFile(join(cwd, WATCH_PATH), "utf8"));
+    return record(parsed) ?? {};
+  } catch {
+    return {};
+  }
+}
+async function readAgentChoice(cwd) {
+  const config = await readWatchConfig(cwd);
+  return {
+    agent: isAgentChoice(config.agent) ? config.agent : null,
+    run: typeof config.run === "string" && config.run !== "" ? config.run : null
+  };
+}
+async function saveAgentChoice(cwd, choice) {
+  const config = await readWatchConfig(cwd);
+  config.agent = choice.agent;
+  if (choice.run !== void 0)
+    config.run = choice.run;
+  const path = join(cwd, WATCH_PATH);
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+}
+
 // ../server/dist/classify.js
 var MANIFESTS = /* @__PURE__ */ new Set([
   "package.json",
@@ -880,12 +1236,12 @@ function isExplorationFile(path) {
 }
 var CHECKOUT_STEPS = [
   "Build the direction on its own branch: git switch -c <branch>, commit it there, switch back.",
-  'Register it: leglas add --title "<title>" --url "/" --branch <branch>.',
+  'Register it: npx leglas add --title "<title>" --url "/" --branch <branch>.',
   "Make sure the config sets devCommand (with {port}), so Leglas can start the checkout."
 ];
 var IN_APP_STEPS = [
   "Author it additively under .leglas/variants/<surface>/, beside the existing directions.",
-  'Register it: leglas add --title "<title>" --url "/?v-<surface>=<direction>".'
+  'Register it: npx leglas add --title "<title>" --url "/?v-<surface>=<direction>".'
 ];
 function classifyDirection(input) {
   const checkout = (reason) => ({ level: "checkout", reason, steps: CHECKOUT_STEPS });
@@ -910,7 +1266,7 @@ function classifyDirection(input) {
 
 // ../server/dist/find-config.js
 import { existsSync } from "fs";
-import { dirname, join, parse } from "path";
+import { dirname as dirname2, join as join2, parse } from "path";
 var CONFIG_BASENAMES = [
   "leglas.config.ts",
   "leglas.config.mjs",
@@ -922,13 +1278,13 @@ function findConfigFile(startDir) {
   let dir = startDir;
   for (; ; ) {
     for (const basename4 of CONFIG_BASENAMES) {
-      const candidate = join(dir, basename4);
+      const candidate = join2(dir, basename4);
       if (existsSync(candidate))
         return candidate;
     }
     if (dir === root)
       return null;
-    const parent = dirname(dir);
+    const parent = dirname2(dir);
     if (parent === dir)
       return null;
     dir = parent;
@@ -936,19 +1292,19 @@ function findConfigFile(startDir) {
 }
 
 // ../server/dist/load-config.js
-import { readFile } from "fs/promises";
-import { relative } from "path";
+import { readFile as readFile2 } from "fs/promises";
+import { relative as relative2 } from "path";
 import { pathToFileURL } from "url";
 async function loadConfig(cwd) {
   const path = findConfigFile(cwd);
   if (path === null) {
     return { ...normalizeConfig(void 0), path: null };
   }
-  const label = relative(cwd, path) || path;
+  const label = relative2(cwd, path) || path;
   let exported;
   try {
     if (path.endsWith(".json")) {
-      exported = JSON.parse(await readFile(path, "utf8"));
+      exported = JSON.parse(await readFile2(path, "utf8"));
     } else {
       const module = await import(pathToFileURL(path).href);
       if (!("default" in module)) {
@@ -969,14 +1325,14 @@ async function loadConfig(cwd) {
 }
 
 // ../server/dist/local-previews.js
-import { mkdir, readFile as readFile2, writeFile } from "fs/promises";
-import { dirname as dirname2, join as join2 } from "path";
+import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname3, join as join3 } from "path";
 var LOCAL_PREVIEWS_PATH = ".leglas/previews.json";
 async function readLocalPreviews(cwd) {
-  const path = join2(cwd, LOCAL_PREVIEWS_PATH);
+  const path = join3(cwd, LOCAL_PREVIEWS_PATH);
   let raw;
   try {
-    raw = await readFile2(path, "utf8");
+    raw = await readFile3(path, "utf8");
   } catch {
     return { previews: [], errors: [] };
   }
@@ -1025,9 +1381,9 @@ async function addLocalPreview(cwd, input, shared) {
   if (check.config === null) {
     return { ok: false, error: check.errors.join(" ") };
   }
-  const path = join2(cwd, LOCAL_PREVIEWS_PATH);
-  await mkdir(dirname2(path), { recursive: true });
-  await writeFile(path, `${JSON.stringify({ previews: [...existing.previews.map(toStored), candidate] }, null, 2)}
+  const path = join3(cwd, LOCAL_PREVIEWS_PATH);
+  await mkdir2(dirname3(path), { recursive: true });
+  await writeFile2(path, `${JSON.stringify({ previews: [...existing.previews.map(toStored), candidate] }, null, 2)}
 `, "utf8");
   return { ok: true };
 }
@@ -1040,9 +1396,9 @@ async function dropLocalPreviews(cwd, titles) {
   const keep = existing.previews.filter((preview) => !titles.includes(preview.title));
   if (keep.length === existing.previews.length)
     return 0;
-  const path = join2(cwd, LOCAL_PREVIEWS_PATH);
-  await mkdir(dirname2(path), { recursive: true });
-  await writeFile(path, `${JSON.stringify({ previews: keep.map(toStored) }, null, 2)}
+  const path = join3(cwd, LOCAL_PREVIEWS_PATH);
+  await mkdir2(dirname3(path), { recursive: true });
+  await writeFile2(path, `${JSON.stringify({ previews: keep.map(toStored) }, null, 2)}
 `, "utf8");
   return existing.previews.length - keep.length;
 }
@@ -1111,10 +1467,10 @@ ${headers}\r
 }
 
 // ../server/dist/worktree.js
-import { execFile, spawn } from "child_process";
+import { execFile, spawn as spawn2 } from "child_process";
 import { rm } from "fs/promises";
 import net2 from "net";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 import { promisify } from "util";
 var run = promisify(execFile);
 var WORKTREES_DIR = ".leglas/worktrees";
@@ -1151,7 +1507,7 @@ function answers(port) {
 }
 async function startWorktree(options) {
   const readyTimeoutMs = options.readyTimeoutMs ?? 9e4;
-  const path = join3(options.cwd, WORKTREES_DIR, worktreeSlug(options.branch));
+  const path = join4(options.cwd, WORKTREES_DIR, worktreeSlug(options.branch));
   const log = options.onLog ?? (() => {
   });
   await rm(path, { recursive: true, force: true });
@@ -1212,7 +1568,7 @@ async function startAppProcess(options) {
   const port = await freePort();
   let child;
   try {
-    child = spawn(substitutePort(options.devCommand, port), {
+    child = spawn2(substitutePort(options.devCommand, port), {
       cwd: options.cwd,
       shell: true,
       // Own process group, so stopping kills the shell and whatever it spawned
@@ -1252,9 +1608,9 @@ async function startAppProcess(options) {
 }
 
 // ../server/dist/requests.js
-import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
 import { randomBytes } from "crypto";
-import { dirname as dirname3, join as join4 } from "path";
+import { dirname as dirname4, join as join5 } from "path";
 var SAFE_SEGMENT = /^[a-z0-9][a-z0-9-]*$/i;
 function targetFor(url) {
   if (!url.startsWith("/"))
@@ -1280,17 +1636,20 @@ function composeRequest(preview, intent) {
   const target = preview.file ?? targetFor(preview.url);
   const cleaned = intent.trim();
   const where = target === null ? `The direction is titled "${preview.title}" and renders at ${preview.url}. Find what produces it.` : `It lives at ${target}.`;
+  const pace = target === null ? `Once found, make the change and finish. ` : `Make the change in that file and finish. `;
   const prompt = `In this project, change only the "${preview.title}" design direction. ${where}
 
 What to change: ${cleaned}
 
+${pace}This is a scoped design change: no test run, no build, and no survey of the rest of the project is needed. The result is checked visually in a live preview, not by tooling.
+
 Leave every other direction exactly as it is; they are alternatives being compared side by side, so changing a sibling destroys the comparison. The direction is already registered, so nothing needs re-registering. Keep the change additive: do not rewrite shared components that other directions rely on.`;
   return { prompt, target };
 }
 var REQUESTS_PATH = ".leglas/requests.json";
 async function readRequests(cwd) {
   try {
-    const raw = await readFile3(join4(cwd, REQUESTS_PATH), "utf8");
+    const raw = await readFile4(join5(cwd, REQUESTS_PATH), "utf8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed.requests))
       return [];
@@ -1307,9 +1666,9 @@ async function readRequests(cwd) {
   }
 }
 async function writeQueue(cwd, requests) {
-  const path = join4(cwd, REQUESTS_PATH);
-  await mkdir2(dirname3(path), { recursive: true });
-  await writeFile2(path, `${JSON.stringify({ requests }, null, 2)}
+  const path = join5(cwd, REQUESTS_PATH);
+  await mkdir3(dirname4(path), { recursive: true });
+  await writeFile3(path, `${JSON.stringify({ requests }, null, 2)}
 `, "utf8");
 }
 async function appendRequest(cwd, request) {
@@ -1341,16 +1700,272 @@ async function removeRequest(cwd, id) {
   return true;
 }
 async function clearRequests(cwd) {
-  await writeQueue(cwd, []);
+  const requests = await readRequests(cwd);
+  const pending = requests.filter((request) => request.status !== "picked-up");
+  const cleared = requests.length - pending.length;
+  if (cleared > 0)
+    await writeQueue(cwd, pending);
+  return { cleared, pending: pending.length };
+}
+
+// ../server/dist/runner.js
+import { spawn as nodeSpawn } from "child_process";
+var POLL_MS = 2e3;
+var OUTPUT_LINES = 20;
+var SESSION_TURNS_CAP = 8;
+function resolveCommand(choice, prompt, sessionId = null) {
+  if (choice.agent === null)
+    return null;
+  if (choice.agent === "custom") {
+    if (choice.run === null)
+      return null;
+    const parsed = parseTemplate(choice.run);
+    if (!parsed.ok)
+      return null;
+    return { agent: "custom", name: "Custom", ...commandFor(parsed.template, prompt), resumed: false };
+  }
+  const adapter = KNOWN_AGENTS[choice.agent];
+  if (sessionId !== null && "resumeArgs" in adapter) {
+    return {
+      agent: choice.agent,
+      name: adapter.name,
+      command: adapter.binary,
+      args: adapter.resumeArgs(sessionId, prompt),
+      resumed: true
+    };
+  }
+  return {
+    agent: choice.agent,
+    name: adapter.name,
+    command: adapter.binary,
+    args: adapter.args(prompt),
+    resumed: false
+  };
+}
+function lineReader(stream, onLine) {
+  let buffered = "";
+  const flush = () => {
+    if (buffered === "")
+      return;
+    onLine(buffered.replace(/\r$/, ""));
+    buffered = "";
+  };
+  stream.on("data", (chunk) => {
+    buffered += chunk.toString();
+    const lines = buffered.split("\n");
+    buffered = lines.pop() ?? "";
+    for (const line of lines)
+      onLine(line.replace(/\r$/, ""));
+  });
+  stream.on("end", flush);
+  return flush;
+}
+function defaultSpawn(command, args, options) {
+  return nodeSpawn(command, args, options);
+}
+function startRunner(options) {
+  const spawn4 = options.spawn ?? defaultSpawn;
+  const setEvery = options.setInterval ?? ((callback, milliseconds) => setInterval(callback, milliseconds));
+  const clearEvery = options.clearInterval ?? ((handle2) => clearInterval(handle2));
+  const failed = /* @__PURE__ */ new Set();
+  let state = {
+    running: false,
+    requestId: null,
+    agent: null,
+    activity: null,
+    startedAt: null
+  };
+  let stopped = false;
+  let ticking = null;
+  let stopPromise = null;
+  let active = null;
+  const sessions = /* @__PURE__ */ new Map();
+  const idle = () => {
+    state = { running: false, requestId: null, agent: null, activity: null, startedAt: null };
+  };
+  const rememberLine = (lines, line) => {
+    lines.push(line);
+    if (lines.length > OUTPUT_LINES)
+      lines.splice(0, lines.length - OUTPUT_LINES);
+  };
+  const reportFailure = (request, error, lines) => {
+    console.error(`Leglas agent failed for ${request.title}: ${error}`);
+    for (const line of lines)
+      console.error(`  ${line}`);
+  };
+  const runChild = (request, resolved, lines, observed) => {
+    let child;
+    try {
+      child = spawn4(resolved.command, resolved.args, {
+        cwd: options.cwd,
+        shell: false,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch (error) {
+      return Promise.resolve({
+        ok: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+    const current = { child, requestId: request.id, cancelled: false };
+    active = current;
+    const stdoutFlush = lineReader(child.stdout, (line) => {
+      rememberLine(lines, line);
+      const sessionId = sessionFrom(resolved.agent, line);
+      if (sessionId !== null)
+        observed.sessionId = sessionId;
+      const activity = activityFrom(resolved.agent, line, options.cwd);
+      if (activity !== null) {
+        if (activity.startsWith("editing"))
+          observed.edited = true;
+        if (active === current)
+          state = { ...state, activity };
+      }
+    });
+    const stderrFlush = lineReader(child.stderr, (line) => rememberLine(lines, line));
+    return new Promise((resolve) => {
+      let settled = false;
+      const settle = (outcome) => {
+        if (settled)
+          return;
+        settled = true;
+        stdoutFlush();
+        stderrFlush();
+        resolve(outcome);
+      };
+      child.once("error", (error) => settle({ ok: false, error: error.message }));
+      child.once("close", (code, signal) => {
+        if (current.cancelled)
+          return settle({ ok: false, error: "cancelled" });
+        if (signal !== null)
+          return settle({ ok: false, error: `stopped by ${signal}` });
+        settle({ ok: true, code: code ?? 0 });
+      });
+    }).finally(() => {
+      if (active === current)
+        active = null;
+    });
+  };
+  const handle = async (request, choice) => {
+    const session = choice.agent !== null ? sessions.get(choice.agent) ?? null : null;
+    const continuable = session !== null && session.turns < SESSION_TURNS_CAP;
+    let resolved = resolveCommand(choice, request.prompt, continuable ? session.id : null);
+    if (resolved === null)
+      return;
+    const lines = [];
+    try {
+      if (!await markPickedUp(options.cwd, request.id))
+        return;
+      if (stopped) {
+        failed.add(request.id);
+        return;
+      }
+      state = {
+        running: true,
+        requestId: request.id,
+        agent: resolved.name,
+        activity: null,
+        startedAt: Date.now()
+      };
+      const observed = { sessionId: null, edited: false };
+      let outcome = await runChild(request, resolved, lines, observed);
+      const cancelled = !outcome.ok && outcome.error === "cancelled";
+      if (!(outcome.ok && outcome.code === 0) && resolved.resumed && !observed.edited && !cancelled && // Not redundant with the line above: a stop that lands between the
+      // first child settling and the retry starting finds no child to
+      // cancel, so nothing says "cancelled". Stopped still means stopped.
+      !stopped) {
+        sessions.delete(resolved.agent);
+        const cold = resolveCommand(choice, request.prompt);
+        if (cold !== null) {
+          resolved = cold;
+          observed.sessionId = null;
+          state = { ...state, activity: null };
+          outcome = await runChild(request, resolved, lines, observed);
+        }
+      }
+      if (outcome.ok && outcome.code === 0) {
+        if (observed.sessionId !== null) {
+          const previous = sessions.get(resolved.agent);
+          sessions.set(resolved.agent, {
+            id: observed.sessionId,
+            turns: resolved.resumed && previous?.id === observed.sessionId ? previous.turns + 1 : 1
+          });
+        }
+        await removeRequest(options.cwd, request.id);
+        return;
+      }
+      sessions.delete(resolved.agent);
+      failed.add(request.id);
+      reportFailure(request, outcome.ok ? `${resolved.command} exited ${outcome.code}` : outcome.error, lines);
+    } finally {
+      idle();
+    }
+  };
+  const tick = async () => {
+    if (stopped)
+      return;
+    const choice = await readAgentChoice(options.cwd);
+    if (choice.agent === null || stopped)
+      return;
+    if (options.externallyAttached())
+      return;
+    const request = nextRequest(await readRequests(options.cwd), failed);
+    if (request !== null && !stopped)
+      await handle(request, choice);
+  };
+  const schedule = () => {
+    if (stopped || ticking !== null)
+      return;
+    const task = tick();
+    ticking = task;
+    void task.catch((error) => console.error(`Leglas runner: ${error instanceof Error ? error.message : String(error)}`)).finally(() => {
+      if (ticking === task)
+        ticking = null;
+    });
+  };
+  const timer = setEvery(schedule, POLL_MS);
+  schedule();
+  const cancel = (id) => {
+    if (active === null || active.cancelled)
+      return false;
+    if (id !== void 0 && active.requestId !== id)
+      return false;
+    active.cancelled = true;
+    failed.add(active.requestId);
+    try {
+      active.child.kill("SIGTERM");
+    } catch {
+    }
+    return true;
+  };
+  const stop = () => {
+    if (stopPromise !== null)
+      return stopPromise;
+    stopped = true;
+    clearEvery(timer);
+    cancel();
+    stopPromise = Promise.resolve(ticking).catch(() => {
+    }).then(() => {
+    });
+    return stopPromise;
+  };
+  return {
+    stop,
+    snapshot: () => ({ ...state, failedIds: [...failed] }),
+    cancel,
+    // schedule already refuses to overlap a tick in flight, so a nudge during
+    // a run costs nothing and a nudge between runs starts the next one now.
+    nudge: schedule
+  };
 }
 
 // ../server/dist/renames.js
-import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname4, join as join5 } from "path";
+import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname5, join as join6 } from "path";
 var RENAMES_PATH = ".leglas/renames.json";
 async function readRenames(cwd) {
   try {
-    const raw = await readFile4(join5(cwd, RENAMES_PATH), "utf8");
+    const raw = await readFile5(join6(cwd, RENAMES_PATH), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.renames === null || typeof parsed.renames !== "object")
       return {};
@@ -1360,9 +1975,9 @@ async function readRenames(cwd) {
   }
 }
 async function writeRenames(cwd, renames) {
-  const path = join5(cwd, RENAMES_PATH);
-  await mkdir3(dirname4(path), { recursive: true });
-  await writeFile3(path, `${JSON.stringify({ renames }, null, 2)}
+  const path = join6(cwd, RENAMES_PATH);
+  await mkdir4(dirname5(path), { recursive: true });
+  await writeFile4(path, `${JSON.stringify({ renames }, null, 2)}
 `, "utf8");
 }
 function resolveTitle(input, titles, renames) {
@@ -1380,7 +1995,7 @@ function resolveTitle(input, titles, renames) {
 import { createReadStream, existsSync as existsSync2, statSync } from "fs";
 import http2 from "http";
 import net3 from "net";
-import { extname, join as join6, normalize } from "path";
+import { extname, join as join7, normalize, relative as relative3 } from "path";
 var LEGLAS_PREFIX = "/leglas";
 var DEFAULT_PORT = 4100;
 var PORT_ATTEMPTS = 20;
@@ -1411,6 +2026,52 @@ function sendJson(res, status, body) {
   });
   res.end(payload);
 }
+function isKnownAgent(value) {
+  return typeof value === "string" && 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 (typeof req.headers.host !== "string")
+    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 hasJsonBody(req) {
+  const contentType = req.headers["content-type"];
+  return typeof contentType === "string" && contentType.split(";", 1)[0]?.trim().toLowerCase() === "application/json";
+}
 function probe(target, timeoutMs = 1e3) {
   return new Promise((resolve) => {
     let url;
@@ -1432,8 +2093,8 @@ function probe(target, timeoutMs = 1e3) {
   });
 }
 function serveFrom(res, dir, relativePath) {
-  const relative3 = normalize(relativePath).replace(/^(\.\.[/\\])+/, "");
-  const candidate = join6(dir, relative3);
+  const relative5 = normalize(relativePath).replace(/^(\.\.[/\\])+/, "");
+  const candidate = join7(dir, relative5);
   if (!candidate.startsWith(dir))
     return false;
   if (!existsSync2(candidate) || !statSync(candidate).isFile())
@@ -1446,9 +2107,36 @@ function serveFrom(res, dir, relativePath) {
   return true;
 }
 function serveShellFile(res, shellDir, urlPath) {
-  const relative3 = normalize(urlPath.slice(LEGLAS_PREFIX.length)).replace(/^(\.\.[/\\])+/, "");
-  const isRoot = relative3 === "" || relative3 === "." || relative3 === "/";
-  return serveFrom(res, shellDir, isRoot ? "index.html" : relative3);
+  const relative5 = normalize(urlPath.slice(LEGLAS_PREFIX.length)).replace(/^(\.\.[/\\])+/, "");
+  const isRoot = relative5 === "" || relative5 === "." || relative5 === "/";
+  return serveFrom(res, shellDir, isRoot ? "index.html" : relative5);
+}
+function snapshotConfig(cwd) {
+  const path = findConfigFile(cwd);
+  if (path === null)
+    return null;
+  try {
+    return { path, mtimeMs: statSync(path).mtimeMs };
+  } catch {
+    return null;
+  }
+}
+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;
+    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;
+    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;
+    return `${label} changed after Leglas started. Restart leglas to pick it up.`;
+  }
+  return null;
 }
 var PLACEHOLDER = `<!doctype html>
 <meta charset="utf-8">
@@ -1491,15 +2179,46 @@ async function bind(server, requested) {
   throw new Error(`No free port between ${requested} and ${requested + PORT_ATTEMPTS - 1}.`);
 }
 async function startServer(options) {
-  const { config, configErrors = [], shellDir = null, project = "", cwd = process.cwd(), fileMounts = /* @__PURE__ */ new Map() } = options;
+  const { config, configErrors = [], shellDir = null, project = "", cwd = process.cwd(), fileMounts = /* @__PURE__ */ new Map(), detect = () => detectAgents() } = options;
   const target = config?.devServer ?? "http://localhost:3000";
   const proxy = createProxyHandler({ target });
+  const bootConfigSnapshot = snapshotConfig(cwd);
   let lastSeen = null;
+  const externallyAttached = () => lastSeen !== null && Date.now() - lastSeen < ATTACHED_WINDOW_MS;
+  let runner = null;
+  let agentsCache = null;
+  let agentsInflight = null;
+  const AGENTS_FRESH_MS = 3e4;
+  const probeAgents = () => {
+    agentsInflight ??= detect().then((agents) => {
+      agentsCache = { at: Date.now(), agents };
+      return agents;
+    }).finally(() => {
+      agentsInflight = null;
+    });
+    return agentsInflight;
+  };
+  const currentAgents = () => {
+    if (agentsCache === null)
+      return probeAgents();
+    if (Date.now() - agentsCache.at > AGENTS_FRESH_MS) {
+      void probeAgents().catch(() => {
+      });
+    }
+    return Promise.resolve(agentsCache.agents);
+  };
   const server = http2.createServer((req, res) => {
     const url = req.url ?? "/";
     const path = url.split("?")[0] ?? "/";
+    if (req.method === "POST" && path.startsWith(`${LEGLAS_PREFIX}/api/`) && !isTrustedMutation(req)) {
+      return sendJson(res, 403, { ok: false, error: "Cross-origin API mutations are refused." });
+    }
     if (path === `${LEGLAS_PREFIX}/api/config`) {
       const boot = config?.previews ?? [];
+      const errors = [...configErrors];
+      const notice = configStalenessNotice(cwd, bootConfigSnapshot, snapshotConfig(cwd));
+      if (notice !== null)
+        errors.push(notice);
       return void readLocalPreviews(cwd).then(({ previews: local }) => {
         const known = new Set(boot.map((preview) => preview.title));
         const fresh = local.filter((preview) => !known.has(preview.title) && preview.branch === void 0 && preview.file === void 0);
@@ -1507,13 +2226,13 @@ async function startServer(options) {
           project,
           devServer: target,
           previews: [...boot, ...fresh],
-          errors: configErrors
+          errors
         });
       }).catch(() => sendJson(res, 200, {
         project,
         devServer: target,
         previews: boot,
-        errors: configErrors
+        errors
       }));
     }
     if (path === `${LEGLAS_PREFIX}/api/request` && req.method === "POST") {
@@ -1537,7 +2256,54 @@ async function startServer(options) {
           url: preview.url,
           intent: parsed.intent.trim(),
           ...composed
-        }).then(() => sendJson(res, 200, { ok: true, ...composed })).catch(() => sendJson(res, 200, { ok: true, ...composed, queued: false }));
+        }).then(() => {
+          runner?.nudge();
+          sendJson(res, 200, { ok: true, ...composed });
+        }).catch(() => sendJson(res, 200, { ok: true, ...composed, queued: false }));
+      });
+    }
+    if (path === `${LEGLAS_PREFIX}/api/agents` && req.method === "GET") {
+      return void Promise.all([currentAgents(), readAgentChoice(cwd)]).then(([agents, choice]) => sendJson(res, 200, {
+        agents,
+        choice: choice.agent,
+        customRun: choice.run
+      }));
+    }
+    if (path === `${LEGLAS_PREFIX}/api/agent` && req.method === "POST") {
+      if (!isLoopbackAddress(req.socket.remoteAddress)) {
+        return sendJson(res, 403, {
+          ok: false,
+          error: "The agent choice can only be made from the machine running Leglas."
+        });
+      }
+      if (!hasJsonBody(req)) {
+        return sendJson(res, 400, { ok: false, error: "Agent choice must be JSON." });
+      }
+      let body = "";
+      req.on("data", (chunk) => body += chunk);
+      return void req.on("end", () => {
+        let parsed;
+        try {
+          parsed = JSON.parse(body || "{}");
+        } catch {
+          return sendJson(res, 400, { ok: false, error: "Body must be JSON." });
+        }
+        if (!isKnownAgent(parsed.agent) && parsed.agent !== "custom") {
+          return sendJson(res, 400, { ok: false, error: "Body needs a known agent." });
+        }
+        if (parsed.run !== void 0 && typeof parsed.run !== "string") {
+          return sendJson(res, 400, { ok: false, error: "The custom run command must be a string." });
+        }
+        if (parsed.agent === "custom") {
+          if (typeof parsed.run !== "string") {
+            return sendJson(res, 400, { ok: false, error: "A custom agent needs a run command." });
+          }
+          const template = parseTemplate(parsed.run);
+          if (!template.ok)
+            return sendJson(res, 400, { ok: false, error: template.error });
+          return void saveAgentChoice(cwd, { agent: "custom", run: parsed.run }).then(() => sendJson(res, 200, { ok: true }), () => sendJson(res, 500, { ok: false, error: "Agent choice could not be saved." }));
+        }
+        return void saveAgentChoice(cwd, { agent: parsed.agent }).then(() => sendJson(res, 200, { ok: true }), () => sendJson(res, 500, { ok: false, error: "Agent choice could not be saved." }));
       });
     }
     if (path === `${LEGLAS_PREFIX}/api/watch` && req.method === "POST") {
@@ -1558,11 +2324,119 @@ async function startServer(options) {
       });
     }
     if (path === `${LEGLAS_PREFIX}/api/requests` && req.method === "GET") {
+      const snapshot = runner?.snapshot() ?? {
+        running: false,
+        requestId: null,
+        agent: null,
+        activity: null,
+        startedAt: null,
+        failedIds: []
+      };
       return void readRequests(cwd).then((requests) => sendJson(res, 200, {
-        requests: requests.map(({ id, title, intent, status }) => ({ id, title, intent, status })),
-        agent: { attached: lastSeen !== null && Date.now() - lastSeen < ATTACHED_WINDOW_MS }
+        requests: requests.map(({ id, title, intent, status }) => ({
+          id,
+          title,
+          intent,
+          status: snapshot.running && snapshot.requestId === id ? "running" : snapshot.failedIds.includes(id) ? "failed" : status
+        })),
+        agent: {
+          attached: externallyAttached(),
+          running: snapshot.running,
+          name: snapshot.running ? snapshot.agent : null,
+          activity: snapshot.running ? snapshot.activity : null,
+          startedAt: snapshot.running ? snapshot.startedAt : null
+        }
       }));
     }
+    if (path === `${LEGLAS_PREFIX}/api/requests/cancel` && req.method === "POST") {
+      if (!hasJsonBody(req)) {
+        return sendJson(res, 200, { ok: true, cancelled: runner?.cancel() ?? false });
+      }
+      let body = "";
+      req.on("data", (chunk) => body += chunk);
+      return void req.on("end", () => {
+        let parsed;
+        try {
+          parsed = JSON.parse(body || "{}");
+        } catch {
+          return sendJson(res, 400, { ok: false, error: "Body must be JSON." });
+        }
+        if (parsed.id !== void 0 && typeof parsed.id !== "string") {
+          return sendJson(res, 400, { ok: false, error: "The request id must be a string." });
+        }
+        return sendJson(res, 200, { ok: true, cancelled: runner?.cancel(parsed.id) ?? false });
+      });
+    }
+    if (path === `${LEGLAS_PREFIX}/api/requests/retry` && req.method === "POST") {
+      if (!hasJsonBody(req)) {
+        return sendJson(res, 400, { ok: false, error: "Retry must be JSON." });
+      }
+      let body = "";
+      req.on("data", (chunk) => body += chunk);
+      return void req.on("end", async () => {
+        let parsed;
+        try {
+          parsed = JSON.parse(body || "{}");
+        } catch {
+          return sendJson(res, 400, { ok: false, error: "Body must be JSON." });
+        }
+        if (typeof parsed.id !== "string") {
+          return sendJson(res, 400, { ok: false, error: "Body needs a request id." });
+        }
+        const request = (await readRequests(cwd)).find((entry) => entry.id === parsed.id);
+        if (request === void 0) {
+          return sendJson(res, 404, { ok: false, error: "No such request." });
+        }
+        if (!(runner?.snapshot().failedIds.includes(request.id) ?? false)) {
+          return sendJson(res, 400, { ok: false, error: "Only a failed request can be retried." });
+        }
+        try {
+          if (!await removeRequest(cwd, request.id)) {
+            return sendJson(res, 404, { ok: false, error: "No such request." });
+          }
+          await appendRequest(cwd, {
+            title: request.title,
+            url: request.url,
+            intent: request.intent,
+            target: request.target,
+            prompt: request.prompt
+          });
+          runner?.nudge();
+          return sendJson(res, 200, { ok: true });
+        } catch {
+          return sendJson(res, 500, { ok: false, error: "The request could not be retried." });
+        }
+      });
+    }
+    if (path === `${LEGLAS_PREFIX}/api/requests/dismiss` && req.method === "POST") {
+      if (!hasJsonBody(req)) {
+        return sendJson(res, 400, { ok: false, error: "Dismiss must be JSON." });
+      }
+      let body = "";
+      req.on("data", (chunk) => body += chunk);
+      return void req.on("end", async () => {
+        let parsed;
+        try {
+          parsed = JSON.parse(body || "{}");
+        } catch {
+          return sendJson(res, 400, { ok: false, error: "Body must be JSON." });
+        }
+        if (typeof parsed.id !== "string") {
+          return sendJson(res, 400, { ok: false, error: "Body needs a request id." });
+        }
+        if (!(runner?.snapshot().failedIds.includes(parsed.id) ?? false)) {
+          return sendJson(res, 400, { ok: false, error: "Only a failed request can be dismissed." });
+        }
+        try {
+          if (!await removeRequest(cwd, parsed.id)) {
+            return sendJson(res, 404, { ok: false, error: "No such request." });
+          }
+          return sendJson(res, 200, { ok: true });
+        } catch {
+          return sendJson(res, 500, { ok: false, error: "The request could not be dismissed." });
+        }
+      });
+    }
     if (path === `${LEGLAS_PREFIX}/api/renames` && req.method === "POST") {
       let body = "";
       req.on("data", (chunk) => body += chunk);
@@ -1587,21 +2461,28 @@ 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 relative3 = slash === -1 ? "" : rest.slice(slash + 1);
+      let relative5 = slash === -1 ? "" : rest.slice(slash + 1);
       try {
-        relative3 = decodeURIComponent(relative3);
+        relative5 = decodeURIComponent(relative5);
       } catch {
-        relative3 = "";
+        relative5 = "";
       }
       const dir = fileMounts.get(slug);
-      if (dir !== void 0 && relative3 !== "" && serveFrom(res, dir, relative3))
+      if (dir !== void 0 && relative5 !== "" && serveFrom(res, dir, relative5))
         return;
       res.writeHead(404, { "content-type": "text/plain; charset=utf-8", "cache-control": "no-store" });
       return res.end("Leglas: no such preview file.");
     }
+    if (path.startsWith(`${LEGLAS_PREFIX}/api/`)) {
+      return sendJson(res, 404, { error: "No such Leglas API path." });
+    }
     if (path === LEGLAS_PREFIX || path.startsWith(`${LEGLAS_PREFIX}/`)) {
       if (shellDir !== null && serveShellFile(res, shellDir, path))
         return;
+      if (shellDir !== null) {
+        res.writeHead(404, { "content-type": "text/plain; charset=utf-8", "cache-control": "no-store" });
+        return res.end("Leglas: no such path.");
+      }
       res.writeHead(200, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" });
       return res.end(PLACEHOLDER);
     }
@@ -1619,16 +2500,23 @@ async function startServer(options) {
     proxy.upgrade(req, socket, head);
   });
   const port = await bind(server, options.port ?? DEFAULT_PORT);
+  runner = startRunner({ cwd, externallyAttached });
+  let closePromise = null;
   return {
     port,
     url: `http://localhost:${port}`,
-    close: () => new Promise((done) => {
-      for (const socket of sockets)
-        socket.destroy();
-      sockets.clear();
-      server.closeAllConnections();
-      server.close(() => done());
-    })
+    close: () => {
+      if (closePromise !== null)
+        return closePromise;
+      closePromise = runner.stop().then(() => new Promise((done) => {
+        for (const socket of sockets)
+          socket.destroy();
+        sockets.clear();
+        server.closeAllConnections();
+        server.close(() => done());
+      }));
+      return closePromise;
+    }
   };
 }
 
@@ -1650,7 +2538,7 @@ function planKeep(options) {
   if (!winner) {
     return {
       ok: false,
-      error: `No direction called ${JSON.stringify(options.title)}. Run leglas list to see them.`
+      error: `No direction called ${JSON.stringify(options.title)}. Run npx leglas list to see them.`
     };
   }
   const from = targetFor(winner.url);
@@ -1687,11 +2575,11 @@ function planKeep(options) {
 }
 
 // src/run-init.ts
-import { readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
-import { join as join7 } from "path";
+import { readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
+import { join as join8 } from "path";
 async function readIfPresent(path) {
   try {
-    return await readFile5(path, "utf8");
+    return await readFile6(path, "utf8");
   } catch {
     return null;
   }
@@ -1699,18 +2587,18 @@ async function readIfPresent(path) {
 async function runInit(options, deps) {
   const existingConfig = findConfigFile(options.cwd);
   const plan = planInit({
-    agents: await readIfPresent(join7(options.cwd, "AGENTS.md")),
+    agents: await readIfPresent(join8(options.cwd, "AGENTS.md")),
     config: existingConfig === null ? null : "present",
-    gitignore: await readIfPresent(join7(options.cwd, ".gitignore")),
+    gitignore: await readIfPresent(join8(options.cwd, ".gitignore")),
     force: options.force
   });
   const touched = [];
   for (const write of plan.writes) {
-    await writeFile4(join7(options.cwd, write.path), write.contents, "utf8");
+    await writeFile5(join8(options.cwd, write.path), write.contents, "utf8");
     touched.push(write.path);
   }
   if (plan.gitignore !== null) {
-    await writeFile4(join7(options.cwd, ".gitignore"), plan.gitignore, "utf8");
+    await writeFile5(join8(options.cwd, ".gitignore"), plan.gitignore, "utf8");
     touched.push(".gitignore");
   }
   if (options.json) {
@@ -1730,8 +2618,8 @@ async function runInit(options, deps) {
 
 // src/run-keep.ts
 import { existsSync as existsSync3 } from "fs";
-import { mkdir as mkdir4, readFile as readFile6, rm as rm2, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname5, join as join8 } from "path";
+import { mkdir as mkdir5, readFile as readFile7, rm as rm2, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname6, join as join9 } from "path";
 
 // src/resolve-title.ts
 function resolveOrExplain(input, titles, renames) {
@@ -1745,7 +2633,7 @@ function resolveOrExplain(input, titles, renames) {
   }
   return {
     ok: false,
-    error: `No direction called ${JSON.stringify(input)}. Renaming one in the rail only renames it here, and it still answers to its title in the config, which its reference block quotes. leglas list shows every title.`
+    error: `No direction called ${JSON.stringify(input)}. Renaming one in the rail only renames it here, and it still answers to its title in the config, which its reference block quotes. npx leglas list shows every title.`
   };
 }
 
@@ -1775,18 +2663,18 @@ async function runKeep(options, deps) {
   if (!resolved.ok) return fail(resolved.error);
   const plan = planKeep({ title: resolved.title, previews, to: options.to });
   if (!plan.ok) return fail(plan.error);
-  const from = join8(options.cwd, plan.move.from);
-  const to = join8(options.cwd, plan.move.to);
+  const from = join9(options.cwd, plan.move.from);
+  const to = join9(options.cwd, plan.move.to);
   if (!existsSync3(from)) {
     return fail(`${plan.move.from} does not exist. Nothing to keep.`);
   }
   if (existsSync3(to)) {
     return fail(`${plan.move.to} already exists. Choose another destination or move it aside.`);
   }
-  const source = await readFile6(from, "utf8");
-  await mkdir4(dirname5(to), { recursive: true });
-  await writeFile5(to, renameExport(source, plan.exportName), "utf8");
-  await rm2(join8(options.cwd, plan.removeDir), { recursive: true, force: true });
+  const source = await readFile7(from, "utf8");
+  await mkdir5(dirname6(to), { recursive: true });
+  await writeFile6(to, renameExport(source, plan.exportName), "utf8");
+  await rm2(join9(options.cwd, plan.removeDir), { recursive: true, force: true });
   const dropped = await dropLocalPreviews(options.cwd, plan.dropTitles);
   if (options.json) {
     deps.log(
@@ -1821,11 +2709,11 @@ async function runKeep(options, deps) {
 
 // src/run-new.ts
 import { existsSync as existsSync4 } from "fs";
-import { mkdir as mkdir5, readFile as readFile7, writeFile as writeFile6 } from "fs/promises";
-import { dirname as dirname6, join as join9 } from "path";
+import { mkdir as mkdir6, readFile as readFile8, writeFile as writeFile7 } from "fs/promises";
+import { dirname as dirname7, join as join10 } from "path";
 async function readIfPresent2(path) {
   try {
-    return await readFile7(path, "utf8");
+    return await readFile8(path, "utf8");
   } catch {
     return null;
   }
@@ -1833,7 +2721,7 @@ async function readIfPresent2(path) {
 async function runNew(options, deps) {
   let from;
   if (options.from !== void 0) {
-    const contents = await readIfPresent2(join9(options.cwd, options.from));
+    const contents = await readIfPresent2(join10(options.cwd, options.from));
     if (contents === null) {
       const message = `${options.from} does not exist, so there is nothing to use as the baseline.`;
       if (options.json) deps.log(JSON.stringify({ ok: false, error: message }));
@@ -1844,8 +2732,8 @@ async function runNew(options, deps) {
   }
   const plan = planNew({
     surface: options.surface,
-    packageJson: await readIfPresent2(join9(options.cwd, "package.json")),
-    gitignore: await readIfPresent2(join9(options.cwd, ".gitignore")),
+    packageJson: await readIfPresent2(join10(options.cwd, "package.json")),
+    gitignore: await readIfPresent2(join10(options.cwd, ".gitignore")),
     from
   });
   const fail = (error) => {
@@ -1868,19 +2756,19 @@ async function runNew(options, deps) {
     deps.log(plan.instructions);
     return { exitCode: 0, written: [] };
   }
-  const existing = plan.writes.filter((write) => existsSync4(join9(options.cwd, write.path)));
+  const existing = plan.writes.filter((write) => existsSync4(join10(options.cwd, write.path)));
   if (existing.length > 0) {
     return fail(`${existing[0]?.path} already exists. Delete it first, or pick another surface name.`);
   }
   const written = [];
   for (const write of plan.writes) {
-    const target = join9(options.cwd, write.path);
-    await mkdir5(dirname6(target), { recursive: true });
-    await writeFile6(target, write.contents, "utf8");
+    const target = join10(options.cwd, write.path);
+    await mkdir6(dirname7(target), { recursive: true });
+    await writeFile7(target, write.contents, "utf8");
     written.push(write.path);
   }
   if (plan.gitignore !== null) {
-    await writeFile6(join9(options.cwd, ".gitignore"), plan.gitignore, "utf8");
+    await writeFile7(join10(options.cwd, ".gitignore"), plan.gitignore, "utf8");
     written.push(".gitignore");
   }
   if (options.json) {
@@ -1895,27 +2783,27 @@ async function runNew(options, deps) {
   deps.log("Then register them so they appear in the interface:");
   deps.log("");
   for (const preview of plan.previews) {
-    deps.log(`  leglas add --title ${JSON.stringify(preview.title)} --url ${JSON.stringify(preview.url)}`);
+    deps.log(`  npx leglas add --title ${JSON.stringify(preview.title)} --url ${JSON.stringify(preview.url)}`);
   }
   return { exitCode: 0, written };
 }
 
 // src/run-previews.ts
-import { readFile as readFile8, writeFile as writeFile7 } from "fs/promises";
-import { join as join10 } from "path";
+import { readFile as readFile9, writeFile as writeFile8 } from "fs/promises";
+import { join as join11 } from "path";
 function envelope(deps, ok, body) {
   deps.log(JSON.stringify({ ok, ...body }));
 }
 async function ensureIgnored(cwd) {
-  const path = join10(cwd, ".gitignore");
+  const path = join11(cwd, ".gitignore");
   let current = null;
   try {
-    current = await readFile8(path, "utf8");
+    current = await readFile9(path, "utf8");
   } catch {
     current = null;
   }
   const next = ignoreEntry(current);
-  if (next !== null) await writeFile7(path, next, "utf8");
+  if (next !== null) await writeFile8(path, next, "utf8");
 }
 async function runAdd(options, deps) {
   const loaded = await loadConfig(options.cwd);
@@ -1924,7 +2812,7 @@ async function runAdd(options, deps) {
     const local = await readLocalPreviews(options.cwd);
     const titles = new Set([...shared, ...local.previews].map((preview) => preview.title));
     if (!titles.has(options.preview.basedOn)) {
-      const error = `--based-on names ${JSON.stringify(options.preview.basedOn)}, which is not a registered direction. leglas list shows what exists.`;
+      const error = `--based-on names ${JSON.stringify(options.preview.basedOn)}, which is not a registered direction. npx leglas list shows what exists.`;
       if (options.json) envelope(deps, false, { error });
       else deps.error(error);
       return { exitCode: 1 };
@@ -1957,6 +2845,7 @@ async function runAdd(options, deps) {
       local: true,
       ...options.preview.branch === void 0 ? {} : { branch: options.preview.branch },
       ...options.preview.file === void 0 ? {} : { file: options.preview.file },
+      note: options.preview.branch === void 0 && options.preview.file === void 0 ? "A running interface picks this up within seconds." : "Restart Leglas to see this preview: branch checkouts and file mounts are built when Leglas starts.",
       ...needsDevCommand ? { warning: "The config sets no devCommand, so Leglas cannot start this branch yet. Add devCommand (with {port}) to the config." } : {}
     });
   } else {
@@ -1972,7 +2861,7 @@ async function runAdd(options, deps) {
     if (options.preview.branch === void 0 && options.preview.file === void 0) {
       deps.log("Local to this machine. A running interface picks it up within seconds.");
     } else {
-      deps.log("Local to this machine. Restart Leglas to see it, or run leglas list.");
+      deps.log("Local to this machine. Restart Leglas to see it, or run npx leglas list.");
     }
   }
   return { exitCode: 0 };
@@ -2007,7 +2896,7 @@ async function runList(options, deps) {
     return { exitCode: errors.length === 0 ? 0 : 1 };
   }
   if (previews.length === 0) {
-    deps.log("No previews yet. Add one with leglas add, or list them in leglas.config.ts.");
+    deps.log("No previews yet. Add one with npx leglas add, or list them in leglas.config.ts.");
   } else {
     const width = Math.max(...previews.map((preview) => preview.title.length));
     for (const preview of previews) {
@@ -2022,9 +2911,16 @@ async function runList(options, deps) {
 }
 async function runRequests(options, deps) {
   if (options.clear) {
-    await clearRequests(options.cwd);
-    if (options.json) envelope(deps, true, { cleared: true });
-    else deps.log("Queue cleared.");
+    const { cleared, pending } = await clearRequests(options.cwd);
+    if (options.json) envelope(deps, true, { cleared, pending });
+    else {
+      deps.log(cleared === 1 ? "Cleared 1 request." : `Cleared ${cleared} requests.`);
+      if (pending > 0) {
+        deps.log(
+          `${pending} arrived while you worked. Run npx leglas requests to collect ${pending === 1 ? "it" : "them"}.`
+        );
+      }
+    }
     return { exitCode: 0 };
   }
   const requests = await collectRequests(options.cwd);
@@ -2041,7 +2937,7 @@ async function runRequests(options, deps) {
     if (request.target !== null) deps.log(`    ${request.target}`);
   }
   deps.log("");
-  deps.log("Run leglas requests --json to get the full prompts, then --clear when done.");
+  deps.log("Run npx leglas requests --json to get the full prompts, then --clear when done.");
   return { exitCode: 0 };
 }
 
@@ -2067,7 +2963,7 @@ function planShow({ title, previews, requests }) {
   if (!found) {
     return {
       ok: false,
-      error: `No direction called ${JSON.stringify(title)}. Run leglas list to see them.`
+      error: `No direction called ${JSON.stringify(title)}. Run npx leglas list to see them.`
     };
   }
   const variants = previews.filter((preview) => preview.basedOn === title).map(describe);
@@ -2146,104 +3042,30 @@ async function runShow(options, deps) {
     deps.log(`  Pending, not yet done (${plan.requests.length}):`);
     for (const request of plan.requests) deps.log(`    ${request.status}  ${request.intent}`);
     deps.log("");
-    deps.log("  Run leglas requests --json for the full prompts.");
+    deps.log("  Run npx leglas requests --json for the full prompts.");
   }
   return { exitCode: 0 };
 }
 
-// src/watch.ts
-var WATCH_PATH = ".leglas/watch.json";
-var PROMPT_TOKEN = "{prompt}";
-var EXAMPLE = `leglas watch --run "claude -p ${PROMPT_TOKEN}"`;
-function tokenize(template) {
-  const tokens = [];
-  let current = "";
-  let started = false;
-  let quote = null;
-  for (const character of template) {
-    if (quote !== null) {
-      if (character === quote) quote = null;
-      else current += character;
-      continue;
-    }
-    if (character === '"' || character === "'") {
-      quote = character;
-      started = true;
-      continue;
-    }
-    if (/\s/.test(character)) {
-      if (started) tokens.push(current);
-      current = "";
-      started = false;
-      continue;
-    }
-    current += character;
-    started = true;
-  }
-  if (quote !== null) {
-    return { ok: false, error: `The agent command has an unclosed ${quote} quote.` };
-  }
-  if (started) tokens.push(current);
-  return { ok: true, tokens };
-}
-function parseTemplate(raw) {
-  const tokenized = tokenize(raw);
-  if (!tokenized.ok) return tokenized;
-  const { tokens } = tokenized;
-  const [command, ...args] = tokens;
-  if (command === void 0) {
-    return { ok: false, error: `Watch needs an agent command, for example: ${EXAMPLE}` };
-  }
-  const placeholders = tokens.filter((token) => token === PROMPT_TOKEN).length;
-  if (placeholders === 0) {
-    return {
-      ok: false,
-      error: `The agent command needs ${PROMPT_TOKEN} as a word of its own, for example: ${EXAMPLE}`
-    };
-  }
-  if (placeholders > 1) {
-    return {
-      ok: false,
-      error: `The agent command takes ${PROMPT_TOKEN} once, for example: ${EXAMPLE}`
-    };
-  }
-  if (command === PROMPT_TOKEN) {
-    return {
-      ok: false,
-      error: `The agent command must name a program before ${PROMPT_TOKEN}, for example: ${EXAMPLE}`
-    };
-  }
-  return { ok: true, template: { command, args } };
-}
-function commandFor(template, prompt) {
-  return {
-    command: template.command,
-    args: template.args.map((argument) => argument === PROMPT_TOKEN ? prompt : argument)
-  };
-}
-function nextRequest(requests, failed) {
-  return requests.find((request) => request.status === "queued" && !failed.has(request.id)) ?? null;
-}
-
 // src/run-watch.ts
-import { spawn as spawn2 } from "child_process";
-import { mkdir as mkdir6, readFile as readFile9, writeFile as writeFile8 } from "fs/promises";
-import { dirname as dirname7, join as join11 } from "path";
-var POLL_MS = 2e3;
+import { spawn as spawn3 } from "child_process";
+import { mkdir as mkdir7, readFile as readFile10, writeFile as writeFile9 } from "fs/promises";
+import { dirname as dirname8, join as join12 } from "path";
+var POLL_MS2 = 2e3;
 var HEARTBEAT_TIMEOUT_MS = 1e3;
-async function readSavedTemplate(cwd) {
+async function saveTemplate(cwd, run3) {
+  const path = join12(cwd, WATCH_PATH);
+  let config = {};
   try {
-    const raw = await readFile9(join11(cwd, WATCH_PATH), "utf8");
-    const parsed = JSON.parse(raw);
-    return typeof parsed.run === "string" && parsed.run !== "" ? parsed.run : null;
+    const parsed = JSON.parse(await readFile10(path, "utf8"));
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      config = parsed;
+    }
   } catch {
-    return null;
   }
-}
-async function saveTemplate(cwd, run3) {
-  const path = join11(cwd, WATCH_PATH);
-  await mkdir6(dirname7(path), { recursive: true });
-  await writeFile8(path, `${JSON.stringify({ run: run3 }, null, 2)}
+  config.run = run3;
+  await mkdir7(dirname8(path), { recursive: true });
+  await writeFile9(path, `${JSON.stringify(config, null, 2)}
 `, "utf8");
 }
 function spawnAgent(command, args, cwd) {
@@ -2254,7 +3076,7 @@ function spawnAgent(command, args, cwd) {
       settled = true;
       resolve(outcome);
     };
-    const child = spawn2(command, args, { cwd, stdio: "inherit" });
+    const child = spawn3(command, args, { cwd, stdio: "inherit" });
     child.on("error", (error) => settle({ ok: false, error: error.message }));
     child.on(
       "close",
@@ -2265,21 +3087,34 @@ function spawnAgent(command, args, cwd) {
   });
 }
 async function runWatch(options, deps) {
-  const saved = options.run === void 0 ? await readSavedTemplate(options.cwd) : null;
-  const raw = options.run ?? saved;
-  if (raw === null) {
+  const saved = options.run === void 0 ? await readAgentChoice(options.cwd) : { agent: null, run: null };
+  const raw = options.run ?? saved.run;
+  let template;
+  let shownCommand2;
+  let synthesizedAgent = null;
+  if (raw !== null) {
+    const parsed = parseTemplate(raw);
+    if (!parsed.ok) {
+      deps.error(parsed.error);
+      return { exitCode: 1 };
+    }
+    template = parsed.template;
+    shownCommand2 = raw;
+  } else if (saved.agent !== null && saved.agent !== "custom") {
+    const adapter = KNOWN_AGENTS[saved.agent];
+    template = {
+      command: adapter.binary,
+      args: adapter.terminalArgs(PROMPT_TOKEN)
+    };
+    shownCommand2 = [template.command, ...template.args].join(" ");
+    synthesizedAgent = adapter.name;
+  } else {
     deps.error(
-      'Watch needs an agent command the first time: leglas watch --run "claude -p {prompt}"'
+      'Watch needs an agent command the first time: pick an agent in the interface, or pass --run "claude -p {prompt}".'
     );
     return { exitCode: 1 };
   }
-  const parsed = parseTemplate(raw);
-  if (!parsed.ok) {
-    deps.error(parsed.error);
-    return { exitCode: 1 };
-  }
-  const template = parsed.template;
-  if (options.run !== void 0) await saveTemplate(options.cwd, raw).catch(() => {
+  if (options.run !== void 0) await saveTemplate(options.cwd, options.run).catch(() => {
   });
   const base = `http://localhost:${options.port ?? DEFAULT_PORT}`;
   const heartbeat = async (watching) => {
@@ -2293,11 +3128,15 @@ async function runWatch(options, deps) {
     } catch {
     }
   };
-  deps.log(`Watching for change requests. Each one runs: ${raw}`);
+  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.");
   const failed = /* @__PURE__ */ new Set();
   let stopped = false;
   let busy = false;
+  let announced = false;
   let inflight = null;
   const handle = async (request) => {
     deps.log("");
@@ -2319,7 +3158,12 @@ async function runWatch(options, deps) {
   };
   const tick = async () => {
     if (stopped) return;
-    void heartbeat(true);
+    if (announced) {
+      void heartbeat(true);
+    } else {
+      await heartbeat(true);
+      announced = true;
+    }
     if (busy) return;
     busy = true;
     try {
@@ -2336,7 +3180,7 @@ async function runWatch(options, deps) {
     }
   };
   return new Promise((resolve) => {
-    const timer = setInterval(() => void tick(), POLL_MS);
+    const timer = setInterval(() => void tick(), POLL_MS2);
     const stop = () => {
       if (stopped) return;
       stopped = true;
@@ -2355,12 +3199,12 @@ async function runWatch(options, deps) {
 
 // src/run-classify.ts
 import { stat } from "fs/promises";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 async function runClassify(options, deps) {
   const declared = await Promise.all(
     options.changes.map(async (change) => ({
       ...change,
-      exists: await stat(join12(options.cwd, change.path)).then(
+      exists: await stat(join13(options.cwd, change.path)).then(
         () => true,
         () => false
       )
@@ -2388,14 +3232,14 @@ async function runClassify(options, deps) {
 // src/run.ts
 import { existsSync as existsSync5 } from "fs";
 import { createRequire } from "module";
-import { basename as basename3, dirname as dirname8, join as join13, relative as relative2 } from "path";
+import { basename as basename3, dirname as dirname9, join as join14, relative as relative4 } from "path";
 import { fileURLToPath } from "url";
 function findShellDir() {
-  const bundled = join13(dirname8(fileURLToPath(import.meta.url)), "shell");
-  if (existsSync5(join13(bundled, "index.html"))) return bundled;
+  const bundled = join14(dirname9(fileURLToPath(import.meta.url)), "shell");
+  if (existsSync5(join14(bundled, "index.html"))) return bundled;
   try {
     const require2 = createRequire(import.meta.url);
-    return dirname8(require2.resolve("@leglas/shell/dist/index.html"));
+    return dirname9(require2.resolve("@leglas/shell/dist/index.html"));
   } catch {
     return null;
   }
@@ -2429,7 +3273,7 @@ async function run2(options, deps) {
   const fileMounts = /* @__PURE__ */ new Map();
   for (const preview of merged?.previews ?? []) {
     if (preview.file !== void 0) {
-      const absolute = join13(options.cwd, preview.file);
+      const absolute = join14(options.cwd, preview.file);
       if (!existsSync5(absolute)) {
         worktreeErrors.push(
           `"${preview.title}" names file ${preview.file}, which does not exist. The preview is skipped.`
@@ -2440,7 +3284,7 @@ async function run2(options, deps) {
       for (let suffix = 2; fileMounts.has(slug); suffix += 1) {
         slug = `${worktreeSlug(preview.title) || "file"}-${suffix}`;
       }
-      fileMounts.set(slug, dirname8(absolute));
+      fileMounts.set(slug, dirname9(absolute));
       previews.push({
         ...preview,
         url: `${FILES_PREFIX}/${slug}/${encodeURIComponent(basename3(absolute))}`
@@ -2501,7 +3345,7 @@ async function run2(options, deps) {
       })
     );
   } else {
-    const configLabel = loaded.path === null ? "no config file, previewing the app root" : relative2(options.cwd, loaded.path) || loaded.path;
+    const configLabel = loaded.path === null ? "no config file, previewing the app root" : relative4(options.cwd, loaded.path) || loaded.path;
     deps.log(`Leglas   ${url}`);
     deps.log(
       `app      ${devServer}${app !== null ? "  (started by Leglas)" : health.reachable ? "" : "  (not reachable)"}`
@@ -2540,6 +3384,8 @@ async function run2(options, deps) {
 export {
   AGENTS_MARKER_END,
   AGENTS_MARKER_START,
+  DEFAULT_PORT,
+  LEGLAS_PREFIX,
   PROMPT_TOKEN,
   WATCH_PATH,
   baselineFrom,