@stage5/lumine 0.3.76 → 0.3.78

package/lib/admin-arena.js

@@ -13,8 +13,13 @@ import path from "node:path";
 //                              at once; a dry run (validation only) unless --confirm;
 //                              re-importing a folder retires that paper's earlier items
 //   status --item <id> --to live|retired|checked
+//   picture-audit [--items <ids> | --cursor <id>] [--limit 1-20] [--renders <dir>]
+//                              advisory JEV image review list of live picture
+//                              items; never retires or edits. --renders holds
+//                              <itemId>.png renders of picture-option items
+//                              (panels are drawn by the web, not stored)
 export const ARENA_USAGE =
-  "Usage: lumine admin arena queue | paper-queue [--cursor <id>] [--limit <1-100>] | marking [--cursor <id>] [--limit <1-200>] | import (--dir <paper folder> | --additive --file <reviewed-items.json>) [--audio audio/<exam>/<paper>] [--live] [--confirm] | status --item <id> --to live|retired|checked [--confirm] | today-queue [--cursor <id>] [--limit <1-100>] | today-member --user <id> | today-import --file <reviewed-questions.json> [--confirm] [--json]";
+  "Usage: lumine admin arena queue | paper-queue [--cursor <id>] [--limit <1-100>] | marking [--cursor <id>] [--limit <1-200>] | import (--dir <paper folder> | --additive --file <reviewed-items.json>) [--audio audio/<exam>/<paper>] [--live] [--confirm] | status --item <id> --to live|retired|checked [--confirm] | today-queue [--cursor <id>] [--limit <1-100>] | today-member --user <id> | today-import --file <reviewed-questions.json> [--confirm] | picture-audit [--items <id,id,...> | --cursor <id>] [--limit <1-20>] [--renders <dir of <itemId>.png>] [--output <review-list.json>] [--json]";
 const MAX_ITEMS = 300;
 
 function validationError(message) {
@@ -62,7 +67,60 @@ function readAdditiveItems(file) {
   return items;
 }
 
+const PICTURE_AUDIT_MAX = 20;
+const RENDER_MAX_BYTES = 3 * 1024 * 1024;
+// The API's JSON body limit is 8 MB; keep a margin for base64 framing.
+const RENDERS_TOTAL_MAX_BYTES = 5 * 1024 * 1024;
+
+function readRenders(dir, itemIds) {
+  const folder = path.resolve(dir);
+  let names;
+  try {
+    names = fs.readdirSync(folder).filter((name) => /^\d{1,10}\.(png|jpe?g)$/i.test(name));
+  } catch {
+    throw validationError(`Cannot read the renders folder ${folder}.`);
+  }
+  const renders = {};
+  let total = 0;
+  for (const name of names) {
+    const id = name.replace(/\..*$/, "");
+    if (itemIds && !itemIds.includes(Number(id))) continue;
+    const bytes = fs.readFileSync(path.join(folder, name));
+    if (!bytes.length || bytes.length > RENDER_MAX_BYTES) throw validationError(`${name} must be a PNG or JPEG of at most 3 MB.`);
+    total += bytes.length;
+    if (total > RENDERS_TOTAL_MAX_BYTES) throw validationError("Renders for one call must total under 5 MB; audit fewer --items at a time.");
+    renders[id] = bytes.toString("base64");
+  }
+  if (Object.keys(renders).length > PICTURE_AUDIT_MAX) throw validationError(`Send renders for at most ${PICTURE_AUDIT_MAX} items per call (use --items).`);
+  return renders;
+}
+
 export function buildArenaOperation({ action, options }) {
+  if (action === "picture-audit") {
+    const limit = Number(options.adminLimit ?? 10);
+    if (!Number.isInteger(limit) || limit < 1 || limit > PICTURE_AUDIT_MAX) throw validationError(`Use --limit from 1 to ${PICTURE_AUDIT_MAX}.`);
+    let itemIds = null;
+    if (options.adminArenaItems) {
+      itemIds = options.adminArenaItems.split(",").map((value) => Number(value.trim()));
+      if (!itemIds.length || itemIds.length > PICTURE_AUDIT_MAX || itemIds.some((id) => !Number.isSafeInteger(id) || id <= 0)) {
+        throw validationError(`--items is 1-${PICTURE_AUDIT_MAX} comma-separated item ids.`);
+      }
+      if (options.adminCursor) throw validationError("Use --items or --cursor, not both.");
+    }
+    const cursor = Number(options.adminCursor || 0);
+    if (!Number.isSafeInteger(cursor) || cursor < 0) throw validationError("Use a non-negative --cursor.");
+    const body = { limit, ...(itemIds ? { itemIds } : { cursor }) };
+    if (options.adminArenaRenders) body.renders = readRenders(options.adminArenaRenders, itemIds);
+    return {
+      name: "arena.picture-audit",
+      method: "POST",
+      path: "/cli/admin/arena/picture-audit",
+      body,
+      mutates: false,
+      requiresRun: false,
+      timeoutMs: 600000,
+    };
+  }
   if (action === "paper-queue") {
     const cursor = Number(options.adminCursor || 0);
     const limit = Number(options.adminLimit ?? 50);
@@ -174,6 +232,16 @@ export function formatArenaResult({ operation, data }) {
     data?.nextCursor ? `Continue: lumine admin arena today-queue --cursor ${data.nextCursor} --json` : "End of Today’s Q queue.",
   ];
   if (operation.name === "arena.today.member") return [JSON.stringify(data, null, 2)];
+  if (operation.name === "arena.picture-audit") {
+    const items = data?.items || [];
+    return [
+      `Picture audit (advisory; nothing retired or edited): ${items.length} items, ${data?.review?.length || 0} to review, ${data?.needsRender?.length || 0} need a render.`,
+      ...items.map((row) => `#${row.itemId} ${row.examFamily} ${row.itemType}${row.number ? ` no ${row.number}` : ""} [${row.kind || "-"}]: ${
+        row.status === "audited" ? `${row.verdict === "flag" ? "REVIEW" : "ok"}${row.cached ? " (saved)" : ""}${row.notes?.length ? ` · ${row.notes.join("; ")}` : ""}` : `${row.status} (${row.reason})`}`),
+      data?.nextCursor ? `Continue: lumine admin arena picture-audit --cursor ${data.nextCursor} --output <file> --json` : "End of live picture items.",
+      data?.notice || "",
+    ].filter(Boolean);
+  }
   if (operation.name === "arena.today.preview" || operation.name === "arena.today.import") return [
     `${data?.dryRun ? "Dry run" : "Saved"}: ${data?.questions?.length || 0} reviewed personal questions.${data?.dryRun ? " Add --confirm to make new questions available." : ""}`,
   ];

package/lib/admin-daily.js

@@ -10,6 +10,7 @@ import { createDailyReviewState, dailyRunProgress } from "./admin-duties.js";
 import { summarizeOwnerViewport, formatOwnerViewportReport } from "./admin-owner-viewport.js";
 import { createDailyCollection } from "./admin-daily-collection.js";
 import { collectDiagnosticPages, diagnosticCollectionSummary } from "./admin-diagnostic-collection.js";
+import { JEV_THUMBNAIL_MAX_TARGETS } from "./admin-jev-images.js";
 export { dailyRunProgress };
 
 // Multi-step conveniences for the full daily management run. Each one runs
@@ -188,7 +189,7 @@ export async function dailyRunGather(options, { run = runAdmin, now, clock } = {
     collection.invalidate(steps.at(-1).name);
     Object.assign(steps.at(-1), { ok: false, error });
   };
-  const evidenceNames = /^(ai-costs|media-costs|reward-activity|reward-diagnostics|jev-review|owner-wake|bot-output)/;
+  const evidenceNames = /^(ai-costs|media-costs|reward-activity|reward-diagnostics|jev-review|jev-images|owner-wake|bot-output)/;
   const step = (name, args, file) => {
     const res = collection.collect(name, args, file, evidenceNames.test(name) ? "evidence" : "priority", run);
     steps.push({
@@ -283,6 +284,10 @@ export async function dailyRunGather(options, { run = runAdmin, now, clock } = {
     since: jevUntil - 86400, until: jevUntil, step, failLast });
   writeAdminJsonFile(path.join(dir, "jev-review-summary.json"), diagnosticCollectionSummary(jevReview), { privateFile: true });
   steps.push({ name: "jev-review-summary", file: "jev-review-summary.json", ok: true });
+  // JEV image checks (advisory): per-area health, cost, agreement with final
+  // decisions, disagreements and escalations for the report's "JEV images"
+  // section. A failed step is unavailable evidence, not a quiet day.
+  step("jev-images", ["jev-images", "report", "--days", "1"], "jev-images.json");
   // One pending queue covers every Build approval type. Exhaust its cursor;
   // an empty/malformed receipt must not look like an empty queue.
   const buildReviews = { complete: false, pages: 0, items: 0 };
@@ -459,6 +464,25 @@ export async function dailyRunGather(options, { run = runAdmin, now, clock } = {
 
 // Recent, provably never-Featured Subjects with the context the editorial
 // ranking needs (comment count, operator view state), newest first.
+export function featuredThumbnailChecks(eligible, run = runAdmin) {
+  const ids = eligible.slice(0, JEV_THUMBNAIL_MAX_TARGETS).map((c) => `subject:${c.id}`);
+  if (!ids.length) return { summary: { status: "none" } };
+  const res = run(["jev-images", "thumbnails", "--targets", ids.join(",")], { timeoutMs: 200000 });
+  const data = res.ok ? res.json?.data : null;
+  if (!data || !Array.isArray(data.items)) {
+    for (const c of eligible) c.thumbnailCheck = { status: "unavailable", reason: "request_failed" };
+    return { summary: { status: "unavailable", reason: "request_failed", advisory: true } };
+  }
+  const byTarget = new Map(data.items.map((item) => [item.target, item]));
+  for (const c of eligible) {
+    const item = byTarget.get(`subject:${c.id}`);
+    c.thumbnailCheck = item
+      ? { status: item.status, ...(item.kind ? { kind: item.kind } : {}), ...(item.status === "ok" ? { verdict: item.verdict, notes: item.notes || [], cached: Boolean(item.cached) } : { reason: item.reason }) }
+      : { status: "unavailable", reason: "not_checked" };
+  }
+  return { summary: { status: data.status, flagged: data.flagged || [], advisory: true, notice: data.notice } };
+}
+
 export async function featuredCandidates(options) {
   const days = Math.max(1, Math.min(30, Number(options.adminDays || 7)));
   const after = options.adminAfter || bangkokCutoff(days);
@@ -524,6 +548,10 @@ export async function featuredCandidates(options) {
       operatorViewed: Boolean(s.operatorViewed?.viewed),
     });
   }
+  // Advisory JEV thumbnail notes (never a ranking or eligibility input). A
+  // failed or switched-off check leaves the candidate list exactly as before.
+  const eligible = candidates.filter((c) => c.neverFeatured === true);
+  const thumbnailChecks = featuredThumbnailChecks(eligible);
   return {
     ok: true,
     status: "success",
@@ -531,7 +559,8 @@ export async function featuredCandidates(options) {
       postedAfter: after,
       coverage: history.json.data.coverage || null,
       boardCount: onBoard.size,
-      eligible: candidates.filter((c) => c.neverFeatured === true),
+      eligible,
+      thumbnailChecks: thumbnailChecks.summary,
       excluded: candidates
         .filter((c) => c.neverFeatured !== true)
         .map((c) => ({ id: c.id, title: c.title, neverFeatured: c.neverFeatured })),

package/lib/admin-jev-images.js

@@ -0,0 +1,158 @@
+// `lumine admin jev-images report|switch|decide` (twinkle-api
+// controllers/cli/admin/jevImages.ts): JEV image checks are advisory only.
+//   report [--days 1..30]                     per-area health, cost, agreement,
+//                                             disagreements and escalations
+//   switch --area <area|all> --mode on|off [--daily-cap <n>]   owner only;
+//                                             takes effect within 30 s, no deploy
+//   decide --area <area> --key <subject> --decision <decision>   record a
+//                                             reviewer's final decision
+//   thumbnails --targets subject:<id>,build:<id>,... | --featured [--saved-only]
+//                                             advisory thumbnail notes for
+//                                             Featured review (area thumbnail)
+export const JEV_IMAGES_AREAS = ["arena_paper", "arena_picture", "study_record", "thumbnail", "sdk_decide"];
+export const JEV_IMAGES_USAGE =
+  "Usage: lumine admin jev-images report [--days 1..30] | switch --area <" +
+  ["all", ...JEV_IMAGES_AREAS].join("|") +
+  "> --mode on|off [--daily-cap <0-5000>] [--build <id>, sdk_decide only, no --daily-cap] | decide --area <area> --key <subject key, e.g. arenaItem:10176> --decision <decision> | thumbnails --targets <subject:<id>,build:<id>,...> | --featured [--saved-only] [--json]";
+export const JEV_THUMBNAIL_MAX_TARGETS = 40;
+
+function invalid(message) {
+  const error = new Error(message);
+  error.code = "CLI_ADMIN_CLI_VALIDATION";
+  return error;
+}
+
+export function buildJevImagesOperation({ action, options = {} }) {
+  if (!action || action === "report") {
+    const days = options.adminDays === "" || options.adminDays == null ? 1 : Number(options.adminDays);
+    if (!Number.isInteger(days) || days < 1 || days > 30) throw invalid("--days must be 1 to 30.");
+    return {
+      name: "jev-images.report",
+      method: "GET",
+      path: `/cli/admin/jev-images/report?days=${days}`,
+      body: undefined,
+      mutates: false,
+      requiresRun: false,
+    };
+  }
+  if (action === "switch") {
+    const area = String(options.adminJevArea || "");
+    if (area !== "all" && !JEV_IMAGES_AREAS.includes(area)) throw invalid(JEV_IMAGES_USAGE);
+    const mode = String(options.adminMode || "");
+    if (mode !== "on" && mode !== "off") throw invalid("--mode is on or off.");
+    const body = { area, mode };
+    if (options.adminJevDailyCap !== "" && options.adminJevDailyCap != null) {
+      const cap = Number(options.adminJevDailyCap);
+      if (area === "all" || !Number.isInteger(cap) || cap < 0 || cap > 5000) {
+        throw invalid("--daily-cap is set per area, 0 to 5000.");
+      }
+      body.dailyCap = cap;
+    }
+    // One app's switch for sdk_decide (Twinkle.ai.decide with images). An app
+    // has no daily cap of its own; bursts are limited by the server.
+    if (options.adminBuild !== "" && options.adminBuild != null) {
+      const buildId = Number(options.adminBuild);
+      if (area !== "sdk_decide" || !Number.isSafeInteger(buildId) || buildId <= 0) {
+        throw invalid("--build is set only with --area sdk_decide and a build id.");
+      }
+      if (body.dailyCap !== undefined) throw invalid("--build sets one app's switch only (--mode on|off); an app has no daily cap of its own.");
+      body.buildId = buildId;
+    }
+    return {
+      name: "jev-images.switch",
+      method: "POST",
+      path: "/cli/admin/jev-images/switch",
+      body,
+      mutates: true,
+      requiresRun: false,
+    };
+  }
+  if (action === "decide") {
+    const area = String(options.adminJevArea || "");
+    if (!JEV_IMAGES_AREAS.includes(area)) throw invalid(JEV_IMAGES_USAGE);
+    const subjectKey = String(options.adminJevKey || "");
+    if (!/^[A-Za-z][A-Za-z0-9_-]{0,30}:[0-9][A-Za-z0-9:_-]{0,60}$/.test(subjectKey)) {
+      throw invalid("--key is a subject key such as arenaItem:10176 or arenaPaper:12.");
+    }
+    const decision = String(options.adminDecision || "");
+    if (!/^[a-z_]{2,24}$/.test(decision)) throw invalid("--decision is required (e.g. keep, fix, retired).");
+    return {
+      name: "jev-images.decide",
+      method: "POST",
+      path: "/cli/admin/jev-images/decide",
+      body: { area, subjectKey, decision },
+      mutates: true,
+      requiresRun: false,
+    };
+  }
+  if (action === "thumbnails") {
+    const featured = options.adminFeatured === true;
+    const raw = String(options.adminTargets || "").trim();
+    if (featured === Boolean(raw)) throw invalid("Use --targets subject:<id>,build:<id>,... or --featured (the current board), not both.");
+    const body = featured ? { featured: true } : { targets: parseThumbnailTargets(raw) };
+    // --saved-only: earlier answers only, no provider call.
+    if (options.adminSavedOnly === true) body.run = false;
+    return {
+      name: "jev-images.thumbnails",
+      method: "POST",
+      path: "/cli/admin/jev-images/thumbnails",
+      body,
+      mutates: false,
+      requiresRun: false,
+      timeoutMs: 180000,
+    };
+  }
+  throw invalid(JEV_IMAGES_USAGE);
+}
+
+export function parseThumbnailTargets(raw) {
+  const targets = [...new Set(String(raw).split(",").map((value) => value.trim()).filter(Boolean))];
+  if (!targets.length || targets.length > JEV_THUMBNAIL_MAX_TARGETS || targets.some((value) => !/^(subject|build):[1-9][0-9]{0,14}$/.test(value))) {
+    throw invalid(`--targets is 1-${JEV_THUMBNAIL_MAX_TARGETS} of subject:<id> or build:<id>, comma-separated.`);
+  }
+  return targets;
+}
+
+export function thumbnailLine(item) {
+  if (!item) return "no thumbnail check";
+  if (item.status !== "ok") return `no thumbnail check (${item.reason || "unavailable"})`;
+  return `${item.verdict === "flag" ? "LOOK AT THE THUMBNAIL" : "thumbnail looks fine"}${item.cached ? " (saved)" : ""}${item.notes?.length ? ` · ${item.notes.join("; ")}` : ""}`;
+}
+
+const usd = (value) => `$${Number(value || 0).toFixed(4)}`;
+
+export function formatJevImagesResult({ operation, data = {} }) {
+  if (operation.name === "jev-images.switch") {
+    return [`JEV images ${data.area}${data.buildId ? ` for build ${data.buildId}` : ""}: ${data.mode}${data.dailyCap !== undefined ? `, daily cap ${data.dailyCap}` : ""} (all servers within ${data.effectiveWithinSeconds ?? 30} s).`];
+  }
+  if (operation.name === "jev-images.decide") {
+    return [`Recorded ${data.decision} for ${data.subjectKey} (${data.area}) on ${data.updated ?? 0} advisory row(s).`];
+  }
+  if (operation.name === "jev-images.thumbnails") {
+    const lines = [`Thumbnail notes (advisory, JEV images): ${data.status || "unavailable"}${data.featuredBoard ? " · current Featured board" : ""} · ${(data.flagged || []).length} to look at`];
+    for (const item of data.items || []) {
+      lines.push(`  ${item.target}${item.kind ? ` (${item.kind})` : ""} ${JSON.stringify(item.title || "")}: ${thumbnailLine(item)}`);
+    }
+    if (data.notice) lines.push(`  ${data.notice}`);
+    return lines;
+  }
+  const lines = [
+    `JEV images (${data.model || "?"}, advisory only) · last ${data.window?.days ?? "?"} day(s) · coverage ${data.coverage?.status || "unknown"} · ${data.totals?.checks ?? 0} checks · ${usd(data.totals?.costUsd)}`,
+  ];
+  for (const [area, a] of Object.entries(data.areas || {})) {
+    const s = a.setting || {};
+    lines.push(
+      `${area}: ${s.mode} (${s.source}, cap ${s.dailyCap}, used today ${s.usedToday ?? "?"}) · ${a.checks} checks, ${a.ok} ok, ${a.errors} errors, ${a.timeouts} timeouts, ${a.droppedRetries} dropped-image retries · p95 ${a.latencyMs?.p95 ?? "-"} ms · ${a.tokens?.input ?? 0} tokens ${usd(a.costUsd)} · agreement ${a.agreementRate === null ? "-" : `${a.agreed}/${a.scored}`} · ${a.flaggedUndecided} flagged awaiting a decision`,
+    );
+    for (const d of a.disagreements || []) {
+      lines.push(`  disagreement #${d.eventId} ${d.subjectKey}: advisory ${d.advisory}, final ${d.finalDecision}`);
+    }
+  }
+  if ((data.escalations || []).length) {
+    lines.push("Escalations:");
+    for (const e of data.escalations) lines.push(`  ${e.area} ${e.code}: ${e.detail}`);
+  } else {
+    lines.push("Escalations: none.");
+  }
+  return lines;
+}

package/lib/admin.js

@@ -50,6 +50,7 @@ import { buildCraftOperation, formatCraftResult } from "./admin-craft.js";
 import { buildNonogramOperation, formatNonogramResult } from './admin-nonogram.js';
 import { buildArenaOperation, formatArenaResult } from "./admin-arena.js";
 import { buildJevRoutingReviewOperation, formatJevRoutingReview } from "./admin-jev-review.js";
+import { buildJevImagesOperation, formatJevImagesResult } from "./admin-jev-images.js";
 import { summarizeGameDiagnostics } from "./game-diagnostic-summary.js";
 import {
   buildSlidingBlockOperation,
@@ -377,8 +378,10 @@ function buildApprovalOperation({ action, target, options }) {
   }
   const id = parseApprovalId(target);
   if (action === "show" || action === "get") {
+    // An Arena paper's advisory JEV pre-screen can take a while on first view.
     return readOperation("approvals.show", `/cli/admin/approvals/${id}`, {
       requiresRun: false,
+      timeoutMs: 180000,
     });
   }
   // An Arena paper's page replaced by the reviewer's blurred copy (names,
@@ -2714,6 +2717,10 @@ export function parseAdminOperation(options) {
   if (namespace === "jev-routing") {
     return buildJevRoutingReviewOperation({ action, target, extra, options });
   }
+  // JEV image checks: report, owner switch, final decisions (admin-jev-images.js).
+  if (namespace === "jev-images") {
+    return buildJevImagesOperation({ action, options });
+  }
   // Who holds which management level (admin-roles.js); read-only, no run.
   if (namespace === "roles") {
     return buildRolesOperation(options);
@@ -6915,6 +6922,20 @@ function arenaItemSummary(item) {
   return "";
 }
 
+// JEV image pre-screen notes (advisory only; the decision stays the reviewer's).
+function printPaperPrescreen(prescreen) {
+  if (!prescreen) return;
+  console.log(`Pre-screen (advisory, JEV images): ${prescreen.status}${prescreen.reason ? ` (${prescreen.reason})` : ""}`);
+  for (const page of prescreen.pages || []) {
+    console.log(page.status === "ok"
+      ? `  page ${page.page}: ${page.verdict === "flag" ? "LOOK CLOSELY" : "looks like an exam page"}${page.cached ? " (saved)" : ""} · ${(page.notes || []).join("; ")}`
+      : `  page ${page.page}: no pre-screen (${page.reason})`);
+  }
+  if (prescreen.blankLooking?.length) console.log(`  blank-looking pages: ${prescreen.blankLooking.join(", ")}`);
+  for (const pair of prescreen.duplicatePages || []) console.log(`  pages ${pair.pages.join(" and ")}: ${pair.kind === "same_file" ? "the same file" : "look nearly identical"}`);
+  if (prescreen.notice) console.log(`  ${prescreen.notice}`);
+}
+
 function printArenaEvidence(arena) {
   if (!arena) return;
   if (arena.kind === "scoreReport") {
@@ -6930,6 +6951,7 @@ function printArenaEvidence(arena) {
     console.log(arena.duplicate ? `Duplicate: ${arena.duplicate.reason} of paper #${arena.duplicate.duplicateOf}` : "Duplicate: none found");
     console.log(`Rarity: ${arena.rarity || "-"} · reward ${arena.reward?.xp?.toLocaleString?.("en-US") ?? 0} XP + ${arena.reward?.coins ?? 0} coins${arena.reward?.onApprove ? " on approval" : arena.reward?.paid ? " (paid)" : ""}`);
     if (arena.reviewNote) console.log(`Review note: ${arena.reviewNote}`);
+    printPaperPrescreen(arena.prescreen);
   }
   if (arena.check) console.log(`Check: ${arena.check}`);
 }
@@ -7673,6 +7695,10 @@ function printAdminResult({ operation, result }) {
     for (const line of formatJevRoutingReview(data)) console.log(line);
     return;
   }
+  if (operation.name.startsWith("jev-images.")) {
+    for (const line of formatJevImagesResult({ operation, data })) console.log(line);
+    return;
+  }
   if (operation.name === "roles.read") {
     printRoles(data);
     return;

package/lib/commands.js

@@ -2472,6 +2472,9 @@ export function parseArgs(args) {
   const raw = {};
   const positional = [];
   const booleanFlags = new Set([
+    // lumine admin jev-images thumbnails --featured [--saved-only]
+    "featured",
+    "savedOnly",
     // lumine admin arena import --live
     "live",
     "additive",
@@ -2719,6 +2722,15 @@ export function parseArgs(args) {
     adminArenaAdditive: parseBoolean(raw.additive, false),
     adminArenaItem: raw.item ? String(raw.item) : "",
     adminArenaTo: raw.to ? String(raw.to) : "",
+    adminArenaRenders: raw.renders ? String(raw.renders) : "",
+    adminArenaItems: raw.items ? String(raw.items) : "",
+    // lumine admin jev-images (admin-jev-images.js)
+    adminJevArea: raw.area ? String(raw.area) : "",
+    adminJevKey: raw.key ? String(raw.key) : "",
+    adminJevDailyCap: raw.dailyCap === undefined ? "" : String(raw.dailyCap),
+    adminTargets: raw.targets ? String(raw.targets) : "",
+    adminFeatured: parseBoolean(raw.featured, false),
+    adminSavedOnly: parseBoolean(raw.savedOnly, false),
     adminClaimFile: raw.claim ? String(raw.claim) : "",
     adminScaffoldFile: raw.scaffold ? String(raw.scaffold) : "",
     adminTargetFile: raw.targetFile ? String(raw.targetFile) : "",
@@ -3336,7 +3348,7 @@ export function printHelp() {
   lumine admin cardcraft-review list [--status pending|approved|all] [--cursor <id>] | show <id> | approve|reject|revoke <id> [--reason <text>]
   lumine admin craft seed --build <id> --file <pairs.json> [--confirm] | stats --build <id> [--limit <1-100>] | revise --build <id> --item <id|name> [--why <text>] [--emoji <emoji>] [--category <field>] [--confirm] | revise --build <id> --pair <pairId|a+b> --why <text> [--confirm] | retire --build <id> --item <id|name> --reason <text> [--confirm] | unfizzle --build <id> [--since <iso>] [--pair <a+b>] [--confirm]   (Twinkle.craft curation: dry run without --confirm)
   lumine admin sliding-block status | add --file <levels.json> [--confirm]   (sliding-block-v1 campaign refills, RushHour: dry run without --confirm; the server solves each board and appends it)
-  lumine admin arena queue | paper-queue [--cursor <id>] [--limit <1-100>] | import --dir <paper folder> [--audio audio/<exam>/<paper>] [--live] [--confirm] | status --item <id> --to live|retired|checked --confirm   (Arena's mock-exam bank: import is a validation-only dry run without --confirm; upload audio first with twinkle-api scripts/arena-upload-media.ts)
+  lumine admin arena queue | paper-queue [--cursor <id>] [--limit <1-100>] | import --dir <paper folder> [--audio audio/<exam>/<paper>] [--live] [--confirm] | status --item <id> --to live|retired|checked --confirm | picture-audit [--items <id,id,...> | --cursor <id>] [--limit 1-20] [--renders <dir of <itemId>.png>] [--output <review-list.json>]   (Arena's mock-exam bank; picture-audit is an advisory JEV image review list that never retires or edits items; import is a validation-only dry run without --confirm; upload audio first with twinkle-api scripts/arena-upload-media.ts)
   lumine admin nonogram status | add --file <pictures.json> | retire <key> | restore <key> [--confirm]   (private reviewed pictures; changes are dry runs without --confirm)
   lumine admin build-plans stuck [--days <1-90>] [--all] | recheck <buildId> [<buildId> ...] [--confirm]   (Lumine Build plans stuck on one milestone: runs, Energy vs estimate, gradings, loop-guard state; recheck re-grades the current milestone with today's evaluator, free for the creator, dry run without --confirm)
   lumine admin storage list [--status pending|approved|rejected|all] [--cursor <id>] | show <user-id-or-username> | approve <request-id> [--size <500MB|1GB|2GB|n MB>] [--reason <text>] | reject <request-id> [--reason <text>] | grant <user-id-or-username> --size <500MB|1GB|2GB|n MB> [--reason <text>]
@@ -3394,6 +3406,7 @@ export function printHelp() {
   lumine admin reward-bank report <buildId> [--days 1] [--json]   (question-bank telemetry: generation outcomes, learners, payouts, ladder, questions to review)
   lumine admin owner-trace [--since 2h|30m|3d|<iso>] [--type route,feed-open,scroll-anchor,content-scroll,error,rejection,session,nav-timing,slow-request,stall,page-load,scroll-perf,scroll-frame] [--perf] [--wake] [--path <substring>] [--limit 300] [--json]   (--wake: sessions, 20 s wake profiles, bounded viewport geometry and dropped-event counts after loads or returns; network tags identify the upload network; what the website did on Mikey's own devices: routes with PUSH/POP/REPLACE, Home feed card opens, scroll-anchor restores, content scroll positions, window errors, and performance: tap-to-page timing, API requests over 1 s, main-thread stalls over 200 ms, page load, scroll frame pacing and slow-frame attribution (Long Animation Frame scripts on Chrome, feed card renders on Safari); --perf shows only those; kept 30 days)
   lumine admin roles [--min-level 1] [--limit 50] [--json]   (every user type with its management level and who holds it; admin pages need level 3, achievement points never pass level 2)
+  lumine admin jev-images report [--days 1..30] | switch --area <all|arena_paper|arena_picture|study_record|thumbnail|sdk_decide> --mode on|off [--daily-cap <0-5000>] [--build <id>, sdk_decide only, no --daily-cap] | decide --area <area> --key <subject key> --decision <decision> | thumbnails --targets <subject:<id>,build:<id>,...> | --featured [--saved-only] [--json]   (JEV image checks: advisory only; per-area health, cost, agreement with final decisions and escalations for the daily run; switch is owner-only and needs no deploy; thumbnails adds notes for Featured review and never replaces or unfeatures anything)
   lumine admin jev-routing review --since <unix|ISO> --until <unix|ISO> [--limit 1..20] [--cursor <cursor> | --all --checkpoint <file> [--resume]] [--include-synthetic] [--json]   (bounded frozen evidence for paired disagreements and Auto fallbacks; collection is not review)
   lumine admin comment draft <target> [--type subject|comment|build|aiStory|dailyReflection] [--file <comment.md>] [--review-receipt <review.json>|--reviewed-version <id> --reviewed-via runtime|code] [--review-context <context.json>] [--identity zero|ciel|auto] [--json]
   lumine admin comment reply comment:<id> [--file <reply.md>] [--reviewed-version <id> --reviewed-via runtime|code] [--review-context <context.json>] [--identity zero|ciel|auto] [--json]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage5/lumine",
-  "version": "0.3.76",
+  "version": "0.3.78",
   "description": "Command line tools for launching Lumine builds on Twinkle.",
   "type": "module",
   "bin": {

package/sdk/BUILD_SDK_INDEX.md

@@ -1,8 +1,8 @@
 # Build SDK Index
 
-Version: 1.75.0
-Updated: 2026-10-31
-Generated: 2026-10-31T07:54:50.319Z
+Version: 1.77.0
+Updated: 2026-11-01
+Generated: 2026-11-01T12:15:43.879Z
 
 ## Platform rules
 Each rule below is a way an app breaks once it runs inside Twinkle's sandboxed frame, even when the code itself is correct. They outrank every other guideline: follow them in every change, including small ones, and fix any break of them you see in code you touch.
@@ -71,7 +71,7 @@ Features every app needs whenever they apply. When you build a new app or make a
 
 ## AI decision design
 - Twinkle.ai.decide runs JEV, a model for narrow decisions over supplied text or structured state, and it is free for viewers: decisions are covered by Twinkle and never use their AI Energy. Whenever an app makes a judgment that ordinary code can only approximate, consider JEV first. Proven patterns: an opponent or boss coach that reads the player's habits (favourite lane, repeated trick, cheese move) and picks a counter-plan from a fixed list, as in Red Square's boss and Open Football's opponent coach; NPCs that understand what a player types and choose an action; classifying or scoring user submissions; ranking supplied candidates; and picking the next exercise or difficulty from evidence about the learner. Any app with an AI opponent, NPC, or adaptive difficulty should decide explicitly whether JEV improves it. These are examples to reason from, not a keyword checklist or a requirement to add AI to every app.
-- Choose the mechanism by the work: use ordinary code for known rules, arithmetic, physics, legal moves, storage, and permissions; use ai.decide for contextual choices, yes/no probabilities, and scores; use ai.chat or ai.generateObject for generated dialogue, explanations, open-ended content, and multi-step reasoning. JEV does not generate text, browse the web, inspect images, or supply missing app data. Combine these tools when it benefits the actual request, without silently turning every decision into a more expensive text-model call.
+- Choose the mechanism by the work: use ordinary code for known rules, arithmetic, physics, legal moves, storage, and permissions; use ai.decide for contextual choices, yes/no probabilities, and scores; use ai.chat or ai.generateObject for generated dialogue, explanations, open-ended content, and multi-step reasoning. JEV does not generate text, browse the web, or supply missing app data. Looking at pictures is a preview (decide with images, see its notes): use it only when the creator asks for it, and keep the feature working when it is unavailable. Combine these tools when it benefits the actual request, without silently turning every decision into a more expensive text-model call.
 - Before adopting JEV, identify the concrete decision, the context available at that moment, the allowed outcomes, and why the added latency is worthwhile. Use your model judgment to make that choice. Do not substitute regex or keyword matching for understanding human-language intent. Explain the user-visible benefit simply; the creator does not need to select a provider, enter an API key, or design question schemas.
 - Send related independent questions about the same state together in one ai.decide request (up to 32). Write complete instructions and distinct option or level descriptions. Include an other/uncertain option when the choices might not cover the input. A second call is useful only when it needs newly obtained context or choices that depend on the first result; answers in one batch do not see each other.
 - Keep code in control. Choice returns an option and its probability distribution; score returns a position on the declared levels; noul is the probability of yes, with 0.5 meaning uncertainty rather than medium strength. Confidence describes the distribution and is not proof of correctness. Test the app's criteria and thresholds on clear, ambiguous, and out-of-scope examples, and provide a suitable uncertain outcome. JEV decisions never authorize XP, Coins, purchases, access, or other server-owned state; use the appropriate existing SDK and server approval paths.
@@ -531,10 +531,10 @@ renderBattery(policy?.energyPercent, policy?.energySegmentsRemaining);
   - Use this for in-app AI replies instead of creating or fetching app-local endpoints such as /api/chat.
   - Example: const chatHistory = conversation.slice(-12).map((entry) => ({ role: entry.role === 'assistant' ? 'assistant' : 'user', content: entry.text }));
 const result = await Twinkle.ai.chat({ message, history: chatHistory, systemPrompt: 'You are a cheerful pirate helper who answers in one sentence.', onText: (text, meta) => renderReply(text), onStatus: (status) => setThinking(status === 'thinking') });
-- async decide({ state, questions }) | scopes: none
-  - Returns: { answers, model, provider, aiUsagePolicy }
+- async decide({ state, questions, images }) | scopes: none
+  - Returns: { answers, model, provider, aiUsagePolicy, imageCount? }
   - Use JEV for fast contextual choices, yes/no probabilities, and scores inside a running app. Send several independent questions about the same state together.
-  - Read the AI decision design guidance when deciding whether this capability benefits the app. This method evaluates supplied context; it does not generate prose, browse, inspect images, run tools, grant access, or award XP/Coins.
+  - Read the AI decision design guidance when deciding whether this capability benefits the app. This method evaluates supplied context; it does not generate prose, browse, run tools, grant access, or award XP/Coins. It looks at pictures only through the preview images option below.
   - state is non-empty text, a JSON object, or a JSON array. questions maps your question IDs to { type, instructions, criteria? }. Instructions may be non-empty text or structured JSON. Every question sees the same state and answers independently; put the complete question in instructions, not just its ID.
   - Choice: { type: 'choice', instructions, criteria: { optionName: description, other: description } }. Supply 2–255 named options. Each description is text, structured JSON, or null. Returns { type: 'choice', choice, probabilities, confidence } under answers[questionId].
   - Score: { type: 'score', instructions, criteria: [lowestLevelDescription, ..., highestLevelDescription] }. Supply 2–10 concrete ordered descriptions. Returns { type: 'score', score, probabilities, confidence, legend }. Levels start at 0; score may be fractional and is a probability-weighted position between 0 and criteria.length - 1.
@@ -542,6 +542,7 @@ const result = await Twinkle.ai.chat({ message, history: chatHistory, systemProm
   - A request accepts 1–32 questions, at most 64 KB of JSON and 20 levels of nesting. Question IDs and option names must be non-empty, at most 128 characters, and cannot be __proto__, constructor, or prototype. Descriptions may use structured JSON; state must contain only data the app is allowed to access.
   - Requires a signed-in viewer and uses the normal runtime AI rate limits. Twinkle selects and calls JEV on its server; never put provider credentials or an external endpoint in app code. Decisions are covered by Twinkle: they never use the viewer's AI Energy, and a viewer with empty Energy still gets answers. The response includes the viewer's current canonical aiUsagePolicy, unchanged by the call.
   - Errors include invalid_ai_decision (bad input), ai_decision_unavailable, ai_decision_timeout, ai_decision_rate_limited, ai_decision_invalid_response, and ai_usage_unavailable, plus the existing auth, access, Energy, and rate-limit errors. Invalid answers are rejected. An answer that fails validation is retried once on the server within the same deadline; there is no other provider retry, fabricated answer, or paid LLM fallback. Do not automatically retry a rejected request.
+  - Preview: images (not generally available yet). Pass images: { name: picture } with 1-4 entries to let JEV look at pictures. Names use lowercase letters, digits and underscores (e.g. drawing); each name becomes a key of state, so state must then be a JSON object without that key, and instructions refer to the picture by name (e.g. 'Does `drawing` show a cat?'). A picture is this app's own upload URL (from Twinkle.files, at most 5 MB each), a canvas, or a PNG/JPEG/WebP Blob of at most 3 MB (5 MB of snapshots per decision). All pictures of one decision together must be at most 10 MB; a larger one is refused with 'Image too large: max 5 MB each, 10 MB per decision. Resize the picture first.' so resize big pictures before asking. Image decisions are covered by Twinkle like text decisions. Only some run at once (one per player, several per app, and a generous ceiling per minute for the app), so wait for one answer before asking again and do not call decide in a tight loop. Until Twinkle turns them on for the app, and whenever a picture cannot be checked or too many decisions are running, decide throws ai_decision_unavailable with a reason (disabled, app_disabled, rate_limited, capped, images_dropped, timeout, ...). There is never a text-only answer that ignores the pictures. Use images only when the creator asks for it, keep the feature usable without it (for example skip the AI check and let the player continue), and never use the answer for safety, access, XP or Coins.
   - Call on meaningful app events with bounded frequency, batch questions, and keep rendering and deterministic game rules in local code. Ignore a result if the app state or turn changed while it was pending. Test uncertain inputs and choose a fallback appropriate to the experience; confidence is not a correctness guarantee.
   - Example: const { answers } = await Twinkle.ai.decide({ state: { playerRequest, availableActions }, questions: { action: { type: 'choice', instructions: 'Which available companion action best fits playerRequest? Use wait when unclear.', criteria: { follow: 'Follow the player', guard: 'Stay and keep watch', wait: 'Do nothing until clarified' } }, needsClarification: { type: 'noul', instructions: 'Is playerRequest too ambiguous to act on?' } } }); const action = answers.needsClarification.noul > 0.5 ? 'wait' : answers.action.choice;
 - async generateObject({ prompt, expectedStructure, images, thinkingMode, mode, model, instructions, systemPrompt, webSearch, requestId, onText, onStatus, onReasoning } = {}) | scopes: none
@@ -554,7 +555,7 @@ const result = await Twinkle.ai.chat({ message, history: chatHistory, systemProm
   - Template values describe types, not answers to copy. All object keys are required and extra keys are rejected, including inside nested objects; {} means an exactly empty object, not a free-form dictionary. A non-empty array uses only its first item as the template for every returned item, with no fixed length; mixed examples do not declare a union. [] allows arbitrary JSON items. A null template accepts any JSON primitive (string, number, boolean or null), but the key is still required. Use 'number' for fractional numbers; 0 and other integer examples require integers. State content requirements in prompt or instructions. GPT routes retain descriptive string examples as field guidance, not enforced enum values.
   - GPT models prefer native JSON Schema output for compatible shapes. Shapes outside the strict provider subset, such as [] with arbitrary items or deeply nested structures, use prompt-based JSON generation with the same final validation. A provider rejection specifically of the native schema triggers one prompt-based fallback; auth, quota, safety and unrelated request failures do not trigger that fallback. Validation retries preserve the original task and instructions. The returned object/result shape and streaming callbacks are unchanged.
   - mode is accepted as an alias for thinkingMode, and mid is accepted as an alias for medium.
-  - Omit model to use the normal Lite/Medium/High routing. Low and Medium use gpt-6-luna; explicit gpt-6-luna accepts Low, Medium or High thinking. Existing apps naming claude-haiku-5-5 now run on gpt-6-luna at the requested thinking level. Explicit claude-sonnet-5-5, gpt-6.1-sol or claude-opus-5-5 still require thinkingMode: 'high'; unknown model IDs reject instead of silently falling back. Retired IDs still work and run on their replacement: claude-sonnet-5 runs claude-sonnet-5-5; gpt-6-sol and gpt-5.6-sol run gpt-6.1-sol; gpt-6-astra, claude-opus-5 and claude-fable-5-1 run claude-opus-5-5.
+  - Omit model to use the normal Lite/Medium/High routing. Low and Medium use gpt-6-luna; explicit gpt-6-luna accepts Low, Medium or High thinking. Existing apps naming claude-haiku-5-5 now run on gpt-6-luna at the requested thinking level. Explicit gpt-6.1-sol requires thinkingMode: 'high' (it reasons at xhigh). Explicit claude-sonnet-5-5 or claude-opus-5-5 think at the requested level (low, medium or high; Opus 5.5's own default is medium). A Claude model's thinking shares one reply with the object, so if a large object fails with code build_ai_output_too_long (cut off at the length limit), offer the player a retry at a lower thinkingMode or a smaller request; a cut-off reply is not charged to the player's AI Energy. Unknown model IDs reject instead of silently falling back. Retired IDs still work and run on their replacement: claude-sonnet-5 runs claude-sonnet-5-5; gpt-6-sol and gpt-5.6-sol run gpt-6.1-sol; gpt-6-astra, claude-opus-5 and claude-fable-5-1 run claude-opus-5-5.
   - thinkingMode low uses GPT-6 Luna with low reasoning and consumes the viewer's AI Energy from confirmed provider usage.
   - thinkingMode medium uses GPT-6 Luna with medium reasoning and consumes normal AI Energy.
   - thinkingMode high without model uses Claude Sonnet 5.5 with high adaptive thinking and consumes high AI Energy. Explicit model: 'gpt-6.1-sol' selects GPT-6.1 Sol with xhigh reasoning at the same High AI Energy tier; model: 'claude-sonnet-5-5' names Sonnet 5.5 directly.
@@ -1574,14 +1575,14 @@ world.updatePresence({ x, y, z, facing });
   - Daily reflections are Daily Question answers shown in the Twinkle feed.
   - Only currently shared public reflections are returned. The response field is the stored shared response version, which may be raw or polished depending on what the author explicitly shared.
   - submittedAt and sharedAt are Unix timestamps (seconds). Use new Date(value * 1000) to convert to JS Date.
-  - dayType is 'word' (Word Day), 'picture' (Picture Day) or null (an ordinary reflection). On a Picture Day the member described a picture instead of reflecting: pictureUrl is the picture they chose (null when they finished with words only), pictureStyle the style they asked for, and response is their description. Show the picture with the description, not the stock question.
+  - dayType is 'word' (Word Day), 'advice' (Advice Day: a Word Day that asks for a piece of advice; response is the advice, or whatever they chose to write instead), 'picture' (Picture Day) or null (an ordinary reflection). On a Picture Day the member described a picture instead of reflecting: pictureUrl is the picture they chose (null when they finished with words only), pictureStyle the style they asked for, and response is their description. Show the picture with the description, not the stock question.
 - async getDailyReflectionsByUser(userId, { cursor, lastId, limit } = {}) | scopes: dailyReflections:read
   - Returns: { reflections: [{ id, userId, response, questionId, submittedAt, sharedAt, username, profilePicUrl, question, dayType, pictureUrl, pictureStyle }], cursor? }
   - Read one user's currently public Daily Reflection shares. response is the exact text the author chose to share publicly, never an unshared raw/private answer.
   - Daily reflections are Daily Question answers shown in the Twinkle feed.
   - Only currently shared public reflections are returned. The response field is the stored shared response version, which may be raw or polished depending on what the author explicitly shared.
   - submittedAt and sharedAt are Unix timestamps (seconds). Use new Date(value * 1000) to convert to JS Date.
-  - dayType is 'word' (Word Day), 'picture' (Picture Day) or null (an ordinary reflection). On a Picture Day the member described a picture instead of reflecting: pictureUrl is the picture they chose (null when they finished with words only), pictureStyle the style they asked for, and response is their description. Show the picture with the description, not the stock question.
+  - dayType is 'word' (Word Day), 'advice' (Advice Day: a Word Day that asks for a piece of advice; response is the advice, or whatever they chose to write instead), 'picture' (Picture Day) or null (an ordinary reflection). On a Picture Day the member described a picture instead of reflecting: pictureUrl is the picture they chose (null when they finished with words only), pictureStyle the style they asked for, and response is their description. Show the picture with the description, not the stock question.
 
 ### Twinkle.privateDb
 - async get(key) | scopes: privateDb:read

package/sdk/LUMINE_ADMIN.md

@@ -1328,7 +1328,7 @@ Birthdate, teacher-signup (`mentor`) and meetup-achievement requests, each with
 
 ```bash
 lumine admin approvals list [--status pending|approved|rejected|all] [--type dob|mentor|meetup]
-lumine admin approvals show <id>
+lumine admin approvals show <id>            # an Arena paper also gets advisory JEV pre-screen notes (see JEV images)
 lumine admin approvals approve|reject <id> [--reason <text>]
 lumine admin teachers audit [--limit 1-100] [--cursor <c>] [--all]
 lumine admin teachers revoke <userId> --reason <text>
@@ -4000,6 +4000,109 @@ input snapshots as described below.
 See `twinkle-api/JEV_PILOT.md` for configuration,
 the synthetic evaluation step and release checks.
 
+### JEV images (standing duty, every full daily review; added 2026-11-01)
+
+```bash
+lumine admin jev-images report --json                 # last 24 h; --days 1..30
+lumine admin jev-images switch --area all --mode off  # owner kill switch, no deploy
+lumine admin jev-images switch --area arena_picture --mode on --daily-cap 100
+lumine admin jev-images decide --area arena_picture --key arenaItem:10176 --decision keep|fix|retired
+lumine admin arena picture-audit [--items <id,...> | --cursor <id>] [--limit 1-20] [--renders <dir>] --output <review-list.json> --json
+lumine admin jev-images thumbnails --targets subject:<id>,build:<id>,... | --featured [--saved-only] --json
+lumine admin jev-images decide --area thumbnail --key subject:37265 --decision keep|replace
+lumine admin jev-images switch --area sdk_decide --build <id> --mode on|off   # one app's image decisions (no per-app cap)
+```
+
+JEV image checks (Mikey, November 1) send pictures to JEV (`jev-1.13.0`,
+pinned) with the `TypeSafe-Danger-Zone-Images` opt-in. The vendor marks images
+experimental. **Every answer is advisory:** never the only gate, never a
+child-safety decision and never a reason to pay or withhold a reward (standing
+ruling 11-01). Areas: `arena_paper` (paper-upload pre-screen notes in
+`approvals show`), `arena_picture` (picture-bank audit), `thumbnail` (Featured
+thumbnail notes, on by default, cap 2000/day) and `sdk_decide`
+(`Twinkle.ai.decide` with images, a preview, **off** until Mikey turns it on).
+`study_record` has no caller: study-record-v1 records are text only, so there
+are no photos to check, and the area stays off.
+
+Each check carries a small coloured square and asks its colour. A wrong or
+unsure colour, or an answer from a different model, means the pictures were
+dropped. The check is retried once (`droppedRetries`), then returns
+`images_dropped`. An unavailable check (off, capped, timeout, provider error,
+dropped images, tables missing) leaves the caller exactly as it was before.
+
+`daily-run gather` saves the report as `jev-images.json`. Give the full report a
+**JEV images** section:
+- per area: mode and source, daily cap and today's use, checks, errors,
+  timeouts, dropped-image retries and give-ups, latency p50/p95, tokens and cost;
+- agreement between advisories and final decisions (`agreed/scored`), every
+  listed disagreement and the flagged items still awaiting a decision;
+- every `escalations` entry. Thresholds (`thresholds` in the JSON): error rate
+  above 20% or timeouts above 10% (at least 5 sent checks), dropped-image retries
+  above 5% of requests or any give-up, daily cost above $0.10 and 3x the previous
+  7-day average, daily cost above $2, agreement below 80% over at least 10
+  decided items, and any check skipped at the cap.
+
+`coverage.status: store_unavailable` means the tables are not migrated: report
+"not deployed", not a quiet day. A failed gather step is unavailable evidence.
+JEV image spend is also in the AI ledger (`surface: jev_images`), so never add
+it to the AI cost total a second time. Agreement is not accuracy: a
+disagreement can be JEV's mistake or the reviewer's, so read the item before
+saying which.
+
+**Paper pre-screen.** For a pending `arenaPaper`, `approvals show <id>` adds a
+`prescreen` block: per page, whether it looks like a test page, legibility, a
+guess at the exam family and printed year, whether it fits its tags, plus
+blank-looking and duplicate pages (plain image arithmetic). Results are saved
+per page, so a second `show` makes no new call (`(saved)`). Add
+`?prescreen=off` to the API read to skip it. The approval criterion is
+unchanged (a real exam paper matching its tags, ruling 10-29): read every page
+yourself. Approve/reject records the final decision for agreement.
+
+**Picture-bank audit.** `arena picture-audit` reads live items with a picture
+and asks fixed questions. For 수능 listening #4 it asks which labelled object
+mismatches the script, whether the keyed object is drawn as briefed, whether
+the ① to ⑤ labels are present, and whether there is stray text. For picture
+choices it asks which picture matches the heard sentence and whether every
+picture is readable. For other single pictures it asks whether the picture is
+readable and whether there is stray text. Picture choices are drawn by the web,
+so pass `--renders <dir>` containing `<itemId>.png` renders of the item as
+printed, for example from an Arena render script. Without one, the item is
+listed under `needsRender`. The command never retires or edits an item. Read
+each `review` item yourself. Record `keep`, `fix` or `retired` with
+`jev-images decide`. Retiring an item through `arena status` records `retired`
+automatically. Fixing or retiring live items needs the usual authorization.
+
+**Featured thumbnails.** `featured candidates` adds a `thumbnailCheck` to each
+eligible candidate and a `thumbnailChecks` summary; `jev-images thumbnails
+--featured` does the same for the current board. Each card's picture (the post's
+own picture, or the cover of the app it is about) gets notes: blank, error or
+loading screen, placeholder, mostly empty at card size, garbled or interface
+text, a watermark, and for an app whether it shows the app. Only
+Twinkle-hosted pictures are read; link previews and videos say
+`external_thumbnail`, and a secret attachment is never looked at. Answers are
+saved per picture, so a re-run makes no new call. The notes are never a ranking
+or eligibility input and nothing is replaced or unfeatured because of them.
+When you look at a flagged picture, record `keep` or `replace` with
+`jev-images decide --area thumbnail --key subject:<id>` (or `build:<id>`).
+Pilot (11-01, app covers only): 43/45 on a held-out set, every good cover
+passed, 2 of 4 bad ones caught. A pass does not mean the picture is fine.
+
+**Image decisions in apps (preview).** `Twinkle.ai.decide({ state, questions,
+images })` lets an app ask about up to four pictures (its own uploads or a
+canvas). Pictures are bounded: an upload at most 5 MB, a snapshot at most 3 MB
+(5 MB of snapshots), and 10 MB for all pictures of one decision; a larger call
+is refused with a plain "Image too large" message before it is fully read. It
+is free for viewers like text decisions. There are no per-app or
+per-viewer daily caps (a decision costs a fraction of a cent); the area's daily
+cap and the cost alarm in the daily report are the spending guard. Bursts are
+limited instead: one image decision in flight per viewer, eight per app, and
+600 a minute per app (per API instance, so up to about twice that across the
+cluster; a class of 30 deciding every ~20 s is about 90 a minute). A throttled call is refused at once as `ai_decision_unavailable` with
+reason `rate_limited`. It never falls back to a text-only answer: when off,
+throttled or failing it returns `ai_decision_unavailable` with a reason.
+`switch --area sdk_decide --build <id> --mode off` switches one app off (or
+`on` to undo it). The report shows its use under `sdk_decide`.
+
 ### Spending by calendar month
 
 ```bash