@brainbase-labs/cli 0.22.0 → 0.24.0

package/dist/index.js

@@ -36008,7 +36008,7 @@ function padStart(s, n) {
 // package.json
 var package_default = {
   name: "@brainbase-labs/cli",
-  version: "0.22.0",
+  version: "0.24.0",
   description: "Pack, share, and install agent templates across harnesses (Claude Code, Codex, ...).",
   type: "module",
   bin: {
@@ -53931,6 +53931,76 @@ function clearTokenIfMatches(prefix) {
   });
 }
 
+// src/core/credentials.ts
+var REGISTRY_COMMANDS = "template, skill, token";
+var CONTROL_PLANE_COMMANDS = "agent, orchestration, link, unlink, sync, status, team";
+var NOT_A_PAT = "(not a bbpat_… token)";
+function maskPat(token) {
+  if (!isValidTokenFormat(token))
+    return NOT_A_PAT;
+  return token.slice(0, TOKEN_PREFIX_LEN);
+}
+function readEnvPat() {
+  const value = process.env.BRAINBASE_TOKEN?.trim();
+  if (!value)
+    return null;
+  return { prefix: maskPat(value), malformed: !isValidTokenFormat(value) };
+}
+function storedPatIgnoredHint(client) {
+  const setEnv = `Set BRAINBASE_TOKEN to that token's value to authenticate with it here, ` + "or run `brainbase login` to refresh the session";
+  switch (client) {
+    case "control-plane":
+      return `The PAT saved in ${TOKEN_FILE} is never used by control-plane ` + `commands (${CONTROL_PLANE_COMMANDS}). ${setEnv}.`;
+    case "managed-task":
+      return `The PAT saved in ${TOKEN_FILE} is not used while a login session is ` + `configured. ${setEnv} — or \`brainbase logout\`, which leaves the ` + "PAT as the only credential.";
+    default: {
+      const exhaustive = client;
+      throw new Error(`unhandled credential client: ${String(exhaustive)}`);
+    }
+  }
+}
+function withStoredPatHint(reason, client) {
+  if (!readToken())
+    return reason;
+  const trimmed = reason.trimEnd();
+  const separator = /[.!?:]$/.test(trimmed) ? " " : ". ";
+  return `${trimmed}${separator}${storedPatIgnoredHint(client)}`;
+}
+function withRejectedSessionHint(message, source, client) {
+  if (source !== "session")
+    return message;
+  return withStoredPatHint(message, client);
+}
+function isRefreshable(session) {
+  return Boolean(session.refresh_token && session.supabase_url && session.supabase_anon_key);
+}
+function describeCredentials() {
+  const env3 = readEnvPat();
+  const status = authStatus();
+  const stored = readToken();
+  const refreshable = Boolean(status.session && !status.ok && isRefreshable(status.session));
+  const session = status.session ? {
+    email: status.session.email ?? null,
+    userId: status.session.user_id,
+    expiresAt: status.session.expires_at ?? null,
+    expired: !status.ok,
+    refreshable
+  } : null;
+  let active = null;
+  if (env3)
+    active = "env_pat";
+  else if (status.ok || refreshable)
+    active = "session";
+  else if (stored)
+    active = "stored_pat";
+  return {
+    active,
+    envPat: env3,
+    session,
+    storedPat: stored ? { name: stored.name ?? null, prefix: stored.prefix } : null
+  };
+}
+
 // src/core/api.ts
 var DEFAULT_CONTROL_PLANE_BASE = "https://api.brainbaselabs.com";
 var DEFAULT_PROXY_BASE = "https://api.v1.brainbaselabs.com";
@@ -54005,7 +54075,7 @@ function legacyScheduleError() {
 function legacyAgentConfigError() {
   return new ApiError("Declarative machine/model config requires the MAS control plane. Set BRAINBASE_CONTROL_PLANE_URL or unset the legacy BRAINBASE_API_URL override.", 400);
 }
-async function resolveCredential() {
+async function resolveCredential(storedPatHint = "control-plane") {
   const envToken = process.env.BRAINBASE_TOKEN;
   if (envToken && envToken.trim()) {
     return {
@@ -54023,19 +54093,20 @@ async function resolveCredential() {
     };
   }
   const status = authStatus();
-  throw new ApiError(status.ok ? "CLI authentication changed while this command was starting; retry it" : status.reason ?? "not logged in", 401);
+  const reason = status.reason ?? "not logged in";
+  throw new ApiError(status.ok ? "CLI authentication changed while this command was starting; retry it" : storedPatHint ? withStoredPatHint(reason, storedPatHint) : reason, 401);
 }
 async function resolveMasCredential() {
   const configuredSession = readAuth();
   try {
-    return await resolveCredential();
+    return await resolveCredential(null);
   } catch (error) {
     if (!(error instanceof ApiError && error.status === 401)) {
       throw error;
     }
     if (configuredSession || readAuth()) {
       if (readToken()) {
-        throw new ApiError(`${error.message}. A stored PAT is available but will not be used while a login session is configured. Run \`brainbase logout\` to use the stored PAT, or \`brainbase login\` to refresh the session.`, 401);
+        throw new ApiError(`${error.message}. ${storedPatIgnoredHint("managed-task")}`, 401);
       }
       throw error;
     }
@@ -54134,7 +54205,8 @@ async function request(pathname, init = {}) {
     body = text2 ? JSON.parse(text2) : null;
   } catch {}
   if (!res.ok) {
-    throw new ApiError(apiErrorMessage(body, res.status), res.status, body);
+    const message = apiErrorMessage(body, res.status);
+    throw new ApiError(res.status === 401 ? withRejectedSessionHint(message, credential.source, "control-plane") : message, res.status, body);
   }
   return body;
 }
@@ -54277,7 +54349,7 @@ async function masRequest(pathname, init) {
     }
     if (!res.ok) {
       const message = masApiErrorMessage(body, res.status);
-      throw new ApiError(res.status >= 500 ? `${message} Task creation may still be processing; check your tasks before running this command again.` : message, res.status, body);
+      throw new ApiError(res.status >= 500 ? `${message} Task creation may still be processing; check your tasks before running this command again.` : res.status === 401 ? withRejectedSessionHint(message, credential.source, "managed-task") : message, res.status, body);
     }
     return body;
   }
@@ -61658,12 +61730,13 @@ async function runLogin(_cwd, args) {
 // src/ui/ink/IdentityCard.tsx
 var jsx_dev_runtime15 = __toESM(require_jsx_dev_runtime(), 1);
 function IdentityCard(props) {
+  const hasRows = Boolean(props.rows?.length || props.controlPlaneUrl || props.expiresAt);
   return /* @__PURE__ */ jsx_dev_runtime15.jsxDEV(Card, {
     title: props.title,
     tone: props.tone ?? "info",
     children: [
       props.email && /* @__PURE__ */ jsx_dev_runtime15.jsxDEV(Box_default, {
-        marginBottom: props.controlPlaneUrl || props.expiresAt ? 1 : 0,
+        marginBottom: hasRows ? 1 : 0,
         children: /* @__PURE__ */ jsx_dev_runtime15.jsxDEV(Text, {
           bold: true,
           children: props.email
@@ -61672,6 +61745,20 @@ function IdentityCard(props) {
       /* @__PURE__ */ jsx_dev_runtime15.jsxDEV(Box_default, {
         flexDirection: "column",
         children: [
+          props.rows?.map(([label, value]) => /* @__PURE__ */ jsx_dev_runtime15.jsxDEV(Box_default, {
+            children: [
+              /* @__PURE__ */ jsx_dev_runtime15.jsxDEV(Box_default, {
+                width: 15,
+                children: /* @__PURE__ */ jsx_dev_runtime15.jsxDEV(Text, {
+                  dimColor: true,
+                  children: label
+                }, undefined, false, undefined, this)
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsx_dev_runtime15.jsxDEV(Text, {
+                children: value
+              }, undefined, false, undefined, this)
+            ]
+          }, label, true, undefined, this)),
           props.controlPlaneUrl && /* @__PURE__ */ jsx_dev_runtime15.jsxDEV(Box_default, {
             children: [
               /* @__PURE__ */ jsx_dev_runtime15.jsxDEV(Box_default, {
@@ -61739,22 +61826,117 @@ async function runLogout() {
 }
 
 // src/cli/whoami.ts
-async function runWhoami() {
-  const { ok, session, reason } = authStatus();
-  if (!ok || !session) {
-    await showIdentityCard({
-      title: "NOT SIGNED IN",
-      tone: "warn",
-      message: `${reason ?? "not logged in"}. Run \`brainbase login\` to connect this device.`
-    });
-    process.exit(1);
+function usableForControlPlane(report) {
+  switch (report.active) {
+    case "env_pat":
+      return !report.envPat?.malformed;
+    case "session":
+      return true;
+    case "stored_pat":
+    case null:
+      return false;
+    default: {
+      const exhaustive = report.active;
+      throw new Error(`unhandled credential: ${String(exhaustive)}`);
+    }
   }
+}
+function exitCodeFor(report) {
+  return usableForControlPlane(report) ? 0 : 1;
+}
+function reasonFor(report) {
+  switch (report.active) {
+    case "env_pat":
+      return report.envPat?.malformed ? "BRAINBASE_TOKEN is set to something that is not a `bbpat_…` token, " + "and it outranks every other credential — so every request will fail " + "until it is corrected or unset. Mint one with `brainbase token create`." : null;
+    case "session":
+      return null;
+    case "stored_pat":
+      return `The stored PAT authenticates registry commands (${REGISTRY_COMMANDS}) only. ` + `Set BRAINBASE_TOKEN to its value for ${CONTROL_PLANE_COMMANDS}, ` + "or run `brainbase login`.";
+    case null:
+      return report.session?.expired ? "Session expired. Run `brainbase login` to connect this device." : "Not logged in. Run `brainbase login` to connect this device.";
+    default: {
+      const exhaustive = report.active;
+      throw new Error(`unhandled credential: ${String(exhaustive)}`);
+    }
+  }
+}
+function toJson(report, reason) {
+  const usingSession = report.active === "session";
+  return {
+    credential: report.active,
+    authenticated: report.active !== null && !report.envPat?.malformed,
+    control_plane: usableForControlPlane(report),
+    email: usingSession ? report.session?.email ?? null : null,
+    user_id: usingSession ? report.session?.userId ?? null : null,
+    expires_at: usingSession ? report.session?.expiresAt ?? null : null,
+    token_prefix: report.active === "env_pat" ? report.envPat?.prefix ?? null : report.active === "stored_pat" ? report.storedPat?.prefix ?? null : null,
+    control_plane_url: controlPlaneBaseUrl(usingSession ? readAuth() : null),
+    session: report.session ? {
+      present: true,
+      expired: report.session.expired,
+      refreshable: report.session.refreshable
+    } : { present: false, expired: false, refreshable: false },
+    stored_pat: report.storedPat ? { present: true, name: report.storedPat.name } : { present: false, name: null },
+    reason
+  };
+}
+function displayPrefix(prefix) {
+  return prefix === NOT_A_PAT ? prefix : `${prefix}…`;
+}
+function cardRows(report) {
+  const rows = [];
+  switch (report.active) {
+    case "env_pat":
+      rows.push(["credential", "BRAINBASE_TOKEN (env PAT)"]);
+      if (report.envPat) {
+        rows.push(["token", displayPrefix(report.envPat.prefix)]);
+      }
+      break;
+    case "session":
+      rows.push([
+        "credential",
+        report.session?.refreshable ? "login session (auth.json) — expired, renews on next use" : "login session (auth.json)"
+      ]);
+      break;
+    case "stored_pat":
+      rows.push(["credential", "stored PAT (token.json)"]);
+      rows.push([
+        "token",
+        report.storedPat?.name ? `${displayPrefix(report.storedPat.prefix)} (${report.storedPat.name})` : displayPrefix(report.storedPat?.prefix ?? "?")
+      ]);
+      break;
+    case null:
+      break;
+    default: {
+      const exhaustive = report.active;
+      throw new Error(`unhandled credential: ${String(exhaustive)}`);
+    }
+  }
+  if (report.session && report.active !== "session") {
+    rows.push([
+      "session",
+      `${report.session.email ?? report.session.userId} (${report.session.expired ? "expired" : "not used — env PAT wins"})`
+    ]);
+  }
+  return rows;
+}
+async function runWhoami(args = {}) {
+  const report = describeCredentials();
+  const reason = reasonFor(report);
+  process.exitCode = exitCodeFor(report);
+  if (args.json) {
+    console.log(JSON.stringify(toJson(report, reason), null, 2));
+    return;
+  }
+  const signedIn = report.active !== null;
   await showIdentityCard({
-    title: "WHOAMI",
-    tone: "ok",
-    email: session.email ?? session.user_id,
-    controlPlaneUrl: controlPlaneBaseUrl(session),
-    expiresAt: session.expires_at
+    title: signedIn ? "WHOAMI" : "NOT SIGNED IN",
+    tone: process.exitCode === 0 ? "ok" : "warn",
+    email: report.active === "session" ? report.session?.email ?? report.session?.userId ?? null : null,
+    controlPlaneUrl: signedIn ? controlPlaneBaseUrl(report.active === "session" ? readAuth() : null) : null,
+    expiresAt: report.active === "session" ? report.session?.expiresAt : null,
+    rows: cardRows(report),
+    message: reason ?? undefined
   });
 }
 
@@ -68922,14 +69104,6 @@ function TokenCreatedCard(props) {
     tone: "warn",
     subtitle: "shown ONCE — copy it now",
     children: [
-      /* @__PURE__ */ jsx_dev_runtime17.jsxDEV(Box_default, {
-        marginBottom: 1,
-        children: /* @__PURE__ */ jsx_dev_runtime17.jsxDEV(Text, {
-          bold: true,
-          color: "yellow",
-          children: props.token
-        }, undefined, false, undefined, this)
-      }, undefined, false, undefined, this),
       /* @__PURE__ */ jsx_dev_runtime17.jsxDEV(Box_default, {
         flexDirection: "column",
         marginBottom: 1,
@@ -68990,20 +69164,22 @@ function TokenCreatedCard(props) {
           /* @__PURE__ */ jsx_dev_runtime17.jsxDEV(Text, {
             dimColor: true,
             children: [
-              "saved locally to ",
+              "saved to ",
               props.storedAt,
-              " (mode 0600)"
+              " (mode 0600) — covers ",
+              REGISTRY_COMMANDS
             ]
           }, undefined, true, undefined, this),
           /* @__PURE__ */ jsx_dev_runtime17.jsxDEV(Text, {
             dimColor: true,
             children: [
-              "for CI: set ",
+              CONTROL_PLANE_COMMANDS,
+              " do ",
               /* @__PURE__ */ jsx_dev_runtime17.jsxDEV(Text, {
                 bold: true,
-                children: "BRAINBASE_TOKEN"
+                children: "not"
               }, undefined, false, undefined, this),
-              " instead of relying on token.json"
+              " read that file — export it instead:"
             ]
           }, undefined, true, undefined, this)
         ]
@@ -69012,9 +69188,12 @@ function TokenCreatedCard(props) {
   }, undefined, true, undefined, this);
 }
 async function showTokenCreatedCard(props) {
+  const { token, ...card } = props;
   await renderStatic(/* @__PURE__ */ jsx_dev_runtime17.jsxDEV(TokenCreatedCard, {
-    ...props
+    ...card
   }, undefined, false, undefined, this));
+  console.log(`  export BRAINBASE_TOKEN=${token}`);
+  console.log("");
 }
 function TokenListCard(props) {
   if (props.active.length === 0) {
@@ -69180,11 +69359,32 @@ function isAllowedScope(value) {
 function isExpired2(token) {
   return Boolean(token.expires_at && Date.parse(token.expires_at) <= Date.now());
 }
+function isJwtRequired(body) {
+  if (!body || typeof body !== "object")
+    return false;
+  const detail = body.detail;
+  if (!detail || typeof detail !== "object")
+    return false;
+  return detail.code === "jwt_required";
+}
+function sessionWouldBeUsed() {
+  const { ok, session } = authStatus();
+  if (ok)
+    return true;
+  return Boolean(session?.refresh_token && session.supabase_url && session.supabase_anon_key);
+}
 function withLoginHint(error) {
-  if (error instanceof ApiError && error.status === 403) {
-    return new Error("Managing tokens needs a logged-in session; a PAT (BRAINBASE_TOKEN) cannot. " + "Run `brainbase login` and try again.");
-  }
-  return error;
+  if (!(error instanceof ApiError) || error.status !== 403)
+    return error;
+  if (!isJwtRequired(error.body))
+    return error;
+  if (!process.env.BRAINBASE_TOKEN?.trim()) {
+    if (sessionWouldBeUsed() || !readToken())
+      return error;
+    return new Error("Managing tokens needs a logged-in session; the stored PAT cannot. " + "Run `brainbase login` and try again.");
+  }
+  const lead = "Managing tokens needs a logged-in session, and BRAINBASE_TOKEN is set — " + "that PAT is being used instead.";
+  return new Error(sessionWouldBeUsed() ? `${lead} Run \`unset BRAINBASE_TOKEN\` and try again.` : `${lead} Run \`unset BRAINBASE_TOKEN\`, then \`brainbase login\`.`);
 }
 async function runTokenCreate(args) {
   banner("token create — make a long-lived CLI key");
@@ -69207,10 +69407,16 @@ async function runTokenCreate(args) {
   }
   const spinner = de();
   spinner.start("Creating token…");
-  const created = await registryApi.createCliToken({
-    name,
-    scopes
-  });
+  let created;
+  try {
+    created = await registryApi.createCliToken({
+      name,
+      scopes
+    });
+  } catch (error) {
+    spinner.stop("Could not create token.");
+    throw withLoginHint(error);
+  }
   spinner.stop("Token created.");
   try {
     writeToken(created.token, name);
@@ -69231,7 +69437,12 @@ async function runTokenCreate(args) {
 }
 async function runTokenList() {
   banner("tokens");
-  const tokens = await registryApi.listCliTokens();
+  let tokens;
+  try {
+    tokens = await registryApi.listCliTokens();
+  } catch (error) {
+    throw withLoginHint(error);
+  }
   const active = tokens.filter((t) => !t.revoked_at);
   const revoked = tokens.filter((t) => t.revoked_at);
   const local = readToken();
@@ -69354,7 +69565,7 @@ async function runTokenRevoke(args) {
       }
       throw new Error(`The server reported no active token with id ${args.id}, but it listed one a moment ago. ` + "The local token has been left alone, since that key may still work. " + "If this server predates `DELETE /v1/registry/cli-tokens/{id}`, revoke from the web app instead.");
     }
-    throw error;
+    throw withLoginHint(error);
   }
   reconcileDeadToken(target, `Revoked ${import_picocolors48.default.bold(target.name)}.`);
 }
@@ -78261,7 +78472,9 @@ import crypto6 from "node:crypto";
 import fs81 from "node:fs";
 import os16 from "node:os";
 import path88 from "node:path";
+import { Readable, Transform as Transform2 } from "node:stream";
 import { pipeline as pipeline2 } from "node:stream/promises";
+import { createGunzip, createInflateRaw } from "node:zlib";
 var SCHEMA_VERSION = "1";
 var SHA256_RE = /^[a-f0-9]{64}$/i;
 var ID_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/;
@@ -78269,6 +78482,9 @@ var ENV_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
 var MAX_SPEC_BYTES = 20 * 1024 * 1024;
 var MAX_FINAL_OUTPUT_BYTES = 10 * 1024 * 1024;
 var MAX_TRAJECTORY_BYTES = 100 * 1024 * 1024;
+var MAX_REMOTE_INPUT_BYTES = 2 * 1024 * 1024 * 1024;
+var MAX_ARCHIVE_EXTRACTED_BYTES = 2 * 1024 * 1024 * 1024;
+var MAX_ARCHIVE_SCAN_BYTES = 2 * 1024 * 1024 * 1024;
 var RESERVED_WORKSPACE_PATHS = new Set([
   ".brainbase",
   ".git",
@@ -78296,21 +78512,51 @@ var NonSecretEnvironmentValueSchema = exports_external.object({
   sensitive: exports_external.literal(false)
 }).strict();
 var RootRelativePathSchema = exports_external.string().min(1).max(1024);
+var ArchivePathSchema = RootRelativePathSchema.refine((value) => {
+  try {
+    return safeRelPath(value) === value;
+  } catch {
+    return false;
+  }
+}, {
+  message: "must be a normalized safe relative path"
+});
 var BudgetSchema = exports_external.object({
   timeout_ms: exports_external.number().int().min(100).max(3600000),
   max_output_bytes: exports_external.number().int().min(1024).max(100 * 1024 * 1024)
 }).strict();
-var MaterialSchema = exports_external.object({
+var MaterialBaseSchema = {
   id: IdSchema,
-  kind: exports_external.enum(["file", "tar_gz"]),
   source: RootRelativePathSchema,
+  download_url_env: EnvNameSchema.optional(),
   destination: RootRelativePathSchema,
   sha256: Sha256Schema,
   size_bytes: exports_external.number().int().min(0).max(2 * 1024 * 1024 * 1024),
-  mode: exports_external.number().int().min(0).max(511).optional(),
+  mode: exports_external.number().int().min(0).max(511).optional()
+};
+var ExpandableMaterialSchema = {
   max_unpacked_bytes: exports_external.number().int().min(1).max(2 * 1024 * 1024 * 1024).optional(),
   max_file_count: exports_external.number().int().min(1).max(1e5).optional()
-}).strict();
+};
+var MaterialSchema = exports_external.discriminatedUnion("kind", [
+  exports_external.object({
+    ...MaterialBaseSchema,
+    ...ExpandableMaterialSchema,
+    kind: exports_external.literal("file")
+  }).strict(),
+  exports_external.object({
+    ...MaterialBaseSchema,
+    ...ExpandableMaterialSchema,
+    kind: exports_external.literal("tar_gz")
+  }).strict(),
+  exports_external.object({
+    ...MaterialBaseSchema,
+    kind: exports_external.literal("archive_file"),
+    archive_path: ArchivePathSchema,
+    file_sha256: Sha256Schema,
+    file_size_bytes: exports_external.number().int().min(0).max(2 * 1024 * 1024 * 1024)
+  }).strict()
+]);
 var CommandSchema = exports_external.object({
   id: IdSchema,
   argv: exports_external.array(exports_external.string().min(1)).min(1).max(128),
@@ -78377,6 +78623,7 @@ var EvaluatorSchema = exports_external.discriminatedUnion("type", [
 ]);
 var EvidenceFileSchema = exports_external.object({
   source: RootRelativePathSchema,
+  download_url_env: EnvNameSchema.optional(),
   sha256: Sha256Schema,
   size_bytes: exports_external.number().int().min(0).max(2 * 1024 * 1024 * 1024)
 }).strict();
@@ -78421,6 +78668,35 @@ var BenchmarkSpecSchema = exports_external.discriminatedUnion("phase", [
     }
   }
   const declaredSecrets = new Set(value.secret_env);
+  const remoteInputs = value.phase === "hydrate" ? value.materials : [
+    value.evidence.final_output,
+    value.evidence.trajectory,
+    ...value.references
+  ];
+  const remoteUrlEnvNames = new Set(remoteInputs.flatMap((input) => input.download_url_env ? [input.download_url_env] : []));
+  const uniqueRemoteInputs = new Map;
+  for (const input of remoteInputs) {
+    if (!input.download_url_env)
+      continue;
+    uniqueRemoteInputs.set([input.source, input.sha256, input.size_bytes].join("\x00"), input.size_bytes);
+  }
+  const remoteInputBytes = [...uniqueRemoteInputs.values()].reduce((total, size2) => total + size2, 0);
+  if (remoteInputBytes > MAX_REMOTE_INPUT_BYTES) {
+    context.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      path: [value.phase === "hydrate" ? "materials" : "references"],
+      message: "remote inputs exceed the aggregate download byte limit"
+    });
+  }
+  for (const name of remoteUrlEnvNames) {
+    if (Object.hasOwn(value.environment, name)) {
+      context.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["environment", name],
+        message: "signed download URLs must be supplied through the process environment"
+      });
+    }
+  }
   const commands = value.phase === "hydrate" ? value.setup_commands.map((command, index) => ({
     command,
     path: ["setup_commands", index, "secret_env"]
@@ -78430,6 +78706,13 @@ var BenchmarkSpecSchema = exports_external.discriminatedUnion("phase", [
   }] : []);
   for (const { command, path: issuePath } of commands) {
     for (const name of command.secret_env) {
+      if (remoteUrlEnvNames.has(name)) {
+        context.addIssue({
+          code: exports_external.ZodIssueCode.custom,
+          path: issuePath,
+          message: `signed download URL environment variables cannot be exposed to commands: ${name}`
+        });
+      }
       if (!declaredSecrets.has(name)) {
         context.addIssue({
           code: exports_external.ZodIssueCode.custom,
@@ -78456,6 +78739,15 @@ var BenchmarkSpecSchema = exports_external.discriminatedUnion("phase", [
       });
     }
   }
+  const materials = value.phase === "hydrate" ? value.materials : value.references;
+  const archiveOutputBytes = materials.reduce((total, material) => total + (material.kind === "archive_file" ? material.file_size_bytes : 0), 0);
+  if (archiveOutputBytes > MAX_ARCHIVE_EXTRACTED_BYTES) {
+    context.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      path: [value.phase === "hydrate" ? "materials" : "references"],
+      message: "archive-file materials exceed the aggregate extracted byte limit"
+    });
+  }
   if (value.phase === "evaluate" && value.evaluators.filter((evaluator) => evaluator.type === "sandbox_command").length > 1) {
     context.addIssue({
       code: exports_external.ZodIssueCode.custom,
@@ -78469,6 +78761,10 @@ var BENCHMARK_CAPABILITIES = {
   cli_version: VERSION,
   schema_versions: [SCHEMA_VERSION],
   phases: ["hydrate", "evaluate"],
+  features: [
+    "remote_input_references_v1",
+    "archive_file_materials_v1"
+  ],
   evaluator_types: [
     "output_assertion",
     "trajectory_assertion",
@@ -78492,6 +78788,11 @@ class BenchmarkPhaseError extends Error {
     this.name = "BenchmarkPhaseError";
   }
 }
+var ZIP_EOCD_SIGNATURE = 101010256;
+var ZIP_CENTRAL_SIGNATURE = 33639248;
+var ZIP_LOCAL_SIGNATURE = 67324752;
+var MAX_ZIP_EOCD_BYTES = 65535 + 22;
+var MAX_ARCHIVE_MEMBERS = 1e5;
 function nowIso() {
   return new Date().toISOString();
 }
@@ -78754,10 +79055,516 @@ async function verifyInput(stagingRoot, material) {
     if (actual !== material.sha256) {
       throw new BenchmarkPhaseError("digest_mismatch", `checksum mismatch for ${material.source}`, { expected: material.sha256, actual });
     }
+    return {
+      source,
+      sha256: actual,
+      size: opened.stat.size,
+      mode: opened.stat.mode & 511
+    };
   } finally {
     fs81.closeSync(opened.fd);
   }
-  return source;
+}
+function inputCacheKey(input) {
+  return [
+    input.source,
+    input.sha256,
+    input.size_bytes
+  ].join(":");
+}
+async function cachedVerifiedInput(stagingRoot, input, context) {
+  const cacheKey = inputCacheKey(input);
+  const cached2 = context.verifiedInputs.get(cacheKey);
+  if (cached2)
+    return cached2;
+  const verified = await verifyInput(stagingRoot, input);
+  context.verifiedInputs.set(cacheKey, verified);
+  return verified;
+}
+function stagedInputRecord(stagingRoot, verified) {
+  return {
+    root: "staging",
+    path: path88.relative(stagingRoot, verified.source).replace(/\\/g, "/"),
+    sha256: verified.sha256,
+    size: verified.size,
+    mode: verified.mode,
+    kind: "file"
+  };
+}
+function remoteUrlEnvironmentNames(spec) {
+  const inputs = spec.phase === "hydrate" ? spec.materials : [
+    spec.evidence.final_output,
+    spec.evidence.trajectory,
+    ...spec.references
+  ];
+  return new Set(inputs.flatMap((input) => input.download_url_env ? [input.download_url_env] : []));
+}
+function removeRemoteHydrationInputs(spec) {
+  const removedSources = new Set;
+  for (const material of spec.materials) {
+    if (!material.download_url_env || removedSources.has(material.source))
+      continue;
+    const relative = safeRelPath(material.source);
+    const source = path88.resolve(spec.staging_root, relative);
+    if (!isWithin(spec.staging_root, source)) {
+      throw new BenchmarkPhaseError("unsafe_path", `source escapes staging root: ${material.source}`);
+    }
+    assertNoSymlinkTraversal(spec.staging_root, relative);
+    try {
+      fs81.rmSync(source, { force: true });
+    } catch {
+      throw new BenchmarkPhaseError("staging_cleanup_failed", `downloaded benchmark input could not be removed: ${material.source}`);
+    }
+    removedSources.add(material.source);
+  }
+}
+async function downloadInputReference(stagingRoot, input, context) {
+  const cacheKey = inputCacheKey(input);
+  const cached2 = context.verifiedInputs.get(cacheKey);
+  if (cached2)
+    return cached2;
+  const envName = input.download_url_env;
+  if (!envName) {
+    return await cachedVerifiedInput(stagingRoot, input, context);
+  }
+  const relative = safeRelPath(input.source);
+  const destination = path88.resolve(stagingRoot, relative);
+  if (!isWithin(stagingRoot, destination)) {
+    throw new BenchmarkPhaseError("unsafe_path", `source escapes staging root: ${input.source}`);
+  }
+  assertNoSymlinkTraversal(stagingRoot, relative);
+  try {
+    fs81.lstatSync(destination);
+    return await cachedVerifiedInput(stagingRoot, input, context);
+  } catch (error2) {
+    if (error2.code !== "ENOENT")
+      throw error2;
+  }
+  const rawUrl = process.env[envName];
+  if (!rawUrl) {
+    throw new BenchmarkPhaseError("missing_environment", `required signed download URL environment variable is missing: ${envName}`);
+  }
+  let url2;
+  try {
+    url2 = new URL(rawUrl);
+  } catch {
+    throw new BenchmarkPhaseError("invalid_download_url", `signed download URL environment variable is invalid: ${envName}`);
+  }
+  if (url2.protocol !== "https:" || url2.username || url2.password) {
+    throw new BenchmarkPhaseError("invalid_download_url", `signed download URL environment variable must contain an HTTPS URL without credentials: ${envName}`);
+  }
+  const remainingMs = context.deadline - Date.now();
+  if (remainingMs <= 0) {
+    throw new BenchmarkPhaseError("phase_timeout", "phase budget expired");
+  }
+  fs81.mkdirSync(path88.dirname(destination), { recursive: true, mode: 448 });
+  assertNoSymlinkTraversal(stagingRoot, relative);
+  assertWritableDestination(stagingRoot, relative);
+  const temporary = `${destination}.${process.pid}.${crypto6.randomBytes(6).toString("hex")}.download`;
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), remainingMs);
+  let descriptor;
+  try {
+    let response;
+    try {
+      response = await fetch(url2, {
+        redirect: "error",
+        signal: controller.signal
+      });
+    } catch {
+      if (controller.signal.aborted || Date.now() >= context.deadline) {
+        throw new BenchmarkPhaseError("phase_timeout", "phase budget expired");
+      }
+      throw new BenchmarkPhaseError("download_failed", `signed input download failed for ${input.source}`);
+    }
+    if (response.redirected || response.status >= 300 && response.status < 400) {
+      throw new BenchmarkPhaseError("download_redirect_rejected", `signed input download redirected for ${input.source}`);
+    }
+    if (!response.ok || !response.body) {
+      throw new BenchmarkPhaseError("download_failed", `signed input download failed for ${input.source}`, { status: response.status });
+    }
+    const declaredLength = response.headers.get("content-length");
+    if (declaredLength !== null && /^\d+$/.test(declaredLength) && Number(declaredLength) > input.size_bytes) {
+      throw new BenchmarkPhaseError("size_mismatch", `size mismatch for ${input.source}`, { expected: input.size_bytes, actual: Number(declaredLength) });
+    }
+    descriptor = fs81.openSync(temporary, "wx", 384);
+    const reader = response.body.getReader();
+    let actual;
+    let size2 = 0;
+    try {
+      const hash = crypto6.createHash("sha256");
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        assertBudget(context);
+        size2 += value.byteLength;
+        if (size2 > input.size_bytes) {
+          throw new BenchmarkPhaseError("size_mismatch", `size mismatch for ${input.source}`, { expected: input.size_bytes, actual: size2 });
+        }
+        hash.update(value);
+        let offset = 0;
+        while (offset < value.byteLength) {
+          offset += fs81.writeSync(descriptor, value, offset, value.byteLength - offset);
+        }
+      }
+      actual = hash.digest("hex");
+    } finally {
+      try {
+        await reader.cancel();
+      } catch {}
+    }
+    if (size2 !== input.size_bytes) {
+      throw new BenchmarkPhaseError("size_mismatch", `size mismatch for ${input.source}`, { expected: input.size_bytes, actual: size2 });
+    }
+    if (actual !== input.sha256) {
+      throw new BenchmarkPhaseError("digest_mismatch", `checksum mismatch for ${input.source}`, { expected: input.sha256, actual });
+    }
+    fs81.fsyncSync(descriptor);
+    fs81.closeSync(descriptor);
+    descriptor = undefined;
+    assertNoSymlinkTraversal(stagingRoot, relative);
+    if (fs81.existsSync(destination)) {
+      return await cachedVerifiedInput(stagingRoot, input, context);
+    }
+    fs81.renameSync(temporary, destination);
+    return await cachedVerifiedInput(stagingRoot, input, context);
+  } catch (error2) {
+    if (!(error2 instanceof BenchmarkPhaseError) && (controller.signal.aborted || Date.now() >= context.deadline)) {
+      throw new BenchmarkPhaseError("phase_timeout", "phase budget expired");
+    }
+    if (error2 instanceof BenchmarkPhaseError)
+      throw error2;
+    throw new BenchmarkPhaseError("download_failed", `signed input download failed for ${input.source}`);
+  } finally {
+    clearTimeout(timer);
+    controller.abort();
+    if (descriptor !== undefined)
+      fs81.closeSync(descriptor);
+    fs81.rmSync(temporary, { force: true });
+  }
+}
+function readExactly(descriptor, length, position) {
+  const buffer = Buffer.alloc(length);
+  let offset = 0;
+  while (offset < length) {
+    const count = fs81.readSync(descriptor, buffer, offset, length - offset, position + offset);
+    if (count === 0) {
+      throw new BenchmarkPhaseError("invalid_archive", "archive ended unexpectedly");
+    }
+    offset += count;
+  }
+  return buffer;
+}
+function decodeZipPath(value, utf8) {
+  if (!utf8 && value.some((byte) => byte >= 128)) {
+    throw new BenchmarkPhaseError("invalid_archive", "ZIP members with non-UTF-8 names are unsupported");
+  }
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(value);
+  } catch {
+    throw new BenchmarkPhaseError("invalid_archive", "ZIP member name is not valid UTF-8");
+  }
+}
+function findZipMembers(archivePath, requested, context) {
+  const descriptor = fs81.openSync(archivePath, "r");
+  try {
+    assertBudget(context);
+    const archiveSize = fs81.fstatSync(descriptor).size;
+    const tailSize = Math.min(archiveSize, MAX_ZIP_EOCD_BYTES);
+    const tailOffset = archiveSize - tailSize;
+    const tail2 = readExactly(descriptor, tailSize, tailOffset);
+    let eocdOffset = -1;
+    for (let offset2 = tail2.length - 22;offset2 >= 0; offset2 -= 1) {
+      assertBudget(context);
+      if (tail2.readUInt32LE(offset2) === ZIP_EOCD_SIGNATURE) {
+        const commentLength = tail2.readUInt16LE(offset2 + 20);
+        if (offset2 + 22 + commentLength === tail2.length) {
+          eocdOffset = offset2;
+          break;
+        }
+      }
+    }
+    if (eocdOffset < 0) {
+      throw new BenchmarkPhaseError("invalid_archive", "invalid ZIP archive");
+    }
+    const diskNumber = tail2.readUInt16LE(eocdOffset + 4);
+    const directoryDisk = tail2.readUInt16LE(eocdOffset + 6);
+    const diskEntries = tail2.readUInt16LE(eocdOffset + 8);
+    const totalEntries = tail2.readUInt16LE(eocdOffset + 10);
+    const directorySize = tail2.readUInt32LE(eocdOffset + 12);
+    const directoryOffset = tail2.readUInt32LE(eocdOffset + 16);
+    if (diskNumber !== 0 || directoryDisk !== 0 || diskEntries !== totalEntries) {
+      throw new BenchmarkPhaseError("invalid_archive", "multi-disk ZIP archives are unsupported");
+    }
+    if (totalEntries === 65535 || directorySize === 4294967295 || directoryOffset === 4294967295) {
+      throw new BenchmarkPhaseError("invalid_archive", "ZIP64 archives are unsupported");
+    }
+    if (totalEntries > MAX_ARCHIVE_MEMBERS || directoryOffset + directorySize > tailOffset + eocdOffset) {
+      throw new BenchmarkPhaseError("invalid_archive", "ZIP central directory is invalid");
+    }
+    let offset = directoryOffset;
+    const found = new Map;
+    for (let index = 0;index < totalEntries; index += 1) {
+      assertBudget(context);
+      const header = readExactly(descriptor, 46, offset);
+      if (header.readUInt32LE(0) !== ZIP_CENTRAL_SIGNATURE) {
+        throw new BenchmarkPhaseError("invalid_archive", "ZIP central directory is invalid");
+      }
+      const flags = header.readUInt16LE(8);
+      const compressionMethod = header.readUInt16LE(10);
+      const compressedSize = header.readUInt32LE(20);
+      const uncompressedSize = header.readUInt32LE(24);
+      const nameLength = header.readUInt16LE(28);
+      const extraLength = header.readUInt16LE(30);
+      const commentLength = header.readUInt16LE(32);
+      const diskStart = header.readUInt16LE(34);
+      const externalAttributes = header.readUInt32LE(38);
+      const localHeaderOffset = header.readUInt32LE(42);
+      const recordSize = 46 + nameLength + extraLength + commentLength;
+      if (offset + recordSize > directoryOffset + directorySize || compressedSize === 4294967295 || uncompressedSize === 4294967295 || localHeaderOffset === 4294967295 || diskStart !== 0) {
+        throw new BenchmarkPhaseError("invalid_archive", "ZIP member metadata is invalid");
+      }
+      const name = decodeZipPath(readExactly(descriptor, nameLength, offset + 46), (flags & 2048) !== 0);
+      const material = requested.get(name);
+      if (material) {
+        if (found.has(name)) {
+          throw new BenchmarkPhaseError("invalid_archive", `archive member is duplicated: ${name}`);
+        }
+        const madeBy = header.readUInt16LE(4) >> 8;
+        const unixMode = externalAttributes >>> 16;
+        const fileType = unixMode & 61440;
+        if (name.endsWith("/") || (externalAttributes & 16) !== 0 || madeBy === 3 && fileType !== 0 && fileType !== 32768) {
+          throw new BenchmarkPhaseError("invalid_archive", `archive member must be a regular file: ${name}`);
+        }
+        if ((flags & 1) !== 0 || compressionMethod !== 0 && compressionMethod !== 8) {
+          throw new BenchmarkPhaseError("invalid_archive", `archive member uses unsupported ZIP features: ${name}`);
+        }
+        if (uncompressedSize !== material.file_size_bytes) {
+          throw new BenchmarkPhaseError("size_mismatch", `size mismatch for archive member ${name}`, { expected: material.file_size_bytes, actual: uncompressedSize });
+        }
+        const localHeader = readExactly(descriptor, 30, localHeaderOffset);
+        if (localHeader.readUInt32LE(0) !== ZIP_LOCAL_SIGNATURE || localHeader.readUInt16LE(6) !== flags || localHeader.readUInt16LE(8) !== compressionMethod) {
+          throw new BenchmarkPhaseError("invalid_archive", "ZIP local header is invalid");
+        }
+        const localNameLength = localHeader.readUInt16LE(26);
+        const localExtraLength = localHeader.readUInt16LE(28);
+        const localName = decodeZipPath(readExactly(descriptor, localNameLength, localHeaderOffset + 30), (flags & 2048) !== 0);
+        const dataOffset = localHeaderOffset + 30 + localNameLength + localExtraLength;
+        if (localName !== name || dataOffset + compressedSize > directoryOffset) {
+          throw new BenchmarkPhaseError("invalid_archive", "ZIP member bounds are invalid");
+        }
+        found.set(name, {
+          compressionMethod,
+          compressedSize,
+          dataOffset
+        });
+      }
+      offset += recordSize;
+    }
+    if (offset !== directoryOffset + directorySize) {
+      throw new BenchmarkPhaseError("invalid_archive", "ZIP central directory is invalid");
+    }
+    for (const memberPath of requested.keys()) {
+      if (!found.has(memberPath)) {
+        throw new BenchmarkPhaseError("missing_input", `archive member does not exist: ${memberPath}`);
+      }
+    }
+    return found;
+  } finally {
+    fs81.closeSync(descriptor);
+  }
+}
+async function writeVerifiedArchiveMember(source, destination, material, context) {
+  fs81.mkdirSync(path88.dirname(destination), { recursive: true, mode: 448 });
+  const temporary = `${destination}.${process.pid}.${crypto6.randomBytes(6).toString("hex")}.tmp`;
+  const descriptor = fs81.openSync(temporary, "wx", 384);
+  const hash = crypto6.createHash("sha256");
+  let size2 = 0;
+  try {
+    for await (const value of source) {
+      assertBudget(context);
+      const chunk2 = Buffer.isBuffer(value) ? value : Buffer.from(value);
+      size2 += chunk2.length;
+      if (size2 > material.file_size_bytes) {
+        throw new BenchmarkPhaseError("size_mismatch", `size mismatch for archive member ${material.archive_path}`, { expected: material.file_size_bytes, actual: size2 });
+      }
+      hash.update(chunk2);
+      let offset = 0;
+      while (offset < chunk2.length) {
+        offset += fs81.writeSync(descriptor, chunk2, offset, chunk2.length - offset);
+      }
+    }
+    if (size2 !== material.file_size_bytes) {
+      throw new BenchmarkPhaseError("size_mismatch", `size mismatch for archive member ${material.archive_path}`, { expected: material.file_size_bytes, actual: size2 });
+    }
+    const actual = hash.digest("hex");
+    if (actual !== material.file_sha256) {
+      throw new BenchmarkPhaseError("digest_mismatch", `checksum mismatch for archive member ${material.archive_path}`, { expected: material.file_sha256, actual });
+    }
+    fs81.fsyncSync(descriptor);
+    fs81.closeSync(descriptor);
+    fs81.renameSync(temporary, destination);
+  } catch (error2) {
+    if (error2 instanceof BenchmarkPhaseError)
+      throw error2;
+    throw new BenchmarkPhaseError("invalid_archive", `archive member could not be extracted: ${material.archive_path}`);
+  } finally {
+    try {
+      fs81.closeSync(descriptor);
+    } catch {}
+    fs81.rmSync(temporary, { force: true });
+  }
+}
+function isZipArchive(archivePath) {
+  const descriptor = fs81.openSync(archivePath, "r");
+  try {
+    const header = Buffer.alloc(4);
+    return fs81.readSync(descriptor, header, 0, header.length, 0) === header.length && [
+      ZIP_LOCAL_SIGNATURE,
+      ZIP_EOCD_SIGNATURE,
+      134695760
+    ].includes(header.readUInt32LE(0));
+  } finally {
+    fs81.closeSync(descriptor);
+  }
+}
+function isGzipArchive(archivePath) {
+  const descriptor = fs81.openSync(archivePath, "r");
+  try {
+    const header = Buffer.alloc(2);
+    return fs81.readSync(descriptor, header, 0, header.length, 0) === header.length && header[0] === 31 && header[1] === 139;
+  } finally {
+    fs81.closeSync(descriptor);
+  }
+}
+function archiveSourceCacheKey(material) {
+  return [
+    material.source,
+    material.sha256,
+    material.size_bytes,
+    material.download_url_env ?? ""
+  ].join("\x00");
+}
+function archiveMemberCacheKey(material) {
+  return [
+    archiveSourceCacheKey(material),
+    material.archive_path,
+    material.file_sha256,
+    material.file_size_bytes
+  ].join("\x00");
+}
+function archiveScanBudget(context) {
+  let scanned = 0;
+  return new Transform2({
+    transform(chunk2, _encoding, callback) {
+      try {
+        assertBudget(context);
+        scanned += chunk2.length;
+        if (scanned > MAX_ARCHIVE_SCAN_BYTES) {
+          throw new BenchmarkPhaseError("invalid_archive", "archive expands beyond the supported scan limit");
+        }
+        callback(null, chunk2);
+      } catch (error2) {
+        callback(error2);
+      }
+    }
+  });
+}
+async function extractArchiveMembers(archivePath, outputRoot, materials, context) {
+  const requested = new Map;
+  for (const material of materials) {
+    let memberPath;
+    try {
+      memberPath = safeRelPath(material.archive_path);
+    } catch {
+      throw new BenchmarkPhaseError("unsafe_path", "archive member path is unsafe");
+    }
+    const existing = requested.get(memberPath);
+    if (existing && (existing.file_sha256 !== material.file_sha256 || existing.file_size_bytes !== material.file_size_bytes)) {
+      throw new BenchmarkPhaseError("invalid_archive", `archive member has conflicting declarations: ${memberPath}`);
+    }
+    requested.set(memberPath, material);
+  }
+  const extracted = new Map;
+  if (isZipArchive(archivePath)) {
+    const indexed = findZipMembers(archivePath, requested, context);
+    for (const [memberPath, material] of requested) {
+      assertBudget(context);
+      const destination = path88.resolve(outputRoot, memberPath);
+      if (!isWithin(outputRoot, destination)) {
+        throw new BenchmarkPhaseError("unsafe_path", `archive member escapes output root: ${memberPath}`);
+      }
+      const member = indexed.get(memberPath);
+      const compressed = member.compressedSize === 0 ? Readable.from([]) : fs81.createReadStream(archivePath, {
+        start: member.dataOffset,
+        end: member.dataOffset + member.compressedSize - 1
+      });
+      const contents = member.compressionMethod === 8 ? compressed.pipe(createInflateRaw()) : compressed;
+      await writeVerifiedArchiveMember(contents, destination, material, context);
+      extracted.set(memberPath, destination);
+    }
+    return extracted;
+  }
+  const matches2 = new Map;
+  let validationError;
+  const unpack = co({
+    cwd: outputRoot,
+    strict: true,
+    preserveOwner: false,
+    filter: (entryPath, entryAny) => {
+      assertBudget(context);
+      const material = requested.get(entryPath);
+      if (!material)
+        return false;
+      const count = (matches2.get(entryPath) ?? 0) + 1;
+      matches2.set(entryPath, count);
+      const entry = entryAny;
+      if (count > 1) {
+        validationError = new BenchmarkPhaseError("invalid_archive", `archive member is duplicated: ${entryPath}`);
+        return false;
+      }
+      if (!["File", "OldFile", "ContiguousFile"].includes(entry.type)) {
+        validationError = new BenchmarkPhaseError("invalid_archive", `archive member must be a regular file: ${entryPath}`);
+        return false;
+      }
+      if (entry.size !== material.file_size_bytes) {
+        validationError = new BenchmarkPhaseError("size_mismatch", `size mismatch for archive member ${entryPath}`, { expected: material.file_size_bytes, actual: entry.size });
+        return false;
+      }
+      return true;
+    }
+  });
+  const archive = fs81.createReadStream(archivePath);
+  const scanBudget = archiveScanBudget(context);
+  try {
+    if (isGzipArchive(archivePath)) {
+      await pipeline2(archive, createGunzip(), scanBudget, unpack);
+    } else {
+      await pipeline2(archive, scanBudget, unpack);
+    }
+  } catch (error2) {
+    if (validationError)
+      throw validationError;
+    if (error2 instanceof BenchmarkPhaseError)
+      throw error2;
+    throw new BenchmarkPhaseError("invalid_archive", "archive members could not be extracted");
+  }
+  if (validationError)
+    throw validationError;
+  for (const [memberPath, material] of requested) {
+    if (!matches2.has(memberPath)) {
+      throw new BenchmarkPhaseError("missing_input", `archive member does not exist: ${memberPath}`);
+    }
+    const verified = await verifyInput(outputRoot, {
+      source: memberPath,
+      sha256: material.file_sha256,
+      size_bytes: material.file_size_bytes
+    });
+    assertBudget(context);
+    extracted.set(memberPath, verified.source);
+  }
+  return extracted;
 }
 async function atomicCopy(source, destination, mode, sourceRoot) {
   fs81.mkdirSync(path88.dirname(destination), { recursive: true });
@@ -78806,21 +79613,31 @@ async function recordFile(root, filePath, rootName, kind = "file") {
     fs81.closeSync(opened.fd);
   }
 }
-async function copyMaterial(material, sourceRoot, destinationRoot, destinationRootName, protectWorkspace) {
-  const source = await verifyInput(sourceRoot, material);
+async function copyMaterial(material, sourceRoot, destinationRoot, destinationRootName, protectWorkspace, context) {
+  const verifiedSource = material.kind === "archive_file" ? undefined : await cachedVerifiedInput(sourceRoot, material, context);
+  const source = material.kind === "archive_file" ? context.preparedArchiveFiles.get(archiveMemberCacheKey(material)) : verifiedSource?.source;
+  if (!source) {
+    throw new BenchmarkPhaseError("invalid_archive", `archive member was not prepared: ${material.id}`);
+  }
   const destinationRel = protectWorkspace ? workspaceRel(material.destination, material.kind === "tar_gz") : normalizedRootRelative(material.destination);
   if (!protectWorkspace && destinationRel.toLowerCase() === ".brainbase-benchmark-owner.json") {
     throw new BenchmarkPhaseError("reserved_path", "benchmark input cannot replace the phase ownership marker");
   }
-  if (material.kind === "file") {
+  if (material.kind === "file" || material.kind === "archive_file") {
     if (destinationRel === ".") {
       throw new BenchmarkPhaseError("unsafe_path", "file destination cannot be a directory root");
     }
     assertWritableDestination(destinationRoot, destinationRel);
     const destination = path88.resolve(destinationRoot, destinationRel);
-    await atomicCopy(source, destination, material.mode, sourceRoot);
+    if (material.kind === "file") {
+      await atomicCopy(source, destination, material.mode ?? verifiedSource?.mode, sourceRoot);
+    } else {
+      await atomicCopy(source, destination, material.mode, path88.dirname(source));
+    }
     const record3 = await recordFile(destinationRoot, destination, destinationRootName);
-    if (record3.sha256 !== material.sha256 || record3.size !== material.size_bytes) {
+    const expectedSha256 = material.kind === "archive_file" ? material.file_sha256 : material.sha256;
+    const expectedSize = material.kind === "archive_file" ? material.file_size_bytes : material.size_bytes;
+    if (record3.sha256 !== expectedSha256 || record3.size !== expectedSize) {
       throw new BenchmarkPhaseError("evidence_tampered", `material changed while it was copied: ${material.source}`);
     }
     return [record3];
@@ -78861,17 +79678,39 @@ async function copyMaterial(material, sourceRoot, destinationRoot, destinationRo
     fs81.rmSync(temporary, { recursive: true, force: true });
   }
 }
-async function preflightMaterial(material, sourceRoot, destinationRoot, protectWorkspace) {
-  const source = await verifyInput(sourceRoot, material);
+async function preflightMaterial(material, materials, sourceRoot, destinationRoot, protectWorkspace, context) {
+  const source = (await cachedVerifiedInput(sourceRoot, material, context)).source;
   const destinationRel = protectWorkspace ? workspaceRel(material.destination, material.kind === "tar_gz") : normalizedRootRelative(material.destination);
   if (!protectWorkspace && destinationRel.toLowerCase() === ".brainbase-benchmark-owner.json") {
     throw new BenchmarkPhaseError("reserved_path", "benchmark input cannot replace the phase ownership marker");
   }
-  if (material.kind === "file") {
+  if (material.kind === "file" || material.kind === "archive_file") {
     if (destinationRel === ".") {
       throw new BenchmarkPhaseError("unsafe_path", "file destination cannot be a directory root");
     }
     assertWritableDestination(destinationRoot, destinationRel);
+    if (material.kind === "archive_file") {
+      const cacheKey = archiveMemberCacheKey(material);
+      let extracted = context.preparedArchiveFiles.get(cacheKey);
+      if (!extracted) {
+        const temporary2 = fs81.mkdtempSync(path88.join(os16.tmpdir(), "brainbase-benchmark-member-"));
+        context.temporaryRoots.add(temporary2);
+        const archiveKey = archiveSourceCacheKey(material);
+        const related = materials.filter((candidate) => candidate.kind === "archive_file" && archiveSourceCacheKey(candidate) === archiveKey);
+        const extractedMembers = await extractArchiveMembers(source, temporary2, related, context);
+        for (const candidate of related) {
+          const prepared = extractedMembers.get(safeRelPath(candidate.archive_path));
+          if (!prepared) {
+            throw new BenchmarkPhaseError("missing_input", `archive member does not exist: ${candidate.archive_path}`);
+          }
+          context.preparedArchiveFiles.set(archiveMemberCacheKey(candidate), prepared);
+        }
+        extracted = context.preparedArchiveFiles.get(cacheKey);
+      }
+      if (!extracted) {
+        throw new BenchmarkPhaseError("missing_input", `archive member does not exist: ${material.archive_path}`);
+      }
+    }
     return [destinationRel];
   }
   const temporary = fs81.mkdtempSync(path88.join(os16.tmpdir(), "brainbase-benchmark-preflight-"));
@@ -78939,14 +79778,18 @@ function prepareOwnedDirectory(root, role, spec) {
 }
 function buildEnvironment(spec, secretNames, additions = {}) {
   const env3 = {};
+  const remoteUrlEnvNames = remoteUrlEnvironmentNames(spec);
   for (const name of BASE_ENV_NAMES) {
-    if (process.env[name] !== undefined)
+    if (!remoteUrlEnvNames.has(name) && process.env[name] !== undefined) {
       env3[name] = process.env[name];
+    }
   }
   for (const [name, declared] of Object.entries(spec.environment)) {
     env3[name] = declared.value;
   }
   for (const name of secretNames) {
+    if (remoteUrlEnvNames.has(name))
+      continue;
     const value = process.env[name];
     if (value === undefined) {
       throw new BenchmarkPhaseError("missing_environment", `required environment variable is missing: ${name}`);
@@ -78958,7 +79801,11 @@ function buildEnvironment(spec, secretNames, additions = {}) {
 }
 function redactCommandOutput(data, spec) {
   let value = data.toString("utf8");
-  for (const name of spec.secret_env) {
+  const sensitiveNames = new Set([
+    ...spec.secret_env,
+    ...remoteUrlEnvironmentNames(spec)
+  ]);
+  for (const name of sensitiveNames) {
     const secret = process.env[name];
     if (secret)
       value = value.split(secret).join("[REDACTED]");
@@ -79128,16 +79975,19 @@ async function executeHydrate(spec, context) {
   const plannedDestinations = [];
   for (const material of spec.materials) {
     assertBudget(context);
-    plannedDestinations.push(...await preflightMaterial(material, spec.staging_root, spec.workspace_root, true));
-    const source = await verifyInput(spec.staging_root, material);
-    context.inputs.push(await recordFile(spec.staging_root, source, "staging"));
+    const verified = await downloadInputReference(spec.staging_root, material, context);
+    plannedDestinations.push(...await preflightMaterial(material, spec.materials, spec.staging_root, spec.workspace_root, true, context));
+    const record3 = stagedInputRecord(spec.staging_root, verified);
+    if (!context.inputs.some((input) => input.path === record3.path && input.sha256 === record3.sha256 && input.size === record3.size)) {
+      context.inputs.push(record3);
+    }
   }
   validateDestinationGraph(plannedDestinations);
   for (const material of spec.materials) {
     assertBudget(context);
     const started = Date.now();
     try {
-      const records = await copyMaterial(material, spec.staging_root, spec.workspace_root, "workspace", true);
+      const records = await copyMaterial(material, spec.staging_root, spec.workspace_root, "workspace", true, context);
       outputs.push(...records);
       context.outputs.push(...records);
       context.steps.push({
@@ -79211,6 +80061,7 @@ async function executeHydrate(spec, context) {
   }
   outputs.splice(0, outputs.length, ...finalOutputs);
   context.outputs.splice(0, context.outputs.length, ...finalOutputs);
+  removeRemoteHydrationInputs(spec);
   assertBudget(context);
   return outputs;
 }
@@ -79416,6 +80267,8 @@ async function evaluateOne(evaluator, spec, finalOutput, trajectory, frozenEvide
   };
 }
 async function executeEvaluate(spec, context) {
+  await downloadInputReference(spec.staging_root, spec.evidence.final_output, context);
+  await downloadInputReference(spec.staging_root, spec.evidence.trajectory, context);
   const finalOutput = await readEvidence(spec.staging_root, spec.evidence.final_output);
   const trajectoryEvidence = await readEvidence(spec.staging_root, spec.evidence.trajectory);
   context.inputs.push(finalOutput.record, trajectoryEvidence.record);
@@ -79429,9 +80282,12 @@ async function executeEvaluate(spec, context) {
   const plannedReferences = [];
   for (const reference of spec.references) {
     assertBudget(context);
-    plannedReferences.push(...await preflightMaterial(reference, spec.staging_root, spec.tests_root, false));
-    const source = await verifyInput(spec.staging_root, reference);
-    context.inputs.push(await recordFile(spec.staging_root, source, "staging"));
+    const verified = await downloadInputReference(spec.staging_root, reference, context);
+    plannedReferences.push(...await preflightMaterial(reference, spec.references, spec.staging_root, spec.tests_root, false, context));
+    const record3 = stagedInputRecord(spec.staging_root, verified);
+    if (!context.inputs.some((input) => input.path === record3.path && input.sha256 === record3.sha256 && input.size === record3.size)) {
+      context.inputs.push(record3);
+    }
   }
   validateDestinationGraph(plannedReferences);
   assertBudget(context);
@@ -79496,7 +80352,7 @@ async function executeEvaluate(spec, context) {
   }
   await verifyRecordsUnchanged(manifest, spec);
   for (const reference of spec.references) {
-    const referenceOutputs = await copyMaterial(reference, spec.staging_root, spec.tests_root, "tests", false);
+    const referenceOutputs = await copyMaterial(reference, spec.staging_root, spec.tests_root, "tests", false, context);
     outputs.push(...referenceOutputs);
     context.outputs.push(...referenceOutputs);
   }
@@ -79646,19 +80502,26 @@ function prepareBenchmarkPhaseInvocation(specPathInput, resultPathInput, expecte
       spec_digest: digest,
       timeout_ms: spec.budget.timeout_ms
     };
+    let cachedResult;
     if (fs81.existsSync(resultPath)) {
       try {
         const cached2 = JSON.parse(fs81.readFileSync(resultPath, "utf8"));
         if (cached2.schema_version === SCHEMA_VERSION && cached2.phase === spec.phase && cached2.attempt_id === spec.attempt_id && cached2.phase_id === spec.phase_id && cached2.spec_digest === digest && cached2.status === "succeeded") {
-          return {
-            ok: true,
-            invocation,
-            spec_bytes: bytes,
-            cached_result: cached2
-          };
+          cachedResult = cached2;
         }
       } catch {}
     }
+    if (cachedResult) {
+      if (spec.phase === "hydrate") {
+        removeRemoteHydrationInputs(spec);
+      }
+      return {
+        ok: true,
+        invocation,
+        spec_bytes: bytes,
+        cached_result: cachedResult
+      };
+    }
     return { ok: true, invocation, spec_bytes: bytes };
   } catch (error2) {
     return {
@@ -79755,14 +80618,21 @@ async function runBenchmarkPhase(specPathInput, resultPathInput, expectedPhase,
       throw new BenchmarkPhaseError("invalid_result_path", `result path must be ${expectedResultPath}`);
     }
     resultPathValidated = true;
+    let cachedResult;
     if (fs81.existsSync(resultPath)) {
       try {
         const cached2 = JSON.parse(fs81.readFileSync(resultPath, "utf8"));
         if (cached2.schema_version === SCHEMA_VERSION && cached2.phase === spec.phase && cached2.attempt_id === spec.attempt_id && cached2.phase_id === spec.phase_id && cached2.spec_digest === digest && cached2.status === "succeeded") {
-          return { exitCode: 0, result: cached2 };
+          cachedResult = cached2;
         }
       } catch {}
     }
+    if (cachedResult) {
+      if (spec.phase === "hydrate") {
+        removeRemoteHydrationInputs(spec);
+      }
+      return { exitCode: 0, result: cachedResult };
+    }
     context = {
       deadline: started + spec.budget.timeout_ms,
       remainingOutputBytes: spec.budget.max_output_bytes,
@@ -79770,7 +80640,10 @@ async function runBenchmarkPhase(specPathInput, resultPathInput, expectedPhase,
       evaluators: [],
       inputs: [],
       outputs: [],
-      logsOwned: false
+      logsOwned: false,
+      verifiedInputs: new Map,
+      preparedArchiveFiles: new Map,
+      temporaryRoots: new Set
     };
     if (spec.phase === "hydrate") {
       outputs = await executeHydrate(spec, context);
@@ -79790,6 +80663,11 @@ async function runBenchmarkPhase(specPathInput, resultPathInput, expectedPhase,
         evaluators = context.evaluators;
     }
   }
+  if (context) {
+    for (const temporary of context.temporaryRoots) {
+      fs81.rmSync(temporary, { recursive: true, force: true });
+    }
+  }
   const result2 = {
     schema_version: SCHEMA_VERSION,
     cli_version: VERSION,
@@ -80201,7 +81079,7 @@ function help() {
   out.push("");
   out.push(`  ${import_picocolors52.default.cyan("login")}     ${import_picocolors52.default.dim("  open the web app and connect this device")}`);
   out.push(`  ${import_picocolors52.default.cyan("logout")}    ${import_picocolors52.default.dim("  clear the local session")}`);
-  out.push(`  ${import_picocolors52.default.cyan("whoami")}    ${import_picocolors52.default.dim("  show the current user")}`);
+  out.push(`  ${import_picocolors52.default.cyan("whoami")} ${import_picocolors52.default.dim("[--json]")} ${import_picocolors52.default.dim(" show which credential is in use and what it covers")}`);
   out.push("");
   out.push(divider("DISCOVERY"));
   out.push("");
@@ -80304,7 +81182,7 @@ function help() {
   out.push(`  ${import_picocolors52.default.dim("BRAINBASE_API_URL")}      legacy KLS host override (uses /api/cli; proxy/registry fallback)`);
   out.push(`  ${import_picocolors52.default.dim("BRAINBASE_PROXY_URL")}    override the model-proxy URL used by harness traffic (default https://api.v1.brainbaselabs.com)`);
   out.push(`  ${import_picocolors52.default.dim("BRAINBASE_REGISTRY_URL")} override the registry API URL (default https://api.v1.brainbaselabs.com)`);
-  out.push(`  ${import_picocolors52.default.dim("BRAINBASE_TOKEN")}        long-lived CLI PAT (overrides token.json)`);
+  out.push(`  ${import_picocolors52.default.dim("BRAINBASE_TOKEN")}        long-lived CLI PAT; the only PAT control-plane commands accept (token.json is not read there)`);
   out.push(`  ${import_picocolors52.default.dim("BRAINBASE_SKIP_AUTH")}    bypass the auth gate for development`);
   out.push(`  ${import_picocolors52.default.dim("BRAINBASE_NON_INTERACTIVE")} force non-interactive mode — skip/auto-default prompts (CI & agents)`);
   out.push(`  ${import_picocolors52.default.dim("BRAINBASE_RUN_ENTRYPOINT")} =1 → agent pull executes the agent entrypoint (sandbox boots; or pass --run-entrypoint)`);
@@ -80556,7 +81434,7 @@ async function main() {
         break;
       }
       case "whoami": {
-        await runWhoami();
+        await runWhoami({ json: jsonFlag });
         break;
       }
       case "template": {