@stage5/lumine 0.2.52 → 0.2.54

package/README.md

@@ -139,6 +139,10 @@ methods. The JSON args are sent as the request body (shapes follow
 ```bash
 lumine sdk call aiStories.chapters '{"limit": 5}'
 lumine sdk call aiStories.list '{"difficulty": 1}' --repeat 5 --build 1374
+lumine sdk call live.list '{}'
+lumine sdk call live.get '{"sessionId": "..."}'
+lumine sdk call live.listReplays '{"limit": 20}'
+lumine sdk call live.getReplay '{"replayId": "..."}'
 ```
 
 It targets the build in the current workspace, or pass `--build <id>`. Add
@@ -146,6 +150,13 @@ It targets the build in the current workspace, or pass `--build <id>`. Add
 which can differ from a method's `Twinkle.*` SDK return shape — check
 `TWINKLE_BUILD_SDK.md` for SDK return shapes. Methods that change data require
 `--allow-write`.
+Stopping a hosted stream is available as
+`lumine sdk call live.stop '{"sessionId":"..."}' --allow-write`; the command
+prints canonical server state and refuses to mint `live:write` without the
+explicit write flag.
+Replay listing and status are available without exposing private playback
+grants. A creator or app owner can remove one with
+`lumine sdk call live.deleteReplay '{"replayId":"..."}' --allow-write`.
 
 ## Assets and AI image generation
 
@@ -218,6 +229,46 @@ claude "Read CLAUDE.md, then make the requested change."
 The login command uses a browser approval code and stores a scoped token and the
 selected project at `~/.twinkle/lumine-cli-auth.json`.
 
+## Sponsoring Zero or Ciel Build Workshop duty
+
+Sponsorship is an approved contribution role, not an open switch and not a
+website-management role. Applications are submitted only through Lumine CLI;
+the Twinkle website provides instructions, but no application form.
+
+```bash
+lumine sponsor agreement
+lumine sponsor apply --providers codex --motivation "Why I want to help" \
+  --availability "My usual duty window" --accept-agreement
+lumine sponsor status
+```
+
+After Mikey approves an application, configure conservative limits based on
+the subscription you are contributing, then start one foreground duty:
+
+```bash
+lumine sponsor capacity --concurrency 1 --helpers 0 \
+  --daily-limit 3 --weekly-limit 10
+lumine sponsor duty start zero --provider codex \
+  --model gpt-5.6-sol --effort max --service-tier priority
+```
+
+While that foreground process has a fresh server lease, Zero or Ciel exposes a
+Build Workshop in chat and users may see the named sponsor and canonical queue.
+With no live duty, the website stays in its ordinary chat state and shows none
+of the Workshop UI. Press Ctrl-C to stop accepting work and drain already
+claimed jobs before duty ends; `pause`, `resume`, and `stop` are also available.
+
+Zero or Ciel remains the user-facing teammate. The local coding agent receives
+only the initial relay and active-job Build follow-ups covered by the user’s
+explicit Workshop consent, the assigned contribution branch, and its scoped
+Build Forum—not the raw assistant chat. It
+cannot merge into Main, publish, or use website-management APIs. Lumine records
+the requested and provider-reported model, effort, service tier, runtime/usage
+evidence, coordinator/helper tree, saved artifact, and branch notice. Every
+completed handoff enters the daily integrity flow; probationary, hard-flagged,
+and sampled work requires review. Each unique cleared handoff earns a flat 50
+Karma Points, while retries and helper agents do not multiply the award.
+
 ## Privileged website administration
 
 `lumine admin` reuses Mikey's saved CLI login while keeping the visible public
@@ -237,6 +288,13 @@ lumine admin economy trace lock --days 3 \
 lumine admin rescue wordle-audit --days 30 \
   --reason "Identify recorded Wordle breaks and rescue status" --json
 lumine admin daily-run start --identity auto --comment-mode off --json
+lumine admin sponsor applications list --status pending --json
+lumine admin sponsor applications review 12 --decision approve \
+  --note "Approved for probationary duty" --json
+lumine admin sponsor integrity scan --json
+lumine admin sponsor integrity cases --status open --json
+lumine admin sponsor integrity get 34 --json
+lumine admin sponsor integrity review 34 --decision clear --json
 lumine admin todo list --json
 lumine admin todo add --kind experiment --status in_progress \
   --title "Validate Zero/Ciel cost optimization" \
@@ -344,7 +402,11 @@ with `todo update`; completing a run does not complete its todos. Experiments
 must meet their stated acceptance criteria—lower AI cost with weaker user
 responses is not a successful optimization. `daily-run report` summarizes
 confirmed mutations, completed queue coverage, explicitly recorded escalations,
-unfinished todos, and the run brief before the run is completed.
+unfinished todos, sponsor-integrity state, and the run brief before the run is
+completed. A run cannot complete until its bounded sponsor-integrity snapshot
+has been scanned and every selected case is cleared or disqualified. `hold` and
+`flag` deliberately keep the run open for human judgment; scans never suspend,
+revoke, or disqualify a sponsor automatically.
 
 Identity inspection, escalation dispositions, AI-bucket maintenance, and
 approved Notable User additions and todos are private operator bookkeeping and

package/lib/admin.js

@@ -96,9 +96,7 @@ function readBuildReviewContextFile(filePath) {
     );
   }
   const understanding =
