@stage5/lumine 0.2.53 → 0.2.55

package/lib/agent/providers/codex.js

@@ -77,7 +77,10 @@ export async function runCodexAgentPass({
     tools: runtime.tools,
     toolSession,
   });
-  return { finalText: result.finalText };
+  return {
+    finalText: result.finalText,
+    provenance: result.provenance,
+  };
 }
 
 export async function reviewCodexAgentLoop({
@@ -120,6 +123,7 @@ async function runCodexAppServerTurn({
       binary,
       cwd: isolationDir,
       environment: providerEnvironment,
+      signal: options.agentAbortSignal,
     });
   } catch (error) {
     throw normalizeProviderLaunchError(error, binary, "Codex");
@@ -128,12 +132,22 @@ async function runCodexAppServerTurn({
     cwd: isolationDir,
     stdio: ["pipe", "pipe", "pipe"],
     env: providerEnvironment,
+    ...(options.agentAbortSignal ? { signal: options.agentAbortSignal } : {}),
   });
   child.stderr.on("data", (chunk) => process.stderr.write(chunk));
+  let childInputError = null;
+  child.stdin.on("error", (error) => {
+    childInputError ||= error;
+  });
 
   let nextRequestId = 1;
   const pendingRequests = new Map();
   let completedTurn = null;
+  let initializedServer = null;
+  let startedThreadResult = null;
+  let latestThreadSettings = null;
+  let latestTokenUsage = null;
+  let reroutedModel = null;
   let completedTurnResolve;
   const completedTurnPromise = new Promise((resolve) => {
     completedTurnResolve = resolve;
@@ -143,10 +157,19 @@ async function runCodexAppServerTurn({
   const inheritedMcpServers = new Set();
 
   function send(message) {
+    if (childInputError || child.stdin.destroyed || child.stdin.writableEnded) {
+      return false;
+    }
     // App-server uses JSON-RPC semantics but intentionally omits the jsonrpc
     // header on its JSONL wire format.
     const { jsonrpc: _jsonrpc, ...wireMessage } = message;
-    child.stdin.write(`${JSON.stringify(wireMessage)}\n`);
+    try {
+      child.stdin.write(`${JSON.stringify(wireMessage)}\n`);
+      return true;
+    } catch (error) {
+      childInputError ||= error;
+      return false;
+    }
   }
 
   function request(method, params) {
@@ -154,7 +177,10 @@ async function runCodexAppServerTurn({
     nextRequestId += 1;
     return new Promise((resolve, reject) => {
       pendingRequests.set(id, { resolve, reject });
-      send({ jsonrpc: "2.0", id, method, params });
+      if (!send({ jsonrpc: "2.0", id, method, params })) {
+        pendingRequests.delete(id);
+        reject(new Error("Codex app-server input closed."));
+      }
     });
   }
 
@@ -199,9 +225,7 @@ async function runCodexAppServerTurn({
         jsonrpc: "2.0",
         id: message.id,
         result: {
-          contentItems: [
-            { type: "inputText", text: JSON.stringify(output) },
-          ],
+          contentItems: [{ type: "inputText", text: JSON.stringify(output) }],
           success,
         },
       });
@@ -269,6 +293,18 @@ async function runCodexAppServerTurn({
       }
       return;
     }
+    if (message.method === "thread/settings/updated") {
+      latestThreadSettings = message.params?.threadSettings || null;
+      return;
+    }
+    if (message.method === "thread/tokenUsage/updated") {
+      latestTokenUsage = message.params?.tokenUsage || null;
+      return;
+    }
+    if (message.method === "model/rerouted") {
+      reroutedModel = firstNonEmptyString(message.params?.toModel);
+      return;
+    }
     if (
       message.method === "item/completed" &&
       message.params?.item?.type === "agentMessage"
@@ -296,7 +332,7 @@ async function runCodexAppServerTurn({
   });
 
   try {
-    await Promise.race([
+    initializedServer = await Promise.race([
       request("initialize", {
         clientInfo: {
           name: "lumine-cli",
@@ -312,6 +348,7 @@ async function runCodexAppServerTurn({
     send({ jsonrpc: "2.0", method: "initialized", params: {} });
     const threadResult = await request("thread/start", {
       ...(options.model ? { model: options.model } : {}),
+      ...(options.serviceTier ? { serviceTier: options.serviceTier } : {}),
       cwd: isolationDir,
       approvalPolicy: "never",
       sandbox: "read-only",
@@ -322,6 +359,7 @@ async function runCodexAppServerTurn({
       developerInstructions,
       dynamicTools: toCodexDynamicTools(tools),
     });
+    startedThreadResult = threadResult || null;
     const threadId = String(threadResult?.thread?.id || "");
     if (!threadId) throw new Error("Codex did not return a thread ID.");
     await delay(250);
@@ -330,9 +368,8 @@ async function runCodexAppServerTurn({
       detail: "toolsAndAuthOnly",
       limit: 100,
     });
-    const inheritedToolServers = (Array.isArray(mcpInventory?.data)
-      ? mcpInventory.data
-      : []
+    const inheritedToolServers = (
+      Array.isArray(mcpInventory?.data) ? mcpInventory.data : []
     )
       .filter((server) => Object.keys(server?.tools || {}).length > 0)
       .map((server) => String(server?.name || "").trim())
@@ -364,7 +401,44 @@ async function runCodexAppServerTurn({
     }
     const finalText =
       completedMessages.at(-1) || String(deltaText || "").trim();
-    return { finalText };
+    const resolvedModel = firstNonEmptyString(
+      reroutedModel,
+      latestThreadSettings?.model,
+      startedThreadResult?.model,
+      startedThreadResult?.thread?.model,
+    );
+    const resolvedEffort = firstNonEmptyString(
+      latestThreadSettings?.effort,
+      startedThreadResult?.reasoningEffort,
+      startedThreadResult?.thread?.effort,
+      startedThreadResult?.thread?.reasoningEffort,
+    );
+    const resolvedServiceTier = firstNonEmptyString(
+      latestThreadSettings?.serviceTier,
+      startedThreadResult?.serviceTier,
+      startedThreadResult?.thread?.serviceTier,
+      startedThreadResult?.thread?.service_tier,
+    );
+    return {
+      finalText,
+      provenance: {
+        resolvedModel,
+        resolvedEffort,
+        resolvedServiceTier,
+        runtimeVersion: firstNonEmptyString(
+          initializedServer?.userAgent,
+          initializedServer?.serverInfo?.version,
+          initializedServer?.server_info?.version,
+        ),
+        evidenceTier:
+          resolvedModel || resolvedEffort || resolvedServiceTier
+            ? "runtime_observed"
+            : "requested_only",
+        usage: normalizeUsageEvidence(
+          latestTokenUsage?.last || latestTokenUsage?.total || turn?.usage,
+        ),
+      },
+    };
   } catch (error) {
     throw normalizeProviderLaunchError(error, binary, "Codex");
   } finally {
@@ -378,13 +452,33 @@ async function runCodexAppServerTurn({
   }
 }
 
-async function loadCodexIsolationArgs({ binary, cwd, environment }) {
+function firstNonEmptyString(...values) {
+  for (const value of values) {
+    const normalized = String(value || "").trim();
+    if (normalized) return normalized.slice(0, 160);
+  }
+  return null;
+}
+
+function normalizeUsageEvidence(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return Object.fromEntries(
+    Object.entries(value)
+      .filter(([, amount]) =>
+        ["number", "string", "boolean"].includes(typeof amount),
+      )
+      .slice(0, 30),
+  );
+}
+
+async function loadCodexIsolationArgs({ binary, cwd, environment, signal }) {
   const [featureOutput, mcpOutput] = await Promise.all([
     runCodexInspectionCommand({
       binary,
       args: ["features", "list"],
       cwd,
       environment,
+      signal,
       label: "feature inventory",
     }),
     runCodexInspectionCommand({
@@ -392,13 +486,19 @@ async function loadCodexIsolationArgs({ binary, cwd, environment }) {
       args: ["mcp", "list", "--json"],
       cwd,
       environment,
+      signal,
       label: "MCP inventory",
     }),
   ]);
   const availableFeatures = new Set(
     featureOutput
       .split("\n")
-      .map((line) => String(line || "").trim().split(/\s+/)[0])
+      .map(
+        (line) =>
+          String(line || "")
+            .trim()
+            .split(/\s+/)[0],
+      )
       .filter((name) => /^[a-z][a-z0-9_]*$/.test(name)),
   );
   let mcpServers;
@@ -437,6 +537,7 @@ async function runCodexInspectionCommand({
   args,
   cwd,
   environment,
+  signal,
   label,
 }) {
   return await new Promise((resolve, reject) => {
@@ -444,13 +545,16 @@ async function runCodexInspectionCommand({
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
       env: environment,
+      ...(signal ? { signal } : {}),
     });
     let stdout = "";
     let settled = false;
     const timeout = setTimeout(() => {
       child.kill();
       finish(
-        new Error(`Codex ${label} timed out; Lumine cannot prove tool isolation.`),
+        new Error(
+          `Codex ${label} timed out; Lumine cannot prove tool isolation.`,
+        ),
       );
     }, CODEX_PREFLIGHT_TIMEOUT_MS);
     const finish = (error, value = "") => {

package/lib/agent.js

@@ -112,6 +112,8 @@ export async function agentCommand(options, { saveWorkspace }) {
   let currentFiles = workspace.files;
   let scopeBaseFiles = workspace.files;
   let finalText = "";
+  const providerRuns = [];
+  let saveResult = null;
   let scopeRepairAttempts = 0;
   let validationRepairAttempts = 0;
 
@@ -160,6 +162,10 @@ export async function agentCommand(options, { saveWorkspace }) {
         },
       });
       finalText = String(providerResult?.finalText || "").trim() || finalText;
+      providerRuns.push({
+        phase: runtime.phase,
+        ...(providerResult?.provenance || {}),
+      });
       await appendAgentTrace(artifacts.traceFile, {
         type: "provider_completed",
         provider: provider.id,
@@ -257,7 +263,7 @@ export async function agentCommand(options, { saveWorkspace }) {
 
     const changedPaths = listChangedPaths(workspace.files, currentFiles);
     if (changedPaths.length > 0) {
-      await saveWorkspace({
+      saveResult = await saveWorkspace({
         ...options,
         dir: workspace.dir,
         publish: false,
@@ -304,6 +310,8 @@ export async function agentCommand(options, { saveWorkspace }) {
       finalText,
       traceFile: artifacts.traceFile,
       feedbackFile: feedback ? artifacts.feedbackFile : null,
+      saveResult,
+      providerRuns,
     };
   } catch (error) {
     await appendAgentTrace(artifacts.traceFile, {

package/lib/auth.js

@@ -6,6 +6,9 @@ import { requestJson } from "./http.js";
 import { sleep, trimTrailingSlash } from "./util.js";
 
 export async function login(options) {
+  const report = options.loginProgressToStderr
+    ? (...args) => console.error(...args)
+    : (...args) => console.log(...args);
   const start = await requestJson({
     method: "POST",
     url: `${options.apiUrl}/cli/device/start`,
@@ -23,15 +26,15 @@ export async function login(options) {
   });
 
   const approvalUrl = start.verificationUriComplete || start.verificationUri;
-  console.log("Connect Lumine CLI to Twinkle.");
+  report("Connect Lumine CLI to Twinkle.");
   if (options.openBrowser && approvalUrl) {
-    console.log("Opening Twinkle in your browser...");
+    report("Opening Twinkle in your browser...");
     const opened = await openBrowser(approvalUrl);
-    if (!opened) console.log("Could not open the browser automatically.");
+    if (!opened) report("Could not open the browser automatically.");
   }
-  console.log(`Approval link: ${approvalUrl}`);
-  console.log(`Code: ${start.userCode}`);
-  console.log("Leave this terminal open. Waiting for approval...");
+  report(`Approval link: ${approvalUrl}`);
+  report(`Code: ${start.userCode}`);
+  report("Leave this terminal open. Waiting for approval...");
 
   const intervalMs = Math.max(Number(start.interval || 3), 1) * 1000;
   const startedAt = Date.now();
@@ -52,10 +55,10 @@ export async function login(options) {
       userId: tokenResponse.user?.id || null,
       expiresAt: Date.now() + Number(tokenResponse.expiresIn || 0) * 1000,
     });
-    console.log(
+    report(
       `Logged in${tokenResponse.user?.username ? ` as ${tokenResponse.user.username}` : ""}.`,
     );
-    console.log("You can now run `lumine` to choose a project.");
+    report("You can now run `lumine` to choose a project.");
     return;
   }
 
@@ -112,7 +115,10 @@ export async function ensureAuth(options) {
   } catch (error) {
     if (options.authToken || !isMissingLoginError(error)) throw error;
   }
-  await login(options);
+  await login({
+    ...options,
+    loginProgressToStderr: Boolean(options.json),
+  });
   return await resolveAuth(options);
 }
 

package/lib/commands.js

@@ -67,6 +67,7 @@ import { runBuildForumCommand } from "./forum.js";
 import { agentCommand } from "./agent.js";
 import { agentMcpCommand } from "./agent/mcp-server.js";
 import { appMcpCommand } from "./app-mcp/server.js";
+import { sponsorCommand } from "./sponsor.js";
 import {
   defaultMainCheckoutDir,
   defaultReferenceDir,
@@ -130,6 +131,14 @@ export async function main() {
     return;
   }
 
+  if (options.command === "sponsor") {
+    await sponsorCommand(options, {
+      saveWorkspace: save,
+      pullWorkspace: pullBuildFiles,
+    });
+    return;
+  }
+
   if (options.command === "agent") {
     await agentCommand(options, { saveWorkspace: save });
     return;
@@ -1122,7 +1131,7 @@ export async function save(options) {
       console.log(
         "Saved to your branch. The project owner can merge or replace main from Twinkle.",
       );
-      return;
+      return result;
     }
     const publish = await publishBuild({ options, buildId, auth });
     if (publish.skipped) {
@@ -1135,6 +1144,7 @@ export async function save(options) {
     );
     console.log(`App: ${options.siteUrl}/app/${buildId}`);
   }
+  return result;
 }
 
 export async function check(options) {
@@ -1502,32 +1512,34 @@ export async function pullBuildFiles({ options, auth, buildId }) {
   // exists (the workspace UI gives Lumine the same context). Never fail the
   // pull over it.
   let assetCount = null;
-  try {
-    const { token } = await mintBuildApiToken({
-      options,
-      auth,
-      buildId: Number(build.id || buildId),
-      scopes: ["files:read"],
-    });
-    const { assets, usage, projectAssets } = await fetchAllRuntimeAssets({
-      options,
-      auth,
-      buildId: Number(build.id || buildId),
-      buildApiToken: token,
-    });
-    await writeAssetsManifest({
-      dir,
-      buildId: Number(build.id || buildId),
-      assets,
-      usage,
-      projectAssets,
-      codeFiles: files,
-    });
-    assetCount = assets.length + (projectAssets?.length || 0);
-  } catch (error) {
-    console.error(
-      `lumine: skipped ${ASSETS_METADATA_FILE} (${error?.message || error})`,
-    );
+  if (!options.skipAssetManifest) {
+    try {
+      const { token } = await mintBuildApiToken({
+        options,
+        auth,
+        buildId: Number(build.id || buildId),
+        scopes: ["files:read"],
+      });
+      const { assets, usage, projectAssets } = await fetchAllRuntimeAssets({
+        options,
+        auth,
+        buildId: Number(build.id || buildId),
+        buildApiToken: token,
+      });
+      await writeAssetsManifest({
+        dir,
+        buildId: Number(build.id || buildId),
+        assets,
+        usage,
+        projectAssets,
+        codeFiles: files,
+      });
+      assetCount = assets.length + (projectAssets?.length || 0);
+    } catch (error) {
+      console.error(
+        `lumine: skipped ${ASSETS_METADATA_FILE} (${error?.message || error})`,
+      );
+    }
   }
   return {
     build,
@@ -2249,6 +2261,7 @@ export function parseArgs(args) {
     "includeLegacy",
     "includePrivateEvidence",
     "noReviewLoop",
+    "acceptAgreement",
   ]);
 
   for (let i = 0; i < rest.length; i += 1) {
@@ -2366,10 +2379,33 @@ export function parseArgs(args) {
     adminReviewContext: raw.reviewContext ? String(raw.reviewContext) : "",
     adminSeverity: raw.severity ? String(raw.severity) : "",
     adminStatus: raw.status ? String(raw.status) : "",
+    adminDecision: raw.decision ? String(raw.decision) : "",
     adminWaitMs: raw.waitMs ? String(raw.waitMs) : "",
     adminBrowserPath: raw.browserPath ? String(raw.browserPath) : "",
     adminEffort: raw.effort ? String(raw.effort) : "",
     agentEffort: command === "agent" && raw.effort ? String(raw.effort) : "",
+    sponsorArgs: command === "sponsor" ? positional : [],
+    sponsorMotivation: raw.motivation ? String(raw.motivation) : "",
+    sponsorAvailability: raw.availability ? String(raw.availability) : "",
+    sponsorProviders: raw.providers
+      ? String(raw.providers)
+      : raw.provider
+        ? String(raw.provider)
+        : "",
+    sponsorCapabilityNotes: raw.capabilityNotes
+      ? String(raw.capabilityNotes)
+      : "",
+    sponsorAcceptAgreement: Boolean(raw.acceptAgreement),
+    sponsorPersona: raw.persona ? String(raw.persona) : "",
+    sponsorConcurrency: raw.concurrency,
+    sponsorHelpers: raw.helpers,
+    sponsorDailyLimit: raw.dailyLimit,
+    sponsorWeeklyLimit: raw.weeklyLimit,
+    sponsorEffort: raw.effort ? String(raw.effort) : "",
+    sponsorServiceTier: raw.serviceTier ? String(raw.serviceTier) : "",
+    sponsorPollMs: raw.pollMs
+      ? Math.min(Math.max(Number(raw.pollMs) || 0, 1_000), 60_000)
+      : 3_000,
     provider: raw.provider ? String(raw.provider) : "",
     providerPath: raw.providerPath ? String(raw.providerPath) : "",
     agentPrompt:
@@ -2692,6 +2728,11 @@ export function printHelp() {
   lumine whoami
   lumine logout
   lumine agent --provider <codex|claude-code> "<build request>"
+  lumine sponsor agreement|apply|status|withdraw
+  lumine sponsor capacity [--concurrency <n>] [--helpers <n>] [--daily-limit <n>] [--weekly-limit <n>]
+  lumine sponsor duty start <zero|ciel> --provider <codex|claude-code> [--model <name>] [--effort <level>] [--service-tier <tier>]
+  lumine sponsor duty pause|resume|stop <zero|ciel>
+  lumine sponsor jobs
   lumine app-mcp <published-app-url-or-id> [--no-open]
   lumine new [title]
   lumine rename [title] [--target <twinkle-build-url-or-id>]
@@ -2750,6 +2791,13 @@ export function printHelp() {
   lumine admin todo list [--status pending|open|in_progress|blocked|completed|cancelled|all] [--limit <number>] [--json]
   lumine admin todo add --title <title> --note <handoff-and-acceptance-criteria> [--kind task|experiment] [--status open|in_progress|blocked] [--json]
   lumine admin todo update <todo-id> --status open|in_progress|blocked|completed|cancelled --note <progress-or-evidence> [--json]
+  lumine admin sponsor applications list [--status pending|approved|rejected|withdrawn] [--json]
+  lumine admin sponsor applications review <application-id> --decision approve|reject [--note <text>] [--json]
+  lumine admin sponsor status set <user-id> --status probationary|trusted|suspended|revoked [--note <text>] [--json]
+  lumine admin sponsor integrity status|scan [--json]
+  lumine admin sponsor integrity cases [--status open|pending|held|flagged|cleared|disqualified] [--json]
+  lumine admin sponsor integrity get <case-id> [--json]
+  lumine admin sponsor integrity review <case-id> --decision clear|hold|flag|disqualify [--note <evidence>] [--json]
   lumine admin recommendations list [--since-run|--after <date>|--include-legacy] [--all --checkpoint <file> [--resume]] [--content-types comment,dailyReflection] [--unviewed|--viewed] [--cursor <cursor>] [--json]
   lumine admin builds candidates [--all --checkpoint <file> [--resume]] [--cursor <cursor>] [--limit <number>] [--json]
   lumine admin builds review <build-url-or-id> [--output-dir <dir>] [--wait-ms <ms>] [--browser-path <path>] [--json]
@@ -2859,7 +2907,7 @@ Options:
   --since-run           Recommendations since the previous completed run (default)
   --include-legacy      Explicitly include the full historical recommendation queue
   --all                 Automatically read every page in the canonical snapshot
-  --checkpoint <file>   Persist automatic pagination or batch progress
+  --checkpoint <file>   Persist bounded pagination metadata or batch progress
   --resume              Resume the exact request recorded by --checkpoint
   --output <file>       Save an admin result or newspaper claim as JSON
   --output-dir <dir>    Directory for managed Build review evidence

package/lib/constants.js

@@ -371,6 +371,7 @@ export const MAIN_CHECKOUT_READONLY_COMMANDS = new Set([
 export const COMMANDS = new Set([
   "admin",
   "agent",
+  "sponsor",
   "agent-mcp",
   "app-mcp",
   "workspace",