@koda-sl/baker-cli 0.476.0 → 0.481.0-dev.2d33e194f

package/dist/chunk-CZYUZL6R.js

@@ -0,0 +1,3151 @@
+import {
+  outputRatioWarningsFor
+} from "./chunk-THU74XR6.js";
+import {
+  nodeParamsPreview
+} from "./chunk-W7KB3LJE.js";
+import {
+  waitForSheet
+} from "./chunk-WN4KX7GE.js";
+import {
+  readAvatars,
+  writeAvatars
+} from "./chunk-KB5HBQEK.js";
+import {
+  fetchBrandLogo
+} from "./chunk-IJDF7D4U.js";
+import {
+  advanceDefinitionStatus
+} from "./chunk-3ACMDRSE.js";
+import {
+  correctedPicture,
+  ingestedNow,
+  isStaticAdCanvas,
+  keepsChosen,
+  pictureRecord,
+  previousAdImage,
+  previousDelivered,
+  relaysSizesOnly,
+  runBaker,
+  seriesLeadsAbove,
+  seriesMembers,
+  seriesRunHints,
+  variantImage,
+  versionRun,
+  writeSeriesMemberCanvas
+} from "./chunk-EOGPNV25.js";
+import {
+  buildFailedRunRecord,
+  buildInitialRunRecord,
+  buildRunRecord,
+  creativeSlugFromCanvasPath,
+  finalFiles,
+  finalOutputLabelsFromCanvas,
+  nodeOutputsToRecord
+} from "./chunk-NQTSHC7Z.js";
+import {
+  clearLegacyDirtyMarker,
+  readRenderState,
+  recordRenderAttempt,
+  recordRendered,
+  recordReviewOutcome,
+  recordSeriesLeadRun,
+  recordSnapshot
+} from "./chunk-AFDPISNJ.js";
+import {
+  BRAND_LOGO_ROLE,
+  CLAIMS_MODEL,
+  CLAIMS_REQUEST,
+  CanvasPrepareError,
+  GLOBAL_PROMPT_FILE,
+  PEOPLE_PROMPT_VERSION,
+  REBUILD_FILE,
+  computeSourceSha,
+  exitOnPrepareError,
+  findBrandRoot,
+  fixBriefNode,
+  fixStaticAd,
+  formatOfAdaptId,
+  isNativeCanvas,
+  listSceneFiles,
+  peoplePrompt,
+  plannedPlacements,
+  prepareCanvas,
+  readPeople,
+  readStaticBrandKit,
+  readStaticPromptJson,
+  rederiveFromVariant,
+  seriesOf,
+  uncastPeople,
+  wireNamedPeople,
+  wireProofBadges
+} from "./chunk-OXBPKBSK.js";
+import {
+  ViewerAnswerSchema,
+  describeViewer,
+  gatewayViewerModel,
+  jevReadJudge,
+  judgeViewerAnswer,
+  liveViewerLookups,
+  marketQuery,
+  mayBeCorrection,
+  misreadings,
+  readTurnRenders,
+  recordTurnRender,
+  recordViewerFail,
+  roundFitsTurn,
+  sureEnough,
+  turnRenderRefusal,
+  updateTurnRenders,
+  viewerCheckBeforeRender,
+  viewerCheckSkip,
+  viewerChecksSpent
+} from "./chunk-V7PMSMPF.js";
+import {
+  holdUnbilledSpend,
+  holdWhenSettled,
+  sendBillingSpend,
+  takeUnbilledSpend
+} from "./chunk-VHMNSO2B.js";
+import {
+  canvasOutputsRoot,
+  describeRewrites,
+  findWorkspaceRoot,
+  localPathParam
+} from "./chunk-65BQAJMH.js";
+import {
+  ValidationError,
+  createEngineFromEnv,
+  resolveConcurrency,
+  ulid
+} from "./chunk-KM4AAAHZ.js";
+import {
+  BackendClient,
+  LOGO_COMPOSITE_ROLE,
+  SERIES_LEAD_ROLE,
+  STATIC_ADAPT_FORMAT_ROLE,
+  STATIC_ADAPT_ROLE,
+  STATIC_FIX_ROLE,
+  STATIC_MASTER_ROLE,
+  STATIC_PICK_ROLE,
+  STATIC_PLACE_ROLE,
+  STATIC_SAFE_FIT_ROLE,
+  STATIC_SIZE_ROLE,
+  STATIC_VARIANTS_ROLE,
+  STATIC_VARIANT_CALL_ROLE,
+  VARIANT_PREFILTER_ROLE,
+  adaptPlan,
+  formatSlug,
+  nodesWithRole,
+  regenerateTargets,
+  rolesById,
+  staticMasterFormat
+} from "./chunk-O4ABJ352.js";
+import {
+  bytesOf,
+  judgeWinner,
+  nearIdenticalFindings,
+  parseJudgeScores,
+  reviewRenderedStatic,
+  samePictureSizes,
+  staticVerdict
+} from "./chunk-AXVOBRQT.js";
+import {
+  AdSpecSchema,
+  adSpecJsonSchema,
+  conceptSummary,
+  isAdSpec,
+  jevCitationJudge,
+  nativeChrome,
+  nativeCopy,
+  nativeSurfaceName,
+  readAdSpec,
+  readInterfaceWords
+} from "./chunk-FYAWA3FO.js";
+import {
+  GLANCE_CHECK_MODEL,
+  VIEWER_CHECK_MODEL,
+  canonicalize,
+  nearestSupportedAspectRatio
+} from "./chunk-CAMX6OHF.js";
+import {
+  RENDER_REVIEW_MODEL,
+  RENDER_REVIEW_UNAVAILABLE,
+  askAboutImages,
+  askAboutText,
+  reviewContextBeside,
+  reviewRenderedVideo,
+  sceneWindowsBeside,
+  videoPathFromOutput
+} from "./chunk-73B3RQJC.js";
+import {
+  describeMarket
+} from "./chunk-5HYSKH77.js";
+import {
+  LayerExecutionError,
+  RunAbortedError,
+  describeFailureReason,
+  requireCredentialsFromEnv,
+  runFailureCode,
+  sha256Hex
+} from "./chunk-NAMEFVWL.js";
+import {
+  apiPost
+} from "./chunk-KB5XJHQX.js";
+import {
+  optionalChatId,
+  optionalTurnId
+} from "./chunk-QXDEZKAR.js";
+
+// src/commands/canvas/run.ts
+import { readFile as readFile6 } from "fs/promises";
+import path7 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
+        )
+      });
+      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/engine/scaffold/static-history.ts
+var PICTURE_ROLES = /* @__PURE__ */ new Set([
+  STATIC_VARIANT_CALL_ROLE,
+  STATIC_VARIANTS_ROLE,
+  VARIANT_PREFILTER_ROLE,
+  STATIC_PICK_ROLE,
+  STATIC_FIX_ROLE,
+  SERIES_LEAD_ROLE
+]);
+var EDIT_ID = /^edit_(\d+)$/;
+function refNode(ref) {
+  return typeof ref === "string" ? ref.match(/^\$ref:([a-z][a-z0-9_]*)\./)?.[1] ?? null : null;
+}
+function depsOf(node) {
+  const found = [];
+  const walk = (v) => {
+    if (typeof v === "string") {
+      const id = refNode(v);
+      if (id) found.push(id);
+    } else if (Array.isArray(v)) v.forEach(walk);
+    else if (v && typeof v === "object") Object.values(v).forEach(walk);
+  };
+  walk(node.inputs);
+  walk(node.params);
+  return found;
+}
+function ancestors(nodes, id) {
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (at) => {
+    const n = byId.get(at);
+    if (!n || seen.has(at)) return;
+    seen.add(at);
+    for (const dep of depsOf(n)) visit(dep);
+  };
+  visit(id);
+  return nodes.filter((n) => seen.has(n.id));
+}
+var isPicture = (n) => PICTURE_ROLES.has(n.tags?.role ?? "");
+function framingPrefilter(nodes, master) {
+  const reads = JSON.stringify(master.inputs ?? {});
+  return nodes.find((n) => n.tags?.role === VARIANT_PREFILTER_ROLE && reads.includes(`$ref:${n.id}.`));
+}
+function frameNode(prefilter, id, image) {
+  if (!prefilter) return null;
+  const { judge_model: _judge, judge_prompt: _prompt, ...params } = prefilter.params ?? {};
+  return { ...prefilter, id, inputs: { ...prefilter.inputs, images: [image] }, params };
+}
+function variantIndex(outputs, sha) {
+  const images = Array.isArray(outputs?.images) ? outputs.images : [];
+  const want = sha.trim().toLowerCase();
+  if (!/^[0-9a-f]{8,64}$/.test(want)) return null;
+  const hits = images.flatMap((img, i) => typeof img?.sha256 === "string" && img.sha256.startsWith(want) ? [i] : []);
+  return hits.length === 1 ? hits[0] ?? null : null;
+}
+function variantSources(nodes) {
+  const calls = nodes.filter((n) => n.tags?.role === STATIC_VARIANT_CALL_ROLE);
+  const ids = new Set(calls.flatMap((call) => ancestors(nodes, call.id).map((n) => n.id)));
+  return nodes.filter((n) => ids.has(n.id));
+}
+function variantFiles(canvas) {
+  return variantSources(canvas.nodes).flatMap((n) => {
+    const { source, path: path8, expect } = n.params ?? {};
+    return n.type === "ingest" && source === "path" && typeof path8 === "string" ? [{ id: n.id, path: path8, expect: String(expect ?? "") }] : [];
+  });
+}
+function declared(n) {
+  const { path: _where, ...params } = n.params ?? {};
+  const own = n.type === "ingest" && n.params?.source === "path" ? params : n.params ?? {};
+  return canonicalize({ type: n.type, inputs: n.inputs ?? {}, params: own });
+}
+function makesSameVariants(current, version, ingested) {
+  const sources = variantSources(current.nodes);
+  if (sources.length === 0) return false;
+  const was = new Map(version.canvas.nodes.map((n) => [n.id, n]));
+  const sameDeclaration = sources.every((n) => {
+    const before = was.get(n.id);
+    return before !== void 0 && declared(before) === declared(n);
+  });
+  return sameDeclaration && variantFiles(current).every((file) => {
+    const asset = version.outputs[file.id]?.asset;
+    return typeof asset?.sha256 === "string" && (ingested[file.id] ?? []).includes(asset.sha256);
+  });
+}
+function madeThisRun(grown) {
+  const master = grown.canvas.nodes.find((n) => n.tags?.role === STATIC_MASTER_ROLE);
+  const head = refNode(master?.inputs?.image);
+  const nodes = grown.canvas.nodes.filter((n) => !(n.id in grown.pinned) || n.id === head);
+  return { ...grown.canvas, nodes };
+}
+function growFromVersion(current, version, growth) {
+  const master = current.nodes.find((n) => n.tags?.role === STATIC_MASTER_ROLE);
+  const history = master ? versionHistory(current, version, growth) : null;
+  if (!master || !history) return null;
+  const { kept, pinned } = history;
+  const keptIds = new Set(kept.map((n) => n.id));
+  const stage = new Set(
+    ancestors(current.nodes, master.id).filter((n) => n.id !== master.id && isPicture(n)).map((n) => n.id)
+  );
+  const rest = current.nodes.filter((n) => !stage.has(n.id) && !keptIds.has(n.id));
+  const top = stepsOnTop({ current, master, kept, rest }, history.picture, growth);
+  if (!top) return null;
+  const at = rest.findIndex((n) => n.id === master.id);
+  const nodes = rest.map((n) => n.id === master.id ? { ...n, inputs: { ...n.inputs, image: top.picture } } : n);
+  return {
+    canvas: { ...current, nodes: [...nodes.slice(0, at), ...kept, ...top.added, ...nodes.slice(at)] },
+    pinned
+  };
+}
+function versionHistory(current, version, growth) {
+  const was = version.canvas.nodes;
+  const image = was.find((n) => n.tags?.role === STATIC_MASTER_ROLE)?.inputs?.image;
+  if (typeof image !== "string") return null;
+  let picture = image;
+  let from = refNode(image) ?? "";
+  if (growth.kind === "variant") {
+    const variants = was.find((n) => n.tags?.role === STATIC_VARIANTS_ROLE);
+    const at = variants ? variantIndex(version.outputs[variants.id], growth.sha256) : null;
+    if (!variants || at === null) return null;
+    picture = `$ref:${variants.id}.images#${at}`;
+    from = variants.id;
+  }
+  const own = new Set(current.nodes.map((n) => n.id));
+  const kept = ancestors(was, from).filter((n) => isPicture(n) || !own.has(n.id));
+  const pinned = {};
+  for (const n of kept) {
+    const outputs = version.outputs[n.id];
+    if (!outputs) return null;
+    pinned[n.id] = outputs;
+  }
+  return { kept, pinned, picture };
+}
+function stepsOnTop(at, picture, growth) {
+  if (growth.kind === "keep") return { added: [], picture };
+  const prefilter = framingPrefilter(at.current.nodes, at.master);
+  const step = growth.kind === "edit" ? editStep(at, picture, growth) : chosenStep(picture);
+  if (!step) return null;
+  const frame2 = frameNode(prefilter, `${step.id}_frame`, `$ref:${step.id}.images#0`);
+  return frame2 ? { added: [step, frame2], picture: `$ref:${frame2.id}.image` } : { added: [step], picture: `$ref:${step.id}.images#0` };
+}
+function editStep(at, picture, growth) {
+  const n = 1 + Math.max(0, ...at.kept.map((k) => Number(k.id.match(EDIT_ID)?.[1] ?? 0)));
+  const template = at.current.nodes.find(
+    (v) => v.type === "image_generate" && [STATIC_VARIANT_CALL_ROLE, STATIC_VARIANTS_ROLE].includes(v.tags?.role ?? "")
+  );
+  if (!template) return null;
+  const masterFormat = staticMasterFormat(at.current);
+  const brief = fixBriefNode({ nodes: [...at.kept, ...at.rest] }, template, growth.promptJson, {
+    instruction: growth.instruction,
+    previous: picture,
+    ...masterFormat ? { format: masterFormat } : {}
+  });
+  const { n: _n, ...params } = brief.params ?? {};
+  return {
+    id: `edit_${n}`,
+    type: brief.type,
+    ...brief.inputs ? { inputs: brief.inputs } : {},
+    params,
+    tags: { role: STATIC_FIX_ROLE }
+  };
+}
+function chosenStep(picture) {
+  return { id: "chosen", type: "collect", inputs: { images: [picture] }, tags: { role: STATIC_PICK_ROLE } };
+}
+
+// src/commands/canvas/named-people-read.ts
+import { createHash } from "crypto";
+import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import path4 from "path";
+var PEOPLE_TIMEOUT_MS = 3e4;
+function peopleReader(cacheDir, spent) {
+  const dir = path4.join(cacheDir, "named-people");
+  return async (lines) => {
+    const said = lines.filter((l) => l.trim());
+    if (said.length === 0) return [];
+    const key = createHash("sha256").update(JSON.stringify([PEOPLE_PROMPT_VERSION, CLAIMS_MODEL, said])).digest("hex");
+    const file = path4.join(dir, `${key}.json`);
+    const cached = await readFile3(file, "utf8").then((text) => readPeople(JSON.parse(text), said)).catch(() => null);
+    if (cached) return cached;
+    const answer = await askAboutText(CLAIMS_MODEL, peoplePrompt(said), spent, {
+      timeoutMs: PEOPLE_TIMEOUT_MS,
+      request: CLAIMS_REQUEST
+    });
+    const people = readPeople(answer, said);
+    if (people) {
+      await mkdir3(dir, { recursive: true });
+      await writeFile3(file, JSON.stringify(answer), "utf8");
+    }
+    return people;
+  };
+}
+
+// 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 path5 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 = path5.join(opts.workspaceRoot, "src", "creatives", slug);
+  const local = path5.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/static-edit.ts
+function specOf(raw) {
+  try {
+    return raw ? readAdSpec(raw) : null;
+  } catch {
+    return null;
+  }
+}
+function frame(spec) {
+  const { copy: _copy, colors: _colors, brand, notes: _notes, source: _source, reference: _reference, ...rest } = spec;
+  const concept = rest.concept ? { ...rest.concept, transfer_note: void 0 } : void 0;
+  const brandShape = brand ? { ...brand, ground: void 0, ink: void 0, accent: void 0, cta: void 0, palette: [] } : void 0;
+  return JSON.stringify({ ...rest, concept, brand: brandShape });
+}
+var ROLE_WORDS = {
+  headline: "the headline",
+  cta: "the button",
+  button: "the button",
+  price: "the price",
+  body: "body text",
+  caption: "a caption",
+  label: "a label",
+  fine_print: "the fine print"
+};
+function copyEdits(before, after) {
+  const out = [];
+  const shared = Math.min(before.length, after.length);
+  for (let i = 0; i < shared; i++) {
+    const a = before[i];
+    const b = after[i];
+    if (a.text !== b.text) out.push(`Change the words "${a.text}" to exactly "${b.text}".`);
+    if ((a.position ?? "") !== (b.position ?? "") && b.position) out.push(`Move "${b.text}" to ${b.position}.`);
+    if ((a.look ?? "") !== (b.look ?? "") && b.look) out.push(`Set "${b.text}" ${b.look}.`);
+    if (a.lettering !== b.lettering || (a.role ?? "") !== (b.role ?? "") || (a.on ?? "") !== (b.on ?? "")) {
+      out.push(`Set "${b.text}" as ${ROLE_WORDS[b.role ?? ""] ?? "it is described"}${b.on ? `, lettered on ${b.on}` : ""}.`);
+    }
+  }
+  for (const added of after.slice(shared)) {
+    const role = ROLE_WORDS[added.role ?? ""];
+    out.push(`Add the words "${added.text}"${role ? ` (${role})` : ""}${added.position ? `, ${added.position}` : ""}.`);
+  }
+  for (const removed of before.slice(shared)) out.push(`Remove the words "${removed.text}".`);
+  return out;
+}
+function colourEdits(before, after) {
+  const out = [];
+  for (const use of after.colors) {
+    const was = before.colors.find((c) => c.object === use.object);
+    if (was && was.name === use.name && was.hex === use.hex) continue;
+    out.push(`Make ${use.object} ${use.name}${use.hex ? ` (${use.hex})` : ""}.`);
+  }
+  const roles = [
+    ["cta", "the button"],
+    ["ground", "the background"],
+    ["ink", "the designed type"],
+    ["accent", "the accent colour"]
+  ];
+  for (const [key, object] of roles) {
+    const was = before.brand?.[key];
+    const now = after.brand?.[key];
+    if (typeof now === "string" && was !== now) out.push(`Make ${object} ${now}.`);
+  }
+  return out;
+}
+function specEditInstruction(previous, next) {
+  const before = specOf(previous);
+  const after = specOf(next);
+  if (!before || !after || frame(before) !== frame(after)) return null;
+  const edits = [...copyEdits(before.copy, after.copy), ...colourEdits(before, after)];
+  return edits.length > 0 ? edits.join(" ") : null;
+}
+var normalized = (text) => text.trim().toLowerCase().replace(/\s+/g, " ");
+function repeatsFailedFix(last, instruction) {
+  return Boolean(last && last.blocking.length > 0 && normalized(last.instruction) === normalized(instruction));
+}
+function fixMemoryOf(shown, from) {
+  if (from !== void 0 && from !== shown.rendered?.runId) return { blocking: [] };
+  return { ...shown.lastFix ? { lastFix: shown.lastFix } : {}, blocking: shown.blocking ?? [] };
+}
+function persistingDefects(before, after) {
+  const now = new Set((after ?? []).filter((f) => f.severity === "blocking").map((f) => f.what));
+  return before.filter((what) => now.has(what));
+}
+
+// src/commands/canvas/static-autofix.ts
+var AUTO_FIX_ROUNDS = 3;
+function wholePicture(f) {
+  const kind = f.kind;
+  if (!kind) return false;
+  return kind.item === "subject" || kind.item === "one_idea" || kind.item === "concept" || (kind.item === "picture" || kind.item === "native") && kind.element === "picture";
+}
+var BRIEF_ITEMS = /* @__PURE__ */ new Set(["subject", "concept", "proof", "person"]);
+var fromBrief = (f) => f.kind !== void 0 && BRIEF_ITEMS.has(f.kind.item);
+var comparesSizes = (f) => f.kind?.item === "sizes";
+var cutCopy = (f) => f.kind?.defect === "cut" && (f.kind.element === "logo" || f.kind.element === "button" || f.kind.element === "copy");
+var MANY_DEFECTS = 3;
+var withoutSize = (what) => what.replace(/^\d+(?:\.\d+)?:\d+(?:\.\d+)?(?:,\s*\d+(?:\.\d+)?:\d+(?:\.\d+)?)*:\s*/, "");
+var sizesOf = (what) => what.match(/^(\d+(?:\.\d+)?:\d+(?:\.\d+)?(?:,\s*\d+(?:\.\d+)?:\d+(?:\.\d+)?)*):\s/)?.[1]?.split(/,\s*/) ?? [];
+function carryUnchanged(now, prior, unchanged) {
+  const settled = (f) => {
+    const sizes = sizesOf(f.what);
+    return sizes.length > 0 && sizes.every((s) => unchanged.includes(s)) && !comparesSizes(f);
+  };
+  return [...now.filter((f) => !settled(f)), ...prior.filter(settled)];
+}
+var pct = (share) => `${Math.round(share * 100)}%`;
+var PAST_BAND = /^(.+?) sits? (?:close to )?where (.+?) covers? (?:it|them) \((.+)\)\.?$/;
+var OFF_EDGE = /^(.+?) runs? off the edge of the picture \((.+)\)\.?$/;
+var OUTSIDE_SPACE = /^(.+?) sits? outside the space every size keeps clear \((.+)\)\.?$/;
+var EXTRA_WORDS = /^the picture adds words that aren't in the copy: (.+?)\. Remove them, or add them to the copy\.?$/;
+var SCENE_PRICES = /^the picture shows prices the copy does not hold: (.+?)\. Make them unreadable\.?$/;
+var PLACED = [PAST_BAND, OFF_EDGE, OUTSIDE_SPACE];
+var MISREAD = /^Text: (".+") reads (".*")\.?$/;
+var MISSING = /^Text: (".+") is missing\.?$/;
+var MAKE_ROOM = "Make the room by moving what is next to it with it and shortening the picture or the gaps, keeping every block in its order.";
+var OVERSHOOT = 0.06;
+function moveInto(what, edges, band) {
+  const at = (edge) => edges.includes(edge);
+  const top = band ? band.top + OVERSHOOT : 0;
+  const bottom = band ? band.bottom + OVERSHOOT : 0;
+  const vertical = at("bottom") && at("top") ? band ? `so all of it sits between ${pct(top)} and ${pct(1 - bottom)} of the height` : "into the middle of the frame, away from its top and bottom" : at("bottom") && band ? `up so all of it sits above ${pct(1 - bottom)} of the height, the bottom ${pct(bottom)} showing only the picture` : at("top") && band ? `down so all of it sits below ${pct(top)} of the height, the top ${pct(top)} showing only the picture` : at("bottom") ? "up, away from the bottom of the frame" : at("top") ? "down, away from the top of the frame" : "";
+  const sides = ["right", "left"].filter((e) => at(e === "right" ? "right edge" : "left edge"));
+  const side = sides.map((e) => band ? `at least ${pct(band[e])} in from the ${e} edge` : `away from the ${e} edge`).join(" and ");
+  if (!vertical) return `Move ${what} ${side}`;
+  return side ? `Move ${what} ${vertical}, and ${side}` : `Move ${what} ${vertical}`;
+}
+function correctionOf(finding, band, kind) {
+  const what = withoutSize(finding).trim();
+  if (/could not be read back/.test(what)) return null;
+  const past = what.match(PAST_BAND);
+  if (past) {
+    const [, block = "", surface = "", edges = ""] = past;
+    const covers = band && edges.includes("bottom") && edges.includes("top") ? `: ${surface} covers the top ${pct(band.top)} and the bottom ${pct(band.bottom)} of the frame` : band && edges.includes("bottom") ? `: ${surface} covers the bottom ${pct(band.bottom)} of the frame` : band && edges.includes("top") ? `: ${surface} covers the top ${pct(band.top)} of the frame` : "";
+    return `${moveInto(block, edges, band)}${covers}. ${MAKE_ROOM}`;
+  }
+  const off = what.match(OFF_EDGE) ?? what.match(OUTSIDE_SPACE);
+  if (off) {
+    const [, block = "", edges = ""] = off;
+    const named = edges.replace(/the (top|bottom) of the screen/g, "the $1 edge").replace(/ and /g, " and ");
+    return `Move ${block} fully inside the frame, with clear space between it and ${named}, smaller if it needs to be.`;
+  }
+  const extra = what.match(EXTRA_WORDS);
+  if (extra) {
+    return `Erase these words wherever they appear, leaving the surface they are on blank or with plain lines: ${extra[1]}.`;
+  }
+  const prices = what.match(SCENE_PRICES);
+  if (prices) {
+    return `Blur these figures until no digit can be read, keeping the document or screen they are on as it is: ${prices[1]}.`;
+  }
+  const misread = what.match(MISREAD);
+  if (misread) return `Re-letter ${misread[1]} exactly as written, letter for letter (it now reads ${misread[2]}).`;
+  const missing = what.match(MISSING);
+  if (missing) return `Add the line ${missing[1]}, spelled exactly, where it belongs in the layout.`;
+  if (kind?.item === "sizes") return FOLLOW_PICTURE;
+  const described = what.replace(/\.$/, "");
+  return `Fix this: ${described.charAt(0).toLowerCase()}${described.slice(1)}.`;
+}
+function autoFixStep(canvas, review, opts = {}) {
+  if ((opts.round ?? 0) >= AUTO_FIX_ROUNDS) return null;
+  const flagged = (review ?? []).filter((f) => f.severity === "blocking");
+  if (flagged.length === 0) return null;
+  if (isNativeCanvas(canvas)) return { kind: "respec", findings: unique(flagged.map((f) => f.what)) };
+  const relaid = relaidSizes(canvas);
+  const blocking = onDerivedSizes(flagged, relaid);
+  const unplaceable = new Set((opts.tooFar ?? []).filter((format) => relaid.some((r) => r.format === format)));
+  const misplaced = (f) => {
+    const what = withoutSize(f.what);
+    const sizes = sizesOf(f.what);
+    return sizes.length > 0 && !sizes.every((size) => unplaceable.has(size)) && (PLACED.some((p) => p.test(what)) || cutCopy(f));
+  };
+  const extend = unique(blocking.filter(misplaced).flatMap((f) => sizesOf(f.what))).filter((size) => !unplaceable.has(size));
+  const placing = extend.length > 0 ? { extend } : {};
+  const rest = blocking.filter((f) => !misplaced(f));
+  const at = (f) => relaid.find((r) => f.what.startsWith(`${r.format}:`));
+  const keepRight = keptRules(opts.fixedBefore);
+  const edits = {};
+  for (const r of relaid) {
+    const lines = unique(rest.filter((f) => at(f) === r).flatMap((f) => correctionOf(f.what, r.band, f.kind) ?? []));
+    if (lines.length > 0) edits[r.id] = [...lines, ...keepRight ? [keepRight] : []].join(" ");
+  }
+  const sizesOnly = () => {
+    const ids = Object.keys(edits);
+    if (ids.length > 0) return { kind: "relayout", ids, edits, ...placing };
+    return extend.length > 0 ? { kind: "extend", sizes: extend } : null;
+  };
+  const onSeveralSizes = (f) => {
+    const what = withoutSize(f.what);
+    return new Set(rest.filter((g) => withoutSize(g.what) === what).flatMap((g) => sizesOf(g.what))).size >= 2;
+  };
+  const settledPicture = opts.previous === "relayout" || opts.previous === "extend";
+  const pictureFindings = rest.filter((f) => !at(f) && (!settledPicture || onSeveralSizes(f)));
+  const onPicture = unique(pictureFindings.map((f) => withoutSize(f.what)));
+  if (onPicture.length === 0) return sizesOnly();
+  const every = unique([...extend, ...deliveredSizes(canvas)]);
+  const afterNewPicture = every.length > 0 ? { extend: every } : {};
+  const persisting = new Set((opts.lastFix?.blocking ?? []).map(withoutSize));
+  const stillWrong = opts.previous === "fix" && onPicture.some((w) => persisting.has(w));
+  const brief = unique(pictureFindings.filter(fromBrief).map((f) => withoutSize(f.what)));
+  const rollAgain = stillWrong || brief.length > 0 || onPicture.length >= MANY_DEFECTS || pictureFindings.some(wholePicture);
+  const last = (opts.round ?? 0) >= AUTO_FIX_ROUNDS - 1;
+  if (rollAgain && (!last || brief.length > 0) && !opts.keepPicture && nodesWithRole(canvas, STATIC_VARIANTS_ROLE).length > 0) {
+    return {
+      kind: "regenerate",
+      ids: [STATIC_VARIANTS_ROLE],
+      note: [`The last picture made from this brief had this wrong, so avoid it: ${onPicture.join(" ")}`, ...keepRight ? [keepRight] : []].join(" "),
+      ...brief.length > 0 ? { brief } : {},
+      ...afterNewPicture
+    };
+  }
+  const changes = unique(
+    pictureFindings.filter((f) => !fromBrief(f)).flatMap((f) => correctionOf(f.what, void 0, f.kind) ?? [])
+  );
+  if (changes.length === 0) return sizesOnly();
+  const named = new Set(blocking.flatMap((f) => sizesOf(f.what)));
+  const keep = relaid.map((r) => r.format).filter((format) => !named.has(format));
+  const remade = every.filter((size) => !keep.includes(size));
+  const kept = {
+    ...keep.length > 0 ? { keep } : {},
+    ...remade.length > 0 ? { extend: remade } : {}
+  };
+  const asked = `Change only this: ${changes.join(" ")}`;
+  const again = onPicture.filter((w) => persisting.has(w)).map((w) => w.replace(/\.$/, ""));
+  const instruction = [
+    again.length > 0 ? `${asked} The last edit was already asked for this and Image 1 still shows it, so make it clearly: ${again.join("; ")}.` : asked,
+    ...keepRight ? [keepRight] : []
+  ].join(" ");
+  if (repeatsFailedFix(opts.lastFix, asked) || repeatsFailedFix(opts.lastFix, instruction)) return null;
+  return { kind: "fix", instruction, ...Object.keys(edits).length > 0 ? { relay: edits } : {}, ...kept };
+}
+var unique = (lines) => [...new Set(lines)];
+var blockingOf = (review) => unique(review.filter((f) => f.severity === "blocking").map((f) => f.what));
+function correctFrom(attempts) {
+  const latest = attempts[attempts.length - 1];
+  const fewest = Math.min(...attempts.map((a) => blockingOf(a.review).length));
+  const base = blockingOf(latest.review).length > fewest ? attempts.find((a) => blockingOf(a.review).length === fewest) : latest;
+  const now = new Set(blockingOf(base.review).map(withoutSize));
+  const fixedBefore = unique(
+    attempts.filter((a) => a !== base).flatMap((a) => blockingOf(a.review)).filter((what) => !now.has(withoutSize(what)))
+  );
+  return { ...base, fixedBefore };
+}
+function keptRules(fixedBefore) {
+  const rules = unique((fixedBefore ?? []).map((f) => withoutSize(f).replace(/\.$/, "")));
+  return rules.length > 0 ? `These were wrong in an earlier version and are right now, so keep them right: ${rules.join("; ")}.` : null;
+}
+var FOLLOW_PICTURE = "Show exactly what the finished ad (Image 2) shows: its people, products, panels and their order, and nothing it does not show.";
+function onDerivedSizes(findings, relaid) {
+  if (relaid.length === 0) return [...findings];
+  return findings.flatMap((f) => {
+    const sizes = sizesOf(f.what);
+    const onPicture = sizes.length > 0 && sizes.every((size) => !relaid.some((r) => r.format === size));
+    if (!onPicture || !comparesSizes(f)) return [f];
+    return relaid.map((r) => ({ ...f, what: `${r.format}: ${withoutSize(f.what)}` }));
+  });
+}
+function deliveredSizes(canvas) {
+  const nodes = canvas?.nodes;
+  const labels = Array.isArray(nodes) ? nodes.find((n) => n.id === "final" && n.type === "collect")?.params?.labels : void 0;
+  return Array.isArray(labels) ? labels.filter((l) => typeof l === "string") : [];
+}
+function relaidSizes(canvas) {
+  const nodes = canvas?.nodes;
+  const placements = Array.isArray(nodes) ? plannedPlacements(nodes) : void 0;
+  return nodesWithRole(canvas, STATIC_ADAPT_FORMAT_ROLE).flatMap((n) => {
+    const format = formatOfAdaptId(n.id);
+    if (!format) return [];
+    const model = String(n.params?.model ?? "");
+    return [{ id: n.id, format, band: adaptPlan(model, format, placements).safe }];
+  });
+}
+function placedTooFar(canvas, outputsByNode) {
+  return nodesWithRole(canvas, STATIC_PLACE_ROLE).flatMap((n) => {
+    const format = n.params?.format;
+    const unmoved = outputsByNode[n.id]?.reason;
+    return (unmoved === "too_far" || unmoved === "inside_band") && typeof format === "string" ? [format] : [];
+  });
+}
+function rendersNewPicture(run) {
+  return !run.fix && !run.useVariant && !run.sizesOnly;
+}
+function paidFor(run) {
+  if (run.fix) return "edit";
+  return run.useVariant || run.sizesOnly ? "sizes" : "options";
+}
+function withRelayNote(canvas, ids, note) {
+  const holder = canvas;
+  if (!Array.isArray(holder.nodes)) return canvas;
+  return {
+    ...holder,
+    nodes: holder.nodes.map((n) => {
+      if (typeof n.id !== "string" || !ids.includes(n.id) || typeof n.params?.prompt !== "string") return n;
+      const [lead = "", ...rest] = n.params.prompt.split("\n\n");
+      return { ...n, params: { ...n.params, prompt: [lead, note, ...rest].join("\n\n") } };
+    })
+  };
+}
+function withRelayEdit(canvas, id, opts) {
+  const holder = canvas;
+  if (!Array.isArray(holder.nodes)) return canvas;
+  const target = holder.nodes.find((n) => n.id === id);
+  const prompt = target?.params?.prompt;
+  const refs = target?.inputs?.reference;
+  if (!target || typeof prompt !== "string" || !Array.isArray(refs)) return canvas;
+  const lastId = `last_${id}`;
+  const remote = /^(?:https?|data):/.test(opts.previous);
+  const last = {
+    id: lastId,
+    type: "ingest",
+    params: remote ? { source: "url", url: opts.previous, expect: "image" } : { source: "path", path: opts.previous, expect: "image" }
+  };
+  const again = opts.asked?.includes(opts.instruction) ? "The last edit was asked for this and Image 1 still shows it wrong, so make the change clearly: " : "";
+  const lead = `Edit: Image 1 is this ad as it was last laid out for this size. ${again}${opts.instruction} Keep the rest of Image 1 as it is: the picture, the colours, the lettering and every word, its layout changed only as much as this needs.`;
+  const kept = prompt.split("\n\n").slice(1).filter((p) => !p.startsWith("Scale:")).map((p) => p.replace(/\bImage (\d+)\b/g, (_, n) => `Image ${Number(n) + 1}`)).map(
+    (p) => p.startsWith("References:") ? p.replace("References:", "References:\nImage 1 (THIS SIZE): the last layout of this size, to edit.").replace(/^Image 2 \(AD\):.*$/m, "Image 2 (AD): the finished ad this size is made from: its words, logo and picture are the ones to keep.") : p
+  );
+  const leads = new Set(
+    holder.nodes.flatMap((n) => n.tags?.role === SERIES_LEAD_ROLE ? [n.id] : [])
+  );
+  const own = refs.map((r) => typeof r === "string" && leads.has(r.match(/^\$ref:([a-z][a-z0-9_]*)\./)?.[1]) ? "$ref:master.image" : r);
+  const edited = {
+    ...target,
+    inputs: { ...target.inputs, reference: [`$ref:${lastId}.asset`, ...own] },
+    params: { ...target.params, prompt: [lead, ...kept].join("\n\n") }
+  };
+  const at = holder.nodes.indexOf(target);
+  return { ...holder, nodes: [...holder.nodes.slice(0, at), last, edited, ...holder.nodes.slice(at + 1)] };
+}
+function withSizesFollowingFix(canvas, opts) {
+  let out = canvas;
+  for (const n of nodesWithRole(canvas, STATIC_ADAPT_FORMAT_ROLE)) {
+    const also = opts.also?.[n.id];
+    const previous = opts.last[n.id];
+    if (previous) {
+      const instruction = `Make the change the finished ad (Image 2) just had: ${opts.change}${also ? ` ${also}` : ""}`;
+      out = withRelayEdit(out, n.id, { previous, instruction });
+    } else if (also) out = withRelayNote(out, [n.id], `This size must also change this: ${also}`);
+  }
+  return out;
+}
+var EXTEND_PROMPT = [
+  "Deliverable: Image 1 is a finished ad set inside a frame with flat grey margins around it. Paint only the grey: continue the picture outward into it so the whole frame reads as one picture, the scene going on (the wall, the floor, the sky, the room) or, where the ad has no scene, its own plain ground and colours.",
+  "Keep everything that is not grey exactly where and as it is: every word, the logo, the button, the people, the products. Nothing in it moves, grows or is redrawn.",
+  "Add nothing in the grey: no words, no letters, no logos, no buttons, no new people or objects, no frames, borders or shadows around the ad. Never repeat any part of the ad in it: no second logo, button, line of text, card or person; the grey is only more of the room, the table, the floor, the sky or the plain ground."
+].join("\n\n");
+function withExtendedSizes(canvas, formats) {
+  const holder = canvas;
+  if (!Array.isArray(holder.nodes)) return canvas;
+  const nodes = holder.nodes;
+  const final = nodes.find((n) => n.id === "final" && n.type === "collect");
+  const labels = final?.params?.labels;
+  const images = final?.inputs?.images;
+  if (!final || !Array.isArray(labels) || !Array.isArray(images)) return canvas;
+  const painter = nodesWithRole(canvas, STATIC_ADAPT_FORMAT_ROLE)[0] ?? nodesWithRole(canvas, STATIC_VARIANT_CALL_ROLE)[0];
+  const params = painter?.params ?? {};
+  const model = typeof params.model === "string" ? params.model : void 0;
+  if (!model) return canvas;
+  const placements = plannedPlacements(nodes) ?? nodes.find((n) => n.type === "static_safe_fit" && Array.isArray(n.params?.placements))?.params?.placements;
+  const copy = placingCopy(nodes);
+  const added = [];
+  const delivered = [...images];
+  for (const format of formats) {
+    const at2 = labels.indexOf(format);
+    const source = images[at2];
+    if (at2 < 0 || typeof source !== "string") continue;
+    const slug = formatSlug(format);
+    const ratio = nearestSupportedAspectRatio("image_generate", model, format);
+    added.push(
+      {
+        id: `place_${slug}`,
+        type: "static_place",
+        inputs: { image: source },
+        params: {
+          format,
+          render_ratio: ratio,
+          ...placements ? { placements: [...placements] } : {},
+          ...copy ? { copy } : {}
+        },
+        tags: { role: STATIC_PLACE_ROLE }
+      },
+      {
+        id: `merge_${slug}`,
+        type: "static_extend_merge",
+        inputs: { placed: `$ref:place_${slug}.placed`, shown: `$ref:place_${slug}.shown`, keep: `$ref:place_${slug}.keep` },
+        params: {
+          render_ratio: ratio,
+          paint: {
+            model,
+            aspect_ratio: ratio,
+            ...params.quality !== void 0 ? { quality: params.quality } : {},
+            ...params.image_size !== void 0 ? { image_size: params.image_size } : {},
+            prompt: EXTEND_PROMPT
+          }
+        }
+      }
+    );
+    delivered[at2] = `$ref:merge_${slug}.image`;
+  }
+  if (added.length === 0) return canvas;
+  const at = nodes.indexOf(final);
+  return {
+    ...holder,
+    nodes: [...nodes.slice(0, at), ...added, { ...final, inputs: { ...final.inputs, images: delivered } }, ...nodes.slice(at + 1)]
+  };
+}
+function placingCopy(nodes) {
+  const told = nodes.find(
+    (n) => (n.type === "static_safe_fit" || n.type === "static_place") && Array.isArray(n.params?.copy)
+  )?.params?.copy;
+  if (Array.isArray(told)) return told;
+  const kept = nodes.find((n) => n.type === "image_aspect_adapt" && Array.isArray(n.params?.copy))?.params?.copy;
+  return Array.isArray(kept) ? kept.filter((t) => typeof t === "string").map((text) => ({ text })) : void 0;
+}
+function withDeliveredSizes(canvas, last) {
+  const holder = canvas;
+  if (!Array.isArray(holder.nodes)) return canvas;
+  const final = holder.nodes.find((n) => n.id === "final" && n.type === "collect");
+  const labels = final?.params?.labels;
+  const images = final?.inputs?.images;
+  if (!final || !Array.isArray(labels) || !Array.isArray(images)) return canvas;
+  const ingests = [];
+  const roles = rolesById(canvas);
+  const delivered = images.map((ref, i) => {
+    const format = labels[i];
+    const file = typeof format === "string" ? last[format] : void 0;
+    if (!file || typeof format !== "string") return ref;
+    const id = `last_${formatSlug(format)}`;
+    const remote = /^(?:https?|data):/.test(file);
+    const from = typeof ref === "string" ? /^\$ref:([^.]+)\./.exec(ref)?.[1] : void 0;
+    const role = from ? roles[from] : void 0;
+    ingests.push({
+      id,
+      type: "ingest",
+      params: remote ? { source: "url", url: file, expect: "image" } : { source: "path", path: file, expect: "image" },
+      ...role === STATIC_MASTER_ROLE ? { tags: { role } } : {}
+    });
+    return `$ref:${id}.asset`;
+  });
+  const at = holder.nodes.indexOf(final);
+  return {
+    ...holder,
+    nodes: [
+      ...holder.nodes.slice(0, at),
+      ...ingests,
+      { ...final, inputs: { ...final.inputs, images: delivered } },
+      ...holder.nodes.slice(at + 1)
+    ]
+  };
+}
+
+// src/commands/canvas/shown-version.ts
+import { z } from "zod";
+var ShownResponse = z.object({
+  data: z.object({
+    runId: z.string(),
+    sourceSha: z.string().optional(),
+    createdAt: z.number(),
+    canvasSnapshotUrl: z.string().optional()
+  })
+});
+var SnapshotFiles = z.object({ files: z.array(z.object({ path: z.string(), url: z.string() })) });
+var HISTORY = {
+  shown: async (slug) => ShownResponse.parse(await apiPost("/api/creatives/run", { slug })).data,
+  file: async (url) => {
+    const res = await fetch(url);
+    return res.ok ? res.json() : null;
+  }
+};
+async function shownVersion(canvasRoot, slug, sources = HISTORY) {
+  const here = await readRenderState(canvasRoot, slug);
+  if (here.rendered) return here;
+  const run = await sources.shown(slug).catch(() => null);
+  if (!run) return here;
+  const prompt = run.canvasSnapshotUrl ? await drawnPrompt(run.canvasSnapshotUrl, sources) : void 0;
+  return {
+    ...here,
+    rendered: { sourceSha: run.sourceSha ?? "", runId: run.runId, at: run.createdAt },
+    ...prompt !== void 0 ? { prompt } : {}
+  };
+}
+async function drawnPrompt(manifestUrl, sources) {
+  const manifest = SnapshotFiles.safeParse(await sources.file(manifestUrl).catch(() => null));
+  const entry = manifest.success ? manifest.data.files.find((f) => f.path === GLOBAL_PROMPT_FILE) : void 0;
+  if (!entry) return void 0;
+  return await sources.file(entry.url).catch(() => null) ?? void 0;
+}
+
+// src/commands/canvas/static-run-review.ts
+import { readFile as readFile4 } from "fs/promises";
+import path6 from "path";
+
+// src/commands/canvas/glance-check.ts
+import sharp from "sharp";
+import { z as z2 } from "zod";
+var GLANCE_REQUIRED = {
+  offer: "guess",
+  for_whom: "unclear",
+  next_step: "unclear"
+};
+var GLANCE_WIDTH = 400;
+var GlanceAnswerSchema = ViewerAnswerSchema.extend({
+  /** What kind of product or service they take it for (D4). */
+  category: z2.object({ answer: z2.string().default(""), clarity: z2.enum(["clear", "guess", "unclear"]).default("unclear") }).default({ answer: "", clarity: "unclear" }),
+  stopped: z2.string().default(""),
+  me: z2.enum(["yes", "no", "unsure"]).default("unsure")
+});
+function wherePhrase(placements) {
+  const fullScreen = placements.length === 0 || placements.some((p) => /automatic|stor|reel/i.test(p));
+  return fullScreen ? "your Instagram or Facebook feed, Stories or Reels" : "your Instagram or Facebook feed";
+}
+function knowledge(viewer) {
+  if (!viewer.knows.includes("brand")) return "You have never heard of the advertiser.";
+  const offer = viewer.knows.includes("offer") ? " You know roughly what they sell." : "";
+  return `You have come across the advertiser before.${offer}`;
+}
+function buildGlancePrompt(input) {
+  const who = input.market ? `You are ${input.market}. ` : "";
+  return [
+    `${who}You are scrolling ${wherePhrase(input.viewer.placements)} on your phone. ${knowledge(input.viewer)}`,
+    "This ad passes under your thumb and holds you for about three seconds: you take in the picture and read the biggest words, not the small print. The image is shown at the size your phone shows it.",
+    "Answer as this person, from those three seconds alone. Do not fill gaps with what ads like this usually sell.",
+    'For each question give your answer in English and how sure you are: "clear" when the ad says it outright or you already know it; "guess" when you are piecing it together; "unclear" when you cannot tell.',
+    "offer: what is being sold or offered?",
+    "for_whom: who is it for?",
+    "next_step: what would you do next if you wanted it?",
+    "category: what kind of product or service is this for (a payroll app, a trade course, a phone)?",
+    'missing: in one short sentence, what you would need to be told to get it; "" when nothing.',
+    "stopped: what made you stop on it, or what nearly made you scroll past, in a few words.",
+    'me: is this for someone like you? "yes", "no" or "unsure".',
+    "",
+    'Reply with only this JSON: {"offer":{"answer":"","clarity":"clear|guess|unclear"},"for_whom":{"answer":"","clarity":"clear|guess|unclear"},"next_step":{"answer":"","clarity":"clear|guess|unclear"},"category":{"answer":"","clarity":"clear|guess|unclear"},"missing":"","stopped":"","me":"yes|no|unsure"}'
+  ].join("\n");
+}
+var QUESTION_WORDS = {
+  offer: "what is offered",
+  for_whom: "who it is for",
+  next_step: "what to do next"
+};
+function missWords(miss) {
+  if (miss.question === "presumes") return `it talks to them as a customer already ("${miss.viewerSaid}")`;
+  const said = miss.viewerSaid.trim() ? `"${miss.viewerSaid.trim()}"` : "nothing";
+  const what = QUESTION_WORDS[miss.question];
+  return miss.reason === "misread" ? `${what} (they were sure it is ${said})` : `${what} (they said ${said})`;
+}
+function glanceFindings(answer, intended, format, viewer, misread = { offer: false, category: false }) {
+  const verdict = judgeViewerAnswer({ ...answer, presumes: "" }, intended, GLANCE_REQUIRED, misread.offer);
+  const category = answer.category.answer.trim();
+  const kind = intended.recognition && category && misread.category ? [
+    {
+      severity: "warning",
+      what: `${format}: At a glance, a stranger took it for "${category}"; it is meant as ${intended.recognition}.`
+    }
+  ] : [];
+  if (verdict.pass) return kind;
+  const needed = answer.missing.trim() ? ` They needed: ${answer.missing.trim().replace(/[.!]+$/, "")}.` : "";
+  const missed = verdict.missed.map(missWords).join("; ");
+  return [
+    {
+      severity: "blocking",
+      what: `${format}: At a glance, ${describeViewer(viewer).replace(/, on .* placements$/, "")} could not tell ${missed}.${needed}`
+    },
+    ...kind
+  ];
+}
+async function glanceMisreads(answer, intended, judge) {
+  const sure = sureEnough(answer.offer.clarity, GLANCE_REQUIRED.offer);
+  const [offer = false, category = false] = await misreadings(
+    [
+      { said: sure ? answer.offer.answer : "", meant: intended.offer, sells: intended.sells },
+      { said: answer.category.answer, meant: intended.recognition }
+    ],
+    judge
+  );
+  return { offer, category };
+}
+function gatewayGlanceModel(onSpend) {
+  return (jpeg, prompt) => askAboutImages(GLANCE_CHECK_MODEL, [jpeg], prompt, onSpend);
+}
+async function glanceCheck(opts) {
+  let jpeg;
+  try {
+    const bytes = await bytesOf(opts.image);
+    jpeg = (await sharp(bytes).resize({ width: GLANCE_WIDTH }).jpeg({ quality: 85 }).toBuffer()).toString("base64");
+  } catch {
+    return null;
+  }
+  const prompt = buildGlancePrompt({ viewer: opts.viewer, ...opts.market ? { market: opts.market } : {} });
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const parsed = GlanceAnswerSchema.safeParse(await opts.ask(jpeg, prompt));
+    if (parsed.success) {
+      const misread = await glanceMisreads(parsed.data, opts.intended, opts.judge ?? jevReadJudge());
+      return glanceFindings(parsed.data, opts.intended, opts.format, opts.viewer, misread);
+    }
+  }
+  return null;
+}
+
+// src/commands/canvas/static-run-review.ts
+function imagesOf(output) {
+  const list = Array.isArray(output) ? output : [output];
+  const images = list.filter((o) => Boolean(o) && typeof o === "object");
+  return images.length > 0 && images.every((i) => i.kind === "image") ? images : null;
+}
+function promptPathOf(parsed) {
+  const nodes = parsed?.nodes;
+  if (!Array.isArray(nodes)) return null;
+  const prompt = nodes.find((n) => n?.id === "prompt" && n?.type === "ingest");
+  const p = prompt?.params;
+  return p?.source === "path" && p.expect === "json" && typeof p.path === "string" ? p.path : null;
+}
+function staticReviewTargets(parsed, output) {
+  const promptPath = promptPathOf(parsed);
+  const images = imagesOf(output);
+  if (!promptPath || !images) return null;
+  const labels = finalOutputLabelsFromCanvas(parsed)?.labels ?? [];
+  return {
+    promptPath,
+    // A local file when the run downloaded it, else its durable URL.
+    images: images.flatMap((image, i) => {
+      const source = typeof image.path === "string" ? image.path : typeof image.url === "string" ? image.url : null;
+      return source ? [{ path: source, format: labels[i] ?? "" }] : [];
+    })
+  };
+}
+function nodesOf(parsed) {
+  const nodes = parsed?.nodes;
+  return Array.isArray(nodes) ? nodes : [];
+}
+var refId = (ref) => typeof ref === "string" ? ref.match(/^\$ref:([a-z][a-z0-9_]*)\./)?.[1] ?? null : null;
+var hasRole = (n, role) => n.tags?.role === role;
+function variantCount(nodes) {
+  const calls = nodes.filter((n) => hasRole(n, STATIC_VARIANT_CALL_ROLE)).length;
+  if (calls > 0) return calls;
+  const one = nodes.find((n) => hasRole(n, STATIC_VARIANTS_ROLE) && n.type === "image_generate");
+  if (one) return typeof one.params?.n === "number" ? one.params.n : 1;
+  if (nodes.some((n) => hasRole(n, STATIC_FIX_ROLE))) return 1;
+  return nodes.filter((n) => n.type === "image_generate" && /^ad(_[a-z])?$/.test(String(n.id))).length;
+}
+function staticRunShape(parsed) {
+  const nodes = nodesOf(parsed);
+  const renders = nodes.filter((n) => n.type === "image_generate" && typeof n.id === "string");
+  const candidates = variantCount(nodes);
+  const logoIds = new Set(nodes.filter((n) => hasRole(n, BRAND_LOGO_ROLE)).map((n) => String(n.id)));
+  const logo = nodes.some((n) => hasRole(n, LOGO_COMPOSITE_ROLE)) || renders.some((n) => {
+    const refs = n.inputs?.reference;
+    return (Array.isArray(refs) ? refs : [refs]).some((r) => logoIds.has(refId(r) ?? ""));
+  });
+  const masterId = nodes.find((n) => hasRole(n, STATIC_MASTER_ROLE))?.id;
+  const adapt = nodes.find((n) => hasRole(n, STATIC_ADAPT_ROLE));
+  return {
+    candidates,
+    judged: candidates > 1 && nodes.some(
+      (n) => n.type === "image_select" && (hasRole(n, STATIC_PICK_ROLE) || n.id === "pick") || hasRole(n, VARIANT_PREFILTER_ROLE) && typeof n.params?.judge_model === "string"
+    ),
+    relays: masterId !== void 0 ? 0 : Math.max(0, renders.length - candidates),
+    cuts: nodes.filter((n) => {
+      const from = refId(n.inputs?.image);
+      return hasRole(n, STATIC_SIZE_ROLE) && from !== null && from === masterId;
+    }).length,
+    relaid: nodes.filter((n) => hasRole(n, STATIC_ADAPT_FORMAT_ROLE)).length,
+    adapted: Array.isArray(adapt?.params?.formats) ? adapt.params.formats.length : 0,
+    logo
+  };
+}
+function shapeHint(shape, copy) {
+  const variants = `${shape.candidates} variant${shape.candidates === 1 ? "" : "s"} rendered${shape.judged ? ", ranked by the checks with a judge on a tie" : ", no judge"}`;
+  const sizes = [
+    ...shape.relaid > 0 ? [`${shape.relaid} size${shape.relaid === 1 ? "" : "s"} re-laid out from the chosen picture (one request each)`] : [],
+    ...shape.cuts > 0 ? [`${shape.cuts} size${shape.cuts === 1 ? "" : "s"} cut from the chosen picture`] : [],
+    ...shape.adapted > 0 ? [`${shape.adapted} adapted from it`] : [],
+    ...shape.relays > 0 ? [`${shape.relays} other format${shape.relays === 1 ? "" : "s"} re-laid from the winner`] : []
+  ];
+  const text = copy === 0 ? "no copy (the picture is the ad)" : "the copy set by the model and read back word for word";
+  return `This run: ${variants}${sizes.length > 0 ? `; ${sizes.join("; ")}` : ""}; ${text}; ${shape.logo ? "the brand logo on the ad from its real file" : "no logo"}.`;
+}
+var PAID_FOR = {
+  edit: "one edit of the version shown",
+  sizes: "only the sizes asked for, laid out again",
+  options: "new options from scratch, every size made from the one chosen"
+};
+function runCostHint(stats, kind) {
+  if (!stats) return null;
+  const cached = stats.cached_nodes > 0 ? ` (${stats.cached_nodes} of ${stats.total_nodes} steps came from the cache, free)` : "";
+  return `This run cost ${Math.round(stats.total_credits)} credits: ${PAID_FOR[kind]}${cached}.`;
+}
+async function textOf(ref) {
+  const r = ref;
+  try {
+    if (typeof r?.path === "string") return await readFile4(r.path, "utf8");
+    if (typeof r?.url === "string") {
+      const res = await fetch(r.url);
+      return res.ok ? await res.text() : null;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+var FIX = "One thing wrong in a version that is otherwise right: `baker canvas run \u2026 --fix \"<what to change>\"` edits that version and changes only that, keeping the picture, the layout and the other words (one render). Wrong or missing words: check the lines in prompt.json `copy` are exactly what should be printed, shorten a line the model keeps breaking, and re-run: a change only to copy, positions or colours is made as an edit of the version shown. Wrong picture, colour or subject: edit prompt.json's `scene`, `colors` or `references`. Layout or a logo drawn wrong: say in each line's `position` (and `scene.layout`) where it sits, by what is around it. A right prompt that rolled badly: `baker canvas run \u2026 --regenerate static_variants` renders new options (every size follows from the new pick). One size wrong while the chosen picture is right (words cut or too small, the button small, something drawn twice): `baker canvas run \u2026 --regenerate adapt_<size>` (for example `adapt_9x16`) lays out that size again from the same picture (one request).";
+function verdictHints(verdict) {
+  if (verdict === "needs_fixes") {
+    return [
+      'NOT READY: the finished ad has blocking problems. Do not present it as done, and never ask the person whether to fix them: fix them now, inside this version. A defect in a version that is otherwise right is a `--fix`: it edits the chosen picture only, and every size is made from it again (each re-laid-out size takes one request; a cut is free). The same defect after a fix means the fix does not work: change the spec (prompt.json) or the approach, never the same retry. If it still cannot be fixed, show the person the best version and say in one plain sentence what is left, in their words ("the logo sits where Stories covers it"), without a question; never record your own checks as their feedback.',
+      FIX
+    ];
+  }
+  if (verdict === "not_reviewed") {
+    return [
+      "The finished ad was NOT reviewed: no model gateway key here, or the review model did not answer twice. Look at every word of every format yourself before showing it, or re-run the same command (every node comes from the cache) to review it again."
+    ];
+  }
+  if (verdict === "ready") {
+    return ["Reviewed every format of the finished ad: every word read back exactly, nothing to fix.", SHOW_IT];
+  }
+  return verdict === "ready_with_notes" ? [SHOW_IT] : [];
+}
+var SHOW_IT = `Show it as a Version ("Version 2"), never a run id or a file, in one line: the idea's message, who it is for, the customer quote it stands on (or that it is an explore bet), and the finding it answers. Name the versions you would run first; never ask which to keep or whether to publish: the person answers in their own time.`;
+function allowedSceneWords(spec) {
+  return [.../* @__PURE__ */ new Set([...spec.scene_text, ...spec.third_party_brands.map((b) => b.name)])];
+}
+function brandPalette(brand) {
+  if (!brand) return [];
+  const named = [brand.ink, brand.accent, brand.cta, brand.ground, ...brand.palette];
+  return [...new Set(named.filter((hex) => typeof hex === "string"))];
+}
+function safeAreaPlacements(viewer) {
+  const named = (viewer?.placements ?? []).filter((p) => p !== "automatic");
+  return named.length > 0 && named.length === viewer?.placements.length ? named : void 0;
+}
+function canvasPlacements(parsed) {
+  const node = nodesWithRole(parsed, VARIANT_PREFILTER_ROLE)[0];
+  const placements = node?.params?.placements;
+  return Array.isArray(placements) && placements.length > 0 && placements.every((p) => typeof p === "string") ? placements : void 0;
+}
+async function reviewStaticRun(opts) {
+  const targets = staticReviewTargets(opts.parsed, opts.output);
+  if (!targets) return null;
+  const prefilterId = nodesWithRole(opts.parsed, VARIANT_PREFILTER_ROLE)[0]?.id;
+  const tieBreak = prefilterId ? opts.outputsByNode[prefilterId]?.reasoning : void 0;
+  const pickId = nodesWithRole(opts.parsed, STATIC_PICK_ROLE)[0]?.id ?? "pick";
+  const reasoning = typeof tieBreak === "string" ? tieBreak : await textOf(opts.outputsByNode[pickId]?.reasoning);
+  const judge = reasoning ? parseJudgeScores(reasoning) : null;
+  let copy = [];
+  let mechanisms = [];
+  let intended = {};
+  let expectLogo = false;
+  let concept = null;
+  let uncast = [];
+  let brand = opts.brandName;
+  let lockup = [...opts.lockup ?? []];
+  let sceneText = [];
+  let lines = [];
+  let native;
+  let palette = [];
+  try {
+    const spec = readAdSpec(JSON.parse(await readFile4(targets.promptPath, "utf8")));
+    copy = spec.copy.map((l) => l.text);
+    lines = spec.copy.map((l) => ({ text: l.text, lettering: l.lettering, ...l.role ? { role: l.role } : {} }));
+    if (spec.native) {
+      copy = nativeCopy(spec.native);
+      lines = copy.map((text) => ({ text, lettering: "designed" }));
+      native = nativeSurfaceName(spec.native);
+    }
+    palette = spec.native ? [] : brandPalette(spec.brand);
+    mechanisms = spec.mechanism.map((m) => m.device);
+    brand = spec.brand?.name ?? opts.brandName;
+    const sells = marketQuery(
+      await readFile4(path6.resolve(path6.dirname(targets.promptPath), "../../../COMPANY.md"), "utf8").catch(() => "")
+    );
+    intended = {
+      ...spec.message?.trim() ? { offer: spec.message.trim() } : {},
+      ...spec.viewer?.who.trim() ? { persona: spec.viewer.who.trim() } : {},
+      ...spec.recognition?.trim() ? { recognition: spec.recognition.trim() } : {},
+      ...sells ? { sells } : {}
+    };
+    lockup = [.../* @__PURE__ */ new Set([...spec.brand?.lockup ?? [], ...lockup])];
+    sceneText = [
+      ...allowedSceneWords(spec),
+      ...spec.native ? nativeChrome(spec.native, spec.viewer?.market?.language, interfaceWordsOf(opts.parsed)) : []
+    ];
+    expectLogo = spec.logo && !spec.native && staticRunShape(opts.parsed).logo;
+    concept = conceptSummary(spec);
+    const cacheDir = path6.join(findWorkspaceRoot(path6.dirname(targets.promptPath)) ?? path6.dirname(targets.promptPath), "canvas", ".cache");
+    const people = spec.native ? [] : await peopleReader(cacheDir, (u) => opts.onSpend?.(u))(copy) ?? [];
+    uncast = uncastPeople(spec, people);
+  } catch {
+    copy = [];
+  }
+  const shape = staticRunShape(opts.parsed);
+  const placements = canvasPlacements(opts.parsed) ?? safeAreaPlacements(opts.viewer);
+  const masterFormat = staticMasterFormat(opts.parsed) ?? void 0;
+  const glancing = opts.glance === false ? Promise.resolve(null) : glanceAtFinished(
+    targets.images,
+    opts.viewer ?? STRANGER,
+    intended,
+    opts.glance ?? gatewayGlanceModel(opts.onSpend),
+    opts.onSpend
+  ).catch(() => null);
+  const comparing = opts.previous ? nearIdenticalFindings(targets.images, opts.previous).catch(() => []) : Promise.resolve([]);
+  const untouched = opts.settled ? await samePictureSizes(targets.images, opts.settled.images) : [];
+  const changed = targets.images.filter((i) => !untouched.includes(i.format));
+  const review = await reviewRenderedStatic({
+    images: changed.length > 0 ? changed : targets.images,
+    copy,
+    lines,
+    palette,
+    ...placements ? { placements } : {},
+    ...brand ? { brand } : {},
+    ...lockup.length > 0 ? { lockup } : {},
+    ...sceneText.length > 0 ? { sceneText } : {},
+    ...masterFormat ? { masterFormat } : {},
+    ...expectLogo ? { expectLogo } : {},
+    ...concept && concept.mustKeep.length > 0 && referenceSource(opts.parsed) ? { concept: { ...concept, reference: referenceSource(opts.parsed) } } : {},
+    logo: shape.logo,
+    ...native ? { native } : {},
+    ...uncast.length > 0 ? { uncastPeople: uncast } : {},
+    ...native ? { scrolled: scrolledLines(opts.parsed, opts.outputsByNode) } : {},
+    mechanisms,
+    ...opts.viewer ? { viewer: describeViewer(opts.viewer) } : {},
+    onSpend: opts.onSpend
+  });
+  const [glanced, compared] = await Promise.all([glancing, comparing]);
+  const glance = review === null ? null : glanced;
+  const unchanged = review === null ? [] : compared;
+  const fresh = review === null ? null : [...review, ...glance ?? [], ...unchanged];
+  const reviewed = fresh === null || !opts.settled ? fresh : carryUnchanged(fresh, opts.settled.review, untouched);
+  const verdict = staticVerdict(reviewed);
+  const hints = verdictHints(verdict);
+  const sizeHints = verdict === "needs_fixes" ? sizeFixHints(opts.parsed, reviewed) : [];
+  const sizesFirst = sizeHints[0]?.startsWith("Do this first") === true;
+  if (sizesFirst) hints.push(...sizeHints);
+  for (const f of reviewed ?? []) hints.push(`${f.severity === "blocking" ? "Must fix" : "Should fix"}: ${f.what}`);
+  if (review !== null && glance === null && opts.glance !== false) {
+    hints.push("The finished ad was not shown to a stranger at a glance (the model did not answer): look at the 4:5 at phone size yourself and say what it sells in three seconds.");
+  }
+  if (!sizesFirst) hints.push(...sizeHints);
+  hints.push(shapeHint(shape, copy.length));
+  hints.push(...variantHints(judge, prefilterOutcome(opts.parsed, opts.outputsByNode)));
+  return { review: reviewed, verdict, judge, hints };
+}
+function scrolledLines(parsed, outputsByNode) {
+  return Object.fromEntries(
+    nodesOf(parsed).flatMap((n) => {
+      const out = typeof n.id === "string" ? outputsByNode[n.id] : void 0;
+      const format = n.params?.format;
+      return n.type === "static_native" && typeof format === "string" && Array.isArray(out?.scrolled) ? [[format, out.scrolled.filter((t) => typeof t === "string")]] : [];
+    })
+  );
+}
+function referenceSource(parsed) {
+  const original = nodesOf(parsed).find((n) => n.id === "original" && n.type === "ingest");
+  const source = original?.params?.url ?? original?.params?.path;
+  return typeof source === "string" && !source.includes("[TODO") ? source : null;
+}
+function interfaceWordsOf(parsed) {
+  const nodes = parsed?.nodes;
+  const screen = Array.isArray(nodes) ? nodes.find((n) => n?.type === "static_native") : void 0;
+  return readInterfaceWords(screen?.params?.interface_words) ?? void 0;
+}
+var STRANGER = { temperature: "cold", knows: [], placements: ["automatic"], source: "knowledge", reasons: [] };
+async function glanceAtFinished(images, viewer, intended, ask, onSpend) {
+  const shown = images.find((i) => i.format === "4:5") ?? images[0];
+  if (!shown) return null;
+  return await glanceCheck({
+    image: shown.path,
+    format: shown.format,
+    viewer,
+    intended,
+    ask,
+    judge: jevReadJudge(onSpend),
+    ...viewer.market ? { market: describeMarket(viewer.market) } : {}
+  });
+}
+function sizeFixHints(parsed, review) {
+  const relaid = nodesWithRole(parsed, STATIC_ADAPT_FORMAT_ROLE).map(
+    (n) => n.id
+  );
+  const blocking = (review ?? []).filter((f) => f.severity === "blocking");
+  const regenerate = relaid.flatMap((id) => {
+    const format = formatOfAdaptId(id);
+    if (!format || !blocking.some((f) => f.what.startsWith(`${format}:`))) return [];
+    return [
+      `The ${format} alone needs fixing and the chosen picture is right: \`baker canvas run \u2026 --regenerate ${id}\` lays out the ${format} again from the same picture (one request). If the chosen picture itself is wrong, \`--fix\` it instead: every size follows.`
+    ];
+  });
+  const relaidFormats = relaid.map(formatOfAdaptId).filter((f) => Boolean(f));
+  const sizesOnly = regenerate.length > 0 && blocking.every((f) => relaidFormats.some((format) => f.what.startsWith(`${format}:`)));
+  const lead = sizesOnly ? regenerate.map((h, i) => i === 0 ? `Do this first, not a --fix: ${h}` : h) : regenerate;
+  return [...lead, ...safeFitHints(parsed, blocking)];
+}
+var COVERED = / sits? where .+? covers? (?:it|them) /;
+function safeFitHints(parsed, blocking) {
+  return nodesWithRole(parsed, STATIC_SAFE_FIT_ROLE).flatMap((n) => {
+    const format = typeof n.params?.format === "string" ? n.params.format : formatOfSlug(n.id.replace(/^safe_/, ""));
+    if (!blocking.some((f) => f.what.startsWith(`${format}:`) && COVERED.test(f.what))) return [];
+    return [
+      `The ${format} was already shrunk and shifted automatically to clear what the app covers; small misses are corrected that way, so this one is too large for it. Change the layout itself (shorter copy, fewer lines, a smaller block of text) rather than a \`--fix\` asking to move it, which moves it only about 1%.`
+    ];
+  });
+}
+function formatOfSlug(slug) {
+  return slug.replace("x", ":").replace("_", ".");
+}
+function prefilterNodeId(parsed) {
+  return nodesWithRole(parsed, VARIANT_PREFILTER_ROLE)[0]?.id ?? null;
+}
+function prefilterOutcome(parsed, outputsByNode) {
+  const id = prefilterNodeId(parsed);
+  const out = id ? outputsByNode[id] : void 0;
+  return out && Array.isArray(out.dropped) ? out : null;
+}
+function prefilterSpend(parsed, outputsByNode, nodeRuns) {
+  const cached = (id2) => nodeRuns.some((r) => r.node_id === id2 && r.cached);
+  const id = prefilterNodeId(parsed);
+  const checks = id && !cached(id) ? prefilterOutcome(parsed, outputsByNode)?.usage ?? [] : [];
+  const fits = [...nodesWithRole(parsed, STATIC_SAFE_FIT_ROLE), ...nodesWithRole(parsed, STATIC_PLACE_ROLE)].filter((n) => !cached(n.id)).flatMap((n) => {
+    const usage = outputsByNode[n.id]?.usage;
+    return Array.isArray(usage) ? usage : [];
+  });
+  return [...checks, ...fits];
+}
+function variantHints(judge, prefilter) {
+  const hints = [];
+  const dropped = prefilter?.dropped ?? [];
+  const kept = Array.isArray(prefilter?.images) ? prefilter.images.length : judge?.length ?? 0;
+  const total = dropped.length + kept;
+  if (prefilter?.flagged) {
+    hints.push(
+      `Every variant failed the checks; variant ${prefilter.flagged.index + 1} had the fewest problems and was kept: ${prefilter.flagged.reasons.join(" ")}`
+    );
+  } else if (dropped.length > 0) {
+    const list = dropped.map((d) => `variant ${d.index + 1} (${d.reasons.join(" ")})`).join("; ");
+    hints.push(`${dropped.length} of ${total} variants set aside by the checks before the judge: ${list}.`);
+  }
+  const alone = prefilter?.order?.length === 1 && !prefilter.flagged ? prefilter.order[0] : void 0;
+  if (alone !== void 0 && dropped.length > 0) {
+    hints.push(
+      `The checks ranked variant ${alone + 1} best, so no judge was needed; the others stay in this run as options the person can switch to (\`baker canvas run --use-variant\`).`
+    );
+  }
+  const winner = judge ? judgeWinner(judge) : null;
+  if (judge && winner) {
+    const gone = new Set(dropped.map((d) => d.index));
+    const shown = prefilter?.order ?? Array.from({ length: total }, (_, i) => i).filter((i) => !gone.has(i));
+    const variant = (shown[winner.image - 1] ?? winner.image - 1) + 1;
+    const why = winner.of === void 0 ? `${winner.total}/${Object.keys(winner.scores).length * 5}` : `first on ${Object.entries(winner.scores).filter(([, beaten]) => beaten === winner.of).map(([criterion]) => criterion.replace(/_/g, " ")).join(", ") || "none of the criteria alone"}`;
+    hints.push(
+      `The judge picked variant ${variant} of the ${judge.length} it compared (${why}); the others it compared stay in this run as options the person can switch to (\`baker canvas run --use-variant\`).`
+    );
+  }
+  return hints;
+}
+
+// src/commands/canvas/static-spec-repair.ts
+import { readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+import sharp2 from "sharp";
+import { z as z3 } from "zod";
+var Answer = z3.object({
+  changed: z3.string().min(1),
+  set: z3.array(z3.object({ path: z3.string().min(1), value: z3.unknown() }))
+});
+function withValueAt(root, path8, value) {
+  const [key, ...rest] = path8;
+  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 printedWords(spec) {
+  return [...spec.copy.map((l) => l.text), ...spec.native ? nativeCopy(spec.native) : []];
+}
+function acceptRepair(before, answer) {
+  const parsed = Answer.safeParse(answer);
+  if (!parsed.success || !isAdSpec(before)) return null;
+  const spec = parsed.data.set.reduce((at, { path: path8, value }) => withValueAt(at, path8.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"]) {
+    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;
+  const kept = printedWords(now.data);
+  if (!printedWords(was.data).every((text) => kept.includes(text))) return null;
+  return { changed: parsed.data.changed, spec };
+}
+function buildSpecRepairPrompt(spec, findings, schema) {
+  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}`),
+    "",
+    "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. 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.",
+    "- 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");
+}
+var REPAIR_TIMEOUT_MS = 15e4;
+var SHOWN_WIDTH = 768;
+async function repairSpec(opts) {
+  const text = await readFile5(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 sharp2(bytes).resize({ width: SHOWN_WIDTH }).jpeg({ quality: 85 }).toBuffer()).toString("base64")).catch(() => null) : null;
+  const prompt = buildSpecRepairPrompt(text, opts.findings, adSpecJsonSchema());
+  const repair = acceptRepair(before, await askAboutImages(RENDER_REVIEW_MODEL, shown ? [shown] : [], prompt, opts.onSpend, REPAIR_TIMEOUT_MS));
+  if (!repair) return null;
+  await writeFile4(opts.promptPath, `${JSON.stringify(repair.spec, null, 2)}
+`, "utf8");
+  return repair.changed;
+}
+
+// src/commands/canvas/run.ts
+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, --regenerate adapt_9x16 lays out the 9:16 again from the picture the last version shows, its --fix correction or chosen variant included, 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: path7.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 = path7.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(path7.resolve(opts.file)) : null);
+  if (!slug) return false;
+  const root = findWorkspaceRoot(opts.file ? path7.dirname(path7.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;
+}
+var canvasHeld = false;
+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;
+  if (creativeSlug) await clearLegacyDirtyMarker(canvasRoot, creativeSlug);
+  const turnId = optionalTurnId();
+  const turnCache = opts.cacheDir ?? path7.join(canvasRoot, ".cache");
+  const refuseTurnRender = async (correction) => {
+    if (!creativeSlug || (opts.autoFixRound ?? 0) > 0) return;
+    const refusal = turnRenderRefusal(await readTurnRenders(turnCache), turnId, creativeSlug, { correction });
+    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 readFile6(path7.join(path7.dirname(filePath), "prompt.json"), "utf8").then((text) => JSON.parse(text)).catch(() => null);
+  await refuseTurnRender(mayBeCorrection(opts, shown.prompt, promptOnDisk));
+  const citing = [];
+  await wireProofBadges(
+    path7.join(path7.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(
+      path7.join(path7.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}
+`)
+    });
+  } 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 = !native && opts.fix === void 0 && opts.useVariant === void 0 && opts.regenerate === void 0 && opts.from === void 0 && shown.rendered ? specEditInstruction(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 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), re-lay out just the size at fault with `--regenerate adapt_<size>`, 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);
+    }
+    grown = await growOn(from, { kind: "edit", instruction, promptJson: promptNow });
+    parsed = grown ? grown.canvas : fixStaticAd(parsed, { instruction, previous, promptJson: promptNow });
+    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 path8 = delivered.find((d) => d.format === formatOfAdaptId(n.id))?.path;
+        return path8 ? [[n.id, path8]] : [];
+      })
+    );
+    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) 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) {
+      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 && makesSameVariants(parsed, version, await ingestedNow(variantFiles(parsed), path7.dirname(filePath)));
+    grown = version && same ? growFromVersion(parsed, version, { kind: "keep" }) : 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 === formatOfAdaptId(id))?.path;
+          parsed = last ? withRelayEdit(parsed, id, { previous: last, instruction, asked: opts.relayAsked?.[id] ?? [] }) : withRelayNote(parsed, [id], instruction);
+        }
+        const relaid = resolved.flatMap((id) => formatOfAdaptId(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 ?? path7.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 ? path7.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: path7.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(path7.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 held = await markCanvasBusy(outputsDir, filePath, runId);
+    canvasHeld = true;
+    process.once("exit", held.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: path7.relative(path7.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 } : {}
+  };
+  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) {
+      await recordRendered(canvasRoot, creativeSlug, sourceSha, result.run_id, {
+        ...promptNow ? { prompt: promptNow } : {},
+        ...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 review = reviewable ? await reviewRenderedVideo({
+      video: reviewable,
+      windows: await sceneWindowsBeside(filePath),
+      ...await reviewContextBeside(filePath),
+      brief: opts.brief?.trim() || void 0,
+      onSpend: (usage) => reviewUsage.push(usage)
+    }) : null;
+    const brandKit = reviewable ? null : await readStaticBrandKit(await findBrandRoot(path7.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(path7.dirname(filePath)) : null;
+    const seriesHints = seriesRoot && creativeSlug ? seriesRunHints(creativeSlug, {
+      leads: await seriesLeadsAbove(seriesRoot, creativeSlug),
+      members: await seriesMembers(seriesRoot, creativeSlug)
+    }) : [];
+    const hints = 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 re-lay out only that size).`
+      ] : []
+    ] : 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 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(path7.join(path7.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 ?? [] : [];
+    if (briefFindings.length > 0) {
+      const target = staticReviewTargets(parsed, result.output);
+      const spent = [];
+      respecced = target ? await repairSpec({
+        promptPath: target.promptPath,
+        findings: briefFindings,
+        ...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) {
+      const did = step.kind === "respec" ? `The spec was corrected: ${respecced}` : step.kind === "fix" ? `The picture was corrected for: ${step.instruction.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) => id.replace(/^adapt_/, "").replace("x", ":")).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 held = await takeUnbilledSpend(cacheDir);
+      return held.length > 0 ? { ...payload, reviewUsage: held } : 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-CZYUZL6R.js.map