firegoat 0.22.0 → 0.23.0

package/dist/cli.js

@@ -6947,7 +6947,7 @@ var require_public_api = __commonJS(function(exports) {
 // package.json
 var package_default = {
   name: "firegoat",
-  version: "0.22.0",
+  version: "0.23.0",
   repository: {
     type: "git",
     url: "git+https://github.com/firegoat-ai/firegoat-cli.git"
@@ -7325,210 +7325,10 @@ import { randomBytes as randomBytes2 } from "node:crypto";
 import {
   appendFileSync,
   createWriteStream as createWriteStream2,
-  existsSync as existsSync3,
   mkdirSync as mkdirSync4,
-  readdirSync as readdirSync2,
   writeFileSync as writeFileSync4
 } from "node:fs";
-import { basename as basename3, delimiter as delimiter2, join as join6 } from "node:path";
-
-// src/claude.ts
-import { spawn, spawnSync } from "node:child_process";
-var CLAUDE_FLAGS = [
-  "--output-format",
-  "stream-json",
-  "--verbose",
-  "--dangerously-skip-permissions",
-  "--strict-mcp-config",
-  "--setting-sources",
-  "",
-  "--disable-slash-commands"
-];
-var NPM_INJECTED = /^(npm_config_|npm_lifecycle_|npm_package_)|^(npm_execpath|npm_node_execpath|npm_command|INIT_CWD)$/;
-var CLAUDE_SESSION = /^(CLAUDECODE|CLAUDE_CODE_.+|CLAUDE_PID|CLAUDE_ENV_FILE|CLAUDE_SESSION_ID|CLAUDE_PROJECT_DIR|CLAUDE_EFFORT|CLAUDE_AGENT_SDK_.+|CLAUDE_PLUGIN_ROOT|CLAUDE_PLUGIN_DATA|CLAUDE_SKILL_DIR)$/;
-var CLAUDE_AUTH = /^CLAUDE_CODE_(OAUTH_TOKEN|OAUTH_REFRESH_TOKEN|USE_[A-Z_]+|SKIP_[A-Z]+_AUTH|CLIENT_CERT|CLIENT_KEY|CLIENT_KEY_PASSPHRASE)$/;
-function hostEnv() {
-  return Object.fromEntries(Object.entries(process.env).filter(([k]) => !NPM_INJECTED.test(k) && !k.startsWith("FIREGOAT_") && (!CLAUDE_SESSION.test(k) || CLAUDE_AUTH.test(k))));
-}
-function claudeEnv(configDir, env = {}, envFile) {
-  return {
-    ...hostEnv(),
-    ...env,
-    CLAUDE_CONFIG_DIR: configDir,
-    CLAUDE_SECURESTORAGE_CONFIG_DIR: "",
-    ...envFile === undefined ? {} : { CLAUDE_ENV_FILE: envFile }
-  };
-}
-function run(opts) {
-  return new Promise((resolve) => {
-    const child = spawn(opts.cmd, opts.args, {
-      cwd: opts.cwd,
-      env: opts.env,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let timedOut = false;
-    let settled = false;
-    const timer = setTimeout(() => {
-      timedOut = true;
-      child.kill("SIGKILL");
-    }, opts.timeoutMs);
-    const done = (r) => {
-      if (settled)
-        return;
-      settled = true;
-      clearTimeout(timer);
-      resolve(r);
-    };
-    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());
-  });
-}
-async function runClaude(opts) {
-  let stdout = "";
-  let pending = "";
-  const exited = await run({
-    cmd: opts.bin,
-    args: [
-      "-p",
-      opts.prompt,
-      ...CLAUDE_FLAGS,
-      ...opts.model === undefined ? [] : ["--model", opts.model],
-      ...opts.extraArgs
-    ],
-    cwd: opts.cwd,
-    env: opts.env,
-    timeoutMs: opts.timeoutMs,
-    onStdout: (c) => {
-      const text = c.toString();
-      stdout += text;
-      if (!opts.onEvent)
-        return;
-      pending += text;
-      const lines = pending.split(`
-`);
-      pending = lines.pop() ?? "";
-      for (const line of lines) {
-        try {
-          opts.onEvent(JSON.parse(line));
-        } catch {}
-      }
-    },
-    onStderr: (c) => opts.stderr.write(c)
-  });
-  if (exited.error)
-    return {
-      events: [],
-      claudeModel: null,
-      ok: false,
-      reason: `could not start ${opts.bin}: ${exited.error.message}`
-    };
-  const events = stdout.split(`
-`).filter((l) => l.trim() !== "").map((l) => {
-    try {
-      return JSON.parse(l);
-    } catch {
-      return;
-    }
-  });
-  const init = events.find((e) => e?.type === "system" && e.subtype === "init");
-  if (!init) {
-    const said = stdout.trim().split(`
-`)[0]?.slice(0, 300);
-    return {
-      events,
-      claudeModel: null,
-      ok: false,
-      reason: `claude did not start a session (exit ${exited.code ?? "by signal"})${said ? `: ${said}` : ", see stderr.txt"}`
-    };
-  }
-  const claudeModel = typeof init.model === "string" ? init.model : null;
-  if (typeof init.session_id !== "string" || init.session_id === "")
-    return {
-      events,
-      claudeModel,
-      ok: false,
-      reason: "claude's init line has no session_id"
-    };
-  const sessionId = init.session_id;
-  const result = events.findLast((e) => e?.type === "result");
-  if (exited.timedOut)
-    return {
-      events,
-      claudeModel,
-      ok: false,
-      reason: `timed out after ${opts.timeoutMs / 1000}s`,
-      result,
-      sessionId
-    };
-  if (!result)
-    return {
-      events,
-      claudeModel,
-      ok: false,
-      reason: `claude exited ${exited.code ?? "by signal"} without a result, see stderr.txt`,
-      sessionId
-    };
-  if (result.is_error === true || result.subtype !== "success")
-    return {
-      events,
-      claudeModel,
-      ok: false,
-      reason: `claude result is an error (subtype=${result.subtype})${result.result ? `: ${result.result.slice(0, 300)}` : ""}`,
-      result,
-      sessionId
-    };
-  return { events, claudeModel, ok: true, result, sessionId };
-}
-async function runShell(opts) {
-  opts.log.write(`$ ${opts.run}
-`);
-  const r = await run({
-    cmd: "/bin/sh",
-    args: ["-c", opts.run],
-    cwd: opts.cwd,
-    env: opts.env,
-    timeoutMs: opts.timeoutMs,
-    onStdout: (c) => opts.log.write(c),
-    onStderr: (c) => opts.log.write(c)
-  });
-  let error;
-  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)
-    error = "killed by a signal";
-  opts.log.write(`[exit ${r.code ?? "none"}${error ? `: ${error}` : ""}]
-
-`);
-  return error ? { run: opts.run, code: r.code, error } : { run: opts.run, code: r.code };
-}
-function checkLogin(opts) {
-  const r = spawnSync(opts.bin, ["auth", "status"], {
-    cwd: opts.cwd,
-    env: opts.env,
-    encoding: "utf8",
-    timeout: 30000
-  });
-  if (r.error)
-    return `could not run ${opts.bin}: ${r.error.message}`;
-  let status;
-  try {
-    status = JSON.parse(r.stdout);
-  } catch {}
-  if (status?.loggedIn === true)
-    return;
-  if (status?.loggedIn === false)
-    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)}`;
-}
+import { basename as basename3, delimiter as delimiter2, join as join7 } from "node:path";
 
 // src/credentials.ts
 import { randomBytes } from "node:crypto";
@@ -7559,6 +7359,9 @@ class ApiError extends Error {
     this.status = status;
   }
 }
+
+class NetworkError extends ApiError {
+}
 function printable(s, max = 300) {
   const t = s.replace(/[\u0000-\u001f\u007f-\u009f]/g, "");
   return t.length > max ? `${t.slice(0, max - 1)}…` : t;
@@ -7639,7 +7442,7 @@ async function send(opts) {
     status = res.status;
     text = await readCapped(res);
   } catch (e) {
-    throw new ApiError(`${opts.step}: ${networkReason(e, opts.timeoutMs)}`, null);
+    throw new NetworkError(`${opts.step}: ${networkReason(e, opts.timeoutMs)}`);
   }
   let json = null;
   try {
@@ -7833,10 +7636,76 @@ function ensureFiregoatDir(root) {
 }
 
 // src/git.ts
-import { spawnSync as spawnSync2 } from "node:child_process";
+import { spawnSync } from "node:child_process";
 import { basename, dirname } from "node:path";
+
+// src/process.ts
+import { spawn } from "node:child_process";
+var NPM_INJECTED = /^(npm_config_|npm_lifecycle_|npm_package_)|^(npm_execpath|npm_node_execpath|npm_command|INIT_CWD)$/;
+var CLAUDE_SESSION = /^(CLAUDECODE|CLAUDE_CODE_.+|CLAUDE_PID|CLAUDE_ENV_FILE|CLAUDE_SESSION_ID|CLAUDE_PROJECT_DIR|CLAUDE_EFFORT|CLAUDE_AGENT_SDK_.+|CLAUDE_PLUGIN_ROOT|CLAUDE_PLUGIN_DATA|CLAUDE_SKILL_DIR)$/;
+var CLAUDE_AUTH = /^CLAUDE_CODE_(OAUTH_TOKEN|OAUTH_REFRESH_TOKEN|USE_[A-Z_]+|SKIP_[A-Z]+_AUTH|CLIENT_CERT|CLIENT_KEY|CLIENT_KEY_PASSPHRASE)$/;
+function hostEnv() {
+  return Object.fromEntries(Object.entries(process.env).filter(([k]) => !NPM_INJECTED.test(k) && !k.startsWith("FIREGOAT_") && (!CLAUDE_SESSION.test(k) || CLAUDE_AUTH.test(k))));
+}
+function run(opts) {
+  return new Promise((resolve) => {
+    const child = spawn(opts.cmd, opts.args, {
+      cwd: opts.cwd,
+      env: opts.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let timedOut = false;
+    let settled = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGKILL");
+    }, opts.timeoutMs);
+    const done = (r) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(r);
+    };
+    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());
+  });
+}
+async function runShell(opts) {
+  opts.log.write(`$ ${opts.run}
+`);
+  const r = await run({
+    cmd: "/bin/sh",
+    args: ["-c", opts.run],
+    cwd: opts.cwd,
+    env: opts.env,
+    timeoutMs: opts.timeoutMs,
+    onStdout: (c) => opts.log.write(c),
+    onStderr: (c) => opts.log.write(c)
+  });
+  let error;
+  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)
+    error = "killed by a signal";
+  opts.log.write(`[exit ${r.code ?? "none"}${error ? `: ${error}` : ""}]
+
+`);
+  return error ? { run: opts.run, code: r.code, error } : { run: opts.run, code: r.code };
+}
+
+// src/git.ts
 function git(dir, args) {
-  const r = spawnSync2("git", args, {
+  const r = spawnSync("git", args, {
     cwd: dir,
     env: hostEnv(),
     encoding: "utf8"
@@ -7846,7 +7715,7 @@ function git(dir, args) {
   return { code: r.status ?? -1, stdout: r.stdout.trim() };
 }
 function gitRepo(dir) {
-  const r = spawnSync2("git", [
+  const r = spawnSync("git", [
     "rev-parse",
     "--path-format=absolute",
     "--git-dir",
@@ -7888,6 +7757,249 @@ function gitRepo(dir) {
   };
 }
 
+// src/harness.ts
+async function runAgent(harness, opts) {
+  let stdout = "";
+  let pending = "";
+  const exited = await run({
+    cmd: opts.bin,
+    args: harness.args(opts),
+    cwd: opts.cwd,
+    env: opts.env,
+    timeoutMs: opts.timeoutMs,
+    onStdout: (c) => {
+      const text = c.toString();
+      stdout += text;
+      if (!opts.onProgress)
+        return;
+      pending += text;
+      const lines = pending.split(`
+`);
+      pending = lines.pop() ?? "";
+      for (const line of lines) {
+        const p = harness.progress(line);
+        if (p)
+          opts.onProgress(p);
+      }
+    },
+    onStderr: (c) => opts.stderr.write(c)
+  });
+  if (exited.error)
+    return {
+      ok: false,
+      reason: `could not start ${opts.bin}: ${exited.error.message}`,
+      steps: [],
+      final: "",
+      reportedModel: null,
+      version: null,
+      turns: null,
+      cost: null
+    };
+  return harness.read(stdout, exited, opts.timeoutMs);
+}
+
+// src/harnesses/claude.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { existsSync as existsSync2, readdirSync } from "node:fs";
+import { join as join3 } from "node:path";
+var FLAGS = [
+  "--output-format",
+  "stream-json",
+  "--verbose",
+  "--dangerously-skip-permissions",
+  "--strict-mcp-config",
+  "--setting-sources",
+  "",
+  "--disable-slash-commands"
+];
+function parse(line) {
+  try {
+    const e = JSON.parse(line);
+    return typeof e === "object" && e !== null ? e : undefined;
+  } catch {
+    return;
+  }
+}
+function content(e) {
+  const message = e?.message;
+  return Array.isArray(message?.content) ? message.content : [];
+}
+function resultText(content) {
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content))
+    return content.map((c) => typeof c.text === "string" ? c.text : `[${c.type}]`).join(`
+`);
+  return "";
+}
+function steps(events) {
+  const out = [];
+  for (const e of events) {
+    if (e?.type === "assistant")
+      for (const b of content(e)) {
+        if (b.type === "tool_use")
+          out.push({
+            kind: "tool_call",
+            name: typeof b.name === "string" ? b.name : "",
+            input: typeof b.input === "object" && b.input !== null ? b.input : null
+          });
+        else if (b.type === "text" && typeof b.text === "string")
+          out.push({ kind: "text", text: b.text });
+      }
+    else if (e?.type === "user") {
+      for (const b of content(e))
+        if (b.type === "tool_result")
+          out.push({
+            kind: "tool_result",
+            isError: b.is_error === true,
+            text: resultText(b.content).trimEnd()
+          });
+    }
+  }
+  return out;
+}
+function read(stdout, exited, timeoutMs) {
+  const events = stdout.split(`
+`).filter((l) => l.trim() !== "").map(parse);
+  let final = "";
+  for (const e of events)
+    if (e?.type === "result" && typeof e.result === "string")
+      final = e.result;
+  const result = events.findLast((e) => e?.type === "result");
+  const trace = {
+    steps: steps(events),
+    final,
+    turns: result?.num_turns ?? null,
+    cost: result?.total_cost_usd ?? null
+  };
+  const init = events.find((e) => e?.type === "system" && e.subtype === "init");
+  if (!init) {
+    const said = stdout.trim().split(`
+`)[0]?.slice(0, 300);
+    return {
+      ...trace,
+      reportedModel: null,
+      version: null,
+      ok: false,
+      reason: `claude did not start a session (exit ${exited.code ?? "by signal"})${said ? `: ${said}` : ", see stderr.txt"}`
+    };
+  }
+  const reportedModel = typeof init.model === "string" ? init.model : null;
+  const version = typeof init.claude_code_version === "string" ? init.claude_code_version : null;
+  if (typeof init.session_id !== "string" || init.session_id === "")
+    return {
+      ...trace,
+      reportedModel,
+      version,
+      ok: false,
+      reason: "claude's init line has no session_id"
+    };
+  const sessionId = init.session_id;
+  if (exited.timedOut)
+    return {
+      ...trace,
+      reportedModel,
+      version,
+      ok: false,
+      reason: `timed out after ${timeoutMs / 1000}s`,
+      sessionId
+    };
+  if (!result)
+    return {
+      ...trace,
+      reportedModel,
+      version,
+      ok: false,
+      reason: `claude exited ${exited.code ?? "by signal"} without a result, see stderr.txt`,
+      sessionId
+    };
+  if (result.is_error === true || result.subtype !== "success")
+    return {
+      ...trace,
+      reportedModel,
+      version,
+      ok: false,
+      reason: `claude result is an error (subtype=${result.subtype})${result.result ? `: ${result.result.slice(0, 300)}` : ""}`,
+      sessionId
+    };
+  return { ...trace, reportedModel, version, ok: true, sessionId };
+}
+function progress(line) {
+  const e = parse(line);
+  if (e?.type !== "assistant")
+    return;
+  const p = {};
+  for (const b of content(e)) {
+    const cmd = b.input?.command;
+    if (b.type === "tool_use" && typeof cmd === "string")
+      p.command = cmd.split(`
+`)[0];
+  }
+  return p;
+}
+function checkLogin(opts) {
+  const r = spawnSync2(opts.bin, ["auth", "status"], {
+    cwd: opts.cwd,
+    env: opts.env,
+    encoding: "utf8",
+    timeout: 30000
+  });
+  if (r.error)
+    return {
+      loggedOut: false,
+      reason: `could not run ${opts.bin}: ${r.error.message}`
+    };
+  let status;
+  try {
+    status = JSON.parse(r.stdout);
+  } catch {}
+  if (status?.loggedIn === true)
+    return;
+  if (status?.loggedIn === false)
+    return {
+      loggedOut: true,
+      reason: "claude is not logged in. Run `claude` once and log in (or set ANTHROPIC_API_KEY), then run eval again"
+    };
+  return {
+    loggedOut: false,
+    reason: `claude auth status gave no login state (exit ${r.status}): ${(r.stdout + r.stderr).trim().slice(0, 300)}`
+  };
+}
+var claude = {
+  name: "claude",
+  bin: "claude",
+  installHint: "Install Claude Code (https://claude.com/claude-code) or pass --claude-bin PATH.",
+  configDirName: ".claude",
+  args: ({ prompt, model, extraArgs }) => [
+    "-p",
+    prompt,
+    ...FLAGS,
+    ...model === undefined ? [] : ["--model", model],
+    ...extraArgs
+  ],
+  env: ({ configDir, homeEnvFile }) => ({
+    CLAUDE_CONFIG_DIR: configDir,
+    CLAUDE_SECURESTORAGE_CONFIG_DIR: "",
+    ...homeEnvFile === undefined ? {} : { CLAUDE_ENV_FILE: homeEnvFile }
+  }),
+  authLabel: () => process.env.ANTHROPIC_API_KEY ? "ANTHROPIC_API_KEY (claude bills the API key; unset it to use your claude login)" : "your claude login",
+  checkLogin,
+  progress,
+  read,
+  sessionsDir: (configDir) => join3(configDir, "projects"),
+  findSession(configDir, sessionId) {
+    const projects = join3(configDir, "projects");
+    if (!existsSync2(projects))
+      return null;
+    for (const d of readdirSync(projects)) {
+      const f = join3(projects, d, `${sessionId}.jsonl`);
+      if (existsSync2(f))
+        return f;
+    }
+    return null;
+  }
+};
+
 // src/help.ts
 var EXIT_CODES = `Exit codes:
   0  Every run's script checks passed
@@ -7921,6 +8033,11 @@ Typical flow for a coding agent driving firegoat:
 
 Run firegoat <command> --help for details and examples.
 
+Telemetry: init, eval, login, logout and feedback each send firegoat.ai one
+anonymous event (command, exit code, error code, duration, versions, OS, run
+counts; never prompts, paths, names or env). FIREGOAT_TELEMETRY=0 or DO_NOT_TRACK=1
+turns it off; FIREGOAT_TELEMETRY accepts only 0 or 1.
+
 ${EXIT_CODES}`;
 }
 var INIT_HELP = `Usage: firegoat init [--force] [--local-skills | --no-skills] [--no-login]
@@ -8060,6 +8177,9 @@ Example:
       end_goal: .env holds a key copied from the dashboard, not a made-up one.
       claude_args: [--chrome]
 
+init also says that firegoat sends anonymous usage stats; FIREGOAT_TELEMETRY=0
+(or DO_NOT_TRACK=1) turns them off. Fields: firegoat --help, Telemetry.
+
 Exit codes: 0 done, 1 the firegoat login failed (the files stay), 2 the skill
 install failed, 3 usage error.`;
 var LOGIN_HELP = `Usage: firegoat login
@@ -8083,6 +8203,9 @@ Env:
                       saved login
   FIREGOAT_BASE_URL   Default https://firegoat.ai/evals; https only (http only
                       for localhost / 127.0.0.1)
+  FIREGOAT_TELEMETRY  0 turns off the anonymous usage event each command sends
+                      (1 or unset: on; anything else is an error). DO_NOT_TRACK=1
+                      turns it off too. With a key, the event carries it
 
 Exit codes: 0 logged in, 1 denied, expired, or firegoat.ai failed or unreachable,
 3 usage error (unknown flag, bad FIREGOAT_BASE_URL, ~/.firegoat a symlink, not a
@@ -8246,23 +8369,23 @@ Exit codes: 0 sent, 2 the service failed (or rate limit), 3 usage error.`;
 
 // src/home.ts
 import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 function homeEnv(home) {
   return {
     HOME: home,
-    XDG_CONFIG_HOME: join3(home, ".config"),
-    XDG_CACHE_HOME: join3(home, ".cache"),
-    XDG_DATA_HOME: join3(home, ".local", "share"),
-    XDG_STATE_HOME: join3(home, ".local", "state")
+    XDG_CONFIG_HOME: join4(home, ".config"),
+    XDG_CACHE_HOME: join4(home, ".cache"),
+    XDG_DATA_HOME: join4(home, ".local", "share"),
+    XDG_STATE_HOME: join4(home, ".local", "state")
   };
 }
 var shellQuote = (s) => `'${s.replaceAll("'", `'\\''`)}'`;
 function makeRunHome(dir) {
-  const home = join3(dir, "home");
+  const home = join4(dir, "home");
   const env = homeEnv(home);
   for (const d of Object.values(env))
     mkdirSync3(d, { recursive: true });
-  const envFile = join3(dir, "home.env");
+  const envFile = join4(dir, "home.env");
   writeFileSync2(envFile, Object.entries(env).map(([k, v]) => `export ${k}=${shellQuote(v)}
 `).join(""));
   return { home, envFile };
@@ -8308,9 +8431,102 @@ async function runAllSteps(opts) {
   }
 }
 
+// src/telemetry.ts
+var TIMEOUT_MS = 2000;
+var TELEMETRY_NOTICE = "firegoat sends anonymous usage stats (no prompts, paths or code); FIREGOAT_TELEMETRY=0 turns it off.";
+var state = {
+  errorCode: null,
+  eval: {
+    harness: null,
+    claudeVersion: null,
+    testCount: null,
+    runCount: null,
+    passCount: null,
+    failCount: null,
+    notGradedCount: null,
+    modelCount: null,
+    parallel: null,
+    uploaded: null,
+    uploadFailed: null
+  },
+  skills: null
+};
+function failWith(code) {
+  state.errorCode = code;
+}
+function claudeVersion(v) {
+  return typeof v === "string" && /^[\x20-\x7e]{1,64}$/.test(v) ? v : null;
+}
+function evalStats(fields) {
+  Object.assign(state.eval, fields);
+}
+function initSkills(scope) {
+  state.skills = scope;
+}
+function flagSet(v) {
+  return v !== undefined && v !== "" && v !== "0" && v !== "false";
+}
+function telemetryEnabled() {
+  const v = process.env.FIREGOAT_TELEMETRY;
+  if (v !== undefined && v !== "0" && v !== "1")
+    throw new ConfigError(`FIREGOAT_TELEMETRY must be 0 (off) or 1 (on), got ${JSON.stringify(v)}`);
+  return v !== "0" && !flagSet(process.env.DO_NOT_TRACK);
+}
+var COMMANDS = new Set(["init", "eval", "login", "logout", "feedback"]);
+function telemetryEvent(argv) {
+  const [cmd, ...rest] = argv;
+  if (cmd === undefined || !COMMANDS.has(cmd))
+    return null;
+  if (rest.includes("--help") || rest.includes("-h"))
+    return null;
+  if (cmd === "eval" && rest.includes("--dry-run"))
+    return "dry-run";
+  return cmd;
+}
+function errorCode(exitCode) {
+  if (exitCode === EXIT.pass)
+    return null;
+  return state.errorCode ?? (exitCode === EXIT.usage ? "usage" : "unknown");
+}
+async function sendTelemetry(event, exitCode, startedAt) {
+  try {
+    const base = baseUrl();
+    let key = null;
+    try {
+      key = resolveKey(base)?.key ?? null;
+    } catch {}
+    const [major, minor] = process.versions.node.split(".");
+    const body = {
+      event,
+      ok: exitCode === EXIT.pass,
+      exitCode,
+      errorCode: errorCode(exitCode),
+      durationMs: Math.round(Date.now() - startedAt),
+      cliVersion: package_default.version,
+      os: process.platform,
+      arch: process.arch,
+      node: `${major}.${minor}`,
+      ci: flagSet(process.env.CI),
+      ...event === "eval" ? state.eval : {},
+      ...event === "init" ? { skills: state.skills, loggedIn: key !== null } : {}
+    };
+    await send({
+      step: "POST /api/cli/events",
+      url: new URL(`${base}/api/cli/events`),
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...key === null ? {} : { Authorization: `Bearer ${key}` }
+      },
+      body: JSON.stringify(body),
+      timeoutMs: TIMEOUT_MS
+    });
+  } catch {}
+}
+
 // src/transcript.ts
-import { readdirSync, statSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join4, relative } from "node:path";
+import { readdirSync as readdirSync2, statSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join5, relative } from "node:path";
 var OUTPUT_LINES = 15;
 var OUTPUT_CHARS = 1500;
 var TEXT_CHARS = 1500;
@@ -8341,28 +8557,20 @@ function describeCall(step, name, input) {
       return `[${step}] ${name} ${input[key]}`;
   return `[${step}] ${name} ${truncate(JSON.stringify(input), 1, INPUT_CHARS)}`;
 }
-function describeToolUse(step, b) {
-  if (typeof b.name !== "string" || b.name === "")
+function describeToolCall(step, c) {
+  if (c.name === "")
     return `[${step}] (tool call without a name)`;
-  if (typeof b.input !== "object" || b.input === null)
-    return `[${step}] ${b.name} (no input)`;
-  return describeCall(step, b.name, b.input);
-}
-function resultText(content) {
-  if (typeof content === "string")
-    return content;
-  if (Array.isArray(content))
-    return content.map((c) => typeof c.text === "string" ? c.text : `[${c.type}]`).join(`
-`);
-  return "";
+  if (c.input === null)
+    return `[${step}] ${c.name} (no input)`;
+  return describeCall(step, c.name, c.input);
 }
 function workdirFiles(dir) {
   const out = [];
   const walk = (d) => {
-    for (const name of readdirSync(d)) {
+    for (const name of readdirSync2(d)) {
       if (SKIP_DIRS.has(name))
         continue;
-      const p = join4(d, name);
+      const p = join5(d, name);
       if (statSync(p).isDirectory())
         walk(p);
       else
@@ -8374,32 +8582,20 @@ function workdirFiles(dir) {
 }
 function writeTranscript(opts) {
   const out = [`# ${opts.title}`, "", "## prompt", opts.prompt, "", "## steps"];
+  const { final } = opts;
   let step = 0;
-  let final = "";
   let lastText = -1;
-  for (const e of opts.events) {
-    const message = e?.message;
-    const content = Array.isArray(message?.content) ? message.content : [];
-    if (e?.type === "assistant")
-      for (const b of content) {
-        if (b.type === "tool_use")
-          out.push(describeToolUse(++step, b));
-        else if (b.type === "text" && typeof b.text === "string") {
-          lastText = out.length;
-          out.push(prose(truncate(b.text, 30, TEXT_CHARS)));
-        }
-      }
-    else if (e?.type === "user")
-      for (const b of content) {
-        if (b.type !== "tool_result")
-          continue;
-        const text = resultText(b.content).trimEnd();
-        const status = b.is_error === true ? "error" : "ok";
-        out.push(text ? `    → ${status}
-${indent(truncate(text, OUTPUT_LINES, OUTPUT_CHARS))}` : `    → ${status}`);
-      }
-    else if (e?.type === "result" && typeof e.result === "string")
-      final = e.result;
+  for (const s of opts.steps) {
+    if (s.kind === "tool_call")
+      out.push(describeToolCall(++step, s));
+    else if (s.kind === "text") {
+      lastText = out.length;
+      out.push(prose(truncate(s.text, 30, TEXT_CHARS)));
+    } else {
+      const status = s.isError ? "error" : "ok";
+      out.push(s.text ? `    → ${status}
+${indent(truncate(s.text, OUTPUT_LINES, OUTPUT_CHARS))}` : `    → ${status}`);
+    }
   }
   if (lastText === out.length - 1 && final && out[lastText] === prose(truncate(final, 30, TEXT_CHARS)))
     out.pop();
@@ -8703,7 +8899,7 @@ function ttyUI(out, opts) {
 }
 
 // src/upload.ts
-import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
 import { basename as basename2 } from "node:path";
 var MAX_FILE = 20 * 1024 * 1024;
 var MAX_CHECKS = 200;
@@ -8785,7 +8981,7 @@ async function uploadRun(t, r) {
   };
   const bytes = {};
   for (const name of FILES) {
-    const b = existsSync2(paths[name]) ? readFileSync3(paths[name]) : Buffer.alloc(0);
+    const b = existsSync3(paths[name]) ? readFileSync3(paths[name]) : Buffer.alloc(0);
     if (b.byteLength > MAX_FILE)
       return {
         status: "failed",
@@ -8868,7 +9064,7 @@ async function uploadRun(t, r) {
 
 // src/which.ts
 import { accessSync, constants, statSync as statSync2 } from "node:fs";
-import { delimiter, join as join5, resolve } from "node:path";
+import { delimiter, join as join6, resolve } from "node:path";
 function resolveBin(bin) {
   const executable = (p) => {
     try {
@@ -8881,8 +9077,8 @@ function resolveBin(bin) {
   if (bin.includes("/"))
     return executable(bin) ? resolve(bin) : undefined;
   for (const dir of (process.env.PATH ?? "").split(delimiter)) {
-    if (dir && executable(join5(dir, bin)))
-      return join5(dir, bin);
+    if (dir && executable(join6(dir, bin)))
+      return join6(dir, bin);
   }
   return;
 }
@@ -8957,23 +9153,12 @@ function parseArgs(args) {
   }
   return opts;
 }
-function findSession(configDir, sessionId) {
-  const projects = join6(configDir, "projects");
-  if (!existsSync3(projects))
-    return null;
-  for (const d of readdirSync2(projects)) {
-    const f = join6(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}-${randomBytes2(2).toString("hex")}`;
 }
 function writeRunJson(r) {
-  writeFileSync4(join6(r.dir, "run.json"), `${JSON.stringify(r, null, 2)}
+  writeFileSync4(join7(r.dir, "run.json"), `${JSON.stringify(r, null, 2)}
 `);
 }
 async function uploadPreflight(opts, ui, project, runGroup, git) {
@@ -9004,10 +9189,12 @@ async function uploadPreflight(opts, ui, project, runGroup, git) {
     if (e.status === 401 || e.status === 403)
       return {
         exitCode: EXIT.usage,
+        code: "auth",
         error: `${origin} rejected the key (${e.message}): run firegoat login or pass --no-upload`
       };
     return {
       exitCode: EXIT.notGraded,
+      code: e instanceof NetworkError ? "network" : "server",
       error: `${e.status === null ? `Could not reach ${origin}` : `${origin} answered`} (${e.message}): retry, check FIREGOAT_BASE_URL, or pass --no-upload`
     };
   }
@@ -9018,8 +9205,8 @@ function runFill(runId, n, testName, out, dir) {
     "run.n": String(n),
     "test.name": testName,
     FIREGOAT_OUT: out,
-    FIREGOAT_WORKDIR: join6(dir, "work"),
-    FIREGOAT_HOME: join6(dir, "home")
+    FIREGOAT_WORKDIR: join7(dir, "work"),
+    FIREGOAT_HOME: join7(dir, "home")
   };
 }
 function renderClaudeArgs(test, vars, fill) {
@@ -9035,10 +9222,10 @@ function planRuns(tests, models, runs) {
 }
 var DRY_RUN_ID = "<runId>";
 function dryRun(opts) {
-  const out = join6(opts.runsRoot, DRY_RUN_ID, "out");
+  const out = join7(opts.runsRoot, DRY_RUN_ID, "out");
   const runs = opts.plan.map((p) => {
     const test = opts.tests.find((t) => t.name === p.test);
-    const fill = runFill(DRY_RUN_ID, p.n, test.name, out, join6(opts.runsRoot, DRY_RUN_ID, test.name, String(p.n)));
+    const fill = runFill(DRY_RUN_ID, p.n, test.name, out, join7(opts.runsRoot, DRY_RUN_ID, test.name, String(p.n)));
     renderEnv(test.env, opts.vars, fill);
     return {
       ...p,
@@ -9060,8 +9247,8 @@ function dryRun(opts) {
 async function runOne(opts) {
   const { test, n } = opts;
   const started = Date.now();
-  const dir = join6(opts.runDir, test.name, String(n));
-  const workdir = join6(dir, "work");
+  const dir = join7(opts.runDir, test.name, String(n));
+  const workdir = join7(dir, "work");
   mkdirSync4(workdir, { recursive: true });
   const { home, envFile } = makeRunHome(dir);
   const fill = runFill(opts.runId, n, test.name, opts.out, dir);
@@ -9080,11 +9267,11 @@ async function runOne(opts) {
     workdir,
     home,
     session: null,
-    transcript: join6(dir, "transcript.txt"),
-    stderr: join6(dir, "stderr.txt"),
-    checksLog: join6(dir, "checks.txt"),
+    transcript: join7(dir, "transcript.txt"),
+    stderr: join7(dir, "stderr.txt"),
+    checksLog: join7(dir, "checks.txt"),
     cleanup: [],
-    cleanupLog: join6(dir, "cleanup.txt"),
+    cleanupLog: join7(dir, "cleanup.txt"),
     num_turns: null,
     cost: null,
     duration_ms: 0,
@@ -9124,18 +9311,21 @@ async function attempt(opts, r, env, stepEnv, homeEnvFile) {
       commands: install,
       cwd: workdir,
       env: stepEnv,
-      logPath: join6(dir, "install.txt")
+      logPath: join7(dir, "install.txt")
     });
     if (error)
       return ["error", `not graded: ${error}`];
   }
   const stderr = createWriteStream2(r.stderr);
-  const outcome = await runClaude({
-    bin: opts.claudeBin,
+  const { harness } = opts;
+  const outcome = await runAgent(harness, {
+    bin: opts.bin,
     prompt: r.prompt,
     cwd: workdir,
     env: {
-      ...claudeEnv(opts.configDir, env, homeEnvFile),
+      ...hostEnv(),
+      ...env,
+      ...harness.env({ configDir: opts.configDir, homeEnvFile }),
       PATH: opts.stepEnv.PATH,
       FIREGOAT_OUT: opts.out,
       FIREGOAT_WORKDIR: workdir,
@@ -9145,27 +9335,30 @@ async function attempt(opts, r, env, stepEnv, homeEnvFile) {
     timeoutMs: test.timeout * 1000,
     model: opts.model ?? undefined,
     extraArgs: r.claudeArgs,
-    onEvent: opts.onEvent
+    onProgress: opts.onProgress
   });
-  r.claudeModel = outcome.claudeModel;
+  r.claudeModel = outcome.reportedModel;
+  if (outcome.version !== null)
+    evalStats({ claudeVersion: claudeVersion(outcome.version) });
   await new Promise((res) => stderr.end(res));
   if (outcome.sessionId)
-    r.session = findSession(opts.configDir, outcome.sessionId);
+    r.session = harness.findSession(opts.configDir, outcome.sessionId);
   writeTranscript({
     path: r.transcript,
     title: `${test.name}#${n}${opts.model ? ` (model ${opts.model})` : ""}`,
     prompt: r.prompt,
-    events: outcome.events,
+    steps: outcome.steps,
+    final: outcome.final,
     workdir
   });
-  r.num_turns = outcome.result?.num_turns ?? null;
-  r.cost = outcome.result?.total_cost_usd ?? null;
+  r.num_turns = outcome.turns;
+  r.cost = outcome.cost;
   if (!outcome.ok)
     return ["error", `not graded: ${outcome.reason}`];
   if (!r.session)
     return [
       "error",
-      `not graded: claude saved no session file for ${outcome.sessionId} under ${opts.configDir}/projects`
+      `not graded: ${harness.name} saved no session file for ${outcome.sessionId} under ${harness.sessionsDir(opts.configDir)}`
     ];
   const log = createWriteStream2(r.checksLog);
   try {
@@ -9202,7 +9395,7 @@ function uploadedSummary(origin, results, runDir) {
     return;
   const head = `Uploaded ${urls.length} session${urls.length === 1 ? "" : "s"} to ${new URL(origin).host} (private)`;
   if (urls.length > MAX_LISTED_URLS) {
-    console.log(`${head}: each run's upload.url in ${join6(runDir, "summary.json")}`);
+    console.log(`${head}: each run's upload.url in ${join7(runDir, "summary.json")}`);
     return;
   }
   console.log(`${head}:`);
@@ -9215,7 +9408,8 @@ async function evalCommand(args, root) {
     return EXIT.pass;
   }
   const json = args.includes("--json");
-  const fatal = (exitCode, error) => {
+  const fatal = (exitCode, error, code) => {
+    failWith(code);
     console.error(`firegoat eval: ${error}`);
     if (json)
       console.log(JSON.stringify({ error, exitCode }));
@@ -9226,7 +9420,7 @@ async function evalCommand(args, root) {
     opts = parseArgs(args);
   } catch (e) {
     if (e instanceof UsageError)
-      return fatal(EXIT.usage, e.message);
+      return fatal(EXIT.usage, e.message, "usage");
     throw e;
   }
   const say = opts.json ? console.error : console.log;
@@ -9243,7 +9437,7 @@ async function evalCommand(args, root) {
     config = loadConfig(root);
   } catch (e) {
     if (e instanceof ConfigError)
-      return fatal(EXIT.usage, e.message);
+      return fatal(EXIT.usage, e.message, "config");
     throw e;
   }
   let tests = config.tests;
@@ -9251,11 +9445,17 @@ async function evalCommand(args, root) {
     const known = new Set(tests.map((t) => t.name));
     const unknown = opts.names.filter((n) => !known.has(n));
     if (unknown.length > 0)
-      return fatal(EXIT.usage, `Unknown test ${unknown.map((n) => JSON.stringify(n)).join(", ")} (known: ${[...known].join(", ")})`);
+      return fatal(EXIT.usage, `Unknown test ${unknown.map((n) => JSON.stringify(n)).join(", ")} (known: ${[...known].join(", ")})`, "usage");
     tests = tests.filter((t) => opts.names.includes(t.name));
   }
   const runs = opts.runs ?? config.runs;
   const models = opts.models.length > 0 ? opts.models : config.models;
+  evalStats({
+    testCount: tests.length,
+    runCount: tests.length * runs * Math.max(models.length, 1),
+    modelCount: models.length,
+    parallel: opts.parallel
+  });
   const vars = { ...config.vars, ...opts.vars };
   const missing = [
     ...new Set(tests.flatMap((t) => [
@@ -9266,13 +9466,13 @@ async function evalCommand(args, root) {
     ]).flatMap(varRefs).filter((k) => !(k in vars)))
   ];
   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`);
+    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`, "config");
   if (opts.dryRun) {
     let repo;
     try {
       repo = gitRepo(root);
     } catch (e) {
-      return fatal(EXIT.usage, e.message);
+      return fatal(EXIT.usage, e.message, "config");
     }
     try {
       dryRun({
@@ -9280,53 +9480,55 @@ async function evalCommand(args, root) {
         tests,
         plan: planRuns(tests, models, runs),
         vars,
-        runsRoot: join6(repo?.mainCheckout ?? root, ".firegoat", "runs"),
+        runsRoot: join7(repo?.mainCheckout ?? root, ".firegoat", "runs"),
         json: opts.json,
         say
       });
     } catch (e) {
       if (e instanceof ConfigError)
-        return fatal(EXIT.usage, e.message);
+        return fatal(EXIT.usage, e.message, "config");
       throw e;
     }
     return EXIT.pass;
   }
-  const claudePath = resolveBin(opts.claudeBin);
-  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.`);
+  const harness = claude;
+  evalStats({ harness: harness.name });
+  const binPath = resolveBin(opts.claudeBin);
+  if (!binPath)
+    return fatal(EXIT.notGraded, `Not graded: ${harness.name} binary ${JSON.stringify(opts.claudeBin)} not found. ${harness.installHint}`, "claude_missing");
   let repo;
   try {
     repo = gitRepo(root);
   } catch (e) {
-    return fatal(EXIT.usage, e.message);
+    return fatal(EXIT.usage, e.message, "config");
   }
   const firegoatDir = ensureFiregoatDir(repo?.mainCheckout ?? root);
-  const configDir = join6(firegoatDir, ".claude");
+  const configDir = join7(firegoatDir, harness.configDirName);
   mkdirSync4(configDir, { recursive: true });
-  ui.auth(process.env.ANTHROPIC_API_KEY ? "ANTHROPIC_API_KEY (claude bills the API key; unset it to use your claude login)" : "your claude login");
-  const loginProblem = checkLogin({
-    bin: claudePath,
-    env: claudeEnv(configDir),
+  ui.auth(harness.authLabel());
+  const loginProblem = harness.checkLogin({
+    bin: binPath,
+    env: { ...hostEnv(), ...harness.env({ configDir }) },
     cwd: root
   });
   if (loginProblem)
-    return fatal(EXIT.notGraded, `Not graded: ${loginProblem}`);
+    return fatal(EXIT.notGraded, `Not graded: ${loginProblem.reason}`, loginProblem.loggedOut ? "claude_logged_out" : "claude_auth_status");
   const evalStarted = Date.now();
   const runId = newRunId();
   let upload;
   try {
     const pre = await uploadPreflight(opts, ui, basename3(repo?.mainCheckout ?? repo?.toplevel ?? root), runId, repo?.info ?? null);
     if (pre && "exitCode" in pre)
-      return fatal(pre.exitCode, pre.error);
+      return fatal(pre.exitCode, pre.error, pre.code);
     upload = pre;
   } catch (e) {
     if (e instanceof ConfigError)
-      return fatal(EXIT.usage, e.message);
+      return fatal(EXIT.usage, e.message, "config");
     throw e;
   }
-  const runsRoot = join6(firegoatDir, "runs");
-  const runDir = join6(runsRoot, runId);
-  const out = join6(runDir, "out");
+  const runsRoot = join7(firegoatDir, "runs");
+  const runDir = join7(runsRoot, runId);
+  const out = join7(runDir, "out");
   mkdirSync4(out, { recursive: true });
   const stepEnv = {
     ...hostEnv(),
@@ -9350,12 +9552,12 @@ async function evalCommand(args, root) {
         ...stepEnv,
         ...renderEnv(Object.fromEntries(Object.entries(config.env).filter(([, v]) => isEvalLevel(v))), vars, { "run.id": runId, FIREGOAT_OUT: out })
       },
-      logPath: join6(runDir, "build.txt")
+      logPath: join7(runDir, "build.txt")
     });
     const secs = Math.round((Date.now() - buildStarted) / 1000);
     ui.build(error ? "fail" : "ok", secs);
     if (error)
-      return fatal(EXIT.notGraded, `Not graded: ${error}`);
+      return fatal(EXIT.notGraded, `Not graded: ${error}`, "build_failed");
   }
   ui.runs(rows);
   const results = new Array(rows.length);
@@ -9365,26 +9567,18 @@ async function evalCommand(args, root) {
     row.state = "running";
     ui.update();
     const r = await runOne({
-      onEvent: (e) => {
-        if (e.type !== "assistant")
-          return;
+      onProgress: (p) => {
         row.turns++;
-        const content = e.message?.content;
-        if (!Array.isArray(content))
-          return;
-        for (const b of content) {
-          const cmd = b.input?.command;
-          if (b.type === "tool_use" && typeof cmd === "string")
-            row.command = cmd.split(`
-`)[0];
-        }
+        if (p.command !== undefined)
+          row.command = p.command;
       },
       test,
       n: row.n,
       model: row.model,
       runId,
       runDir,
-      claudeBin: claudePath,
+      harness,
+      bin: binPath,
       configDir,
       install: config.install,
       cleanup: config.cleanup,
@@ -9422,6 +9616,14 @@ async function evalCommand(args, root) {
   for (const r of results)
     totals[r.status]++;
   const uploadsFailed = results.filter((r) => r.upload?.status === "failed").length;
+  const uploaded = results.filter((r) => r.upload?.status === "uploaded").length;
+  evalStats({
+    passCount: totals.pass,
+    failCount: totals.fail,
+    notGradedCount: totals.error,
+    uploaded,
+    uploadFailed: uploadsFailed
+  });
   const doc = {
     firegoatVersion: package_default.version,
     runId,
@@ -9432,9 +9634,9 @@ async function evalCommand(args, root) {
     totals,
     runs: results
   };
-  writeFileSync4(join6(runDir, "summary.json"), `${JSON.stringify(doc, null, 2)}
+  writeFileSync4(join7(runDir, "summary.json"), `${JSON.stringify(doc, null, 2)}
 `);
-  appendFileSync(join6(runsRoot, "index.jsonl"), `${JSON.stringify({
+  appendFileSync(join7(runsRoot, "index.jsonl"), `${JSON.stringify({
     runId,
     startedAt: new Date(evalStarted).toISOString(),
     dir: root,
@@ -9444,7 +9646,7 @@ async function evalCommand(args, root) {
     failed: totals.fail,
     notGraded: totals.error,
     cost: results.every((r) => r.cost !== null) ? results.reduce((sum, r) => sum + r.cost, 0) : null,
-    uploaded: results.filter((r) => r.upload?.status === "uploaded").length,
+    uploaded,
     uploadFailed: uploadsFailed
   })}
 `);
@@ -9464,6 +9666,10 @@ async function evalCommand(args, root) {
     console.error(`firegoat eval: ${uploadsFailed} upload${uploadsFailed === 1 ? "" : "s"} failed (each run's upload.error in summary.json)`);
   if (opts.json)
     console.log(JSON.stringify(doc, null, 2));
+  if (totals.error > 0)
+    failWith("not_graded");
+  else if (totals.fail > 0)
+    failWith("checks_failed");
   return totals.error > 0 ? EXIT.notGraded : totals.fail > 0 ? EXIT.fail : EXIT.pass;
 }
 
@@ -9534,7 +9740,7 @@ function defaultDeviceStore() {
 }
 var VERSION = "0.2.0";
 var DEFAULT_BASE_URL2 = "https://firegoat.ai/evals";
-var TIMEOUT_MS = 15000;
+var TIMEOUT_MS2 = 15000;
 function envBaseUrl() {
   return globalThis.process?.env?.FEEDBACK_API_URL;
 }
@@ -9638,7 +9844,7 @@ class FeedbackClient {
       method: "POST",
       headers,
       body: body === undefined ? undefined : JSON.stringify(body),
-      signal: AbortSignal.timeout(TIMEOUT_MS)
+      signal: AbortSignal.timeout(TIMEOUT_MS2)
     });
     const text = await res.text();
     let data;
@@ -9728,7 +9934,12 @@ firegoat ${package_default.version}` : `firegoat ${package_default.version}`,
     if (e instanceof FeedbackError) {
       const hint = e.code === "possible_secret" ? " Remove the secret from the title/body and send again." : e.code === "rate_limited" && e.retryAfterSeconds ? ` Try again in ${e.retryAfterSeconds}s.` : "";
       console.error(`firegoat feedback: ${e.code}: ${e.message}.${hint}`);
-      return e.code === "invalid_request" || e.code === "possible_secret" ? EXIT.usage : EXIT.notGraded;
+      if (e.code === "invalid_request" || e.code === "possible_secret") {
+        failWith("usage");
+        return EXIT.usage;
+      }
+      failWith(e.code === "rate_limited" ? "rate_limited" : "server");
+      return EXIT.notGraded;
     }
     throw e;
   }
@@ -9737,12 +9948,12 @@ firegoat ${package_default.version}` : `firegoat ${package_default.version}`,
 // src/init.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
 import { existsSync as existsSync4, writeFileSync as writeFileSync5 } from "node:fs";
-import { basename as basename4, join as join7 } from "node:path";
+import { basename as basename4, join as join8 } from "node:path";
 import { createInterface } from "node:readline/promises";
 
 // src/login.ts
 import { spawn as spawn2 } from "node:child_process";
-var TIMEOUT_MS2 = 30000;
+var TIMEOUT_MS3 = 30000;
 var MAX_EXPIRES_S = 900;
 var MAX_INTERVAL_S = 60;
 var FORM = { "Content-Type": "application/x-www-form-urlencoded" };
@@ -9776,7 +9987,7 @@ async function loginFlow(say, interactive) {
     step: cfgStep,
     url: new URL(`${base}/api/traces/oauth/config`),
     method: "GET",
-    timeoutMs: TIMEOUT_MS2
+    timeoutMs: TIMEOUT_MS3
   });
   if (cfg.status !== 200)
     throw replyError(cfgStep, cfg);
@@ -9792,7 +10003,7 @@ async function loginFlow(say, interactive) {
     method: "POST",
     headers: FORM,
     body: new URLSearchParams({ client_id: clientId }).toString(),
-    timeoutMs: TIMEOUT_MS2
+    timeoutMs: TIMEOUT_MS3
   });
   if (dev.status !== 200)
     throw replyError(devStep, dev);
@@ -9833,7 +10044,7 @@ async function loginFlow(say, interactive) {
         client_id: clientId,
         device_code: deviceCode
       }).toString(),
-      timeoutMs: TIMEOUT_MS2
+      timeoutMs: TIMEOUT_MS3
     });
     if (r.status === 200) {
       const t = r.json?.access_token;
@@ -9887,10 +10098,12 @@ ${LOGIN_HELP}`);
     return EXIT.pass;
   } catch (e) {
     if (e instanceof ConfigError) {
+      failWith("config");
       console.error(`firegoat login: ${e.message}`);
       return EXIT.usage;
     }
     if (e instanceof ApiError) {
+      failWith(e instanceof NetworkError ? "network" : "login_failed");
       console.error(`firegoat login: ${e.message}`);
       return EXIT.fail;
     }
@@ -9933,7 +10146,7 @@ function skillsDir(scope) {
   if (scope === "local")
     return ".claude/skills/";
   const config = process.env.CLAUDE_CONFIG_DIR?.trim();
-  return config ? `${join7(config, "skills")}/` : "~/.claude/skills/";
+  return config ? `${join8(config, "skills")}/` : "~/.claude/skills/";
 }
 function template(product) {
   return `# firegoat.yaml: evals for how well coding agents use ${product}.
@@ -10080,6 +10293,7 @@ ${UPLOADS_ON}`);
   } catch (e) {
     if (!(e instanceof ApiError))
       throw e;
+    failWith(e instanceof NetworkError ? "network" : "login_failed");
     console.error(`firegoat init: Login failed: ${e.message}`);
     return EXIT.fail;
   }
@@ -10116,6 +10330,7 @@ ${INIT_HELP}`);
     return EXIT.usage;
   }
   let scope = noSkills ? "none" : localSkills ? "local" : "global";
+  initSkills(scope);
   const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
   const color = interactive && !process.env.NO_COLOR;
   const paint = (code, text) => color ? `\x1B[${code}m${text}\x1B[0m` : text;
@@ -10128,7 +10343,7 @@ ${INIT_HELP}`);
     console.log(rule);
   }
   ensureFiregoatDir(cwd);
-  const configPath = join7(cwd, CONFIG_FILE);
+  const configPath = join8(cwd, CONFIG_FILE);
   const keep = existsSync4(configPath) && !force;
   if (!keep)
     writeFileSync5(configPath, template(basename4(cwd)));
@@ -10143,6 +10358,7 @@ ${INIT_HELP}`);
   if (interactive && !noSkills && !localSkills) {
     scope = await askScope(`  ${paint("38;5;208", "◉")}  ${paint("90", "03")}  Install the firegoat-onboarding skill globally (~/.claude/skills) or in this repo (.claude/skills)?`);
     process.stdout.write("\x1B[1A\x1B[2K");
+    initSkills(scope);
   }
   if (scope !== "none") {
     const argv = [...SKILLS_ARGV, ...scope === "global" ? ["-g"] : []];
@@ -10157,6 +10373,7 @@ ${INIT_HELP}`);
       encoding: "utf8"
     });
     if (r.error || r.status !== 0) {
+      failWith("skills_failed");
       process.stderr.write(`${r.stdout ?? ""}${r.stderr ?? ""}`);
       console.error(`firegoat init: Installing the skill failed (${r.error?.message ?? `exit ${r.status}`}). Run it yourself: npx ${argv.join(" ")}`);
       return EXIT.notGraded;
@@ -10180,11 +10397,16 @@ ${INIT_HELP}`);
     if (loginExit !== EXIT.pass)
       return loginExit;
   }
+  const telemetryOn = telemetryEnabled();
   if (!interactive) {
+    if (telemetryOn)
+      console.log(TELEMETRY_NOTICE);
     console.log(`
 Prompt for your coding agent: ${AGENT_PROMPT}`);
     return EXIT.pass;
   }
+  if (telemetryOn)
+    console.log(`  ${paint("90", TELEMETRY_NOTICE)}`);
   console.log(rule);
   console.log(`  Next: hand this to your coding agent
 `);
@@ -10225,16 +10447,33 @@ ${topHelp(package_default.version)}`);
       return EXIT.usage;
   }
 }
-main(process.argv.slice(2)).then((code) => process.exit(code), (err) => {
+function crashed(err) {
   if (err instanceof ConfigError) {
+    failWith("config");
     console.error(err.message);
-    process.exit(EXIT.usage);
+    return EXIT.usage;
   }
   if (err?.code === "ABORT_ERR") {
+    failWith("aborted");
     console.error(`
 Aborted.`);
-    process.exit(130);
+    return 130;
   }
+  failWith("unknown");
   console.error(err);
-  process.exit(EXIT.notGraded);
+  return EXIT.notGraded;
+}
+var startedAt = Date.now();
+var argv = process.argv.slice(2);
+var event;
+try {
+  event = telemetryEnabled() ? telemetryEvent(argv) : null;
+} catch (e) {
+  console.error(`firegoat: ${e.message}`);
+  process.exit(EXIT.usage);
+}
+main(argv).catch(crashed).then(async (code) => {
+  if (event)
+    await sendTelemetry(event, code, startedAt);
+  process.exit(code);
 });