@stage5/lumine 0.3.61 → 0.3.63

package/lib/admin-chat-reports.js

@@ -23,6 +23,16 @@ function indent(text, prefix) {
     .join("\n");
 }
 
+// A member's platinum cover photo goes through the same report queue
+// (subjectType "profile_cover"); its snapshot is the cover as one line.
+function isCoverReport(report) {
+  return report?.subjectType === "profile_cover";
+}
+
+function subjectNoun(report) {
+  return isCoverReport(report) ? "cover photo" : "message";
+}
+
 function formatMessageLine(message, marker = " ") {
   const author = message.username || (message.userId ? `user #${message.userId}` : "unknown");
   const content = String(message.content ?? "").trim() || "(no text)";
@@ -32,6 +42,7 @@ function formatMessageLine(message, marker = " ") {
 }
 
 function where(report) {
+  if (isCoverReport(report)) return "their profile cover photo (only Mikey can take it down)";
   const parts = [];
   if (report.channelKind) parts.push(report.channelKind);
   if (report.channelId) parts.push(`channel ${report.channelId}`);
@@ -45,7 +56,7 @@ export function formatChatReportLine(report) {
     .replace(/\s+/g, " ")
     .trim();
   const short = preview.length > 80 ? `${preview.slice(0, 79)}…` : preview;
-  return `#${report.id} ${String(report.status || "open").toUpperCase()} · ${report.reasonLabel || report.reason || "no reason"} · ${who(report.reporter)} → ${who(report.reported)} · ${formatTime(report.createdAt)}${Number(report.reportsOfThisMessage) > 1 ? ` · ${report.reportsOfThisMessage} reports of this message` : ""}${short ? `\n    "${short}"` : ""}`;
+  return `#${report.id} ${String(report.status || "open").toUpperCase()} · ${report.reasonLabel || report.reason || "no reason"} · ${who(report.reporter)} → ${who(report.reported)} · ${formatTime(report.createdAt)}${Number(report.reportsOfThisMessage) > 1 ? ` · ${report.reportsOfThisMessage} reports of this ${subjectNoun(report)}` : ""}${short ? `\n    "${short}"` : ""}`;
 }
 
 export function formatChatReportList(data = {}) {
@@ -71,7 +82,7 @@ export function formatChatReportList(data = {}) {
 export function formatChatReport(report = {}) {
   const lines = [];
   lines.push(
-    `Chat report #${report.id}: ${String(report.status || "open").toUpperCase()} · filed ${formatTime(report.createdAt)}${report.ownerNotifiedAt ? ` · Mikey notified ${formatTime(report.ownerNotifiedAt)}` : ""}`,
+    `${isCoverReport(report) ? "Cover photo report" : "Chat report"} #${report.id}: ${String(report.status || "open").toUpperCase()} · filed ${formatTime(report.createdAt)}${report.ownerNotifiedAt ? ` · Mikey notified ${formatTime(report.ownerNotifiedAt)}` : ""}`,
   );
   lines.push(`Reporter → reported: ${who(report.reporter)} → ${who(report.reported)}`);
   lines.push(
@@ -81,7 +92,7 @@ export function formatChatReport(report = {}) {
   const place = where(report);
   if (place) lines.push(`Where: ${place}`);
   if (Number(report.reportsOfThisMessage) > 1) {
-    lines.push(`This message has ${report.reportsOfThisMessage} reports.`);
+    lines.push(`This ${subjectNoun(report)} has ${report.reportsOfThisMessage} reports.`);
   }
   if (Array.isArray(report.safetyHoldIds) && report.safetyHoldIds.length) {
     lines.push(`Safety hold(s): #${report.safetyHoldIds.join(", #")}`);
@@ -96,8 +107,14 @@ export function formatChatReport(report = {}) {
 
   const message = report.message;
   lines.push("");
-  lines.push(`Reported message${report.messageId ? ` #${report.messageId}` : ""}:`);
+  lines.push(
+    isCoverReport(report)
+      ? "Reported cover photo:"
+      : `Reported message${report.messageId ? ` #${report.messageId}` : ""}:`,
+  );
   lines.push(message ? formatMessageLine(message, ">") : "  (no snapshot kept)");
+  // a cover has no surrounding conversation
+  if (isCoverReport(report)) return lines;
 
   const before = Array.isArray(report.context?.before) ? report.context.before : [];
   const after = Array.isArray(report.context?.after) ? report.context.after : [];

package/lib/build-review.js

@@ -938,19 +938,12 @@ async function runChromeReview({
       child.exitCode !== null || child.signalCode !== null;
     const closeRequestedAt = Date.now();
     stderrAfterClose = "";
-    await cdp.send("Browser.close").catch(() => {});
-    let forcedTermination = false;
-    const closeResult = await Promise.race([
-      closed,
-      delay(5_000).then(() => {
-        forcedTermination = true;
-        return stopChrome(child, closed);
-      }),
-    ]);
+    // Observation is complete; shutdown has its own bounded deadline.
+    clearTimeout(timer);
+    const closeResult = await closeReviewBrowser({ child, closed, cdp });
     return {
       ...closeResult,
       closeRequested: true,
-      forcedTermination,
       evidenceCompleteBeforeClose,
       exitedBeforeClose,
       closeDurationMs: Date.now() - closeRequestedAt,
@@ -972,12 +965,40 @@ async function runChromeReview({
   }
 }
 
+export async function closeReviewBrowser({ child, closed, cdp, graceMs = 12_000 }) {
+  // The macOS network-service watchdog can take ~10 s to print its shutdown
+  // diagnosis and exit 2. The former 5+3 s kill erased that evidence and made
+  // a completed app review look like an unexplained browser crash.
+  let closeAcknowledged = false, closeCommandError = null, forcedTermination = false;
+  const command = cdp.send("Browser.close").then(
+    () => { closeAcknowledged = true; },
+    error => { closeCommandError = String(error?.message || error).slice(0, 240); },
+  );
+  let result = await waitForChromeExit(closed, graceMs);
+  if (!result) {
+    forcedTermination = true;
+    result = await stopChrome(child, closed);
+  }
+  await command; // The CDP command has its existing timeout/channel-close bound.
+  return { ...result, forcedTermination, closeAcknowledged, closeCommandError };
+}
+
+async function waitForChromeExit(closed, milliseconds) {
+  let timer;
+  try {
+    return await Promise.race([
+      closed,
+      new Promise(resolve => { timer = setTimeout(() => resolve(null), milliseconds); }),
+    ]);
+  } finally { clearTimeout(timer); }
+}
+
 // SIGTERM, then SIGKILL if Chrome is still there after 3 s: a browser wedged
 // in teardown (the case this review must tolerate) can ignore SIGTERM, and
 // the review must never hang or leave Chrome running.
 async function stopChrome(child, closed) {
   child.kill("SIGTERM");
-  const ended = await Promise.race([closed, delay(3_000).then(() => null)]);
+  const ended = await waitForChromeExit(closed, 3_000);
   if (ended) return ended;
   child.kill("SIGKILL");
   return closed;
@@ -1151,6 +1172,8 @@ export async function runManagedBuildReview({ options, authToken, buildId }) {
       exitCode: browser.code,
       signal: browser.signal,
       closeRequested: browser.closeRequested === true,
+      closeAcknowledged: browser.closeAcknowledged === true,
+      closeCommandError: browser.closeCommandError || null,
       forcedTermination: browser.forcedTermination === true,
       exitedCleanly: browser.code === 0 && !browser.signal,
       stdioDrainTimedOut: browser.stdioDrainTimedOut === true,

package/package.json

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

package/sdk/BUILD_SDK_INDEX.md

@@ -2,7 +2,7 @@
 
 Version: 1.71.0
 Updated: 2026-10-24
-Generated: 2026-10-24T05:37:23.377Z
+Generated: 2026-10-24T10:03:41.930Z
 
 ## 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.
@@ -1500,17 +1500,19 @@ world.updatePresence({ x, y, z, facing });
 
 ### Twinkle.reflections
 - async getDailyReflections({ userIds, cursor, lastId, limit } = {}) | scopes: dailyReflections:read
-  - Returns: { reflections: [{ id, userId, response, questionId, submittedAt, sharedAt, username, profilePicUrl, question }], cursor? }
+  - Returns: { reflections: [{ id, userId, response, questionId, submittedAt, sharedAt, username, profilePicUrl, question, dayType, pictureUrl, pictureStyle }], cursor? }
   - Read only 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.
 - async getDailyReflectionsByUser(userId, { cursor, lastId, limit } = {}) | scopes: dailyReflections:read
-  - Returns: { reflections: [{ id, userId, response, questionId, submittedAt, sharedAt, username, profilePicUrl, question }], cursor? }
+  - 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.
 
 ### Twinkle.privateDb
 - async get(key) | scopes: privateDb:read
@@ -1588,7 +1590,7 @@ world.updatePresence({ x, y, z, facing });
 
 ### Twinkle.rewards
 - await Twinkle.rewards.getStatus() | scopes: rewards:claim
-  - Returns: { mode: "live", dayKey, userDailyClaims, claimsToday, missedRematch?: { afterDays, perDay, usedToday, ready: [{ ruleId, setKey, variantOf, missed }], upcoming, nextReadyDay }, budgets: { userDailyXP, userDailyCoins }, rules: [{ id, title, howTo?, category?, series?, xp, coins, verifier: "numeric-quiz" | "completion", minSeconds?, progression?, retryReward: { xp, coins }, maxAttempts, available, setKey, questionCount }], challenges: [{ challengeId, ruleId, attempts, attemptsRemaining, state: "open" | "finished" | "earned", setKey, questions: [{ prompt, hint?, guide? }] }], history: [{ ruleId, xp, coins, attempt, createdAt }], balances: { xp, coins } } | { mode: "preview", dayKey?, rules, challenges: [], history: [], balances?, problems?: string[], message }
+  - Returns: { mode: "live", dayKey, userDailyClaims, claimsToday, craftDiscovery?: { pendingByRule: { [ruleId]: number } }, missedRematch?: { afterDays, perDay, usedToday, ready: [{ ruleId, setKey, variantOf, missed }], upcoming, nextReadyDay }, budgets: { userDailyXP, userDailyCoins }, rules: [{ id, title, howTo?, category?, series?, xp, coins, verifier: "numeric-quiz" | "completion", minSeconds?, progression?, retryReward: { xp, coins }, maxAttempts, available, setKey, questionCount }], challenges: [{ challengeId, ruleId, attempts, attemptsRemaining, state: "open" | "finished" | "earned", setKey, questions: [{ prompt, hint?, guide? }] }], history: [{ ruleId, xp, coins, attempt, createdAt }], balances: { xp, coins } } | { mode: "preview", dayKey?, rules, challenges: [], history: [], balances?, problems?: string[], message }
   - Read canonical earning rules (without answer keys), today’s started challenges, today’s receipts and balances. Drafts return preview mode: for the app's owner the rules come from the draft's own rewards.json and question sheet (problems lists what is still wrong with them); anyone else sees no rules. Unapproved or revoked published releases return an error.
   - rules[].available is false on a site day (UTC) the reviewer scheduled no questions for; show the rule as not available instead of starting it. xp/coins are the first-try amounts; retryReward is what a correct answer pays after a wrong one (equal to xp/coins unless the reviewer set a retry share). maxAttempts null means unlimited wrong answers until the site's daily reset (UTC midnight, 9:00 AM in Korea). retry.paidAttempts, when set, is the last attempt number a correct answer is still paid on: a later correct answer is recorded as solved (receipt xp 0, coins 0) and pays nothing — tell the learner before they pass it.
   - challenges lists challenges this viewer already started today with their questions, so an app can resume after a reload without calling start. A question's guide (reviewer-approved JSON teaching content: explanation, interactive-model configuration) is present only once the viewer has answered at least once, right or wrong; render it as the after-attempt lesson. claimsToday against userDailyClaims (null = uncapped) tells whether another bounty can still pay today.
@@ -1599,6 +1601,7 @@ world.updatePresence({ x, y, z, facing });
   - nonogram-picture-v1 uses Twinkle’s private, editorially reviewed picture bank. Set pictureSize to 5, 10 or 15 on each completion rule. Do not bundle daily solutions or a fixed answer catalog in app files. The collection is maintained through lumine admin nonogram; the reward amounts and daily limits still come from the approved rules.
   - Collection progression keeps every approved keyed set available independently of other players' solves. collectionSets lists { setKey, number }; challenges carry collection, practice, completed and completion. Live status includes viewerId for a per-viewer durable outbox. Attempts and completion persist across days/releases; the daily reward allowance does not reset a puzzle's paid tries. Existing receipts (including rematches), Vault solves/practice and studied guides count. Completed puzzles can be revisited; do not treat any receipt for the grade as completing all its puzzles. Collection rules support up to 500 permanent sets per rule; legacy queued/dated rules keep their 62-set limit.
   - missedRematch appears when rewards.json declares missedRematch ({ afterDays, perDay }; it requires userDailyClaims) and the app has collection rules. A collection set may declare variantOf: another set's key, meaning the same puzzle with new numbers (an ordinary puzzle for everyone). A learner who missed any puzzle of a family (an original plus its variants) and has not solved one of its puzzles on the first try gets the family's first unmet puzzle as a rematch afterDays site days after their last answer in the family. ready lists today's rematches (variantOf is the family's original, missed the puzzle this learner got wrong most recently; once perDay are used it only keeps one already opened today): open setKey with start({ ruleId, setKey }) at any time (before or after today's bounties) and the challenge comes back with rematch: { variantOf, answered }: one answer, the rule's full first-try amounts, a receipt (rematch: true) that does not count toward userDailyClaims but does count toward the XP/Coin budgets. usedToday against perDay says how many rematches were opened today; opening one uses it. upcoming and nextReadyDay describe rematches not ready yet.
+  - For craft-discovery-v1 rules, live status includes craftDiscovery.pendingByRule: counts of this viewer’s unpaid discoveries eligible for each configured rule. Use these advisory counts to skip empty tier probes; they are not rewards or a promise that a later claim will succeed. claim still checks and consumes canonical proof transactionally. Refresh status after claims. Older servers and preview mode may omit this field.
 - await Twinkle.rewards.getReceipt({ challengeId }) | scopes: rewards:claim
   - Returns: { mode: "live", status: "awarded" | "completed" | "pending" | "expired" | "not_found", receipt: { id, challengeId, ruleId, reviewId, artifactVersionId, dayKey, xp, coins, attempt, createdAt } | null, balances: { xp, coins } } | { mode: "preview", status: "not_found", receipt: null, message }
   - Read an existing receipt for this app and signed-in viewer by server-issued challengeId, including previous UTC days and previous approved versions. Requires the current approved published release and runtime grant; a stale frame must reload first. Never awards, retries a claim, returns answer keys, or restores removed rewards permission.

package/sdk/LUMINE_ADMIN.md

@@ -2826,8 +2826,9 @@ never previously been Featured from canonical evidence.
 
 Keep current manual pins from the past two days (Mikey, October 13, 2026).
 Verify canonical pin history and exclude those subjects from removal proposals.
-Subject 3529, “What is special about Twinkle?”, also has an explicit keep
-instruction. An absent pin is still never restored. This supersedes the older
+Subject3529, “What is special about Twinkle?”, had an October13 keep instruction,
+but Mikey removed it on October19 at06:28:27UTC (canonical event2504).
+Do not restore it from that superseded keep note. An absent pin is still never restored. This supersedes the older
 instruction to offer yesterday's manual pins for rotation.
 
 For the daily old-to-new proposal, prepare a canonical plan without changing pins: