@koda-sl/baker-cli 0.560.0 → 0.561.0

package/dist/chunk-X7XFAFU4.js

@@ -0,0 +1,2209 @@
+import {
+  nodeParamsPreview
+} from "./chunk-XZAVBONI.js";
+import {
+  outputRatioWarningsFor,
+  shownBaseline,
+  shownVersion
+} from "./chunk-2VHYY4RU.js";
+import {
+  waitForSheet
+} from "./chunk-WN4KX7GE.js";
+import {
+  fetchBrandLogo
+} from "./chunk-F62BW6DJ.js";
+import {
+  advanceDefinitionStatus
+} from "./chunk-3ACMDRSE.js";
+import {
+  correctedPicture,
+  growFromVersion,
+  ingestedNow,
+  keepsChosen,
+  madeThisRun,
+  makesSameVariants,
+  pictureRecord,
+  plainRunGrowth,
+  previousAdImage,
+  previousDelivered,
+  relaysSizesOnly,
+  runBaker,
+  seriesLeadsAbove,
+  seriesMembers,
+  seriesRunHints,
+  variantFiles,
+  variantImage,
+  versionRun,
+  writeSeriesMemberCanvas
+} from "./chunk-ZD5MNBLA.js";
+import {
+  AUTO_FIX_ROUNDS,
+  autoFixStep,
+  clearLegacyDirtyMarker,
+  correctFrom,
+  fixMemoryOf,
+  formatOfSizeNode,
+  frameChanges,
+  isStaticAdCanvas,
+  lostVital,
+  oneSizeFix,
+  paidFor,
+  peopleReader,
+  persistingDefects,
+  pictureEdit,
+  placedTooFar,
+  plainRunEdit,
+  prefilterSpend,
+  readRenderState,
+  recordRenderAttempt,
+  recordRendered,
+  recordReviewOutcome,
+  recordSeriesLeadRun,
+  recordSnapshot,
+  rendersNewPicture,
+  repeatsFailedFix,
+  reviewStaticRun,
+  runCostHint,
+  sizeShapeOf,
+  specEditInstruction,
+  staticReviewTargets,
+  stopsWithoutRepair,
+  withDeliveredSizes,
+  withExtendedSizes,
+  withRelayEdit,
+  withRelayNote,
+  withSizesFollowingFix
+} from "./chunk-RHSKKWPO.js";
+import {
+  buildFailedRunRecord,
+  buildInitialRunRecord,
+  buildRunRecord,
+  creativeSlugFromCanvasPath,
+  finalFiles,
+  finalOutputLabelsFromCanvas,
+  nodeOutputsToRecord,
+  withFacts
+} from "./chunk-EJBLF2LI.js";
+import {
+  CanvasPrepareError,
+  REBUILD_FILE,
+  anchorLines,
+  castHandles,
+  computeSourceSha,
+  exitOnPrepareError,
+  findBrandRoot,
+  fixStaticAd,
+  formatOfAdaptId,
+  isNativeCanvas,
+  listSceneFiles,
+  prepareCanvas,
+  readIdeaAnchor,
+  readStaticBrandKit,
+  readStaticPromptJson,
+  rederiveFromVariant,
+  seriesOf,
+  wireNamedPeople,
+  wireProofBadges
+} from "./chunk-GQ4DMO5Q.js";
+import {
+  gatewayViewerModel,
+  jevReadJudge,
+  liveViewerLookups,
+  mayBeCorrection,
+  readTurnRenders,
+  recordTurnRender,
+  recordViewerFail,
+  roundFitsTurn,
+  turnRenderRefusal,
+  updateTurnRenders,
+  viewerCheckBeforeRender,
+  viewerCheckSkip,
+  viewerChecksSpent
+} from "./chunk-SJIEU3VG.js";
+import {
+  heldRules
+} from "./chunk-QPTYTM2X.js";
+import {
+  readAvatars,
+  writeAvatars
+} from "./chunk-OFMFBRSL.js";
+import {
+  readCaseFile
+} from "./chunk-3FLSRUID.js";
+import {
+  ruleTells
+} from "./chunk-UKZKLXTE.js";
+import {
+  holdUnbilledSpend,
+  holdWhenSettled,
+  sendBillingSpend,
+  takeUnbilledSpend
+} from "./chunk-Y5PNLB24.js";
+import {
+  canvasOutputsRoot,
+  describeRewrites,
+  findWorkspaceRoot,
+  localPathParam
+} from "./chunk-N3PASNUA.js";
+import {
+  ValidationError,
+  createEngineFromEnv,
+  resolveConcurrency,
+  ulid
+} from "./chunk-DWPOAU4Z.js";
+import {
+  BackendClient,
+  STATIC_ADAPT_FORMAT_ROLE,
+  castsNobody,
+  isPlateCanvas,
+  nodesWithRole,
+  regenerateTargets,
+  rolesById
+} from "./chunk-X3GWGFZP.js";
+import {
+  bytesOf
+} from "./chunk-GWLP45WQ.js";
+import {
+  reviewAgainstRules
+} from "./chunk-6QINKM6T.js";
+import {
+  AdSpecSchema,
+  adSpecJsonSchema,
+  decisionOf,
+  isAdSpec,
+  isMemeTemplate,
+  isVital,
+  jevCitationJudge,
+  nativeCopy
+} from "./chunk-H3HA22Z3.js";
+import {
+  RENDER_REVIEW_MODEL,
+  RENDER_REVIEW_UNAVAILABLE,
+  askAboutImages,
+  reviewContextBeside,
+  reviewRenderedVideo,
+  rulesDigest,
+  sceneWindowsBeside,
+  videoPathFromOutput
+} from "./chunk-DLM5OSHM.js";
+import {
+  VIEWER_CHECK_MODEL
+} from "./chunk-MCJ5I5LR.js";
+import {
+  LayerExecutionError,
+  RunAbortedError,
+  describeFailureReason,
+  requireCredentialsFromEnv,
+  runFailureCode,
+  sha256Hex
+} from "./chunk-EL3TDR5S.js";
+import {
+  optionalChatId,
+  optionalTurnId
+} from "./chunk-45D6WRCJ.js";
+
+// src/commands/canvas/run.ts
+import { readFile as readFile4 } from "fs/promises";
+import path5 from "path";
+import { defineCommand } from "citty";
+
+// src/commands/canvas/run-progress.ts
+function clampNodeError(error) {
+  return { ...error, message: error.message.slice(0, 2e3) };
+}
+var RunProgressTracker = class {
+  runId;
+  meta;
+  startedAt;
+  nodes = /* @__PURE__ */ new Map();
+  finalLabels;
+  planned = false;
+  constructor(runId, meta, finalLabels) {
+    this.runId = runId;
+    this.meta = meta;
+    this.finalLabels = finalLabels;
+    this.startedAt = Date.now();
+  }
+  apply(event) {
+    if (event.kind === "plan") {
+      for (const node of event.nodes) {
+        this.nodes.set(node.node_id, {
+          nodeId: node.node_id,
+          nodeType: node.node_type,
+          cached: false,
+          credits: 0,
+          durationMs: 0,
+          outputs: [],
+          deps: node.deps,
+          status: "pending",
+          paramsPreview: nodeParamsPreview(node.params, node.deps),
+          ...node.role !== void 0 ? { role: node.role } : {}
+        });
+      }
+      this.planned = true;
+      return;
+    }
+    if (event.kind === "node_start") {
+      this.patchNode(event.node_id, { status: "running" });
+      return;
+    }
+    if (event.kind === "node_settled") {
+      this.patchNode(event.run.node_id, {
+        status: "completed",
+        cached: event.run.cached,
+        credits: event.run.credits,
+        durationMs: event.run.duration_ms,
+        outputs: nodeOutputsToRecord(
+          event.outputs,
+          event.run.node_id === this.finalLabels?.nodeId ? this.finalLabels.labels : void 0
+        ),
+        ...withFacts(event.outputs)
+      });
+      return;
+    }
+    this.patchNode(event.node_id, { status: "failed", error: clampNodeError(event.error) });
+  }
+  /** True once the plan event landed — before that there is nothing worth posting. */
+  hasPlan() {
+    return this.planned;
+  }
+  /** Plan facts (deps + params preview) for stamping the terminal record's nodes. */
+  planInfo() {
+    const info = /* @__PURE__ */ new Map();
+    for (const node of this.nodes.values()) {
+      info.set(node.nodeId, {
+        deps: node.deps ?? [],
+        paramsPreview: node.paramsPreview,
+        ...node.role !== void 0 ? { role: node.role } : {}
+      });
+    }
+    return info;
+  }
+  /** The current in-flight state as a postable full record. */
+  snapshot() {
+    const nodes = [...this.nodes.values()];
+    return {
+      runId: this.runId,
+      ...this.meta,
+      status: "running",
+      stats: {
+        totalNodes: nodes.length,
+        cachedNodes: nodes.filter((n) => n.cached).length,
+        totalCredits: nodes.reduce((sum, n) => sum + n.credits, 0),
+        durationMs: Date.now() - this.startedAt
+      },
+      nodes
+    };
+  }
+  /**
+   * Terminal record for a failed run, preserving what each node got to —
+   * completed nodes keep their outputs so the graph shows exactly where the
+   * run died instead of an empty husk.
+   */
+  failedSnapshot(errorMessage) {
+    const snapshot = this.snapshot();
+    return {
+      ...snapshot,
+      status: "failed",
+      errorMessage: errorMessage.slice(0, 2e3),
+      stats: { ...snapshot.stats, durationMs: Date.now() - this.startedAt }
+    };
+  }
+  patchNode(nodeId, patch) {
+    const existing = this.nodes.get(nodeId);
+    if (!existing) return;
+    this.nodes.set(nodeId, { ...existing, ...patch, status: patch.status ?? existing.status });
+  }
+};
+var RunRecordPoster = class {
+  post;
+  latest = null;
+  inflight = null;
+  warned = false;
+  keepaliveTimer = null;
+  constructor(post) {
+    this.post = post;
+  }
+  /** Queue a progress snapshot; returns immediately. */
+  enqueue(payload) {
+    this.latest = payload;
+    if (!this.inflight) this.inflight = this.pump();
+  }
+  /**
+   * Re-post the latest snapshot on an interval even with no new node events, so
+   * the backend's `canvasRuns.updatedAt` heartbeat stays fresh during a long
+   * single-clip poll (a video_generate clip can run minutes with no
+   * intervening node events). When this process dies the keepalive stops → the
+   * run's `updatedAt` goes stale → the backend reconciliation sweep force-fails
+   * it as interrupted and surfaces the clips that finished. `produce` returns
+   * null before the plan lands (nothing worth posting yet).
+   */
+  startKeepalive(produce, intervalMs = 6e4) {
+    if (this.keepaliveTimer) return;
+    this.keepaliveTimer = setInterval(() => {
+      const snapshot = produce();
+      if (snapshot) this.enqueue(snapshot);
+    }, intervalMs);
+    this.keepaliveTimer.unref?.();
+  }
+  stopKeepalive() {
+    if (this.keepaliveTimer) {
+      clearInterval(this.keepaliveTimer);
+      this.keepaliveTimer = null;
+    }
+  }
+  /**
+   * Post the terminal record (awaited, errors surfaced to the caller). Any
+   * queued progress snapshot is superseded — the terminal record is the full
+   * state — but an in-flight POST is awaited first so it can't land after.
+   */
+  async flush(terminal) {
+    this.stopKeepalive();
+    this.latest = null;
+    if (this.inflight) await this.inflight;
+    await this.post(terminal);
+  }
+  async pump() {
+    while (this.latest) {
+      const payload = this.latest;
+      this.latest = null;
+      try {
+        await this.post(payload);
+      } catch (e) {
+        if (!this.warned) {
+          this.warned = true;
+          const msg = e instanceof Error ? e.message : String(e);
+          process.stderr.write(`[warn] live run progress not streaming (${msg})
+`);
+        }
+      }
+    }
+    this.inflight = null;
+  }
+};
+
+// src/commands/canvas/run-retention.ts
+import { rm } from "fs/promises";
+import path from "path";
+function runDirsToPrune(entries, keep, currentRunId) {
+  const runs = entries.filter((e) => /^r_[0-9A-Za-z]+$/.test(e) && e !== currentRunId).sort();
+  if (keep <= 0) return runs;
+  return runs.slice(0, Math.max(0, runs.length - keep));
+}
+async function pruneOldRuns(outputsDir, keep, currentRunId, log) {
+  const { readdir: readdir2 } = await import("fs/promises");
+  let entries;
+  try {
+    entries = await readdir2(outputsDir);
+  } catch {
+    return;
+  }
+  const toPrune = runDirsToPrune(entries, keep, currentRunId);
+  if (toPrune.length === 0) return;
+  for (const dir of toPrune) {
+    await rm(path.join(outputsDir, dir), { recursive: true, force: true }).catch(
+      (e) => log(`[prune   ] could not remove ${dir}: ${e.message}`)
+    );
+  }
+  log(`[prune   ] removed ${toPrune.length} old run dir(s), kept the ${keep} newest`);
+}
+
+// src/commands/canvas/run-resume.ts
+import { randomUUID } from "crypto";
+import { rmSync } from "fs";
+import { mkdir, readFile, rm as rm2, writeFile } from "fs/promises";
+import path2 from "path";
+function markerKey(canvasPath) {
+  const slug = creativeSlugFromCanvasPath(canvasPath);
+  const identity = slug ?? path2.relative(process.cwd(), path2.resolve(canvasPath));
+  return sha256Hex(Buffer.from(identity)).slice(0, 32);
+}
+function markerFile(outputsDir, canvasPath) {
+  return path2.join(outputsDir, ".inflight", `${markerKey(canvasPath)}.json`);
+}
+function classifyRemoteRun(run) {
+  if (run.interrupted === true || run.status === "awaiting_approval") return "adopt";
+  if (run.status !== "running") return "ignore";
+  return run.adoptable === true ? "adopt" : "concurrent";
+}
+var HEARTBEAT_MS = 2e4;
+var MARKER_LIVE_MS = 9e4;
+function isLiveRender(marker, now = Date.now()) {
+  if (marker.pid === void 0) return false;
+  const beat = marker.heartbeatAt ?? marker.startedAt;
+  if (beat === void 0 || now - beat > MARKER_LIVE_MS) return false;
+  try {
+    process.kill(marker.pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}
+async function resolveRunId(opts) {
+  const existing = await readMarker(opts.outputsDir, opts.canvasPath);
+  if (existing?.pid !== void 0 && existing.pid !== process.pid && (opts.isRendering ?? ((marker) => isLiveRender(marker)))(existing)) {
+    return { runId: existing.runId, resumed: false, rendering: { runId: existing.runId, pid: existing.pid } };
+  }
+  if (opts.explicitRunId) return { runId: opts.explicitRunId, resumed: false };
+  if (!opts.fresh) {
+    if (existing) {
+      const sameSource = existing.sourceSha !== void 0 && existing.sourceSha === opts.sourceSha;
+      return { runId: existing.runId, resumed: true, source: "local", sameSource };
+    }
+    if (opts.adoptedRunId) return { runId: opts.adoptedRunId, resumed: true, source: "remote", sameSource: true };
+    if (opts.remote) {
+      try {
+        const active = await opts.remote.getActiveRun(opts.remote.creativeSlug, opts.remote.sourceSha);
+        if (active) {
+          const decision = classifyRemoteRun(active);
+          if (decision === "adopt") return { runId: active.runId, resumed: true, source: "remote", sameSource: true };
+          if (decision === "concurrent") {
+            return { runId: `r_${ulid()}`, resumed: false, concurrentRunId: active.runId };
+          }
+        }
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        process.stderr.write(`[warn] resumable-run lookup failed (${msg}) \u2014 starting a fresh run
+`);
+      }
+    }
+  }
+  return { runId: `r_${ulid()}`, resumed: false };
+}
+async function readMarker(outputsDir, canvasPath) {
+  try {
+    const parsed = JSON.parse(await readFile(markerFile(outputsDir, canvasPath), "utf8"));
+    if (typeof parsed.runId !== "string" || parsed.runId.length === 0) return null;
+    const num = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+    return {
+      runId: parsed.runId,
+      ...Number.isInteger(parsed.pid) ? { pid: parsed.pid } : {},
+      ...typeof parsed.token === "string" ? { token: parsed.token } : {},
+      ...num(parsed.startedAt) !== void 0 ? { startedAt: num(parsed.startedAt) } : {},
+      ...num(parsed.heartbeatAt) !== void 0 ? { heartbeatAt: num(parsed.heartbeatAt) } : {},
+      ...typeof parsed.sourceSha === "string" ? { sourceSha: parsed.sourceSha } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+async function markRunInFlight(outputsDir, canvasPath, runId, sourceSha) {
+  const file = markerFile(outputsDir, canvasPath);
+  const token = randomUUID();
+  const startedAt = Date.now();
+  const write = (heartbeatAt) => writeFile(
+    file,
+    JSON.stringify({
+      runId,
+      pid: process.pid,
+      token,
+      canvasPath: path2.resolve(canvasPath),
+      startedAt,
+      heartbeatAt,
+      ...sourceSha ? { sourceSha } : {}
+    })
+  );
+  try {
+    await mkdir(path2.dirname(file), { recursive: true });
+    await write(startedAt);
+  } catch {
+  }
+  const timer = setInterval(() => {
+    void readMarker(outputsDir, canvasPath).then((marker) => marker?.token === token ? write(Date.now()) : void 0).catch(() => void 0);
+  }, HEARTBEAT_MS);
+  timer.unref();
+  return { token, stop: () => clearInterval(timer) };
+}
+function busyFile(outputsDir, canvasPath) {
+  return path2.join(outputsDir, ".inflight", `${markerKey(canvasPath)}.busy.json`);
+}
+async function markCanvasBusy(outputsDir, canvasPath, runId, pid = process.pid) {
+  const file = busyFile(outputsDir, canvasPath);
+  const write = () => writeFile(file, JSON.stringify({ runId, pid, heartbeatAt: Date.now() }));
+  try {
+    await mkdir(path2.dirname(file), { recursive: true });
+    await write();
+  } catch {
+  }
+  const timer = setInterval(() => void write().catch(() => void 0), HEARTBEAT_MS);
+  timer.unref();
+  let released = false;
+  const release = () => {
+    if (released) return;
+    released = true;
+    clearInterval(timer);
+    try {
+      rmSync(file, { force: true });
+    } catch {
+    }
+  };
+  return { release };
+}
+async function canvasBusyElsewhere(outputsDir, canvasPath, now = Date.now()) {
+  try {
+    const held = JSON.parse(await readFile(busyFile(outputsDir, canvasPath), "utf8"));
+    if (typeof held.runId !== "string" || held.pid === void 0 || held.pid === process.pid) return null;
+    return isLiveRender(held, now) ? { runId: held.runId, pid: held.pid } : null;
+  } catch {
+    return null;
+  }
+}
+async function clearRunMarker(outputsDir, canvasPath, token) {
+  try {
+    if (token !== void 0) {
+      const marker = await readMarker(outputsDir, canvasPath);
+      if (marker?.token !== void 0 && marker.token !== token) return;
+    }
+    await rm2(markerFile(outputsDir, canvasPath), { force: true });
+  } catch {
+  }
+}
+
+// src/commands/canvas/run-snapshot.ts
+import { existsSync } from "fs";
+import { mkdir as mkdir2, readdir, readFile as readFile2, stat, writeFile as writeFile2 } from "fs/promises";
+import path3 from "path";
+var SNAPSHOT_SCHEMA = "baker-canvas-snapshot/1";
+var MAX_SNAPSHOT_FILE_BYTES = 32 * 1024 * 1024;
+var EXT_TO_MIME = {
+  json: "application/json",
+  html: "text/html",
+  css: "text/css",
+  js: "text/javascript",
+  txt: "text/plain",
+  md: "text/markdown",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  webp: "image/webp",
+  gif: "image/gif",
+  avif: "image/avif",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mov: "video/quicktime",
+  ttf: "font/ttf",
+  otf: "font/otf",
+  woff: "font/woff",
+  woff2: "font/woff2"
+};
+function mimeForFile(filePath) {
+  const ext = path3.extname(filePath).slice(1).toLowerCase();
+  return EXT_TO_MIME[ext] ?? "application/octet-stream";
+}
+function toPosix(p) {
+  return p.split(path3.sep).join("/");
+}
+function isInside(dir, target) {
+  const rel = path3.relative(dir, target);
+  return !rel.startsWith("..") && !path3.isAbsolute(rel);
+}
+function localPathRefsFromCanvas(parsed) {
+  const nodes = parsed?.nodes;
+  if (!Array.isArray(nodes)) return [];
+  const refs = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    const n = node;
+    const params = n.params;
+    if (!params || typeof params !== "object") continue;
+    const key = localPathParam(n);
+    const value = key ? params[key] : void 0;
+    if (isSnapshotablePath(value)) refs.add(value);
+  }
+  return [...refs];
+}
+function isSnapshotablePath(value) {
+  return typeof value === "string" && value.length > 0 && !value.includes("[TODO");
+}
+var FINGERPRINTED_FILES = ["prompt.json", "_definition.md"];
+async function sourceRefsToSnapshot(canvasDir, parsed) {
+  const refs = new Set(localPathRefsFromCanvas(parsed));
+  for (const sceneFile of await listSceneFiles(canvasDir)) {
+    refs.add(toPosix(path3.relative(canvasDir, sceneFile)));
+  }
+  refs.add(REBUILD_FILE);
+  for (const fingerprinted of FINGERPRINTED_FILES) {
+    if (existsSync(path3.join(canvasDir, fingerprinted))) refs.add(fingerprinted);
+  }
+  return [...refs];
+}
+async function uploadRunSnapshot(client, opts) {
+  try {
+    const canvasDir = path3.dirname(opts.canvasPath);
+    const canvasBytes = Buffer.from(opts.raw);
+    const canvasEntry = {
+      path: path3.basename(opts.canvasPath),
+      bytes: canvasBytes,
+      sha256: sha256Hex(canvasBytes),
+      mime: "application/json"
+    };
+    const files = [];
+    const skipped = [];
+    for (const refPath of await sourceRefsToSnapshot(canvasDir, opts.parsed)) {
+      const abs = path3.isAbsolute(refPath) ? refPath : path3.resolve(canvasDir, refPath);
+      if (!isInside(canvasDir, abs)) {
+        skipped.push({
+          path: toPosix(path3.relative(canvasDir, abs)),
+          reason: "outside the creative folder \u2014 read from the workspace on rerun"
+        });
+        continue;
+      }
+      let st;
+      try {
+        st = await stat(abs);
+      } catch {
+        skipped.push({ path: toPosix(path3.relative(canvasDir, abs)), reason: "missing" });
+        continue;
+      }
+      const fileList = st.isDirectory() ? await listFilesRecursive(abs) : [abs];
+      for (const file of fileList) {
+        const rel = toPosix(path3.relative(canvasDir, file));
+        const size = (await stat(file)).size;
+        if (size > MAX_SNAPSHOT_FILE_BYTES) {
+          skipped.push({ path: rel, reason: `too large (${size} bytes)` });
+          continue;
+        }
+        const bytes = await readFile2(file);
+        files.push({ path: rel, bytes, sha256: sha256Hex(bytes), mime: mimeForFile(file) });
+      }
+    }
+    const identity = sha256Hex(
+      Buffer.from(
+        JSON.stringify({
+          creativeSlug: opts.creativeSlug,
+          entries: [canvasEntry, ...files].map((entry) => [entry.path, entry.sha256]),
+          skipped
+        })
+      )
+    );
+    if (opts.previous?.identity === identity) return opts.previous;
+    const put = (bytes, mime) => putContentAddressed(client, bytes, mime, opts.signal);
+    const canvasUpload = await put(canvasEntry.bytes, canvasEntry.mime);
+    const uploaded = [];
+    for (const file of files) {
+      const upload = await put(file.bytes, file.mime);
+      uploaded.push({ path: file.path, sha256: upload.sha256, url: upload.url });
+    }
+    const manifest = {
+      schema: SNAPSHOT_SCHEMA,
+      creativeSlug: opts.creativeSlug,
+      canvasSha: canvasUpload.sha256,
+      canvas: { path: canvasEntry.path, sha256: canvasUpload.sha256, url: canvasUpload.url },
+      files: uploaded,
+      skipped: skipped.length > 0 ? skipped : void 0
+    };
+    const manifestUpload = await put(Buffer.from(JSON.stringify(manifest)), "application/json");
+    return { identity, url: manifestUpload.url };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    process.stderr.write(`[warn] canvas snapshot not uploaded (${msg}) \u2014 this run cannot be re-run from another workspace
+`);
+    return null;
+  }
+}
+var MAX_GRAPH_BYTES = 4 * 1024 * 1024;
+async function uploadRunGraph(client, graph, signal) {
+  try {
+    const bytes = Buffer.from(JSON.stringify(graph));
+    if (bytes.length > MAX_GRAPH_BYTES) return null;
+    return (await putContentAddressed(client, bytes, "application/json", signal)).url;
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    process.stderr.write(`[warn] run graph not kept (${msg}) \u2014 a correction from another workspace starts from its picture
+`);
+    return null;
+  }
+}
+async function putContentAddressed(client, bytes, mime, signal) {
+  const sha256 = sha256Hex(bytes);
+  const { putUrl, publicUrl } = await client.presignAssetUpload(sha256, mime, signal, "blueprint");
+  const held = await fetch(publicUrl, { method: "HEAD", signal }).then(
+    (res2) => res2.ok,
+    () => false
+  );
+  if (held) return { sha256, url: publicUrl };
+  const res = await fetch(putUrl, {
+    method: "PUT",
+    body: new Uint8Array(bytes),
+    headers: { "Content-Type": mime },
+    signal
+  });
+  if (!res.ok) throw new Error(`snapshot PUT failed ${res.status} ${res.statusText}`);
+  return { sha256, url: publicUrl };
+}
+async function listFilesRecursive(dir) {
+  const entries = await readdir(dir, { recursive: true, withFileTypes: true });
+  return entries.filter((d) => d.isFile()).map((d) => path3.join(d.parentPath, d.name));
+}
+var SnapshotConflictError = class extends Error {
+  conflicts;
+  constructor(conflicts) {
+    super(`local files differ from the recorded snapshot: ${conflicts.join(", ")}`);
+    this.name = "SnapshotConflictError";
+    this.conflicts = conflicts;
+  }
+};
+async function restoreRunSnapshot(manifest, targetDir, opts = {}) {
+  const entries = [manifest.canvas, ...manifest.files];
+  const resolvedTarget = path3.resolve(targetDir);
+  const planned = [];
+  const conflicts = [];
+  const upToDate = [];
+  for (const entry of entries) {
+    if (path3.isAbsolute(entry.path) || entry.path.split("/").includes("..")) {
+      throw new Error(`snapshot entry escapes the creative directory: ${entry.path}`);
+    }
+    const target = path3.resolve(resolvedTarget, entry.path);
+    if (target !== resolvedTarget && !target.startsWith(resolvedTarget + path3.sep)) {
+      throw new Error(`snapshot entry escapes the creative directory: ${entry.path}`);
+    }
+    const existing = await readFile2(target).catch(() => null);
+    if (existing) {
+      if (sha256Hex(existing) === entry.sha256) {
+        upToDate.push(entry.path);
+        continue;
+      }
+      if (!opts.force) {
+        conflicts.push(entry.path);
+        continue;
+      }
+    }
+    planned.push({ entry, target });
+  }
+  if (conflicts.length > 0) throw new SnapshotConflictError(conflicts);
+  const restored = [];
+  for (const { entry, target } of planned) {
+    const res = await fetch(entry.url);
+    if (!res.ok) throw new Error(`snapshot download failed for ${entry.path}: ${res.status} ${res.statusText}`);
+    const bytes = Buffer.from(await res.arrayBuffer());
+    if (sha256Hex(bytes) !== entry.sha256) {
+      throw new Error(`snapshot download for ${entry.path} does not match its recorded sha256`);
+    }
+    await mkdir2(path3.dirname(target), { recursive: true });
+    await writeFile2(target, bytes);
+    restored.push(entry.path);
+  }
+  return { canvasPath: path3.resolve(resolvedTarget, manifest.canvas.path), restored, upToDate };
+}
+
+// src/commands/avatars/namedPerson.ts
+var RESEARCH_TIMEOUT_MS = 18e4;
+async function avatarOfNamedPerson(who) {
+  const research = await writeAvatars(
+    "/api/avatars/research",
+    { who, create: true },
+    { timeoutMs: RESEARCH_TIMEOUT_MS }
+  );
+  const handle = research.avatar?.handle;
+  if (research.status !== "found" || !handle) return null;
+  const read = () => readAvatars("/api/avatars/get", { handle });
+  const avatar = await waitForSheet(await read(), read);
+  return avatar.sheetUrl ? { handle, sheetUrl: avatar.sheetUrl } : null;
+}
+
+// src/commands/canvas/slug-restore.ts
+import { existsSync as existsSync2 } from "fs";
+import path4 from "path";
+var SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+var SlugRestoreError = class extends Error {
+  code;
+  fix;
+  constructor(code, message, fix) {
+    super(message);
+    this.name = "SlugRestoreError";
+    this.code = code;
+    this.fix = fix;
+  }
+};
+async function canvasForSlug(slug, opts) {
+  if (!SLUG_PATTERN.test(slug)) {
+    throw new SlugRestoreError("invalid_slug", `"${slug}" is not a valid creative slug`);
+  }
+  const targetDir = path4.join(opts.workspaceRoot, "src", "creatives", slug);
+  const local = path4.join(targetDir, `${slug}.canvas.json`);
+  if (!opts.forceRemote && existsSync2(local)) return { canvasPath: local };
+  const client = opts.client();
+  if (!client) {
+    throw new SlugRestoreError(
+      "missing_credentials",
+      `"${slug}" is not in this workspace, and restoring it from run history needs Baker credentials (BAKER_API_URL / BAKER_API_KEY).`
+    );
+  }
+  const latest = await client.getLatestSnapshotRun(slug);
+  if (!latest) {
+    throw new SlugRestoreError(
+      "no_snapshot_run",
+      `No creative "${slug}" in this workspace, and no recorded run of it to restore from.`,
+      "Check the slug against `ls src/creatives`, or scaffold the creative first."
+    );
+  }
+  const manifest = await fetchManifest(latest.canvasSnapshotUrl);
+  if (latest.canvasSha && manifest.canvasSha !== latest.canvasSha) {
+    throw new SlugRestoreError("snapshot_mismatch", `the snapshot of run ${latest.runId} does not match its recorded canvas`);
+  }
+  try {
+    const restore = await restoreRunSnapshot(manifest, targetDir, { force: opts.forceRemote });
+    opts.log(
+      restore.restored.length > 0 ? `[restore] ${restore.restored.length} file(s) from run ${latest.runId}: ${restore.restored.join(", ")}` : `[restore] local files already match run ${latest.runId}, nothing downloaded`
+    );
+    for (const skipped of manifest.skipped ?? []) {
+      opts.log(`[warn] snapshot omitted ${skipped.path} (${skipped.reason}); supply it locally if the run needs it fresh`);
+    }
+    return { canvasPath: restore.canvasPath, adoptRunId: await adoptableRun(client, slug, latest.runId) };
+  } catch (e) {
+    if (e instanceof SnapshotConflictError) {
+      throw new SlugRestoreError(
+        "local_files_differ",
+        `local files differ from the recorded snapshot: ${e.conflicts.join(", ")}`,
+        "Re-run with --force-remote to overwrite them, or run the local canvas file directly with `baker canvas run <file>`."
+      );
+    }
+    throw e;
+  }
+}
+async function adoptableRun(client, slug, restoredRunId) {
+  const active = await client.getActiveRun(slug).catch(() => null);
+  return active?.runId === restoredRunId && active.adoptable === true ? restoredRunId : void 0;
+}
+async function fetchManifest(url) {
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new SlugRestoreError("snapshot_unavailable", `snapshot manifest download failed: ${res.status} ${res.statusText}`);
+  }
+  const manifest = await res.json();
+  if (manifest?.schema !== SNAPSHOT_SCHEMA || typeof manifest.canvas?.path !== "string") {
+    throw new SlugRestoreError("snapshot_invalid", "snapshot manifest has an unexpected shape");
+  }
+  return manifest;
+}
+
+// src/commands/canvas/series-run.ts
+async function runSeries(slugs, deps) {
+  return Promise.all(
+    slugs.map(async (slug) => {
+      const plan = await deps.plan(slug);
+      if ("refused" in plan) return { slug, status: "refused", error: plan.refused };
+      if (!plan.run) return { slug, status: "up_to_date", ...plan.runId ? { run_id: plan.runId } : {} };
+      return resultOf(slug, await deps.run(slug));
+    })
+  );
+}
+function resultOf(slug, answer) {
+  if (answer.ok !== true) {
+    const error = answer.error ?? {};
+    return {
+      slug,
+      status: "failed",
+      error: {
+        code: error.code ?? "render_failed",
+        message: error.message ?? "The render did not finish.",
+        ...error.fix ? { fix: error.fix } : {}
+      }
+    };
+  }
+  const verdict = answer.verdict;
+  const status = verdict === "ready" || verdict === "ready_with_notes" || verdict === "needs_fixes" ? verdict : "ready";
+  return {
+    slug,
+    status,
+    ...typeof answer.run_id === "string" ? { run_id: answer.run_id } : {},
+    ...answer.files !== void 0 ? { files: answer.files } : {}
+  };
+}
+function seriesEnvelope(lead, results) {
+  const ready = results.filter((r) => r.status === "ready" || r.status === "ready_with_notes");
+  const fixes = results.filter((r) => r.status === "needs_fixes");
+  const stopped = results.filter((r) => r.status === "refused" || r.status === "failed");
+  return {
+    ok: true,
+    data: { lead, ready: ready.map((r) => r.slug), ads: results },
+    hints: [
+      ...ready.filter((r) => r.run_id).map((r) => `Save: baker creatives publish --slug ${r.slug} --run-id ${r.run_id} --title "<title>" --output <lead size>`),
+      ...fixes.length > 0 ? [
+        `Still needs fixes after its own corrections: ${fixes.map((r) => r.slug).join(", ")}. Correct each by itself (baker canvas run --slug <slug> --fix "<what to change>"); the others stay as they are.`
+      ] : [],
+      ...stopped.map((r) => `${r.slug}: ${r.error?.message ?? "not rendered"}${r.error?.fix ? ` ${r.error.fix}` : ""}`),
+      `A new version of the lead (${lead}) reaches every ad of the series on the next \`baker canvas run --series ${lead}\`.`
+    ]
+  };
+}
+
+// src/commands/canvas/voice-retake.ts
+var nodesOf = (graph) => {
+  const nodes = graph?.nodes;
+  return Array.isArray(nodes) ? nodes : [];
+};
+function refsIn(value) {
+  if (typeof value === "string") {
+    const id = /^\$ref:([^.]+)\./.exec(value)?.[1];
+    return id ? [id] : [];
+  }
+  if (Array.isArray(value)) return value.flatMap(refsIn);
+  if (value && typeof value === "object") return Object.values(value).flatMap(refsIn);
+  return [];
+}
+function keptVoiceClips(graph) {
+  const nodes = nodesOf(graph);
+  const byId = new Map(nodes.flatMap((n) => typeof n.id === "string" ? [[n.id, n]] : []));
+  const tracks = nodes.filter((n) => {
+    const tags = n.tags ?? {};
+    return n.type === "audio_timeline" && tags.role === "voice" && tags.on_camera === true;
+  });
+  const seen = /* @__PURE__ */ new Set();
+  const queue = tracks.flatMap((t) => refsIn(t.inputs));
+  while (queue.length > 0) {
+    const id = queue.pop();
+    if (seen.has(id)) continue;
+    seen.add(id);
+    queue.push(...refsIn(byId.get(id)?.inputs));
+  }
+  return [...seen].flatMap((id) => {
+    const node = byId.get(id);
+    return node?.type === "video_generate" ? [node] : [];
+  });
+}
+var promptOf = (node) => JSON.stringify(node?.params?.prompt ?? null);
+function retakenTalkingScenes(previous, canvas) {
+  const before = new Map(nodesOf(previous).map((n) => [n.id, n]));
+  return keptVoiceClips(canvas).filter((clip) => before.has(clip.id) && promptOf(before.get(clip.id)) !== promptOf(clip)).map((clip) => String(clip.id));
+}
+
+// src/commands/canvas/static-spec-repair.ts
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import sharp from "sharp";
+import { z } from "zod";
+var Answer = z.object({
+  changed: z.string().min(1),
+  set: z.array(z.object({ path: z.string().min(1), value: z.unknown() }))
+});
+function withValueAt(root, path6, value) {
+  const [key, ...rest] = path6;
+  if (key === void 0) return value;
+  if (Array.isArray(root)) {
+    const at = Number(key);
+    if (!Number.isInteger(at) || at < 0 || at > root.length) return root;
+    const next = [...root];
+    next[at] = withValueAt(root[at], rest, value);
+    return next;
+  }
+  const holder = root && typeof root === "object" ? root : {};
+  return { ...holder, [key]: withValueAt(holder[key], rest, value) };
+}
+function declaredAvatars(spec) {
+  return new Set((spec.concept?.load_bearing ?? []).filter(isVital).flatMap((l) => castHandles(l.ours ?? "")));
+}
+function groundedAvatars(spec) {
+  return new Set(spec.references.flatMap((r) => r.avatar ? [r.avatar.toLowerCase()] : []));
+}
+function castsOnly(spec, avatars) {
+  const people = spec.references.filter((r) => r.id.startsWith("PERSON_"));
+  return people.length > 0 && people.every((r) => r.avatar !== void 0 && avatars.has(r.avatar.toLowerCase()));
+}
+function keepsCast(was, now) {
+  const declared = declaredAvatars(was);
+  if (castsNobody(was) && !castsNobody(now) && !castsOnly(now, declared)) return false;
+  const before = groundedAvatars(was);
+  const after = groundedAvatars(now);
+  return ![...declared].some((handle) => before.has(handle) && !after.has(handle));
+}
+function memeTemplateReferences(spec) {
+  return spec.references.filter(isMemeTemplate);
+}
+function keepsMemeTemplates(was, now) {
+  return memeTemplateReferences(was).every(
+    (t) => now.references.some((r) => r.id === t.id && r.role === t.role && r.image === t.image && r.what === t.what && r.keep === t.keep)
+  );
+}
+function printedWords(spec) {
+  return [...spec.copy.map((l) => l.text), ...spec.native ? nativeCopy(spec.native) : []];
+}
+function acceptRepair(before, answer, held = { rules: [] }) {
+  const parsed = Answer.safeParse(answer);
+  if (!parsed.success || !isAdSpec(before)) return null;
+  const spec = parsed.data.set.reduce((at, { path: path6, value }) => withValueAt(at, path6.split("."), value), before);
+  if (!isAdSpec(spec)) return null;
+  const was = AdSpecSchema.safeParse(before);
+  const now = AdSpecSchema.safeParse(spec);
+  if (!was.success || !now.success) return null;
+  if (JSON.stringify(was.data) === JSON.stringify(now.data)) return null;
+  for (const key of ["concept", "mechanism", "message", "brand", "viewer"]) {
+    if (JSON.stringify(was.data[key]) !== JSON.stringify(now.data[key])) return null;
+  }
+  if (was.data.native && was.data.native.surface !== now.data.native?.surface) return null;
+  if (!keepsCast(was.data, now.data) || !keepsMemeTemplates(was.data, now.data)) return null;
+  const kept = printedWords(now.data);
+  const said = printedWords(was.data);
+  if (!said.every((text) => kept.includes(text))) return null;
+  if (was.data.native) {
+    const shown = now.data.native ? nativeCopy(now.data.native) : [];
+    if (!nativeCopy(was.data.native).every((text) => shown.includes(text))) return null;
+  }
+  const added = kept.filter((text) => !said.includes(text));
+  if (ruleTells(added, held.rules, held.language).some((t) => t.kind === "forbidden")) return null;
+  return { changed: parsed.data.changed, spec };
+}
+function memeTemplatesOf(spec) {
+  let raw;
+  try {
+    raw = JSON.parse(spec);
+  } catch {
+    return [];
+  }
+  const parsed = AdSpecSchema.safeParse(raw);
+  return parsed.success ? memeTemplateReferences(parsed.data).map((r) => `${r.id} (${r.what})`) : [];
+}
+function buildSpecRepairPrompt(spec, findings, schema, rejected = [], restore = []) {
+  const templates = memeTemplatesOf(spec);
+  return [
+    "This is the spec (prompt.json) a static ad was drawn from, and the image is the ad it gave.",
+    "A review found these defects in it, and they come from what the spec asks for, so drawing it again or editing the picture brings them back:",
+    ...findings.map((f) => `- ${f}`),
+    ...restore.length > 0 ? [
+      "",
+      "Restore what made the proven ad win, as the concept declares it: put each of these back in the scene, the references and the lines' `look`, carried by exactly what of ours the concept names; never drop it or put anything the concept does not declare in its place.",
+      ...restore.map((r) => `- ${r}`)
+    ] : [],
+    ...rejected.length > 0 ? [
+      "",
+      "What the person rejected in earlier versions of this ad, in their words: never bring back any of it, in the scene, the references or the layout.",
+      ...rejected.map((r) => `- ${r}`)
+    ] : [],
+    "",
+    "Correct the spec so these defects cannot happen, changing as little as you can:",
+    "- Drop, replace or reword the element, photo, reference, layout or scene instruction that causes a defect (never what the concept keeps of the proven ad). A second subject the viewer would read as another one (another pet, another person) is dropped, or made unmistakably the same one.",
+    "- A rating or stars shown with no source: name the source only if the spec already states one anywhere; otherwise drop the stars or the rating. Never invent a source, a number or a claim.",
+    "- A native screen's layout (where its headline, bubbles or cards sit, what it shows) is changed in its `native` block.",
+    "- Keep every line of copy word for word: never reword, shorten or drop one. Keep the schema, the brand and everything the defects do not touch.",
+    "- Preserve `concept`, `mechanism`, `message` and `brand` exactly, including the CTA colour. Fix how the ad executes its idea; never change why it works or remove its load-bearing elements to make a defect pass.",
+    ...templates.length > 0 ? [
+      `- These references are real meme templates, grounded on their real pictures: ${templates.join("; ")}. Keep each exactly as it is (id, role, image and use) and keep the scene using it as the picture; never drop, replace or redraw one, and never describe its people or faces in the scene for the image model to draw.`
+    ] : [],
+    "- Keep a native screen on the same `native.surface`. Notes stays Notes, a review stays on its review platform. Change its layout or content only; never replace it with a physical document or a generic ad.",
+    "",
+    'Reply with only this JSON, naming only the fields you replace, each by its dotted path in the spec ("scene.layout", "references", "copy.2.position", "native.messages"), with its whole new value: {"changed": "<one plain sentence a marketer reads: what you changed and why>", "set": [{"path": "<dotted path>", "value": <its new value>}]}',
+    "",
+    "The spec:",
+    spec,
+    // Bench, Oct 2026: without it the model set a field the spec does not have ("native.layout").
+    ...schema ? ["", "Its JSON schema: set only fields and values it allows.", JSON.stringify(schema)] : []
+  ].join("\n");
+}
+function restoreLines(spec, jobs) {
+  const parsed = AdSpecSchema.safeParse(spec);
+  if (!parsed.success || jobs.length === 0) return [];
+  return (parsed.data.concept?.load_bearing ?? []).filter((l) => isVital(l) && l.job !== void 0 && jobs.includes(l.job)).map((l) => {
+    const carried = decisionOf(l) === "keep" ? "kept as in the proven ad" : `carried by ${l.ours?.trim() || "what of ours the concept names"}`;
+    return `${l.job === "stop" ? "what stops the scroll" : "the proof"}, "${l.element}": ${carried}`;
+  });
+}
+var REPAIR_TIMEOUT_MS = 15e4;
+var SHOWN_WIDTH = 768;
+async function repairSpec(opts) {
+  const text = await readFile3(opts.promptPath, "utf8").catch(() => null);
+  if (text === null) return null;
+  let before;
+  try {
+    before = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  const shown = opts.image ? await bytesOf(opts.image).then(async (bytes) => (await sharp(bytes).resize({ width: SHOWN_WIDTH }).jpeg({ quality: 85 }).toBuffer()).toString("base64")).catch(() => null) : null;
+  const prompt = buildSpecRepairPrompt(
+    text,
+    opts.findings,
+    adSpecJsonSchema(),
+    opts.rejected,
+    restoreLines(before, opts.restore ?? [])
+  );
+  const repair = acceptRepair(
+    before,
+    await askAboutImages(RENDER_REVIEW_MODEL, shown ? [shown] : [], prompt, opts.onSpend, REPAIR_TIMEOUT_MS),
+    opts.held
+  );
+  if (!repair) return null;
+  await writeFile3(opts.promptPath, `${JSON.stringify(repair.spec, null, 2)}
+`, "utf8");
+  return repair.changed;
+}
+
+// src/commands/canvas/run.ts
+function refusePlateVersion(runId) {
+  const message = `The version of run ${runId} could not be found with the picture its sizes are cut from, so it cannot be changed on top of. Render the creative again (baker canvas run --slug <slug>), then make the change on that version.`;
+  process.stderr.write(`${JSON.stringify({ ok: false, error: { code: "version_not_found", message } }, null, 2)}
+`);
+  process.exit(2);
+}
+var OPERATOR = "Operator only, agents never need it.";
+var runCommand = defineCommand({
+  meta: {
+    name: "run",
+    description: "Validate and execute a canvas. Pass the canvas file, or `--slug <slug>` to run a creative by name: its canvas in this workspace, or, when this workspace does not have it (a fresh workspace, another chat's creative), its files restored from its latest recorded run first. A run that was interrupted resumes; a finished one re-renders from the cache."
+  },
+  args: {
+    file: { type: "positional", required: false, description: "Path to canvas JSON (or use --slug)" },
+    slug: {
+      type: "string",
+      description: "Run the creative src/creatives/<slug>/ by name instead of passing its file. Restores its files from run history when they are not in this workspace; local files are never overwritten unless you pass --force-remote."
+    },
+    series: {
+      type: "string",
+      description: "Render every ad of the series this lead ad leads, all at once (`baker creatives make <idea> --series <lead>` made them): each is the lead's ready version with its own words, reviewed and corrected on its own. An ad already ready from the lead's current version is not rendered again. Start here for several messages in one style: baker canvas run --series spring-offer"
+    },
+    "force-remote": {
+      type: "boolean",
+      default: false,
+      description: "With --slug: restore the recorded files even over local ones, replacing those that differ"
+    },
+    until: {
+      type: "string",
+      description: "Stop before the expensive half and leave the run resumable. `frames` settles the pictures and stops on the doorstep of the clips, so the look can be checked for the price of a few images instead of a whole ad. Continue with `baker canvas run <file> --run-id <the same id>` \u2014 everything already done is cached and is not paid for twice."
+    },
+    brief: {
+      type: "string",
+      description: "What the person asked for, IN THEIR OWN WORDS \u2014 paste their message, do not summarise it. The review compares the finished video against this and reports what they asked for that is missing or contradicted. Without it the review can only say whether the video is well made, not whether it is the one they wanted: every other check grades the render against the spec, and a spec that misread the request agrees with itself."
+    },
+    "run-id": { type: "string", description: "Override run id (also resumes that run, re-attaching its in-flight jobs)" },
+    fix: {
+      type: "string",
+      description: `Static ad only: correct a finished version instead of rendering a new one. One render takes that version as its first reference and changes only what you say here ("the CTA sits in the Stories band: move it up", "'Analitica' is missing its accent"), keeping the picture, layout and every other word. It is added on top of that version: its options, pick and earlier corrections are kept as they were made (free), the edit after them. Every size is made again from it (each other size re-laid out from it, one request each) and the review follows as usual. The version is the creative's last render, or --from <run_id>.`
+    },
+    from: {
+      type: "string",
+      description: "With --fix, --use-variant or a --regenerate of sizes only: the run id of the version (default: the one the creative shows, its last render here, or in a new chat the version chosen, else its newest)"
+    },
+    "use-variant": {
+      type: "string",
+      description: "Static ad only: the person asked in the chat for another of a version's variants over the judge's pick. Give its sha256 (the picture's, never the option's number): every size is made again from that picture, the judge's pick replaced. The only requests re-lay out each other size from that picture (one per size). The version is --from <run_id>, else the creative's last render."
+    },
+    autofix: {
+      type: "boolean",
+      default: true,
+      description: `Static ad: when the review finds a blocking defect, the run corrects it itself before it reports (up to ${AUTO_FIX_ROUNDS} more renders: the chosen picture fixed, or only the size at fault laid out again). --no-autofix reports after the first render.`
+    },
+    "skip-viewer-check": {
+      type: "boolean",
+      default: false,
+      description: "Static ad only: render without the viewer check (see `baker canvas viewer-check`). Only when the person has heard what the viewer missed and asked for this copy as it is."
+    },
+    fresh: {
+      type: "boolean",
+      default: false,
+      description: "Ignore any interrupted-run marker and start a new run id instead of resuming"
+    },
+    "cache-policy": { type: "string", description: "read_write | bypass | read_only" },
+    regenerate: {
+      type: "string",
+      description: "Comma-separated node ids or roles to force fresh THIS run (e.g. --regenerate pick,adapt; on a static ad --regenerate static_variants, or its id gen, renders the variants again; on one cut from one picture --regenerate format_9x16 sets the 9:16's words again on the picture the last version shows, its --fix correction or chosen variant included; on one laid out again for each size --regenerate adapt_9x16 lays out the 9:16 again from that picture, and --regenerate static_adapt_format every re-laid-out size), bypassing the content cache for just those nodes + everything downstream. For a persistent re-render, bump a node's `regenerate` field in the canvas JSON instead."
+    },
+    concurrency: {
+      type: "string",
+      description: "Max nodes running at once (default 8; env BAKER_CANVAS_CONCURRENCY)"
+    },
+    parallel: {
+      type: "string",
+      description: "Alias for --concurrency: independent clips (and every other same-layer node) already fan out in parallel up to this bound"
+    },
+    // citty consumes any `--no-<flag>` as a negation of `<flag>`, so the
+    // opt-out spelling `--no-record` requires the flag to be named `record`
+    // (a literal "no-record" arg would never receive a value).
+    record: {
+      type: "boolean",
+      default: true,
+      description: "Post the durable run-history record to Baker (disable with --no-record)"
+    },
+    "cache-dir": { type: "string", description: `${OPERATOR} Cache root (default <workspace root>/canvas/.cache)` },
+    "outputs-dir": { type: "string", description: `${OPERATOR} Per-run outputs root (default <workspace root>/canvas)` },
+    "keep-runs": {
+      type: "string",
+      description: `${OPERATOR} After the run, prune old r_* run dirs, keeping the N newest (off by default)`
+    },
+    "remote-cache": {
+      type: "string",
+      description: `${OPERATOR} on | off: company-scoped remote cache + durable asset persistence (default on; env BAKER_CANVAS_REMOTE_CACHE)`
+    }
+  },
+  async run({ args }) {
+    if (args.series) {
+      await executeSeriesRun(String(args.series));
+      return;
+    }
+    await executeCanvasRun({
+      file: args.file ? String(args.file) : void 0,
+      slug: args.slug ? String(args.slug) : void 0,
+      forceRemote: args["force-remote"] === true,
+      cacheDir: args["cache-dir"] ? String(args["cache-dir"]) : void 0,
+      outputsDir: args["outputs-dir"] ? String(args["outputs-dir"]) : void 0,
+      runId: args["run-id"] ? String(args["run-id"]) : void 0,
+      fresh: args.fresh === true,
+      fix: args.fix ? String(args.fix) : void 0,
+      from: args.from ? String(args.from) : void 0,
+      useVariant: args["use-variant"] ? String(args["use-variant"]) : void 0,
+      skipViewerCheck: args["skip-viewer-check"] === true,
+      autoFix: args.autofix !== false,
+      brief: args.brief ? String(args.brief) : void 0,
+      until: args.until ? String(args.until) : void 0,
+      cachePolicy: args["cache-policy"] ? String(args["cache-policy"]) : void 0,
+      regenerate: args.regenerate !== void 0 ? String(args.regenerate) : void 0,
+      // --concurrency wins; --parallel is the discoverable alias for the same bound.
+      concurrency: (args.concurrency ?? args.parallel) !== void 0 ? String(args.concurrency ?? args.parallel) : void 0,
+      keepRuns: args["keep-runs"] !== void 0 ? Number(args["keep-runs"]) : void 0,
+      remoteCache: args["remote-cache"] !== void 0 ? String(args["remote-cache"]) !== "off" : void 0,
+      record: args.record !== false
+    });
+  }
+});
+function stopBeforeKinds(until) {
+  if (until?.trim() === "frames") return /* @__PURE__ */ new Set(["video_generate"]);
+  return null;
+}
+function failPreflight(code, message, fix) {
+  process.stderr.write(`${JSON.stringify({ ok: false, error: { code, message, ...fix ? { fix } : {} } }, null, 2)}
+`);
+  process.exit(2);
+}
+async function canvasFileFor(opts) {
+  if (opts.file) return { canvasPath: path5.resolve(opts.file) };
+  if (!opts.slug) failPreflight("missing_canvas", "Pass the canvas file, or --slug <slug> to run a creative by name.");
+  const cwd = process.cwd();
+  try {
+    return await canvasForSlug(opts.slug, {
+      workspaceRoot: findWorkspaceRoot(cwd) ?? cwd,
+      forceRemote: opts.forceRemote === true,
+      client: buildBackendClient,
+      log: (line) => process.stdout.write(`${line}
+`)
+    });
+  } catch (e) {
+    if (e instanceof SlugRestoreError) failPreflight(e.code, e.message, e.fix);
+    throw e;
+  }
+}
+async function executeSeriesRun(lead) {
+  const root = findWorkspaceRoot(process.cwd()) ?? process.cwd();
+  const members = await seriesMembers(root, lead);
+  if (members.length === 0) {
+    failPreflight(
+      "no_series_ads",
+      `No ad names "${lead}" as its lead (\`series: ${lead}\` in its _definition.md).`,
+      `Make each other message as an ad of the series first (baker creatives make <idea> --series ${lead}), or each language (baker creatives translate --slug ${lead} --to es-MX,de).`
+    );
+  }
+  const canvasRoot = path5.join(root, "canvas");
+  process.stdout.write(`[series] rendering ${members.length} ads of ${lead} at once: ${members.join(", ")}
+`);
+  const results = await runSeries(members, {
+    plan: async (slug) => {
+      const made = await writeSeriesMemberCanvas(root, slug, { takeLeadDesign: true });
+      if (made === null) return { refused: { code: "not_in_series", message: `${slug} is no ad of this series.`, fix: "" } };
+      if ("refused" in made) return made;
+      if (made.designFromLead) process.stdout.write(`[series] ${slug} takes the lead's design, its own words kept
+`);
+      try {
+        const prepared = await prepareCanvas(made.canvasPath, { write: false });
+        const state = await readRenderState(canvasRoot, slug);
+        const fresh = state.rendered?.sourceSha === prepared.sourceSha && (state.blocking ?? []).length === 0;
+        return fresh ? { run: false, runId: state.rendered?.runId } : { run: true };
+      } catch (e) {
+        const envelope = e instanceof CanvasPrepareError ? e.toEnvelope().error : null;
+        return {
+          refused: {
+            code: String(envelope?.code ?? "prepare_failed"),
+            message: String(envelope?.message ?? (e instanceof Error ? e.message : e)),
+            fix: String(envelope?.fix ?? "")
+          }
+        };
+      }
+    },
+    run: (slug) => runBaker(["canvas", "run", "--slug", slug])
+  });
+  process.stdout.write(`${JSON.stringify(seriesEnvelope(lead, results), null, 2)}
+`);
+}
+async function refreshSeriesAd(opts) {
+  const slug = opts.slug ?? (opts.file ? creativeSlugFromCanvasPath(path5.resolve(opts.file)) : null);
+  if (!slug) return false;
+  const root = findWorkspaceRoot(opts.file ? path5.dirname(path5.resolve(opts.file)) : process.cwd());
+  if (!root) return false;
+  const made = await writeSeriesMemberCanvas(root, slug);
+  if (made === null) return false;
+  if ("refused" in made) failPreflight(made.refused.code, made.refused.message, made.refused.fix);
+  process.stdout.write(
+    `[series] ${slug} is the lead ${made.lead}'s version ${made.leadRunId} with this ad's words${made.written ? " (canvas written)" : ""}
+`
+  );
+  return made.newLeadVersion;
+}
+async function editScopeNotes(input) {
+  const { opts, shown } = input;
+  const plain = (opts.autoFixRound ?? 0) === 0 && opts.fix === void 0 && opts.regenerate === void 0 && opts.useVariant === void 0 && opts.from === void 0;
+  if (!plain || !shown.rendered) return [];
+  const notes = [];
+  const changed = !input.native && input.asEdit === null && shown.prompt ? frameChanges(shown.prompt, input.promptNow) : [];
+  if (changed.length > 0) {
+    notes.push(
+      `[scope] this run changes ${changed.join(", ")} since the version shown: new pictures are made. If the person asked only for words, colours or one element, put the rest back (or use --fix).`
+    );
+  }
+  const local = { record: async () => null, graph: async () => null };
+  const previous = await versionRun(input.canvasRoot, shown.rendered.runId, local);
+  for (const clip of previous ? retakenTalkingScenes(previous.canvas, input.canvas) : []) {
+    notes.push(
+      `[voice] the take ${clip} is said again by the video model: it may not sound like the other takes; listen to it before you show it.`
+    );
+  }
+  return notes;
+}
+var canvasHeld = false;
+var RECORDED_RULE_IDS = 100;
+async function executeCanvasRun(opts) {
+  const startedAt = opts.autoFixStartedAt ?? Date.now();
+  const newAsk = (opts.autoFixRound ?? 0) === 0 ? await refreshSeriesAd(opts) : false;
+  const { canvasPath: filePath, adoptRunId } = await canvasFileFor(opts);
+  const canvasRoot = canvasOutputsRoot(filePath);
+  const creativeSlug = creativeSlugFromCanvasPath(filePath) ?? void 0;
+  const held = creativeSlug ? await heldRules(path5.dirname(filePath)) : { rules: [] };
+  if (creativeSlug) await clearLegacyDirtyMarker(canvasRoot, creativeSlug);
+  const turnId = optionalTurnId();
+  const turnCache = opts.cacheDir ?? path5.join(canvasRoot, ".cache");
+  const refuseTurnRender = async (correction) => {
+    if (!creativeSlug || (opts.autoFixRound ?? 0) > 0) return;
+    const onDisk = await readFile4(filePath, "utf8").then((text) => JSON.parse(text)).catch(() => null);
+    const shape = sizeShapeOf(onDisk);
+    const refusal = turnRenderRefusal(await readTurnRenders(turnCache), turnId, creativeSlug, { correction, shape });
+    if (!refusal) return;
+    process.stderr.write(
+      `${JSON.stringify({ ok: false, error: { code: refusal.code, message: refusal.message, fix: refusal.fix } }, null, 2)}
+`
+    );
+    process.exit(2);
+  };
+  const shown = creativeSlug ? await shownVersion(canvasRoot, creativeSlug) : {};
+  const promptOnDisk = await readFile4(path5.join(path5.dirname(filePath), "prompt.json"), "utf8").then((text) => JSON.parse(text)).catch(() => null);
+  await refuseTurnRender(mayBeCorrection(opts, shown.prompt, promptOnDisk));
+  const ideaHeld = creativeSlug && (opts.autoFixRound ?? 0) === 0 ? (await shownBaseline({
+    canvasRoot,
+    slug: creativeSlug,
+    creativeDir: path5.dirname(filePath),
+    turnId,
+    shown,
+    record: true
+  })).baseline : void 0;
+  const citing = [];
+  await wireProofBadges(
+    path5.join(path5.dirname(filePath), "prompt.json"),
+    fetchBrandLogo,
+    (line) => process.stderr.write(`${line}
+`),
+    jevCitationJudge((u) => citing.push(u))
+  );
+  await holdUnbilledSpend(turnCache, citing);
+  if ((opts.autoFixRound ?? 0) === 0) {
+    const reading = [];
+    await wireNamedPeople(
+      path5.join(path5.dirname(filePath), "prompt.json"),
+      avatarOfNamedPerson,
+      (line) => process.stderr.write(`${line}
+`),
+      peopleReader(turnCache, (u) => reading.push(u))
+    );
+    await holdUnbilledSpend(turnCache, reading);
+  }
+  let prepared;
+  try {
+    prepared = await prepareCanvas(filePath, {
+      requireSuppliedAssets: true,
+      gate: true,
+      log: (line) => process.stderr.write(`${line}
+`),
+      ...ideaHeld ? { baseline: ideaHeld } : {},
+      firstRender: creativeSlug !== void 0 && !shown.rendered && (opts.autoFixRound ?? 0) === 0
+    });
+  } catch (e) {
+    if (creativeSlug) await recordRenderAttempt(canvasRoot, creativeSlug, await computeSourceSha(filePath));
+    exitOnPrepareError(e);
+  }
+  if (creativeSlug) await recordRenderAttempt(canvasRoot, creativeSlug, prepared.sourceSha);
+  if (prepared.rewrites.length > 0) {
+    process.stderr.write(
+      `[canvas] rewrote ${prepared.rewrites.length} asset reference(s) in the canvas file so it says what runs (absolute paths \u2192 canvas-relative, a URL in an ingest path \u2192 source "url", a path into canvas/ \u2192 the durable URL of the same bytes):
+${describeRewrites(prepared.rewrites)}
+`
+    );
+  }
+  let parsed = prepared.canvas;
+  const promptNow = isStaticAdCanvas(parsed) ? await readStaticPromptJson(parsed).catch(() => null) : null;
+  const native = isNativeCanvas(parsed);
+  if (native && (opts.fix !== void 0 || opts.useVariant !== void 0)) {
+    process.stderr.write(
+      `${JSON.stringify(
+        {
+          ok: false,
+          error: {
+            code: "nothing_to_fix",
+            message: "This ad is a native screen drawn exactly from prompt.json, not a painted picture: there is nothing to correct by --fix or to pick by --use-variant.",
+            fix: "Edit prompt.json's `native` block (its words, people, photos, frame) and run again: nothing renders but a photo whose description changed. A photo with a defect: `--regenerate photo_<n>`."
+          }
+        },
+        null,
+        2
+      )}
+`
+    );
+    process.exit(2);
+  }
+  const asEdit = opts.fix === void 0 && opts.useVariant === void 0 && opts.regenerate === void 0 && opts.from === void 0 && shown.rendered ? plainRunEdit(parsed, shown.prompt, promptNow) : null;
+  const editOf = asEdit && shown.rendered ? await previousAdImage(canvasRoot, shown.rendered.runId, void 0, rolesById(parsed)) : null;
+  const editInstruction = editOf ? asEdit : null;
+  if (editInstruction) {
+    process.stdout.write(`[edit] only the words or colours changed: editing the version of run ${shown.rendered?.runId}: ${editInstruction}
+`);
+  }
+  const runNotes = await editScopeNotes({
+    opts,
+    asEdit,
+    native,
+    shown,
+    promptNow,
+    canvas: parsed,
+    canvasRoot
+  });
+  for (const note of runNotes) process.stderr.write(`${note}
+`);
+  const fixInstruction = opts.fix ?? editInstruction ?? void 0;
+  const requested = opts.regenerate?.split(",").map((id) => id.trim()) ?? [];
+  await refuseTurnRender(
+    fixInstruction !== void 0 || requested.length > 0 && isStaticAdCanvas(parsed) && relaysSizesOnly(parsed, regenerateTargets(parsed, requested).ids)
+  );
+  const fromRun = opts.from ?? shown.rendered?.runId;
+  const memory = fixMemoryOf(shown, opts.from);
+  if (opts.fix !== void 0 && repeatsFailedFix(memory.lastFix, opts.fix)) {
+    const left = memory.lastFix?.blocking ?? [];
+    process.stderr.write(
+      `${JSON.stringify(
+        {
+          ok: false,
+          error: {
+            code: "no_progress",
+            message: `Not rendered: this exact fix already ran and left ${left.length === 1 ? "this" : "these"} in place: ${left.join(" | ")}`,
+            fix: `Do not ask for the same correction again. Change the approach: edit prompt.json so the problem cannot happen (shorter words, a line moved or dropped, a different position), make just the size at fault again (${oneSizeFix(sizeShapeOf(parsed))}), or ask for new options with \`--regenerate static_variants\`.`
+          }
+        },
+        null,
+        2
+      )}
+`
+    );
+    process.exit(2);
+  }
+  let grown = null;
+  const growOn = async (from, growth) => {
+    const version = await versionRun(canvasRoot, from);
+    return version ? growFromVersion(parsed, version, growth) : null;
+  };
+  if (fixInstruction !== void 0) {
+    const instruction = fixInstruction.trim();
+    const from = opts.from ?? shown.rendered?.runId;
+    const previous = editOf ?? (from ? await previousAdImage(canvasRoot, from, void 0, rolesById(parsed)) : null);
+    if (!instruction || !isStaticAdCanvas(parsed) || !from || !previous) {
+      const message = !instruction ? "--fix needs the correction in words." : !isStaticAdCanvas(parsed) ? "--fix corrects a static ad; this canvas is not one." : !from ? "--fix needs a version to correct: this creative has no recorded render here. Pass --from <run_id>." : `--fix could not find the finished ad of run ${from}: pass --from with a run that rendered one.`;
+      process.stderr.write(`${JSON.stringify({ ok: false, error: { code: "nothing_to_fix", message } }, null, 2)}
+`);
+      process.exit(2);
+    }
+    const rejected = creativeSlug ? await readCaseFile(creativeSlug) : [];
+    const { rules } = held;
+    grown = await growOn(from, { kind: "edit", instruction, promptJson: promptNow, rejected, rules });
+    if (!grown && isPlateCanvas(parsed)) refusePlateVersion(from);
+    parsed = grown ? grown.canvas : fixStaticAd(parsed, { instruction, previous, promptJson: promptNow, rejected, rules });
+    const labels = finalOutputLabelsFromCanvas(parsed);
+    const delivered = await previousDelivered(canvasRoot, from, labels?.nodeId ?? "final", labels?.labels ?? [], {
+      prefer: "url"
+    });
+    const last = Object.fromEntries(
+      nodesWithRole(parsed, STATIC_ADAPT_FORMAT_ROLE).flatMap((n) => {
+        const path6 = delivered.find((d) => d.format === formatOfAdaptId(n.id))?.path;
+        return path6 ? [[n.id, path6]] : [];
+      })
+    );
+    parsed = withSizesFollowingFix(parsed, {
+      last,
+      change: instruction.replace(/^Change only this: /, ""),
+      ...opts.relayAlso ? { also: opts.relayAlso } : {}
+    });
+    const kept = delivered.filter((d) => opts.keepSizes?.includes(d.format));
+    if (kept.length > 0) {
+      parsed = withDeliveredSizes(parsed, Object.fromEntries(kept.map((d) => [d.format, d.path])));
+      process.stdout.write(`[fix] keeping ${kept.map((d) => d.format).join(", ")} as it was: nothing blocking on it
+`);
+    }
+    if (!editInstruction) process.stdout.write(`[fix] correcting the version of run ${from}: ${instruction}
+`);
+  }
+  if (opts.useVariant !== void 0 && opts.fix === void 0) {
+    const sha = opts.useVariant.trim();
+    const from = opts.from ?? shown.rendered?.runId;
+    grown = from && isStaticAdCanvas(parsed) ? await growOn(from, { kind: "variant", sha256: sha }) : null;
+    const url = from && !grown && isStaticAdCanvas(parsed) ? await variantImage(canvasRoot, from, sha, void 0, rolesById(parsed)) : null;
+    if (!from || !grown && !url) {
+      const message = !isStaticAdCanvas(parsed) ? "--use-variant re-makes the sizes of a static ad; this canvas is not one." : !from ? "--use-variant needs the version the variant belongs to: this creative has no recorded render here. Pass --from <run_id>." : `--use-variant found no variant ${sha} in run ${from}: pass the sha256 \`baker creatives feedback --slug <slug>\` prints, and --from with that version's run.`;
+      process.stderr.write(`${JSON.stringify({ ok: false, error: { code: "no_such_variant", message } }, null, 2)}
+`);
+      process.exit(2);
+    }
+    if (!grown && isPlateCanvas(parsed)) refusePlateVersion(from);
+    if (grown) parsed = grown.canvas;
+    else if (url) parsed = rederiveFromVariant(parsed, { url });
+    process.stdout.write(`[variant] making every size of run ${from} again from the chosen variant ${sha.slice(0, 12)}
+`);
+  }
+  let relaidFrom;
+  if (opts.regenerate !== void 0 && opts.fix === void 0 && opts.useVariant === void 0 && isStaticAdCanvas(parsed)) {
+    const requested2 = opts.regenerate.split(",").map((id) => id.trim());
+    const from = opts.from ?? shown.rendered?.runId;
+    const sizesOnly = relaysSizesOnly(parsed, regenerateTargets(parsed, requested2).ids);
+    grown = from && sizesOnly ? await growOn(from, { kind: "keep" }) : null;
+    const url = from && sizesOnly && !grown ? await correctedPicture(canvasRoot, from) ?? (shown.picture?.redrawn && shown.picture.runId === from ? await previousAdImage(canvasRoot, from, void 0, rolesById(parsed)) : null) : null;
+    if (from && grown) {
+      parsed = grown.canvas;
+      relaidFrom = from;
+      process.stdout.write(`[regenerate] re-laying out from the picture run ${from} shows, kept as it was made
+`);
+    } else if (from && url && !isPlateCanvas(parsed)) {
+      parsed = rederiveFromVariant(parsed, { url });
+      relaidFrom = from;
+      process.stdout.write(`[regenerate] re-laying out from the picture run ${from} shows (its correction or the person's choice)
+`);
+    }
+  }
+  const plain = fixInstruction === void 0 && opts.useVariant === void 0 && opts.regenerate === void 0 && (opts.extendSizes?.length ?? 0) === 0;
+  if (plain && fromRun && !native && isStaticAdCanvas(parsed) && !seriesOf(parsed)) {
+    const version = await versionRun(canvasRoot, fromRun);
+    const same = version !== null && makesSameVariants(parsed, version, await ingestedNow(variantFiles(parsed), path5.dirname(filePath)));
+    const growth = version ? plainRunGrowth(parsed, version, {
+      sameVariants: same,
+      frameChanged: shown.prompt !== void 0 && frameChanges(shown.prompt, promptNow).length > 0,
+      wordsChanged: shown.prompt !== void 0 && specEditInstruction(shown.prompt, promptNow) !== null,
+      pictureChanged: shown.prompt !== void 0 && pictureEdit(shown.prompt, promptNow) !== null
+    }) : null;
+    grown = version && growth ? growFromVersion(parsed, version, growth) : null;
+    if (grown) {
+      parsed = grown.canvas;
+      relaidFrom = fromRun;
+      process.stdout.write(`[version] nothing the variants are made from changed: keeping the picture of run ${fromRun}
+`);
+    }
+  }
+  if (grown) {
+    const kept = Object.keys(grown.pinned);
+    process.stdout.write(`[version] built on top of the version before: ${kept.join(", ")} kept as they were made (free)
+`);
+  }
+  const canvasText = prepared.text;
+  let regenerate;
+  if (opts.regenerate !== void 0) {
+    const requested2 = opts.regenerate.split(",").map((id) => id.trim()).filter((id) => id.length > 0);
+    const known = new Set(canvasNodeIds(parsed));
+    const { ids: resolved, unknown } = regenerateTargets(parsed, requested2);
+    if (unknown.length > 0) {
+      process.stderr.write(
+        `${JSON.stringify(
+          {
+            ok: false,
+            error: {
+              code: "unknown_regenerate_node",
+              message: `--regenerate names node id(s) not in this canvas: ${unknown.join(", ")}. Known ids: ${[...known].join(", ")}`
+            }
+          },
+          null,
+          2
+        )}
+`
+      );
+      process.exit(2);
+    }
+    if (resolved.length > 0) {
+      regenerate = new Set(resolved);
+      process.stdout.write(`[regenerate] forcing fresh this run: ${[...regenerate].join(", ")} (+ downstream)
+`);
+      if (opts.relayNote) parsed = withRelayNote(parsed, resolved, opts.relayNote);
+      const editFrom = opts.from ?? shown.rendered?.runId;
+      if (opts.relayEdits && editFrom) {
+        const labels = finalOutputLabelsFromCanvas(parsed);
+        const delivered = await previousDelivered(canvasRoot, editFrom, labels?.nodeId ?? "final", labels?.labels ?? [], {
+          prefer: "url"
+        });
+        for (const [id, instruction] of Object.entries(opts.relayEdits)) {
+          if (!resolved.includes(id)) continue;
+          const last = delivered.find((d) => d.format === formatOfSizeNode(parsed, id))?.path;
+          parsed = last ? withRelayEdit(parsed, id, { previous: last, instruction, asked: opts.relayAsked?.[id] ?? [] }) : withRelayNote(parsed, [id], instruction);
+        }
+        const relaid = resolved.flatMap((id) => formatOfSizeNode(parsed, id) ?? []);
+        parsed = withDeliveredSizes(
+          parsed,
+          Object.fromEntries(delivered.filter((d) => !relaid.includes(d.format)).map((d) => [d.format, d.path]))
+        );
+      }
+    }
+  }
+  if (opts.extendSizes && opts.extendSizes.length > 0 && isStaticAdCanvas(parsed)) {
+    const from = opts.from ?? shown.rendered?.runId;
+    if (opts.extendOnly && from) {
+      const labels = finalOutputLabelsFromCanvas(parsed);
+      const delivered = await previousDelivered(canvasRoot, from, labels?.nodeId ?? "final", labels?.labels ?? [], {
+        prefer: "url"
+      });
+      parsed = withDeliveredSizes(parsed, Object.fromEntries(delivered.map((d) => [d.format, d.path])));
+    }
+    parsed = withExtendedSizes(parsed, opts.extendSizes);
+    process.stdout.write(`[extend] placing ${opts.extendSizes.join(", ")} clear of what covers or cuts it, its margins painted
+`);
+  }
+  const cacheDir = opts.cacheDir ?? path5.join(canvasRoot, ".cache");
+  const engine = createEngineFromEnv({
+    cacheDir,
+    outputsDir: opts.outputsDir ?? canvasRoot,
+    log: (line) => process.stdout.write(`${line}
+`),
+    remoteCache: opts.remoteCache
+  });
+  const validation = await engine.validateDeep(parsed);
+  if (!validation.ok) {
+    process.stderr.write(
+      `${JSON.stringify({ ok: false, error: { code: "validation", issues: validation.issues } }, null, 2)}
+`
+    );
+    process.exit(2);
+  }
+  const advisories = (validation.warnings ?? []).filter((w) => w.code !== "ORPHAN_NODE");
+  for (const w of [...advisories, ...await outputRatioWarningsFor(parsed, filePath)]) {
+    process.stdout.write(`[warn] ${w.code}: ${w.message}
+`);
+  }
+  const canvasSha = sha256Hex(Buffer.from(canvasText));
+  const sourceSha = prepared.sourceSha;
+  const client = opts.record === false ? null : buildBackendClient();
+  const outputsDir = opts.outputsDir ? path5.resolve(opts.outputsDir) : canvasRoot;
+  const { runId, resumed, source, sameSource, concurrentRunId, rendering } = await resolveRunId({
+    explicitRunId: opts.runId,
+    adoptedRunId: adoptRunId,
+    fresh: opts.fresh === true || fixInstruction !== void 0 || opts.useVariant !== void 0 || relaidFrom !== void 0,
+    outputsDir,
+    canvasPath: filePath,
+    sourceSha,
+    remote: client && creativeSlug && sourceSha ? { creativeSlug, sourceSha, getActiveRun: (slug, sha) => client.getActiveRun(slug, sha) } : void 0
+  });
+  const holder = rendering ?? await canvasBusyElsewhere(outputsDir, filePath);
+  if (holder) {
+    process.stderr.write(
+      `${JSON.stringify(
+        {
+          ok: false,
+          error: {
+            code: "CONFLICT",
+            message: `This canvas is already rendering in another process (run ${holder.runId}, pid ${holder.pid}).`,
+            fix: "Wait for that render to finish and use its result instead of starting a second one: two renders of one canvas share a run and overwrite each other. If you started it in the background, read its output when it completes."
+          }
+        },
+        null,
+        2
+      )}
+`
+    );
+    process.exit(2);
+  }
+  const viewerUsage = [];
+  const viewerCheck = creativeSlug && isStaticAdCanvas(parsed) ? await viewerCheckBeforeRender({
+    creativeDir: path5.dirname(filePath),
+    cacheDir,
+    slug: creativeSlug,
+    skip: viewerCheckSkip({
+      fix: opts.fix !== void 0,
+      useVariant: opts.useVariant !== void 0,
+      relaid: relaidFrom !== void 0,
+      autoFixRound: opts.autoFixRound ?? 0,
+      resumed: resumed && sameSource === true,
+      asked: opts.skipViewerCheck === true
+    }),
+    spent: viewerChecksSpent(await readTurnRenders(turnCache), turnId, creativeSlug),
+    lookups: liveViewerLookups(path5.dirname(canvasRoot)),
+    model: VIEWER_CHECK_MODEL,
+    ask: gatewayViewerModel(VIEWER_CHECK_MODEL, (usage) => viewerUsage.push(usage)),
+    judge: jevReadJudge((usage) => viewerUsage.push(usage))
+  }) : null;
+  for (const line of viewerCheck?.lines ?? []) process.stdout.write(`${line}
+`);
+  await holdUnbilledSpend(cacheDir, viewerUsage);
+  if (viewerCheck?.failure) {
+    if (creativeSlug && turnId && viewerCheck.failure.error.code === "viewer_check_failed") {
+      await updateTurnRenders(turnCache, (ledger) => recordViewerFail(ledger, turnId, creativeSlug));
+    }
+    process.stderr.write(`${JSON.stringify(viewerCheck.failure, null, 2)}
+`);
+    process.exit(2);
+  }
+  if (resumed) {
+    process.stdout.write(
+      `[resume] continuing interrupted run ${runId}${source === "remote" ? " (adopted from run history)" : ""} \u2014 in-flight jobs re-attach, cached nodes skip
+`
+    );
+  }
+  if (concurrentRunId) {
+    process.stderr.write(
+      `[concurrent] this canvas appears to be running elsewhere right now (run ${concurrentRunId}) \u2014 starting a separate run; pass --run-id ${concurrentRunId} to adopt it instead
+`
+    );
+  }
+  const abort = new AbortController();
+  let abortedBy = null;
+  for (const signalName of ["SIGINT", "SIGTERM"]) {
+    process.once(signalName, () => {
+      abortedBy = signalName;
+      process.stderr.write(`[interrupt] ${signalName} received \u2014 flushing a resumable snapshot (repeat to force-quit)
+`);
+      abort.abort(new Error(`aborted by ${signalName}`));
+    });
+  }
+  const inFlight = await markRunInFlight(outputsDir, filePath, runId, sourceSha);
+  if (!canvasHeld) {
+    const held2 = await markCanvasBusy(outputsDir, filePath, runId);
+    canvasHeld = true;
+    process.once("exit", held2.release);
+  }
+  const clearMarker = () => {
+    inFlight.stop();
+    return clearRunMarker(outputsDir, filePath, inFlight.token);
+  };
+  const snapshot = client && creativeSlug ? await uploadRunSnapshot(client, {
+    canvasPath: filePath,
+    raw: canvasText,
+    creativeSlug,
+    parsed,
+    previous: (await readRenderState(canvasRoot, creativeSlug)).snapshot
+  }) : null;
+  if (snapshot && creativeSlug) await recordSnapshot(canvasRoot, creativeSlug, snapshot);
+  const graphUrl = client && creativeSlug && isStaticAdCanvas(parsed) ? await uploadRunGraph(client, parsed) : null;
+  const recordMeta = {
+    creativeSlug,
+    canvasPath: path5.relative(path5.dirname(canvasRoot), filePath) || void 0,
+    canvasSha,
+    // The fingerprint the dashboard compares against the current source to flag
+    // "edited since last render": the same `computeSourceSha` the edit-sync posts,
+    // taken after the preflight wrote the projected graph, so the two are comparable.
+    sourceSha,
+    chatId: optionalChatId(),
+    canvasSnapshotUrl: snapshot?.url,
+    ...graphUrl ? { graphUrl } : {},
+    ...newAsk ? { newAsk: true } : {},
+    ...creativeSlug ? { rules: { digest: rulesDigest(held.rules), ids: held.rules.slice(0, RECORDED_RULE_IDS).map((r) => r.id) } } : {}
+  };
+  if (client) {
+    const registered = await postInitialRunRecord(client, buildInitialRunRecord(runId, recordMeta));
+    if (!registered) {
+      process.stderr.write(
+        "[warn] run start not registered \u2014 this run stays invisible to the dashboard until a later progress post lands, and cannot be resumed from another workspace\n"
+      );
+    }
+  }
+  const leadRun = seriesOf(parsed)?.run_id;
+  if (creativeSlug && leadRun) await recordSeriesLeadRun(canvasRoot, creativeSlug, leadRun);
+  const record = client ? (payload) => client.recordRun(payload) : null;
+  const finalLabels = finalOutputLabelsFromCanvas(parsed) ?? void 0;
+  const progress = record ? new RunProgressTracker(runId, recordMeta, finalLabels) : null;
+  const poster = record ? new RunRecordPoster(record) : null;
+  const flushBilled = async (p, payload) => {
+    const failure = await sendBillingSpend(cacheDir, payload.reviewUsage ?? [], () => p.flush(payload));
+    if (failure !== null) process.stderr.write(`[warn] run record not persisted (${failure})
+`);
+  };
+  if (progress && poster) {
+    poster.startKeepalive(() => progress.hasPlan() ? progress.snapshot() : null);
+  }
+  const frameUrls = [];
+  let next = null;
+  const madeHere = grown ? madeThisRun({ canvas: parsed, pinned: grown.pinned }) : parsed;
+  const readerSpend = holdWhenSettled(cacheDir, (run, outputs) => prefilterSpend(madeHere, { [run.node_id]: outputs }, [run]));
+  const isFrameNode = (id) => parsed.nodes?.find((n) => n.id === id)?.type === "image_generate";
+  try {
+    const policy = opts.cachePolicy ?? "read_write";
+    const result = await engine.run(parsed, {
+      run_id: runId,
+      signal: abort.signal,
+      cache_policy: policy,
+      ...stopBeforeKinds(opts.until) ? { stop_before_kinds: stopBeforeKinds(opts.until) } : {},
+      concurrency: resolveConcurrency(opts.concurrency, process.env.BAKER_CANVAS_CONCURRENCY),
+      regenerate,
+      ...grown ? { pinned: grown.pinned } : {},
+      // Always set, because the frame collector has to run whether or not this run is
+      // reporting progress to a backend — without it a checkpoint stops with nothing to
+      // show, which is the only thing a checkpoint is for.
+      onProgress: (event) => {
+        if (event.kind === "node_settled") readerSpend.settled(event.run, event.outputs);
+        if (event.kind === "node_settled" && isFrameNode(event.run.node_id)) {
+          for (const out of Object.values(event.outputs ?? {})) {
+            const url = out?.url;
+            if (url) frameUrls.push(url);
+          }
+        }
+        if (progress && poster) {
+          progress.apply(event);
+          if (progress.hasPlan()) poster.enqueue(progress.snapshot());
+        }
+      }
+    });
+    await clearMarker();
+    const beforeRunId = shown.rendered?.runId;
+    if (creativeSlug) {
+      const idea = await readIdeaAnchor(path5.dirname(filePath));
+      await recordRendered(canvasRoot, creativeSlug, sourceSha, result.run_id, {
+        ...promptNow ? { prompt: promptNow } : {},
+        ...idea ? { anchor: idea.anchor, idea: anchorLines(idea.view) } : {},
+        ...seriesOf(parsed)?.run_id ? { seriesLeadRun: seriesOf(parsed)?.run_id } : {},
+        picture: pictureRecord(result.run_id, {
+          chose: opts.useVariant !== void 0,
+          of: shown.picture,
+          from: fromRun,
+          keeps: fixInstruction !== void 0 || relaidFrom !== void 0,
+          redrawn: opts.autoFixKind === "regenerate"
+        })
+      });
+    }
+    const keepRuns = opts.keepRuns;
+    if (keepRuns !== void 0 && Number.isFinite(keepRuns)) {
+      await pruneOldRuns(outputsDir, keepRuns, result.run_id, (line) => process.stdout.write(`${line}
+`));
+    }
+    const reviewable = videoPathFromOutput(result.output);
+    await readerSpend.drained();
+    const reviewUsage = poster ? await takeUnbilledSpend(cacheDir) : [];
+    const videoRules = held.rules;
+    const review = reviewable ? await reviewRenderedVideo({
+      video: reviewable,
+      windows: await sceneWindowsBeside(filePath),
+      ...await reviewContextBeside(filePath),
+      rules: videoRules,
+      checkStills: (stills, labels) => reviewAgainstRules({ stills, formats: labels, rules: videoRules, onSpend: (usage) => reviewUsage.push(usage) }),
+      brief: opts.brief?.trim() || void 0,
+      onSpend: (usage) => reviewUsage.push(usage)
+    }) : null;
+    const brandKit = reviewable ? null : await readStaticBrandKit(await findBrandRoot(path5.dirname(filePath)) ?? process.cwd());
+    const runShape = {
+      fix: fixInstruction !== void 0,
+      useVariant: opts.useVariant !== void 0,
+      sizesOnly: relaidFrom !== void 0 || opts.extendOnly === true || regenerate !== void 0 && relaysSizesOnly(parsed, [...regenerate])
+    };
+    const staticReview = reviewable ? null : await reviewStaticRun({
+      parsed: madeHere,
+      output: result.output,
+      outputsByNode: result.outputs_by_node,
+      onSpend: (usage) => reviewUsage.push(usage),
+      viewer: viewerCheck?.viewer ?? null,
+      ...brandKit?.name ? { brandName: brandKit.name } : {},
+      ...brandKit?.lockup ? { lockup: brandKit.lockup } : {},
+      // Only a new picture is compared with the last one: an edit, a fix, a chosen option or a
+      // re-layout keeps it on purpose, and would read as "this retry changed nothing".
+      ...beforeRunId && beforeRunId !== result.run_id && rendersNewPicture(runShape) ? { previous: await previousDelivered(canvasRoot, beforeRunId, finalLabels?.nodeId ?? "final", finalLabels?.labels ?? []) } : {},
+      // A size this round did not touch keeps the last round's verdict: the review's second look at it is no defect of the round.
+      ...opts.settledReview && opts.from ? {
+        settled: {
+          review: opts.settledReview,
+          images: await previousDelivered(canvasRoot, opts.from, finalLabels?.nodeId ?? "final", finalLabels?.labels ?? [])
+        }
+      } : {}
+    });
+    const blockingNow = (staticReview?.review ?? []).filter((f) => f.severity === "blocking").map((f) => f.what);
+    const stillThere = fixInstruction !== void 0 && staticReview?.review ? persistingDefects(memory.blocking, staticReview.review) : [];
+    if (creativeSlug && staticReview) {
+      await recordReviewOutcome(canvasRoot, creativeSlug, {
+        blocking: blockingNow,
+        ...fixInstruction !== void 0 ? { lastFix: { instruction: fixInstruction.trim(), blocking: stillThere } } : {}
+      });
+    }
+    const costHint = staticReview ? runCostHint(result.stats, paidFor(runShape)) : null;
+    const corrected = opts.autoFixed ?? [];
+    const seriesRoot = creativeSlug && staticReview ? findWorkspaceRoot(path5.dirname(filePath)) : null;
+    const seriesHints = seriesRoot && creativeSlug ? seriesRunHints(creativeSlug, {
+      leads: await seriesLeadsAbove(seriesRoot, creativeSlug),
+      members: await seriesMembers(seriesRoot, creativeSlug)
+    }) : [];
+    const reviewHints = staticReview ? [
+      ...corrected.length > 0 ? [
+        `Corrected automatically before this result, ${corrected.length} more render${corrected.length === 1 ? "" : "s"}: ${corrected.join(" Then ")} What follows is the review of the corrected version.`
+      ] : [],
+      ...staticReview.hints,
+      ...costHint ? [costHint] : [],
+      ...seriesHints,
+      ...stillThere.length > 0 ? [
+        `The fix did not remove ${stillThere.length === 1 ? "this" : "these"}: ${stillThere.join(" | ")}. The same instruction will not run again; change the approach (edit prompt.json so it cannot happen, or make only that size again with \`--regenerate\` on its size node).`
+      ] : []
+    ] : reviewable ? review === null ? [RENDER_REVIEW_UNAVAILABLE] : review.length === 0 ? ["Reviewed the finished video frame by frame \u2014 nothing to report."] : [
+      `Reviewed the finished video and found ${review.length} thing${review.length === 1 ? "" : "s"} to fix. Show the user what is wrong before you show them the ad.`,
+      ...review.map((f) => `${f.severity === "blocking" ? "Must fix" : "Should fix"} \u2014 ${f.what}`),
+      ...review.some((f) => f.scene) ? [
+        `Anything about the mark or the closing card is a composition fix, not a re-render: both are drawn as HTML by the caption composition, so editing it and re-running re-renders only that pass \u2014 the clips are cached and no generation is paid for again. Fix them, then re-run: edit the \`show\` of the scene files named above \u2014 a shot with a person handling equipment is where limbs and objects go wrong, so widen it, move the hands out of frame, or drop the person from that beat. Re-running re-renders only the scenes you edited; everything else comes from the cache (this run: ${result.stats?.cached_nodes ?? 0} of ${result.stats?.total_nodes ?? 0} nodes were cached).`
+      ] : []
+    ] : [];
+    const hints = [...runNotes, ...reviewHints];
+    const findings = staticReview ? staticReview.review : review;
+    const ready = staticReview ? staticReview.verdict === "ready" || staticReview.verdict === "ready_with_notes" : review !== null && !review.some((f) => f.severity === "blocking");
+    const definitionStatus = ready && creativeSlug ? await advanceDefinitionStatus(path5.join(path5.dirname(filePath), "_definition.md"), "rendered") : null;
+    if (poster) {
+      await flushBilled(
+        poster,
+        // `review` is null only when nobody looked (no key, no ffmpeg, unreadable video);
+        // an empty array is a render that was reviewed and came back clean. The record
+        // has to keep those apart.
+        buildRunRecord(
+          result,
+          {
+            ...recordMeta,
+            ...findings ? { review: findings } : {},
+            ...reviewUsage.length > 0 ? { reviewUsage } : {},
+            // A static ad that failed a check is never shown as a version (the backend reads both).
+            ...staticReview ? { verdict: staticReview.verdict, presentable: staticReview.verdict !== "needs_fixes" } : {}
+          },
+          progress?.planInfo(),
+          finalLabels
+        )
+      );
+    }
+    const round = opts.autoFixRound ?? 0;
+    const keepPicture = opts.useVariant !== void 0 || opts.autoFixKeepPicture === true || (fixInstruction !== void 0 || relaidFrom !== void 0) && keepsChosen(shown.picture, fromRun);
+    const attempts = staticReview?.review ? [...opts.autoFixAttempts ?? [], { runId: result.run_id, review: staticReview.review }] : [];
+    const base = attempts.length > 0 ? correctFrom(attempts) : null;
+    const reverted = base !== null && base.runId !== result.run_id;
+    let step = staticReview && base && opts.autoFix !== false ? (
+      // The graph the next round re-prepares (the file's), never this run's rewrite of it: a fix or a
+      // re-layout takes the variants out of `parsed`, and only the file's graph can draw a new picture.
+      autoFixStep(prepared.canvas, base.review, {
+        round,
+        keepPicture,
+        // Gone back to an earlier attempt: what this round did and left is no longer the picture's.
+        ...!reverted && opts.autoFixKind ? { previous: opts.autoFixKind } : {},
+        ...!reverted && fixInstruction !== void 0 ? { lastFix: { instruction: fixInstruction.trim(), blocking: stillThere } } : {},
+        tooFar: reverted ? [] : placedTooFar(parsed, result.outputs_by_node),
+        fixedBefore: base.fixedBefore
+      })
+    ) : null;
+    if (step && reverted && base) {
+      process.stdout.write(
+        `[autofix] run ${result.run_id} came out worse than run ${base.runId}: the next correction starts from run ${base.runId}
+`
+      );
+    }
+    const outOfTime = step !== null && !roundFitsTurn(await readTurnRenders(turnCache), turnId, creativeSlug, Date.now() - startedAt, step.kind);
+    if (outOfTime) {
+      process.stdout.write(
+        `[autofix] not started: this ad has had its time in this turn (${Math.round((Date.now() - startedAt) / 6e4)} min in this render). It stands as it is.
+`
+      );
+      hints.unshift(
+        "Out of time for this ad in this turn: no further correction or render. Show this version as it stands and say in one plain sentence what is left; the person's next message says what changes."
+      );
+      step = null;
+    }
+    if (!step && reverted && base) {
+      hints.unshift(
+        `Run ${base.runId} has fewer problems than this one: correct that one, never this one (add \`--from ${base.runId}\` to a --fix).`
+      );
+    }
+    let respecced = null;
+    const briefFindings = step?.kind === "respec" ? step.findings : step?.kind === "regenerate" ? step.brief ?? [] : [];
+    const lost = [...new Set((base?.review ?? []).filter(lostVital).flatMap((f) => f.kind?.job ? [f.kind.job] : []))];
+    if (briefFindings.length > 0) {
+      const target = staticReviewTargets(parsed, result.output);
+      const spent = [];
+      respecced = target ? await repairSpec({
+        promptPath: target.promptPath,
+        findings: briefFindings,
+        rejected: creativeSlug ? await readCaseFile(creativeSlug) : [],
+        held,
+        ...lost.length > 0 ? { restore: lost } : {},
+        ...target.images[0] ? { image: target.images[0].path } : {},
+        onSpend: (usage) => spent.push(usage)
+      }) : null;
+      if (spent.length > 0) await holdUnbilledSpend(cacheDir, spent);
+      if (step?.kind === "respec" && respecced === null) step = null;
+    }
+    if (step && stopsWithoutRepair(base?.review ?? [], briefFindings, respecced !== null)) {
+      process.stdout.write(
+        "[autofix] stopped: what made the proven ad win is gone and no correction of prompt.json may restore it\n"
+      );
+      hints.unshift(
+        "The automatic correction stopped: what made the proven ad win is gone and no correction of prompt.json may restore it, so a new picture from the same plan would come back without it."
+      );
+      step = null;
+    }
+    if (step) {
+      const did = step.kind === "respec" ? `The spec was corrected: ${respecced}` : step.kind === "fix" ? `The picture was corrected for: ${step.instruction.replace(/^[^:]*: /, "")}` : step.kind === "regenerate" && relaysSizesOnly(parsed, regenerateTargets(parsed, step.ids).ids) ? `The ${step.ids.join(" and ")} ${step.ids.length === 1 ? "was" : "were"} made again from the same chosen picture, avoiding: ${step.note.replace(/^[^:]*: /, "")}` : step.kind === "regenerate" ? `${respecced ? `The spec was corrected (${respecced}) and a` : "A"} new picture was made, avoiding: ${step.note.replace(/^[^:]*: /, "")}` : step.kind === "extend" ? `The ${step.sizes.join(" and ")} ${step.sizes.length === 1 ? "was" : "were"} placed clear of what covers or cuts ${step.sizes.length === 1 ? "it" : "them"}, the margins painted to match.` : `The ${step.ids.map((id) => formatOfSizeNode(parsed, id) ?? id).join(" and ")} was edited: ${Object.values(step.edits).join(" ")}`;
+      const files = finalFiles(result.output, finalLabels?.labels);
+      process.stdout.write(
+        `[autofix] round ${round + 1} of ${AUTO_FIX_ROUNDS}: run ${result.run_id} needs fixes. ${did} If the correction fails, run ${result.run_id} stands as the latest version: ${JSON.stringify(files)}
+`
+      );
+      next = {
+        file: filePath,
+        cacheDir: opts.cacheDir,
+        outputsDir: opts.outputsDir,
+        concurrency: opts.concurrency,
+        keepRuns: opts.keepRuns,
+        remoteCache: opts.remoteCache,
+        record: opts.record,
+        brief: opts.brief,
+        cachePolicy: opts.cachePolicy,
+        fresh: true,
+        from: base?.runId ?? result.run_id,
+        autoFixRound: round + 1,
+        autoFixAttempts: attempts,
+        autoFixStartedAt: startedAt,
+        autoFixed: [...corrected, did],
+        autoFixKind: step.kind,
+        ...base ? { settledReview: [...base.review] } : {},
+        ...keepPicture ? { autoFixKeepPicture: true } : {},
+        ...step.kind === "fix" ? {
+          fix: step.instruction,
+          ...step.relay ? { relayAlso: step.relay } : {},
+          ...step.keep ? { keepSizes: step.keep } : {},
+          ...step.extend ? { extendSizes: step.extend } : {}
+        } : step.kind === "extend" ? { extendSizes: step.sizes, extendOnly: true } : step.kind === "relayout" ? {
+          ...step.extend ? { extendSizes: step.extend } : {},
+          regenerate: step.ids.join(","),
+          relayEdits: step.edits,
+          // A second edit of a size is told what the first asked for.
+          ...opts.autoFixKind === "relayout" && opts.relayEdits ? { relayAsked: Object.fromEntries(Object.entries(opts.relayEdits).map(([id, asked]) => [id, [asked]])) } : {}
+        } : step.kind === "regenerate" ? { regenerate: step.ids.join(","), relayNote: step.note, ...step.extend ? { extendSizes: step.extend } : {} } : {}
+      };
+    } else {
+      if (creativeSlug && turnId && staticReview) {
+        const tookMs = Date.now() - startedAt;
+        await updateTurnRenders(
+          turnCache,
+          (ledger) => recordTurnRender(ledger, turnId, creativeSlug, staticReview.verdict, tookMs)
+        );
+      }
+      process.stdout.write(
+        `${JSON.stringify(
+          {
+            ok: true,
+            outputs_dir: result.outputs_dir,
+            output: result.output,
+            stats: result.stats,
+            // The agent reads a finding's words; the review model's typed fields are the correction's.
+            ...findings ? { review: findings.map(({ kind: _kind, ...finding }) => finding) } : {},
+            ...staticReview?.judge?.length ? { judge: staticReview.judge } : {},
+            ...definitionStatus === "updated" ? { definition_status: "rendered" } : {},
+            ...hints.length ? { hints } : {},
+            // Last, so a `| tail` keeps them: production agents cut them off and re-ran to get them back.
+            // A static ad whose review found a blocking problem is finished but NOT ready.
+            ...staticReview ? { verdict: staticReview.verdict } : {},
+            run_id: result.run_id,
+            files: finalFiles(result.output, finalLabels?.labels)
+          },
+          null,
+          2
+        )}
+`
+      );
+    }
+  } catch (e) {
+    const failedPayload = async (message) => {
+      await readerSpend.drained();
+      const payload = progress?.hasPlan() ? progress.failedSnapshot(message) : buildFailedRunRecord(runId, message, recordMeta);
+      const held2 = await takeUnbilledSpend(cacheDir);
+      return held2.length > 0 ? { ...payload, reviewUsage: held2 } : payload;
+    };
+    if (e instanceof RunAbortedError && e.reason === "signal") {
+      const message = `Interrupted${abortedBy ? ` by ${abortedBy}` : ""} \u2014 re-run \`baker canvas run\` to resume; in-flight jobs re-attach, completed nodes come from the cache.`;
+      if (poster) await flushBilled(poster, { ...await failedPayload(message), interrupted: true });
+      process.stderr.write(`${JSON.stringify({ ok: false, error: { code: "interrupted", message } }, null, 2)}
+`);
+      process.exit(abortedBy === "SIGTERM" ? 143 : 130);
+    }
+    if (e instanceof RunAbortedError && e.reason === "checkpoint") {
+      await clearMarker();
+      if (poster) {
+        await flushBilled(poster, {
+          ...await failedPayload(`Frames ready to review before the clips. Resume with --run-id ${runId}.`),
+          status: "awaiting_approval"
+        });
+      }
+      const frames = frameUrls;
+      process.stdout.write(
+        `${JSON.stringify(
+          {
+            ok: true,
+            data: { stopped: "frames", runId, frames },
+            hints: [
+              `${e.message}`,
+              frames.length > 0 ? `Review these ${frames.length} frames against the brief and Brand, fix any defects, then resume immediately with the same run id. Wait for the user only when they explicitly requested storyboards only or a review before continuing; do not ask them to choose a version.` : "No frame outputs were captured \u2014 carry on rather than blocking on nothing.",
+              `Carry on with: baker canvas run ${filePath} --run-id ${runId}`
+            ]
+          },
+          null,
+          2
+        )}
+`
+      );
+      process.exit(0);
+    }
+    await clearMarker();
+    if (e instanceof ValidationError) {
+      process.stderr.write(
+        `${JSON.stringify({ ok: false, error: { code: "validation", issues: e.issues } }, null, 2)}
+`
+      );
+      process.exit(2);
+    }
+    if (e instanceof LayerExecutionError) {
+      const failures = e.failures.map((f) => ({ node_id: f.nodeId, message: describeFailureReason(f.reason) }));
+      if (poster) await flushBilled(poster, await failedPayload(e.message));
+      process.stderr.write(
+        `${JSON.stringify({ ok: false, error: { code: runFailureCode(e), message: e.message, failures } }, null, 2)}
+`
+      );
+      process.exit(1);
+    }
+    const msg = e instanceof Error ? e.message : String(e);
+    if (poster) await flushBilled(poster, await failedPayload(msg));
+    process.stderr.write(`${JSON.stringify({ ok: false, error: { code: runFailureCode(e), message: msg } }, null, 2)}
+`);
+    process.exit(1);
+  }
+  if (next) await executeCanvasRun(next);
+}
+function canvasNodeIds(parsed) {
+  const nodes = parsed?.nodes;
+  if (!Array.isArray(nodes)) return [];
+  return nodes.map((node) => node?.id).filter((id) => typeof id === "string");
+}
+function buildBackendClient() {
+  try {
+    const creds = requireCredentialsFromEnv();
+    return new BackendClient({ baseUrl: creds.url, apiKey: creds.apiKey });
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    process.stderr.write(`[warn] run history disabled (${msg})
+`);
+    return null;
+  }
+}
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function postInitialRunRecord(client, payload) {
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      await client.recordRun(payload);
+      return true;
+    } catch {
+      if (attempt < 2) await sleep(500 * 2 ** attempt);
+    }
+  }
+  return false;
+}
+
+export {
+  runCommand,
+  stopBeforeKinds,
+  executeCanvasRun,
+  buildBackendClient
+};
+//# sourceMappingURL=chunk-X7XFAFU4.js.map