@velven/cli 0.3.0 → 0.5.0

package/dist/velven.js

@@ -23,14 +23,13 @@ class CliError extends Error {
   }
 }
 // package.json
-var version = "0.3.0";
+var version = "0.5.0";
 
 // src/version.ts
 var VERSION = version;
 
 // src/api.ts
 var USER_AGENT = `velven-cli/${VERSION}`;
-var REFUSED_CODES = new Set(["not_owner", "too_large", "too_many_files", "not_found", "invalid_fields", "forbidden"]);
 function errorFromResponse(status, body, path, creds, retryAfter) {
   const b = body && typeof body === "object" ? body : {};
   const errorText = typeof b.error === "string" ? b.error : undefined;
@@ -59,7 +58,7 @@ function errorFromResponse(status, body, path, creds, retryAfter) {
   if (!body && status === 404) {
     return new CliError(`This Velven does not answer ${path}. Check VELVEN_API.`, EXIT.failed, "not_found");
   }
-  if (REFUSED_CODES.has(code) || status >= 400) {
+  if (status >= 400) {
     return new CliError(sentence ?? `Velven refused the request (HTTP ${status}).`, EXIT.refused, code, fields);
   }
   return new CliError(sentence ?? `Unexpected answer from Velven (HTTP ${status}).`, EXIT.failed, code);
@@ -75,34 +74,61 @@ function requestHeaders(api, accept) {
 function causeOf(e) {
   return e instanceof Error && e.cause instanceof Error ? e.cause.message : e instanceof Error ? e.message : String(e);
 }
-async function call(api, method, path, body) {
-  const headers = requestHeaders(api, "application/json");
-  if (body !== undefined)
-    headers["content-type"] = "application/json";
+var RETRY_PAUSE_MS = 1000;
+async function call(api, method, path, body, options = {}) {
+  return answerOf(api, path, body === undefined ? undefined : { type: "application/json", data: JSON.stringify(body) }, method, options.retryOnce?.sleep);
+}
+async function putBytes(url, bytes, type, tooLarge) {
   let response;
   try {
-    response = await fetch(`${api.base}${path}`, {
-      method,
-      headers,
-      body: body === undefined ? undefined : JSON.stringify(body)
-    });
+    response = await fetch(url, { method: "PUT", headers: { "content-type": type, "user-agent": USER_AGENT }, body: bytes });
   } catch (e) {
-    throw new CliError(`Could not reach Velven at ${api.base} (${causeOf(e)}).`, EXIT.failed, "network");
+    throw new CliError(`Could not upload the picture (${causeOf(e)}).`, EXIT.failed, "network");
   }
-  const text = await response.text();
-  let parsed = null;
-  if (text) {
+  await response.text().catch(() => "");
+  if (response.status === 413)
+    throw new CliError(tooLarge, EXIT.refused, "too_large");
+  if (!response.ok)
+    throw new CliError(`The picture's upload was refused (HTTP ${response.status}). Try again in a moment.`, response.status >= 500 ? EXIT.failed : EXIT.refused, `http_${response.status}`);
+}
+async function answerOf(api, path, body, method, retry) {
+  const headers = requestHeaders(api, "application/json");
+  if (body !== undefined)
+    headers["content-type"] = body.type;
+  for (let attempt = 0;; attempt++) {
+    const again = retry !== undefined && attempt === 0;
+    let response;
+    let text;
     try {
-      parsed = JSON.parse(text);
-    } catch {
-      parsed = null;
+      response = await fetch(`${api.base}${path}`, { method, headers, body: body?.data });
+      text = await response.text();
+    } catch (e) {
+      if (again) {
+        await retry(RETRY_PAUSE_MS);
+        continue;
+      }
+      throw new CliError(`Could not reach Velven at ${api.base} (${causeOf(e)}).`, EXIT.failed, "network");
     }
+    let parsed = null;
+    if (text) {
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        parsed = null;
+      }
+    }
+    if (!response.ok) {
+      const error = errorFromResponse(response.status, parsed, path, api.creds, response.headers.get("retry-after"));
+      if (again && response.status >= 500 && error.code !== "workflow_unavailable") {
+        await retry(RETRY_PAUSE_MS);
+        continue;
+      }
+      throw error;
+    }
+    if (parsed === null)
+      throw new CliError(`Velven answered ${path} with something other than JSON.`, EXIT.failed, "bad_response");
+    return parsed;
   }
-  if (!response.ok)
-    throw errorFromResponse(response.status, parsed, path, api.creds, response.headers.get("retry-after"));
-  if (parsed === null)
-    throw new CliError(`Velven answered ${path} with something other than JSON.`, EXIT.failed, "bad_response");
-  return parsed;
 }
 function seg(value) {
   return encodeURIComponent(String(value));
@@ -120,7 +146,8 @@ async function stream(api, path, options, onEvent) {
   async function connect() {
     let got = false;
     const connectionKeys = new Set;
-    const url = options.from !== undefined && lastId === null ? `${path}${path.includes("?") ? "&" : "?"}from=${options.from}` : path;
+    const start = options.start && lastId === null ? "from" in options.start ? `from=${options.start.from}` : `after=${options.start.after}` : null;
+    const url = start ? `${path}${path.includes("?") ? "&" : "?"}${start}` : path;
     const headers = requestHeaders(api, "text/event-stream");
     if (lastId !== null)
       headers["last-event-id"] = lastId;
@@ -323,10 +350,9 @@ async function login(ctx) {
     ctx.out("Opened it in your browser. Waiting for you to approve...");
   else
     ctx.out("Open that link in a browser. Waiting for you to approve...");
-  let interval = Math.max(1, started.interval || 5);
-  const deadline = Date.now() + (started.expires_in || 900) * 1000;
+  const deadline = Date.now() + started.expires_in * 1000;
   while (Date.now() < deadline) {
-    await ctx.sleep(interval * 1000);
+    await ctx.sleep(started.interval * 1000);
     try {
       const token = await call(api, "POST", "/api/agent/token", { device_code: started.device_code });
       await saveToken(ctx, base, { token: token.access_token, handle: token.handle });
@@ -339,10 +365,6 @@ async function login(ctx) {
         throw e;
       if (e.code === "authorization_pending")
         continue;
-      if (e.code === "slow_down") {
-        interval += 5;
-        continue;
-      }
       if (e.code === "access_denied")
         throw new CliError("The sign-in was denied. Nothing was saved.", EXIT.auth, "access_denied");
       if (e.code === "expired_token" || e.code === "invalid_grant")
@@ -408,7 +430,11 @@ function parseArgs(argv, spec) {
     if (value === undefined || eq === -1 && value.startsWith("--")) {
       throw new CliError(`--${name} needs a value.`, EXIT.usage, "usage");
     }
-    flags[name] = value;
+    if (kind === "strings") {
+      const given = flags[name];
+      flags[name] = [...Array.isArray(given) ? given : [], value];
+    } else
+      flags[name] = value;
   }
   return { positionals, flags };
 }
@@ -416,6 +442,10 @@ function stringFlag(parsed, name) {
   const value = parsed.flags[name];
   return typeof value === "string" ? value : undefined;
 }
+function stringsFlag(parsed, name) {
+  const value = parsed.flags[name];
+  return Array.isArray(value) ? value : typeof value === "string" ? [value] : [];
+}
 
 // src/context.ts
 import { spawn } from "node:child_process";
@@ -467,9 +497,21 @@ function nodeContext() {
   };
 }
 
+// src/create.ts
+import { randomUUID } from "node:crypto";
+import { readFile as readFile3 } from "node:fs/promises";
+import { resolve } from "node:path";
+
 // src/create-state.ts
 import { chmod as chmod2, mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname as dirname2, join as join2 } from "node:path";
+function questionOf(value) {
+  if (!value || typeof value !== "object")
+    return;
+  const q = value;
+  const choices = Array.isArray(q.choices) && q.choices.every((c) => typeof c === "string") ? q.choices : null;
+  return typeof q.project === "string" && typeof q.item === "string" && choices?.length ? { project: q.project, item: q.item, choices } : undefined;
+}
 function createStatePath(ctx) {
   return join2(ctx.home, ".config", "velven", "create.json");
 }
@@ -489,9 +531,11 @@ async function readCreateFile(ctx) {
 }
 async function readCreateState(ctx, api) {
   const state = (await readCreateFile(ctx)).apis[api] ?? {};
+  const question = questionOf(state.question);
   return {
     ...typeof state.project === "string" && state.project ? { project: state.project } : {},
-    ...Number.isInteger(state.turn) ? { turn: state.turn } : {}
+    ...Number.isInteger(state.turn) ? { turn: state.turn } : {},
+    ...question ? { question } : {}
   };
 }
 async function saveCreateState(ctx, api, patch) {
@@ -499,6 +543,8 @@ async function saveCreateState(ctx, api, patch) {
   const next = { ...file.apis[api], ...patch };
   if (next.turn === undefined)
     delete next.turn;
+  if (next.question === undefined)
+    delete next.question;
   file.apis[api] = next;
   const path = createStatePath(ctx);
   await mkdir2(dirname2(path), { recursive: true, mode: 448 });
@@ -507,13 +553,21 @@ async function saveCreateState(ctx, api, patch) {
   await chmod2(path, 384);
 }
 
+// src/text.ts
+var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+function when(iso) {
+  if (!iso)
+    return "";
+  const d = new Date(iso);
+  return Number.isNaN(d.getTime()) ? iso : d.toISOString().slice(0, 16).replace("T", " ") + " UTC";
+}
+
 // src/create-timeline.ts
 var BAR_WIDTH = 60;
 var FOLD_OVER = 20;
 var LABEL_MAX = 44;
 var CHAIN_SLACK_MS = 50;
-var PHASE_ORDER = ["workspace", "planning", "coding", "building", "playtesting", "reviewing", "fixing", "saving", "previewing", "replying", "settle"];
-var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+var PHASE_ORDER = ["routing", "workspace", "planning", "coding", "building", "playtesting", "reviewing", "fixing", "saving", "previewing", "replying", "settle"];
 function seconds(ms) {
   return `${(ms / 1000).toFixed(1)} s`;
 }
@@ -569,7 +623,11 @@ function spanFacts(span) {
     fps_median: (v) => `${v} fps`,
     memory_mb: (v) => `${v} MB memory`,
     clocks: (v) => Number(v) > 1 ? "across two clocks" : null,
-    reasoning: (v) => Number(v) > 0 ? `reasoning ${count(Number(v))}` : null
+    reasoning: (v) => Number(v) > 0 ? `reasoning ${count(Number(v))}` : null,
+    route: (v) => `routed ${v}`,
+    route_by: (v) => v === "fallback" ? "the router did not answer" : null,
+    downgraded: (v) => v === true ? "full was over the hold" : null,
+    route_reason: (v) => `"${v}"`
   };
   if (span.kind === "model") {
     const input = (num(a.input) ?? 0) + (num(a.cached) ?? 0);
@@ -707,13 +765,13 @@ function bar(row, total) {
   return `|${" ".repeat(a)}${"#".repeat(b - a)}${" ".repeat(BAR_WIDTH - b)}|`;
 }
 function renderTimeline(turn, spans, options = {}) {
-  const kind = `${turn.effort} ${turn.plan ? "plan turn" : isFirstBuild(spans) ? "first build" : "build turn"}`;
+  const kind = turnKind(turn, spans);
   if (spans.length === 0) {
     const why = turn.status === "queued" || turn.status === "running" ? " A turn's timeline is written when it ends." : "";
     return [`Turn ${turn.id}, a ${kind}, ${turn.status}: no timeline.${why}`];
   }
   const spanEnd = Math.max(...spans.map(endOf));
-  const total = Math.max(spanEnd, turn.timing?.total_ms ?? 0);
+  const total = Math.max(spanEnd, turn.timing.total_ms ?? 0);
   const critical = criticalPath(spans);
   const { roots, children } = treeOf(spans);
   const rows = [];
@@ -756,7 +814,7 @@ function renderTimeline(turn, spans, options = {}) {
       visit(span, 0);
   const cut = (label) => label.length > LABEL_MAX ? `${label.slice(0, LABEL_MAX - 3)}...` : label;
   const width = Math.max(...rows.map((r) => cut(r.label).length), 4);
-  const turnTotal = turn.timing?.total_ms ?? spanEnd;
+  const turnTotal = turn.timing.total_ms ?? spanEnd;
   const lines = [
     `Turn ${turn.id}, a ${kind}, ${turn.status}: ${duration(turnTotal)}, ${plural(spans.length, "span")}${firsts(turn.timing)}. * marks the critical path.`,
     `${"span".padEnd(width)}  ${"0 s".padEnd(BAR_WIDTH / 2 + 1)}${seconds(total).padStart(BAR_WIDTH / 2 + 1)}  ${"start".padStart(8)}  ${"time".padStart(8)}`
@@ -768,12 +826,26 @@ function renderTimeline(turn, spans, options = {}) {
   return lines;
 }
 function isFirstBuild(spans) {
-  return spans.some((s) => s.name === "beginTurn" && s.attrs?.first_build === true);
+  return spans.some((s) => (s.name === "beginTurn" || s.name === "askRouter") && s.attrs?.first_build === true);
+}
+function workOf(spans) {
+  const interview = spans.find((s) => s.name === "askInterviewer" && typeof s.attrs?.interview === "string")?.attrs?.interview;
+  if (interview === "ask")
+    return "interview";
+  if (interview === "draft")
+    return "draft";
+  const route = spans.find((s) => s.name === "askRouter" && typeof s.attrs?.route === "string")?.attrs?.route;
+  return typeof route === "string" ? route : null;
+}
+function turnKind(turn, spans) {
+  const work = workOf(spans);
+  if (work === "interview" || work === "draft")
+    return `${turn.effort} ${work} turn`;
+  const what = turn.plan ? "plan turn" : isFirstBuild(spans) ? "first build" : "build turn";
+  return `${turn.effort} ${work === "fast" || work === "full" ? `${work} ` : ""}${what}`;
 }
 function firsts(timing) {
-  if (!timing || timing.first_dev_ms === undefined && timing.first_write_ms === undefined && timing.first_preview_ms === undefined)
-    return "";
-  const say = (ms) => typeof ms === "number" ? duration(ms) : "-";
+  const say = (ms) => ms === null ? "-" : duration(ms);
   return `; live link ${say(timing.first_dev_ms)}, first change ${say(timing.first_write_ms)}, first playable ${say(timing.first_preview_ms)}`;
 }
 var isEngineRun = (s) => s.kind === "step" && s.name === "engine_programmer";
@@ -806,11 +878,7 @@ function engineSummary(spans) {
   if (!run)
     return null;
   const a = run.attrs ?? {};
-  const kids = spans.filter((s) => s.parent === run.id);
-  const steps = num(a.steps) ?? kids.filter((s) => s.kind === "model").length;
-  const tools = num(a.tools) ?? kids.filter((s) => s.kind === "tool").length;
-  const images = num(a.images) ?? kids.filter((s) => s.kind === "tool" && s.name === "make_image").length;
-  const figures = [plural(steps, "model step"), plural(tools, "tool call"), plural(images, "image")];
+  const figures = [plural(num(a.steps) ?? 0, "model step"), plural(num(a.tools) ?? 0, "tool call"), plural(num(a.images) ?? 0, "image")];
   if (a.cut === true)
     figures.push("cut short");
   return `in ${duration(run.ms)}: ${figures.join(", ")}`;
@@ -824,23 +892,29 @@ function table(rows, indent) {
 var sec = (ms) => ms === null ? "-" : seconds(ms);
 var pair = (p, f) => `${f(p.p50)} / ${f(p.p90)}`;
 function groupTitle(g) {
+  if (g.work === "interview" || g.work === "draft")
+    return `${g.effort} ${g.work} turns, ${g.engine}`;
   const what = g.plan ? "plan turns" : g.first_build === true ? "first builds" : g.first_build === false ? "later builds" : "build turns";
-  return `${g.effort} ${what}, ${g.engine}`;
+  const work = g.work === "plan" ? "routed " : g.work ? `${g.work} ` : "";
+  return `${g.effort} ${work}${what}, ${g.engine}`;
 }
 function renderStats(groups, options) {
   const over = `the last ${plural(options.days, "day")}${options.origin ? `, from ${options.origin}` : ""}`;
   if (groups.length === 0)
     return [`No turns finished in ${over}.`];
-  const per = options.microsPerCredit ?? null;
-  const credits = (micros) => micros === null || !per ? "-" : String(Math.ceil(micros / per));
+  const per = options.microsPerCredit;
+  const credits = (micros) => micros === null || per === null ? "-" : String(Math.ceil(micros / per));
   const cents = (micros) => micros === null ? "-" : (micros / 1e4).toFixed(1);
   const lines = [`Turns created in ${over}: p50 and p90 over the done turns.`];
   for (const g of groups) {
     lines.push("", `${groupTitle(g)}: ${plural(g.turns, "done turn")}, ${g.failed} failed`);
+    const reacted = REACTION_WORDS.filter(([key]) => (g.reactions[key] ?? 0) > 0).map(([key, words]) => `${words} ${g.reactions[key]}`);
+    if (reacted.length)
+      lines.push(`  the next message: ${reacted.join(", ")}`);
     const figures = [
       ["figure", "p50", "p90", "turns"],
       ["first live link", sec(g.first_dev_ms.p50), sec(g.first_dev_ms.p90), ""],
-      ["first change", sec(g.first_write_ms?.p50 ?? null), sec(g.first_write_ms?.p90 ?? null), ""],
+      ["first change", sec(g.first_write_ms.p50), sec(g.first_write_ms.p90), ""],
       ["first playable", sec(g.first_preview_ms.p50), sec(g.first_preview_ms.p90), ""],
       ["whole turn", sec(g.total_ms.p50), sec(g.total_ms.p90), ""]
     ];
@@ -865,6 +939,12 @@ function renderStats(groups, options) {
   }
   return lines;
 }
+var REACTION_WORDS = [
+  ["moved_on", "moved on"],
+  ["corrected", "corrected it"],
+  ["asked_checks", "asked for checks"],
+  ["none", "no reaction"]
+];
 function rank(phase) {
   const i = PHASE_ORDER.indexOf(phase);
   return i === -1 ? PHASE_ORDER.length : i;
@@ -875,38 +955,82 @@ var CREATE_HELP = `velven create: describe a game, and Velven's agents build it.
 
 Usage:
   velven create new [title...]       Start a project; it becomes the current one
-      --engine <id>                  The engine pack (default phaser)
-      --genre <id>                   The genre pack (default arcade)
-  velven create send <text...>       Send the project a message: prints the estimate, asks, then follows the turn
+      --engine <id>                  The engine pack (default: Velven picks, 3D unless your idea is clearly 2D)
+      --genre <id>                   The genre pack (default none: an open game, Velven follows your idea;
+                                     --genre arcade holds it to arcade's rules)
+  velven create send <text...>       Send the project a message: prints the estimate, asks, then follows the turn.
+                                     Velven picks how much to do (a quick change, a full build with a playtest,
+                                     a plan; on a new game a question or two, then a short plan to shape) unless
+                                     you pass --effort or a plan flag. Sent while a turn runs, it joins that turn
+                                     when the turn is writing code, else waits for the turn to end (with
+                                     --effort, a plan flag, --build, --ref or --answer it always waits)
       --project <id>                 A project other than the current one
-      --effort quick|standard|deep   How much the turn may do; kept for later messages until you change it
-      --plan, --no-plan              Plan mode: the turn updates the design document and changes no game files;
-                                     kept until you change it (on by default for standard, off for quick)
+      --effort quick|standard|deep   How much the turn may do, instead of Velven's pick. The project keeps it
+                                     for a later message that passes only a plan flag; a message with neither
+                                     flag is Velven's pick again
+      --plan, --no-plan              Plan mode, instead of Velven's pick: the turn updates the design document
+                                     and changes no game files. Kept as --effort is (with --effort alone, on for
+                                     a new standard or deep, off for quick)
+      --build                        Build it: no more questions, Velven fills in what the plan leaves open
+                                     (Velven still picks how much)
+      --answer <n>                   Answer the open question with its choice n (its words are sent, unless
+                                     you give your own)
+      --queue                        Sent while a turn runs: wait for it to end instead of joining it
+      --ref <file|ref-n>             A reference picture (PNG, JPEG or WebP, up to 10 MB) sent with the message, or
+                                     one the project keeps by its id (ref-3); up to 4
       --yes, -y                      Do not ask before sending
       --detach                       Send it and return at once; follow it later with watch
   velven create watch [turn]         Follow a turn to its end (default: the last one)
       --from <n>                     Start from this event
-  velven create cancel [turn]        Stop a turn: what it finished is saved, unused credits come back
+  velven create watch <project>      Follow a project's chat: its turns, messages, pictures, queue and versions
+      --from <n>                     Only what came after this event
+      --until-idle                   End once no turn runs, no preview is being rebuilt and no message waits
+                                     to start (one on a paused queue waits for resume)
+  velven create cancel [turn]        Stop a turn: what it finished is saved, unused credits come back, and the
+                                     messages waiting on the project pause until you resume them
+  velven create resume               Start the messages waiting on the project again after a failed or stopped
+                                     turn paused them
+      --project <id>                 A project other than the current one
+  velven create versions             The project's versions, newest first: each saved turn, and 0, the template
+      --project <id>                 A project other than the current one
+  velven create restore <version>    Go back (or forward) to a version: instant and free; Velven rebuilds its
+                                     preview when it expired
+      --project <id>                 A project other than the current one
   velven create list                 Your projects (* is the current one)
-  velven create show [project]       A project, its newest turn and its preview link (a fresh 24-hour link)
+  velven create show [project]       A project, what it is doing, its newest turn and its preview link (a fresh
+                                     24-hour link)
       --timeline                     The newest turn's timeline instead: a waterfall of every step, model and
                                      tool call, the critical path marked (* at the line's end)
       --turn <id>                    With --timeline: this turn instead of the project's newest
       --all                          With --timeline: list every tool call and screenshot (past 20 under one
                                      step they fold into one line)
+  velven create refs                 The project's reference pictures: each id, when it was added and how many
+                                     messages carried it (a project keeps up to 16)
+      --project <id>                 A project other than the current one
+  velven create refs rm <ref-n>      Delete a picture, sent or not; the messages that carried it keep its number
+  velven create plan                 The project's short plan: what the game is, how it plays, its look
+      --project <id>                 A project other than the current one
+  velven create queue                The messages waiting on the project, in the order they run
+      --project <id>                 A project other than the current one
+  velven create queue edit <id> <text...>   Change a waiting message's words (--build: send it as Build it)
+  velven create queue move <id> <place>     Move a waiting message to a place in line (1 runs next)
+  velven create queue rm <id>        Remove a waiting message
   velven create credits              Your credits and the latest entries
+  velven create usage                What each of your turns held and used, newest first
+      --project <id>                 Only this project's turns
+      --before <turn>                The page before this turn (the line at the end names it)
   velven create stats                Admins: p50 and p90 over recent turns, by effort, plan mode and engine
       --days <n>                     Turns created in the last n days, 1 to 90 (default 7)
       --origin <origin>              Only turns sent from web, api, cli, mcp or benchmark
 
-  --json: new, send, list, show, credits and stats print one JSON object (send prints the finished turn,
-  show --timeline the timeline); watch prints one event per line.
-  Ctrl+C stops following a turn; the turn goes on.
+  --json: new, send, list, show, plan, queue, refs, versions, restore, resume, credits, usage and stats print one
+  JSON object (send prints the finished turn, show --timeline the timeline); watch prints one event per line.
+  Ctrl+C stops following a turn; the turn goes on. On a project, it stops watching (exit 0).
 
 Exit codes:
   0 done (also a turn that stopped at its credit cap or time limit)   1 failed, cancelled or no longer followed
-  2 bad command   3 needs sign-in   4 refused (no credits, closed, busy, too many turns, effort unavailable,
-  not found)   5 rate limited, try later`;
+  2 bad command   3 needs sign-in   4 refused (no credits, closed, a turn is open, too many turns, effort
+  unavailable, a picture refused, not found)   5 rate limited, try later`;
 var CREATE_FLAGS = {
   engine: "string",
   genre: "string",
@@ -914,29 +1038,52 @@ var CREATE_FLAGS = {
   effort: "string",
   plan: "boolean",
   "no-plan": "boolean",
+  build: "boolean",
+  answer: "string",
+  queue: "boolean",
+  ref: "strings",
   yes: "boolean",
   detach: "boolean",
   from: "string",
+  "until-idle": "boolean",
   json: "boolean",
   timeline: "boolean",
   turn: "string",
   all: "boolean",
   days: "string",
-  origin: "string"
+  origin: "string",
+  before: "string"
 };
 var SUBCOMMANDS = {
   new: ["engine", "genre", "json"],
-  send: ["project", "effort", "plan", "no-plan", "yes", "detach", "json"],
-  watch: ["from", "json"],
+  send: ["project", "effort", "plan", "no-plan", "build", "answer", "queue", "ref", "yes", "detach", "json"],
+  watch: ["from", "until-idle", "json"],
   cancel: [],
+  resume: ["project", "json"],
+  versions: ["project", "json"],
+  restore: ["project", "json"],
   list: ["json"],
   show: ["json", "timeline", "turn", "all"],
+  refs: ["project", "json"],
+  plan: ["project", "json"],
+  queue: ["project", "build", "json"],
   credits: ["json"],
+  usage: ["project", "before", "json"],
   stats: ["days", "origin", "json"]
 };
 var EFFORTS = ["quick", "standard", "deep"];
+var REFS_PER_MESSAGE = 4;
+var REFS_PER_PROJECT = 16;
 var ORIGINS = ["web", "api", "cli", "mcp", "benchmark"];
 var ROOT = "/api/v1/create";
+var FAILURE_SENTENCES = {
+  credits: "This turn could not start: not enough credits.",
+  capacity: "Velven is at capacity; try again in a few minutes.",
+  model: "The model service did not answer.",
+  sandbox: "The workspace did not start.",
+  build: "The build was refused, so no preview was made.",
+  unknown: "Something went wrong on Velven's side."
+};
 async function create(ctx, parsed) {
   const [sub, ...args] = parsed.positionals;
   if (!sub) {
@@ -960,9 +1107,15 @@ async function create(ctx, parsed) {
     case "send":
       return send(ctx, api, args, parsed, json);
     case "watch":
-      return watch(ctx, api, args[0], stringFlag(parsed, "from"), json);
+      return watch(ctx, api, args, stringFlag(parsed, "from"), parsed.flags["until-idle"] === true, json);
     case "cancel":
       return cancel(ctx, api, args[0]);
+    case "resume":
+      return resume(ctx, api, args, stringFlag(parsed, "project"), json);
+    case "versions":
+      return versions(ctx, api, args, stringFlag(parsed, "project"), json);
+    case "restore":
+      return restore(ctx, api, args, stringFlag(parsed, "project"), json);
     case "list":
       return list(ctx, api, json);
     case "show":
@@ -974,6 +1127,14 @@ async function create(ctx, parsed) {
       return show(ctx, api, args[0], json);
     case "stats":
       return stats(ctx, api, stringFlag(parsed, "days"), stringFlag(parsed, "origin"), json);
+    case "refs":
+      return referencePictures(ctx, api, args, stringFlag(parsed, "project"), json);
+    case "usage":
+      return usage(ctx, api, stringFlag(parsed, "project"), stringFlag(parsed, "before"), json);
+    case "plan":
+      return showPlan(ctx, api, args, stringFlag(parsed, "project"), json);
+    case "queue":
+      return queue(ctx, api, args, stringFlag(parsed, "project"), parsed.flags.build === true, json);
     default:
       return credits(ctx, api, json);
   }
@@ -993,12 +1154,17 @@ async function newProject(ctx, api, title, engine, genre, json) {
     return EXIT.ok;
   }
   ctx.out(`Started ${project.title ?? "a project"} (${project.id}): ${packs(project)}. It is now the current project.`);
-  ctx.out('Tell it what to build: velven create send "a one-button game where a fox jumps over logs"');
+  if (!project.genre)
+    ctx.out("An open game: Velven follows your idea. --genre arcade holds a project to arcade's rules.");
+  if (!engine)
+    ctx.out("Velven picks the engine from your idea: 3D unless it is clearly 2D.");
+  ctx.out('Tell it what to build: velven create send "a cozy game where you grow a garden on a floating island"');
   return EXIT.ok;
 }
 async function send(ctx, api, words, parsed, json) {
-  const text = words.join(" ").trim();
-  if (!text)
+  let text = words.join(" ").trim();
+  const answerFlag = stringFlag(parsed, "answer");
+  if (!text && answerFlag === undefined)
     throw new CliError('Say what to build or change, like velven create send "make the fox jump higher".', EXIT.usage, "usage");
   const effort = stringFlag(parsed, "effort");
   if (effort !== undefined && !EFFORTS.includes(effort)) {
@@ -1008,60 +1174,292 @@ async function send(ctx, api, words, parsed, json) {
     throw new CliError("Pass --plan or --no-plan, not both.", EXIT.usage, "usage");
   }
   const plan = parsed.flags.plan === true ? true : parsed.flags["no-plan"] === true ? false : undefined;
+  const routed = effort === undefined && plan === undefined;
+  const refs = stringsFlag(parsed, "ref");
+  if (refs.length > REFS_PER_MESSAGE)
+    throw new CliError(`A message takes up to ${REFS_PER_MESSAGE} pictures; ${refs.length} were given with --ref.`, EXIT.usage, "usage");
   const project = await currentProject(ctx, api.base, stringFlag(parsed, "project"));
+  let answer;
+  if (answerFlag !== undefined) {
+    const { question } = await readCreateState(ctx, api.base);
+    if (!question || question.project !== project) {
+      throw new CliError("There is no question to answer on this project. Send your answer in words instead.", EXIT.usage, "no_question");
+    }
+    const choice = Number(answerFlag);
+    if (!/^\d+$/.test(answerFlag) || choice < 1 || choice > question.choices.length) {
+      throw new CliError(`--answer is the number of a choice, 1 to ${question.choices.length}, not "${answerFlag}".`, EXIT.usage, "usage");
+    }
+    answer = { item: question.item, choice };
+    if (!text)
+      text = question.choices[choice - 1];
+  }
+  const pictures = await Promise.all(refs.map((ref) => REF_ID.test(ref) ? ref : readPicture(ctx, ref)));
   const say = json ? () => {} : (line) => ctx.out(line);
   const query = new URLSearchParams;
+  if (routed)
+    query.set("routed", "true");
+  if (routed && parsed.flags.build === true)
+    query.set("intent", "build");
   if (effort !== undefined)
     query.set("effort", effort);
   if (plan !== undefined)
     query.set("plan", String(plan));
   const search = query.toString();
   const { estimate } = await call(api, "GET", `${ROOT}/projects/${seg(project)}/estimate${search ? `?${search}` : ""}`);
-  const kind = estimate.plan ? `${estimate.effort} plan turn` : estimate.first_build === true ? `${estimate.effort} first build (its pictures are made before the first preview)` : `${estimate.effort} build turn`;
-  say(`A ${kind}: about ${estimate.credits.typical} credits, at most ${estimate.credits.cap}. You have ${estimate.available} available.`);
+  if (estimate.open_turn) {} else if (routed) {
+    const what = estimate.shaping ? "a question or a short plan" : estimate.first_build ? "a first build (its pictures are made before the first preview)" : "a small change";
+    say(`Velven picks how much to do: about ${estimate.credits.typical} credits for ${what}, at most ${estimate.credits.cap} held. You have ${estimate.available} available.`);
+  } else {
+    const kind = estimate.plan ? `${estimate.effort} plan turn` : estimate.first_build ? `${estimate.effort} first build (its pictures are made before the first preview)` : `${estimate.effort} build turn`;
+    say(`A ${kind}: about ${estimate.credits.typical} credits, at most ${estimate.credits.cap}. You have ${estimate.available} available.`);
+  }
   if (!estimate.enough) {
     throw new CliError(estimate.reason ?? "Velven cannot start this turn now.", EXIT.refused, "not_enough");
   }
   if (ctx.interactive && !json && parsed.flags.yes !== true) {
-    const answer = (await ctx.ask("Send it? (Y/n) ")).trim().toLowerCase();
-    if (answer === "n" || answer === "no") {
+    const reply = (await ctx.ask("Send it? (Y/n) ")).trim().toLowerCase();
+    if (reply === "n" || reply === "no") {
       ctx.out("Nothing was sent.");
       return EXIT.failed;
     }
   }
-  const body = { text };
+  const body = { text, client_id: randomUUID() };
+  if (parsed.flags.queue === true)
+    body.delivery = "queue";
   if (effort !== undefined)
     body.effort = effort;
   if (plan !== undefined)
     body.plan = plan;
-  const sent = await call(api, "POST", `${ROOT}/projects/${seg(project)}/messages`, body);
-  const turn = sent.turn;
+  if (parsed.flags.build === true)
+    body.intent = "build";
+  if (answer)
+    body.answer = answer;
+  if (pictures.length) {
+    const ids = [];
+    for (const picture of pictures)
+      ids.push(typeof picture === "string" ? picture : await uploadPicture(api, project, picture));
+    body.references = ids;
+    say(`Attached ${plural(ids.length, "picture")}: ${ids.join(", ")}.`);
+  }
+  const sent = await call(api, "POST", `${ROOT}/projects/${seg(project)}/messages`, body, { retryOnce: { sleep: ctx.sleep } });
+  if ((await readCreateState(ctx, api.base)).question?.project === project)
+    await saveCreateState(ctx, api.base, { question: undefined });
+  const already = sent.again ? "(already sent) " : "";
+  if ("steer" in sent)
+    return steered(ctx, api, project, sent, already, parsed.flags.detach === true, json);
+  let turn;
+  let stream2;
+  if ("queued" in sent) {
+    const queued = sent.queued;
+    if (queued.state === "refused")
+      throw new CliError(queued.refused ?? "Velven could not start this message.", EXIT.refused, "refused");
+    if (queued.state === "waiting" || queued.turn === null) {
+      if (json)
+        ctx.out(JSON.stringify({ ok: true, queued, why: sent.why, ...sent.again ? { again: true } : {} }));
+      else
+        say(`${already}${queuedLine(queued, sent.why)}`);
+      return EXIT.ok;
+    }
+    turn = { id: queued.turn, ...queued.capped === true ? { queued: true } : {} };
+  } else {
+    turn = sent.turn;
+    stream2 = sent.stream;
+  }
   await saveCreateState(ctx, api.base, { project, turn: turn.id });
   if (turn.queued)
-    say(`Turn ${turn.id} waits for room on Velven and starts on its own.`);
+    say(`${already}Turn ${turn.id} waits for room on Velven and starts on its own.`);
   else
-    say(`Turn ${turn.id} is on its way.`);
+    say(`${already}Turn ${turn.id} is on its way.`);
   if (parsed.flags.detach === true) {
     if (json)
-      ctx.out(JSON.stringify({ ok: true, turn }));
+      ctx.out(JSON.stringify({ ok: true, turn, ...sent.again ? { again: true } : {} }));
     else
       say(`Follow it: velven create watch ${turn.id}; stop it: velven create cancel ${turn.id}`);
     return EXIT.ok;
   }
-  const path = sent.stream?.startsWith("/") ? sent.stream : `${ROOT}/turns/${seg(turn.id)}/stream`;
-  return follow(ctx, api, turn.id, path, undefined, json ? "final" : "text");
+  const path = stream2 ?? `${ROOT}/turns/${seg(turn.id)}/stream`;
+  return follow(ctx, api, turn.id, path, undefined, json ? "final" : "text", project);
 }
-async function watch(ctx, api, arg, fromFlag, json) {
+async function steered(ctx, api, project, sent, already, detach, json) {
+  const turn = sent.steer.turn;
+  const say = json ? () => {} : (line) => ctx.out(line);
+  if (sent.steer.state === "dropped") {
+    if (json)
+      ctx.out(JSON.stringify({ ok: true, message: sent.message, steer: sent.steer, again: true }));
+    else
+      say(`${already}${STEER_DROPPED}`);
+    return EXIT.ok;
+  }
+  await saveCreateState(ctx, api.base, { project, turn });
+  say(`${already}Sent to the running turn (${turn}).`);
+  if (sent.steer.state === "taken")
+    say(STEER_TAKEN);
+  if (detach) {
+    if (json)
+      ctx.out(JSON.stringify({ ok: true, message: sent.message, steer: sent.steer, ...sent.again ? { again: true } : {} }));
+    else
+      say(`Follow it: velven create watch ${turn}; stop it: velven create cancel ${turn}`);
+    return EXIT.ok;
+  }
+  const mine = `m${sent.message.id}`;
+  let state = sent.steer.state;
+  let queuedWhy;
+  let started = null;
+  let replied = false;
+  let ended = null;
+  const controller = new AbortController;
+  ctx.untilStopped().then(() => controller.abort());
+  let final;
+  try {
+    final = await stream(api, `${ROOT}/projects/${seg(project)}/stream`, { start: { after: sent.seq }, signal: controller.signal, sleep: ctx.sleep }, (raw) => {
+      const event = raw;
+      const items = event.type === "snapshot" ? event.items : event.type === "item" ? [event.item] : [];
+      for (const item of items) {
+        const summary = item.summary;
+        if (summary.kind !== "message")
+          continue;
+        if (item.id === mine && summary.steer) {
+          const paused = summary.steer.state === "queued" && summary.steer.why === "paused" && queuedWhy !== "paused";
+          if (summary.steer.state !== state || paused) {
+            state = summary.steer.state;
+            queuedWhy = summary.steer.why;
+            if (state === "taken")
+              say(STEER_TAKEN);
+            if (state === "queued")
+              say(steerQueuedLine(queuedWhy));
+          }
+          if (summary.steer.started && started === null)
+            started = summary.steer.started;
+        }
+        if (item.turn_id === turn && summary.role === "agent" && !replied) {
+          replied = true;
+          say(summary.text);
+        }
+      }
+      const turns = event.type === "snapshot" ? event.turns : event.type === "turn" ? [event.turn] : [];
+      for (const t of turns)
+        if (t.id === turn && ENDED.has(t.status))
+          ended = t;
+      return event.type === "error" || ended !== null;
+    });
+  } catch (e) {
+    if (e instanceof CliError && e.code === "stream_lost") {
+      const lost = new CliError(`${e.message} The turn goes on: velven create watch ${turn}`, e.exitCode, e.code);
+      if (!json)
+        throw lost;
+      ctx.out(JSON.stringify({ ok: false, error: lost.message, code: lost.code, turn: { id: turn } }));
+      return lost.exitCode;
+    }
+    throw e;
+  } finally {
+    controller.abort();
+  }
+  if (final === null || final.type === "error") {
+    const message = final === null ? `The turn goes on. Watch it: velven create watch ${turn}; stop it: velven create cancel ${turn}` : `${final.message} The turn may go on. Watch it: velven create watch ${turn}`;
+    if (json)
+      ctx.out(JSON.stringify({ ok: false, error: message, code: final === null ? "detached" : final.code, turn: { id: turn } }));
+    else
+      ctx.err(message);
+    return EXIT.failed;
+  }
+  const end = ended;
+  const code = end?.status === "done" ? EXIT.ok : EXIT.failed;
+  if (json) {
+    const read = await call(api, "GET", `${ROOT}/turns/${seg(turn)}`).catch(() => null);
+    ctx.out(JSON.stringify({ ok: code === EXIT.ok, message: sent.message, steer: { turn, state }, turn: read?.turn ?? end }));
+    return code;
+  }
+  if (!replied) {
+    const read = await call(api, "GET", `${ROOT}/turns/${seg(turn)}`).catch(() => null);
+    if (read?.turn.reply?.body)
+      ctx.out(read.turn.reply.body);
+  }
+  if (end)
+    for (const line of endLines(end))
+      ctx.out(line);
+  if (started !== null)
+    ctx.out(`Your message is running: velven create watch ${started}`);
+  return code;
+}
+var ENDED = new Set(["done", "cancelled", "failed"]);
+var STEER_TAKEN = "Taken into account.";
+var STEER_QUEUED = "Could not be taken this turn; queued as the next message.";
+var STEER_PAUSED = "Could not be taken this turn; queued, but the queue is paused after a failed or stopped turn. Start it: velven create resume";
+function steerQueuedLine(why) {
+  return why === "paused" ? STEER_PAUSED : STEER_QUEUED;
+}
+var STEER_DROPPED = "Taken out of the queue; it will not run.";
+function endLines(turn) {
+  if (turn.status === "done")
+    return [`Turn ${turn.id} is done.`, ...stopLines(turn.stop_reason)];
+  if (turn.status === "cancelled")
+    return [`Turn ${turn.id} was cancelled. What it finished is saved.`];
+  const sentence = turn.error ?? (turn.failure ? FAILURE_SENTENCES[turn.failure.class] : "Velven could not finish it.");
+  return [`Turn ${turn.id} failed: ${sentence} A failed turn costs nothing.${turn.failure?.retryable ? " Try again." : ""}`];
+}
+function stopLines(stop) {
+  if (stop === "cap")
+    return ["It stopped at its credit cap. What it finished is saved: send another message to go on."];
+  if (stop === "time")
+    return ["It stopped at its time limit. What it finished is saved: send another message to go on."];
+  return [];
+}
+var REF_ID = /^ref-[1-9][0-9]{0,2}$/;
+async function uploadPicture(api, project, picture) {
+  const { upload } = await call(api, "POST", `${ROOT}/projects/${seg(project)}/references/uploads`);
+  const tooLarge = `The picture ${picture.file} is larger than ${Math.floor(upload.max_bytes / (1024 * 1024))} MB. Send a smaller one.`;
+  if (picture.bytes.length > upload.max_bytes)
+    throw new CliError(tooLarge, EXIT.refused, "too_large");
+  await putBytes(upload.url, picture.bytes, picture.type, tooLarge);
+  try {
+    const { reference } = await call(api, "POST", `${ROOT}/projects/${seg(project)}/references`, { upload: upload.id });
+    return reference.id;
+  } catch (e) {
+    if (e instanceof CliError && e.code === "too_many_references") {
+      const named = `velven create refs --project ${project}`;
+      throw new CliError(`${e.message} See them: ${named}; remove one: velven create refs rm <ref-n> --project ${project}.`, e.exitCode, e.code);
+    }
+    throw e;
+  }
+}
+var PICTURE_TYPES = { png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", webp: "image/webp" };
+async function readPicture(ctx, file) {
+  let bytes;
+  try {
+    bytes = new Uint8Array(await readFile3(resolve(ctx.cwd, file)));
+  } catch {
+    throw new CliError(`Could not read the picture ${file}.`, EXIT.usage, "usage");
+  }
+  const ext = file.toLowerCase().split(".").pop() ?? "";
+  return { file, bytes, type: PICTURE_TYPES[ext] ?? "application/octet-stream" };
+}
+async function turnProject(ctx, api, turn) {
+  try {
+    const { turn: view } = await call(api, "GET", `${ROOT}/turns/${seg(turn)}`);
+    return view.project;
+  } catch {
+    return (await readCreateState(ctx, api.base)).project ?? null;
+  }
+}
+async function watch(ctx, api, args, fromFlag, untilIdle, json) {
+  const [arg, ...rest] = args;
+  if (rest.length)
+    throw new CliError("Name one turn or one project to watch, like velven create watch 12.", EXIT.usage, "usage");
   let from;
   if (fromFlag !== undefined) {
     if (!/^\d+$/.test(fromFlag))
       throw new CliError(`--from is an event number, like 12, not "${fromFlag}".`, EXIT.usage, "usage");
     from = Number(fromFlag);
   }
+  if (arg !== undefined && !/^\d+$/.test(arg))
+    return watchProject(ctx, api, arg, from, untilIdle, json);
+  if (untilIdle)
+    throw new CliError("--until-idle goes with a project, like velven create watch <project> --until-idle.", EXIT.usage, "usage");
   const turn = await turnId(ctx, api.base, arg, "watch");
+  const named = json ? null : await turnProject(ctx, api, turn);
   let code;
   try {
-    code = await follow(ctx, api, turn, `${ROOT}/turns/${seg(turn)}/stream`, from, json ? "events" : "text");
+    code = await follow(ctx, api, turn, `${ROOT}/turns/${seg(turn)}/stream`, from, json ? "events" : "text", named);
   } catch (e) {
     if (e instanceof CliError && e.code === "stream_lost")
       await saveCreateState(ctx, api.base, { turn });
@@ -1070,13 +1468,311 @@ async function watch(ctx, api, arg, fromFlag, json) {
   await saveCreateState(ctx, api.base, { turn });
   return code;
 }
-async function follow(ctx, api, turn, path, from, mode) {
+async function watchProject(ctx, api, project, after, untilIdle, json) {
   const controller = new AbortController;
   ctx.untilStopped().then(() => controller.abort());
-  const said = { held: null, engine: null };
+  const kept = (await readCreateState(ctx, api.base)).question;
+  const before = kept?.project === project ? kept : null;
+  const chat = chatView(ctx, api.base, project, before);
+  let idle = false;
+  let synced = false;
   let final;
   try {
-    final = await stream(api, path, { from, signal: controller.signal, sleep: ctx.sleep }, (event2) => {
+    final = await stream(api, `${ROOT}/projects/${seg(project)}/stream`, { ...after !== undefined ? { start: { after } } : {}, signal: controller.signal, sleep: ctx.sleep }, (raw) => {
+      const event = raw;
+      if (json)
+        ctx.out(JSON.stringify(raw));
+      else
+        chat.show(event);
+      if (event.type === "summary") {
+        const { open_turn, rebuilding, queue } = event.summary;
+        idle = open_turn === null && rebuilding === null && (queue.waiting === 0 || queue.paused !== null);
+      }
+      if (event.type === "synchronized")
+        synced = true;
+      return event.type === "error" || untilIdle && synced && idle && (event.type === "synchronized" || event.type === "summary");
+    });
+  } catch (e) {
+    if (e instanceof CliError && e.code === "stream_lost")
+      throw new CliError(`${e.message} Watch it again: velven create watch ${project}`, e.exitCode, e.code);
+    throw e;
+  } finally {
+    controller.abort();
+    if (chat.question !== before)
+      await saveCreateState(ctx, api.base, { question: chat.question ?? undefined });
+  }
+  if (final?.type === "error") {
+    if (!json)
+      ctx.err(final.message || "The project's stream answered with an error.");
+    return EXIT.failed;
+  }
+  return EXIT.ok;
+}
+function chatView(ctx, base, project, kept) {
+  const send2 = `velven create send --project ${project}`;
+  const said = new Map;
+  const turns = new Map;
+  let headed = null;
+  let queueSaid = "";
+  let failureSaid = "";
+  let synced = false;
+  let olderSaid = false;
+  const header = (turn, summary) => {
+    if (turn === null || headed === turn) {
+      headed = turn;
+      return;
+    }
+    headed = turn;
+    const marks = summary ? [summary.status, summary.version ? `version ${summary.version}` : null, summary.rolled_back ? "rolled back" : null].filter((m) => m !== null) : [];
+    ctx.out(`Turn ${turn}${marks.length ? ` (${marks.join(", ")})` : ""}`);
+  };
+  const turnKey = (t) => `${t.status}|${t.phase ?? ""}`;
+  const works = new Map;
+  const item = (i, summaries) => {
+    if (i.summary.kind === "route" && i.turn_id !== null)
+      works.set(i.turn_id, i.summary.work);
+    const lines = itemLines(i, base, send2, i.turn_id !== null && works.get(i.turn_id) === "draft");
+    const known = said.get(i.id) ?? new Set;
+    said.set(i.id, known);
+    const fresh = [...lines.out.map((line) => ({ key: `out ${line}`, line, write: ctx.out })), ...lines.err.map((line) => ({ key: `err ${line}`, line, write: ctx.err }))].filter((l) => !known.has(l.key));
+    const under = chatTurn(i);
+    if (fresh.length)
+      header(under, under !== null ? summaries.get(under) : undefined);
+    for (const { key, line, write } of fresh) {
+      known.add(key);
+      write(line);
+    }
+    if (i.summary.kind === "question") {
+      if (i.summary.state === "open")
+        view.question = { project, item: i.id, choices: i.summary.choices };
+      else if (view.question?.item === i.id)
+        view.question = null;
+    }
+  };
+  const view = {
+    question: kept,
+    show(event) {
+      switch (event.type) {
+        case "snapshot": {
+          const summaries = new Map(event.turns.map((t) => [t.id, t]));
+          for (const t of event.turns)
+            turns.set(t.id, turnKey(t));
+          if (event.older && !olderSaid)
+            ctx.err("Earlier turns are not shown.");
+          olderSaid ||= event.older !== null;
+          for (const i of chatOrder(event.items))
+            item(i, summaries);
+          return;
+        }
+        case "item":
+          item(event.item, new Map);
+          return;
+        case "turn": {
+          const t = event.turn;
+          const before = turns.get(t.id);
+          if (before === turnKey(t))
+            return;
+          turns.set(t.id, turnKey(t));
+          if (ENDED.has(t.status)) {
+            if (before?.split("|")[0] !== t.status)
+              for (const line of endLines(t))
+                ctx.out(line);
+          } else if (t.phase)
+            ctx.err(`Turn ${t.id}: ${t.phase}`);
+          return;
+        }
+        case "queue": {
+          const waiting = event.queue.queued.filter((q) => q.state === "waiting").length;
+          const line = event.queue.paused ? `${plural(waiting, "message")} waiting. ${pausedLine(event.queue.paused)}` : waiting ? `${plural(waiting, "message")} waiting.` : queueSaid ? "Nothing is waiting." : "";
+          if (line && line !== queueSaid)
+            ctx.out(line);
+          queueSaid = line;
+          return;
+        }
+        case "summary": {
+          const line = failureLine(event.summary) ?? "";
+          if (line && line !== failureSaid)
+            ctx.out(line);
+          failureSaid = line;
+          return;
+        }
+        case "synchronized":
+          if (!synced)
+            ctx.out("Up to date.");
+          synced = true;
+          return;
+        default:
+          return;
+      }
+    }
+  };
+  return view;
+}
+function chatTurn(i) {
+  return i.summary.kind === "message" && i.summary.steer ? i.summary.steer.turn : i.turn_id;
+}
+function chatOrder(items) {
+  const last = new Map;
+  const byId = new Map(items.map((i) => [i.id, i]));
+  for (const i of items) {
+    for (let up = i.parent ? byId.get(i.parent) : undefined;up; up = up.parent ? byId.get(up.parent) : undefined) {
+      last.set(up.id, Math.max(last.get(up.id) ?? up.pos, i.pos));
+    }
+  }
+  const at = (i) => i.summary.kind === "run" && i.status !== "running" ? Math.max(i.seq, last.get(i.id) ?? i.pos) + 0.5 : i.pos;
+  return [...items].sort((a, b) => at(a) - at(b));
+}
+function itemLines(i, base, send2, draft) {
+  const out = [];
+  const err = [];
+  const s = i.summary;
+  const ended = i.status !== "running";
+  switch (s.kind) {
+    case "message":
+      if (s.role === "agent") {
+        out.push(s.text);
+        break;
+      }
+      out.push(`> ${s.text}`);
+      if (s.steer?.state === "sent")
+        out.push(`  Sent to the running turn (${s.steer.turn}).`);
+      if (s.steer?.state === "taken")
+        out.push(`  ${STEER_TAKEN}`);
+      if (s.steer?.state === "queued")
+        out.push(`  ${steerQueuedLine(s.steer.why)}`);
+      if (s.steer?.state === "dropped")
+        out.push(`  ${STEER_DROPPED}`);
+      if (s.steer?.started)
+        out.push(`  It is running as turn ${s.steer.started}.`);
+      break;
+    case "route":
+      out.push(s.said);
+      break;
+    case "question":
+      out.push(`${s.question} (question ${s.index} of ${s.of})`);
+      for (const [n, choice] of s.choices.entries())
+        out.push(`  ${n + 1}. ${choice}`);
+      if (s.state === "open")
+        out.push(`Answer: ${send2} --answer 1 (a choice's number), or in your own words.`);
+      if (s.state === "answered" && s.answered_choice !== null)
+        out.push(`  Answered: ${s.answered_choice}.`);
+      break;
+    case "plan":
+      if (!ended)
+        break;
+      out.push(`Plan: ${s.title}${s.pitch ? `: ${s.pitch}` : ""}`);
+      if (draft)
+        out.push(`Build it: ${send2} --build "Build it"`);
+      break;
+    case "brief":
+      if (i.status !== "done")
+        break;
+      out.push(`Designing ${s.title ?? "your game"}${s.pitch ? `: ${s.pitch}` : ""}`);
+      if (s.style)
+        out.push(`  Style: ${s.style}`);
+      if (s.palette.length)
+        out.push(`  Palette: ${s.palette.join(", ")}`);
+      break;
+    case "run": {
+      const label = jobLabel(s.job);
+      if (!ended)
+        err.push(`${label} started${s.model ? ` (${s.model})` : ""}.`);
+      else if (i.status === "done")
+        err.push(`${label} done${s.summary ? `: ${s.summary}` : "."}`);
+      else
+        err.push(`${label} ${i.status}.`);
+      break;
+    }
+    case "tool":
+      if (!ended && !s.note)
+        break;
+      err.push(`  ${s.name}: ${s.note ?? s.summary ?? ""}`.trimEnd());
+      if (i.status === "failed")
+        err.push(`  ${s.name} failed${s.summary ? `: ${s.summary}` : "."}`);
+      break;
+    case "picture":
+      if (s.placeholder)
+        err.push(`  A placeholder stands in for ${s.picture_id}.`);
+      else if (s.media)
+        out.push(`Painted ${s.picture_id} (${s.width} by ${s.height})${s.redraw ? " again" : ""} ${mediaLink(base, s.media)}`);
+      break;
+    case "files":
+      if (s.changed.length)
+        err.push(`  changed: ${s.changed.map((c) => `${c.path} +${c.added} -${c.removed}`).join(", ")}${s.more > 0 ? `, and ${s.more} more` : ""}`);
+      break;
+    case "build":
+      if (!ended)
+        break;
+      if (s.ok)
+        err.push(`The build passed in ${(s.ms / 1000).toFixed(1)} s.`);
+      else
+        err.push("The build failed:", ...s.errors.map((e) => `  ${e}`));
+      break;
+    case "preview":
+      if (i.status === "running") {
+        if (s.rebuild)
+          out.push("Rebuilding the preview (no credits).");
+      } else if (i.status === "done") {
+        out.push(`${s.rebuild ? "The preview is rebuilt" : s.purpose === "playtest" ? "A playtest preview is ready" : "A preview is ready"}: velven create show prints its link.`);
+      } else if (i.status === "failed")
+        out.push(`No preview was made${s.refused ? `: ${s.refused}` : "."}`);
+      else
+        err.push("The preview's rebuild stopped: the next turn makes its own.");
+      break;
+    case "playtest":
+      if (!ended)
+        break;
+      err.push(`Playtest round ${s.round}: ${s.ok ? "every check passed" : plural(s.problems, "problem")}.`);
+      if (s.judge_summary)
+        err.push(`  ${s.judge_summary}`);
+      for (const shot of s.shots)
+        err.push(`  screenshot ${shot.label}: ${mediaLink(base, shot)}`);
+      if (s.clip)
+        out.push(`Clip: ${mediaLink(base, s.clip.media)}`);
+      break;
+    case "review":
+      if (!ended)
+        break;
+      err.push(`Review: ${s.ok ? "no problems" : plural(s.problems, "problem")}.${s.summary ? ` ${s.summary}` : ""}`);
+      break;
+    case "commit":
+      if (i.status === "done")
+        out.push(`Committed ${s.sha.slice(0, 7)}: ${s.message}`);
+      else if (ended)
+        out.push(`Not saved (${s.sha.slice(0, 7)}): ${s.message}`);
+      break;
+    case "restore":
+      out.push(restoreLine(s.version, s.commit, s.from_version));
+      break;
+  }
+  return { out, err };
+}
+function restoreLine(version2, commit, from) {
+  return `Went ${from !== null && version2 < from ? "back" : "forward"} to version ${version2} (commit ${commit.slice(0, 7)}).`;
+}
+function failureLine(summary) {
+  const failure = summary.failure;
+  if (!failure || failure.turn !== null && failure.turn !== summary.latest?.turn)
+    return null;
+  return `${failure.turn !== null ? `Turn ${failure.turn} failed: ` : ""}${FAILURE_SENTENCES[failure.class]}${failure.retryable ? " Try again." : ""}`;
+}
+var askedIn = (q) => Number(/^t(\d+)\./.exec(q.item)?.[1] ?? 0);
+async function keepQuestion(ctx, base, turn, project, asked) {
+  const kept = (await readCreateState(ctx, base)).question;
+  const same = kept !== undefined && kept.project === (asked?.project ?? project);
+  if (asked) {
+    if (!same || askedIn(kept) <= turn)
+      await saveCreateState(ctx, base, { question: asked });
+  } else if (same && askedIn(kept) < turn)
+    await saveCreateState(ctx, base, { question: undefined });
+}
+async function follow(ctx, api, turn, path, from, mode, project) {
+  const controller = new AbortController;
+  ctx.untilStopped().then(() => controller.abort());
+  const said = { held: null, engine: null, project, asked: false, next: [], base: api.base, question: null, work: null };
+  let final;
+  try {
+    final = await stream(api, path, { ...from !== undefined ? { start: { from } } : {}, signal: controller.signal, sleep: ctx.sleep }, (event2) => {
       if (mode === "events")
         ctx.out(JSON.stringify(event2));
       else if (mode === "text")
@@ -1093,6 +1789,7 @@ async function follow(ctx, api, turn, path, from, mode) {
   } finally {
     controller.abort();
     release(ctx, said);
+    await keepQuestion(ctx, api.base, turn, project, said.question);
   }
   if (final === null) {
     const message = `The turn goes on. Watch it: velven create watch ${turn}; stop it: velven create cancel ${turn}`;
@@ -1118,11 +1815,10 @@ async function follow(ctx, api, turn, path, from, mode) {
     }
     ctx.out(JSON.stringify({ ok: code === EXIT.ok, ...error, turn: view }));
   } else if (mode === "text") {
-    finish(ctx, turn, event);
+    finish(ctx, turn, event, said);
   }
   return code;
 }
-var plural2 = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
 function capital(text) {
   return text.charAt(0).toUpperCase() + text.slice(1);
 }
@@ -1134,8 +1830,8 @@ function lasting(at, expires) {
   if (!Number.isFinite(minutes) || minutes <= 0)
     return "";
   if (minutes < 90)
-    return plural2(minutes, "minute");
-  return plural2(Math.round(minutes / 60), "hour");
+    return plural(minutes, "minute");
+  return plural(Math.round(minutes / 60), "hour");
 }
 function jobDone(ctx, label, figures, summary) {
   if (figures)
@@ -1165,12 +1861,57 @@ function render(ctx, event, said) {
   release(ctx, said);
   switch (event.type) {
     case "turn.started":
-      ctx.err(`Started: ${event.effort}${event.plan ? ", plan mode" : ""}, ${plural2(event.credits_held, "credit")} held.`);
+      if (event.routed)
+        ctx.err(`Started: Velven is choosing the work, ${plural(event.credits_held, "credit")} held.`);
+      else
+        ctx.err(`Started: ${event.effort}${event.plan ? ", plan mode" : ""}, ${plural(event.credits_held, "credit")} held.`);
+      return;
+    case "route":
+      said.work = event.work;
+      ctx.out(event.said);
+      ctx.err(`  (${event.work}, ${event.effort}${event.plan ? ", plan mode" : ""}, ${plural(event.credits_held, "credit")} held: ${event.reason})`);
+      return;
+    case "ask": {
+      ctx.out(`${event.question} (question ${event.index} of ${event.of})`);
+      for (const [i, choice] of event.choices.entries())
+        ctx.out(`  ${i + 1}. ${choice}`);
+      const send2 = sendCommand(said);
+      if (event.item_id && said.project) {
+        said.question = { project: said.project, item: event.item_id, choices: event.choices };
+        ctx.out(`Answer: ${send2} --answer 1 (a choice's number), or in your own words.`);
+      } else
+        ctx.out(`Answer: ${send2} "${event.choices[0]}", or in your own words.`);
+      if (event.picture || event.topic === "style")
+        ctx.out(`Or show the look: ${send2} --ref <file> "like this".`);
+      ctx.out(`Just build it: ${send2} --build "Just build it"`);
+      said.asked = true;
       return;
+    }
+    case "plan":
+      if (!event.done)
+        return;
+      for (const line of planCard(event.plan))
+        ctx.out(line);
+      if (said.work === "draft")
+        ctx.out(`Build it: ${sendCommand(said)} --build "Build it"`);
+      return;
+    case "brief": {
+      if (!event.done)
+        return;
+      if (event.title || event.pitch)
+        ctx.out(`Designing ${event.title ?? "your game"}${event.pitch ? `: ${event.pitch}` : ""}`);
+      if (event.style)
+        ctx.out(`  Style: ${event.style}`);
+      if (event.palette.length)
+        ctx.out(`  Palette: ${event.palette.join(", ")}`);
+      return;
+    }
     case "turn.queued":
       ctx.err("Still waiting for room on Velven.");
       return;
     case "phase":
+      if (event.progress)
+        ctx.out(event.progress.label);
       ctx.err(`${capital(event.phase)}${event.detail ? `: ${event.detail}` : ""}`);
       return;
     case "job": {
@@ -1192,6 +1933,9 @@ function render(ctx, event, said) {
     }
     case "tool":
       ctx.err(`  ${event.name}: ${event.summary}${typeof event.ms === "number" ? ` (${duration(event.ms)})` : ""}`);
+      if (event.picture?.media) {
+        ctx.out(`Painted ${event.picture.id} (${event.picture.width} by ${event.picture.height}) ${dim(ctx, mediaLink(said.base, event.picture.media))}`);
+      }
       return;
     case "text":
       ctx.out(event.text);
@@ -1210,10 +1954,10 @@ function render(ctx, event, said) {
         ctx.err("The live link is gone.");
       return;
     case "shot":
-      ctx.err(`  screenshot ${event.label}: ${event.url}`);
+      ctx.err(`  screenshot ${event.label}: ${mediaLink(said.base, event.media)}`);
       return;
     case "clip":
-      ctx.out(`Clip: ${event.url}`);
+      ctx.out(`Clip: ${mediaLink(said.base, event.media)}`);
       return;
     case "build":
       if (event.ok)
@@ -1225,10 +1969,10 @@ function render(ctx, event, said) {
       }
       return;
     case "playtest":
-      ctx.err(`Playtest round ${event.round}: ${event.ok ? "every check passed" : plural2(event.problems, "check problem")}.`);
+      ctx.err(`Playtest round ${event.round}: ${event.ok ? "every check passed" : plural(event.problems, "check problem")}.`);
       return;
     case "review":
-      ctx.err(`Review: ${event.ok ? "no problems" : plural2(event.problems, "problem")}.`);
+      ctx.err(`Review: ${event.ok ? "no problems" : plural(event.problems, "problem")}.`);
       return;
     case "commit":
       ctx.out(`Committed ${event.sha.slice(0, 7)}: ${event.message}`);
@@ -1243,44 +1987,138 @@ function render(ctx, event, said) {
       return;
     }
     case "cost":
-      ctx.err(`${event.credits_used} of ${plural2(event.credits_held, "credit")} used so far.`);
+      ctx.err(`${event.credits_used} of ${plural(event.credits_held, "credit")} used so far.`);
+      return;
+    case "next":
+      said.next = event.choices;
+      return;
+    case "steer":
+      ctx.out(event.state === "taken" ? "A message you sent while it ran was taken into account." : event.why === "paused" ? "A message you sent while it ran could not be taken this turn; it is queued, but the queue is paused. Start it: velven create resume" : "A message you sent while it ran could not be taken this turn; it is queued as the next message.");
       return;
     default:
       return;
   }
 }
-function finish(ctx, turn, event) {
+function finish(ctx, turn, event, said) {
   if (event.type === "error") {
     const tail = event.code === "turn_stopped" || event.code === "not_found" ? " Check it again later: velven create show" : ` The turn may go on. Watch it: velven create watch ${turn}; check it: velven create show`;
     ctx.err(`${event.message || "The turn's stream answered with an error."}${tail}`);
     return;
   }
-  if (event.reply)
-    ctx.out(event.reply);
+  const reply = event.reply && said.asked ? event.reply.split(`
+
+`).slice(1).join(`
+
+`) : event.reply;
+  if (reply)
+    ctx.out(reply);
+  if (said.next.length) {
+    ctx.out("Where it could go next:");
+    for (const [i, choice] of said.next.entries())
+      ctx.out(`  ${i + 1}. ${choice}`);
+    ctx.out(`Send one: velven create send${said.project ? ` --project ${said.project}` : ""} "${said.next[0]}"`);
+  }
   if (event.preview)
     ctx.out(`Play it: ${event.preview.url}`);
-  const back = event.refunded > 0 ? `; ${plural2(event.refunded, "credit")} came back` : "";
+  const back = event.refunded > 0 ? `; ${plural(event.refunded, "credit")} came back` : "";
   if (event.status === "done") {
-    ctx.out(`Turn ${turn} is done: ${plural2(event.credits_charged, "credit")} used${back}.`);
+    ctx.out(`Turn ${turn} is done: ${plural(event.credits_charged, "credit")} used${back}.`);
     if (event.stop_reason === "cap")
       ctx.out("It stopped at its credit cap. What it finished is saved: send another message to go on.");
     if (event.stop_reason === "time")
       ctx.out("It stopped at its time limit. What it finished is saved: send another message to go on.");
-    return;
+  } else if (event.status === "cancelled") {
+    ctx.err(`Turn ${turn} was cancelled: ${plural(event.credits_charged, "credit")} used${back}. What it finished is saved.`);
+  } else {
+    ctx.err(`Turn ${turn} failed: ${event.error ?? (event.failure ? FAILURE_SENTENCES[event.failure.class] : "Velven could not finish it.")} A failed turn costs nothing.`);
   }
-  if (event.status === "cancelled") {
-    ctx.err(`Turn ${turn} was cancelled: ${plural2(event.credits_charged, "credit")} used${back}. What it finished is saved.`);
-    return;
+  if (reply?.includes(BUILD_AGAIN))
+    ctx.out(`Try again: ${sendCommand(said)} --build "Build it"`);
+  else if (event.status === "failed" && event.failure?.retryable)
+    ctx.out(`Try again: ${sendCommand(said)} with the same words.`);
+  if (event.next_turn) {
+    const elsewhere = event.next_project && said.project && event.next_project !== said.project ? ` on project ${event.next_project}` : "";
+    ctx.out(`Your next message${elsewhere} is running: velven create watch ${event.next_turn}`);
   }
-  ctx.err(`Turn ${turn} failed: ${event.error ?? "Velven could not finish it."} A failed turn costs nothing.`);
+}
+var BUILD_AGAIN = "Press Build it to try again.";
+function sendCommand(said) {
+  return `velven create send${said.project ? ` --project ${said.project}` : ""}`;
+}
+function mediaLink(base, media) {
+  return `${base}${ROOT}/media/${media.id}`;
+}
+function dim(ctx, text) {
+  return ctx.interactive && !ctx.env.NO_COLOR ? `\x1B[2m${text}\x1B[22m` : text;
+}
+function planCard(plan) {
+  const lines = [];
+  if (plan.title)
+    lines.push(plan.title);
+  if (plan.pitch)
+    lines.push(plan.pitch);
+  if (plan.dimension)
+    lines.push(`${plan.dimension === "3d" ? "3D" : "2D"}${plan.camera ? `, ${plan.camera}` : ""}`);
+  if (plan.play?.length) {
+    lines.push("How it plays:");
+    for (const [i, beat] of plan.play.entries())
+      lines.push(`  ${i + 1}. ${beat}`);
+  }
+  if (plan.look)
+    lines.push(`Look: ${plan.look}`);
+  if (plan.palette?.length)
+    lines.push(`Palette: ${plan.palette.join(", ")}`);
+  if (plan.contents?.length) {
+    lines.push("What is in it:");
+    for (const thing of plan.contents)
+      lines.push(`  - ${thing}`);
+  }
+  if (plan.ending)
+    lines.push(`How it ends: ${plan.ending}`);
+  if (plan.score !== undefined)
+    lines.push(plan.score ? "It keeps a score." : "No score.");
+  return lines;
+}
+function queuedLine(queued, why) {
+  const ahead = queued.position !== null && queued.position > 1 ? plural(queued.position - 1, "message") : null;
+  const list = "velven create queue lists what waits.";
+  switch (why) {
+    case "paused":
+      return `Queued, but the queue is paused after a failed or stopped turn. Start it: velven create resume`;
+    case "wrapping_up":
+      return `Queued: the turn is finishing, so it runs next${ahead ? ` after ${ahead} ahead of it` : ""}. ${list}`;
+    case "limit":
+      return `Queued: five messages already joined this turn, so it runs next${ahead ? ` after ${ahead} ahead of it` : ""}. ${list}`;
+    case "phase":
+      return `Queued: the turn is not writing code now, so it runs after the turn${ahead ? ` and ${ahead} ahead of it` : ""}. ${list}`;
+    case "steer_off":
+      return `Queued: it runs after the turn that is running${ahead ? ` and ${ahead} ahead of it` : ""}. ${list}`;
+    default:
+      return `Queued: it runs after ${ahead ? `${ahead} ahead of it` : "the message ahead of it"}. ${list}`;
+  }
+}
+function pausedLine(paused) {
+  return `Paused after a ${paused.why === "failed" ? "failed" : "stopped"} turn. Resume: velven create resume`;
 }
 async function cancel(ctx, api, arg) {
   const turn = await turnId(ctx, api.base, arg, "cancel");
   const answer = await call(api, "POST", `${ROOT}/turns/${seg(turn)}/cancel`, {});
-  if (answer.status === "cancelled")
+  if (answer.status === "cancelled" && !answer.started)
     ctx.out(`Turn ${turn} is cancelled before it started. Its credits are back.`);
+  else if (answer.status === "cancelled")
+    ctx.out(`Turn ${turn} is stopped: ${plural(answer.credits_charged, "credit")} used. What it finished is saved.`);
   else
     ctx.out(`Turn ${turn} is stopping. What it finished is saved and unused credits come back. Follow it: velven create watch ${turn}`);
+  try {
+    const { turn: view } = await call(api, "GET", `${ROOT}/turns/${seg(turn)}`);
+    const queue = await call(api, "GET", `${ROOT}/projects/${seg(view.project)}/queue`);
+    if (queue.paused || answer.status === "cancelling" && queue.queued.some((q) => q.state === "waiting")) {
+      ctx.out(`${answer.status === "cancelled" ? "Stopped" : "Stopping"}. The messages waiting on this project are paused: velven create resume starts them.`);
+    }
+  } catch (e) {
+    if (!(e instanceof CliError))
+      throw e;
+  }
   return EXIT.ok;
 }
 async function list(ctx, api, json) {
@@ -1312,11 +2150,14 @@ async function show(ctx, api, arg, json) {
   }
   ctx.out(`${project.title ?? "Untitled"} (${project.id})`);
   ctx.out(`Packs: ${packs(project)}`);
-  ctx.out(`Next turn: ${project.effort}, plan mode ${project.plan ? "on" : "off"}`);
-  ctx.out(`Latest commit: ${project.head ? project.head.slice(0, 7) : "none yet"}`);
+  if (project.turn && !project.turn.routed)
+    ctx.out(`Next turn: ${project.effort}, plan mode ${project.plan ? "on" : "off"}`);
+  const summary = project.summary;
+  const version2 = summary?.head?.version;
+  ctx.out(`Latest commit: ${project.head ? `${project.head.slice(0, 7)}${version2 !== null && version2 !== undefined ? ` (version ${version2})` : ""}` : "none yet"}`);
   const t = project.turn;
   if (t) {
-    const charged = t.credits.charged !== null ? `, ${plural2(t.credits.charged, "credit")} used` : `, ${plural2(t.credits.held, "credit")} held`;
+    const charged = t.credits.charged !== null ? `, ${plural(t.credits.charged, "credit")} used` : `, ${plural(t.credits.held, "credit")} held`;
     const stop = t.stop_reason === "cap" ? ", stopped at its credit cap" : t.stop_reason === "time" ? ", stopped at its time limit" : "";
     ctx.out(`Newest turn: ${t.id}, ${t.status}${t.phase && t.status === "running" ? ` (${t.phase})` : ""}${charged}${stop}`);
     if (t.error)
@@ -1324,12 +2165,32 @@ async function show(ctx, api, arg, json) {
   } else {
     ctx.out("Newest turn: none yet");
   }
+  if (summary)
+    for (const line of summaryLines(summary))
+      ctx.out(line);
   if (project.preview?.url)
     ctx.out(`Play it: ${project.preview.url}${project.preview.expires_at ? ` (the preview lasts until ${when(project.preview.expires_at)})` : ""}`);
   else
     ctx.out("Preview: none yet");
   return EXIT.ok;
 }
+function summaryLines(summary) {
+  const lines = [];
+  if (summary.open_turn)
+    lines.push(`Running: ${summary.open_turn.phase ?? "starting"} (turn ${summary.open_turn.id})`);
+  if (summary.rebuilding) {
+    const version2 = summary.head?.version;
+    lines.push(`A preview of ${version2 !== null && version2 !== undefined ? `version ${version2}` : "the current version"} is being rebuilt.`);
+  }
+  if (summary.queue.paused)
+    lines.push(`${plural(summary.queue.waiting, "message")} waiting. ${pausedLine(summary.queue.paused)}`);
+  else if (summary.queue.waiting > 0)
+    lines.push(`${plural(summary.queue.waiting, "message")} waiting.`);
+  const failure = failureLine(summary);
+  if (failure)
+    lines.push(failure);
+  return lines;
+}
 async function showTimeline(ctx, api, arg, turnFlag, all, json) {
   let id;
   if (turnFlag !== undefined) {
@@ -1346,12 +2207,11 @@ async function showTimeline(ctx, api, arg, turnFlag, all, json) {
     id = view.turn.id;
   }
   const { turn } = await call(api, "GET", `${ROOT}/turns/${seg(id)}?timeline=1`);
-  const timeline = turn.timeline ?? { started_at: turn.started_at, spans: [] };
   if (json) {
-    ctx.out(JSON.stringify({ ok: true, turn: turn.id, timeline }));
+    ctx.out(JSON.stringify({ ok: true, turn: turn.id, timeline: turn.timeline }));
     return EXIT.ok;
   }
-  for (const line of renderTimeline(turn, timeline.spans, { all }))
+  for (const line of renderTimeline(turn, turn.timeline.spans, { all }))
     ctx.out(line);
   return EXIT.ok;
 }
@@ -1379,8 +2239,249 @@ async function stats(ctx, api, daysFlag, origin, json) {
     ctx.out(JSON.stringify({ ok: true, ...answer }));
     return EXIT.ok;
   }
-  for (const line of renderStats(answer.stats, { days, origin, microsPerCredit: answer.micros_per_credit ?? null }))
+  for (const line of renderStats(answer.stats, { days, origin, microsPerCredit: answer.micros_per_credit }))
+    ctx.out(line);
+  return EXIT.ok;
+}
+async function referencePictures(ctx, api, args, projectFlag, json) {
+  const [action, id, ...rest] = args;
+  if (action === "rm") {
+    if (id === undefined || !REF_ID.test(id) || rest.length) {
+      throw new CliError("Name one picture to remove by its id, like velven create refs rm ref-3.", EXIT.usage, "usage");
+    }
+    const project2 = await currentProject(ctx, api.base, projectFlag);
+    await call(api, "DELETE", `${ROOT}/projects/${seg(project2)}/references/${seg(id)}`);
+    if (json)
+      ctx.out(JSON.stringify({ ok: true, deleted: id }));
+    else
+      ctx.out(`Removed ${id}. The messages that carried it keep its number, shown as removed.`);
+    return EXIT.ok;
+  }
+  if (action !== undefined) {
+    throw new CliError(`Unknown command "create refs ${action}". List the pictures with velven create refs, remove one with velven create refs rm ref-3.`, EXIT.usage, "usage");
+  }
+  const project = await currentProject(ctx, api.base, projectFlag);
+  const { references } = await call(api, "GET", `${ROOT}/projects/${seg(project)}/references`);
+  if (json) {
+    ctx.out(JSON.stringify({ ok: true, references }));
+    return EXIT.ok;
+  }
+  if (!references.length) {
+    ctx.out('No reference pictures yet. Attach one: velven create send --ref <picture> "like this".');
+    return EXIT.ok;
+  }
+  for (const r of references) {
+    const carried = r.messages ? `on ${plural(r.messages, "message")}` : "not sent yet";
+    ctx.out(`${r.id.padEnd(7)}  ${when(r.created_at).padEnd(20)}  ${`${r.width} by ${r.height}`.padEnd(12)}  ${carried}`);
+  }
+  ctx.out(`${references.length} of ${REFS_PER_PROJECT} kept. A picture no message carried goes a day after it was last uploaded.`);
+  return EXIT.ok;
+}
+async function usage(ctx, api, project, before, json) {
+  if (before !== undefined && (!/^\d+$/.test(before) || Number(before) === 0))
+    throw new CliError(`--before is a turn number, like 12, not "${before}".`, EXIT.usage, "usage");
+  const query = new URLSearchParams;
+  if (project)
+    query.set("project", project);
+  if (before)
+    query.set("before", before);
+  const search = query.toString();
+  const answer = await call(api, "GET", `${ROOT}/usage${search ? `?${search}` : ""}`);
+  if (json) {
+    ctx.out(JSON.stringify({ ok: true, ...answer }));
+    return EXIT.ok;
+  }
+  if (!answer.turns.length) {
+    ctx.out(before ? "No earlier turns." : "No turns yet.");
+    return EXIT.ok;
+  }
+  for (const t of answer.turns) {
+    const used = t.credits.charged !== null ? `${plural(t.credits.charged, "credit")} used` : `${plural(t.credits.held, "credit")} held`;
+    const kind = t.work ?? `${t.effort}${t.plan ? " plan" : ""}`;
+    ctx.out(`turn ${String(t.turn).padEnd(6)}  ${when(t.created_at).padEnd(20)}  ${(t.project.title ?? "Untitled").padEnd(24)}  ${kind.padEnd(10)}  ${t.status.padEnd(9)}  ${used}`.trimEnd());
+  }
+  if (answer.next !== null)
+    ctx.out(`More: velven create usage${project ? ` --project ${project}` : ""} --before ${answer.next}`);
+  return EXIT.ok;
+}
+async function showPlan(ctx, api, args, projectFlag, json) {
+  if (args.length)
+    throw new CliError("velven create plan takes no words: name another project with --project <id>.", EXIT.usage, "usage");
+  const id = await currentProject(ctx, api.base, projectFlag);
+  const { project } = await call(api, "GET", `${ROOT}/projects/${seg(id)}`);
+  const plan = project.game_plan ?? null;
+  if (json) {
+    ctx.out(JSON.stringify({ ok: true, plan }));
+    return EXIT.ok;
+  }
+  if (!plan) {
+    ctx.out('This project has no plan yet. Send your idea and Velven sketches one with you: velven create send "a cozy farming game".');
+    return EXIT.ok;
+  }
+  for (const line of planCard(plan))
     ctx.out(line);
+  if (!project.head)
+    ctx.out(`Build it: velven create send${projectFlag ? ` --project ${id}` : ""} --build "Build it"`);
+  return EXIT.ok;
+}
+function queuedId(id, usage2) {
+  if (id === undefined || !/^\d+$/.test(id) || Number(id) === 0)
+    throw new CliError(usage2, EXIT.usage, "usage");
+  return Number(id);
+}
+async function queue(ctx, api, args, projectFlag, build, json) {
+  const [action, id, ...rest] = args;
+  if (build && action !== "edit")
+    throw new CliError("--build goes with velven create queue edit.", EXIT.usage, "usage");
+  if (action === "rm") {
+    const n = queuedId(rest.length ? undefined : id, "Name one waiting message by its number, like velven create queue rm 12.");
+    const project2 = await currentProject(ctx, api.base, projectFlag);
+    await call(api, "DELETE", `${ROOT}/projects/${seg(project2)}/queue/${seg(n)}`);
+    if (json)
+      ctx.out(JSON.stringify({ ok: true, removed: n }));
+    else
+      ctx.out(`Removed message ${n}: it will not run.`);
+    return EXIT.ok;
+  }
+  if (action === "edit") {
+    const n = queuedId(id, 'Name the waiting message and its new words, like velven create queue edit 12 "add a pond".');
+    const text = rest.join(" ").trim();
+    if (!text && !build)
+      throw new CliError(`Give the message's new words, like velven create queue edit 12 "add a pond", or --build.`, EXIT.usage, "usage");
+    const project2 = await currentProject(ctx, api.base, projectFlag);
+    const body = {};
+    if (text)
+      body.text = text;
+    if (build)
+      body.intent = "build";
+    const { queued: queued2 } = await call(api, "PATCH", `${ROOT}/projects/${seg(project2)}/queue/${seg(n)}`, body);
+    if (json)
+      ctx.out(JSON.stringify({ ok: true, queued: queued2 }));
+    else
+      ctx.out(`Changed message ${n}${queued2.position !== null ? `, ${ordinal(queued2.position)} in line` : ""}.`);
+    return EXIT.ok;
+  }
+  if (action === "move") {
+    const n = queuedId(id, "Name the waiting message and its new place, like velven create queue move 12 1.");
+    const [place, ...extra] = rest;
+    if (place === undefined || !/^\d+$/.test(place) || Number(place) === 0 || extra.length) {
+      throw new CliError(`The place is a number, 1 for the next to run, like velven create queue move ${n} 1.`, EXIT.usage, "usage");
+    }
+    const project2 = await currentProject(ctx, api.base, projectFlag);
+    const view = await moveQueued(api, project2, n, Number(place));
+    const moved = view.queued.find((q) => q.id === n);
+    if (json)
+      ctx.out(JSON.stringify({ ok: true, ...view }));
+    else
+      ctx.out(`Moved message ${n}${moved?.position ? ` to ${ordinal(moved.position)} in line` : ""}.`);
+    return EXIT.ok;
+  }
+  if (action !== undefined) {
+    throw new CliError(`Unknown command "create queue ${action}". List what waits with velven create queue; change one with queue edit, move one with queue move, remove one with queue rm.`, EXIT.usage, "usage");
+  }
+  const project = await currentProject(ctx, api.base, projectFlag);
+  const { queued, paused } = await call(api, "GET", `${ROOT}/projects/${seg(project)}/queue`);
+  if (json) {
+    ctx.out(JSON.stringify({ ok: true, queued, paused }));
+    return EXIT.ok;
+  }
+  if (!queued.length) {
+    ctx.out("Nothing is waiting on this project.");
+    return EXIT.ok;
+  }
+  if (paused)
+    ctx.out(pausedLine(paused));
+  for (const q of queued) {
+    const at = q.position !== null ? `${q.position}.` : q.state === "refused" ? "x" : "-";
+    const words = q.text.length > 60 ? `${q.text.slice(0, 59)}…` : q.text;
+    ctx.out(`${at.padStart(3)} ${String(q.id).padEnd(6)}  ${when(q.created_at).padEnd(20)}  ${q.intent === "build" ? "[build] " : ""}${words}`);
+    if (q.from_steer)
+      ctx.out("      (from a message sent while a turn ran)");
+    if (q.state === "refused" && q.refused)
+      ctx.out(`      Not sent: ${q.refused}`);
+  }
+  if (queued.some((q) => q.state === "waiting")) {
+    ctx.out(`They run in this order ${paused ? "once you resume" : "when the running turn ends"}. Change one: velven create queue edit <number> <text>; move one: queue move <number> <place>; remove one: queue rm <number>`);
+  }
+  return EXIT.ok;
+}
+async function moveQueued(api, project, id, place) {
+  for (let attempt = 0;; attempt++) {
+    const { queued } = await call(api, "GET", `${ROOT}/projects/${seg(project)}/queue`);
+    const waiting = queued.filter((q) => q.state === "waiting").sort((a, b) => (a.position ?? 0) - (b.position ?? 0));
+    if (!waiting.some((q) => q.id === id))
+      throw new CliError(`Message ${id} is not waiting on this project: velven create queue lists what waits.`, EXIT.refused, "not_found");
+    const order = waiting.map((q) => q.id).filter((q) => q !== id);
+    order.splice(Math.min(place, waiting.length) - 1, 0, id);
+    try {
+      return await call(api, "PUT", `${ROOT}/projects/${seg(project)}/queue/order`, { order });
+    } catch (e) {
+      if (!(e instanceof CliError) || e.code !== "queue_mismatch" || attempt > 0)
+        throw e;
+    }
+  }
+}
+function ordinal(n) {
+  const tens = n % 100;
+  const suffix = tens >= 11 && tens <= 13 ? "th" : ["th", "st", "nd", "rd"][n % 10] ?? "th";
+  return `${n}${suffix}`;
+}
+async function resume(ctx, api, args, projectFlag, json) {
+  if (args.length)
+    throw new CliError("velven create resume takes no words: name another project with --project <id>.", EXIT.usage, "usage");
+  const project = await currentProject(ctx, api.base, projectFlag);
+  const answer = await call(api, "POST", `${ROOT}/projects/${seg(project)}/queue/resume`, {});
+  if (answer.started !== null)
+    await saveCreateState(ctx, api.base, { project, turn: answer.started });
+  if (json) {
+    ctx.out(JSON.stringify({ ok: true, ...answer }));
+    return EXIT.ok;
+  }
+  const { queued } = await call(api, "GET", `${ROOT}/projects/${seg(project)}/queue`);
+  const waiting = queued.filter((q) => q.state === "waiting").length + (answer.started !== null ? 1 : 0);
+  const first = answer.started !== null ? ` The first starts now: velven create watch ${answer.started}` : waiting > 0 ? " They start when the running turn ends." : "";
+  ctx.out(answer.resumed ? `Resumed: ${waiting} waiting.${first}` : `Nothing was paused.${first}`);
+  return EXIT.ok;
+}
+async function versions(ctx, api, args, projectFlag, json) {
+  if (args.length)
+    throw new CliError("velven create versions takes no words: name another project with --project <id>.", EXIT.usage, "usage");
+  const project = await currentProject(ctx, api.base, projectFlag);
+  const { versions: rows } = await call(api, "GET", `${ROOT}/projects/${seg(project)}/versions`);
+  if (json) {
+    ctx.out(JSON.stringify({ ok: true, versions: rows }));
+    return EXIT.ok;
+  }
+  if (!rows.length) {
+    ctx.out('No versions yet: a turn that saves the game makes one. velven create send "a fox that hops over logs"');
+    return EXIT.ok;
+  }
+  for (const v of rows) {
+    const label = v.version === 0 ? "0 template" : String(v.version);
+    const words = v.version === 0 ? "" : v.message.length > 60 ? `${v.message.slice(0, 59)}…` : v.message;
+    const marks = [v.head ? "head" : null, v.rolled_back ? "rolled back" : null, v.preview?.status === "ready" ? "preview" : null].filter((m) => m !== null);
+    ctx.out(`${label.padStart(10)}  ${v.commit.slice(0, 7)}  ${words.padEnd(60)}  ${marks.join(", ")}`.trimEnd());
+  }
+  ctx.out("Go back or forward to one: velven create restore <version>");
+  return EXIT.ok;
+}
+async function restore(ctx, api, args, projectFlag, json) {
+  const [arg, ...rest] = args;
+  if (arg === undefined || !/^\d+$/.test(arg) || rest.length) {
+    throw new CliError("Name the version to go to by its number, like velven create restore 3 (velven create versions lists them).", EXIT.usage, "usage");
+  }
+  const project = await currentProject(ctx, api.base, projectFlag);
+  const answer = await call(api, "POST", `${ROOT}/projects/${seg(project)}/restore`, { version: Number(arg) });
+  if (json) {
+    ctx.out(JSON.stringify({ ok: true, ...answer }));
+    return EXIT.ok;
+  }
+  if ("unchanged" in answer)
+    ctx.out(`Already on version ${arg}.`);
+  else
+    ctx.out(restoreLine(answer.restored.version, answer.restored.commit, answer.restored.from_version));
+  if (answer.rebuild)
+    ctx.out("Its preview expired; Velven is rebuilding it (no credits). velven create show prints it when ready.");
   return EXIT.ok;
 }
 async function credits(ctx, api, json) {
@@ -1389,7 +2490,7 @@ async function credits(ctx, api, json) {
     ctx.out(JSON.stringify({ ok: true, credits: view }));
     return EXIT.ok;
   }
-  ctx.out(`${plural2(view.available, "credit")} available: ${view.daily_left} left of today's allowance, ${view.balance} in your balance, ${view.held} held by open turns.`);
+  ctx.out(`${plural(view.available, "credit")} available: ${view.daily_left} left of today's allowance, ${view.balance} in your balance, ${view.held} held by open turns.`);
   for (const row of view.ledger.slice(0, 10)) {
     const amount = row.amount > 0 ? `+${row.amount}` : String(row.amount);
     ctx.out(`  ${when(row.created_at).padEnd(20)}  ${amount.padStart(6)}  ${row.kind}${row.turn_id !== null ? ` (turn ${row.turn_id})` : ""}`);
@@ -1400,12 +2501,6 @@ function packs(project) {
   const engine = `${project.engine.id} ${project.engine.version}`;
   return project.genre ? `${engine}, ${project.genre.id} ${project.genre.version}` : engine;
 }
-function when(iso) {
-  if (!iso)
-    return "";
-  const d = new Date(iso);
-  return Number.isNaN(d.getTime()) ? iso : d.toISOString().slice(0, 16).replace("T", " ") + " UTC";
-}
 async function currentProject(ctx, base, given) {
   if (given)
     return given;
@@ -1428,9 +2523,9 @@ async function turnId(ctx, base, arg, verb) {
 
 // src/dev.ts
 import { createReadStream as createReadStream2 } from "node:fs";
-import { open as open2, readdir as readdir3, readFile as readFile5, realpath as realpath2, stat as stat2 } from "node:fs/promises";
+import { readdir as readdir3, readFile as readFile6, realpath as realpath2, stat as stat2 } from "node:fs/promises";
 import { createServer } from "node:http";
-import { extname, join as join5, relative as relative2, resolve, sep } from "node:path";
+import { extname, join as join5, relative as relative2, resolve as resolve2, sep } from "node:path";
 import { createBrotliDecompress, createGunzip } from "node:zlib";
 
 // ../scan-rules/src/each-limit.ts
@@ -1753,7 +2848,7 @@ function refusalSentence(findings) {
 // src/files.ts
 import { createHash } from "node:crypto";
 import { createReadStream } from "node:fs";
-import { open, readdir as readdir2, readFile as readFile4, realpath, stat } from "node:fs/promises";
+import { open, readdir as readdir2, readFile as readFile5, realpath, stat } from "node:fs/promises";
 import { join as join4, relative } from "node:path";
 
 // src/ignore.ts
@@ -2058,7 +3153,7 @@ function mediaProblem(kind, path, size2, bytes, missing = "is not among the file
 }
 
 // src/project.ts
-import { readdir, readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
+import { readdir, readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
 import { join as join3, win32 } from "node:path";
 var SPACE_TYPES = ["game", "world", "tool", "wonder"];
 var DEVICES = ["desktop", "mobile", "vr"];
@@ -2078,7 +3173,7 @@ async function readProject(dir) {
   const path = join3(dir, names.includes(PROJECT_FILE) ? PROJECT_FILE : names.find(isProjectName) ?? PROJECT_FILE);
   let text;
   try {
-    text = await readFile3(path, "utf8");
+    text = await readFile4(path, "utf8");
   } catch {
     return { path, exists: false, data: {} };
   }
@@ -2243,7 +3338,7 @@ async function walk(root, skipped = () => {}) {
   const realRoot = await realpath(root);
   let rules = [];
   try {
-    rules = parseIgnore(await readFile4(join4(root, ".velvenignore"), "utf8"));
+    rules = parseIgnore(await readFile5(join4(root, ".velvenignore"), "utf8"));
   } catch {
     rules = [];
   }
@@ -2305,11 +3400,11 @@ function checkLimits(files, { maxBytes, maxFiles } = ACCOUNT_LIMITS) {
     throw new CliError(`The folder is ${formatSize(total)}; a version holds at most ${formatSize(maxBytes)}. The largest files: ${largest}.`, EXIT.refused, "too_large");
   }
 }
-async function readHead(abs) {
+async function readStart(abs, length) {
   const handle = await open(abs, "r");
   try {
-    const head = new Uint8Array(HEAD_BYTES);
-    const { bytesRead } = await handle.read(head, 0, HEAD_BYTES, 0);
+    const head = new Uint8Array(length);
+    const { bytesRead } = await handle.read(head, 0, length, 0);
     return head.subarray(0, bytesRead);
   } finally {
     await handle.close();
@@ -2319,7 +3414,7 @@ var SCAN_WINDOW = 8 * MB;
 var SCAN_OVERLAP = 64 * 1024;
 async function fileFindings(file) {
   if (!scansContent(file.path) || isCompressed(file.path))
-    return refuseFindings(file.path, await readHead(file.abs));
+    return refuseFindings(file.path, await readStart(file.abs, HEAD_BYTES));
   const encoding = extensionOf(file.path) === "wasm" ? "latin1" : "utf8";
   const handle = await open(file.abs, "r");
   try {
@@ -2364,7 +3459,7 @@ async function checkMedia(config, files) {
       continue;
     const path = mediaPath(raw);
     const file = files.find((f) => f.path === path);
-    const bytes = !file ? undefined : file.size <= MEDIA_RULES[kind].maxBytes ? new Uint8Array(await readFile4(file.abs)) : await readHead(file.abs);
+    const bytes = !file ? undefined : file.size <= MEDIA_RULES[kind].maxBytes ? new Uint8Array(await readFile5(file.abs)) : await readStart(file.abs, HEAD_BYTES);
     const problem = mediaProblem(kind, path, file?.size, bytes, "is not among the files this publish sends: check the path, and that .velvenignore does not leave it out");
     if (problem)
       problems.push(problem);
@@ -2376,9 +3471,9 @@ async function checkMedia(config, files) {
   return out;
 }
 function hashFile(abs) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const hash = createHash("sha256");
-    createReadStream(abs).on("data", (chunk) => hash.update(chunk)).on("error", reject).on("end", () => resolve(hash.digest("hex")));
+    createReadStream(abs).on("data", (chunk) => hash.update(chunk)).on("error", reject).on("end", () => resolve2(hash.digest("hex")));
   });
 }
 var HASH_CHUNK = 4 * MB;
@@ -2482,16 +3577,6 @@ function contentType(path, head) {
 }
 var WASM_HEAD_BYTES = 1024 * 1024;
 var ISOLATION_HEADER = { "Document-Isolation-Policy": "isolate-and-credentialless" };
-async function readStart(abs, length) {
-  const handle = await open2(abs, "r");
-  try {
-    const head = new Uint8Array(length);
-    const { bytesRead } = await handle.read(head, 0, length, 0);
-    return head.subarray(0, bytesRead);
-  } finally {
-    await handle.close();
-  }
-}
 function inflatedStart(abs, encoding) {
   return new Promise((resolveHead) => {
     const source = createReadStream2(abs);
@@ -2551,7 +3636,7 @@ function injectSdk(html, src) {
   return tag + html;
 }
 async function ignoreRules(root) {
-  return parseIgnore(await readFile5(join5(root, ".velvenignore"), "utf8").catch(() => ""));
+  return parseIgnore(await readFile6(join5(root, ".velvenignore"), "utf8").catch(() => ""));
 }
 async function namedAsOnDisk(base, rel) {
   const parts = rel.split("/").filter(Boolean);
@@ -2567,7 +3652,7 @@ async function statExact(base, rel) {
   return info && await namedAsOnDisk(base, rel) ? info : null;
 }
 async function startDevServer(root, options) {
-  const base = resolve(root);
+  const base = resolve2(root);
   const realBase = await realpath2(base);
   const server = createServer(async (req, res) => {
     const send2 = (status, body2, headers2 = {}) => {
@@ -2586,7 +3671,7 @@ async function startDevServer(root, options) {
     if (!parts.every(servableSegment))
       return send2(404, "Not found", { "content-type": "text/plain; charset=utf-8" });
     let rel = parts.join("/");
-    let file = resolve(base, rel);
+    let file = resolve2(base, rel);
     if (file !== base && !file.startsWith(base + sep))
       return send2(404, "Not found");
     let info = await statExact(base, rel);
@@ -2615,7 +3700,7 @@ async function startDevServer(root, options) {
     if (!real || !servableRelative(relative2(realBase, real))) {
       return send2(404, "Not found", { "content-type": "text/plain; charset=utf-8" });
     }
-    let body = await readFile5(file);
+    let body = await readFile6(file);
     const { type, encoding } = contentType(file, body);
     if (rel === options.entry && options.sdkSrc && !encoding)
       body = injectSdk(body.toString("utf8"), options.sdkSrc);
@@ -2638,7 +3723,7 @@ async function startDevServer(root, options) {
   };
 }
 async function dev(ctx, dirArg, portFlag) {
-  const dir = resolve(ctx.cwd, dirArg ?? ".");
+  const dir = resolve2(ctx.cwd, dirArg ?? ".");
   const info = await stat2(dir).catch(() => null);
   if (!info?.isDirectory())
     throw new CliError(`There is no folder at ${dir}.`, EXIT.usage, "usage");
@@ -2689,10 +3774,10 @@ async function dev(ctx, dirArg, portFlag) {
 
 // src/publish.ts
 import { stat as stat3 } from "node:fs/promises";
-import { resolve as resolve2 } from "node:path";
+import { resolve as resolve3 } from "node:path";
 
 // src/upload.ts
-import { open as open3 } from "node:fs/promises";
+import { open as open2 } from "node:fs/promises";
 var PARALLEL = 6;
 var ATTEMPTS = 4;
 function slicesOf(files, pieceBytes = PIECE_BYTES) {
@@ -2711,7 +3796,7 @@ function slicesOf(files, pieceBytes = PIECE_BYTES) {
   return slices;
 }
 async function readSlice({ file, offset, length }) {
-  const handle = await open3(file.abs, "r");
+  const handle = await open2(file.abs, "r");
   try {
     const body = Buffer.alloc(length);
     let read = 0;
@@ -2729,7 +3814,7 @@ async function readSlice({ file, offset, length }) {
 function retryable(status) {
   return status === null || status === 408 || status === 429 || status >= 500;
 }
-async function uploadMissing(ctx, base, targets, files, onProgress, pieceBytes = PIECE_BYTES) {
+async function uploadMissing(ctx, base, targets, files, pieceBytes = PIECE_BYTES) {
   const slices = slicesOf(files, pieceBytes);
   let failure = null;
   await eachLimit(targets, PARALLEL, async (target) => {
@@ -2760,10 +3845,8 @@ async function uploadMissing(ctx, base, targets, files, onProgress, pieceBytes =
         });
         status = response.status;
         detail = (await response.text()).slice(0, 200);
-        if (response.ok) {
-          onProgress(slice.length);
+        if (response.ok)
           return;
-        }
       } catch (e) {
         detail = e instanceof Error ? e.message : String(e);
       }
@@ -2778,7 +3861,6 @@ async function uploadMissing(ctx, base, targets, files, onProgress, pieceBytes =
 }
 
 // src/publish.ts
-var plural3 = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
 var DONE = ["live", "refused", "unjudged", "replaced", "preview"];
 var POLL_MS = 3000;
 var WAIT_LIMIT_MS = 20 * 60 * 1000;
@@ -2796,7 +3878,7 @@ function fileEntry(f) {
 }
 var hashesOf = (f) => f.pieces ?? (f.sha256 ? [f.sha256] : []);
 async function folderOf(ctx, arg) {
-  const dir = resolve2(ctx.cwd, arg ?? ".");
+  const dir = resolve3(ctx.cwd, arg ?? ".");
   const info = await stat3(dir).catch(() => null);
   if (!info)
     throw new CliError(`There is no folder at ${dir}.`, EXIT.usage, "usage");
@@ -2871,7 +3953,7 @@ async function publish(ctx, options) {
   if (guest)
     say(`By publishing you agree to Velven's Terms: ${terms}`);
   const total = files.reduce((sum, f) => sum + f.size, 0);
-  say(`Publishing ${plural3(files.length, "file")} (${formatSize(total)}) from ${dir}`);
+  say(`Publishing ${plural(files.length, "file")} (${formatSize(total)}) from ${dir}`);
   await hashAll(files);
   const body = {
     fields: listingFields(config),
@@ -2909,15 +3991,12 @@ async function publish(ctx, options) {
   const slices = slicesOf(files);
   const bytes = [...wanted].reduce((sum, sha) => sum + (slices.get(sha)?.length ?? 0), 0);
   if (sending) {
-    say(`Uploading ${sending} of ${plural3(distinct.length, "file")} (${formatSize(bytes)}); the rest are already on Velven.`);
+    say(`Uploading ${sending} of ${plural(distinct.length, "file")} (${formatSize(bytes)}); the rest are already on Velven.`);
   } else
     say("Every file is already on Velven; nothing to upload.");
-  await uploadMissing(ctx, base, created.uploads, files, () => {});
+  await uploadMissing(ctx, base, created.uploads, files);
   const versionPath = `/api/v1/hosting/versions/${seg(created.version.id)}`;
-  const finished = await call(api, "POST", `${versionPath}/finish`, {
-    preview: !options.prod,
-    ...guest && claim ? { claim } : {}
-  }).catch(claimedMeanwhile(base, slug, created.version.id, "finish"));
+  const finished = await call(api, "POST", `${versionPath}/finish`, { preview: !options.prod }).catch(claimedMeanwhile(base, slug, created.version.id, "finish"));
   const result = {
     ok: true,
     space: created.space,
@@ -3049,26 +4128,17 @@ async function signedIn(ctx) {
   return { base, creds: await requireToken(ctx, base) };
 }
 async function listVersions(api, slug) {
-  const answer = await call(api, "GET", `/api/v1/hosting/spaces/${seg(slug)}/versions`);
-  return Array.isArray(answer) ? answer : answer.versions;
-}
-function when2(iso) {
-  if (!iso)
-    return "";
-  const d = new Date(iso);
-  return Number.isNaN(d.getTime()) ? iso : d.toISOString().slice(0, 16).replace("T", " ") + " UTC";
+  return (await call(api, "GET", `/api/v1/hosting/spaces/${seg(slug)}/versions`)).versions;
 }
 function printVersions(ctx, rows) {
   for (const v of rows) {
-    const live = v.live || v.status === "live" ? "*" : " ";
-    const size2 = v.files !== undefined ? `${v.files} files${v.size !== undefined ? `, ${formatSize(v.size)}` : ""}` : "";
-    const cols = [`${live} ${String(v.number).padStart(3)}`, v.status.padEnd(9), when2(v.createdAt).padEnd(20), size2];
+    const cols = [`${v.live ? "*" : " "} ${String(v.number).padStart(3)}`, v.status.padEnd(9), when(v.createdAt).padEnd(20), `${v.files} files, ${formatSize(v.size)}`];
     ctx.out(cols.join("  ").trimEnd());
     if (v.reason && v.status !== "live")
       ctx.out(`        ${v.reason}`);
   }
 }
-async function versions(ctx, spaceFlag, json) {
+async function versions2(ctx, spaceFlag, json) {
   const api = await signedIn(ctx);
   const slug = await spaceSlug(ctx, spaceFlag);
   const rows = await listVersions(api, slug);
@@ -3109,7 +4179,7 @@ async function rollback(ctx, arg, spaceFlag) {
     number = versionNumber(await ctx.ask("Which version should go live? "));
   }
   const answer = await call(api, "POST", `/api/v1/hosting/spaces/${seg(slug)}/rollback`, { version: number });
-  ctx.out(`Version ${answer.version?.number ?? number} of ${slug} is live again${answer.pageUrl ? `: ${answer.pageUrl}` : "."}`);
+  ctx.out(`Version ${answer.version.number} of ${slug} is live again: ${answer.pageUrl}`);
   return EXIT.ok;
 }
 var RESET_CATEGORIES = ["scores", "saves", "achievements", "content", "rooms"];
@@ -3133,7 +4203,7 @@ async function reset(ctx, options) {
   if (player)
     body.player = player;
   const answer = await call(api, "POST", `/api/v1/hosting/spaces/${seg(slug)}/reset`, body);
-  const counts = answer.deleted ? Object.entries(answer.deleted).map(([k, n]) => `${n} ${k}`) : [];
+  const counts = Object.entries(answer.deleted).map(([k, n]) => `${n} ${k}`);
   ctx.out(`Deleted ${what}${counts.length ? ` (${counts.join(", ")})` : ""}.`);
   return EXIT.ok;
 }
@@ -3206,7 +4276,7 @@ var COMMANDS = {
   },
   versions: {
     flags: { json: "boolean", space: "string" },
-    run: (ctx, p) => versions(ctx, stringFlag(p, "space"), p.flags.json === true)
+    run: (ctx, p) => versions2(ctx, stringFlag(p, "space"), p.flags.json === true)
   },
   rollback: { flags: { space: "string" }, run: (ctx, p) => rollback(ctx, p.positionals[0], stringFlag(p, "space")) },
   reset: {