@brainbase-labs/cli 0.19.1 → 0.20.0

package/dist/index.js

@@ -35141,9 +35141,9 @@ var require_dist2 = __commonJS((exports, module) => {
 });
 
 // src/index.ts
-var import_picocolors48 = __toESM(require_picocolors(), 1);
+var import_picocolors49 = __toESM(require_picocolors(), 1);
 import process14 from "node:process";
-import fs79 from "node:fs";
+import fs81 from "node:fs";
 
 // src/cli/template.ts
 var import_picocolors12 = __toESM(require_picocolors(), 1);
@@ -36008,7 +36008,7 @@ function padStart(s, n) {
 // package.json
 var package_default = {
   name: "@brainbase-labs/cli",
-  version: "0.19.1",
+  version: "0.20.0",
   description: "Pack, share, and install agent templates across harnesses (Claude Code, Codex, ...).",
   type: "module",
   bin: {
@@ -58081,45 +58081,59 @@ async function extract(opts) {
   const maxCount = opts.maxFileCount ?? MAX_FILE_COUNT;
   const maxRatio = opts.maxRatio ?? 100;
   let totalBytes = 0;
-  let fileCount = 0;
+  let entryCount = 0;
   const written = [];
+  let filterError;
   await co({
     file: opts.tarFile,
     cwd: out,
     strict: true,
     filter: (entryPath, entryAny) => {
-      const entry = entryAny;
-      const t = entry.type;
-      if (t !== "File" && t !== "OldFile" && t !== "ContiguousFile" && t !== "Directory" && t !== "GNUDumpDir") {
-        throw new TarballError(`refusing entry type "${t}" for ${entryPath}`);
-      }
       try {
-        safeRelPath(entryPath);
-      } catch (err) {
-        throw new TarballError(err.message);
-      }
-      const size2 = entry.size ?? 0;
-      if (size2 > maxBytes) {
-        throw new TarballError(`entry ${entryPath} size ${size2} exceeds cap ${maxBytes}`);
-      }
-      if (t === "Directory" || t === "GNUDumpDir")
+        if (filterError)
+          return false;
+        const entry = entryAny;
+        const t = entry.type;
+        if (t !== "File" && t !== "OldFile" && t !== "ContiguousFile" && t !== "Directory" && t !== "GNUDumpDir") {
+          throw new TarballError(`refusing entry type "${t}" for ${entryPath}`);
+        }
+        let normalizedPath;
+        try {
+          normalizedPath = safeRelPath(entryPath);
+        } catch (err) {
+          throw new TarballError(err.message);
+        }
+        if (normalizedPath.split("/").length > 64) {
+          throw new TarballError(`entry path exceeds 64 segments: ${entryPath}`);
+        }
+        const size2 = entry.size ?? 0;
+        if (size2 > maxBytes) {
+          throw new TarballError(`entry ${entryPath} size ${size2} exceeds cap ${maxBytes}`);
+        }
+        entryCount++;
+        if (entryCount > maxCount) {
+          throw new TarballError(`too many entries (>${maxCount})`);
+        }
+        if (t === "Directory" || t === "GNUDumpDir")
+          return true;
+        totalBytes += size2;
+        if (totalBytes > maxBytes) {
+          throw new TarballError(`total uncompressed bytes ${totalBytes} exceeds cap ${maxBytes}`);
+        }
+        if (totalBytes > compressed * maxRatio) {
+          throw new TarballError(`decompression ratio exceeds ${maxRatio}× (${totalBytes}B from ${compressed}B)`);
+        }
+        written.push(entryPath);
         return true;
-      fileCount++;
-      if (fileCount > maxCount) {
-        throw new TarballError(`too many entries (>${maxCount})`);
-      }
-      totalBytes += size2;
-      if (totalBytes > maxBytes) {
-        throw new TarballError(`total uncompressed bytes ${totalBytes} exceeds cap ${maxBytes}`);
-      }
-      if (totalBytes > compressed * maxRatio) {
-        throw new TarballError(`decompression ratio exceeds ${maxRatio}× (${totalBytes}B from ${compressed}B)`);
+      } catch (error) {
+        filterError = error instanceof TarballError ? error : new TarballError(error instanceof Error ? error.message : "invalid archive entry");
+        return false;
       }
-      written.push(entryPath);
-      return true;
     },
     preserveOwner: false
   });
+  if (filterError)
+    throw filterError;
   return written;
 }
 async function sha256OfFile(filePath) {
@@ -77030,6 +77044,1934 @@ function printHelp4() {
 `));
 }
 
+// src/cli/benchmark.ts
+var import_picocolors48 = __toESM(require_picocolors(), 1);
+import {
+  execFileSync as execFileSync3,
+  spawn as spawn5
+} from "node:child_process";
+import crypto7 from "node:crypto";
+import fs80 from "node:fs";
+import os17 from "node:os";
+import path88 from "node:path";
+
+// src/core/benchmark-phase.ts
+import {
+  execFileSync as execFileSync2,
+  spawn as spawn4
+} from "node:child_process";
+import crypto6 from "node:crypto";
+import fs79 from "node:fs";
+import os16 from "node:os";
+import path87 from "node:path";
+import { pipeline as pipeline2 } from "node:stream/promises";
+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}$/;
+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 RESERVED_WORKSPACE_PATHS = new Set([
+  ".brainbase",
+  ".git",
+  "brainbase.agent.yaml"
+]);
+var BASE_ENV_NAMES = [
+  "HOME",
+  "LANG",
+  "LC_ALL",
+  "LOGNAME",
+  "PATH",
+  "SHELL",
+  "TMPDIR",
+  "USER"
+];
+var SENSITIVE_ENV_NAME_RE = /(?:^|_)(?:TOKEN|SECRET|PASSWORD|PASSWD|API_KEY|PRIVATE_KEY|ACCESS_KEY|PAT|CREDENTIAL)(?:$|_)|^(?:PGPASSWORD|DATABASE_URL|REDIS_URL|MONGODB_URI)$/i;
+var AbsolutePathSchema = exports_external.string().min(1).refine(path87.isAbsolute, {
+  message: "must be an absolute path"
+});
+var Sha256Schema = exports_external.string().regex(SHA256_RE).transform((value) => value.toLowerCase());
+var IdSchema = exports_external.string().regex(ID_RE);
+var EnvNameSchema = exports_external.string().regex(ENV_NAME_RE);
+var NonSecretEnvironmentValueSchema = exports_external.object({
+  value: exports_external.string(),
+  sensitive: exports_external.literal(false)
+}).strict();
+var RootRelativePathSchema = exports_external.string().min(1).max(1024);
+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({
+  id: IdSchema,
+  kind: exports_external.enum(["file", "tar_gz"]),
+  source: RootRelativePathSchema,
+  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(),
+  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 CommandSchema = exports_external.object({
+  id: IdSchema,
+  argv: exports_external.array(exports_external.string().min(1)).min(1).max(128),
+  cwd: RootRelativePathSchema.default("."),
+  timeout_ms: exports_external.number().int().min(100).max(3600000).optional(),
+  secret_env: exports_external.array(EnvNameSchema).max(100).default([])
+}).strict();
+var BaseSpecSchema = exports_external.object({
+  schema_version: exports_external.literal(SCHEMA_VERSION),
+  attempt_id: exports_external.string().uuid(),
+  phase_id: IdSchema,
+  workspace_root: AbsolutePathSchema,
+  staging_root: AbsolutePathSchema,
+  logs_root: AbsolutePathSchema,
+  budget: BudgetSchema,
+  environment: exports_external.record(EnvNameSchema, NonSecretEnvironmentValueSchema).default({}),
+  secret_env: exports_external.array(EnvNameSchema).max(100).default([])
+}).strict();
+var OutputAssertionSchema = exports_external.discriminatedUnion("operator", [
+  exports_external.object({ operator: exports_external.literal("exact"), expected: exports_external.string() }).strict(),
+  exports_external.object({ operator: exports_external.literal("contains"), expected: exports_external.string() }).strict(),
+  exports_external.object({
+    operator: exports_external.literal("regex"),
+    pattern: exports_external.string().max(4096),
+    flags: exports_external.string().regex(/^[imsu]*$/).default("")
+  }).strict()
+]);
+var WorkspaceAssertionSchema = exports_external.discriminatedUnion("operator", [
+  exports_external.object({ operator: exports_external.literal("exists") }).strict(),
+  exports_external.object({ operator: exports_external.literal("not_exists") }).strict(),
+  exports_external.object({ operator: exports_external.literal("sha256"), expected: Sha256Schema }).strict(),
+  exports_external.object({ operator: exports_external.literal("contains"), expected: exports_external.string() }).strict()
+]);
+var EvaluatorBase = {
+  id: IdSchema,
+  required: exports_external.boolean().default(true),
+  primary: exports_external.boolean().default(false)
+};
+var EvaluatorSchema = exports_external.discriminatedUnion("type", [
+  exports_external.object({
+    ...EvaluatorBase,
+    type: exports_external.literal("output_assertion"),
+    assertion: OutputAssertionSchema
+  }).strict(),
+  exports_external.object({
+    ...EvaluatorBase,
+    type: exports_external.literal("trajectory_assertion"),
+    event_type: exports_external.string().min(1).max(256),
+    min_count: exports_external.number().int().min(0).default(1),
+    max_count: exports_external.number().int().min(0).optional()
+  }).strict(),
+  exports_external.object({
+    ...EvaluatorBase,
+    type: exports_external.literal("workspace_assertion"),
+    path: RootRelativePathSchema,
+    assertion: WorkspaceAssertionSchema
+  }).strict(),
+  exports_external.object({
+    ...EvaluatorBase,
+    type: exports_external.literal("sandbox_command"),
+    command: CommandSchema.omit({ id: true }),
+    root: exports_external.enum(["workspace", "tests"]).default("tests")
+  }).strict()
+]);
+var EvidenceFileSchema = exports_external.object({
+  source: RootRelativePathSchema,
+  sha256: Sha256Schema,
+  size_bytes: exports_external.number().int().min(0).max(2 * 1024 * 1024 * 1024)
+}).strict();
+var FinalOutputEvidenceSchema = EvidenceFileSchema.extend({
+  size_bytes: exports_external.number().int().min(0).max(MAX_FINAL_OUTPUT_BYTES)
+}).strict();
+var TrajectoryEvidenceSchema = EvidenceFileSchema.extend({
+  size_bytes: exports_external.number().int().min(0).max(MAX_TRAJECTORY_BYTES)
+}).strict();
+var HydrateSpecSchema = BaseSpecSchema.extend({
+  phase: exports_external.literal("hydrate"),
+  materials: exports_external.array(MaterialSchema).max(1e4).default([]),
+  setup_commands: exports_external.array(CommandSchema).max(128).default([])
+}).strict();
+var EvaluateSpecSchema = BaseSpecSchema.extend({
+  phase: exports_external.literal("evaluate"),
+  tests_root: AbsolutePathSchema,
+  evidence: exports_external.object({
+    final_output: FinalOutputEvidenceSchema,
+    trajectory: TrajectoryEvidenceSchema
+  }).strict(),
+  references: exports_external.array(MaterialSchema).max(1e4).default([]),
+  evaluators: exports_external.array(EvaluatorSchema).min(1).max(1000),
+  candidate_artifacts: exports_external.array(RootRelativePathSchema).max(1000).default([]),
+  capture_workspace_archive: exports_external.boolean().default(false),
+  workspace_limits: exports_external.object({
+    max_file_count: exports_external.number().int().min(1).max(1e6).default(1e5),
+    max_total_bytes: exports_external.number().int().min(1).max(20 * 1024 * 1024 * 1024).default(2 * 1024 * 1024 * 1024)
+  }).strict().default({})
+}).strict();
+var BenchmarkSpecSchema = exports_external.discriminatedUnion("phase", [
+  HydrateSpecSchema,
+  EvaluateSpecSchema
+]).superRefine((value, context) => {
+  for (const name of Object.keys(value.environment)) {
+    if (SENSITIVE_ENV_NAME_RE.test(name)) {
+      context.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["environment", name],
+        message: "credential-like values must be supplied through secret_env"
+      });
+    }
+  }
+  const declaredSecrets = new Set(value.secret_env);
+  const commands = value.phase === "hydrate" ? value.setup_commands.map((command, index) => ({
+    command,
+    path: ["setup_commands", index, "secret_env"]
+  })) : value.evaluators.flatMap((evaluator, index) => evaluator.type === "sandbox_command" ? [{
+    command: evaluator.command,
+    path: ["evaluators", index, "command", "secret_env"]
+  }] : []);
+  for (const { command, path: issuePath } of commands) {
+    for (const name of command.secret_env) {
+      if (!declaredSecrets.has(name)) {
+        context.addIssue({
+          code: exports_external.ZodIssueCode.custom,
+          path: issuePath,
+          message: `command secret_env references undeclared binding: ${name}`
+        });
+      }
+    }
+  }
+  const uniqueLists = value.phase === "hydrate" ? [
+    { items: value.materials, path: "materials" },
+    { items: value.setup_commands, path: "setup_commands" }
+  ] : [
+    { items: value.references, path: "references" },
+    { items: value.evaluators, path: "evaluators" }
+  ];
+  for (const { items, path: issuePath } of uniqueLists) {
+    const ids = items.map((item) => item.id);
+    if (new Set(ids).size !== ids.length) {
+      context.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: [issuePath],
+        message: `${issuePath} ids must be unique`
+      });
+    }
+  }
+  if (value.phase === "evaluate" && value.evaluators.filter((evaluator) => evaluator.type === "sandbox_command").length > 1) {
+    context.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      path: ["evaluators"],
+      message: "schema version 1 supports at most one sandbox_command evaluator"
+    });
+  }
+});
+var BENCHMARK_CAPABILITIES = {
+  contract: "brainbase.benchmark.phase",
+  cli_version: VERSION,
+  schema_versions: [SCHEMA_VERSION],
+  phases: ["hydrate", "evaluate"],
+  evaluator_types: [
+    "output_assertion",
+    "trajectory_assertion",
+    "workspace_assertion",
+    "sandbox_command"
+  ],
+  limits: {
+    max_secret_bindings: 100,
+    max_evaluators: 1000,
+    max_sandbox_commands: 1
+  }
+};
+
+class BenchmarkPhaseError extends Error {
+  code;
+  details;
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "BenchmarkPhaseError";
+  }
+}
+function nowIso() {
+  return new Date().toISOString();
+}
+function normalizedRootRelative(input) {
+  if (input === ".")
+    return ".";
+  return safeRelPath(input);
+}
+function isWithin(root, candidate) {
+  const relative = path87.relative(path87.resolve(root), path87.resolve(candidate));
+  return relative === "" || !relative.startsWith("..") && !path87.isAbsolute(relative);
+}
+function canonicalFuturePath(input) {
+  const resolved = path87.resolve(input);
+  const suffix = [];
+  let current = resolved;
+  while (!fs79.existsSync(current)) {
+    const parent = path87.dirname(current);
+    if (parent === current)
+      break;
+    suffix.unshift(path87.basename(current));
+    current = parent;
+  }
+  const canonicalBase = fs79.realpathSync(current);
+  return path87.join(canonicalBase, ...suffix);
+}
+function validateRoots(spec) {
+  const workspace = path87.resolve(spec.workspace_root);
+  if (!fs79.existsSync(workspace) || fs79.lstatSync(workspace).isSymbolicLink() || !fs79.lstatSync(workspace).isDirectory()) {
+    throw new BenchmarkPhaseError("invalid_workspace_root", "workspace_root must be an existing real directory");
+  }
+  const canonicalWorkspace = canonicalFuturePath(workspace);
+  const staging = path87.resolve(spec.staging_root);
+  const expectedStaging = path87.join(workspace, ".brainbase", "benchmark", spec.attempt_id, "incoming");
+  if (staging !== expectedStaging) {
+    throw new BenchmarkPhaseError("invalid_staging_root", `staging_root must be ${expectedStaging}`);
+  }
+  if (!fs79.existsSync(staging) || fs79.lstatSync(staging).isSymbolicLink() || !fs79.lstatSync(staging).isDirectory() || fs79.realpathSync(staging) !== path87.join(canonicalWorkspace, ".brainbase", "benchmark", spec.attempt_id, "incoming")) {
+    throw new BenchmarkPhaseError("invalid_staging_root", "staging_root must be a real directory under workspace_root");
+  }
+  const canonicalLogs = validateExternalRoot("logs_root", spec.logs_root, canonicalWorkspace);
+  if (spec.phase === "evaluate") {
+    const canonicalTests = validateExternalRoot("tests_root", spec.tests_root, canonicalWorkspace);
+    if (isWithin(canonicalTests, canonicalLogs) || isWithin(canonicalLogs, canonicalTests)) {
+      throw new BenchmarkPhaseError("invalid_tests_root", "tests_root and logs_root must be disjoint");
+    }
+  }
+}
+function validateExternalRoot(label, input, canonicalWorkspace) {
+  const candidate = path87.resolve(input);
+  if (candidate === path87.parse(candidate).root) {
+    throw new BenchmarkPhaseError(`invalid_${label}`, `${label} cannot be a filesystem root`);
+  }
+  if (fs79.existsSync(candidate) && fs79.lstatSync(candidate).isSymbolicLink()) {
+    throw new BenchmarkPhaseError(`invalid_${label}`, `${label} cannot be a symlink`);
+  }
+  const canonicalCandidate = canonicalFuturePath(candidate);
+  if (isWithin(canonicalWorkspace, canonicalCandidate)) {
+    throw new BenchmarkPhaseError(`invalid_${label}`, `${label} must be outside workspace_root`);
+  }
+  if (isWithin(canonicalCandidate, canonicalWorkspace)) {
+    throw new BenchmarkPhaseError(`invalid_${label}`, `${label} cannot contain workspace_root`);
+  }
+  return canonicalCandidate;
+}
+function workspaceRel(input, allowRoot = false) {
+  const rel = normalizedRootRelative(input);
+  if (rel === "." && !allowRoot) {
+    throw new BenchmarkPhaseError("unsafe_path", "destination cannot be the workspace root");
+  }
+  const first = rel.split("/")[0].toLowerCase();
+  if (RESERVED_WORKSPACE_PATHS.has(first)) {
+    throw new BenchmarkPhaseError("reserved_path", `benchmark input cannot replace ${first}`);
+  }
+  return rel;
+}
+function assertNoSymlinkTraversal(root, relative) {
+  const rel = normalizedRootRelative(relative);
+  if (rel === ".")
+    return;
+  let current = path87.resolve(root);
+  for (const segment of rel.split("/").slice(0, -1)) {
+    current = path87.join(current, segment);
+    if (!fs79.existsSync(current))
+      continue;
+    if (fs79.lstatSync(current).isSymbolicLink()) {
+      throw new BenchmarkPhaseError("unsafe_path", `path traverses symlink: ${relative}`);
+    }
+  }
+}
+function assertOpenedFileWithinRoot(root, filePath, openedStat, label) {
+  let canonicalRoot;
+  let canonicalFile;
+  let currentStat;
+  try {
+    canonicalRoot = fs79.realpathSync(root);
+    canonicalFile = fs79.realpathSync(filePath);
+    currentStat = fs79.statSync(filePath);
+  } catch {
+    throw new BenchmarkPhaseError("unsafe_path", `${label} changed while it was opened`);
+  }
+  if (!isWithin(canonicalRoot, canonicalFile) || currentStat.dev !== openedStat.dev || currentStat.ino !== openedStat.ino) {
+    throw new BenchmarkPhaseError("unsafe_path", `${label} escapes its declared root`);
+  }
+}
+function openRegularFileNoFollow(filePath, label, root) {
+  const noFollow = typeof fs79.constants.O_NOFOLLOW === "number" ? fs79.constants.O_NOFOLLOW : 0;
+  let fd;
+  try {
+    fd = fs79.openSync(filePath, fs79.constants.O_RDONLY | noFollow);
+  } catch (error2) {
+    const code = error2.code;
+    if (code === "ELOOP") {
+      throw new BenchmarkPhaseError("unsafe_path", `${label} cannot be a symlink`);
+    }
+    throw error2;
+  }
+  const stat = fs79.fstatSync(fd);
+  if (!stat.isFile()) {
+    fs79.closeSync(fd);
+    throw new BenchmarkPhaseError("invalid_input", `${label} must be a regular file`);
+  }
+  if (root) {
+    try {
+      assertOpenedFileWithinRoot(root, filePath, stat, label);
+    } catch (error2) {
+      fs79.closeSync(fd);
+      throw error2;
+    }
+  }
+  return { fd, stat };
+}
+async function sha256OfDescriptor(fd) {
+  const hash = crypto6.createHash("sha256");
+  const stream = fs79.createReadStream("", {
+    fd,
+    autoClose: false,
+    start: 0
+  });
+  for await (const chunk2 of stream) {
+    hash.update(chunk2);
+  }
+  return hash.digest("hex");
+}
+function readDescriptor(fd) {
+  return fs79.readFileSync(fd);
+}
+function assertWritableDestination(root, relative) {
+  const rel = normalizedRootRelative(relative);
+  if (rel === ".")
+    return;
+  let current = path87.resolve(root);
+  const segments = rel.split("/");
+  for (const segment of segments.slice(0, -1)) {
+    current = path87.join(current, segment);
+    if (!fs79.existsSync(current))
+      continue;
+    const stat = fs79.lstatSync(current);
+    if (stat.isSymbolicLink()) {
+      throw new BenchmarkPhaseError("unsafe_path", `path traverses symlink: ${relative}`);
+    }
+    if (!stat.isDirectory()) {
+      throw new BenchmarkPhaseError("destination_conflict", `destination parent is not a directory: ${relative}`);
+    }
+  }
+  const destination = path87.resolve(root, rel);
+  if (fs79.existsSync(destination) && fs79.lstatSync(destination).isDirectory()) {
+    throw new BenchmarkPhaseError("destination_conflict", `file destination is an existing directory: ${relative}`);
+  }
+}
+function validateDestinationGraph(paths) {
+  const portablePaths = new Map;
+  for (const candidate of paths) {
+    const key2 = candidate.toLowerCase();
+    const existing = portablePaths.get(key2);
+    if (existing && existing !== candidate) {
+      throw new BenchmarkPhaseError("destination_conflict", `destination ${candidate} conflicts by case with ${existing}`);
+    }
+    portablePaths.set(key2, candidate);
+  }
+  const sorted = [...portablePaths.keys()].sort();
+  for (let index = 0;index < sorted.length - 1; index += 1) {
+    const current = sorted[index];
+    const next = sorted[index + 1];
+    if (next.startsWith(`${current}/`)) {
+      throw new BenchmarkPhaseError("destination_conflict", `destination ${current} conflicts with descendant ${next}`);
+    }
+  }
+}
+function sourcePath(stagingRoot, relative) {
+  const rel = safeRelPath(relative);
+  const source = path87.resolve(stagingRoot, rel);
+  if (!isWithin(stagingRoot, source)) {
+    throw new BenchmarkPhaseError("unsafe_path", `source escapes staging root: ${relative}`);
+  }
+  assertNoSymlinkTraversal(stagingRoot, rel);
+  let stat;
+  try {
+    stat = fs79.lstatSync(source);
+  } catch {
+    throw new BenchmarkPhaseError("missing_input", `staged input does not exist: ${relative}`);
+  }
+  if (!stat.isFile()) {
+    throw new BenchmarkPhaseError("invalid_input", `staged input must be a regular file: ${relative}`);
+  }
+  return source;
+}
+function rootForRecord(spec, rootName) {
+  if (rootName === "workspace")
+    return spec.workspace_root;
+  if (rootName === "staging")
+    return spec.staging_root;
+  if (rootName === "logs")
+    return spec.logs_root;
+  if (rootName === "tests" && spec.phase === "evaluate")
+    return spec.tests_root;
+  return null;
+}
+async function verifyRecordsUnchanged(records, spec) {
+  for (const record3 of records) {
+    const root = rootForRecord(spec, record3.root);
+    if (!root) {
+      throw new BenchmarkPhaseError("evidence_tampered", `unknown evidence root: ${record3.root}`);
+    }
+    const relative = safeRelPath(record3.path);
+    assertNoSymlinkTraversal(root, relative);
+    const candidate = path87.resolve(root, relative);
+    if (!isWithin(root, candidate) || !fs79.existsSync(candidate)) {
+      throw new BenchmarkPhaseError("evidence_tampered", `evidence was removed during evaluation: ${record3.root}:${record3.path}`);
+    }
+    const stat = fs79.lstatSync(candidate);
+    if (record3.kind === "symlink") {
+      const target = stat.isSymbolicLink() ? fs79.readlinkSync(candidate) : null;
+      if (target === null || Buffer.byteLength(target) !== record3.size || sha256(target) !== record3.sha256) {
+        throw new BenchmarkPhaseError("evidence_tampered", `evidence changed during evaluation: ${record3.root}:${record3.path}`);
+      }
+      continue;
+    }
+    if (!stat.isFile()) {
+      throw new BenchmarkPhaseError("evidence_tampered", `evidence changed during evaluation: ${record3.root}:${record3.path}`);
+    }
+    const opened = openRegularFileNoFollow(candidate, `evidence ${record3.root}:${record3.path}`, root);
+    try {
+      if (opened.stat.size !== record3.size || await sha256OfDescriptor(opened.fd) !== record3.sha256) {
+        throw new BenchmarkPhaseError("evidence_tampered", `evidence changed during evaluation: ${record3.root}:${record3.path}`);
+      }
+    } finally {
+      fs79.closeSync(opened.fd);
+    }
+  }
+}
+async function verifyInput(stagingRoot, material) {
+  const source = sourcePath(stagingRoot, material.source);
+  const opened = openRegularFileNoFollow(source, `staged input ${material.source}`, stagingRoot);
+  try {
+    if (opened.stat.size !== material.size_bytes) {
+      throw new BenchmarkPhaseError("size_mismatch", `size mismatch for ${material.source}`, { expected: material.size_bytes, actual: opened.stat.size });
+    }
+    const actual = await sha256OfDescriptor(opened.fd);
+    if (actual !== material.sha256) {
+      throw new BenchmarkPhaseError("digest_mismatch", `checksum mismatch for ${material.source}`, { expected: material.sha256, actual });
+    }
+  } finally {
+    fs79.closeSync(opened.fd);
+  }
+  return source;
+}
+async function atomicCopy(source, destination, mode, sourceRoot) {
+  fs79.mkdirSync(path87.dirname(destination), { recursive: true });
+  const temporary = `${destination}.${process.pid}.${crypto6.randomBytes(6).toString("hex")}.tmp`;
+  const opened = openRegularFileNoFollow(source, `copy source ${source}`, sourceRoot);
+  try {
+    await pipeline2(fs79.createReadStream("", {
+      fd: opened.fd,
+      autoClose: false,
+      start: 0
+    }), fs79.createWriteStream(temporary, {
+      flags: "wx",
+      mode: 384
+    }));
+    fs79.chmodSync(temporary, mode ?? opened.stat.mode & 511);
+    fs79.renameSync(temporary, destination);
+  } finally {
+    fs79.closeSync(opened.fd);
+    fs79.rmSync(temporary, { force: true });
+  }
+}
+async function recordFile(root, filePath, rootName, kind = "file") {
+  const relative = path87.relative(root, filePath).replace(/\\/g, "/");
+  if (kind === "symlink") {
+    const stat = fs79.lstatSync(filePath);
+    const target = fs79.readlinkSync(filePath);
+    return {
+      root: rootName,
+      path: relative,
+      sha256: sha256(target),
+      size: Buffer.byteLength(target),
+      mode: stat.mode & 511,
+      kind
+    };
+  }
+  const opened = openRegularFileNoFollow(filePath, `${rootName} file ${relative}`, root);
+  try {
+    return {
+      root: rootName,
+      path: relative,
+      sha256: await sha256OfDescriptor(opened.fd),
+      size: opened.stat.size,
+      mode: opened.stat.mode & 511
+    };
+  } finally {
+    fs79.closeSync(opened.fd);
+  }
+}
+async function copyMaterial(material, sourceRoot, destinationRoot, destinationRootName, protectWorkspace) {
+  const source = await verifyInput(sourceRoot, material);
+  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 (destinationRel === ".") {
+      throw new BenchmarkPhaseError("unsafe_path", "file destination cannot be a directory root");
+    }
+    assertWritableDestination(destinationRoot, destinationRel);
+    const destination = path87.resolve(destinationRoot, destinationRel);
+    await atomicCopy(source, destination, material.mode, sourceRoot);
+    const record3 = await recordFile(destinationRoot, destination, destinationRootName);
+    if (record3.sha256 !== material.sha256 || record3.size !== material.size_bytes) {
+      throw new BenchmarkPhaseError("evidence_tampered", `material changed while it was copied: ${material.source}`);
+    }
+    return [record3];
+  }
+  const temporary = fs79.mkdtempSync(path87.join(os16.tmpdir(), "brainbase-benchmark-"));
+  try {
+    const verifiedArchive = path87.join(temporary, "material.tar.gz");
+    await atomicCopy(source, verifiedArchive, 384, sourceRoot);
+    const archiveRecord = await recordFile(temporary, verifiedArchive, "staging");
+    if (archiveRecord.sha256 !== material.sha256 || archiveRecord.size !== material.size_bytes) {
+      throw new BenchmarkPhaseError("evidence_tampered", `material changed while it was copied: ${material.source}`);
+    }
+    const extractedRoot = path87.join(temporary, "extracted");
+    const extracted = await extract({
+      tarFile: verifiedArchive,
+      outDir: extractedRoot,
+      maxTotalBytes: material.max_unpacked_bytes,
+      maxFileCount: material.max_file_count
+    });
+    const outputs = [];
+    for (const extractedRel of extracted.sort()) {
+      const sourceFile = path87.resolve(extractedRoot, safeRelPath(extractedRel));
+      const stat = fs79.lstatSync(sourceFile);
+      if (!stat.isFile())
+        continue;
+      const combined = destinationRel === "." ? safeRelPath(extractedRel) : safeRelPath(path87.posix.join(destinationRel, extractedRel));
+      const checked = protectWorkspace ? workspaceRel(combined) : combined;
+      if (!protectWorkspace && checked.toLowerCase() === ".brainbase-benchmark-owner.json") {
+        throw new BenchmarkPhaseError("reserved_path", "benchmark input cannot replace the phase ownership marker");
+      }
+      assertWritableDestination(destinationRoot, checked);
+      const destination = path87.resolve(destinationRoot, checked);
+      await atomicCopy(sourceFile, destination, material.mode, extractedRoot);
+      outputs.push(await recordFile(destinationRoot, destination, destinationRootName));
+    }
+    return outputs;
+  } finally {
+    fs79.rmSync(temporary, { recursive: true, force: true });
+  }
+}
+async function preflightMaterial(material, sourceRoot, destinationRoot, protectWorkspace) {
+  const source = await verifyInput(sourceRoot, material);
+  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 (destinationRel === ".") {
+      throw new BenchmarkPhaseError("unsafe_path", "file destination cannot be a directory root");
+    }
+    assertWritableDestination(destinationRoot, destinationRel);
+    return [destinationRel];
+  }
+  const temporary = fs79.mkdtempSync(path87.join(os16.tmpdir(), "brainbase-benchmark-preflight-"));
+  try {
+    const verifiedArchive = path87.join(temporary, "material.tar.gz");
+    await atomicCopy(source, verifiedArchive, 384, sourceRoot);
+    const archiveRecord = await recordFile(temporary, verifiedArchive, "staging");
+    if (archiveRecord.sha256 !== material.sha256 || archiveRecord.size !== material.size_bytes) {
+      throw new BenchmarkPhaseError("evidence_tampered", `material changed while it was copied: ${material.source}`);
+    }
+    const extractedRoot = path87.join(temporary, "extracted");
+    const extracted = await extract({
+      tarFile: verifiedArchive,
+      outDir: extractedRoot,
+      maxTotalBytes: material.max_unpacked_bytes,
+      maxFileCount: material.max_file_count
+    });
+    const planned = [];
+    for (const extractedRel of extracted) {
+      const combined = destinationRel === "." ? safeRelPath(extractedRel) : safeRelPath(path87.posix.join(destinationRel, extractedRel));
+      const checked = protectWorkspace ? workspaceRel(combined) : combined;
+      if (!protectWorkspace && checked.toLowerCase() === ".brainbase-benchmark-owner.json") {
+        throw new BenchmarkPhaseError("reserved_path", "benchmark input cannot replace the phase ownership marker");
+      }
+      assertWritableDestination(destinationRoot, checked);
+      planned.push(checked);
+    }
+    return planned;
+  } finally {
+    fs79.rmSync(temporary, { recursive: true, force: true });
+  }
+}
+function ownerMarker(root) {
+  return path87.join(root, ".brainbase-benchmark-owner.json");
+}
+function verifyOwnedDirectory(root, role, spec) {
+  if (!fs79.existsSync(root) || fs79.lstatSync(root).isSymbolicLink())
+    return false;
+  try {
+    const marker = JSON.parse(fs79.readFileSync(ownerMarker(root), "utf8"));
+    return marker.attempt_id === spec.attempt_id && marker.phase === spec.phase && marker.phase_id === spec.phase_id && marker.role === role;
+  } catch {
+    return false;
+  }
+}
+function prepareOwnedDirectory(root, role, spec) {
+  if (fs79.existsSync(root)) {
+    if (!verifyOwnedDirectory(root, role, spec)) {
+      const stat = fs79.lstatSync(root);
+      if (!stat.isDirectory() || fs79.readdirSync(root).length > 0) {
+        throw new BenchmarkPhaseError(`unowned_${role}_root`, `${role}_root exists without a matching attempt ownership marker`);
+      }
+    } else {
+      fs79.rmSync(root, { recursive: true, force: true });
+    }
+  }
+  fs79.mkdirSync(root, { recursive: true, mode: 448 });
+  writeJsonAtomic(ownerMarker(root), {
+    schema_version: SCHEMA_VERSION,
+    attempt_id: spec.attempt_id,
+    phase: spec.phase,
+    phase_id: spec.phase_id,
+    role
+  });
+}
+function buildEnvironment(spec, secretNames, additions = {}) {
+  const env3 = {};
+  for (const name of BASE_ENV_NAMES) {
+    if (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) {
+    const value = process.env[name];
+    if (value === undefined) {
+      throw new BenchmarkPhaseError("missing_environment", `required environment variable is missing: ${name}`);
+    }
+    env3[name] = value;
+  }
+  Object.assign(env3, additions);
+  return env3;
+}
+function redactCommandOutput(data, spec) {
+  let value = data.toString("utf8");
+  for (const name of spec.secret_env) {
+    const secret = process.env[name];
+    if (secret)
+      value = value.split(secret).join("[REDACTED]");
+  }
+  return Buffer.from(value);
+}
+function descendantPids(parentPid) {
+  if (process.platform === "win32")
+    return [];
+  try {
+    const output = execFileSync2("ps", ["-eo", "pid=,ppid="], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const children = new Map;
+    for (const line of output.split(`
+`)) {
+      const [pidRaw, parentRaw] = line.trim().split(/\s+/);
+      const pid = Number(pidRaw);
+      const parent = Number(parentRaw);
+      if (!Number.isInteger(pid) || !Number.isInteger(parent))
+        continue;
+      const current = children.get(parent) ?? [];
+      current.push(pid);
+      children.set(parent, current);
+    }
+    const descendants = [];
+    const stack = [...children.get(parentPid) ?? []];
+    while (stack.length > 0) {
+      const pid = stack.pop();
+      descendants.push(pid);
+      stack.push(...children.get(pid) ?? []);
+    }
+    return descendants;
+  } catch {
+    return [];
+  }
+}
+function terminate(child) {
+  if (child.pid === undefined)
+    return;
+  for (const pid of descendantPids(child.pid).reverse()) {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {}
+  }
+  try {
+    if (process.platform !== "win32")
+      process.kill(-child.pid, "SIGKILL");
+    else
+      child.kill("SIGKILL");
+  } catch {
+    child.kill("SIGKILL");
+  }
+}
+async function runCommand(command, root, spec, context, additions = {}) {
+  const cwdRel = normalizedRootRelative(command.cwd);
+  assertNoSymlinkTraversal(root, cwdRel);
+  const cwd2 = path87.resolve(root, cwdRel);
+  let cwdStat;
+  try {
+    cwdStat = fs79.lstatSync(cwd2);
+  } catch {
+    throw new BenchmarkPhaseError("invalid_command_cwd", `command cwd is invalid: ${command.cwd}`);
+  }
+  if (!isWithin(root, cwd2) || cwdStat.isSymbolicLink() || !cwdStat.isDirectory()) {
+    throw new BenchmarkPhaseError("invalid_command_cwd", `command cwd is invalid: ${command.cwd}`);
+  }
+  const remainingMs = context.deadline - Date.now();
+  if (remainingMs <= 0)
+    throw new BenchmarkPhaseError("phase_timeout", "phase budget expired");
+  const timeoutMs2 = Math.min(command.timeout_ms ?? remainingMs, remainingMs);
+  const started = Date.now();
+  return await new Promise((resolve, reject2) => {
+    const child = spawn4(command.argv[0], command.argv.slice(1), {
+      cwd: cwd2,
+      env: buildEnvironment(spec, command.secret_env, additions),
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: process.platform !== "win32"
+    });
+    const stdout = [];
+    const stderr = [];
+    let captured = 0;
+    let settled = false;
+    let timer;
+    const fail = (error2) => {
+      if (settled)
+        return;
+      settled = true;
+      if (timer)
+        clearTimeout(timer);
+      terminate(child);
+      reject2(error2);
+    };
+    const capture = (target, chunk2) => {
+      if (settled)
+        return;
+      captured += chunk2.length;
+      context.remainingOutputBytes -= chunk2.length;
+      if (captured > spec.budget.max_output_bytes || context.remainingOutputBytes < 0) {
+        fail(new BenchmarkPhaseError("output_limit_exceeded", `command output exceeded budget: ${command.id}`));
+        return;
+      }
+      target.push(chunk2);
+    };
+    child.stdout?.on("data", (chunk2) => capture(stdout, chunk2));
+    child.stderr?.on("data", (chunk2) => capture(stderr, chunk2));
+    child.on("error", (error2) => {
+      fail(new BenchmarkPhaseError("command_start_failed", `failed to start ${command.id}: ${error2.message}`));
+    });
+    timer = setTimeout(() => {
+      fail(new BenchmarkPhaseError("command_timeout", `command timed out: ${command.id}`));
+    }, timeoutMs2);
+    child.on("close", (code, signal) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      if (code === null) {
+        reject2(new BenchmarkPhaseError("command_terminated", `command was terminated by ${signal ?? "an unknown signal"}: ${command.id}`));
+        return;
+      }
+      resolve({
+        exitCode: code,
+        stdout: Buffer.concat(stdout),
+        stderr: Buffer.concat(stderr),
+        durationMs: Date.now() - started
+      });
+    });
+  });
+}
+async function writeLog(root, name, data, spec) {
+  const destination = path87.join(root, name);
+  fs79.mkdirSync(path87.dirname(destination), { recursive: true });
+  const temporary = `${destination}.${process.pid}.${crypto6.randomBytes(6).toString("hex")}.tmp`;
+  try {
+    fs79.writeFileSync(temporary, redactCommandOutput(data, spec), {
+      flag: "wx",
+      mode: 384
+    });
+    fs79.renameSync(temporary, destination);
+  } finally {
+    fs79.rmSync(temporary, { force: true });
+  }
+  return await recordFile(root, destination, "logs");
+}
+function writeBufferAtomic(destination, data) {
+  fs79.mkdirSync(path87.dirname(destination), { recursive: true });
+  const temporary = `${destination}.${process.pid}.${crypto6.randomBytes(6).toString("hex")}.tmp`;
+  try {
+    fs79.writeFileSync(temporary, data, { flag: "wx", mode: 384 });
+    fs79.renameSync(temporary, destination);
+  } finally {
+    fs79.rmSync(temporary, { force: true });
+  }
+}
+function assertBudget(context) {
+  if (Date.now() > context.deadline) {
+    throw new BenchmarkPhaseError("phase_timeout", "phase budget expired");
+  }
+}
+async function executeHydrate(spec, context) {
+  fs79.mkdirSync(spec.workspace_root, { recursive: true });
+  prepareOwnedDirectory(spec.logs_root, "logs", spec);
+  context.logsOwned = true;
+  const outputs = [];
+  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"));
+  }
+  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);
+      outputs.push(...records);
+      context.outputs.push(...records);
+      context.steps.push({
+        id: material.id,
+        type: `material:${material.kind}`,
+        status: "passed",
+        duration_ms: Date.now() - started
+      });
+    } catch (error2) {
+      context.steps.push({
+        id: material.id,
+        type: `material:${material.kind}`,
+        status: "failed",
+        duration_ms: Date.now() - started
+      });
+      throw error2;
+    }
+  }
+  for (const command of spec.setup_commands) {
+    assertBudget(context);
+    let result2;
+    try {
+      result2 = await runCommand(command, spec.workspace_root, spec, context);
+    } catch (error2) {
+      context.steps.push({
+        id: command.id,
+        type: "setup_command",
+        status: "failed",
+        duration_ms: 0
+      });
+      throw error2;
+    }
+    const stdout = await writeLog(spec.logs_root, `${command.id}.stdout.log`, result2.stdout, spec);
+    const stderr = await writeLog(spec.logs_root, `${command.id}.stderr.log`, result2.stderr, spec);
+    context.steps.push({
+      id: command.id,
+      type: "setup_command",
+      status: result2.exitCode === 0 ? "passed" : "failed",
+      duration_ms: result2.durationMs,
+      exit_code: result2.exitCode,
+      stdout,
+      stderr
+    });
+    outputs.push(stdout, stderr);
+    context.outputs.push(stdout, stderr);
+    if (result2.exitCode !== 0) {
+      throw new BenchmarkPhaseError("setup_failed", `setup command failed: ${command.id}`, {
+        exit_code: result2.exitCode
+      });
+    }
+  }
+  const finalOutputs = [];
+  const seenOutputs = new Set;
+  for (const output of outputs) {
+    const key2 = `${output.root}:${output.path}`;
+    if (seenOutputs.has(key2))
+      continue;
+    seenOutputs.add(key2);
+    if (output.root !== "workspace") {
+      finalOutputs.push(output);
+      continue;
+    }
+    const candidate = path87.resolve(spec.workspace_root, safeRelPath(output.path));
+    assertNoSymlinkTraversal(spec.workspace_root, output.path);
+    if (!fs79.existsSync(candidate))
+      continue;
+    const stat = fs79.lstatSync(candidate);
+    if (!stat.isFile() && !stat.isSymbolicLink())
+      continue;
+    finalOutputs.push(await recordFile(spec.workspace_root, candidate, "workspace", stat.isSymbolicLink() ? "symlink" : "file"));
+  }
+  outputs.splice(0, outputs.length, ...finalOutputs);
+  context.outputs.splice(0, context.outputs.length, ...finalOutputs);
+  assertBudget(context);
+  return outputs;
+}
+async function readEvidence(stagingRoot, evidence) {
+  const filePath = sourcePath(stagingRoot, evidence.source);
+  const opened = openRegularFileNoFollow(filePath, `evidence ${evidence.source}`, stagingRoot);
+  try {
+    const buffer = readDescriptor(opened.fd);
+    if (opened.stat.size !== evidence.size_bytes) {
+      throw new BenchmarkPhaseError("size_mismatch", `size mismatch for ${evidence.source}`, { expected: evidence.size_bytes, actual: opened.stat.size });
+    }
+    const actual = sha256(buffer);
+    if (actual !== evidence.sha256) {
+      throw new BenchmarkPhaseError("digest_mismatch", `checksum mismatch for ${evidence.source}`, { expected: evidence.sha256, actual });
+    }
+    return {
+      path: filePath,
+      buffer,
+      record: {
+        root: "staging",
+        path: path87.relative(stagingRoot, filePath).replace(/\\/g, "/"),
+        sha256: evidence.sha256,
+        size: opened.stat.size,
+        mode: opened.stat.mode & 511
+      }
+    };
+  } finally {
+    fs79.closeSync(opened.fd);
+  }
+}
+async function workspaceManifest(spec, context) {
+  const records = [];
+  let totalBytes = 0;
+  const stack = [path87.resolve(spec.workspace_root)];
+  while (stack.length > 0) {
+    const directory = stack.pop();
+    const entries = fs79.readdirSync(directory, { withFileTypes: true }).sort((a3, b4) => a3.name.localeCompare(b4.name));
+    for (const entry of entries) {
+      assertBudget(context);
+      const full = path87.join(directory, entry.name);
+      const relative = path87.relative(spec.workspace_root, full).replace(/\\/g, "/");
+      if (relative === ".brainbase" || relative.startsWith(".brainbase/"))
+        continue;
+      if (relative === ".git" || relative.startsWith(".git/"))
+        continue;
+      if (entry.isDirectory()) {
+        stack.push(full);
+        continue;
+      }
+      if (!entry.isFile() && !entry.isSymbolicLink())
+        continue;
+      const record3 = await recordFile(spec.workspace_root, full, "workspace", entry.isSymbolicLink() ? "symlink" : "file");
+      records.push(record3);
+      totalBytes += record3.size;
+      if (records.length > spec.workspace_limits.max_file_count) {
+        throw new BenchmarkPhaseError("workspace_limit_exceeded", "workspace file count exceeds budget");
+      }
+      if (totalBytes > spec.workspace_limits.max_total_bytes) {
+        throw new BenchmarkPhaseError("workspace_limit_exceeded", "workspace bytes exceed budget");
+      }
+    }
+  }
+  return records.sort((a3, b4) => a3.path.localeCompare(b4.path));
+}
+function trajectoryEvents(value) {
+  if (Array.isArray(value))
+    return value;
+  if (value && typeof value === "object" && Array.isArray(value.events)) {
+    return value.events;
+  }
+  throw new BenchmarkPhaseError("invalid_trajectory", "trajectory evidence must be an array or an object with events");
+}
+function eventType(event) {
+  if (!event || typeof event !== "object")
+    return;
+  const record3 = event;
+  for (const key2 of ["event_type", "type", "kind"]) {
+    if (typeof record3[key2] === "string")
+      return record3[key2];
+  }
+  return;
+}
+async function evaluateOne(evaluator, spec, finalOutput, trajectory, frozenEvidence, context) {
+  const started = Date.now();
+  const base2 = {
+    id: evaluator.id,
+    type: evaluator.type,
+    required: evaluator.required,
+    primary: evaluator.primary,
+    engine: "brainbase-cli",
+    engine_version: VERSION
+  };
+  if (evaluator.type === "output_assertion") {
+    const assertion = evaluator.assertion;
+    let verdict2 = false;
+    if (assertion.operator === "exact")
+      verdict2 = finalOutput === assertion.expected;
+    if (assertion.operator === "contains")
+      verdict2 = finalOutput.includes(assertion.expected);
+    if (assertion.operator === "regex") {
+      const regexResult = await runCommand({
+        id: `${evaluator.id}.regex`,
+        argv: [
+          process.execPath,
+          "-e",
+          [
+            'const fs=require("node:fs");',
+            "try {",
+            'const pattern=Buffer.from(process.env.BB_REGEX_PATTERN_B64,"base64").toString("utf8");',
+            'const value=fs.readFileSync(process.env.BB_REGEX_INPUT,"utf8");',
+            "process.exit(new RegExp(pattern,process.env.BB_REGEX_FLAGS).test(value)?0:1);",
+            "} catch { process.exit(2); }"
+          ].join("")
+        ],
+        cwd: ".",
+        secret_env: []
+      }, spec.tests_root, spec, context, {
+        BB_REGEX_INPUT: frozenEvidence.finalOutputPath,
+        BB_REGEX_PATTERN_B64: Buffer.from(assertion.pattern).toString("base64"),
+        BB_REGEX_FLAGS: assertion.flags
+      });
+      if (regexResult.exitCode === 2) {
+        throw new BenchmarkPhaseError("invalid_evaluator", `invalid regex in evaluator: ${evaluator.id}`);
+      }
+      verdict2 = regexResult.exitCode === 0;
+    }
+    return { ...base2, status: verdict2 ? "passed" : "failed", verdict: verdict2, duration_ms: Date.now() - started };
+  }
+  if (evaluator.type === "trajectory_assertion") {
+    const count = trajectory.filter((event) => eventType(event) === evaluator.event_type).length;
+    const verdict2 = count >= evaluator.min_count && (evaluator.max_count === undefined || count <= evaluator.max_count);
+    return {
+      ...base2,
+      status: verdict2 ? "passed" : "failed",
+      verdict: verdict2,
+      duration_ms: Date.now() - started,
+      details: { count, min_count: evaluator.min_count, max_count: evaluator.max_count }
+    };
+  }
+  if (evaluator.type === "workspace_assertion") {
+    const relative = workspaceRel(evaluator.path);
+    assertNoSymlinkTraversal(spec.workspace_root, relative);
+    const candidate = path87.resolve(spec.workspace_root, relative);
+    let stat = null;
+    try {
+      stat = fs79.lstatSync(candidate);
+    } catch (error2) {
+      const code = error2.code;
+      if (code !== "ENOENT" && code !== "ENOTDIR")
+        throw error2;
+    }
+    if (stat?.isSymbolicLink()) {
+      throw new BenchmarkPhaseError("unsafe_path", `workspace assertion cannot target a symlink: ${relative}`);
+    }
+    const exists2 = stat !== null;
+    let verdict2 = false;
+    if (evaluator.assertion.operator === "exists")
+      verdict2 = exists2;
+    if (evaluator.assertion.operator === "not_exists")
+      verdict2 = !exists2;
+    if (evaluator.assertion.operator === "sha256") {
+      if (stat?.isFile()) {
+        const opened = openRegularFileNoFollow(candidate, `workspace assertion ${relative}`, spec.workspace_root);
+        try {
+          verdict2 = await sha256OfDescriptor(opened.fd) === evaluator.assertion.expected;
+        } finally {
+          fs79.closeSync(opened.fd);
+        }
+      }
+    }
+    if (evaluator.assertion.operator === "contains") {
+      if (stat?.isFile()) {
+        const opened = openRegularFileNoFollow(candidate, `workspace assertion ${relative}`, spec.workspace_root);
+        try {
+          verdict2 = readDescriptor(opened.fd).toString("utf8").includes(evaluator.assertion.expected);
+        } finally {
+          fs79.closeSync(opened.fd);
+        }
+      }
+    }
+    return { ...base2, status: verdict2 ? "passed" : "failed", verdict: verdict2, duration_ms: Date.now() - started };
+  }
+  const commandRoot = evaluator.root === "workspace" ? spec.workspace_root : spec.tests_root;
+  const command = { id: evaluator.id, ...evaluator.command };
+  const result2 = await runCommand(command, commandRoot, spec, context, {
+    BRAINBASE_BENCHMARK_WORKSPACE: spec.workspace_root,
+    BRAINBASE_BENCHMARK_TESTS: spec.tests_root,
+    BRAINBASE_BENCHMARK_LOGS: spec.logs_root,
+    BRAINBASE_BENCHMARK_FINAL_OUTPUT: frozenEvidence.finalOutputPath,
+    BRAINBASE_BENCHMARK_TRAJECTORY: frozenEvidence.trajectoryPath
+  });
+  const stdout = await writeLog(spec.logs_root, `${evaluator.id}.stdout.log`, result2.stdout, spec);
+  const stderr = await writeLog(spec.logs_root, `${evaluator.id}.stderr.log`, result2.stderr, spec);
+  const verdict = result2.exitCode === 0;
+  return {
+    ...base2,
+    status: verdict ? "passed" : "failed",
+    verdict,
+    duration_ms: result2.durationMs,
+    details: { exit_code: result2.exitCode },
+    stdout,
+    stderr
+  };
+}
+async function executeEvaluate(spec, 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);
+  let parsedTrajectory;
+  try {
+    parsedTrajectory = JSON.parse(trajectoryEvidence.buffer.toString("utf8"));
+  } catch {
+    throw new BenchmarkPhaseError("invalid_trajectory", "trajectory evidence is not valid JSON");
+  }
+  const trajectory = trajectoryEvents(parsedTrajectory);
+  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"));
+  }
+  validateDestinationGraph(plannedReferences);
+  assertBudget(context);
+  validateRoots(spec);
+  prepareOwnedDirectory(spec.tests_root, "tests", spec);
+  prepareOwnedDirectory(spec.logs_root, "logs", spec);
+  context.logsOwned = true;
+  validateRoots(spec);
+  const outputs = [];
+  const finalOutputPath = path87.join(spec.logs_root, "candidate-evidence", "final-output");
+  const trajectoryPath = path87.join(spec.logs_root, "candidate-evidence", "trajectory.json");
+  writeBufferAtomic(finalOutputPath, finalOutput.buffer);
+  writeBufferAtomic(trajectoryPath, trajectoryEvidence.buffer);
+  const frozenEvidenceRecords = [
+    await recordFile(spec.logs_root, finalOutputPath, "logs"),
+    await recordFile(spec.logs_root, trajectoryPath, "logs")
+  ];
+  outputs.push(...frozenEvidenceRecords);
+  context.outputs.push(...frozenEvidenceRecords);
+  assertBudget(context);
+  const manifest = await workspaceManifest(spec, context);
+  const manifestPath2 = path87.join(spec.logs_root, "candidate-workspace-manifest.json");
+  writeJsonAtomic(manifestPath2, {
+    schema_version: SCHEMA_VERSION,
+    attempt_id: spec.attempt_id,
+    phase_id: spec.phase_id,
+    files: manifest
+  });
+  const manifestRecord = await recordFile(spec.logs_root, manifestPath2, "logs");
+  outputs.push(manifestRecord);
+  context.outputs.push(manifestRecord);
+  for (const artifactRelInput of spec.candidate_artifacts) {
+    const artifactRel = workspaceRel(artifactRelInput);
+    assertNoSymlinkTraversal(spec.workspace_root, artifactRel);
+    const source = path87.resolve(spec.workspace_root, artifactRel);
+    const frozenArtifact = manifest.find((entry) => entry.path === artifactRel && entry.kind !== "symlink");
+    if (!frozenArtifact || !fs79.existsSync(source) || !fs79.lstatSync(source).isFile()) {
+      throw new BenchmarkPhaseError("missing_artifact", `candidate artifact is missing: ${artifactRel}`);
+    }
+    const destination = path87.resolve(spec.logs_root, "candidate-artifacts", artifactRel);
+    await atomicCopy(source, destination, undefined, spec.workspace_root);
+    const artifact = await recordFile(spec.logs_root, destination, "logs");
+    if (artifact.sha256 !== frozenArtifact.sha256 || artifact.size !== frozenArtifact.size || artifact.mode !== frozenArtifact.mode) {
+      throw new BenchmarkPhaseError("evidence_tampered", `candidate artifact changed after the workspace freeze: ${artifactRel}`);
+    }
+    outputs.push(artifact);
+    context.outputs.push(artifact);
+  }
+  if (spec.capture_workspace_archive) {
+    const regularFiles = manifest.filter((entry) => entry.kind !== "symlink").map((entry) => entry.path);
+    const archive = path87.join(spec.logs_root, "candidate-workspace.tar.gz");
+    const temporary = `${archive}.${process.pid}.${crypto6.randomBytes(6).toString("hex")}.tmp`;
+    try {
+      await pack({ rootDir: spec.workspace_root, outFile: temporary, files: regularFiles });
+      fs79.renameSync(temporary, archive);
+    } finally {
+      fs79.rmSync(temporary, { force: true });
+    }
+    const archiveRecord = await recordFile(spec.logs_root, archive, "logs");
+    outputs.push(archiveRecord);
+    context.outputs.push(archiveRecord);
+  }
+  await verifyRecordsUnchanged(manifest, spec);
+  for (const reference of spec.references) {
+    const referenceOutputs = await copyMaterial(reference, spec.staging_root, spec.tests_root, "tests", false);
+    outputs.push(...referenceOutputs);
+    context.outputs.push(...referenceOutputs);
+  }
+  const frozenOutputCount = context.outputs.length;
+  const evaluators = [];
+  const evaluatorOrder = new Map(spec.evaluators.map((evaluator, index) => [evaluator.id, index]));
+  const executionOrder = [...spec.evaluators].sort((left, right) => Number(left.type === "sandbox_command") - Number(right.type === "sandbox_command"));
+  for (const evaluator of executionOrder) {
+    assertBudget(context);
+    const started = Date.now();
+    try {
+      const evaluated = await evaluateOne(evaluator, spec, finalOutput.buffer.toString("utf8"), trajectory, { finalOutputPath, trajectoryPath }, context);
+      assertBudget(context);
+      evaluators.push(evaluated);
+      context.evaluators.push(evaluated);
+      if (evaluated.stdout) {
+        outputs.push(evaluated.stdout);
+        context.outputs.push(evaluated.stdout);
+      }
+      if (evaluated.stderr) {
+        outputs.push(evaluated.stderr);
+        context.outputs.push(evaluated.stderr);
+      }
+    } catch (error2) {
+      const normalized = stableError(error2);
+      const errored = {
+        id: evaluator.id,
+        type: evaluator.type,
+        required: evaluator.required,
+        primary: evaluator.primary,
+        status: "errored",
+        verdict: null,
+        engine: "brainbase-cli",
+        engine_version: VERSION,
+        duration_ms: Date.now() - started,
+        details: {
+          error_code: normalized?.code ?? "phase_failed",
+          error_message: normalized?.message ?? "evaluator execution failed"
+        }
+      };
+      evaluators.push(errored);
+      context.evaluators.push(errored);
+      if (evaluator.required)
+        throw error2;
+      assertBudget(context);
+    }
+  }
+  await verifyRecordsUnchanged([...context.inputs, ...context.outputs.slice(0, frozenOutputCount)], spec);
+  if (!verifyOwnedDirectory(spec.tests_root, "tests", spec) || !verifyOwnedDirectory(spec.logs_root, "logs", spec)) {
+    throw new BenchmarkPhaseError("evidence_tampered", "benchmark evaluator changed an owned phase directory marker");
+  }
+  assertBudget(context);
+  evaluators.sort((left, right) => evaluatorOrder.get(left.id) - evaluatorOrder.get(right.id));
+  return { outputs, evaluators };
+}
+function stableError(error2) {
+  if (error2 instanceof BenchmarkPhaseError) {
+    return { code: error2.code, message: error2.message, details: error2.details };
+  }
+  if (error2 instanceof TarballError) {
+    return { code: "invalid_archive", message: error2.message };
+  }
+  if (error2 instanceof exports_external.ZodError) {
+    return {
+      code: "invalid_spec",
+      message: "benchmark phase spec is invalid",
+      details: error2.issues.map((issue2) => ({
+        path: issue2.path.join("."),
+        code: issue2.code,
+        message: issue2.message
+      }))
+    };
+  }
+  return {
+    code: "phase_failed",
+    message: error2 instanceof Error ? error2.message : "unknown benchmark phase failure"
+  };
+}
+function rawIdentity(value) {
+  if (!value || typeof value !== "object") {
+    return { phase: "unknown", attemptId: null, phaseId: null };
+  }
+  const record3 = value;
+  return {
+    phase: record3.phase === "hydrate" || record3.phase === "evaluate" ? record3.phase : "unknown",
+    attemptId: typeof record3.attempt_id === "string" ? record3.attempt_id : null,
+    phaseId: typeof record3.phase_id === "string" ? record3.phase_id : null
+  };
+}
+function readSpecBytes(specPathInput) {
+  const specPath = path87.resolve(specPathInput);
+  const noFollow = typeof fs79.constants.O_NOFOLLOW === "number" ? fs79.constants.O_NOFOLLOW : 0;
+  let fd;
+  try {
+    fd = fs79.openSync(specPath, fs79.constants.O_RDONLY | noFollow);
+  } catch {
+    throw new BenchmarkPhaseError("spec_read_failed", "spec file could not be read");
+  }
+  try {
+    const stat = fs79.fstatSync(fd);
+    if (!stat.isFile() || stat.size > MAX_SPEC_BYTES) {
+      throw new BenchmarkPhaseError("invalid_spec_file", "spec must be a regular JSON file no larger than 20 MiB");
+    }
+    return readDescriptor(fd);
+  } finally {
+    fs79.closeSync(fd);
+  }
+}
+function validateBenchmarkInvocationBytes(bytes, resultPathInput, expectedPhase) {
+  const digest = sha256(bytes);
+  let raw;
+  try {
+    raw = JSON.parse(bytes.toString("utf8"));
+  } catch {
+    throw new BenchmarkPhaseError("invalid_spec_json", "spec is not valid JSON");
+  }
+  const spec = BenchmarkSpecSchema.parse(raw);
+  if (spec.phase !== expectedPhase) {
+    throw new BenchmarkPhaseError("phase_mismatch", `the ${expectedPhase} command cannot execute a ${spec.phase} spec`);
+  }
+  validateRoots(spec);
+  const resultPath = path87.resolve(resultPathInput);
+  const expectedResultPath = path87.join(path87.resolve(spec.logs_root), "result.json");
+  if (resultPath !== expectedResultPath) {
+    throw new BenchmarkPhaseError("invalid_result_path", `result path must be ${expectedResultPath}`);
+  }
+  return { spec, digest, resultPath };
+}
+function prepareBenchmarkPhaseInvocation(specPathInput, resultPathInput, expectedPhase, startedAt, started) {
+  let raw = undefined;
+  let digest = null;
+  let identity2 = rawIdentity(raw);
+  try {
+    const bytes = readSpecBytes(specPathInput);
+    digest = sha256(bytes);
+    try {
+      raw = JSON.parse(bytes.toString("utf8"));
+    } catch {
+      throw new BenchmarkPhaseError("invalid_spec_json", "spec is not valid JSON");
+    }
+    identity2 = rawIdentity(raw);
+    const { spec, resultPath } = validateBenchmarkInvocationBytes(bytes, resultPathInput, expectedPhase);
+    const invocation = {
+      phase: spec.phase,
+      attempt_id: spec.attempt_id,
+      phase_id: spec.phase_id,
+      spec_digest: digest,
+      timeout_ms: spec.budget.timeout_ms
+    };
+    if (fs79.existsSync(resultPath)) {
+      try {
+        const cached2 = JSON.parse(fs79.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
+          };
+        }
+      } catch {}
+    }
+    return { ok: true, invocation, spec_bytes: bytes };
+  } catch (error2) {
+    return {
+      ok: false,
+      result: {
+        schema_version: SCHEMA_VERSION,
+        cli_version: VERSION,
+        phase: identity2.phase === "unknown" ? expectedPhase : identity2.phase,
+        attempt_id: identity2.attemptId,
+        phase_id: identity2.phaseId,
+        spec_digest: digest,
+        status: "failed",
+        started_at: startedAt,
+        completed_at: nowIso(),
+        duration_ms: Date.now() - started,
+        steps: [],
+        inputs: [],
+        outputs: [],
+        error: stableError(error2)
+      }
+    };
+  }
+}
+function writeBenchmarkPhaseTimeoutResult(specBytes, resultPathInput, expectedPhase, startedAt, started) {
+  const { spec, digest, resultPath } = validateBenchmarkInvocationBytes(specBytes, resultPathInput, expectedPhase);
+  const result2 = {
+    schema_version: SCHEMA_VERSION,
+    cli_version: VERSION,
+    phase: spec.phase,
+    attempt_id: spec.attempt_id,
+    phase_id: spec.phase_id,
+    spec_digest: digest,
+    status: "failed",
+    started_at: startedAt,
+    completed_at: nowIso(),
+    duration_ms: Date.now() - started,
+    steps: [],
+    inputs: [],
+    outputs: [],
+    error: {
+      code: "phase_timeout",
+      message: "phase budget expired"
+    }
+  };
+  try {
+    prepareOwnedDirectory(spec.logs_root, "logs", spec);
+    writeJsonAtomic(resultPath, result2);
+  } catch (error2) {
+    result2.error.details = {
+      result_write_error: error2 instanceof Error ? error2.message : "failed to write timeout result"
+    };
+  }
+  return result2;
+}
+async function runBenchmarkPhase(specPathInput, resultPathInput, expectedPhase, immutableSpecBytes) {
+  const startedAt = nowIso();
+  const started = Date.now();
+  const resultPath = path87.resolve(resultPathInput);
+  let raw = undefined;
+  let digest = null;
+  let identity2 = rawIdentity(raw);
+  const steps = [];
+  let inputs = [];
+  let outputs = [];
+  let evaluators;
+  let status = "failed";
+  let error2;
+  let context;
+  let resultPathValidated = false;
+  try {
+    let bytes;
+    if (immutableSpecBytes) {
+      bytes = immutableSpecBytes;
+      if (bytes.length > MAX_SPEC_BYTES) {
+        throw new BenchmarkPhaseError("invalid_spec_file", "spec must be a regular JSON file no larger than 20 MiB");
+      }
+    } else {
+      bytes = readSpecBytes(specPathInput);
+    }
+    digest = sha256(bytes);
+    try {
+      raw = JSON.parse(bytes.toString("utf8"));
+    } catch {
+      throw new BenchmarkPhaseError("invalid_spec_json", "spec is not valid JSON");
+    }
+    identity2 = rawIdentity(raw);
+    const spec = BenchmarkSpecSchema.parse(raw);
+    if (expectedPhase && spec.phase !== expectedPhase) {
+      throw new BenchmarkPhaseError("phase_mismatch", `the ${expectedPhase} command cannot execute a ${spec.phase} spec`);
+    }
+    validateRoots(spec);
+    const expectedResultPath = path87.join(path87.resolve(spec.logs_root), "result.json");
+    if (resultPath !== expectedResultPath) {
+      throw new BenchmarkPhaseError("invalid_result_path", `result path must be ${expectedResultPath}`);
+    }
+    resultPathValidated = true;
+    if (fs79.existsSync(resultPath)) {
+      try {
+        const cached2 = JSON.parse(fs79.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 };
+        }
+      } catch {}
+    }
+    context = {
+      deadline: started + spec.budget.timeout_ms,
+      remainingOutputBytes: spec.budget.max_output_bytes,
+      steps,
+      evaluators: [],
+      inputs: [],
+      outputs: [],
+      logsOwned: false
+    };
+    if (spec.phase === "hydrate") {
+      outputs = await executeHydrate(spec, context);
+    } else {
+      const evaluated = await executeEvaluate(spec, context);
+      outputs = evaluated.outputs;
+      evaluators = evaluated.evaluators;
+    }
+    inputs = context.inputs;
+    status = "succeeded";
+  } catch (caught) {
+    error2 = stableError(caught);
+    if (context) {
+      inputs = context.inputs;
+      outputs = context.outputs;
+      if (context.evaluators.length)
+        evaluators = context.evaluators;
+    }
+  }
+  const result2 = {
+    schema_version: SCHEMA_VERSION,
+    cli_version: VERSION,
+    phase: identity2.phase === "unknown" && expectedPhase ? expectedPhase : identity2.phase,
+    attempt_id: identity2.attemptId,
+    phase_id: identity2.phaseId,
+    spec_digest: digest,
+    status,
+    started_at: startedAt,
+    completed_at: nowIso(),
+    duration_ms: Date.now() - started,
+    steps,
+    inputs,
+    outputs,
+    ...evaluators ? { evaluators } : {},
+    ...error2 ? { error: error2 } : {}
+  };
+  if (!resultPathValidated || !context?.logsOwned) {
+    return { exitCode: status === "succeeded" ? 0 : 1, result: result2 };
+  }
+  try {
+    writeJsonAtomic(resultPath, result2);
+  } catch (writeError) {
+    result2.status = "failed";
+    result2.error = {
+      code: "result_write_failed",
+      message: writeError instanceof Error ? writeError.message : "failed to write result"
+    };
+    return { exitCode: 1, result: result2 };
+  }
+  return { exitCode: status === "succeeded" ? 0 : 1, result: result2 };
+}
+
+// src/cli/benchmark.ts
+function parsePhaseArgs(args) {
+  let spec;
+  let result2;
+  let json = false;
+  const seen = new Set;
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--json") {
+      if (seen.has(arg))
+        throw new Error(`Duplicate benchmark option: ${arg}`);
+      seen.add(arg);
+      json = true;
+      continue;
+    }
+    if (arg === "--spec" || arg === "--result") {
+      if (seen.has(arg))
+        throw new Error(`Duplicate benchmark option: ${arg}`);
+      seen.add(arg);
+      const value = args[index + 1];
+      if (!value || value.startsWith("--")) {
+        throw new Error(`${arg} requires a path`);
+      }
+      if (arg === "--spec")
+        spec = value;
+      else
+        result2 = value;
+      index += 1;
+      continue;
+    }
+    throw new Error(`Unknown benchmark argument: ${arg}`);
+  }
+  if (!spec)
+    throw new Error("--spec is required");
+  if (!result2)
+    throw new Error("--result is required");
+  if (!json)
+    throw new Error("--json is required for benchmark phase commands");
+  return { spec, result: result2, json: true };
+}
+function argumentFailure(phase, message) {
+  const timestamp = new Date().toISOString();
+  return {
+    schema_version: "1",
+    cli_version: VERSION,
+    phase,
+    attempt_id: null,
+    phase_id: null,
+    spec_digest: null,
+    status: "failed",
+    started_at: timestamp,
+    completed_at: timestamp,
+    duration_ms: 0,
+    steps: [],
+    inputs: [],
+    outputs: [],
+    error: {
+      code: "invalid_arguments",
+      message
+    }
+  };
+}
+function phaseFailure(invocation, startedAt, started, code, message) {
+  return {
+    schema_version: "1",
+    cli_version: VERSION,
+    phase: invocation.phase,
+    attempt_id: invocation.attempt_id,
+    phase_id: invocation.phase_id,
+    spec_digest: invocation.spec_digest,
+    status: "failed",
+    started_at: startedAt,
+    completed_at: new Date().toISOString(),
+    duration_ms: Date.now() - started,
+    steps: [],
+    inputs: [],
+    outputs: [],
+    error: { code, message }
+  };
+}
+function descendantPids2(parentPid) {
+  if (process.platform === "win32")
+    return [];
+  try {
+    const output = execFileSync3("ps", ["-eo", "pid=,ppid="], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const children = new Map;
+    for (const line of output.split(`
+`)) {
+      const [pidRaw, parentRaw] = line.trim().split(/\s+/);
+      const pid = Number(pidRaw);
+      const parent = Number(parentRaw);
+      if (!Number.isInteger(pid) || !Number.isInteger(parent))
+        continue;
+      const current = children.get(parent) ?? [];
+      current.push(pid);
+      children.set(parent, current);
+    }
+    const descendants = [];
+    const stack = [...children.get(parentPid) ?? []];
+    while (stack.length > 0) {
+      const pid = stack.pop();
+      descendants.push(pid);
+      stack.push(...children.get(pid) ?? []);
+    }
+    return descendants;
+  } catch {
+    return [];
+  }
+}
+function terminatePhase(child) {
+  if (child.pid === undefined)
+    return;
+  for (const pid of descendantPids2(child.pid).reverse()) {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {}
+  }
+  try {
+    if (process.platform !== "win32")
+      process.kill(-child.pid, "SIGKILL");
+    else
+      child.kill("SIGKILL");
+  } catch {
+    child.kill("SIGKILL");
+  }
+}
+function createAnonymousSpecFd(bytes) {
+  const temporary = path88.join(os17.tmpdir(), `brainbase-benchmark-spec-${process.pid}-${crypto7.randomBytes(12).toString("hex")}`);
+  fs80.writeFileSync(temporary, bytes, { flag: "wx", mode: 384 });
+  try {
+    const fd = fs80.openSync(temporary, "r");
+    fs80.unlinkSync(temporary);
+    return fd;
+  } catch (error2) {
+    fs80.rmSync(temporary, { force: true });
+    throw error2;
+  }
+}
+async function runSupervisedPhase(phase, parsed, write) {
+  const startedAt = new Date().toISOString();
+  const started = Date.now();
+  const prepared = prepareBenchmarkPhaseInvocation(parsed.spec, parsed.result, phase, startedAt, started);
+  if (!prepared.ok) {
+    write(`${JSON.stringify(prepared.result)}
+`);
+    return 1;
+  }
+  if (prepared.cached_result) {
+    write(`${JSON.stringify(prepared.cached_result)}
+`);
+    return 0;
+  }
+  const { invocation, spec_bytes: specBytes } = prepared;
+  const deadline = started + invocation.timeout_ms;
+  const entrypoint = process.argv[1];
+  if (!entrypoint) {
+    const failure = phaseFailure(invocation, startedAt, started, "phase_supervisor_failed", "benchmark phase supervisor could not resolve the CLI entrypoint");
+    write(`${JSON.stringify(failure)}
+`);
+    return 1;
+  }
+  const remainingMs = deadline - Date.now();
+  if (remainingMs <= 0) {
+    let failure = phaseFailure(invocation, startedAt, started, "phase_timeout", "phase budget expired");
+    try {
+      failure = writeBenchmarkPhaseTimeoutResult(specBytes, parsed.result, phase, startedAt, started);
+    } catch {}
+    write(`${JSON.stringify(failure)}
+`);
+    return 1;
+  }
+  const childToken = crypto7.randomBytes(32).toString("hex");
+  let specFd;
+  try {
+    specFd = createAnonymousSpecFd(specBytes);
+  } catch {
+    const failure = phaseFailure(invocation, startedAt, started, "phase_supervisor_failed", "benchmark phase supervisor could not snapshot the validated spec");
+    write(`${JSON.stringify(failure)}
+`);
+    return 1;
+  }
+  let child;
+  try {
+    child = spawn5(process.execPath, [
+      entrypoint,
+      "benchmark",
+      "__phase-child",
+      phase,
+      "--result",
+      parsed.result,
+      "--spec-fd",
+      "3",
+      "--token",
+      childToken
+    ], {
+      env: {
+        ...process.env,
+        BRAINBASE_BENCHMARK_PHASE_CHILD_TOKEN: childToken
+      },
+      stdio: ["ignore", "pipe", "pipe", specFd],
+      detached: process.platform !== "win32"
+    });
+  } catch {
+    fs80.closeSync(specFd);
+    const failure = phaseFailure(invocation, startedAt, started, "phase_supervisor_failed", "benchmark phase child process could not be started");
+    write(`${JSON.stringify(failure)}
+`);
+    return 1;
+  }
+  fs80.closeSync(specFd);
+  return await new Promise((resolve) => {
+    const stdout = [];
+    let settled = false;
+    let timedOut = false;
+    let timer;
+    const expire = () => {
+      if (settled || timedOut)
+        return;
+      timedOut = true;
+      terminatePhase(child);
+    };
+    const remainingAfterSpawn = deadline - Date.now();
+    if (remainingAfterSpawn <= 0)
+      queueMicrotask(expire);
+    else
+      timer = setTimeout(expire, remainingAfterSpawn);
+    child.stdout?.on("data", (chunk2) => {
+      if (!timedOut)
+        stdout.push(chunk2);
+    });
+    child.stderr?.resume();
+    child.on("error", () => {
+      if (settled)
+        return;
+      settled = true;
+      if (timer)
+        clearTimeout(timer);
+      const failure = phaseFailure(invocation, startedAt, started, "phase_supervisor_failed", "benchmark phase child process could not be started");
+      write(`${JSON.stringify(failure)}
+`);
+      resolve(1);
+    });
+    child.on("close", (code) => {
+      if (settled)
+        return;
+      settled = true;
+      if (timer)
+        clearTimeout(timer);
+      if (Date.now() >= deadline)
+        timedOut = true;
+      if (timedOut) {
+        let failure = phaseFailure(invocation, startedAt, started, "phase_timeout", "phase budget expired");
+        try {
+          failure = writeBenchmarkPhaseTimeoutResult(specBytes, parsed.result, phase, startedAt, started);
+        } catch {}
+        write(`${JSON.stringify(failure)}
+`);
+        resolve(1);
+        return;
+      }
+      const output = Buffer.concat(stdout).toString("utf8");
+      if (!output) {
+        const failure = phaseFailure(invocation, startedAt, started, "phase_supervisor_failed", "benchmark phase child exited without a result");
+        write(`${JSON.stringify(failure)}
+`);
+        resolve(1);
+        return;
+      }
+      write(output.endsWith(`
+`) ? output : `${output}
+`);
+      resolve(code === 0 ? 0 : 1);
+    });
+  });
+}
+async function runBenchmark(sub, args, write = (value) => process.stdout.write(value)) {
+  switch (sub) {
+    case "__phase-child": {
+      const [
+        phase,
+        resultFlag,
+        resultPath,
+        specFdFlag,
+        specFdRaw,
+        tokenFlag,
+        token
+      ] = args;
+      const specFd = Number(specFdRaw);
+      if (phase !== "hydrate" && phase !== "evaluate" || resultFlag !== "--result" || !resultPath || specFdFlag !== "--spec-fd" || !Number.isInteger(specFd) || specFd < 3 || tokenFlag !== "--token" || !token || token !== process.env.BRAINBASE_BENCHMARK_PHASE_CHILD_TOKEN) {
+        throw new Error("Invalid internal benchmark phase invocation");
+      }
+      const specBytes = fs80.readFileSync(specFd);
+      const { exitCode, result: result2 } = await runBenchmarkPhase("", resultPath, phase, specBytes);
+      write(`${JSON.stringify(result2)}
+`);
+      return exitCode;
+    }
+    case "hydrate":
+    case "evaluate": {
+      let parsed;
+      try {
+        parsed = parsePhaseArgs(args);
+      } catch (error2) {
+        const failure = argumentFailure(sub, error2 instanceof Error ? error2.message : "invalid benchmark arguments");
+        write(`${JSON.stringify(failure)}
+`);
+        return 1;
+      }
+      return await runSupervisedPhase(sub, parsed, write);
+    }
+    case "capabilities": {
+      if (args.length !== 1 || args[0] !== "--json") {
+        throw new Error("Usage: brainbase benchmark capabilities --json");
+      }
+      write(`${JSON.stringify(BENCHMARK_CAPABILITIES)}
+`);
+      return 0;
+    }
+    case undefined:
+    case "help":
+    case "-h":
+    case "--help":
+      printHelp5();
+      return 0;
+    default:
+      throw new Error(`Unknown benchmark subcommand: ${sub}`);
+  }
+}
+function printHelp5() {
+  const out = [];
+  out.push("");
+  out.push(`  ${import_picocolors48.default.bold("brainbase benchmark")} ${import_picocolors48.default.dim("<sub> [options]")}`);
+  out.push("");
+  out.push(`  ${import_picocolors48.default.cyan("hydrate")} ${import_picocolors48.default.dim("--spec <path> --result <path> --json")}`);
+  out.push(`  ${import_picocolors48.default.cyan("evaluate")} ${import_picocolors48.default.dim("--spec <path> --result <path> --json")}`);
+  out.push(`  ${import_picocolors48.default.cyan("capabilities")} ${import_picocolors48.default.dim("--json")}`);
+  out.push("");
+  out.push(`  ${import_picocolors48.default.dim("These machine-only commands execute versioned benchmark phase specs inside a task sandbox.")}`);
+  out.push("");
+  console.log(out.join(`
+`));
+}
+
 // src/index.ts
 var PROTECTED = new Set([
   "template",
@@ -77050,115 +78992,121 @@ var STORED_PAT_COMMANDS = new Set([
 function help() {
   const out = [];
   out.push("");
-  out.push(`  ${brandTint("◆")}  ${import_picocolors48.default.bold("brainbase")}  ${import_picocolors48.default.dim(`v${VERSION}`)}`);
-  out.push(`     ${import_picocolors48.default.dim("connect your local agent to the brainbase platform")}`);
+  out.push(`  ${brandTint("◆")}  ${import_picocolors49.default.bold("brainbase")}  ${import_picocolors49.default.dim(`v${VERSION}`)}`);
+  out.push(`     ${import_picocolors49.default.dim("connect your local agent to the brainbase platform")}`);
   out.push("");
   out.push(divider("USAGE"));
   out.push("");
-  out.push(`  ${import_picocolors48.default.bold("brainbase")} ${import_picocolors48.default.dim("<command> [options]")}`);
+  out.push(`  ${import_picocolors49.default.bold("brainbase")} ${import_picocolors49.default.dim("<command> [options]")}`);
   out.push("");
   out.push(divider("AUTH"));
   out.push("");
-  out.push(`  ${import_picocolors48.default.cyan("login")}     ${import_picocolors48.default.dim("  open the web app and connect this device")}`);
-  out.push(`  ${import_picocolors48.default.cyan("logout")}    ${import_picocolors48.default.dim("  clear the local session")}`);
-  out.push(`  ${import_picocolors48.default.cyan("whoami")}    ${import_picocolors48.default.dim("  show the current user")}`);
+  out.push(`  ${import_picocolors49.default.cyan("login")}     ${import_picocolors49.default.dim("  open the web app and connect this device")}`);
+  out.push(`  ${import_picocolors49.default.cyan("logout")}    ${import_picocolors49.default.dim("  clear the local session")}`);
+  out.push(`  ${import_picocolors49.default.cyan("whoami")}    ${import_picocolors49.default.dim("  show the current user")}`);
   out.push("");
   out.push(divider("DISCOVERY"));
   out.push("");
-  out.push(`  ${import_picocolors48.default.cyan("team list")}                  ${import_picocolors48.default.dim("show the teams you can create agents in")}`);
-  out.push(`  ${import_picocolors48.default.cyan("agent list")}                 ${import_picocolors48.default.dim("show a team's agents and their ids")}`);
+  out.push(`  ${import_picocolors49.default.cyan("team list")}                  ${import_picocolors49.default.dim("show the teams you can create agents in")}`);
+  out.push(`  ${import_picocolors49.default.cyan("agent list")}                 ${import_picocolors49.default.dim("show a team's agents and their ids")}`);
   out.push("");
   out.push(divider("LINKED AGENT"));
   out.push("");
-  out.push(`  ${import_picocolors48.default.cyan("agent create")}               ${import_picocolors48.default.dim("claim an unclaimed brainbase.agent.yaml and create the cloud agent")}`);
-  out.push(`  ${import_picocolors48.default.cyan("agent pull")} ${import_picocolors48.default.dim("[<id>]")}          ${import_picocolors48.default.dim("bring cloud changes into this folder (--force to override; --run-entrypoint to also execute the agent entrypoint)")}`);
-  out.push(`  ${import_picocolors48.default.cyan("agent push")}                 ${import_picocolors48.default.dim("send local changes to the cloud (--force to overwrite cloud-side conflicts with local)")}`);
-  out.push(`  ${import_picocolors48.default.cyan("agent unpack")}               ${import_picocolors48.default.dim("install the claimed agent into a harness layout")}`);
-  out.push(`  ${import_picocolors48.default.cyan("link")}                       ${import_picocolors48.default.dim("attach this folder to an existing agent")}`);
-  out.push(`  ${import_picocolors48.default.cyan("agent status")}               ${import_picocolors48.default.dim("show what would pull and what would push")}`);
-  out.push(`  ${import_picocolors48.default.cyan("agent env")}                  ${import_picocolors48.default.dim("print export lines for `eval $(brainbase agent env)`")}`);
-  out.push(`  ${import_picocolors48.default.cyan("run")} ${import_picocolors48.default.dim("<cmd> [args...]")}         ${import_picocolors48.default.dim("run <cmd> with secrets.env loaded into env")}`);
-  out.push(`  ${import_picocolors48.default.cyan("status")}                     ${import_picocolors48.default.dim("show what this folder is linked to")}`);
-  out.push(`  ${import_picocolors48.default.cyan("unlink")}                     ${import_picocolors48.default.dim("disconnect this folder")}`);
+  out.push(`  ${import_picocolors49.default.cyan("agent create")}               ${import_picocolors49.default.dim("claim an unclaimed brainbase.agent.yaml and create the cloud agent")}`);
+  out.push(`  ${import_picocolors49.default.cyan("agent pull")} ${import_picocolors49.default.dim("[<id>]")}          ${import_picocolors49.default.dim("bring cloud changes into this folder (--force to override; --run-entrypoint to also execute the agent entrypoint)")}`);
+  out.push(`  ${import_picocolors49.default.cyan("agent push")}                 ${import_picocolors49.default.dim("send local changes to the cloud (--force to overwrite cloud-side conflicts with local)")}`);
+  out.push(`  ${import_picocolors49.default.cyan("agent unpack")}               ${import_picocolors49.default.dim("install the claimed agent into a harness layout")}`);
+  out.push(`  ${import_picocolors49.default.cyan("link")}                       ${import_picocolors49.default.dim("attach this folder to an existing agent")}`);
+  out.push(`  ${import_picocolors49.default.cyan("agent status")}               ${import_picocolors49.default.dim("show what would pull and what would push")}`);
+  out.push(`  ${import_picocolors49.default.cyan("agent env")}                  ${import_picocolors49.default.dim("print export lines for `eval $(brainbase agent env)`")}`);
+  out.push(`  ${import_picocolors49.default.cyan("run")} ${import_picocolors49.default.dim("<cmd> [args...]")}         ${import_picocolors49.default.dim("run <cmd> with secrets.env loaded into env")}`);
+  out.push(`  ${import_picocolors49.default.cyan("status")}                     ${import_picocolors49.default.dim("show what this folder is linked to")}`);
+  out.push(`  ${import_picocolors49.default.cyan("unlink")}                     ${import_picocolors49.default.dim("disconnect this folder")}`);
   out.push("");
   out.push(divider("TASKS"));
   out.push("");
-  out.push(`  ${import_picocolors48.default.cyan("task create")} ${import_picocolors48.default.dim("--message <text>")}   ${import_picocolors48.default.dim("create a managed task and start its first run")}`);
+  out.push(`  ${import_picocolors49.default.cyan("task create")} ${import_picocolors49.default.dim("--message <text>")}   ${import_picocolors49.default.dim("create a managed task and start its first run")}`);
+  out.push("");
+  out.push(divider("BENCHMARK RUNTIME"));
+  out.push("");
+  out.push(`  ${import_picocolors49.default.cyan("benchmark hydrate")} ${import_picocolors49.default.dim("--spec <path> --result <path> --json")}`);
+  out.push(`  ${import_picocolors49.default.cyan("benchmark evaluate")} ${import_picocolors49.default.dim("--spec <path> --result <path> --json")}`);
+  out.push(`  ${import_picocolors49.default.cyan("benchmark capabilities")} ${import_picocolors49.default.dim("--json")}`);
   out.push("");
   out.push(divider("ORCHESTRATIONS"));
   out.push("");
-  out.push(`  ${import_picocolors48.default.cyan("orchestration create")}           ${import_picocolors48.default.dim("claim a local orchestration manifest and create it in the cloud")}`);
-  out.push(`  ${import_picocolors48.default.cyan("orchestration list")}             ${import_picocolors48.default.dim("list orchestrations under a team")}`);
-  out.push(`  ${import_picocolors48.default.cyan("orchestration pull")} ${import_picocolors48.default.dim("<id>")}        ${import_picocolors48.default.dim("recursively fetch an orchestration + every member agent")}`);
-  out.push(`  ${import_picocolors48.default.cyan("orchestration push")}             ${import_picocolors48.default.dim("recursively push each member, then update the graph")}`);
-  out.push(`  ${import_picocolors48.default.cyan("orchestration status")}           ${import_picocolors48.default.dim("show what would push and what would pull")}`);
+  out.push(`  ${import_picocolors49.default.cyan("orchestration create")}           ${import_picocolors49.default.dim("claim a local orchestration manifest and create it in the cloud")}`);
+  out.push(`  ${import_picocolors49.default.cyan("orchestration list")}             ${import_picocolors49.default.dim("list orchestrations under a team")}`);
+  out.push(`  ${import_picocolors49.default.cyan("orchestration pull")} ${import_picocolors49.default.dim("<id>")}        ${import_picocolors49.default.dim("recursively fetch an orchestration + every member agent")}`);
+  out.push(`  ${import_picocolors49.default.cyan("orchestration push")}             ${import_picocolors49.default.dim("recursively push each member, then update the graph")}`);
+  out.push(`  ${import_picocolors49.default.cyan("orchestration status")}           ${import_picocolors49.default.dim("show what would push and what would pull")}`);
   out.push("");
   out.push(divider("TEMPLATES"));
   out.push("");
-  out.push(`  ${import_picocolors48.default.cyan("template pack")}                       ${import_picocolors48.default.dim("bundle the current agent into a template")}`);
-  out.push(`  ${import_picocolors48.default.cyan("template publish")}                    ${import_picocolors48.default.dim("upload a template to the registry")}`);
-  out.push(`  ${import_picocolors48.default.cyan("template search")} ${import_picocolors48.default.dim("[query]")}             ${import_picocolors48.default.dim("search the registry")}`);
-  out.push(`  ${import_picocolors48.default.cyan("template info")}    ${import_picocolors48.default.dim("<creator/slug>")}     ${import_picocolors48.default.dim("show registry details for a template")}`);
-  out.push(`  ${import_picocolors48.default.cyan("template onboard")} ${import_picocolors48.default.dim("<creator/slug>")}     ${import_picocolors48.default.dim("install (or refresh) a template")}`);
-  out.push(`  ${import_picocolors48.default.cyan("template list")}                       ${import_picocolors48.default.dim("show installed templates")}`);
-  out.push(`  ${import_picocolors48.default.cyan("template remove")}  ${import_picocolors48.default.dim("<creator/slug>")}     ${import_picocolors48.default.dim("uninstall a template")}`);
+  out.push(`  ${import_picocolors49.default.cyan("template pack")}                       ${import_picocolors49.default.dim("bundle the current agent into a template")}`);
+  out.push(`  ${import_picocolors49.default.cyan("template publish")}                    ${import_picocolors49.default.dim("upload a template to the registry")}`);
+  out.push(`  ${import_picocolors49.default.cyan("template search")} ${import_picocolors49.default.dim("[query]")}             ${import_picocolors49.default.dim("search the registry")}`);
+  out.push(`  ${import_picocolors49.default.cyan("template info")}    ${import_picocolors49.default.dim("<creator/slug>")}     ${import_picocolors49.default.dim("show registry details for a template")}`);
+  out.push(`  ${import_picocolors49.default.cyan("template onboard")} ${import_picocolors49.default.dim("<creator/slug>")}     ${import_picocolors49.default.dim("install (or refresh) a template")}`);
+  out.push(`  ${import_picocolors49.default.cyan("template list")}                       ${import_picocolors49.default.dim("show installed templates")}`);
+  out.push(`  ${import_picocolors49.default.cyan("template remove")}  ${import_picocolors49.default.dim("<creator/slug>")}     ${import_picocolors49.default.dim("uninstall a template")}`);
   out.push("");
   out.push(divider("SKILLS"));
   out.push("");
-  out.push(`  ${import_picocolors48.default.cyan("skill add")} ${import_picocolors48.default.dim("<source>")}                  ${import_picocolors48.default.dim("install a skill (github / git / brainbase)")}`);
-  out.push(`  ${import_picocolors48.default.cyan("skill list")}                            ${import_picocolors48.default.dim("show locally installed skills + their source")}`);
-  out.push(`  ${import_picocolors48.default.cyan("skill update")} ${import_picocolors48.default.dim("<slug>")}                  ${import_picocolors48.default.dim("re-fetch a skill from its recorded source")}`);
-  out.push(`  ${import_picocolors48.default.cyan("skill remove")} ${import_picocolors48.default.dim("<slug>")}                  ${import_picocolors48.default.dim("uninstall a skill")}`);
-  out.push(`  ${import_picocolors48.default.cyan("skill search")} ${import_picocolors48.default.dim("[query]")}                 ${import_picocolors48.default.dim("search the brainbase skill registry")}`);
-  out.push(`  ${import_picocolors48.default.cyan("skill info")} ${import_picocolors48.default.dim("<creator/slug>")}            ${import_picocolors48.default.dim("show registry details for a skill")}`);
-  out.push(`  ${import_picocolors48.default.cyan("skill publish")} ${import_picocolors48.default.dim("[dir]")}                  ${import_picocolors48.default.dim("publish a SKILL.md folder (defaults to .)")}`);
+  out.push(`  ${import_picocolors49.default.cyan("skill add")} ${import_picocolors49.default.dim("<source>")}                  ${import_picocolors49.default.dim("install a skill (github / git / brainbase)")}`);
+  out.push(`  ${import_picocolors49.default.cyan("skill list")}                            ${import_picocolors49.default.dim("show locally installed skills + their source")}`);
+  out.push(`  ${import_picocolors49.default.cyan("skill update")} ${import_picocolors49.default.dim("<slug>")}                  ${import_picocolors49.default.dim("re-fetch a skill from its recorded source")}`);
+  out.push(`  ${import_picocolors49.default.cyan("skill remove")} ${import_picocolors49.default.dim("<slug>")}                  ${import_picocolors49.default.dim("uninstall a skill")}`);
+  out.push(`  ${import_picocolors49.default.cyan("skill search")} ${import_picocolors49.default.dim("[query]")}                 ${import_picocolors49.default.dim("search the brainbase skill registry")}`);
+  out.push(`  ${import_picocolors49.default.cyan("skill info")} ${import_picocolors49.default.dim("<creator/slug>")}            ${import_picocolors49.default.dim("show registry details for a skill")}`);
+  out.push(`  ${import_picocolors49.default.cyan("skill publish")} ${import_picocolors49.default.dim("[dir]")}                  ${import_picocolors49.default.dim("publish a SKILL.md folder (defaults to .)")}`);
   out.push("");
   out.push(divider("CLI TOKENS"));
   out.push("");
-  out.push(`  ${import_picocolors48.default.cyan("token create")}                        ${import_picocolors48.default.dim("issue a long-lived CLI key for CI / scripts")}`);
-  out.push(`  ${import_picocolors48.default.cyan("token list")}                          ${import_picocolors48.default.dim("show your active tokens")}`);
-  out.push(`  ${import_picocolors48.default.cyan("token revoke")} ${import_picocolors48.default.dim("<id>")}                  ${import_picocolors48.default.dim("revoke a token")}`);
+  out.push(`  ${import_picocolors49.default.cyan("token create")}                        ${import_picocolors49.default.dim("issue a long-lived CLI key for CI / scripts")}`);
+  out.push(`  ${import_picocolors49.default.cyan("token list")}                          ${import_picocolors49.default.dim("show your active tokens")}`);
+  out.push(`  ${import_picocolors49.default.cyan("token revoke")} ${import_picocolors49.default.dim("<id>")}                  ${import_picocolors49.default.dim("revoke a token")}`);
   out.push("");
   out.push(divider("MCP"));
   out.push("");
-  out.push(`  ${import_picocolors48.default.cyan("mcp check")} ${import_picocolors48.default.dim("[--json]")}              ${import_picocolors48.default.dim("verify MCP server connectivity through the brainbase proxy (runs at sandbox bootstrap)")}`);
+  out.push(`  ${import_picocolors49.default.cyan("mcp check")} ${import_picocolors49.default.dim("[--json]")}              ${import_picocolors49.default.dim("verify MCP server connectivity through the brainbase proxy (runs at sandbox bootstrap)")}`);
   out.push("");
   out.push(divider("FLAGS"));
   out.push("");
-  out.push(`  ${import_picocolors48.default.dim("--harness <id>")}     force harness for onboard / sync (e.g. claude-code)`);
-  out.push(`  ${import_picocolors48.default.dim("--scope <s>")}        force scope: global | project`);
-  out.push(`  ${import_picocolors48.default.dim("--yes, -y")}          skip confirmations / auto-overwrite`);
-  out.push(`  ${import_picocolors48.default.dim("--agent <id>")}       for link/task create: use this agent id explicitly`);
-  out.push(`  ${import_picocolors48.default.dim("--message <text>")}   for task create: required first user message`);
-  out.push(`  ${import_picocolors48.default.dim("--title <text>")}     for task create: optional task title`);
-  out.push(`  ${import_picocolors48.default.dim("--model <id>")}       for task create: optional model override`);
-  out.push(`  ${import_picocolors48.default.dim("--org <id-or-slug>")} pick the organization (team/agent list, agent create, orchestration create/list)`);
-  out.push(`  ${import_picocolors48.default.dim("--team <id>")}        pick the team, same commands (works without --org)`);
-  out.push(`  ${import_picocolors48.default.dim("--json")}             for team/agent list, task create, mcp check: machine-readable output`);
-  out.push(`  ${import_picocolors48.default.dim("--no-tracking")}      for link: skip routing LLM traffic through brainbase`);
-  out.push(`  ${import_picocolors48.default.dim("--track")}            for agent create: enable tracking non-interactively (off without a TTY)`);
-  out.push(`  ${import_picocolors48.default.dim("--shell <sh|fish>")}  for agent env: pick output format (auto-detected from $SHELL)`);
-  out.push(`  ${import_picocolors48.default.dim("--all")}              for template list: include installs from other folders`);
-  out.push(`  ${import_picocolors48.default.dim("--web <url>")}        for login: web app URL (default https://app.brainbaselabs.com)`);
+  out.push(`  ${import_picocolors49.default.dim("--harness <id>")}     force harness for onboard / sync (e.g. claude-code)`);
+  out.push(`  ${import_picocolors49.default.dim("--scope <s>")}        force scope: global | project`);
+  out.push(`  ${import_picocolors49.default.dim("--yes, -y")}          skip confirmations / auto-overwrite`);
+  out.push(`  ${import_picocolors49.default.dim("--agent <id>")}       for link/task create: use this agent id explicitly`);
+  out.push(`  ${import_picocolors49.default.dim("--message <text>")}   for task create: required first user message`);
+  out.push(`  ${import_picocolors49.default.dim("--title <text>")}     for task create: optional task title`);
+  out.push(`  ${import_picocolors49.default.dim("--model <id>")}       for task create: optional model override`);
+  out.push(`  ${import_picocolors49.default.dim("--org <id-or-slug>")} pick the organization (team/agent list, agent create, orchestration create/list)`);
+  out.push(`  ${import_picocolors49.default.dim("--team <id>")}        pick the team, same commands (works without --org)`);
+  out.push(`  ${import_picocolors49.default.dim("--json")}             machine-readable output for supported commands`);
+  out.push(`  ${import_picocolors49.default.dim("--no-tracking")}      for link: skip routing LLM traffic through brainbase`);
+  out.push(`  ${import_picocolors49.default.dim("--track")}            for agent create: enable tracking non-interactively (off without a TTY)`);
+  out.push(`  ${import_picocolors49.default.dim("--shell <sh|fish>")}  for agent env: pick output format (auto-detected from $SHELL)`);
+  out.push(`  ${import_picocolors49.default.dim("--all")}              for template list: include installs from other folders`);
+  out.push(`  ${import_picocolors49.default.dim("--web <url>")}        for login: web app URL (default https://app.brainbaselabs.com)`);
   out.push("");
   out.push(divider("ENV"));
   out.push("");
-  out.push(`  ${import_picocolors48.default.dim("BRAINBASE_HOME")}         override the local config dir (default ~/.brainbase)`);
-  out.push(`  ${import_picocolors48.default.dim("BRAINBASE_WEB_URL")}      override the web app URL used by login`);
-  out.push(`  ${import_picocolors48.default.dim("BRAINBASE_CONTROL_PLANE_URL")} override the MAS host (/v2/cli; task create uses /v2/tasks)`);
-  out.push(`  ${import_picocolors48.default.dim("BRAINBASE_API_URL")}      legacy KLS host override (uses /api/cli; proxy/registry fallback)`);
-  out.push(`  ${import_picocolors48.default.dim("BRAINBASE_PROXY_URL")}    override the model-proxy URL used by harness traffic (default https://api.v1.brainbaselabs.com)`);
-  out.push(`  ${import_picocolors48.default.dim("BRAINBASE_REGISTRY_URL")} override the registry API URL (default https://api.v1.brainbaselabs.com)`);
-  out.push(`  ${import_picocolors48.default.dim("BRAINBASE_TOKEN")}        long-lived CLI PAT (overrides token.json)`);
-  out.push(`  ${import_picocolors48.default.dim("BRAINBASE_SKIP_AUTH")}    bypass the auth gate for development`);
-  out.push(`  ${import_picocolors48.default.dim("BRAINBASE_NON_INTERACTIVE")} force non-interactive mode — skip/auto-default prompts (CI & agents)`);
-  out.push(`  ${import_picocolors48.default.dim("BRAINBASE_RUN_ENTRYPOINT")} =1 → agent pull executes the agent entrypoint (sandbox boots; or pass --run-entrypoint)`);
+  out.push(`  ${import_picocolors49.default.dim("BRAINBASE_HOME")}         override the local config dir (default ~/.brainbase)`);
+  out.push(`  ${import_picocolors49.default.dim("BRAINBASE_WEB_URL")}      override the web app URL used by login`);
+  out.push(`  ${import_picocolors49.default.dim("BRAINBASE_CONTROL_PLANE_URL")} override the MAS host (/v2/cli; task create uses /v2/tasks)`);
+  out.push(`  ${import_picocolors49.default.dim("BRAINBASE_API_URL")}      legacy KLS host override (uses /api/cli; proxy/registry fallback)`);
+  out.push(`  ${import_picocolors49.default.dim("BRAINBASE_PROXY_URL")}    override the model-proxy URL used by harness traffic (default https://api.v1.brainbaselabs.com)`);
+  out.push(`  ${import_picocolors49.default.dim("BRAINBASE_REGISTRY_URL")} override the registry API URL (default https://api.v1.brainbaselabs.com)`);
+  out.push(`  ${import_picocolors49.default.dim("BRAINBASE_TOKEN")}        long-lived CLI PAT (overrides token.json)`);
+  out.push(`  ${import_picocolors49.default.dim("BRAINBASE_SKIP_AUTH")}    bypass the auth gate for development`);
+  out.push(`  ${import_picocolors49.default.dim("BRAINBASE_NON_INTERACTIVE")} force non-interactive mode — skip/auto-default prompts (CI & agents)`);
+  out.push(`  ${import_picocolors49.default.dim("BRAINBASE_RUN_ENTRYPOINT")} =1 → agent pull executes the agent entrypoint (sandbox boots; or pass --run-entrypoint)`);
   out.push("");
   out.push(divider("HARNESSES"));
   out.push("");
-  out.push(`  ${import_picocolors48.default.dim("•")} ${import_picocolors48.default.bold("claude-code")}  ${import_picocolors48.default.dim("skills, mcps, agents, commands, playbooks, instructions, files")}`);
-  out.push(`  ${import_picocolors48.default.dim("•")} ${import_picocolors48.default.bold("codex")}        ${import_picocolors48.default.dim("skills, mcps, commands, playbooks, instructions, files")}`);
-  out.push(`  ${import_picocolors48.default.dim("•")} ${import_picocolors48.default.bold("kafka")}        ${import_picocolors48.default.dim("skills, mcps, agents, commands, playbooks, instructions, files")}`);
+  out.push(`  ${import_picocolors49.default.dim("•")} ${import_picocolors49.default.bold("claude-code")}  ${import_picocolors49.default.dim("skills, mcps, agents, commands, playbooks, instructions, files")}`);
+  out.push(`  ${import_picocolors49.default.dim("•")} ${import_picocolors49.default.bold("codex")}        ${import_picocolors49.default.dim("skills, mcps, commands, playbooks, instructions, files")}`);
+  out.push(`  ${import_picocolors49.default.dim("•")} ${import_picocolors49.default.bold("kafka")}        ${import_picocolors49.default.dim("skills, mcps, agents, commands, playbooks, instructions, files")}`);
   out.push("");
   console.log(out.join(`
 `));
@@ -77222,13 +79170,13 @@ async function requireAuth(cmd) {
   if (STORED_PAT_COMMANDS.has(cmd) && readToken())
     return;
   console.error("");
-  console.error(`  ${brandTint("◆")}  ${import_picocolors48.default.bold("brainbase")}`);
+  console.error(`  ${brandTint("◆")}  ${import_picocolors49.default.bold("brainbase")}`);
   console.error("");
-  console.error(`  ${import_picocolors48.default.red("✗")}  You need to sign in to use ${import_picocolors48.default.bold("brainbase " + cmd)}.`);
+  console.error(`  ${import_picocolors49.default.red("✗")}  You need to sign in to use ${import_picocolors49.default.bold("brainbase " + cmd)}.`);
   if (status.reason)
-    console.error(`     ${import_picocolors48.default.dim(status.reason)}`);
+    console.error(`     ${import_picocolors49.default.dim(status.reason)}`);
   console.error("");
-  console.error(`     Run ${import_picocolors48.default.cyan("brainbase login")} to connect this device.`);
+  console.error(`     Run ${import_picocolors49.default.cyan("brainbase login")} to connect this device.`);
   console.error("");
   process14.exit(1);
 }
@@ -77238,7 +79186,7 @@ async function main() {
   const rawCwd = process14.cwd();
   const cwd2 = (() => {
     try {
-      return fs79.realpathSync(rawCwd);
+      return fs81.realpathSync(rawCwd);
     } catch {
       return rawCwd;
     }
@@ -77251,7 +79199,7 @@ async function main() {
     await runRun(cwd2, argv);
     return;
   }
-  const sharedArgs = cmd === "task" ? [] : argv;
+  const sharedArgs = cmd === "task" || cmd === "benchmark" ? [] : argv;
   const yes = hasFlag2(sharedArgs, "--yes", "-y");
   const all = hasFlag2(sharedArgs, "--all");
   const harness = getFlag(sharedArgs, "--harness");
@@ -77380,6 +79328,11 @@ async function main() {
         await runTask(cwd2, sub, argv);
         break;
       }
+      case "benchmark": {
+        const sub = argv.shift();
+        process14.exitCode = await runBenchmark(sub, argv);
+        break;
+      }
       case "orchestration":
       case "orch": {
         const sub = argv.shift();
@@ -77419,10 +79372,10 @@ async function main() {
         process14.exit(1);
     }
   } catch (err) {
-    console.error(import_picocolors48.default.red(`
+    console.error(import_picocolors49.default.red(`
 ${err.message}`));
     if (err instanceof ApiError && err.status === 401) {
-      console.error(`  Run ${import_picocolors48.default.cyan("brainbase login")} to connect this device.`);
+      console.error(`  Run ${import_picocolors49.default.cyan("brainbase login")} to connect this device.`);
     }
     if (process14.env.BRAINBASE_DEBUG)
       console.error(err.stack);