@stage5/lumine 0.2.53 → 0.2.54

package/README.md

@@ -229,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
@@ -248,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" \
@@ -355,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

@@ -814,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(
@@ -1490,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|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 +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",
@@ -2265,6 +2377,79 @@ function printAdminMonthlyMediaCosts(monthlyMediaCosts) {
 
 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 +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)

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) {