@cychien/ezdesign 0.9.2 → 0.11.0

package/dist/cli.mjs

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { readFileSync as readFileSync16 } from "node:fs";
-import { dirname as dirname11, join as join22, resolve as resolve5 } from "node:path";
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { readFileSync as readFileSync21 } from "node:fs";
+import { dirname as dirname11, join as join27, resolve as resolve6 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import open2, { apps } from "open";
 
@@ -30,6 +31,10 @@ var NO_UPDATE_CHECK_ENV = `${ENV_PREFIX}_NO_UPDATE_CHECK`;
 var DESIGN_HARNESS_ENV = `${ENV_PREFIX}_DESIGN_HARNESS`;
 var API_URL_ENV = `${ENV_PREFIX}_API_URL`;
 var NO_IDLE_STOP_ENV = `${ENV_PREFIX}_NO_IDLE_STOP`;
+var PROJECTS_FILE = join(DATA_DIR, "projects.json");
+var HOME_PATH = `${URL_PREFIX}/home`;
+var LOGIN_ENV_VAR = `${ENV_PREFIX}_LOGIN_ENV`;
+var LOGIN_ENV_CACHE = join(DATA_DIR, "login-env.json");
 function envFlagOn(raw) {
   return raw !== void 0 && raw !== "" && raw !== "0" && raw.toLowerCase() !== "false";
 }
@@ -138,7 +143,6 @@ function controlPortRange() {
 function assertControlPortEnv() {
   controlPortRange();
 }
-var MAX_ATTACHMENT_BYTES = 8 * 1024 * 1024;
 var ATTACHMENT_GRACE_MS = 24 * 60 * 6e4;
 var UPDATE_CHECK_TTL_MS = 4 * 60 * 6e4;
 var POLL_TIMEOUT_MS = 5e4;
@@ -147,6 +151,10 @@ var IDLE_STOP_MS = 30 * 6e4;
 var IDLE_CHECK_MS = 6e4;
 var SHELL_RETRY_MS = 1e3;
 var SHELL_RETURN_MS = 2e3;
+var DEV_SERVER_READY_MS = 6e4;
+var DEV_SERVER_PORT_SCAN_AFTER_MS = 3e3;
+var DEV_SERVER_STOP_GRACE_MS = 3e3;
+var DEV_SERVER_LOG_LINES = 2e3;
 
 // src/shell-quote.ts
 function shellQuote(arg) {
@@ -233,6 +241,7 @@ var Request = z.discriminatedUnion("t", [
     capture: CaptureId,
     kind: z.enum(["image", "video"]),
     url: HttpUrl,
+    as: z.enum(["file", "hls"]).optional(),
     referer: z.string().max(16384).nullable(),
     userAgent: z.string().max(1024),
     context: CaptureContext
@@ -244,7 +253,7 @@ var Request = z.discriminatedUnion("t", [
     t: z.literal("upload"),
     id: RequestId,
     capture: CaptureId,
-    kind: z.enum(["image", "screenshot", "frame"]),
+    kind: z.enum(["image", "screenshot", "frame", "video"]),
     size: z.number().int().nonnegative(),
     context: CaptureContext
   }),
@@ -290,6 +299,13 @@ var Request = z.discriminatedUnion("t", [
     exclude: z.array(z.string().max(256)).max(200),
     limit: z.number().int().min(1).max(50)
   }),
+  z.object({
+    t: z.literal("probe"),
+    id: RequestId,
+    sources: z.array(z.object({ url: HttpUrl, as: z.enum(["file", "hls"]) })).min(1).max(20),
+    referer: z.string().max(16384).nullable(),
+    userAgent: z.string().max(1024)
+  }),
   /** Aborts the request `ref` (a `download` or `read`), which then fails `cancelled`. */
   z.object({ t: z.literal("cancel"), ref: RequestId })
 ]);
@@ -324,7 +340,11 @@ var ReplyValue = {
   read: z.object({ bytes: z.number().int().nonnegative() }),
   commit: z.object({ item: WireItem, merged: z.boolean() }),
   discard: Done,
-  suggest: z.object({ tags: z.array(z.object({ name: z.string(), uses: z.number().int() })).max(50) })
+  suggest: z.object({ tags: z.array(z.object({ name: z.string(), uses: z.number().int() })).max(50) }),
+  probe: z.object({
+    durations: z.array(z.number().nonnegative().nullable()),
+    masters: z.array(z.boolean())
+  })
 };
 var WireError = z.discriminatedUnion("code", [
   /** The ranges do not meet. `host` lets the extension say which side is old. */
@@ -369,6 +389,24 @@ function writeAtomic(path, data, mode) {
   renameSync(temp, path);
 }
 
+// src/self-node.ts
+var RUN_AS_NODE = "ELECTRON_RUN_AS_NODE";
+var onElectron = Boolean(process.versions.electron) || process.env[RUN_AS_NODE] === "1";
+var SELF_NODE = {
+  execPath: process.execPath,
+  env: onElectron ? { [RUN_AS_NODE]: "1" } : {}
+};
+function scrubRunAsNode(env = process.env) {
+  delete env[RUN_AS_NODE];
+}
+function selfNodeCommandLine(args, runtime = SELF_NODE) {
+  const env = Object.entries(runtime.env).map(([k, v]) => `${k}=${shellQuote(v)}`);
+  return [...env, ...[runtime.execPath, ...args].map(shellQuote)].join(" ");
+}
+function selfNodeEnv(base = process.env, runtime = SELF_NODE) {
+  return { ...base, ...runtime.env };
+}
+
 // src/update-check.ts
 import { mkdirSync, readFileSync, writeFileSync as writeFileSync2 } from "node:fs";
 import { dirname } from "node:path";
@@ -538,9 +576,10 @@ function chooseHostNode(current, recorded) {
 }
 function hostWrapperScript(options) {
   const q = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
+  const env = Object.entries(options.nodeEnv ?? {}).map(([k, v]) => `${k}=${q(v)} `).join("");
   return [
     "#!/bin/sh",
-    `EZDESIGN_DATA_DIR=${q(options.dataDir)} exec ${q(options.node)} ${q(options.host)} "$@"`,
+    `${env}EZDESIGN_DATA_DIR=${q(options.dataDir)} exec ${q(options.node)} ${q(options.host)} "$@"`,
     ""
   ].join("\n");
 }
@@ -567,8 +606,8 @@ function resolvePlacement(options) {
 }
 function probeNode(path) {
   if (path === process.execPath) return { path, version: process.version };
-  const run2 = spawnSync(path, ["-p", "process.version"], { encoding: "utf8", timeout: 1e4, env: {} });
-  const version = run2.status === 0 ? run2.stdout.trim() : "";
+  const run4 = spawnSync(path, ["-p", "process.version"], { encoding: "utf8", timeout: 1e4, env: { [RUN_AS_NODE]: "1" } });
+  const version = run4.status === 0 ? run4.stdout.trim() : "";
   return { path, version: /^v\d+\.\d+\.\d+/.test(version) ? version : null };
 }
 async function installCapture(options) {
@@ -593,7 +632,8 @@ async function installCapture(options) {
   mkdirSync3(at.hostDir, { recursive: true });
   const host = join4(at.hostDir, HOST_BUNDLE);
   writeAtomic(host, readFileSync3(bundle));
-  writeAtomic(at.wrapper, hostWrapperScript({ node: choice.node.path, host, dataDir: at.dataDir }), 493);
+  const nodeEnv = choice.node.path === SELF_NODE.execPath ? SELF_NODE.env : {};
+  writeAtomic(at.wrapper, hostWrapperScript({ node: choice.node.path, host, dataDir: at.dataDir, nodeEnv }), 493);
   const extensionGeneration = installExtension(join4(options.distDir, "extension"), at.extensionDir);
   const manifest = `${JSON.stringify(hostManifest(at.wrapper, ALLOWED_ORIGINS), null, 2)}
 `;
@@ -783,13 +823,13 @@ function forget(key, file) {
 }
 
 // src/daemon.ts
-import { createHash as createHash8, randomBytes as randomBytes8, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+import { createHash as createHash8, randomBytes as randomBytes10, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
 import { EventEmitter } from "node:events";
-import { accessSync, constants, mkdirSync as mkdirSync16, readFileSync as readFileSync14, statSync as statSync4 } from "node:fs";
+import { mkdirSync as mkdirSync17, readFileSync as readFileSync19, statSync as statSync8 } from "node:fs";
 import { createServer } from "node:http";
-import { delimiter, dirname as dirname8, join as join19 } from "node:path";
+import { dirname as dirname9, join as join25 } from "node:path";
 import { fileURLToPath } from "node:url";
-import express3, { Router as Router6 } from "express";
+import express4, { Router as Router8 } from "express";
 
 // src/app-proxy.ts
 import {
@@ -818,6 +858,23 @@ var MAX_FRAME_TITLE = 80;
 var DEFAULT_FRAME_WIDTH = 1280;
 var MIN_FRAME_SIZE = { width: 240, height: 240 };
 var MAX_FRAME_SIZE = { width: 3840, height: 12e3 };
+var MAX_IMAGE_BYTES = 20 * 1024 * 1024;
+var IMAGE_TYPES = {
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/gif": "gif",
+  "image/webp": "webp",
+  "image/avif": "avif",
+  "image/svg+xml": "svg"
+};
+var ASSET_SHAPE = new RegExp(`^[0-9a-f]{12}\\.(${Object.values(IMAGE_TYPES).join("|")})$`);
+function asAssetName(raw) {
+  return typeof raw === "string" && ASSET_SHAPE.test(raw) ? raw : null;
+}
+function mimeOfAsset(name) {
+  const ext = name.slice(name.indexOf(".") + 1);
+  return Object.keys(IMAGE_TYPES).find((mime) => IMAGE_TYPES[mime] === ext);
+}
 
 // src/canvas/frame-document.ts
 var FRAME_HOST = "localhost";
@@ -825,6 +882,24 @@ var FRAME_ROUTE = "/frames";
 function frameUrl(frameOrigin, canvasId2, frameId2, hash) {
   return `${frameOrigin}${URL_PREFIX}${FRAME_ROUTE}/${canvasId2}/${frameId2}?rev=${hash}`;
 }
+var ASSETS_DIR = "frames/assets";
+function imageFrameHtml(title, asset2) {
+  const text = title.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/"/g, "&quot;");
+  return [
+    "<!doctype html>",
+    "<html>",
+    "<head>",
+    '<meta charset="utf-8">',
+    `<title>${text}</title>`,
+    "<style>html,body{margin:0;height:100%}img{display:block;width:100%;height:100%;object-fit:contain}</style>",
+    "</head>",
+    "<body>",
+    `<img src="assets/${asset2}" alt="${text}">`,
+    "</body>",
+    "</html>",
+    ""
+  ].join("\n");
+}
 function isFrameHost(host) {
   if (!host) return false;
   return host.replace(/:\d+$/, "").toLowerCase() === FRAME_HOST;
@@ -946,16 +1021,47 @@ function wantsHtml(accept) {
 // src/app-proxy.ts
 var NO_APP = `<!doctype html><meta charset="utf-8"><title>ezdesign</title>
 <p>No dev server is attached to this review. Run <code>ezdesign &lt;url&gt;</code> in the project to attach one.</p>`;
+var UNREACHABLE_HEADER = "x-ezdesign-unreachable";
+var unreachable = (origin) => `<!doctype html><meta charset="utf-8"><title>\u9023\u4E0D\u4E0A App</title>
+<style>
+  /* The shell's dev-server prompt, in its tokens' values: this page is served without the shell's CSS. */
+  body { margin: 0; background: #faf9f6; -webkit-font-smoothing: antialiased;
+    color: #171717; font: 13.5px/1.55 -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Noto Sans TC', sans-serif; }
+  main { display: grid; width: min(520px, calc(100% - 48px)); margin: max(48px, 12vh) auto 48px; }
+  h1 { margin: 0; font-size: 16px; font-weight: 600; line-height: 1.4; }
+  p { margin: 6px 0 18px; color: #676767; }
+  code { font: 12.5px ui-monospace, SFMono-Regular, Menlo, monospace; }
+  button { justify-self: start; height: 32px; padding: 0 14px; border: 1px solid #171717; border-radius: 7px;
+    background: #171717; color: #fff; box-shadow: inset 0 1px 0 0 rgb(255 255 255 / 0.14);
+    font: 600 13px -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Noto Sans TC', sans-serif; cursor: pointer; }
+  button:hover { opacity: 0.88; }
+</style>
+<main>
+<h1>\u9023\u4E0D\u4E0A App</h1>
+<p><code>${origin.replace(/^https?:\/\//, "")}</code> \u6C92\u6709\u56DE\u61C9\uFF0Cdev server \u53EF\u80FD\u505C\u4E86\u3002</p>
+<button type="button" onclick="location.reload()">\u91CD\u65B0\u6574\u7406</button>
+</main>
+<script>
+  setInterval(() => fetch(location.href, { method: 'HEAD', cache: 'no-store' })
+    .then((r) => { if (!r.headers.has('${UNREACHABLE_HEADER}')) location.reload() }, () => {}), 1500)
+</script>`;
 var AppProxy = class {
   constructor(shellPath, onRequest) {
     this.shellPath = shellPath;
     this.onRequest = onRequest;
     const router = () => this.current.kind === "attached" ? this.current.origin : void 0;
+    const error = (_err, req, res) => {
+      if (!("writeHead" in res) || res.headersSent) return void res.end();
+      const origin = this.current.kind === "attached" ? this.current.origin : "";
+      res.writeHead(502, { "content-type": wantsHtml(req.headers.accept) ? "text/html; charset=utf-8" : "text/plain", [UNREACHABLE_HEADER]: "1" });
+      res.end(wantsHtml(req.headers.accept) ? unreachable(origin) : "");
+    };
     this.htmlProxy = createProxyMiddleware({
       router,
       changeOrigin: true,
       selfHandleResponse: true,
       on: {
+        error,
         proxyRes: responseInterceptor(async (buffer, proxyRes, _req, res) => {
           res.removeHeader("content-security-policy");
           res.removeHeader("x-frame-options");
@@ -965,7 +1071,7 @@ var AppProxy = class {
         })
       }
     });
-    this.rawProxy = createProxyMiddleware({ router, changeOrigin: true, ws: true });
+    this.rawProxy = createProxyMiddleware({ router, changeOrigin: true, ws: true, on: { error } });
   }
   current = { kind: "none" };
   upgraded = /* @__PURE__ */ new Set();
@@ -1101,7 +1207,7 @@ var CANVAS_TOOLS = {
       "Add one frame to an open canvas: a complete, self-contained HTML document (<!doctype html>, its own <head> and styles) rendered in its own iframe at a real viewport width.",
       "Scripts and CDN assets are allowed. No CSS is shared between frames.",
       "width is the viewport width the page is designed for (390 phone, 768 tablet, 1280 desktop; default 1280); height defaults to a common screen for that width.",
-      "Leave position out unless the user asked for a particular arrangement: the frame is then placed where it overlaps nothing, the frames of one turn side by side in the order you add them, in a row under the earlier ones. After creation a frame's position is the user's, and its size never changes: pick width and height here.",
+      "Leave position out unless the user asked for a particular arrangement: the frame is then placed where it overlaps nothing, the frames of one turn side by side in the order you add them, in a row under the earlier ones. After creation a frame's position is the user's and its width is fixed; its height can follow its content through update_frame.",
       "Call once per frame, as soon as it is ready: the user watches frames appear."
     ].join("\n"),
     input: {
@@ -1128,16 +1234,18 @@ var CANVAS_TOOLS = {
   }),
   update_frame: tool({
     description: [
-      "Replace a frame's HTML document and/or retitle it.",
+      "Replace a frame's HTML document, retitle it, and/or change its height.",
       "Pass expectedHash - the hash read_canvas, add_frame or your last update_frame returned - so an edit you have not seen is never overwritten: if the file changed since, nothing is written and the error names its current hash.",
       "For a small change you may instead edit the frame's file directly; the user's canvas updates either way.",
-      "A frame's position belongs to the user and its size is fixed when it is added; neither can be changed here."
+      "Pass height whenever the content needs a taller or shorter frame; frames below it move down to make room. Never remove a frame and add it again to resize it: that loses its place and the annotations made on it.",
+      "A frame's position belongs to the user and its width is the viewport it was designed for; neither can be changed here."
     ].join("\n"),
     input: {
       canvasId,
       frameId,
       html: z2.string().optional().describe("The new complete HTML document."),
       title: z2.string().optional().describe("A new label for the frame."),
+      height: px("A new viewport height in CSS px, to fit the content."),
       expectedHash: z2.string().optional().describe("The hash of the version you are replacing.")
     },
     run: (port, args) => map(
@@ -1146,9 +1254,10 @@ var CANVAS_TOOLS = {
         frameId: args.frameId,
         ...args.html !== void 0 ? { html: args.html } : {},
         ...args.title !== void 0 ? { title: args.title } : {},
+        ...args.height !== void 0 ? { height: args.height } : {},
         ...args.expectedHash !== void 0 ? { expectedHash: args.expectedHash } : {}
       }),
-      (f) => ({ frameId: f.id, file: f.file, hash: f.hash })
+      listing
     )
   }),
   remove_frame: tool({
@@ -1163,8 +1272,8 @@ function isCanvasTool(permissionName) {
   return permissionName.startsWith(prefix) && CANVAS_TOOL_NAMES.includes(permissionName.slice(prefix.length));
 }
 function runCanvasTool(port, name, args) {
-  const run2 = CANVAS_TOOLS[name].run;
-  const outcome = run2(port, args);
+  const run4 = CANVAS_TOOLS[name].run;
+  const outcome = run4(port, args);
   if (!outcome.ok) return { isError: true, content: [{ type: "text", text: canvasProblemMessage(outcome.problem) }] };
   const value = outcome.value;
   return { content: [{ type: "text", text: JSON.stringify(value) }], structuredContent: value };
@@ -1220,7 +1329,7 @@ var CanvasMcp = class {
         server.registerTool(
           name,
           // Strict, so `x` or `width` on an existing frame is refused rather than
-          // silently ignored: a frame's position is the user's, its size fixed.
+          // silently ignored: a frame's position is the user's, its width fixed.
           { description: spec.description, inputSchema: z2.object(spec.input).strict() },
           (args) => runCanvasTool(this.port, name, args)
         );
@@ -1258,6 +1367,11 @@ function canvasProblemMessage(problem) {
       return `BAD_NAME: give a non-empty name of at most ${problem.max} characters.`;
     case "BAD_RECT":
       return `BAD_RECT: ${problem.reason}`;
+    case "IMAGE_UNSUPPORTED":
+    case "IMAGE_TOO_LARGE":
+    case "IMAGE_EMPTY":
+    case "ASSET_NOT_FOUND":
+      return `${problem.code}: only the user pastes images onto a canvas.`;
   }
 }
 
@@ -1290,7 +1404,7 @@ function canvasBrief(input) {
     `The review shell has these tabs: ${tabs.join(", ") || "none"}.` + (shownArchived.length ? ` Archived: ${shownArchived.map((c) => `"${c.name}" (${c.id})`).join(", ")}.` : "") + (more > 0 ? ` ${more} more: call list_canvases.` : ""),
     ...where ? [where] : [],
     `Items with anchor.frame were made inside a canvas frame; anchor.source is then a line of that frame's file under ${CANVASES_DIR}/.`,
-    "A frame's HTML is yours: change it with update_frame or by editing that file. Its position is the user's, and its size is fixed when it is added. Never edit canvas.json or layout.json.",
+    "A frame's HTML is yours: change it with update_frame or by editing that file. Its position is the user's and its width is fixed; when the content needs a different height, pass height to update_frame rather than adding the frame again. Never edit canvas.json or layout.json.",
     `To show the user designs, mockups or alternatives side by side, put each one in a frame on a canvas. Canvas tools (${CANVAS_SERVER_NAME}): ${CANVAS_TOOL_NAMES.join(", ")}.`,
     target ? `Add new frames to canvas "${target.name}" (${target.id}). Call create_canvas only when the user asks for a new canvas or this one is full.` : "No canvas is open: create one with create_canvas for new frames.",
     ""
@@ -1298,7 +1412,7 @@ function canvasBrief(input) {
 }
 
 // src/canvas/routes.ts
-import { Router } from "express";
+import express2, { Router } from "express";
 function problemText(problem) {
   switch (problem.code) {
     case "CANVAS_NOT_FOUND":
@@ -1321,19 +1435,32 @@ function problemText(problem) {
       return `a name is 1 to ${problem.max} characters`;
     case "BAD_RECT":
       return `bad frame geometry: ${problem.reason}`;
+    case "IMAGE_UNSUPPORTED":
+      return `${problem.mime || "this file"} is not an image a frame can show`;
+    case "IMAGE_TOO_LARGE":
+      return `the image is ${problem.bytes} bytes; the limit is ${problem.limit}`;
+    case "IMAGE_EMPTY":
+      return "the image is empty";
+    case "ASSET_NOT_FOUND":
+      return `no image ${problem.asset} on canvas ${problem.canvasId}`;
   }
 }
 function statusOf(problem) {
   switch (problem.code) {
     case "CANVAS_NOT_FOUND":
     case "FRAME_NOT_FOUND":
+    case "ASSET_NOT_FOUND":
       return 404;
     case "CANVAS_ARCHIVED":
     case "FRAME_CONFLICT":
       return 409;
     case "HTML_TOO_LARGE":
+    case "IMAGE_TOO_LARGE":
       return 413;
+    case "IMAGE_UNSUPPORTED":
+      return 415;
     case "HTML_EMPTY":
+    case "IMAGE_EMPTY":
     case "NOT_A_DOCUMENT":
     case "TOO_MANY_FRAMES":
     case "BAD_NAME":
@@ -1411,6 +1538,31 @@ function parseDuplicate(raw) {
   if (!source || !copy || at === null) return null;
   return { from: source, id: copy, ...at ? { at } : {} };
 }
+function rect(raw) {
+  const at = point(raw);
+  const { width, height } = raw ?? {};
+  return at && finite(width) && finite(height) ? { ...at, width, height } : null;
+}
+function parseImageFrame(raw) {
+  if (typeof raw !== "object" || raw === null) return null;
+  const { id: rawId, asset: rawAsset, title, rect: rawRect } = raw;
+  const id = asFrameId(rawId);
+  const asset2 = asAssetName(rawAsset);
+  const at = rect(rawRect);
+  if (!id || !asset2 || !at || typeof title !== "string") return null;
+  return { id, asset: asset2, title, rect: at };
+}
+var rawImage = express2.raw({ type: () => true, limit: MAX_IMAGE_BYTES });
+function receiveImage(req, res, then) {
+  if (Number(req.get("content-length")) > MAX_IMAGE_BYTES) {
+    return void res.status(413).json({ error: "the image is too large", code: "IMAGE_TOO_LARGE" });
+  }
+  rawImage(req, res, (err) => {
+    if (!err) return then(Buffer.isBuffer(req.body) ? req.body : Buffer.alloc(0));
+    const status = err.status === 413 ? 413 : 400;
+    res.status(status).json({ error: status === 413 ? "the image is too large" : "unreadable image body" });
+  });
+}
 function canvasApiRouter(host) {
   const api = Router();
   const { user, read: read4 } = host;
@@ -1440,15 +1592,28 @@ function canvasApiRouter(host) {
     answer(res, user.delete(req.params.canvasId), () => ({ ok: true }));
   });
   api.post("/canvases/:canvasId/ops", (req, res) => {
-    const step = parseLayoutStep(req.body);
-    if (!step) return res.status(400).json({ error: "not a layout step" });
-    answer(res, user.applyLayoutOps(req.params.canvasId, step), (wire) => wire);
+    const step2 = parseLayoutStep(req.body);
+    if (!step2) return res.status(400).json({ error: "not a layout step" });
+    answer(res, user.applyLayoutOps(req.params.canvasId, step2), (wire) => wire);
   });
   api.post("/canvases/:canvasId/frames", (req, res) => {
     const input = parseDuplicate(req.body);
     if (!input) return res.status(400).json({ error: "not a duplicate" });
     answer(res, user.duplicate(req.params.canvasId, input), (wire) => wire);
   });
+  api.post("/canvases/:canvasId/assets", (req, res) => {
+    const mime = (req.get("content-type") ?? "").split(";")[0].trim().toLowerCase();
+    receiveImage(
+      req,
+      res,
+      (bytes) => answer(res, user.addAsset(req.params.canvasId, mime, bytes), (asset2) => ({ asset: asset2 }))
+    );
+  });
+  api.post("/canvases/:canvasId/image-frames", (req, res) => {
+    const input = parseImageFrame(req.body);
+    if (!input) return res.status(400).json({ error: "not an image frame" });
+    answer(res, user.addImageFrame(req.params.canvasId, input), (wire) => wire);
+  });
   api.put("/view", (req, res) => {
     const view = parseView(req.body);
     if (!view) return res.status(400).json({ error: "not a view" });
@@ -1467,6 +1632,20 @@ function frameHost(read4, shellOrigin) {
     }
     const [canvasRaw, frameRaw, extra] = framePath ? req.path.slice(FRAMES_PATH.length).split("/") : [];
     const canvasId2 = asCanvasId(canvasRaw);
+    const assetName = frameRaw === "assets" ? asAssetName(extra) : null;
+    const image = req.method === "GET" && canvasId2 && assetName ? read4.asset(canvasId2, assetName) : null;
+    if (image) {
+      res.sendFile(image.path, {
+        // The project's `.ezdesign/` is a dot directory.
+        dotfiles: "allow",
+        headers: {
+          "content-type": image.mime,
+          "cache-control": "public, max-age=31536000, immutable",
+          "x-content-type-options": "nosniff"
+        }
+      });
+      return;
+    }
     const frameId2 = asFrameId(frameRaw);
     const doc = req.method === "GET" && canvasId2 && frameId2 && extra === void 0 ? read4.frameDocument(canvasId2, frameId2) : null;
     if (!doc) {
@@ -1526,12 +1705,27 @@ function normalizeRect(raw) {
     height: clamp(Math.round(raw.height), MIN_FRAME_SIZE.height, MAX_FRAME_SIZE.height)
   };
 }
+function growDown(rect3, height, others) {
+  const next = normalizeRect({ ...rect3, height });
+  const growth = next.height - rect3.height;
+  if (growth <= 0) return { rect: next, moved: [] };
+  const spanned = (a, b) => a.x < b.x + b.width && b.x < a.x + a.width;
+  const pushers = [rect3];
+  const moved = [];
+  const below = others.filter(([, r]) => r.y >= rect3.y + rect3.height).sort((a, b) => a[1].y - b[1].y);
+  for (const [id, r] of below) {
+    if (!pushers.some((p) => spanned(p, r))) continue;
+    pushers.push(r);
+    moved.push([id, { ...r, y: r.y + growth }]);
+  }
+  return { rect: next, moved };
+}
 function freeAlongRow(from, size, existing, limit) {
   let x = from.x;
   for (; ; ) {
     if (x + size.width > limit) return null;
-    const rect2 = { x, y: from.y, width: size.width, height: size.height };
-    const hits = existing.filter((r) => overlaps(rect2, r));
+    const rect3 = { x, y: from.y, width: size.width, height: size.height };
+    const hits = existing.filter((r) => overlaps(rect3, r));
     if (!hits.length) return { x, y: from.y };
     x = Math.max(...hits.map((r) => r.x + r.width + GAP));
   }
@@ -1582,12 +1776,12 @@ var FrameFileWatcher = class {
   }
   /** `<canvasId>/frames/<frameId>.html`, both ids through `asCanvasId` /
    *  `asFrameId`; anything else - temp files, manifests, dotfiles - ignored. */
-  schedule(relative) {
-    if (relative === null) return;
-    const parts = String(relative).split(/[\\/]/);
-    if (parts.length !== 3 || parts[1] !== "frames") return;
-    const canvasId2 = asCanvasId(parts[0]);
-    const file = /^(.*)\.html$/.exec(parts[2]);
+  schedule(relative3) {
+    if (relative3 === null) return;
+    const parts2 = String(relative3).split(/[\\/]/);
+    if (parts2.length !== 3 || parts2[1] !== "frames") return;
+    const canvasId2 = asCanvasId(parts2[0]);
+    const file = /^(.*)\.html$/.exec(parts2[2]);
     const frameId2 = file ? asFrameId(file[1]) : null;
     if (!canvasId2 || !frameId2) return;
     const key = `${canvasId2}/${frameId2}`;
@@ -1682,8 +1876,10 @@ var Workspace = class {
       archive: (canvasId2) => this.archive(canvasId2),
       reopen: (canvasId2) => this.reopen(canvasId2),
       delete: (canvasId2) => this.delete(canvasId2),
-      applyLayoutOps: (canvasId2, step) => this.applyLayoutOps(canvasId2, step),
+      applyLayoutOps: (canvasId2, step2) => this.applyLayoutOps(canvasId2, step2),
       duplicate: (canvasId2, input) => this.duplicate(canvasId2, input),
+      addAsset: (canvasId2, mime, bytes) => this.addAsset(canvasId2, mime, bytes),
+      addImageFrame: (canvasId2, input) => this.addImageFrame(canvasId2, input),
       setView: (view) => this.setView(view)
     };
   }
@@ -1703,7 +1899,11 @@ var Workspace = class {
         const frame = this.liveFrame(ref.canvasId, ref.frameId);
         return held && frame ? { canvas: held.manifest.name, frame: frame.title } : null;
       },
-      frameDocument: (canvasId2, frameId2) => this.frameDocument(canvasId2, frameId2)
+      frameDocument: (canvasId2, frameId2) => this.frameDocument(canvasId2, frameId2),
+      asset: (canvasId2, name) => {
+        const path = join6(this.dir(canvasId2), ASSETS_DIR, name);
+        return this.canvases.has(canvasId2) && existsSync5(path) ? { path, mime: mimeOfAsset(name) } : null;
+      }
     };
   }
   // ---------------------------------------------------------------- lifecycle
@@ -1899,14 +2099,30 @@ var Workspace = class {
       return;
     }
     const old = this.now() - UNNAMED_FILE_GRACE_MS;
-    for (const name of files) {
-      if (named.has(`frames/${name}`)) continue;
-      const path = join6(framesDir, name);
+    const unlinkOld = (path) => {
       try {
         if (statSync(path).mtimeMs < old) unlinkSync(path);
       } catch {
       }
+    };
+    for (const name of files) {
+      if (named.has(`frames/${name}`) || `frames/${name}` === ASSETS_DIR) continue;
+      unlinkOld(join6(framesDir, name));
+    }
+    const shown = /* @__PURE__ */ new Set();
+    for (const frame of held.manifest.frames) {
+      try {
+        const html = readFileSync5(join6(this.dir(held.manifest.id), frame.file), "utf8");
+        for (const m of html.matchAll(/assets\/([0-9a-f]{12}\.\w+)/g)) shown.add(m[1]);
+      } catch {
+      }
+    }
+    let assets = [];
+    try {
+      assets = readdirSync2(join6(this.dir(held.manifest.id), ASSETS_DIR));
+    } catch {
     }
+    for (const name of assets) if (!shown.has(name)) unlinkOld(join6(this.dir(held.manifest.id), ASSETS_DIR, name));
   }
   frameDocument(canvasId2, frameId2) {
     const held = this.canvases.get(canvasId2);
@@ -2064,16 +2280,16 @@ var Workspace = class {
     return ok(void 0);
   }
   // ----------------------------------------------------------- board edits
-  applyLayoutOps(canvasId2, step) {
+  applyLayoutOps(canvasId2, step2) {
     const writable = this.writable(canvasId2);
     if (!writable.ok) return writable;
     const held = writable.value;
     const id = held.manifest.id;
-    if (held.recentOps.includes(step.opId)) return ok(this.wire(id));
+    if (held.recentOps.includes(step2.opId)) return ok(this.wire(id));
     let movedRects = false;
     let movedFrames = false;
     const live3 = (frameId2) => held.manifest.frames.find((f) => f.id === frameId2 && f.deletedAt === void 0);
-    for (const op of step.ops) {
+    for (const op of step2.ops) {
       if (op.t === "move") {
         for (const { id: frameId2, x, y } of op.frames) {
           const was = held.layout.rects[frameId2];
@@ -2101,7 +2317,7 @@ var Workspace = class {
     }
     if (movedRects) this.writeLayout(held);
     if (movedFrames) this.writeManifest(held);
-    held.recentOps = [...held.recentOps, step.opId].slice(-RECENT_OPS);
+    held.recentOps = [...held.recentOps, step2.opId].slice(-RECENT_OPS);
     if (movedRects || movedFrames) this.opts.onChange({ kind: "updated", canvasId: id });
     return ok(this.wire(id));
   }
@@ -2125,10 +2341,10 @@ var Workspace = class {
     }
     const sourceRect = held.layout.rects[source.id] ?? NO_RECT;
     const at = input.at ?? placeBeside(sourceRect, live3.map((f) => held.layout.rects[f.id] ?? NO_RECT));
-    const rect2 = normalizeRect({ ...at, width: sourceRect.width, height: sourceRect.height });
+    const rect3 = normalizeRect({ ...at, width: sourceRect.width, height: sourceRect.height });
     const file = `frames/${input.id}.html`;
     writeAtomic(join6(this.dir(id), file), bytes.toString("utf8"));
-    held.layout.rects[input.id] = rect2;
+    held.layout.rects[input.id] = rect3;
     this.writeLayout(held);
     const title = cleanName(`${source.title} \u526F\u672C`, MAX_FRAME_TITLE) ?? source.title;
     held.manifest.frames.push({ id: input.id, title, file, hash: sha1(bytes), createdAt: this.now() });
@@ -2136,6 +2352,47 @@ var Workspace = class {
     this.opts.onChange({ kind: "updated", canvasId: id });
     return ok(this.wire(id));
   }
+  addAsset(canvasId2, mime, bytes) {
+    const writable = this.writable(canvasId2);
+    if (!writable.ok) return writable;
+    const ext = IMAGE_TYPES[mime];
+    if (!ext) return { ok: false, problem: { code: "IMAGE_UNSUPPORTED", mime } };
+    if (!bytes.length) return { ok: false, problem: { code: "IMAGE_EMPTY" } };
+    if (bytes.length > MAX_IMAGE_BYTES) {
+      return { ok: false, problem: { code: "IMAGE_TOO_LARGE", bytes: bytes.length, limit: MAX_IMAGE_BYTES } };
+    }
+    const name = `${sha1(bytes)}.${ext}`;
+    const path = join6(this.dir(writable.value.manifest.id), ASSETS_DIR, name);
+    if (!existsSync5(path)) {
+      mkdirSync5(join6(this.dir(writable.value.manifest.id), ASSETS_DIR), { recursive: true });
+      writeAtomic(path, bytes);
+    }
+    return ok(name);
+  }
+  addImageFrame(canvasId2, input) {
+    const writable = this.writable(canvasId2);
+    if (!writable.ok) return writable;
+    const held = writable.value;
+    const id = held.manifest.id;
+    if (held.manifest.frames.some((f) => f.id === input.id)) return ok(this.wire(id));
+    const title = cleanName(input.title, MAX_FRAME_TITLE);
+    if (title === null) return { ok: false, problem: { code: "BAD_NAME", max: MAX_FRAME_TITLE } };
+    if (!asAssetName(input.asset) || !existsSync5(join6(this.dir(id), ASSETS_DIR, input.asset))) {
+      return { ok: false, problem: { code: "ASSET_NOT_FOUND", canvasId: id, asset: input.asset } };
+    }
+    if (held.manifest.frames.filter((f) => f.deletedAt === void 0).length >= MAX_FRAMES_PER_CANVAS) {
+      return { ok: false, problem: { code: "TOO_MANY_FRAMES", limit: MAX_FRAMES_PER_CANVAS } };
+    }
+    const html = imageFrameHtml(title, input.asset);
+    const file = `frames/${input.id}.html`;
+    writeAtomic(join6(this.dir(id), file), html);
+    held.layout.rects[input.id] = normalizeRect(input.rect);
+    this.writeLayout(held);
+    held.manifest.frames.push({ id: input.id, title, file, hash: sha1(html), createdAt: this.now() });
+    this.writeManifest(held);
+    this.opts.onChange({ kind: "updated", canvasId: id });
+    return ok(this.wire(id));
+  }
   // ------------------------------------------------------------ agent edits
   frameOf(held, frame) {
     return this.project(held).frames.find((f) => f.id === frame.id);
@@ -2157,7 +2414,7 @@ var Workspace = class {
     const rectOf = (frameId2) => held.layout.rects[frameId2] ?? NO_RECT;
     const turn = this.turnFrames.filter((frameId2) => live3.some((f) => f.id === frameId2)).map(rectOf);
     const at = input.position ?? autoPlace(live3.map((f) => rectOf(f.id)), turn, normalizeRect({ x: 0, y: 0, ...size }));
-    const rect2 = normalizeRect({ ...at, ...size });
+    const rect3 = normalizeRect({ ...at, ...size });
     let id;
     do
       id = randomBytes3(6).toString("hex");
@@ -2165,7 +2422,7 @@ var Workspace = class {
     const file = `frames/${id}.html`;
     const frame = { id, title, file, hash: sha1(input.html), createdAt: this.now() };
     writeAtomic(join6(this.dir(held.manifest.id), file), input.html);
-    held.layout.rects[id] = rect2;
+    held.layout.rects[id] = rect3;
     this.writeLayout(held);
     held.manifest.frames.push(frame);
     this.turnFrames.push(id);
@@ -2202,15 +2459,29 @@ var Workspace = class {
       writeAtomic(path, input.html);
       hash = sha1(input.html);
     }
-    if (hash !== frame.hash || title !== void 0 && title !== frame.title) {
+    const resized = input.height === void 0 ? false : this.resizeFrame(held, frame.id, input.height);
+    const rewritten = hash !== frame.hash || title !== void 0 && title !== frame.title;
+    if (rewritten) {
       frame.hash = hash;
       if (title !== void 0) frame.title = title;
       this.writeManifest(held);
       this.served.delete(`${held.manifest.id}/${frame.id}`);
-      this.opts.onChange({ kind: "updated", canvasId: held.manifest.id });
     }
+    if (rewritten || resized) this.opts.onChange({ kind: "updated", canvasId: held.manifest.id });
     return ok(this.frameOf(held, frame));
   }
+  /** True if anything moved. */
+  resizeFrame(held, frameId2, height) {
+    const rects = held.layout.rects;
+    const rect3 = rects[frameId2] ?? NO_RECT;
+    const others = held.manifest.frames.filter((f) => f.deletedAt === void 0 && f.id !== frameId2).map((f) => [f.id, rects[f.id] ?? NO_RECT]);
+    const grown = growDown(rect3, height, others);
+    if (grown.rect.height === rect3.height) return false;
+    rects[frameId2] = grown.rect;
+    for (const [id, moved] of grown.moved) rects[id] = moved;
+    this.writeLayout(held);
+    return true;
+  }
   removeFrame(canvasId2, frameId2) {
     const writable = this.writable(canvasId2);
     if (!writable.ok) return writable;
@@ -2267,6 +2538,119 @@ function refuseCrossSite(sessionOrigin) {
   };
 }
 
+// src/library/policy.ts
+var VIDEO_CAP_BYTES = 2e8;
+var THUMBNAIL_LONG_SIDE = 400;
+var TAG_MAX_LENGTH = 64;
+function normalizeTag(raw) {
+  const name = raw.normalize("NFC").trim().replace(/\s+/g, " ");
+  if (name === "" || name.length > TAG_MAX_LENGTH || /[,，]/.test(name)) return null;
+  return lowercaseInitial(name);
+}
+function lowercaseInitial(name) {
+  const [first = "", second = ""] = name;
+  if (second !== second.toLowerCase()) return name;
+  return first.toLowerCase() + name.slice(first.length);
+}
+function tagKey(name) {
+  return name.normalize("NFKC").trim().replace(/\s+/g, " ").toLowerCase();
+}
+
+// src/attachment-policy.ts
+var MAX_ATTACHMENT_BYTES = 8 * 1024 * 1024;
+function isVideoMime(mime) {
+  return mime.startsWith("video/");
+}
+function attachmentByteLimit(mime) {
+  return isVideoMime(mime) ? VIDEO_CAP_BYTES : MAX_ATTACHMENT_BYTES;
+}
+
+// src/attachment-wire.ts
+var MAX_SHEETS = 6;
+var MAX_SHEET_BYTES = 4 * 1024 * 1024;
+var MAX_DIGEST_BYTES = 10 * 1024 * 1024;
+var SETTLE_BODY_LIMIT = Math.ceil(MAX_DIGEST_BYTES * 4 / 3) + 256 * 1024;
+var FAILURES = {
+  "unsupported-browser": true,
+  "unsupported-codec": true,
+  unreadable: true,
+  crashed: true
+};
+var BASE64 = /^[A-Za-z0-9+/]*={0,2}$/;
+var positive = (n) => typeof n === "number" && Number.isFinite(n) && n > 0;
+var count = (n) => Number.isInteger(n) && n >= 0;
+function parseVideoSettle(raw) {
+  if (typeof raw !== "object" || raw === null) return "a settle is an object";
+  const r = raw;
+  if (r.state === "failed") {
+    if (typeof r.reason !== "string" || !Object.hasOwn(FAILURES, r.reason)) return "unknown failure reason";
+    if (typeof r.detail !== "string") return "detail must be a string";
+    return { state: "failed", reason: r.reason, detail: r.detail.slice(0, 500) };
+  }
+  if (r.state !== "ready") return "state must be ready or failed";
+  const { durationMs, width, height, fps, audio } = r;
+  if (![durationMs, width, height, fps].every(positive)) return "durationMs, width, height and fps must be positive";
+  if (typeof audio !== "boolean") return "audio must be a boolean";
+  const w = width;
+  const h = height;
+  if (!Array.isArray(r.sheets) || r.sheets.length < 1 || r.sheets.length > MAX_SHEETS) {
+    return `sheets must hold 1 to ${MAX_SHEETS} images`;
+  }
+  const sheets = [];
+  let total = 0;
+  for (const sheet of r.sheets) {
+    if (typeof sheet !== "string" || !BASE64.test(sheet)) return "a sheet must be base64";
+    const bytes = new Uint8Array(Buffer.from(sheet, "base64"));
+    if (bytes.byteLength > MAX_SHEET_BYTES) return "a sheet is too large";
+    if (bytes[0] !== 255 || bytes[1] !== 216 || bytes[2] !== 255) return "a sheet must be a JPEG";
+    total += bytes.byteLength;
+    sheets.push(bytes);
+  }
+  if (total > MAX_DIGEST_BYTES) return "the sheets together are too large";
+  if (!Array.isArray(r.motion)) return "motion must be a list";
+  const motion = [];
+  const used = /* @__PURE__ */ new Set();
+  let previous = -1;
+  for (const raw2 of r.motion) {
+    if (typeof raw2 !== "object" || raw2 === null) return "a stretch is an object";
+    const m = raw2;
+    if (!count(m.fromMs) || !count(m.toMs) || m.toMs < m.fromMs) {
+      return "a stretch needs fromMs <= toMs";
+    }
+    if (m.fromMs < previous) return "stretches must be in time order";
+    previous = m.fromMs;
+    if (!insideFrame(m.region, w, h)) return "a stretch region must lie inside the frame";
+    if (!count(m.frames) || !count(m.shown) || m.shown > m.frames) {
+      return "a stretch needs shown <= frames";
+    }
+    if (m.sheet === null) {
+      if (m.shown !== 0) return "a stretch without a sheet shows nothing";
+    } else {
+      if (!Number.isInteger(m.sheet) || m.sheet < 2 || m.sheet > sheets.length) {
+        return "a stretch names a sheet that is not there";
+      }
+      if (used.has(m.sheet)) return "two stretches name one sheet";
+      used.add(m.sheet);
+    }
+    const { x, y, width: rw, height: rh } = m.region;
+    motion.push({
+      fromMs: m.fromMs,
+      toMs: m.toMs,
+      region: { x, y, width: rw, height: rh },
+      frames: m.frames,
+      shown: m.shown,
+      sheet: m.sheet
+    });
+  }
+  if (used.size !== sheets.length - 1) return "every sheet past the first belongs to a stretch";
+  return { state: "ready", durationMs, width: w, height: h, fps, audio, motion, sheets };
+}
+function insideFrame(raw, width, height) {
+  if (typeof raw !== "object" || raw === null) return false;
+  const { x, y, width: w, height: h } = raw;
+  return count(x) && count(y) && Number.isInteger(w) && Number.isInteger(h) && w > 0 && h > 0 && x + w <= width && y + h <= height;
+}
+
 // src/session-directory.ts
 var SessionDirectory = class {
   constructor(make, records, log = () => {
@@ -2289,16 +2673,15 @@ var SessionDirectory = class {
       if (runtime.endedByUser && !req.reopen) return { ok: false, reason: "ended-by-user" };
       runtime.reopen();
     }
-    if (req.origin) {
-      const holder = this.byOrigin(req.origin);
-      if (holder && holder !== runtime) holder.detachApp();
-      runtime.attachApp(
-        { kind: "attached", origin: req.origin, attachedAt: req.now },
-        { userAttached: true }
-      );
-    }
+    if (req.origin) this.attachOrigin(runtime, req.origin, { userAttached: true, now: req.now });
+    this.records.used?.(req.project, req.now);
     return { ok: true, runtime };
   }
+  attachOrigin(runtime, origin, opts) {
+    const holder = this.byOrigin(origin);
+    if (holder && holder !== runtime) holder.detachApp();
+    runtime.attachApp({ kind: "attached", origin, attachedAt: opts.now }, { userAttached: opts.userAttached });
+  }
   /** `GET /control/sessions/find?project=`: the live session, or the persisted
    *  active one woken up - a poll that reconnects after an idle exit still finds
    *  its queued feedback. Null for an unknown or ended project. */
@@ -2381,15 +2764,28 @@ import {
   mkdirSync as mkdirSync8,
   readFileSync as readFileSync8,
   readdirSync as readdirSync4,
-  renameSync as renameSync3,
-  rmSync as rmSync5,
+  renameSync as renameSync4,
+  rmSync as rmSync6,
   writeFileSync as writeFileSync6
 } from "node:fs";
 import { join as join9 } from "node:path";
 
 // src/store.ts
 import { createHash as createHash2, randomBytes as randomBytes4 } from "node:crypto";
-import { constants as fsConstants, copyFileSync, mkdirSync as mkdirSync7, readFileSync as readFileSync7, readdirSync as readdirSync3, statSync as statSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync5 } from "node:fs";
+import { once } from "node:events";
+import {
+  constants as fsConstants,
+  copyFileSync,
+  createWriteStream,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync7,
+  readdirSync as readdirSync3,
+  renameSync as renameSync3,
+  rmSync as rmSync5,
+  statSync as statSync2,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync5
+} from "node:fs";
 import { join as join8 } from "node:path";
 
 // src/preferences.ts
@@ -2428,6 +2824,13 @@ function rememberAnnouncementSeen(id, file = PREFERENCES_FILE) {
   write(file, { ...prefs, announcementsSeen: next });
   return next;
 }
+function rememberedLastAgent(file = PREFERENCES_FILE) {
+  return read(file).lastAgent;
+}
+function rememberLastAgent(command, file = PREFERENCES_FILE) {
+  const prefs = read(file);
+  if (prefs.lastAgent !== command) write(file, { ...prefs, lastAgent: command });
+}
 function write(file, prefs) {
   mkdirSync6(dirname4(file), { recursive: true });
   writeFileSync4(file, JSON.stringify(prefs, null, 2));
@@ -2482,6 +2885,30 @@ function dedupeName(name, taken) {
     if (!taken.has(candidate)) return candidate;
   }
 }
+function isPendingVideo(a) {
+  return a.video?.state === "pending";
+}
+function sheetFileName(id, sheet) {
+  return `${id}.sheet-${sheet}.jpg`;
+}
+function sheetNumbers(video) {
+  return [1, ...video.motion.flatMap((m) => m.sheet === null ? [] : [m.sheet])];
+}
+function attachmentFiles(a) {
+  const own = `${a.id}-${a.name}`;
+  return a.video?.state === "ready" ? [own, ...sheetNumbers(a.video).map((n) => sheetFileName(a.id, n))] : [own];
+}
+function statusOf2(a) {
+  const video = a.video;
+  if (!video || video.state === "ready") return { state: "ready" };
+  if (video.state === "failed") return { state: "failed", reason: video.reason };
+  return { state: "pending" };
+}
+function digestOf(settle) {
+  if (settle.state === "failed") return settle;
+  const { sheets: _, ...frames } = settle;
+  return frames;
+}
 function isProjectSession(value) {
   const record = value;
   return typeof record?.project === "string" && typeof record.app?.kind === "string" && record.targetOrigin === void 0;
@@ -2623,6 +3050,7 @@ var SessionStore = class {
    *  the one the user just asked for. Rounds on *other* elements are left alone,
    *  which is what lets a button and a heading be explored at once. */
   startExplore(round) {
+    if (round.attachments?.some(isPendingVideo)) throw new Error("a video still being digested cannot start an explore");
     const fresh = {
       ...round,
       status: "generating",
@@ -2736,6 +3164,7 @@ var SessionStore = class {
   /** Move the queue (+ optional note and its files) into a sealed batch awaiting
    *  agent pickup. Attachment bytes stay put - the batch now references them. */
   sendBatch(note, attachments = [], references = [], skills = [], view) {
+    if (this.holdsPendingVideo(attachments)) throw new Error("a video still being digested cannot be sent");
     const items = this.annotations;
     if (items.length === 0 && !note?.trim() && attachments.length === 0 && references.length === 0 && skills.length === 0) {
       return null;
@@ -2809,13 +3238,42 @@ var SessionStore = class {
   attachmentPath(a) {
     return join8(this.attachmentsDir, `${a.id}-${a.name}`);
   }
+  sheetPath(a, sheet) {
+    return join8(this.attachmentsDir, sheetFileName(a.id, sheet));
+  }
   addAttachment(rawName, mime, bytes) {
-    return this.storeAttachment(rawName, mime, bytes.byteLength, (path) => writeFileSync5(path, bytes));
+    return this.storeAttachment(newId(), rawName, mime, bytes.byteLength, (path) => writeFileSync5(path, bytes));
+  }
+  async receiveAttachment(rawName, mime, body, limit) {
+    const id = newId();
+    mkdirSync7(this.attachmentsDir, { recursive: true });
+    const part = join8(this.attachmentsDir, `${id}.part`);
+    const out = createWriteStream(part);
+    let size = 0;
+    try {
+      for await (const chunk of body) {
+        size += chunk.byteLength;
+        if (size > limit) break;
+        if (!out.write(chunk)) await once(out, "drain");
+      }
+      out.end();
+      await once(out, "close");
+    } catch (error) {
+      out.destroy();
+      rmSync5(part, { force: true });
+      throw error;
+    }
+    if (size > limit || size === 0) {
+      rmSync5(part, { force: true });
+      return size === 0 ? "empty" : "too-large";
+    }
+    return this.storeAttachment(id, rawName, mime, size, (path) => renameSync3(part, path));
   }
   /** A copy, not a link to the library's file: a session owns its attachments
    *  outright, and the sweep deletes them. A clone where the filesystem has one. */
   copyAttachment(title, mime, from, origin) {
     return this.storeAttachment(
+      newId(),
       libraryAttachmentName(title, mime),
       mime,
       statSync2(from).size,
@@ -2823,16 +3281,17 @@ var SessionStore = class {
       origin
     );
   }
-  storeAttachment(rawName, mime, size, write3, origin) {
+  storeAttachment(id, rawName, mime, size, write3, origin) {
     const index = this.attachmentIndex;
     const taken = new Set(Object.values(index).map((a) => a.name));
     const attachment = {
-      id: newId(),
+      id,
       name: dedupeName(sanitizeAttachmentName(rawName, mime), taken),
       mime,
       size,
       createdAt: Date.now(),
-      ...origin ? { origin } : {}
+      ...origin ? { origin } : {},
+      ...isVideoMime(mime) ? { video: { state: "pending" } } : {}
     };
     mkdirSync7(this.attachmentsDir, { recursive: true });
     write3(this.attachmentPath(attachment));
@@ -2851,6 +3310,31 @@ var SessionStore = class {
     }
     return found;
   }
+  get pendingVideoIds() {
+    return Object.values(this.attachmentIndex).flatMap((a) => isPendingVideo(a) ? [a.id] : []);
+  }
+  holdsPendingVideo(extra = []) {
+    return [...extra, ...this.annotations.flatMap((a) => a.attachments ?? [])].some(isPendingVideo);
+  }
+  settleVideo(id, settle) {
+    const index = this.attachmentIndex;
+    const entry = index[id];
+    if (!entry) return { state: "gone" };
+    if (!isPendingVideo(entry)) return statusOf2(entry);
+    if (settle.state === "ready") {
+      settle.sheets.forEach((bytes, i) => writeFileSync5(this.sheetPath(entry, i + 1), bytes));
+    }
+    const settled = { ...entry, video: digestOf(settle) };
+    this.writeJson("attachments.json", { ...index, [id]: settled });
+    const queue = this.annotations;
+    if (queue.some((a) => a.attachments?.some((x) => x.id === id))) {
+      this.writeJson(
+        "queue.json",
+        queue.map((a) => a.attachments ? { ...a, attachments: a.attachments.map((x) => x.id === id ? settled : x) } : a)
+      );
+    }
+    return statusOf2(settled);
+  }
   removeAttachment(id) {
     const index = this.attachmentIndex;
     const target = index[id];
@@ -2865,9 +3349,11 @@ var SessionStore = class {
     if (!list2?.length) return;
     const index = this.attachmentIndex;
     for (const a of list2) {
-      try {
-        unlinkSync2(this.attachmentPath(a));
-      } catch {
+      for (const name of attachmentFiles(a)) {
+        try {
+          unlinkSync2(join8(this.attachmentsDir, name));
+        } catch {
+        }
       }
       delete index[a.id];
     }
@@ -2896,7 +3382,7 @@ var SessionStore = class {
     const index = this.attachmentIndex;
     const doomed = Object.values(index).filter((a) => !referenced.has(a.id) && a.createdAt < cutoff);
     this.dropAttachments(doomed);
-    const kept = new Set(Object.values(this.attachmentIndex).map((a) => `${a.id}-${a.name}`));
+    const kept = new Set(Object.values(this.attachmentIndex).flatMap(attachmentFiles));
     let entries3;
     try {
       entries3 = readdirSync3(this.attachmentsDir);
@@ -2957,6 +3443,18 @@ var SessionStore = class {
   setAgent(command) {
     this.patchSession({ agent: command });
   }
+  setAgentBy(by) {
+    const { agentDeclined: _agentDeclined, ...rest } = this.session;
+    this.writeJson("session.json", { ...rest, agentBy: by });
+  }
+  declineAgent() {
+    this.patchSession({ agentDeclined: true });
+  }
+  /** A restore brings back only an agent still connected when the daemon stopped. */
+  clearAgent() {
+    const { agent: _agent, agentBy: _agentBy, ...rest } = this.session;
+    this.writeJson("session.json", rest);
+  }
   /** Remember one of the user's agent-config picks - the model, and anything else
    *  the agent offers - so the next session opens on it. */
   setAgentConfig(configId, value) {
@@ -2967,7 +3465,7 @@ var SessionStore = class {
    *  The picks go with it - they described that agent's options, and the next one
    *  need not have them. */
   end(by) {
-    const { agent: _agent, agentConfig: _agentConfig, ...rest } = this.session;
+    const { agent: _agent, agentBy: _agentBy, agentDeclined: _agentDeclined, agentConfig: _agentConfig, ...rest } = this.session;
     this.writeJson("session.json", { ...rest, state: "ended", endedBy: by });
   }
   /** This review's conversations, oldest first, with one guaranteed to exist.
@@ -3401,19 +3899,19 @@ var TRANSIENT = /\.(staging|prev)-\d+$/;
 function recover(sessionsDir, entries3) {
   for (const name of entries3) {
     const path = join9(sessionsDir, name);
-    if (/\.staging-\d+$/.test(name)) rmSync5(path, { recursive: true, force: true });
+    if (/\.staging-\d+$/.test(name)) rmSync6(path, { recursive: true, force: true });
     const prev = /^(.*)\.prev-\d+$/.exec(name);
     if (!prev) continue;
     const original = join9(sessionsDir, prev[1]);
-    if (existsSync6(original)) rmSync5(path, { recursive: true, force: true });
-    else renameSync3(path, original);
+    if (existsSync6(original)) rmSync6(path, { recursive: true, force: true });
+    else renameSync4(path, original);
   }
 }
 function writeMerged(sessionsDir, merged, hadExisting) {
   const { key } = merged.files;
   const target = join9(sessionsDir, key);
   const staging = join9(sessionsDir, `${key}.staging-${process.pid}`);
-  rmSync5(staging, { recursive: true, force: true });
+  rmSync6(staging, { recursive: true, force: true });
   const attachments = join9(staging, "attachments");
   mkdirSync8(attachments, { recursive: true });
   if (hadExisting) {
@@ -3426,27 +3924,27 @@ function writeMerged(sessionsDir, merged, hadExisting) {
     const from = join9(sessionsDir, copy.sourceKey, "attachments", `${copy.from.id}-${copy.from.name}`);
     if (existsSync6(from)) copyFileSync2(from, join9(attachments, `${copy.to.id}-${copy.to.name}`));
   }
-  for (const [field, file] of Object.entries(FILES)) {
+  for (const [field3, file] of Object.entries(FILES)) {
     writeFileSync6(
       join9(staging, file),
-      JSON.stringify(merged.files[field], null, 2)
+      JSON.stringify(merged.files[field3], null, 2)
     );
   }
   writeFileSync6(join9(staging, "session.json"), JSON.stringify(merged.files.session, null, 2));
   if (hadExisting) {
     const prev = join9(sessionsDir, `${key}.prev-${process.pid}`);
-    renameSync3(target, prev);
-    renameSync3(staging, target);
-    rmSync5(prev, { recursive: true, force: true });
+    renameSync4(target, prev);
+    renameSync4(staging, target);
+    rmSync6(prev, { recursive: true, force: true });
   } else {
-    renameSync3(staging, target);
+    renameSync4(staging, target);
   }
 }
 function moveToLegacy(sessionsDir, legacyDir, key) {
   mkdirSync8(legacyDir, { recursive: true });
   let dest = join9(legacyDir, key);
   for (let n = 2; existsSync6(dest); n++) dest = join9(legacyDir, `${key}-${n}`);
-  renameSync3(join9(sessionsDir, key), dest);
+  renameSync4(join9(sessionsDir, key), dest);
 }
 function migrateLegacySessions(sessionsDir = SESSIONS_DIR, legacyDir = LEGACY_SESSIONS_DIR) {
   const report2 = { merged: /* @__PURE__ */ new Map(), skipped: [] };
@@ -3550,12 +4048,12 @@ function fieldsFromSchema(schema) {
       customs.push({ key, questionId, ...text ? { text } : {} });
       continue;
     }
-    const field = fieldFrom(key, property);
-    if (!field) {
+    const field3 = fieldFrom(key, property);
+    if (!field3) {
       if (required.has(key)) return null;
       continue;
     }
-    fields.push(required.has(key) ? field : { ...field, optional: true });
+    fields.push(required.has(key) ? field3 : { ...field3, optional: true });
   }
   for (const { questionId, ...custom } of customs) {
     const owner = fields.find((f) => f.key === questionId);
@@ -3645,49 +4143,49 @@ function validateAnswers(fields, raw) {
   if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return null;
   const given = raw;
   const answers = {};
-  for (const field of fields) {
-    const custom = field.kind === "select" || field.kind === "multiselect" ? field.custom : void 0;
+  for (const field3 of fields) {
+    const custom = field3.kind === "select" || field3.kind === "multiselect" ? field3.custom : void 0;
     const typed = custom ? given[custom.key] : void 0;
     if (typed !== void 0 && typed !== null && typed !== "") {
       if (typeof typed !== "string") return null;
       answers[custom.key] = typed;
     }
-    const value = given[field.key];
+    const value = given[field3.key];
     if (value === void 0 || value === null || value === "") {
-      if (field.optional || typed) continue;
+      if (field3.optional || typed) continue;
       return null;
     }
-    const checked = checkAnswer(field, value);
+    const checked = checkAnswer(field3, value);
     if (checked === null) return null;
-    answers[field.key] = checked;
+    answers[field3.key] = checked;
   }
   return answers;
 }
-function checkAnswer(field, value) {
-  switch (field.kind) {
+function checkAnswer(field3, value) {
+  switch (field3.kind) {
     case "select":
-      return typeof value === "string" && field.options.some((o) => o.id === value) ? value : null;
+      return typeof value === "string" && field3.options.some((o) => o.id === value) ? value : null;
     case "multiselect": {
       if (!Array.isArray(value) || !value.every((v) => typeof v === "string")) return null;
       const ids = value;
       if (new Set(ids).size !== ids.length) return null;
-      if (!ids.every((id) => field.options.some((o) => o.id === id))) return null;
-      if (field.min !== void 0 && ids.length < field.min) return null;
-      if (field.max !== void 0 && ids.length > field.max) return null;
+      if (!ids.every((id) => field3.options.some((o) => o.id === id))) return null;
+      if (field3.min !== void 0 && ids.length < field3.min) return null;
+      if (field3.max !== void 0 && ids.length > field3.max) return null;
       return ids;
     }
     case "text": {
       if (typeof value !== "string") return null;
-      if (field.min !== void 0 && value.length < field.min) return null;
-      if (field.max !== void 0 && value.length > field.max) return null;
-      if (field.pattern !== void 0 && !safeMatch(field.pattern, value)) return null;
+      if (field3.min !== void 0 && value.length < field3.min) return null;
+      if (field3.max !== void 0 && value.length > field3.max) return null;
+      if (field3.pattern !== void 0 && !safeMatch(field3.pattern, value)) return null;
       return value;
     }
     case "number": {
       if (typeof value !== "number" || !Number.isFinite(value)) return null;
-      if (field.integer && !Number.isInteger(value)) return null;
-      if (field.min !== void 0 && value < field.min) return null;
-      if (field.max !== void 0 && value > field.max) return null;
+      if (field3.integer && !Number.isInteger(value)) return null;
+      if (field3.min !== void 0 && value < field3.min) return null;
+      if (field3.max !== void 0 && value > field3.max) return null;
       return value;
     }
     case "boolean":
@@ -3726,7 +4224,7 @@ function configValueName(option, value) {
 
 // src/usage-limit.ts
 import { spawn as spawn2 } from "node:child_process";
-import { mkdirSync as mkdirSync9, mkdtempSync, readFileSync as readFileSync9, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "node:fs";
+import { mkdirSync as mkdirSync9, mkdtempSync, readFileSync as readFileSync9, rmSync as rmSync7, writeFileSync as writeFileSync7 } from "node:fs";
 import { tmpdir } from "node:os";
 import { join as join10 } from "node:path";
 
@@ -3739,7 +4237,7 @@ var CLIENT = { name: "ezdesign", version: "1" };
 function askCodex(binary, method, params) {
   const child = spawn(binary, ["app-server"], { stdio: ["pipe", "pipe", "ignore"] });
   const timer = setTimeout(() => child.kill("SIGKILL"), TIMEOUT_MS);
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     let answer2;
     let rest = "";
     const send = (message2) => {
@@ -3764,8 +4262,8 @@ function askCodex(binary, method, params) {
         }
       }
     });
-    child.on("error", () => resolve6(void 0));
-    child.on("close", () => resolve6(answer2));
+    child.on("error", () => resolve7(void 0));
+    child.on("close", () => resolve7(answer2));
     send({ jsonrpc: "2.0", id: INITIALIZE, method: "initialize", params: { clientInfo: CLIENT } });
   }).finally(() => clearTimeout(timer));
 }
@@ -3902,25 +4400,25 @@ async function readClaudeLimit(binary) {
   });
   const timer = setTimeout(() => child.kill("SIGKILL"), READ_TIMEOUT_MS);
   try {
-    return await new Promise((resolve6) => {
+    return await new Promise((resolve7) => {
       let out = "";
       child.stdout.setEncoding("utf8");
       child.stdout.on("data", (chunk) => out += chunk);
-      child.on("error", () => resolve6(void 0));
+      child.on("error", () => resolve7(void 0));
       child.on("close", () => {
         try {
           const answer2 = JSON.parse(out).result;
-          resolve6(
+          resolve7(
             typeof answer2 === "string" ? claudeLimitFromUsageText(answer2) ?? void 0 : void 0
           );
         } catch {
-          resolve6(void 0);
+          resolve7(void 0);
         }
       });
     });
   } finally {
     clearTimeout(timer);
-    rmSync6(cwd, { recursive: true, force: true });
+    rmSync7(cwd, { recursive: true, force: true });
   }
 }
 var lastRead = /* @__PURE__ */ new Map();
@@ -3935,12 +4433,13 @@ async function readLimit(command, now = Date.now()) {
 }
 var READ_TIMEOUT_MS = 6e4;
 
-// src/agent-children.ts
+// src/child-groups.ts
 import { execFileSync } from "node:child_process";
-import { mkdirSync as mkdirSync10, readFileSync as readFileSync10, rmSync as rmSync7, writeFileSync as writeFileSync8 } from "node:fs";
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync10, rmSync as rmSync8, writeFileSync as writeFileSync8 } from "node:fs";
 import { join as join11 } from "node:path";
 var FILE2 = join11(DATA_DIR, "agent-children.json");
 var live2 = /* @__PURE__ */ new Map();
+process.on("exit", () => killTrackedGroups());
 function read3() {
   try {
     return JSON.parse(readFileSync10(FILE2, "utf8"));
@@ -3967,7 +4466,7 @@ function running(pid) {
     return false;
   }
 }
-function isStillTheAgent(pid, command) {
+function isStillTheProcess(pid, command) {
   try {
     const actual = execFileSync("ps", ["-o", "command=", "-p", String(pid)], {
       encoding: "utf8",
@@ -3988,17 +4487,17 @@ function killGroup(pid, signal = "SIGKILL") {
     }
   }
 }
-function trackAgent(pid, command) {
+function trackGroup(pid, command) {
   live2.set(pid, command);
   write2();
 }
-function untrackAgent(pid) {
+function untrackGroup(pid) {
   if (live2.delete(pid)) write2();
 }
-function killTrackedAgents() {
+function killTrackedGroups() {
   for (const pid of live2.keys()) killGroup(pid);
 }
-function reapOrphanedAgents() {
+function reapOrphanedGroups() {
   const record = read3();
   if (!record) {
     write2();
@@ -4007,17 +4506,17 @@ function reapOrphanedAgents() {
   if (record.daemonPid !== process.pid && running(record.daemonPid)) return 0;
   let killed = 0;
   for (const { pid, command } of record.children ?? []) {
-    if (pid === process.pid || !isStillTheAgent(pid, command)) continue;
+    if (pid === process.pid || !isStillTheProcess(pid, command)) continue;
     killGroup(pid);
     killed++;
   }
   write2();
   return killed;
 }
-function clearAgentRecord() {
+function clearGroupRecord() {
   live2.clear();
   try {
-    rmSync7(FILE2, { force: true });
+    rmSync8(FILE2, { force: true });
   } catch {
   }
 }
@@ -4044,8 +4543,8 @@ var MessageQueue = class {
   next() {
     if (this.queued.length) return Promise.resolve(this.queued.shift());
     if (this.retired) return Promise.resolve(RETIRED);
-    return new Promise((resolve6) => {
-      this.waiting = resolve6;
+    return new Promise((resolve7) => {
+      this.waiting = resolve7;
     });
   }
   /** Wakes the reader and answers every later read. Retiring rather than
@@ -4114,7 +4613,6 @@ var FEED_CAP = 100;
 function trimTitle(title, cwd) {
   return title.replaceAll(`${cwd}/`, "");
 }
-process.on("exit", () => killTrackedAgents());
 var AcpAgent = class {
   constructor(opts) {
     this.opts = opts;
@@ -4126,7 +4624,7 @@ var AcpAgent = class {
       stdio: ["pipe", "pipe", "pipe"],
       env: { ...process.env, ...opts.env }
     });
-    if (this.child.pid) trackAgent(this.child.pid, opts.command);
+    if (this.child.pid) trackGroup(this.child.pid, opts.command);
     this.child.stderr?.on("data", (chunk) => {
       this.stderrTail = [...this.stderrTail, chunk.toString()].slice(-20);
     });
@@ -4320,10 +4818,10 @@ var AcpAgent = class {
   }
   settle(id, outcome) {
     if (!this.ask || this.ask.id !== id || !this.askResolve) return false;
-    const resolve6 = this.askResolve;
+    const resolve7 = this.askResolve;
     this.ask = null;
     this.askResolve = null;
-    resolve6(outcome);
+    resolve7(outcome);
     this.opts.onChange();
     return true;
   }
@@ -4518,11 +5016,11 @@ var AcpAgent = class {
     killGroup(pid, "SIGTERM");
     setTimeout(() => {
       killGroup(pid);
-      untrackAgent(pid);
+      untrackGroup(pid);
     }, 3e3).unref();
   }
   untrack() {
-    if (this.child.pid !== void 0) untrackAgent(this.child.pid);
+    if (this.child.pid !== void 0) untrackGroup(this.child.pid);
   }
   fail(message2) {
     if (this.state === "exited") return;
@@ -4538,10 +5036,10 @@ ${tail}` : message2;
   }
   /** A question nobody can answer any more must not hang the agent's request. */
   settleAsk() {
-    const resolve6 = this.askResolve;
+    const resolve7 = this.askResolve;
     this.ask = null;
     this.askResolve = null;
-    resolve6?.(null);
+    resolve7?.(null);
   }
   turnEnded(stopReason, epoch) {
     if (epoch !== this.epoch || this.state !== "working") return;
@@ -4557,19 +5055,19 @@ ${tail}` : message2;
    *  was settled by a shutdown. One at a time by protocol shape: the agent
    *  blocks on the request, so a second cannot arrive while one is pending. */
   pendAsk(ask) {
-    return new Promise((resolve6) => {
+    return new Promise((resolve7) => {
       this.ask = { id: `ask-${++this.askSeq}`, ...ask };
-      this.askResolve = resolve6;
+      this.askResolve = resolve7;
       this.opts.onChange();
     });
   }
   async requestPermission(params) {
     const toolName = params.toolCall.name ?? params.toolCall.title ?? "";
     if (this.opts.ownTool?.(toolName)) {
-      const once = params.options.find((o) => o.kind === "allow_once");
-      if (once) return { outcome: { outcome: "selected", optionId: once.optionId } };
+      const once2 = params.options.find((o) => o.kind === "allow_once");
+      if (once2) return { outcome: { outcome: "selected", optionId: once2.optionId } };
     }
-    const field = {
+    const field3 = {
       key: "option",
       kind: "select",
       options: params.options.map((o) => ({ id: o.optionId, name: o.name, hint: o.kind }))
@@ -4577,7 +5075,7 @@ ${tail}` : message2;
     const outcome = await this.pendAsk({
       kind: "permission",
       title: params.toolCall.title ?? "The agent needs a decision",
-      fields: [field]
+      fields: [field3]
     });
     const optionId = outcome && "answers" in outcome ? outcome.answers.option : void 0;
     if (typeof optionId !== "string") return { outcome: { outcome: "cancelled" } };
@@ -4729,8 +5227,8 @@ ${tail}` : message2;
       this.canFork = !!init.agentCapabilities?.sessionCapabilities?.fork;
       this.ctx = ctx;
       await this.openSession();
-      await new Promise((resolve6) => {
-        this.finish = resolve6;
+      await new Promise((resolve7) => {
+        this.finish = resolve7;
       });
     });
   }
@@ -4822,109 +5320,1378 @@ function worthListing(chat, index, all) {
   return !!chat.title || chat.current || index === all.length - 1;
 }
 
-// src/explore.ts
-var MAX_VARIANT_HTML = 32 * 1024;
-var MAX_VARIANT_NAME = 40;
-var FORBIDDEN_TAGS = ["script", "iframe", "object", "embed", "link", "meta", "base"];
-function variantProblemMessage(problem) {
-  switch (problem.code) {
-    case "empty":
-      return "html is empty. Send the markup for one element.";
-    case "too-long":
-      return `html is ${problem.length} bytes; the limit is ${MAX_VARIANT_HTML}. Send one element's markup, not a page.`;
-    case "name-too-long":
-      return `name is ${problem.length} characters; the limit is ${MAX_VARIANT_NAME}. A short label, not a description.`;
-    case "forbidden-tag":
-      return `html contains <${problem.tag}>, which a variant may not use. A variant is markup and CSS only - no scripts, no embeds, no external resources.`;
-    case "event-handler":
-      return `html sets the inline handler ${problem.attribute}. A variant is markup and CSS only - no scripts.`;
-    case "javascript-url":
-      return "html contains a javascript: url. A variant is markup and CSS only - no scripts.";
-    case "not-one-root":
-      return problem.roots === 0 ? "html has no element at its top level. A variant is one root element, optionally with a <style> block inside it." : `html has ${problem.roots} top-level elements. A variant is one root element - wrap them in a single container.`;
+// src/dev-server/index.ts
+import { readFileSync as readFileSync13, realpathSync as realpathSync2 } from "node:fs";
+import { join as join15, relative as relative2 } from "node:path";
+
+// src/login-env.ts
+import { spawn as spawn4 } from "node:child_process";
+import { randomBytes as randomBytes5 } from "node:crypto";
+import { accessSync, constants, readFileSync as readFileSync11 } from "node:fs";
+import { delimiter, join as join13 } from "node:path";
+var LOGIN_SHELL_TIMEOUT_MS = 1e4;
+var PROCESS_LOCAL_VARS = /* @__PURE__ */ new Set(["_", "SHLVL", "PWD", "OLDPWD", LOGIN_ENV_VAR, RUN_AS_NODE]);
+var adopted = null;
+function adoptLoginEnvironment() {
+  adopted ??= resolveLoginEnvironment(process.env, LOGIN_ENV_CACHE);
+  return adopted;
+}
+async function resolveLoginEnvironment(env, cacheFile) {
+  const request2 = env[LOGIN_ENV_VAR];
+  if (!request2) return { kind: "inherited" };
+  if (request2 === "resolved") return { kind: "already-resolved" };
+  const shell = env.SHELL || "/bin/zsh";
+  const home = env.HOME ?? "";
+  const cached = readCache(cacheFile, shell, home);
+  const fresh = dumpLoginShell(shell, env).then((dumped2) => {
+    if (dumped2.env) cacheDump(cacheFile, { shell, home, env: dumped2.env });
+    return dumped2;
+  });
+  if (cached) {
+    merge(env, cached);
+    void fresh.catch(() => {
+    });
+    return { kind: "cached" };
   }
+  const started = Date.now();
+  const dumped = await fresh;
+  if (!dumped.env) return { kind: "failed", shell, error: dumped.error };
+  merge(env, dumped.env);
+  return { kind: "resolved", shell, ms: Date.now() - started };
 }
-function checkVariant(name, html) {
-  if (name.length > MAX_VARIANT_NAME) return { code: "name-too-long", length: name.length };
-  if (!html.trim()) return { code: "empty" };
-  if (html.length > MAX_VARIANT_HTML) return { code: "too-long", length: html.length };
-  const tags = scanTags(html);
-  if (!tags) return { code: "not-one-root", roots: 0 };
-  for (const tag of tags.names) {
-    if (FORBIDDEN_TAGS.includes(tag)) return { code: "forbidden-tag", tag };
+function cacheDump(file, cache) {
+  try {
+    writeAtomic(file, JSON.stringify(cache), 384);
+  } catch {
   }
-  const handler = /\son([a-z]+)\s*=/i.exec(html);
-  if (handler) return { code: "event-handler", attribute: `on${handler[1].toLowerCase()}` };
-  if (/javascript:/i.test(html)) return { code: "javascript-url" };
-  if (tags.roots !== 1) return { code: "not-one-root", roots: tags.roots };
-  return null;
 }
-var VOID_TAGS = /* @__PURE__ */ new Set([
-  "area",
-  "base",
-  "br",
-  "col",
-  "embed",
-  "hr",
-  "img",
-  "input",
-  "link",
-  "meta",
-  "param",
-  "source",
-  "track",
-  "wbr"
-]);
-function scanTags(html) {
-  const names2 = [];
-  let depth = 0;
-  let roots = 0;
-  let i = 0;
-  while (i < html.length) {
-    const lt = html.indexOf("<", i);
-    if (lt === -1) break;
-    if (html.startsWith("<!--", lt)) {
-      const end2 = html.indexOf("-->", lt + 4);
-      i = end2 === -1 ? html.length : end2 + 3;
-      continue;
-    }
-    if (html.startsWith("<!", lt) || html.startsWith("<?", lt)) {
-      const end2 = html.indexOf(">", lt);
-      i = end2 === -1 ? html.length : end2 + 1;
-      continue;
-    }
-    const tag = /^<(\/?)([a-zA-Z][a-zA-Z0-9-]*)/.exec(html.slice(lt, lt + 64));
-    if (!tag) {
-      i = lt + 1;
-      continue;
-    }
-    const end = closingBracket(html, lt);
-    if (end === -1) break;
-    const closing = tag[1] === "/";
-    const name = tag[2].toLowerCase();
-    names2.push(name);
-    const selfClosing = html[end - 1] === "/";
-    if (closing) {
-      if (depth === 0) return null;
-      depth -= 1;
-    } else if (!selfClosing && !VOID_TAGS.has(name)) {
-      if (depth === 0) roots += 1;
-      depth += 1;
-    } else if (depth === 0) {
-      roots += 1;
-    }
-    i = end + 1;
-    if (!closing && RAW_TEXT2.has(name) && !selfClosing) {
-      const close = html.toLowerCase().indexOf(`</${name}`, i);
-      if (close === -1) break;
-      i = close;
-    }
+function merge(env, dump) {
+  for (const [key, value] of Object.entries(dump)) if (!PROCESS_LOCAL_VARS.has(key)) env[key] = value;
+  env[LOGIN_ENV_VAR] = "resolved";
+}
+function readCache(file, shell, home) {
+  try {
+    const cache = JSON.parse(readFileSync11(file, "utf8"));
+    return cache.shell === shell && cache.home === home && cache.env && typeof cache.env === "object" ? cache.env : null;
+  } catch {
+    return null;
   }
-  return { names: names2, roots };
 }
-var RAW_TEXT2 = /* @__PURE__ */ new Set(["style", "script", "textarea", "title"]);
-function closingBracket(html, from) {
-  let quote = null;
+function dumpLoginShell(shell, env) {
+  const marker = randomBytes5(8).toString("hex");
+  const { file, args } = loginShellInvocation(shell, marker);
+  return new Promise((resolve7) => {
+    const minimal = { HOME: env.HOME ?? "", USER: env.USER ?? "", LOGNAME: env.LOGNAME ?? "", SHELL: shell, TERM: "dumb" };
+    const child = spawn4(file, args, { env: minimal, stdio: ["ignore", "pipe", "ignore"], detached: true });
+    let stdout = "";
+    child.stdout.on("data", (chunk) => stdout += chunk.toString());
+    const timer = setTimeout(() => {
+      try {
+        process.kill(-child.pid, "SIGKILL");
+      } catch {
+      }
+    }, LOGIN_SHELL_TIMEOUT_MS);
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      resolve7({ error: error.message });
+    });
+    child.on("close", () => {
+      clearTimeout(timer);
+      const dump = parseEnvDump(stdout, marker);
+      resolve7(dump ? { env: dump } : { error: `${shell} printed no environment within ${LOGIN_SHELL_TIMEOUT_MS / 1e3} s` });
+    });
+  });
+}
+function loginShellInvocation(shell, marker) {
+  return { file: shell, args: ["-i", "-l", "-c", `printf %s ${marker}; /usr/bin/env -0; printf %s ${marker}`] };
+}
+function parseEnvDump(stdout, marker) {
+  const first = stdout.indexOf(marker);
+  const last = stdout.lastIndexOf(marker);
+  if (first === -1 || last === first) return null;
+  const dump = {};
+  for (const entry of stdout.slice(first + marker.length, last).split("\0")) {
+    const eq = entry.indexOf("=");
+    if (eq > 0) dump[entry.slice(0, eq)] = entry.slice(eq + 1);
+  }
+  return dump;
+}
+function findExecutable(binary, path) {
+  for (const dir of (path ?? "").split(delimiter).filter(Boolean)) {
+    const candidate = join13(dir, binary);
+    try {
+      accessSync(candidate, constants.X_OK);
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/dev-server/detect.ts
+import { readFileSync as readFileSync12, statSync as statSync4 } from "node:fs";
+import { join as join14 } from "node:path";
+var LOCKFILES_BY_PRECEDENCE = [
+  { file: "pnpm-lock.yaml", manager: "pnpm" },
+  { file: "yarn.lock", manager: "yarn" },
+  { file: "bun.lock", manager: "bun" },
+  { file: "bun.lockb", manager: "bun" },
+  { file: "package-lock.json", manager: "npm" }
+];
+function readProjectFacts(root) {
+  const isFile = (name) => statSync4(join14(root, name), { throwIfNoEntry: false })?.isFile() === true;
+  return {
+    packageJson: readPackageJson(join14(root, "package.json")),
+    lockfiles: LOCKFILES_BY_PRECEDENCE.filter((l) => isFile(l.file)).map((l) => l.file),
+    pnpmWorkspace: isFile("pnpm-workspace.yaml")
+  };
+}
+function readPackageJson(file) {
+  let pkg2;
+  try {
+    pkg2 = JSON.parse(readFileSync12(file, "utf8"));
+  } catch {
+    return null;
+  }
+  if (!pkg2 || typeof pkg2 !== "object" || Array.isArray(pkg2)) return null;
+  const { scripts, packageManager, workspaces } = pkg2;
+  const named = scripts && typeof scripts === "object" ? Object.entries(scripts).filter((e) => typeof e[1] === "string") : [];
+  return {
+    scripts: Object.fromEntries(named),
+    ...typeof packageManager === "string" ? { packageManager } : {},
+    workspaces: Array.isArray(workspaces) || !!workspaces && typeof workspaces === "object" && Array.isArray(workspaces.packages)
+  };
+}
+var MANAGERS = ["pnpm", "yarn", "bun", "npm"];
+var SERVER_LOOKING = /(^|[:_-])(dev|start|serve)([:_-]|$)/;
+function detectDevCommand(facts) {
+  const pkg2 = facts.packageJson;
+  if (!pkg2) return { kind: "undecided", reason: "no-package-json", serverScripts: [] };
+  const script = "dev" in pkg2.scripts ? "dev" : "start" in pkg2.scripts ? "start" : null;
+  if (!script) {
+    const serverScripts = Object.keys(pkg2.scripts).filter((name) => SERVER_LOOKING.test(name));
+    const atRoot = pkg2.workspaces || facts.pnpmWorkspace;
+    return { kind: "undecided", reason: atRoot ? "monorepo-root" : "no-script", serverScripts };
+  }
+  const fromField = MANAGERS.find((m) => pkg2.packageManager?.split("@")[0] === m);
+  if (fromField) return { kind: "command", command: { manager: fromField, script, managerFrom: "packageManager" } };
+  const lock = LOCKFILES_BY_PRECEDENCE.find((l) => facts.lockfiles.includes(l.file));
+  if (lock) return { kind: "command", command: { manager: lock.manager, script, managerFrom: "lockfile" } };
+  return { kind: "command", command: { manager: "npm", script, managerFrom: "default" } };
+}
+function commandLine(command) {
+  switch (command.manager) {
+    case "npm":
+      return command.script === "start" ? "npm start" : "npm run dev";
+    case "bun":
+      return `bun run ${command.script}`;
+    default:
+      return `${command.manager} ${command.script}`;
+  }
+}
+function requiredTools(command) {
+  return command.manager === "bun" ? ["bun"] : [command.manager, "node"];
+}
+function toolsForLine(line2) {
+  const first = line2.trim().split(/\s+/)[0] ?? "";
+  if (!/^[\w.+-]+$/.test(first)) return [];
+  return ["npm", "npx", "pnpm", "yarn"].includes(first) ? [first, "node"] : [first];
+}
+var parts = (...items) => items.map((item) => typeof item === "string" ? { text: item } : item);
+var run = (command) => ({ command });
+var INSTALL = {
+  node: parts("\u5F9E https://nodejs.org \u5B89\u88DD Node.js\uFF0C\u6216\u57F7\u884C ", run("brew install node")),
+  npm: parts("npm \u96A8 Node.js \u4E00\u8D77\u5B89\u88DD\uFF1A\u5F9E https://nodejs.org \u5B89\u88DD Node.js"),
+  pnpm: parts("\u57F7\u884C ", run("corepack enable pnpm"), "\uFF0C\u6216 ", run("npm install -g pnpm")),
+  yarn: parts("\u57F7\u884C ", run("corepack enable yarn"), "\uFF0C\u6216 ", run("npm install -g yarn")),
+  bun: parts("\u57F7\u884C ", run("curl -fsSL https://bun.sh/install | bash"), "\uFF0C\u6216 ", run("brew install oven-sh/bun/bun"))
+};
+function missingTools(tools, findOnPath) {
+  return tools.filter((tool2) => findOnPath(tool2) === null).map((tool2) => ({ tool: tool2, install: INSTALL[tool2] ?? parts("\u5B89\u88DD ", run(tool2), "\uFF0C\u4E26\u78BA\u8A8D\u767B\u5165 shell \u7684 PATH \u627E\u5F97\u5230\u5B83") }));
+}
+
+// src/dev-server/lifecycle.ts
+var INITIAL = { state: { phase: "idle" }, lastAttempt: 0, lastRunId: 0 };
+function step(machine, event) {
+  const state = machine.state;
+  const to = (next, effects = [], counters = {}) => ({
+    machine: { ...machine, ...counters, state: next },
+    effects,
+    stateChanged: next !== state
+  });
+  const same = (effects = []) => ({ machine, effects, stateChanged: false });
+  const current = (runId) => liveRun(state)?.id === runId;
+  const resolveAfresh = (now, by) => {
+    const attempt = machine.lastAttempt + 1;
+    return to({ phase: "resolving", since: now, by, attempt }, [{ type: "resolve", attempt }], { lastAttempt: attempt });
+  };
+  const restartRun = (now, by) => {
+    if (state.phase === "stopping") return to({ ...state, then: { kind: "restart", by, since: now } });
+    const run4 = liveRun(state);
+    return to({ phase: "stopping", run: run4, then: { kind: "restart", by, since: now } }, [
+      { type: "kill", runId: run4.id },
+      ...detachShown(state)
+    ]);
+  };
+  const crash = (run4, cause, tail, exit = {}) => to(
+    {
+      phase: "crashed",
+      command: run4.command,
+      cause,
+      ...exit.code !== void 0 && exit.code !== null ? { exitCode: exit.code } : {},
+      ...exit.signal ? { signal: exit.signal } : {},
+      tail
+    },
+    [...detachShown(state), NO_RESUME]
+  );
+  switch (event.type) {
+    case "ensure":
+      return RESTARTABLE.has(state.phase) ? resolveAfresh(event.now, event.by) : same();
+    case "restart":
+      if (liveRun(state)) return restartRun(event.now, event.by);
+      return RESTARTABLE.has(state.phase) ? resolveAfresh(event.now, event.by) : same();
+    case "confirmed":
+      return liveRun(state) ? restartRun(event.now, event.by) : resolveAfresh(event.now, event.by);
+    case "stop": {
+      if (state.phase === "stopping") return to({ ...state, then: { kind: "stopped" } }, [NO_RESUME]);
+      const run4 = liveRun(state);
+      if (run4) {
+        return to({ phase: "stopping", run: run4, then: { kind: "stopped" } }, [
+          { type: "kill", runId: run4.id },
+          ...detachShown(state),
+          NO_RESUME
+        ]);
+      }
+      if (state.phase === "resolving" || state.phase === "needs-command") return to({ phase: "stopped" }, [NO_RESUME]);
+      if (state.phase === "blocked") return to({ phase: "stopped", command: state.command }, [NO_RESUME]);
+      return same();
+    }
+    case "resolved": {
+      if (state.phase !== "resolving" || state.attempt !== event.attempt) return same();
+      const r = event.resolution;
+      switch (r.kind) {
+        case "run": {
+          const run4 = { id: machine.lastRunId + 1, command: r.command, startedAt: event.now, by: state.by };
+          return to(
+            { phase: "starting", since: state.since, run: run4 },
+            [
+              { type: "spawn", run: run4 },
+              { type: "arm-timers", runId: run4.id },
+              { type: "persist-resume", resume: { by: state.by } }
+            ],
+            { lastRunId: run4.id }
+          );
+        }
+        case "external":
+          return to({ phase: "external", origin: r.origin }, [{ type: "attach", origin: r.origin }]);
+        case "blocked":
+          return to({ phase: "blocked", command: r.command, missing: r.missing });
+        case "undecided":
+          return to({ phase: "needs-command", reason: r.reason, serverScripts: r.serverScripts }, [{ type: "ask-agent" }]);
+      }
+      return same();
+    }
+    case "origins": {
+      if (!current(event.runId) || !event.origins.length) return same();
+      if (state.phase === "starting") {
+        const origin = event.origins[0];
+        return to({ phase: "running", run: state.run, origin, origins: event.origins }, [{ type: "attach", origin }]);
+      }
+      if (state.phase === "running" && event.origins.length > state.origins.length) {
+        return to({ ...state, origins: event.origins });
+      }
+      return same();
+    }
+    case "scan-due":
+      return state.phase === "starting" && current(event.runId) ? same([{ type: "scan-ports", runId: event.runId }]) : same();
+    case "port-found":
+      if (state.phase !== "starting" || !current(event.runId)) return same();
+      return to({ phase: "running", run: state.run, origin: event.origin, origins: [event.origin] }, [
+        { type: "attach", origin: event.origin }
+      ]);
+    case "ready-timeout": {
+      if (state.phase !== "starting" || !current(event.runId)) return same();
+      const crashed = crash(state.run, "no-url", event.tail);
+      return { ...crashed, effects: [{ type: "kill", runId: event.runId }, ...crashed.effects] };
+    }
+    case "exited": {
+      if (!current(event.runId)) return same();
+      if (state.phase === "stopping") {
+        return state.then.kind === "stopped" ? to({ phase: "stopped", command: state.run.command }) : resolveAfresh(state.then.since, state.then.by);
+      }
+      if (state.phase === "running" && event.code === 0) {
+        return same([{ type: "confirm-external", runId: event.runId, origin: state.origin, tail: event.tail }]);
+      }
+      return crash(liveRun(state), "exited", event.tail, { code: event.code, signal: event.signal });
+    }
+    case "external-confirmed":
+      if (state.phase !== "running" || !current(event.runId)) return same();
+      return to({ phase: "external", origin: event.origin }, [{ type: "attach", origin: event.origin }, NO_RESUME]);
+    case "external-gone":
+      if (state.phase !== "running" || !current(event.runId)) return same();
+      return crash(state.run, "exited", event.tail, { code: 0 });
+    case "spawn-failed":
+      if (state.phase !== "starting" || !current(event.runId)) return same();
+      return crash(state.run, "spawn", [event.error]);
+    case "ask-again":
+      if (state.phase !== "needs-command" || state.proposal?.state === "asking") return same();
+      return to({ phase: "needs-command", reason: state.reason, serverScripts: state.serverScripts }, [{ type: "ask-agent" }]);
+    case "proposal":
+      return state.phase === "needs-command" ? to({ ...state, proposal: event.proposal }) : same();
+    case "command-forgotten":
+      return state.phase === "blocked" || state.phase === "crashed" || state.phase === "stopped" ? to({ phase: "stopped" }) : same();
+    case "origin-picked":
+      if (state.phase !== "running" || state.origin === event.origin || !state.origins.includes(event.origin)) return same();
+      return to({ ...state, origin: event.origin }, [{ type: "attach", origin: event.origin }]);
+  }
+}
+var NO_RESUME = { type: "persist-resume", resume: null };
+var RESTARTABLE = /* @__PURE__ */ new Set(["idle", "stopped", "crashed", "blocked"]);
+function liveRun(state) {
+  return state.phase === "starting" || state.phase === "running" || state.phase === "stopping" ? state.run : null;
+}
+function detachShown(state) {
+  return state.phase === "running" ? [{ type: "detach", origin: state.origin }] : [];
+}
+var commandWire = (command) => ({ line: command.line, cwd: command.cwd, source: command.source });
+function toWire(state) {
+  switch (state.phase) {
+    case "idle":
+      return { phase: "idle" };
+    case "resolving":
+      return { phase: "starting", since: state.since };
+    case "starting":
+      return { phase: "starting", command: commandWire(state.run.command), since: state.since };
+    case "running":
+      return {
+        phase: "running",
+        command: commandWire(state.run.command),
+        origin: state.origin,
+        origins: [...state.origins],
+        since: state.run.startedAt
+      };
+    case "stopping":
+      return state.then.kind === "restart" ? { phase: "starting", command: commandWire(state.run.command), since: state.then.since } : { phase: "stopped", command: commandWire(state.run.command) };
+    case "external":
+      return { phase: "external", origin: state.origin };
+    case "needs-command":
+      return {
+        phase: "needs-command",
+        reason: state.reason,
+        serverScripts: [...state.serverScripts],
+        ...state.proposal ? { proposal: state.proposal } : {}
+      };
+    case "blocked":
+      return { phase: "blocked", command: commandWire(state.command), missing: [...state.missing] };
+    case "stopped":
+      return { phase: "stopped", ...state.command ? { command: commandWire(state.command) } : {} };
+    case "crashed":
+      return {
+        phase: "crashed",
+        command: commandWire(state.command),
+        cause: state.cause,
+        ...state.exitCode !== void 0 ? { exitCode: state.exitCode } : {},
+        ...state.signal ? { signal: state.signal } : {},
+        tail: [...state.tail]
+      };
+  }
+}
+
+// src/dev-server/process.ts
+import { execFile, spawn as spawn5 } from "node:child_process";
+import { promisify } from "node:util";
+
+// src/dev-server/urls.ts
+var ANSI = /\x1b\[[0-?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[@-Z\\-_]/g;
+function stripAnsi(text) {
+  return text.replace(ANSI, "");
+}
+var URL_IN_TEXT = /\bhttps?:\/\/[^\s'"<>`)]+/g;
+var LOCAL_HOSTS = {
+  localhost: "localhost",
+  "127.0.0.1": "127.0.0.1",
+  "[::1]": "[::1]",
+  "0.0.0.0": "localhost",
+  "[::]": "localhost"
+};
+function localOriginsIn(line2) {
+  const found = [];
+  for (const [raw] of stripAnsi(line2).matchAll(URL_IN_TEXT)) {
+    let url;
+    try {
+      url = new URL(raw.replace(/[.,;:!?\]}]+$/, ""));
+    } catch {
+      continue;
+    }
+    const host = LOCAL_HOSTS[url.hostname];
+    if (!host) continue;
+    found.push(`${url.protocol}//${host}${url.port ? `:${url.port}` : ""}`);
+  }
+  return found;
+}
+var OriginScanner = class {
+  partial = "";
+  seen = [];
+  push(chunk) {
+    const text = this.partial + chunk;
+    const parts2 = text.split(/\r?\n/);
+    this.partial = parts2.pop() ?? "";
+    return parts2.map((line2) => this.take(line2));
+  }
+  flush() {
+    const rest = this.partial;
+    this.partial = "";
+    return rest ? [this.take(rest)] : [];
+  }
+  get origins() {
+    return this.seen;
+  }
+  take(line2) {
+    const visible = stripAnsi(line2).split("\r").at(-1) ?? "";
+    for (const origin of localOriginsIn(visible)) if (!this.seen.includes(origin)) this.seen.push(origin);
+    return visible;
+  }
+};
+function parseListeningPorts(lsofOutput) {
+  const ports = /* @__PURE__ */ new Set();
+  for (const line2 of lsofOutput.split("\n")) {
+    if (!line2.startsWith("n")) continue;
+    const port = Number(line2.slice(line2.lastIndexOf(":") + 1));
+    if (Number.isInteger(port) && port > 0 && port < 65536) ports.add(port);
+  }
+  return [...ports].sort((a, b) => a - b);
+}
+
+// src/dev-server/process.ts
+var DEV_SERVER_ENV = { BROWSER: "none" };
+var ManagedProcess = class _ManagedProcess {
+  constructor(pid) {
+    this.pid = pid;
+    this.closed = new Promise((resolve7) => this.markClosed = resolve7);
+  }
+  scanner = new OriginScanner();
+  exitedAt = null;
+  /** Settles once the leader has exited and its pipes are drained. */
+  closed;
+  markClosed;
+  /** Never throws: a shell that cannot start reports through `spawnFailed`. */
+  static launch(spec, log, listener) {
+    let child;
+    try {
+      child = spawn5(spec.line, {
+        shell: true,
+        detached: true,
+        cwd: spec.absoluteCwd,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env, ...DEV_SERVER_ENV }
+      });
+    } catch (error) {
+      const proc2 = new _ManagedProcess(void 0);
+      proc2.markClosed();
+      queueMicrotask(() => listener.spawnFailed(error instanceof Error ? error.message : String(error)));
+      return proc2;
+    }
+    const proc = new _ManagedProcess(child.pid);
+    const pid = child.pid;
+    if (pid) trackGroup(pid, spec.line);
+    const take = (chunk) => {
+      const lines = proc.scanner.push(chunk.toString());
+      if (!lines.length) return;
+      log.push(lines);
+      listener.output(lines, proc.scanner.origins);
+    };
+    child.stdout?.on("data", take);
+    child.stderr?.on("data", take);
+    child.on("exit", () => {
+      if (!pid) return;
+      try {
+        process.kill(-pid, "SIGTERM");
+      } catch {
+      }
+    });
+    child.on("error", (error) => {
+      if (pid) untrackGroup(pid);
+      if (proc.exitedAt !== null) return;
+      proc.exitedAt = Date.now();
+      proc.markClosed();
+      listener.spawnFailed(error.message);
+    });
+    child.on("close", (code, signal) => {
+      if (pid) untrackGroup(pid);
+      if (proc.exitedAt !== null) return;
+      const rest = proc.scanner.flush();
+      if (rest.length) {
+        log.push(rest);
+        listener.output(rest, proc.scanner.origins);
+      }
+      proc.exitedAt = Date.now();
+      proc.markClosed();
+      listener.exited(code, signal);
+    });
+    return proc;
+  }
+  get running() {
+    return this.pid !== void 0 && this.exitedAt === null;
+  }
+  async stop(graceMs) {
+    const pid = this.pid;
+    if (!this.running || pid === void 0) return;
+    killGroup(pid, graceMs > 0 ? "SIGTERM" : "SIGKILL");
+    const hard = setTimeout(() => killGroup(pid, "SIGKILL"), graceMs);
+    hard.unref();
+    await this.closed;
+    clearTimeout(hard);
+  }
+  async listeningOrigins() {
+    if (!this.running || this.pid === void 0) return [];
+    const pids = (await run2("pgrep", ["-g", String(this.pid)])).split(/\s+/).filter(Boolean);
+    if (!pids.length) return [];
+    const listening = await run2("lsof", ["-nP", "-iTCP", "-sTCP:LISTEN", "-a", "-p", pids.join(","), "-F", "pn"]);
+    return parseListeningPorts(listening).map((port) => `http://localhost:${port}`);
+  }
+};
+var execFileAsync = promisify(execFile);
+async function run2(file, args) {
+  try {
+    return (await execFileAsync(file, args, { encoding: "utf8", timeout: 5e3 })).stdout;
+  } catch {
+    return "";
+  }
+}
+var LogRing = class {
+  constructor(cap = DEV_SERVER_LOG_LINES) {
+    this.cap = cap;
+  }
+  lines = [];
+  dropped = 0;
+  push(lines) {
+    this.lines.push(...lines);
+    const over = this.lines.length - this.cap;
+    if (over > 0) {
+      this.lines.splice(0, over);
+      this.dropped += over;
+    }
+  }
+  tail(count2) {
+    return this.lines.slice(-count2);
+  }
+  clear() {
+    this.lines = [];
+    this.dropped = 0;
+  }
+  wire() {
+    return { lines: [...this.lines], dropped: this.dropped };
+  }
+};
+async function originAnswers(origin, timeoutMs = 1500) {
+  try {
+    const res = await fetch(origin, { redirect: "manual", signal: AbortSignal.timeout(timeoutMs) });
+    await res.body?.cancel();
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function listenerCwd(origin) {
+  let port;
+  try {
+    const url = new URL(origin);
+    port = url.port || (url.protocol === "https:" ? "443" : "80");
+  } catch {
+    return { kind: "unknown" };
+  }
+  const pid = (await run2("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"])).split(/\s+/).find(Boolean);
+  if (!pid) return { kind: "unknown" };
+  const cwd = (await run2("lsof", ["-a", "-p", pid, "-d", "cwd", "-Fn"])).split("\n").find((l) => l.startsWith("n"));
+  return cwd ? { kind: "known", path: cwd.slice(1) } : { kind: "unknown" };
+}
+
+// src/dev-server/proposal.ts
+import { randomBytes as randomBytes6 } from "node:crypto";
+import { mkdirSync as mkdirSync11, realpathSync, statSync as statSync5 } from "node:fs";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+var PROPOSAL_TIMEOUT_MS = 18e4;
+var MAX_LINE = 500;
+async function askAgentForCommand(req) {
+  try {
+    return await askOnce(req);
+  } catch (error) {
+    return { kind: "failed", error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function askOnce(req) {
+  mkdirSync11(ACP_NPM_PREFIX, { recursive: true });
+  return new Promise((settle) => {
+    let asked = false;
+    let done = false;
+    const finish = (outcome) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      req.signal.removeEventListener("abort", aborted);
+      agent.stop();
+      settle(outcome);
+    };
+    const agent = new AcpAgent({
+      command: req.agent,
+      launch: launchCommand(req.agent, ACP_NPM_PREFIX),
+      cwd: req.project,
+      onChange: () => {
+        const snap = agent.snapshot();
+        if (snap.ask) agent.decline(snap.ask.id);
+        if (snap.state === "idle" && !asked) {
+          asked = true;
+          agent.prompt(proposalPrompt(req));
+        }
+      },
+      onTurnEnd: (reply) => finish(fromReply(reply, req)),
+      onExit: (error) => finish({ kind: "failed", error: error ?? "the agent exited before it answered" })
+    });
+    const timer = setTimeout(() => finish({ kind: "failed", error: "the agent did not answer in time" }), PROPOSAL_TIMEOUT_MS);
+    const aborted = () => finish({ kind: "failed", error: "no longer needed" });
+    req.signal.addEventListener("abort", aborted, { once: true });
+  });
+}
+var REASONS = {
+  "no-package-json": "There is no package.json at the project root.",
+  "no-script": 'package.json has neither a "dev" nor a "start" script.',
+  "monorepo-root": 'This is a workspace root with neither a "dev" nor a "start" script.'
+};
+function proposingAgent(preferred, installed) {
+  const usable = (command) => {
+    const profile = agentProfileFor(command);
+    return !profile || installed(profile);
+  };
+  return [...preferred, ...AGENT_PROFILES.map((p) => p.command)].find((c) => !!c && usable(c)) ?? null;
+}
+function proposalPrompt(req) {
+  const scripts = Object.entries(req.facts.packageJson?.scripts ?? {});
+  return [
+    "ezdesign wants to start this project's local web dev server so the user can review the page.",
+    `Please propose the command that starts this project's dev server, from ${req.project}.`,
+    "",
+    `Its own rules could not decide: ${REASONS[req.undecided.reason]}`,
+    scripts.length ? `Scripts in package.json:
+${scripts.map(([name, line2]) => `- ${name}: ${line2}`).join("\n")}` : "",
+    req.facts.lockfiles.length ? `Lockfiles: ${req.facts.lockfiles.join(", ")}` : "No lockfile.",
+    "",
+    "Read files to decide; do not run anything or change anything - every such request will be declined.",
+    "Choose the one web app a designer would want to see, and the command that serves it with live reload.",
+    "End your answer with exactly one fenced json block:",
+    "```json",
+    '{"command": "pnpm --filter web dev", "cwd": ".", "reason": "one sentence"}',
+    "```",
+    "`cwd` is relative to the project root. If nothing here serves a web page, answer",
+    '`{"command": null, "reason": "one sentence"}` instead.'
+  ].filter((line2, i, all) => line2 || all[i - 1]).join("\n");
+}
+function parseProposalReply(reply) {
+  const blocks = [...reply.matchAll(/```(?:json)?\s*\n([\s\S]*?)```/g)];
+  const last = blocks.at(-1)?.[1];
+  if (!last) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(last);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+  const { command, cwd, reason } = parsed;
+  const why = typeof reason === "string" ? reason.slice(0, MAX_LINE) : "";
+  if (command === null) return { kind: "none", reason: why };
+  if (typeof command !== "string") return null;
+  const line2 = command.trim();
+  if (!line2 || line2.length > MAX_LINE || /[\0\r\n]/.test(line2)) return null;
+  const dir = typeof cwd === "string" && cwd.trim() ? cwd.trim() : ".";
+  if (isAbsolute(dir)) return null;
+  return { kind: "command", line: line2, cwd: dir, reason: why };
+}
+function fromReply(reply, req) {
+  const parsed = parseProposalReply(reply);
+  if (!parsed) return { kind: "failed", error: "the agent did not answer with a command" };
+  if (parsed.kind === "none") return { kind: "none-found", reason: parsed.reason };
+  const cwd = projectRelativePath(req.project, parsed.cwd);
+  if (cwd === null) return { kind: "failed", error: `the agent named a folder outside the project: ${parsed.cwd}` };
+  return {
+    kind: "proposed",
+    proposal: { id: randomBytes6(8).toString("hex"), agent: req.agent, line: parsed.line, cwd, reason: parsed.reason }
+  };
+}
+function projectRelativePath(project, cwd) {
+  if (isAbsolute(cwd)) return null;
+  try {
+    const root = realpathSync(project);
+    const target = realpathSync(resolve(root, cwd));
+    if (!statSync5(target).isDirectory()) return null;
+    const rel = relative(root, target);
+    return rel === "" || !rel.startsWith("..") && !rel.startsWith(sep) && !isAbsolute(rel) ? rel : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/dev-server/routes.ts
+import { Router as Router2 } from "express";
+function initiator(req) {
+  return req.body?.host === "desktop" ? "desktop" : "browser";
+}
+var field = (req, name) => req.body?.[name];
+function devServerApiRouter(devServer) {
+  const router = Router2();
+  router.get("/dev-server/log", (_req, res) => {
+    res.set("cache-control", "no-store").json(devServer.logWire());
+  });
+  router.post("/dev-server/start", (req, res) => {
+    devServer.ensure(initiator(req));
+    res.status(202).json({ ok: true });
+  });
+  router.post("/dev-server/restart", (req, res) => {
+    devServer.restart(initiator(req));
+    res.status(202).json({ ok: true });
+  });
+  router.post("/dev-server/stop", async (_req, res) => {
+    if (devServer.external) return void res.status(409).json({ error: "this dev server was not started here" });
+    await devServer.stop();
+    res.json({ ok: true });
+  });
+  router.post("/dev-server/command", (req, res) => {
+    const line2 = field(req, "line");
+    const cwd = field(req, "cwd") ?? "";
+    if (typeof line2 !== "string" || typeof cwd !== "string") {
+      return void res.status(400).json({ error: "line and cwd must be strings" });
+    }
+    const proposalId = field(req, "proposalId");
+    const choice = { line: line2, cwd, ...typeof proposalId === "string" ? { proposalId } : {} };
+    const outcome = devServer.saveCommandAndRun(choice, initiator(req));
+    if (outcome === "invalid-line") return void res.status(400).json({ error: "the command must be one line of 1-500 characters" });
+    if (outcome === "invalid-cwd") return void res.status(400).json({ error: "the folder must be inside the project" });
+    res.status(202).json({ ok: true });
+  });
+  router.delete("/dev-server/command", (_req, res) => {
+    devServer.forgetCommand();
+    res.json({ ok: true });
+  });
+  router.post("/dev-server/propose", (_req, res) => {
+    devServer.askAgentAgain();
+    res.status(202).json({ ok: true });
+  });
+  router.post("/dev-server/origin", (req, res) => {
+    const origin = field(req, "origin");
+    if (typeof origin !== "string" || !devServer.pickOrigin(origin)) {
+      return void res.status(404).json({ error: "not an origin this dev server printed" });
+    }
+    res.json({ ok: true });
+  });
+  return router;
+}
+
+// src/dev-server/index.ts
+function isTheAgentsProposal(offered, proposalId, line2, cwd) {
+  return !!offered && proposalId === offered.id && offered.line === line2 && offered.cwd === cwd;
+}
+var CRASH_TAIL_LINES = 30;
+var PORT_SCAN_EVERY_MS = 1e3;
+var MAX_LINE2 = 500;
+var DevServer = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  machine = INITIAL;
+  live = null;
+  log = new LogRing();
+  proposal = null;
+  startPreview = null;
+  snapshot() {
+    const wire = toWire(this.machine.state);
+    if (wire.phase !== "idle" && wire.phase !== "stopped" || wire.command) return wire;
+    const { command } = this.upcoming();
+    return command ? { ...wire, command } : wire;
+  }
+  summary() {
+    const wire = toWire(this.machine.state);
+    return "origin" in wire ? { phase: wire.phase, origin: wire.origin } : { phase: wire.phase };
+  }
+  offersApp() {
+    return this.machine.state.phase !== "idle" || this.upcoming().runnable;
+  }
+  logWire() {
+    return this.log.wire();
+  }
+  /** Idempotent: a no-op while starting, running or external; from anywhere
+   *  else it reuses (D7), runs, or waits for a command. Never throws and never
+   *  waits - progress arrives through `onChange`. */
+  ensure(by) {
+    this.dispatch({ type: "ensure", now: Date.now(), by });
+  }
+  restart(by) {
+    this.dispatch({ type: "restart", now: Date.now(), by });
+  }
+  get managedBy() {
+    const state = this.machine.state;
+    return state.phase === "starting" || state.phase === "running" || state.phase === "stopping" ? state.run.by : null;
+  }
+  get external() {
+    return this.machine.state.phase === "external";
+  }
+  /** The daemon is exiting: the group goes, gracefully, and what the record
+   *  says to resume stays for the next daemon. */
+  async release() {
+    if (this.live?.process.running) await this.live.process.stop(DEV_SERVER_STOP_GRACE_MS);
+  }
+  /** Resolves once the process group is gone (or at once when there was none).
+   *  A server this daemon did not start is left alone (D7). */
+  async stop() {
+    const live3 = this.live;
+    this.dispatch({ type: "stop" });
+    if (live3?.process.running) await live3.process.closed;
+  }
+  saveCommandAndRun(choice, by) {
+    const line2 = choice.line.trim();
+    if (!line2 || line2.length > MAX_LINE2 || /[\0\r\n]/.test(line2)) return "invalid-line";
+    const cwd = projectRelativePath(this.deps.project, choice.cwd.trim() || ".");
+    if (cwd === null) return "invalid-cwd";
+    const source = isTheAgentsProposal(this.proposal?.live, choice.proposalId, line2, cwd) ? "agent" : "user";
+    this.writeRecord({ ...this.readRecord(), command: { line: line2, cwd, source, decidedAt: Date.now() } });
+    this.dispatch({ type: "confirmed", now: Date.now(), by });
+    return "started";
+  }
+  askAgentAgain() {
+    this.dispatch({ type: "ask-again" });
+  }
+  forgetCommand() {
+    const { command: _, ...rest } = this.readRecord();
+    this.writeRecord(rest);
+    this.startPreview = null;
+    this.dispatch({ type: "command-forgotten" });
+    this.deps.onChange();
+  }
+  pickOrigin(origin) {
+    const state = this.machine.state;
+    if (state.phase !== "running" || !state.origins.includes(origin)) return false;
+    this.dispatch({ type: "origin-picked", origin });
+    return true;
+  }
+  resume() {
+    const resume = this.readRecord().resume;
+    if (resume) this.ensure(resume.by);
+  }
+  forgetResume() {
+    const record = this.readRecord();
+    if (!record.resume) return;
+    const { resume: _, ...rest } = record;
+    this.writeRecord(rest);
+  }
+  dispatch(event) {
+    const { machine, effects, stateChanged } = step(this.machine, event);
+    if (this.proposal && machine.state.phase !== "needs-command") {
+      this.proposal.abort.abort();
+      this.proposal = null;
+    }
+    this.machine = machine;
+    if (stateChanged) this.startPreview = null;
+    for (const effect of effects) this.perform(effect);
+    if (stateChanged) this.deps.onChange();
+  }
+  dispatchAfterThisStep(event) {
+    queueMicrotask(() => this.dispatch(event));
+  }
+  reportAlreadyExited(runId) {
+    this.dispatchAfterThisStep({ type: "exited", runId, code: null, signal: null, tail: this.log.tail(CRASH_TAIL_LINES) });
+  }
+  perform(effect) {
+    switch (effect.type) {
+      case "resolve": {
+        const { attempt } = effect;
+        void this.resolve().then((resolution) => this.dispatch({ type: "resolved", attempt, resolution, now: Date.now() }));
+        return;
+      }
+      case "spawn": {
+        const { run: run4 } = effect;
+        const runId = run4.id;
+        this.log.clear();
+        this.log.push([`$ ${run4.command.line}`]);
+        const spec = { line: run4.command.line, absoluteCwd: join15(this.deps.project, run4.command.cwd) };
+        const managed = ManagedProcess.launch(spec, this.log, {
+          output: (_, origins) => this.dispatch({ type: "origins", runId, origins }),
+          exited: (code, signal) => this.dispatch({ type: "exited", runId, code, signal, tail: this.log.tail(CRASH_TAIL_LINES) }),
+          spawnFailed: (error) => this.dispatch({ type: "spawn-failed", runId, error })
+        });
+        this.live = { runId, process: managed };
+        return;
+      }
+      case "arm-timers": {
+        const { runId } = effect;
+        setTimeout(() => this.dispatch({ type: "scan-due", runId }), DEV_SERVER_PORT_SCAN_AFTER_MS).unref();
+        setTimeout(
+          () => this.dispatch({ type: "ready-timeout", runId, tail: this.log.tail(CRASH_TAIL_LINES) }),
+          DEV_SERVER_READY_MS
+        ).unref();
+        return;
+      }
+      case "scan-ports": {
+        const { runId } = effect;
+        const managed = this.live?.runId === runId ? this.live.process : null;
+        if (!managed) return;
+        void (async () => {
+          for (const origin of await managed.listeningOrigins()) {
+            if (await originAnswers(origin)) return this.dispatch({ type: "port-found", runId, origin });
+          }
+          setTimeout(() => this.dispatch({ type: "scan-due", runId }), PORT_SCAN_EVERY_MS).unref();
+        })();
+        return;
+      }
+      case "kill": {
+        const { runId } = effect;
+        const managed = this.live?.runId === runId ? this.live.process : null;
+        if (managed?.running) void managed.stop(DEV_SERVER_STOP_GRACE_MS);
+        else this.reportAlreadyExited(runId);
+        return;
+      }
+      case "confirm-external": {
+        const { runId, origin, tail } = effect;
+        void originAnswers(origin).then(
+          (alive) => this.dispatch(alive ? { type: "external-confirmed", runId, origin } : { type: "external-gone", runId, tail })
+        );
+        return;
+      }
+      case "attach":
+        return this.deps.attach(effect.origin);
+      case "detach":
+        return this.deps.detachLeavingRecord(effect.origin);
+      case "ask-agent": {
+        this.proposal?.abort.abort();
+        this.proposal = null;
+        const agent = this.deps.proposingAgent();
+        if (!agent) return;
+        const asking = { live: null, abort: new AbortController() };
+        this.proposal = asking;
+        this.dispatchAfterThisStep({ type: "proposal", proposal: { state: "asking", agent } });
+        const facts = readProjectFacts(this.deps.project);
+        const undecided = detectDevCommand(facts);
+        if (undecided.kind !== "undecided") return;
+        void askAgentForCommand({ agent, project: this.deps.project, facts, undecided, signal: asking.abort.signal }).then(
+          (outcome) => {
+            if (this.proposal !== asking) return;
+            if (outcome.kind === "proposed") asking.live = outcome.proposal;
+            this.dispatch({
+              type: "proposal",
+              proposal: outcome.kind === "proposed" ? { state: "proposed", ...outcome.proposal } : outcome.kind === "none-found" ? { state: "none-found", agent, reason: outcome.reason } : { state: "failed", agent, error: outcome.error }
+            });
+          }
+        );
+        return;
+      }
+      case "persist-resume": {
+        const { resume: _, ...rest } = this.readRecord();
+        this.writeRecord(effect.resume ? { ...rest, resume: effect.resume } : rest);
+        return;
+      }
+    }
+  }
+  async resolve() {
+    await this.deps.environmentReady();
+    const recorded = this.deps.userAttachedOrigin();
+    if (recorded && !this.deps.heldElsewhere(recorded) && await originAnswers(recorded)) {
+      const cwd = await listenerCwd(recorded);
+      if (cwd.kind === "unknown" || this.contains(cwd.path)) return { kind: "external", origin: recorded };
+    }
+    const stored = this.storedCommand();
+    let command;
+    let tools;
+    if (stored) {
+      command = stored;
+      tools = toolsForLine(stored.line);
+    } else {
+      const detection = detectDevCommand(readProjectFacts(this.deps.project));
+      if (detection.kind === "undecided") {
+        return { kind: "undecided", reason: detection.reason, serverScripts: detection.serverScripts };
+      }
+      command = { line: commandLine(detection.command), cwd: "", source: "detected" };
+      tools = requiredTools(detection.command);
+    }
+    const missing = missingTools(tools, (binary) => findExecutable(binary, process.env.PATH));
+    return missing.length ? { kind: "blocked", command, missing } : { kind: "run", command };
+  }
+  contains(path) {
+    try {
+      return projectRelativePath(this.deps.project, relative2(realpathSync2(this.deps.project), path)) !== null;
+    } catch {
+      return false;
+    }
+  }
+  upcoming() {
+    if (this.startPreview) return this.startPreview;
+    const stored = this.storedCommand();
+    if (stored) return this.startPreview = { command: stored, runnable: true };
+    const detection = detectDevCommand(readProjectFacts(this.deps.project));
+    this.startPreview = detection.kind === "command" ? { command: { line: commandLine(detection.command), cwd: "", source: "detected" }, runnable: true } : { command: null, runnable: detection.reason === "monorepo-root" || detection.serverScripts.length > 0 };
+    return this.startPreview;
+  }
+  readRecord() {
+    try {
+      return JSON.parse(readFileSync13(join15(this.deps.dir, RECORD_FILE), "utf8"));
+    } catch {
+      return {};
+    }
+  }
+  writeRecord(record) {
+    writeAtomic(join15(this.deps.dir, RECORD_FILE), `${JSON.stringify(record, null, 2)}
+`);
+  }
+  storedCommand() {
+    const stored = this.readRecord().command;
+    return stored ? { line: stored.line, cwd: stored.cwd, source: stored.source } : null;
+  }
+};
+var RECORD_FILE = "dev-server.json";
+
+// src/desktop-wire.ts
+var DESKTOP_CONTRACT = 1;
+var DESKTOP_HEADER = "x-ezdesign-desktop";
+
+// src/projects/book.ts
+import { existsSync as existsSync8, readFileSync as readFileSync14 } from "node:fs";
+import { basename } from "node:path";
+var ProjectBook = class {
+  constructor(sessions, file = PROJECTS_FILE) {
+    this.file = file;
+    this.entries = readBook(file);
+    this.withSession = new Map([...sessions].map((s) => [s.project, { createdAt: s.createdAt }]));
+  }
+  entries;
+  withSession;
+  markUsed(project, now) {
+    if (!this.withSession.has(project)) this.withSession.set(project, { createdAt: now });
+    this.update(project, { usedAt: now });
+  }
+  add(project, now) {
+    this.update(project, { addedAt: now });
+  }
+  hide(project, now) {
+    if (this.isListed(project)) this.update(project, { hiddenAt: now });
+  }
+  isListed(project) {
+    return this.entries.has(project) || this.withSession.has(project);
+  }
+  list() {
+    return mergeProjects(this.entries, this.withSession, (project) => existsSync8(project));
+  }
+  update(project, change) {
+    this.entries.set(project, { ...this.entries.get(project), ...change });
+    const file = { version: 1, projects: Object.fromEntries(this.entries) };
+    writeAtomic(this.file, `${JSON.stringify(file, null, 2)}
+`);
+  }
+};
+var isHidden = (entry) => entry.hiddenAt !== void 0 && entry.hiddenAt >= Math.max(entry.usedAt ?? 0, entry.addedAt ?? 0);
+var byName = new Intl.Collator("en", { sensitivity: "base", numeric: true });
+function mergeProjects(entries3, sessions, exists) {
+  const rows = [];
+  for (const project of /* @__PURE__ */ new Set([...entries3.keys(), ...sessions.keys()])) {
+    const entry = entries3.get(project) ?? {};
+    if (isHidden(entry)) continue;
+    const usedAt = entry.usedAt ?? entry.addedAt ?? sessions.get(project)?.createdAt ?? null;
+    rows.push({ project, name: basename(project), usedAt, exists: exists(project) });
+  }
+  return rows.sort((a, b) => byName.compare(a.name, b.name) || byName.compare(a.project, b.project));
+}
+function readBook(file) {
+  try {
+    const parsed = JSON.parse(readFileSync14(file, "utf8"));
+    return new Map(Object.entries(parsed.projects ?? {}));
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+
+// src/projects/hub.ts
+import { statSync as statSync6 } from "node:fs";
+import { isAbsolute as isAbsolute2 } from "node:path";
+var ProjectHub = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  listeners = /* @__PURE__ */ new Set();
+  touched = false;
+  list() {
+    const runtimes = new Map(this.deps.sessions.list().map((r) => [r.project, r]));
+    const projects = this.deps.book.list().map((row) => {
+      const runtime = runtimes.get(row.project);
+      return {
+        ...row,
+        session: runtime ? { devServer: runtime.devServer.summary(), agentWorking: runtime.agentWorking } : null
+      };
+    });
+    return { version: this.deps.version, projects, account: this.deps.account() };
+  }
+  add(path) {
+    if (!isAbsolute2(path) || !statSync6(path, { throwIfNoEntry: false })?.isDirectory()) {
+      return { error: "not a folder on this computer" };
+    }
+    const project = this.deps.projectRoot(path);
+    this.deps.book.add(project, Date.now());
+    this.changed();
+    return this.list().projects.find((p) => p.project === project);
+  }
+  hide(project) {
+    this.deps.book.hide(project, Date.now());
+    this.changed();
+  }
+  /** Opens the review and connects its agent; the dev server waits for the user to start it. */
+  async open(project, by) {
+    if (!this.deps.book.isListed(project)) return { ok: false, status: 404, error: "not a project on the list" };
+    await this.deps.restored();
+    const opened = await this.deps.sessions.open({ project, reopen: true, now: Date.now() });
+    if (!opened.ok) return { ok: false, status: 404, error: "the review could not be opened" };
+    opened.runtime.ensureAgent(this.deps.defaultAgent(), by);
+    this.changed();
+    return { project, shellUrl: opened.runtime.shellUrl() };
+  }
+  async stop(project) {
+    const runtime = this.deps.sessions.list().find((r) => r.project === project);
+    if (runtime && !runtime.devServer.external) await runtime.devServer.stop();
+  }
+  async stopManagedBy(by) {
+    const targets = this.deps.sessions.list().filter((r) => r.devServer.managedBy === by);
+    await Promise.all(targets.map((r) => r.devServer.stop()));
+    return targets.length;
+  }
+  disconnectAgentsOf(by) {
+    return this.deps.sessions.list().filter((r) => r.disconnectAgentOf(by)).length;
+  }
+  changed() {
+    for (const listener of this.listeners) listener();
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    this.touched = true;
+    return () => this.listeners.delete(listener);
+  }
+  takeBusy() {
+    const busy = this.touched || this.listeners.size > 0;
+    this.touched = false;
+    return busy;
+  }
+};
+
+// src/projects/routes.ts
+import { readFileSync as readFileSync15 } from "node:fs";
+import { join as join16 } from "node:path";
+import { Router as Router3 } from "express";
+
+// src/version-header.ts
+var VERSION_HEADER = "x-ezdesign-version";
+
+// src/version.ts
+function versionMismatchBody(cliVersion, daemonVersion) {
+  return {
+    error: cliVersion ? `this ${APP_NAME} CLI is v${cliVersion} but the daemon is running v${daemonVersion}` : `this ${APP_NAME} CLI predates the running daemon (v${daemonVersion})`,
+    hint: `re-run as \`npx -y ${NPM_PACKAGE}@latest <url>\` to bring both to the current version`
+  };
+}
+function versionGate(daemonVersion) {
+  return (req, res, next) => {
+    const cliVersion = req.get(VERSION_HEADER) || void 0;
+    if (cliVersion === daemonVersion) return next();
+    res.status(409).json(versionMismatchBody(cliVersion, daemonVersion));
+  };
+}
+function desktopContractGate(served = DESKTOP_CONTRACT) {
+  return (req, res, next) => {
+    const asked = Number(req.get(DESKTOP_HEADER));
+    if (Number.isInteger(asked) && asked >= 1 && asked <= served) return next();
+    res.status(409).json({ error: `this ${APP_NAME} daemon serves desktop contracts up to ${served}` });
+  };
+}
+
+// src/projects/routes.ts
+var field2 = (req, name) => req.body?.[name];
+function projectsApiRouter(hub, opts) {
+  const router = Router3();
+  router.use("/projects", refuseCrossSite(opts.origin));
+  router.get("/projects/events", (req, res) => {
+    res.set({ "content-type": "text/event-stream", "cache-control": "no-store", connection: "keep-alive" });
+    res.flushHeaders();
+    const push = () => res.write(`data: ${JSON.stringify(hub.list())}
+
+`);
+    push();
+    const unsubscribe = hub.subscribe(push);
+    req.on("close", unsubscribe);
+  });
+  router.use("/projects", versionGate(opts.version));
+  router.get("/projects", (_req, res) => {
+    res.set("cache-control", "no-store").json(hub.list());
+  });
+  router.post("/projects/open", async (req, res) => {
+    const project = field2(req, "project");
+    if (typeof project !== "string") return void res.status(400).json({ error: "project required" });
+    const opened = await hub.open(project, field2(req, "host") === "desktop" ? "desktop" : "browser");
+    if ("ok" in opened) return void res.status(opened.status).json({ error: opened.error });
+    res.json(opened);
+  });
+  router.post("/projects/stop", async (req, res) => {
+    const project = field2(req, "project");
+    if (typeof project !== "string") return void res.status(400).json({ error: "project required" });
+    await hub.stop(project);
+    res.json({ ok: true });
+  });
+  router.post("/projects", (req, res) => {
+    const path = field2(req, "path");
+    if (typeof path !== "string") return void res.status(400).json({ error: "path required" });
+    const added = hub.add(path.trim());
+    if ("error" in added) return void res.status(400).json(added);
+    res.json(added);
+  });
+  router.post("/projects/hide", (req, res) => {
+    const project = field2(req, "project");
+    if (typeof project !== "string") return void res.status(400).json({ error: "project required" });
+    hub.hide(project);
+    res.json({ ok: true });
+  });
+  return router;
+}
+var homeHtml = (version, icon) => `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${APP_NAME}</title>
+<link rel="icon" href="${icon}">
+<link rel="stylesheet" href="${URL_PREFIX}/home.css">
+</head>
+<body>
+<div id="ez-home"></div>
+<script src="${URL_PREFIX}/home.js" data-version="${version}"></script>
+</body>
+</html>`;
+function homePageRouter(opts) {
+  const router = Router3();
+  router.get(HOME_PATH, (_req, res) => res.type("html").set("cache-control", "no-store").send(homeHtml(opts.version, opts.icon)));
+  for (const file of ["home.js", "home.css"]) {
+    router.get(`${URL_PREFIX}/${file}`, (_req, res) => {
+      res.type(file.endsWith(".css") ? "text/css" : "text/javascript").set("cache-control", "no-store").send(readFileSync15(join16(opts.distDir, file)));
+    });
+  }
+  return router;
+}
+
+// src/project-root.ts
+import { existsSync as existsSync9 } from "node:fs";
+import { dirname as dirname5, join as join17, parse, resolve as resolve2 } from "node:path";
+function projectRoot(from) {
+  let dir = resolve2(from);
+  const { root } = parse(dir);
+  for (; ; ) {
+    if (existsSync9(join17(dir, ".git")) || existsSync9(join17(dir, "package.json"))) return dir;
+    if (dir === root) return resolve2(from);
+    dir = dirname5(dir);
+  }
+}
+
+// src/explore.ts
+var MAX_VARIANT_HTML = 32 * 1024;
+var MAX_VARIANT_NAME = 40;
+var FORBIDDEN_TAGS = ["script", "iframe", "object", "embed", "link", "meta", "base"];
+function variantProblemMessage(problem) {
+  switch (problem.code) {
+    case "empty":
+      return "html is empty. Send the markup for one element.";
+    case "too-long":
+      return `html is ${problem.length} bytes; the limit is ${MAX_VARIANT_HTML}. Send one element's markup, not a page.`;
+    case "name-too-long":
+      return `name is ${problem.length} characters; the limit is ${MAX_VARIANT_NAME}. A short label, not a description.`;
+    case "forbidden-tag":
+      return `html contains <${problem.tag}>, which a variant may not use. A variant is markup and CSS only - no scripts, no embeds, no external resources.`;
+    case "event-handler":
+      return `html sets the inline handler ${problem.attribute}. A variant is markup and CSS only - no scripts.`;
+    case "javascript-url":
+      return "html contains a javascript: url. A variant is markup and CSS only - no scripts.";
+    case "not-one-root":
+      return problem.roots === 0 ? "html has no element at its top level. A variant is one root element, optionally with a <style> block inside it." : `html has ${problem.roots} top-level elements. A variant is one root element - wrap them in a single container.`;
+  }
+}
+function checkVariant(name, html) {
+  if (name.length > MAX_VARIANT_NAME) return { code: "name-too-long", length: name.length };
+  if (!html.trim()) return { code: "empty" };
+  if (html.length > MAX_VARIANT_HTML) return { code: "too-long", length: html.length };
+  const tags = scanTags(html);
+  if (!tags) return { code: "not-one-root", roots: 0 };
+  for (const tag of tags.names) {
+    if (FORBIDDEN_TAGS.includes(tag)) return { code: "forbidden-tag", tag };
+  }
+  const handler = /\son([a-z]+)\s*=/i.exec(html);
+  if (handler) return { code: "event-handler", attribute: `on${handler[1].toLowerCase()}` };
+  if (/javascript:/i.test(html)) return { code: "javascript-url" };
+  if (tags.roots !== 1) return { code: "not-one-root", roots: tags.roots };
+  return null;
+}
+var VOID_TAGS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+function scanTags(html) {
+  const names2 = [];
+  let depth = 0;
+  let roots = 0;
+  let i = 0;
+  while (i < html.length) {
+    const lt = html.indexOf("<", i);
+    if (lt === -1) break;
+    if (html.startsWith("<!--", lt)) {
+      const end2 = html.indexOf("-->", lt + 4);
+      i = end2 === -1 ? html.length : end2 + 3;
+      continue;
+    }
+    if (html.startsWith("<!", lt) || html.startsWith("<?", lt)) {
+      const end2 = html.indexOf(">", lt);
+      i = end2 === -1 ? html.length : end2 + 1;
+      continue;
+    }
+    const tag = /^<(\/?)([a-zA-Z][a-zA-Z0-9-]*)/.exec(html.slice(lt, lt + 64));
+    if (!tag) {
+      i = lt + 1;
+      continue;
+    }
+    const end = closingBracket(html, lt);
+    if (end === -1) break;
+    const closing = tag[1] === "/";
+    const name = tag[2].toLowerCase();
+    names2.push(name);
+    const selfClosing = html[end - 1] === "/";
+    if (closing) {
+      if (depth === 0) return null;
+      depth -= 1;
+    } else if (!selfClosing && !VOID_TAGS.has(name)) {
+      if (depth === 0) roots += 1;
+      depth += 1;
+    } else if (depth === 0) {
+      roots += 1;
+    }
+    i = end + 1;
+    if (!closing && RAW_TEXT2.has(name) && !selfClosing) {
+      const close = html.toLowerCase().indexOf(`</${name}`, i);
+      if (close === -1) break;
+      i = close;
+    }
+  }
+  return { names: names2, roots };
+}
+var RAW_TEXT2 = /* @__PURE__ */ new Set(["style", "script", "textarea", "title"]);
+function closingBracket(html, from) {
+  let quote = null;
   for (let i = from + 1; i < html.length; i += 1) {
     const ch = html[i];
     if (quote) {
@@ -4972,7 +6739,7 @@ function point2(v) {
   const r = typeof rel === "object" && rel !== null ? rel : {};
   return { x: px2, y: py, rel: { x: num(r.x) ?? 0, y: num(r.y) ?? 0 } };
 }
-function rect(v) {
+function rect2(v) {
   if (typeof v !== "object" || v === null) return void 0;
   const { x, y, width, height } = v;
   const vals = [num(x), num(y), num(width), num(height)];
@@ -5008,7 +6775,7 @@ function sanitizeAnchor(raw) {
   if (page) out.page = page;
   const p = point2(v.point);
   if (p) out.point = p;
-  const r = rect(v.rect);
+  const r = rect2(v.rect);
   if (r) out.rect = r;
   const vp = viewport(v.viewport);
   if (vp) out.viewport = vp;
@@ -5185,8 +6952,8 @@ function parseBatchView(raw) {
 }
 
 // src/truth.ts
-import { existsSync as existsSync8 } from "node:fs";
-import { join as join13, resolve } from "node:path";
+import { existsSync as existsSync10 } from "node:fs";
+import { join as join18, resolve as resolve3 } from "node:path";
 var PRODUCT_MD = "PRODUCT.md";
 var DESIGN_MD = "DESIGN.md";
 function designHarnessEnabled(env = process.env) {
@@ -5201,8 +6968,8 @@ function effortLine(effort) {
 var FILE_NAME = { product: PRODUCT_MD, design: DESIGN_MD };
 function truthState(project, enabled, seen = false) {
   return {
-    product: existsSync8(join13(project, PRODUCT_MD)),
-    design: existsSync8(join13(project, DESIGN_MD)),
+    product: existsSync10(join18(project, PRODUCT_MD)),
+    design: existsSync10(join18(project, DESIGN_MD)),
     enabled,
     seen
   };
@@ -5234,10 +7001,10 @@ function harnessReady(truth) {
   return truth.enabled && truth.product && truth.design;
 }
 function skillDir(fromDir) {
-  return resolve(fromDir, "..", "skills", "ezdesign");
+  return resolve3(fromDir, "..", "skills", "ezdesign");
 }
 function skillReference(skill, name) {
-  return join13(skill, "reference", `${name}.md`);
+  return join18(skill, "reference", `${name}.md`);
 }
 var names = (files) => files.map((f) => `\`${FILE_NAME[f]}\``);
 function truthFilesZh(files) {
@@ -5255,7 +7022,7 @@ function creationSteps(missing, skill) {
   steps.push("stack");
   if (missing.includes("design")) steps.push("design");
   steps.push("components");
-  return steps.map((step) => `read \`${skillReference(skill, step)}\` and follow it`);
+  return steps.map((step2) => `read \`${skillReference(skill, step2)}\` and follow it`);
 }
 function makeReading(skill, effort = "high") {
   const files = ["make", "baseline", ...effort === "low" ? [] : ["principles"]].map(
@@ -5505,55 +7272,90 @@ function toAgentAttachment(a, files) {
     mime: a.mime,
     size: a.size,
     path: files.attachmentPath(a),
-    ...a.origin ? { origin: a.origin } : {}
+    ...a.origin ? { origin: a.origin } : {},
+    ...a.video && a.video.state !== "pending" ? { video: toAgentVideo(a, a.video, files) } : {}
+  };
+}
+var READ_FRAMES = "A recording you cannot open: do not read `path`. Read `overview` first, then the `sheet` of each stretch of `motion` you need. A sheet is a grid of frames in time order, left to right, each labelled with its time in seconds; a motion sheet is cropped to `region` (pixels of the video) and starts with the frame before the motion, so consecutive labels give you its timing and easing. `shown` < `frames` means only that many of its changed frames are on the sheet, evenly spaced.";
+var READ_AUDIO = " It has sound you cannot hear: if it may matter, ask the user what is said.";
+var UNREADABLE = {
+  "unsupported-browser": () => "the browser the review ran in cannot decode video",
+  "unsupported-codec": (detail) => `that browser cannot decode its codec (${detail})`,
+  unreadable: (detail) => `its file could not be read as a video (${detail})`,
+  crashed: () => "the browser stopped while taking them"
+};
+var seconds = (ms) => Math.round(ms) / 1e3;
+function toAgentVideo(a, video, files) {
+  if (video.state === "failed") {
+    return {
+      read: `No frames could be taken from this video: ${UNREADABLE[video.reason](video.detail)}. Do not try to read \`path\`. Tell the user, and ask them what it shows.`,
+      unreadable: video.reason
+    };
+  }
+  return {
+    read: READ_FRAMES + (video.audio ? READ_AUDIO : ""),
+    duration: seconds(video.durationMs),
+    width: video.width,
+    height: video.height,
+    fps: video.fps,
+    audio: video.audio,
+    overview: files.sheetPath(a, 1),
+    motion: video.motion.map((m) => ({
+      from: seconds(m.fromMs),
+      to: seconds(m.toMs),
+      region: m.region,
+      frames: m.frames,
+      shown: m.shown,
+      ...m.sheet === null ? {} : { sheet: files.sheetPath(a, m.sheet) }
+    }))
   };
 }
 function toAgentAttachments(list2, files) {
   return list2?.length ? list2.map((a) => toAgentAttachment(a, files)) : void 0;
 }
 function anchorParts(anchor, textMax, withViewport, frames) {
-  const parts = [];
-  if (anchor.source) parts.push(anchor.source);
-  if (anchor.components?.length) parts.push(`<${anchor.components.join(" \u2190 ")}>`);
-  if (anchor.section) parts.push(`[section: ${anchor.section}]`);
-  if (anchor.text) parts.push(`"${truncate(anchor.text, textMax)}"`);
+  const parts2 = [];
+  if (anchor.source) parts2.push(anchor.source);
+  if (anchor.components?.length) parts2.push(`<${anchor.components.join(" \u2190 ")}>`);
+  if (anchor.section) parts2.push(`[section: ${anchor.section}]`);
+  if (anchor.text) parts2.push(`"${truncate(anchor.text, textMax)}"`);
   if (anchor.contains?.length) {
-    parts.push(`[framed ${anchor.contains.length}: ${anchor.contains.join("; ")}]`);
+    parts2.push(`[framed ${anchor.contains.length}: ${anchor.contains.join("; ")}]`);
   }
   if (withViewport && anchor.viewport) {
     const { width, height, preset } = anchor.viewport;
-    parts.push(preset ? `@${preset} ${width}x${height}` : `@${width}x${height}`);
+    parts2.push(preset ? `@${preset} ${width}x${height}` : `@${width}x${height}`);
   }
   if (anchor.frame) {
     const named = frames?.(anchor.frame);
-    parts.push(
+    parts2.push(
       named ? `[canvas frame "${named.frame}" on canvas "${named.canvas}"]` : `[canvas frame ${anchor.frame.canvasId}/${anchor.frame.frameId}]`
     );
   }
-  if (parts.length === 0 && anchor.selector) parts.push(anchor.selector);
-  return parts;
+  if (parts2.length === 0 && anchor.selector) parts2.push(anchor.selector);
+  return parts2;
 }
 function referenceLabel(reference, frames) {
   return anchorParts(reference.anchor, 40, false, frames).join(" \xB7 ") || reference.label;
 }
 function toAgentItem(a, files, frames) {
-  const parts = anchorParts(a.anchor, a.kind === "text" ? 60 : 40, true, frames);
-  if (a.kind === "page") parts.unshift(`[page ${a.anchor.page ?? ""}]`.trim());
+  const parts2 = anchorParts(a.anchor, a.kind === "text" ? 60 : 40, true, frames);
+  if (a.kind === "page") parts2.unshift(`[page ${a.anchor.page ?? ""}]`.trim());
   if (a.kind === "point") {
     const rel = a.anchor.point?.rel;
     const at = rel ? ` ${Math.round(rel.x * 100)}%/${Math.round(rel.y * 100)}%` : "";
-    parts.unshift(`[pin${at}]`);
+    parts2.unshift(`[pin${at}]`);
   }
   a.references?.forEach(
-    (r) => parts.push(`[ref ${r.n}: ${r.variant ? "chosen variant \xB7 " : ""}${referenceLabel(r, frames)}]`)
+    (r) => parts2.push(`[ref ${r.n}: ${r.variant ? "chosen variant \xB7 " : ""}${referenceLabel(r, frames)}]`)
   );
-  a.attachments?.forEach((x, i) => parts.push(`[file ${i + 1}: ${x.name}]`));
+  a.attachments?.forEach((x, i) => parts2.push(`[file ${i + 1}: ${x.name}${x.video ? ", video" : ""}]`));
   const attachments = toAgentAttachments(a.attachments, files);
   return {
     id: a.id,
     kind: a.kind,
     comment: a.comment,
-    label: parts.join(" \xB7 "),
+    label: parts2.join(" \xB7 "),
     anchor: a.anchor,
     ...attachments ? { attachments } : {},
     ...a.references?.length ? { references: a.references } : {}
@@ -5717,103 +7519,218 @@ function register(server, sink) {
     }
   );
 }
-
-// src/skills.ts
-import { readFileSync as readFileSync11, readdirSync as readdirSync6 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { join as join14 } from "node:path";
-var SKILL_DIRS = [".claude/skills", ".agents/skills"];
-function readFrontmatter(path) {
-  let text;
+
+// src/skills.ts
+import { readFileSync as readFileSync16, readdirSync as readdirSync6, statSync as statSync7 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join19 } from "node:path";
+var SKILL_DIRS = [".claude/skills", ".agents/skills"];
+function readFrontmatter(path) {
+  let text;
+  try {
+    text = readFileSync16(path, "utf8");
+  } catch {
+    return null;
+  }
+  if (!text.startsWith("---")) return null;
+  const end = text.indexOf("\n---", 3);
+  if (end === -1) return null;
+  const fields = {};
+  for (const line2 of text.slice(3, end).split("\n")) {
+    const match = /^(name|description|user-invocable):\s*(.*)$/.exec(line2);
+    if (!match) continue;
+    const value = match[2].trim().replace(/^['"]|['"]$/g, "");
+    if (value) fields[match[1]] = value;
+  }
+  return fields;
+}
+function entries2(dir) {
+  try {
+    return readdirSync6(dir, { withFileTypes: true }).filter((e) => !e.name.startsWith(".") && (e.isDirectory() || e.isSymbolicLink() && isDir(join19(dir, e.name)))).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+function isDir(path) {
+  try {
+    return statSync7(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function readSkill(dir, name, source) {
+  const fields = readFrontmatter(join19(dir, name, "SKILL.md"));
+  if (!fields) return null;
+  if (fields["user-invocable"]?.toLowerCase() === "false") return null;
+  return { name, description: fields.description ?? "", source };
+}
+function listSkills(project, home = homedir4()) {
+  const found = /* @__PURE__ */ new Map();
+  const roots = [
+    [home, "user"],
+    [project, "project"]
+  ];
+  for (const [root, source] of roots) {
+    for (const dir of SKILL_DIRS) {
+      const container = join19(root, dir);
+      for (const name of entries2(container)) {
+        const skill = readSkill(container, name, source);
+        if (skill) found.set(skill.name, skill);
+      }
+    }
+  }
+  const plugins = join19(project, ".claude/plugins");
+  for (const plugin of entries2(plugins)) {
+    const container = join19(plugins, plugin, "skills");
+    for (const name of entries2(container)) {
+      const skill = readSkill(container, name, "plugin");
+      if (skill) found.set(`${plugin}:${name}`, { ...skill, name: `${plugin}:${name}` });
+    }
+  }
+  return [...found.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+function skillPrefix(agent) {
+  return agentBrandFor(agent) === "claude" ? "/" : "$";
+}
+function spendSkillMarkers(text, skills, agent) {
+  return text.replace(/\[skill (\d+)\]/g, (whole, n) => {
+    const name = skills[Number(n) - 1];
+    return name === void 0 ? whole : `${skillPrefix(agent)}${name}`;
+  });
+}
+
+// src/registry.ts
+import { spawn as spawn7 } from "node:child_process";
+import { createHash as createHash4 } from "node:crypto";
+import { existsSync as existsSync12, mkdirSync as mkdirSync13, openSync as openSync2, readFileSync as readFileSync17, realpathSync as realpathSync4, rmSync as rmSync10, writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join21 } from "node:path";
+
+// src/installer.ts
+import { spawn as spawn6 } from "node:child_process";
+import { existsSync as existsSync11, mkdirSync as mkdirSync12, readdirSync as readdirSync7, realpathSync as realpathSync3, rmSync as rmSync9 } from "node:fs";
+import { dirname as dirname6, join as join20, resolve as resolve4, sep as sep2 } from "node:path";
+function npmCli() {
+  const bin = dirname6(process.execPath);
+  for (const candidate of [
+    join20(bin, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js"),
+    join20(bin, "node_modules", "npm", "bin", "npm-cli.js")
+  ]) {
+    if (existsSync11(candidate)) return candidate;
+  }
+  return null;
+}
+function npmErrorSummary(stderr) {
+  const lines = stderr.split("\n").map((l) => l.trim());
+  const own = lines.filter((l) => /^npm (error|ERR!)/.test(l)).map((l) => l.replace(/^npm (error|ERR!)\s*/, "")).filter((l) => l && !/^A complete log of this run/.test(l));
+  if (own.length) return own.slice(0, 2).join(" ");
+  return lines.filter(Boolean).at(-1) ?? "";
+}
+function run3(label, command, args, opts = {}) {
+  return new Promise((resolve7, reject) => {
+    const child = spawn6(command, args, { stdio: ["ignore", "pipe", "pipe"], shell: opts.shell, env: opts.env });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (c) => stdout += c);
+    child.stderr.on("data", (c) => stderr += c);
+    child.on("error", (err) => reject(new Error(`${label} could not start: ${err.message}`)));
+    child.on("close", (code) => {
+      if (code === 0) return resolve7({ stdout, stderr });
+      const why = npmErrorSummary(stderr);
+      reject(new Error(`${label} failed${why ? `: ${why}` : ` (exit ${code})`}`));
+    });
+  });
+}
+async function npm(label, args) {
+  const cli = npmCli();
+  if (cli) {
+    await run3(label, process.execPath, [cli, ...args]);
+    return;
+  }
+  await run3(label, process.platform === "win32" ? "npm.cmd" : "npm", args.map(shellQuote), {
+    shell: true
+  });
+}
+function packageSpec(version) {
+  return `${NPM_PACKAGE}@${version}`;
+}
+function installedPackageRoot(version) {
+  return join20(VERSIONS_DIR, version, "node_modules", NPM_PACKAGE);
+}
+async function verifyInstall(pkgRoot, version) {
+  const cliEntry2 = join20(pkgRoot, "dist", "cli.mjs");
+  if (!existsSync11(cliEntry2)) return false;
+  try {
+    const { stdout } = await run3(`${APP_NAME} --version`, SELF_NODE.execPath, [cliEntry2, "--version"], {
+      env: selfNodeEnv()
+    });
+    return stdout.trim() === version;
+  } catch {
+    return false;
+  }
+}
+async function installVersion(version) {
+  const pkgRoot = installedPackageRoot(version);
+  if (await verifyInstall(pkgRoot, version)) return pkgRoot;
+  const prefix = join20(VERSIONS_DIR, version);
+  mkdirSync12(prefix, { recursive: true });
+  await npm(`npm install ${packageSpec(version)}`, [
+    "install",
+    "--prefix",
+    prefix,
+    "--no-audit",
+    "--no-fund",
+    "--no-package-lock",
+    "--loglevel=error",
+    packageSpec(version)
+  ]);
+  if (!await verifyInstall(pkgRoot, version)) {
+    throw new Error(`the installed ${packageSpec(version)} does not run as v${version}`);
+  }
+  return pkgRoot;
+}
+function realOrResolved(path) {
   try {
-    text = readFileSync11(path, "utf8");
+    return realpathSync3(path);
   } catch {
-    return null;
-  }
-  if (!text.startsWith("---")) return null;
-  const end = text.indexOf("\n---", 3);
-  if (end === -1) return null;
-  const fields = {};
-  for (const line2 of text.slice(3, end).split("\n")) {
-    const match = /^(name|description|user-invocable):\s*(.*)$/.exec(line2);
-    if (!match) continue;
-    const value = match[2].trim().replace(/^['"]|['"]$/g, "");
-    if (value) fields[match[1]] = value;
+    return resolve4(path);
   }
-  return fields;
 }
-function entries2(dir) {
+function pruneInstalledVersions(runningFrom, root = VERSIONS_DIR) {
+  let versions;
   try {
-    return readdirSync6(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
+    versions = readdirSync7(root);
   } catch {
-    return [];
-  }
-}
-function readSkill(dir, name, source) {
-  const fields = readFrontmatter(join14(dir, name, "SKILL.md"));
-  if (!fields) return null;
-  if (fields["user-invocable"]?.toLowerCase() === "false") return null;
-  return { name, description: fields.description ?? "", source };
-}
-function listSkills(project, home = homedir4()) {
-  const found = /* @__PURE__ */ new Map();
-  const roots = [
-    [home, "user"],
-    [project, "project"]
-  ];
-  for (const [root, source] of roots) {
-    for (const dir of SKILL_DIRS) {
-      const container = join14(root, dir);
-      for (const name of entries2(container)) {
-        const skill = readSkill(container, name, source);
-        if (skill) found.set(skill.name, skill);
-      }
-    }
+    return;
   }
-  const plugins = join14(project, ".claude/plugins");
-  for (const plugin of entries2(plugins)) {
-    const container = join14(plugins, plugin, "skills");
-    for (const name of entries2(container)) {
-      const skill = readSkill(container, name, "plugin");
-      if (skill) found.set(`${plugin}:${name}`, { ...skill, name: `${plugin}:${name}` });
-    }
+  const running2 = realOrResolved(runningFrom);
+  for (const version of versions) {
+    const dir = join20(root, version);
+    if (running2.startsWith(realOrResolved(dir) + sep2)) continue;
+    rmSync9(dir, { recursive: true, force: true });
   }
-  return [...found.values()].sort((a, b) => a.name.localeCompare(b.name));
-}
-function skillPrefix(agent) {
-  return agentBrandFor(agent) === "claude" ? "/" : "$";
-}
-function spendSkillMarkers(text, skills, agent) {
-  return text.replace(/\[skill (\d+)\]/g, (whole, n) => {
-    const name = skills[Number(n) - 1];
-    return name === void 0 ? whole : `${skillPrefix(agent)}${name}`;
-  });
 }
 
 // src/registry.ts
-import { spawn as spawn4 } from "node:child_process";
-import { createHash as createHash4 } from "node:crypto";
-import { mkdirSync as mkdirSync11, openSync as openSync2, readFileSync as readFileSync12, realpathSync, rmSync as rmSync8, writeFileSync as writeFileSync9 } from "node:fs";
 function readRegistry() {
   try {
-    return JSON.parse(readFileSync12(REGISTRY_FILE, "utf8"));
+    return JSON.parse(readFileSync17(REGISTRY_FILE, "utf8"));
   } catch {
     return null;
   }
 }
 function writeRegistry(info) {
-  mkdirSync11(DATA_DIR, { recursive: true });
+  mkdirSync13(DATA_DIR, { recursive: true });
   writeFileSync9(REGISTRY_FILE, JSON.stringify(info, null, 2));
 }
 function clearRegistry(pid) {
   if (pid !== void 0 && readRegistry()?.pid !== pid) return;
-  rmSync8(REGISTRY_FILE, { force: true });
+  rmSync10(REGISTRY_FILE, { force: true });
 }
 var ownDataDirId;
 function dataDirId() {
   if (ownDataDirId === void 0) {
-    mkdirSync11(DATA_DIR, { recursive: true });
-    const real = realpathSync.native(DATA_DIR);
+    mkdirSync13(DATA_DIR, { recursive: true });
+    const real = realpathSync4.native(DATA_DIR);
     ownDataDirId = createHash4("sha256").update(real).digest("hex").slice(0, 16);
   }
   return ownDataDirId;
@@ -5829,7 +7746,7 @@ async function probeDaemon(port, pid) {
     if (!res.ok) return null;
     const body = await res.json();
     if (body.ok !== true || body.pid !== pid || !servesThisDataDir(body)) return null;
-    return { version: body.version ?? "unknown" };
+    return { version: body.version ?? "unknown", ...typeof body.desktop === "number" ? { desktopContract: body.desktop } : {} };
   } catch {
     return null;
   }
@@ -5838,7 +7755,7 @@ async function findRunningDaemon() {
   const info = readRegistry();
   if (!info) return null;
   const probed = await probeDaemon(info.port, info.pid);
-  if (probed) return { ...info, version: probed.version };
+  if (probed) return { ...info, ...probed };
   clearRegistry(info.pid);
   return null;
 }
@@ -5860,18 +7777,20 @@ async function stopDaemon(daemon) {
     await new Promise((r) => setTimeout(r, 50));
   }
 }
-function launchDaemon(cliEntry2, args = []) {
-  mkdirSync11(DATA_DIR, { recursive: true });
+function launchDaemon(cliEntry2, args = [], launch = {}) {
+  mkdirSync13(DATA_DIR, { recursive: true });
   const log = openSync2(DAEMON_LOG, "a");
-  const child = spawn4(process.execPath, [cliEntry2, "__daemon", ...args], {
+  const runtime = launch.runtime ?? SELF_NODE;
+  const child = spawn7(runtime.execPath, [cliEntry2, "__daemon", ...args], {
     detached: true,
-    stdio: ["ignore", log, log]
+    stdio: ["ignore", log, log],
+    env: selfNodeEnv({ ...process.env, ...launch.env }, runtime)
   });
   child.unref();
   return child;
 }
-async function spawnDaemon(cliEntry2) {
-  launchDaemon(cliEntry2);
+async function spawnDaemon(launch) {
+  launchDaemon(launch.cliEntry, [], launch);
   const deadline = Date.now() + 8e3;
   while (Date.now() < deadline) {
     await new Promise((r) => setTimeout(r, 150));
@@ -5881,18 +7800,29 @@ async function spawnDaemon(cliEntry2) {
   throw new Error(`daemon failed to start within 8s (see ${DAEMON_LOG})`);
 }
 async function ensureDaemon(cliEntry2, version) {
+  return ensureDaemonWhere(() => ({ cliEntry: cliEntry2 }), (running2) => running2.version === version);
+}
+async function ensureDaemonWhere(launch, accepts) {
   for (let attempt = 0; attempt < 2; attempt++) {
-    const running2 = await findRunningDaemon() ?? await spawnDaemon(cliEntry2);
-    if (running2.version === version) return running2;
+    const running2 = await findRunningDaemon() ?? await spawnDaemon(await launch());
+    if (accepts(running2)) return running2;
     await stopDaemon(running2);
   }
   throw new Error(`a daemon running another version keeps taking over (see ${DAEMON_LOG})`);
 }
+async function resolveDaemon(cliEntry2, version) {
+  const running2 = await findRunningDaemon();
+  if (running2 && isNewer(running2.version, version)) {
+    const entry = join21(installedPackageRoot(running2.version), "dist", "cli.mjs");
+    if (existsSync12(entry)) return { kind: "newer", daemon: running2, cliEntry: entry };
+  }
+  return { kind: "ours", daemon: await ensureDaemon(cliEntry2, version) };
+}
 
 // src/library/index.ts
 import { createHash as createHash6 } from "node:crypto";
-import { createReadStream, mkdirSync as mkdirSync13, writeFileSync as writeFileSync10 } from "node:fs";
-import { resolve as resolve2 } from "node:path";
+import { createReadStream, mkdirSync as mkdirSync15, writeFileSync as writeFileSync10 } from "node:fs";
+import { resolve as resolve5 } from "node:path";
 
 // src/library/internal/errors.ts
 var LibraryError = class extends Error {
@@ -5921,13 +7851,13 @@ function asLibraryError(error) {
 }
 
 // src/library/internal/files.ts
-import { createHash as createHash5, randomBytes as randomBytes6 } from "node:crypto";
-import { existsSync as existsSync9, mkdirSync as mkdirSync12, readdirSync as readdirSync7, renameSync as renameSync4, rmSync as rmSync9 } from "node:fs";
+import { createHash as createHash5, randomBytes as randomBytes8 } from "node:crypto";
+import { existsSync as existsSync13, mkdirSync as mkdirSync14, readdirSync as readdirSync8, renameSync as renameSync5, rmSync as rmSync11 } from "node:fs";
 import { open } from "node:fs/promises";
-import { dirname as dirname5, join as join15 } from "node:path";
+import { dirname as dirname7, join as join22 } from "node:path";
 
 // src/library/internal/ulid.ts
-import { randomBytes as randomBytes5 } from "node:crypto";
+import { randomBytes as randomBytes7 } from "node:crypto";
 var ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
 var RANDOM_MAX = (1n << 80n) - 1n;
 var lastTime = -1;
@@ -5945,7 +7875,7 @@ function ulid(now = Date.now()) {
     lastRandom += 1n;
   } else {
     lastTime = Math.max(now, lastTime);
-    lastRandom = BigInt(`0x${randomBytes5(10).toString("hex")}`) >> 1n;
+    lastRandom = BigInt(`0x${randomBytes7(10).toString("hex")}`) >> 1n;
   }
   return encode(BigInt(lastTime), 10) + encode(lastRandom, 16);
 }
@@ -5954,15 +7884,15 @@ function ulid(now = Date.now()) {
 function libraryPaths(root) {
   return {
     root,
-    db: join15(root, "library.db"),
-    blobs: join15(root, "blobs"),
-    thumbs: join15(root, "thumbs"),
+    db: join22(root, "library.db"),
+    blobs: join22(root, "blobs"),
+    thumbs: join22(root, "thumbs"),
     // Under the root so sealing a stage into `blobs/` is a rename on one filesystem.
-    staging: join15(root, "staging")
+    staging: join22(root, "staging")
   };
 }
 function contentPath(dir, sha256, ext) {
-  return join15(dir, sha256.slice(0, 2), `${sha256}.${ext}`);
+  return join22(dir, sha256.slice(0, 2), `${sha256}.${ext}`);
 }
 var SNIFF_BYTES = 4096;
 var ascii = (bytes, start, end) => String.fromCharCode(...bytes.subarray(start, end));
@@ -6005,10 +7935,10 @@ var StagedFile = class {
   thumbPath;
   framePath;
   constructor(dir, name) {
-    this.partPath = join15(dir, `${name}.part`);
-    this.sealedPath = join15(dir, `${name}.bytes`);
-    this.thumbPath = join15(dir, `${name}.thumb.webp`);
-    this.framePath = join15(dir, `${name}.frame.png`);
+    this.partPath = join22(dir, `${name}.part`);
+    this.sealedPath = join22(dir, `${name}.bytes`);
+    this.thumbPath = join22(dir, `${name}.thumb.webp`);
+    this.framePath = join22(dir, `${name}.frame.png`);
   }
   get bytes() {
     return this.written;
@@ -6038,7 +7968,7 @@ var StagedFile = class {
     await this.handle.sync();
     await this.handle.close();
     this.handle = null;
-    renameSync4(this.partPath, this.sealedPath);
+    renameSync5(this.partPath, this.sealedPath);
     return this.hash.digest("hex");
   }
   remove() {
@@ -6047,7 +7977,7 @@ var StagedFile = class {
       });
       this.handle = null;
     }
-    for (const path of [this.partPath, this.sealedPath, this.thumbPath, this.framePath]) rmSync9(path, { force: true });
+    for (const path of [this.partPath, this.sealedPath, this.thumbPath, this.framePath]) rmSync11(path, { force: true });
   }
 };
 function isAlive(pid) {
@@ -6061,22 +7991,22 @@ function isAlive(pid) {
 var unreleased = /* @__PURE__ */ new Set();
 var exitHookInstalled = false;
 function sweepDeadStaging(paths) {
-  for (const name of readdirSync7(paths.staging)) {
+  for (const name of readdirSync8(paths.staging)) {
     const pid = Number(name.split("-")[0]);
     if (Number.isInteger(pid) && pid > 0 && pid !== process.pid && !isAlive(pid)) {
-      rmSync9(join15(paths.staging, name), { recursive: true, force: true });
+      rmSync11(join22(paths.staging, name), { recursive: true, force: true });
     }
   }
 }
 function claimStaging(paths) {
-  const dir = join15(paths.staging, `${process.pid}-${randomBytes6(4).toString("hex")}`);
-  mkdirSync12(dir);
+  const dir = join22(paths.staging, `${process.pid}-${randomBytes8(4).toString("hex")}`);
+  mkdirSync14(dir);
   const area = {
     dir,
     create: () => new StagedFile(dir, ulid()),
     release: () => {
       unreleased.delete(area);
-      rmSync9(dir, { recursive: true, force: true });
+      rmSync11(dir, { recursive: true, force: true });
     }
   };
   unreleased.add(area);
@@ -6089,12 +8019,12 @@ function claimStaging(paths) {
   return area;
 }
 function placeContent(from, target) {
-  if (existsSync9(target)) {
-    rmSync9(from, { force: true });
+  if (existsSync13(target)) {
+    rmSync11(from, { force: true });
     return "existed";
   }
-  mkdirSync12(dirname5(target), { recursive: true });
-  renameSync4(from, target);
+  mkdirSync14(dirname7(target), { recursive: true });
+  renameSync5(from, target);
   return "placed";
 }
 
@@ -6128,24 +8058,6 @@ function pngSize(bytes) {
   return { width: view.getUint32(16), height: view.getUint32(20) };
 }
 
-// src/library/policy.ts
-var VIDEO_CAP_BYTES = 2e8;
-var THUMBNAIL_LONG_SIDE = 400;
-var TAG_MAX_LENGTH = 64;
-function normalizeTag(raw) {
-  const name = raw.normalize("NFC").trim().replace(/\s+/g, " ");
-  if (name === "" || name.length > TAG_MAX_LENGTH || /[,，]/.test(name)) return null;
-  return lowercaseInitial(name);
-}
-function lowercaseInitial(name) {
-  const [first = "", second = ""] = name;
-  if (second !== second.toLowerCase()) return name;
-  return first.toLowerCase() + name.slice(first.length);
-}
-function tagKey(name) {
-  return name.normalize("NFKC").trim().replace(/\s+/g, " ").toLowerCase();
-}
-
 // src/library/internal/store.ts
 var SCHEMA = { epoch: 1, version: 2 };
 var NODE_FLOOR = "22.13.0";
@@ -6270,14 +8182,14 @@ async function openStore(sqlite, file) {
   }
 }
 var OPEN_PATIENCE_MS = 5e3;
-async function patiently(step) {
+async function patiently(step2) {
   const deadline = Date.now() + OPEN_PATIENCE_MS;
   for (; ; ) {
     try {
-      return step();
+      return step2();
     } catch (error) {
       if (!isBusy(error) || Date.now() > deadline) throw error;
-      await new Promise((resolve6) => setTimeout(resolve6, 10 + Math.random() * 40));
+      await new Promise((resolve7) => setTimeout(resolve7, 10 + Math.random() * 40));
     }
   }
 }
@@ -6546,7 +8458,7 @@ var SUGGEST_LIMIT = 8;
 var FIND_LIMIT = 50;
 var clamp2 = (value, min, max) => Math.min(max, Math.max(min, Math.floor(value)));
 async function openLibrary(options = {}) {
-  const paths = libraryPaths(resolve2(options.dir ?? libraryDir()));
+  const paths = libraryPaths(resolve5(options.dir ?? libraryDir()));
   const sqlite = await loadSqlite();
   ensureLayout(paths);
   const store = await openStore(sqlite, paths.db);
@@ -6560,7 +8472,7 @@ async function openLibrary(options = {}) {
 }
 function ensureLayout(paths) {
   try {
-    for (const dir of [paths.root, paths.blobs, paths.thumbs, paths.staging]) mkdirSync13(dir, { recursive: true });
+    for (const dir of [paths.root, paths.blobs, paths.thumbs, paths.staging]) mkdirSync15(dir, { recursive: true });
   } catch (error) {
     throw asLibraryError(error);
   }
@@ -6881,12 +8793,22 @@ var Stage = class {
 };
 
 // src/library-routes.ts
-import express2, { Router as Router2 } from "express";
+import express3, { Router as Router4 } from "express";
 var PAGE_LIMIT = 60;
 var MAX_TAGS = 100;
 var MAX_NOTE = 1e4;
 var ITEM_ID = /^[0-9A-HJKMNP-TV-Z]{26}$/;
 var MAX_PASTE_BYTES = 64 * 1024 * 1024;
+function storedFileOptions(mediaType) {
+  return {
+    dotfiles: "allow",
+    headers: {
+      "content-type": mediaType,
+      "x-content-type-options": "nosniff",
+      "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; sandbox"
+    }
+  };
+}
 var itemUrl = (id, file, sha256) => `${URL_PREFIX}/api/library/items/${id}/${file}?v=${sha256.slice(0, 16)}`;
 function storedOriginal(item) {
   return item.content.type === "file" ? item.content : item.content.frame;
@@ -6898,10 +8820,19 @@ function libraryAttachables(library, ids) {
     const file = item && storedOriginal(item);
     if (!item || !file) return { missing: id };
     const { pageUrl, pageTitle, mediaUrl } = item.source;
+    const { content } = item;
     ok2.push({
       title: pageTitle || hostOf(pageUrl),
       file,
-      origin: { libraryItemId: item.id, pageUrl, pageTitle, mediaUrl, note: item.note, tags: [...item.tags] }
+      origin: {
+        libraryItemId: item.id,
+        pageUrl,
+        pageTitle,
+        mediaUrl,
+        note: item.note,
+        tags: [...item.tags],
+        ...content.type === "link" ? { videoFrame: { reason: content.reason, playbackTime: content.playbackTime } } : {}
+      }
     });
   }
   return { ok: ok2 };
@@ -7005,7 +8936,7 @@ function refuse(res, status, code, error) {
   res.status(status).json({ error, code });
 }
 function libraryApiRouter(host) {
-  const router = Router2();
+  const router = Router4();
   const withLibrary = (handle) => (req, res, next) => {
     host.library().then(
       (library) => {
@@ -7053,17 +8984,10 @@ function libraryApiRouter(host) {
         res.sendFile(
           stored.path,
           {
-            // The library lives under `~/.ezdesign`, which `send` would refuse as a dotfile path.
-            dotfiles: "allow",
+            ...storedFileOptions(stored.mediaType),
             // Content-addressed: a url names its bytes for good.
             maxAge: req.query.v ? "1y" : 0,
-            immutable: Boolean(req.query.v),
-            headers: {
-              "content-type": stored.mediaType,
-              "x-content-type-options": "nosniff",
-              // A saved SVG opened on its own must not run on the session origin.
-              "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; sandbox"
-            }
+            immutable: Boolean(req.query.v)
           },
           (error) => {
             if (error && !res.headersSent) refuse(res, 404, "not-found", `the ${file} of ${req.params.id} is missing`);
@@ -7073,7 +8997,7 @@ function libraryApiRouter(host) {
       })
     );
   }
-  router.post("/library/items", express2.raw({ type: "multipart/form-data", limit: MAX_PASTE_BYTES }), (req, res, next) => {
+  router.post("/library/items", express3.raw({ type: "multipart/form-data", limit: MAX_PASTE_BYTES }), (req, res, next) => {
     void (async () => {
       const paste = await parsePaste(req);
       if (!paste) return refuse(res, 400, "bad-request", "a paste is a multipart form of original, thumbnail and meta");
@@ -7118,15 +9042,15 @@ function lazyLibrary(open3) {
 }
 
 // src/extension-routes.ts
-import { Router as Router3 } from "express";
+import { Router as Router5 } from "express";
 
 // src/capture-seen.ts
-import { mkdirSync as mkdirSync14, readFileSync as readFileSync13 } from "node:fs";
-import { dirname as dirname6, join as join16 } from "node:path";
-var seenFile = (dataDir) => join16(nativeHostDir(dataDir), "extension-seen.json");
+import { mkdirSync as mkdirSync16, readFileSync as readFileSync18 } from "node:fs";
+import { dirname as dirname8, join as join23 } from "node:path";
+var seenFile = (dataDir) => join23(nativeHostDir(dataDir), "extension-seen.json");
 function readExtensionSeen(dataDir) {
   try {
-    const { version, at } = JSON.parse(readFileSync13(seenFile(dataDir), "utf8"));
+    const { version, at } = JSON.parse(readFileSync18(seenFile(dataDir), "utf8"));
     return typeof version === "string" && typeof at === "number" ? { version, at } : null;
   } catch {
     return null;
@@ -7135,7 +9059,7 @@ function readExtensionSeen(dataDir) {
 
 // src/extension-routes.ts
 function extensionApiRouter(placement) {
-  const router = Router3();
+  const router = Router5();
   router.get("/extension/status", (_req, res) => {
     res.set("cache-control", "no-store").json({ greeted: readExtensionSeen(placement.dataDir) });
   });
@@ -7155,9 +9079,9 @@ function extensionApiRouter(placement) {
 }
 
 // src/announcement-routes.ts
-import { Router as Router4 } from "express";
+import { Router as Router6 } from "express";
 function announcementApiRouter() {
-  const router = Router4();
+  const router = Router6();
   router.get("/announcements/seen", (_req, res) => {
     res.set("cache-control", "no-store").json({ seen: seenAnnouncements() });
   });
@@ -7170,7 +9094,7 @@ function announcementApiRouter() {
 }
 
 // src/account.ts
-import { createHash as createHash7, randomBytes as randomBytes7 } from "node:crypto";
+import { createHash as createHash7, randomBytes as randomBytes9 } from "node:crypto";
 var DEFAULT_API_URL = "https://api.ezdesign.dev";
 var ACCOUNT_CALLBACK_PATH = `${URL_PREFIX}/account/callback`;
 var CLIENT_ID = APP_NAME;
@@ -7208,8 +9132,8 @@ var Account = class {
   }
   authorizeUrl(redirectUri) {
     this.dropStale();
-    const verifier = base64url(randomBytes7(32));
-    const state = base64url(randomBytes7(16));
+    const verifier = base64url(randomBytes9(32));
+    const state = base64url(randomBytes9(16));
     this.pendingByState.set(state, { verifier, redirectUri, at: this.now() });
     const url = new URL(`${this.deps.baseUrl}/authorize`);
     url.search = new URLSearchParams({
@@ -7288,9 +9212,9 @@ var Account = class {
 };
 
 // src/account-routes.ts
-import { Router as Router5 } from "express";
+import { Router as Router7 } from "express";
 function accountApiRouter(host) {
-  const router = Router5();
+  const router = Router7();
   router.get("/account/login", (_req, res) => {
     res.set("cache-control", "no-store").redirect(303, host.account.authorizeUrl(host.callbackUrl()));
   });
@@ -7357,111 +9281,8 @@ ${page.close ? "<script>window.close()</script>" : ""}
 </html>`;
 }
 
-// src/installer.ts
-import { spawn as spawn5 } from "node:child_process";
-import { existsSync as existsSync10, mkdirSync as mkdirSync15, readdirSync as readdirSync8, realpathSync as realpathSync2, rmSync as rmSync10 } from "node:fs";
-import { dirname as dirname7, join as join17, resolve as resolve3, sep } from "node:path";
-function npmCli() {
-  const bin = dirname7(process.execPath);
-  for (const candidate of [
-    join17(bin, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js"),
-    join17(bin, "node_modules", "npm", "bin", "npm-cli.js")
-  ]) {
-    if (existsSync10(candidate)) return candidate;
-  }
-  return null;
-}
-function npmErrorSummary(stderr) {
-  const lines = stderr.split("\n").map((l) => l.trim());
-  const own = lines.filter((l) => /^npm (error|ERR!)/.test(l)).map((l) => l.replace(/^npm (error|ERR!)\s*/, "")).filter((l) => l && !/^A complete log of this run/.test(l));
-  if (own.length) return own.slice(0, 2).join(" ");
-  return lines.filter(Boolean).at(-1) ?? "";
-}
-function run(label, command, args, opts = {}) {
-  return new Promise((resolve6, reject) => {
-    const child = spawn5(command, args, { stdio: ["ignore", "pipe", "pipe"], shell: opts.shell });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (c) => stdout += c);
-    child.stderr.on("data", (c) => stderr += c);
-    child.on("error", (err) => reject(new Error(`${label} could not start: ${err.message}`)));
-    child.on("close", (code) => {
-      if (code === 0) return resolve6({ stdout, stderr });
-      const why = npmErrorSummary(stderr);
-      reject(new Error(`${label} failed${why ? `: ${why}` : ` (exit ${code})`}`));
-    });
-  });
-}
-async function npm(label, args) {
-  const cli = npmCli();
-  if (cli) {
-    await run(label, process.execPath, [cli, ...args]);
-    return;
-  }
-  await run(label, process.platform === "win32" ? "npm.cmd" : "npm", args.map(shellQuote), {
-    shell: true
-  });
-}
-function packageSpec(version) {
-  return `${NPM_PACKAGE}@${version}`;
-}
-function installedPackageRoot(version) {
-  return join17(VERSIONS_DIR, version, "node_modules", NPM_PACKAGE);
-}
-async function verifyInstall(pkgRoot, version) {
-  const cliEntry2 = join17(pkgRoot, "dist", "cli.mjs");
-  if (!existsSync10(cliEntry2)) return false;
-  try {
-    const { stdout } = await run(`${APP_NAME} --version`, process.execPath, [cliEntry2, "--version"]);
-    return stdout.trim() === version;
-  } catch {
-    return false;
-  }
-}
-async function installVersion(version) {
-  const pkgRoot = installedPackageRoot(version);
-  if (await verifyInstall(pkgRoot, version)) return pkgRoot;
-  const prefix = join17(VERSIONS_DIR, version);
-  mkdirSync15(prefix, { recursive: true });
-  await npm(`npm install ${packageSpec(version)}`, [
-    "install",
-    "--prefix",
-    prefix,
-    "--no-audit",
-    "--no-fund",
-    "--no-package-lock",
-    "--loglevel=error",
-    packageSpec(version)
-  ]);
-  if (!await verifyInstall(pkgRoot, version)) {
-    throw new Error(`the installed ${packageSpec(version)} does not run as v${version}`);
-  }
-  return pkgRoot;
-}
-function realOrResolved(path) {
-  try {
-    return realpathSync2(path);
-  } catch {
-    return resolve3(path);
-  }
-}
-function pruneInstalledVersions(runningFrom, root = VERSIONS_DIR) {
-  let versions;
-  try {
-    versions = readdirSync8(root);
-  } catch {
-    return;
-  }
-  const running2 = realOrResolved(runningFrom);
-  for (const version of versions) {
-    const dir = join17(root, version);
-    if (running2.startsWith(realOrResolved(dir) + sep)) continue;
-    rmSync10(dir, { recursive: true, force: true });
-  }
-}
-
 // src/updater.ts
-import { join as join18 } from "node:path";
+import { join as join24 } from "node:path";
 var Updater = class {
   constructor(deps) {
     this.deps = deps;
@@ -7513,7 +9334,7 @@ var Updater = class {
       this.set("installing");
       const pkgRoot = await this.deps.install(target);
       this.set("handing-over");
-      await this.deps.handover(join18(pkgRoot, "dist", "cli.mjs"));
+      await this.deps.handover(join24(pkgRoot, "dist", "cli.mjs"));
       await this.deps.retire();
     } catch (err) {
       this.error = err instanceof Error ? err.message : String(err);
@@ -7522,48 +9343,27 @@ var Updater = class {
   }
 };
 
-// src/version.ts
-var VERSION_HEADER = `x-${APP_NAME}-version`;
-function versionMismatchBody(cliVersion, daemonVersion) {
-  return {
-    error: cliVersion ? `this ${APP_NAME} CLI is v${cliVersion} but the daemon is running v${daemonVersion}` : `this ${APP_NAME} CLI predates the running daemon (v${daemonVersion})`,
-    hint: `re-run as \`npx -y ${NPM_PACKAGE}@latest <url>\` to bring both to the current version`
-  };
-}
-function versionGate(daemonVersion) {
-  return (req, res, next) => {
-    const cliVersion = req.get(VERSION_HEADER) || void 0;
-    if (cliVersion === daemonVersion) return next();
-    res.status(409).json(versionMismatchBody(cliVersion, daemonVersion));
-  };
-}
-
 // src/daemon.ts
 function agentInstalled(profile, env = process.env) {
-  return (env.PATH ?? "").split(delimiter).filter(Boolean).some((dir) => {
-    try {
-      accessSync(join19(dir, profile.binary), constants.X_OK);
-      return true;
-    } catch {
-      return false;
-    }
-  });
+  return findExecutable(profile.binary, env.PATH) !== null;
 }
-var distDir = dirname8(fileURLToPath(import.meta.url));
+function defaultAgent() {
+  return proposingAgent([rememberedLastAgent()], (p) => agentInstalled(p));
+}
+var distDir = dirname9(fileURLToPath(import.meta.url));
 var SKILL_DIR = skillDir(distDir);
-var shellWord = (w) => /^[\w@%+=:,./-]+$/.test(w) ? w : `'${w.replace(/'/g, `'\\''`)}'`;
-var SELF_CLI = [process.execPath, ...process.execArgv, process.argv[1] ?? ""].filter(Boolean).map(shellWord).join(" ");
+var SELF_CLI = selfNodeCommandLine([...process.execArgv, process.argv[1] ?? ""].filter(Boolean));
 function inspireAccess() {
   return readInspireToken() ? { cli: SELF_CLI } : "unavailable";
 }
-var asset = (name) => readFileSync14(join19(distDir, name));
+var asset = (name) => readFileSync19(join25(distDir, name));
 var overlayKeyed = null;
 function overlayAssetKey() {
-  const files = ["overlay.js", "overlay.css"].map((name) => join19(distDir, name));
+  const files = ["overlay.js", "overlay.css"].map((name) => join25(distDir, name));
   let stamp;
   try {
     stamp = files.map((file) => {
-      const stat = statSync4(file);
+      const stat = statSync8(file);
       return `${stat.mtimeMs}:${stat.size}`;
     }).join("|");
   } catch {
@@ -7571,7 +9371,7 @@ function overlayAssetKey() {
   }
   if (overlayKeyed?.stamp !== stamp) {
     const hash = createHash8("sha1");
-    for (const file of files) hash.update(readFileSync14(file));
+    for (const file of files) hash.update(readFileSync19(file));
     overlayKeyed = { stamp, key: hash.digest("hex").slice(0, 12) };
   }
   return overlayKeyed.key;
@@ -7585,7 +9385,7 @@ function decodeAttachmentName(raw) {
   }
 }
 var SHELL_ICON = `data:image/svg+xml,${encodeURIComponent(brandMarkSvg())}`;
-var shellHtml = (version) => `<!doctype html>
+var shellHtml = (version, app) => `<!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
@@ -7596,11 +9396,11 @@ var shellHtml = (version) => `<!doctype html>
 </head>
 <body>
 <div id="ez-shell"></div>
-<script src="${URL_PREFIX}/shell.js" data-version="${version}"></script>
+<script src="${URL_PREFIX}/shell.js" data-version="${version}" data-app="${app ?? ""}"></script>
 </body>
 </html>`;
 function listen(app, port) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const server = createServer(app);
     server.once("error", reject);
     server.listen(port, "127.0.0.1", () => {
@@ -7608,7 +9408,7 @@ function listen(app, port) {
       server.on("error", (err) => {
         console.error(`server on port ${port} failed: ${err.message}`);
       });
-      resolve6(server);
+      resolve7(server);
     });
   });
 }
@@ -7659,9 +9459,10 @@ function acpPrompt(feedback, skills, agent, truth, history = [], effort = "high"
     ] : [],
     "Each item resolves to source: trust `anchor.source` (file:line) when present, else",
     "use `anchor.components` / `anchor.section` / `anchor.selector` / `anchor.text`.",
-    "`[file n]` in a comment is `attachments[n-1]` (read the file at `path`); one with an",
-    "`origin` is a reference from their library: `origin.pageUrl` is where it was captured",
-    "and `origin.note` what they wrote about it;",
+    "`[file n]` in a comment is `attachments[n-1]` (read the file at `path`, or, for a video,",
+    "what its `video.read` says); one with an `origin` is a reference from their library:",
+    "`origin.pageUrl` is where it was captured, `origin.note` what they wrote about it, and",
+    "`origin.videoFrame` that the file is one still of a video the library kept only as a link;",
     "`[ref n]` names the entry in `references` whose `n` matches.",
     "A reference carrying a `variant` is one the user chose in an explore round. Its html is",
     "the look they settled on, not code to paste: it is a stand-in that rendered in a shadow",
@@ -7707,7 +9508,8 @@ function explorePrompt(round, capture, files, truth, earlier, language) {
     round.direction ? `They asked for: ${round.direction}` : "They gave no direction: they want to see how it could be arranged to read more easily and look cleaner. Range across genuinely different arrangements - what leads, what recedes, how it is grouped, how much it shows - rather than varying one thing.",
     ...attachments?.length ? [
       "",
-      "`[file n]` in that direction is `attachments[n-1]` here - read the file at `path`:",
+      "`[file n]` in that direction is `attachments[n-1]` here - read the file at `path`, or,",
+      "for a video, what its `video.read` says:",
       "",
       "```json",
       JSON.stringify(attachments, null, 2),
@@ -7879,13 +9681,32 @@ function configChangeNote(option, value) {
   return `\u5DF2\u5207\u63DB${label}\uFF1A${configValueName(option, value)}`;
 }
 var SessionRuntime = class {
-  constructor(project, version, updater, library, account) {
+  constructor(project, version, updater, library, account, services) {
     this.project = project;
     this.version = version;
     this.updater = updater;
     this.library = library;
     this.account = account;
+    this.services = services;
     this.store = new SessionStore(project);
+    this.devServer = new DevServer({
+      project,
+      dir: this.store.dir,
+      userAttachedOrigin: () => {
+        const app = this.store.app;
+        return app.kind === "attached" ? app.origin : null;
+      },
+      heldElsewhere: (origin) => services.heldElsewhere(this, origin),
+      attach: (origin) => services.attachOrigin(this, origin),
+      detachLeavingRecord: (origin) => this.detachDevServerApp(origin),
+      environmentReady: services.environmentReady,
+      proposingAgent: () => proposingAgent([this.store.session.agent, rememberedLastAgent()], (p) => agentInstalled(p)),
+      onChange: () => {
+        this.showAppWhenServed();
+        this.broadcast();
+        services.projects.changed();
+      }
+    });
     this.appProxy = new AppProxy(`${URL_PREFIX}/shell`, (req) => {
       this.pageCookies = req.headers.cookie ?? null;
     });
@@ -7894,7 +9715,7 @@ var SessionRuntime = class {
       view: this.store,
       frameOrigin: () => `http://${FRAME_HOST}:${this.port}`,
       overlay: () => ({ assets: overlayAssetKey(), shellOrigin: this.shellOrigin }),
-      hasApp: () => this.app.kind === "attached",
+      hasApp: () => this.app.kind === "attached" || this.devServer.offersApp(),
       onChange: (change) => this.canvasChanged(change),
       // eslint-disable-next-line no-console
       log: (message2) => console.error(message2)
@@ -7914,6 +9735,7 @@ var SessionRuntime = class {
     this.bus.setMaxListeners(50);
   }
   store;
+  devServer;
   bus = new EventEmitter();
   /** The explore rounds this session is taking variants for, and the tool the
    *  agent sends them through. */
@@ -7937,7 +9759,7 @@ var SessionRuntime = class {
    *  Held in memory only, and handed out only for the token in the agent's environment. */
   pageCookies = null;
   pageStorage = null;
-  pageStateToken = randomBytes8(32).toString("base64url");
+  pageStateToken = randomBytes10(32).toString("base64url");
   /** The dev-server proxy and the live attachment. */
   appProxy;
   port = 0;
@@ -7972,6 +9794,8 @@ var SessionRuntime = class {
   agentProgress = null;
   /** SPIKE: the ACP-driven agent, when this session owns one. */
   acp = null;
+  /** Who connected `acp` from a shell, so the app's quit disconnects only its own. */
+  acpBy = null;
   /** Since the last idle check. Born touched: a session just opened is in use. */
   touched = true;
   /** Release the port and detach everyone attached, so the origin can be handed
@@ -7979,11 +9803,11 @@ var SessionRuntime = class {
   async stop() {
     this.acp?.stop();
     this.acp = null;
-    for (const resolve6 of this.pollWaiters) resolve6(null);
+    for (const resolve7 of this.pollWaiters) resolve7(null);
     this.pollWaiters.clear();
     for (const client2 of this.sseClients) client2.end();
     this.sseClients.clear();
-    const closed = new Promise((resolve6) => this.server.close(() => resolve6()));
+    const closed = new Promise((resolve7) => this.server.close(() => resolve7()));
     this.server.closeAllConnections();
     this.appProxy.detach();
     this.canvases.close();
@@ -8032,10 +9856,66 @@ var SessionRuntime = class {
   }
   setRestoreOnStart(on) {
     this.store.setRestoreOnStart(on);
+    if (!on) this.devServer.forgetResume();
+  }
+  detachDevServerApp(origin) {
+    if (this.app.kind !== "attached" || this.app.origin !== origin) return;
+    this.appProxy.detach();
+    this.forgetPageState();
+    this.canvases.appChanged({ show: false, create: this.shellClients.size > 0 });
+  }
+  lastDevServerPhase = "idle";
+  showAppWhenServed() {
+    const phase = this.devServer.snapshot().phase;
+    const served = (p) => p === "running" || p === "external";
+    if (served(phase) && !served(this.lastDevServerPhase)) {
+      this.canvases.appChanged({ show: true, create: this.shellClients.size > 0 });
+    }
+    this.lastDevServerPhase = phase;
+  }
+  /** Opening the project: the agent it was on, else `fallback`, unless they disconnected it here. */
+  ensureAgent(fallback, by) {
+    const live3 = !!this.acp && this.acp.snapshot().state !== "exited";
+    const { agent, agentDeclined } = this.store.session;
+    if (live3 || agentDeclined || this.pollWaiters.size > 0) return;
+    const command = agent ?? this.store.currentChat.agent ?? fallback;
+    if (command) this.connectAgent(command, by);
+  }
+  /** A shell's pick. The chat carries on when this agent can resume it; otherwise,
+   *  as with a switch, a new chat begins. */
+  connectAgent(command, by) {
+    const live3 = !!this.acp && this.acp.snapshot().state !== "exited";
+    const resumes = !live3 && (this.store.currentChat.agent ?? command) === command;
+    if (!(resumes ? this.attachAcpAgent(command) : this.switchAcpAgent(command))) return false;
+    this.acpBy = by;
+    this.store.setAgentBy(by);
+    this.broadcast();
+    return true;
+  }
+  /** A restore does not bring it back. Asked for by the user, it stays off until they connect one. */
+  disconnectAgent(opts) {
+    this.acp?.stop();
+    this.acp = null;
+    this.acpBy = null;
+    this.agentBusy = false;
+    this.activeBatch = null;
+    this.activeSkills = [];
+    this.agentProgress = null;
+    this.store.clearAgent();
+    if (opts.declined) this.store.declineAgent();
+    this.broadcast();
+  }
+  /** The app's quit: what its windows connected goes with them. */
+  disconnectAgentOf(by) {
+    if (this.acpBy !== by) return false;
+    this.disconnectAgent({ declined: false });
+    return true;
   }
   resumeAgent() {
-    const agent = this.store.session.agent;
-    if (agent) this.restoreAcpAgent(agent);
+    const { agent, agentBy } = this.store.session;
+    if (!agent) return;
+    this.restoreAcpAgent(agent);
+    this.acpBy = agentBy ?? null;
   }
   /** Off the live agent, not the record: the record holds what was asked for. */
   get acpCommand() {
@@ -8075,6 +9955,10 @@ var SessionRuntime = class {
       ...this.app.kind === "attached" ? { app: this.app.origin } : {},
       canvas: this.canvases.read.snapshot(this.agentHasCanvasTools),
       annotations: this.store.annotations,
+      ...(() => {
+        const pending = this.store.pendingVideoIds;
+        return pending.length ? { pendingVideos: pending } : {};
+      })(),
       conversation: this.store.visibleConversation,
       agentOnline: this.pollWaiters.size > 0 || !!this.acp && this.acp.snapshot().state !== "exited",
       agentBusy: this.agentBusy,
@@ -8093,7 +9977,10 @@ var SessionRuntime = class {
       ...update ? { update } : {},
       account: this.account.snapshot(),
       ...live3.length ? { explores: live3 } : {},
-      ...this.canExplore ? { canExplore: true } : {}
+      ...this.canExplore ? { canExplore: true } : {},
+      devServer: this.devServer.snapshot(),
+      appTab: this.app.kind === "attached" || this.devServer.offersApp(),
+      project: this.project
     };
   }
   /** The chat list as the shell draws it: newest first, because that is the one
@@ -8112,7 +9999,16 @@ var SessionRuntime = class {
 
 `;
     for (const res of this.sseClients) res.write(data);
+    if (this.agentWorking !== this.listedAgentWorking) {
+      this.listedAgentWorking = this.agentWorking;
+      this.services.projects.changed();
+    }
+  }
+  get agentWorking() {
+    return this.agentBusy || !!this.acp?.snapshot().cancelling;
   }
+  /** What the project list last heard, so it hears of a turn only as it starts and ends. */
+  listedAgentWorking = false;
   /** The workspace wrote, or a frame's file was found changed. Shell clients get
    *  the one canvas that changed as a named event - the snapshot never carries
    *  frames, so a streaming turn does not resend forty of them per token - and
@@ -8210,7 +10106,7 @@ var SessionRuntime = class {
       return this.acp.snapshot().agent === command;
     }
     this.store.setAgent(command);
-    mkdirSync16(ACP_NPM_PREFIX, { recursive: true });
+    mkdirSync17(ACP_NPM_PREFIX, { recursive: true });
     this.acp = new AcpAgent({
       command,
       launch: launchCommand(command, ACP_NPM_PREFIX),
@@ -8672,7 +10568,7 @@ var SessionRuntime = class {
   wakePollers() {
     const waiters = [...this.pollWaiters];
     this.pollWaiters.clear();
-    for (const resolve6 of waiters) resolve6(this.pollOutcome());
+    for (const resolve7 of waiters) resolve7(this.pollOutcome());
     this.broadcast();
   }
   /** Immediate poll outcome, or null when the agent should keep waiting. */
@@ -8707,11 +10603,11 @@ var SessionRuntime = class {
     this.agentProgress = null;
     const immediate = this.pollOutcome();
     if (immediate) return immediate;
-    return new Promise((resolve6) => {
+    return new Promise((resolve7) => {
       const waiter = (r) => {
         clearTimeout(timer);
         gone.removeEventListener("abort", leave);
-        resolve6(r);
+        resolve7(r);
       };
       const leave = () => {
         this.pollWaiters.delete(waiter);
@@ -8725,36 +10621,51 @@ var SessionRuntime = class {
     });
   }
   apiRouter() {
-    const api = Router6();
+    const api = Router8();
     api.use(refuseCrossSite(() => this.shellOrigin));
     api.use((_req, _res, next) => {
       this.touch();
       next();
     });
-    api.post(
-      "/attachments",
-      express3.raw({ type: () => true, limit: MAX_ATTACHMENT_BYTES }),
-      (req, res) => {
-        const bytes = req.body;
-        if (!Buffer.isBuffer(bytes) || bytes.byteLength === 0) {
-          return res.status(400).json({ error: "attachment body is empty" });
+    api.post("/attachments", (req, res, next) => {
+      const mime = (req.get("content-type") ?? "").split(";")[0]?.trim() || "application/octet-stream";
+      const limit = attachmentByteLimit(mime);
+      if (Number(req.get("content-length")) > limit) return res.status(413).json({ error: "attachment is too large" });
+      this.store.receiveAttachment(decodeAttachmentName(req.get("x-ez-name")), mime, req, limit).then((stored) => {
+        if (stored === "too-large") return res.status(413).json({ error: "attachment is too large" });
+        if (stored === "empty") return res.status(400).json({ error: "attachment body is empty" });
+        if (stored.video) this.broadcast();
+        res.json(stored);
+      }, next);
+    });
+    api.get("/attachments/:id/content", (req, res) => {
+      const entry = this.store.attachmentIndex[req.params.id];
+      if (!entry) return res.status(404).json({ error: "attachment not found" });
+      res.sendFile(
+        this.store.attachmentPath(entry),
+        storedFileOptions(entry.mime),
+        // A Range reader drops requests it no longer needs, so a stream cut short
+        // after the headers went out is the reader's choice, not a failure.
+        (error) => {
+          if (error && !res.headersSent) res.status(404).json({ error: "attachment not found" });
         }
-        const mime = (req.get("content-type") ?? "").split(";")[0]?.trim();
-        const attachment = this.store.addAttachment(
-          decodeAttachmentName(req.get("x-ez-name")),
-          mime || "application/octet-stream",
-          bytes
-        );
-        res.json(attachment);
-      }
-    );
+      );
+    });
+    api.put("/attachments/:id/video", express4.json({ limit: SETTLE_BODY_LIMIT }), (req, res) => {
+      const settle = parseVideoSettle(req.body);
+      if (typeof settle === "string") return res.status(400).json({ error: settle });
+      const status = this.store.settleVideo(req.params.id, settle);
+      if (status.state !== "gone") this.broadcast();
+      res.status(status.state === "gone" ? 404 : 200).json(status);
+    });
     api.post(CANVAS_MCP_ROUTE, ...this.canvasMcp.handlers());
-    api.use(express3.json({ limit: "2mb" }));
+    api.use(express4.json({ limit: "2mb" }));
     api.post(MCP_ROUTE, this.exploreMcp.handler());
     api.use(canvasApiRouter({ user: this.canvases.user, read: this.canvases.read }));
     api.use(libraryApiRouter({ library: this.library }));
     api.use(extensionApiRouter({ distDir, version: this.version, dataDir: libraryHome() }));
     api.use(announcementApiRouter());
+    api.use(devServerApiRouter(this.devServer));
     api.use(
       accountApiRouter({ account: this.account, callbackUrl: () => `${this.shellOrigin}${ACCOUNT_CALLBACK_PATH}` })
     );
@@ -8838,6 +10749,7 @@ var SessionRuntime = class {
         case "referenced":
           return res.status(409).json({ error: "attachment belongs to queued or sent feedback" });
         default:
+          this.broadcast();
           return res.json({ ok: true });
       }
     });
@@ -8851,11 +10763,11 @@ var SessionRuntime = class {
             return res.status(404).json({ error: `\u7D20\u6750 ${found.missing} \u5DF2\u7D93\u4E0D\u5728\u7D20\u6750\u5EAB\u88E1\u4E86` });
           }
           const pick = newId();
-          res.json(
-            found.ok.map(
-              ({ title, file, origin }) => this.store.copyAttachment(title, file.mediaType, file.path, { pick, ...origin })
-            )
+          const copied = found.ok.map(
+            ({ title, file, origin }) => this.store.copyAttachment(title, file.mediaType, file.path, { pick, ...origin })
           );
+          if (copied.some((a) => a.video)) this.broadcast();
+          res.json(copied);
         },
         (error) => error instanceof LibraryError ? res.status(503).json({ error: error.message }) : next(error)
       ).catch(next);
@@ -8906,6 +10818,7 @@ var SessionRuntime = class {
       if (!ids) return res.status(400).json({ error: "attachments must be an array of ids" });
       const files = this.store.getAttachments(ids);
       if (!files) return res.status(400).json({ error: "unknown attachment id" });
+      if (this.store.holdsPendingVideo(files)) return res.status(409).json({ error: "\u5F71\u7247\u9084\u5728\u8655\u7406\uFF0C\u8655\u7406\u5B8C\u624D\u80FD\u4EA4\u7D66 agent" });
       const refs = parseReferences(req.body?.references);
       if (!refs) return res.status(400).json({ error: "references must be an array of anchors" });
       const skills = Array.isArray(req.body?.skills) ? req.body.skills.filter((v) => typeof v === "string") : [];
@@ -8972,12 +10885,17 @@ var SessionRuntime = class {
       const id = String(req.body?.id ?? "");
       const profile = AGENT_PROFILES.find((p) => p.id === id);
       if (!profile) return res.status(400).json({ error: "unknown agent" });
-      if (!this.acp) {
-        return res.status(409).json({ error: "this review is not driving an agent" });
+      if (!this.acp && this.pollWaiters.size > 0) {
+        return res.status(409).json({ error: "another agent is driving this review" });
       }
-      if (!this.switchAcpAgent(profile.command)) {
+      if (!this.connectAgent(profile.command, initiator(req))) {
         return res.status(409).json({ error: "that agent cannot be started right now" });
       }
+      rememberLastAgent(profile.command);
+      res.json({ ok: true });
+    });
+    api.post("/acp/disconnect", (_req, res) => {
+      this.disconnectAgent({ declined: true });
       res.json({ ok: true });
     });
     api.get("/acp/skills", (_req, res) => {
@@ -9025,6 +10943,7 @@ var SessionRuntime = class {
       if (!ids) return res.status(400).json({ error: "attachments must be an array of ids" });
       const files = this.store.getAttachments(ids);
       if (!files) return res.status(400).json({ error: "unknown attachment id" });
+      if (files.some((f) => f.video?.state === "pending")) return res.status(409).json({ error: "\u5F71\u7247\u9084\u5728\u8655\u7406\uFF0C\u8655\u7406\u5B8C\u624D\u80FD\u4EA4\u7D66 agent" });
       const refs = parseReferences(req.body?.references);
       if (!refs) return res.status(400).json({ error: "references must be an array of anchors" });
       const round = await this.startExplore({
@@ -9187,11 +11106,14 @@ var SessionRuntime = class {
     return api;
   }
   async start() {
-    const app = express3();
+    const app = express4();
     app.use(frameHost(this.canvases.read, () => this.shellOrigin));
-    const rk = Router6();
-    rk.get("/shell", (_req, res) => res.type("html").send(shellHtml(this.version)));
-    for (const file of ["overlay.js", "overlay.css", "shell.js", "shell.css", "events-worker.js"]) {
+    const rk = Router8();
+    rk.get(
+      "/shell",
+      (_req, res) => res.type("html").send(shellHtml(this.version, this.app.kind === "attached" ? this.app.origin : null))
+    );
+    for (const file of ["overlay.js", "overlay.css", "shell.js", "shell.css", "events-worker.js", "video-digest.js"]) {
       const type = file.endsWith(".css") ? "text/css" : "text/javascript";
       const keyed = file.startsWith("overlay.");
       rk.get(
@@ -9204,7 +11126,7 @@ var SessionRuntime = class {
     }
     rk.use(
       "/announcements",
-      express3.static(join19(distDir, "announcements"), { immutable: true, maxAge: "1y", fallthrough: false })
+      express4.static(join25(distDir, "announcements"), { immutable: true, maxAge: "1y", fallthrough: false })
     );
     rk.get(ACCOUNT_CALLBACK_PATH.slice(URL_PREFIX.length), crossSiteAccountCallback(this.account));
     rk.use("/api", this.apiRouter());
@@ -9222,6 +11144,7 @@ var SessionRuntime = class {
     if (this.port === preferred) this.shellReturnDeadline = Date.now() + SHELL_RETURN_MS;
     this.store.setPort(this.port);
     this.canvases.start();
+    this.devServer.resume();
     return this.port;
   }
   /** Whether a shell is open on this session, once any left open across a
@@ -9289,17 +11212,23 @@ async function handoverTo(cliEntry2) {
   throw new Error(`new daemon did not come up within 20s (see ${DAEMON_LOG})`);
 }
 async function daemonMain(version, opts = {}) {
+  scrubRunAsNode();
+  const environment = adoptLoginEnvironment();
   const range = controlPortRange();
   if (opts.succeed === void 0) {
-    const [adopted] = await ownDaemonsInRange(range);
-    if (adopted) return adopt(adopted);
+    const [adopted2] = await ownDaemonsInRange(range);
+    if (adopted2) return adopt(adopted2);
   }
   let sessions;
+  let projectsChanged = () => {
+  };
   const broadcastAll = () => {
     for (const s of sessions.list()) s.broadcast();
+    projectsChanged();
   };
   let stopping = false;
   let boundAt = 0n;
+  const releaseDevServers = () => Promise.all(sessions.list().map((s) => s.devServer.release()));
   const updater = new Updater({
     current: version,
     latestVersion: updateChecksDisabled() ? async () => null : () => latestVersion(),
@@ -9307,16 +11236,42 @@ async function daemonMain(version, opts = {}) {
     handover: handoverTo,
     // Exit is the release: it frees every port at once and takes the agent
     // children with it, which is what the successor is waiting for.
-    retire: async () => process.exit(0),
+    retire: async () => {
+      await releaseDevServers();
+      process.exit(0);
+    },
     onChange: broadcastAll
   });
   const library = lazyLibrary(() => openLibrary({ dir: libraryDir(libraryHome()) }));
   const account = new Account({ baseUrl: apiBaseUrl(), onChange: broadcastAll });
+  let controlPort = 0;
+  const controlOrigin = () => `http://127.0.0.1:${controlPort}`;
+  const book = new ProjectBook(listPersistedSessions());
+  const projects = new ProjectHub({
+    sessions: { list: () => sessions.list(), open: (req) => sessions.open(req) },
+    book,
+    version,
+    account: () => account.snapshot(),
+    defaultAgent,
+    projectRoot,
+    restored: () => restored
+  });
+  projectsChanged = () => projects.changed();
+  const services = {
+    projects,
+    attachOrigin: (runtime, origin) => sessions.attachOrigin(runtime, origin, { userAttached: false, now: Date.now() }),
+    heldElsewhere: (runtime, origin) => {
+      const holder = sessions.byOrigin(origin);
+      return !!holder && holder !== runtime;
+    },
+    environmentReady: () => environment
+  };
   sessions = new SessionDirectory(
-    (project) => new SessionRuntime(project, version, updater, library, account),
+    (project) => new SessionRuntime(project, version, updater, library, account, services),
     {
       restorable: listRestorableSessions,
       get: persistedSession,
+      used: (project, now) => book.markUsed(project, now),
       migrate: () => {
         const { merged } = migrateLegacySessions();
         if (merged.size) {
@@ -9327,8 +11282,8 @@ async function daemonMain(version, opts = {}) {
     // eslint-disable-next-line no-console
     (message2) => console.error(message2)
   );
-  const control = express3();
-  control.use(express3.json());
+  const control = express4();
+  control.use(express4.json());
   control.get("/control/health", (_req, res) => {
     if (stopping) return res.status(503).json({ ok: false, stopping: true });
     res.json({
@@ -9337,12 +11292,32 @@ async function daemonMain(version, opts = {}) {
       version,
       pid: process.pid,
       dataDirId: dataDirId(),
-      boundAt: String(boundAt)
+      boundAt: String(boundAt),
+      desktop: DESKTOP_CONTRACT
     });
   });
+  control.use("/control/desktop", refuseCrossSite(controlOrigin), desktopContractGate());
+  control.post("/control/desktop/open", async (req, res) => {
+    const path = req.body?.path;
+    if (typeof path !== "string") return res.status(400).json({ error: "path required" });
+    const added = projects.add(path);
+    if ("error" in added) return res.status(400).json(added);
+    const opened = await projects.open(added.project, "desktop");
+    if ("ok" in opened) return res.status(opened.status).json({ error: opened.error });
+    res.json(opened);
+  });
+  control.post("/control/desktop/quit", async (_req, res) => {
+    projects.disconnectAgentsOf("desktop");
+    res.json({ stopped: await projects.stopManagedBy("desktop") });
+  });
+  control.use(homePageRouter({ version, distDir, icon: SHELL_ICON }));
+  control.use(`${URL_PREFIX}/api`, projectsApiRouter(projects, { version, origin: controlOrigin }));
+  control.get(ACCOUNT_CALLBACK_PATH, crossSiteAccountCallback(account));
+  control.use(`${URL_PREFIX}/api/account`, refuseCrossSite(controlOrigin));
+  control.use(`${URL_PREFIX}/api`, accountApiRouter({ account, callbackUrl: () => `${controlOrigin()}${ACCOUNT_CALLBACK_PATH}` }));
   let ready;
-  const restored = new Promise((resolve6) => {
-    ready = resolve6;
+  const restored = new Promise((resolve7) => {
+    ready = resolve7;
   });
   control.use("/control/sessions", (_req, _res, next) => {
     restored.then(() => next(), next);
@@ -9360,7 +11335,7 @@ async function daemonMain(version, opts = {}) {
     );
   });
   control.post("/control/sessions", async (req, res) => {
-    const { url, reopen, project, agent } = req.body ?? {};
+    const { url, reopen, project, agent, connectAgent, devServer } = req.body ?? {};
     if (typeof project !== "string" || !project) {
       return res.status(400).json({ error: "missing project" });
     }
@@ -9386,11 +11361,14 @@ async function daemonMain(version, opts = {}) {
     }
     const runtime = opened.runtime;
     runtime.touch();
+    if (devServer === true && !parsed) runtime.devServer.ensure("cli");
     if (typeof agent === "string" && agent) {
       if (!runtime.attachAcpAgent(agent) && !runtime.switchAcpAgent(agent)) {
         return res.status(409).json({ error: "that agent cannot be started right now" });
       }
       runtime.broadcast();
+    } else if (connectAgent === true) {
+      runtime.ensureAgent(defaultAgent(), "cli");
     }
     res.json({
       port: runtime.port,
@@ -9414,16 +11392,17 @@ async function daemonMain(version, opts = {}) {
       ...runtime.app.kind === "attached" ? { app: runtime.app.origin } : {}
     });
   });
-  control.post("/control/stop", (_req, res) => {
+  control.post("/control/stop", refuseCrossSite(controlOrigin), (_req, res) => {
     stopping = true;
     clearRegistry(process.pid);
     res.json({ ok: true });
-    setTimeout(() => process.exit(0), 100);
+    void releaseDevServers().then(() => process.exit(0));
   });
   const controlServer = await listenOn(control, [...range.ports, 0]);
   boundAt = process.hrtime.bigint();
   const controlAddress = controlServer.address();
   const port = typeof controlAddress === "object" && controlAddress ? controlAddress.port : 0;
+  controlPort = port;
   if (opts.succeed === void 0) {
     const before = (a, b) => {
       const [x, y] = [a.boundAt ?? 0n, b.boundAt ?? 0n];
@@ -9437,14 +11416,16 @@ async function daemonMain(version, opts = {}) {
     }
   }
   writeRegistry({ port, pid: process.pid, startedAt: Date.now() });
-  const reaped = reapOrphanedAgents();
+  const reaped = reapOrphanedGroups();
   if (reaped > 0) {
-    console.error(`reaped ${reaped} agent process group(s) left by a killed daemon`);
+    console.error(`reaped ${reaped} process group(s) left by a killed daemon`);
   }
   const cleanup = () => {
     clearRegistry(process.pid);
-    clearAgentRecord();
-    process.exit(0);
+    void releaseDevServers().then(() => {
+      clearGroupRecord();
+      process.exit(0);
+    });
   };
   process.on("SIGTERM", cleanup);
   process.on("SIGINT", cleanup);
@@ -9452,9 +11433,10 @@ async function daemonMain(version, opts = {}) {
   if (!predecessorGone) {
     console.error(`predecessor pid ${opts.succeed} is still running; restoring sessions anyway`);
   }
+  await environment;
   await sessions.restore({ migrate: predecessorGone });
   ready();
-  if (predecessorGone) pruneInstalledVersions(join19(distDir, "cli.mjs"));
+  if (predecessorGone) pruneInstalledVersions(join25(distDir, "cli.mjs"));
   void refreshCaptureInstall({ distDir, version, dataDir: libraryHome() }).catch(
     (err) => console.error(`capture extension refresh failed: ${err instanceof Error ? err.message : String(err)}`)
   );
@@ -9463,7 +11445,7 @@ async function daemonMain(version, opts = {}) {
   if (!envFlagOn(process.env[NO_IDLE_STOP_ENV])) {
     const idle = new IdleCount(IDLE_STOP_MS / IDLE_CHECK_MS);
     setInterval(() => {
-      const busy = sessions.list().filter((s) => s.takeBusy()).length > 0;
+      const busy = [sessions.list().filter((s) => s.takeBusy()).length > 0, projects.takeBusy()].some(Boolean);
       if (idle.observe(busy) && sessions.size > 0) {
         sessions.retireIdle();
         cleanup();
@@ -9474,8 +11456,8 @@ async function daemonMain(version, opts = {}) {
 }
 
 // src/inspire.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync17, writeFileSync as writeFileSync11 } from "node:fs";
-import { dirname as dirname9, join as join20 } from "node:path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync18, writeFileSync as writeFileSync11 } from "node:fs";
+import { dirname as dirname10, join as join26 } from "node:path";
 var DEFAULT_INSPIRE_URL = "https://inspire.ezdesign.dev";
 var INSPIRE_URL_ENV = `${APP_NAME.toUpperCase()}_INSPIRE_URL`;
 var SEARCH_TIMEOUT_MS = 15e3;
@@ -9490,17 +11472,17 @@ function apiUrl(path, base = inspireBaseUrl()) {
   return `${base}${path.startsWith("/") ? path : `/${path}`}`;
 }
 function inspirationCacheDir(dataDir = DATA_DIR) {
-  return join20(dataDir, "cache", "inspiration");
+  return join26(dataDir, "cache", "inspiration");
 }
 function imageCachePath(entryId, image, index = 0, dataDir = DATA_DIR) {
   const position = image.position ?? index;
-  const parts = [image.kind, image.viewport ?? void 0, String(position)].filter(
+  const parts2 = [image.kind, image.viewport ?? void 0, String(position)].filter(
     (p) => typeof p === "string" && p !== ""
   );
-  return join20(inspirationCacheDir(dataDir), entryId, `${parts.join("-")}.png`);
+  return join26(inspirationCacheDir(dataDir), entryId, `${parts2.join("-")}.png`);
 }
 function sourceCachePath(entryId, source, dataDir = DATA_DIR) {
-  return join20(inspirationCacheDir(dataDir), entryId, `source.${source.kind}`);
+  return join26(inspirationCacheDir(dataDir), entryId, `source.${source.kind}`);
 }
 var slugify = (raw) => raw.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 function entryTitle(entry) {
@@ -9575,7 +11557,7 @@ async function download(url, path, fetchImpl) {
   try {
     const res = await fetchImpl(url, { signal: AbortSignal.timeout(IMAGE_TIMEOUT_MS) });
     if (!res.ok) return false;
-    mkdirSync17(dirname9(path), { recursive: true });
+    mkdirSync18(dirname10(path), { recursive: true });
     writeFileSync11(path, Buffer.from(await res.arrayBuffer()));
     return true;
   } catch {
@@ -9598,12 +11580,12 @@ async function cacheFiles(results, opts = {}) {
     );
     for (const [index, image] of ordered2) {
       const path = imageCachePath(entry.id, image, index, dataDir);
-      if (existsSync11(path) || await download(image.url, path, fetchImpl)) images.push(path);
+      if (existsSync14(path) || await download(image.url, path, fetchImpl)) images.push(path);
     }
     const sources = [];
     for (const source of entry.sources ?? []) {
       const path = sourceCachePath(entry.id, source, dataDir);
-      if (await download(source.url, path, fetchImpl) || existsSync11(path)) sources.push(path);
+      if (await download(source.url, path, fetchImpl) || existsSync14(path)) sources.push(path);
     }
     files.set(entry.id, { images, sources });
   }
@@ -9652,22 +11634,9 @@ function parseSearchArgs(args) {
   return { query, tags, limit, json: args.includes("--json") };
 }
 
-// src/project-root.ts
-import { existsSync as existsSync12 } from "node:fs";
-import { dirname as dirname10, join as join21, parse, resolve as resolve4 } from "node:path";
-function projectRoot(from) {
-  let dir = resolve4(from);
-  const { root } = parse(dir);
-  for (; ; ) {
-    if (existsSync12(join21(dir, ".git")) || existsSync12(join21(dir, "package.json"))) return dir;
-    if (dir === root) return resolve4(from);
-    dir = dirname10(dir);
-  }
-}
-
 // src/cli.ts
 var cliEntry = fileURLToPath2(import.meta.url);
-var pkg = JSON.parse(readFileSync16(join22(dirname11(cliEntry), "../package.json"), "utf8"));
+var pkg = JSON.parse(readFileSync21(join27(dirname11(cliEntry), "../package.json"), "utf8"));
 var EXTENSION_HELP = `  ${APP_NAME} extension install [--user-data-dir <dir>] | uninstall | status
       install the native host the Chrome capture extension saves through, and
       print the folder to load in chrome://extensions. Saving needs no daemon
@@ -9678,14 +11647,18 @@ var EXTENSION_HELP = `  ${APP_NAME} extension install [--user-data-dir <dir>] |
 var HELP = `${APP_NAME} - annotate your live dev app, feedback flows to your local agent
 
 Usage:
-  ${APP_NAME} [<url>] [--reopen] [--agent <name|command>]
+  ${APP_NAME} [<url>] [--reopen] [--agent <name|command> | --no-agent]
       open (or resume) this project's review session. With <url>, that dev
       server is on its App tab (a dev server that moved ports keeps the
-      conversation); without one, the shell opens on the project's canvases.
-      --agent (SPIKE) drives the agent over ACP: the session spawns it, feedback
-      goes straight to it, and its stream, questions and permission prompts all
-      surface in the review shell - no terminal needed. Profiles: claude, gemini,
-      codex; anything else is run as an ACP agent command line.
+      conversation); without one, its App tab offers to start the project's
+      dev server, or the shell opens on its canvases when there is none.
+      The session drives its agent over ACP: it spawns it, feedback goes
+      straight to it, and its stream, questions and permission prompts all
+      surface in the review shell - no terminal needed. Without --agent it
+      connects the agent this project had, else your last one, else the first
+      installed of claude, codex and gemini; one you disconnected in the shell
+      stays off. --agent picks one: claude, codex, gemini, or any ACP agent
+      command line. --no-agent connects none, for an agent working it with poll.
   ${APP_NAME} poll [<url>] [--agent-reply <msg>]
       block until the user sends feedback; prints JSON, then exits
   ${APP_NAME} progress [<url>] <msg>
@@ -9820,7 +11793,9 @@ async function cmdOpen(rawUrl, flags, agentArg) {
       );
     }
   }
-  const daemon = await ensureDaemon(cliEntry, pkg.version);
+  const resolved = await resolveDaemon(cliEntry, pkg.version);
+  if (resolved.kind === "newer") return reexecAs(resolved.cliEntry);
+  const daemon = resolved.daemon;
   const project = projectRoot(process.cwd());
   const res = await controlFetch(daemon.port, "/control/sessions", {
     method: "POST",
@@ -9828,7 +11803,7 @@ async function cmdOpen(rawUrl, flags, agentArg) {
       ...target ? { url: target.href } : {},
       reopen: flags.has("--reopen"),
       project,
-      ...agentArg ? { agent: agentCommand(agentArg) } : {}
+      ...agentArg ? { agent: agentCommand(agentArg) } : { connectAgent: !flags.has("--no-agent") }
     })
   });
   const body = await res.json();
@@ -9839,10 +11814,19 @@ async function cmdOpen(rawUrl, flags, agentArg) {
   console.log(`shell:   ${body.shellUrl}${body.shellOpen ? " (already open in your browser)" : ""}`);
   if (body.agent) {
     console.log(`agent:   ${body.agent} (ACP) - review runs in the shell`);
-  } else {
+  } else if (flags.has("--no-agent")) {
     console.log(`next:    run \`${APP_NAME} poll\` in this project and wait for feedback`);
+  } else {
+    console.log(`next:    pick an agent in the shell, or run again with --agent claude|codex|gemini`);
   }
 }
+function reexecAs(cliEntry2) {
+  const { status } = spawnSync2(SELF_NODE.execPath, [cliEntry2, ...process.argv.slice(2)], {
+    stdio: "inherit",
+    env: selfNodeEnv()
+  });
+  process.exit(status ?? 1);
+}
 async function cmdPoll(handle, reply) {
   let port = await findSessionPort(handle);
   if (reply?.trim()) {
@@ -10030,7 +12014,7 @@ async function cmdExtension(args) {
     if (rest[i] !== "--user-data-dir") fail(`unknown option: ${rest[i]}`, `${APP_NAME} extension install [--user-data-dir <dir>]`);
     const dir = rest[++i];
     if (!dir) fail("missing value for --user-data-dir");
-    userDataDirs.push(resolve5(dir));
+    userDataDirs.push(resolve6(dir));
   }
   const placement = { distDir: dirname11(cliEntry), version: pkg.version };
   try {
@@ -10117,6 +12101,7 @@ async function main() {
       const agentIdx = argv.indexOf("--agent");
       const agentArg = agentIdx >= 0 ? argv[agentIdx + 1] : void 0;
       if (agentIdx >= 0 && !agentArg) fail("missing value for --agent", "e.g. --agent claude");
+      if (agentArg && flags.has("--no-agent")) fail("--agent and --no-agent cannot be used together");
       return cmdOpen(first === void 0 || first.startsWith("--") ? void 0 : first, flags, agentArg);
     }
   }