orbit-runner 0.1.0

package/dist/index.js

@@ -0,0 +1,1445 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { cac } from "cac";
+import pc5 from "picocolors";
+
+// src/commands/doctor.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+import pc from "picocolors";
+
+// src/claude.ts
+import { execFileSync } from "node:child_process";
+
+// src/constants.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+var CLI_VERSION = "0.1.0";
+var DEFAULT_API_URL = "https://api.orbitagents.dev";
+var resolveApiUrl = (configApiUrl) => process.env.ORBIT_API_URL ?? configApiUrl ?? DEFAULT_API_URL;
+var CONFIG_DIR = join(homedir(), ".config", "orbit-runner");
+var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+var DEFAULT_WORK_DIR = join(homedir(), ".orbit-runner");
+var PLUGIN_MARKETPLACE_SOURCE = "rafaelszago/orbit-plugin";
+var PLUGIN_MARKETPLACE_NAME = "orbit-marketplace";
+var PLUGIN_ID = "orbit@orbit-marketplace";
+var MCP_SERVER_NAME = "orbit";
+
+// src/claude.ts
+var stripSlash = (u) => u.replace(/\/+$/, "");
+function run(bin, args) {
+  return execFileSync(bin, args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+}
+function tryRun(bin, args) {
+  try {
+    return { ok: true, out: run(bin, args) };
+  } catch (err) {
+    const e = err;
+    return { ok: false, out: `${e.stdout ?? ""}${e.stderr ?? ""}`.trim() || e.message };
+  }
+}
+function claudeVersion(bin = "claude") {
+  const r = tryRun(bin, ["--version"]);
+  return r.ok ? r.out.trim() : null;
+}
+var claudeAvailable = (bin = "claude") => claudeVersion(bin) !== null;
+function mcpServerRegistered(name = MCP_SERVER_NAME, bin = "claude") {
+  const r = tryRun(bin, ["mcp", "list"]);
+  return r.ok && new RegExp(`(^|\\n)\\s*${name}\\b`, "m").test(r.out);
+}
+function addMcpServer(opts) {
+  const name = opts.name ?? MCP_SERVER_NAME;
+  const bin = opts.bin ?? "claude";
+  if (mcpServerRegistered(name, bin))
+    return "exists";
+  run(bin, [
+    "mcp",
+    "add",
+    name,
+    `${stripSlash(opts.url)}/mcp`,
+    "-t",
+    "http",
+    "-H",
+    `x-api-key: ${opts.key}`,
+    "-s",
+    "user"
+  ]);
+  return "added";
+}
+function marketplaceRegistered(bin = "claude") {
+  const r = tryRun(bin, ["plugin", "marketplace", "list"]);
+  return r.ok && (r.out.includes(PLUGIN_MARKETPLACE_SOURCE) || r.out.includes(PLUGIN_MARKETPLACE_NAME));
+}
+function addMarketplace(bin = "claude") {
+  if (marketplaceRegistered(bin))
+    return "exists";
+  run(bin, ["plugin", "marketplace", "add", PLUGIN_MARKETPLACE_SOURCE]);
+  return "added";
+}
+function pluginInstalled(bin = "claude") {
+  const r = tryRun(bin, ["plugin", "list"]);
+  return r.ok && /(^|\n)\s*orbit\b/m.test(r.out);
+}
+function installPlugin(bin = "claude") {
+  if (pluginInstalled(bin))
+    return "exists";
+  run(bin, ["plugin", "install", PLUGIN_ID, "-s", "user"]);
+  return "installed";
+}
+
+// src/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+import { z } from "zod";
+var expandHome = (p) => p === "~" || p.startsWith("~/") ? join2(homedir2(), p.slice(1)) : p;
+var projectSchema = z.object({
+  repo: z.string(),
+  repos: z.record(z.string()).optional(),
+  model: z.string().nullable().optional(),
+  effort: z.string().nullable().optional()
+});
+var configSchema = z.object({
+  api_key: z.string().min(1, "api_key is required — create one in Orbit → Settings → Agents"),
+  api_url: z.string().url().optional(),
+  poll_interval_seconds: z.number().int().positive().default(30),
+  max_slots: z.number().int().positive().default(2),
+  rate_limit_pause_minutes: z.number().int().positive().default(30),
+  task_retry_cooldown_minutes: z.number().int().positive().default(10),
+  work_dir: z.string().default(DEFAULT_WORK_DIR),
+  claude_bin: z.string().default("claude"),
+  claude_args: z.array(z.string()).default([]),
+  model: z.string().nullable().default(null),
+  effort: z.string().nullable().default(null),
+  projects: z.record(projectSchema).default({})
+});
+var configExists = () => existsSync(CONFIG_PATH);
+function loadConfig() {
+  let raw;
+  try {
+    raw = readFileSync(CONFIG_PATH, "utf8");
+  } catch {
+    throw new Error(`No config at ${CONFIG_PATH}. Run \`orbit-runner init\` first.`);
+  }
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`Config at ${CONFIG_PATH} is not valid JSON: ${err.message}`);
+  }
+  const parsed = configSchema.safeParse(json);
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((i) => `  • ${i.path.join(".") || "(root)"}: ${i.message}`).join(`
+`);
+    throw new Error(`Config at ${CONFIG_PATH} is invalid:
+${issues}`);
+  }
+  return parsed.data;
+}
+function tryLoadConfig() {
+  try {
+    return loadConfig();
+  } catch {
+    return null;
+  }
+}
+function saveConfig(config) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_PATH, `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+}
+
+// src/orbit.ts
+var stripSlash2 = (u) => u.replace(/\/+$/, "");
+var sessionMcpConfig = (apiUrl, apiKey) => ({
+  mcpServers: {
+    [MCP_SERVER_NAME]: {
+      type: "http",
+      url: `${stripSlash2(apiUrl)}/mcp`,
+      headers: { "x-api-key": apiKey }
+    }
+  }
+});
+function parseMcp(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("{"))
+    return JSON.parse(trimmed);
+  let last = null;
+  for (const line of trimmed.split(`
+`)) {
+    if (line.startsWith("data:"))
+      last = line.slice("data:".length).trim();
+  }
+  if (last === null)
+    throw new Error(`unrecognized MCP response: ${trimmed.slice(0, 200)}`);
+  return JSON.parse(last);
+}
+
+class OrbitClient {
+  apiKey;
+  id = 0;
+  base;
+  constructor(apiUrl, apiKey) {
+    this.apiKey = apiKey;
+    this.base = stripSlash2(apiUrl);
+  }
+  headers() {
+    return {
+      "x-api-key": this.apiKey,
+      "content-type": "application/json",
+      accept: "application/json, text/event-stream"
+    };
+  }
+  async callTool(name, args = {}) {
+    this.id += 1;
+    let res;
+    try {
+      res = await fetch(`${this.base}/mcp`, {
+        method: "POST",
+        headers: this.headers(),
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: this.id,
+          method: "tools/call",
+          params: { name, arguments: args }
+        })
+      });
+    } catch (err) {
+      throw new Error(`Orbit API unreachable: ${err.message}`);
+    }
+    const msg = parseMcp(await res.text());
+    if (msg.error)
+      throw new Error(`${name}: ${msg.error.message ?? JSON.stringify(msg.error)}`);
+    const text = msg.result?.content?.find((c) => c.type === "text")?.text ?? "";
+    let payload;
+    try {
+      payload = JSON.parse(text);
+    } catch {
+      payload = { text };
+    }
+    if (msg.result?.isError) {
+      const detail = payload?.error ?? text;
+      throw new Error(`${name}: ${detail}`);
+    }
+    return payload;
+  }
+  async verifyKey() {
+    await this.callTool("list_projects");
+  }
+  async heartbeat(input) {
+    const res = await fetch(`${this.base}/api/runner/heartbeat`, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify(input)
+    });
+    if (!res.ok)
+      throw new Error(`heartbeat failed: ${res.status} ${res.statusText}`);
+  }
+}
+
+// src/commands/doctor.ts
+var ICON = {
+  ok: pc.green("✔"),
+  warn: pc.yellow("⚠"),
+  fail: pc.red("✗")
+};
+var formatCheck = (c) => `${ICON[c.status]} ${c.label}${c.detail ? pc.dim(` — ${c.detail}`) : ""}`;
+async function runChecks() {
+  const checks = [];
+  const version = claudeVersion();
+  checks.push(version ? { label: "Claude Code CLI", status: "ok", detail: version } : {
+    label: "Claude Code CLI",
+    status: "fail",
+    detail: "`claude` not on PATH — install Claude Code"
+  });
+  const config = tryLoadConfig();
+  if (!config) {
+    checks.push({
+      label: "Runner config",
+      status: "fail",
+      detail: "missing or invalid — run `orbit-runner init`"
+    });
+    return checks;
+  }
+  checks.push({
+    label: "Runner config",
+    status: "ok",
+    detail: "~/.config/orbit-runner/config.json"
+  });
+  const apiUrl = resolveApiUrl(config.api_url);
+  try {
+    await new OrbitClient(apiUrl, config.api_key).verifyKey();
+    checks.push({ label: "Orbit API + key", status: "ok", detail: apiUrl });
+  } catch (err) {
+    checks.push({ label: "Orbit API + key", status: "fail", detail: err.message });
+  }
+  const keys = Object.keys(config.projects);
+  if (keys.length === 0) {
+    checks.push({
+      label: "Project mapping",
+      status: "warn",
+      detail: "no projects mapped — the runner has nothing to poll"
+    });
+  }
+  for (const key of keys) {
+    const project = config.projects[key];
+    if (!project)
+      continue;
+    const repo = expandHome(project.repo);
+    if (!existsSync2(repo)) {
+      checks.push({
+        label: `Project ${key} repo`,
+        status: "fail",
+        detail: `${repo} does not exist`
+      });
+      continue;
+    }
+    if (!existsSync2(join3(repo, ".git"))) {
+      checks.push({
+        label: `Project ${key} repo`,
+        status: "fail",
+        detail: `${repo} is not a git repo`
+      });
+      continue;
+    }
+    const hasAllowlist = existsSync2(join3(repo, ".claude", "settings.json"));
+    checks.push(hasAllowlist ? { label: `Project ${key} repo`, status: "ok", detail: repo } : {
+      label: `Project ${key} repo`,
+      status: "warn",
+      detail: `${repo} — no .claude/settings.json allowlist; headless sessions get every tool denied`
+    });
+  }
+  if (version) {
+    checks.push(mcpServerRegistered() ? { label: "Orbit MCP (interactive Claude)", status: "ok" } : {
+      label: "Orbit MCP (interactive Claude)",
+      status: "warn",
+      detail: "not registered — run `orbit-runner init` (or ignore if you used --no-plugin)"
+    });
+    checks.push(pluginInstalled() ? { label: "Orbit plugin (interactive Claude)", status: "ok" } : {
+      label: "Orbit plugin (interactive Claude)",
+      status: "warn",
+      detail: "not installed — optional; enables /orbit:tasks and the workflow skill"
+    });
+  }
+  return checks;
+}
+async function doctorCommand() {
+  const checks = await runChecks();
+  console.log(pc.bold("orbit-runner doctor"));
+  for (const c of checks)
+    console.log(`  ${formatCheck(c)}`);
+  if (checks.some((c) => c.status === "fail"))
+    process.exitCode = 1;
+}
+
+// src/commands/init.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { join as join4 } from "node:path";
+import * as p from "@clack/prompts";
+import pc2 from "picocolors";
+async function initCommand(opts) {
+  p.intro(pc2.bgCyan(pc2.black(" orbit-runner init ")));
+  const existing = configExists() ? tryLoadConfig() : null;
+  if (existing)
+    p.log.info("Found an existing config — press enter to keep current values.");
+  let apiKey = opts.key ?? process.env.ORBIT_API_KEY ?? existing?.api_key;
+  if (!apiKey) {
+    const answer = await p.password({
+      message: "Orbit agent API key",
+      validate: (v) => v && v.length > 0 ? undefined : "Required — Orbit → Settings → Agents"
+    });
+    if (p.isCancel(answer))
+      return cancelled();
+    apiKey = answer;
+  }
+  const apiUrl = resolveApiUrl(existing?.api_url);
+  let projects = [];
+  const spin = p.spinner();
+  spin.start("Verifying key against Orbit");
+  try {
+    const client = new OrbitClient(apiUrl, apiKey);
+    await client.verifyKey();
+    projects = await fetchProjects(client);
+    spin.stop(`${pc2.green("Key verified")}${pc2.dim(` · ${apiUrl}`)}`);
+  } catch (err) {
+    spin.stop(pc2.yellow(`Could not verify key: ${err.message}`));
+    const proceed = await p.confirm({ message: "Save anyway and continue?", initialValue: false });
+    if (p.isCancel(proceed) || !proceed)
+      return cancelled();
+  }
+  const mapped = { ...existing?.projects ?? {} };
+  const chosen = await chooseProjects(projects, Object.keys(mapped));
+  if (chosen === null)
+    return cancelled();
+  for (const key of chosen) {
+    const guess = mapped[key]?.repo ?? detectRepo();
+    const repo = await p.text({
+      message: `Local git repo for ${pc2.cyan(key)}`,
+      initialValue: guess ?? "",
+      validate: (v) => v && v.length > 0 ? undefined : "Required"
+    });
+    if (p.isCancel(repo))
+      return cancelled();
+    mapped[key] = { ...mapped[key], repo };
+  }
+  const config = configSchema.parse({
+    ...existing ?? {},
+    api_key: apiKey,
+    projects: mapped,
+    ...apiUrl !== DEFAULT_API_URL ? { api_url: apiUrl } : {}
+  });
+  saveConfig(config);
+  p.log.success(`Saved ${pc2.cyan("~/.config/orbit-runner/config.json")}`);
+  if (opts.plugin) {
+    await setupClaude(apiUrl, apiKey);
+  } else {
+    p.log.info(pc2.dim("Skipped plugin/MCP setup (--no-plugin). The runner still supplies MCP to sessions it spawns."));
+  }
+  const checks = await runChecks();
+  p.note(checks.map(formatCheck).join(`
+`), "Doctor");
+  const failed = checks.some((c) => c.status === "fail");
+  p.outro(failed ? pc2.yellow("Saved with warnings above — fix the ✗ items, then run `orbit-runner start`.") : `${pc2.green("Ready.")} Flag a task agent-ready in Orbit, then run ${pc2.cyan("orbit-runner start")}.`);
+}
+async function chooseProjects(projects, preselected) {
+  if (projects.length === 0) {
+    const answer = await p.text({
+      message: "Project key to map (e.g. ORB)",
+      initialValue: preselected[0] ?? ""
+    });
+    if (p.isCancel(answer))
+      return null;
+    return answer ? [answer] : [];
+  }
+  const selection = await p.multiselect({
+    message: "Which projects should this runner work?",
+    options: projects.map((pr) => ({
+      value: pr.key,
+      label: `${pr.key} — ${pr.name}`,
+      hint: preselected.includes(pr.key) ? "mapped" : undefined
+    })),
+    initialValues: preselected,
+    required: false
+  });
+  if (p.isCancel(selection))
+    return null;
+  return selection;
+}
+async function setupClaude(apiUrl, apiKey) {
+  if (!claudeAvailable()) {
+    p.log.warn("`claude` CLI not found — skipping plugin/MCP setup. Install Claude Code, then re-run `orbit-runner init`.");
+    return;
+  }
+  const spin = p.spinner();
+  spin.start("Setting up Orbit in Claude Code (user scope)");
+  try {
+    const mcp = addMcpServer({ url: apiUrl, key: apiKey });
+    const marketplace = addMarketplace();
+    const plugin = installPlugin();
+    spin.stop(pc2.green("Claude Code configured"));
+    p.log.step(`MCP server — ${outcome(mcp === "added", "registered", "already registered")}`);
+    p.log.step(`Marketplace — ${outcome(marketplace === "added", "added", "already added")}`);
+    p.log.step(`Plugin — ${outcome(plugin === "installed", "installed", "already installed")}`);
+  } catch (err) {
+    spin.stop(pc2.yellow("Plugin/MCP setup hit a snag"));
+    p.log.warn(err.message);
+    p.log.info("Your config is saved — you can finish this step manually (see the README) or re-run `init`.");
+  }
+}
+var outcome = (changed, did, already) => changed ? pc2.green(did) : pc2.dim(already);
+async function fetchProjects(client) {
+  try {
+    const res = await client.callTool("list_projects");
+    const arr = Array.isArray(res) ? res : res?.projects ?? [];
+    return arr.map((x) => x).filter((x) => typeof x.key === "string").map((x) => ({ key: String(x.key), name: String(x.name ?? x.key) }));
+  } catch {
+    return [];
+  }
+}
+function detectRepo() {
+  const cwd = process.cwd();
+  return existsSync3(join4(cwd, ".git")) ? cwd : undefined;
+}
+function cancelled() {
+  p.cancel("Setup cancelled.");
+}
+
+// src/commands/logs.ts
+import {
+  closeSync,
+  existsSync as existsSync4,
+  openSync,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync3,
+  readSync,
+  statSync
+} from "node:fs";
+import { basename as basename2, join as join6, resolve } from "node:path";
+import pc3 from "picocolors";
+
+// src/paths.ts
+import { readdirSync, readFileSync as readFileSync2, unlinkSync } from "node:fs";
+import { basename, join as join5 } from "node:path";
+var suffix = (project) => project ? `-${project.toLowerCase()}` : "";
+var pidfilePath = (workDir, project) => join5(workDir, `runner${suffix(project)}.pid`);
+var statePath = (workDir, project) => join5(workDir, `runner${suffix(project)}.state.json`);
+var runnerLogPath = (workDir, project) => join5(workDir, `runner${suffix(project)}.log`);
+var worktreesDir = (workDir) => join5(workDir, "worktrees");
+var logsDir = (workDir) => join5(workDir, "logs");
+function readPid(pidFile) {
+  try {
+    const n = Number.parseInt(readFileSync2(pidFile, "utf8").trim(), 10);
+    return Number.isFinite(n) ? n : null;
+  } catch {
+    return null;
+  }
+}
+function pidAlive(pid) {
+  if (!pid)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+var readLivePid = (pidFile) => {
+  const pid = readPid(pidFile);
+  return pidAlive(pid) ? pid : null;
+};
+function loadState(path) {
+  try {
+    return JSON.parse(readFileSync2(path, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function discoverInstances(workDir, scope) {
+  let names;
+  try {
+    names = readdirSync(workDir).filter((f) => /^runner(-[^.]+)?\.pid$/.test(f));
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names.sort()) {
+    const m = /^runner(?:-([^.]+))?\.pid$/.exec(name);
+    const project = m?.[1] ? m[1].toUpperCase() : null;
+    if (scope != null && project !== scope)
+      continue;
+    out.push({
+      project,
+      pidFile: join5(workDir, name),
+      state: loadState(statePath(workDir, project))
+    });
+  }
+  return out;
+}
+function fmtDuration(seconds) {
+  const s = Math.max(0, Math.floor(seconds));
+  const h = Math.floor(s / 3600);
+  const m = Math.floor(s % 3600 / 60);
+  const sec = s % 60;
+  if (h)
+    return `${h}h${m}m`;
+  if (m)
+    return `${m}m${sec}s`;
+  return `${sec}s`;
+}
+var taskFromLog = (path) => basename(path).replace(/-\d+\.log$/, "").toUpperCase();
+function safeRemove(...paths) {
+  for (const p2 of paths) {
+    try {
+      unlinkSync(p2);
+    } catch {}
+  }
+}
+
+// src/util.ts
+var delay = (ms) => new Promise((r) => setTimeout(r, ms));
+var pad = (n) => String(n).padStart(2, "0");
+function fmtDateTime(ms) {
+  const d = new Date(ms);
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+
+// src/commands/logs.ts
+async function logsCommand(task, opts) {
+  const config = tryLoadConfig();
+  const workDir = resolve(expandHome(config?.work_dir ?? DEFAULT_WORK_DIR));
+  const dir = logsDir(workDir);
+  const collect = () => {
+    if (task) {
+      if (!existsSync4(dir))
+        return [];
+      const matches = readdirSync2(dir).filter((f) => f.toLowerCase().startsWith(`${task.toLowerCase()}-`) && f.endsWith(".log")).sort();
+      const last = matches[matches.length - 1];
+      return last ? [join6(dir, last)] : [];
+    }
+    const files2 = [];
+    for (const { state } of discoverInstances(workDir)) {
+      for (const s of state.slots ?? []) {
+        if (s.log_path && existsSync4(s.log_path) && !files2.includes(s.log_path))
+          files2.push(s.log_path);
+      }
+    }
+    return files2;
+  };
+  const files = collect();
+  if (files.length === 0 && !opts.follow) {
+    if (task)
+      throw new Error(`no logs for ${task} under ${dir}`);
+    console.log("orbit-runner: no active sessions");
+    return;
+  }
+  if (!opts.follow) {
+    files.forEach((fp, i) => {
+      if (i)
+        console.log();
+      console.log(pc3.dim(`==> ${basename2(fp)} <==`));
+      console.log(tailText(fp, 200));
+    });
+    return;
+  }
+  await followLogs(collect, task === undefined);
+}
+function tailText(path, lines) {
+  try {
+    const arr = readFileSync3(path, "utf8").split(`
+`);
+    if (arr.at(-1) === "")
+      arr.pop();
+    return arr.slice(-lines).join(`
+`);
+  } catch {
+    return "";
+  }
+}
+async function followLogs(collect, multiplex) {
+  console.log(pc3.dim("Following… (Ctrl-C to stop)"));
+  let stop = false;
+  process.on("SIGINT", () => {
+    stop = true;
+  });
+  const offsets = new Map;
+  for (const f of collect())
+    offsets.set(f, fileSize(f));
+  while (!stop) {
+    for (const f of collect()) {
+      const { text: text2, next } = readSince(f, offsets.get(f) ?? 0);
+      offsets.set(f, next);
+      if (!text2)
+        continue;
+      const prefix = multiplex ? `[${taskFromLog(f)}] ` : "";
+      for (const line of text2.split(`
+`)) {
+        if (line)
+          process.stdout.write(`${prefix}${line}
+`);
+      }
+    }
+    await delay(500);
+  }
+}
+function fileSize(path) {
+  try {
+    return statSync(path).size;
+  } catch {
+    return 0;
+  }
+}
+function readSince(path, offset) {
+  let fd;
+  try {
+    fd = openSync(path, "r");
+  } catch {
+    return { text: "", next: offset };
+  }
+  try {
+    const buf = Buffer.alloc(65536);
+    let pos = offset;
+    let out = "";
+    for (;; ) {
+      const n = readSync(fd, buf, 0, buf.length, pos);
+      if (n <= 0)
+        break;
+      out += buf.toString("utf8", 0, n);
+      pos += n;
+    }
+    return { text: out, next: pos };
+  } finally {
+    closeSync(fd);
+  }
+}
+
+// src/commands/start.ts
+import { mkdirSync as mkdirSync3 } from "node:fs";
+import { resolve as resolve4 } from "node:path";
+
+// src/daemon.ts
+import { spawn } from "node:child_process";
+import { closeSync as closeSync3, mkdirSync as mkdirSync2, openSync as openSync3, renameSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join8, resolve as resolve3 } from "node:path";
+
+// ../../packages/shared/src/constants.ts
+var STATUS_CATEGORIES = ["backlog", "todo", "in_progress", "done", "canceled"];
+var ACTIVITY_TYPES = [
+  "task.created",
+  "task.updated",
+  "task.status_changed",
+  "task.assigned",
+  "task.commented",
+  "task.deleted",
+  "task.dependency_added",
+  "task.dependency_removed",
+  "project.created",
+  "project.updated",
+  "agent.created",
+  "agent.session_started",
+  "agent.session_progress",
+  "agent.session_completed",
+  "agent.session_abandoned",
+  "digest.standup",
+  "github.branch_created",
+  "github.pr_opened",
+  "github.pr_merged",
+  "github.pr_closed",
+  "github.pr_changes_requested"
+];
+var WEBHOOK_FORMATS = ["json", "slack"];
+var AGENT_KINDS = ["claude-code", "custom"];
+var COMMENT_KINDS = ["comment", "progress", "summary"];
+var RUNNER_STATUSES = ["active", "paused_rate_limit"];
+var RUNNER_HEARTBEAT_INTERVAL_SECONDS = 30;
+var RUNNER_OFFLINE_AFTER_MISSED_BEATS = 2;
+var RUNNER_OFFLINE_THRESHOLD_MS = RUNNER_HEARTBEAT_INTERVAL_SECONDS * (RUNNER_OFFLINE_AFTER_MISSED_BEATS + 1) * 1000;
+var RUNNER_REALTIME_TYPES = ["runner.heartbeat"];
+var REALTIME_EVENT_TYPES = [...ACTIVITY_TYPES, ...RUNNER_REALTIME_TYPES];
+// ../../packages/shared/src/schemas.ts
+import { z as z2 } from "zod";
+var prioritySchema = z2.number().int().min(0).max(4);
+var createProjectSchema = z2.object({
+  name: z2.string().min(1).max(120),
+  key: z2.string().min(2).max(6).regex(/^[A-Z][A-Z0-9]*$/, "Key must be uppercase letters/digits"),
+  description: z2.string().max(4000).optional()
+});
+var createTaskSchema = z2.object({
+  projectId: z2.string(),
+  title: z2.string().min(1).max(300),
+  description: z2.string().max(50000).optional(),
+  statusId: z2.string().optional(),
+  priority: prioritySchema.optional(),
+  agentReady: z2.boolean().optional(),
+  assigneeUserId: z2.string().nullish(),
+  labelIds: z2.array(z2.string()).optional(),
+  estimate: z2.number().int().min(0).max(100).nullish(),
+  parentTask: z2.string().nullish()
+});
+var updateTaskSchema = createTaskSchema.omit({ projectId: true }).partial();
+var addDependencySchema = z2.object({
+  dependsOn: z2.string().min(1)
+});
+var createCommentSchema = z2.object({
+  body: z2.string().min(1).max(50000),
+  kind: z2.enum(COMMENT_KINDS).default("comment")
+});
+var createLabelSchema = z2.object({
+  name: z2.string().min(1).max(60),
+  color: z2.string().regex(/^#[0-9a-fA-F]{6}$/)
+});
+var createAgentSchema = z2.object({
+  name: z2.string().min(1).max(120),
+  kind: z2.enum(AGENT_KINDS).default("claude-code")
+});
+var createWebhookSchema = z2.object({
+  url: z2.string().url(),
+  events: z2.array(z2.enum(ACTIVITY_TYPES)).min(1),
+  format: z2.enum(WEBHOOK_FORMATS).default("json")
+});
+var createStatusSchema = z2.object({
+  name: z2.string().min(1).max(60),
+  category: z2.enum(STATUS_CATEGORIES),
+  color: z2.string().regex(/^#[0-9a-fA-F]{6}$/)
+});
+var runnerHeartbeatSchema = z2.object({
+  slotsTotal: z2.number().int().min(0).max(64),
+  slotsBusy: z2.number().int().min(0).max(64),
+  taskIds: z2.array(z2.string().min(1).max(64)).max(64).default([]),
+  status: z2.enum(RUNNER_STATUSES).default("active"),
+  rateLimitResetsAt: z2.string().datetime().nullish()
+}).refine((v) => v.slotsBusy <= v.slotsTotal, {
+  message: "slotsBusy cannot exceed slotsTotal",
+  path: ["slotsBusy"]
+});
+var realtimeEventSchema = z2.object({
+  type: z2.enum(REALTIME_EVENT_TYPES),
+  orgId: z2.string(),
+  taskId: z2.string().nullable(),
+  projectId: z2.string().nullable(),
+  actorType: z2.enum(["user", "agent", "system"]),
+  actorId: z2.string(),
+  actorName: z2.string(),
+  payload: z2.record(z2.unknown()),
+  createdAt: z2.string()
+});
+// src/ratelimit.ts
+var EPOCH_LIMIT_RE = /usage limit reached\|(\d{10,13})/;
+var TEXT_LIMIT_RE = /usage limit reached|reached your usage limit|hit your usage limit|limit reached ∙ resets|out of usage/i;
+var RESETS_AT_RE = /resets?\s+(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)/i;
+function parseResetTime(output, fallbackPauseMinutes, now = Date.now()) {
+  const epochMatch = EPOCH_LIMIT_RE.exec(output);
+  if (epochMatch?.[1]) {
+    let epoch = Number.parseInt(epochMatch[1], 10);
+    if (epoch < 1000000000000)
+      epoch *= 1000;
+    return Math.max(epoch, now + 60000);
+  }
+  if (!TEXT_LIMIT_RE.test(output))
+    return null;
+  const at = RESETS_AT_RE.exec(output);
+  if (at?.[1]) {
+    const hour12 = Number.parseInt(at[1], 10);
+    const minute = at[2] ? Number.parseInt(at[2], 10) : 0;
+    const pm = at[3]?.toLowerCase() === "pm";
+    const hour = hour12 % 12 + (pm ? 12 : 0);
+    const reset = new Date(now);
+    reset.setHours(hour, minute, 0, 0);
+    if (reset.getTime() <= now)
+      reset.setDate(reset.getDate() + 1);
+    return reset.getTime();
+  }
+  return now + fallbackPauseMinutes * 60000;
+}
+
+// src/repo.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { existsSync as existsSync5 } from "node:fs";
+import { join as join7, resolve as resolve2 } from "node:path";
+var isGitRepo = (path) => existsSync5(join7(path, ".git"));
+var REPO_HINT_RE = /^\s*repo:\s*(\S+)\s*$/im;
+function resolveModelEffort(config, projectKey, cli) {
+  const proj = config.projects[projectKey];
+  return {
+    model: cli.model ?? proj?.model ?? config.model ?? null,
+    effort: cli.effort ?? proj?.effort ?? config.effort ?? null
+  };
+}
+var parseRepoHint = (description) => REPO_HINT_RE.exec(description)?.[1] ?? null;
+function resolveRepo(config, projectKey, description) {
+  const proj = config.projects[projectKey];
+  if (!proj)
+    throw new Error(`no repo mapping for project ${projectKey}`);
+  const def = resolve2(expandHome(proj.repo));
+  const hint = parseRepoHint(description);
+  if (!hint)
+    return { repo: def, hint: null };
+  const named = proj.repos?.[hint];
+  if (named)
+    return { repo: resolve2(expandHome(named)), hint };
+  const other = config.projects[hint];
+  if (other)
+    return { repo: resolve2(expandHome(other.repo)), hint };
+  const path = resolve2(expandHome(hint));
+  if (isGitRepo(path))
+    return { repo: path, hint };
+  return { repo: def, hint: `!${hint}` };
+}
+function git(repo, args) {
+  return execFileSync2("git", ["-C", repo, ...args], { encoding: "utf8" });
+}
+function gitQuiet(repo, args) {
+  try {
+    return {
+      code: 0,
+      out: execFileSync2("git", ["-C", repo, ...args], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"]
+      })
+    };
+  } catch (err) {
+    return { code: err.status ?? 1, out: "" };
+  }
+}
+function makeWorktree(repo, ident, workDir) {
+  git(repo, ["fetch", "origin", "--quiet"]);
+  const head = gitQuiet(repo, ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]);
+  const base = head.out.trim() || "origin/main";
+  const low = ident.toLowerCase();
+  let branch = `orbit/${low}`;
+  let path = join7(worktreesDir(workDir), low);
+  let n = 1;
+  while (existsSync5(path) || gitQuiet(repo, ["rev-parse", "--verify", "--quiet", branch]).code === 0) {
+    n += 1;
+    branch = `orbit/${low}-${n}`;
+    path = join7(worktreesDir(workDir), `${low}-${n}`);
+  }
+  git(repo, ["worktree", "add", "-b", branch, path, base]);
+  return { worktree: path, branch };
+}
+
+// src/session.ts
+import { closeSync as closeSync2, openSync as openSync2, readSync as readSync2 } from "node:fs";
+
+class Session {
+  task;
+  child;
+  logPath;
+  worktree;
+  branch;
+  running = true;
+  exitCode = null;
+  started = Date.now();
+  scanOffset = 0;
+  followOffset = 0;
+  constructor(task, child, logPath, worktree, branch) {
+    this.task = task;
+    this.child = child;
+    this.logPath = logPath;
+    this.worktree = worktree;
+    this.branch = branch;
+    child.on("exit", (code) => {
+      this.exitCode = code ?? 0;
+      this.running = false;
+    });
+  }
+  readFrom(which) {
+    let fd;
+    try {
+      fd = openSync2(this.logPath, "r");
+    } catch {
+      return "";
+    }
+    try {
+      let pos = which === "scan" ? this.scanOffset : this.followOffset;
+      const buf = Buffer.alloc(65536);
+      let out = "";
+      for (;; ) {
+        const n = readSync2(fd, buf, 0, buf.length, pos);
+        if (n <= 0)
+          break;
+        out += buf.toString("utf8", 0, n);
+        pos += n;
+      }
+      if (which === "scan")
+        this.scanOffset = pos;
+      else
+        this.followOffset = pos;
+      return out;
+    } finally {
+      closeSync2(fd);
+    }
+  }
+  readNewOutput() {
+    return this.readFrom("scan");
+  }
+  readFollow() {
+    return this.readFrom("follow");
+  }
+  asState() {
+    return {
+      task: this.task,
+      pid: this.child.pid,
+      log_path: this.logPath,
+      branch: this.branch,
+      worktree: this.worktree,
+      started: Math.floor(this.started / 1000)
+    };
+  }
+}
+
+// src/daemon.ts
+var stamp = () => new Date().toTimeString().slice(0, 8);
+var dlog = (msg) => console.log(`[${stamp()}] ${msg}`);
+
+class Runner {
+  config;
+  apiUrl;
+  stopping = false;
+  orbit;
+  workDir;
+  scope;
+  pollKeys;
+  pidFile;
+  stateFile;
+  mcpConfigPath;
+  follow;
+  cliModel;
+  cliEffort;
+  sessions = [];
+  pausedUntil = 0;
+  cooldowns = new Map;
+  rr = 0;
+  startedAt = Date.now();
+  lastHeartbeat = 0;
+  constructor(config, apiUrl, opts) {
+    this.config = config;
+    this.apiUrl = apiUrl;
+    this.orbit = new OrbitClient(apiUrl, config.api_key);
+    this.workDir = resolve3(expandHome(config.work_dir));
+    this.scope = opts.project ?? null;
+    this.follow = Boolean(opts.follow);
+    this.cliModel = opts.model;
+    this.cliEffort = opts.effort;
+    this.pollKeys = this.scope ? [this.scope] : Object.keys(config.projects);
+    this.pidFile = pidfilePath(this.workDir, this.scope);
+    this.stateFile = statePath(this.workDir, this.scope);
+    this.mcpConfigPath = join8(this.workDir, `mcp${suffix(this.scope)}.json`);
+    mkdirSync2(logsDir(this.workDir), { recursive: true });
+    mkdirSync2(worktreesDir(this.workDir), { recursive: true });
+  }
+  async run() {
+    this.writeMcpConfig();
+    this.writePidfile();
+    this.installSignalHandlers();
+    const model = this.cliModel ?? this.config.model ?? "default";
+    const effort = this.cliEffort ?? this.config.effort ?? "default";
+    dlog(`orbit-runner up: scope=${this.scope ?? "all"}, ${this.pollKeys.length} project(s), ` + `${this.config.max_slots} slot(s), polling every ${this.config.poll_interval_seconds}s, ` + `model=${model}, effort=${effort}`);
+    try {
+      this.writeState();
+      while (!this.stopping) {
+        try {
+          await this.tick();
+        } catch (err) {
+          dlog(`tick failed (will retry): ${err.message}`);
+        }
+        await this.sleep(this.config.poll_interval_seconds * 1000);
+      }
+      await this.shutdown();
+    } finally {
+      this.cleanupFiles();
+    }
+  }
+  async sleep(ms) {
+    const deadline = Date.now() + ms;
+    while (!this.stopping && Date.now() < deadline) {
+      await delay(Math.min(1000, Math.max(0, deadline - Date.now())));
+      if (this.follow)
+        this.pumpFollow(this.sessions);
+      await this.heartbeat();
+      if (this.sessions.some((s) => !s.running))
+        return;
+    }
+  }
+  async tick() {
+    this.scanRunningSessions();
+    await this.reapFinishedSessions();
+    await this.heartbeat(true);
+    if (Date.now() < this.pausedUntil) {
+      this.writeState();
+      return;
+    }
+    while (this.sessions.length < this.config.max_slots && !this.stopping) {
+      const task = await this.nextTask();
+      if (!task)
+        break;
+      if (!await this.spawn(task))
+        break;
+    }
+    this.writeState();
+  }
+  async nextTask() {
+    const keys = this.pollKeys;
+    if (keys.length === 0)
+      return null;
+    const inFlight = new Set(this.sessions.map((s) => s.task));
+    for (let i = 0;i < keys.length; i++) {
+      const key = keys[(this.rr + i) % keys.length];
+      if (!key)
+        continue;
+      const payload = await this.orbit.callTool("get_next_task", {
+        project_key: key
+      });
+      const task = payload.task;
+      if (!task)
+        continue;
+      if (inFlight.has(task.identifier))
+        continue;
+      if (Date.now() < (this.cooldowns.get(task.identifier) ?? 0))
+        continue;
+      this.rr = (this.rr + i + 1) % keys.length;
+      return task;
+    }
+    return null;
+  }
+  async spawn(task) {
+    const ident = task.identifier;
+    const projectKey = ident.slice(0, ident.lastIndexOf("-"));
+    if (!this.config.projects[projectKey]) {
+      dlog(`${ident}: no repo mapping for project ${projectKey}, skipping`);
+      return false;
+    }
+    const description = await this.fetchDescription(ident);
+    const { repo, hint } = resolveRepo(this.config, projectKey, description);
+    if (hint?.startsWith("!"))
+      dlog(`${ident}: unknown repo hint ${JSON.stringify(hint.slice(1))}; using project default`);
+    else if (hint)
+      dlog(`${ident}: repo hint ${JSON.stringify(hint)} -> ${repo}`);
+    let worktree;
+    let branch;
+    try {
+      ({ worktree, branch } = makeWorktree(repo, ident, this.workDir));
+    } catch (err) {
+      dlog(`${ident}: worktree setup failed, skipping this poll: ${err.message}`);
+      return false;
+    }
+    const logPath = join8(logsDir(this.workDir), `${ident.toLowerCase()}-${Math.floor(Date.now() / 1000)}.log`);
+    const prompt = `Work on ${ident} using the orbit workflow: claim it with start_task ` + `(branch ${branch}), implement it, open a PR, and complete the task with the PR link.`;
+    const { model, effort } = resolveModelEffort(this.config, projectKey, {
+      model: this.cliModel,
+      effort: this.cliEffort
+    });
+    const args = ["-p", prompt, "--mcp-config", this.mcpConfigPath, "--strict-mcp-config"];
+    if (model)
+      args.push("--model", model);
+    if (effort)
+      args.push("--effort", effort);
+    args.push(...this.config.claude_args);
+    const fd = openSync3(logPath, "a");
+    let child;
+    try {
+      child = spawn(this.config.claude_bin, args, {
+        cwd: worktree,
+        stdio: ["ignore", fd, fd],
+        detached: true
+      });
+    } finally {
+      closeSync3(fd);
+    }
+    this.sessions.push(new Session(ident, child, logPath, worktree, branch));
+    const extras = [model ? `model=${model}` : "", effort ? `effort=${effort}` : ""].filter(Boolean).join(" ");
+    dlog(`${ident}: spawned claude (pid ${child.pid}) in ${worktree} [${branch}]${extras ? ` (${extras})` : ""}`);
+    await this.heartbeat(true);
+    return true;
+  }
+  async fetchDescription(ident) {
+    try {
+      const full = await this.orbit.callTool("get_task", { task: ident });
+      return full.description ?? "";
+    } catch (err) {
+      dlog(`${ident}: could not fetch task detail for repo hint: ${err.message}`);
+      return "";
+    }
+  }
+  scanRunningSessions() {
+    for (const s of this.sessions)
+      this.checkForRateLimit(s, s.readNewOutput());
+  }
+  async reapFinishedSessions() {
+    for (const s of this.sessions.filter((x) => !x.running)) {
+      if (this.follow)
+        this.pumpFollow([s]);
+      this.sessions = this.sessions.filter((x) => x !== s);
+      this.checkForRateLimit(s, s.readNewOutput());
+      dlog(`${s.task}: session exited with code ${s.exitCode} after ` + `${Math.floor((Date.now() - s.started) / 1000)}s (log: ${s.logPath})`);
+      try {
+        await this.closeOut(s);
+      } catch (err) {
+        dlog(`${s.task}: could not check/annotate task state: ${err.message}`);
+      }
+    }
+  }
+  async closeOut(session) {
+    const task = await this.orbit.callTool("get_task", { task: session.task });
+    const done = task.statusCategory === "done";
+    const prOpened = Boolean(task.github);
+    if (done || prOpened) {
+      dlog(`${session.task}: completed (${done ? "done" : "PR opened"})`);
+      return;
+    }
+    const cooldownMs = this.config.task_retry_cooldown_minutes * 60000;
+    this.cooldowns.set(session.task, Date.now() + cooldownMs);
+    dlog(`${session.task}: cooling down for ${Math.floor(cooldownMs / 60000)}m before re-dispatch`);
+    const note2 = `runner: session exited without completing (exit code ${session.exitCode}); ` + "releasing the slot. The stale-session sweep will free the claim.";
+    await this.orbit.callTool("update_progress", { task: session.task, message: note2 });
+    dlog(`${session.task}: posted exit-without-completing note`);
+  }
+  pumpFollow(sessions) {
+    for (const s of sessions) {
+      const chunk = s.readFollow();
+      if (!chunk)
+        continue;
+      for (const line of chunk.split(`
+`)) {
+        if (line)
+          process.stdout.write(`[${s.task}] ${line}
+`);
+      }
+    }
+  }
+  checkForRateLimit(session, output) {
+    if (!output || Date.now() < this.pausedUntil)
+      return;
+    const reset = parseResetTime(output, this.config.rate_limit_pause_minutes);
+    if (reset === null)
+      return;
+    this.pausedUntil = reset;
+    const until = fmtDateTime(reset);
+    dlog(`usage limit reported by ${session.task}; pausing all dispatch until ${until}`);
+    this.orbit.callTool("update_progress", {
+      task: session.task,
+      message: `runner: Claude Code usage limit hit; pausing dispatch of new sessions until ${until}.`
+    }).catch((err) => dlog(`could not post pause note to Orbit: ${err.message}`));
+  }
+  async heartbeat(force = false) {
+    const now = Date.now();
+    if (!force && now - this.lastHeartbeat < RUNNER_HEARTBEAT_INTERVAL_SECONDS * 1000)
+      return;
+    this.lastHeartbeat = now;
+    const paused = now < this.pausedUntil;
+    try {
+      await this.orbit.heartbeat({
+        slotsTotal: this.config.max_slots,
+        slotsBusy: this.sessions.length,
+        taskIds: this.sessions.map((s) => s.task),
+        status: paused ? "paused_rate_limit" : "active",
+        rateLimitResetsAt: paused ? new Date(this.pausedUntil).toISOString() : null
+      });
+    } catch (err) {
+      dlog(`heartbeat failed (non-fatal): ${err.message}`);
+    }
+  }
+  writeMcpConfig() {
+    writeFileSync2(this.mcpConfigPath, JSON.stringify(sessionMcpConfig(this.apiUrl, this.config.api_key)), {
+      mode: 384
+    });
+  }
+  writePidfile() {
+    writeFileSync2(this.pidFile, String(process.pid));
+  }
+  writeState() {
+    const state = {
+      pid: process.pid,
+      project: this.scope,
+      started: Math.floor(this.startedAt / 1000),
+      poll_interval_seconds: this.config.poll_interval_seconds,
+      max_slots: this.config.max_slots,
+      model: this.cliModel ?? this.config.model ?? null,
+      effort: this.cliEffort ?? this.config.effort ?? null,
+      paused_until: Math.floor(this.pausedUntil / 1000),
+      slots: this.sessions.map((s) => s.asState())
+    };
+    const tmp = `${this.stateFile}.tmp`;
+    try {
+      writeFileSync2(tmp, JSON.stringify(state));
+      renameSync(tmp, this.stateFile);
+    } catch (err) {
+      dlog(`could not write state file: ${err.message}`);
+    }
+  }
+  cleanupFiles() {
+    safeRemove(this.pidFile, this.stateFile, this.mcpConfigPath);
+  }
+  installSignalHandlers() {
+    const stop = (sig) => {
+      dlog(`received ${sig}, shutting down`);
+      this.stopping = true;
+    };
+    process.on("SIGINT", () => stop("SIGINT"));
+    process.on("SIGTERM", () => stop("SIGTERM"));
+  }
+  async shutdown() {
+    for (const s of this.sessions) {
+      if (s.running && s.child.pid) {
+        dlog(`${s.task}: terminating session (pid ${s.child.pid})`);
+        killGroup(s.child.pid, "SIGTERM");
+      }
+    }
+    const deadline = Date.now() + 1e4;
+    while (this.sessions.some((s) => s.running) && Date.now() < deadline)
+      await delay(200);
+    for (const s of this.sessions) {
+      if (s.running && s.child.pid)
+        killGroup(s.child.pid, "SIGKILL");
+    }
+    await this.heartbeat(true).catch(() => {});
+    dlog("orbit-runner stopped; Orbit's stale-session sweep frees any held claims");
+  }
+}
+function killGroup(pid, signal) {
+  try {
+    process.kill(-pid, signal);
+  } catch {}
+}
+function validateForStart(config, scope) {
+  if (!config.api_key)
+    throw new Error("no API key. Run `orbit-runner init`.");
+  if (Object.keys(config.projects).length === 0) {
+    throw new Error('config needs at least one entry under "projects". Run `orbit-runner init`.');
+  }
+  for (const [key, proj] of Object.entries(config.projects)) {
+    const repo = resolve3(expandHome(proj.repo));
+    if (!isGitRepo(repo))
+      throw new Error(`projects.${key}.repo is not a git repo: ${repo}`);
+    for (const [name, alt] of Object.entries(proj.repos ?? {})) {
+      if (!isGitRepo(resolve3(expandHome(alt)))) {
+        throw new Error(`projects.${key}.repos.${name} is not a git repo: ${alt}`);
+      }
+    }
+  }
+  if (scope && !config.projects[scope]) {
+    const known = Object.keys(config.projects).join(", ") || "none";
+    throw new Error(`--project ${scope} is not in the config's projects (${known}).`);
+  }
+  if (!claudeAvailable(config.claude_bin)) {
+    throw new Error(`claude CLI not found (${config.claude_bin})`);
+  }
+}
+async function runDaemon(config, apiUrl, opts) {
+  await new Runner(config, apiUrl, opts).run();
+}
+async function startBackground(workDir, scope, childArgs) {
+  mkdirSync2(workDir, { recursive: true });
+  const logPath = runnerLogPath(workDir, scope);
+  const fd = openSync3(logPath, "a");
+  try {
+    const child = spawn(process.execPath, [process.argv[1] ?? "", "start", "--foreground", ...childArgs], {
+      detached: true,
+      stdio: ["ignore", fd, fd]
+    });
+    child.unref();
+  } finally {
+    closeSync3(fd);
+  }
+  const pidFile = pidfilePath(workDir, scope);
+  const deadline = Date.now() + 5000;
+  while (Date.now() < deadline) {
+    const live = readLivePid(pidFile);
+    if (live) {
+      console.log(`orbit-runner: started (pid ${live}); logs at ${logPath}`);
+      return;
+    }
+    await delay(100);
+  }
+  console.error(`orbit-runner: started, but the pidfile did not appear in time — check ${logPath}`);
+}
+
+// src/commands/start.ts
+async function startCommand(opts) {
+  const config = loadConfig();
+  const apiUrl = resolveApiUrl(config.api_url);
+  const scope = opts.project ? opts.project.toUpperCase() : null;
+  validateForStart(config, scope);
+  const workDir = resolve4(expandHome(config.work_dir));
+  const existing = readLivePid(pidfilePath(workDir, scope));
+  if (existing) {
+    throw new Error(`already running for ${scope ?? "all projects"} (pid ${existing}); pidfile ${pidfilePath(workDir, scope)}`);
+  }
+  const foreground = Boolean(opts.foreground || opts.follow);
+  if (foreground) {
+    mkdirSync3(workDir, { recursive: true });
+    await runDaemon(config, apiUrl, {
+      project: scope,
+      model: opts.model,
+      effort: opts.effort,
+      follow: opts.follow
+    });
+    return;
+  }
+  const childArgs = [];
+  if (scope)
+    childArgs.push("--project", scope);
+  if (opts.model)
+    childArgs.push("--model", opts.model);
+  if (opts.effort)
+    childArgs.push("--effort", opts.effort);
+  await startBackground(workDir, scope, childArgs);
+}
+
+// src/commands/status.ts
+import { resolve as resolve5 } from "node:path";
+import pc4 from "picocolors";
+async function statusCommand(opts) {
+  const config = tryLoadConfig();
+  const workDir = resolve5(expandHome(config?.work_dir ?? DEFAULT_WORK_DIR));
+  const scope = opts.project ? opts.project.toUpperCase() : null;
+  const instances = discoverInstances(workDir, scope);
+  if (instances.length === 0) {
+    console.log(`orbit-runner: no runner instances${scope ? ` for ${scope}` : ""} (not running)`);
+    return;
+  }
+  const nowSec = Date.now() / 1000;
+  for (const { project, pidFile, state } of instances) {
+    const label = (project ?? "all").padEnd(8);
+    const pid = readPid(pidFile);
+    if (!pidAlive(pid)) {
+      console.log(`${pc4.dim("●")} ${label} stale     pidfile points to dead pid ${pid}`);
+      continue;
+    }
+    const up = fmtDuration(nowSec - (state.started ?? nowSec));
+    const model = state.model ?? "default";
+    const effort = state.effort ?? "default";
+    const slots = state.slots ?? [];
+    const pausedMs = (state.paused_until ?? 0) * 1000;
+    const pauseNote = pausedMs > Date.now() ? pc4.yellow(`  PAUSED until ${fmtDateTime(pausedMs)}`) : "";
+    console.log(`${pc4.green("●")} ${label} running   pid ${pid}  up ${up}  ` + `model=${model} effort=${effort}  slots ${slots.length}/${state.max_slots ?? "?"}${pauseNote}`);
+    for (const s of slots) {
+      const sUp = fmtDuration(nowSec - (s.started ?? nowSec));
+      console.log(`    ${(s.task ?? "").padEnd(10)} pid ${String(s.pid ?? "?").padEnd(7)} up ${sUp.padEnd(7)} ${s.branch ?? ""}`);
+    }
+  }
+}
+
+// src/commands/stop.ts
+import { resolve as resolve6 } from "node:path";
+async function stopCommand(opts) {
+  const config = tryLoadConfig();
+  const workDir = resolve6(expandHome(config?.work_dir ?? DEFAULT_WORK_DIR));
+  const scope = opts.project ? opts.project.toUpperCase() : null;
+  const instances = discoverInstances(workDir, scope);
+  if (instances.length === 0) {
+    console.log(`orbit-runner: no runner${scope ? ` for ${scope}` : ""} is running`);
+    return;
+  }
+  for (const { project, pidFile } of instances) {
+    const label = project ?? "all";
+    const pid = readPid(pidFile);
+    if (!pidAlive(pid)) {
+      safeRemove(pidFile, statePath(workDir, project));
+      console.log(`${label}: not running (removed stale pidfile)`);
+      continue;
+    }
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+      safeRemove(pidFile, statePath(workDir, project));
+      console.log(`${label}: not running (removed stale pidfile)`);
+      continue;
+    }
+    const deadline = Date.now() + 12000;
+    while (pidAlive(pid) && Date.now() < deadline)
+      await delay(200);
+    console.log(pidAlive(pid) ? `${label}: SIGTERM sent to pid ${pid} (still shutting down)` : `${label}: stopped (pid ${pid})`);
+  }
+}
+
+// src/index.ts
+var cli = cac("orbit-runner");
+cli.command("init", "Configure the runner and set up the Claude Code plugin + MCP").option("--key <key>", "Orbit agent API key (else prompted, or $ORBIT_API_KEY)").option("--no-plugin", "Don't touch your interactive Claude (skip the plugin + MCP install)").action((opts) => initCommand({ key: opts.key, plugin: opts.plugin !== false }));
+cli.command("start", "Start the runner daemon").option("-p, --project <key>", "Scope to a single project").option("-F, --foreground", "Run inline instead of daemonizing").option("-f, --follow", "Stream live session logs (implies --foreground)").option("-m, --model <model>", "Override the model for spawned sessions").option("-e, --effort <effort>", "Override the effort for spawned sessions").action((opts) => startCommand({
+  project: opts.project,
+  foreground: opts.foreground,
+  follow: opts.follow,
+  model: opts.model,
+  effort: opts.effort
+}));
+cli.command("stop", "Stop the runner daemon").option("-p, --project <key>", "Target a single project's instance").action((opts) => stopCommand({ project: opts.project }));
+cli.command("status", "Show the configured runner and daemon state").option("-p, --project <key>", "Target a single project's instance").action((opts) => statusCommand({ project: opts.project }));
+cli.command("logs [task]", "Tail per-session logs").option("-f, --follow", "Follow live output").action((task, opts) => logsCommand(task, { follow: opts.follow }));
+cli.command("doctor", "Check that the environment is ready to run").action(() => doctorCommand());
+cli.help();
+cli.version(CLI_VERSION);
+async function main() {
+  const parsed = cli.parse(process.argv, { run: false });
+  if (!cli.matchedCommand) {
+    if (!parsed.options.help && !parsed.options.version)
+      cli.outputHelp();
+    return;
+  }
+  await cli.runMatchedCommand();
+}
+main().catch((err) => {
+  console.error(pc5.red("✗"), err instanceof Error ? err.message : String(err));
+  process.exitCode = 1;
+});