@velven/cli 0.4.0 → 0.5.1

package/dist/velven.js

@@ -23,14 +23,13 @@ class CliError extends Error {
   }
 }
 // package.json
-var version = "0.4.0";
+var version = "0.5.1";
 
 // 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,8 +74,9 @@ 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) {
-  return answerOf(api, path, body === undefined ? undefined : { type: "application/json", data: JSON.stringify(body) }, method);
+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;
@@ -91,30 +91,44 @@ async function putBytes(url, bytes, type, tooLarge) {
   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) {
+async function answerOf(api, path, body, method, retry) {
   const headers = requestHeaders(api, "application/json");
   if (body !== undefined)
     headers["content-type"] = body.type;
-  let response;
-  try {
-    response = await fetch(`${api.base}${path}`, { method, headers, body: body?.data });
-  } catch (e) {
-    throw new CliError(`Could not reach Velven at ${api.base} (${causeOf(e)}).`, EXIT.failed, "network");
-  }
-  const text = await response.text();
-  let parsed = null;
-  if (text) {
+  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));
@@ -132,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;
@@ -335,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 });
@@ -351,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")
@@ -488,12 +498,20 @@ 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");
 }
@@ -513,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) {
@@ -523,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 });
@@ -531,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 = ["routing", "workspace", "planning", "coding", "building", "playtesting", "reviewing", "fixing", "saving", "previewing", "replying", "settle"];
-var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
 function seconds(ms) {
   return `${(ms / 1000).toFixed(1)} s`;
 }
@@ -741,7 +771,7 @@ function renderTimeline(turn, spans, options = {}) {
     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 = [];
@@ -784,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)}`
@@ -815,9 +845,7 @@ function turnKind(turn, spans) {
   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";
@@ -850,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(", ")}`;
@@ -878,19 +902,19 @@ 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]}`);
+    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), ""]
     ];
@@ -937,7 +961,9 @@ Usage:
   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 waits its turn
+                                     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, instead of Velven's pick. The project keeps it
                                      for a later message that passes only a plan flag; a message with neither
@@ -947,15 +973,32 @@ Usage:
                                      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
@@ -967,8 +1010,10 @@ Usage:
   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 behind the running turn, in the order they run
+  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
@@ -978,14 +1023,14 @@ Usage:
       --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, plan, queue, refs, 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.
+  --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,
-  a picture refused, 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",
@@ -994,10 +1039,13 @@ var CREATE_FLAGS = {
   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",
@@ -1008,14 +1056,17 @@ var CREATE_FLAGS = {
 };
 var SUBCOMMANDS = {
   new: ["engine", "genre", "json"],
-  send: ["project", "effort", "plan", "no-plan", "build", "ref", "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", "json"],
+  queue: ["project", "build", "json"],
   credits: ["json"],
   usage: ["project", "before", "json"],
   stats: ["days", "origin", "json"]
@@ -1025,6 +1076,14 @@ 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) {
@@ -1048,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":
@@ -1069,7 +1134,7 @@ async function create(ctx, parsed) {
     case "plan":
       return showPlan(ctx, api, args, stringFlag(parsed, "project"), json);
     case "queue":
-      return queue(ctx, api, args, stringFlag(parsed, "project"), json);
+      return queue(ctx, api, args, stringFlag(parsed, "project"), parsed.flags.build === true, json);
     default:
       return credits(ctx, api, json);
   }
@@ -1097,8 +1162,9 @@ async function newProject(ctx, api, title, engine, genre, json) {
   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)) {
@@ -1112,8 +1178,22 @@ async function send(ctx, api, words, parsed, json) {
   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 pictures = await Promise.all(refs.map((ref) => REF_ID.test(ref) ? ref : readPicture(ctx, ref)));
   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)
@@ -1124,41 +1204,49 @@ async function send(ctx, api, words, parsed, json) {
     query.set("effort", effort);
   if (plan !== undefined)
     query.set("plan", String(plan));
-  query.set("queue", "true");
   const search = query.toString();
   const { estimate } = await call(api, "GET", `${ROOT}/projects/${seg(project)}/estimate${search ? `?${search}` : ""}`);
-  if (routed) {
-    const what = estimate.shaping === true ? "a question or a short plan" : estimate.first_build === true ? "a first build (its pictures are made before the first preview)" : "a small change";
+  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 === true ? `${estimate.effort} first build (its pictures are made before the first preview)` : `${estimate.effort} build turn`;
+    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, queue: true };
+  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;
   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 ${plural2(ids.length, "picture")}: ${ids.join(", ")}.`);