-    typeof parsed.understanding === "string"
-      ? parsed.understanding.trim()
-      : "";
+    typeof parsed.understanding === "string" ? parsed.understanding.trim() : "";
   if (!understanding) {
     throw cliValidationError(
       "The Build review context understanding must be a non-empty string.",
@@ -816,6 +814,108 @@ export function parseAdminOperation(options) {
     );
   }
 
+  if (namespace === "sponsor" || namespace === "sponsors") {
+    if (action === "applications") {
+      if (!target || target === "list") {
+        return readOperation(
+          "sponsor.applications.list",
+          withQuery("/cli/admin/sponsors/applications", {
+            status: options.adminStatus || "pending",
+            limit: options.limit,
+          }),
+        );
+      }
+      if (target === "review") {
+        const applicationId = parseRequiredInteger(
+          extra,
+          "Sponsor application ID",
+          1,
+        );
+        const decision = parseChoice(
+          options.adminDecision || options.adminStatus,
+          "--decision",
+          ["approve", "reject"],
+        );
+        return writeOperation(
+          "sponsor.application.review",
+          "POST",
+          `/cli/admin/sponsors/applications/${applicationId}/review`,
+          { decision, note: options.note || undefined },
+        );
+      }
+    }
+    if (action === "status" && target === "set") {
+      const sponsorUserId = parseRequiredInteger(extra, "Sponsor user ID", 1);
+      const status = parseChoice(options.adminStatus, "--status", [
+        "probationary",
+        "trusted",
+        "suspended",
+        "revoked",
+      ]);
+      return writeOperation(
+        "sponsor.status.set",
+        "PUT",
+        `/cli/admin/sponsors/${sponsorUserId}/status`,
+        { status, note: options.note || undefined },
+      );
+    }
+    if (action === "integrity") {
+      if (target === "status") {
+        return readOperation(
+          "sponsor.integrity.status",
+          "/cli/admin/daily-runs/sponsor-integrity/status",
+        );
+      }
+      if (target === "scan") {
+        return writeOperation(
+          "sponsor.integrity.scan",
+          "POST",
+          "/cli/admin/daily-runs/sponsor-integrity/scan",
+          {},
+        );
+      }
+      if (target === "cases") {
+        return readOperation(
+          "sponsor.integrity.cases",
+          withQuery("/cli/admin/daily-runs/sponsor-integrity/cases", {
+            status: options.adminStatus || "open",
+            limit: options.limit,
+          }),
+        );
+      }
+      if (target === "get") {
+        const caseId = parseRequiredInteger(extra, "Integrity case ID", 1);
+        return readOperation(
+          "sponsor.integrity.get",
+          `/cli/admin/daily-runs/sponsor-integrity/cases/${caseId}`,
+        );
+      }
+      if (target === "review") {
+        const caseId = parseRequiredInteger(extra, "Integrity case ID", 1);
+        const decision = parseChoice(options.adminDecision, "--decision", [
+          "clear",
+          "hold",
+          "flag",
+          "disqualify",
+        ]);
+        if (decision !== "clear" && !String(options.note || "").trim()) {
+          throw cliValidationError(
+            "Sponsor-integrity hold, flag, and disqualify decisions require --note <evidence>.",
+          );
+        }
+        return writeOperation(
+          "sponsor.integrity.review",
+          "POST",
+          `/cli/admin/daily-runs/sponsor-integrity/cases/${caseId}/review`,
+          { decision, note: options.note || undefined },
+        );
+      }
+    }
+    throw cliValidationError(
+      "Usage: lumine admin sponsor applications list|review | sponsor status set | sponsor integrity status|scan|cases|get|review.",
+    );
+  }
+
   if (namespace === "daily-run") {
     if (action === "start") {
       return writeOperation(
@@ -1235,6 +1335,35 @@ export function parseAdminOperation(options) {
     );
   }
 
+  if (namespace === "ai-costs") {
+    if (action === "monthly" && !target && !extra) {
+      if (options.adminDays) {
+        throw cliValidationError(
+          "ai-costs monthly uses UTC calendar months and does not accept --days.",
+        );
+      }
+      return readOperation("ai-costs.monthly", "/cli/admin/ai-costs/monthly");
+    }
+    throw cliValidationError("Usage: lumine admin ai-costs monthly [--json].");
+  }
+
+  if (namespace === "media-costs") {
+    if (action === "monthly" && !target && !extra) {
+      if (options.adminDays) {
+        throw cliValidationError(
+          "media-costs monthly uses the canonical UTC ledger and does not accept --days.",
+        );
+      }
+      return readOperation(
+        "media-costs.monthly",
+        "/cli/admin/media-costs/monthly",
+      );
+    }
+    throw cliValidationError(
+      "Usage: lumine admin media-costs monthly [--json].",
+    );
+  }
+
   if (namespace === "brief" && !action) {
     if (options.adminDays) {
       const days = Number(options.adminDays);
@@ -1419,9 +1548,7 @@ export function parseAdminOperation(options) {
           ...(confirmedBuildReviewMethod
             ? { buildReviewMethod: confirmedBuildReviewMethod }
             : {}),
-          ...(buildReviewUnderstanding
-            ? { buildReviewUnderstanding }
-            : {}),
+          ...(buildReviewUnderstanding ? { buildReviewUnderstanding } : {}),
         },
       );
     }
@@ -1465,7 +1592,7 @@ export function parseAdminOperation(options) {
   }
 
   throw cliValidationError(
-    "Usage: lumine admin identity|economy|rescue|daily-run|escalation|todo|recommendations|builds|post|subjects|subject|featured|comment|announcement|chat|news|audit|brief|bot-output|notable ...",
+    "Usage: lumine admin identity|economy|rescue|sponsor|daily-run|escalation|todo|recommendations|builds|post|subjects|subject|featured|comment|announcement|chat|news|audit|brief|ai-costs|media-costs|bot-output|notable ...",
   );
 }
 
@@ -2024,6 +2151,16 @@ function parseRequiredInteger(
   return number;
 }
 
+function parseChoice(value, label, choices) {
+  const normalized = String(value || "")
+    .trim()
+    .toLowerCase();
+  if (!choices.includes(normalized)) {
+    throw cliValidationError(`${label} must be ${choices.join(", ")}.`);
+  }
+  return normalized;
+}
+
 function defaultDailyRunKey() {
   const parts = new Intl.DateTimeFormat("en-CA", {
     timeZone: "Asia/Bangkok",
@@ -2047,8 +2184,272 @@ function adminValueFingerprint(value) {
   return createHash("sha256").update(JSON.stringify(value)).digest("hex");
 }
 
+function formatAdminUsd(value) {
+  const amount = Number(value);
+  if (!Number.isFinite(amount)) return "unavailable";
+  return `$${amount.toLocaleString("en-US", {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+  })}`;
+}
+
+function formatAdminMonthlyCostComparison(projection, previousMonthKey) {
+  const rawPercent = projection?.comparisonToPreviousMonth?.percentChange;
+  const percent = rawPercent === null ? NaN : Number(rawPercent);
+  if (!Number.isFinite(percent)) {
+    return `comparison with ${previousMonthKey} unavailable`;
+  }
+  if (percent === 0) return `even with ${previousMonthKey}`;
+  return `${Math.abs(percent).toFixed(2)}% ${percent < 0 ? "below" : "above"} ${previousMonthKey}`;
+}
+
+function printAdminMonthlyAiCosts(monthlyAiCosts) {
+  const previous = monthlyAiCosts.previousMonth;
+  const current = monthlyAiCosts.currentMonth;
+  const generatedAt = new Date(
+    Number(monthlyAiCosts.generatedAt) * 1000,
+  ).toISOString();
+  console.log(`Application AI-cost ledger (UTC; generated ${generatedAt}).`);
+  console.log(
+    `${previous.monthKey} closed month: ${formatAdminUsd(previous.estimatedCostUsd)} estimated cost.`,
+  );
+  if (current.completed.dayCount > 0) {
+    console.log(
+      `${current.monthKey} completed-day MTD through ${current.completed.throughDayKey}: ${formatAdminUsd(current.completed.estimatedCostUsd)} across ${current.completed.dayCount} completed UTC day(s).`,
+    );
+  } else {
+    console.log(
+      `${current.monthKey} completed-day MTD: ${formatAdminUsd(current.completed.estimatedCostUsd)}; no UTC day has completed yet.`,
+    );
+  }
+  console.log(
+    `${current.inProgressDay.dayKey} in progress: ${formatAdminUsd(current.inProgressDay.estimatedCostUsd)} so far (excluded from completed-day MTD and both projections).`,
+  );
+
+  const allPace = current.projections.allCompletedDaysPace;
+  if (allPace) {
+    console.log(
+      `All-completed-days pace full-month projection: ${formatAdminUsd(allPace.estimatedMonthTotalUsd)} (${formatAdminUsd(allPace.dailyAverageUsd)}/day across ${allPace.basisDayCount} completed day(s); ${formatAdminMonthlyCostComparison(allPace, previous.monthKey)}).`,
+    );
+  } else {
+    console.log(
+      "All-completed-days pace full-month projection: unavailable until one UTC day has completed.",
+    );
+  }
+
+  const recentPace = current.projections.recentSevenCompletedDaysPace;
+  if (recentPace) {
+    console.log(
+      `Recent-seven-completed-day pace full-month projection: ${formatAdminUsd(recentPace.estimatedMonthTotalUsd)} (${formatAdminUsd(recentPace.dailyAverageUsd)}/day from ${recentPace.basisStartDayKey} through ${recentPace.basisEndDayKey}; ${formatAdminMonthlyCostComparison(recentPace, previous.monthKey)}).`,
+    );
+  } else {
+    console.log(
+      "Recent-seven-completed-day pace full-month projection: unavailable until seven UTC days have completed.",
+    );
+  }
+}
+
+function formatAdminMediaUsd(value) {
+  const amount = Number(value);
+  if (!Number.isFinite(amount)) return "unavailable";
+  return `$${amount.toLocaleString("en-US", {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 6,
+  })}`;
+}
+
+function formatAdminMediaBytes(value) {
+  const bytes = Number(value);
+  if (!Number.isFinite(bytes) || bytes < 0) return "unavailable";
+  if (bytes < 1024) return `${Math.floor(bytes)} B`;
+  const units = ["KB", "MB", "GB", "TB"];
+  let amount = bytes / 1024;
+  let unit = units[0];
+  for (let index = 1; index < units.length && amount >= 1024; index += 1) {
+    amount /= 1024;
+    unit = units[index];
+  }
+  return `${amount.toFixed(amount >= 100 ? 0 : amount >= 10 ? 1 : 2)} ${unit}`;
+}
+
+function printAdminMonthlyMediaCosts(monthlyMediaCosts) {
+  const generatedAt = new Date(
+    Number(monthlyMediaCosts.generatedAt) * 1000,
+  ).toISOString();
+  const current = monthlyMediaCosts.currentMonth;
+  const today = monthlyMediaCosts.currentUtcDay;
+  const operations = monthlyMediaCosts.operations;
+  const streamAttempts = today.streamAttempts || {
+    attemptedCount: 0,
+    reachedLiveCount: 0,
+    endedCount: 0,
+    failedCount: 0,
+    cancelledCount: 0,
+    inProgressCount: 0,
+    failureCodeCounts: [],
+  };
+  console.log(
+    `Lumine media-cost monitor (UTC; ${monthlyMediaCosts.status}; generated ${generatedAt}).`,
+  );
+  console.log(
+    `${current.monthKey}: ${formatAdminMediaUsd(current.estimatedSpentUsd)} settled estimate + ${formatAdminMediaUsd(current.activeReservedUsd)} active reservations + ${formatAdminMediaUsd(current.carryoverUsd)} carryover = ${formatAdminMediaUsd(current.guardedTotalUsd)} guarded of ${formatAdminMediaUsd(current.limitUsd)} (${Number(current.percentUsed).toFixed(2)}% used; ${formatAdminMediaUsd(current.remainingUsd)} remaining).`,
+  );
+  console.log(
+    `${today.dayKey} so far: ${today.reservationsCreated} action(s) reserved, ${today.commitmentsSettled} committed, ${today.cancellationsSettled} cancelled, ${formatAdminMediaUsd(today.estimatedCostSettledUsd)} settled estimate.`,
+  );
+  console.log(
+    `Stream attempts created ${today.dayKey} UTC: ${streamAttempts.attemptedCount} attempted / ${streamAttempts.reachedLiveCount} reached live / ${streamAttempts.endedCount} ended after live / ${streamAttempts.failedCount} failed / ${streamAttempts.cancelledCount} cancelled before live / ${streamAttempts.inProgressCount} still in progress.`,
+  );
+  const streamFailureCodeCounts = Array.isArray(
+    streamAttempts.failureCodeCounts,
+  )
+    ? streamAttempts.failureCodeCounts
+    : [];
+  console.log(
+    streamFailureCodeCounts.length > 0
+      ? `Stream failure codes: ${streamFailureCodeCounts
+          .map((entry) => `${entry.code}=${entry.count}`)
+          .join(", ")}.`
+      : "Stream failure codes: none.",
+  );
+  const stillActiveOrCleanupPendingCount =
+    operations.live.stillActiveOrCleanupPendingCount ??
+    Number(operations.live.provisioningCount || 0) +
+      Number(operations.live.readyCount || 0) +
+      Number(operations.live.liveCount || 0) +
+      Number(operations.live.endingCount || 0) +
+      Number(operations.live.cleanupFailedCount || 0);
+  const replayOperations = operations.replays || {
+    pendingCount: 0,
+    processingCount: 0,
+    readyCount: 0,
+    failedCount: 0,
+    deletePendingCount: 0,
+    deleteFailedCount: 0,
+    expiredReadyCount: 0,
+    finalizationOverdueCount: 0,
+    deletionOverdueCount: 0,
+    storedBytes: 0,
+    storedObjectCount: 0,
+  };
+  const replayViewers = operations.replayViewers || {
+    activeGrantCount: 0,
+    expiredActiveGrantCount: 0,
+  };
+  const kindRows = [
+    ["Short clips", current.byKind.clip],
+    ["Live inputs", current.byKind.liveInput],
+    ["Live viewers", current.byKind.liveViewer],
+  ];
+  if (current.byKind.replayViewer) {
+    kindRows.push(["Replay viewers", current.byKind.replayViewer]);
+  }
+  for (const [label, cost] of kindRows) {
+    console.log(
+      `${label}: ${cost.actionCount} action(s), ${cost.committedCount} committed for ${formatAdminMediaUsd(cost.estimatedSpentUsd)}, ${cost.activeReservedCount} active reservation(s) holding ${formatAdminMediaUsd(cost.activeReservedUsd)}, ${cost.cancelledCount} cancelled.`,
+    );
+  }
+  console.log(
+    `Ledger reconciliation: ${current.reconciliation.consistent ? "consistent" : "MISMATCH"}; spent delta ${formatAdminMediaUsd(current.reconciliation.spentDeltaUsd)}, reserved delta ${formatAdminMediaUsd(current.reconciliation.reservedDeltaUsd)}.`,
+  );
+  console.log(
+    `Operations: clips ${operations.clips.completingCount} completing / ${operations.clips.processingCount} processing / ${operations.clips.staleCount} stale; live ${operations.live.liveCount} broadcasting / ${stillActiveOrCleanupPendingCount} active-or-cleanup-pending / ${operations.live.costBearingChannelCount} cost-bearing channel(s) / ${operations.live.possibleOrphanedCount ?? operations.live.cleanupOverdueCount} possible orphan(s); viewers ${operations.viewers.activeGrantCount} active / ${operations.viewers.expiredActiveGrantCount} expired-active.`,
+  );
+  console.log(
+    `Replays: ${replayOperations.pendingCount} pending / ${replayOperations.processingCount} processing / ${replayOperations.readyCount} ready / ${replayOperations.failedCount} failed / ${replayOperations.deletePendingCount} deleting / ${replayOperations.deleteFailedCount} delete-failed; ${replayOperations.finalizationOverdueCount} finalization-overdue / ${replayOperations.deletionOverdueCount} deletion-overdue / ${replayOperations.expiredReadyCount} expired-ready; ${formatAdminMediaBytes(replayOperations.storedBytes)} across ${replayOperations.storedObjectCount} canonical object(s); viewers ${replayViewers.activeGrantCount} active / ${replayViewers.expiredActiveGrantCount} expired-active.`,
+  );
+  console.log(
+    `Shared runtime storage context: ${operations.runtimeStorage.readyImages.assetCount} ready image(s), ${formatAdminMediaBytes(operations.runtimeStorage.readyImages.totalBytes)}; ${operations.runtimeStorage.readyClips.assetCount} ready clip(s), ${formatAdminMediaBytes(operations.runtimeStorage.readyClips.totalBytes)}. Images include all Build runtime image uploads, not only camera captures.`,
+  );
+  if (monthlyMediaCosts.alerts.length === 0) {
+    console.log("Media-cost alerts: none.");
+  } else {
+    for (const alert of monthlyMediaCosts.alerts) {
+      console.log(
+        `Media-cost alert [${String(alert.severity).toUpperCase()}] ${alert.code}: ${alert.message}`,
+      );
+    }
+  }
+  console.log(
+    "These are conservative provider-cost ledger estimates, not an AWS invoice; reconcile IVS, MediaConvert, replay S3, and shared runtime S3 Cost Explorer data separately after billing lag.",
+  );
+}
+
 function printAdminResult({ operation, result }) {
   const data = result?.data || {};
+  if (Array.isArray(data.applications)) {
+    console.log(`${data.applications.length} sponsor application(s):`);
+    for (const application of data.applications) {
+      console.log(
+        `  #${application.id} ${String(application.status).toUpperCase()} · ${application.username || `user ${application.userId}`} · agreement ${application.agreementVersion || "unknown"}`,
+      );
+    }
+    return;
+  }
+  if (data.application) {
+    console.log(
+      `Sponsor application #${data.application.id}: ${String(data.application.status).toUpperCase()} · ${data.application.username || `user ${data.application.userId}`}`,
+    );
+    return;
+  }
+  if (data.sponsor) {
+    console.log(
+      `Sponsor ${data.sponsor.username || `user ${data.sponsor.userId}`}: ${String(data.sponsor.status).toUpperCase()}.`,
+    );
+    return;
+  }
+  if (data.scan) {
+    const scan = data.scan;
+    console.log(
+      `Sponsor-integrity scan #${scan.id || "not started"}: ${scan.status || "not started"} · ${scan.scannedCount || 0} scanned · ${scan.selectedReviewCount || 0} selected · ${data.openCaseCount || 0} open.`,
+    );
+    if (Array.isArray(data.casesCreated) && data.casesCreated.length > 0) {
+      console.log(
+        `Created ${data.casesCreated.length} review case(s) on this page.`,
+      );
+    }
+    return;
+  }
+  if (Array.isArray(data.cases)) {
+    console.log(`${data.cases.length} sponsor-integrity case(s):`);
+    for (const item of data.cases) {
+      const flags =
+        Array.isArray(item.hardFlags) && item.hardFlags.length
+          ? ` · flags=${item.hardFlags.join(",")}`
+          : "";
+      console.log(
+        `  #${item.id} ${String(item.status).toUpperCase()} · job #${item.jobId} · ${item.sponsorUsername || `sponsor ${item.sponsorUserId}`}${flags}`,
+      );
+    }
+    return;
+  }
+  if (data.case) {
+    const item = data.case;
+    console.log(
+      `Sponsor-integrity case #${item.id}: ${String(item.status).toUpperCase()} · job #${item.job?.id} · ${item.sponsorUsername || `sponsor ${item.sponsorUserId}`}.`,
+    );
+    const relays = Array.isArray(item.relays) && item.relays.length > 0
+      ? item.relays
+      : item.relay
+        ? [item.relay]
+        : [];
+    console.log(
+      `Relays: ${relays.map((relay) => `${relay.kind || "initial_request"}: ${relay.summary || "(missing)"}`).join(" | ") || "(missing)"}`,
+    );
+    console.log(
+      `Provenance: ${(item.agents || []).map((agent) => `${agent.role}:${agent.provider}:${agent.resolvedModel || "unresolved"}:${agent.resolvedEffort || "unresolved"}`).join(" · ") || "missing"}`,
+    );
+    console.log(
+      `Artifact files: ${(item.artifactFiles || []).map((file) => file.path).join(", ") || "none"}`,
+    );
+    return;
+  }
+  if (data.caseId) {
+    console.log(
+      `Sponsor-integrity case #${data.caseId}: ${data.decision}${data.scanCompleted ? "; scan complete" : ""}.`,
+    );
+    return;
+  }
   if (data.review) {
     console.log(
       `Confirmed Build #${data.review.buildId} runtime at published artifact #${data.review.publishedArtifactVersionId}.`,
@@ -2057,6 +2458,14 @@ function printAdminResult({ operation, result }) {
     console.log(`Review receipt: ${data.receiptPath}`);
     return;
   }
+  if (data.monthlyAiCosts) {
+    printAdminMonthlyAiCosts(data.monthlyAiCosts);
+    return;
+  }
+  if (data.monthlyMediaCosts) {
+    printAdminMonthlyMediaCosts(data.monthlyMediaCosts);
+    return;
+  }
   if (data.validation) {
     console.log(
       `Editorial valid for edition #${data.validation.editionId}: ${data.validation.citedEventCount} cited and ${data.validation.coveredEventCount} covered event(s).`,
@@ -2089,6 +2498,11 @@ function printAdminResult({ operation, result }) {
       );
     }
     printTodoItems(report.carryoverTodos?.items || [], "Unfinished work");
+    if (report.sponsorIntegrity) {
+      console.log(
+        `Sponsor integrity: ${report.sponsorIntegrity.scan?.status || "not started"}; ${report.sponsorIntegrity.cases?.open || 0} open case(s); ${report.sponsorIntegrity.pendingApplications || 0} pending application(s).`,
+      );
+    }
     const surfaces = report.brief?.engagementPulse?.surfaces;
     if (surfaces && typeof surfaces === "object") {
       const deltas = Object.entries(surfaces)