@stage5/lumine 0.2.53 → 0.2.55

package/lib/admin.js

@@ -1,4 +1,5 @@
 import { createHash, randomUUID } from "node:crypto";
+import { once } from "node:events";
 import { readFileSync } from "node:fs";
 import { assertAuthScope, resolveAuth } from "./auth.js";
 import { requestJson } from "./http.js";
@@ -8,7 +9,13 @@ import {
   validateNewsEditorial,
   writeNewsClaimArtifacts,
 } from "./admin-news.js";
-import { runAutomaticPagination, runBatchSkips } from "./admin-workflows.js";
+import {
+  forEachPaginatedResultItem,
+  getPaginatedResultStorage,
+  runAutomaticPagination,
+  runBatchSkips,
+  writePaginatedResultJson,
+} from "./admin-workflows.js";
 import {
   parseBuildReviewReceipt,
   runManagedBuildReview,
@@ -380,9 +387,25 @@ export function assertRecommendationWindowResult({ operation, result }) {
   }
 }
 
-function finishAdminOutput({ options, operation, result }) {
+async function finishAdminOutput({ options, operation, result }) {
+  const paginationStorage = getPaginatedResultStorage(result);
   if (options.json) {
-    console.log(JSON.stringify(result));
+    if (paginationStorage) {
+      await writePaginatedResultJson({
+        result,
+        write: async (chunk) => {
+          if (!process.stdout.write(chunk)) {
+            await once(process.stdout, "drain");
+          }
+        },
+      });
+    } else {
+      console.log(JSON.stringify(result));
+    }
+    return result;
+  }
+  if (paginationStorage) {
+    await printSpooledAdminResult({ result, storage: paginationStorage });
     return result;
   }
   printAdminResult({ operation, result });
@@ -814,6 +837,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(
@@ -1490,7 +1615,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|ai-costs|media-costs|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 ...",
   );
 }
 
@@ -2049,6 +2174,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",
@@ -2263,8 +2398,132 @@ function printAdminMonthlyMediaCosts(monthlyMediaCosts) {
   );
 }
 