-  }
-  const sent = await call(api, "POST", `${ROOT}/projects/${seg(project)}/messages`, body);
+    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) {
@@ -1167,9 +1255,9 @@ async function send(ctx, api, words, parsed, json) {
       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 }));
+        ctx.out(JSON.stringify({ ok: true, queued, why: sent.why, ...sent.again ? { again: true } : {} }));
       else
-        say(queuedLine(queued));
+        say(`${already}${queuedLine(queued, sent.why)}`);
       return EXIT.ok;
     }
     turn = { id: queued.turn, ...queued.capped === true ? { queued: true } : {} };
@@ -1179,19 +1267,143 @@ async function send(ctx, api, words, parsed, json) {
   }
   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 = stream2?.startsWith("/") ? stream2 : `${ROOT}/turns/${seg(turn.id)}/stream`;
+  const path = stream2 ?? `${ROOT}/turns/${seg(turn.id)}/stream`;
   return follow(ctx, api, turn.id, path, undefined, json ? "final" : "text", project);
 }
+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`);
@@ -1222,21 +1434,27 @@ async function readPicture(ctx, file) {
   return { file, bytes, type: PICTURE_TYPES[ext] ?? "application/octet-stream" };
 }
 async function turnProject(ctx, api, turn) {
-  const { project: current } = await readCreateState(ctx, api.base);
   try {
     const { turn: view } = await call(api, "GET", `${ROOT}/turns/${seg(turn)}`);
-    return view.project ?? current ?? null;
+    return view.project;
   } catch {
-    return current ?? null;
+    return (await readCreateState(ctx, api.base)).project ?? null;
   }
 }
-async function watch(ctx, api, arg, fromFlag, json) {
+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;
@@ -1250,13 +1468,311 @@ async function watch(ctx, api, arg, fromFlag, json) {
   await saveCreateState(ctx, api.base, { turn });
   return code;
 }
+async function watchProject(ctx, api, project, after, untilIdle, json) {
+  const controller = new AbortController;
+  ctx.untilStopped().then(() => controller.abort());
+  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, `${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: [] };
+  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, signal: controller.signal, sleep: ctx.sleep }, (event2) => {
+    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")
@@ -1273,6 +1789,7 @@ async function follow(ctx, api, turn, path, from, mode, project) {
   } 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}`;
@@ -1302,7 +1819,6 @@ async function follow(ctx, api, turn, path, from, mode, project) {
   }
   return code;
 }
-var plural2 = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
 function capital(text) {
   return text.charAt(0).toUpperCase() + text.slice(1);
 }
@@ -1314,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)
@@ -1345,21 +1861,26 @@ function render(ctx, event, said) {
   release(ctx, said);
   switch (event.type) {
     case "turn.started":
-      if (event.routed === true)
-        ctx.err(`Started: Velven is choosing the work, ${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" : ""}, ${plural2(event.credits_held, "credit")} held.`);
+        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" : ""}, ${plural2(event.credits_held, "credit")} held: ${event.reason})`);
+      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);
-      ctx.out(`Answer: ${send2} "${event.choices[0]}", or in your own words.`);
+      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"`);
@@ -1371,7 +1892,8 @@ function render(ctx, event, said) {
         return;
       for (const line of planCard(event.plan))
         ctx.out(line);
-      ctx.out(`Build it: ${sendCommand(said)} --build "Build it"`);
+      if (said.work === "draft")
+        ctx.out(`Build it: ${sendCommand(said)} --build "Build it"`);
       return;
     case "brief": {
       if (!event.done)
@@ -1411,8 +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?.url)
-        ctx.out(`Painted ${event.picture.id} (${event.picture.width} by ${event.picture.height}) ${dim(ctx, event.picture.url)}`);
+      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);
@@ -1431,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)
@@ -1446,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}`);
@@ -1464,11 +1987,14 @@ 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;
   }
@@ -1494,20 +2020,22 @@ function finish(ctx, turn, event, said) {
   }
   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.");
   } else if (event.status === "cancelled") {
-    ctx.err(`Turn ${turn} was cancelled: ${plural2(event.credits_charged, "credit")} used${back}. What it finished is saved.`);
+    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 ?? "Velven could not finish it."} A failed turn costs nothing.`);
+    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 (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}`);
@@ -1517,6 +2045,9 @@ 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;
 }
@@ -1548,17 +2079,46 @@ function planCard(plan) {
     lines.push(plan.score ? "It keeps a score." : "No score.");
   return lines;
 }
-function queuedLine(queued) {
-  const ahead = queued.position !== null && queued.position > 1 ? ` and ${plural2(queued.position - 1, "message")} ahead of it` : "";
-  return `Queued: it runs after the turn that is running${ahead}. velven create queue lists what waits.`;
+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) {
@@ -1590,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)
@@ -1602,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) {
@@ -1624,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;
 }
@@ -1657,7 +2239,7 @@ 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;
 }
@@ -1689,7 +2271,7 @@ async function referencePictures(ctx, api, args, projectFlag, json) {
     return EXIT.ok;
   }
   for (const r of references) {
-    const carried = r.messages !== undefined ? r.messages ? `on ${plural2(r.messages, "message")}` : "not sent yet" : r.attached ? "sent" : "not sent yet";
+    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.`);
@@ -1714,7 +2296,7 @@ async function usage(ctx, api, project, before, json) {
     return EXIT.ok;
   }
   for (const t of answer.turns) {
-    const used = t.credits.charged !== null ? `${plural2(t.credits.charged, "credit")} used` : `${plural2(t.credits.held, "credit")} held`;
+    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());
   }
