@stage5/lumine 0.3.66 → 0.3.68

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 | import --dir <paper folder> [--audio audio/<exam>/<paper>] [--live] [--confirm] | status --item <id> --to live|retired|checked [--confirm] [--json]";
+  "Usage: lumine admin arena queue | marking [--cursor <id>] [--limit <1-200>] | import --dir <paper folder> [--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) {
@@ -50,6 +50,37 @@ function readPaper(dir) {
 }
 
 export function buildArenaOperation({ action, options }) {
+  if (action === "today-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.today.queue", method: "GET", path: `/cli/admin/arena/today/queue?cursor=${cursor}&limit=${limit}`, mutates: false, requiresRun: false };
+  }
+  if (action === "today-member") {
+    const id = Number(options.adminUser);
+    if (!Number.isSafeInteger(id) || id <= 0) throw validationError("Use today-member --user <member id>.");
+    return { name: "arena.today.member", method: "GET", path: `/cli/admin/arena/today/member/${id}`, mutates: false, requiresRun: false };
+  }
+  if (action === "today-import") {
+    if (!options.adminFile) throw validationError("Use today-import --file <reviewed-questions.json> [--confirm].");
+    const file = path.resolve(options.adminFile);
+    if (fs.statSync(file).size > 1000000) throw validationError("The import file must be under 1 MB.");
+    const payload = JSON.parse(fs.readFileSync(file, "utf8"));
+    const confirm = confirmed(options);
+    return { name: confirm ? "arena.today.import" : "arena.today.preview", method: "POST", path: "/cli/admin/arena/today/import", body: { ...payload, dryRun: !confirm }, mutates: confirm, requiresRun: false };
+  }
+  if (action === "marking") {
+    const cursor = Number(options.adminCursor || 0);
+    const limit = Number(options.adminLimit ?? 100);
+    if (!Number.isSafeInteger(cursor) || cursor < 0 || !Number.isInteger(limit) || limit < 1 || limit > 200) {
+      throw validationError("Use a non-negative --cursor and --limit from 1 to 200.");
+    }
+    return {
+      name: "arena.marking", method: "GET",
+      path: `/cli/admin/arena/marking?cursor=${cursor}&limit=${limit}`,
+      body: undefined, mutates: false, requiresRun: false,
+    };
+  }
   if (!action || action === "queue") {
     return {
       name: "arena.queue",
@@ -102,6 +133,22 @@ export function buildArenaOperation({ action, options }) {
 }
 
 export function formatArenaResult({ operation, data }) {
+  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.",
+  ];
+  if (operation.name === "arena.today.member") return [JSON.stringify(data, null, 2)];
+  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." : ""}`,
+  ];
+  if (operation.name === "arena.marking") {
+    const entries = data?.entries || [];
+    return [
+      `Checked ${data?.scannedBattles ?? 0} completed battles; ${entries.length} need follow-up on this page.`,
+      ...entries.map((row) => `Battle ${row.battleId}, member ${row.userId}, ${row.examKey}: ${row.reasons.join(", ")} (${row.pendingAnswers} answers pending; ${row.xpEarned}/${row.xpExpected} XP and ${row.coinsEarned}/${row.coinsExpected} Coins paid)`),
+      ...(data?.nextCursor ? [`Continue: lumine admin arena marking --cursor ${data.nextCursor} --json`] : ["End of marking/reward census."]),
+    ];
+  }
   if (operation.name === "arena.queue") {
     const types = data?.types || [];
     if (!types.length) return ["No live Arena items yet."];

package/lib/admin-daily.js

@@ -264,7 +264,10 @@ export async function dailyRunGather(options, { run = runAdmin } = {}) {
     ...(!wake.ok ? ["owner-wake"] : []),
     ...(!wakeSessions.ok ? ["owner-wake-sessions"] : []),
   ];
-  if (ownerWake.collectionFailures.length) ownerWake.coverage = ownerWake.usableSamples ? "partial" : "unavailable";
+  if (ownerWake.collectionFailures.length) {
+    ownerWake.coverage = ownerWake.usableSamples ? "partial" : "unavailable";
+    ownerWake.detail.coverage = ownerWake.detail.samples ? "partial" : "unavailable";
+  }
   writeAdminJsonFile(path.join(dir, "owner-wake-summary.json"), ownerWake, { privateFile: true });
   fs.writeFileSync(path.join(dir, "owner-wake-summary.md"), formatOwnerViewportReport(ownerWake), { mode: 0o600 });
   steps.push({ name: "owner-wake-summary", file: "owner-wake-summary.json", ok: true });

package/lib/admin-owner-trace.js

@@ -201,6 +201,9 @@ function describeViewport(data) {
     `nav bottom ${nav.bottom ?? "?"} (${nav.position || "absent"})`,
     `inset ${data.inset ?? "?"} focus ${focus.tag || "none"}${focus.type ? `:${focus.type}` : ""}`,
     `scroll ${data.root?.scrollTop ?? "?"}`,
+    isPlainObject(data.signals) ? `signals ${Object.entries(data.signals).map(([name, count]) => `${name}:${count}`).join(",")}` : "",
+    isPlainObject(data.layout) ? `detail ${data.layout.omitted || `v${data.layout.v}; body top ${data.layout.body?.top ?? "?"}; ancestor effects ${Array.isArray(data.layout.ancestors) ? data.layout.ancestors.length : "?"}`}` : "",
+    isPlainObject(data.activity) ? `changes ${data.activity.changes ?? "?"}/${data.activity.limit ?? "?"}; skipped events ${data.activity.skippedEvents ?? "?"}` : "",
     data._trimmed ? `trimmed ${JSON.stringify(data._trimmed)}` : "",
   ].filter(Boolean).join(" · ");
 }

package/lib/admin-owner-viewport.js

@@ -33,7 +33,9 @@ export function summarizeOwnerViewport(data, sessionData = data) {
     }
     cycle.samples += 1;
     if (d.phase === "background") cycle.backgroundSamples += 1;
-    cycle.lastScheduledMs = Math.max(cycle.lastScheduledMs, Number(d.scheduledMs) || 0);
+    // Activity samples can occur minutes later; only a scheduled baseline
+    // establishes that the report actually observed the 20-second follow-up.
+    if (d.phase === "settle") cycle.lastScheduledMs = Math.max(cycle.lastScheduledMs, Number(d.scheduledMs) || 0);
     if (d.phase !== "settle" || d.scheduledMs < 1000 || d.visibility !== "visible") continue;
     cycle.settledSamples += 1;
     const nav = d.nav;
@@ -81,6 +83,7 @@ export function summarizeOwnerViewport(data, sessionData = data) {
     truncated: Boolean(data?.truncated), sessionHeadersTruncated: Boolean(sessionData?.truncated),
     viewportEvents, usableSamples, unavailableSamples: unavailable, droppedEvents: dropped,
     wakeProfiles: events.filter(e => e.type === "wake").length,
+    detail: summarizeViewportDetail(events, usableSamples, partial),
     clients, clientsWithoutGeometry,
     cycles: rows, cyclesMissingHeaders: missingHeaders,
     cyclesReaching20s: rows.filter(c => c.lastScheduledMs >= 20_000).length,
@@ -92,6 +95,92 @@ export function summarizeOwnerViewport(data, sessionData = data) {
   };
 }
 
+function summarizeViewportDetail(events, usableSamples, partial) {
+  const rows = events.filter(e => e.type === "wake-viewport" && e.data?.v === 1 &&
+    !e.data.error && !e.data._trimmed && e.data.window && e.data.root && e.data.focus);
+  const detailed = rows.filter(e => e.data.layout?.v === 2 && !e.data.layout.omitted);
+  const omitted = rows.filter(e => e.data.layout?.omitted).length;
+  const limitedAncestors = detailed.filter(e => e.data.layout.ancestorLimit).length;
+  const capped = new Set();
+  const groups = new Map();
+  const examples = [];
+  let firstTouchPairs = 0, firstTouchChanges = 0, boundaryChanges = 0, ancestorSamples = 0;
+  const addExample = (event, kind, extra) => {
+    if (examples.filter(example => example.kind === kind).length < 3) examples.push({ kind, sessionId: event.sessionId,
+      cycle: event.data.cycle, seq: event.seq, clientTime: event.clientTime, path: event.path, ...extra });
+  };
+  for (const event of rows) {
+    const d = event.data, key = `${event.sessionId}:${d.cycle}`;
+    const limit = Number(d.activity?.limit);
+    if ((limit > 0 && Number(d.activity?.changes) >= limit) || Number(d.activity?.skippedEvents) > 0) capped.add(key);
+    if (d.layout?.v !== 2 || d.layout.omitted) continue;
+    if (Array.isArray(d.layout.ancestors) && d.layout.ancestors.length) {
+      ancestorSamples++;
+      addExample(event, "ancestor-layout-effects", { ancestors: d.layout.ancestors });
+    }
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key).push(event);
+  }
+  for (const group of groups.values()) {
+    // Within one client session sequence order survives wall-clock changes.
+    group.sort((a, b) => a.seq - b.seq || a.clientTime - b.clientTime);
+    let previous = null, firstTouch = null;
+    for (const event of group) {
+      const d = event.data;
+      if (d.signals?.["first-touch"]) firstTouch = event;
+      if (d.signals?.["after-first-touch"] && firstTouch) {
+        const delta = compareBoundaries(firstTouch, event);
+        // A tap can navigate or focus a keyboard; neither is a same-page repair.
+        if (delta && d.elapsedMs - firstTouch.data.elapsedMs <= 2000) {
+          firstTouchPairs++;
+          if (delta.maximum >= 40) {
+            firstTouchChanges++;
+            addExample(event, "first-touch-boundary-change", { beforeSeq: firstTouch.seq, ...delta });
+          }
+        }
+        firstTouch = null;
+      }
+      if (previous) {
+        const delta = compareBoundaries(previous, event);
+        if (delta && delta.maximum >= 40) {
+          boundaryChanges++;
+          addExample(event, "boundary-change", { beforeSeq: previous.seq, signals: d.signals, ...delta });
+        }
+      }
+      previous = event;
+    }
+  }
+  return {
+    coverage: !detailed.length ? "unavailable" : partial || limitedAncestors || detailed.length < usableSamples ? "partial" : "observed",
+    samples: detailed.length, omittedSamples: omitted, limitedAncestorSamples: limitedAncestors, activityCappedCycles: capped.size,
+    firstTouchPairs, firstTouchChanges, boundaryChanges, ancestorSamples, examples,
+    note: "Boundary changes (>=40px) and ancestor CSS effects are comparison evidence, not confirmed gaps or repairs. A first touch can naturally move browser controls. Unchanged DOM measurements cannot rule out a visible rendering fault. Activity capture is bounded; no samples or a reached cap cannot establish healthy behavior.",
+  };
+}
+
+function compareBoundaries(before, after) {
+  const a = before.data, b = after.data;
+  if (![a.elapsedMs, b.elapsedMs, a.window.width, b.window.width].every(Number.isFinite) ||
+      before.path !== after.path || a.window.width !== b.window.width ||
+      a.layout.orientation !== b.layout.orientation || b.elapsedMs <= a.elapsedMs) return null;
+  for (const d of [a, b]) {
+    if (d.visibility !== "visible" || d.inset !== 0 || d.focus.editable ||
+        ["input", "textarea", "iframe"].includes(d.focus.tag) ||
+        !Number.isFinite(d.visual?.scale) || Math.abs(d.visual.scale - 1) > 0.01 ||
+        d.nav?.position !== "fixed" || parseFloat(d.nav.bottomStyle) !== 0 ||
+        d.nav.height <= 0 || d.nav.display === "none" || d.nav.visibility === "hidden") return null;
+    if (![d.window.height, d.root.height, d.visual.height, d.visual.offsetTop, d.nav.bottom].every(Number.isFinite)) return null;
+  }
+  const changes = {
+    window: b.window.height - a.window.height,
+    root: b.root.height - a.root.height,
+    visual: b.visual.height - a.visual.height,
+    visualTop: b.visual.offsetTop - a.visual.offsetTop,
+    navBottom: b.nav.bottom - a.nav.bottom,
+  };
+  return { changes, maximum: Math.max(...Object.values(changes).map(Math.abs)) };
+}
+
 export function formatOwnerViewportReport(summary) {
   const lines = [
     "# Owner wake viewport follow-up", "",
@@ -100,6 +189,9 @@ export function formatOwnerViewportReport(summary) {
     `Collection failures: ${summary.collectionFailures?.join(", ") || "none"}.`, "",
     `Large-gap candidates: ${summary.largeGapCycles} cycles; ${summary.repeatedLargeGapCycles} had settled bottom-nav gaps >=100px at least 500ms apart in actual time, no focused input, no app keyboard inset and scale 1.`, "",
     `Missing/trimmed geometry: ${summary.unavailableSamples}; clients without usable geometry: ${summary.clientsWithoutGeometry}; reported dropped events: ${summary.droppedEvents}; cycles without session context: ${summary.cyclesMissingHeaders}; truncated trace: ${summary.truncated}; truncated session history: ${summary.sessionHeadersTruncated}.`, "",
+    `Expanded diagnostics: **${summary.detail?.coverage || "unavailable"}**; ${summary.detail?.samples || 0} detailed samples, ${summary.detail?.omittedSamples || 0} payload-budget omissions, ${summary.detail?.limitedAncestorSamples || 0} bounded ancestor scans, ${summary.detail?.activityCappedCycles || 0} cycles reached the activity cap.`, "",
+    `Comparison leads: ${summary.detail?.boundaryChanges || 0} boundary changes >=40px; ${summary.detail?.firstTouchPairs || 0} comparable first-touch pairs (${summary.detail?.firstTouchChanges || 0} changed >=40px); ${summary.detail?.ancestorSamples || 0} samples with ancestor layout effects. These are not diagnoses. See detail.examples in owner-wake-summary.json and the corresponding raw sequence numbers.`, "",
+    summary.detail?.note || "Expanded telemetry has not been observed in this window.", "",
     summary.note, "",
     "Read owner-wake.json and owner-wake-sessions.json alongside this summary. Compare affected and ordinary cycles within the same client/browser version. Distinguish viewport height changes, viewport panning and nav displacement; correlate the wake performance profile and its upload network tag. Record the evidence and next action in the daily report even when coverage is unavailable.", "",
     "| Client | Platform | Cycle | Samples | Settled | Large gap | Max root gap | Max visual gap |",

package/lib/admin.js

@@ -3013,6 +3013,20 @@ export function parseAdminOperation(options) {
     // Mikey's decisions, any time; each comes with its evidence (approvals.ts).
     return buildApprovalOperation({ action, target, options });
   }
+  if (namespace === "dictionary") {
+    if (action === "korean-status") return readOperation("dictionary.korean-status", "/cli/admin/dictionary/korean/status", { requiresRun: false });
+    if (action === "korean-pending") return readOperation("dictionary.korean-pending", withQuery("/cli/admin/dictionary/korean/pending", {
+      cursor: options.adminCursor || undefined,
+      limit: parseRequiredInteger(options.adminLimit || 30, "--limit", 1, 100),
+    }), { requiresRun: false });
+    if (action === "korean-review" && target) {
+      const raw = readAdminJsonFile(target, "<reviewed-definitions.json>", { maxBytes: 512 * 1024 });
+      const items = Array.isArray(raw) ? raw : raw?.items;
+      if (!Array.isArray(items) || !items.length || items.length > 100) throw cliValidationError("Review 1 to 100 Korean definitions, keeping exported word IDs, revisions and source hashes.");
+      return writeOperation("dictionary.korean-review", "POST", "/cli/admin/dictionary/korean/review", { items, dryRun: Boolean(options.adminDryRun) }, { requiresRun: false, mutates: !options.adminDryRun, timeoutMs: 120000 });
+    }
+    throw cliValidationError("Use: lumine admin dictionary korean-status | korean-pending [--cursor <time:id>] [--limit <1-100>] | korean-review <reviewed-definitions.json> [--dry-run]");
+  }
   if (namespace === "word-games") {
     if (action === "status") return readOperation("word-games.status", "/cli/admin/word-games/status", { requiresRun: false });
     if (action === "candidates") return readOperation("word-games.candidates", withQuery("/cli/admin/word-games/candidates", {

package/lib/commands.js

@@ -3310,6 +3310,7 @@ export function printHelp() {
   lumine admin teachers audit [--limit <1-100>] [--cursor <c>] [--all] | revoke <userId> --reason <text>   (approved teachers, a page at a time or --all: new flags first, then changed since your review; revoke removes the status cleanly)
   lumine admin teachers branches suggest | networks | confirm <networkId> --branch <name> [--branch <name>] [--note <text>] | unconfirm <networkId> | set <userId|username> --branch <name> [--note <text>] | clear <userId|username> | apply | list [--branch <name>|none]   (which branch each teacher works at, confirmed by you through the academy networks they use: suggest finds the networks, confirm names their branch (repeat --branch for a building branches share), apply gives teachers the branch most of their actions there point at and lists the unclear ones; set wins over networks)
   lumine admin teachers review <userId> --decision legit|revoke --note <text> [--fingerprint <fp>, required for revoke] | review --all-flagged --expect <id[:fp],...> --note <text>   (record your review of the facts shown; --all-flagged records only the --expect teachers; nothing is recorded if they changed since. A reviewed teacher comes back when its flags or linked accounts change; accounts sharing a network count only when they change a network flag)
+  lumine admin dictionary korean-status | korean-pending [--cursor <time:id>] [--limit <1-100>] | korean-review <reviewed-definitions.json> [--dry-run]   (shared Korean word-bank definitions; daily review, no paid generation)
   lumine admin english import <verdicts.json> --pass a|b | adjudicate <file> | add-questions <file> | relevel <file> | mastery <userId> --reason <why> | backfill-distractors | summary | review [--limit <n>] | accept|retire <questionId> | retag <questionId> --skill <code>   (English skill tags and bank upkeep for Grammarbles; content written by Claude Code agents)
   lumine admin reward-review list [--status pending|approved|all] [--cursor <id>] [--json]
   lumine admin cardcraft-review list [--status pending|approved|all] [--cursor <id>] | show <id> | approve|reject|revoke <id> [--reason <text>]

package/lib/sdk.js

@@ -41,6 +41,9 @@ export const SDK_CLI_METHODS = {
   "wordMaster.reportIssue": { path: "api/content/word-master/telemetry", scopes: ["content:write"], write: true },
   "wordMaster.getDailyWords": { path: "api/content/word-master/words", scopes: ["content:read"] },
   "wordMaster.getWord": { path: "api/content/word-master/details", scopes: ["content:write"], write: true },
+  "wordMaster.lookupWord": { path: "api/content/word-master/dictionary", scopes: ["content:read"] },
+  "wordMaster.generateKoreanDefinition": { path: "api/content/word-master/korean-definition", scopes: ["content:write"], write: true },
+  "wordMaster.getKoreanDefinition": { path: "api/content/word-master/korean-definition-status", scopes: ["content:write"], write: true },
   "wordMaster.generateEntry": { path: "api/content/word-master/generate-entry", scopes: ["content:write"], write: true },
   "wordMaster.getEntry": { path: "api/content/word-master/entry-status", scopes: ["content:read"], write: true },
   "wordMaster.encounterWords": { path: "api/content/word-master/encounter", scopes: ["content:write"], write: true },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage5/lumine",
-  "version": "0.3.66",
+  "version": "0.3.68",
   "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.73.0
-Updated: 2026-10-25
-Generated: 2026-10-25T00:59:10.277Z
+Updated: 2026-10-27
+Generated: 2026-10-26T22:37:17.385Z
 
 ## 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.
@@ -828,6 +828,21 @@ const result = await Twinkle.characters.chat({ character: 'zero', thinkingMode:
   - Returns: { word: { id, word, definition, example, wordLevel, canGenerate }, mode }
   - Open an existing Word Master word’s reviewed definition and example, and add it to the viewer’s book.
   - Pass wordId or the exact word. Reuses reviewed existing definitions and suitable public AI Card examples. Blank definition/example means missing. Adds this encounter to the book but awards nothing; this is a write for CLI/capture permission purposes. No viewer AI Battery is used.
+- async lookupWord({ wordId, word }) | scopes: content:read
+  - Returns: { word: { id, word, wordLevel, definitions: [{ partOfSpeech, definition }], koreanDefinition, koreanDefinitionRevision, koreanDefinitionStatus } }
+  - Read an exact word from the shared dictionary without spending Battery or changing the viewer’s book.
+  - Pass wordId or an exact English headword (1–64 characters; internal spaces, apostrophes and hyphens supported). Only existing, uncensored word-bank entries are eligible; an unknown spelling returns dictionary_word_not_found (404). This does not create words or perform reverse Korean search.
+  - koreanDefinitionStatus is missing, generated (awaiting daily review), or reviewed. definitions contains up to 12 existing English meanings. Reads never generate or charge. Always use current canonical text: daily corrections replace earlier generated text.
+- async generateKoreanDefinition({ wordId, requestId, useAiBattery }) | scopes: content:write
+  - Returns: { entry?: { id, wordId, requestId, status, failureCode }, word?, pending?, alreadyComplete?, aiUsagePolicy? }
+  - Fill a missing shared Korean definition using the searching member’s AI Battery.
+  - Before the intentional search, clearly disclose that a missing Korean definition uses the viewer’s AI Battery; pass useAiBattery:true. Do not generate on page load, resume, keystrokes or background refresh. Cached content costs no Battery. This is shared canonical dictionary content in BOTH preview and live, across all apps; it grants no XP, Coins, mastery or completion receipt.
+  - Persist a stable 16–64 character requestId before calling. One reservation per word prevents concurrent duplicate generations. pending:true means another request owns that reservation: use free lookupWord checks, then allow an explicit retry if it remains missing. Never invent a payment or definition from local state.
+  - entry.status is pending, generated, ready, failed or superseded. Recover unknown transport outcomes with getKoreanDefinition and the SAME requestId; retrying generate with that same ID is idempotent. A confirmed failed job may be deliberately retried with a new ID. Only successful saved definitions charge Battery, atomically with publication. At most 20 generation attempts per member per UTC day and one active generation per member.
+- async getKoreanDefinition({ requestId }) | scopes: content:write
+  - Returns: { entry: { id, wordId, requestId, status, failureCode } | null, word?, aiUsagePolicy? }
+  - Recover a Korean-definition request after a lost response without another model call.
+  - Scoped to this build and viewer. A generated result is saved and charged once; status never launches another model call. entry:null means no job was found: an explicit retry must reuse the saved requestId. Return values include the current shared definition, including subsequent reviewer corrections.
 - async generateEntry({ wordId, requestId, useAiBattery }) | scopes: content:write
   - Returns: { entry?, word?, alreadyComplete?, aiUsagePolicy, mode }
   - Use viewer AI Battery to fill a missing meaning/example once, with a server-verified contribution receipt.

package/sdk/LUMINE_ADMIN.md

@@ -1653,6 +1653,27 @@ control contents. Normal wakes are retained for comparison. `--perf` also
 includes the geometry rows. The session's `viewportTrace: 1` marks support;
 older tabs do not acquire it until they load a version containing the change.
 
+The October 26 expanded recorder keeps that v1 event compatible and adds
+`layout.v: 2` (`viewportDetail: 2` on the session): body/root bounds, nav padding,
+orientation and bounded ancestor CSS-effect flags. Mobile load/return cycles
+also capture one first-touch/300ms pair and at most four debounced
+resize/scroll/orientation bursts. `signals` and `activity` retain event counts,
+the cap and skipped/pending events; optional context can explicitly report
+`omitted: "payload-budget"`. No page content, screenshot or automatic correction
+is included. Check `work/mobile-bottom-gap-20261026/telemetry/STATUS.md` for
+actual release status; use the workspace CLI for this expanded summary until
+an npm release containing it is recorded there.
+
+The daily summary's `detail` reports expanded coverage, capped/omitted samples,
+boundary changes, comparable first-touch pairs and ancestor effects, with raw
+sequence numbers for follow-up. These are comparison leads, never proof of a
+rendering defect or repair. Normal toolbar movement changes heights too. A
+normal DOM rectangle cannot disprove a visible compositor-only gap, and reads
+may flush pending layout. Review new evidence and keep the original roughly
+108px gap open until its cause and fix are established. Follow the owner-wake
+section in `agent-guides/lumine-admin.md`; do not restart the stopped physical
+phone/Simulator investigation without Mikey's instruction.
+
 `daily-run gather` additionally saves `owner-wake.json`, the retained session
 context in `owner-wake-sessions.json`, and `owner-wake-summary.json` / `.md`.
 Include the coverage and follow-up in the daily report. A >=100px settled gap
@@ -5544,3 +5565,13 @@ Every full daily website-management run adds reviewed Word Master words across a
 ## Word Search monthly champions
 
 Word Search rankings come from server-verified solves, but every board comes from public inputs, so a script playing at a human-looking pace can still rank. A month's champion prize (word-search-champion-v1) opens only after review. From 07:00 UTC on the 2nd, run `lumine admin word-games champions --build <id>`. It lists the last three final months: the current candidate, whether the win is confirmed or collected, and each top-three player's best solves (score, seconds, words, gaps between words, gap variation (near 0 means machine-even spacing), misses, pauses, hints, best streak, days played). Confirm a believable human with `lumine admin word-games confirm <YYYY-MM> <userId> --build <id> --reason "<evidence>"`. Disqualify a scripted winner with `disqualify`; the next eligible player becomes the candidate, so review them too. Removed and fully banned accounts are skipped automatically. Both writes are audited, and neither works after the prize is collected. Until confirmation the winner's game shows that the win is being checked.
+
+## Shared Korean dictionary definitions
+
+Every full management run includes this dedicated review, requested by Mikey October 27. A missing Korean definition is generated on an intentional member search using **that member's AI Battery**; saved definitions are shared and free to reuse. Preview and live apps use the same canonical word bank. These admin commands never invoke a paid model, charge a member, or grant rewards.
+
+- `lumine admin dictionary korean-status --json`: current generated/reviewed/pending coverage, oldest pending time, outstanding jobs and recent failures.
+- `lumine admin dictionary korean-pending --limit 100 [--cursor <time:id>] --json`: full text, English reference meanings, exact IDs/revisions/source hashes. Continue through `nextCursor` until null. Read and assess every entry; collection alone is not review.
+- `lumine admin dictionary korean-review <reviewed.json> --dry-run --json`, then omit `--dry-run` to apply the same reviewed payload within authorized content-maintenance scope. Accepts an array or `{ "items": [...] }`, 1–100 entries, each `{ "wordId": 123, "word": "example", "expectedRevision": 1, "expectedSourceHash": "<exported SHA-256>", "koreanDefinition": "<checked Korean meaning>", "reason": "<what was checked or corrected>" }`. Keep exact exported identity/version fields; supply a reason even when accepting unchanged text. All entries commit together with a mutation audit. Conflicts require re-export and re-review, never blind retry with new revisions.
+
+Assess common senses, part of speech and inflections, precision and natural Korean for learners. Use your own language judgment and source checks where needed; no paid batch-generation calls. Corrections update the shared word-bank field for all apps; successful reviews mark it reviewed and advance its revision. Future paid generation never overwrites existing text. The final run report includes reviewed/corrected/remaining counts, oldest waiting age, generation/Battery recovery failures, pagination coverage and carryovers. Re-read status after applying. Missing tables/endpoints mean the release is unavailable, not an empty healthy queue.