leglas 0.3.0 → 0.4.1

package/dist/bin.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/bin.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import { createRequire as createRequire2 } from "module";
 
 // src/args.ts
@@ -353,7 +353,7 @@ function parseArgs(argv) {
 
 // src/run-classify.ts
 import { stat } from "fs/promises";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 
 // ../server/dist/config.js
 var DEFAULT_DEV_SERVER = "http://localhost:3000";
@@ -485,6 +485,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: (result2) => {
+      try {
+        const parsed2 = record(JSON.parse(result2.stdout));
+        if (parsed2?.loggedIn === true)
+          return "ok";
+        if (parsed2?.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: (result2) => result2.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: (result2) => {
+      if (/logged in|signed in/i.test(result2.stdout))
+        return "ok";
+      if (result2.code !== 0 || /not logged in|log in|sign in/i.test(result2.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 result2 = await probe2(adapter.binary, adapter.authArgs).catch(() => null);
+    return {
+      id,
+      name: adapter.name,
+      available,
+      auth: result2 === null ? "unknown" : adapter.authVerdict(result2)
+    };
+  }));
+}
+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 parsed2 = JSON.parse(await readFile(join(cwd, WATCH_PATH), "utf8"));
+    return record(parsed2) ?? {};
+  } 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",
@@ -552,7 +906,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",
@@ -564,13 +918,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;
@@ -578,19 +932,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)) {
@@ -611,16 +965,25 @@ 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");
-  } catch {
-    return { previews: [], errors: [] };
+    raw = await readFile3(path, "utf8");
+  } catch (error) {
+    const code = error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : null;
+    if (code === "ENOENT") {
+      return { previews: [], errors: [] };
+    }
+    return {
+      previews: [],
+      errors: [
+        `${LOCAL_PREVIEWS_PATH} could not be read (${code ?? "unknown error"}). Check its permissions and file type; nothing shared is lost.`
+      ]
+    };
   }
   let parsed2;
   try {
@@ -667,9 +1030,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 };
 }
@@ -682,9 +1045,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;
 }
@@ -753,10 +1116,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";
@@ -793,7 +1156,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 });
@@ -854,7 +1217,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
@@ -894,9 +1257,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("/"))
@@ -922,17 +1285,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 parsed2 = JSON.parse(raw);
     if (!Array.isArray(parsed2.requests))
       return [];
