@pimmesz/afterburner 1.0.1

package/dist/cli/index.js

@@ -0,0 +1,1524 @@
+#!/usr/bin/env node
+import {
+  ConsoleNotifier,
+  JsonlRunStore,
+  ManualBudgetProvider,
+  budgetFromUsageCache,
+  claudeConfigDir,
+  createBudgetProvider,
+  createRunner,
+  createSelector,
+  dataDir,
+  defaultClaudeProjectsDir,
+  defaultUsageCachePath,
+  findConfigPath,
+  generateScheduleArtifacts,
+  liveDowngradeReason,
+  loadConfig,
+  looksRemoteRepoUrl,
+  readUsageCache,
+  runOnce,
+  startWatch,
+  writeUsageCache
+} from "../chunk-OZAFLQDP.js";
+import {
+  MCP_STUB_MESSAGE
+} from "../chunk-2NSOEZWY.js";
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// package.json
+var package_default = {
+  name: "@pimmesz/afterburner",
+  version: "1.0.1",
+  description: "Convert idle Claude subscription quota into shippable engineering work: budget-aware trigger, bounded task selection, PR-only output.",
+  license: "Apache-2.0",
+  publishConfig: {
+    access: "public"
+  },
+  type: "module",
+  packageManager: "pnpm@11.5.3",
+  engines: {
+    node: ">=22.12"
+  },
+  bin: {
+    afterburner: "./dist/cli/index.js",
+    abr: "./dist/cli/index.js"
+  },
+  main: "./dist/core/index.js",
+  types: "./dist/core/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/core/index.d.ts",
+      import: "./dist/core/index.js",
+      default: "./dist/core/index.js"
+    }
+  },
+  files: [
+    "dist",
+    "skill",
+    "assets/afterburner-logo.png",
+    "afterburner.config.example.ts",
+    ".env.example"
+  ],
+  scripts: {
+    build: "tsup",
+    prepack: "pnpm build",
+    dev: "tsx src/cli/index.ts",
+    lint: "eslint . && prettier --check .",
+    format: "prettier --write .",
+    typecheck: "tsc --noEmit",
+    test: "vitest run",
+    "test:watch": "vitest"
+  },
+  repository: {
+    type: "git",
+    url: "https://github.com/pimmesz/afterburner.git"
+  },
+  keywords: [
+    "claude",
+    "claude-code",
+    "automation",
+    "quota",
+    "agent",
+    "pull-request"
+  ],
+  dependencies: {
+    commander: "^15.0.0",
+    cosmiconfig: "^9.0.2",
+    "env-paths": "^4.0.0",
+    "node-cron": "^4.2.1",
+    zod: "^4.4.3"
+  },
+  devDependencies: {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^25.9.2",
+    eslint: "^10.4.1",
+    "eslint-config-prettier": "^10.1.8",
+    prettier: "^3.8.4",
+    tsup: "^8.5.1",
+    tsx: "^4.22.4",
+    typescript: "^6.0.3",
+    "typescript-eslint": "^8.61.0",
+    vitest: "^4.1.8"
+  }
+};
+
+// src/cli/ui.ts
+var noColor = !!process.env.NO_COLOR || process.env.TERM === "dumb";
+var fancy = process.stdout.isTTY === true && !noColor;
+var fancyErr = process.stderr.isTTY === true && !noColor;
+var canAnimate = fancyErr && !process.env.CI;
+var paint = (enabled) => (open, close) => (s) => enabled ? `\x1B[${open}m${s}\x1B[${close}m` : s;
+var wrap = paint(fancy);
+var bold = wrap(1, 22);
+var dim = wrap(2, 22);
+var red = wrap(31, 39);
+var green = wrap(32, 39);
+var yellow = wrap(33, 39);
+var cyan = wrap(36, 39);
+var flame = (s) => fancy ? `\x1B[38;5;208m${s}\x1B[39m` : s;
+var errRed = paint(fancyErr)(31, 39);
+var errYellow = paint(fancyErr)(33, 39);
+var flameErr = (s) => fancyErr ? `\x1B[38;5;208m${s}\x1B[39m` : s;
+var emoji = {
+  jet: "\u2708\uFE0F",
+  // ✈️
+  rocket: "\u{1F680}",
+  // 🚀
+  flame: "\u{1F525}",
+  // 🔥
+  thrust: "\u{1F4A8}",
+  // 💨
+  fuel: "\u26FD"
+  // ⛽
+};
+function deco(glyph) {
+  return fancy ? `${glyph} ` : "";
+}
+function section(glyph, title) {
+  return `${deco(glyph)}${bold(title)}`;
+}
+function step(label, value) {
+  return `${green("\u2713")} ${bold(label)}: ${value}`;
+}
+function nextCmd(cmd, note) {
+  const line = `  ${bold(flame(cmd))}`;
+  return note ? `${line}
+  ${dim(note)}` : line;
+}
+function cmdRow(cmd, note, width = 32) {
+  return `  ${bold(cmd.padEnd(width))}${dim(note)}`;
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function spinner(text) {
+  if (!canAnimate) {
+    process.stderr.write(`${text}
+`);
+    return { update: () => {
+    }, stop: (final) => final && process.stderr.write(`${final}
+`) };
+  }
+  let current = text;
+  let i = 0;
+  const render = () => {
+    i = (i + 1) % SPINNER_FRAMES.length;
+    process.stderr.write(`\r${flameErr(SPINNER_FRAMES[i] ?? "")} ${current}\x1B[K`);
+  };
+  const id = setInterval(render, 80);
+  render();
+  return {
+    update: (t) => {
+      current = t;
+    },
+    stop: (final) => {
+      clearInterval(id);
+      process.stderr.write("\r\x1B[K");
+      if (final) process.stderr.write(`${final}
+`);
+    }
+  };
+}
+async function spool() {
+  if (!canAnimate) return;
+  const trail = ["", "\xB7", "\xB7\xB7", emoji.thrust, `${emoji.thrust}${emoji.flame}`];
+  for (const t of trail) {
+    process.stderr.write(`\r${emoji.jet} ${flameErr(t)}\x1B[K`);
+    await sleep(55);
+  }
+  process.stderr.write("\r\x1B[K");
+}
+async function ignite() {
+  if (!canAnimate) return;
+  const burst = [
+    `${emoji.jet} ${flameErr(emoji.thrust)}`,
+    `${emoji.jet} ${flameErr(emoji.thrust + emoji.flame)}`,
+    `${emoji.jet} ${flameErr(emoji.thrust + emoji.flame + emoji.flame)}`,
+    `${emoji.jet}${flameErr(emoji.flame + emoji.flame + emoji.flame)}`
+  ];
+  for (const frame of burst) {
+    process.stderr.write(`\r${frame}\x1B[K`);
+    await sleep(70);
+  }
+  process.stderr.write("\r\x1B[K");
+}
+function banner() {
+  const title = `${deco(emoji.jet)}${flame(bold("afterburner"))}`;
+  return `${title}
+${dim("  idle Claude quota, turned into reviewed pull requests")}`;
+}
+
+// src/cli/commands/doctor.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync2, statSync } from "fs";
+import { mkdir, rm, writeFile } from "fs/promises";
+import { isAbsolute, join, resolve as resolve2 } from "path";
+
+// src/cli/helpers.ts
+import { existsSync } from "fs";
+import { basename, dirname, resolve } from "path";
+async function loadConfigOrExit(configPath) {
+  try {
+    return await loadConfig(configPath);
+  } catch (error) {
+    console.error(errRed(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+}
+function fail(message) {
+  console.error(errRed(message));
+  process.exit(1);
+}
+var DISCOVERABLE_CONFIG_NAMES = /* @__PURE__ */ new Set([
+  "package.json",
+  ".afterburnerrc",
+  ".afterburnerrc.json",
+  ".afterburnerrc.yaml",
+  ".afterburnerrc.yml",
+  ".afterburnerrc.js",
+  ".afterburnerrc.ts",
+  ".afterburnerrc.mjs",
+  ".afterburnerrc.cjs",
+  "afterburner.config.js",
+  "afterburner.config.ts",
+  "afterburner.config.mjs",
+  "afterburner.config.cjs"
+]);
+function suggestCommand(sub, configPath, cwd = process.cwd()) {
+  const absolute = resolve(configPath);
+  if (dirname(absolute) === resolve(cwd) && DISCOVERABLE_CONFIG_NAMES.has(basename(absolute))) {
+    return `afterburner ${sub}`;
+  }
+  const quoted = /\s/.test(configPath) ? `"${configPath}"` : configPath;
+  return `afterburner ${sub} --config ${quoted}`;
+}
+function formatTokens(tokens) {
+  return tokens.toLocaleString("en-US");
+}
+function resolveCliEntry() {
+  const entry = process.argv[1] ? resolve(process.argv[1]) : "";
+  if (!entry || !existsSync(entry)) {
+    fail("Could not resolve the afterburner CLI entry script, is the installation intact?");
+  }
+  if (entry.endsWith(".ts")) {
+    fail(
+      "This command must run from the built CLI (it embeds a node-runnable path). Run `pnpm build` and use `node dist/cli/index.js ...`, or install the package."
+    );
+  }
+  return entry;
+}
+
+// src/cli/commands/doctor.ts
+function registerDoctor(program2, packageInfo2) {
+  program2.command("doctor").description("Check prerequisites and configuration; every failure prints an actionable fix").option("--config <path>", "path to a config file").option("--check-updates", "query the npm registry for the latest published version").action(
+    (opts) => runDoctor({ packageInfo: packageInfo2, configPath: opts.config, checkUpdates: opts.checkUpdates })
+  );
+}
+async function runDoctor(opts) {
+  console.log(`${deco(emoji.fuel)}${bold("afterburner doctor")}`);
+  const results = [];
+  let latest;
+  if (opts.checkUpdates) {
+    const spin = spinner("checking npm for the latest version\u2026");
+    latest = await fetchLatestNpmVersion(opts.packageInfo.packageName);
+    spin.stop();
+  } else {
+    latest = { status: "skipped" };
+  }
+  results.push(
+    checkVersion({
+      ...opts.packageInfo,
+      latest,
+      cliEntryPath: process.argv[1],
+      cwd: process.cwd()
+    })
+  );
+  results.push(checkNodeVersion());
+  results.push(checkGit());
+  let config;
+  let configPath;
+  try {
+    const loaded = await loadConfig(opts.configPath);
+    config = loaded.config;
+    configPath = loaded.filepath;
+    results.push({ name: "config", ok: true, detail: `valid (${loaded.filepath})` });
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    results.push({
+      name: "config",
+      ok: false,
+      detail,
+      // Only suggest init when there is no config at all, for load/parse
+      // failures the detail above already carries the exact fix, and
+      // suggesting init for a config init just wrote would be circular.
+      ...detail.startsWith("No Afterburner config found") ? { fix: "Run `afterburner init` to create one." } : {}
+    });
+  }
+  if (config && configPath) {
+    results.push(checkRepos(config, configPath));
+    results.push(...checkBackend(config));
+    results.push(await checkBudgetProvider(config));
+  }
+  results.push(await checkRunStoreWritable());
+  let failures = 0;
+  for (const result of results) {
+    const mark = result.ok ? green("\u2713") : red("\u2717");
+    console.log(`${mark} ${bold(result.name)}: ${result.detail}`);
+    if (!result.ok) {
+      failures += 1;
+      if (result.fix) console.log(`    ${dim("fix:")} ${yellow(result.fix)}`);
+    }
+  }
+  console.log(
+    failures === 0 ? `
+${green(`${deco(emoji.rocket)}All checks passed.`)}` : `
+${red(`${failures} check(s) failed.`)}`
+  );
+  console.log(`
+${renderDoctorNextSteps({ config, configPath, failures })}`);
+  process.exitCode = failures === 0 ? 0 : 1;
+}
+function renderDoctorNextSteps(opts) {
+  const next = section(emoji.rocket, "Next");
+  if (!opts.config || !opts.configPath) {
+    return `${next}
+${nextCmd("afterburner init", "three questions; writes the config and takes it from there")}`;
+  }
+  const { config, configPath } = opts;
+  const cmd = (sub) => suggestCommand(sub, configPath, opts.cwd);
+  if (config.repos.length === 0) {
+    return `${next}
+  Add a repo to "repos" in ${configPath}, e.g.
+    { url: '/absolute/path/to/repo', enabledTaskCategories: ['docs', 'tests'] },
+  then re-run:
+${nextCmd(cmd("doctor"))}`;
+  }
+  if (opts.failures > 0) {
+    return `${next}
+  Fix the failed checks above (each prints its fix), then re-run:
+${nextCmd(cmd("doctor"))}`;
+  }
+  const repoNames = config.repos.map((r) => r.url);
+  const repoLine = repoNames.length <= 2 ? repoNames.join(", ") : `${repoNames.slice(0, 2).join(", ")} (and ${repoNames.length - 2} more)`;
+  const engineLine = config.agent.backend === "dry-run" ? "dry-run \u2014 simulation only; set agent.backend: 'claude-code' in the config to do real work" : config.agent.backend === "claude-code" ? "claude-code \u2014 spends subscription quota you already pay for; PRs only with --live" : "api-key \u2014 bills your Anthropic API account per token (real money); PRs only with --live";
+  const budgetLine = config.budget.provider === "manual" ? "manual \u2014 trusts budget.manual (automatic option: `afterburner statusline install`, then budget.provider: 'claude-usage')" : config.budget.provider === "claude-usage" ? "claude-usage \u2014 reads your real usage via the status line hook" : "claude-code-transcripts \u2014 estimates from local Claude Code session logs";
+  const nextNote = config.agent.backend === "dry-run" ? "previews the next task; nothing is executed or spent" : `previews the next task (live execution ships in a future release; ${cmd("run-once --live")} currently validates and refuses)`;
+  return `${section(emoji.flame, "Ready")}
+  Config: ${configPath}
+  Repos:  ${repoLine}
+  Engine: ${engineLine}
+  Budget: ${budgetLine}
+  Safety: live PRs need BOTH a live engine in the config AND --live (two-part opt-in)
+  Later:  \`afterburner schedule install\` (recommended OS scheduler) or \`afterburner watch\` (foreground)
+
+${next}
+${nextCmd(cmd("run-once --dry-run"), nextNote)}`;
+}
+function checkVersion(opts) {
+  const localUpdateCommand = "pnpm build && npm install -g .";
+  const npmUpdateCommand = `npm install -g ${opts.packageName}@latest`;
+  const isSourceRun = isPathInside(opts.cliEntryPath, opts.cwd);
+  if (opts.latest.status === "found" && opts.latest.latestVersion) {
+    const comparison = compareSemver(opts.latest.latestVersion, opts.currentVersion);
+    if (comparison > 0) {
+      return {
+        name: "version",
+        ok: false,
+        detail: `${opts.currentVersion} installed, latest is ${opts.latest.latestVersion}`,
+        fix: isSourceRun ? localUpdateCommand : npmUpdateCommand
+      };
+    }
+    return {
+      name: "version",
+      ok: true,
+      detail: comparison === 0 ? `${opts.currentVersion} (latest)` : `${opts.currentVersion} (newer than npm latest ${opts.latest.latestVersion})`
+    };
+  }
+  if (opts.latest.status === "not-published") {
+    return {
+      name: "version",
+      ok: true,
+      detail: `${opts.currentVersion} (${opts.packageName} is not published to npm yet; source installs update with \`${localUpdateCommand}\`)`
+    };
+  }
+  if (opts.latest.status === "failed") {
+    return {
+      name: "version",
+      ok: true,
+      detail: `${opts.currentVersion} (could not check npm latest: ${opts.latest.detail ?? "unknown error"})`
+    };
+  }
+  return {
+    name: "version",
+    ok: true,
+    detail: isSourceRun ? `${opts.currentVersion} (source run; update with \`${localUpdateCommand}\`)` : `${opts.currentVersion} (check npm latest with \`afterburner doctor --check-updates\`)`
+  };
+}
+async function fetchLatestNpmVersion(packageName) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 3e3);
+  try {
+    const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(packageName)}`, {
+      signal: controller.signal,
+      headers: { accept: "application/json" }
+    });
+    if (response.status === 404) return { status: "not-published" };
+    if (!response.ok) {
+      return { status: "failed", detail: `npm registry returned HTTP ${response.status}` };
+    }
+    const body = await response.json();
+    const latestVersion = body["dist-tags"]?.latest;
+    return typeof latestVersion === "string" ? { status: "found", latestVersion } : { status: "failed", detail: "npm registry response did not include dist-tags.latest" };
+  } catch (error) {
+    return {
+      status: "failed",
+      detail: error instanceof Error ? error.message : String(error)
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function compareSemver(a, b) {
+  const [aMajor, aMinor, aPatch] = parseSemver(a);
+  const [bMajor, bMinor, bPatch] = parseSemver(b);
+  const differences = [aMajor - bMajor, aMinor - bMinor, aPatch - bPatch];
+  for (const difference of differences) {
+    if (difference !== 0) return difference;
+  }
+  return 0;
+}
+function parseSemver(version) {
+  const stableVersion = version.split("-", 1)[0] ?? "0";
+  const [major = "0", minor = "0", patch = "0"] = stableVersion.split(".");
+  return [Number(major) || 0, Number(minor) || 0, Number(patch) || 0];
+}
+function isPathInside(candidate, parent) {
+  if (!candidate) return false;
+  const absoluteCandidate = resolve2(candidate);
+  const absoluteParent = resolve2(parent);
+  return absoluteCandidate === absoluteParent || absoluteCandidate.startsWith(`${absoluteParent}/`);
+}
+function checkNodeVersion() {
+  const [major = 0, minor = 0] = process.versions.node.split(".").map(Number);
+  const ok = major > 22 || major === 22 && minor >= 12;
+  return ok ? { name: "node", ok: true, detail: `v${process.versions.node} (>= 22.12)` } : {
+    name: "node",
+    ok: false,
+    detail: `v${process.versions.node} is too old`,
+    fix: "Install Node.js 22.12 or newer (https://nodejs.org or your version manager)."
+  };
+}
+function checkGit() {
+  const result = spawnSync("git", ["--version"], { encoding: "utf8" });
+  return result.status === 0 ? { name: "git", ok: true, detail: result.stdout.trim() } : {
+    name: "git",
+    ok: false,
+    detail: "git not found on PATH",
+    fix: "Install git (macOS: `xcode-select --install`, Debian/Ubuntu: `apt install git`, Windows: https://git-scm.com)."
+  };
+}
+function checkRepos(config, configPath) {
+  if (config.repos.length === 0) {
+    return {
+      name: "repos",
+      ok: false,
+      detail: "none configured; run-once refuses to start without an allowlisted repo",
+      fix: `Add an entry to "repos" in ${configPath}, e.g. { url: '/absolute/path/to/repo', enabledTaskCategories: ['docs', 'tests'] }.`
+    };
+  }
+  const problems = [];
+  for (const repo of config.repos) {
+    if (looksRemoteRepoUrl(repo.url)) continue;
+    if (!isAbsolute(repo.url)) {
+      problems.push(
+        `"${repo.url}" is not an absolute path; scheduled runs resolve it against a different working directory`
+      );
+      continue;
+    }
+    const stat = statSync(repo.url, { throwIfNoEntry: false });
+    if (!stat) {
+      problems.push(`"${repo.url}" does not exist on this machine`);
+    } else if (!stat.isDirectory()) {
+      problems.push(`"${repo.url}" is not a directory`);
+    }
+  }
+  if (problems.length > 0) {
+    return {
+      name: "repos",
+      ok: false,
+      detail: problems.join("; "),
+      fix: `Use absolute paths for local repos in ${configPath}.`
+    };
+  }
+  return {
+    name: "repos",
+    ok: true,
+    detail: `${config.repos.length} configured (${config.repos.map((r) => r.url).join(", ")})`
+  };
+}
+function checkBackend(config) {
+  const backend = config.agent.backend;
+  if (backend === "dry-run") {
+    return [
+      { name: "engine", ok: true, detail: "dry-run (simulation only, no external requirements)" }
+    ];
+  }
+  if (backend === "api-key") {
+    return [
+      process.env.ANTHROPIC_API_KEY ? { name: "engine", ok: true, detail: "api-key: ANTHROPIC_API_KEY is set" } : {
+        name: "engine",
+        ok: false,
+        detail: "api-key engine selected but ANTHROPIC_API_KEY is not set",
+        fix: "Export ANTHROPIC_API_KEY in your environment. Note this engine bills per token at API rates."
+      }
+    ];
+  }
+  const results = [];
+  const version = spawnSync("claude", ["--version"], { encoding: "utf8" });
+  if (version.status !== 0) {
+    results.push({
+      name: "engine",
+      ok: false,
+      detail: "claude-code engine selected but the `claude` CLI is not on PATH",
+      fix: "Install Claude Code: `npm install -g @anthropic-ai/claude-code`, then run `claude /login`."
+    });
+    return results;
+  }
+  results.push({ name: "engine", ok: true, detail: `claude-code: ${version.stdout.trim()}` });
+  const auth = spawnSync("claude", ["auth", "status"], { encoding: "utf8" });
+  results.push(classifyClaudeAuth(auth.status, auth.stdout));
+  if (process.env.ANTHROPIC_API_KEY) {
+    results.push({
+      name: "env",
+      ok: false,
+      detail: "ANTHROPIC_API_KEY is set: in headless mode it ALWAYS outranks your subscription login, so runs would bill the API instead of spending subscription quota",
+      fix: "unset ANTHROPIC_API_KEY (Afterburner also strips it from child processes as a defense, but fix the environment)."
+    });
+  }
+  return results;
+}
+async function checkBudgetProvider(config, deps = {}) {
+  const provider = config.budget.provider;
+  if (provider === "manual") {
+    return {
+      name: "budget",
+      ok: true,
+      detail: "manual provider (values from budget.manual; override per run with --weekly-remaining-pct / --weekly-remaining-tokens / --session-available)"
+    };
+  }
+  const projectsDir = deps.projectsDir ?? defaultClaudeProjectsDir();
+  const transcriptsExist = existsSync2(projectsDir);
+  if (provider === "claude-code-transcripts") {
+    return transcriptsExist ? { name: "budget", ok: true, detail: `transcripts provider (reading ${projectsDir})` } : {
+      name: "budget",
+      ok: false,
+      detail: `claude-code-transcripts provider selected but ${projectsDir} does not exist`,
+      fix: "Use Claude Code on this machine at least once (it writes the transcripts), or set budget.provider to 'manual'."
+    };
+  }
+  const cachePath = deps.usageCachePath ?? defaultUsageCachePath();
+  const cache = await readUsageCache(cachePath);
+  const fallbackNote = transcriptsExist ? "runs currently fall back to the transcript estimate" : `and the transcript fallback is also unavailable (${projectsDir} does not exist)`;
+  if (!cache) {
+    return {
+      name: "budget",
+      ok: false,
+      detail: `claude-usage provider selected but no usage cache exists yet; ${fallbackNote}`,
+      fix: "Run `afterburner statusline install`, then use Claude Code once so it captures your usage limits."
+    };
+  }
+  const nowMs = deps.nowMs ?? Date.now();
+  const { budget, fallbackReason } = budgetFromUsageCache(
+    cache,
+    {
+      weeklyAllowanceSonnetTokens: config.budget.weeklyAllowanceSonnetTokens,
+      maxAgeMs: config.budget.usageCacheMaxAgeHours * 36e5
+    },
+    nowMs
+  );
+  if (!budget) {
+    return {
+      name: "budget",
+      ok: false,
+      detail: `claude-usage cache is unusable (${fallbackReason}); ${fallbackNote}`,
+      fix: "Use Claude Code once to refresh the cache (the statusLine hook updates it automatically while you work)."
+    };
+  }
+  return {
+    name: "budget",
+    ok: true,
+    detail: `claude-usage provider (cache fresh, captured ${formatAge(nowMs - Date.parse(cache.capturedAt))} ago via the statusLine hook)`
+  };
+}
+function formatAge(ms) {
+  const minutes = Math.round(ms / 6e4);
+  if (minutes < 60) return `${minutes}m`;
+  return `${Math.round(minutes / 60)}h`;
+}
+function classifyClaudeAuth(exitStatus, stdout) {
+  if (exitStatus !== 0) {
+    return {
+      name: "claude auth",
+      ok: false,
+      detail: "not logged in",
+      fix: "Run `claude /login` (interactive), or set CLAUDE_CODE_OAUTH_TOKEN from `claude setup-token` for headless machines."
+    };
+  }
+  let authMethod;
+  try {
+    authMethod = String(JSON.parse(stdout).authMethod ?? "");
+  } catch {
+    return { name: "claude auth", ok: true, detail: "logged in (could not parse auth method)" };
+  }
+  if (authMethod.startsWith("api_key")) {
+    return {
+      name: "claude auth",
+      ok: false,
+      detail: `authenticated via ${authMethod}, NOT your subscription; headless runs would bill the API`,
+      fix: "Unset ANTHROPIC_API_KEY (or remove the apiKeyHelper from ~/.claude/settings.json) and run `claude /login` to use subscription credentials."
+    };
+  }
+  return {
+    name: "claude auth",
+    ok: true,
+    detail: `logged in via subscription (${authMethod || "unknown method"})`
+  };
+}
+async function checkRunStoreWritable() {
+  const probePath = join(dataDir, `.doctor-probe-${process.pid}`);
+  try {
+    await mkdir(dataDir, { recursive: true });
+    await writeFile(probePath, "probe", "utf8");
+    await rm(probePath, { force: true });
+    return { name: "run store", ok: true, detail: `writable (${dataDir})` };
+  } catch (error) {
+    return {
+      name: "run store",
+      ok: false,
+      detail: `cannot write to ${dataDir}: ${error instanceof Error ? error.message : String(error)}`,
+      fix: `Ensure the directory exists and is writable by your user (mkdir -p "${dataDir}").`
+    };
+  }
+}
+
+// src/cli/commands/init.ts
+import { existsSync as existsSync3, statSync as statSync2 } from "fs";
+import { writeFile as writeFile2 } from "fs/promises";
+import { createInterface } from "readline/promises";
+import { homedir } from "os";
+import { join as join2, resolve as resolve3 } from "path";
+var BACKENDS = ["dry-run", "claude-code", "api-key"];
+var BUDGET_PROVIDERS = ["manual", "claude-usage", "claude-code-transcripts"];
+var ENGINE_CHOICES = {
+  "dry-run": "simulates everything, spends nothing. The safe default.",
+  "claude-code": "your Claude subscription via the local `claude` login. No extra money; it spends quota you already pay for.",
+  "api-key": "bills your Anthropic API account per token. Every run costs real money."
+};
+var ENGINE_NOTES = {
+  "dry-run": "dry-run (simulates everything, spends nothing)",
+  "claude-code": "claude-code (spends subscription quota you already pay for)",
+  "api-key": "api-key (bills your Anthropic API account; real money)"
+};
+var BUDGET_NOTES = {
+  manual: "manual (uses the numbers in budget.manual)",
+  "claude-usage": "claude-usage (run `afterburner statusline install`, then use Claude Code once to fill the cache)",
+  "claude-code-transcripts": "claude-code-transcripts (estimates from local Claude Code logs)"
+};
+var CONFIG_FILENAMES = [
+  "afterburner.config.js",
+  "afterburner.config.ts",
+  "afterburner.config.mjs",
+  "afterburner.config.cjs"
+];
+function registerInit(program2, packageInfo2) {
+  program2.command("init").alias("setup").description(
+    "Interactive setup: 3 questions, writes afterburner.config.mjs (next to your repo, or in the current directory)"
+  ).option("--yes", "non-interactive: accept all defaults (dry-run engine, no repos)").option("--force", "overwrite an existing config file").action((opts) => runInit(opts, packageInfo2));
+}
+async function runInit(opts, packageInfo2) {
+  console.log(`${banner()}
+`);
+  let targetDir = process.cwd();
+  let target = join2(targetDir, "afterburner.config.mjs");
+  let backend = "dry-run";
+  let budgetProvider = "manual";
+  let repoUrl = "";
+  let verifyNow = false;
+  if (!opts.yes) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+      fail(
+        "Interactive prompts need a terminal on stdin and stdout. Use `afterburner init --yes` for non-interactive setup."
+      );
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const aborted = () => fail("\nAborted. No config written.");
+    rl.on("SIGINT", aborted);
+    try {
+      console.log(
+        "Afterburner turns unused Claude subscription quota into small, reviewed pull requests.\nDry-run first: nothing executes or spends until a live engine is set in the config\nAND you pass --live. Three questions, then an optional health check.\n"
+      );
+      console.log(bold("Step 1 of 3 \u2014 Engine (who does the work, and what it can spend)"));
+      BACKENDS.forEach((name, i) => {
+        console.log(`  ${i + 1}. ${name}: ${ENGINE_CHOICES[name]}`);
+      });
+      backend = BACKENDS[await askChoice(rl, "Engine [1]: ", BACKENDS.length)] ?? "dry-run";
+      console.log(step("Engine", backend));
+      console.log(`
+${bold("Step 2 of 3 \u2014 Repository (the allowlist of what it may touch)")}`);
+      console.log('  - a local path (e.g. ~/code/my-project, or "." for this folder)');
+      console.log("      \u2192 a dry run can scan it for candidate tasks right away");
+      console.log("  - a GitHub URL (e.g. https://github.com/you/repo)");
+      console.log("      \u2192 saved to your allowlist; used once live runs are enabled");
+      console.log(
+        "  - leave empty to skip for now (the health check flags it until a repo is added)"
+      );
+      const repoAnswer = (await rl.question("Repo path or URL: ")).trim();
+      const repoPath = localRepoPath(repoAnswer);
+      repoUrl = repoPath ?? repoAnswer;
+      const repoEcho = repoUrl === "" ? '(skipped \u2014 add one to "repos" later)' : !repoPath && !looksRemoteRepoUrl(repoAnswer) ? `${repoUrl} (not an existing directory \u2014 saved as typed; the health check will flag it)` : repoUrl;
+      console.log(step("Repo", repoEcho));
+      if (repoPath && repoPath !== targetDir && !hasConfig(repoPath)) {
+        console.log("\nWhere should the config live?");
+        console.log(`  1. ${repoPath} (next to the repo)`);
+        console.log(`  2. ${targetDir} (current directory)`);
+        if (await askChoice(rl, "Config location [1]: ", 2) === 0) {
+          targetDir = repoPath;
+          target = join2(targetDir, "afterburner.config.mjs");
+        }
+      }
+      console.log(
+        `
+${bold("Step 3 of 3 \u2014 Budget tracking (how it knows how much quota is left)")}`
+      );
+      console.log("  1. manual: trust the numbers in the config; tweak them anytime. Easy start.");
+      console.log("  2. claude-usage: read your real usage from Claude Code. Most accurate; needs");
+      console.log(
+        "     `afterburner statusline install` after setup (the health check reminds you)."
+      );
+      console.log("  3. claude-code-transcripts: estimate from local Claude Code session logs.");
+      budgetProvider = BUDGET_PROVIDERS[await askChoice(rl, "Budget tracking [1]: ", BUDGET_PROVIDERS.length)] ?? "manual";
+      console.log(step("Budget", budgetProvider));
+      const verifyAnswer = (await rl.question("\nRun the health check now (afterburner doctor)? [Y/n]: ")).trim().toLowerCase();
+      verifyNow = verifyAnswer === "" || verifyAnswer === "y" || verifyAnswer === "yes";
+    } catch (error) {
+      if (error?.code === "ABORT_ERR") aborted();
+      throw error;
+    } finally {
+      rl.close();
+    }
+  }
+  assertCanWriteConfig(targetDir, target, opts.force === true);
+  await writeFile2(target, renderConfig(backend, budgetProvider, repoUrl), "utf8");
+  console.log(`
+${step("Config", target)}`);
+  if (verifyNow) {
+    console.log();
+    await runDoctor({ packageInfo: packageInfo2, configPath: target });
+    return;
+  }
+  console.log(
+    `
+${renderOnboardingSummary({
+      configPath: target,
+      repoUrl,
+      backend,
+      budgetProvider,
+      interactive: !opts.yes
+    })}`
+  );
+}
+function assertCanWriteConfig(targetDir, target, force) {
+  const existing = CONFIG_FILENAMES.map((name) => join2(targetDir, name)).filter(
+    (p) => existsSync3(p)
+  );
+  if (existing.length > 0 && !force) {
+    fail(`${existing[0]} already exists. Pass --force to overwrite it.`);
+  }
+  const shadowing = existing.filter((p) => p !== target);
+  if (shadowing.length > 0) {
+    fail(
+      `Remove ${shadowing.join(", ")} first, or cosmiconfig will load it instead of the generated ${target}.`
+    );
+  }
+}
+function hasConfig(dir) {
+  return CONFIG_FILENAMES.some((name) => existsSync3(join2(dir, name)));
+}
+async function askChoice(rl, prompt, count) {
+  for (; ; ) {
+    const answer = (await rl.question(prompt)).trim();
+    const index = answer === "" ? 0 : Number(answer) - 1;
+    if (Number.isInteger(index) && index >= 0 && index < count) return index;
+    console.log(`Invalid choice "${answer}". Enter a number from 1 to ${count}.`);
+  }
+}
+function localRepoPath(repoUrl, base = process.cwd()) {
+  if (repoUrl === "" || looksRemoteRepoUrl(repoUrl)) return null;
+  const expanded = repoUrl === "~" ? homedir() : repoUrl.replace(/^~(?=\/)/, homedir());
+  const absolute = resolve3(base, expanded);
+  return statSync2(absolute, { throwIfNoEntry: false })?.isDirectory() ? absolute : null;
+}
+function renderOnboardingSummary(opts) {
+  const lines = [];
+  if (!opts.interactive) {
+    lines.push(
+      step("Engine", ENGINE_NOTES[opts.backend]),
+      step("Repo", opts.repoUrl || '(none yet \u2014 add one to "repos" in the config)'),
+      step("Budget", BUDGET_NOTES[opts.budgetProvider]),
+      ""
+    );
+  }
+  lines.push(
+    dim(
+      "Safety: every run is a dry run until agent.backend is a live engine AND you pass --live."
+    ),
+    "",
+    section(emoji.rocket, "Next"),
+    nextCmd(
+      suggestCommand("doctor", opts.configPath, opts.cwd),
+      "checks the setup end to end and prints the exact next command"
+    )
+  );
+  return lines.join("\n");
+}
+function renderConfig(backend, budgetProvider, repoUrl) {
+  const repoBlock = repoUrl ? `    {
+      url: ${JSON.stringify(repoUrl)},
+      defaultBranch: 'main',
+      branchPrefix: 'claude/',
+      enabledTaskCategories: ['docs', 'tests', 'dead-code'],
+    },` : `    // {
+    //   url: '/absolute/path/to/your/repo', // or 'https://github.com/you/repo'
+    //   defaultBranch: 'main',
+    //   branchPrefix: 'claude/',
+    //   enabledTaskCategories: ['docs', 'tests', 'dead-code'],
+    // },`;
+  return `// Afterburner configuration. Safe by default: dry-run, no live execution.
+// Docs: see afterburner.config.example.ts in the package, or the README.
+const config = {
+  repos: [
+${repoBlock}
+  ],
+  budget: {
+    // 'manual'                  \u2192 use the manual values below.
+    // 'claude-usage'            \u2192 read your real 5h/7d usage % + reset times from
+    //                             Claude Code (run \`afterburner statusline install\`
+    //                             first); most accurate, falls back to transcripts.
+    // 'claude-code-transcripts' \u2192 estimate spend from your local Claude Code sessions.
+    provider: '${budgetProvider}',
+    weeklyAllowanceSonnetTokens: 5_000_000,
+    minWeeklyHeadroomPct: 20,
+    safetyMarginTokens: 200_000,
+    requireSessionAvailable: true,
+    // Manual estimates: check /usage in Claude Code and keep these roughly
+    // current. sessionAvailable is read here by the manual and transcripts
+    // providers; claude-usage reads the real 5-hour window from its cache.
+    manual: {
+      sessionAvailable: true,
+      weeklyRemainingPct: 100,
+      weeklyRemainingTokensEst: 3_000_000,
+    },
+  },
+  schedule: { cron: '17 */4 * * *', timezone: 'UTC' },
+  agent: {
+    // The engine: 'dry-run' simulates, 'claude-code' spends subscription quota,
+    // 'api-key' bills your Anthropic API account (real money). Live runs also
+    // need the --live flag (two-part opt-in).
+    backend: '${backend}',
+    // Upper bound for a single task, in Sonnet-equivalent tokens.
+    maxTaskTokens: 200_000,
+    // Fable/Mythos-tier models are blocked by default: they can bill real
+    // money at API rates outside promotional windows.
+    allowFable: false,
+  },
+};
+
+export default config;
+`;
+}
+
+// src/cli/commands/log.ts
+function registerLog(program2) {
+  program2.command("log").description("Print the run store (the canonical audit trail of what happened)").option("--json", "output raw JSON records").action(async (opts) => {
+    const records = await new JsonlRunStore().list();
+    if (records.length === 0) {
+      console.log("No runs recorded yet. Try `afterburner run-once --dry-run`.");
+      return;
+    }
+    if (opts.json) {
+      console.log(JSON.stringify(records, null, 2));
+      return;
+    }
+    for (const r of records) {
+      const pr = r.prUrl ? ` pr=${r.prUrl}` : "";
+      console.log(
+        `${r.timestamp}  ${r.outcome.padEnd(9)} [${r.category}] ${r.title}
+  repo=${r.repoUrl} branch=${r.branch} fp=${r.fingerprint} est=${formatTokens(r.estCostSonnetTokens)} sonnet-eq${pr}`
+      );
+    }
+  });
+}
+
+// src/cli/commands/mcp.ts
+function registerMcp(program2) {
+  program2.command("mcp").description("Start the MCP server front-end (not implemented yet)").action(() => {
+    throw new Error(MCP_STUB_MESSAGE);
+  });
+}
+
+// src/cli/commands/run-once.ts
+function registerRunOnce(program2) {
+  program2.command("run-once").description(
+    "Run one ignition cycle: pick at most one bounded task per configured repo (dry-run by default)"
+  ).option("--config <path>", "path to a config file").option("--dry-run", "force a dry run (this is the default behavior)").option(
+    "--live",
+    "arm live execution; only takes effect when agent.backend is also a live engine in the config (two-part opt-in)"
+  ).option("--weekly-remaining-pct <pct>", "override budget: remaining weekly %", Number).option(
+    "--weekly-remaining-tokens <tokens>",
+    "override budget: remaining weekly Sonnet-equivalent tokens",
+    Number
+  ).option("--session-available <bool>", "override budget: session window available (true|false)").action(async (opts) => {
+    if (opts.live && opts.dryRun) {
+      fail("Pass either --live or --dry-run, not both.");
+    }
+    const live = opts.live === true && opts.dryRun !== true;
+    const { config, filepath } = await loadConfigOrExit(opts.config);
+    if (config.repos.length === 0) {
+      fail(
+        `No repos configured in ${filepath}. Add an entry to "repos", e.g. { url: '/absolute/path/to/repo', enabledTaskCategories: ['docs', 'tests'] }.`
+      );
+    }
+    if (opts.weeklyRemainingPct !== void 0 && !Number.isFinite(opts.weeklyRemainingPct)) {
+      fail("--weekly-remaining-pct must be a number.");
+    }
+    if (opts.weeklyRemainingTokens !== void 0 && !Number.isFinite(opts.weeklyRemainingTokens)) {
+      fail("--weekly-remaining-tokens must be a number.");
+    }
+    if (opts.sessionAvailable !== void 0 && opts.sessionAvailable !== "true" && opts.sessionAvailable !== "false") {
+      fail("--session-available must be true or false.");
+    }
+    const { provider, source } = createBudgetProvider(config, {
+      onNote: (m) => console.error(`[afterburner] ${m}`)
+    });
+    let budget;
+    try {
+      budget = await provider.getBudget();
+    } catch (error) {
+      fail(error instanceof Error ? error.message : String(error));
+    }
+    if (opts.weeklyRemainingPct !== void 0)
+      budget.weeklyRemainingPct = opts.weeklyRemainingPct;
+    if (opts.weeklyRemainingTokens !== void 0) {
+      budget.weeklyRemainingTokensEst = opts.weeklyRemainingTokens;
+    }
+    if (opts.sessionAvailable !== void 0) {
+      budget.sessionAvailable = opts.sessionAvailable === "true";
+    }
+    await spool();
+    const runner = createRunner(config, live);
+    const downgrade = liveDowngradeReason(config, live, filepath);
+    if (downgrade) console.error(errYellow(downgrade));
+    const modeLabel = runner.backend === "dry-run" ? cyan("DRY-RUN (no side effects)") : flame(`LIVE via ${runner.backend}`);
+    console.log(`${deco(emoji.jet)}Mode: ${modeLabel}`);
+    const sessionLabel = budget.sessionAvailable ? green("available") : yellow("unavailable");
+    console.log(
+      `${deco(emoji.fuel)}Budget ${dim(`(${source})`)}: session=${sessionLabel} weekly=${budget.weeklyRemainingPct}% (~${formatTokens(budget.weeklyRemainingTokensEst)} Sonnet-eq tokens remaining)`
+    );
+    const outcomes = await runOnce({
+      config,
+      budgetProvider: new ManualBudgetProvider(budget),
+      selector: createSelector(config),
+      runner,
+      store: new JsonlRunStore(),
+      notifier: new ConsoleNotifier()
+    });
+    if (outcomes.some((o) => o.status === "completed")) await ignite();
+    for (const outcome of outcomes) {
+      console.log(`
+repo ${dim(outcome.repoUrl)}`);
+      if (outcome.status === "skipped") {
+        console.log(`  ${dim("skipped:")} ${outcome.reason}`);
+        continue;
+      }
+      const { task, result } = outcome;
+      if (!task || !result) continue;
+      console.log(`  ${flame(deco("\u25B2"))}${bold(`[${task.category}] ${task.title}`)}`);
+      console.log(`  ${dim("branch  ")} ${cyan(result.branch)}`);
+      console.log(`  ${dim("PR title")} ${result.prTitle}`);
+      console.log(
+        `  ${dim("est cost")} ${flame(formatTokens(task.estCostSonnetTokens))} Sonnet-equivalent tokens`
+      );
+      console.log(`  ${dim(result.summary)}`);
+    }
+    if (runner.backend === "dry-run" && outcomes.some((o) => o.status === "completed")) {
+      const liveCmd = suggestCommand("run-once --live", filepath);
+      console.log(`
+${section(emoji.rocket, "Next")}`);
+      console.log(
+        config.agent.backend === "dry-run" ? `  This was a preview. Live execution ships in a future release; once it does,
+  set agent.backend: 'claude-code' in ${filepath}, then: ${liveCmd}` : `  This was a preview. Live execution ships in a future release;
+  ${liveCmd} currently validates the setup and refuses.`
+      );
+    }
+  });
+}
+
+// src/cli/commands/schedule.ts
+import { mkdir as mkdir2, rm as rm2, writeFile as writeFile3 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { dirname as dirname2, resolve as resolve4 } from "path";
+function currentPlatform() {
+  const platform = process.platform;
+  if (platform === "darwin" || platform === "linux" || platform === "win32") return platform;
+  fail(
+    `Unsupported platform "${platform}" for native scheduling. Use \`afterburner watch\` instead.`
+  );
+}
+function registerSchedule(program2) {
+  const schedule = program2.command("schedule").description("Install or remove a native OS scheduler entry (launchd / systemd / schtasks)");
+  schedule.command("install").description("Generate and install the native scheduler entry for this OS").option("--config <path>", "path to a config file (recorded in the scheduled command)").action(async (opts) => {
+    const { config, filepath } = await loadConfigOrExit(opts.config);
+    const configPath = opts.config ? resolve4(opts.config) : filepath;
+    const artifacts = generateScheduleArtifacts(currentPlatform(), {
+      cron: config.schedule.cron,
+      timezone: config.schedule.timezone,
+      nodePath: process.execPath,
+      cliPath: resolveCliEntry(),
+      configPath
+    });
+    for (const file of artifacts.files) {
+      await mkdir2(dirname2(file.path), { recursive: true });
+      await writeFile3(file.path, file.content, "utf8");
+      console.log(`Wrote ${file.path}`);
+    }
+    console.log(`
+Kind: ${artifacts.kind}`);
+    console.log(`Scheduled runs will use this config: ${configPath}`);
+    console.log(`Activate with:
+${artifacts.activationHint}`);
+    console.log(`
+Remove later with:
+${artifacts.removalHint}`);
+  });
+  schedule.command("uninstall").description("Remove the native scheduler entry files for this OS").option("--config <path>", "path to a config file").action(async (opts) => {
+    const { config } = await loadConfigOrExit(opts.config);
+    const artifacts = generateScheduleArtifacts(currentPlatform(), {
+      cron: config.schedule.cron,
+      timezone: config.schedule.timezone,
+      nodePath: process.execPath,
+      cliPath: resolveCliEntry()
+    });
+    if (artifacts.files.length === 0) {
+      console.log(
+        `Nothing to delete on this platform. Remove the tasks with:
+${artifacts.removalHint}`
+      );
+      return;
+    }
+    for (const file of artifacts.files) {
+      if (existsSync4(file.path)) {
+        await rm2(file.path);
+        console.log(`Removed ${file.path}`);
+      } else {
+        console.log(`Not found (already removed?): ${file.path}`);
+      }
+    }
+    console.log(`
+Finish deactivation with:
+${artifacts.removalHint}`);
+  });
+}
+
+// src/cli/commands/skill.ts
+import { copyFile, mkdir as mkdir3 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import { join as join3 } from "path";
+import { fileURLToPath } from "url";
+function findBundledSkill() {
+  for (const relative of ["../../skill/SKILL.md", "../../../skill/SKILL.md"]) {
+    const candidate = fileURLToPath(new URL(relative, import.meta.url));
+    if (existsSync5(candidate)) return candidate;
+  }
+  fail("Bundled skill/SKILL.md not found, is the package installation intact?");
+}
+function registerSkill(program2) {
+  const skill = program2.command("skill").description("Manage the Claude Code skill front-end for Afterburner");
+  skill.command("install").description("Copy the skill into your personal Claude Code skills directory").option("--force", "overwrite an existing installation").action(async (opts) => {
+    const source = findBundledSkill();
+    const targetDir = join3(claudeConfigDir(), "skills", "afterburner");
+    const target = join3(targetDir, "SKILL.md");
+    if (existsSync5(target) && !opts.force) {
+      fail(`${target} already exists. Pass --force to overwrite it.`);
+    }
+    await mkdir3(targetDir, { recursive: true });
+    await copyFile(source, target);
+    console.log(`Installed ${target}`);
+    console.log("Claude Code now exposes /afterburner (restart running sessions to pick it up).");
+  });
+}
+
+// src/cli/commands/statusline.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync6 } from "fs";
+import { copyFile as copyFile2, mkdir as mkdir4, readFile, rm as rm3, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname3, join as join4 } from "path";
+function wrappedStatePath() {
+  return join4(dataDir, "statusline-wrapped.json");
+}
+function claudeSettingsPath() {
+  return join4(claudeConfigDir(), "settings.json");
+}
+function registerStatusline(program2) {
+  const statusline = program2.command("statusline").description(
+    "Claude Code statusLine hook: caches your live usage limits so the budget provider can read them"
+  ).action(runHook);
+  statusline.command("install").description(
+    "Wire the hook into Claude Code settings.json (non-destructively wraps any existing status line)"
+  ).option("--force", "reinstall even if already configured").action(install);
+  statusline.command("uninstall").description("Remove the hook and restore any previous status line").action(uninstall);
+}
+async function runHook() {
+  let input = "";
+  try {
+    input = await readStdin();
+  } catch {
+  }
+  let data = {};
+  try {
+    data = JSON.parse(input);
+  } catch {
+  }
+  if (data.rate_limits) {
+    try {
+      await writeUsageCache(defaultUsageCachePath(), {
+        capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        rateLimits: data.rate_limits,
+        model: data.model?.display_name
+      });
+    } catch {
+    }
+  }
+  const wrapped = await readWrappedState();
+  if (wrapped?.command) {
+    await passThrough(wrapped.command, input);
+  } else {
+    process.stdout.write(renderDefaultStatusLine(data) + "\n");
+  }
+}
+function renderDefaultStatusLine(data) {
+  const parts = ["afterburner", data.model?.display_name ?? "claude"];
+  const five = data.rate_limits?.five_hour?.used_percentage;
+  const seven = data.rate_limits?.seven_day?.used_percentage;
+  if (typeof five === "number") parts.push(`5h ${Math.round(five)}%`);
+  if (typeof seven === "number") parts.push(`7d ${Math.round(seven)}%`);
+  return parts.join(" \xB7 ");
+}
+function readStdin() {
+  if (process.stdin.isTTY) return Promise.resolve("");
+  return new Promise((resolve6, reject) => {
+    let buf = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (c) => buf += c);
+    process.stdin.on("end", () => resolve6(buf));
+    process.stdin.on("error", reject);
+  });
+}
+async function readWrappedState() {
+  try {
+    const saved = JSON.parse(await readFile(wrappedStatePath(), "utf8"));
+    return saved.statusLine ?? null;
+  } catch {
+    return null;
+  }
+}
+function passThrough(command, input) {
+  return new Promise((resolve6) => {
+    const child = spawn(command, { shell: true, stdio: ["pipe", "inherit", "inherit"] });
+    child.on("error", () => resolve6());
+    child.on("close", () => resolve6());
+    child.stdin.on("error", () => {
+    });
+    child.stdin.end(input);
+  });
+}
+async function readSettings(path) {
+  if (!existsSync6(path)) return {};
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch {
+    fail(`Could not parse ${path} as JSON, fix it before installing the status line hook.`);
+  }
+}
+async function backup(path) {
+  if (!existsSync6(path)) return null;
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const dest = `${path}.afterburner-backup.${stamp}`;
+  await copyFile2(path, dest);
+  return dest;
+}
+var STATUSLINE_SENTINEL = "# afterburner-statusline-hook";
+function ourCommand() {
+  return `"${process.execPath}" "${resolveCliEntry()}" statusline ${STATUSLINE_SENTINEL}`;
+}
+function isOurCommand(command) {
+  return !!command && command.includes(STATUSLINE_SENTINEL);
+}
+async function install(opts) {
+  const settingsPath = claudeSettingsPath();
+  const settings = await readSettings(settingsPath);
+  const existing = settings.statusLine;
+  if (isOurCommand(existing?.command) && !opts.force) {
+    console.log("Afterburner status line hook is already installed. Pass --force to reinstall.");
+    return;
+  }
+  if (existing && !isOurCommand(existing.command)) {
+    if (existsSync6(wrappedStatePath()) && !opts.force) {
+      fail(
+        `A wrapped status line is already recorded at ${wrappedStatePath()}, but settings.json has a different one. Resolve manually, or pass --force to overwrite the recorded wrapper.`
+      );
+    }
+    await mkdir4(dirname3(wrappedStatePath()), { recursive: true });
+    await writeWrappedState(existing);
+    console.log("Found an existing status line, it will be chained after the afterburner hook.");
+  }
+  const next = { type: "command", command: ourCommand() };
+  if (existing?.padding !== void 0) next.padding = existing.padding;
+  settings.statusLine = next;
+  const backedUp = await backup(settingsPath);
+  await mkdir4(dirname3(settingsPath), { recursive: true });
+  await writeFile4(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  if (backedUp) console.log(`Backed up ${settingsPath} \u2192 ${backedUp}`);
+  console.log(`Installed the status line hook in ${settingsPath}.`);
+  console.log(
+    "Use Claude Code once (it populates usage after the first API response), then set budget.provider: 'claude-usage' in your afterburner config."
+  );
+}
+async function writeWrappedState(existing) {
+  await writeFile4(wrappedStatePath(), JSON.stringify({ statusLine: existing }, null, 2), "utf8");
+}
+async function uninstall() {
+  const settingsPath = claudeSettingsPath();
+  const settings = await readSettings(settingsPath);
+  const existing = settings.statusLine;
+  if (!isOurCommand(existing?.command)) {
+    console.log(
+      "The afterburner status line hook is not the active status line; nothing to remove."
+    );
+    return;
+  }
+  const saved = await readWrappedState();
+  if (saved) {
+    settings.statusLine = saved;
+  } else {
+    delete settings.statusLine;
+  }
+  await rm3(wrappedStatePath(), { force: true });
+  const restored = saved !== null;
+  const backedUp = await backup(settingsPath);
+  await writeFile4(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  if (backedUp) console.log(`Backed up ${settingsPath} \u2192 ${backedUp}`);
+  console.log(
+    restored ? `Removed the afterburner hook and restored your previous status line in ${settingsPath}.` : `Removed the afterburner status line hook from ${settingsPath}.`
+  );
+}
+
+// src/cli/commands/watch.ts
+function registerWatch(program2) {
+  program2.command("watch").description("Foreground scheduler daemon; prefer schedule install for unattended runs").option("--config <path>", "path to a config file").option(
+    "--live",
+    "arm live execution for every tick; only takes effect when agent.backend is a live engine (two-part opt-in)"
+  ).action(async (opts) => {
+    const { config, filepath } = await loadConfigOrExit(opts.config);
+    const live = opts.live === true;
+    const runner = createRunner(config, live);
+    const downgrade = liveDowngradeReason(config, live, filepath);
+    if (downgrade) console.error(errYellow(downgrade));
+    const { provider, source } = createBudgetProvider(config, {
+      onNote: (m) => console.error(`[afterburner] ${m}`)
+    });
+    console.log(banner());
+    console.log(
+      `${deco(emoji.jet)}${bold("watching")} ${dim(
+        `cron="${config.schedule.cron}" tz=${config.schedule.timezone} mode=${runner.backend === "dry-run" ? "dry-run" : `LIVE (${runner.backend})`} budget=${source} config=${filepath}`
+      )}`
+    );
+    const handle = startWatch({
+      cron: config.schedule.cron,
+      timezone: config.schedule.timezone,
+      onTick: async () => {
+        console.log(`[afterburner] tick ${(/* @__PURE__ */ new Date()).toISOString()}`);
+        const outcomes = await runOnce({
+          config,
+          budgetProvider: provider,
+          selector: createSelector(config),
+          runner,
+          store: new JsonlRunStore(),
+          notifier: new ConsoleNotifier()
+        });
+        for (const outcome of outcomes) {
+          console.log(`[afterburner]   ${outcome.repoUrl}: ${outcome.status}, ${outcome.reason}`);
+        }
+      }
+    });
+    const stop = () => {
+      console.log("\n[afterburner] stopping watcher");
+      handle.stop();
+      process.exit(0);
+    };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+  });
+}
+
+// src/cli/update-check.ts
+import { mkdir as mkdir5, readFile as readFile2, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname4, join as join5, resolve as resolve5 } from "path";
+var DEFAULT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_TIMEOUT_MS = 750;
+function defaultUpdateCachePath() {
+  return join5(dataDir, "update-check.json");
+}
+async function maybeNotifyUpdate(opts) {
+  if (!shouldCheckForUpdates(opts)) return;
+  const cachePath = opts.cachePath ?? defaultUpdateCachePath();
+  const nowMs = opts.nowMs ?? Date.now();
+  const cached = await readUpdateCache(cachePath);
+  const cachedNotice = cached ? renderUpdateNotice({
+    packageName: opts.packageName,
+    currentVersion: opts.currentVersion,
+    latestVersion: cached.latestVersion,
+    updateCommand: updateCommand(opts)
+  }) : null;
+  if (cachedNotice) process.stderr.write(`${cachedNotice}
+`);
+  const checkedAtMs = cached ? Date.parse(cached.checkedAt) : 0;
+  const maxAgeMs = opts.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
+  const ageMs = nowMs - checkedAtMs;
+  if (Number.isFinite(checkedAtMs) && ageMs >= 0 && ageMs < maxAgeMs) return;
+  const latestVersion = await fetchLatestVersion(opts);
+  await writeUpdateCacheBestEffort(cachePath, {
+    checkedAt: new Date(nowMs).toISOString(),
+    latestVersion: latestVersion === void 0 ? cached?.latestVersion ?? null : latestVersion
+  });
+  if (latestVersion === void 0) return;
+  if (!cachedNotice) {
+    const freshNotice = renderUpdateNotice({
+      packageName: opts.packageName,
+      currentVersion: opts.currentVersion,
+      latestVersion,
+      updateCommand: updateCommand(opts)
+    });
+    if (freshNotice) process.stderr.write(`${freshNotice}
+`);
+  }
+}
+var UPDATE_NOTIFY_EXCLUDED = /* @__PURE__ */ new Set(["statusline", "mcp"]);
+function shouldNotifyForCommand(commandName) {
+  return !UPDATE_NOTIFY_EXCLUDED.has(commandName);
+}
+function shouldCheckForUpdates(opts) {
+  const env = opts.env ?? process.env;
+  const stderrIsTty = opts.stderrIsTty ?? process.stderr.isTTY === true;
+  return stderrIsTty && !env.CI && !env.NO_UPDATE_NOTIFIER && env.NODE_ENV !== "test" && opts.packageName.length > 0 && opts.currentVersion.length > 0;
+}
+function renderUpdateNotice(opts) {
+  if (!opts.latestVersion) return null;
+  if (compareSemver2(opts.latestVersion, opts.currentVersion) <= 0) return null;
+  return `${section(emoji.rocket, "Update available")}: ${opts.currentVersion} -> ${opts.latestVersion}
+${nextCmd(opts.updateCommand)}`;
+}
+async function readUpdateCache(path) {
+  try {
+    const cache = JSON.parse(await readFile2(path, "utf8"));
+    const valid = typeof cache?.checkedAt === "string" && (cache.latestVersion === null || typeof cache.latestVersion === "string");
+    return valid ? cache : null;
+  } catch {
+    return null;
+  }
+}
+async function writeUpdateCache(path, cache) {
+  await mkdir5(dirname4(path), { recursive: true });
+  await writeFile5(path, JSON.stringify(cache, null, 2) + "\n", "utf8");
+}
+async function writeUpdateCacheBestEffort(path, cache) {
+  try {
+    await writeUpdateCache(path, cache);
+  } catch {
+  }
+}
+async function fetchLatestVersion(opts) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  try {
+    const response = await fetch(
+      `https://registry.npmjs.org/${encodeURIComponent(opts.packageName)}/latest`,
+      {
+        signal: controller.signal,
+        headers: { accept: "application/json" }
+      }
+    );
+    if (response.status === 404) return null;
+    if (!response.ok) return void 0;
+    const body = await response.json();
+    return typeof body.version === "string" ? body.version : void 0;
+  } catch {
+    return void 0;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function updateCommand(opts) {
+  return isPathInside2(opts.cliEntryPath, opts.cwd) ? "pnpm build && npm install -g ." : `npm install -g ${opts.packageName}@latest`;
+}
+function isPathInside2(candidate, parent) {
+  if (!candidate) return false;
+  const absoluteCandidate = resolve5(candidate);
+  const absoluteParent = resolve5(parent);
+  return absoluteCandidate === absoluteParent || absoluteCandidate.startsWith(`${absoluteParent}/`);
+}
+function compareSemver2(a, b) {
+  const [aMajor, aMinor, aPatch] = parseSemver2(a);
+  const [bMajor, bMinor, bPatch] = parseSemver2(b);
+  const differences = [aMajor - bMajor, aMinor - bMinor, aPatch - bPatch];
+  for (const difference of differences) {
+    if (difference !== 0) return difference;
+  }
+  return 0;
+}
+function parseSemver2(version) {
+  const stableVersion = version.split("-", 1)[0] ?? "0";
+  const [major = "0", minor = "0", patch = "0"] = stableVersion.split(".");
+  return [Number(major) || 0, Number(minor) || 0, Number(patch) || 0];
+}
+
+// src/cli/welcome.ts
+function renderWelcome(configPath) {
+  const lines = [banner(), ""];
+  const cmd = cmdRow;
+  if (!configPath) {
+    lines.push(
+      "Looks like a first run. Setup takes about a minute, and nothing spends quota or",
+      "touches a repo until you explicitly opt in (dry-run is the default).",
+      "",
+      "Start here:",
+      cmd("afterburner init", "answer 3 quick questions; writes a config")
+    );
+  } else {
+    lines.push(
+      `Config: ${dim(configPath)}`,
+      "",
+      "Everyday commands:",
+      cmd("afterburner doctor", "check prerequisites and config"),
+      cmd("afterburner run-once --dry-run", "preview the next task (no changes made)"),
+      cmd(
+        "afterburner run-once --live",
+        "real PRs (stubbed in this version; validates and refuses)"
+      ),
+      cmd("afterburner log", "recent run history")
+    );
+  }
+  lines.push("", dim("Full command list: afterburner --help"));
+  return lines.join("\n");
+}
+
+// src/cli/index.ts
+var program = new Command();
+var packageInfo = { packageName: package_default.name, currentVersion: package_default.version };
+program.name("afterburner").description(
+  "Turn unused Claude subscription quota into small, reviewed pull requests. PR-only, dry-run by default."
+).version(package_default.version).addHelpText("beforeAll", `${banner()}
+`);
+program.hook("preAction", async (_thisCommand, actionCommand) => {
+  let top = actionCommand;
+  while (top.parent && top.parent !== program) top = top.parent;
+  if (!shouldNotifyForCommand(top.name())) return;
+  try {
+    await maybeNotifyUpdate({
+      ...packageInfo,
+      cliEntryPath: process.argv[1],
+      cwd: process.cwd()
+    });
+  } catch {
+  }
+});
+registerInit(program, packageInfo);
+registerDoctor(program, packageInfo);
+registerRunOnce(program);
+registerWatch(program);
+registerSchedule(program);
+registerLog(program);
+registerSkill(program);
+registerStatusline(program);
+registerMcp(program);
+if (process.argv.length <= 2) {
+  console.log(renderWelcome(await findConfigPath()));
+} else {
+  try {
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    console.error(errRed(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+}