@stage5/lumine 0.3.69 → 0.3.70

package/lib/admin-arena.js

@@ -14,7 +14,7 @@ import path from "node:path";
 //                              re-importing a folder retires that paper's earlier items
 //   status --item <id> --to live|retired|checked
 export const ARENA_USAGE =
-  "Usage: lumine admin arena queue | 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] [--json]";
 const MAX_ITEMS = 300;
 
 function validationError(message) {
@@ -63,6 +63,12 @@ function readAdditiveItems(file) {
 }
 
 export function buildArenaOperation({ action, options }) {
+  if (action === "paper-queue") {
+    const cursor = Number(options.adminCursor || 0);
+    const limit = Number(options.adminLimit ?? 50);
+    if (!Number.isSafeInteger(cursor) || cursor < 0 || !Number.isInteger(limit) || limit < 1 || limit > 100) throw validationError("Use a non-negative --cursor and --limit from 1 to 100.");
+    return { name: "arena.paper.queue", method: "GET", path: `/cli/admin/arena/paper-queue?cursor=${cursor}&limit=${limit}`, mutates: false, requiresRun: false };
+  }
   if (action === "today-queue") {
     const cursor = Number(options.adminCursor || 0);
     const limit = Number(options.adminLimit ?? 50);
@@ -151,6 +157,11 @@ export function buildArenaOperation({ action, options }) {
 }
 
 export function formatArenaResult({ operation, data }) {
+  if (operation.name === "arena.paper.queue") return [
+    `Checked ${data?.scannedMembers ?? 0} members; ${data?.entries?.length ?? 0} exam tracks are waiting for fresh papers on this page.`,
+    ...(data?.entries || []).map(row => `${row.username} (${row.userId}): ${row.examKey} ${row.difficulty}/${row.length}${row.reason === "solo_mastery_paper" ? " — solo mastery ready" : ""}`),
+    data?.nextCursor ? `Continue: lumine admin arena paper-queue --cursor ${data.nextCursor} --json` : "End of waiting-member queue.",
+  ];
   if (operation.name === "arena.today.queue") return [
     ...(data?.members || []).map(m => `#${m.userId} ${m.username}: ${m.ready} questions ready${m.refillDue ? `; refill to ${m.target}` : ""} (preferences v${m.revision})`),
     data?.nextCursor ? `Continue: lumine admin arena today-queue --cursor ${data.nextCursor} --json` : "End of Today’s Q queue.",

package/lib/admin-daily.js

@@ -9,6 +9,7 @@ import { readAdminJsonFile, writeAdminJsonFile } from "./admin-news.js";
 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";
 export { dailyRunProgress };
 
 // Multi-step conveniences for the full daily management run. Each one runs
@@ -86,7 +87,7 @@ export function runAdmin(
     sponsor: ["applications"],
     "bot-output": [null],
     "math-lab": ["queue"],
-    arena: ["queue", "today-queue"],
+    arena: ["queue", "today-queue", "paper-queue"],
     "word-games": ["status"],
     nonogram: ["status"],
     subjects: ["candidates"],
@@ -179,12 +180,15 @@ export async function dailyRunGather(options, { run = runAdmin, now, clock } = {
   );
   const collection = createDailyCollection(dir, options, { now, clock });
   const yesterday = collection.costDate;
+  // Resume keeps the original observation boundary; no page slides its window
+  // forward while the operator works through a long diagnostic queue.
+  const diagnosticUntil = Math.floor(Date.parse(collection.startedAt) / 1000);
   const steps = [];
   const failLast = (error) => {
     collection.invalidate(steps.at(-1).name);
     Object.assign(steps.at(-1), { ok: false, error });
   };
-  const evidenceNames = /^(ai-costs|media-costs|reward-activity|reward-diagnostics|owner-wake|bot-output)/;
+  const evidenceNames = /^(ai-costs|media-costs|reward-activity|reward-diagnostics|jev-review|owner-wake|bot-output)/;
   const step = (name, args, file) => {
     const res = collection.collect(name, args, file, evidenceNames.test(name) ? "evidence" : "priority", run);
     steps.push({
@@ -205,6 +209,29 @@ export async function dailyRunGather(options, { run = runAdmin, now, clock } = {
   step("brief", ["brief"], "brief.json");
   step("todos", ["todo", "list"], "todos.json");
   step("escalations", ["escalation", "list"], "escalations.json");
+  const paperQueue = { complete: false, pages: 0, waitingTracks: 0 };
+  let paperCursor = 0;
+  for (;;) {
+    paperQueue.pages++;
+    const res = step(`arena-paper-page-${paperQueue.pages}`,
+      ["arena", "paper-queue", "--cursor", String(paperCursor), "--limit", "100"],
+      `arena-paper-queue-${paperQueue.pages}.json`);
+    if (!res.ok) break;
+    const data = res.json?.data;
+    const next = data?.nextCursor;
+    if (data?.demandBasis !== "waiting-published-papers-v1" || !Array.isArray(data?.entries) ||
+        !(next === null || (Number.isSafeInteger(next) && next > paperCursor))) {
+      failLast("Invalid or non-advancing Arena paper-waiting page.");
+      break;
+    }
+    paperQueue.waitingTracks += data.entries.length;
+    if (next === null) { paperQueue.complete = true; break; }
+    if (paperQueue.pages >= 100) {
+      failLast("Arena paper-waiting queue reached its 100-page bound.");
+      break;
+    }
+    paperCursor = next;
+  }
   step("math-lab-queue", ["math-lab", "queue"], "math-lab-queue.json");
   step("arena-queue", ["arena", "queue"], "arena-queue.json");
   step("word-games-status", ["word-games", "status"], "word-games-status.json");
@@ -245,7 +272,17 @@ export async function dailyRunGather(options, { run = runAdmin, now, clock } = {
     ["reward-activity", "--date", yesterday, "--days", "7"],
     "reward-activity.json",
   );
-  step("reward-diagnostics", ["reward-diagnostics", "--days", "1"], "reward-diagnostics.json");
+  const rewardDiagnostics = collectDiagnosticPages({ name: "reward-diagnostics",
+    command: ["reward-diagnostics", "--days", "1"], since: diagnosticUntil - 86400,
+    until: diagnosticUntil, step, failLast });
+  writeAdminJsonFile(path.join(dir, "reward-diagnostics-summary.json"), diagnosticCollectionSummary(rewardDiagnostics), { privateFile: true });
+  steps.push({ name: "reward-diagnostics-summary", file: "reward-diagnostics-summary.json", ok: true });
+  const jevUntil = Math.floor(diagnosticUntil / 86400) * 86400;
+  const jevReview = collectDiagnosticPages({ name: "jev-review", jevReview: true,
+    command: ["jev-routing", "review", "--since", String(jevUntil - 86400), "--limit", "20"],
+    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 });
   // 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 };
@@ -294,17 +331,21 @@ export async function dailyRunGather(options, { run = runAdmin, now, clock } = {
   // flags: a required report section (agent-guides/lumine-admin.md)
   step("approvals-pending", ["approvals", "list", "--status", "pending"], "approvals-pending.json");
   step("personal-followups", ["followup", "list"], "personal-followups.json");
-  const wake = step("owner-wake", ["owner-trace", "--since", "24h", "--wake", "--limit", "2000"], "owner-wake.json");
+  const wake = collectDiagnosticPages({ name: "owner-wake", ownerTrace: true,
+    command: ["owner-trace", "--since", String(diagnosticUntil - 86400), "--wake", "--limit", "2000"],
+    since: diagnosticUntil - 86400, until: diagnosticUntil, step, failLast });
   // A phone tab can live longer than the daily window. Retain its version,
   // browser and device context instead of silently calling it unknown.
-  const wakeSessions = step("owner-wake-sessions", ["owner-trace", "--since", "30d", "--type", "session", "--limit", "2000"], "owner-wake-sessions.json");
+  const wakeSessions = collectDiagnosticPages({ name: "owner-wake-sessions", ownerTrace: true,
+    command: ["owner-trace", "--since", String(diagnosticUntil - 30 * 86400), "--type", "session", "--limit", "2000"],
+    since: diagnosticUntil - 30 * 86400, until: diagnosticUntil, step, failLast });
   const ownerWake = summarizeOwnerViewport(
-    wake.ok ? wake.json.data : null,
-    wakeSessions.ok ? wakeSessions.json.data : null,
+    wake,
+    wakeSessions,
   );
   ownerWake.collectionFailures = [
-    ...(!wake.ok ? ["owner-wake"] : []),
-    ...(!wakeSessions.ok ? ["owner-wake-sessions"] : []),
+    ...(!wake.complete ? ["owner-wake"] : []),
+    ...(!wakeSessions.complete ? ["owner-wake-sessions"] : []),
   ];
   if (ownerWake.collectionFailures.length) {
     ownerWake.coverage = ownerWake.usableSamples ? "partial" : "unavailable";
@@ -372,12 +413,17 @@ export async function dailyRunGather(options, { run = runAdmin, now, clock } = {
     costDateUtc: yesterday,
     collection: { id: collection.collectionId, startedAt: collection.startedAt, phase: collection.phase, warnings: collection.warnings },
     personalQueue,
+    paperQueue,
     buildReviews,
+    rewardDiagnostics: diagnosticCollectionSummary(rewardDiagnostics),
+    jevReview: diagnosticCollectionSummary(jevReview),
     ownerWake: {
       coverage: ownerWake.coverage,
       truncated: ownerWake.truncated,
       largeGapCycles: ownerWake.largeGapCycles,
       reportFile: path.join(dir, "owner-wake-summary.md"),
+      collection: diagnosticCollectionSummary(wake),
+      sessionCollection: diagnosticCollectionSummary(wakeSessions),
     },
     botOutput: {
       complete: botOk,

package/lib/admin-diagnostic-collection.js

@@ -0,0 +1,106 @@
+// Fixed-window keyset collection. Every page stays a separate acknowledged
+// source; aggregates are conveniences, never proof that the source was read.
+function jevPosition(cursor, since, until) {
+  try {
+    if (typeof cursor !== "string" || !/^[A-Za-z0-9_-]{1,1024}$/.test(cursor)) return null;
+    const value = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+    if (value.version !== 1 || value.kind !== "jev-routing-review" ||
+        value.since !== since || value.until !== until || value.includeSynthetic !== false ||
+        !Number.isSafeInteger(value.createdAt) || value.createdAt < since || value.createdAt >= until ||
+        !Number.isSafeInteger(value.id) || value.id <= 0) return null;
+    return value;
+  } catch { return null; }
+}
+
+export function collectDiagnosticPages({ name, command, since, until, ownerTrace = false, jevReview = false, step, failLast }) {
+  const events = [];
+  const ids = new Set();
+  const cursors = new Set();
+  const sourceFiles = [];
+  let cursor = null;
+  let pages = 0;
+  let duplicateRows = 0;
+  let complete = false;
+  let deferred = false;
+  let failure = null;
+  const pageLimit = ownerTrace ? 20 : 100;
+  for (;;) {
+    pages++;
+    const args = [...command, "--until", String(until)];
+    if (cursor !== null) args.push("--cursor", String(cursor));
+    const file = `${name}${pages === 1 ? "" : `-${pages}`}.json`;
+    const result = step(`${name}${pages === 1 ? "" : `-page-${pages}`}`, args, file);
+    sourceFiles.push(file);
+    if (!result.ok) {
+      deferred = Boolean(result.deferred);
+      failure = deferred ? result.reason : "source-read-failed";
+      break;
+    }
+    const data = result.json?.data;
+    const next = data?.nextCursor;
+    const rows = jevReview ? data?.items : data?.events;
+    const window = jevReview ? data?.collectionWindow : data;
+    const validCursor = next === null || (jevReview ? Boolean(jevPosition(next, since, until)) : ownerTrace
+      ? typeof next === "string" && /^\d+:\d+$/.test(next)
+      : Number.isSafeInteger(next) && next > 0 && (cursor === null || next < cursor));
+    if (!Array.isArray(rows) || window?.since !== since || window?.until !== until ||
+        !validCursor || data.coverage === "unavailable" ||
+        (jevReview && (window.includeSynthetic !== false || data.after !== cursor ||
+          data.hasMore !== (next !== null) || data.coverage?.scope !== "page" ||
+          data.coverage?.status !== (next === null ? "exhausted" : "partial"))) ||
+        (ownerTrace && data.truncated !== (next !== null))) {
+      failure = "Invalid diagnostic page or fixed-window coverage; deploy the matching API before collecting.";
+      failLast(failure);
+      break;
+    }
+    const idOf = row => jevReview ? row.eventId : row.id;
+    if (rows.some(row => !Number.isSafeInteger(idOf(row)) || idOf(row) <= 0)) {
+      failure = "Diagnostic page contains an invalid event ID.";
+      failLast(failure);
+      break;
+    }
+    if (jevReview && cursor !== null && next !== null) {
+      const old = jevPosition(cursor, since, until), current = jevPosition(next, since, until);
+      if (!(current.createdAt > old.createdAt || current.createdAt === old.createdAt && current.id > old.id)) {
+        failure = "JEV review cursor did not advance.";
+        failLast(failure);
+        break;
+      }
+    }
+    if (ownerTrace && cursor !== null && next !== null) {
+      const [oldTime, oldId] = cursor.split(":").map(Number);
+      const [time, id] = next.split(":").map(Number);
+      if (!(time < oldTime || time === oldTime && id < oldId)) {
+        failure = "Owner trace cursor did not advance.";
+        failLast(failure);
+        break;
+      }
+    }
+    for (const row of rows) {
+      if (ids.has(idOf(row))) { duplicateRows++; continue; }
+      ids.add(idOf(row));
+      events.push(row);
+    }
+    if (next === null) { complete = true; break; }
+    if (cursors.has(next) || pages >= pageLimit) {
+      failure = `Diagnostic pagination repeated a cursor or reached its ${pageLimit}-page bound.`;
+      failLast(failure);
+      break;
+    }
+    cursors.add(next);
+    cursor = next;
+  }
+  if (ownerTrace) events.sort((a, b) => a.serverTime - b.serverTime || a.id - b.id);
+  return { since, until, complete, pages, rows: events.length, duplicateRows,
+    sourceFiles, deferred, failure, events, truncated: !complete };
+}
+
+export function diagnosticCollectionSummary(collection) {
+  const { events, ...summary } = collection;
+  const outcomes = {};
+  for (const row of events) {
+    const key = `${row.source || row.type || row.route || "unknown"}:${row.operation || ""}:${row.outcome || row.selectedSource || ""}`;
+    outcomes[key] = (outcomes[key] || 0) + 1;
+  }
+  return { ...summary, outcomes, note: "Metadata only. Read the source pages; this summary does not acknowledge review or prove member outcomes." };
+}

package/lib/admin-duties.js

@@ -44,7 +44,11 @@ export function createDailyReviewState(dir, gather, previous = {}) {
     if (gather.buildReviews && (
       source.file === "rr-pending.json" || /^build-reviews-\d+\.json$/.test(source.file)
     )) continue;
+    if (gather.paperQueue && /^arena-paper-queue-\d+\.json$/.test(source.file)) continue;
     if (gather.personalQueue && /^arena-today-queue-\d+\.json$/.test(source.file)) continue;
+    if (gather.rewardDiagnostics && /^reward-diagnostics(?:-\d+|-summary)?\.json$/.test(source.file)) continue;
+    if (gather.jevReview && /^jev-review(?:-\d+|-summary)?\.json$/.test(source.file)) continue;
+    if (gather.ownerWake?.collection && /^owner-wake(?:-sessions)?(?:-\d+)?\.json$/.test(source.file)) continue;
     if (gather.botOutput && (
       source.file === "bot-chats.txt" || /^bot-output-\d+\.json$/.test(source.file)
     )) continue;

package/lib/admin-jev-review.js

@@ -0,0 +1,76 @@
+// Bounded owner-only frozen evidence. Collection never acknowledges reading
+// and never reconstructs missing input from the member's edited chat history.
+export const JEV_REVIEW_USAGE =
+  "Usage: lumine admin jev-routing review --since <unix|ISO> --until <unix|ISO> [--limit 1..20] [--cursor <cursor>] [--include-synthetic] [--all] [--json].";
+
+function invalid(message) {
+  const error = new Error(message);
+  error.code = "CLI_ADMIN_CLI_VALIDATION";
+  throw error;
+}
+
+function explicitTimestamp(value, name) {
+  if (typeof value !== "string" && typeof value !== "number") invalid(JEV_REVIEW_USAGE);
+  const text = String(value).trim();
+  if (!/^\d+$/.test(text) && !/^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?(?:Z|[+-]\d{2}:\d{2}))?$/.test(text)) {
+    invalid(`--${name} requires an explicit Unix timestamp or ISO date, not a relative window.`);
+  }
+  const seconds = /^\d+$/.test(text) ? Number(text) : Math.floor(Date.parse(text) / 1000);
+  if (!Number.isSafeInteger(seconds) || seconds <= 0) invalid(`Invalid --${name} timestamp.`);
+  // Keep ISO input intact for the API's strict calendar/date-zone validation.
+  return { text, seconds };
+}
+
+export function buildJevRoutingReviewOperation({ action, target, extra, options = {} }) {
+  if (action !== "review" || target || extra) invalid(JEV_REVIEW_USAGE);
+  if (options.adminAll && options.adminCursor) {
+    invalid("Use --all from the beginning of the window, or --resume with its saved checkpoint; use --cursor only for an individual page.");
+  }
+  const since = explicitTimestamp(options.adminSince, "since");
+  const until = explicitTimestamp(options.adminUntil, "until");
+  if (until.seconds <= since.seconds || until.seconds - since.seconds > 8 * 86400) {
+    invalid("Use a fixed window with since < until, at most eight days.");
+  }
+  // The global parser's `limit` defaults to 50 for unrelated commands.
+  // `adminLimit` records only an explicitly supplied --limit.
+  const rawLimit = options.adminLimit;
+  const limit = rawLimit == null || rawLimit === "" ? 20 : Number(rawLimit);
+  if ((rawLimit != null && !["string", "number"].includes(typeof rawLimit)) ||
+      !Number.isSafeInteger(limit) || limit < 1 || limit > 20) invalid("--limit must be 1–20.");
+  if (options.adminIncludeSynthetic !== undefined && typeof options.adminIncludeSynthetic !== "boolean") {
+    invalid("--include-synthetic is a flag without a value.");
+  }
+  const includeSynthetic = options.adminIncludeSynthetic === true;
+  const query = new URLSearchParams({ since: since.text, until: until.text, limit: String(limit) });
+  if (includeSynthetic) query.set("includeSynthetic", "true");
+  if (options.adminCursor) query.set("cursor", String(options.adminCursor));
+  return {
+    name: "jevRouting.review",
+    method: "GET",
+    path: `/cli/admin/jev-routing/review?${query.toString()}`,
+    body: undefined,
+    mutates: false,
+    requiresRun: false,
+    pagination: {
+      collectionKey: "items",
+      after: since.seconds,
+      summaryKeys: ["collectionWindow", "coverage", "notes"],
+      filters: { since: since.text, until: until.text, includeSynthetic },
+    },
+  };
+}
+
+export function formatJevRoutingReview(data = {}) {
+  const window = data.collectionWindow || {};
+  const coverage = data.coverage || {};
+  const lines = [
+    `JEV review: [${window.since ?? "?"}, ${window.until ?? "?"}) · synthetic ${window.includeSynthetic ? "included" : "excluded"}`,
+    `${data.items?.length || 0} events returned · page ${coverage.status || "coverage unknown"}${coverage.fromBeginning === false ? " · resumed after a cursor" : ""}`,
+  ];
+  for (const item of data.items || []) {
+    lines.push(`#${item.eventId} ${item.route} · ${(item.reviewReasons || []).join(", ")} · selected ${item.selectedSource || "not recorded"} · frozen input ${item.contextAvailable ? "available" : item.contextUnavailableReason || "unavailable"}`);
+  }
+  if (data.nextCursor) lines.push(`Next cursor: ${data.nextCursor}`);
+  lines.push("Collection is not review. Read the JSON source pages; an exhausted resumed page does not prove the whole window was collected.");
+  return lines;
+}

package/lib/admin-owner-trace.js

@@ -4,7 +4,7 @@
 // no daily run needed. The server keeps 30 days.
 
 export const OWNER_TRACE_USAGE =
-  "Usage: lumine admin owner-trace [--since 2h|30m|3d|<iso>|<unix>] [--type route,feed-open,scroll-anchor,content-scroll,error,...] [--perf] [--wake] [--path <substring>] [--limit 300] [--json].";
+  "Usage: lumine admin owner-trace [--since 2h|30m|3d|<iso>|<unix>] [--until <unix-second>] [--cursor <time:id>] [--type route,feed-open,scroll-anchor,content-scroll,error,...] [--perf] [--wake] [--path <substring>] [--limit 300] [--json].";
 
 // --perf: only the performance events (tap-to-page timeline, slow API
 // requests, main-thread stalls, page load).
@@ -59,6 +59,15 @@ export function buildOwnerTraceOperation(options) {
   const query = new URLSearchParams();
   query.set("since", normalizeSince(options.adminSince));
   query.set("limit", String(limit));
+  if (options.adminUntil) {
+    const until = Number(options.adminUntil);
+    if (!Number.isSafeInteger(until) || until <= 0) throw validationError("--until must be a positive unix second.");
+    query.set("until", String(until));
+  }
+  if (options.adminCursor) {
+    if (!/^\d+:\d+$/.test(options.adminCursor)) throw validationError("--cursor must be a returned time:id pair.");
+    query.set("cursor", options.adminCursor);
+  }
   const types = String(options.adminType || "")
     .split(",")
     .map((type) => type.trim())
@@ -333,7 +342,7 @@ export function formatOwnerTrace(data) {
   const sessions = new Set(events.map((event) => event.sessionId));
   const since = Number(data?.since || 0);
   lines.push(
-    `Owner trace since ${since ? `${formatDay(since * 1000)} ${formatClock(since * 1000).slice(0, 5)}` : "?"} · ${events.length} event(s) · ${sessions.size} session(s)${data?.truncated ? " · older events cut off (raise --limit or narrow --since)" : ""}`,
+    `Owner trace since ${since ? `${formatDay(since * 1000)} ${formatClock(since * 1000).slice(0, 5)}` : "?"} · ${events.length} event(s) · ${sessions.size} session(s)${data?.truncated ? ` · more pages (keep --since/--until; --cursor ${data.nextCursor || "unavailable"})` : ""}`,
   );
   if (!events.length) {
     lines.push("Nothing recorded in this window.");

package/lib/admin.js

@@ -7,6 +7,7 @@ import {
   readdirSync,
   readFileSync,
   realpathSync,
+  statSync,
   writeFileSync,
 } from "node:fs";
 import path from "node:path";
@@ -48,6 +49,8 @@ import { buildSpendingOperation, completeSpendingReport, formatSpending } from "
 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 { summarizeGameDiagnostics } from "./game-diagnostic-summary.js";
 import {
   buildSlidingBlockOperation,
   formatSlidingBlockResult,
@@ -1314,6 +1317,32 @@ function readEditorialFile(filePath) {
   }
 }
 
+function gameDiagnosticSummary(options) {
+  const filePath = String(options.adminFile || "").trim();
+  const outputPath = options.adminOutput ? String(options.adminOutput).trim() : null;
+  if (options.positional?.length !== 2 || !filePath || outputPath === "") {
+    throw cliValidationError("Usage: lumine admin game-diagnostics summarize --file <envelope.json> [--json]. This reads retained evidence locally.");
+  }
+  const maxBytes = 16 * 1024 * 1024;
+  let metadata;
+  try { metadata = statSync(filePath); }
+  catch { throw cliValidationError("Could not read the game diagnostic envelope."); }
+  if (!metadata.isFile() || metadata.size > maxBytes) {
+    throw cliValidationError("The game diagnostic envelope must be a regular file under 16 MB.");
+  }
+  if (outputPath) {
+    let outputMetadata;
+    try { outputMetadata = statSync(outputPath); }
+    catch (error) { if (error.code !== "ENOENT") throw error; }
+    if (path.resolve(outputPath) === path.resolve(filePath) ||
+        (outputMetadata?.dev === metadata.dev && outputMetadata?.ino === metadata.ino)) {
+      throw cliValidationError("Keep the raw evidence: summary output must differ from the input file, including aliases.");
+    }
+  }
+  const envelope = readAdminJsonFile(filePath, "game diagnostic envelope", { maxBytes });
+  return { ok: true, status: "success", changed: false, data: summarizeGameDiagnostics(envelope) };
+}
+
 export async function adminCommand(options) {
   const [namespace, action] = options.positional || [];
   const composite =
@@ -1323,15 +1352,21 @@ export async function adminCommand(options) {
         ? dailyRunProgress
         : namespace === "featured" && action === "candidates"
           ? featuredCandidates
+          : namespace === "game-diagnostics" && action === "summarize"
+            ? gameDiagnosticSummary
           : namespace === "report" && action === "serve"
             ? reportServe
             : null;
   if (composite) {
     const result = await composite(options);
     if (options.adminOutput) {
-      writeFileSync(options.adminOutput, JSON.stringify(result), {
-        mode: 0o600,
-      });
+      if (composite === gameDiagnosticSummary) {
+        writeAdminJsonFile(options.adminOutput, result, { privateFile: true });
+      } else {
+        writeFileSync(options.adminOutput, JSON.stringify(result), {
+          mode: 0o600,
+        });
+      }
     }
     console.log(JSON.stringify(result, null, options.json ? 0 : 2));
     if (result && result.ok === false) process.exitCode = 1;
@@ -2409,6 +2444,7 @@ const FEATURED_RUN_OPERATIONS = new Set([
 // run's write work without the newspaper, sponsor scan or bank seeding (the
 // API holds the same line through the run's scopes).
 const APPROVALS_RUN_EXCLUDED_OPERATIONS = new Set([
+  "subject.website-update.post",
   "news.claim",
   "news.print",
   "news.submit",
@@ -2427,6 +2463,7 @@ export function assertAdminOperationAllowedForRunScope({
         "news.claim",
         "news.submit",
         "news.print",
+        "subject.website-update.post",
         "daily-run.complete",
         "daily-run.fail",
       ].includes(operation.name)
@@ -2674,6 +2711,9 @@ export function parseAdminOperation(options) {
   if (namespace === "owner-trace") {
     return buildOwnerTraceOperation(options);
   }
+  if (namespace === "jev-routing") {
+    return buildJevRoutingReviewOperation({ action, target, extra, options });
+  }
   // Who holds which management level (admin-roles.js); read-only, no run.
   if (namespace === "roles") {
     return buildRolesOperation(options);
@@ -3696,7 +3736,8 @@ export function parseAdminOperation(options) {
     if (days > 30 || userId && !buildId) throw cliValidationError("Use --build with --user; --days must be 1–30.");
     return readOperation("reward-diagnostics.read", withQuery("/cli/admin/reward-diagnostics", {
       buildId: buildId || undefined, userId: userId || undefined, days,
-      before: options.adminCursor ? parseRequiredInteger(options.adminCursor, "--cursor", 1) : undefined
+      before: options.adminCursor ? parseRequiredInteger(options.adminCursor, "--cursor", 1) : undefined,
+      until: options.adminUntil ? parseRequiredInteger(options.adminUntil, "--until", 1) : undefined
     }), { requiresRun: false });
   }
 
@@ -4162,6 +4203,22 @@ export function parseAdminOperation(options) {
   }
 
   if (namespace === "subject") {
+    if (action === "post-update") {
+      if (target || extra || !options.adminFile) {
+        throw cliValidationError("Usage: lumine admin subject post-update --file <article.json> [--confirm]. Preview is the default.");
+      }
+      const article = readAdminJsonFile(options.adminFile, "--file", { maxBytes: 256 * 1024 });
+      if (!article || typeof article !== "object" || Array.isArray(article)) {
+        throw cliValidationError("The article file must contain one composed website-update object.");
+      }
+      if (options.adminConfirm && options.adminConfirm !== "true") {
+        throw cliValidationError("Pass --confirm on its own, without a value.");
+      }
+      const confirm = options.adminConfirm === "true";
+      if (confirm && options.adminDryRun) throw cliValidationError("Choose --confirm or --dry-run, not both.");
+      const operation = confirm ? writeOperation : bodyReadOperation;
+      return operation("subject.website-update.post", "POST", "/cli/admin/subjects/website-update", { article, confirm });
+    }
     if (action === "get") return subjectGetOperation(target, options);
     if (action === "comments") {
       const subjectId = parseSubjectId(target);
@@ -7595,6 +7652,10 @@ function printAdminResult({ operation, result }) {
     printOwnerTrace(data);
     return;
   }
+  if (operation.name === "jevRouting.review") {
+    for (const line of formatJevRoutingReview(data)) console.log(line);
+    return;
+  }
   if (operation.name === "roles.read") {
     printRoles(data);
     return;

package/lib/commands.js

@@ -2508,6 +2508,7 @@ export function parseArgs(args) {
     "wake",
     "includeLegacy",
     "includePrivateEvidence",
+    "includeSynthetic",
     "allFlagged",
     "reviewed",
     "noReviewLoop",
@@ -2681,6 +2682,8 @@ export function parseArgs(args) {
     adminApprove: raw.approve ? String(raw.approve) : "",
     adminSinceRun: Boolean(raw.sinceRun),
     adminSince: raw.since ? String(raw.since) : "",
+    adminUntil: raw.until ? String(raw.until) : "",
+    adminIncludeSynthetic: Boolean(raw.includeSynthetic),
     adminPath: raw.path ? String(raw.path) : "",
     adminPerf: Boolean(raw.perf),
     adminWake: Boolean(raw.wake),
@@ -3322,7 +3325,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 | 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   (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 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>]
@@ -3330,6 +3333,7 @@ export function printHelp() {
   lumine admin meetup story list | show <crewId> | approve <crewId> [--note <text>] [--no-announce] | send-back <crewId> --note <text> | unpublish <crewId> --note <text>   (Bridge Builder story pages: publishes only what every tagged member's parent allowed)
   lumine admin reward-activity [--date YYYY-MM-DD] [--days <1..31>] [--build <id>] [--json]
   lumine admin reward-diagnostics [--build <id> --user <id>] [--days <1..30>] [--cursor <id>] [--json]
+  lumine admin game-diagnostics summarize --file <envelope.json> [--json]   (local retained sharedDb receipts; deduplicates stable events, preserves delivery and coverage limits)
   lumine admin chat-reports list [--status pending|open|reviewing|resolved|dismissed|all] [--cursor <id>] [--json]
   lumine admin chat-reports show <report-id> [--json]   (reported message snapshot + surrounding context)
   lumine admin chat-reports set <report-id> --status reviewing|resolved|dismissed|open --note <what was decided> [--json]
@@ -3352,6 +3356,7 @@ export function printHelp() {
   lumine admin builds review <build-url-or-id> [--output-dir <dir>] [--wait-ms <ms>] [--interact <steps.json>] [--browser-path <path>] [--json]
   lumine admin subjects candidates [--since-run|--after <date>|--include-legacy] [--effort unassigned] [--unviewed|--viewed] [--all --checkpoint <file> [--resume]] [--cursor <cursor>] [--json]
   lumine admin subject get|reveal <subject-url-or-id> [--json]
+  lumine admin subject post-update --file <article.json> [--confirm] [--json]
   lumine admin subject comments <subject-url-or-id> [--unviewed|--viewed] [--all --checkpoint <file> [--resume]] [--cursor <cursor>] [--json]
   lumine admin subject effort set <subject-id> --level <1|2|3> [--json]
   lumine admin subject creator set-made-by-poster <subject-id> [--json]
@@ -3378,6 +3383,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-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]
   lumine admin comment post --draft-id <id> [--json]

package/lib/game-diagnostic-summary.js

@@ -0,0 +1,204 @@
+import { createHash } from "node:crypto";
+
+const MAX_BYTES = 16 * 1024 * 1024;
+const MAX_ROWS = 10000;
+const DELIVERY_NUMBERS = new Set([
+  "v", "pending", "acknowledged", "requestFailures", "evicted", "expired",
+  "exhausted", "storageFailures", "oversized", "invalid", "attempt", "attempts",
+  "failures", "localEvictions", "coalescedBatches", "retryInMs"
+]);
+const DELIVERY_FIELDS = new Set([...DELIVERY_NUMBERS, "sending", "lastOutcome"]);
+const KINDS = new Set([
+  "lifecycle", "launch-outcome", "save-failed", "save-ok", "save-load-failed",
+  "save-protected", "save-recovered", "soundtrack-diagnostics", "error", "startup"
+]);
+const EVENTS = new Set([
+  "hidden", "visible", "blur", "focus", "pagehide", "session_started", "action",
+  "battle_choice", "board_solved", "board_started", "fight_left", "fight_result",
+  "fight_started", "input", "lesson_step", "progress", "puzzle_progress",
+  "runtime_error", "save_status", "scene", "stalled"
+]);
+const SOUNDTRACK_COUNTERS = new Set([
+  "ready", "recommendations", "recommendations-empty", "tag-load", "tag-search",
+  "tag-submit", "tag-remove", "lock-open", "lock-open-failed", "progress-load", "progress-save"
+]);
+const record = value => value !== null && typeof value === "object" &&
+  (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+const positiveId = value => Number.isSafeInteger(value) && value > 0;
+const stableId = value => typeof value === "string" && /^[\w:.-]{1,160}$/.test(value);
+const hash = text => createHash("sha256").update(text).digest("hex");
+
+// Validate the pure helper too: a caller need not have used the CLI's file cap.
+// Sort keys for semantic comparison, but never mutate the retained source.
+function canonicalJson(value, limit = MAX_BYTES) {
+  let bytes = 0;
+  const ancestors = new Set();
+  const token = text => {
+    bytes += Buffer.byteLength(text);
+    if (bytes > limit) throw new Error("Game diagnostic JSON exceeds its byte limit.");
+    return text;
+  };
+  function visit(item, depth) {
+    if (depth > 32) throw new Error("Game diagnostic JSON exceeds depth 32.");
+    if (item === null || typeof item === "boolean") return token(JSON.stringify(item));
+    if (typeof item === "number" && Number.isFinite(item)) return token(JSON.stringify(item));
+    if (typeof item === "string") {
+      if (item.length > limit) throw new Error("Game diagnostic JSON exceeds its byte limit.");
+      return token(JSON.stringify(item));
+    }
+    if ((!Array.isArray(item) && !record(item)) || ancestors.has(item)) throw new Error("Game diagnostics require finite, acyclic JSON values.");
+    ancestors.add(item);
+    const parts = [];
+    if (Array.isArray(item)) {
+      parts.push(token("["));
+      for (let i = 0; i < item.length; i++) {
+        if (i) parts.push(token(","));
+        parts.push(visit(item[i], depth + 1));
+      }
+      parts.push(token("]"));
+    } else {
+      parts.push(token("{"));
+      for (const key of Object.keys(item).sort()) {
+        if (parts.length > 1) parts.push(token(","));
+        parts.push(token(JSON.stringify(key)), token(":"), visit(item[key], depth + 1));
+      }
+      parts.push(token("}"));
+    }
+    ancestors.delete(item);
+    return parts.join("");
+  }
+  return visit(value, 0);
+}
+
+function semanticJson(data) {
+  if (!record(data.delivery)) return canonicalJson(data, 16384);
+  const semantic = { ...data };
+  const remaining = Object.entries(data.delivery).filter(([key]) => !DELIVERY_FIELDS.has(key));
+  if (remaining.length) semantic.delivery = Object.fromEntries(remaining);
+  else delete semantic.delivery;
+  return canonicalJson(semantic, 16384);
+}
+
+function deliverySnapshot(data) {
+  if (!record(data.delivery)) return null;
+  const snapshot = {};
+  for (const key of DELIVERY_NUMBERS) {
+    const value = data.delivery[key];
+    if (Number.isSafeInteger(value) && value >= 0) snapshot[key] = value;
+  }
+  if (typeof data.delivery.sending === "boolean") snapshot.sending = data.delivery.sending;
+  if (["none", "viewer-changed", "acknowledged", "failed"].includes(data.delivery.lastOutcome)) snapshot.lastOutcome = data.delivery.lastOutcome;
+  return Object.keys(snapshot).length ? snapshot : null;
+}
+
+function coverageOf(value) {
+  if (value !== undefined && !record(value)) throw new Error("Game diagnostic coverage must be an object.");
+  const coverage = { complete: value?.complete === true };
+  if (value?.complete !== undefined && typeof value.complete !== "boolean") throw new Error("Coverage complete must be a boolean.");
+  for (const key of ["since", "until"]) if (value?.[key] !== undefined) {
+    if (!Number.isSafeInteger(value[key]) || value[key] < 0) throw new Error("Coverage boundaries must be nonnegative integers.");
+    coverage[key] = value[key];
+  }
+  if (coverage.since !== undefined && coverage.until !== undefined && coverage.since >= coverage.until) throw new Error("Coverage until must be after since.");
+  return coverage;
+}
+
+/** Local, metadata-only summary. Input rows remain the canonical evidence. */
+export function summarizeGameDiagnostics(envelope) {
+  if (!record(envelope) || !positiveId(envelope.buildId) ||
+      typeof envelope.topic !== "string" || !/^[\w.-]{1,100}$/.test(envelope.topic) ||
+      !Array.isArray(envelope.entries) || envelope.entries.length > MAX_ROWS) {
+    throw new Error("Expected {buildId, topic, entries}; buildId must be positive, topic a technical name and entries at most 10000 rows.");
+  }
+  canonicalJson(envelope);
+  const collection = coverageOf(envelope.coverage);
+  const receipts = new Map(), groups = new Map(), legacy = [], observations = [];
+  let duplicateInputRows = 0, stableRows = 0, unknownArtifactRows = 0;
+  for (const entry of envelope.entries) {
+    if (!record(entry) || !positiveId(entry.id) || !positiveId(entry.userId) || !positiveId(entry.topicId) || !record(entry.data)) {
+      throw new Error("Every diagnostic entry requires canonical positive id, userId, topicId and object data; payload viewerId is not identity.");
+    }
+    if (entry.buildId !== undefined && entry.buildId !== envelope.buildId) throw new Error("Entry buildId does not match the envelope.");
+    const data = entry.data;
+    if (data.artifactVersionId != null && !positiveId(data.artifactVersionId)) throw new Error("artifactVersionId must be positive or unknown.");
+    for (const field of ["eventId", "batchId"]) if (data[field] != null && !stableId(data[field])) throw new Error(`Invalid diagnostic ${field}.`);
+    const exact = canonicalJson(data, 16384);
+    const receiptHash = hash(canonicalJson([entry.userId, entry.topicId, data.artifactVersionId ?? null, exact]));
+    if (receipts.has(entry.id)) {
+      if (receipts.get(entry.id) !== receiptHash) throw new Error("Conflicting copies of one canonical entry ID; inspect the retained raw source.");
+      duplicateInputRows++;
+      continue;
+    }
+    receipts.set(entry.id, receiptHash);
+    const artifactVersionId = data.artifactVersionId ?? null;
+    if (artifactVersionId === null) unknownArtifactRows++;
+    const fields = { entryId: entry.id, userId: entry.userId, topicId: entry.topicId, artifactVersionId };
+    const snapshot = deliverySnapshot(data);
+    if (snapshot) observations.push({ ...fields, delivery: snapshot });
+    const idType = data.eventId != null ? "eventId" : data.batchId != null ? "batchId" : null;
+    if (!idType) { legacy.push(data); continue; }
+    stableRows++;
+    const key = canonicalJson([envelope.buildId, envelope.topic, entry.topicId, entry.userId, artifactVersionId, idType, data[idType]]);
+    let group = groups.get(key);
+    if (!group) {
+      group = { ...fields, idType, stableId: data[idType], hashes: new Map(), rows: 0 };
+      groups.set(key, group);
+    }
+    group.rows++;
+    const fingerprint = hash(semanticJson(data));
+    let variant = group.hashes.get(fingerprint);
+    if (!variant) { variant = { data, entryIds: [] }; group.hashes.set(fingerprint, variant); }
+    variant.entryIds.push(entry.id);
+  }
+
+  const counted = [...legacy], collisions = [];
+  let uniqueStableEvents = 0, retryDuplicateReceipts = 0, collisionGroups = 0, collidingReceipts = 0;
+  for (const group of groups.values()) {
+    if (group.hashes.size > 1) {
+      collisionGroups++; collidingReceipts += group.rows;
+      if (collisions.length < 100) collisions.push({ userId: group.userId, topicId: group.topicId,
+        artifactVersionId: group.artifactVersionId, idType: group.idType, stableId: group.stableId,
+        receipts: group.rows, variants: [...group.hashes].slice(0, 20).map(([sha256, variant]) => ({ sha256,
+          entryIds: variant.entryIds.slice(0, 20), omittedEntryIds: Math.max(0, variant.entryIds.length - 20) })),
+        omittedVariants: Math.max(0, group.hashes.size - 20) });
+      continue;
+    }
+    uniqueStableEvents++; retryDuplicateReceipts += group.rows - 1;
+    counted.push(group.hashes.values().next().value.data);
+  }
+  const byKind = {}, alzebraEventNames = {}, soundtrackCounters = {};
+  let invalidCounterMetrics = 0;
+  for (const data of counted) {
+    const kind = data.batchId && !data.kind ? "alzebra-batch" : KINDS.has(data.kind) ? data.kind : "other";
+    byKind[kind] = (byKind[kind] || 0) + 1;
+    if (kind === "alzebra-batch" && Array.isArray(data.events)) for (const event of data.events) {
+      const name = EVENTS.has(event?.name) ? event.name : "other";
+      alzebraEventNames[name] = (alzebraEventNames[name] || 0) + 1;
+    }
+    if (kind === "soundtrack-diagnostics" && record(data.counters)) for (const name of SOUNDTRACK_COUNTERS) {
+      const value = data.counters[name];
+      if (value === undefined) continue;
+      if (!record(value) || !["count", "failed", "durationMs", "maxMs"].every(key => Number.isSafeInteger(value[key]) && value[key] >= 0 && value[key] <= 1e11) || value.failed > value.count) {
+        invalidCounterMetrics++;
+        continue;
+      }
+      const total = soundtrackCounters[name] ||= { count: 0, failed: 0, durationMs: 0, maxMs: 0 };
+      total.count += value.count; total.failed += value.failed; total.durationMs += value.durationMs;
+      total.maxMs = Math.max(total.maxMs, value.maxMs);
+    }
+  }
+  observations.sort((a, b) => b.entryId - a.entryId);
+  return {
+    schema: 1, buildId: envelope.buildId, topic: envelope.topic, collection,
+    rows: { input: envelope.entries.length, canonical: receipts.size, duplicateInputRows,
+      stableRows, legacyRows: legacy.length, unknownArtifactRows },
+    deduplication: { coverage: receipts.size === 0 ? "empty" : legacy.length || unknownArtifactRows || collisionGroups ? "partial" : "complete",
+      uniqueStableEvents, retryDuplicateReceipts, collisionGroups, collidingReceipts,
+      countedEvents: counted.length, collisions, omittedCollisions: Math.max(0, collisionGroups - collisions.length) },
+    counts: { byKind, alzebraEventNames, soundtrackCounters, invalidCounterMetrics },
+    delivery: { observations: observations.slice(0, 100), totalObservations: observations.length,
+      omittedObservations: Math.max(0, observations.length - 100),
+      note: "Per-receipt client snapshots; cumulative counters are not summed. An acknowledged count concerns earlier client receipts, not this row's gameplay save." },
+    note: "Preserve and read the raw receipts. Legacy rows remain separate and may contain retries; unknown artifacts are not version evidence. Collisions are excluded from event counts. Collection completeness describes supplied server rows, not successful delivery of every client event."
+  };
+}

package/package.json

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

package/sdk/LUMINE_ADMIN.md

@@ -1186,6 +1186,7 @@ lumine admin report serve --file <dir>/daily-management-report.md [--port <n>] [
 ```
 
 These compose the documented commands in this contract, running them as child processes, so every scope check, audit and pagination rule applies unchanged.
+- **Arena members waiting for papers come first.** `arena paper-queue --cursor <member-id> --limit <1-100> --json` lists members blocked by the lack of a fresh complete published paper, using the member-facing pass/retry and solo-mastery rules. Follow every `nextCursor`, including after an empty page; require `demandBasis: waiting-published-papers-v1`. Group all pages by exam/difficulty and prioritize these waiting members before generic unseen-question depth. Failed ordinary papers remain retryable; open/pending-marking sittings are not publication waits. Ten successful distinct Full Hard clears, with Zero/Ciel allowed, are needed between solo mastery attempts. The pass and full-marks 20× XP/Coins rewards are separately reserved, each once. Publish complete independently reviewed papers and verify the same members can advance. `gather` collects this queue first as `arena-paper-queue-N.json`, with `paperQueue.complete/pages/waitingTracks`; missing/malformed/partial coverage must not be reported as an empty healthy queue. Use the workspace CLI until npm publication is verified. This step grants no new authoring spend or publication authority.
 - **`gather`** saves its fixed set of read-only reports into `<dir>`, including the canonical published Math Lab queue in `math-lab-queue.json` and all types of pending Build review requests in `build-reviews-N.json`. Build reviews follow `nextCursor` to exhaustion; `gather.json` → `buildReviews` records `complete`, attempted `pages` and collected `items`. A failed/malformed page, cursor loop or 100-page bound reports incomplete coverage, never an empty healthy queue. Read the current collection once; it replaces the rewards-only list. Older packages without `buildReviews` need a separate `review list --status pending` collection through cursor exhaustion. Previous queue receipts remain on disk as history but do not become current evidence or duplicate reading duties after a new gather. It is not the complete daily checklist: app refills/usage, individual review assessments, sponsor integrity and other duties need their own steps. Repository agents follow the current full-run coverage index in `agent-guides/lumine-admin.md`. It follows `bot-output` to exhaustion and renders `bot-chats.txt`, then lists any failed step in `gather.json`. Total/per-step `durationMs`, attempts and recovered reads make recurring slow or failing collection steps visible during the daily review. It also creates `review-state.json`: collection never acknowledges reading. Children bypass update checks, require matching fresh stdout/file receipts, and retry an unconfirmed opted-in read at most once. Mutations never auto-retry. It needs the active run for run-scoped reads.
 - **`progress`** reads local review state and explicit operator acknowledgments, writes private `progress.json`, and keeps reading, canonical effort mutations, the run lease, and browser checks separate. `collectionFailures` includes failures without a page file, such as a cursor loop; acknowledging the available files cannot make an incomplete collection complete. A fresh successful gather clears those failures. Add all required duties for the actual run scope and its carryovers; collection alone is not a full review. A completed run lease cannot complete a pending duty. Reading acknowledgments bind to the current file bytes and are operator attestations, not proof of comprehension.
 - **`featured candidates`** returns Subjects posted after the Bangkok-midnight cutoff that are off the board and provably never Featured. Each one comes with its human/bot comment counts, explicit comment truncation/completeness, and whether Mikey has viewed it. Counts from truncated context are partial. An unavailable Subject context fails the collection. Eligibility only: ranking stays editorial.
@@ -1880,6 +1881,10 @@ and seeding coverage for steps 1-3 once the app is approved.
   decisions. The old Math Studio steps 1–3 / 20-per-run recipe is historical,
   not current authorization.
 
+### Game diagnostic delivery
+
+For retained game delivery evidence, `lumine admin game-diagnostics summarize --file <envelope.json> --json` is local-only and requires no login. The envelope is `{buildId,topic,entries,coverage:{complete,since,until}}`; keep the canonical sharedDb `id`, `userId`, `topicId` and parsed `data` on every row. The command deduplicates stable event/batch IDs within their canonical user/topic/artifact scope, flags conflicting copies, and reports legacy/unknown-version coverage. Raw evidence is still required for judgment. Cumulative delivery snapshots are not summed; server collection completeness does not prove complete client delivery. The reviewed October28 producers and CLI are not live until their release receipts confirm them. See `work/games-followup-20261028/` and the repository's daily guide.
+
 ### Reward activity report (standing duty, every full daily review; added 2026-09-12)
 
 Also inspect failed or unconfirmed payouts with `lumine admin reward-diagnostics --days 1 --json`.
@@ -3155,6 +3160,46 @@ type PostSkip = Success<{
 
 ## Twinkle Newspaper
 
+**Daily website-code update article (Mikey, 2026-10-28):** before claiming an
+edition, the duty bot (Zero/Ciel) publishes a real Subject at reward/effort level
+**2** about member-relevant website code changes shipped since the previous
+paper. Check Git/push history against successful production deployments and the
+actual live revision, then explain the useful changes in plain language; a push
+or a proposed fix is not a release. This is website development news, not a
+roundup of member posts or internal tooling. Cite that Subject's actual event
+from the claim digest and include the linked article on every front page; use
+it as the lead only when its significance warrants it. Verify author, level,
+source link and printed placement, and avoid duplicate posts or repeated release
+coverage. If no relevant changes shipped, say so briefly without inventing news.
+The standing instruction authorizes this scoped post and coverage; it grants no
+unrelated release authority. Keep release evidence and private diagnostics out
+of the public article. Follow the repository's daily website-code update
+procedure and the existing dated-revision contract for an approved correction.
+
+Use the scoped posting command after composing and reviewing the article:
+
+```bash
+lumine admin subject post-update --file article.json --json
+lumine admin subject post-update --file article.json --confirm --json
+```
+
+The first command is a read-only preview. The second publishes as the selected
+run's duty bot at level 2; `newspaper` or `full` run scope is required. The file
+contains `title`, `description`, `coverageStart` and `coverageEnd` (Unix seconds),
+and `releaseEvidence`: an array of `{repository, commit, deployedAt, summary}`.
+Use full Git commit hashes and verified deployment times inside the completed
+coverage interval. The evidence stays private; put only useful member-facing
+information in the article. An empty evidence array is allowed when no relevant
+changes shipped, and the article should say that briefly. The command does not
+independently verify GitHub/Vercel receipts: the operator must do that first.
+
+One canonical article is permitted per scheduled editorial day. An identical
+retry returns its existing Subject instead of notifying members again; a
+changed payload, changed duty bot or edited/deleted post requires inspection
+and is not silently overwritten or recreated. Preview reports any existing
+Subject. The already-published October28 article is reserved as a legacy post;
+reuse Subject37265 rather than trying to republish it with this new command.
+
 **Audience (Mikey, 2026-09-15): children and young Twinkle users aged 10–15.**
 Choose and write stories for what these readers would voluntarily spend time
 reading. Before selecting a story, identify its appeal to them: curiosity,
@@ -5467,6 +5512,10 @@ Legacy aliases such as `subjects list`, `subjects get`, `subjects featured`,
 `comments get`, and `recommend` remain accepted, but the singular command forms
 shown above are the canonical interface.
 
+For bounded case evidence, use `lumine admin jev-routing review --since <UTC-day> --until <next-UTC-day> --json` and follow every cursor, or `--all --checkpoint <persistent-file>`. Daily gather retains every20-event source page for the preceding complete UTC day. The reader covers paired disagreements and Auto fallbacks once per event; synthetic traffic is excluded unless `--include-synthetic` is explicit. It returns only currently unexpired frozen input and labels absent/expired input. A missing endpoint is unavailable coverage, not an empty healthy day. Collection never acknowledges reading or proves classification accuracy. This October28 reader and independent Auto-input capture are local until the matching release is verified.
+
+Before calling a reply unrelated, check its original generation trigger and the bounded `askedAbout` descriptor. A member may have edited the visible turn or asked about linked content. The descriptor explicitly represents current stored metadata, not a separately frozen generation snapshot; never bypass deleted context.
+
 Read `jevRoutingShadow` alongside `jevPilot` in both the admin brief and full
 daily report. The September 21 primary-chat experiment is historical: chat
 routing is off by default and served-route audits were retired September 23.