firegoat 0.7.0 → 0.9.0

package/dist/cli.js

@@ -6947,19 +6947,17 @@ var require_public_api = __commonJS(function(exports) {
 // package.json
 var package_default = {
   name: "firegoat",
-  version: "0.7.0",
+  version: "0.9.0",
   repository: {
     type: "git",
-    url: "git+https://github.com/team2027/firegoat-cli.git"
+    url: "git+https://github.com/firegoat-ai/firegoat-cli.git"
   },
   devDependencies: {
     "@biomejs/biome": "^2.5.15",
     "@types/bun": "latest",
+    typescript: "^7",
     yaml: "^2.9.1"
   },
-  peerDependencies: {
-    typescript: "^7"
-  },
   bin: {
     firegoat: "dist/cli.js"
   },
@@ -6970,7 +6968,7 @@ var package_default = {
   files: [
     "dist"
   ],
-  homepage: "https://github.com/team2027/firegoat-cli#readme",
+  homepage: "https://github.com/firegoat-ai/firegoat-cli#readme",
   license: "MIT",
   publishConfig: {
     access: "public"
@@ -6987,411 +6985,8 @@ var package_default = {
   packageManager: "bun@1.4.3"
 };
 
-// src/claude-login.ts
-import { spawnSync as spawnSync2 } from "node:child_process";
-import { mkdirSync as mkdirSync3 } from "node:fs";
-
-// src/auth.ts
-import {
-  chmodSync,
-  existsSync as existsSync2,
-  mkdirSync as mkdirSync2,
-  readFileSync,
-  writeFileSync
-} from "node:fs";
-import { join as join2 } from "node:path";
-
-// src/sandbox.ts
-import { spawnSync } from "node:child_process";
-import { existsSync, mkdirSync, realpathSync } from "node:fs";
-import { homedir } from "node:os";
-import { basename, dirname, join } from "node:path";
-var SANDBOX_EXEC = "/usr/bin/sandbox-exec";
-function firegoatHome() {
-  return process.env.FIREGOAT_HOME || join(homedir(), ".firegoat");
-}
-function claudeConfigDir() {
-  return join(firegoatHome(), "claude");
-}
-var TOOLCHAINS = [
-  ".nvm",
-  ".fnm",
-  ".volta",
-  ".bun",
-  ".deno",
-  ".cargo",
-  ".rustup",
-  ".pyenv",
-  ".rbenv",
-  ".asdf",
-  ".sdkman",
-  ".local/share/mise",
-  ".local/share/fnm",
-  ".local/share/claude",
-  ".local/share/uv",
-  "go",
-  "Library/pnpm"
-];
-var TOOLCHAIN_SECRETS = [".cargo/credentials", ".cargo/credentials.toml"];
-function real(p) {
-  return realpathSync(p);
-}
-function under(p, dir) {
-  return p === dir || p.startsWith(`${dir}/`);
-}
-function readableToolDirs(home, claudeBin) {
-  const dirs = new Set;
-  const add = (p) => {
-    if (existsSync(p))
-      dirs.add(real(p));
-  };
-  for (const t of TOOLCHAINS)
-    add(join(home, t));
-  for (const p of (process.env.PATH ?? "").split(":")) {
-    if (!p.startsWith("/") || !existsSync(p))
-      continue;
-    const r = real(p);
-    if (!under(r, home) || r === home)
-      continue;
-    const prefix = dirname(r);
-    dirs.add(basename(r) === "bin" && prefix !== home && prefix !== join(home, ".local") ? prefix : r);
-  }
-  add(dirname(dirname(process.execPath)));
-  add(dirname(claudeBin));
-  add(dirname(real(claudeBin)));
-  return [...dirs];
-}
-var q = (s) => JSON.stringify(s);
-function sandboxProfile(opts) {
-  const home = real(homedir());
-  const reads = readableToolDirs(home, opts.claudeBin).map((d) => `(subpath ${q(d)})`);
-  return `(version 1)
-(allow default)
-
-(deny file-read* (subpath ${q(home)}))
-(allow file-read-metadata)
-(allow file-read*
-  ${reads.join(`
-  `)}
-  (subpath ${q(join(home, "Library/Keychains"))})
-  (regex ${q(`^${home}/Library/Preferences/com\\.apple\\.security`)})
-  (regex ${q(`^${home}/Library/Preferences/\\.GlobalPreferences`)}))
-(deny file-read* file-write*
-  ${TOOLCHAIN_SECRETS.map((s) => `(literal ${q(join(home, s))})`).join(`
-  `)})
-
-(deny file-write* (subpath "/"))
-(allow file-write*
-  (subpath "/dev")
-  (subpath "/private/tmp")
-  (subpath "/private/var/folders"))
-(allow file-read* file-write*
-  (subpath ${q(real(opts.configDir))})
-  (subpath ${q(real(opts.runRoot))}))
-
-(deny file-read* file-write* (subpath ${q(real(opts.repo))}))
-`;
-}
-function agentEnv(runRoot, apiKey) {
-  const env = { ...process.env };
-  delete env.ANTHROPIC_API_KEY;
-  if (apiKey)
-    env.ANTHROPIC_API_KEY = apiKey;
-  const cache = join(runRoot, "cache");
-  const tmp = join(runRoot, "tmp");
-  mkdirSync(cache, { recursive: true });
-  mkdirSync(tmp, { recursive: true });
-  return {
-    ...env,
-    CLAUDE_CONFIG_DIR: claudeConfigDir(),
-    TMPDIR: tmp,
-    XDG_CACHE_HOME: cache,
-    npm_config_cache: join(cache, "npm"),
-    npm_config_store_dir: join(cache, "pnpm-store"),
-    YARN_CACHE_FOLDER: join(cache, "yarn"),
-    BUN_INSTALL_CACHE_DIR: join(cache, "bun"),
-    PIP_CACHE_DIR: join(cache, "pip"),
-    UV_CACHE_DIR: join(cache, "uv"),
-    GOMODCACHE: join(cache, "gomod"),
-    GOCACHE: join(cache, "gobuild"),
-    CARGO_HOME: join(cache, "cargo")
-  };
-}
-function wrap(profile, cmd, args) {
-  if (profile === null)
-    return { cmd, args };
-  return { cmd: SANDBOX_EXEC, args: ["-p", profile, cmd, ...args] };
-}
-function probeSandbox(opts) {
-  const outside = join(homedir(), `.firegoat-escape-probe-${process.pid}-${Date.now()}`);
-  const script = 'touch "$1" 2>/dev/null && echo home-write; cat "$2" >/dev/null 2>&1 && echo repo-read; touch "$3" 2>/dev/null && echo work-write; rm -f "$1" "$3"';
-  const { cmd, args } = wrap(opts.profile, "/bin/sh", [
-    "-c",
-    script,
-    "probe",
-    outside,
-    opts.repoFile,
-    join(opts.workdir, ".firegoat-probe")
-  ]);
-  const r = spawnSync(cmd, args, { encoding: "utf8", cwd: opts.workdir });
-  if (r.error)
-    return `sandbox probe could not start: ${r.error.message}`;
-  const got = r.stdout.trim().split(`
-`).filter(Boolean);
-  if (got.includes("home-write") || got.includes("repo-read"))
-    return `sandbox does not hold (escaped: ${got.filter((g) => g !== "work-write").join(", ")}); refusing to run the agent`;
-  if (!got.includes("work-write"))
-    return `sandbox blocks writes in the workdir (stderr: ${r.stderr.trim() || "none"})`;
-  return;
-}
-
-// src/auth.ts
-var authFile = () => join2(firegoatHome(), "auth.json");
-var keyFile = () => join2(firegoatHome(), "anthropic-api-key");
-
-class AuthError extends Error {
-}
-function readMethod() {
-  const file = authFile();
-  if (!existsSync2(file))
-    return;
-  let doc;
-  try {
-    doc = JSON.parse(readFileSync(file, "utf8"));
-  } catch (e) {
-    throw new AuthError(`${file} is not valid JSON: ${e.message}`);
-  }
-  const method = doc?.method;
-  if (method !== "claude" && method !== "api-key")
-    throw new AuthError(`${file}: method must be "claude" or "api-key", got ${JSON.stringify(method)}. Run: npx firegoat init`);
-  return method;
-}
-function saveMethod(method) {
-  mkdirSync2(firegoatHome(), { recursive: true });
-  writeFileSync(authFile(), `${JSON.stringify({ method }, null, 2)}
-`);
-}
-function saveApiKey(apiKey) {
-  mkdirSync2(firegoatHome(), { recursive: true });
-  const file = keyFile();
-  writeFileSync(file, `${apiKey}
-`, { mode: 384 });
-  chmodSync(file, 384);
-  saveMethod("api-key");
-  return file;
-}
-function looksLikeAnthropicKey(s) {
-  return /^sk-ant-[A-Za-z0-9_-]{20,}$/.test(s);
-}
-function resolveAuth(env) {
-  if (env.CI && env.ANTHROPIC_API_KEY)
-    return {
-      method: "api-key",
-      label: "Anthropic API key from ANTHROPIC_API_KEY (CI)",
-      apiKey: env.ANTHROPIC_API_KEY
-    };
-  const method = readMethod() ?? "claude";
-  if (method === "claude")
-    return {
-      method,
-      label: `Claude login in ${claudeConfigDir()}`
-    };
-  const file = keyFile();
-  if (!existsSync2(file))
-    throw new AuthError(`auth is set to api-key but ${file} is missing. Run: npx firegoat init`);
-  const apiKey = readFileSync(file, "utf8").trim();
-  if (!apiKey)
-    throw new AuthError(`${file} is empty. Run: npx firegoat init`);
-  return { method, label: `Anthropic API key in ${file}`, apiKey };
-}
-
-// src/exit.ts
-var EXIT = { pass: 0, fail: 1, notGraded: 2, usage: 3 };
-
-// src/help.ts
-var EXIT_CODES = `Exit codes:
-  0  every run's script checks passed
-  1  a script check failed
-  2  at least one run was not graded (claude missing or logged out, crash, timeout,
-     setup failed); wins over 1
-  3  usage or config error (bad flag, unknown test, invalid or missing firegoat.yaml)`;
-function topHelp(version) {
-  return `firegoat ${version}: local AX evals. A coding agent gets one prompt in a fresh,
-sandboxed folder; firegoat records the transcript and runs your script checks.
-
-Typical flow (for an agent driving firegoat on behalf of a human):
-  1. npx firegoat init --yes          write firegoat.yaml (read: npx firegoat init --help)
-  2. edit firegoat.yaml               real user problems as prompts, a goal, checks
-  3. ask the human to run once:       npx firegoat claude login   (opens a browser)
-  4. npx firegoat eval --json         run the tests; JSON summary on stdout
-  5. judge each run's goal + rubric yourself, from its run.json, transcript and
-     workdir: firegoat only runs the script checks
-
-Commands:
-  init           write firegoat.yaml; choose how the agent signs in
-  claude login   sign claude in to firegoat's own config dir (interactive, once)
-  eval           run the tests
-  open           open (or --print) a run's folder
-
-Run firegoat <command> --help for details and examples.
-
-${EXIT_CODES}`;
-}
-var INIT_HELP = `Usage: firegoat init [--yes] [--force] [--skills] [--auth claude|api-key]
-
-Writes firegoat.yaml in the current folder with starter tests from what the repo
-ships (package.json, pyproject.toml, go.mod, Cargo.toml, README), and adds
-.firegoat/ to .gitignore. Edit the tests afterwards; they are templates.
-
-  --yes, -y       don't ask questions (default when stdin is not a terminal)
-  --force, -f     overwrite an existing firegoat.yaml
-  --skills        also run: npx skills add team2027/skills --skill firegoat-onboarding
-                  --skill suggesting-eval-prompts (into .claude/skills/)
-  --auth claude   the agent signs in with a Claude login: runs \`firegoat claude login\`
-                  (interactive: a human must complete it in the browser)
-  --auth api-key  the agent signs in with an Anthropic API key, read from stdin when
-                  piped (else asked for without echo) and stored in
-                  ~/.firegoat/anthropic-api-key (mode 0600), never in the repo
-                  Without --auth, init asks (unless --yes). In CI, ANTHROPIC_API_KEY in
-                  the env wins.
-
-firegoat.yaml reference:
-  agents: [claude-code]       only claude-code for now
-  runs: 1                     runs per test
-  setup: <sh> | [<sh>, ...]   once per eval, in the repo, on the host; whatever it
-                              writes to $FIREGOAT_OUT is copied into each run and put
-                              first on the agent's PATH
-  workdir_setup: <sh> | [...] in each fresh workdir before the agent starts
-                              (env: $FIREGOAT_OUT, $FIREGOAT_WORKDIR, vars)
-  vars: {KEY: value}          defaults for {{vars.KEY}}; --var KEY=value overrides
-  tests:
-    - name: quickstart        letters, digits, '.', '_', '-'; unique
-      prompt: ...             what a user would ask the agent; one concrete outcome
-      goal: ...               one sentence that is true when the problem is solved
-      rubric: [...]           optional criteria for whoever grades the run (you)
-      checks:                 optional shell commands, run in the workdir after the
-        - run: ...            agent; exit 0 = pass; they set eval's exit code
-      timeout: 600            optional, seconds
-
-  The agent's folder has no repo files. Checks get $FIREGOAT_WORKDIR,
-  $FIREGOAT_SESSION (stream-json transcript), $FIREGOAT_OUT and the vars.
-  goal and rubric are not run by firegoat: they are handed to the caller to judge.
-
-Example:
-  setup: npm pack --pack-destination "$FIREGOAT_OUT"
-  workdir_setup: npm init -y >/dev/null && npm install "$FIREGOAT_OUT"/*.tgz
-  tests:
-    - name: first-call
-      prompt: >-
-        Using the acme SDK (already installed from the build under test), send a test
-        event and print the event id. Credentials are in ACME_API_KEY. Keep it minimal.
-      goal: A script sends one event and prints its id.
-      rubric:
-        - uses the SDK's client, not raw HTTP
-        - does not install acme from the registry
-      checks:
-        - run: grep -qE 'evt_[A-Za-z0-9]+' "$FIREGOAT_SESSION"
-
-Next: npx firegoat claude login (a human, once), then npx firegoat eval.
-
-Exit codes: 0 done, 2 the skills install or claude login failed, 3 usage error.`;
-var EVAL_HELP = `Usage: firegoat eval [test..] [--runs N] [--var KEY=value].. [--json] [--host]
-                     [--claude-bin PATH]
-
-Runs each test headless: claude gets the prompt in a fresh folder outside the repo,
-sandboxed on macOS (it can't read your home dir or the repo), with setup:'s outputs
-on PATH. Then the test's script checks run in that folder.
-
-  test..             only these tests (by name)
-  --runs N           runs per test (overrides runs: in firegoat.yaml)
-  --var KEY=value    fills {{vars.KEY}}; env for setup, workdir_setup and checks
-  --json             the summary as JSON on stdout; progress goes to stderr
-  --host             no sandbox (required off macOS; use a throwaway container)
-  --claude-bin PATH  claude binary (env FIREGOAT_CLAUDE_BIN; default: claude on PATH)
-
-Sign-in: the one chosen in firegoat init (Claude login or stored API key); in CI,
-ANTHROPIC_API_KEY from the env. eval prints which. Not logged in = exit 2 with the
-command to run.
-
-Output: .firegoat/runs/<runId>/
-  summary.json            every run, plus totals and a grading hint
-  <test>/<n>/run.json     one run: test, n, status and reason (from the checks),
-                          prompt, goal, rubric, checks [{run, code}], and paths:
-                          dir, workdir, session, stderr, checksLog
-  <test>/<n>/session.jsonl  the agent's transcript, stream-json (one event per line)
-  setup.txt, <test>/<n>/workdir_setup.txt, checks.txt   logs
-
-Grading: firegoat runs only the script checks; they set the exit code. The goal and
-rubric are yours to judge, with your own process. session.jsonl is stream-json: the
-last line has type "result" with the agent's final message; tool calls are
-"tool_use" items in "assistant" messages; tool output is in "user" messages.
-
-Examples:
-  npx firegoat eval --json                  all tests, JSON summary on stdout
-  npx firegoat eval quickstart --runs 3     one test, three runs
-  npx firegoat eval --var SHA=$(git rev-parse HEAD)
-
-firegoat.yaml is looked up in the current folder, then parents up to the git root.
-A run can take minutes (default timeout 600s per test).
-
-${EXIT_CODES}`;
-var OPEN_HELP = `Usage: firegoat open [runId] [--print]
-
-Opens a run's folder (.firegoat/runs/<runId>/) with the system opener; the latest
-run by default. --print only prints the path (use this from an agent).
-
-Exit codes: 0 done, 2 the opener failed, 3 no such run.`;
-var CLAUDE_LOGIN_HELP = `Usage: firegoat claude login [--claude-bin PATH]
-
-Signs claude in to firegoat's own config dir (~/.firegoat/claude), once per machine.
-Evals then run on that login, never your ~/.claude. Interactive: it opens a browser,
-so an agent should ask the human to run it. \`firegoat login\` is a deprecated alias.
-
-Exit codes: 0 logged in, 2 claude missing or the login failed, 3 usage error.`;
-
-// src/claude-login.ts
-function claudeLoginCommand(args) {
-  let claudeBin = process.env.FIREGOAT_CLAUDE_BIN || "claude";
-  for (let i = 0;i < args.length; i++) {
-    const a = args[i];
-    if (a === "--help" || a === "-h") {
-      console.log(CLAUDE_LOGIN_HELP);
-      return EXIT.pass;
-    }
-    if (a === "--claude-bin" && args[i + 1] !== undefined)
-      claudeBin = args[++i];
-    else if (a.startsWith("--claude-bin="))
-      claudeBin = a.slice(13);
-    else {
-      console.error(`firegoat claude login: unknown argument: ${a}`);
-      return EXIT.usage;
-    }
-  }
-  const configDir = claudeConfigDir();
-  mkdirSync3(configDir, { recursive: true });
-  const env = {
-    ...process.env,
-    CLAUDE_CONFIG_DIR: configDir
-  };
-  delete env.ANTHROPIC_API_KEY;
-  console.error(`Signing claude in to ${configDir}. Evals run with this login, never your own ~/.claude.`);
-  const r = spawnSync2(claudeBin, ["auth", "login"], { env, stdio: "inherit" });
-  if (r.error) {
-    console.error(`firegoat claude login: could not run ${claudeBin}: ${r.error.message}`);
-    return EXIT.notGraded;
-  }
-  if (r.status !== 0) {
-    console.error(`firegoat claude login: claude auth login exited ${r.status}`);
-    return EXIT.notGraded;
-  }
-  saveMethod("claude");
-  console.log("logged in; evals now sign in with this Claude login. next: npx firegoat eval");
-  return EXIT.pass;
-}
-
 // src/config.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
-import { dirname as dirname2, join as join3 } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
 
 // node_modules/yaml/dist/index.js
 var composer = require_composer();
@@ -7442,7 +7037,6 @@ var $visitAsync = visit.visitAsync;
 // src/config.ts
 var CONFIG_FILE = "firegoat.yaml";
 var DEFAULT_TIMEOUT = 600;
-var SUPPORTED_AGENTS = ["claude-code"];
 
 class ConfigError extends Error {
 }
@@ -7464,6 +7058,11 @@ function posInt(v, path, fallback) {
     fail(path, "must be a positive integer");
   return v;
 }
+function onlyKeys(v, path, allowed) {
+  for (const k of Object.keys(v))
+    if (!allowed.includes(k))
+      fail(path === "(root)" ? k : `${path}.${k}`, `unknown key (allowed: ${allowed.join(", ")})`);
+}
 function parseConfig(text) {
   let raw;
   try {
@@ -7473,17 +7072,8 @@ function parseConfig(text) {
   }
   if (!isRecord(raw))
     fail("(root)", "must be a mapping");
-  const agents = raw.agents === undefined ? ["claude-code"] : raw.agents;
-  if (!Array.isArray(agents) || agents.length === 0)
-    fail("agents", "must be a non-empty list");
-  agents.forEach((a, i) => {
-    if (!SUPPORTED_AGENTS.includes(a)) {
-      fail(`agents[${i}]`, `unsupported agent ${JSON.stringify(a)} (v1 supports: ${SUPPORTED_AGENTS.join(", ")})`);
-    }
-  });
+  onlyKeys(raw, "(root)", ["runs", "setup", "workdir_setup", "vars", "tests"]);
   const runs = posInt(raw.runs, "runs", 1);
-  if (raw.build !== undefined)
-    fail("build", "was replaced by setup: in firegoat 0.4.0: a shell command (or list) that writes what the agent gets to $FIREGOAT_OUT");
   const setup = commands(raw.setup, "setup");
   const workdirSetup = commands(raw.workdir_setup, "workdir_setup");
   const vars = parseVars(raw.vars);
@@ -7494,6 +7084,7 @@ function parseConfig(text) {
     const p = `tests[${i}]`;
     if (!isRecord(t))
       fail(p, "must be a mapping");
+    onlyKeys(t, p, ["name", "prompt", "end_goal", "checks", "timeout"]);
     const name = str(t.name, `${p}.name`);
     if (!NAME.test(name))
       fail(`${p}.name`, "may only contain letters, digits, '.', '_' and '-'");
@@ -7504,27 +7095,22 @@ function parseConfig(text) {
     if (!Array.isArray(checksRaw))
       fail(`${p}.checks`, "must be a list");
     const checks = [];
-    const rubric = rubricOf(t.rubric, `${p}.rubric`);
     checksRaw.forEach((c, j) => {
       const cp = `${p}.checks[${j}]`;
       if (!isRecord(c))
         fail(cp, "must be a mapping");
-      if ("judge" in c)
-        rubric.push(str(c.judge, `${cp}.judge`));
-      else
-        checks.push({ run: str(c.run, `${cp}.run`) });
+      onlyKeys(c, cp, ["run"]);
+      checks.push({ run: str(c.run, `${cp}.run`) });
     });
     return {
       name,
       prompt: str(t.prompt, `${p}.prompt`),
-      goal: str(t.goal, `${p}.goal`),
-      rubric,
+      end_goal: str(t.end_goal, `${p}.end_goal`),
       checks,
       timeout: posInt(t.timeout, `${p}.timeout`, DEFAULT_TIMEOUT)
     };
   });
   return {
-    agents,
     runs,
     setup,
     workdirSetup,
@@ -7533,15 +7119,6 @@ function parseConfig(text) {
   };
 }
 var NAME = /^[A-Za-z0-9._-]+$/;
-function rubricOf(raw, path) {
-  if (raw === undefined)
-    return [];
-  if (typeof raw === "string")
-    return [str(raw, path)];
-  if (!Array.isArray(raw))
-    fail(path, "must be a string or a list of strings");
-  return raw.map((r, i) => str(r, `${path}[${i}]`));
-}
 function commands(raw, path) {
   if (raw === undefined)
     return [];
@@ -7581,258 +7158,132 @@ function render(text, vars) {
 }
 function loadConfig(dir) {
   const file = `${dir}/${CONFIG_FILE}`;
-  if (!existsSync3(file))
+  if (!existsSync(file))
     throw new ConfigError(`${CONFIG_FILE} not found in ${dir}. Run: npx firegoat init`);
-  return parseConfig(readFileSync2(file, "utf8"));
-}
-function findConfigDir(cwd) {
-  let dir = cwd;
-  for (;; ) {
-    if (existsSync3(join3(dir, CONFIG_FILE)))
-      return dir;
-    const parent = dirname2(dir);
-    if (existsSync3(join3(dir, ".git")) || parent === dir)
-      return cwd;
-    dir = parent;
-  }
+  return parseConfig(readFileSync(file, "utf8"));
 }
 
 // src/eval.ts
 import { randomBytes } from "node:crypto";
 import {
-  createWriteStream as createWriteStream3,
-  existsSync as existsSync4,
-  mkdirSync as mkdirSync5,
-  mkdtempSync,
-  readFileSync as readFileSync3,
-  realpathSync as realpathSync2,
+  createWriteStream as createWriteStream2,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2,
+  readdirSync,
   writeFileSync as writeFileSync2
 } from "node:fs";
-import { tmpdir } from "node:os";
-import { join as join6, resolve as resolve2 } from "node:path";
+import { delimiter as delimiter2, join as join3 } from "node:path";
 
 // src/claude.ts
-import { spawn, spawnSync as spawnSync3 } from "node:child_process";
-import { createWriteStream } from "node:fs";
-import { createInterface } from "node:readline";
+import { spawn, spawnSync } from "node:child_process";
 var CLAUDE_FLAGS = [
   "--output-format",
   "stream-json",
   "--verbose",
   "--dangerously-skip-permissions",
-  "--no-session-persistence",
   "--strict-mcp-config",
   "--setting-sources",
-  ""
+  "",
+  "--disable-slash-commands"
 ];
-function claudeArgv(prompt) {
-  return ["-p", prompt, ...CLAUDE_FLAGS];
-}
-var live = new Set;
-function killGroup(child, signal) {
-  if (child.pid === undefined)
-    return;
-  try {
-    process.kill(-child.pid, signal);
-  } catch {
-    try {
-      child.kill(signal);
-    } catch {}
-  }
-}
-var signalsHooked = false;
-function hookSignals() {
-  if (signalsHooked)
-    return;
-  signalsHooked = true;
-  for (const sig of ["SIGINT", "SIGTERM"]) {
-    process.on(sig, () => {
-      for (const c of live)
-        killGroup(c, "SIGKILL");
-      process.exit(sig === "SIGINT" ? 130 : 143);
-    });
-  }
+function claudeEnv(configDir) {
+  return {
+    ...process.env,
+    CLAUDE_CONFIG_DIR: configDir,
+    CLAUDE_SECURESTORAGE_CONFIG_DIR: ""
+  };
 }
-function spawnWatched(opts) {
-  hookSignals();
+function run(opts) {
   return new Promise((resolve) => {
-    let child;
-    try {
-      child = spawn(opts.cmd, opts.args, {
-        cwd: opts.cwd,
-        env: opts.env,
-        stdio: ["ignore", "pipe", "pipe"],
-        detached: true,
-        shell: false
-      });
-    } catch (e) {
-      resolve({
-        code: null,
-        timedOut: false,
-        spawnError: e
-      });
-      return;
-    }
-    live.add(child);
+    const child = spawn(opts.cmd, opts.args, {
+      cwd: opts.cwd,
+      env: opts.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
     let timedOut = false;
-    let done = false;
-    let exitCode = null;
-    let exited = false;
-    let linesDone = !opts.onLine;
-    let stderrDone = false;
-    let stdoutDone = !!opts.onLine;
-    let graceTimer;
-    const finish = (r) => {
-      if (done)
+    let settled = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGKILL");
+    }, opts.timeoutMs);
+    const done = (r) => {
+      if (settled)
         return;
-      done = true;
+      settled = true;
       clearTimeout(timer);
-      clearTimeout(killTimer);
-      clearTimeout(graceTimer);
-      live.delete(child);
       resolve(r);
     };
-    const maybeFinish = () => {
-      if (exited && linesDone && stderrDone && stdoutDone)
-        finish({ code: exitCode, timedOut });
-    };
-    let killTimer;
-    const stop = () => {
-      killGroup(child, "SIGTERM");
-      killTimer = setTimeout(() => killGroup(child, "SIGKILL"), 3000);
-    };
-    const timer = setTimeout(() => {
-      timedOut = true;
-      stop();
-    }, opts.timeoutMs);
-    child.on("error", (err) => {
-      if (child.pid === undefined)
-        finish({ code: null, timedOut: false, spawnError: err });
-    });
-    child.on("exit", (code) => {
-      exited = true;
-      exitCode = code;
-      graceTimer = setTimeout(() => {
-        child.stdout?.destroy();
-        child.stderr?.destroy();
-        finish({ code: exitCode, timedOut });
-      }, 2000);
-      maybeFinish();
-    });
-    child.stderr?.on("data", opts.onStderr);
-    child.stderr?.on("close", () => {
-      stderrDone = true;
-      maybeFinish();
-    });
-    if (opts.onLine) {
-      const onLine = opts.onLine;
-      const rl = createInterface({
-        input: child.stdout
-      });
-      rl.on("line", (line) => {
-        if (onLine(line) === "kill")
-          stop();
-      });
-      rl.on("close", () => {
-        linesDone = true;
-        maybeFinish();
-      });
-    } else {
-      if (opts.onStdout)
-        child.stdout?.on("data", opts.onStdout);
-      child.stdout?.on("close", () => {
-        stdoutDone = true;
-        maybeFinish();
-      });
-    }
+    child.stdout.on("data", opts.onStdout);
+    child.stderr.on("data", opts.onStderr);
+    child.on("error", (error) => done({ code: null, timedOut, error }));
+    child.on("close", (code) => done({ code, timedOut }));
+    child.on("exit", (code) => setTimeout(() => {
+      child.stdout.destroy();
+      child.stderr.destroy();
+      done({ code, timedOut });
+    }, 2000).unref());
   });
 }
-function closeStream(s) {
-  return new Promise((r) => s.end(r));
-}
 async function runClaude(opts) {
-  const session = createWriteStream(opts.sessionPath);
-  const stderr = createWriteStream(opts.stderrPath);
-  let first = true;
-  let badStart;
-  let result;
-  const spawned = await spawnWatched({
-    ...wrap(opts.profile, opts.bin, claudeArgv(opts.prompt)),
+  let stdout = "";
+  const exited = await run({
+    cmd: opts.bin,
+    args: ["-p", opts.prompt, ...CLAUDE_FLAGS],
     cwd: opts.cwd,
     env: opts.env,
     timeoutMs: opts.timeoutMs,
-    onStderr: (c) => stderr.write(c),
-    onLine: (line) => {
-      session.write(`${line}
-`);
-      if (line.trim() === "")
-        return;
-      let msg;
-      try {
-        const parsed = JSON.parse(line);
-        if (typeof parsed === "object" && parsed !== null)
-          msg = parsed;
-      } catch {}
-      if (first) {
-        first = false;
-        if (msg?.type !== "system" || msg.subtype !== "init") {
-          badStart = `claude output did not start with a system/init stream-json line (got: ${line.slice(0, 120)})`;
-          return "kill";
-        }
-        if (msg.apiKeySource !== opts.keySource) {
-          badStart = opts.keySource === "none" ? `claude would use API key billing (apiKeySource=${JSON.stringify(msg.apiKeySource)}) instead of your Claude login. firegoat removes ANTHROPIC_API_KEY from the agent's env; check apiKeyHelper or other API key settings, then run \`npx firegoat claude login\`` : `claude did not use the configured API key (apiKeySource=${JSON.stringify(msg.apiKeySource)}, expected "ANTHROPIC_API_KEY")`;
-          return "kill";
-        }
-        return;
-      }
-      if (msg?.type === "result")
-        result = msg;
-      return;
-    }
+    onStdout: (c) => {
+      stdout += c.toString();
+    },
+    onStderr: (c) => opts.stderr.write(c)
   });
-  await Promise.all([closeStream(session), closeStream(stderr)]);
-  if (spawned.spawnError) {
-    const e = spawned.spawnError;
-    if (e.code === "ENOENT")
-      return {
-        ok: false,
-        reason: `claude binary not found: ${opts.bin} (install Claude Code, or pass --claude-bin / set FIREGOAT_CLAUDE_BIN)`
-      };
+  if (exited.error)
     return {
       ok: false,
-      reason: `could not start ${opts.bin}: ${e.message}`
+      reason: `could not start ${opts.bin}: ${exited.error.message}`
     };
-  }
-  if (badStart)
-    return { ok: false, reason: badStart };
-  if (spawned.timedOut)
+  const events = stdout.split(`
+`).filter((l) => l.trim() !== "").map((l) => {
+    try {
+      return JSON.parse(l);
+    } catch {
+      return;
+    }
+  });
+  const init = events[0];
+  if (init?.type !== "system" || init.subtype !== "init")
     return {
       ok: false,
-      reason: `timed out after ${opts.timeoutMs / 1000}s`,
-      result
+      reason: `claude did not start a session (exit ${exited.code ?? "by signal"}), see stderr.txt`
     };
-  if (first)
+  const sessionId = String(init.session_id);
+  const result = events.findLast((e) => e?.type === "result");
+  if (exited.timedOut)
     return {
       ok: false,
-      reason: `claude produced no output (exit ${spawned.code ?? "signal"}), see stderr.txt`
+      reason: `timed out after ${opts.timeoutMs / 1000}s`,
+      result,
+      sessionId
     };
   if (!result)
     return {
       ok: false,
-      reason: `claude exited ${spawned.code ?? "by signal"} without a result line, see stderr.txt`
+      reason: `claude exited ${exited.code ?? "by signal"} without a result, see stderr.txt`,
+      sessionId
     };
   if (result.is_error === true || result.subtype !== "success")
     return {
       ok: false,
-      reason: `claude result is an error (subtype=${result.subtype}, is_error=${result.is_error})`,
-      result
+      reason: `claude result is an error (subtype=${result.subtype})`,
+      result,
+      sessionId
     };
-  return { ok: true, result };
+  return { ok: true, result, sessionId };
 }
 async function runShell(opts) {
   opts.log.write(`$ ${opts.run}
 `);
-  const r = await spawnWatched({
+  const r = await run({
     cmd: "/bin/sh",
     args: ["-c", opts.run],
     cwd: opts.cwd,
@@ -7842,8 +7293,8 @@ async function runShell(opts) {
     onStderr: (c) => opts.log.write(c)
   });
   let error;
-  if (r.spawnError)
-    error = `could not start /bin/sh: ${r.spawnError.message}`;
+  if (r.error)
+    error = `could not start /bin/sh: ${r.error.message}`;
   else if (r.timedOut)
     error = `timed out after ${opts.timeoutMs / 1000}s`;
   else if (r.code === null)
@@ -7851,23 +7302,17 @@ async function runShell(opts) {
   opts.log.write(`[exit ${r.code ?? "none"}${error ? `: ${error}` : ""}]
 
 `);
-  const out = { run: opts.run, code: r.code };
-  if (error)
-    out.error = error;
-  if (r.spawnError)
-    out.notStarted = true;
-  return out;
+  return error ? { run: opts.run, code: r.code, error } : { run: opts.run, code: r.code };
 }
 function checkLogin(opts) {
-  const { cmd, args } = wrap(opts.profile, opts.bin, ["auth", "status"]);
-  const r = spawnSync3(cmd, args, {
+  const r = spawnSync(opts.bin, ["auth", "status"], {
     cwd: opts.cwd,
     env: opts.env,
     encoding: "utf8",
     timeout: 30000
   });
   if (r.error)
-    return `could not run claude auth status: ${r.error.message}`;
+    return `could not run ${opts.bin}: ${r.error.message}`;
   let status;
   try {
     status = JSON.parse(r.stdout);
@@ -7875,56 +7320,163 @@ function checkLogin(opts) {
   if (status?.loggedIn === true)
     return;
   if (status?.loggedIn === false)
-    return `claude is not logged in to firegoat's config dir (${opts.env.CLAUDE_CONFIG_DIR}). Run: npx firegoat claude login`;
+    return "claude is not logged in. Run `claude` once and log in (or set ANTHROPIC_API_KEY), then run eval again";
   return `claude auth status gave no login state (exit ${r.status}): ${(r.stdout + r.stderr).trim().slice(0, 300)}`;
 }
 
+// src/exit.ts
+var EXIT = { pass: 0, fail: 1, notGraded: 2, usage: 3 };
+
+// src/firegoat-dir.ts
+import { existsSync as existsSync2, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+function ensureFiregoatDir(root) {
+  const dir = join(root, ".firegoat");
+  mkdirSync(dir, { recursive: true });
+  const ignore = join(dir, ".gitignore");
+  if (!existsSync2(ignore))
+    writeFileSync(ignore, `*
+`);
+  return dir;
+}
+
+// src/help.ts
+var EXIT_CODES = `Exit codes:
+  0  every run's script checks passed
+  1  a script check failed
+  2  at least one run was not graded (claude missing or logged out, crash, timeout,
+     setup failed); wins over 1
+  3  usage or config error (bad flag, unknown test, invalid or missing firegoat.yaml)`;
+function topHelp(version) {
+  return `firegoat ${version}: local AX evals. Your own claude gets one prompt in a fresh
+folder, with none of your claude config; firegoat saves the session and runs your
+script checks.
+
+  npx firegoat init     create firegoat.yaml and .firegoat/, install the skills
+  npx firegoat eval     run the tests (claude must be logged in: run \`claude\` once)
+
+Typical flow for a coding agent driving firegoat:
+  1. read npx firegoat init --help, then edit firegoat.yaml
+  2. npx firegoat eval --json
+  3. judge each run's end_goal from its run.json, session and workdir: firegoat only
+     runs the script checks
+
+Run firegoat <command> --help for details and examples.
+
+${EXIT_CODES}`;
+}
+var INIT_HELP = `Usage: firegoat init [--force] [--no-skills]
+
+In the current folder: creates .firegoat/ (ignored by git through its own .gitignore)
+and a starter firegoat.yaml, installs the firegoat-onboarding and
+suggesting-eval-prompts skills into .claude/skills/ (npx skills add firegoat-ai/skills;
+asks first in a terminal), then prints a prompt to paste into your coding agent.
+
+  --force       replace an existing firegoat.yaml
+  --no-skills   don't install the skills
+
+firegoat.yaml reference:
+  runs: 1                     runs per test
+  setup: <sh> | [<sh>, ...]   once per eval, in this folder; what it writes to
+                              $FIREGOAT_OUT is first on the agent's PATH
+  workdir_setup: <sh> | [...] in each fresh folder before the agent starts
+  vars: {KEY: value}          defaults for {{vars.KEY}} in prompts and checks;
+                              --var KEY=value overrides
+  tests:
+    - name: quickstart        letters, digits, '.', '_', '-'; unique
+      prompt: ...             what a user would ask the agent; one concrete outcome
+      end_goal: ...           what is true when the problem is solved; not graded by
+                              firegoat, handed to you to judge
+      checks:                 optional shell commands, run in the agent's folder
+        - run: ...            afterwards; exit 0 = pass; they set eval's exit code
+      timeout: 600            optional, seconds
+
+  Unknown keys are errors. setup, workdir_setup and checks get the vars as env vars,
+  plus $FIREGOAT_OUT and $FIREGOAT_WORKDIR; checks also get $FIREGOAT_SESSION (the
+  claude session file, one JSON event per line).
+
+Example:
+  setup: npm pack --pack-destination "$FIREGOAT_OUT"
+  workdir_setup: npm init -y >/dev/null && npm install "$FIREGOAT_OUT"/*.tgz
+  tests:
+    - name: first-call
+      prompt: >-
+        Using the acme SDK (already installed from the build under test), send a test
+        event and print the event id. Credentials are in ACME_API_KEY. Keep it minimal.
+      end_goal: >-
+        A script sends one event with the SDK's client (not raw HTTP) and prints its
+        id, without installing acme from the registry.
+      checks:
+        - run: grep -qE 'evt_[A-Za-z0-9]+' "$FIREGOAT_SESSION"
+        - run: |
+            ! grep -Eq 'npm (install|i) [^"]*acme' "$FIREGOAT_SESSION"
+
+Exit codes: 0 done, 2 the skills install failed, 3 usage error.`;
+var EVAL_HELP = `Usage: firegoat eval [test..] [--runs N] [--var KEY=value].. [--json]
+                     [--claude-bin PATH]
+
+Runs each test in firegoat.yaml (in the current folder): your claude gets the prompt
+in a fresh, empty folder, .firegoat/runs/<runId>/<test>/<n>/work, with setup:'s
+outputs on PATH. Then the test's checks run in that folder.
+
+claude runs on its own login (or ANTHROPIC_API_KEY if set, as claude always does)
+with a fresh config dir, .firegoat/.claude: none of your settings, CLAUDE.md,
+plugins, skills or MCP servers. claude saves its session there. There is no
+sandbox: the agent can reach the rest of your machine, including the repo.
+
+  test..             only these tests (by name)
+  --runs N           runs per test (overrides runs: in firegoat.yaml)
+  --var KEY=value    fills {{vars.KEY}}; env for setup, workdir_setup and checks
+  --json             the summary as JSON on stdout (or {error, exitCode} if eval
+                     stops early); progress goes to stderr
+  --claude-bin PATH  claude binary (env FIREGOAT_CLAUDE_BIN; default: claude on PATH)
+
+Output: .firegoat/runs/<runId>/
+  summary.json            every run, plus totals
+  <test>/<n>/run.json     one run: status and reason (from the checks), prompt,
+                          end_goal, checks [{run, code}], and paths: workdir,
+                          session (claude's session file), stderr, checksLog
+  setup.txt, <test>/<n>/workdir_setup.txt, checks.txt   logs
+
+Grading: firegoat runs only the script checks; they set the exit code. end_goal is
+yours to judge. The session is one JSON event per line: "assistant" messages hold
+"tool_use" items (the agent's commands), "user" messages their output.
+
+Examples:
+  npx firegoat eval --json                  all tests, JSON summary on stdout
+  npx firegoat eval quickstart --runs 3     one test, three runs
+  npx firegoat eval --var SHA=$(git rev-parse HEAD)
+
+A run can take minutes (default timeout 600s per test).
+
+${EXIT_CODES}`;
+
 // src/setup.ts
-import { cpSync, createWriteStream as createWriteStream2, mkdirSync as mkdirSync4 } from "node:fs";
-import { delimiter, join as join4 } from "node:path";
-var SETUP_TIMEOUT_MS = 600000;
-async function runAll(commands, cwd, env, logPath, what) {
-  const log = createWriteStream2(logPath);
+import { createWriteStream } from "node:fs";
+var STEP_TIMEOUT_MS = 600000;
+async function runSteps(opts) {
+  const log = createWriteStream(opts.logPath);
   try {
-    for (const run of commands) {
+    for (const run of opts.commands) {
       const r = await runShell({
         run,
-        cwd,
-        env,
-        timeoutMs: SETUP_TIMEOUT_MS,
+        cwd: opts.cwd,
+        env: opts.env,
+        timeoutMs: STEP_TIMEOUT_MS,
         log
       });
       if (r.code !== 0)
-        return `${what} failed (${r.error ?? `exit ${r.code}`}): ${run} (log: ${logPath})`;
+        return `${opts.what} failed (${r.error ?? `exit ${r.code}`}): ${run} (log: ${opts.logPath})`;
     }
     return;
   } finally {
     await new Promise((r) => log.end(r));
   }
 }
-async function setupOnce(opts) {
-  mkdirSync4(opts.out, { recursive: true });
-  return runAll(opts.commands, opts.root, { ...opts.env, FIREGOAT_OUT: opts.out }, opts.logPath, "setup");
-}
-async function prepareRun(opts) {
-  const out = join4(opts.runRoot, "out");
-  if (opts.out === null)
-    mkdirSync4(out);
-  else
-    cpSync(opts.out, out, { recursive: true });
-  const path = [out, opts.env.PATH ?? ""].join(delimiter);
-  const error = await runAll(opts.commands, opts.workdir, {
-    ...opts.env,
-    PATH: path,
-    FIREGOAT_OUT: out,
-    FIREGOAT_WORKDIR: opts.workdir
-  }, opts.logPath, "workdir_setup");
-  return error ? { error } : { out, path };
-}
 
 // src/which.ts
 import { accessSync, constants, statSync } from "node:fs";
-import { delimiter as delimiter2, join as join5, resolve } from "node:path";
+import { delimiter, join as join2, resolve } from "node:path";
 function resolveBin(bin) {
   const executable = (p) => {
     try {
@@ -7936,40 +7488,15 @@ function resolveBin(bin) {
   };
   if (bin.includes("/"))
     return executable(bin) ? resolve(bin) : undefined;
-  for (const dir of (process.env.PATH ?? "").split(delimiter2)) {
-    if (dir && executable(join5(dir, bin)))
-      return join5(dir, bin);
+  for (const dir of (process.env.PATH ?? "").split(delimiter)) {
+    if (dir && executable(join2(dir, bin)))
+      return join2(dir, bin);
   }
   return;
 }
 
 // src/eval.ts
 var CHECK_TIMEOUT_MS = 120000;
-var GRADING_HINT = "firegoat ran only the script checks. The goal and rubric are for the caller to judge, from each run's session (stream-json transcript) and workdir.";
-function blankRun(test, n, dir, prompt) {
-  return {
-    test: test.name,
-    n,
-    status: "error",
-    reason: "",
-    prompt,
-    goal: test.goal,
-    rubric: test.rubric,
-    checks: [],
-    dir,
-    workdir: null,
-    session: join6(dir, "session.jsonl"),
-    stderr: join6(dir, "stderr.txt"),
-    checksLog: join6(dir, "checks.txt"),
-    num_turns: null,
-    cost: null,
-    duration_ms: 0
-  };
-}
-function writeRunJson(r) {
-  writeFileSync2(join6(r.dir, "run.json"), `${JSON.stringify(r, null, 2)}
-`);
-}
 
 class UsageError extends Error {
 }
@@ -7977,7 +7504,6 @@ function parseArgs(args) {
   const opts = {
     names: [],
     json: false,
-    host: false,
     vars: {},
     claudeBin: process.env.FIREGOAT_CLAUDE_BIN || "claude"
   };
@@ -7996,8 +7522,6 @@ function parseArgs(args) {
     };
     if (flag === "--json")
       opts.json = true;
-    else if (flag === "--host")
-      opts.host = true;
     else if (flag === "--var") {
       const kv = value();
       const at = kv.indexOf("=");
@@ -8020,151 +7544,135 @@ function parseArgs(args) {
   }
   return opts;
 }
+function findSession(configDir, sessionId) {
+  const projects = join3(configDir, "projects");
+  if (!existsSync3(projects))
+    return null;
+  for (const d of readdirSync(projects)) {
+    const f = join3(projects, d, `${sessionId}.jsonl`);
+    if (existsSync3(f))
+      return f;
+  }
+  return null;
+}
 function newRunId() {
   const ts = new Date().toISOString().replace(/\.\d+Z$/, "Z").replace(/[-:]/g, "");
   return `${ts}-${randomBytes(2).toString("hex")}`;
 }
-function gitignoreHasFiregoat(cwd) {
-  const file = join6(cwd, ".gitignore");
-  if (!existsSync4(file))
-    return false;
-  return readFileSync3(file, "utf8").split(`
-`).map((l) => l.trim()).some((l) => /^\/?\.firegoat\/?(\*\*?)?$/.test(l));
-}
-function newRunRoot(label) {
-  const runRoot = realpathSync2(mkdtempSync(join6(tmpdir(), `firegoat-${label}-`)));
-  const workdir = join6(runRoot, "work");
-  mkdirSync5(workdir);
-  return { runRoot, workdir };
-}
-function isolate(iso, claudeBin, runRoot, workdir) {
-  if (iso.host)
-    return { profile: null };
-  const profile = sandboxProfile({
-    claudeBin,
-    runRoot,
-    configDir: claudeConfigDir(),
-    repo: iso.repo
-  });
-  const broken = probeSandbox({ profile, workdir, repoFile: iso.repoFile });
-  return broken ? { error: broken } : { profile };
-}
 async function runOne(opts) {
   const { test, n } = opts;
   const started = Date.now();
-  const dir = join6(opts.runDir, test.name, String(n));
-  mkdirSync5(dir, { recursive: true });
-  const summary = blankRun(test, n, dir, render(test.prompt, opts.vars));
-  const session = summary.session;
+  const dir = join3(opts.runDir, test.name, String(n));
+  const workdir = join3(dir, "work");
+  mkdirSync2(workdir, { recursive: true });
+  const r = {
+    test: test.name,
+    n,
+    status: "error",
+    reason: "",
+    prompt: render(test.prompt, opts.vars),
+    end_goal: test.end_goal,
+    checks: [],
+    dir,
+    workdir,
+    session: null,
+    stderr: join3(dir, "stderr.txt"),
+    checksLog: join3(dir, "checks.txt"),
+    num_turns: null,
+    cost: null,
+    duration_ms: 0
+  };
   const done = (status, reason) => {
-    summary.status = status;
-    summary.reason = reason;
-    summary.duration_ms = Date.now() - started;
-    writeRunJson(summary);
-    return summary;
+    r.status = status;
+    r.reason = reason;
+    r.duration_ms = Date.now() - started;
+    writeFileSync2(join3(dir, "run.json"), `${JSON.stringify(r, null, 2)}
+`);
+    return r;
   };
-  const { runRoot, workdir } = newRunRoot(`${test.name}-${n}`);
-  summary.workdir = workdir;
-  const sandbox = isolate(opts.iso, opts.claudeBin, runRoot, workdir);
-  if ("error" in sandbox)
-    return done("error", `not graded: ${sandbox.error}`);
-  const hostEnv = { ...process.env, ...opts.vars };
-  let extra = {};
-  if (opts.out !== null || opts.workdirSetup.length > 0) {
-    const prepared = await prepareRun({
-      out: opts.out,
-      runRoot,
-      workdir,
+  const stepEnv = { ...opts.stepEnv, FIREGOAT_WORKDIR: workdir };
+  if (opts.workdirSetup.length > 0) {
+    const error = await runSteps({
+      what: "workdir_setup",
       commands: opts.workdirSetup,
-      env: hostEnv,
-      logPath: join6(dir, "workdir_setup.txt")
+      cwd: workdir,
+      env: stepEnv,
+      logPath: join3(dir, "workdir_setup.txt")
     });
-    if ("error" in prepared)
-      return done("error", `not graded: ${prepared.error}`);
-    if (opts.out !== null)
-      extra = { PATH: prepared.path, FIREGOAT_OUT: prepared.out };
+    if (error)
+      return done("error", `not graded: ${error}`);
   }
-  const agentPath = extra.PATH ? { PATH: extra.PATH } : {};
+  const stderr = createWriteStream2(r.stderr);
   const outcome = await runClaude({
-    env: {
-      ...agentEnv(runRoot, opts.auth.method === "api-key" ? opts.auth.apiKey : undefined),
-      ...agentPath
-    },
-    keySource: opts.auth.method === "api-key" ? "ANTHROPIC_API_KEY" : "none",
-    profile: sandbox.profile,
     bin: opts.claudeBin,
-    prompt: summary.prompt,
+    prompt: r.prompt,
     cwd: workdir,
-    sessionPath: session,
-    stderrPath: summary.stderr,
+    env: { ...claudeEnv(opts.configDir), PATH: opts.stepEnv.PATH },
+    stderr,
     timeoutMs: test.timeout * 1000
   });
-  if (outcome.result) {
-    summary.num_turns = outcome.result.num_turns ?? null;
-    summary.cost = outcome.result.total_cost_usd ?? null;
-  }
+  await new Promise((res) => stderr.end(res));
+  if (outcome.sessionId)
+    r.session = findSession(opts.configDir, outcome.sessionId);
+  r.num_turns = outcome.result?.num_turns ?? null;
+  r.cost = outcome.result?.total_cost_usd ?? null;
   if (!outcome.ok)
     return done("error", `not graded: ${outcome.reason}`);
-  if (test.checks.length === 0)
-    return done("pass", "no script checks; the goal is for the grader");
-  const log = createWriteStream3(summary.checksLog);
-  const env = {
-    ...process.env,
-    ...hostEnv,
-    ...extra,
-    FIREGOAT_SESSION: resolve2(session),
-    FIREGOAT_WORKDIR: workdir
-  };
-  const results = [];
+  if (!r.session)
+    return done("error", `not graded: claude saved no session file for ${outcome.sessionId} under ${opts.configDir}/projects`);
+  const log = createWriteStream2(r.checksLog);
   try {
-    for (const c of test.checks) {
-      results.push(await runShell({
+    for (const c of test.checks)
+      r.checks.push(await runShell({
         run: render(c.run, opts.vars),
         cwd: workdir,
-        env,
+        env: { ...stepEnv, FIREGOAT_SESSION: r.session },
         timeoutMs: CHECK_TIMEOUT_MS,
         log
       }));
-    }
   } finally {
-    await new Promise((r) => log.end(r));
+    await new Promise((res) => log.end(res));
   }
-  summary.checks = results.map((r) => r.error === undefined ? { run: r.run, code: r.code } : { run: r.run, code: r.code, error: r.error });
-  const broken = results.find((r) => r.notStarted);
-  if (broken)
-    return done("error", `not graded: check ${broken.run}: ${broken.error}`);
-  const failed = results.filter((r) => r.code !== 0);
+  const failed = r.checks.filter((c) => c.code !== 0);
   if (failed.length > 0)
-    return done("fail", failed.map((r) => `check failed (${r.error ?? `exit ${r.code}`}): ${r.run}`).join("; "));
-  return done("pass", `${results.length}/${results.length} checks passed`);
+    return done("fail", failed.map((c) => `check failed (${c.error ?? `exit ${c.code}`}): ${c.run}`).join("; "));
+  return done("pass", test.checks.length === 0 ? "no script checks" : `${r.checks.length}/${r.checks.length} checks passed`);
 }
-async function evalCommand(args, cwd) {
+async function evalCommand(args, root) {
   if (args.includes("--help") || args.includes("-h")) {
     console.log(EVAL_HELP);
     return EXIT.pass;
   }
+  const json = args.includes("--json");
+  const fatal = (exitCode, error) => {
+    console.error(`firegoat eval: ${error}`);
+    if (json)
+      console.log(JSON.stringify({ error, exitCode }));
+    return exitCode;
+  };
   let opts;
   try {
     opts = parseArgs(args);
   } catch (e) {
-    if (e instanceof UsageError) {
-      console.error(`firegoat eval: ${e.message}`);
-      return EXIT.usage;
-    }
+    if (e instanceof UsageError)
+      return fatal(EXIT.usage, e.message);
     throw e;
   }
   const say = opts.json ? console.error : console.log;
-  const warn = console.error;
-  const root = findConfigDir(cwd);
-  const config = loadConfig(root);
+  let config;
+  try {
+    config = loadConfig(root);
+  } catch (e) {
+    if (e instanceof ConfigError)
+      return fatal(EXIT.usage, e.message);
+    throw e;
+  }
   let tests = config.tests;
   if (opts.names.length > 0) {
     const known = new Set(tests.map((t) => t.name));
     const unknown = opts.names.filter((n) => !known.has(n));
-    if (unknown.length > 0) {
-      console.error(`firegoat eval: unknown test ${unknown.map((n) => JSON.stringify(n)).join(", ")} (known: ${[...known].join(", ")})`);
-      return EXIT.usage;
-    }
+    if (unknown.length > 0)
+      return fatal(EXIT.usage, `unknown test ${unknown.map((n) => JSON.stringify(n)).join(", ")} (known: ${[...known].join(", ")})`);
     tests = tests.filter((t) => opts.names.includes(t.name));
   }
   const runs = opts.runs ?? config.runs;
@@ -8172,572 +7680,204 @@ async function evalCommand(args, cwd) {
   const missing = [
     ...new Set(tests.flatMap((t) => [t.prompt, ...t.checks.map((c) => c.run)]).flatMap(varRefs).filter((k) => !(k in vars)))
   ];
-  if (missing.length > 0) {
-    console.error(`firegoat eval: no value for ${missing.map((k) => `{{vars.${k}}}`).join(", ")}: pass --var ${missing[0]}=... or set it under vars: in firegoat.yaml`);
-    return EXIT.usage;
-  }
+  if (missing.length > 0)
+    return fatal(EXIT.usage, `no value for ${missing.map((k) => `{{vars.${k}}}`).join(", ")}: pass --var ${missing[0]}=... or set it under vars: in firegoat.yaml`);
   const claudePath = resolveBin(opts.claudeBin);
-  if (!claudePath) {
-    console.error(`firegoat eval: not graded: claude binary ${JSON.stringify(opts.claudeBin)} not found. Install Claude Code (https://claude.com/claude-code) or pass --claude-bin PATH / FIREGOAT_CLAUDE_BIN.`);
-    return EXIT.notGraded;
-  }
-  if (opts.host)
-    warn("warning: --host: the agent runs without isolation and can read and write your files");
-  else if (process.platform !== "darwin" || !existsSync4(SANDBOX_EXEC)) {
-    console.error(`firegoat eval: isolation needs macOS (${SANDBOX_EXEC}); this is ${process.platform}. In CI or Linux, run inside a throwaway container and pass --host.`);
-    return EXIT.usage;
-  }
-  const iso = {
-    host: opts.host,
-    repo: root,
-    repoFile: join6(root, "firegoat.yaml")
-  };
-  let auth;
-  try {
-    auth = resolveAuth(process.env);
-  } catch (e) {
-    if (e instanceof AuthError) {
-      console.error(`firegoat eval: ${e.message}`);
-      return EXIT.usage;
-    }
-    throw e;
-  }
-  say(`auth: ${auth.label}`);
-  if (auth.method === "claude" && process.env.ANTHROPIC_API_KEY)
-    warn("note: ANTHROPIC_API_KEY in your shell is not passed to the agent (it is used only in CI, or after `firegoat init --auth api-key`)");
-  mkdirSync5(claudeConfigDir(), { recursive: true });
-  const pre = newRunRoot("preflight");
-  const preSandbox = isolate(iso, claudePath, pre.runRoot, pre.workdir);
-  const loginProblem = "error" in preSandbox ? preSandbox.error : auth.method === "claude" ? checkLogin({
+  if (!claudePath)
+    return fatal(EXIT.notGraded, `not graded: claude binary ${JSON.stringify(opts.claudeBin)} not found. Install Claude Code (https://claude.com/claude-code) or pass --claude-bin PATH / FIREGOAT_CLAUDE_BIN.`);
+  const firegoatDir = ensureFiregoatDir(root);
+  const configDir = join3(firegoatDir, ".claude");
+  mkdirSync2(configDir, { recursive: true });
+  const loginProblem = checkLogin({
     bin: claudePath,
-    env: agentEnv(pre.runRoot),
-    profile: preSandbox.profile,
-    cwd: pre.workdir
-  }) : undefined;
-  if (loginProblem) {
-    console.error(`firegoat eval: not graded: ${loginProblem}`);
-    return EXIT.notGraded;
-  }
-  mkdirSync5(join6(root, ".firegoat"), { recursive: true });
-  if (!gitignoreHasFiregoat(root))
-    warn("hint: add .firegoat/ to .gitignore (it holds run traces)");
+    env: claudeEnv(configDir),
+    cwd: root
+  });
+  if (loginProblem)
+    return fatal(EXIT.notGraded, `not graded: ${loginProblem}`);
   const runId = newRunId();
-  const runDir = join6(root, ".firegoat", "runs", runId);
-  mkdirSync5(runDir, { recursive: true });
-  const summaryPath = join6(runDir, "summary.json");
-  let out = null;
+  const runDir = join3(firegoatDir, "runs", runId);
+  const out = join3(runDir, "out");
+  mkdirSync2(out, { recursive: true });
+  const stepEnv = {
+    ...process.env,
+    ...vars,
+    FIREGOAT_OUT: out,
+    PATH: [out, process.env.PATH ?? ""].join(delimiter2)
+  };
   if (config.setup.length > 0) {
     say("setup...");
-    out = join6(runDir, "out");
-    const error = await setupOnce({
+    const error = await runSteps({
+      what: "setup",
       commands: config.setup,
-      root,
-      out,
-      env: { ...process.env, ...vars },
-      logPath: join6(runDir, "setup.txt")
+      cwd: root,
+      env: stepEnv,
+      logPath: join3(runDir, "setup.txt")
     });
-    if (error) {
-      console.error(`firegoat eval: not graded: ${error}`);
-      return EXIT.notGraded;
-    }
+    if (error)
+      return fatal(EXIT.notGraded, `not graded: ${error}`);
   }
   const results = [];
-  const writeSummary = () => {
-    const totals = { pass: 0, fail: 0, error: 0 };
-    for (const r of results)
-      totals[r.status]++;
-    const doc = {
-      runId,
-      runsDir: runDir,
-      isolation: opts.host ? "host" : "seatbelt",
-      auth: auth.method,
-      grading: GRADING_HINT,
-      totals,
-      runs: results
-    };
-    writeFileSync2(summaryPath, `${JSON.stringify(doc, null, 2)}
-`);
-    return doc;
-  };
-  for (const test of tests) {
+  for (const test of tests)
     for (let n = 1;n <= runs; n++) {
-      let r;
-      try {
-        r = await runOne({
-          test,
-          n,
-          runDir,
-          claudeBin: claudePath,
-          iso,
-          auth,
-          out,
-          workdirSetup: config.workdirSetup,
-          vars,
-          warn
-        });
-      } catch (e) {
-        const dir = join6(runDir, test.name, String(n));
-        mkdirSync5(dir, { recursive: true });
-        r = blankRun(test, n, dir, test.prompt);
-        r.reason = `not graded: firegoat crashed: ${e.message}`;
-        writeRunJson(r);
-      }
+      const r = await runOne({
+        test,
+        n,
+        runDir,
+        claudeBin: claudePath,
+        configDir,
+        workdirSetup: config.workdirSetup,
+        stepEnv,
+        vars
+      });
       results.push(r);
-      writeSummary();
       say(`${r.status.toUpperCase()} ${r.test}#${r.n} ${r.reason}`);
     }
-  }
-  const doc = writeSummary();
-  const { pass, fail, error } = doc.totals;
+  const totals = { pass: 0, fail: 0, error: 0 };
+  for (const r of results)
+    totals[r.status]++;
+  const doc = { runId, runsDir: runDir, totals, runs: results };
+  writeFileSync2(join3(runDir, "summary.json"), `${JSON.stringify(doc, null, 2)}
+`);
   say(`
-${pass} passed, ${fail} failed, ${error} not graded (${results.length} runs)`);
-  say(`runs: ${runDir}`);
-  say(`goal and rubric are not graded by firegoat; per run: ${join6(runDir, "<test>", "<n>", "run.json")}`);
+${totals.pass} passed, ${totals.fail} failed, ${totals.error} not graded (${results.length} runs)`);
+  say(`runs: ${runDir} (end_goal is for you to judge: see run.json per run)`);
   if (opts.json)
     console.log(JSON.stringify(doc, null, 2));
-  return error > 0 ? EXIT.notGraded : fail > 0 ? EXIT.fail : EXIT.pass;
+  return totals.error > 0 ? EXIT.notGraded : totals.fail > 0 ? EXIT.fail : EXIT.pass;
 }
 
 // src/init.ts
-import { spawnSync as spawnSync4 } from "node:child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
-import { basename as basename2, join as join7 } from "node:path";
-import { createInterface as createInterface2 } from "node:readline/promises";
-import { Writable } from "node:stream";
-var SKILLS = ["firegoat-onboarding", "suggesting-eval-prompts"];
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { existsSync as existsSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { basename, join as join4 } from "node:path";
+import { createInterface } from "node:readline/promises";
 var SKILLS_ARGV = [
   "skills",
   "add",
-  "team2027/skills",
-  ...SKILLS.flatMap((s) => ["--skill", s]),
+  "firegoat-ai/skills",
+  "--skill",
+  "firegoat-onboarding",
+  "--skill",
+  "suggesting-eval-prompts",
   "--agent",
   "claude-code",
   "-y"
 ];
-var GITIGNORE_LINE = ".firegoat/";
-function readText(file) {
-  try {
-    return readFileSync4(file, "utf8");
-  } catch {
-    return;
-  }
-}
-function tomlSections(text) {
-  const sections = new Map;
-  let current = "";
-  sections.set(current, new Map);
-  for (const raw of text.split(`
-`)) {
-    const line = raw.trim();
-    const header = line.match(/^\[\[?\s*([^\]]+?)\s*\]\]?$/);
-    if (header?.[1]) {
-      current = header[1];
-      if (!sections.has(current))
-        sections.set(current, new Map);
-      continue;
-    }
-    const kv = line.match(/^([A-Za-z0-9_.-]+|"[^"]+")\s*=\s*["']([^"']*)["']/);
-    if (kv?.[1] && kv[2] !== undefined)
-      sections.get(current)?.set(kv[1].replace(/"/g, ""), kv[2]);
-  }
-  return sections;
-}
-function detect(cwd) {
-  const readme = ["README.md", "README", "readme.md", "Readme.md"].find((f) => existsSync5(join7(cwd, f)));
-  const fallback = { name: basename2(cwd), library: true, readme };
-  const pkgText = readText(join7(cwd, "package.json"));
-  if (pkgText !== undefined) {
-    try {
-      const pkg = JSON.parse(pkgText);
-      const name = typeof pkg.name === "string" ? pkg.name : fallback.name;
-      let bin;
-      if (typeof pkg.bin === "string")
-        bin = name.replace(/^@[^/]+\//, "");
-      else if (pkg.bin && typeof pkg.bin === "object")
-        bin = Object.keys(pkg.bin)[0];
-      const library = !bin || pkg.main !== undefined || pkg.exports !== undefined || pkg.module !== undefined;
-      const docsUrl = typeof pkg.homepage === "string" && /^https?:\/\//.test(pkg.homepage) ? pkg.homepage : undefined;
-      return { ecosystem: "npm", name, bin, library, readme, docsUrl };
-    } catch {}
-  }
-  const pyText = readText(join7(cwd, "pyproject.toml"));
-  if (pyText !== undefined) {
-    const s = tomlSections(pyText);
-    const name = s.get("project")?.get("name") ?? s.get("tool.poetry")?.get("name") ?? fallback.name;
-    const scripts = s.get("project.scripts") ?? s.get("tool.poetry.scripts");
-    const bin = scripts ? [...scripts.keys()][0] : undefined;
-    const urls = s.get("project.urls");
-    const docsUrl = urls?.get("Documentation") ?? urls?.get("documentation") ?? urls?.get("Homepage") ?? urls?.get("homepage");
-    return { ecosystem: "python", name, bin, library: true, readme, docsUrl };
-  }
-  const goText = readText(join7(cwd, "go.mod"));
-  if (goText !== undefined) {
-    const name = goText.match(/^module\s+(\S+)/m)?.[1] ?? fallback.name;
-    return { ecosystem: "go", name, library: true, readme };
-  }
-  const cargoText = readText(join7(cwd, "Cargo.toml"));
-  if (cargoText !== undefined) {
-    const name = tomlSections(cargoText).get("package")?.get("name");
-    return {
-      ecosystem: "rust",
-      name: name ?? fallback.name,
-      library: true,
-      readme
-    };
-  }
-  return fallback;
-}
-var LANG = {
-  npm: "Node.js",
-  python: "Python",
-  go: "Go",
-  rust: "Rust"
-};
-function importName(p) {
-  if (p.ecosystem === "python" || p.ecosystem === "rust")
-    return p.name.replace(/-/g, "_");
-  return p.name;
-}
-var GREP_EXCLUDES = [
-  "--exclude=output.txt",
-  "--exclude=package.json",
-  "--exclude=package-lock.json",
-  "--exclude=pyproject.toml",
-  "--exclude=requirements.txt",
-  "--exclude=go.mod",
-  "--exclude=go.sum",
-  "--exclude=Cargo.toml",
-  "--exclude=Cargo.lock",
-  "--exclude-dir=node_modules",
-  "--exclude-dir=.venv",
-  "--exclude-dir=target"
-].join(" ");
-function sq(s) {
-  return `'${s.replace(/'/g, `'\\''`)}'`;
-}
-function templates(p) {
-  const docs = p.docsUrl ? `its docs at ${p.docsUrl}` : "its official docs";
-  const out = [];
-  if (p.bin) {
-    out.push({
-      name: "cli-first-run",
-      prompt: `I just heard about the \`${p.bin}\` command-line tool from ${p.name} and want to see it actually do something useful. Use it for one basic real task and save what it prints to cli-output.txt. Keep it minimal. Use only ${docs} as a guide.`,
-      goal: `cli-output.txt exists and holds real output from running \`${p.bin}\`, not an install log or an error.`,
-      checks: [
-        "test -s cli-output.txt",
-        "! grep -qiE 'command not found|not recognized|ENOENT' cli-output.txt"
-      ]
-    });
-  }
-  if (p.library && p.ecosystem) {
-    out.push({
-      name: "quickstart",
-      prompt: `I want to use ${p.name} in a new ${LANG[p.ecosystem]} project. Get the smallest working example going: a program that uses ${p.name} to do one real thing, then run it and save what it prints to output.txt. Keep it minimal. Use only ${docs} as a guide.`,
-      goal: `A program in the workdir uses ${p.name}, runs without errors, and its output is saved in output.txt.`,
-      checks: [
-        "test -s output.txt",
-        `grep -rqsF ${GREP_EXCLUDES} -- ${sq(importName(p))} .`
-      ]
-    });
-  }
-  if (out.length === 0) {
-    out.push({
-      name: "quickstart",
-      prompt: `I want to try ${p.name}. Follow its quickstart in a new project, get the smallest example working, then run it and save what it prints to output.txt. Keep it minimal. Use only ${docs} as a guide.`,
-      goal: `The ${p.name} quickstart example runs without errors and its output is saved in output.txt.`,
-      checks: ["test -s output.txt"]
-    });
-  }
-  return out;
-}
-function block(text, indent) {
-  return text.split(`
-`).map((l) => indent + l).join(`
-`);
-}
-function renderYaml(p, tests) {
-  const lines = [
-    `# firegoat.yaml: evals for how well coding agents use ${p.name}.`,
-    "# Each test runs a coding agent in an empty workdir with `prompt` as the first message.",
-    "# These are starter templates: edit the prompts to match real user problems.",
-    "# Good prompts state one concrete outcome as a user would, not implementation steps,",
-    "# and ask for observable proof (stdout or a file) that `checks` can verify.",
-    "",
-    "# Agents to evaluate (v1 supports: claude-code).",
-    "agents: [claude-code]",
-    "# How many times to run each test.",
-    "runs: 1",
-    "",
-    "# Optional: test your local build instead of the published package.",
-    "# setup: runs once per eval, in this folder, on your machine. Whatever it writes to",
-    "# $FIREGOAT_OUT is copied into each run's folder and put on the agent's PATH.",
-    "# workdir_setup: runs in each fresh workdir before the agent starts. Then tell the",
-    '# agent in the prompt: "The package is already installed from the build under test."',
-    "#",
-    "# npm:",
-    '# setup: npm pack --pack-destination "$FIREGOAT_OUT"',
-    '# workdir_setup: npm init -y >/dev/null && npm install "$FIREGOAT_OUT"/*.tgz',
-    "#",
-    "# python:",
-    '# setup: uv build --wheel --out-dir "$FIREGOAT_OUT"',
-    '# workdir_setup: uv venv && uv pip install "$FIREGOAT_OUT"/*.whl',
-    "#",
-    "# a CLI binary (lands on PATH as is):",
-    '# setup: go build -o "$FIREGOAT_OUT/mycli" ./cmd/mycli',
-    "#",
-    "# Values for {{vars.KEY}} in prompts and checks, overridden by `--var KEY=value`;",
-    "# setup commands and checks also get them as env vars.",
-    "# vars:",
-    "#   SHA: main",
-    "",
-    "tests:"
-  ];
-  for (const t of tests) {
-    lines.push(`  - name: ${t.name}  # letters, digits, '.', '_' and '-'`, "    # What a user would ask the agent. Edit this.", "    prompt: >-", block(t.prompt, "      "), "    # One sentence that is true when the user's problem is solved.", "    goal: >-", block(t.goal, "      "), "    # Shell commands run in the agent's workdir afterwards; exit 0 = pass.", "    checks:", ...t.checks.map((c) => `      - run: ${JSON.stringify(c)}`), "    # Seconds before the agent run is stopped.", "    timeout: 600");
-  }
-  return `${lines.join(`
-`)}
+function template(product) {
+  return `# firegoat.yaml: evals for how well coding agents use ${product}.
+# Each test runs your claude in an empty folder (.firegoat/runs/...) with \`prompt\`
+# as the first message, then runs \`checks\` there. Reference: npx firegoat init --help
+
+# How many times to run each test.
+runs: 1
+
+# Optional: test your local build instead of the published package.
+# setup: runs once per eval, here; what it writes to $FIREGOAT_OUT is put on the
+# agent's PATH. workdir_setup: runs in each fresh folder before the agent starts.
+#
+# npm:
+# setup: npm pack --pack-destination "$FIREGOAT_OUT"
+# workdir_setup: npm init -y >/dev/null && npm install "$FIREGOAT_OUT"/*.tgz
+#
+# python:
+# setup: uv build --wheel --out-dir "$FIREGOAT_OUT"
+# workdir_setup: uv venv && uv pip install "$FIREGOAT_OUT"/*.whl
+#
+# a CLI binary:
+# setup: go build -o "$FIREGOAT_OUT/mycli" ./cmd/mycli
+
+tests:
+  - name: quickstart
+    # What a user would ask their agent. Edit this.
+    prompt: >-
+      I want to try ${product}. Get the smallest working example going in a new
+      project, run it, and save what it prints to output.txt. Keep it minimal.
+    # True when the user's problem is solved. Not graded by firegoat: it goes to
+    # your agent (eval --json, run.json) to judge.
+    end_goal: >-
+      A minimal project uses ${product}, runs without errors, and output.txt holds
+      its output.
+    # Shell commands run in the agent's folder afterwards; exit 0 = pass.
+    checks:
+      - run: test -s output.txt
+    # Seconds before the agent run is stopped.
+    timeout: 600
 `;
 }
-function ensureGitignore(cwd) {
-  const file = join7(cwd, ".gitignore");
-  const text = readText(file);
-  if (text === undefined) {
-    writeFileSync3(file, `${GITIGNORE_LINE}
-`);
-    return `created .gitignore with ${GITIGNORE_LINE}`;
-  }
-  const has = text.split(/\r?\n/).some((l) => ["/.firegoat/", ".firegoat/", ".firegoat"].includes(l.trim()));
-  if (has)
-    return `.gitignore already ignores ${GITIGNORE_LINE}`;
-  const sep = text === "" || text.endsWith(`
-`) ? "" : `
-`;
-  writeFileSync3(file, `${text}${sep}${GITIGNORE_LINE}
-`);
-  return `added ${GITIGNORE_LINE} to .gitignore`;
-}
-function installSkills(cwd) {
-  const r = spawnSync4("npx", ["-y", ...SKILLS_ARGV], {
-    cwd,
-    stdio: "inherit"
-  });
-  if (r.error)
-    return r.error.message;
-  if (r.status !== 0)
-    return `exit ${r.status ?? "by signal"}`;
-  return;
-}
-async function ask(question) {
-  const rl = createInterface2({ input: process.stdin, output: process.stdout });
-  try {
-    return (await rl.question(question)).trim();
-  } finally {
-    rl.close();
-  }
-}
-async function readSecret(question) {
-  if (!process.stdin.isTTY) {
-    const chunks = [];
-    for await (const c of process.stdin)
-      chunks.push(c);
-    return Buffer.concat(chunks).toString("utf8").trim();
-  }
-  process.stdout.write(question);
-  const silent = new Writable({ write: (_c, _e, cb) => cb() });
-  const rl = createInterface2({
-    input: process.stdin,
-    output: silent,
-    terminal: true
+var AGENT_PROMPT = "Scan my project and setup 2-3 agent experience prompts to test general usage of the app. Use firegoat skills";
+var CLIPBOARD = [
+  ["pbcopy", []],
+  ["wl-copy", []],
+  ["xclip", ["-selection", "clipboard"]],
+  ["clip", []]
+];
+function copyToClipboard(text) {
+  return CLIPBOARD.some(([cmd, args]) => {
+    const r = spawnSync2(cmd, args, { input: text });
+    return !r.error && r.status === 0;
   });
-  try {
-    return (await rl.question("")).trim();
-  } finally {
-    rl.close();
-    process.stdout.write(`
-`);
-  }
 }
-async function chooseAuth() {
-  let current;
+async function askYes(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
   try {
-    current = resolveAuth({}).label;
-  } catch (e) {
-    current = e.message;
-  }
-  console.log(`How should the agent sign in? (now: ${current})
-  1) Login with Claude (your Claude plan)
-  2) Paste an Anthropic API key`);
-  for (;; ) {
-    const a = await ask("choose [1/2]: ");
-    if (a === "1")
-      return "claude";
-    if (a === "2")
-      return "api-key";
-    console.log("type 1 or 2");
-  }
-}
-async function setUpAuth(method) {
-  if (method === "claude") {
-    const code = claudeLoginCommand([]);
-    return code === 0 ? undefined : code;
-  }
-  const key = await readSecret("Anthropic API key (input hidden): ");
-  if (!looksLikeAnthropicKey(key)) {
-    console.error("firegoat init: that does not look like an Anthropic API key (sk-ant-...); nothing stored");
-    return EXIT.usage;
-  }
-  const file = saveApiKey(key);
-  console.log(`stored the API key in ${file} (mode 0600, not in the repo); evals pass it to the agent as ANTHROPIC_API_KEY`);
-  return;
-}
-async function askYesNo(question) {
-  const rl = createInterface2({ input: process.stdin, output: process.stdout });
-  try {
-    const answer = await rl.question(`${question} [y/N] `);
-    return /^y(es)?$/i.test(answer.trim());
+    const a = (await rl.question(`${question} [Y/n] `)).trim();
+    return a === "" || /^y(es)?$/i.test(a);
   } finally {
     rl.close();
   }
 }
-function describe(p) {
-  if (!p.ecosystem)
-    return "no package manifest found, writing a generic test";
-  const parts = [`${p.ecosystem} package ${p.name}`];
-  if (p.bin)
-    parts.push(`bin: ${p.bin}`);
-  if (p.readme)
-    parts.push(`docs: ${p.readme}`);
-  return parts.join(", ");
-}
 async function initCommand(args, cwd) {
-  let yes = false;
   let force = false;
-  let skills = false;
-  let auth;
-  for (let i = 0;i < args.length; i++) {
-    const a = args[i];
-    if (a === "--auth" || a.startsWith("--auth=")) {
-      const v = a === "--auth" ? args[++i] : a.slice(7);
-      if (v !== "claude" && v !== "api-key") {
-        console.error(`firegoat init: --auth must be claude or api-key, got ${v ?? "nothing"}`);
-        return EXIT.usage;
-      }
-      auth = v;
-      continue;
-    }
-    switch (a) {
-      case "--yes":
-      case "-y":
-        yes = true;
-        break;
-      case "--force":
-      case "-f":
-        force = true;
-        break;
-      case "--skills":
-        skills = true;
-        break;
-      case "--help":
-      case "-h":
-        console.log(INIT_HELP);
-        return 0;
-      default:
-        console.error(`firegoat init: unknown argument: ${a}
+  let skills = true;
+  for (const a of args) {
+    if (a === "--help" || a === "-h") {
+      console.log(INIT_HELP);
+      return EXIT.pass;
+    }
+    if (a === "--force" || a === "-f")
+      force = true;
+    else if (a === "--no-skills")
+      skills = false;
+    else {
+      console.error(`firegoat init: unknown argument: ${a}
 
 ${INIT_HELP}`);
-        return EXIT.usage;
-    }
-  }
-  const configPath = join7(cwd, CONFIG_FILE);
-  const keepConfig = existsSync5(configPath) && !force;
-  if (keepConfig && !skills && !auth) {
-    console.error(`firegoat init: ${CONFIG_FILE} already exists; not overwriting. Use --force to replace it.`);
-    return EXIT.usage;
-  }
-  if (keepConfig) {
-    console.log(`kept existing ${CONFIG_FILE} (use --force to replace it)`);
-  } else {
-    const project = detect(cwd);
-    const tests = templates(project);
-    console.log(`detected: ${describe(project)}`);
-    writeFileSync3(configPath, renderYaml(project, tests));
-    console.log(`wrote ${CONFIG_FILE} (${tests.length} test${tests.length === 1 ? "" : "s"}: ${tests.map((t) => t.name).join(", ")}); edit the prompts to fit your users`);
-  }
-  console.log(ensureGitignore(cwd));
-  const interactive = !yes && process.stdin.isTTY && process.stdout.isTTY;
-  if (!auth && interactive)
-    auth = await chooseAuth();
-  if (auth) {
-    const failed = await setUpAuth(auth);
-    if (failed !== undefined)
-      return failed;
-  }
-  if (!skills && interactive)
-    skills = await askYesNo(`Add the ${SKILLS.join(" and ")} skills to .claude/skills/ (help your agent draft better evals)?`);
+      return EXIT.usage;
+    }
+  }
+  ensureFiregoatDir(cwd);
+  const configPath = join4(cwd, CONFIG_FILE);
+  if (existsSync4(configPath) && !force)
+    console.log(`kept ${CONFIG_FILE} (--force replaces it)`);
+  else {
+    writeFileSync3(configPath, template(basename(cwd)));
+    console.log(`wrote ${CONFIG_FILE}: edit the quickstart test to fit your users`);
+  }
+  const interactive = process.stdin.isTTY && process.stdout.isTTY;
+  if (skills && interactive)
+    skills = await askYes("Install the firegoat-onboarding skill for your coding agent?");
   if (skills) {
     console.log(`installing skills: npx ${SKILLS_ARGV.join(" ")}`);
-    const failed = installSkills(cwd);
-    if (failed) {
-      console.error(`firegoat init: installing the skills failed (${failed}). Run it yourself: npx ${SKILLS_ARGV.join(" ")}`);
+    const env = { ...process.env };
+    delete env.npm_config_package;
+    const r = spawnSync2("npx", ["-y", ...SKILLS_ARGV], {
+      cwd,
+      env,
+      stdio: "inherit"
+    });
+    if (r.error || r.status !== 0) {
+      console.error(`firegoat init: installing the skills failed (${r.error?.message ?? `exit ${r.status}`}). Run it yourself: npx ${SKILLS_ARGV.join(" ")}`);
       return EXIT.notGraded;
     }
-  } else {
-    console.log(`hint: \`npx firegoat init --skills\` adds the ${SKILLS.join(" and ")} skills to .claude/skills/ (keeps your ${CONFIG_FILE})`);
   }
-  console.log("next: npx firegoat eval");
-  return 0;
-}
+  console.log(`
+Paste this into your coding agent:
 
-// src/open.ts
-import { spawnSync as spawnSync5 } from "node:child_process";
-import { existsSync as existsSync6, readdirSync } from "node:fs";
-import { join as join8 } from "node:path";
-var OPENER = {
-  darwin: "open",
-  linux: "xdg-open"
-};
-function openCommand(args, cwd) {
-  let print = false;
-  const ids = [];
-  for (const a of args) {
-    if (a === "--help" || a === "-h") {
-      console.log(OPEN_HELP);
-      return EXIT.pass;
-    }
-    if (a === "--print")
-      print = true;
-    else if (a.startsWith("-")) {
-      console.error(`firegoat open: unknown flag: ${a}`);
-      return EXIT.usage;
-    } else
-      ids.push(a);
-  }
-  if (ids.length > 1) {
-    console.error("firegoat open: takes at most one run id");
-    return EXIT.usage;
-  }
-  const base = join8(findConfigDir(cwd), ".firegoat", "runs");
-  const runs = existsSync6(base) ? readdirSync(base).sort() : [];
-  const id = ids[0] ?? runs.at(-1);
-  if (!id) {
-    console.error(`firegoat open: no runs in ${base}. Run: npx firegoat eval`);
-    return EXIT.usage;
-  }
-  if (!runs.includes(id)) {
-    console.error(`firegoat open: no run ${JSON.stringify(id)} in ${base} (latest: ${runs.at(-1) ?? "none"})`);
-    return EXIT.usage;
-  }
-  const dir = join8(base, id);
-  console.log(dir);
-  const opener = OPENER[process.platform];
-  if (print || !opener)
-    return EXIT.pass;
-  const r = spawnSync5(opener, [dir], { stdio: "inherit" });
-  if (r.error || r.status !== 0) {
-    console.error(`firegoat open: ${opener} failed (${r.error?.message ?? `exit ${r.status}`}); the run is at the path above`);
-    return EXIT.notGraded;
-  }
+${AGENT_PROMPT}
+`);
+  if (interactive && copyToClipboard(AGENT_PROMPT))
+    console.log("\x1B[32mPrompt copied!\x1B[0m");
   return EXIT.pass;
 }
 
@@ -8756,24 +7896,8 @@ async function main(argv) {
       return 0;
     case "init":
       return initCommand(rest, process.cwd());
-    case "claude":
-      if (rest[0] === "login")
-        return claudeLoginCommand(rest.slice(1));
-      if (rest[0] === "--help" || rest[0] === "-h") {
-        console.log(CLAUDE_LOGIN_HELP);
-        return 0;
-      }
-      console.error(`firegoat claude: unknown subcommand
-
-${CLAUDE_LOGIN_HELP}`);
-      return EXIT.usage;
-    case "login":
-      console.error("firegoat login is deprecated for the Claude sign-in: use `firegoat claude login`");
-      return claudeLoginCommand(rest);
     case "eval":
       return evalCommand(rest, process.cwd());
-    case "open":
-      return openCommand(rest, process.cwd());
     default:
       console.error(`unknown command: ${cmd}