@@ -949,9 +1315,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) {
@@ -991,13 +1357,264 @@ async function clearRequests(cwd) {
   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 parsed2 = parseTemplate(choice.run);
+    if (!parsed2.ok)
+      return null;
+    return { agent: "custom", name: "Custom", ...commandFor(parsed2.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 spawn5 = 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 = spawn5(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 parsed2 = JSON.parse(raw);
     if (parsed2.renames === null || typeof parsed2.renames !== "object")
       return {};
@@ -1007,9 +1624,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) {
@@ -1027,7 +1644,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, relative as relative2 } 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;
@@ -1058,6 +1675,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;
@@ -1079,8 +1742,8 @@ function probe(target, timeoutMs = 1e3) {
   });
 }
 function serveFrom(res, dir, relativePath) {
-  const relative4 = normalize(relativePath).replace(/^(\.\.[/\\])+/, "");
-  const candidate = join6(dir, relative4);
+  const relative5 = normalize(relativePath).replace(/^(\.\.[/\\])+/, "");
+  const candidate = join7(dir, relative5);
   if (!candidate.startsWith(dir))
     return false;
   if (!existsSync2(candidate) || !statSync(candidate).isFile())
@@ -1093,9 +1756,9 @@ function serveFrom(res, dir, relativePath) {
   return true;
 }
 function serveShellFile(res, shellDir, urlPath) {
-  const relative4 = normalize(urlPath.slice(LEGLAS_PREFIX.length)).replace(/^(\.\.[/\\])+/, "");
-  const isRoot = relative4 === "" || relative4 === "." || relative4 === "/";
-  return serveFrom(res, shellDir, isRoot ? "index.html" : relative4);
+  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);
@@ -1111,15 +1774,15 @@ function configStalenessNotice(cwd, boot, current) {
   if (boot === null && current === null)
     return null;
   if (boot === null && current !== null) {
-    const label = relative2(cwd, current.path) || current.path;
+    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 = relative2(cwd, boot.path) || boot.path;
+    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 = relative2(cwd, current.path) || current.path;
+    const label = relative3(cwd, current.path) || current.path;
     return `${label} changed after Leglas started. Restart leglas to pick it up.`;
   }
   return null;
@@ -1165,27 +1828,63 @@ 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));
+      return void readLocalPreviews(cwd).then(({ previews: local, errors: localErrors }) => {
+        if (localErrors.length > 0) {
+          return sendJson(res, 200, {
+            project,
+            devServer: target,
+            previews: boot,
+            errors
+          });
+        }
+        const localTitles = new Set(local.map((preview) => preview.title));
+        const currentBoot = boot.filter((preview) => preview.local !== true || localTitles.has(preview.title));
+        const known = new Set(currentBoot.map((preview) => preview.title));
         const fresh = local.filter((preview) => !known.has(preview.title) && preview.branch === void 0 && preview.file === void 0);
         sendJson(res, 200, {
           project,
           devServer: target,
-          previews: [...boot, ...fresh],
+          previews: [...currentBoot, ...fresh],
           errors
         });
       }).catch(() => sendJson(res, 200, {
@@ -1195,6 +1894,47 @@ async function startServer(options) {
         errors
       }));
     }
+    if (path === `${LEGLAS_PREFIX}/api/previews/delete` && req.method === "POST") {
+      let body = "";
+      req.on("data", (chunk) => body += chunk);
+      return void req.on("end", async () => {
+        let parsed2;
+        try {
+          parsed2 = JSON.parse(body || "{}");
+        } catch {
+          return sendJson(res, 400, { ok: false, error: "Body must be JSON." });
+        }
+        const titles = parsed2.titles;
+        if (!Array.isArray(titles) || titles.length === 0 || titles.some((title) => typeof title !== "string" || title.trim() === "")) {
+          return sendJson(res, 400, {
+            ok: false,
+            error: "Body needs a non-empty array of direction titles."
+          });
+        }
+        const unique = [...new Set(titles)];
+        try {
+          const local = await readLocalPreviews(cwd);
+          if (local.errors.length > 0) {
+            return sendJson(res, 409, { ok: false, error: local.errors.join(" ") });
+          }
+          const localTitles = new Set(local.previews.map((preview) => preview.title));
+          const unknown = unique.filter((title) => !localTitles.has(title));
+          if (unknown.length > 0) {
+            return sendJson(res, 400, {
+              ok: false,
+              error: "Only machine-local directions can be deleted from the registry."
+            });
+          }
+          const deleted = await dropLocalPreviews(cwd, unique);
+          return sendJson(res, 200, { ok: true, deleted });
+        } catch {
+          return sendJson(res, 500, {
+            ok: false,
+            error: "The directions could not be deleted from Leglas."
+          });
+        }
+      });
+    }
     if (path === `${LEGLAS_PREFIX}/api/request` && req.method === "POST") {
       let body = "";
       req.on("data", (chunk) => body += chunk);
@@ -1205,8 +1945,12 @@ async function startServer(options) {
         } catch {
           return sendJson(res, 400, { ok: false, error: "Body must be JSON." });
         }
-        const local = await readLocalPreviews(cwd).then((read) => read.previews, () => []);
-        const preview = [...config?.previews ?? [], ...local].find((entry) => entry.title === parsed2.title);
+        const localRead = await readLocalPreviews(cwd).catch(() => null);
+        const local = localRead?.errors.length === 0 ? localRead.previews : [];
+        const localTitles = new Set(local.map((entry) => entry.title));
+        const bootConfig = config?.previews ?? [];
+        const boot = localRead === null || localRead.errors.length > 0 ? bootConfig : bootConfig.filter((entry) => entry.local !== true || localTitles.has(entry.title));
+        const preview = [...boot, ...local].find((entry) => entry.title === parsed2.title);
         if (!preview || !parsed2.intent?.trim()) {
           return sendJson(res, 400, { ok: false, error: "Unknown preview, or empty request." });
         }
@@ -1216,7 +1960,54 @@ async function startServer(options) {
           url: preview.url,
           intent: parsed2.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 parsed2;
+        try {
+          parsed2 = JSON.parse(body || "{}");
+        } catch {
+          return sendJson(res, 400, { ok: false, error: "Body must be JSON." });
+        }
+        if (!isKnownAgent(parsed2.agent) && parsed2.agent !== "custom") {
+          return sendJson(res, 400, { ok: false, error: "Body needs a known agent." });
+        }
+        if (parsed2.run !== void 0 && typeof parsed2.run !== "string") {
+          return sendJson(res, 400, { ok: false, error: "The custom run command must be a string." });
+        }
+        if (parsed2.agent === "custom") {
+          if (typeof parsed2.run !== "string") {
+            return sendJson(res, 400, { ok: false, error: "A custom agent needs a run command." });
+          }
+          const template = parseTemplate(parsed2.run);
+          if (!template.ok)
+            return sendJson(res, 400, { ok: false, error: template.error });
+          return void saveAgentChoice(cwd, { agent: "custom", run: parsed2.run }).then(() => sendJson(res, 200, { ok: true }), () => sendJson(res, 500, { ok: false, error: "Agent choice could not be saved." }));
+        }
+        return void saveAgentChoice(cwd, { agent: parsed2.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") {
@@ -1237,11 +2028,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 parsed2;
+        try {
+          parsed2 = JSON.parse(body || "{}");
+        } catch {
+          return sendJson(res, 400, { ok: false, error: "Body must be JSON." });
+        }
+        if (parsed2.id !== void 0 && typeof parsed2.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(parsed2.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 parsed2;
+        try {
+          parsed2 = JSON.parse(body || "{}");
+        } catch {
+          return sendJson(res, 400, { ok: false, error: "Body must be JSON." });
+        }
+        if (typeof parsed2.id !== "string") {
+          return sendJson(res, 400, { ok: false, error: "Body needs a request id." });
+        }
+        const request = (await readRequests(cwd)).find((entry) => entry.id === parsed2.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 parsed2;
+        try {
+          parsed2 = JSON.parse(body || "{}");
+        } catch {
+          return sendJson(res, 400, { ok: false, error: "Body must be JSON." });
+        }
+        if (typeof parsed2.id !== "string") {
+          return sendJson(res, 400, { ok: false, error: "Body needs a request id." });
+        }
+        if (!(runner?.snapshot().failedIds.includes(parsed2.id) ?? false)) {
+          return sendJson(res, 400, { ok: false, error: "Only a failed request can be dismissed." });
+        }
+        try {
+          if (!await removeRequest(cwd, parsed2.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);
@@ -1266,14 +2165,14 @@ 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 relative4 = slash === -1 ? "" : rest.slice(slash + 1);
+      let relative5 = slash === -1 ? "" : rest.slice(slash + 1);
       try {
-        relative4 = decodeURIComponent(relative4);
+        relative5 = decodeURIComponent(relative5);
       } catch {
-        relative4 = "";
+        relative5 = "";
       }
       const dir = fileMounts.get(slug);
-      if (dir !== void 0 && relative4 !== "" && serveFrom(res, dir, relative4))
+      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.");
@@ -1305,16 +2204,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;
+    }
   };
 }
 
@@ -1323,7 +2229,7 @@ async function runClassify(options, deps) {
   const declared = await Promise.all(
     options.changes.map(async (change) => ({
       ...change,
-      exists: await stat(join7(options.cwd, change.path)).then(
+      exists: await stat(join8(options.cwd, change.path)).then(
         () => true,
         () => false
       )
@@ -1588,8 +2494,8 @@ function runExplore(options, deps) {
 }
 
 // src/run-init.ts
-import { readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
-import { join as join8 } from "path";
+import { readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
+import { join as join9 } from "path";
 
 // src/init.ts
 var AGENTS_MARKER_START = "<!-- leglas:start -->";
@@ -1722,7 +2628,7 @@ ${AGENTS_SECTION}`
 // src/run-init.ts
 async function readIfPresent(path) {
   try {
-    return await readFile5(path, "utf8");
+    return await readFile6(path, "utf8");
   } catch {
     return null;
   }
@@ -1730,18 +2636,18 @@ async function readIfPresent(path) {
 async function runInit(options, deps) {
   const existingConfig = findConfigFile(options.cwd);
   const plan = planInit({
-    agents: await readIfPresent(join8(options.cwd, "AGENTS.md")),
+    agents: await readIfPresent(join9(options.cwd, "AGENTS.md")),
     config: existingConfig === null ? null : "present",
-    gitignore: await readIfPresent(join8(options.cwd, ".gitignore")),
+    gitignore: await readIfPresent(join9(options.cwd, ".gitignore")),
     force: options.force
   });
   const touched = [];
   for (const write of plan.writes) {
-    await writeFile4(join8(options.cwd, write.path), write.contents, "utf8");
+    await writeFile5(join9(options.cwd, write.path), write.contents, "utf8");
     touched.push(write.path);
   }
   if (plan.gitignore !== null) {
-    await writeFile4(join8(options.cwd, ".gitignore"), plan.gitignore, "utf8");
+    await writeFile5(join9(options.cwd, ".gitignore"), plan.gitignore, "utf8");
     touched.push(".gitignore");
   }
   if (options.json) {
@@ -1761,8 +2667,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 join9 } from "path";
+import { mkdir as mkdir5, readFile as readFile7, rm as rm2, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname6, join as join10 } from "path";
 
 // src/keep.ts
 import { basename as basename2, extname as extname2, normalize as normalize2 } from "path";
@@ -1861,18 +2767,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 = join9(options.cwd, plan.move.from);
-  const to = join9(options.cwd, plan.move.to);
+  const from = join10(options.cwd, plan.move.from);
+  const to = join10(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(join9(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(join10(options.cwd, plan.removeDir), { recursive: true, force: true });
   const dropped = await dropLocalPreviews(options.cwd, plan.dropTitles);
   if (options.json) {
     deps.log(
@@ -1907,11 +2813,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 join10 } from "path";
+import { mkdir as mkdir6, readFile as readFile8, writeFile as writeFile7 } from "fs/promises";
+import { dirname as dirname7, join as join11 } from "path";
 async function readIfPresent2(path) {
   try {
-    return await readFile7(path, "utf8");
+    return await readFile8(path, "utf8");
   } catch {
     return null;
   }
@@ -1919,7 +2825,7 @@ async function readIfPresent2(path) {
 async function runNew(options, deps) {
   let from;
   if (options.from !== void 0) {
-    const contents = await readIfPresent2(join10(options.cwd, options.from));
+    const contents = await readIfPresent2(join11(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 }));
@@ -1930,8 +2836,8 @@ async function runNew(options, deps) {
   }
   const plan = planNew({
     surface: options.surface,
-    packageJson: await readIfPresent2(join10(options.cwd, "package.json")),
-    gitignore: await readIfPresent2(join10(options.cwd, ".gitignore")),
+    packageJson: await readIfPresent2(join11(options.cwd, "package.json")),
+    gitignore: await readIfPresent2(join11(options.cwd, ".gitignore")),
     from
   });
   const fail = (error) => {
@@ -1954,19 +2860,19 @@ async function runNew(options, deps) {
     deps.log(plan.instructions);
     return { exitCode: 0, written: [] };
   }
-  const existing = plan.writes.filter((write) => existsSync4(join10(options.cwd, write.path)));
+  const existing = plan.writes.filter((write) => existsSync4(join11(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 = join10(options.cwd, write.path);
-    await mkdir5(dirname6(target), { recursive: true });
-    await writeFile6(target, write.contents, "utf8");
+    const target = join11(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(join10(options.cwd, ".gitignore"), plan.gitignore, "utf8");
+    await writeFile7(join11(options.cwd, ".gitignore"), plan.gitignore, "utf8");
     written.push(".gitignore");
   }
   if (options.json) {
@@ -1987,21 +2893,21 @@ async function runNew(options, deps) {
 }
 
 // src/run-previews.ts
-import { readFile as readFile8, writeFile as writeFile7 } from "fs/promises";
-import { join as join11 } from "path";
+import { readFile as readFile9, writeFile as writeFile8 } from "fs/promises";
+import { join as join12 } from "path";
 function envelope(deps, ok, body) {
   deps.log(JSON.stringify({ ok, ...body }));
 }
 async function ensureIgnored(cwd) {
-  const path = join11(cwd, ".gitignore");
+  const path = join12(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);
@@ -2246,100 +3152,24 @@ async function runShow(options, deps) {
 }
 
 // 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 join12 } from "path";
-
-// src/watch.ts
-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}` };
-  }
-  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
-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 join13 } from "path";
+var POLL_MS2 = 2e3;
 var HEARTBEAT_TIMEOUT_MS = 1e3;
-async function readSavedTemplate(cwd) {
+async function saveTemplate(cwd, run3) {
+  const path = join13(cwd, WATCH_PATH);
+  let config = {};
   try {
-    const raw = await readFile9(join12(cwd, WATCH_PATH), "utf8");
-    const parsed2 = JSON.parse(raw);
-    return typeof parsed2.run === "string" && parsed2.run !== "" ? parsed2.run : null;
+    const parsed2 = JSON.parse(await readFile10(path, "utf8"));
+    if (typeof parsed2 === "object" && parsed2 !== null && !Array.isArray(parsed2)) {
+      config = parsed2;
+    }
   } catch {
-    return null;
   }
-}
-async function saveTemplate(cwd, run3) {
-  const path = join12(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) {
@@ -2350,7 +3180,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",
@@ -2361,21 +3191,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 parsed2 = parseTemplate(raw);
+    if (!parsed2.ok) {
+      deps.error(parsed2.error);
+      return { exitCode: 1 };
+    }
+    template = parsed2.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: npx 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 parsed2 = parseTemplate(raw);
-  if (!parsed2.ok) {
-    deps.error(parsed2.error);
-    return { exitCode: 1 };
-  }
-  const template = parsed2.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) => {
@@ -2389,11 +3232,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("");
@@ -2415,7 +3262,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 {
@@ -2432,7 +3284,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;
@@ -2452,14 +3304,14 @@ async function runWatch(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 relative3 } 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;
   }
@@ -2493,7 +3345,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.`
@@ -2504,7 +3356,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))}`
@@ -2565,7 +3417,7 @@ async function run2(options, deps) {
       })
     );
   } else {
-    const configLabel = loaded.path === null ? "no config file, previewing the app root" : relative3(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)"}`
@@ -2659,7 +3511,7 @@ function version() {
 async function openBrowser(url) {
   const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
   try {
-    spawn3(command, [url], { detached: true, stdio: "ignore" }).unref();
+    spawn4(command, [url], { detached: true, stdio: "ignore" }).unref();
   } catch {
   }
 }