@@ -1742,42 +2324,164 @@ async function showPlan(ctx, api, args, projectFlag, json) {
     ctx.out(`Build it: velven create send${projectFlag ? ` --project ${id}` : ""} --build "Build it"`);
   return EXIT.ok;
 }
-async function queue(ctx, api, args, projectFlag, json) {
+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") {
-    if (id === undefined || !/^\d+$/.test(id) || Number(id) === 0 || rest.length) {
-      throw new CliError("Name one waiting message by its number, like velven create queue rm 12.", EXIT.usage, "usage");
+    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);
-    await call(api, "DELETE", `${ROOT}/projects/${seg(project2)}/queue/${seg(id)}`);
+    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, removed: Number(id) }));
+      ctx.out(JSON.stringify({ ok: true, ...view }));
     else
-      ctx.out(`Removed message ${id}: it will not run.`);
+      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, remove one with velven create queue rm 12.`, EXIT.usage, "usage");
+    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 } = await call(api, "GET", `${ROOT}/projects/${seg(project)}/queue`);
+  const { queued, paused } = await call(api, "GET", `${ROOT}/projects/${seg(project)}/queue`);
   if (json) {
-    ctx.out(JSON.stringify({ ok: true, queued }));
+    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 when the running turn ends. Remove one: velven create queue rm <number>");
+  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) {
@@ -1786,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 this week'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})` : ""}`);
@@ -1797,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;
@@ -1825,7 +2523,7 @@ 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 readFile6, 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 as resolve2, sep } from "node:path";
 import { createBrotliDecompress, createGunzip } from "node:zlib";
@@ -2702,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();
@@ -2716,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 {
@@ -2761,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 readFile5(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);
@@ -2879,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);
@@ -3089,7 +3777,7 @@ import { stat as stat3 } from "node:fs/promises";
 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) {
@@ -3108,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;
@@ -3126,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) => {
@@ -3157,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);
       }
@@ -3175,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;
@@ -3268,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),
@@ -3306,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,
@@ -3446,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);
@@ -3506,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"];
@@ -3530,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;
 }
@@ -3603,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: {