+async function printSpooledAdminResult({ result, storage }) {
+  const data = result?.data || {};
+  const count = Number(storage.candidateCount || 0);
+  if (storage.collectionKey === "subjects") {
+    console.log(`${count} subject(s):`);
+    await forEachPaginatedResultItem(result, async (subject) => {
+      console.log(
+        `#${subject.id} ${subject.title || "(untitled)"} — ${subject.author?.username || "unknown"} — effort ${subject.effortLevel ?? "unknown"}`,
+      );
+      console.log(`  ${subject.url}`);
+    });
+  } else if (storage.collectionKey === "events") {
+    console.log(`${count} audit event(s):`);
+    await forEachPaginatedResultItem(result, async (event) => {
+      const target =
+        event.targetType && event.targetId
+          ? ` ${event.targetType}:${event.targetId}`
+          : "";
+      console.log(
+        `#${event.id} run ${event.runId ?? "-"} ${event.action}${target} — ${event.result}${event.changed === true ? " (changed)" : event.changed === false ? " (no change)" : ""}`,
+      );
+    });
+  } else if (storage.collectionKey === "comments") {
+    console.log(`${count} comment(s) for ${data.subject?.url || "this target"}:`);
+    await forEachPaginatedResultItem(result, async (comment) => {
+      console.log(
+        `#${comment.id} ${comment.author?.username || "unknown"}: ${comment.content || "(empty)"}`,
+      );
+    });
+  } else if (storage.collectionKey === "items") {
+    console.log(`${count} recommendation candidate(s):`);
+    await forEachPaginatedResultItem(result, async (item) => {
+      console.log(`#${item.contentId} ${item.contentType}`);
+      if (item.url || item.subjectUrl) {
+        console.log(`  ${item.url || item.subjectUrl}`);
+      }
+    });
+  } else if (storage.collectionKey === "builds") {
+    console.log(`${count} Build candidate(s):`);
+    await forEachPaginatedResultItem(result, async (build) => {
+      console.log(`#${build.id} ${build.title || "(untitled)"}`);
+      if (build.url) console.log(`  ${build.url}`);
+    });
+  } else {
+    console.log(
+      `${count} ${storage.collectionKey} candidate(s) saved at ${storage.spoolPath}.`,
+    );
+  }
+  printPagination(data.pagination);
+}
+
 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}.`,
@@ -2313,6 +2572,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)

package/lib/agent/providers/claude-code.js

@@ -79,8 +79,12 @@ export async function runClaudeCodeAgentPass({
     args,
     cwd: isolationDir,
     streamJson: true,
+    signal: options.agentAbortSignal,
   });
-  return { finalText: result.finalText };
+  return {
+    finalText: result.finalText,
+    provenance: result.provenance,
+  };
 }
 
 export async function reviewClaudeCodeAgentLoop({
@@ -96,6 +100,7 @@ export async function reviewClaudeCodeAgentLoop({
     binary,
     cwd: isolationDir,
     streamJson: false,
+    signal: options.agentAbortSignal,
     args: [
       "-p",
       "--output-format",
@@ -129,16 +134,22 @@ export async function reviewClaudeCodeAgentLoop({
   }
 }
 
-async function runClaudeProcess({ binary, args, cwd, streamJson }) {
+async function runClaudeProcess({ binary, args, cwd, streamJson, signal }) {
   const child = spawn(binary, args, {
     cwd,
     stdio: ["ignore", "pipe", "pipe"],
     env: createSubscriptionAgentEnvironment(),
+    ...(signal ? { signal } : {}),
   });
   child.stderr.on("data", (chunk) => process.stderr.write(chunk));
   let finalText = "";
   let structuredOutput = null;
   let rawOutput = "";
+  let providerModel = null;
+  let providerEffort = null;
+  let providerUsage = {};
+  let providerServiceTier = null;
+  let providerRuntimeVersion = null;
 
   if (streamJson) {
     const lines = readline.createInterface({
@@ -155,13 +166,53 @@ async function runClaudeProcess({ binary, args, cwd, streamJson }) {
         return;
       }
       if (event?.type === "assistant") {
+        providerModel =
+          firstNonEmptyString(event.message?.model, providerModel) || null;
+        providerEffort =
+          firstNonEmptyString(
+            event.message?.effort,
+            event.message?.reasoning_effort,
+            providerEffort,
+          ) || null;
+        providerUsage = mergeUsageEvidence(providerUsage, event.message?.usage);
         const texts = (event.message?.content || [])
           .filter((block) => block?.type === "text")
           .map((block) => String(block.text || "").trim())
           .filter(Boolean);
         if (texts.length > 0) finalText = texts.join("\n\n");
       }
+      if (event?.type === "system") {
+        providerModel = firstNonEmptyString(event.model, providerModel) || null;
+        providerRuntimeVersion =
+          firstNonEmptyString(
+            event.claude_code_version,
+            event.claudeCodeVersion,
+            event.version,
+            providerRuntimeVersion,
+          ) || null;
+      }
       if (event?.type === "result") {
+        providerModel = firstNonEmptyString(event.model, providerModel) || null;
+        providerEffort =
+          firstNonEmptyString(
+            event.effort,
+            event.reasoning_effort,
+            providerEffort,
+          ) || null;
+        providerServiceTier =
+          firstNonEmptyString(
+            event.service_tier,
+            event.serviceTier,
+            providerServiceTier,
+          ) || null;
+        providerUsage = mergeUsageEvidence(providerUsage, event.usage);
+        providerRuntimeVersion =
+          firstNonEmptyString(
+            event.claude_code_version,
+            event.claudeCodeVersion,
+            event.version,
+            providerRuntimeVersion,
+          ) || null;
         if (typeof event.result === "string" && event.result.trim()) {
           finalText = event.result.trim();
         }
@@ -200,8 +251,58 @@ async function runClaudeProcess({ binary, args, cwd, streamJson }) {
     }
     finalText = String(parsed?.result || "").trim();
     structuredOutput = parsed?.structured_output || null;
+    providerModel = firstNonEmptyString(parsed?.model) || null;
+    providerEffort =
+      firstNonEmptyString(parsed?.effort, parsed?.reasoning_effort) || null;
+    providerServiceTier =
+      firstNonEmptyString(parsed?.service_tier, parsed?.serviceTier) || null;
+    providerRuntimeVersion =
+      firstNonEmptyString(
+        parsed?.claude_code_version,
+        parsed?.claudeCodeVersion,
+        parsed?.version,
+      ) || null;
+    providerUsage = mergeUsageEvidence(providerUsage, parsed?.usage);
   }
-  return { finalText, structuredOutput };
+  return {
+    finalText,
+    structuredOutput,
+    provenance: {
+      resolvedModel: providerModel,
+      resolvedEffort: providerEffort,
+      resolvedServiceTier: providerServiceTier,
+      runtimeVersion: providerRuntimeVersion,
+      evidenceTier:
+        providerModel || providerEffort || providerServiceTier
+          ? "provider_reported"
+          : "requested_only",
+      usage: providerUsage,
+    },
+  };
+}
+
+function firstNonEmptyString(...values) {
+  for (const value of values) {
+    const normalized = String(value || "").trim();
+    if (normalized) return normalized.slice(0, 160);
+  }
+  return null;
+}
+
+function mergeUsageEvidence(current, value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return current;
+  }
+  return {
+    ...current,
+    ...Object.fromEntries(
+      Object.entries(value)
+        .filter(([, amount]) =>
+          ["number", "string", "boolean"].includes(typeof amount),
+        )
+        .slice(0, 30),
+    ),
+  };
 }
 
 function normalizeProviderLaunchError(error, binary) {